@heyputer/shell 2.1.0

package/src/commands/files.js

@@ -0,0 +1,1187 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import { execSync } from 'node:child_process';
+import { glob } from 'glob';
+import path from 'path';
+import { minimatch } from 'minimatch';
+import chalk from 'chalk';
+import Conf from 'conf';
+import fetch from 'node-fetch';
+import { API_BASE, BASE_URL, PROJECT_NAME, getHeaders, showDiskSpaceUsage, resolvePath, resolveRemotePath } from '../commons.js';
+import { formatDateTime, formatSize, getSystemEditor } from '../utils.js';
+import inquirer from 'inquirer';
+import { getAuthToken, getCurrentDirectory, getCurrentUserName } from './auth.js';
+import { updatePrompt } from './shell.js';
+import crypto from '../crypto.js';
+import { getPuter } from '../modules/PuterModule.js';
+
+
+const config = new Conf({ projectName: PROJECT_NAME });
+
+
+/**
+ * List files in given path
+ * @param {string} path Path to the file or directory
+ * @returns List of files found
+ */
+export async function listRemoteFiles(path) {
+    const puter = getPuter();
+    return await puter.fs.readdir(path);
+}
+
+/**
+ * List files in the current working directory.
+ * @param {string} args Default current working directory
+ */
+export async function listFiles(args = []) {
+  const names = args.length > 0 ? args : ['.'];
+  for (let path of names)
+    try {
+        if (!path.startsWith('/')){
+            path =  resolvePath(getCurrentDirectory(), path);
+        }
+        if (!(await pathExists(path))){
+            console.log(chalk.yellow(`Directory ${chalk.red(path)} doesn't exists!`));
+            continue;
+        }
+        console.log(chalk.green(`Listing files in ${chalk.dim(path)}:\n`));
+        const files = await listRemoteFiles(path);
+        if (Array.isArray(files) && files.length > 0) {
+            console.log(chalk.cyan(`Type  Name                 Size    Modified          UID`));
+            console.log(chalk.dim('----------------------------------------------------------------------------------'));
+            files.forEach(file => {
+                const type = file.is_dir ? 'd' : '-';
+                const write = file.writable ? 'w' : '-';
+                const name = file.name.padEnd(20);
+                const size = file.is_dir ? '0' : formatSize(file.size);
+                const modified = formatDateTime(file.modified);
+                const uid = file.uid?.split('-');
+                console.log(`${type}${write}   ${name} ${size.padEnd(8)} ${modified}  ${uid[0]}-...-${uid.slice(-1)}`);
+            });
+            console.log(chalk.green(`There are ${files.length} object(s).`));
+        } else {
+            console.log(chalk.red('No files or directories found.'));
+        }
+    } catch (error) {
+        console.log(chalk.red('Failed to list files.'));
+        console.error(chalk.red(`Error: ${error.message}`));
+    }
+}
+
+/**
+ * Create a folder in the current working directory.
+ * @param {Array} args Options
+ * @returns void
+ */
+export async function makeDirectory(args = []) {
+    if (args.length < 1) {
+        console.log(chalk.red('Usage: mkdir <directory_name>'));
+        return;
+    }
+
+    const directoryName = args[0];
+    console.log(chalk.green(`Creating directory "${directoryName}" in "${getCurrentDirectory()}"...\n`));
+
+    const puter = getPuter();
+
+    try {
+        const data = await puter.fs.mkdir(`${getCurrentDirectory()}/${directoryName}`, {
+            overwrite: false,
+            dedupeName: true,
+            createMissingParents: false
+        })
+        if (data && data.id) {
+            console.log(chalk.green(`Directory "${directoryName}" created successfully!`));
+            console.log(chalk.dim(`Path: ${data.path}`));
+            console.log(chalk.dim(`UID: ${data.uid}`));
+        } else {
+            console.log(chalk.red('Failed to create directory. Please check your input.'));
+        }
+    } catch (error) {
+        console.log(chalk.red('Failed to create directory.'));
+        console.error(chalk.red(`Error: ${error.message}`));
+    }
+}
+
+/**
+ * Rename a file or directory
+ * @param {Array} args Options
+ * @returns void
+ */
+export async function renameFileOrDirectory(args = []) {
+    if (args.length < 2) {
+        console.log(chalk.red('Usage: mv <source> <destination>'));
+        return;
+    }
+
+    const sourcePath = args[0].startsWith('/') ? args[0] : resolvePath(getCurrentDirectory(), args[0]);
+    const destPath = args[1].startsWith('/') ? args[1] : resolvePath(getCurrentDirectory(), args[1]);
+
+    console.log(chalk.green(`Moving "${sourcePath}" to "${destPath}"...\n`));
+    
+    const puter = getPuter();
+    try {
+        // Step 1: Get the source file/directory info
+        const statData = await puter.fs.stat(sourcePath);
+        if (!statData || !statData.uid) {
+            console.log(chalk.red(`Could not find source "${sourcePath}".`));
+            return;
+        }
+
+        const sourceUid = statData.uid;
+        const sourceName = statData.name;
+
+        // Step 2: Check if destination is an existing directory
+        let destData = null;
+        try {
+            destData = await puter.fs.stat(destPath);
+        } catch (error) {
+            if (error.code == "subject_does_not_exist") {
+                // no-op
+            } else {
+                throw (error);
+            }
+        }
+        
+        // Determine if this is a rename or move operation
+        const isMove = destData && destData.is_dir;
+        const newName = isMove ? sourceName : path.basename(destPath);
+        const destination = isMove ? destPath : path.dirname(destPath);
+
+        if (isMove) {
+            // Move operation: use /move endpoint
+            const moveData = await puter.fs.move(sourceUid, destination, {
+                overwrite: false,
+                newName: newName,
+                createMissingParents: false,
+            });
+            if (moveData && moveData.moved) {
+                console.log(chalk.green(`Successfully moved "${sourcePath}" to "${moveData.moved.path}"!`));
+            } else {
+                console.log(chalk.red('Failed to move item. Please check your input.'));
+            }
+        } else {
+            // Rename operation: use /rename endpoint
+            const renameData = await puter.fs.rename(sourceUid, newName);
+            if (renameData) {
+                console.log(chalk.green(`Successfully renamed "${sourcePath}" to "${renameData.path}"!`));
+            } else {
+                console.log(chalk.red('Failed to rename item. Please check your input.'));
+            }
+        }
+    } catch (error) {
+        console.log(chalk.red('Failed to move/rename item.'));
+        console.error(chalk.red(`Error: ${error.message}`));
+        console.error(error);
+    }
+}
+
+/**
+ * Helper function to recursively find files matching the pattern
+ * @param {Array} files List of files
+ * @param {string} pattern The pattern to find
+ * @param {string} basePath the base path
+ * @returns array of matching files
+ */
+async function findMatchingFiles(files, pattern, basePath) {
+    const matchedPaths = [];
+    const puter = getPuter();
+
+    for (const file of files) {
+        const filePath = path.join(basePath, file.name);
+
+        // Check if the current file/directory matches the pattern
+        if (minimatch(filePath, pattern, { dot: true })) {
+            matchedPaths.push(filePath);
+        }
+
+        // If it's a directory, recursively search its contents
+        if (file.is_dir) {
+            const dirFiles = await puter.fs.readdir(filePath);
+            if (dirFiles && dirFiles.length > 0) {
+                const dirMatches = await findMatchingFiles(dirFiles, pattern, filePath);
+                matchedPaths.push(...dirMatches);
+            }
+        }
+    }
+
+    return matchedPaths;
+}
+
+/**
+ * Find files matching the pattern in the local directory (DEPRECATED: Not used)
+ * @param {string} localDir - Local directory path.
+ * @param {string} pattern - File pattern (e.g., "*.html", "myapp/*").
+ * @returns {Array} - Array of file objects with local and relative paths.
+ */
+function findLocalMatchingFiles(localDir, pattern) {
+    const files = [];
+    const walkDir = (dir) => {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walkDir(fullPath); // Recursively traverse directories
+            } else if (minimatch(fullPath, path.join(localDir, pattern), { dot: true })) {
+                files.push({
+                    localPath: fullPath,
+                    relativePath: path.relative(localDir, fullPath)
+                });
+            }
+        }
+    };
+
+    walkDir(localDir);
+    return files;
+}
+
+/**
+ * Move a file/directory to the Trash
+ * @param {Array} args Options:
+ * -f: Force delete (no confirmation)
+ * @returns void
+ */
+export async function removeFileOrDirectory(args = []) {
+    if (args.length < 1) {
+        console.log(chalk.red('Usage: rm <name> [-f]'));
+        return;
+    }
+
+    const skipConfirmation = args.includes('-f'); // Check the flag if provided
+    const names = skipConfirmation ? args.filter(option => option !== '-f') : args;
+
+    const puter = getPuter();
+
+    try {
+        // Step 1: Fetch the list of files and directories from the server
+        const files = await puter.fs.readdir(getCurrentDirectory());
+        if (!Array.isArray(files) || files.length == 0) {
+            console.error(chalk.red('No files or directories found on the server.'));
+            return;
+        }
+
+        // Step 2: Find all files/directories matching the provided patterns
+        const matchedPaths = [];
+        for (const name of names) {
+            if (name.startsWith('/')){
+                const pattern = resolvePath('/', name);
+                matchedPaths.push(pattern);
+                continue;
+            }
+            const pattern = resolvePath(getCurrentDirectory(), name);
+            const matches = await findMatchingFiles(files, pattern, getCurrentDirectory());
+            matchedPaths.push(...matches);
+        }
+
+        if (matchedPaths.length === 0) {
+            console.error(chalk.red('No files or directories found matching the pattern.'));
+            return;
+        }
+
+        // Step 3: Prompt for confirmation (unless -f flag is provided)
+        if (!skipConfirmation) {
+            console.log(chalk.yellow(`The following items will be moved to Trash:`));
+            console.log(chalk.cyan('Hint: Execute "clean" to empty the Trash.'));
+            matchedPaths.forEach(path => console.log(chalk.dim(`- ${path}`)));
+
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: `Are you sure you want to move these ${matchedPaths.length} item(s) to Trash?`,
+                    default: false
+                }
+            ]);
+
+            if (!confirm) {
+                console.log(chalk.yellow('Operation canceled.'));
+                return;
+            }
+        }
+
+        // Step 4: Move each matched file/directory to Trash
+        for (const path of matchedPaths) {
+            try {
+                console.log(chalk.green(`Preparing to remove "${path}"...`));
+
+                // Step 4.1: Get the UID of the file/directory
+                const statData = await puter.fs.stat(path);
+                if (!statData || !statData.uid) {
+                    console.error(chalk.red(`Could not find file or directory with path "${path}".`));
+                    continue;
+                }
+
+                const uid = statData.uid;
+
+                // Step 4.2: Perform the move operation to Trash
+                const moveData = await puter.fs.move(uid, `/${getCurrentUserName()}/Trash`, {
+                    overwrite: false,
+                    newName: uid,
+                    createMissingParents: false,
+                });
+                if (moveData && moveData.moved) {
+                    console.log(chalk.green(`Successfully moved "${path}" to Trash!`));
+                    console.log(chalk.dim(`Moved to: ${moveData.moved.path}`));
+                } else {
+                    console.error(chalk.red(`Failed to move "${path}" to Trash.`));
+                }
+            } catch (error) {
+                console.error(chalk.red(`Failed to remove "${path}".`));
+                console.error(chalk.red(`Error: ${error.message}`));
+            }
+        }
+    } catch (error) {
+        console.error(chalk.red('Failed to remove items.'));
+        console.error(chalk.red(`Error: ${error.message}`));
+    }
+}
+
+/**
+ * Delete a folder and its contents (PREVENTED BY PUTER API)
+ * @param {string} folderPath - The path of the folder to delete (defaults to Trash).
+ * @param {boolean} skipConfirmation - Whether to skip the confirmation prompt.
+ */
+export async function deleteFolder(folderPath, skipConfirmation = false) {
+    console.log(chalk.green(`Preparing to delete "${folderPath}"...\n`));
+
+    const puter = getPuter();
+    try {
+        // Step 1: Prompt for confirmation (unless skipConfirmation is true)
+        if (!skipConfirmation) {
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: `Are you sure you want to delete all contents of "${folderPath}"?`,
+                    default: false
+                }
+            ]);
+
+            if (!confirm) {
+                console.log(chalk.yellow('Operation canceled.'));
+                return;
+            }
+        }
+
+        // Step 2: Perform the delete operation
+        const deleteData = await puter.fs.delete(folderPath, {
+            descendantsOnly: true,
+            recursive: true
+        });
+        if (Object.keys(deleteData).length == 0) {
+            console.log(chalk.green(`Successfully deleted all contents from: ${chalk.cyan(folderPath)}`));
+        } else {
+            console.log(chalk.red('Failed to delete folder. Please check your input.'));
+        }
+    } catch (error) {
+        console.log(chalk.red('Failed to delete folder.'));
+        console.error(chalk.red(`Error: ${error.message}`));
+        console.error(error);
+    }
+}
+
+/**
+ * Empty the Trash (wrapper for deleteFolder).
+ * @param {boolean} skipConfirmation - Whether to skip the confirmation prompt.
+ */
+export async function emptyTrash(skipConfirmation = true) {
+    const trashPath = `/${getCurrentUserName()}/Trash`;
+    await deleteFolder(trashPath, skipConfirmation);
+}
+
+/**
+ * Show statistical information about the current working directory.
+ * @param {Array} args array of path names
+ */
+export async function getInfo(args = []) {
+    const names = args.length > 0 ? args : ['.'];
+    const puter = getPuter();
+    for (let name of names)
+        try {
+            name = `${getCurrentDirectory()}/${name}`;
+            console.log(chalk.green(`Getting stat info for: "${name}"...\n`));
+            const data = await puter.fs.stat(name);
+            if (data) {
+                console.log(chalk.cyan('File/Directory Information:'));
+                console.log(chalk.dim('----------------------------------------'));
+                console.log(chalk.cyan(`Name: `) + chalk.white(data.name));
+                console.log(chalk.cyan(`Path: `) + chalk.white(data.path));
+                console.log(chalk.cyan(`Type: `) + chalk.white(data.is_dir ? 'Directory' : 'File'));
+                console.log(chalk.cyan(`Size: `) + chalk.white(data.size ? formatSize(data.size) : 'N/A'));
+                console.log(chalk.cyan(`Created: `) + chalk.white(new Date(data.created * 1000).toLocaleString()));
+                console.log(chalk.cyan(`Modified: `) + chalk.white(new Date(data.modified * 1000).toLocaleString()));
+                console.log(chalk.cyan(`Writable: `) + chalk.white(data.writable ? 'Yes' : 'No'));
+                console.log(chalk.cyan(`Owner: `) + chalk.white(data.owner.username));
+                console.log(chalk.dim('----------------------------------------'));
+            } else {
+                console.error(chalk.red('Unable to get stat info. Please check your credentials.'));
+            }
+        } catch (error) {
+            console.error(chalk.red(`Failed to get stat info.\nError: ${error.message}`));
+        }
+}
+
+/**
+ * Show the current working directory
+ */
+export async function showCwd() {
+    console.log(chalk.green(`${config.get('cwd')}`));
+}
+
+/**
+ * Change the current working directory
+ * @param {Array} args - The path arguments
+ * @returns void
+ */
+export async function changeDirectory(args) {
+    let currentPath = config.get('cwd');
+    // If no arguments, print the current directory
+    if (!args.length) {
+        console.log(chalk.green(currentPath));
+        return;
+    }
+    const puter = getPuter();
+
+    const path = args[0];
+    // Handle "/","~",".." and deeper navigation
+    const newPath = path.startsWith('/')? path: (path === '~'? `/${getCurrentUserName()}` :resolvePath(currentPath, path));
+    try {
+        // Check if the new path is a valid directory
+        const data = await puter.fs.stat(newPath);
+        if (data && data.is_dir) {
+            // Update the newPath to use the correct name from the response
+            const arrayDirs = newPath.split('/');
+            arrayDirs.pop();
+            arrayDirs.push(data.name);
+            updatePrompt(arrayDirs.join('/')); // Update the shell prompt
+        } else {
+            console.log(chalk.red(`"${newPath}" is not a directory`));
+        }
+    } catch (error) {
+        console.log(chalk.red(`Cannot access "${newPath}": ${error.message}`));
+    }
+}
+
+/**
+ * Fetch disk usage information
+ * @param {Object} body - Optional arguments to include in the request body.
+ */
+export async function getDiskUsage(body = null) {
+    console.log(chalk.green('Fetching disk usage information...\n'));
+    const puter = getPuter();
+    try {
+        const data = await puter.fs.space();
+        if (data) {
+            showDiskSpaceUsage(data);
+        } else {
+            console.error(chalk.red('Unable to fetch disk usage information.'));
+        }
+    } catch (error) {
+        console.error(chalk.red(`Failed to fetch disk usage information.\nError: ${error.message}`));
+    }
+}
+
+/**
+ * Check if a path exists
+ * @param {string} filePath List of files/directories
+ */
+export async function pathExists(filePath) {
+    if (filePath.length < 1) {
+        console.log(chalk.red('No path provided.'));
+        return false;
+    }
+    const puter = getPuter();
+    try {
+        // Step 1: Check if the file already exists
+        await puter.fs.stat(filePath);
+        return true;
+    } catch (error){
+        if (error.code == "subject_does_not_exist") {
+            return false;
+        }
+        console.error(chalk.red('Failed to check if file exists.'));
+        console.error('ERROR', error);
+            return false;
+    }    
+}
+
+/**
+ * Create a new file (similar to Unix "touch" command).
+ * @param {Array} args - The arguments passed to the command (file name and optional content).
+ * @returns {boolean} - True if the file was created successfully, false otherwise.
+ */
+export async function createFile(args = []) {
+    if (args.length < 1) {
+        console.log(chalk.red('Usage: touch <file_name> [content]'));
+        return false;
+    }
+
+    const filePath = args[0]; // File path (e.g., "app/index.html")
+    const content = args.length > 1 ? args.slice(1).join(' ') : ''; // Optional content
+    let fullPath = filePath;
+    if (!filePath.startsWith(`/${getCurrentUserName()}/`)){
+        fullPath = resolvePath(getCurrentDirectory(), filePath); // Resolve the full path
+    }
+    const dirName = path.dirname(fullPath); // Extract the directory name
+    const fileName = path.basename(fullPath); // Extract the file name
+    const dedupeName = false; // Default: false
+    const overwrite = true; // Default: true
+
+    const puter = getPuter();
+    console.log(chalk.green(`Creating file:\nFileName: "${chalk.dim(fileName)}"\nPath: "${chalk.dim(dirName)}"\nContent Length: ${chalk.dim(content.length)}`));
+    try {
+        // Step 1: Check if the file already exists
+        try {
+            const statData = await puter.fs.stat(fullPath);
+            if (statData && statData.id) {
+                if (!overwrite) {
+                    console.error(chalk.red(`File "${filePath}" already exists. Use --overwrite=true to replace it.`));
+                    return false;
+                }
+                console.log(chalk.yellow(`File "${filePath}" already exists. It will be overwritten.`));
+            }
+        } catch (error) {
+            if (error.code == "subject_does_not_exist") {
+                console.log(chalk.cyan('File does not exists. It will be created.'));
+            } else {
+                throw error;
+            }
+        }
+
+        // Step 2: Check disk space
+        const dfData = await puter.fs.space();
+        if (dfData.used >= dfData.capacity) {
+            console.error(chalk.red('Not enough disk space to create the file.'));
+            showDiskSpaceUsage(dfData); // Display disk usage info
+            return false;
+        }
+
+        // Step 3: Create the nested directories if they don't exist
+        try {
+            await puter.fs.stat(dirName);
+        } catch (error) {
+            if (error.code == "subject_does_not_exist") {
+                // Create the directory if it doesn't exist
+                await puter.fs.mkdir(dirName, {
+                    overwrite: false,
+                    dedupeName: true,
+                    createMissingParents: true
+                })
+            } else {
+                throw error;
+            }
+        }
+
+        // Step 4: Create the file
+        const fileBlob = new Blob([content || ''], { type: 'text/plain' });
+
+        const createData = await puter.fs.upload(fileBlob, dirName, {
+            overwrite: overwrite,
+            dedupeName: dedupeName,
+            name: fileName
+        });
+        console.log(chalk.green(`File "${createData.name}" created successfully!`));
+        console.log(chalk.dim(`Path: ${createData.path}`));
+        console.log(chalk.dim(`UID: ${createData.uid}`));
+    } catch (error) {
+        console.error(chalk.red(`Failed to create file.\nError: ${error.message}`));
+        return false;
+    }
+    return true;
+}
+
+/**
+ * Read and display the content of a file (similar to Unix "cat" command).
+ * @param {Array} args - The arguments passed to the command (file path).
+ */
+export async function readFile(args = []) {
+    if (args.length < 1) {
+        console.log(chalk.red('Usage: cat <file_path>'));
+        return;
+    }
+    const puter = getPuter();
+
+    const filePath = resolvePath(getCurrentDirectory(), args[0]);
+    console.log(chalk.green(`Reading file "${filePath}"...\n`));
+
+    try {
+        // Step 1: Fetch the file content        
+        const fileBlob = await puter.fs.read(filePath);
+        if (!fileBlob) {
+            console.error(chalk.red(`Failed to read file.`));
+            return;
+        }
+        const data = await fileBlob.text();
+
+        // Step 2: Dispaly the content
+        if (data.length) {
+            console.log(chalk.cyan(data));
+        } else {
+            console.error(chalk.red('File is empty.'));
+        }
+    } catch (error) {
+        console.error(chalk.red(`Failed to read file.\nError: ${error.message}`));
+    }
+}
+
+/**
+ * Upload a file from the host machine to the Puter server
+ * @param {Array} args - The arguments passed to the command: (<local_path> [remote_path] [dedupe_name] [overwrite])
+ */
+export async function uploadFile(args = []) {
+    if (args.length < 1) {
+        console.log(chalk.red('Usage: push <local_path> [remote_path] [dedupe_name] [overwrite]'));
+        return;
+    }
+
+    const localPath = args[0];
+    let remotePath = '';
+    if (args.length > 1){
+        remotePath = args[1].startsWith('/')? args[1]: resolvePath(getCurrentDirectory(), args[1]);
+    } else {
+        remotePath = resolvePath(getCurrentDirectory(), '.');
+    }
+    const dedupeName = args.length > 2 ? args[2] === 'true' : true; // Default: true
+    const overwrite = args.length > 3 ? args[3] === 'true' : false; // Default: false
+
+    console.log(chalk.green(`Uploading files from "${localPath}" to "${remotePath}"...\n`));
+    const puter = getPuter();
+    try {
+        // Step 1: Find all matching files (excluding hidden files)
+        const files = glob.sync(localPath, { nodir: true, dot: false });
+
+        if (files.length === 0) {
+            console.error(chalk.red('No files found to upload.'));
+            return;
+        }
+
+        // Step 2: Check disk space
+        const dfData = await puter.fs.space();
+        if (dfData.used >= dfData.capacity) {
+            console.error(chalk.red('Not enough disk space to upload the files.'));
+            showDiskSpaceUsage(dfData); // Display disk usage info
+            return;
+        }
+
+        // Step 3: Upload each file
+        for (const filePath of files) {
+            const fileName = path.basename(filePath);
+            const fileContent = fs.readFileSync(filePath);
+            const blob = new Blob([fileContent]);
+
+            const uploadData = await puter.fs.upload(blob, remotePath, {
+                overwrite: overwrite,
+                dedupeName: dedupeName,
+                name: fileName
+            });
+            console.log(chalk.green(`File "${uploadData.name}" uploaded successfully!`));
+            console.log(chalk.dim(`Path: ${uploadData.path}`));
+            console.log(chalk.dim(`UID: ${uploadData.uid}`));
+        }
+    } catch (error) {
+        console.error(chalk.red(`Failed to upload files.\nError: ${error.message}`));
+    }
+}
+
+/**
+ * Download a file from the Puter server to the host machine 
+ * @param {Array} args - The arguments passed to the command (remote file path, Optional: local path).
+ */
+export async function downloadFile(args = []) {
+    if (args.length < 1) {
+        console.log(chalk.red('Usage: pull <remote_file_path> [local_path] [overwrite]'));
+        return;
+    }
+
+    const remotePathPattern = resolvePath(getCurrentDirectory(), args[0]); // Resolve the remote file path pattern
+    const localBasePath = path.dirname(args.length > 1 ? args[1] : '.'); // Default to the current directory
+    const overwrite = args.length > 2 ? args[2] === 'true' : false; // Default: false
+
+    console.log(chalk.green(`Downloading files matching "${remotePathPattern}" to "${localBasePath}"...\n`));
+    const puter = getPuter();
+    try {
+        // Step 1: Fetch the list of files and directories from the server
+        const files = await puter.fs.readdir(getCurrentDirectory());
+        if (!Array.isArray(files) || files.length === 0) {
+            console.error(chalk.red('No files or directories found on the server.'));
+            return;
+        }
+
+        // Step 2: Recursively find files matching the pattern
+        const matchedFiles = await findMatchingFiles(files, remotePathPattern, getCurrentDirectory());
+
+        if (matchedFiles.length === 0) {
+            console.error(chalk.red('No files found matching the pattern.'));
+            return;
+        }
+
+        // Step 3: Download each matched file
+        for (const remoteFilePath of matchedFiles) {
+            const relativePath = path.relative(getCurrentDirectory(), remoteFilePath);
+            const localFilePath = path.join(localBasePath, relativePath);
+
+            // Ensure the local directory exists
+            if (!fs.existsSync(path.dirname(localFilePath))){
+                fs.mkdirSync(path.dirname(localFilePath), { recursive: true });
+            }
+
+            console.log(chalk.green(`Downloading file "${remoteFilePath}" to "${localFilePath}"...`));
+
+            const fileUrl = await puter.fs.getReadURL(remoteFilePath);
+            const downloadResponse = await fetch(fileUrl);
+
+            if (!downloadResponse.ok) {
+                console.error(chalk.red(`Failed to download file "${remoteFilePath}". Server response: ${downloadResponse.statusText}`));
+                continue;
+            }
+
+            // Step 5: Save the file content to the local filesystem
+            const fileContent = await downloadResponse.text();
+
+            // Check if the file exists, if so then delete it before writing.
+            if (overwrite && fs.existsSync(localFilePath)) {
+                fs.unlinkSync(localFilePath);
+                console.log(chalk.yellow(`File "${localFilePath}" already exists. Overwriting...`));
+            }
+
+            fs.writeFileSync(localFilePath, fileContent, 'utf8');
+            const fileSize = fs.statSync(localFilePath).size;
+            console.log(chalk.green(`File: "${remoteFilePath}" downloaded to "${localFilePath}" (size: ${formatSize(fileSize)})`));
+        }
+    } catch (error) {
+        console.error(chalk.red(`Failed to download files.\nError: ${error.message}`));
+    }
+}
+
+/**
+ * Copy files or directories from one location to another on the Puter server (similar to Unix "cp" command).
+ * @param {Array} args - The arguments passed to the command (source path, destination path).
+ */
+export async function copyFile(args = []) {
+    if (args.length < 2) {
+        console.log(chalk.red('Usage: cp <source_path> <destination_path>'));
+        return;
+    }
+
+    const sourcePath = args[0].startsWith(`/${getCurrentUserName()}`) ? args[0] : resolvePath(getCurrentDirectory(), args[0]); // Resolve the source path
+    const destinationPath = args[1].startsWith(`/${getCurrentUserName()}`) ? args[1] : resolvePath(getCurrentDirectory(), args[1]); // Resolve the destination path
+
+    console.log(chalk.green(`Copy: "${chalk.dim(sourcePath)}" to: "${chalk.dim(destinationPath)}"...\n`));
+    const puter = getPuter();
+    try {
+        // Step 1: Check if the source is a directory or a file
+        let statData;
+        try {
+            statData = await puter.fs.stat(sourcePath);
+        } catch (error) {
+            if (error == "subject_does_not_exist") {
+                console.error(chalk.red(`Source path "${sourcePath}" does not exist.`));
+                return;
+            } else {
+                console.error(chalk.red(`Failed to check source path. Server response: ${await statResponse.text()}`));
+                return;
+            }
+        }
+
+        if (statData.is_dir) {
+            // Step 2: If source is a directory, copy all files recursively
+            const files = await listFiles([sourcePath]);
+            for (const file of files) {
+                const relativePath = file.path.replace(sourcePath, '');
+                const destPath = path.join(destinationPath, relativePath);
+
+                const copyData = await puter.fs.copy(file.path, destPath);
+                if (copyData && copyData.length > 0 && copyData[0].copied) {
+                    console.log(chalk.green(`File "${chalk.dim(file.path)}" copied successfully to "${chalk.dim(copyData[0].copied.path)}"!`));
+                } else {
+                    console.error(chalk.red(`Failed to copy file "${file.path}". Invalid response from server.`));
+                }
+            }
+        } else {
+            // Step 3: If source is a file, copy it directly
+            const copyData = await puter.fs.copy(sourcePath, destinationPath);
+            if (copyData && copyData.length > 0 && copyData[0].copied) {
+                console.log(chalk.green(`File "${sourcePath}" copied successfully to "${copyData[0].copied.path}"!`));
+                console.log(chalk.dim(`UID: ${copyData[0].copied.uid}`));
+            } else {
+                console.error(chalk.red('Failed to copy file. Invalid response from server.'));
+            }
+        }
+    } catch (error) {
+        console.error(chalk.red(`Failed to copy file.\nError: ${error.message}`));
+    }
+}
+
+
+/**
+ * List all files in a local directory.
+ * @param {string} localDir - The local directory path.
+ * @param {boolean} recursive - Whether to recursively list files in subdirectories
+ * @returns {Array} - Array of local file objects.
+ */
+function listLocalFiles(localDir, recursive = false) {
+    const files = [];
+    const walkDir = (dir, baseDir) => {
+
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            const relativePath = path.relative(baseDir, fullPath);
+            if (entry.isDirectory()) {
+                if (recursive) {
+                    walkDir(fullPath, baseDir); // Recursively traverse directories if flag is set
+                }
+            } else {
+                files.push({
+                    relativePath: relativePath,
+                    localPath: fullPath,
+                    size: fs.statSync(fullPath).size,
+                    modified: fs.statSync(fullPath).mtime.getTime()
+                });
+            }
+        }
+
+    };
+
+    walkDir(localDir, localDir);
+    return files;
+}
+
+/**
+ * Compare local and remote files to determine actions.
+ * @param {Array} localFiles - Array of local file objects.
+ * @param {Array} remoteFiles - Array of remote file objects.
+ * @param {string} localDir - Local directory path.
+ * @param {string} remoteDir - Remote directory path.
+ * @returns {Object} - Object containing files to upload, download, and delete.
+ */
+function compareFiles(localFiles, remoteFiles, localDir, remoteDir) {
+    const toUpload = []; // Files to upload to remote
+    const toDownload = []; // Files to download from remote
+    const toDelete = []; // Files to delete from remote
+
+    // Create a map of remote files for quick lookup
+    const remoteFileMap = new Map();
+    remoteFiles.forEach(file => {
+        remoteFileMap.set(file.name, {
+            size: file.size,
+            modified: new Date(file.modified).getTime()
+        });
+    });
+
+    // Check local files
+    for (const file of localFiles) {
+        const remoteFile = remoteFileMap.get(file.relativePath);
+        if (!remoteFile || file.modified > remoteFile.modified) {
+            toUpload.push(file); // New or updated file
+        }
+    }
+
+    // Check remote files
+    for (const file of remoteFiles) {
+        const localFile = localFiles.find(f => f.relativePath === file.name);
+        if (localFile){
+            console.log(`localFile: ${localFile.relativePath}, modified: ${localFile.modified}`);
+        }
+        console.log(`file: ${file.name}, modified: ${file.modified}`);
+        if (!localFile) {
+            toDelete.push({ relativePath: file.name }); // Extra file in remote
+        } else if (file.modified > parseInt(localFile.modified / 1000)) {
+            toDownload.push(localFile); // New or updated file in remote
+        }
+    }
+
+    return { toUpload, toDownload, toDelete };
+}
+
+/**
+ * Find conflicts where the same file has been modified in both locations.
+ * @param {Array} toUpload - Files to upload.
+ * @param {Array} toDownload - Files to download.
+ * @returns {Array} - Array of conflicting file paths.
+ */
+function findConflicts(toUpload, toDownload) {
+    const conflicts = [];
+    const uploadPaths = toUpload.map(file => file.relativePath);
+    const downloadPaths = toDownload.map(file => file.relativePath);
+
+    for (const path of uploadPaths) {
+        if (downloadPaths.includes(path)) {
+            conflicts.push(path);
+        }
+    }
+
+    return conflicts;
+}
+
+/**
+ * Resolve given local path directory
+ * @param {string} localPath The local path to resolve
+ * @returns {Promise<string>} The resolved absolute path
+ * @throws {Error} If the path does not exist or is not a directory
+ */
+async function resolveLocalDirectory(localPath) {
+    // Resolve the path to an absolute path
+    const absolutePath = path.resolve(localPath);
+  
+    // Check if the path exists
+    if (!fs.existsSync(absolutePath)) {
+      throw new Error(`Path does not exist: ${absolutePath}`);
+    }
+  
+    // Check if the path is a directory
+    const stats = await fs.promises.stat(absolutePath);
+    if (!stats.isDirectory()) {
+      throw new Error(`Path is not a directory: ${absolutePath}`);
+    }
+    return absolutePath;
+}
+
+/**
+ * Ensure a remote directory exists, creating it if necessary
+ * @param {string} remotePath - The remote directory path
+ */
+async function ensureRemoteDirectoryExists(remotePath) {
+    const puter = getPuter();
+    try {
+        const exists = await pathExists(remotePath);
+        if (!exists) {
+            // Create the directory and any missing parents
+            await puter.fs.mkdir(remotePath, {
+                overwrite: false,
+                dedupeName: true,
+                createMissingParents: true
+            })
+        }
+    } catch (error) {
+        console.error(chalk.red(`Failed to create remote directory: ${remotePath}`));
+        throw error;
+    }
+}
+
+/**
+ * Synchronize a local directory with a remote directory on Puter.
+ * @param {string[]} args - Command-line arguments (e.g., [localDir, remoteDir, --delete, -r]).
+ */
+export async function syncDirectory(args = []) {
+    const usageMessage = 'Usage: update <local_directory> <remote_directory> [--delete] [-r] [--overwrite]';
+    if (args.length < 2) {
+        console.log(chalk.red(usageMessage));
+        return;
+    }
+
+    let localDir = '';
+    let remoteDir = '';
+    let deleteFlag = '';
+    let recursiveFlag = false;
+    let overwriteFlag = false;
+    try {
+        localDir = await resolveLocalDirectory(args[0]);
+        remoteDir = resolveRemotePath(getCurrentDirectory(), args[1]);
+        deleteFlag = args.includes('--delete'); // Whether to delete extra files
+        recursiveFlag = args.includes('-r'); // Whether to recursively process subdirectories
+        overwriteFlag = args.includes('--overwrite');
+    } catch (error) {
+        console.error(chalk.red(error.message));
+        console.log(chalk.green(usageMessage));
+        return;
+    }
+
+    console.log(chalk.green(`Syncing local directory ${chalk.cyan(localDir)}" with remote directory ${chalk.cyan(remoteDir)}"...\n`));
+
+    try {
+        // Step 1: Validate local directory
+        if (!fs.existsSync(localDir)) {
+            console.error(chalk.red(`Local directory "${localDir}" does not exist.`));
+            return;
+        }
+
+        // Step 2: Fetch remote directory contents
+        let remoteFiles = [];
+        try {
+            remoteFiles = await listRemoteFiles(remoteDir);
+        } catch (error) {
+            console.log(chalk.yellow('Remote directory is empty or does not exist. Continuing...'));
+        }
+
+        // Step 3: List local files
+        const localFiles = listLocalFiles(localDir, recursiveFlag);
+
+        // Step 4: Compare local and remote files
+        let { toUpload, toDownload, toDelete } = compareFiles(localFiles, remoteFiles, localDir, remoteDir);
+        let filteredToUpload = [...toUpload];
+        let filteredToDownload = [...toDownload];
+
+        // Step 5: Handle conflicts (if any)
+        const conflicts = findConflicts(toUpload, toDownload);
+        if (conflicts.length > 0) {
+            if (overwriteFlag) {
+                console.log(chalk.yellow('Overwriting existing files with local version.'));
+                filteredToDownload = filteredToDownload.filter(file => !conflicts.includes(file.relativePath));
+            } else {
+                console.log(chalk.yellow('The following files have conflicts:'));
+                conflicts.forEach(file => console.log(chalk.dim(`- ${file}`)));
+
+                const { resolve } = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'resolve',
+                        message: 'How would you like to resolve conflicts?',
+                        choices: [
+                            { name: 'Keep local version', value: 'local' },
+                            { name: 'Keep remote version', value: 'remote' },
+                            { name: 'Skip conflicting files', value: 'skip' }
+                        ]
+                    }
+                ]);
+
+                if (resolve === 'local') {
+                    filteredToDownload = filteredToDownload.filter(file => !conflicts.includes(file.relativePath));
+                } else if (resolve === 'remote') {
+                    filteredToUpload = filteredToUpload.filter(file => !conflicts.includes(file.relativePath));
+                } else {
+                    filteredToUpload = filteredToUpload.filter(file => !conflicts.includes(file.relativePath));
+                    filteredToDownload = filteredToDownload.filter(file => !conflicts.includes(file.relativePath));
+                }
+            }
+        }
+
+        // Step 6: Perform synchronization
+        console.log(chalk.green('Starting synchronization...'));
+
+        // Upload new/updated files
+        for (const file of filteredToUpload) {
+            console.log(chalk.cyan(`Uploading "${file.relativePath}"...`));
+            const dedupeName = 'false';
+            const overwrite = 'true';
+
+            // Create parent directories if needed
+            const remoteFilePath = path.join(remoteDir, file.relativePath);
+            const remoteFileDir = path.dirname(remoteFilePath);
+            
+            // Ensure remote directory exists
+            await ensureRemoteDirectoryExists(remoteFileDir);
+
+            await uploadFile([file.localPath, remoteFileDir, dedupeName, overwrite]);
+        }
+
+        // Download new/updated files
+        for (const file of filteredToDownload) {
+            console.log(chalk.cyan(`Downloading "${file.relativePath}"...`));
+            const overwrite = 'true';
+            // Create local parent directories if needed
+            const localFilePath = path.join(localDir, file.relativePath);
+            // const localFileDir = path.dirname(localFilePath);
+
+            await downloadFile([file.remotePath, localFilePath, overwrite]);
+        }
+
+        // Delete extra files (if --delete flag is set)
+        if (deleteFlag) {
+            for (const file of toDelete) {
+                console.log(chalk.yellow(`Deleting "${file.relativePath}"...`));
+                await removeFileOrDirectory([path.join(remoteDir, file.relativePath), '-f']);
+            }
+        }
+
+        console.log(chalk.green('Synchronization complete!'));
+    } catch (error) {
+        console.error(chalk.red('Failed to synchronize directories.'));
+        console.error(chalk.red(`Error: ${error.message}`));
+    }
+}
+
+/**
+ * Edit a remote file using the local system editor
+ * @param {Array} args - The file path to edit
+ * @returns {Promise<void>}
+ */
+export async function editFile(args = []) {
+  if (args.length < 1) {
+    console.log(chalk.red('Usage: edit <file>'));
+    return;
+  }
+
+  const filePath = args[0].startsWith('/') ? args[0] : resolvePath(getCurrentDirectory(), args[0]);
+  console.log(chalk.green(`Fetching file: ${filePath}`));
+
+  const puter = getPuter();
+
+  try {
+    // Step 1: Check if file exists
+    const statData = await puter.fs.stat(filePath);
+    if (!statData || statData.is_dir) {
+      console.log(chalk.red(`File not found or is a directory: ${filePath}`));
+      return;
+    }
+
+    // Step 2: Download the file content
+    const fileBlob = await puter.fs.read(filePath);
+    const fileContent = await fileBlob.text();
+    if (!fileContent) {
+      console.log(chalk.red(`Failed to download file: ${filePath}`));
+      return;
+    }
+    console.log(chalk.green(`File fetched: ${filePath} (${formatSize(fileContent.length)} bytes)`));
+
+    // Step 3: Create a temporary file
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'puter-'));
+    const tempFilePath = path.join(tempDir, path.basename(filePath));
+    fs.writeFileSync(tempFilePath, fileContent, 'utf-8');
+
+    // Step 4: Determine the editor to use
+    const editor = getSystemEditor();
+    console.log(chalk.cyan(`Opening file with ${editor}...`));
+    
+    // Step 5: Open the file in the editor using execSync instead of spawn
+    // This will block until the editor is closed, which is better for terminal-based editors
+    try {
+      execSync(`${editor} "${tempFilePath}"`, { 
+        stdio: 'inherit',
+        env: process.env
+      });
+      
+      // Read the updated content after editor closes
+      const updatedContent = fs.readFileSync(tempFilePath, 'utf8');
+      const blob = new Blob([updatedContent]);
+      console.log(chalk.cyan('Uploading changes...'));
+      
+      // Step 7: Upload the updated file content
+      // Step 7.1: Check disk space
+      const dfData = await puter.fs.space();
+      if (dfData.used >= dfData.capacity) {
+          console.log(chalk.red('Not enough disk space to upload the file.'));
+          showDiskSpaceUsage(dfData); // Display disk usage info
+          return;
+      }
+
+      // Step 7.2: Uploading the updated file
+      const fileName = path.basename(filePath);
+      const dirName = path.dirname(filePath);
+
+      const uploadData = await puter.fs.upload(blob, dirName, {
+        overwrite: true,
+        dedupeName: false,
+        name: fileName
+      });
+      console.log(chalk.green(`File saved: ${uploadData.path}`));
+    } catch (error) {
+      if (error.status === 130) {
+        // This is a SIGINT (Ctrl+C), which is normal for some editors
+        console.log(chalk.yellow('Editor closed without saving.'));
+      } else {
+        console.log(chalk.red(`Error during editing: ${error.message}`));
+      }
+    } finally {
+      // Clean up temporary files
+      try {
+        fs.unlinkSync(tempFilePath);
+        fs.rmdirSync(tempDir);
+      } catch (e) {
+        console.error(chalk.dim(`Failed to clean up temporary files: ${e.message}`));
+      }
+    }
+  } catch (error) {
+    console.log(chalk.red(`Error: ${error.message}`));
+  }
+}