c0de-agent 1.8.0 → 1.10.0

package/dist/update/ipc.js

@@ -1,17 +1,45 @@
+import { timingSafeEqual } from 'node:crypto';
 import { createServer } from 'node:http';
-/** 旧实例启动时创建 handoff 端点。收到 POST /handoff 即触发 onHandoff（序列化 + 退出）。 */
-function createHandoffServer(onHandoff) {
+/**
+ * 恒时比较 Authorization 头与期望值：字符串直接比较可被时序攻击逐字符探测。
+ * 长度不等直接 false——timingSafeEqual 要求等长 buffer，先比较长度本身
+ * 不泄露内容信息。
+ */
+function authHeaderMatches(actual, expected) {
+    if (typeof actual !== 'string' || actual.length !== expected.length)
+        return false;
+    return timingSafeEqual(Buffer.from(actual), Buffer.from(expected));
+}
+/**
+ * 旧实例启动时创建 handoff 端点。收到 POST /handoff 即触发 onHandoff
+ * （关闭主服务与资源），响应 200；exitAfterResponse 时随后退出进程。
+ */
+function createHandoffServer(onHandoff, opts = {}) {
     return new Promise((resolve, reject) => {
+        const expected = opts.expectedToken && opts.expectedToken.length > 0
+            ? `Bearer ${opts.expectedToken}`
+            : '';
         const handler = async (req, res) => {
             if (req.method === 'POST' && req.url === '/handoff') {
+                if (expected && !authHeaderMatches(req.headers.authorization, expected)) {
+                    res.writeHead(401, { 'content-type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'unauthorized' }));
+                    return;
+                }
                 try {
                     await onHandoff();
                     res.writeHead(200, { 'content-type': 'application/json' });
                     res.end(JSON.stringify({ ok: true }));
+                    // 仅 200 才调度退出：500 时 exit(0) 会掩盖让渡失败——保留进程供
+                    // 诊断/重试，由下方错误日志暴露 onHandoff 失败原因。
+                    if (opts.exitAfterResponse) {
+                        setTimeout(() => process.exit(0), 250);
+                    }
                 }
                 catch (error) {
                     res.writeHead(500, { 'content-type': 'application/json' });
                     res.end(JSON.stringify({ ok: false, error: String(error) }));
+                    console.error('[handoff] onHandoff failed, keeping process alive:', error);
                 }
                 return;
             }
@@ -32,10 +60,28 @@ function createHandoffServer(onHandoff) {
         });
     });
 }
-/** 新实例请求旧实例让出端口（graceful shutdown）。失败抛错。 */
-async function requestHandoff(port, host = '127.0.0.1') {
-    const res = await fetch(`http://${host}:${port}/handoff`, { method: 'POST' });
-    if (!res.ok)
-        throw new Error(`handoff failed: HTTP ${res.status}`);
+/** 新实例请求旧实例让出端口（graceful shutdown）。失败抛可区分的 HandoffError。 */
+async function requestHandoff(port, host = '127.0.0.1', token) {
+    let res;
+    try {
+        res = await fetch(`http://${host}:${port}/handoff`, {
+            method: 'POST',
+            ...(token ? { headers: { Authorization: `Bearer ${token}` } } : {}),
+        });
+    }
+    catch (err) {
+        // 连接层失败（ECONNREFUSED 等）：旧实例无 handoff 端点。抛 kind='connect'
+        // 让调用方（requestHandoffWithRetry）区分处理——直接尝试绑端口。
+        const error = new Error(`handoff connect failed: ${err instanceof Error ? err.message : String(err)}`);
+        error.kind = 'connect';
+        throw error;
+    }
+    if (!res.ok) {
+        // 收到 HTTP 响应但非 2xx（如 401 token 不匹配、500 onHandoff 失败）。
+        const error = new Error(`handoff failed: HTTP ${res.status}`);
+        error.kind = 'http';
+        error.status = res.status;
+        throw error;
+    }
 }
 export { createHandoffServer, requestHandoff };

package/dist/update/updater.d.ts

@@ -16,8 +16,9 @@ type HotUpdateResult = {
  * 启动新实例的函数签名。
  * @param snapshotPath 快照文件路径（旧实例已写入）
  * @param argv          传给新进程的完整参数（含 restore flag + 可选 handoff flag）
+ * @param opts          热更新选项（authToken 等经环境变量传递给新实例）
  */
-type SpawnFn = (snapshotPath: string, argv: string[]) => Promise<void>;
+type SpawnFn = (snapshotPath: string, argv: string[], opts?: HotUpdateOptions) => Promise<void>;
 type HotUpdateOptions = {
     /** 自更新安装函数；默认 `npm install -g <pkg>`。 */
     installFn?: (pkg: string) => Promise<void>;
@@ -30,6 +31,10 @@ type HotUpdateOptions = {
     restoreFlag?: string;
     /** 旧实例 handoff 端口；提供时新实例启动后请求旧实例 graceful shutdown。 */
     handoffPort?: number;
+    /** 旧实例主服务端口；新实例 --port 复用（保证接管同一地址）。 */
+    port?: number;
+    /** 传给新实例的认证 token（经环境变量 C0DE_AUTH_TOKEN），保证新旧实例握手同 token。 */
+    authToken?: string;
 };
 /**
  * 执行热更新（spec §18.1-18.2 流程）：
@@ -38,8 +43,7 @@ type HotUpdateOptions = {
  *   3. detached 启动新版本实例，传入快照路径（新实例 restore + 端口接管）
  *
  * 注：旧实例的 graceful shutdown / 端口让渡由新实例启动后通过 IPC 协调
- * （见 ipc.ts），本函数只负责"序列化 + 安装 + 接力"。若提供 handoffPort，
- * argv 会带上 --handoff-port，新实例据此 requestHandoff 通知旧实例退出。
+ * （见 ipc.ts），本函数只负责"序列化 + 安装 + 接力"。
  */
 declare function performHotUpdate(snapshot: SessionSnapshot, opts?: HotUpdateOptions): Promise<HotUpdateResult>;
 /** 清理快照临时目录（热更新完成或放弃后调用）。 */

package/dist/update/updater.js

@@ -16,13 +16,17 @@ function defaultInstall(pkg) {
         });
     });
 }
-/** 默认启动新实例：detached spawn，argv 全部透传给新进程。 */
-function defaultSpawn(_snapshotPath, argv) {
+/** 默认启动新实例：detached spawn CLI bin，argv = serve <restore> <handoff>。
+ * 必须以 `serve` 子命令开头（CLI dispatch 按首参选命令）；
+ * --port 复用旧实例端口，--handoff-port 让新实例启动后请求旧实例退出。
+ * 认证 token 经环境变量传递（不落 argv，避免 ps 泄漏）。 */
+function defaultSpawn(_snapshotPath, argv, opts) {
     return new Promise((resolve, reject) => {
         try {
             const child = spawn(process.argv0, [process.argv[1] ?? '', ...argv], {
                 detached: true,
                 stdio: 'ignore',
+                ...(opts?.authToken ? { env: { ...process.env, C0DE_AUTH_TOKEN: opts.authToken } } : {}),
             });
             child.unref();
             resolve();
@@ -39,8 +43,7 @@ function defaultSpawn(_snapshotPath, argv) {
  *   3. detached 启动新版本实例，传入快照路径（新实例 restore + 端口接管）
  *
  * 注：旧实例的 graceful shutdown / 端口让渡由新实例启动后通过 IPC 协调
- * （见 ipc.ts），本函数只负责"序列化 + 安装 + 接力"。若提供 handoffPort，
- * argv 会带上 --handoff-port，新实例据此 requestHandoff 通知旧实例退出。
+ * （见 ipc.ts），本函数只负责"序列化 + 安装 + 接力"。
  */
 async function performHotUpdate(snapshot, opts = {}) {
     const pkg = opts.packageName ?? DEFAULT_PACKAGE;
@@ -59,13 +62,18 @@ async function performHotUpdate(snapshot, opts = {}) {
         };
     }
     const restoreFlag = opts.restoreFlag ?? '--restore';
-    const argv = [restoreFlag, snapshotPath];
+    const argv = [
+        'serve',
+        restoreFlag,
+        snapshotPath,
+        ...(opts.port !== undefined ? ['--port', String(opts.port)] : []),
+    ];
     if (opts.handoffPort !== undefined) {
         argv.push('--handoff-port', String(opts.handoffPort));
     }
     const spawnNew = opts.spawnNewInstanceFn ?? defaultSpawn;
     try {
-        await spawnNew(snapshotPath, argv);
+        await spawnNew(snapshotPath, argv, opts);
     }
     catch (error) {
         return {

package/dist/update/version.d.ts

@@ -10,9 +10,14 @@ type CheckOptions = {
     currentVersion?: string;
     registryUrl?: string;
 };
+/**
+ * 读取当前安装版本（package.json 的 version 字段）。
+ * src/dev 与 dist 两种布局下 `../../package.json` 都指向包根；读取失败回退常量。
+ */
+declare function getCurrentVersion(): string;
 /** 语义化版本比较：a < b → -1，a == b → 0，a > b → 1。忽略前导 v 和 prerelease。 */
 declare function compareSemver(a: string, b: string): number;
 /** 查询 npm registry 判断是否有新版本。网络/解析失败时返回 hasUpdate:false，绝不抛错。 */
 declare function checkForUpdate(opts?: CheckOptions): Promise<UpdateCheckResult>;
 export type { CheckOptions, UpdateCheckResult };
-export { checkForUpdate, compareSemver };
+export { checkForUpdate, compareSemver, getCurrentVersion };

package/dist/update/version.js

@@ -1,7 +1,22 @@
-// 版本检查（spec §18.1）：查询 npm registry 比对当前版本。
+import { readFileSync } from 'node:fs';
 const DEFAULT_PACKAGE = 'c0de-agent';
 const DEFAULT_VERSION = '0.1.0';
 const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
+/**
+ * 读取当前安装版本（package.json 的 version 字段）。
+ * src/dev 与 dist 两种布局下 `../../package.json` 都指向包根；读取失败回退常量。
+ */
+function getCurrentVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf-8'));
+        if (typeof pkg.version === 'string' && pkg.version.length > 0)
+            return pkg.version;
+    }
+    catch {
+        // 打包布局异常：回退保守常量
+    }
+    return DEFAULT_VERSION;
+}
 /** 取 semver 的数值核心（去前导 v 与 prerelease）。 */
 function semverCore(v) {
     return (v.replace(/^v/, '').split('-')[0] ?? '').split('.').map(Number);
@@ -23,7 +38,7 @@ function compareSemver(a, b) {
 /** 查询 npm registry 判断是否有新版本。网络/解析失败时返回 hasUpdate:false，绝不抛错。 */
 async function checkForUpdate(opts = {}) {
     const pkg = opts.packageName ?? DEFAULT_PACKAGE;
-    const current = opts.currentVersion ?? DEFAULT_VERSION;
+    const current = opts.currentVersion ?? getCurrentVersion();
     const registry = opts.registryUrl ?? DEFAULT_REGISTRY;
     const fetchImpl = opts.fetchImpl ?? fetch;
     const result = {
@@ -46,4 +61,4 @@ async function checkForUpdate(opts = {}) {
     }
     return result;
 }
-export { checkForUpdate, compareSemver };
+export { checkForUpdate, compareSemver, getCurrentVersion };

package/drizzle/0005_snapshot_mtime.sql

@@ -0,0 +1 @@
+ALTER TABLE "file_snapshots" ADD COLUMN "mtime_ms" bigint;