@nowcrew/daemon 0.6.95 → 0.6.97-beta.1

package/dist/machine-info.js

@@ -33,6 +33,7 @@ export const SELF_TRAINING_EXECUTION_CAPABILITY = "self_training_execution_v1";
 export const EXECUTION_LARGE_ATTACHMENTS_CAPABILITY = "execution_attachments_300m_v1";
 export const PROJECT_SKILL_PROJECTION_CAPABILITY = "project_skill_projection_v2";
 export const MACHINE_ENVIRONMENT_CAPABILITY = "machine_environment_v1";
+export const MACHINE_HELLO_ACK_CAPABILITY = "machine_hello_ack_v1";
 export const NATIVE_PROJECT_WORKSPACE_READINESS = Object.freeze({
     resolverReady: true,
     nativeRuntimeAdaptersReady: true,
@@ -62,6 +63,7 @@ export const DAEMON_CAPABILITIES = Object.freeze([
     "agent_ability_runtime_assets_v1",
     "agent_environments_v1",
     MACHINE_ENVIRONMENT_CAPABILITY,
+    MACHINE_HELLO_ACK_CAPABILITY,
 ]);
 /** 能力只按平台过滤,进程存活期间静态(CLAUDE.md 红线)。Windows 在 junction/copy 真机 smoke 通过前不宣告 Project Skills。 */
 export const daemonCapabilities = (runtimePlatform = process.platform, readiness = NATIVE_PROJECT_WORKSPACE_READINESS) => {

package/dist/project-skills/machine-hello-publisher.js

@@ -1,20 +1,109 @@
 import { WebSocket } from "ws";
+const HELLO_RETRY_DELAYS_MS = [1_000, 2_000, 4_000];
 /** 记住最近一次 hello 与 socket,便于存储身份变化后重发;Project Skills 状态恒为 ready。 */
 export function createMachineHelloPublisher(input) {
     let latest = null;
     let latestSocket = null;
-    const republish = () => {
-        if (latest === null || latestSocket?.readyState !== WebSocket.OPEN)
+    let acknowledged = false;
+    let attempts = 0;
+    // 发送代次:每开一轮新发送(attach/publish/republish)自增,随帧发出并要求 ack 回显。
+    let generation = 0;
+    let retryTimer;
+    const clearRetry = () => {
+        if (retryTimer !== undefined) {
+            clearTimeout(retryTimer);
+            retryTimer = undefined;
+        }
+    };
+    const scheduleRetry = () => {
+        clearRetry();
+        if (acknowledged || latest === null || latestSocket?.readyState !== WebSocket.OPEN)
+            return;
+        // 当前 server 不支持 ack → 不排重试(否则永远等不到确认,白跑满退避)。
+        if (input.ackSupported && !input.ackSupported())
+            return;
+        const delay = HELLO_RETRY_DELAYS_MS[attempts - 1];
+        if (delay === undefined) {
+            // 退避跑满仍未 ack:期待 ack(ackSupported 已声明支持)才升级为断连重连,避免旧行为下反复重连。
+            if (input.ackSupported !== undefined && latestSocket !== null)
+                input.onExhausted?.(latestSocket);
             return;
-        const hello = input.effective({ ...latest, projectSkillsStatus: "ready" });
+        }
+        retryTimer = setTimeout(() => {
+            retryTimer = undefined;
+            sendCurrent();
+        }, delay);
+    };
+    function sendCurrent() {
+        if (latest === null || latestSocket?.readyState !== WebSocket.OPEN || acknowledged)
+            return;
+        // helloSeq 随帧发出;同一代次的多次重试复用同一 seq,ack 回显该 seq 即视为确认。
+        const hello = input.effective({ ...latest, projectSkillsStatus: "ready", helloSeq: generation });
+        const attempt = attempts + 1;
+        attempts = attempt;
         try {
             latestSocket.send(JSON.stringify(hello));
-            input.onSent(hello);
+            input.onSent(hello, attempt);
+        }
+        catch (error) {
+            input.onSendFailed?.(hello, attempt, error);
         }
-        catch { /* 非 OPEN,忽略 */ }
+        scheduleRetry();
+    }
+    const attach = (socket) => {
+        clearRetry();
+        latestSocket = socket;
+        acknowledged = false;
+        attempts = 0;
+        generation += 1;
+        sendCurrent();
+    };
+    const detach = (socket) => {
+        if (latestSocket !== socket)
+            return;
+        clearRetry();
+        latestSocket = null;
+        acknowledged = false;
+        attempts = 0;
+    };
+    const republish = () => {
+        if (latest === null || latestSocket === null)
+            return;
+        clearRetry();
+        acknowledged = false;
+        attempts = 0;
+        generation += 1;
+        sendCurrent();
+    };
+    const acknowledge = (socket, seq) => {
+        // 非当前 socket / 已确认 / 该 socket 已在关闭(close 后迟到的 ack)一律忽略:
+        // 后者会错误触发 onAck→清零强制重连计数,削弱重连上限。
+        if (latestSocket !== socket || latest === null || acknowledged || socket.readyState !== WebSocket.OPEN)
+            return;
+        // 代次校验:只接受回显当前代次的 ack,忽略上一代次迟到的 ack(否则会误停新代次的重试)。
+        // seq 缺省(老 server 不回显)时退回仅按 socket 匹配,保持兼容。
+        if (seq !== undefined && seq !== generation)
+            return;
+        acknowledged = true;
+        clearRetry();
+        input.onAck?.(input.effective({ ...latest, projectSkillsStatus: "ready" }));
     };
     return Object.freeze({
-        publish: (hello, socket) => { latest = hello; latestSocket = socket; republish(); },
+        publish: (hello, socket) => {
+            latest = hello;
+            if (latestSocket !== socket) {
+                attach(socket);
+                return;
+            }
+            acknowledged = false;
+            attempts = 0;
+            generation += 1;
+            clearRetry();
+            sendCurrent();
+        },
+        attach,
+        detach,
         republish,
+        acknowledge,
     });
 }

package/dist/serve.js

@@ -9,7 +9,7 @@ import { randomUUID } from "node:crypto";
 import { dslog, setSlogDefaults, drainSpool, flushSlog } from "./slog.js";
 import { mergeRunAgentResults, reportScheduledStartFailure, runAgent } from "./runner.js";
 import { buildOriginDecisionRetryPrompt, buildScheduledPrompt } from "./prompt.js";
-import { daemonCapabilities, daemonCapabilityBindings, } from "./machine-info.js";
+import { daemonCapabilities, daemonCapabilityBindings, MACHINE_HELLO_ACK_CAPABILITY, } from "./machine-info.js";
 import { reconcileExecutionJournal } from "./execution-recovery.js";
 import { initReleaseSlog, reportDaemonConnectionClose, reportReleaseError } from "./release-channel-guard.js";
 import { handleWorkspaceControlRequest } from "./workspace-control-handler.js";
@@ -65,6 +65,10 @@ export function serve(config, opts = {}) {
     let serverCapabilities = new Set();
     let backoff = 1000;
     const maxBackoff = opts.maxBackoffMs ?? 30_000;
+    // hello 重试跑满仍未 ack 时主动断连重连(破 server 侧连接归属/fence 死锁)。收到 ack 清零;
+    // 连续多次仍拿不到 ack 则停手,退回 connected-offline,避免事故期把控制面打成重连风暴。
+    const maxUnackedHelloReconnects = 3;
+    let unackedHelloReconnects = 0;
     const testShutdown = readTestShutdownConfiguration(process.env);
     const shutdownTimeoutMs = opts.shutdownTimeoutMs ?? testShutdown.timeoutMs ?? 30_000;
     const createWebSocket = opts.createWebSocket ?? ((url) => new WebSocket(url));
@@ -160,7 +164,41 @@ export function serve(config, opts = {}) {
                 : configuredIdentity;
             return currentIdentity === undefined ? hello : { ...hello, ...currentIdentity };
         },
-        onSent: (hello) => log(`📤 已上报机器信息: ${hello.hostname} · ${hello.os} · installed=[${hello.runtimes.join(",")}] · executable=[${hello.executionRuntimes.join(",")}] · agents=[${hello.agentHandles.join(",")}]`),
+        onSent: (hello, attempt) => dslog("daemon.machine_hello_send_queued", "机器 hello 已进入发送队列", {
+            attempt, hostname: hello.hostname, daemon_version: hello.daemonVersion,
+        }),
+        onSendFailed: (hello, attempt, error) => dslog("daemon.machine_hello_send_failed", "机器 hello 发送失败", {
+            level: "WARN", attempt, hostname: hello.hostname, daemon_version: hello.daemonVersion,
+            error_message: error instanceof Error ? error.message : String(error),
+        }),
+        onAck: (hello) => {
+            unackedHelloReconnects = 0; // 拿到确认 = 本连接登记成功,清零强制重连计数。
+            dslog("daemon.machine_hello_ack_received", "机器 hello 已收到控制面确认", {
+                hostname: hello.hostname, daemon_version: hello.daemonVersion,
+            });
+        },
+        // 仅当当前 server 声明支持 ack 才重试;老 server 收不到 ack,重试无意义(退回单次上报)。
+        ackSupported: () => serverCapabilities.has(MACHINE_HELLO_ACK_CAPABILITY),
+        // 重试跑满仍未 ack → 断开当前连接,靠重连换新连接(新 epoch/token)破 server 侧 fence 死锁。
+        onExhausted: (socket) => {
+            if (stopped || ws !== socket || socket.readyState !== WebSocket.OPEN)
+                return;
+            if (unackedHelloReconnects >= maxUnackedHelloReconnects) {
+                dslog("daemon.machine_hello_unacked_giveup", "机器 hello 连续多次重连仍未确认,停止强制重连(保持连接,等待下次事件或人工介入)", {
+                    level: "ERROR", reconnects: unackedHelloReconnects,
+                });
+                return;
+            }
+            unackedHelloReconnects += 1;
+            // 抖动重连间隔:控制面回滚时多台 daemon 会同时耗尽重试,固定间隔会同步重连造成羊群。
+            // close handler 用当前 backoff 排重连,这里注入 1~4s 随机值把各机错峰(open 会再把它复位)。
+            const jitteredBackoff = 1_000 + Math.floor(Math.random() * 3_000);
+            backoff = Math.min(jitteredBackoff, maxBackoff);
+            dslog("daemon.machine_hello_unacked_reconnect", "机器 hello 重试跑满仍未确认,断开重连换新连接", {
+                level: "WARN", reconnects: unackedHelloReconnects, backoff_ms: backoff,
+            });
+            socket.close(1011, "machine hello unacknowledged");
+        },
     });
     const machineRuntime = createMachineRuntimeEnvironment({
         config,
@@ -310,6 +348,7 @@ export function serve(config, opts = {}) {
             // 连上了才有机会把离线期间(断连原因/退出前)落盘的日志补传上去
             void drainSpool();
             // 上报本机信息 (hostname/os/daemon 版本/已装 runtimes)
+            machineHelloPublisher.attach(openedSocket);
             machineRuntime.open(openedSocket, { capabilities: capabilities.machineHello, beforePublish: Promise.resolve(), connectionId });
             opts.onOpen?.(ws);
             void sendSnapshot(`reconnect-${randomUUID()}`);
@@ -352,6 +391,11 @@ export function serve(config, opts = {}) {
             if (typeof decoded !== "object" || decoded === null)
                 return;
             const rawType = "type" in decoded && typeof decoded.type === "string" ? decoded.type : "";
+            if (rawType === "machine:hello_ack") {
+                const ackSeq = "helloSeq" in decoded && typeof decoded.helloSeq === "number" ? decoded.helloSeq : undefined;
+                machineHelloPublisher.acknowledge(connectionSocket, ackSeq);
+                return;
+            }
             if (rawType === "machine:environment:get" || rawType === "machine:environment:refresh") {
                 await handleMachineEnvironmentFrame(decoded, machineRuntime.provider, sendToConnection);
                 return;
@@ -735,6 +779,11 @@ export function serve(config, opts = {}) {
                 // ready 帧带 server 视角的 machineId/workspaceId → 作为后续所有日志的默认关联键
                 const r = msg;
                 setSlogDefaults({ machine_id: r.machineId, workspace_id: r.workspaceId });
+                // 旧 server 无此字段 → 空集合(daemon 保持全部旧行为)。ackSupported() 依赖它判断是否重试,
+                // 必须在任何 republish() 之前就位;否则本轮 republish 看到空集合→不排重试→整套 ack/重连机制哑火。
+                serverCapabilities = new Set(Array.isArray(r.serverCapabilities)
+                    ? r.serverCapabilities.filter((c) => typeof c === "string")
+                    : []);
                 if (opts.storageRuntime !== undefined && typeof r.workspaceId === "string" && typeof r.machineId === "string") {
                     const bindingSocket = ws;
                     bindStorageServerIdentity(opts.storageRuntime, { workspaceId: r.workspaceId, machineId: r.machineId }, {
@@ -751,10 +800,7 @@ export function serve(config, opts = {}) {
                         },
                     });
                 }
-                // 旧 server 无此字段 → 空集合(daemon 保持全部旧行为)。
-                serverCapabilities = new Set(Array.isArray(r.serverCapabilities)
-                    ? r.serverCapabilities.filter((c) => typeof c === "string")
-                    : []);
+                machineHelloPublisher.republish();
                 if (serverCapabilities.has(PROJECT_SKILLS_CAPABILITY)) {
                     void projectSkillsController.initialize()
                         .then(() => projectSkillsController.publishCurrent())
@@ -1203,6 +1249,7 @@ export function serve(config, opts = {}) {
         });
         connectionSocket.on("close", (code) => {
             machineRuntime.close(connectionSocket);
+            machineHelloPublisher.detach(connectionSocket);
             if (stopped || ws !== connectionSocket)
                 return;
             // server 能力随连接失效;下个连接的 ready 帧重新声明(防降级重连后沿用过期能力)。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.6.95",
+  "version": "0.6.97-beta.1",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -18,13 +18,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "daemon": "pnpm --filter @nowcrew/cli build && tsx src/main.ts",
-    "build": "tsc -p tsconfig.json",
-    "prepublishOnly": "pnpm build && node ../scripts/daemon-release-artifact.mjs --strict-registry",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit"
-  },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.2.1",
     "@nowcrew/cli": "0.4.17",
@@ -46,5 +39,11 @@
     "tsx": "^4.19.0",
     "typescript": "^5.6.0",
     "vitest": "^2.1.0"
+  },
+  "scripts": {
+    "daemon": "pnpm --filter @nowcrew/cli build && tsx src/main.ts",
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
   }
-}
+}