memoir-cli 3.1.1 → 3.2.0

package/src/commands/projects.js

@@ -0,0 +1,240 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+import boxen from 'boxen';
+import { execFileSync } from 'child_process';
+
+const home = os.homedir();
+const TODOS_PATH = path.join(home, '.config', 'memoir', 'project-todos.json');
+
+// ─── Helpers ───
+
+async function loadTodos() {
+  try {
+    return await fs.readJson(TODOS_PATH);
+  } catch {
+    return {};
+  }
+}
+
+async function saveTodos(todos) {
+  await fs.ensureDir(path.dirname(TODOS_PATH));
+  await fs.writeJson(TODOS_PATH, todos, { spaces: 2 });
+}
+
+function git(args, cwd) {
+  try {
+    return execFileSync('git', args, {
+      cwd,
+      stdio: ['pipe', 'pipe', 'ignore'],
+      timeout: 5000,
+    }).toString().trim();
+  } catch {
+    return null;
+  }
+}
+
+function timeAgo(dateStr) {
+  const diff = Date.now() - new Date(dateStr).getTime();
+  const mins = Math.floor(diff / 60000);
+  if (mins < 60) return `${mins}m ago`;
+  const hrs = Math.floor(mins / 60);
+  if (hrs < 24) return `${hrs}h ago`;
+  const days = Math.floor(hrs / 24);
+  if (days < 30) return `${days}d ago`;
+  return `${Math.floor(days / 30)}mo ago`;
+}
+
+// ─── Scan ───
+
+async function discoverProjects() {
+  const maxDepth = 3;
+  const skipDirs = new Set([
+    'node_modules', '.git', '.next', '.vercel', 'dist', 'build',
+    '__pycache__', '.venv', 'venv', '.cache', '.npm', '.bun',
+    'Library', '.Trash', 'Applications', 'Pictures', 'Music',
+    'Movies', 'Public', 'Downloads', '.local', '.cargo', '.rustup',
+    '.docker', '.ssh', '.config', '.claude', '.gemini',
+  ]);
+
+  const projectMarkers = [
+    'package.json', 'Cargo.toml', 'go.mod', 'pyproject.toml',
+    'requirements.txt', 'Gemfile', 'pom.xml', 'build.gradle',
+    'Makefile', 'CMakeLists.txt', '.project', 'CLAUDE.md',
+    'GEMINI.md', 'AGENTS.md',
+    '.gitignore', 'index.html', 'main.py', 'app.py', 'index.js',
+  ];
+
+  const projects = [];
+
+  const scanDir = async (dir, depth = 0) => {
+    if (depth > maxDepth) return;
+    let entries;
+    try { entries = await fs.readdir(dir, { withFileTypes: true }); } catch { return; }
+
+    const hasMarker = entries.some(e => !e.isDirectory() && projectMarkers.includes(e.name));
+    if (hasMarker && dir !== home) {
+      projects.push(dir);
+      return;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith('.') && entry.name !== '.github') continue;
+      if (skipDirs.has(entry.name)) continue;
+      await scanDir(path.join(dir, entry.name), depth + 1);
+    }
+  };
+
+  await scanDir(home);
+  return projects;
+}
+
+function getProjectStatus(dir) {
+  const name = path.basename(dir);
+  const hasGit = fs.pathExistsSync(path.join(dir, '.git'));
+
+  const info = { name, path: dir, hasGit, branch: null, dirty: false, logs: [] };
+
+  if (!hasGit) return info;
+
+  info.branch = git(['branch', '--show-current'], dir) || 'unknown';
+
+  const status = git(['status', '--porcelain'], dir);
+  info.dirty = status ? status.length > 0 : false;
+
+  const logRaw = git(['log', '-5', '--format=%ad|%s', '--date=format:%b %d, %H:%M'], dir);
+  if (logRaw) {
+    info.logs = logRaw.split('\n').filter(Boolean).map(line => {
+      const sep = line.indexOf('|');
+      return { date: line.slice(0, sep), msg: line.slice(sep + 1) };
+    });
+  }
+
+  const lastDate = git(['log', '-1', '--format=%aI'], dir);
+  if (lastDate) info.lastActivity = lastDate;
+
+  return info;
+}
+
+// ─── Commands ───
+
+export async function projectsListCommand(options) {
+  const dirs = await discoverProjects();
+  const todos = await loadTodos();
+
+  // Gather status for all projects
+  const projects = dirs.map(d => {
+    const s = getProjectStatus(d);
+    s.todos = todos[s.name] || [];
+    return s;
+  });
+
+  // Sort by last activity (most recent first)
+  projects.sort((a, b) => {
+    if (!a.lastActivity && !b.lastActivity) return 0;
+    if (!a.lastActivity) return 1;
+    if (!b.lastActivity) return -1;
+    return new Date(b.lastActivity) - new Date(a.lastActivity);
+  });
+
+  if (options.json) {
+    console.log(JSON.stringify(projects, null, 2));
+    return;
+  }
+
+  console.log('\n' + boxen(
+    chalk.white.bold('  projects  ') + chalk.gray(`  ${projects.length} found`),
+    { padding: { top: 0, bottom: 0, left: 1, right: 1 }, borderStyle: 'round', borderColor: 'cyan', dimBorder: true }
+  ));
+
+  const limit = options.all ? projects.length : Math.min(projects.length, 15);
+
+  for (let i = 0; i < limit; i++) {
+    const p = projects[i];
+    const dot = p.hasGit
+      ? (p.dirty ? chalk.yellow('●') : chalk.green('●'))
+      : chalk.gray('●');
+
+    const age = p.lastActivity ? chalk.gray(` ${timeAgo(p.lastActivity)}`) : '';
+    const branchTag = p.branch && p.branch !== 'main' && p.branch !== 'master'
+      ? chalk.magenta(` [${p.branch}]`)
+      : '';
+    const dirtyTag = p.dirty ? chalk.yellow(' *') : '';
+    const todoTag = p.todos.length > 0
+      ? chalk.yellow(` (${p.todos.length} todo${p.todos.length > 1 ? 's' : ''})`)
+      : '';
+
+    console.log(`\n  ${dot} ${chalk.white.bold(p.name)}${branchTag}${dirtyTag}${todoTag}${age}`);
+
+    // Show last few commits
+    const logCount = options.verbose ? 5 : 2;
+    for (let j = 0; j < Math.min(p.logs.length, logCount); j++) {
+      const log = p.logs[j];
+      console.log(`    ${chalk.gray(log.date)} ${chalk.dim(log.msg)}`);
+    }
+
+    // Show todos inline
+    if (p.todos.length > 0 && options.verbose) {
+      for (const t of p.todos) {
+        console.log(`    ${chalk.yellow('□')} ${chalk.yellow(t)}`);
+      }
+    }
+  }
+
+  if (!options.all && projects.length > 15) {
+    console.log(chalk.gray(`\n  ... and ${projects.length - 15} more (use --all to show all)`));
+  }
+
+  console.log(chalk.gray(`\n  ${chalk.green('●')} clean  ${chalk.yellow('●')} dirty  ${chalk.gray('●')} no git\n`));
+}
+
+export async function projectsTodoCommand(projectName, text, options) {
+  const todos = await loadTodos();
+
+  // List todos for a project
+  if (!text && !options.done && !options.clear) {
+    const items = todos[projectName] || [];
+    if (items.length === 0) {
+      console.log(chalk.gray(`\n  No todos for ${projectName}\n`));
+      return;
+    }
+    console.log(chalk.white.bold(`\n  ${projectName} todos:\n`));
+    items.forEach((t, i) => {
+      console.log(`  ${chalk.gray(`${i + 1}.`)} ${chalk.yellow('□')} ${t}`);
+    });
+    console.log('');
+    return;
+  }
+
+  // Mark done
+  if (options.done !== undefined) {
+    const idx = parseInt(options.done, 10) - 1;
+    const items = todos[projectName] || [];
+    if (idx < 0 || idx >= items.length) {
+      console.error(chalk.red(`\n  ✖ Invalid index. ${projectName} has ${items.length} todo(s).\n`));
+      return;
+    }
+    const removed = items.splice(idx, 1)[0];
+    todos[projectName] = items;
+    if (items.length === 0) delete todos[projectName];
+    await saveTodos(todos);
+    console.log(chalk.green(`\n  ✔ Done: ${removed}\n`));
+    return;
+  }
+
+  // Clear all
+  if (options.clear) {
+    delete todos[projectName];
+    await saveTodos(todos);
+    console.log(chalk.green(`\n  ✔ Cleared all todos for ${projectName}\n`));
+    return;
+  }
+
+  // Add todo
+  if (!todos[projectName]) todos[projectName] = [];
+  todos[projectName].push(text);
+  await saveTodos(todos);
+  console.log(chalk.green(`\n  ✔ Added to ${projectName}: ${text}\n`));
+}

package/src/commands/push.js

@@ -179,14 +179,16 @@ export async function pushCommand(options = {}) {
         mask: '*',
         validate: (input) => input.length >= 6 ? true : 'Passphrase must be at least 6 characters'
       }]);
-      spinner.start(chalk.gray('Encrypting...'));
+      spinner.start(chalk.gray('Deriving encryption key...'));
 
       encryptedDir = path.join(os.tmpdir(), `memoir-encrypted-${Date.now()}`);
       await fs.ensureDir(encryptedDir);
-      await encryptDirectory(stagingDir, encryptedDir, passphrase);
+      const encryptedCount = await encryptDirectory(stagingDir, encryptedDir, passphrase, spinner);
+      spinner.succeed(chalk.green(spinner.text));
+      spinner.start();
 
       // Save verify token so restore can check passphrase before decrypting
-      const token = createVerifyToken(passphrase);
+      const token = await createVerifyToken(passphrase);
       await fs.writeFile(path.join(encryptedDir, 'verify.enc'), token);
 
       uploadDir = encryptedDir;

package/src/commands/restore.js

@@ -11,10 +11,18 @@ import { fetchFromLocal, fetchFromGit } from '../providers/restore.js';
 import { decryptDirectory, verifyPassphrase } from '../security/encryption.js';
 import { detectLocalHomeKey } from '../adapters/restore.js';
 import { restoreWorkspace } from '../workspace/tracker.js';
+import { getSession } from '../cloud/auth.js';
+import { unbundleToDir } from '../cloud/storage.js';
+import { SUPABASE_URL, SUPABASE_ANON_KEY, STORAGE_BUCKET } from '../cloud/constants.js';
 
 const home = os.homedir();
 
 export async function restoreCommand(options = {}) {
+  // Handle --from <token> for shared links
+  if (options.from) {
+    return restoreFromShare(options);
+  }
+
   const config = await getConfig(options.profile);
 
   if (!config) {
@@ -37,7 +45,7 @@ export async function restoreCommand(options = {}) {
 
     const onlyFilter = options.only ? options.only.split(',').map(t => t.trim().toLowerCase()) : null;
 
-    const autoYes = options.yes || false;
+    const autoYes = !options.interactive;
 
     if (config.provider === 'local' || config.provider.includes('local')) {
       restored = await fetchFromLocal(config, stagingDir, spinner, onlyFilter, autoYes);
@@ -68,7 +76,7 @@ export async function restoreCommand(options = {}) {
 
         if (await fs.pathExists(verifyPath)) {
           const token = await fs.readFile(verifyPath);
-          if (!verifyPassphrase(token, passphrase)) {
+          if (!(await verifyPassphrase(token, passphrase))) {
             console.log(chalk.red('  Wrong passphrase. Try again.'));
             passphrase = null;
             continue;
@@ -85,7 +93,7 @@ export async function restoreCommand(options = {}) {
       spinner.start(chalk.gray('Decrypting...'));
       const decryptedDir = path.join(os.tmpdir(), `memoir-decrypted-${Date.now()}`);
       try {
-        const count = await decryptDirectory(stagingDir, decryptedDir, passphrase);
+        const count = await decryptDirectory(stagingDir, decryptedDir, passphrase, spinner);
         spinner.succeed(chalk.green(`Decrypted ${count} files`));
 
         // Now restore from decrypted dir
@@ -244,3 +252,189 @@ export async function restoreCommand(options = {}) {
     await fs.remove(stagingDir);
   }
 }
+
+async function restoreFromShare(options) {
+  const shareToken = options.from;
+
+  console.log();
+  const spinner = ora({ text: chalk.gray('Fetching share link...'), spinner: 'dots' }).start();
+
+  const stagingDir = path.join(os.tmpdir(), `memoir-share-restore-${Date.now()}`);
+  await fs.ensureDir(stagingDir);
+
+  try {
+    // Fetch share metadata from Supabase
+    const metaRes = await fetch(
+      `${SUPABASE_URL}/rest/v1/shared_links?select=*&token=eq.${shareToken}&limit=1`,
+      {
+        headers: {
+          'apikey': SUPABASE_ANON_KEY,
+          'Content-Type': 'application/json',
+        },
+      }
+    );
+
+    if (!metaRes.ok) {
+      throw new Error('Failed to fetch share link');
+    }
+
+    const links = await metaRes.json();
+    if (!links || links.length === 0) {
+      spinner.stop();
+      console.log('\n' + boxen(
+        chalk.red('✖ Share link not found\n\n') +
+        chalk.gray('The link may have expired or been deleted.'),
+        { padding: 1, borderStyle: 'round', borderColor: 'red' }
+      ) + '\n');
+      return;
+    }
+
+    const shareLink = links[0];
+
+    // Check expiry
+    if (new Date(shareLink.expires_at) < new Date()) {
+      spinner.stop();
+      console.log('\n' + boxen(
+        chalk.red('✖ Share link expired\n\n') +
+        chalk.gray(`This link expired on ${new Date(shareLink.expires_at).toLocaleString()}`),
+        { padding: 1, borderStyle: 'round', borderColor: 'red' }
+      ) + '\n');
+      return;
+    }
+
+    // Check use count
+    if (shareLink.use_count >= shareLink.max_uses) {
+      spinner.stop();
+      console.log('\n' + boxen(
+        chalk.red('✖ Share link exhausted\n\n') +
+        chalk.gray(`This link has been used ${shareLink.use_count}/${shareLink.max_uses} times.`),
+        { padding: 1, borderStyle: 'round', borderColor: 'red' }
+      ) + '\n');
+      return;
+    }
+
+    // Show share info
+    spinner.stop();
+    const tools = shareLink.tools || [];
+    if (tools.length > 0) {
+      console.log(chalk.cyan('\n  Shared tools: ') + chalk.white(tools.join(', ')));
+    }
+    console.log(chalk.gray(`  Uses: ${shareLink.use_count + 1}/${shareLink.max_uses}`) +
+      chalk.gray(` | Expires: ${new Date(shareLink.expires_at).toLocaleString()}`));
+    console.log();
+
+    // Download the backup
+    spinner.start(chalk.gray('Downloading share bundle...'));
+
+    // Try authenticated first, fall back to anon key
+    const session = await getSession();
+    const authHeaders = session
+      ? { 'Authorization': `Bearer ${session.access_token}`, 'apikey': SUPABASE_ANON_KEY }
+      : { 'apikey': SUPABASE_ANON_KEY };
+
+    const dlRes = await fetch(`${SUPABASE_URL}/storage/v1/object/${STORAGE_BUCKET}/${shareLink.backup_id}`, {
+      headers: authHeaders,
+    });
+
+    if (!dlRes.ok) {
+      throw new Error(`Download failed: ${await dlRes.text()}`);
+    }
+
+    const gzipped = Buffer.from(await dlRes.arrayBuffer());
+    await unbundleToDir(gzipped, stagingDir);
+
+    // Decrypt — backup is always encrypted for shares
+    const manifestPath = path.join(stagingDir, 'manifest.enc');
+    if (!await fs.pathExists(manifestPath)) {
+      throw new Error('Share bundle is missing encryption manifest');
+    }
+
+    spinner.stop();
+    console.log(chalk.cyan('  🔒 This share is encrypted'));
+
+    // Verify passphrase
+    const verifyPath = path.join(stagingDir, 'verify.enc');
+    let passphrase;
+    for (let attempt = 0; attempt < 3; attempt++) {
+      const { pass } = await inquirer.prompt([{
+        type: 'password',
+        name: 'pass',
+        message: 'Decryption passphrase:',
+        mask: '*',
+      }]);
+      passphrase = pass;
+
+      if (await fs.pathExists(verifyPath)) {
+        const token = await fs.readFile(verifyPath);
+        if (!(await verifyPassphrase(token, passphrase))) {
+          console.log(chalk.red('  Wrong passphrase. Try again.'));
+          passphrase = null;
+          continue;
+        }
+      }
+      break;
+    }
+
+    if (!passphrase) {
+      console.log(chalk.red('\n  Too many failed attempts.'));
+      return;
+    }
+
+    spinner.start(chalk.gray('Decrypting...'));
+    const decryptedDir = path.join(os.tmpdir(), `memoir-share-decrypted-${Date.now()}`);
+    let restored = false;
+
+    try {
+      const count = await decryptDirectory(stagingDir, decryptedDir, passphrase, spinner);
+      spinner.succeed(chalk.green(`Decrypted ${count} files`));
+
+      // Restore from decrypted dir
+      spinner.start(chalk.gray('Restoring...'));
+      const onlyFilter = options.only ? options.only.split(',').map(t => t.trim().toLowerCase()) : null;
+      const autoYes = !options.interactive;
+      const { restoreMemories } = await import('../adapters/restore.js');
+      restored = await restoreMemories(decryptedDir, spinner, onlyFilter, autoYes);
+    } catch (err) {
+      spinner.fail(chalk.red('Decryption failed: ') + err.message);
+      return;
+    } finally {
+      await fs.remove(decryptedDir);
+    }
+
+    // Increment use_count
+    try {
+      const patchHeaders = { 'apikey': SUPABASE_ANON_KEY, 'Content-Type': 'application/json' };
+      if (session) patchHeaders['Authorization'] = `Bearer ${session.access_token}`;
+
+      await fetch(`${SUPABASE_URL}/rest/v1/shared_links?token=eq.${shareToken}`, {
+        method: 'PATCH',
+        headers: patchHeaders,
+        body: JSON.stringify({ use_count: shareLink.use_count + 1 }),
+      });
+    } catch {
+      // Best-effort — don't fail restore if count update fails
+    }
+
+    spinner.stop();
+
+    if (restored) {
+      console.log('\n' + boxen(
+        gradient.pastel('  Done!  ') + '\n\n' +
+        chalk.white('Shared memories restored successfully.') + '\n' +
+        chalk.gray('Restart your AI tools to pick up the changes.'),
+        { padding: 1, borderStyle: 'round', borderColor: 'green', dimBorder: true }
+      ) + '\n');
+    } else {
+      console.log('\n' + boxen(
+        chalk.yellow('Nothing was restored.\n\n') +
+        chalk.gray('You may have skipped all the restore prompts.'),
+        { padding: 1, borderStyle: 'round', borderColor: 'yellow' }
+      ) + '\n');
+    }
+
+  } catch (error) {
+    spinner.fail(chalk.red('Restore from share failed: ') + error.message);
+  } finally {
+    await fs.remove(stagingDir);
+  }
+}

package/src/commands/share.js

@@ -0,0 +1,192 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+import ora from 'ora';
+import boxen from 'boxen';
+import gradient from 'gradient-string';
+import inquirer from 'inquirer';
+import { getSession } from '../cloud/auth.js';
+import { extractMemories, adapters } from '../adapters/index.js';
+import { encryptDirectory, createVerifyToken } from '../security/encryption.js';
+import { bundleDir } from '../cloud/storage.js';
+import { SUPABASE_URL, SUPABASE_ANON_KEY, STORAGE_BUCKET } from '../cloud/constants.js';
+
+export async function shareCommand(options = {}) {
+  // Must be logged in to share
+  const session = await getSession();
+  if (!session) {
+    console.log('\n' + boxen(
+      chalk.red('✖ Not logged in\n\n') +
+      chalk.white('Sharing requires a memoir cloud account.\n') +
+      chalk.white('Run ') + chalk.cyan.bold('memoir login') + chalk.white(' to sign in.'),
+      { padding: 1, borderStyle: 'round', borderColor: 'red' }
+    ) + '\n');
+    return;
+  }
+
+  console.log();
+  const spinner = ora({ text: chalk.gray('Scanning for AI tools...'), spinner: 'dots' }).start();
+
+  const stagingDir = path.join(os.tmpdir(), `memoir-share-${Date.now()}`);
+  await fs.ensureDir(stagingDir);
+
+  let encryptedDir = null;
+
+  try {
+    // Scan and extract memories (same as push)
+    const onlyFilter = options.only ? options.only.split(',').map(t => t.trim().toLowerCase()) : null;
+    const foundAny = await extractMemories(stagingDir, spinner, onlyFilter);
+
+    if (!foundAny) {
+      spinner.stop();
+      console.log('\n' + boxen(
+        chalk.yellow('No AI tools detected on this machine.\n\n') +
+        chalk.gray('Supported: Claude, Gemini, Codex, Cursor, Copilot, Windsurf, Aider'),
+        { padding: 1, borderStyle: 'round', borderColor: 'yellow' }
+      ) + '\n');
+      return;
+    }
+
+    // Count what was found
+    const found = [];
+    for (const adapter of adapters) {
+      if (adapter.customExtract) {
+        for (const file of adapter.files) {
+          if (await fs.pathExists(path.join(adapter.source, file))) {
+            found.push(adapter.name);
+            break;
+          }
+        }
+      } else if (await fs.pathExists(adapter.source)) {
+        found.push(adapter.name);
+      }
+    }
+
+    // Ask for encryption passphrase
+    spinner.stop();
+    const { passphrase } = await inquirer.prompt([{
+      type: 'password',
+      name: 'passphrase',
+      message: '🔒 Set a passphrase for this share link (recipient will need it):',
+      mask: '*',
+      validate: (input) => input.length >= 6 ? true : 'Passphrase must be at least 6 characters'
+    }]);
+
+    spinner.start(chalk.gray('Encrypting...'));
+
+    encryptedDir = path.join(os.tmpdir(), `memoir-share-enc-${Date.now()}`);
+    await fs.ensureDir(encryptedDir);
+    await encryptDirectory(stagingDir, encryptedDir, passphrase, spinner);
+
+    // Save verify token so recipient can check passphrase
+    const token = await createVerifyToken(passphrase);
+    await fs.writeFile(path.join(encryptedDir, 'verify.enc'), token);
+
+    // Bundle and upload to Supabase Storage
+    spinner.text = chalk.gray('Uploading share bundle...');
+    const gzipped = await bundleDir(encryptedDir);
+
+    const shareToken = crypto.randomUUID();
+    const storagePath = `shares/${session.user.id}/${shareToken}.gz`;
+
+    const uploadRes = await fetch(`${SUPABASE_URL}/storage/v1/object/${STORAGE_BUCKET}/${storagePath}`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${session.access_token}`,
+        'apikey': SUPABASE_ANON_KEY,
+        'Content-Type': 'application/octet-stream',
+      },
+      body: gzipped,
+    });
+
+    if (!uploadRes.ok) {
+      const err = await uploadRes.text();
+      throw new Error(`Upload failed: ${err}`);
+    }
+
+    // Parse options
+    const expiresHours = parseInt(options.expires) || 24;
+    const maxUses = parseInt(options.uses) || 5;
+    const expiresAt = new Date(Date.now() + expiresHours * 60 * 60 * 1000).toISOString();
+
+    // Store share metadata in shared_links table
+    spinner.text = chalk.gray('Creating share link...');
+    const metaRes = await fetch(`${SUPABASE_URL}/rest/v1/shared_links`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${session.access_token}`,
+        'apikey': SUPABASE_ANON_KEY,
+        'Content-Type': 'application/json',
+        'Prefer': 'return=representation',
+      },
+      body: JSON.stringify({
+        token: shareToken,
+        backup_id: storagePath,
+        created_by: session.user.id,
+        expires_at: expiresAt,
+        max_uses: maxUses,
+        use_count: 0,
+        tools: found,
+        size_bytes: gzipped.length,
+      }),
+    });
+
+    if (!metaRes.ok) {
+      const err = await metaRes.text();
+      throw new Error(`Failed to create share link: ${err}`);
+    }
+
+    spinner.stop();
+
+    // Count total files
+    let totalFiles = 0;
+    for (const adapter of adapters) {
+      const adapterDir = path.join(stagingDir, adapter.name.toLowerCase().replace(/ /g, '-'));
+      if (await fs.pathExists(adapterDir)) {
+        const countDir = async (dir) => {
+          let c = 0;
+          const entries = await fs.readdir(dir, { withFileTypes: true });
+          for (const e of entries) {
+            if (e.isDirectory()) c += await countDir(path.join(dir, e.name));
+            else c++;
+          }
+          return c;
+        };
+        totalFiles += await countDir(adapterDir);
+      }
+    }
+
+    // Format expiry for display
+    const expiryDate = new Date(expiresAt);
+    const expiryStr = expiryDate.toLocaleString();
+
+    // Success output
+    const shareUrl = `https://memoir.sh/share/${shareToken}`;
+    const restoreCmd = `memoir restore --from ${shareToken}`;
+    const toolList = found.map(t => chalk.cyan('  ✔ ' + t)).join('\n');
+
+    console.log('\n' + boxen(
+      gradient.pastel('  Shared!  ') + '\n\n' +
+      toolList + '\n' +
+      chalk.white(`${totalFiles} files from ${found.length} tool${found.length !== 1 ? 's' : ''}`) + '\n' +
+      chalk.green('  🔒 E2E encrypted') + '\n\n' +
+      chalk.white.bold('Share link:') + '\n' +
+      chalk.cyan(`  ${shareUrl}`) + '\n\n' +
+      chalk.white.bold('Recipient runs:') + '\n' +
+      chalk.cyan(`  ${restoreCmd}`) + '\n\n' +
+      chalk.gray(`Expires: ${expiryStr} (${expiresHours}h)`) + '\n' +
+      chalk.gray(`Max uses: ${maxUses}`),
+      { padding: 1, borderStyle: 'round', borderColor: 'green', dimBorder: true }
+    ) + '\n');
+
+  } catch (error) {
+    spinner.fail(chalk.red('Share failed: ') + error.message);
+  } finally {
+    await fs.remove(stagingDir);
+    if (encryptedDir) {
+      await fs.remove(encryptedDir).catch(() => {});
+    }
+  }
+}