/// --- ./cmd/info.go --- ///

package cmd

import (

"fmt"

"github.com/spf13/cobra"

)

var infoCmd = &cobra.Command{

Use: "info [file_id]",

Short: "Show detailed information about a file or folder",

Args: cobra.ExactArgs(1),

RunE: func(cmd *cobra.Command, args []string) error {

fileID := args[0]

driver, err := getDriver()

if err != nil {

return err

}

defer driver.Close()

obj, err := driver.Info(cmd.Context(), fileID)

if err != nil {

return err

}

return outputTableOrJSON(obj, func() {

typeStr := "File"

if obj.IsDir {

typeStr = "Folder"

}

fmt.Printf("📂 Name: %s\n", obj.Name)

fmt.Printf("🆔 ID: %s\n", obj.ID)

fmt.Printf("📦 Type: %s\n", typeStr)

if !obj.IsDir {

fmt.Printf("💾 Size: %s\n", formatSize(obj.Size))

if obj.Hash != "" {

fmt.Printf("#️⃣ SHA1: %s\n", obj.Hash)

}

}

fmt.Printf("🕒 Modified: %s\n", obj.ModTime.Format("2006-01-02 15:04:05"))

})

},

}

func init() {

rootCmd.AddCommand(infoCmd)

}

/// --- ./cmd/ls.go --- ///

package cmd

import (

"fmt"

"github.com/spf13/cobra"

)

var lsCmd = &cobra.Command{

Use: "ls [path]",

Short: "List directory",

Args: cobra.MaximumNArgs(1),

RunE: func(cmd *cobra.Command, args []string) error {

driver, err := getDriver()

if err != nil {

return err

}

path := "/"

if len(args) > 0 {

path = args[0]

}

objects, err := driver.List(cmd.Context(), path)

if err != nil {

return err

}

return outputTableOrJSON(objects, func() {

fmt.Printf("%-30s %-10s %s\n", "NAME", "SIZE", "TIME")

for _, obj := range objects {

size := "-"

if !obj.IsDir {

size = formatSize(obj.Size)

} else {

size = "DIR"

}

name := obj.Name

if obj.IsDir {

name += "/"

}

fmt.Printf("%-30s %-10s %s\n", name, size, obj.ModTime.Format("2006-01-02 15:04"))

}

})

},

}

func init() {

rootCmd.AddCommand(lsCmd)

}

/// --- ./cmd/share.go --- ///

package cmd

import (

"fmt"

"time"

"github.com/Ab-code520/cloud-cli/core"

"github.com/spf13/cobra"

)

var shareCmd = &cobra.Command{

Use: "share [subcommand]",

Short: "Manage file shares (create, list, delete)",

Long: `Manage file shares for cloud drive.

Examples:

cloud-cli share create file_id1 file_id2 # Create a share for files

cloud-cli share list # List all shares

cloud-cli share delete share_id1 share_id2 # Delete shares`,

}

var shareCreateCmd = &cobra.Command{

Use: "create [file_id...]",

Short: "Create a share for files/folders",

Long: `Create a share for one or more files or folders.

Examples:

cloud-cli share create abc123 # Permanent share

cloud-cli share create abc123 --days 7 # 7-day share`,

Args: cobra.MinimumNArgs(1),

RunE: func(cmd *cobra.Command, args []string) error {

driver, err := getDriver()

if err != nil {

return err

}

defer driver.Close()

sh, ok := driver.(core.Sharable)

if !ok {

return fmt.Errorf("share is not supported by this driver")

}

days, _ := cmd.Flags().GetInt("days")

url, err := sh.CreateShare(cmd.Context(), args, days)

if err != nil {

return err

}

fmt.Printf("✅ Share created successfully!\n")

fmt.Printf("🔗 URL: %s\n", url)

return nil

},

}

var shareListCmd = &cobra.Command{

Use: "list",

Short: "List all shares",

RunE: func(cmd *cobra.Command, args []string) error {

driver, err := getDriver()

if err != nil {

return err

}

defer driver.Close()

sh, ok := driver.(core.Sharable)

if !ok {

return fmt.Errorf("share is not supported by this driver")

}

shares, err := sh.ListShares(cmd.Context(), 1, 50)

if err != nil {

return err

}

if len(shares) == 0 {

fmt.Println("No shares found.")

return nil

}

fmt.Printf("📦 Found %d shares:\n\n", len(shares))

for _, s := range shares {

status := "🟢 Active"

if s.IsExpired {

status = "🔴 Expired"

}

fmt.Printf("%s %s\n", status, s.Title)

fmt.Printf(" ID: %s\n", s.ShareID)

fmt.Printf(" 🔗 %s\n", s.URL)

fmt.Printf(" 📄 Files: %d | 📅 Created: %s\n\n", s.FileCount, time.Unix(s.CreatedAt, 0).Format("2006-01-02"))

}

return nil

},

}

var shareDeleteCmd = &cobra.Command{

Use: "delete [share_id...]",

Short: "Delete one or more shares",

Args: cobra.MinimumNArgs(1),

RunE: func(cmd *cobra.Command, args []string) error {

driver, err := getDriver()

if err != nil {

return err

}

defer driver.Close()

sh, ok := driver.(core.Sharable)

if !ok {

return fmt.Errorf("share is not supported by this driver")

}

err = sh.DeleteShare(cmd.Context(), args)

if err != nil {

return err

}

fmt.Printf("✅ Deleted %d share(s) successfully.\n", len(args))

return nil

},

}

func init() {

shareCreateCmd.Flags().IntP("days", "d", -1, "Expiration days (-1 for permanent)")

shareCmd.AddCommand(shareCreateCmd)

shareCmd.AddCommand(shareListCmd)

shareCmd.AddCommand(shareDeleteCmd)

rootCmd.AddCommand(shareCmd)

}

/// --- ./cmd/delete.go --- ///

package cmd

import (

"context"

"fmt"

"github.com/spf13/cobra"

)

var deleteCmd = &cobra.Command{

Use: "delete [id_or_path...]",

Short: "Delete file(s) or folder(s)",

Long: `Delete one or more files or folders.

Examples:

cloud-cli delete file_id # Delete single file

cloud-cli delete id1 id2 id3 # Batch delete

cloud-cli delete /path/to/file.txt # Delete by path`,

Args: cobra.MinimumNArgs(1),

RunE: func(cmd *cobra.Command, args []string) error {

driver, err := getDriver()

if err != nil {

return err

}

defer driver.Close()

deleted := 0

failed := 0

for _, arg := range args {

obj, err := findObjectByPath(driver, arg)

if err != nil {

fmt.Printf("❌ Cannot find '%s': %v\n", arg, err)

failed++

continue

}

if err := driver.Delete(context.Background(), obj); err != nil {

fmt.Printf("❌ Failed to delete '%s': %v\n", obj.Name, err)

failed++

} else {

fmt.Printf("🗑️ Deleted: %s\n", obj.Name)

deleted++

}

}

fmt.Printf("\n📊 Summary: %d deleted, %d failed\n", deleted, failed)

return nil

},

}

func init() {

rootCmd.AddCommand(deleteCmd)

}

/// --- ./cmd/output.go --- ///

package cmd

import (

"encoding/json"

"fmt"

"os"

"strings"

)

// outputFormat controls the global output format (table, json).

var outputFormat string

// outputJSON encodes v as JSON to stdout.

func outputJSON(v interface{}) error {

enc := json.NewEncoder(os.Stdout)

enc.SetIndent("", " ")

return enc.Encode(v)

}

// outputTableOrJSON calls tableFn if outputFormat is "table" (default),

// otherwise encodes v as JSON.

func outputTableOrJSON(v interface{}, tableFn func()) error {

switch strings.ToLower(outputFormat) {

case "json":

return outputJSON(v)

default:

tableFn()

return nil

}

}

func formatSize(b int64) string {

const unit = 1024

if b < unit {

return fmt.Sprintf("%d B", b)

}

div, exp := int64(unit), 0

for n := b / unit; n >= unit; n /= unit {

div *= unit

exp++

}

return fmt.Sprintf("%.1f %ciB", float64(b)/float64(div), "KMGTPE"[exp])

}

/// --- ./cmd/download.go --- ///

package cmd

import (

"fmt"

"io"

"os"

"path/filepath"

"github.com/spf13/cobra"

)

var downloadCmd = &cobra.Command{

Use: "download [remote_path] [local_path]",

Short: "Download file",

Args: cobra.ExactArgs(2),

RunE: func(cmd *cobra.Command, args []string) error {

driver, err := getDriver()

if err != nil {

return err

}

remotePath := args[0]

localPath := args[1]

// Fix #8: Support recursive path finding

obj, err := findObjectByPathOrID(driver, remotePath)

if err != nil {

return err

}

if obj.IsDir {

return fmt.Errorf("download does not support directories yet")

}

// Fix #7: Use cmd.Context() for cancellation

reader, err := driver.Open(cmd.Context(), obj, 0)

if err != nil {

return err

}

defer reader.Close()

if err := os.MkdirAll(filepath.Dir(localPath), 0755); err != nil {

return err

}

out, err := os.Create(localPath)

if err != nil {

return err

}

defer out.Close()

fmt.Printf("Downloading %s (%s)...\n", obj.Name, formatSize(obj.Size))

// Simple copy, progress bar could be added here via io.TeeReader

_, err = io.Copy(out, reader)

if err != nil {

return err

}

fmt.Printf("Downloaded to %s\n", localPath)

return nil

},

}

func init() {

rootCmd.AddCommand(downloadCmd)

}

/// --- ./cmd/rename.go --- ///

package cmd

import (

"fmt"

"github.com/spf13/cobra"

)

var renameCmd = &cobra.Command{

Use: "rename [file_id] [new_name]",

Short: "Rename a file or folder",

Args: cobra.ExactArgs(2),

RunE: func(cmd *cobra.Command, args []string) error {

fileID := args[0]

newName := args[1]

driver, err := getDriver()

if err != nil {

return err

}

defer driver.Close()

obj, err := driver.Info(cmd.Context(), fileID)

if err != nil {

return fmt.Errorf("get file info: %w", err)

}

err = driver.Rename(cmd.Context(), obj, newName)

if err != nil {

return fmt.Errorf("rename failed: %w", err)

}

fmt.Printf("✅ Successfully renamed '%s' to '%s'\n", obj.Name, newName)

return nil

},

}

func init() {

rootCmd.AddCommand(renameCmd)

}

/// --- ./cmd/recycle.go --- ///

package cmd

import (

"fmt"

"time"

"github.com/Ab-code520/cloud-cli/core"

"github.com/spf13/cobra"

)

var recycleCmd = &cobra.Command{

Use: "recycle [subcommand]",

Short: "Manage recycle bin (list, restore, delete)",

Long: `Manage recycle bin items.

Examples:

cloud-cli recycle list # List deleted files

cloud-cli recycle restore fid1 fid2 # Restore files

cloud-cli recycle delete fid1 fid2 # Permanently delete`,

}

var recycleListCmd = &cobra.Command{

Use: "list",

Short: "List items in recycle bin",

RunE: func(cmd *cobra.Command, args []string) error {

driver, err := getDriver()

if err != nil {

return err

}

defer driver.Close()

rb, ok := driver.(core.RecycleBin)

if !ok {

return fmt.Errorf("recycle bin is not supported by this driver")

}

page, _ := cmd.Flags().GetInt("page")

size, _ := cmd.Flags().GetInt("size")

items, err := rb.ListRecycle(cmd.Context(), page, size)

if err != nil {

return err

}

if len(items) == 0 {

fmt.Println("♻️ Recycle bin is empty.")

return nil

}

fmt.Printf("♻️ Found %d items in recycle bin:\n\n", len(items))

for _, item := range items {

typeIcon := "📄"

if item.IsDir {

typeIcon = "📁"

}

sizeStr := ""

if !item.IsDir {

sizeStr = fmt.Sprintf(" (%s)", formatSize(item.Size))

}

fmt.Printf("%s %s%s\n", typeIcon, item.FileName, sizeStr)

fmt.Printf(" 🆔 %s | 🗑️ Deleted: %s\n\n", item.FID, time.Unix(item.DeletedAt, 0).Format("2006-01-02 15:04:05"))

}

return nil

},

}

var recycleRestoreCmd = &cobra.Command{

Use: "restore [file_id...]",

Short: "Restore items from recycle bin",

Args: cobra.MinimumNArgs(1),

RunE: func(cmd *cobra.Command, args []string) error {

driver, err := getDriver()

if err != nil {

return err

}

defer driver.Close()

rb, ok := driver.(core.RecycleBin)

if !ok {

return fmt.Errorf("recycle bin is not supported by this driver")

}

err = rb.RecoverRecycle(cmd.Context(), args)

if err != nil {

return err

}

fmt.Printf("✅ Successfully restored %d item(s).\n", len(args))

return nil

},

}

var recycleDeleteCmd = &cobra.Command{

Use: "delete [file_id...]",

Short: "Permanently delete items from recycle bin",

Long: "Permanently delete items from recycle bin. This action cannot be undone!",

Args: cobra.MinimumNArgs(1),

RunE: func(cmd *cobra.Command, args []string) error {

driver, err := getDriver()

if err != nil {

return err

}

defer driver.Close()

rb, ok := driver.(core.RecycleBin)

if !ok {

return fmt.Errorf("recycle bin is not supported by this driver")

}

err = rb.DeleteRecycle(cmd.Context(), args)

if err != nil {

return err

}

fmt.Printf("✅ Permanently deleted %d item(s).\n", len(args))

return nil

},

}

func init() {

recycleListCmd.Flags().IntP("page", "p", 1, "Page number")

recycleListCmd.Flags().IntP("size", "s", 50, "Items per page")

recycleCmd.AddCommand(recycleListCmd)

recycleCmd.AddCommand(recycleRestoreCmd)

recycleCmd.AddCommand(recycleDeleteCmd)

rootCmd.AddCommand(recycleCmd)

}

/// --- ./cmd/helpers.go --- ///

package cmd

import (

"context"

"fmt"

"strings"

"github.com/Ab-code520/cloud-cli/core"

)

// findObjectByPath resolves a path like "/folder/subfolder/file.txt" to an Object.

// It recursively traverses the directory structure from root ("0").

func findObjectByPath(driver core.Storage, path string) (*core.Object, error) {

if path == "" || path == "/" || path == "0" {

return &core.Object{ID: "0", Name: "/", IsDir: true}, nil

}

// Remove leading slash

path = strings.TrimPrefix(path, "/")

parts := strings.Split(path, "/")

// Find the file/dir

return resolvePathParts(driver, context.Background(), "0", parts)

}

func resolvePathParts(driver core.Storage, ctx context.Context, currentID string, parts []string) (*core.Object, error) {

if len(parts) == 0 {

return driver.Info(ctx, currentID)

}

part := parts[0]

// Optimization: If currentID is "0" and part is just a name, we can try Info if supported?

// No, Info usually takes ID. We must List.

objs, err := driver.List(ctx, currentID)

if err != nil {

return nil, fmt.Errorf("list %s: %w", currentID, err)

}

for _, obj := range objs {

if obj.Name == part {

if len(parts) == 1 {

// Found it

return obj, nil

}

// It's a directory (intermediate part), recurse

if obj.IsDir {

return resolvePathParts(driver, ctx, obj.ID, parts[1:])

} else {

return nil, fmt.Errorf("%s is a file, not a directory", part)

}

}

}

return nil, fmt.Errorf("path '%s' not found", strings.Join(parts, "/"))

}

// findObjectByPathOrID tries to parse as ID first, then path.

func findObjectByPathOrID(driver core.Storage, path string) (*core.Object, error) {

// If it looks like an ID (alphanumeric, length ~32), try Info first

if isValidDirID(path) {

obj, err := driver.Info(context.Background(), path)

if err == nil {

return obj, nil

}

// Fallback to path resolution

}

return findObjectByPath(driver, path)

}

/// --- ./cmd/mkdir.go --- ///

package cmd

import (

"context"

"fmt"

"github.com/spf13/cobra"

)

var mkdirCmd = &cobra.Command{

Use: "mkdir [path]",

Short: "Create directory",

Args: cobra.ExactArgs(1),

RunE: func(cmd *cobra.Command, args []string) error {

driver, err := getDriver()

if err != nil {

return err

}

_, err = driver.Mkdir(context.Background(), args[0])

if err != nil {

return err

}

fmt.Printf("Created directory %s\n", args[0])

return nil

},

}

func init() {

rootCmd.AddCommand(mkdirCmd)

}

/// --- ./cmd/search.go --- ///

package cmd

import (

"fmt"

"github.com/Ab-code520/cloud-cli/core"

"github.com/spf13/cobra"

)

var searchCmd = &cobra.Command{

Use: "search [query]",

Short: "Search for files and folders in cloud drive",

Long: `Search for files and folders in your cloud drive.

Examples:

cloud-cli search "report.pdf" # Search by filename

cloud-cli search "photos" --dir abc # Search in specific directory

cloud-cli search "*.mp4" # Use wildcard pattern`,

Args: cobra.ExactArgs(1),

RunE: func(cmd *cobra.Command, args []string) error {

query := args[0]

driver, err := getDriver()

if err != nil {

return err

}

defer driver.Close()

s, ok := driver.(core.Searchable)

if !ok {

return fmt.Errorf("search is not supported by this driver")

}

dirID, _ := cmd.Flags().GetString("dir")

page, _ := cmd.Flags().GetInt("page")

size, _ := cmd.Flags().GetInt("size")

results, err := s.Search(cmd.Context(), query, dirID, page, size)

if err != nil {

return err

}

if len(results) == 0 {

if outputFormat == "json" {

return outputTableOrJSON([]interface{}{}, func() {})

}

fmt.Printf("🔍 No results found for '%s'\n", query)

return nil

}

return outputTableOrJSON(results, func() {

fmt.Printf("🔍 Found %d results for '%s':\n\n", len(results), query)

for _, obj := range results {

typeIcon := "📄"

if obj.IsDir {

typeIcon = "📁"

}

sizeStr := ""

if !obj.IsDir {

sizeStr = fmt.Sprintf(" (%s)", formatSize(obj.Size))

}

fmt.Printf("%s %s%s\n", typeIcon, obj.Name, sizeStr)

fmt.Printf(" 🆔 %s | 📅 %s\n\n", obj.ID, obj.ModTime.Format("2006-01-02"))

}

})

},

}

func init() {

searchCmd.Flags().StringP("dir", "d", "", "Search in specific directory ID")

searchCmd.Flags().IntP("page", "p", 1, "Page number")

searchCmd.Flags().IntP("size", "s", 50, "Results per page")

rootCmd.AddCommand(searchCmd)

}

/// --- ./cmd/copy.go --- ///

package cmd

import (

"fmt"

"github.com/Ab-code520/cloud-cli/core"

"github.com/spf13/cobra"

)

var copyCmd = &cobra.Command{

Use: "copy [source_id] [dest_dir_id]",

Short: "Copy a file or folder to another directory",

Long: `Copy a file or folder to another directory.

Examples:

cloud-cli copy file123 folder456 # Copy file123 into folder456

cloud-cli copy file123 0 # Copy file123 to root directory`,

Args: cobra.ExactArgs(2),

RunE: func(cmd *cobra.Command, args []string) error {

srcID := args[0]

destID := args[1]

driver, err := getDriver()

if err != nil {

return err

}

defer driver.Close()

// Get source object

srcObj, err := driver.Info(cmd.Context(), srcID)

if err != nil {

return fmt.Errorf("get source info: %w", err)

}

// Construct destination directory object

destDirObj := &core.Object{ID: destID}

// Call Copy

err = driver.Copy(cmd.Context(), srcObj, destDirObj)

if err != nil {

return fmt.Errorf("copy failed: %w", err)

}

fmt.Printf("✅ Successfully copied '%s' to directory '%s'\n", srcObj.Name, destID)

return nil

},

}

func init() {

rootCmd.AddCommand(copyCmd)

}

/// --- ./cmd/sync.go --- ///

package cmd

import (

"fmt"

"path/filepath"

"github.com/Ab-code520/cloud-cli/core"

"github.com/spf13/cobra"

)

var syncCmd = &cobra.Command{

Use: "sync <source> <destination>",

Short: "Synchronize directories (Local <-> Cloud)",

Long: `Synchronize files between local directory and cloud drive.

Supports one-way sync (up/down) and deletion of extra files.

Examples:

# Upload local folder to quark (only new/changed files)

cloud-cli sync ./photos quark:/backup/photos

# Preview sync (Dry Run)

cloud-cli sync ./data quark:/backup --dry-run

# Sync and delete extra files in destination

cloud-cli sync ./important quark:/important --delete`,

Args: cobra.ExactArgs(2),

RunE: func(cmd *cobra.Command, args []string) error {

srcInput := args[0]

destInput := args[1]

// Parse paths

srcDriverName, srcPath, err := parseResourcePath(srcInput)

if err != nil {

return err

}

destDriverName, destPath, err := parseResourcePath(destInput)

if err != nil {

return err

}

// Initialize drivers

// For local driver, if path is absolute, we set root to "/" so we can traverse fully.

// If relative, we keep default (cwd) and pass relative path.

srcRoot := ""

if srcDriverName == "local" && filepath.IsAbs(srcPath) {

srcRoot = "/"

}

srcDriver, err := initDriver(srcDriverName, srcRoot)

if err != nil {

return fmt.Errorf("init source driver: %w", err)

}

defer srcDriver.Close()

destRoot := ""

if destDriverName == "local" && filepath.IsAbs(destPath) {

destRoot = "/"

}

destDriver, err := initDriver(destDriverName, destRoot)

if err != nil {

return fmt.Errorf("init dest driver: %w", err)

}

defer destDriver.Close()

// Config

dryRun, _ := cmd.Flags().GetBool("dry-run")

deleteExtra, _ := cmd.Flags().GetBool("delete")

syncer := &core.Syncer{

Source: srcDriver,

Dest: destDriver,

Config: core.SyncConfig{

DryRun: dryRun,

DeleteExtra: deleteExtra,

},

OnAction: func(action *core.SyncAction) {

icon := " "

switch action.Type {

case "upload":

icon = "⬆️"

case "update":

icon = "🔄"

case "delete":

icon = "🗑️"

case "mkdir":

icon = "📁"

case "skip":

icon = "⏭️"

}

msg := fmt.Sprintf("%s %s %s", icon, action.Type, action.Object.Name)

if dryRun {

msg += " [DRY RUN]"

}

fmt.Println(msg)

},

}

fmt.Printf("🔄 Syncing %s -> %s ...\n", srcInput, destInput)

if dryRun {

fmt.Println("👀 This is a dry run, no files will be modified.")

}

if err := syncer.Sync(cmd.Context(), srcPath, destPath); err != nil {

return fmt.Errorf("sync failed: %w", err)

}

fmt.Println("✅ Sync completed.")

return nil

},

}

func init() {

syncCmd.Flags().Bool("dry-run", false, "Preview changes without executing")

syncCmd.Flags().Bool("delete", false, "Delete extra files in destination")

rootCmd.AddCommand(syncCmd)

}

/// --- ./cmd/user.go --- ///

package cmd

import (

"fmt"

"github.com/spf13/cobra"

)

var userCmd = &cobra.Command{

Use: "user",

Short: "Show user info",

RunE: func(cmd *cobra.Command, args []string) error {

driver, err := getDriver()

if err != nil {

return err

}

info, err := driver.User(cmd.Context())

if err != nil {

return err

}

return outputTableOrJSON(info, func() {

if name, ok := info["name"]; ok {

fmt.Printf("👤 Name: %v\n", name)

}

if used, ok := info["space_used"]; ok {

fmt.Printf("💾 Used: %s\n", formatSize(int64(used.(float64))))

}

if total, ok := info["space_total"]; ok {

fmt.Printf("📊 Total: %s\n", formatSize(int64(total.(float64))))

}

})

},

}

func init() {

rootCmd.AddCommand(userCmd)

}