@seamnet/client 0.14.5 → 0.16.0

package/bin/cli.js

@@ -1,9 +1,7 @@
 #!/usr/bin/env node
 
 import { parseArgs } from 'node:util';
-import { init } from '../lib/init.js';
-import { status } from '../lib/status.js';
-import { stop } from '../lib/stop.js';
+import { join } from 'node:path';
 
 const command = process.argv[2];
 
@@ -12,13 +10,19 @@ if (!command || command === '--help' || command === '-h') {
 seam-client — join the Seam network
 
 Commands:
-  init      --invite-code <code> --name <name>  Register and join Seam
-            --api <url>                         API base (default: $SEAM_API_BASE || https://seam.chat)
-  guardian  start|stop|run                      Manage guardian background process
-  autostart                                     Start guardian if credentials exist and not running (CC SessionStart hook)
-  status                                        Check Seam status
-  stop                                          Stop guardian
-  mcp-serve                                     Start MCP server (used by Claude Code)
+  init         --invite-code <code> --name <name>  Register and join Seam
+               --api <url>                         API base (default: $SEAM_API_BASE || https://seam.chat)
+  guardian     start|stop|run                      Manage guardian background process
+  autostart                                        Start guardian if credentials exist and not running (CC SessionStart hook)
+  status                                           Check Seam status
+  stop                                             Stop guardian
+  upgrade                                          Upgrade this AI's seam-client (per-AI mode)
+  upgrade-all                                      Host-tool: bump global package + restart all registered guardians
+  mcp-serve                                        Start MCP server (used by Claude Code)
+
+Environment:
+  SEAM_HOME    Absolute path to a .seam data directory. Resolution priority:
+               1) $SEAM_HOME, 2) cwd-upwalk for .seam/, 3) $HOME/.seam fallback.
 
 Example:
   npx seam-client init --invite-code ABC123 --name my-ai
@@ -46,8 +50,11 @@ try {
         console.error('Error: --name is required');
         process.exit(1);
       }
-      // 优先级：--api 参数 > SEAM_API_BASE 环境变量 > 默认 https://seam.chat
+      if (!process.env.SEAM_HOME) {
+        process.env.SEAM_HOME = join(process.cwd(), '.seam');
+      }
       const apiBase = values.api || process.env.SEAM_API_BASE || 'https://seam.chat';
+      const { init } = await import('../lib/init.js');
       await init({
         inviteCode: values['invite-code'],
         name: values.name,
@@ -55,14 +62,21 @@ try {
       });
       break;
     }
-    case 'status':
+    case 'status': {
+      const { status } = await import('../lib/status.js');
       await status();
       break;
+    }
     case 'upgrade': {
       const { upgrade } = await import('../lib/upgrade.js');
       await upgrade();
       break;
     }
+    case 'upgrade-all': {
+      const { upgradeAll } = await import('../lib/upgrade-all.js');
+      await upgradeAll();
+      break;
+    }
     case 'stop': {
       const { guardianStop } = await import('../lib/guardian.js');
       await guardianStop();

package/bin/seam.js

@@ -47,6 +47,7 @@ function printHelp() {
     '  seam msg group --group <id> (--text <text> | --text-file <path> | --image <path>)',
     '  seam contacts list',
     '  seam contacts get --user <userId>',
+    '  seam tell --to <id|alias> [--from <name>] --text <text>',
     '  seam wechat bind',
     '  seam wechat send (--text <text> | --text-file <path> | --image <path> | --file <path>)',
     '  seam wechat status',
@@ -169,6 +170,30 @@ async function cmdMsgSend(restArgs) {
   }
 }
 
+async function cmdTell(restArgs) {
+  const { values } = parseArgs({
+    args: restArgs,
+    options: {
+      to: { type: 'string' },
+      from: { type: 'string' },
+      text: { type: 'string' },
+      'text-file': { type: 'string' },
+    },
+    strict: false,
+  });
+  if (!values.to) output(false, '--to required');
+  const text = readText({ text: values.text, textFile: values['text-file'] });
+  if (text == null) output(false, '--text or --text-file required');
+  const { tell } = await import('../lib/tell.js');
+  const res = await tell({
+    to: values.to,
+    from: values.from,
+    text,
+    guardianRequest,
+  });
+  output(res.ok !== false, res);
+}
+
 async function cmdMsgGroup(restArgs) {
   const { values } = parseArgs({
     args: restArgs,
@@ -377,43 +402,11 @@ async function cmdInvite(subAction, restArgs) {
 
 // === cc (Claude Code 管理) ===
 
-import { execSync, spawn } from 'node:child_process';
-
-function ccGetSessions() {
-  let lines;
-  try {
-    lines = execSync('tmux list-sessions -F "#{session_name}"', {
-      encoding: 'utf8', timeout: 5000,
-    }).trim().split('\n').filter(Boolean);
-  } catch {
-    return [];
-  }
-  return lines.map(name => {
-    let ccRunning = false;
-    try {
-      const panePid = execSync(`tmux display-message -t "${name}" -p '#{pane_pid}'`, {
-        encoding: 'utf8', timeout: 3000,
-      }).trim();
-      // pane 进程本身可能就是 claude（tmux 直接启动时），也可能是 bash 的子进程
-      const self = execSync(`ps -o comm= -p ${panePid} 2>/dev/null`, {
-        encoding: 'utf8', timeout: 3000,
-      }).trim();
-      let child = '';
-      try {
-        child = execSync(`ps -o comm= --ppid ${panePid} 2>/dev/null`, {
-          encoding: 'utf8', timeout: 3000,
-        }).trim().split('\n').pop() || '';
-      } catch {}
-      ccRunning = ['claude', 'claude-code'].includes(self) ||
-                  ['claude', 'claude-code'].includes(child);
-    } catch {}
-    return { session: name, cc: ccRunning };
-  });
-}
+const tmuxUtils = require('../lib/tmux-utils.cjs');
 
 async function cmdCc(subAction, restArgs) {
   if (!subAction || subAction === 'list') {
-    const sessions = ccGetSessions();
+    const sessions = tmuxUtils.listSessions();
     if (sessions.length === 0) output(true, { sessions: [], message: 'no tmux sessions' });
     output(true, { sessions });
     return;
@@ -430,10 +423,7 @@ async function cmdCc(subAction, restArgs) {
     });
     if (!values.session) output(false, '--session required');
     try {
-      const text = execSync(
-        `tmux capture-pane -t "${values.session}" -p | tail -${parseInt(values.lines) || 20}`,
-        { encoding: 'utf8', timeout: 5000 }
-      );
+      const text = tmuxUtils.readOutput(values.session, parseInt(values.lines) || 20);
       output(true, { session: values.session, lines: text.trimEnd().split('\n') });
     } catch (e) {
       output(false, `read failed: ${e.message}`);
@@ -452,24 +442,11 @@ async function cmdCc(subAction, restArgs) {
     });
     if (!values.session) output(false, '--session required');
     if (!values.text) output(false, '--text required');
-    const sessions = ccGetSessions();
-    const target = sessions.find(s => s.session === values.session);
-    if (!target) output(false, `session "${values.session}" not found`);
-    if (!target.cc) output(false, `session "${values.session}": CC not running`);
     try {
-      // 分两步：先发文本（literal），再单独发 Enter
-      // CC 用 raw terminal mode，合在一起发会丢回车
-      execSync(
-        `tmux send-keys -t "${values.session}" -l ${JSON.stringify(values.text)}`,
-        { timeout: 5000 }
-      );
-      execSync(
-        `tmux send-keys -t "${values.session}" Enter`,
-        { timeout: 5000 }
-      );
+      tmuxUtils.sendToCC(values.session, values.text);
       output(true, { session: values.session, sent: values.text });
     } catch (e) {
-      output(false, `send failed: ${e.message}`);
+      output(false, e.message);
     }
     return;
   }
@@ -484,21 +461,12 @@ async function cmdCc(subAction, restArgs) {
       strict: false,
     });
     if (!values.dir) output(false, '--dir required');
-    if (!existsSync(values.dir)) output(false, `dir not found: ${values.dir}`);
-    const sessionName = values.session || join(values.dir).split('/').pop();
-    // 检查 session 是否已存在
-    const existing = ccGetSessions();
-    if (existing.find(s => s.session === sessionName)) {
-      output(false, `session "${sessionName}" already exists`);
-    }
+    const sessionName = values.session || values.dir.split('/').pop();
     try {
-      execSync(
-        `tmux new-session -d -s "${sessionName}" -c "${values.dir}" 'claude --dangerously-skip-permissions'`,
-        { timeout: 10000 }
-      );
+      tmuxUtils.startCC(values.dir, sessionName);
       output(true, { session: sessionName, dir: values.dir, started: true });
     } catch (e) {
-      output(false, `start failed: ${e.message}`);
+      output(false, e.message);
     }
     return;
   }
@@ -528,6 +496,7 @@ function parseDuration(str) {
       if (action === 'group') return await cmdMsgGroup(rest);
       output(false, `Unknown msg action: ${action}`);
     }
+    if (domain === 'tell') return await cmdTell(argv.slice(1));
     if (domain === 'contacts') return await cmdContacts(action, rest);
     if (domain === 'guardian') return await cmdGuardian(action);
     if (domain === 'wechat') return await cmdWechat(action, rest);

package/lib/guardian.js

@@ -15,6 +15,7 @@ import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, openSyn
 import { join, isAbsolute } from 'node:path';
 import { execSync, spawn } from 'node:child_process';
 import { SEAM_DIR, CREDENTIALS_PATH, SOCKET_PATH, LOGS_DIR, PID_PATH } from './paths.js';
+import { writeEntry as registryWrite, removeEntry as registryRemove } from './registry.js';
 
 /**
  * 解析 $TMUX 里的 socket path。返回可用于 `tmux -S <path>` 的绝对路径或 null。
@@ -136,16 +137,36 @@ export async function guardianRun() {
     console.error(`Guardian already running (pid: ${existingPid}). Exiting.`);
     process.exit(0);
   }
-  // 写 PID（覆盖 guardianStart 写的 child.pid），退出时清理
-  writeFileSync(PID_PATH, String(process.pid));
-  const cleanPid = () => { try { if (existsSync(PID_PATH)) unlinkSync(PID_PATH); } catch {} };
-  process.on('exit', cleanPid);
-  process.on('SIGTERM', () => { cleanPid(); process.exit(0); });
-  process.on('SIGINT', () => { cleanPid(); process.exit(0); });
-
   const credentials = JSON.parse(readFileSync(CREDENTIALS_PATH, 'utf8'));
   const ccSession = process.env.SEAM_CC_SESSION || '';
   const ccSocket = process.env.SEAM_CC_SOCKET || resolveTmuxSocketPath() || '';
+
+  // 写 PID（覆盖 guardianStart 写的 child.pid），退出时清理
+  writeFileSync(PID_PATH, String(process.pid));
+
+  // 写 cross-AI registry entry（~/.shared/seam-registry/<userId>.json）
+  try {
+    registryWrite({
+      userId: credentials.userId,
+      aliases: [credentials.name].filter(Boolean),
+      seam_home: SEAM_DIR,
+      tmux_session: ccSession,
+      tmux_socket: ccSocket,
+      socket: SOCKET_PATH,
+      pid: process.pid,
+      started_at: new Date().toISOString(),
+    });
+  } catch (e) {
+    console.error(`[guardian] registry write failed (non-fatal): ${e.message}`);
+  }
+
+  const cleanup = () => {
+    try { if (existsSync(PID_PATH)) unlinkSync(PID_PATH); } catch {}
+    try { registryRemove(credentials.userId); } catch {}
+  };
+  process.on('exit', cleanup);
+  process.on('SIGTERM', () => { cleanup(); process.exit(0); });
+  process.on('SIGINT', () => { cleanup(); process.exit(0); });
   const jsonlPath = join(LOGS_DIR, 'guardian.jsonl');
 
   if (!existsSync(LOGS_DIR)) mkdirSync(LOGS_DIR, { recursive: true });
@@ -219,35 +240,28 @@ export async function guardianRun() {
       ? '🔄 [Seam] 升级完成。Guardian 将在 10 秒后重启 CC 以加载新的 MCP 工具。你会在新对话里看到单个 seam 工具取代原来的多个工具。'
       : '🔄 [Seam] 入网完成。Guardian 将在 10 秒后重启 CC 以加载 MCP 工具。重启后你会在新的对话里读到 IDENTITY.md。';
     hub.inject(notice);
-    setTimeout(() => {
+    setTimeout(async () => {
       try {
-        execSync(`${tmux} send-keys -t ${safeSession} '/exit' Enter`, {
-          stdio: 'ignore',
-          timeout: 5000,
-        });
-        setTimeout(() => {
-          try {
-            execSync(
-              `${tmux} send-keys -t ${safeSession} 'claude --dangerously-skip-permissions --continue' Enter`,
-              { stdio: 'ignore', timeout: 5000 }
-            );
-            guardianState.set('cc_restarted', new Date().toISOString());
-            if (isUpgradeRestart) guardianState.delete('pending_upgrade_restart');
-            hub.logger('guardian').info('cc_restart_injected');
-          } catch (e) {
-            hub.logger('guardian').error('cc_restart_failed', e);
-          }
-        }, 3000);
+        const { restartCC } = require('./tmux-utils.cjs');
+        const ok = await restartCC(safeSession, { socketPath: ccSocket, continueSession: true });
+        if (ok) {
+          guardianState.set('cc_restarted', new Date().toISOString());
+          if (isUpgradeRestart) guardianState.delete('pending_upgrade_restart');
+          hub.logger('guardian').info('cc_restart_injected');
+        } else {
+          hub.logger('guardian').error('cc_restart_failed', new Error('restartCC returned false'));
+        }
       } catch (e) {
-        hub.logger('guardian').error('cc_exit_failed', e);
+        hub.logger('guardian').error('cc_restart_failed', e);
       }
-    }, 10000); // 3s → 10s 给 AI 读到通知的时间
+    }, 10000);
   }
 
-  // Keep alive + graceful shutdown (pid 文件清理)
+  // Keep alive + graceful shutdown (pid 文件清理 + registry 清理)
   const shutdown = async (signal) => {
     hub.logger('guardian').info('shutdown_signal', { signal });
     try { if (existsSync(PID_PATH)) unlinkSync(PID_PATH); } catch {}
+    try { registryRemove(credentials.userId); } catch {}
     await stop();
     process.exit(0);
   };

package/lib/init.js

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync, writeFileSync, readFileSync, chmodSync } from 'n
 import { execSync } from 'node:child_process';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
 import { register } from './api.js';
 import {
   SEAM_DIR, CREDENTIALS_PATH, VERSION_PATH,
@@ -85,9 +86,12 @@ export async function init({ inviteCode, name, apiBase }) {
   // Step 9: Write .mcp.json in current directory
   writeMcpConfig(result);
 
-  // Step 10: Write .claude/settings.json (pre-authorize MCP)
+  // Step 10: Write .claude/settings.json (pre-authorize MCP + inject SEAM_HOME)
   writeSettings();
 
+  // Step 10b: Register this SEAM_HOME so `upgrade-all` can find it
+  registerSeamHome();
+
   // Step 11: Add @IDENTITY.md to CLAUDE.md
   patchClaudeMd();
 
@@ -196,6 +200,10 @@ function writeSettings() {
 
   settings.enableAllProjectMcpServers = true;
 
+  // host-tool: CC 子进程注入 SEAM_HOME，paths.js 第一级 fallback 命中
+  if (!settings.env) settings.env = {};
+  settings.env.SEAM_HOME = SEAM_DIR;
+
   // SessionStart hook: CC 启动时自动拉起 guardian（如果还没跑）
   if (!settings.hooks) settings.hooks = {};
   if (!Array.isArray(settings.hooks.SessionStart)) settings.hooks.SessionStart = [];
@@ -218,7 +226,22 @@ function writeSettings() {
   }
 
   writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-  console.log('  MCP pre-authorized + SessionStart guardian autostart wired.');
+  console.log(`  MCP pre-authorized + env.SEAM_HOME=${SEAM_DIR} + SessionStart hook wired.`);
+}
+
+function registerSeamHome() {
+  const homesPath = join(homedir(), '.seam-homes');
+  let lines = [];
+  if (existsSync(homesPath)) {
+    lines = readFileSync(homesPath, 'utf8').split('\n').filter(Boolean);
+  }
+  if (!lines.includes(SEAM_DIR)) {
+    lines.push(SEAM_DIR);
+    writeFileSync(homesPath, lines.join('\n') + '\n');
+    console.log(`  Registered to ${homesPath}`);
+  } else {
+    console.log(`  Already registered in ${homesPath}`);
+  }
 }
 
 export function patchClaudeMd() {

package/lib/paths.js

@@ -1,6 +1,23 @@
-import { join } from 'node:path';
+import { join, resolve, dirname } from 'node:path';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
 
-export const SEAM_DIR = join(process.cwd(), '.seam');
+export function resolveSeamHome() {
+  if (process.env.SEAM_HOME) return resolve(process.env.SEAM_HOME);
+
+  let dir = process.cwd();
+  while (true) {
+    const candidate = join(dir, '.seam');
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  return join(homedir(), '.seam');
+}
+
+export const SEAM_DIR = resolveSeamHome();
 export const CREDENTIALS_PATH = join(SEAM_DIR, 'credentials.json');
 export const CONFIG_PATH = join(SEAM_DIR, 'config.json');
 export const VERSION_PATH = join(SEAM_DIR, 'version.json');

package/lib/registry.js

@@ -0,0 +1,101 @@
+/**
+ * Cross-AI registry：~/.shared/seam-registry/<userId>.json
+ *
+ * Guardian 启动时写 entry，shutdown 时删 entry。`seam tell` 读 entries 查目标
+ * AI。死信检测在读时做：pid 已死的 entry 直接删除。
+ *
+ * 并发写：每条 entry 单独文件 + atomic rename（写 .tmp 再 rename）。
+ * 同 userId 双 guardian 不应出现（guardian 单例锁保证），出现则后写覆盖先写。
+ */
+
+import { existsSync, readFileSync, writeFileSync, readdirSync, mkdirSync, renameSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const REGISTRY_DIR = join(homedir(), '.shared', 'seam-registry');
+
+function ensureDir() {
+  if (!existsSync(REGISTRY_DIR)) {
+    mkdirSync(REGISTRY_DIR, { recursive: true });
+  }
+}
+
+function isAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function entryPath(userId) {
+  return join(REGISTRY_DIR, `${userId}.json`);
+}
+
+export function writeEntry(entry) {
+  if (!entry?.userId) throw new Error('writeEntry: userId required');
+  ensureDir();
+  const target = entryPath(entry.userId);
+  const tmp = `${target}.tmp.${process.pid}.${Date.now()}`;
+  writeFileSync(tmp, JSON.stringify(entry, null, 2));
+  renameSync(tmp, target);
+  return target;
+}
+
+export function removeEntry(userId) {
+  if (!userId) return;
+  const target = entryPath(userId);
+  try {
+    if (existsSync(target)) unlinkSync(target);
+  } catch {}
+}
+
+/**
+ * 列出所有活 entry。死信（pid 已死）会被顺手删除。
+ * 顺便清掉残留 .tmp.* 文件（上次崩溃留下的）。
+ */
+export function readAll() {
+  if (!existsSync(REGISTRY_DIR)) return [];
+  let files;
+  try {
+    files = readdirSync(REGISTRY_DIR);
+  } catch {
+    return [];
+  }
+  const alive = [];
+  for (const f of files) {
+    const full = join(REGISTRY_DIR, f);
+    if (f.includes('.tmp.')) {
+      try { unlinkSync(full); } catch {}
+      continue;
+    }
+    if (!f.endsWith('.json')) continue;
+    let entry;
+    try {
+      entry = JSON.parse(readFileSync(full, 'utf8'));
+    } catch {
+      try { unlinkSync(full); } catch {}
+      continue;
+    }
+    if (!isAlive(entry.pid)) {
+      try { unlinkSync(full); } catch {}
+      continue;
+    }
+    alive.push(entry);
+  }
+  return alive;
+}
+
+export function findByAlias(needle) {
+  if (!needle) return null;
+  const entries = readAll();
+  for (const e of entries) {
+    if (e.userId === needle) return e;
+    if (Array.isArray(e.aliases) && e.aliases.includes(needle)) return e;
+  }
+  return null;
+}
+
+export { REGISTRY_DIR };

package/lib/tell.js

@@ -0,0 +1,67 @@
+/**
+ * seam tell：跨 AI 单条投递。
+ *
+ * 优先走 cross-AI registry —— 目标 AI 在本机 → 直接调 tmux sendToCC 注入；
+ * 不在或 socket 死 → fallback 走 IM 发到对方 userId。
+ *
+ * 入站 inject 加 from header：`💬 [本机 ← <from>] <text>`
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { findByAlias } from './registry.js';
+import { CREDENTIALS_PATH } from './paths.js';
+
+const require = createRequire(import.meta.url);
+
+function resolveSelfName() {
+  if (!existsSync(CREDENTIALS_PATH)) return null;
+  try {
+    return JSON.parse(readFileSync(CREDENTIALS_PATH, 'utf8'))?.name || null;
+  } catch {
+    return null;
+  }
+}
+
+function formatLocalInject(from, text) {
+  const tag = from ? `[本机 ← ${from}]` : '[本机]';
+  return `💬 ${tag} ${text}`;
+}
+
+/**
+ * @returns {Promise<{ok:true, channel:'local'|'im', target:string} | {ok:false, error:string}>}
+ */
+export async function tell({ to, from, text, guardianRequest }) {
+  if (!to) return { ok: false, error: '--to required' };
+  if (!text) return { ok: false, error: '--text required' };
+
+  const fromName = from || resolveSelfName() || '?';
+
+  const entry = findByAlias(to);
+  if (entry?.tmux_session) {
+    try {
+      const { sendToCC } = require('./tmux-utils.cjs');
+      const injectText = formatLocalInject(fromName, text);
+      sendToCC(entry.tmux_session, injectText, { socketPath: entry.tmux_socket || undefined });
+      return { ok: true, channel: 'local', target: entry.userId };
+    } catch (e) {
+      // 本机命中但 CC 不在线 / tmux session 死了 → 落 IM
+      if (!guardianRequest) {
+        return { ok: false, error: `local inject failed: ${e.message}` };
+      }
+    }
+  }
+
+  if (!guardianRequest) {
+    return { ok: false, error: `target "${to}" not in registry and no IM fallback wired` };
+  }
+
+  const targetUserId = entry?.userId || to;
+  try {
+    const res = await guardianRequest({ action: 'send_im', to: targetUserId, text });
+    if (res?.ok === false) return { ok: false, error: res.error || 'IM fallback failed' };
+    return { ok: true, channel: 'im', target: targetUserId };
+  } catch (e) {
+    return { ok: false, error: `IM fallback error: ${e.message}` };
+  }
+}

package/lib/tmux-utils.cjs

@@ -0,0 +1,122 @@
+/**
+ * tmux-utils — 可靠的 tmux 交互。
+ *
+ * CC 用 raw terminal mode，tmux send-keys 需要特殊处理：
+ * 1. 文本用 -l (literal) 发，不解释特殊键
+ * 2. Enter 单独发
+ * 3. 发完验证是否被接收
+ */
+
+const { execSync } = require('node:child_process');
+const { existsSync, readFileSync } = require('node:fs');
+const { join } = require('node:path');
+
+const EXEC_OPTS = { encoding: 'utf8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] };
+
+function tmuxCmd(socketPath) {
+  return socketPath ? `tmux -S "${socketPath}"` : 'tmux';
+}
+
+function listSessions(socketPath) {
+  const tmux = tmuxCmd(socketPath);
+  let lines;
+  try {
+    lines = execSync(`${tmux} list-sessions -F "#{session_name}"`, EXEC_OPTS)
+      .trim().split('\n').filter(Boolean);
+  } catch {
+    return [];
+  }
+  return lines.map(name => {
+    const cc = isCCRunning(name, socketPath);
+    return { session: name, cc };
+  });
+}
+
+function isCCRunning(session, socketPath) {
+  const tmux = tmuxCmd(socketPath);
+  try {
+    const panePid = execSync(
+      `${tmux} display-message -t "${session}" -p '#{pane_pid}'`, EXEC_OPTS
+    ).trim();
+    const self = execSync(`ps -o comm= -p ${panePid} 2>/dev/null`, EXEC_OPTS).trim();
+    if (['claude', 'claude-code'].includes(self)) return true;
+    try {
+      const child = execSync(`ps -o comm= --ppid ${panePid} 2>/dev/null`, EXEC_OPTS)
+        .trim().split('\n').pop() || '';
+      if (['claude', 'claude-code'].includes(child)) return true;
+    } catch {}
+  } catch {}
+  return false;
+}
+
+/**
+ * 给 tmux session 里的 CC 发用户消息。
+ * 用 -l (literal) 发文本 + 单独 Enter，保证 raw terminal mode 下不丢回车。
+ */
+function sendToCC(session, text, { socketPath, skipCheck = false } = {}) {
+  const tmux = tmuxCmd(socketPath);
+  if (!skipCheck && !isCCRunning(session, socketPath)) {
+    throw new Error(`session "${session}": CC not running`);
+  }
+  // 用 -l 发纯文本（不解释特殊键）
+  execSync(`${tmux} send-keys -t "${session}" -l ${JSON.stringify(text)}`, EXEC_OPTS);
+  // 单独发 Enter 提交
+  execSync(`${tmux} send-keys -t "${session}" Enter`, EXEC_OPTS);
+}
+
+/**
+ * 读 tmux session 的最后 N 行输出。
+ */
+function readOutput(session, lines = 20, socketPath) {
+  const tmux = tmuxCmd(socketPath);
+  return execSync(
+    `${tmux} capture-pane -t "${session}" -p | tail -${parseInt(lines) || 20}`,
+    EXEC_OPTS
+  );
+}
+
+/**
+ * 在新 tmux session 里启动 CC。
+ */
+function startCC(dir, session, socketPath) {
+  const tmux = tmuxCmd(socketPath);
+  if (!existsSync(dir)) throw new Error(`dir not found: ${dir}`);
+  try {
+    execSync(`${tmux} has-session -t "${session}" 2>/dev/null`, EXEC_OPTS);
+    throw new Error(`session "${session}" already exists`);
+  } catch (e) {
+    if (e.message.includes('already exists')) throw e;
+  }
+  execSync(
+    `${tmux} new-session -d -s "${session}" -c "${dir}" 'claude --dangerously-skip-permissions'`,
+    { ...EXEC_OPTS, timeout: 10000 }
+  );
+}
+
+/**
+ * 给 CC 发 /exit 然后重启（带 --continue）。
+ * guardian 升级后自动重启 CC 用这个。
+ */
+function restartCC(session, { socketPath, continueSession = true } = {}) {
+  const tmux = tmuxCmd(socketPath);
+  // 发 /exit
+  execSync(`${tmux} send-keys -t "${session}" -l '/exit'`, EXEC_OPTS);
+  execSync(`${tmux} send-keys -t "${session}" Enter`, EXEC_OPTS);
+  // 等 CC 退出
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      try {
+        const cmd = continueSession
+          ? 'claude --dangerously-skip-permissions --continue'
+          : 'claude --dangerously-skip-permissions';
+        execSync(`${tmux} send-keys -t "${session}" -l ${JSON.stringify(cmd)}`, EXEC_OPTS);
+        execSync(`${tmux} send-keys -t "${session}" Enter`, EXEC_OPTS);
+        resolve(true);
+      } catch (e) {
+        resolve(false);
+      }
+    }, 3000);
+  });
+}
+
+module.exports = { listSessions, isCCRunning, sendToCC, readOutput, startCC, restartCC, tmuxCmd };

package/lib/upgrade-all.js

@@ -0,0 +1,67 @@
+/**
+ * Host-tool 模式：对所有已注册的 SEAM_HOME 滚动升级 + 重启 guardian。
+ *
+ * 流程：
+ * 1. 全局升 npm 包（仅一次）
+ * 2. 读 ~/.seam-homes，遍历每个 SEAM_HOME
+ * 3. 每个 SEAM_HOME spawn 子进程 stop → start guardian（隔离 paths.js 缓存）
+ * 4. 清掉目录已不存在的 entry
+ *
+ * 注：本文件是 stage 1 的 registry 实现；stage 2 会替换为 ~/.shared/seam-registry/<userId>.json。
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { execSync, spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const CLI_PATH = join(dirname(__filename), '..', 'bin', 'cli.js');
+
+export async function upgradeAll() {
+  console.log('Seam — host-tool upgrade-all\n');
+
+  console.log('1. npm install -g @seamnet/client@latest');
+  try {
+    execSync('npm install -g @seamnet/client@latest', { stdio: 'inherit' });
+  } catch (e) {
+    console.error(`  npm install -g failed: ${e.message}`);
+    process.exit(1);
+  }
+
+  const homesPath = join(homedir(), '.seam-homes');
+  if (!existsSync(homesPath)) {
+    console.log('\n2. ~/.seam-homes 不存在——无已注册 AI，结束。');
+    return;
+  }
+  const lines = readFileSync(homesPath, 'utf8').split('\n').filter(Boolean);
+  console.log(`\n2. ${lines.length} 个已注册 SEAM_HOME，逐个重启 guardian`);
+
+  const alive = [];
+  for (const home of lines) {
+    console.log(`\n  → ${home}`);
+    if (!existsSync(home)) {
+      console.log('    跳过（目录已不存在，从 registry 移除）');
+      continue;
+    }
+    const env = { ...process.env, SEAM_HOME: home };
+    const stopRes = spawnSync('node', [CLI_PATH, 'stop'], { env, stdio: 'inherit' });
+    if (stopRes.status !== 0) {
+      console.log('    stop 非零退出（guardian 可能未运行，继续）');
+    }
+    const startRes = spawnSync('node', [CLI_PATH, 'guardian', 'start'], { env, stdio: 'inherit' });
+    if (startRes.status !== 0) {
+      console.error(`    start 失败 (exit ${startRes.status})`);
+    } else {
+      alive.push(home);
+    }
+  }
+
+  if (alive.length !== lines.length) {
+    writeFileSync(homesPath, alive.length ? alive.join('\n') + '\n' : '');
+    console.log(`\n  registry 清理：${lines.length} → ${alive.length}`);
+  }
+
+  console.log(`\nDone. ${alive.length} 个 AI guardian 已重启。`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seamnet/client",
-  "version": "0.14.5",
+  "version": "0.16.0",
   "description": "One command to join Seam — the network where people and AI stay in sync.",
   "bin": {
     "seam-client": "bin/cli.js",