@nowcrew/daemon 0.5.30 → 0.5.31

package/dist/remote/wrapper.js

@@ -0,0 +1,40 @@
+import { randomUUID } from "node:crypto";
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function optionValue(args, long, short) {
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (value.startsWith(`${long}=`))
+            return value.slice(long.length + 1);
+        if (value === long || (short && value === short)) {
+            const next = args[index + 1];
+            return next && !next.startsWith("-") ? next : null;
+        }
+    }
+    return null;
+}
+export function resolveClaudeWrapperSession(args, createId = randomUUID) {
+    if (args.includes("--continue") || args.includes("-c")) {
+        throw new Error("NowCrew remote requires an explicit session ID; use --resume <session-id> instead of --continue");
+    }
+    if (args.includes("--fork-session")) {
+        throw new Error("NowCrew remote cannot identify a fork chosen inside Claude; start a new session or resume without --fork-session");
+    }
+    const sessionId = optionValue(args, "--session-id") ?? optionValue(args, "--resume", "-r") ?? createId();
+    if (!UUID.test(sessionId)) {
+        throw new Error("Claude remote sessions require a UUID in --session-id or --resume");
+    }
+    const hasSessionSelector = args.some((value) => value === "--session-id" || value.startsWith("--session-id=")
+        || value === "--resume" || value.startsWith("--resume=") || value === "-r");
+    return {
+        sessionId,
+        args: hasSessionSelector ? [...args] : ["--session-id", sessionId, ...args],
+    };
+}
+export function buildCodexWrappedInvocation(userArgs, socketPath = "") {
+    const hasRemote = userArgs.some((value) => value === "--remote" || value.startsWith("--remote="));
+    return {
+        bin: "codex",
+        args: hasRemote ? [...userArgs] : ["--remote", socketPath ? `unix://${socketPath}` : "unix://", ...userArgs],
+        env: process.env,
+    };
+}

package/dist/runner.js

@@ -106,6 +106,10 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
     }, { onActivity, onConsole }, {
         launchRuntime: dependencies.launchRuntime ?? ((request) => launchSupervisedRuntime(request, dependencies.startSupervisor, dependencies.cancellation, dependencies.platform)),
         ...(dependencies.cancellation === undefined ? {} : { cancellation: dependencies.cancellation }),
+        ...(dependencies.startupGate === undefined ? {} : { startupGate: dependencies.startupGate }),
+        ...(dependencies.startupTimeoutMs === undefined
+            ? {}
+            : { startupTimeoutMs: dependencies.startupTimeoutMs }),
     });
     const activities = [...local.activities];
     if (!input.scheduled && (runtime === "codex" || runtime === "kimi")

package/dist/runtime-startup-gate.js

@@ -0,0 +1,91 @@
+export function createRuntimeStartupGate(limits, now = Date.now) {
+    const activeByRuntime = new Map();
+    const queue = [];
+    let activeTotal = 0;
+    let lastLaunchAt = Number.NEGATIVE_INFINITY;
+    const promote = () => {
+        while (activeTotal < limits.maxStartingTotal) {
+            const index = queue.findIndex((entry) => !entry.released
+                && (activeByRuntime.get(entry.runtime) ?? 0) < limits.maxStartingPerRuntime);
+            if (index < 0)
+                return;
+            const [next] = queue.splice(index, 1);
+            if (!next || next.released)
+                continue;
+            next.promoted = true;
+            activeTotal += 1;
+            activeByRuntime.set(next.runtime, (activeByRuntime.get(next.runtime) ?? 0) + 1);
+            const grant = () => {
+                next.timer = null;
+                if (next.released)
+                    return;
+                next.launchGranted = true;
+                lastLaunchAt = now();
+                next.resolve();
+            };
+            const delay = Math.max(0, lastLaunchAt + limits.startupGapMs - now());
+            if (delay === 0)
+                grant();
+            else
+                next.timer = setTimeout(grant, delay);
+        }
+    };
+    return {
+        reserve: (runtime) => {
+            let resolveReady;
+            const ready = new Promise((resolve) => { resolveReady = resolve; });
+            const entry = {
+                runtime,
+                released: false,
+                promoted: false,
+                launchGranted: false,
+                timer: null,
+                resolve: resolveReady,
+            };
+            queue.push(entry);
+            promote();
+            return {
+                ready,
+                isQueued: () => !entry.launchGranted && !entry.released,
+                release: () => {
+                    if (entry.released)
+                        return;
+                    entry.released = true;
+                    if (entry.timer !== null)
+                        clearTimeout(entry.timer);
+                    if (entry.promoted) {
+                        activeTotal = Math.max(0, activeTotal - 1);
+                        const nextForRuntime = Math.max(0, (activeByRuntime.get(runtime) ?? 1) - 1);
+                        if (nextForRuntime === 0)
+                            activeByRuntime.delete(runtime);
+                        else
+                            activeByRuntime.set(runtime, nextForRuntime);
+                    }
+                    else {
+                        const index = queue.indexOf(entry);
+                        if (index >= 0)
+                            queue.splice(index, 1);
+                    }
+                    promote();
+                },
+            };
+        },
+        snapshot: () => ({
+            startingTotal: activeTotal,
+            queuedTotal: queue.length,
+            startingByRuntime: {
+                claude: activeByRuntime.get("claude") ?? 0,
+                codex: activeByRuntime.get("codex") ?? 0,
+                kimi: activeByRuntime.get("kimi") ?? 0,
+            },
+        }),
+    };
+}
+export function isRuntimeReadyEvent(runtime, event) {
+    if (typeof event !== "object" || event === null)
+        return false;
+    const value = event;
+    if (runtime === "claude")
+        return value.type === "system" && value.subtype === "init";
+    return value.type === "thread.started";
+}

package/dist/serve.js

@@ -28,6 +28,8 @@ import { closeWebSocketWithinDeadline } from "./websocket-shutdown.js";
 import { reconcileExecutionJournal } from "./execution-recovery.js";
 import { createSharedSlotManager } from "./shared-execution-slots.js";
 import { createCompletionRetransmitter } from "./completion-retransmitter.js";
+import { createRuntimeStartupGate } from "./runtime-startup-gate.js";
+import { createHostExecutionCoordinator, hostCoordinatedSlotManager, hostCoordinatedStartupGate, } from "./host-execution-coordinator.js";
 // normalize.ts 的活动种类 → activity 枚举
 const ACTIVITY_MAP = {
     init: "working", text: "thinking", reading: "reading", sending: "sending",
@@ -60,7 +62,9 @@ export function serve(config, opts = {}) {
     const executeProtocol = opts.execution?.runExecution ?? runExecution;
     let detectedExecutionRuntimes = [];
     let runtimeFacts = null;
-    const sharedSlots = createSharedSlotManager(config.executionLimits);
+    const hostCoordinator = opts.execution?.hostCoordinator ?? createHostExecutionCoordinator();
+    const sharedSlots = hostCoordinatedSlotManager(createSharedSlotManager(config.executionLimits), hostCoordinator);
+    const runtimeStartupGate = hostCoordinatedStartupGate(createRuntimeStartupGate(config.executionLimits), hostCoordinator);
     const knownExecutionHashes = new Map();
     const executionReservations = new Map();
     const executionRuns = new Map();
@@ -115,8 +119,11 @@ export function serve(config, opts = {}) {
         if ((entry.state === "completed" || entry.state === "interrupted") && entry.completion !== null) {
             return { executionId: entry.executionId, state: entry.state, completion: entry.completion, updatedAt: entry.updatedAt };
         }
+        if (entry.state === "running" && entry.runtimeReadyAt !== null) {
+            return { executionId: entry.executionId, state: "running", updatedAt: entry.runtimeReadyAt };
+        }
         if (entry.state === "accepted" || entry.state === "running") {
-            return { executionId: entry.executionId, state: entry.state, updatedAt: entry.updatedAt };
+            return { executionId: entry.executionId, state: "accepted", updatedAt: entry.acceptedAt };
         }
         return null;
     };
@@ -137,10 +144,10 @@ export function serve(config, opts = {}) {
                 state: acceptanceState, effectivePermission: entry.effectivePermission ?? "workspace_write",
                 at: entry.acceptedAt,
             });
-            if (entry.state === "running" && entry.processStartedAt !== null) {
+            if (entry.state === "running" && entry.runtimeReadyAt !== null) {
                 safeExecutionSend({
                     type: "execution:started", protocolVersion: 1,
-                    executionId: entry.executionId, at: entry.processStartedAt,
+                    executionId: entry.executionId, at: entry.runtimeReadyAt,
                 });
             }
         }
@@ -335,8 +342,30 @@ export function serve(config, opts = {}) {
                         }
                         return;
                     }
-                    knownExecutionHashes.set(spec.executionId, hash);
                     const reservation = sharedSlots.reserve(spec.agent.handle, "execution");
+                    if (!reservation.accepted) {
+                        dslog("execution.machine_queue_rejected", "机器执行队列已满", {
+                            level: "WARN",
+                            execution_id: spec.executionId,
+                            agent_handle: spec.agent.handle,
+                            ...reservation.facts,
+                        });
+                        safeExecutionSend(ExecutionRejectedSchema.parse({
+                            type: "execution:rejected", protocolVersion: 1, executionId: spec.executionId,
+                            reason: "resource_limit", message: "Local machine execution queue is full",
+                            at: new Date().toISOString(),
+                        }));
+                        return;
+                    }
+                    knownExecutionHashes.set(spec.executionId, hash);
+                    const machineQueueEnteredAt = Date.now();
+                    if (reservation.isQueued()) {
+                        dslog("execution.machine_queued", "execution 已进入机器队列", {
+                            execution_id: spec.executionId,
+                            agent_handle: spec.agent.handle,
+                            ...reservation.facts,
+                        });
+                    }
                     executionReservations.set(spec.executionId, reservation);
                     const cancellation = cancellationFor(spec.executionId);
                     const cleanupExecutionReservation = () => {
@@ -371,8 +400,22 @@ export function serve(config, opts = {}) {
                             ...reservation.facts,
                         },
                         report: reportExecutionFrame,
+                        startupGate: runtimeStartupGate,
+                        startupTimeoutMs: config.executionLimits.startupTimeoutMs,
                         ...(reservation.state === undefined ? {} : {
-                            slot: { state: reservation.state, ready: reservation.ready },
+                            slot: {
+                                state: reservation.state,
+                                ready: reservation.ready.then(() => {
+                                    const snapshot = sharedSlots.snapshot();
+                                    dslog("execution.machine_slot_ready", "execution 获得机器执行名额", {
+                                        execution_id: spec.executionId,
+                                        agent_handle: spec.agent.handle,
+                                        queue_ms: Date.now() - machineQueueEnteredAt,
+                                        active_total: snapshot.activeTotal,
+                                        queued_total: snapshot.queuedTotal,
+                                    });
+                                }),
+                            },
                         }),
                         cancellation,
                     }).finally(() => {
@@ -539,12 +582,26 @@ export function serve(config, opts = {}) {
                 }
                 running.add(key);
                 legacyReservation = sharedSlots.reserve(msg.agentHandle, "legacy");
+                if (legacyReservation.isQueued()) {
+                    const snapshot = sharedSlots.snapshot();
+                    dslog("run.machine_queued", "legacy run 已进入机器队列", {
+                        ...runKeys,
+                        active_total: snapshot.activeTotal,
+                        queued_total: snapshot.queuedTotal,
+                    });
+                }
                 await awaitWithCancellation(legacyReservation.ready, controller.cancellation);
                 const queueMs = Date.now() - queueWaitStart;
+                const machineSnapshot = sharedSlots.snapshot();
                 const threadLabel = threadId ?? null;
                 const from = msg.wake?.senderHandle ?? "?";
                 const incoming = msg.wake?.content ?? "";
-                dslog("run.start", `开始运行 ${msg.agentHandle}`, { ...runKeys, queue_ms: queueMs });
+                dslog("run.start", `开始运行 ${msg.agentHandle}`, {
+                    ...runKeys,
+                    queue_ms: queueMs,
+                    active_total: machineSnapshot.activeTotal,
+                    queued_total: machineSnapshot.queuedTotal,
+                });
                 log(`\n${"─".repeat(56)}`);
                 log(`🔔 唤醒 agent=${msg.agentHandle}  reason=${msg.reason ?? "?"}`);
                 log(`   channel = ${msg.channelId}`);
@@ -650,7 +707,11 @@ export function serve(config, opts = {}) {
                         ...(!scheduled && threadId ? { wakeMessageId: threadId } : {}),
                         ...(!scheduled && msg.wake?.seq !== undefined ? { wakeContextUpToSeq: msg.wake.seq } : {}),
                         ...(attemptWake ? { wake: attemptWake } : {}),
-                    }, reportActivity, reportConsole, { cancellation: controller.cancellation });
+                    }, reportActivity, reportConsole, {
+                        cancellation: controller.cancellation,
+                        startupGate: runtimeStartupGate,
+                        startupTimeoutMs: config.executionLimits.startupTimeoutMs,
+                    });
                 });
                 const result = mergeRunAgentResults(guarded.results);
                 // 本轮 token 用量上报:runner 已从 result 事件提取(含缓存读/写细分),
@@ -848,6 +909,7 @@ export function serve(config, opts = {}) {
                 for (const run of legacyRuns.values())
                     run.controller.request();
                 await deadline.waitFor(Promise.all(pending));
+                await deadline.waitFor(hostCoordinator.drain());
                 await executionJournal.close({ signal: deadline.signal });
             }
             finally {

package/dist/shared-execution-slots.js

@@ -1,46 +1,58 @@
 export function createSharedSlotManager(limits) {
     const activeByHandle = new Map();
-    const queuesByHandle = new Map();
-    const promoteNext = (handle) => {
-        const queue = queuesByHandle.get(handle) ?? [];
-        while ((activeByHandle.get(handle) ?? 0) < limits.maxParallelPerAgent && queue.length > 0) {
-            const next = queue.shift();
-            if (next.released)
+    const queue = [];
+    let activeTotal = 0;
+    const queuedFor = (handle) => queue.filter((entry) => !entry.released && entry.handle === handle).length;
+    const promote = () => {
+        while (activeTotal < limits.maxParallelTotal) {
+            const index = queue.findIndex((entry) => !entry.released
+                && (activeByHandle.get(entry.handle) ?? 0) < limits.maxParallelPerAgent);
+            if (index < 0)
+                return;
+            const [next] = queue.splice(index, 1);
+            if (!next || next.released)
                 continue;
             next.promoted = true;
-            activeByHandle.set(handle, (activeByHandle.get(handle) ?? 0) + 1);
+            activeTotal += 1;
+            activeByHandle.set(next.handle, (activeByHandle.get(next.handle) ?? 0) + 1);
             next.resolve();
         }
-        if (queue.length === 0)
-            queuesByHandle.delete(handle);
     };
     return {
         reserve: (handle, kind) => {
-            const active = activeByHandle.get(handle) ?? 0;
-            const queued = queuesByHandle.get(handle)?.length ?? 0;
-            const facts = { activeForAgent: active, queuedForAgent: queued };
-            if (kind === "execution" && active >= limits.maxParallelPerAgent
-                && queued >= limits.maxQueuedPerAgent) {
-                return { facts, ready: Promise.resolve(), isQueued: () => false, release: () => { } };
+            const activeForAgent = activeByHandle.get(handle) ?? 0;
+            const queuedForAgent = queuedFor(handle);
+            const facts = {
+                activeForAgent,
+                queuedForAgent,
+                activeTotal,
+                queuedTotal: queue.length,
+            };
+            const canStartImmediately = activeTotal < limits.maxParallelTotal
+                && activeForAgent < limits.maxParallelPerAgent
+                && queue.length === 0;
+            if (kind === "execution" && !canStartImmediately && (queuedForAgent >= limits.maxQueuedPerAgent
+                || queue.length >= limits.maxQueuedTotal)) {
+                return {
+                    accepted: false,
+                    facts,
+                    ready: Promise.resolve(),
+                    isQueued: () => false,
+                    release: () => { },
+                };
             }
             let resolveReady;
             const ready = new Promise((resolve) => { resolveReady = resolve; });
             const entry = {
-                kind,
+                handle,
                 released: false,
-                promoted: active < limits.maxParallelPerAgent,
+                promoted: false,
                 resolve: resolveReady,
             };
-            if (entry.promoted) {
-                activeByHandle.set(handle, active + 1);
-                resolveReady();
-            }
-            else {
-                const queue = queuesByHandle.get(handle) ?? [];
-                queue.push(entry);
-                queuesByHandle.set(handle, queue);
-            }
+            queue.push(entry);
+            promote();
             return {
+                accepted: true,
                 facts,
                 state: entry.promoted ? "ready" : "queued",
                 ready,
@@ -50,19 +62,22 @@ export function createSharedSlotManager(limits) {
                         return;
                     entry.released = true;
                     if (entry.promoted) {
-                        activeByHandle.set(handle, Math.max(0, (activeByHandle.get(handle) ?? 1) - 1));
+                        activeTotal = Math.max(0, activeTotal - 1);
+                        const nextForAgent = Math.max(0, (activeByHandle.get(handle) ?? 1) - 1);
+                        if (nextForAgent === 0)
+                            activeByHandle.delete(handle);
+                        else
+                            activeByHandle.set(handle, nextForAgent);
                     }
                     else {
-                        const queue = queuesByHandle.get(handle);
-                        const index = queue?.indexOf(entry) ?? -1;
-                        if (queue !== undefined && index >= 0)
+                        const index = queue.indexOf(entry);
+                        if (index >= 0)
                             queue.splice(index, 1);
-                        if (queue?.length === 0)
-                            queuesByHandle.delete(handle);
                     }
-                    promoteNext(handle);
+                    promote();
                 },
             };
         },
+        snapshot: () => ({ activeTotal, queuedTotal: queue.length }),
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.5.30",
+  "version": "0.5.31",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",