@tuskydp/cli 0.3.0 → 0.4.0

package/src/commands/decrypt.ts

@@ -1,309 +0,0 @@
-/**
- * `tusky decrypt` — Decrypt a file downloaded from Walrus.
- *
- * Works in two modes:
- *   1. With --export <manifest.json> — reads wrappedKey/iv from the export
- *      manifest, derives master key from passphrase + salt. Fully offline.
- *   2. Without --export — fetches encryption params from the Tusky API and
- *      looks up the file metadata by ID. Requires API access.
- *
- * In both modes, the passphrase is resolved from:
- *   --passphrase flag > TUSKYDP_PASSWORD env var > interactive prompt
- */
-
-import type { Command } from 'commander';
-import { readFileSync, writeFileSync, existsSync } from 'fs';
-import { resolve, basename } from 'path';
-import chalk from 'chalk';
-import ora from 'ora';
-import inquirer from 'inquirer';
-import { getApiUrl, getApiKey } from '../config.js';
-import { createSDKClient } from '../sdk.js';
-import { createSpinner } from '../lib/progress.js';
-import { loadMasterKey } from '../lib/keyring.js';
-import {
-  deriveMasterKey,
-  verifyPassphrase,
-  unwrapMasterKey,
-  decryptBuffer,
-} from '../crypto.js';
-import type { ExportManifest, ExportedFile } from './export.js';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Resolve the master key. Priority:
- *   1. Session keyring (~/.tusky/session.enc)
- *   2. Passphrase derivation (requires API or --salt/--encrypted-master-key)
- */
-async function resolveMasterKey(options: {
-  passphrase?: string;
-  salt?: string;
-  verifier?: string;
-  encryptedMasterKey?: string;
-}): Promise<Buffer> {
-  // Try session keyring first
-  const sessionKey = loadMasterKey();
-  if (sessionKey) return sessionKey;
-
-  // Need passphrase
-  let passphrase = options.passphrase ?? process.env.TUSKYDP_PASSWORD;
-  if (!passphrase) {
-    const answers = await inquirer.prompt([{
-      type: 'password',
-      name: 'passphrase',
-      message: 'Enter encryption passphrase:',
-      mask: '*',
-    }]);
-    passphrase = answers.passphrase as string;
-  }
-
-  if (!options.salt) {
-    throw new Error('Cannot derive master key: salt is required. Use --export with an export manifest, or ensure the Tusky API is accessible.');
-  }
-
-  const salt = Buffer.from(options.salt, 'base64');
-  const wrappingKey = deriveMasterKey(passphrase, salt);
-
-  // Verify if we have a verifier
-  if (options.verifier) {
-    const verifierBuf = Buffer.from(options.verifier, 'base64');
-    if (!verifyPassphrase(wrappingKey, verifierBuf)) {
-      throw new Error('Invalid passphrase.');
-    }
-  }
-
-  // Unwrap master key if account has one
-  if (options.encryptedMasterKey) {
-    return unwrapMasterKey(Buffer.from(options.encryptedMasterKey, 'base64'), wrappingKey);
-  }
-
-  // Legacy: wrapping key IS the master key
-  return wrappingKey;
-}
-
-// ---------------------------------------------------------------------------
-// Command registration
-// ---------------------------------------------------------------------------
-
-async function readStdin(): Promise<Buffer> {
-  return new Promise((resolve, reject) => {
-    const chunks: Buffer[] = [];
-    process.stdin.on('data', (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
-    process.stdin.on('end', () => resolve(Buffer.concat(chunks)));
-    process.stdin.on('error', reject);
-  });
-}
-
-export function registerDecryptCommand(program: Command) {
-  program
-    .command('decrypt [encrypted-file]')
-    .description('Decrypt a file downloaded from Walrus using your encryption passphrase')
-    .option('-o, --output <path>', 'Output path for decrypted file')
-    .option('--stdin', 'Read ciphertext from stdin (for sandboxed agents without filesystem access)')
-    .option('--stdout', 'Write plaintext to stdout instead of a file')
-    .option('--file-id <id>', 'Tusky file ID (to look up wrappedKey/iv from API)')
-    .option('--export <path>', 'Path to tusky-export.json manifest (for offline decryption)')
-    .option('--passphrase <passphrase>', 'Encryption passphrase (also reads TUSKYDP_PASSWORD env var)')
-    .option('--wrapped-key <key>', 'Per-file wrapped key (base64, from export manifest)')
-    .option('--iv <iv>', 'Per-file encryption IV (base64, from export manifest)')
-    .option('--checksum <sha256>', 'Expected plaintext SHA-256 checksum (hex)')
-    .action(async (encryptedFile: string | undefined, options: {
-      output?: string;
-      stdin?: boolean;
-      stdout?: boolean;
-      fileId?: string;
-      export?: string;
-      passphrase?: string;
-      wrappedKey?: string;
-      iv?: string;
-      checksum?: string;
-    }) => {
-      // When piping to stdout, send spinner to stderr to avoid polluting the binary stream
-      const spinnerStream = options.stdout ? process.stderr : process.stdout;
-      const spinner = ora({ text: 'Preparing decryption...', stream: spinnerStream as NodeJS.WritableStream });
-      spinner.start();
-
-      try {
-        // Resolve ciphertext source: --stdin, or file path
-        let ciphertext: Buffer;
-        let defaultFileName = 'decrypted';
-
-        if (options.stdin) {
-          spinner.text = 'Reading ciphertext from stdin...';
-          ciphertext = await readStdin();
-        } else {
-          if (!encryptedFile) {
-            spinner.fail('Provide an encrypted file path, or use --stdin to read from stdin.');
-            return;
-          }
-          const inputPath = resolve(encryptedFile);
-          if (!existsSync(inputPath)) {
-            spinner.fail(`File not found: ${inputPath}`);
-            return;
-          }
-          defaultFileName = basename(inputPath).replace(/\.enc$/, '');
-          ciphertext = readFileSync(inputPath);
-        }
-
-        let wrappedKey: string;
-        let iv: string;
-        let checksum: string | undefined = options.checksum;
-        let fileName: string = defaultFileName;
-        let encryptionParams: { salt?: string; verifier?: string; encryptedMasterKey?: string } = {};
-
-        // ── Mode 1: Export manifest ──────────────────────────────────
-        if (options.export) {
-          spinner.text = 'Reading export manifest...';
-          const manifestPath = resolve(options.export);
-          if (!existsSync(manifestPath)) {
-            spinner.fail(`Export manifest not found: ${manifestPath}`);
-            return;
-          }
-
-          const manifest: ExportManifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
-          let exportedFile: ExportedFile | undefined;
-
-          if (options.fileId) {
-            exportedFile = manifest.files.find((f) => f.fileId === options.fileId);
-          } else {
-            exportedFile = manifest.files.find((f) =>
-              f.name === defaultFileName || f.name === encryptedFile,
-            );
-
-            if (!exportedFile && manifest.files.length === 1) {
-              exportedFile = manifest.files[0];
-            }
-          }
-
-          if (!exportedFile) {
-            spinner.fail(
-              options.fileId
-                ? `File ID ${options.fileId} not found in export manifest.`
-                : `Could not match "${defaultFileName}" to a file in the export manifest. Use --file-id to specify.`,
-            );
-            return;
-          }
-
-          if (!exportedFile.encrypted) {
-            spinner.fail(`File "${exportedFile.name}" is not encrypted (public vault). No decryption needed.`);
-            return;
-          }
-
-          if (!exportedFile.wrappedKey || !exportedFile.encryptionIv) {
-            spinner.fail(`File "${exportedFile.name}" is missing encryption metadata in the export.`);
-            return;
-          }
-
-          wrappedKey = exportedFile.wrappedKey;
-          iv = exportedFile.encryptionIv;
-          checksum = checksum ?? exportedFile.plaintextChecksumSha256 ?? undefined;
-          fileName = exportedFile.name;
-
-          // Read account-level encryption params from manifest
-          if (manifest.encryption) {
-            encryptionParams = {
-              salt: manifest.encryption.salt ?? undefined,
-              verifier: manifest.encryption.verifier ?? undefined,
-              encryptedMasterKey: manifest.encryption.encryptedMasterKey ?? undefined,
-            };
-          }
-
-        // ── Mode 2: Direct flags ─────────────────────────────────────
-        } else if (options.wrappedKey && options.iv) {
-          wrappedKey = options.wrappedKey;
-          iv = options.iv;
-
-        // ── Mode 3: Fetch from API ───────────────────────────────────
-        } else if (options.fileId) {
-          spinner.text = 'Fetching file metadata from API...';
-          const apiUrl = getApiUrl(program.opts().apiUrl);
-          const apiKey = getApiKey(program.opts().apiKey);
-          const sdk = createSDKClient(apiUrl, apiKey);
-
-          const file = await sdk.files.get(options.fileId);
-          if (!file.encrypted) {
-            spinner.fail('This file is not encrypted. No decryption needed.');
-            return;
-          }
-          if (!file.wrappedKey || !file.encryptionIv) {
-            spinner.fail('File is missing encryption metadata.');
-            return;
-          }
-
-          wrappedKey = file.wrappedKey;
-          iv = file.encryptionIv;
-          checksum = checksum ?? file.plaintextChecksumSha256 ?? undefined;
-          fileName = file.name;
-
-          // Also fetch encryption params for master key derivation
-          const params = await sdk.account.getEncryptionParams();
-          encryptionParams = {
-            salt: params.salt ?? undefined,
-            verifier: params.verifier ?? undefined,
-            encryptedMasterKey: params.encryptedMasterKey ?? undefined,
-          };
-
-        } else {
-          spinner.fail(
-            'Need encryption metadata. Use one of:\n' +
-            '  --export <manifest.json>          (offline, from tusky export)\n' +
-            '  --file-id <id>                    (online, fetches from API)\n' +
-            '  --wrapped-key <key> --iv <iv>     (manual, base64 values)',
-          );
-          return;
-        }
-
-        // If we don't have encryption params yet, try API
-        if (!encryptionParams.salt) {
-          try {
-            const apiUrl = getApiUrl(program.opts().apiUrl);
-            const apiKey = getApiKey(program.opts().apiKey);
-            const sdk = createSDKClient(apiUrl, apiKey);
-            const params = await sdk.account.getEncryptionParams();
-            encryptionParams = {
-              salt: params.salt ?? undefined,
-              verifier: params.verifier ?? undefined,
-              encryptedMasterKey: params.encryptedMasterKey ?? undefined,
-            };
-          } catch {
-            // API unavailable — that's ok if we have a session key
-          }
-        }
-
-        // Resolve master key
-        spinner.text = 'Deriving encryption key...';
-        const masterKey = await resolveMasterKey({
-          passphrase: options.passphrase,
-          ...encryptionParams,
-        });
-
-        // Decrypt
-        spinner.text = 'Decrypting...';
-        const plaintext = decryptBuffer(ciphertext, wrappedKey, iv, masterKey, checksum);
-
-        if (options.stdout) {
-          spinner.stop();
-          process.stdout.write(plaintext);
-          if (checksum) {
-            process.stderr.write(chalk.dim('  Integrity check passed (SHA-256)\n'));
-          }
-        } else {
-          // Write to disk
-          const outputPath = options.output ? resolve(options.output) : resolve(fileName);
-          writeFileSync(outputPath, plaintext);
-          spinner.succeed(`Decrypted -> ${outputPath} (${plaintext.length} bytes)`);
-          if (checksum) {
-            console.log(chalk.dim('  Integrity check passed (SHA-256)'));
-          }
-        }
-      } catch (err: any) {
-        spinner.fail(`Decryption failed: ${err.message}`);
-        if (err.message.includes('Unsupported state') || err.message.includes('auth tag')) {
-          console.log(chalk.dim('  This usually means the passphrase is incorrect or the file is corrupted.'));
-        }
-      }
-    });
-}

package/src/commands/encryption.ts

@@ -1,305 +0,0 @@
-import type { Command } from 'commander';
-import chalk from 'chalk';
-import inquirer from 'inquirer';
-import { getSDKClientFromParent } from '../sdk.js';
-import {
-  deriveMasterKey,
-  computeVerifier,
-  verifyPassphrase,
-  generateSalt,
-  generateMasterKey,
-  generateRecoveryKey,
-  wrapMasterKey,
-  unwrapMasterKey,
-} from '../crypto.js';
-import { storeMasterKey, loadMasterKey, clearSession } from '../lib/keyring.js';
-
-export function registerEncryptionCommands(program: Command) {
-  const encryption = program.command('encryption').description('Manage E2E encryption');
-
-  encryption.command('setup')
-    .description('Set encryption passphrase (first time only)')
-    .action(async () => {
-      const sdk = getSDKClientFromParent(encryption);
-
-      // Check if already set up
-      const { setupComplete } = await sdk.account.getEncryptionParams();
-      if (setupComplete) {
-        console.log(chalk.yellow('Encryption is already set up.'));
-        console.log(chalk.dim('Use: tusky encryption change-passphrase'));
-        return;
-      }
-
-      // Get passphrase
-      const answers = await inquirer.prompt([
-        {
-          type: 'password',
-          name: 'passphrase',
-          message: 'Enter encryption passphrase:',
-          mask: '*',
-          validate: (input: string) => input.length >= 8 || 'Passphrase must be at least 8 characters',
-        },
-        {
-          type: 'password',
-          name: 'confirm',
-          message: 'Confirm passphrase:',
-          mask: '*',
-        },
-      ]);
-
-      if (answers.passphrase !== answers.confirm) {
-        console.error(chalk.red('Passphrases do not match.'));
-        return;
-      }
-
-      // Generate random master key and derive wrapping key from passphrase
-      const masterKey = generateMasterKey();
-      const salt = generateSalt();
-      const wrappingKey = deriveMasterKey(answers.passphrase, salt);
-      const verifier = computeVerifier(wrappingKey);
-
-      // Wrap master key with wrapping key (for passphrase unlock)
-      const encryptedMasterKey = wrapMasterKey(masterKey, wrappingKey);
-
-      // Wrap master key with recovery key (for recovery flow)
-      const recoveryKeyRaw = generateRecoveryKey();
-      const wrappedMasterKeyBackup = wrapMasterKey(masterKey, recoveryKeyRaw);
-      const recoveryKeyBase64 = recoveryKeyRaw.toString('base64');
-
-      // Send to server
-      await sdk.account.setupEncryption({
-        salt: salt.toString('base64'),
-        verifier: verifier.toString('base64'),
-        encryptedMasterKey: encryptedMasterKey.toString('base64'),
-        wrappedMasterKeyBackup: wrappedMasterKeyBackup.toString('base64'),
-      });
-
-      // Store master key in session
-      storeMasterKey(masterKey);
-
-      // Display recovery key
-      console.log('');
-      console.log(chalk.yellow.bold('SAVE YOUR RECOVERY KEY — it will not be shown again:'));
-      console.log('');
-      console.log(chalk.bold(`  ${recoveryKeyBase64}`));
-      console.log('');
-
-      const confirmSaved = await inquirer.prompt([{
-        type: 'confirm',
-        name: 'saved',
-        message: 'Have you saved your recovery key?',
-        default: false,
-      }]);
-
-      if (!confirmSaved.saved) {
-        console.log(chalk.yellow('Please save your recovery key before continuing!'));
-        console.log(chalk.bold(`  ${recoveryKeyBase64}`));
-      }
-
-      console.log(chalk.green('Encryption configured successfully.'));
-    });
-
-  encryption.command('unlock')
-    .description('Unlock encryption for this session')
-    .option('--passphrase <passphrase>', 'Passphrase (non-interactive; also reads TUSKYDP_PASSWORD env var)')
-    .action(async (options: { passphrase?: string }) => {
-      const sdk = getSDKClientFromParent(encryption);
-
-      const { setupComplete, salt, verifier, encryptedMasterKey } = await sdk.account.getEncryptionParams();
-      if (!setupComplete) {
-        console.error(chalk.red('Encryption not set up. Run: tusky encryption setup'));
-        return;
-      }
-
-      // Resolve passphrase: flag > env var > interactive prompt
-      let passphrase = options.passphrase ?? process.env.TUSKYDP_PASSWORD;
-      if (!passphrase) {
-        const answers = await inquirer.prompt([{
-          type: 'password',
-          name: 'passphrase',
-          message: 'Enter encryption passphrase:',
-          mask: '*',
-        }]);
-        passphrase = answers.passphrase as string;
-      }
-
-      const saltBuffer = Buffer.from(salt!, 'base64');
-      const verifierBuffer = Buffer.from(verifier!, 'base64');
-      const wrappingKey = deriveMasterKey(passphrase, saltBuffer);
-
-      if (!verifyPassphrase(wrappingKey, verifierBuffer)) {
-        console.error(chalk.red('Invalid passphrase.'));
-        process.exit(1);
-      }
-
-      // Unwrap the real master key (or fall back to legacy where wrapping key = master key)
-      let masterKey: Buffer;
-      if (encryptedMasterKey) {
-        masterKey = unwrapMasterKey(Buffer.from(encryptedMasterKey, 'base64'), wrappingKey);
-      } else {
-        masterKey = wrappingKey;
-      }
-
-      storeMasterKey(masterKey);
-      console.log(chalk.green('Encryption session unlocked.'));
-    });
-
-  encryption.command('status')
-    .description('Show encryption status')
-    .action(async () => {
-      const sdk = getSDKClientFromParent(encryption);
-      const { setupComplete } = await sdk.account.getEncryptionParams();
-      const sessionActive = loadMasterKey() !== null;
-
-      console.log(`Encryption setup:   ${setupComplete ? chalk.green('Complete') : chalk.yellow('Not set up')}`);
-      console.log(`Session unlocked:   ${sessionActive ? chalk.green('Yes') : chalk.yellow('No')}`);
-    });
-
-  encryption.command('change-passphrase')
-    .description('Change encryption passphrase')
-    .action(async () => {
-      const sdk = getSDKClientFromParent(encryption);
-
-      const { setupComplete, salt, verifier, encryptedMasterKey } = await sdk.account.getEncryptionParams();
-      if (!setupComplete) {
-        console.error(chalk.red('Encryption not set up. Run: tusky encryption setup'));
-        return;
-      }
-
-      const answers = await inquirer.prompt([
-        {
-          type: 'password',
-          name: 'currentPassphrase',
-          message: 'Enter current passphrase:',
-          mask: '*',
-        },
-        {
-          type: 'password',
-          name: 'newPassphrase',
-          message: 'Enter new passphrase:',
-          mask: '*',
-          validate: (input: string) => input.length >= 8 || 'Passphrase must be at least 8 characters',
-        },
-        {
-          type: 'password',
-          name: 'confirmNew',
-          message: 'Confirm new passphrase:',
-          mask: '*',
-        },
-      ]);
-
-      if (answers.newPassphrase !== answers.confirmNew) {
-        console.error(chalk.red('New passphrases do not match.'));
-        return;
-      }
-
-      // Verify current passphrase
-      const currentSalt = Buffer.from(salt!, 'base64');
-      const currentVerifier = Buffer.from(verifier!, 'base64');
-      const currentWrappingKey = deriveMasterKey(answers.currentPassphrase, currentSalt);
-
-      if (!verifyPassphrase(currentWrappingKey, currentVerifier)) {
-        console.error(chalk.red('Invalid current passphrase.'));
-        return;
-      }
-
-      // Unwrap the real master key (or use wrapping key as legacy fallback)
-      let masterKey: Buffer;
-      if (encryptedMasterKey) {
-        masterKey = unwrapMasterKey(Buffer.from(encryptedMasterKey, 'base64'), currentWrappingKey);
-      } else {
-        masterKey = currentWrappingKey;
-      }
-
-      // Derive new wrapping key, re-wrap master key
-      const newSalt = generateSalt();
-      const newWrappingKey = deriveMasterKey(answers.newPassphrase, newSalt);
-      const newVerifier = computeVerifier(newWrappingKey);
-      const newEncryptedMasterKey = wrapMasterKey(masterKey, newWrappingKey);
-
-      // Generate new recovery key and wrap master key with it
-      const newRecoveryKey = generateRecoveryKey();
-      const newWrappedBackup = wrapMasterKey(masterKey, newRecoveryKey);
-
-      await sdk.account.resetEncryption({
-        salt: newSalt.toString('base64'),
-        verifier: newVerifier.toString('base64'),
-        encryptedMasterKey: newEncryptedMasterKey.toString('base64'),
-        wrappedMasterKeyBackup: newWrappedBackup.toString('base64'),
-      });
-
-      storeMasterKey(masterKey);
-
-      console.log(chalk.yellow.bold('NEW RECOVERY KEY (save it!):'));
-      console.log(chalk.bold(`  ${newRecoveryKey.toString('base64')}`));
-      console.log(chalk.green('Passphrase changed successfully.'));
-    });
-
-  encryption.command('recover')
-    .description('Recover master key with recovery key')
-    .action(async () => {
-      const sdk = getSDKClientFromParent(encryption);
-
-      const answers = await inquirer.prompt([
-        {
-          type: 'input',
-          name: 'recoveryKey',
-          message: 'Enter your recovery key (base64):',
-        },
-        {
-          type: 'password',
-          name: 'newPassphrase',
-          message: 'Enter new passphrase:',
-          mask: '*',
-          validate: (input: string) => input.length >= 8 || 'Passphrase must be at least 8 characters',
-        },
-        {
-          type: 'password',
-          name: 'confirmNew',
-          message: 'Confirm new passphrase:',
-          mask: '*',
-        },
-      ]);
-
-      if (answers.newPassphrase !== answers.confirmNew) {
-        console.error(chalk.red('Passphrases do not match.'));
-        return;
-      }
-
-      // Get wrapped master key backup from server
-      const { wrappedMasterKeyBackup } = await sdk.account.getRecoveryData();
-      const wrappedData = Buffer.from(wrappedMasterKeyBackup!, 'base64');
-      const recoveryKeyRaw = Buffer.from(answers.recoveryKey, 'base64');
-
-      let masterKey: Buffer;
-      try {
-        masterKey = unwrapMasterKey(wrappedData, recoveryKeyRaw);
-      } catch {
-        console.error(chalk.red('Invalid recovery key.'));
-        return;
-      }
-
-      // Derive new wrapping key from new passphrase, wrap the RECOVERED master key
-      const newSalt = generateSalt();
-      const newWrappingKey = deriveMasterKey(answers.newPassphrase, newSalt);
-      const newVerifier = computeVerifier(newWrappingKey);
-      const newEncryptedMasterKey = wrapMasterKey(masterKey, newWrappingKey);
-
-      // Generate new recovery key and wrap master key with it
-      const newRecoveryKey = generateRecoveryKey();
-      const newWrappedBackup = wrapMasterKey(masterKey, newRecoveryKey);
-
-      await sdk.account.resetEncryption({
-        salt: newSalt.toString('base64'),
-        verifier: newVerifier.toString('base64'),
-        encryptedMasterKey: newEncryptedMasterKey.toString('base64'),
-        wrappedMasterKeyBackup: newWrappedBackup.toString('base64'),
-      });
-
-      storeMasterKey(masterKey);
-
-      console.log(chalk.yellow.bold('NEW RECOVERY KEY (save it!):'));
-      console.log(chalk.bold(`  ${newRecoveryKey.toString('base64')}`));
-      console.log(chalk.green('Recovery successful. Passphrase reset.'));
-    });
-}