@nowcrew/daemon 0.6.18 → 0.6.20

package/dist/project-skills/serve-capability.js

@@ -0,0 +1,28 @@
+import { WebSocket } from "ws";
+import { daemonCapabilityBindings, } from "../machine-info.js";
+import { prepareProjectSkillConnectionCapabilities, } from "./capability.js";
+export function createProjectSkillConnectionCapabilityProvider(input) {
+    return async () => daemonCapabilityBindings(input.platform, await prepareProjectSkillConnectionCapabilities(input));
+}
+export function createProjectSkillMachineHelloPublisher(input) {
+    let latest = null;
+    let latestSocket = null;
+    const republish = () => {
+        if (latest === null || latestSocket?.readyState !== WebSocket.OPEN)
+            return;
+        const hello = input.effective(latest, input.status());
+        try {
+            latestSocket.send(JSON.stringify(hello));
+            input.onSent(hello);
+        }
+        catch { /* 非 OPEN,忽略 */ }
+    };
+    return Object.freeze({
+        publish: (hello, socket) => {
+            latest = hello;
+            latestSocket = socket;
+            republish();
+        },
+        republish,
+    });
+}

package/dist/project-skills/serve-startup.js

@@ -0,0 +1,22 @@
+import { createExecutionJournal } from "../execution-journal.js";
+import { reconcileExecutionJournal } from "../execution-recovery.js";
+import { dslog, flushSlog } from "../slog.js";
+export async function initializeProjectSkillProtectedExecutionJournal(input) {
+    return input.startup.initializeAfterLeaseProtection(input.config.agentsRoot, async (snapshot) => {
+        input.protectedExecutionIds.clear();
+        for (const executionId of snapshot)
+            input.protectedExecutionIds.add(executionId);
+        const journal = input.injectedJournal ?? createExecutionJournal(input.config.agentsRoot, {
+            protectedExecutionIds: () => input.protectedExecutionIds,
+        });
+        await reconcileExecutionJournal(journal, {
+            agentsRoot: input.config.agentsRoot,
+            serverUrl: input.config.serverUrl,
+            ...(input.profileName === undefined ? {} : { profileName: input.profileName }),
+            log: dslog,
+            flush: flushSlog,
+            writeStderr: (line) => process.stderr.write(line),
+        });
+        return journal;
+    });
+}

package/dist/project-skills/types.js

@@ -1,4 +1,5 @@
 export const PROJECT_SKILLS_CAPABILITY = "project_skills_v1";
+export const PROJECT_SKILL_PROJECTION_V2_CAPABILITY = "project_skill_projection_v2";
 export const MAX_PROJECT_ID_LENGTH = 64;
 export const MAX_PROJECT_SKILL_NAME_LENGTH = 128;
 export const MAX_PROJECT_SKILL_DESCRIPTION_LENGTH = 1_000;

package/dist/provider-env.js

@@ -49,6 +49,9 @@ export function applyProviderEnv(base, runtime, cfg, homeDir) {
             env[DEEPSEEK_CODEX_KEY_ENV] = cfg.providerApiKey;
         return env;
     }
+    if (runtime === "codex") {
+        return { ...base, CODEX_HOME: join(homeDir, ".codex") };
+    }
     if (runtime !== "claude" || cfg.provider !== "custom")
         return base;
     const env = { ...base };

package/dist/runtimes/codex-home.js

@@ -0,0 +1,50 @@
+import { chmod, lstat, mkdir, symlink } from "node:fs/promises";
+import { join, resolve } from "node:path";
+const PRIVATE_CODEX_HOME = ".codex";
+const SHARED_CODEX_ENTRIES = [
+    { name: "auth.json", type: "file" },
+    { name: "sessions", type: "dir" },
+    { name: "session_index.jsonl", type: "file" },
+];
+export function defaultCodexHome(homeDir) {
+    return resolve(homeDir, PRIVATE_CODEX_HOME);
+}
+async function linkIfMissing(source, target, type) {
+    try {
+        await lstat(target);
+        return;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    try {
+        await lstat(source);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    try {
+        await symlink(source, target, type);
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+    }
+}
+/**
+ * Isolate Codex's high-volume runtime state per Agent while preserving the
+ * machine login and native resume files used by existing sessions.
+ */
+export async function materializeDefaultCodexHome(agentHome, sourceHome) {
+    const codexHome = defaultCodexHome(agentHome);
+    await mkdir(codexHome, { recursive: true, mode: 0o700 });
+    await chmod(codexHome, 0o700);
+    const source = sourceHome === undefined ? null : resolve(sourceHome);
+    if (source === null || source === codexHome)
+        return codexHome;
+    await Promise.all(SHARED_CODEX_ENTRIES.map(({ name, type }) => linkIfMissing(join(source, name), join(codexHome, name), type)));
+    return codexHome;
+}

package/dist/serve.js

@@ -8,7 +8,7 @@ import { randomUUID } from "node:crypto";
 import { initSlog, dslog, setSlogDefaults, drainSpool, flushSlog } from "./slog.js";
 import { mergeRunAgentResults, reportScheduledStartFailure, runAgent } from "./runner.js";
 import { buildOriginDecisionRetryPrompt, buildScheduledPrompt } from "./prompt.js";
-import { collectMachineHello, cliVersion, daemonCapabilityBindings, daemonVersion, detectExecutionRuntimesWithSignal, } from "./machine-info.js";
+import { collectMachineHello, cliVersion, daemonCapabilities, daemonVersion, detectExecutionRuntimesWithSignal, } from "./machine-info.js";
 import { conservativeExecutionRuntimes, createRuntimeProbeCoordinator, } from "./runtime-probe.js";
 import { listWorkspace, readWorkspaceFile } from "./workspace-fs.js";
 import { listSkills } from "./skills.js";
@@ -18,14 +18,12 @@ import { normalizeScheduledContext } from "./scheduled-report.js";
 import { formatDaemonLogLine } from "./log-format.js";
 import { reportAgentRunComplete } from "./scheduled-run-report.js";
 import { runWithOriginDecisionGuard } from "./origin-decision.js";
-import { createExecutionJournal } from "./execution-journal.js";
 import { createExecutionTelemetryJournal } from "./execution-telemetry-journal.js";
 import { ExecutionRejectedSchema, ExecutionSnapshotSchema, LegacyAgentStartSchema, ServerToDaemonExecutionFrameSchema, } from "./execution-protocol.js";
 import { hashExecutionSpec, projectWorkspaceCapabilityRejection, runExecution, } from "./execution-runner.js";
 import { awaitWithCancellation, createRuntimeCancellation, RuntimeCancelledError, } from "./runtime-cancellation.js";
 import { createShutdownDeadline, readTestShutdownConfiguration } from "./shutdown-deadline.js";
 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 { createAgentMemoryBridge } from "./agent-memory/bridge.js";
@@ -39,6 +37,10 @@ import { createProjectRegistry } from "./project-skills/registry.js";
 import { createProjectSkillsController, } from "./project-skills/controller.js";
 import { PROJECT_SKILLS_CAPABILITY } from "./project-skills/types.js";
 import { createAgentProjectionCoordinator } from "./project-skills/agent-projection-coordinator.js";
+import { createProjectSkillRuntimeRootStartup, } from "./project-skills/runtime-root-startup.js";
+import { createProjectSkillControllerReadiness, withProjectSkillCapabilityStatus } from "./project-skills/capability.js";
+import { initializeProjectSkillProtectedExecutionJournal } from "./project-skills/serve-startup.js";
+import { createProjectSkillConnectionCapabilityProvider, createProjectSkillMachineHelloPublisher } from "./project-skills/serve-capability.js";
 import { createAgentAbilityRuntime } from "./agent-ability/runtime.js";
 import { createProjectSkillsReconciler, } from "./project-skills/reconciler.js";
 import { initializedProjectSkillsReconciler } from "./project-skills/initialized-reconciler.js";
@@ -65,7 +67,9 @@ export function serve(config, opts = {}) {
     const createWebSocket = opts.createWebSocket ?? ((url) => new WebSocket(url));
     let reconnectTimer = null;
     let stopPromise = null;
-    const executionJournal = opts.execution?.journal ?? createExecutionJournal(config.agentsRoot);
+    let executionJournal;
+    const injectedExecutionJournal = opts.execution?.journal;
+    const protectedExecutionIds = new Set();
     const agentMemory = opts.execution?.dependencies?.agentMemory
         ?? (config.agentMemory === null ? undefined : createAgentMemoryBridge(config.agentMemory));
     const executionTelemetry = createExecutionTelemetryJournal(config.agentsRoot);
@@ -126,6 +130,7 @@ export function serve(config, opts = {}) {
         agentsRoot: config.agentsRoot,
         coordinator: projectionCoordinator,
         scannedProjects: () => projectSkillsController.scannedProjects(),
+        protectedExecutionIds,
     });
     projectSkillsController = opts.projectSkills?.controller ?? createProjectSkillsController({
         registry: createProjectRegistry(config.agentsRoot),
@@ -139,53 +144,34 @@ export function serve(config, opts = {}) {
             catch { /* 下一次 ready 或项目操作会重新发送完整快照 */ }
         },
         reconcile: (handle, bindings) => projectSkillsReconciler.reconcile(handle, bindings),
-        ensureSnapshot: (handle, snapshot) => projectSkillsReconciler.ensureSnapshot(handle, snapshot),
+        ensureSnapshot: (handle, snapshot, options) => projectSkillsReconciler.ensureSnapshot(handle, snapshot, options),
     });
-    let projectSkillsStatus = "initializing";
-    let projectSkillsInitialization = null;
-    let latestMachineHello = null;
-    let latestHelloSocket = null;
-    const effectiveMachineHello = (hello) => ({
-        ...hello,
-        projectSkillsStatus,
-        capabilities: projectSkillsStatus === "ready"
-            ? hello.capabilities
-            : hello.capabilities.filter((capability) => capability !== PROJECT_SKILLS_CAPABILITY),
+    const projectSkillRuntimeRootStartup = opts.projectSkills?.runtimeRootStartup
+        ?? createProjectSkillRuntimeRootStartup();
+    const projectSkillControllerReadiness = createProjectSkillControllerReadiness({
+        initialize: () => projectSkillsController.initialize(),
+        onUnavailable: (error) => dslog("project_skills.registry_failed", "本机项目注册表读取失败", {
+            level: "ERROR", error_code: error.code ?? "project_registry_corrupt",
+        }),
+        onSettled: () => machineHelloPublisher.republish(),
+    });
+    const machineHelloPublisher = createProjectSkillMachineHelloPublisher({
+        status: projectSkillControllerReadiness.status,
+        effective: withProjectSkillCapabilityStatus,
+        onSent: (hello) => log(`📤 已上报机器信息: ${hello.hostname} · ${hello.os} · installed=[${hello.runtimes.join(",")}] · executable=[${hello.executionRuntimes.join(",")}] · agents=[${hello.agentHandles.join(",")}]`),
+    });
+    const initializedProjectSkills = initializedProjectSkillsReconciler(projectSkillControllerReadiness.ensure, projectSkillsReconciler);
+    const prepareProjectSkillCapabilities = createProjectSkillConnectionCapabilityProvider({
+        platform: process.platform,
+        baseCapabilities: opts.machineInfo?.capabilities ?? daemonCapabilities(process.platform),
+        additionalCapabilities: () => managedDaemonCapabilities(updateEligibility),
+        probeRuntimeRootStorePrimitive: projectSkillRuntimeRootStartup.probeNativePublicationPrimitiveReadiness,
+        initializeController: projectSkillControllerReadiness.ensure,
+        recoverRuntimeRootsAndLeases: async () => projectSkillRuntimeRootStartup
+            .recover(config.agentsRoot, executionJournal, protectedExecutionIds)
+            .then(() => true, () => false),
+        applyReadiness: projectSkillControllerReadiness.applyPreflight,
     });
-    const sendEffectiveMachineHello = () => {
-        if (latestMachineHello === null || latestHelloSocket?.readyState !== WebSocket.OPEN)
-            return;
-        const hello = effectiveMachineHello(latestMachineHello);
-        try {
-            latestHelloSocket.send(JSON.stringify(hello));
-            log(`📤 已上报机器信息: ${hello.hostname} · ${hello.os} · installed=[${hello.runtimes.join(",")}] · executable=[${hello.executionRuntimes.join(",")}] · agents=[${hello.agentHandles.join(",")}]`);
-        }
-        catch { /* 非 OPEN,忽略 */ }
-    };
-    const ensureProjectSkillsInitialized = () => {
-        if (projectSkillsStatus === "ready")
-            return Promise.resolve(true);
-        if (projectSkillsInitialization !== null)
-            return projectSkillsInitialization;
-        projectSkillsStatus = "initializing";
-        const attempt = projectSkillsController.initialize().then(() => {
-            projectSkillsStatus = "ready";
-            return true;
-        }, (error) => {
-            projectSkillsStatus = "unavailable";
-            dslog("project_skills.registry_failed", "本机项目注册表读取失败", {
-                level: "ERROR", error_code: error.code ?? "project_registry_corrupt",
-            });
-            return false;
-        }).finally(() => {
-            if (projectSkillsInitialization === attempt)
-                projectSkillsInitialization = null;
-            sendEffectiveMachineHello();
-        });
-        projectSkillsInitialization = attempt;
-        return attempt;
-    };
-    const initializedProjectSkills = initializedProjectSkillsReconciler(ensureProjectSkillsInitialized, projectSkillsReconciler);
     const safeExecutionSend = (frame) => {
         try {
             if (ws?.readyState !== WebSocket.OPEN)
@@ -283,7 +269,6 @@ export function serve(config, opts = {}) {
             reservation.release();
     };
     let connectedAt = 0; // 本次 WS 连接建立时刻(断开日志算在线时长用)
-    const capabilities = daemonCapabilityBindings(process.platform, opts.machineInfo?.capabilities);
     initSlog(config.serverUrl, config.machineToken, { daemonVersion: daemonVersion(), cliVersion: cliVersion(), ...(opts.profileName === undefined ? {} : { profileName: opts.profileName }), agentsRoot: config.agentsRoot });
     dslog("daemon.start", "daemon 常驻模式启动", { server_url: config.serverUrl, runtime: config.runtimeBin });
     // 并行调度:同一 agent 可并行处理多个【不同任务】(线程/频道),每任务隔离 cwd+work-log。
@@ -293,12 +278,17 @@ export function serve(config, opts = {}) {
     const activeExecutionTaskKeys = new Map();
     const legacyTaskTails = new Map();
     const log = (s) => process.stdout.write(formatDaemonLogLine(s) + "\n");
-    function connect() {
+    async function connect() {
         if (stopped)
             return;
-        const wsUrl = buildControlPlaneUrl(config.serverUrl, config.machineToken, process.platform, undefined, projectSkillsStatus === "ready", capabilities.controlPlaneUrl);
+        const capabilities = await prepareProjectSkillCapabilities();
+        if (stopped)
+            return;
+        const wsUrl = (opts.buildControlPlaneUrl ?? buildControlPlaneUrl)(config.serverUrl, config.machineToken, process.platform, undefined, projectSkillControllerReadiness.status() === "ready", capabilities.controlPlaneUrl);
         ws = createWebSocket(wsUrl);
+        let connectionEpochToken;
         ws.on("open", () => {
+            connectionEpochToken = projectSkillsController.beginConnectionEpoch();
             const openedSocket = ws;
             backoff = 1000;
             connectedAt = Date.now();
@@ -308,12 +298,11 @@ export function serve(config, opts = {}) {
             void drainSpool();
             // 上报本机信息 (hostname/os/daemon 版本/已装 runtimes)
             const { detectInstalled, detectExecutable = detectExecutionRuntimesWithSignal } = opts.machineInfo ?? {};
-            const helloPromise = collectMachineHello(config.agentsRoot, config.executionLimits, process.platform, {
+            const helloPromise = (opts.machineInfo?.collect ?? collectMachineHello)(config.agentsRoot, config.executionLimits, process.platform, {
                 ...(detectInstalled ? { detectInstalled } : {}),
                 ...(opts.profileName === undefined ? {} : { profileName: opts.profileName }),
                 // First hello must not wait for third-party handshakes; optional transports arrive in the refresh.
                 detectExecutable: async (installed) => conservativeExecutionRuntimes(installed),
-                additionalCapabilities: () => managedDaemonCapabilities(updateEligibility),
                 capabilities: capabilities.machineHello,
             });
             runtimeFacts = helloPromise
@@ -324,9 +313,7 @@ export function serve(config, opts = {}) {
                 if (ws === openedSocket && openedSocket.readyState === WebSocket.OPEN
                     && detected.some((runtime) => !hello.executionRuntimes.includes(runtime))) {
                     detectedExecutionRuntimes = detected;
-                    latestMachineHello = { ...hello, executionRuntimes: [...detected] };
-                    latestHelloSocket = openedSocket;
-                    sendEffectiveMachineHello();
+                    machineHelloPublisher.publish({ ...hello, executionRuntimes: [...detected] }, openedSocket);
                 }
                 return detected;
             })
@@ -341,9 +328,7 @@ export function serve(config, opts = {}) {
                 if (ws !== openedSocket || openedSocket.readyState !== WebSocket.OPEN)
                     return;
                 detectedExecutionRuntimes = hello.executionRuntimes;
-                latestMachineHello = hello;
-                latestHelloSocket = openedSocket;
-                sendEffectiveMachineHello();
+                machineHelloPublisher.publish(hello, openedSocket);
             })
                 .catch(() => { });
             opts.onOpen?.(ws);
@@ -678,7 +663,7 @@ export function serve(config, opts = {}) {
                     ? r.serverCapabilities.filter((c) => typeof c === "string")
                     : []);
                 if (serverCapabilities.has(PROJECT_SKILLS_CAPABILITY)) {
-                    if (await ensureProjectSkillsInitialized())
+                    if (await projectSkillControllerReadiness.ensure())
                         await projectSkillsController.publishCurrent();
                 }
                 return;
@@ -700,11 +685,11 @@ export function serve(config, opts = {}) {
                 if (typeof request.reqId !== "string")
                     return;
                 const result = serverCapabilities.has(PROJECT_SKILLS_CAPABILITY)
-                    ? await projectSkillsController.handle(msg)
+                    ? await projectSkillsController.handle(msg, connectionEpochToken)
                     : { ok: false, error: "capability_unavailable" };
                 if (result.ok && (msg.type === "project:remove"
                     || msg.type === "project:rescan")) {
-                    void ensureProjectSkillsInitialized();
+                    void projectSkillControllerReadiness.ensure();
                 }
                 try {
                     ws?.send(JSON.stringify({ type: "fs:result", reqId: request.reqId, ...result }));
@@ -1130,7 +1115,7 @@ export function serve(config, opts = {}) {
             void flushSlog();
             reconnectTimer = setTimeout(() => {
                 reconnectTimer = null;
-                connect();
+                void connect();
             }, backoff);
             backoff = Math.min(backoff * 2, maxBackoff);
         });
@@ -1140,16 +1125,14 @@ export function serve(config, opts = {}) {
         });
     }
     const ready = (async () => {
-        await reconcileExecutionJournal(executionJournal, {
-            agentsRoot: config.agentsRoot,
-            serverUrl: config.serverUrl,
+        executionJournal = await initializeProjectSkillProtectedExecutionJournal({
+            config,
             ...(opts.profileName === undefined ? {} : { profileName: opts.profileName }),
-            log: dslog,
-            flush: flushSlog,
-            writeStderr: (line) => process.stderr.write(line),
+            startup: projectSkillRuntimeRootStartup,
+            protectedExecutionIds,
+            ...(injectedExecutionJournal === undefined ? {} : { injectedJournal: injectedExecutionJournal }),
         });
-        void ensureProjectSkillsInitialized();
-        connect();
+        await connect();
     })();
     const stop = () => {
         if (stopPromise !== null)
@@ -1180,7 +1163,9 @@ export function serve(config, opts = {}) {
                     run.controller.request();
                 await deadline.waitFor(Promise.all(pending));
                 await deadline.waitFor(hostCoordinator.drain());
-                await executionJournal.close({ signal: deadline.signal });
+                if (executionJournal !== undefined) {
+                    await executionJournal.close({ signal: deadline.signal });
+                }
             }
             finally {
                 deadline.dispose();

package/dist/supervised-runtime.js

@@ -1,5 +1,4 @@
 import { fileURLToPath } from "node:url";
-import { join } from "node:path";
 import { startDormantSupervisor, } from "./execution-supervisor.js";
 import { buildClaudeArgs } from "./runtimes/claude.js";
 import { DEEPSEEK_HARNESS_CONFIG_ENV, deepSeekHarnessConfigPath, } from "./runtimes/deepseek-harness.js";
@@ -13,10 +12,7 @@ export function supervisorLaunch(request) {
         ...(request.reasoning === undefined ? {} : { reasoning: request.reasoning }),
     };
     if (request.runtime === "claude") {
-        const additionalDirectories = request.claudeAdditionalDirectories
-            ?? (request.agentRoot === undefined
-                ? undefined
-                : [join(request.agentRoot, ".crew", "claude-skills"), request.agentRoot]);
+        const additionalDirectories = request.claudeAdditionalDirectories;
         return {
             command: request.bin,
             args: buildClaudeArgs({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.6.18",
+  "version": "0.6.20",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -25,7 +25,7 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.2.1",
-    "@nowcrew/cli": "^0.4.14",
+    "@nowcrew/cli": "^0.4.13",
     "cross-spawn": "^7.0.6",
     "ws": "^8",
     "yaml": "^2.8.1",