@tuskydp/cli 0.1.0 → 0.1.2

package/src/commands/files.ts

@@ -0,0 +1,192 @@
+import type { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { cliConfig } from '../config.js';
+import { getSDKClient } from '../sdk.js';
+import { createTable, formatBytes, formatDate } from '../lib/output.js';
+import { resolveVault } from '../lib/resolve.js';
+
+export function registerFileCommands(program: Command) {
+  // ls command (top-level shortcut)
+  program.command('ls [vault]')
+    .description('List files')
+    .option('--sort <field>', 'Sort by: name, size, date', 'date')
+    .option('--limit <n>', 'Max results', '50')
+    .option('-f, --follow', 'Watch mode: refresh every 3 seconds')
+    .action(async (vaultRef: string | undefined, options) => {
+      const sdk = getSDKClient(program);
+      const format = program.opts().format || cliConfig.get('outputFormat');
+
+      let vaultId: string | undefined;
+      if (vaultRef) {
+        vaultId = await resolveVault(sdk, vaultRef);
+      }
+
+      const sortMap: Record<string, string> = { name: 'name', size: 'sizeBytes', date: 'createdAt' };
+
+      const fetchAndRender = async (): Promise<void> => {
+        const { files } = await sdk.files.list({
+          vaultId,
+          limit: parseInt(options.limit),
+          sortBy: sortMap[options.sort] as 'createdAt' | 'name' | 'sizeBytes',
+          order: 'desc',
+        });
+
+        if (format === 'json') {
+          console.log(JSON.stringify({ files }, null, 2));
+          return;
+        }
+
+        if (files.length === 0) {
+          console.log(chalk.dim('No files found.'));
+          return;
+        }
+
+        const table = createTable(['Name', 'Size', 'Status', 'Uploaded', 'ID']);
+        for (const f of files) {
+          const statusColors: Record<string, typeof chalk.green> = {
+            hot: chalk.green,
+            synced: chalk.blue,
+            cold: chalk.yellow,
+            error: chalk.red,
+            uploading: chalk.dim,
+          };
+          const statusColor = statusColors[f.status] || chalk.white;
+
+          table.push([
+            f.name,
+            formatBytes(f.plaintextSizeBytes || f.sizeBytes),
+            statusColor(f.status),
+            formatDate(f.createdAt),
+            chalk.dim(f.id),
+          ]);
+        }
+        console.log(table.toString());
+      };
+
+      if (options.follow) {
+        const clear = () => process.stdout.write('\x1B[2J\x1B[H');
+        const render = async () => {
+          clear();
+          console.log(chalk.dim(`Watching files — refreshing every 3s (Ctrl+C to stop)\n`));
+          try {
+            await fetchAndRender();
+          } catch (err: any) {
+            console.error(chalk.red(`Error: ${err.message}`));
+          }
+        };
+        await render();
+        const interval = setInterval(render, 3000);
+        process.on('SIGINT', () => {
+          clearInterval(interval);
+          process.exit(0);
+        });
+        // Keep process alive
+        await new Promise(() => {});
+      } else {
+        await fetchAndRender();
+      }
+    });
+
+  // info command
+  program.command('info <file-id>')
+    .description('Show file details')
+    .action(async (fileId: string) => {
+      const sdk = getSDKClient(program);
+      const format = program.opts().format || cliConfig.get('outputFormat');
+      const file = await sdk.files.get(fileId);
+
+      if (format === 'json') {
+        console.log(JSON.stringify(file, null, 2));
+        return;
+      }
+
+      console.log(`Name:        ${file.name}`);
+      console.log(`Size:        ${formatBytes(file.plaintextSizeBytes || file.sizeBytes)}`);
+      console.log(`MIME:        ${file.mimeType}`);
+      console.log(`Status:      ${file.status}`);
+      console.log(`Encrypted:   ${file.encrypted ? 'Yes' : 'No'}`);
+      console.log(`Vault:       ${file.vaultId}`);
+      if (file.folderId) console.log(`Folder:      ${file.folderId}`);
+      if (file.walrusBlobId) console.log(`Walrus Blob: ${file.walrusBlobId}`);
+      if (file.lastSyncError) console.log(`Sync Error:  ${chalk.red(file.lastSyncError)}`);
+      console.log(`Uploaded:    ${new Date(file.createdAt).toISOString()}`);
+      console.log(`ID:          ${file.id}`);
+    });
+
+  // status command
+  program.command('status <file-id>')
+    .description('Show sync status')
+    .action(async (fileId: string) => {
+      const sdk = getSDKClient(program);
+      const file = await sdk.files.getStatus(fileId);
+
+      console.log(`File:        ${file.name}`);
+      console.log(`Status:      ${file.status}`);
+      if (file.walrusBlobId) {
+        console.log(`Walrus Blob: ${file.walrusBlobId}`);
+      } else {
+        console.log(`Walrus:      ${chalk.dim('Not synced yet')}`);
+      }
+    });
+
+  // retry command
+  program.command('retry [file-ids...]')
+    .description('Retry failed Walrus sync (all errored files if no IDs given)')
+    .action(async (fileIds: string[]) => {
+      const sdk = getSDKClient(program);
+      const format = program.opts().format || cliConfig.get('outputFormat');
+
+      if (fileIds.length === 0) {
+        const result = await sdk.files.retryAll();
+        if (format === 'json') {
+          console.log(JSON.stringify(result, null, 2));
+        } else if (result.retriedCount === 0) {
+          console.log(chalk.dim('No files in error status.'));
+        } else {
+          console.log(chalk.green(`Re-queued ${result.retriedCount} file(s) for Walrus sync.`));
+        }
+        return;
+      }
+
+      for (const fileId of fileIds) {
+        try {
+          const result = await sdk.files.retry(fileId);
+          if (format === 'json') {
+            console.log(JSON.stringify(result, null, 2));
+          } else {
+            console.log(chalk.green(`Retried: ${fileId}`));
+          }
+        } catch (err: any) {
+          console.error(chalk.red(`Failed to retry ${fileId}: ${err.message}`));
+        }
+      }
+    });
+
+  // rm command
+  program.command('rm <file-ids...>')
+    .description('Delete one or more files')
+    .option('--force', 'Skip confirmation prompt')
+    .action(async (fileIds: string[], options) => {
+      const sdk = getSDKClient(program);
+
+      if (!options.force) {
+        const answers = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'confirm',
+          message: `Delete ${fileIds.length} file(s)? This cannot be undone.`,
+          default: false,
+        }]);
+        if (!answers.confirm) return;
+      }
+
+      for (const fileId of fileIds) {
+        try {
+          await sdk.files.delete(fileId);
+          console.log(chalk.green(`Deleted: ${fileId}`));
+        } catch (err: any) {
+          console.error(chalk.red(`Failed to delete ${fileId}: ${err.message}`));
+        }
+      }
+    });
+}

package/src/commands/mcp.ts

@@ -0,0 +1,220 @@
+/**
+ * Commander registration for `tusky mcp` subcommands:
+ *   - tusky mcp serve          — Start the MCP server (stdio transport)
+ *   - tusky mcp install-config — Write MCP config for Claude Code / Cursor
+ */
+
+import type { Command } from 'commander';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname, resolve } from 'path';
+import { homedir } from 'os';
+import chalk from 'chalk';
+import { getApiUrl, getApiKey, cliConfig } from '../config.js';
+import { startMcpServer } from '../mcp/server.js';
+
+// ---------------------------------------------------------------------------
+// Config file locations for each supported client
+// ---------------------------------------------------------------------------
+
+interface McpClientTarget {
+  name: string;
+  configPath: string;
+  description: string;
+}
+
+function getTargets(): McpClientTarget[] {
+  const home = homedir();
+
+  return [
+    {
+      name: 'claude-code',
+      configPath: join(process.cwd(), '.mcp.json'),
+      description: 'Claude Code (project-level .mcp.json in current directory)',
+    },
+    {
+      name: 'claude-desktop',
+      configPath:
+        process.platform === 'win32'
+          ? join(home, 'AppData', 'Roaming', 'Claude', 'claude_desktop_config.json')
+          : join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'),
+      description: 'Claude Desktop',
+    },
+    {
+      name: 'cursor',
+      configPath: join(home, '.cursor', 'mcp.json'),
+      description: 'Cursor editor',
+    },
+  ];
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function getTuskyBinaryCommand(): { command: string; args: string[] } {
+  // Strategy: use absolute paths to avoid PATH resolution failures.
+  // Agent hosts (Claude Code, Cursor, Desktop) spawn processes with a
+  // minimal PATH that won't include nvm shims, pnpm globals, etc.
+  //
+  // Priority:
+  //   1. If `tusky` exists in a well-known PATH dir → use it directly
+  //      (standard npm -g install lands in /usr/local/bin or /opt/homebrew/bin)
+  //   2. Resolve absolute path to node + our entry script
+  //      (works for pnpm link, local dev, non-standard installs)
+  //   3. Fallback to npx
+
+  // Check if `tusky` is available in the standard agent-visible PATH dirs
+  const agentPathDirs = ['/usr/local/bin', '/opt/homebrew/bin', '/usr/bin'];
+  for (const dir of agentPathDirs) {
+    const tuskyBin = join(dir, 'tusky');
+    if (existsSync(tuskyBin)) {
+      return { command: tuskyBin, args: ['mcp', 'serve'] };
+    }
+  }
+
+  // Not in standard PATH — resolve absolute node + entry script paths
+  // (handles pnpm link --global, local dev, monorepo installs)
+  const nodeExe = process.execPath;
+  const thisDir = dirname(new URL(import.meta.url).pathname);
+
+  // Try: <thisDir>/../../bin/tuskydp.js  (running from dist/commands/)
+  const entryPoint = resolve(join(thisDir, '..', '..', 'bin', 'tuskydp.js'));
+  if (existsSync(entryPoint)) {
+    return { command: nodeExe, args: [entryPoint, 'mcp', 'serve'] };
+  }
+
+  // Try: <thisDir>/../../../dist/bin/tuskydp.js  (running from src/commands/ in dev)
+  const distEntry = resolve(join(thisDir, '..', '..', '..', 'dist', 'bin', 'tuskydp.js'));
+  if (existsSync(distEntry)) {
+    return { command: nodeExe, args: [distEntry, 'mcp', 'serve'] };
+  }
+
+  // Last resort: npx (works if npm/npx is in the agent's PATH)
+  return { command: 'npx', args: ['-y', '@tuskydp/cli', 'mcp', 'serve'] };
+}
+
+function buildMcpServerEntry(apiKey?: string, apiUrl?: string) {
+  const { command, args } = getTuskyBinaryCommand();
+
+  const env: Record<string, string> = {};
+  if (apiKey) env.TUSKYDP_API_KEY = apiKey;
+  if (apiUrl) env.TUSKYDP_API_URL = apiUrl;
+
+  // Placeholder for password — user fills in
+  env.TUSKYDP_PASSWORD = '';
+
+  const entry: Record<string, unknown> = {
+    command,
+    args,
+  };
+
+  if (Object.keys(env).length > 0) {
+    entry.env = env;
+  }
+
+  return entry;
+}
+
+function readJsonFile(filePath: string): Record<string, unknown> {
+  if (!existsSync(filePath)) return {};
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+function writeJsonFile(filePath: string, data: Record<string, unknown>): void {
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+}
+
+// ---------------------------------------------------------------------------
+// Command registration
+// ---------------------------------------------------------------------------
+
+export function registerMcpCommands(program: Command) {
+  const mcp = program
+    .command('mcp')
+    .description('MCP server for AI agents (Claude Code, Cursor, etc.)');
+
+  // ── tusky mcp serve ──────────────────────────────────────────────────
+  mcp
+    .command('serve')
+    .description('Start the MCP server (stdio transport for AI agent integration)')
+    .action(async () => {
+      // Resolve API credentials from the same priority chain as all CLI commands
+      const root = mcp.parent || mcp;
+      const apiUrl = getApiUrl(root.opts().apiUrl);
+      const apiKey = getApiKey(root.opts().apiKey);
+
+      await startMcpServer({ apiKey, apiUrl });
+    });
+
+  // ── tusky mcp install-config ─────────────────────────────────────────
+  mcp
+    .command('install-config')
+    .description('Add Tusky MCP server config to Claude Code, Claude Desktop, or Cursor')
+    .option('--target <target>', 'Target client: claude-code, claude-desktop, cursor', 'claude-code')
+    .option('--api-key <key>', 'API key to embed (defaults to stored key)')
+    .option('--api-url <url>', 'API URL override')
+    .action(async (options: { target: string; apiKey?: string; apiUrl?: string }) => {
+      const targets = getTargets();
+      const target = targets.find((t) => t.name === options.target);
+
+      if (!target) {
+        console.error(
+          chalk.red(`Unknown target "${options.target}". Valid targets: ${targets.map((t) => t.name).join(', ')}`),
+        );
+        process.exit(1);
+      }
+
+      // Resolve API key (flag > stored > error)
+      const root = mcp.parent || mcp;
+      const apiKey = options.apiKey ?? root.opts().apiKey ?? process.env.TUSKYDP_API_KEY ?? cliConfig.get('apiKey');
+      const apiUrl = options.apiUrl ?? root.opts().apiUrl ?? process.env.TUSKYDP_API_URL;
+
+      // Only include non-default values
+      const resolvedApiUrl = apiUrl && apiUrl !== 'https://api.tusky.ai' ? apiUrl : undefined;
+
+      // Build the server entry
+      const serverEntry = buildMcpServerEntry(apiKey, resolvedApiUrl);
+
+      // Read existing config
+      const config = readJsonFile(target.configPath);
+
+      // Merge into mcpServers
+      if (!config.mcpServers || typeof config.mcpServers !== 'object') {
+        config.mcpServers = {};
+      }
+
+      const mcpServers = config.mcpServers as Record<string, unknown>;
+      const existed = 'tusky' in mcpServers;
+      mcpServers.tusky = serverEntry;
+
+      // Write back
+      writeJsonFile(target.configPath, config);
+
+      console.log(chalk.green(`${existed ? 'Updated' : 'Added'} Tusky MCP server config for ${target.description}`));
+      console.log(chalk.dim(`  Config file: ${target.configPath}`));
+      console.log('');
+
+      if (!apiKey) {
+        console.log(chalk.yellow('  Note: No API key found. Add your API key to the config:'));
+        console.log(chalk.dim(`  Set TUSKYDP_API_KEY in the env block of ${target.configPath}`));
+        console.log('');
+      }
+
+      console.log(chalk.yellow('  Remember to set TUSKYDP_PASSWORD in the config for private vault encryption:'));
+      console.log(chalk.dim(`  Edit the env block in ${target.configPath}`));
+      console.log('');
+
+      if (options.target === 'claude-desktop') {
+        console.log(chalk.dim('  Restart Claude Desktop to pick up the changes.'));
+      } else if (options.target === 'claude-code') {
+        console.log(chalk.dim('  Claude Code will automatically detect the .mcp.json file.'));
+      } else if (options.target === 'cursor') {
+        console.log(chalk.dim('  Restart Cursor to pick up the changes.'));
+      }
+    });
+}

package/src/commands/rehydrate.ts

@@ -0,0 +1,37 @@
+import type { Command } from 'commander';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+import { resolveWalrusConfig } from '@tuskydp/shared/walrus-networks.js';
+import { formatBytes } from '../lib/output.js';
+import { createSpinner } from '../lib/progress.js';
+
+export async function rehydrateCommand(blobId: string, options: {
+  output?: string;
+}, _program: Command) {
+  const spinner = createSpinner('Fetching blob from Walrus...');
+  spinner.start();
+
+  try {
+    const tuskyEnv = process.env.TUSKY_ENV || 'production';
+    const walrus = resolveWalrusConfig(tuskyEnv);
+
+    const url = `${walrus.aggregatorUrl}/v1/blobs/${blobId}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Walrus fetch failed: ${response.status} ${response.statusText}`);
+    }
+
+    const arrayBuf = await response.arrayBuffer();
+    const fileBuffer = Buffer.from(new Uint8Array(arrayBuf));
+
+    // Sanitize blob ID for use as filename (replace non-filesystem-safe characters)
+    const safeBlobId = blobId.replace(/[^a-zA-Z0-9_-]/g, '_');
+    const outputPath = options.output || join(process.cwd(), `blob-${safeBlobId}`);
+    writeFileSync(outputPath, fileBuffer);
+
+    spinner.succeed(`Downloaded -> ${outputPath} (${formatBytes(fileBuffer.length)})`);
+  } catch (err: any) {
+    spinner.fail(`Rehydrate failed: ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/tui.ts

@@ -0,0 +1,11 @@
+import type { Command } from 'commander';
+import { launchTui } from '../tui/index.js';
+
+export function registerTuiCommand(program: Command) {
+  program
+    .command('tui')
+    .description('Interactive terminal UI')
+    .action(async () => {
+      await launchTui();
+    });
+}

package/src/commands/upload.ts

@@ -0,0 +1,143 @@
+import type { Command } from 'commander';
+import { readFileSync, statSync, readdirSync } from 'fs';
+import { basename, join, resolve } from 'path';
+import { lookup } from 'mime-types';
+import chalk from 'chalk';
+import { getApiUrl, getApiKey } from '../config.js';
+import { createSDKClient } from '../sdk.js';
+import { resolveVault } from '../lib/resolve.js';
+import { formatBytes } from '../lib/output.js';
+import { createSpinner } from '../lib/progress.js';
+import { encryptBuffer } from '../crypto.js';
+import { loadMasterKey } from '../lib/keyring.js';
+
+async function expandPaths(paths: string[], recursive?: boolean): Promise<string[]> {
+  const result: string[] = [];
+  for (const p of paths) {
+    const resolved = resolve(p);
+    const stat = statSync(resolved, { throwIfNoEntry: false });
+    if (!stat) {
+      console.warn(chalk.yellow(`Warning: ${p} not found, skipping`));
+      continue;
+    }
+    if (stat.isFile()) {
+      result.push(resolved);
+    } else if (stat.isDirectory() && recursive) {
+      const entries = readdirSync(resolved, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isFile()) {
+          result.push(join(resolved, entry.name));
+        } else if (entry.isDirectory()) {
+          const subFiles = await expandPaths([join(resolved, entry.name)], true);
+          result.push(...subFiles);
+        }
+      }
+    } else if (stat.isDirectory()) {
+      console.warn(chalk.yellow(`Warning: ${p} is a directory. Use --recursive to upload contents.`));
+    }
+  }
+  return result;
+}
+
+export async function uploadCommand(paths: string[], options: {
+  vault?: string;
+  recursive?: boolean;
+}, program: Command) {
+  const apiUrl = getApiUrl(program.opts().apiUrl);
+  const apiKey = getApiKey(program.opts().apiKey);
+  const sdk = createSDKClient(apiUrl, apiKey);
+
+  const vaultId = await resolveVault(sdk, options.vault);
+  const vault = await sdk.vaults.get(vaultId);
+  const isPrivate = vault.visibility === 'private';
+
+  let masterKey: Buffer | null = null;
+  if (isPrivate) {
+    masterKey = loadMasterKey();
+    if (!masterKey) {
+      console.error(chalk.red('Encryption session not unlocked. Run: tusky encryption unlock'));
+      process.exit(1);
+    }
+  }
+
+  const filePaths = await expandPaths(paths, options.recursive);
+  if (filePaths.length === 0) {
+    console.log(chalk.yellow('No files to upload.'));
+    return;
+  }
+
+  let totalSize = 0;
+  let successCount = 0;
+
+  for (const filePath of filePaths) {
+    const spinner = createSpinner(`Uploading ${basename(filePath)}`);
+    spinner.start();
+
+    try {
+      const stat = statSync(filePath);
+      const fileBuffer = readFileSync(filePath);
+      const mimeType = lookup(filePath) || 'application/octet-stream';
+
+      let uploadBody: Buffer;
+      let encryptionMeta: {
+        wrappedKey?: string;
+        encryptionIv?: string;
+        plaintextSizeBytes?: number;
+        plaintextChecksumSha256?: string;
+      } = {};
+
+      if (isPrivate && masterKey) {
+        spinner.text = `Encrypting ${basename(filePath)}...`;
+        const { ciphertext, wrappedKey, iv, plaintextChecksum } = encryptBuffer(fileBuffer, masterKey);
+        uploadBody = ciphertext;
+        encryptionMeta = {
+          wrappedKey,
+          encryptionIv: iv,
+          plaintextSizeBytes: stat.size,
+          plaintextChecksumSha256: plaintextChecksum,
+        };
+      } else {
+        uploadBody = fileBuffer;
+      }
+
+      // Request presigned URL
+      spinner.text = `Requesting upload URL for ${basename(filePath)}...`;
+      const { fileId, uploadUrl } = await sdk.files.requestUpload({
+        name: basename(filePath),
+        mimeType,
+        sizeBytes: uploadBody.length,
+        vaultId,
+        ...encryptionMeta,
+      });
+
+      // Upload to Spaces via presigned URL
+      spinner.text = `Uploading ${basename(filePath)} (${formatBytes(uploadBody.length)})...`;
+      const uploadResponse = await fetch(uploadUrl, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/octet-stream' },
+        body: new Uint8Array(uploadBody),
+      });
+      if (!uploadResponse.ok) throw new Error(`Upload failed: ${uploadResponse.status}`);
+
+      // Confirm
+      spinner.text = `Confirming ${basename(filePath)}...`;
+      await sdk.files.confirmUpload(fileId);
+
+      spinner.succeed(`${basename(filePath)} -> ${fileId} (${formatBytes(uploadBody.length)})`);
+      totalSize += uploadBody.length;
+      successCount++;
+    } catch (err: any) {
+      spinner.fail(`Failed: ${basename(filePath)} — ${err.message}`);
+      // Surface PPU payment details if present (402 errors)
+      if (err.statusCode === 402) {
+        console.error(chalk.yellow('  This may require topping up your wallet balance.'));
+        console.error(chalk.dim('  Check your wallet: tusky account usage'));
+      }
+    }
+  }
+
+  if (filePaths.length > 1) {
+    const icon = isPrivate ? 'private' : 'public';
+    console.log(`\nUploaded ${successCount} file(s) (${formatBytes(totalSize)}) to vault "${vault.name}" [${icon}]`);
+  }
+}