@nowcrew/daemon 0.6.101-beta.3 → 0.6.101-beta.4

package/dist/execution-journal-lock.js

@@ -3,10 +3,25 @@ import { renameSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { join, resolve } from "node:path";
 import { z } from "zod";
+const ProtectedGroupSchema = z.object({ pid: z.number().int().positive(), processIdentity: z.string().min(1) }).strict();
+export async function inspectProtectedProcessGroup(pid) {
+    try {
+        process.kill(-pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ESRCH")
+            return false;
+        if (error.code === "EPERM")
+            return true;
+        throw error;
+    }
+}
 const OwnerSchema = z.object({
     pid: z.number().int().positive(),
     processIdentity: z.string().min(1),
     token: z.string().uuid(),
+    protectedGroup: ProtectedGroupSchema.optional(),
 }).strict();
 export class JournalLockedError extends Error {
     journalPath;
@@ -144,7 +159,8 @@ export async function inspectJournalLock(options) {
         let inspection;
         try {
             const identity = await options.inspectIdentity(owner.pid);
-            inspection = identity === owner.processIdentity
+            const protectedAlive = owner.protectedGroup !== undefined && await (options.inspectProcessGroup ?? inspectProtectedProcessGroup)(owner.protectedGroup.pid);
+            inspection = identity === owner.processIdentity || protectedAlive
                 ? {
                     status: "owned",
                     ownerPid: owner.pid,
@@ -333,7 +349,9 @@ export function createJournalLease(options) {
                 if (observed === null)
                     continue;
                 const identity = await options.inspectIdentity(observed.owner.pid);
-                if (identity === observed.owner.processIdentity) {
+                const protectedAlive = observed.owner.protectedGroup !== undefined
+                    && await (options.inspectProcessGroup ?? inspectProtectedProcessGroup)(observed.owner.protectedGroup.pid);
+                if (identity === observed.owner.processIdentity || protectedAlive) {
                     throw new JournalLockedError(`Execution journal is locked by process ${observed.owner.pid}`, { journalPath, ownerPid: observed.owner.pid });
                 }
                 await options.hooks?.beforeRemoveObservedOwner?.(observed.owner);
@@ -408,6 +426,9 @@ export function createJournalLease(options) {
             status = "closed";
             return;
         }
+        if (lease.owner.protectedGroup && await (options.inspectProcessGroup ?? inspectProtectedProcessGroup)(lease.owner.protectedGroup.pid)) {
+            throw new JournalLockedError("Protected maintenance process group is still alive", { journalPath, ownerPid: lease.owner.protectedGroup.pid });
+        }
         status = "closing";
         lease.releasing = true;
         await awaitAbortable((async () => {
@@ -426,8 +447,36 @@ export function createJournalLease(options) {
         status = "closed";
         void cleanupReleasedDirectory(releasedDirectory);
     };
+    const protectProcessGroup = async (raw) => {
+        const group = ProtectedGroupSchema.parse(raw);
+        const lease = registry.get(options.directory);
+        if (!attached || status !== "open" || !lease || lease.releasing || lease.refs !== 1)
+            throw new JournalLockedError("Lease cannot protect a worker", { journalPath });
+        await validateInstalledOwner(lease);
+        if (await options.inspectIdentity(group.pid) !== group.processIdentity
+            || !await (options.inspectProcessGroup ?? inspectProtectedProcessGroup)(group.pid))
+            throw new JournalLockedError("Worker identity is absent", { journalPath });
+        if (lease.owner.protectedGroup) {
+            if (JSON.stringify(lease.owner.protectedGroup) === JSON.stringify(group))
+                return;
+            throw new JournalLockedError("Lease already protects a worker", { journalPath });
+        }
+        const owner = { ...lease.owner, protectedGroup: group };
+        const temp = join(options.directory, `.journal-owner.${lease.owner.token}.${randomUUID()}.tmp`);
+        try {
+            await fileSystem.writeDurableFile(temp, `${JSON.stringify(owner)}\n`);
+            await fileSystem.rename(temp, join(lockDirectory, lease.ownerFile));
+            lease.owner = owner;
+            await options.syncDirectory(lockDirectory);
+            await options.syncDirectory(options.directory);
+        }
+        finally {
+            await fileSystem.rm(temp, { force: true }).catch(() => undefined);
+        }
+    };
     return {
         acquire,
+        protectProcessGroup,
         assertUsable: () => {
             if (status !== "open") {
                 throw new JournalLockedError(`Execution journal lease is ${status}`, { journalPath });

package/dist/host-execution-coordinator.js

@@ -302,6 +302,16 @@ export function createHostExecutionCoordinator(options = {}) {
             }
             let releasePromise = null;
             return {
+                protectProcessGroup: async (pid) => {
+                    const processIdentity = await defaultProcessController.inspectIdentity(pid);
+                    if (processIdentity === null)
+                        throw new Error("maintenance worker identity is absent");
+                    for (const lease of leases) {
+                        if (!lease.protectProcessGroup)
+                            throw new Error("lease process-group protection is unavailable");
+                        await lease.protectProcessGroup({ pid, processIdentity });
+                    }
+                },
                 release: () => {
                     if (releasePromise !== null)
                         return releasePromise;

package/dist/machine-info.js

@@ -1,3 +1,4 @@
+import { RUNTIME_TOOL_UPDATES_CAPABILITY } from "./runtime-tool-update-protocol.js";
 import { MAINTENANCE_CAPABILITY } from "./marketplace-maintenance-protocol.js";
 import { retryHarnessProbe } from "./runtimes/harness-probe-retry.js";
 import { MARKETPLACE_CAPABILITY } from "./marketplace-protocol.js";
@@ -40,6 +41,7 @@ export const NATIVE_PROJECT_WORKSPACE_READINESS = Object.freeze({
     nativeRuntimeAdaptersReady: true,
 });
 export const DAEMON_CAPABILITIES = Object.freeze([
+    RUNTIME_TOOL_UPDATES_CAPABILITY,
     MARKETPLACE_CAPABILITY,
     MAINTENANCE_CAPABILITY,
     "scheduled_job_v1",
@@ -74,7 +76,7 @@ export const daemonCapabilities = (runtimePlatform = process.platform, readiness
     const nativeWorkspaceReady = nativeWorkspacePlatform
         && readiness.resolverReady
         && readiness.nativeRuntimeAdaptersReady;
-    return Object.freeze(DAEMON_CAPABILITIES.filter((capability) => (((capability !== MARKETPLACE_CAPABILITY && capability !== MAINTENANCE_CAPABILITY) || nativeWorkspacePlatform)
+    return Object.freeze(DAEMON_CAPABILITIES.filter((capability) => (((capability !== MARKETPLACE_CAPABILITY && capability !== MAINTENANCE_CAPABILITY && capability !== RUNTIME_TOOL_UPDATES_CAPABILITY) || nativeWorkspacePlatform)
         && (capability !== PROJECT_WORKSPACES_CAPABILITY || nativeWorkspaceReady)
         && (capability !== "message_file_preview_v1" || nativeWorkspacePlatform)
         && (nativeWorkspacePlatform

package/dist/machine-runtime-environment.js

@@ -138,6 +138,7 @@ export function createMachineRuntimeEnvironment(options) {
     };
     return {
         provider,
+        refresh: refreshRuntimes,
         prewarm: () => {
             if (stopped || warmed)
                 return;

package/dist/runtime-tool-update-bridge.js

@@ -0,0 +1,126 @@
+import { createHash } from "node:crypto";
+import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+import { RuntimeToolResponseSchema } from "./runtime-tool-update-protocol.js";
+export function runtimeToolEnvironment(env) {
+    // Keep only machine identity and lookup settings. Never pass runtime/control-plane credentials or Node injection flags.
+    return Object.fromEntries(Object.entries(env).filter(([key]) => /^(PATH|HOME|USER|LOGNAME|SHELL|TMPDIR|TMP|TEMP|LANG|LC_[A-Z_]+|XDG_CONFIG_HOME|XDG_CACHE_HOME)$/u.test(key)));
+}
+async function readReport(dir) {
+    const file = join(dir, "report.json");
+    if ((await stat(file)).size > 256_000)
+        throw new Error("invalid_report");
+    return RuntimeToolResponseSchema.parse(JSON.parse(await readFile(file, "utf8")));
+}
+async function stopGroup(pid) {
+    if (!pid)
+        return true;
+    try {
+        process.kill(-pid, "SIGKILL");
+    }
+    catch (error) {
+        return error.code === "ESRCH";
+    }
+    const deadline = Date.now() + 3000;
+    while (Date.now() < deadline) {
+        try {
+            process.kill(-pid, 0);
+        }
+        catch (error) {
+            return error.code === "ESRCH";
+        }
+        await new Promise(resolve => setTimeout(resolve, 50));
+    }
+    return false;
+}
+export function createRuntimeToolProgressPoller(read, progress, intervalMs = 250) {
+    let active = true;
+    let pending = null;
+    const interval = setInterval(() => {
+        if (!active || pending || !progress)
+            return;
+        pending = read().then(async (data) => { if (active)
+            await progress(data); })
+            .catch(() => { }).finally(() => { pending = null; });
+    }, intervalMs);
+    return { async stop() { active = false; clearInterval(interval); await pending; } };
+}
+async function supervise(dir, env, start, progress, protectProcessGroup) {
+    const child = spawn(process.execPath, [join(dir, "runner.mjs"), "--managed-worker"], { cwd: dir, env, detached: true, stdio: ["ignore", "ignore", "ignore", "ipc"] });
+    const closed = new Promise(resolve => { child.once("error", () => resolve(null)); child.once("close", resolve); });
+    const polling = createRuntimeToolProgressPoller(() => readReport(dir), progress);
+    let expired = false;
+    const timer = setTimeout(() => { expired = true; void stopGroup(child.pid); }, start ? 12 * 60_000 : 120_000);
+    let launchFailed = false;
+    try {
+        if (start) {
+            if (!protectProcessGroup || !child.pid)
+                throw new Error("lease_protection_unavailable");
+            await protectProcessGroup(child.pid);
+        }
+        await new Promise((resolve, reject) => child.send({ type: "runtime-tools:go" }, error => error ? reject(error) : resolve()));
+    }
+    catch {
+        launchFailed = true;
+        await stopGroup(child.pid);
+    }
+    const code = await closed;
+    clearTimeout(timer);
+    await polling.stop();
+    // A successful parent exit does not prove its package-manager descendants stopped.
+    const stopped = await stopGroup(child.pid);
+    return { stopped, success: stopped && !expired && !launchFailed && code === 0 };
+}
+export async function runRuntimeToolBridge(config, request, acquireEnv, progress, deps = {}) {
+    let dir;
+    let started = false;
+    let processStopped = true;
+    const failure = (errorCode) => ({ processStopped, data: request.action === "start" ? { operation: {
+                operationId: request.operationId, state: started ? "unknown" : "failed", currentIndex: 0, targets: request.targets,
+                items: request.targets.map(t => ({ runtime: t.installation.runtime, state: started ? "unknown" : "failed", errorCode })),
+                updatedAt: new Date().toISOString(), errorCode,
+            } } : {} });
+    try {
+        const response = await (deps.fetch ?? fetch)(`${config.serverUrl.replace(/\/+$/, "")}/machine/runtime-tool-updates/runner/${request.runner.releaseId}`, {
+            headers: { authorization: `Bearer ${config.machineToken}` }, redirect: "error", signal: AbortSignal.timeout(15_000),
+        });
+        if (!response.ok || !response.body)
+            return failure("runner_unavailable");
+        const chunks = [];
+        let bytes = 0;
+        for await (const chunk of response.body) {
+            bytes += chunk.length;
+            if (bytes > 512_000)
+                return failure("runner_unavailable");
+            chunks.push(chunk);
+        }
+        const content = Buffer.concat(chunks);
+        if (createHash("sha256").update(content).digest("hex") !== request.runner.sha256)
+            return failure("runner_unavailable");
+        const env = runtimeToolEnvironment(await acquireEnv());
+        dir = await mkdtemp(join(tmpdir(), "nowwork-runtime-update-"));
+        await writeFile(join(dir, "runner.mjs"), content, { mode: 0o600 });
+        await writeFile(join(dir, "request.json"), JSON.stringify(request), { mode: 0o600 });
+        started = true;
+        processStopped = false;
+        const outcome = await supervise(dir, env, request.action === "start", progress, deps.protectProcessGroup);
+        processStopped = outcome.stopped;
+        if (!outcome.success)
+            return failure("operation_unknown");
+        const data = await readReport(dir);
+        if (request.action === "start" && data.operation?.operationId !== request.operationId)
+            return failure("operation_unknown");
+        if (request.action === "inspect" && !data.snapshot)
+            return failure("inspection_failed");
+        return { data, processStopped };
+    }
+    catch {
+        return failure(started ? "operation_unknown" : "runner_unavailable");
+    }
+    finally {
+        if (dir && processStopped)
+            await rm(dir, { recursive: true, force: true });
+    }
+}

package/dist/runtime-tool-update-controller.js

@@ -0,0 +1,151 @@
+import { RuntimeToolRequestSchema, RuntimeToolResponseSchema } from "./runtime-tool-update-protocol.js";
+const finalStates = new Set(["completed", "failed", "unknown", "cancelled"]);
+const phaseRank = (state) => ({ queued: 0, preflight: 1, installing: 2, verifying: 3, completed: 4, failed: 4, unknown: 4, cancelled: 4 })[state];
+function advancesProgress(previous, next) {
+    if (finalStates.has(previous.state) || finalStates.has(next.state)
+        || next.operationId !== previous.operationId || JSON.stringify(next.targets) !== JSON.stringify(previous.targets)
+        || next.currentIndex < previous.currentIndex || next.currentIndex >= previous.targets.length
+        || (next.currentIndex === previous.currentIndex && phaseRank(next.state) < phaseRank(previous.state)))
+        return false;
+    return previous.items.every((item, index) => {
+        const candidate = next.items[index];
+        if (!candidate || candidate.runtime !== item.runtime)
+            return false;
+        return finalStates.has(item.state) ? candidate.state === item.state && candidate.errorCode === item.errorCode
+            : phaseRank(candidate.state) >= phaseRank(item.state);
+    });
+}
+export function createRuntimeToolUpdateController(deps) {
+    const entries = new Map();
+    let current = null;
+    let stopped = false;
+    let orphaned = false;
+    const now = deps.now ?? Date.now;
+    const date = () => new Date(now()).toISOString();
+    const wait = deps.wait ?? (() => new Promise(resolve => setTimeout(resolve, 500)));
+    const fail = (error) => ({ ok: false, error });
+    const result = (data) => ({ ok: true, data });
+    const set = (entry, patch) => { entry.operation = { ...entry.operation, ...patch, updatedAt: date() }; };
+    async function execute(entry) {
+        const deadline = now() + 10 * 60_000;
+        let acceptingProgress = false;
+        let lease = null;
+        try {
+            while (!stopped && entry.operation.state === "queued" && now() < deadline && !lease) {
+                lease = await deps.acquire();
+                if (!lease)
+                    await wait();
+            }
+            if (entry.operation.state === "cancelled")
+                return;
+            if (!lease || stopped || now() >= deadline) {
+                set(entry, { state: "failed", errorCode: "runtime_busy" });
+                return;
+            }
+            set(entry, { state: "preflight" });
+            // Mark unsafe before spawning: an exception or lost response cannot authorize another writer.
+            entry.processStopped = false;
+            acceptingProgress = true;
+            const output = await deps.run(entry.request, raw => {
+                if (!acceptingProgress)
+                    return;
+                const parsed = RuntimeToolResponseSchema.safeParse(raw);
+                if (parsed.success && parsed.data.operation && advancesProgress(entry.operation, parsed.data.operation))
+                    entry.operation = parsed.data.operation;
+            }, lease.protectProcessGroup);
+            acceptingProgress = false;
+            const data = RuntimeToolResponseSchema.parse(output.data);
+            entry.processStopped = output.processStopped;
+            if (!data.operation || data.operation.operationId !== entry.operation.operationId
+                || JSON.stringify(data.operation.targets) !== JSON.stringify(entry.request.targets)
+                || data.operation.currentIndex < entry.operation.currentIndex || !finalStates.has(data.operation.state))
+                throw new Error("operation_mismatch");
+            entry.operation = data.operation;
+            if (!entry.processStopped)
+                set(entry, { state: "unknown", errorCode: "operation_unknown" });
+        }
+        catch {
+            acceptingProgress = false;
+            set(entry, { state: "unknown", errorCode: "operation_unknown" });
+        }
+        finally {
+            acceptingProgress = false;
+            // Retain the barrier if process-group termination could not be proved.
+            if (entry.processStopped) {
+                try {
+                    await lease?.release();
+                }
+                catch {
+                    entry.processStopped = false;
+                    set(entry, { state: "unknown", errorCode: "operation_unknown" });
+                }
+            }
+        }
+    }
+    return {
+        async handle(raw) {
+            const parsed = RuntimeToolRequestSchema.safeParse(raw);
+            if (!parsed.success || stopped)
+                return fail("invalid_request");
+            const request = parsed.data;
+            if (request.action === "inspect") {
+                try {
+                    const data = RuntimeToolResponseSchema.parse((await deps.run(request)).data);
+                    return data.snapshot ? result(data) : fail("inspection_failed");
+                }
+                catch {
+                    return fail("inspection_failed");
+                }
+            }
+            const entry = entries.get(request.operationId);
+            if (request.action === "start") {
+                if (entry)
+                    return result({ operation: entry.operation });
+                if (orphaned || [...entries.values()].some(x => x.operation.state === "unknown"))
+                    return fail("operation_unknown");
+                if (current)
+                    return fail("runtime_busy");
+                if (entries.size >= 100)
+                    return fail("operation_limit");
+                if (new Set(request.targets.map(t => t.installation.runtime)).size !== request.targets.length)
+                    return fail("invalid_request");
+                const operation = { operationId: request.operationId, state: "queued", currentIndex: 0, targets: request.targets,
+                    items: request.targets.map(t => ({ runtime: t.installation.runtime, state: "queued", errorCode: null })), updatedAt: date(), errorCode: null };
+                const next = { operation, request, processStopped: true };
+                entries.set(request.operationId, next);
+                current = execute(next).finally(() => { current = null; });
+                return result({ operation });
+            }
+            if (!entry) {
+                orphaned = true;
+                return fail("operation_unknown");
+            }
+            if (request.action === "status")
+                return result({ operation: entry.operation });
+            if (request.action === "cancel") {
+                if (entry.operation.state !== "queued")
+                    return fail("already_started");
+                set(entry, { state: "cancelled", items: entry.operation.items.map(x => ({ ...x, state: "cancelled" })) });
+                return result({ operation: entry.operation });
+            }
+            if (!entry.processStopped || current)
+                return fail("operation_unknown");
+            try {
+                const output = await deps.run({ action: "inspect", runner: entry.request.runner });
+                const snapshot = RuntimeToolResponseSchema.parse(output.data).snapshot;
+                if (!snapshot || !output.processStopped)
+                    return fail("operation_unknown");
+                const matches = entry.operation.targets.every(target => snapshot.tools.some(tool => tool.runtime === target.installation.runtime
+                    && tool.version === target.targetVersion && tool.path === target.installation.path && tool.source === target.installation.source
+                    && tool.prefix === target.installation.prefix && tool.brewPath === target.installation.brewPath && tool.automatic));
+                set(entry, { state: matches ? "completed" : "failed", errorCode: matches ? null : "verification_failed", snapshot,
+                    items: entry.operation.items.map(x => ({ ...x, state: matches ? "completed" : "failed", errorCode: matches ? null : "verification_failed" })) });
+                return result({ operation: entry.operation, snapshot });
+            }
+            catch {
+                return fail("inspection_failed");
+            }
+        },
+        async stop() { stopped = true; await current; },
+    };
+}

package/dist/runtime-tool-update-protocol.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+export const RUNTIME_TOOL_UPDATES_CAPABILITY = "runtime_tool_updates_v1";
+const boundedPath = z.string().min(1).max(4096);
+export const RuntimeToolRunnerSchema = z.object({ releaseId: z.string().regex(/^[a-f0-9]{64}$/), sha256: z.string().regex(/^[a-f0-9]{64}$/) }).strict();
+export const RuntimeToolInstallationSchema = z.object({
+    runtime: z.enum(["codex", "claude"]), path: boundedPath, realPath: boundedPath,
+    version: z.string().max(100).nullable(), source: z.enum(["npm", "homebrew", "native", "unknown"]),
+    nodeVersion: z.string().max(100).nullable(), nodePath: boundedPath.nullable(), npmPath: boundedPath.nullable(), prefix: boundedPath.nullable(),
+    brewPath: boundedPath.nullable(), brewKind: z.enum(["formula", "cask"]).nullable(), brewName: z.enum(["codex", "claude-code"]).nullable(),
+    fingerprint: z.string().regex(/^[a-f0-9]{64}$/), alternatives: z.array(boundedPath).max(32), automatic: z.boolean(), reason: z.string().max(100).nullable(),
+}).strict();
+export const RuntimeToolSnapshotSchema = z.object({ checkedAt: z.string().datetime(), tools: z.array(RuntimeToolInstallationSchema).max(2) }).strict();
+export const RuntimeToolTargetSchema = z.object({ installation: RuntimeToolInstallationSchema, targetVersion: z.string().regex(/^\d+\.\d+\.\d+$/).max(100) }).strict();
+export const RuntimeToolStateSchema = z.enum(["queued", "preflight", "installing", "verifying", "completed", "failed", "unknown", "cancelled"]);
+export const RuntimeToolOperationSchema = z.object({ operationId: z.string().uuid(), state: RuntimeToolStateSchema, currentIndex: z.number().int().min(0).max(2),
+    targets: z.array(RuntimeToolTargetSchema).min(1).max(2), items: z.array(z.object({ runtime: z.enum(["codex", "claude"]), state: RuntimeToolStateSchema, errorCode: z.string().max(100).nullable() }).strict()).max(2),
+    updatedAt: z.string().datetime(), errorCode: z.string().max(100).nullable(), snapshot: RuntimeToolSnapshotSchema.optional(),
+}).strict();
+export const RuntimeToolRequestSchema = z.discriminatedUnion("action", [
+    z.object({ action: z.literal("inspect"), runner: RuntimeToolRunnerSchema }).strict(),
+    z.object({ action: z.literal("start"), operationId: z.string().uuid(), targets: z.array(RuntimeToolTargetSchema).min(1).max(2), runner: RuntimeToolRunnerSchema }).strict(),
+    ...["status", "cancel", "verify"].map(action => z.object({ action: z.literal(action), operationId: z.string().uuid() }).strict()),
+]);
+export const RuntimeToolResponseSchema = z.object({ snapshot: RuntimeToolSnapshotSchema.optional(), operation: RuntimeToolOperationSchema.optional() }).strict();

package/dist/runtime-tool-update-serve.js

@@ -0,0 +1,54 @@
+import { prepareDaemonRestart } from "./daemon-updater.js";
+import { createRuntimeToolUpdateController } from "./runtime-tool-update-controller.js";
+import { augmentedPath } from "./runtime-path.js";
+import { runRuntimeToolBridge } from "./runtime-tool-update-bridge.js";
+export async function acquireRuntimeToolLease(localSlots, host) {
+    const local = await prepareDaemonRestart({ localSlots });
+    if (!local.ok)
+        return null;
+    try {
+        const shared = await host.tryAcquireExclusiveExecution();
+        if (!shared) {
+            await local.release();
+            return null;
+        }
+        let released = false;
+        return { protectProcessGroup: async (pid) => {
+                if (!shared.protectProcessGroup)
+                    throw new Error("lease protection unavailable");
+                await shared.protectProcessGroup(pid);
+            }, async release() { if (released)
+                return; await shared.release(); await local.release(); released = true; } };
+    }
+    catch (error) {
+        await local.release();
+        throw error;
+    }
+}
+export function createServeRuntimeToolUpdates(config, localSlots, host, acquireEnv, refresh) {
+    const controller = createRuntimeToolUpdateController({ acquire: () => acquireRuntimeToolLease(localSlots, host),
+        run: async (request, progress, protectProcessGroup) => {
+            const result = await runRuntimeToolBridge(config, request, async () => {
+                const env = await acquireEnv();
+                return { ...env, PATH: augmentedPath(env, {}, process.platform, "append") };
+            }, progress, { ...(protectProcessGroup ? { protectProcessGroup } : {}) });
+            if (request.action === "start" && result.processStopped)
+                refresh();
+            return result;
+        } });
+    return {
+        handle(raw, send) {
+            if (!raw || typeof raw !== "object" || !("type" in raw) || raw.type !== "runtime-tools:operation")
+                return false;
+            const { reqId, type: _type, ...request } = raw;
+            if (typeof reqId === "string") {
+                if (process.platform !== "linux" && process.platform !== "darwin")
+                    send({ type: "fs:result", reqId, ok: false, error: "unsupported_platform" });
+                else
+                    void controller.handle(request).then(result => send({ type: "fs:result", reqId, ...result })).catch(() => send({ type: "fs:result", reqId, ok: false, error: "operation_unknown" }));
+            }
+            return true;
+        },
+        stop: controller.stop,
+    };
+}

package/dist/serve.js

@@ -48,6 +48,7 @@ import { initializedProjectSkillsReconciler } from "./project-skills/initialized
 import { parseMemoryPruneTraceId } from "./memory-prune-diagnostics.js";
 import { probeRuntimeHealth } from "./runtime-health.js";
 import { createServeMarketplace } from "./marketplace-serve.js";
+import { createServeRuntimeToolUpdates } from "./runtime-tool-update-serve.js";
 import { buildControlPlaneUrl } from "./control-plane-url.js";
 import { resolveDaemonLocalStateRootFromEnv } from "./daemon-local-home.js";
 import { bindStorageServerIdentity, createStorageIdentityAdmission, } from "./storage-serve-adapter.js";
@@ -210,6 +211,7 @@ export function serve(config, opts = {}) {
         onError: (code, context) => dslog("execution.runtime_detection_failed", "机器环境或 runtime 探测失败", { level: "ERROR", error_code: code, ...context }),
     });
     machineRuntime.prewarm();
+    const runtimeToolUpdates = createServeRuntimeToolUpdates(config, localSlots, hostCoordinator, async () => ({ ...(await machineRuntime.provider.acquire()).env }), () => machineRuntime.refresh());
     const initializedProjectSkills = initializedProjectSkillsReconciler(() => projectSkillsController.ensureScanned(), projectSkillsReconciler);
     const configuredCapabilities = opts.machineInfo?.capabilities ?? daemonCapabilities(process.platform);
     const prepareCapabilities = async () => daemonCapabilityBindings(process.platform, [...configuredCapabilities, ...await managedDaemonCapabilities(updateEligibility)]);
@@ -842,6 +844,12 @@ export function serve(config, opts = {}) {
                 }
                 return;
             }
+            const runtimeUpdateSocket = ws;
+            if (runtimeToolUpdates.handle(msg, frame => { try {
+                runtimeUpdateSocket?.send(JSON.stringify(frame));
+            }
+            catch { /* Server reconciles via status. */ } }))
+                return;
             if (marketplace.handle(msg, frame => { try {
                 ws?.send(JSON.stringify(frame));
             }
@@ -1326,6 +1334,7 @@ export function serve(config, opts = {}) {
                 webSocketClosed,
                 updateController.drain(),
                 marketplace.stop(),
+                runtimeToolUpdates.stop(),
                 executionFrameQueue,
                 ...executionRuns.values(),
                 ...[...legacyRuns.values()].map((run) => run.done),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.6.101-beta.3",
+  "version": "0.6.101-beta.4",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -18,6 +18,14 @@
   "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",
+    "test:release-critical": "vitest run test/automatic-daemon-installer.test.ts test/automatic-install-target.test.ts test/automatic-service-migration.test.ts test/computer-cli.test.ts test/computer-service.test.ts test/computer-setup-client.test.ts test/computer-setup-orchestration.test.ts test/computer-setup.test.ts test/daemon-release-version.test.ts test/daemon-update-controller.test.ts test/daemon-update-eligibility.test.ts test/daemon-updater.test.ts test/execution-protocol.test.ts test/machine-info.test.ts --maxWorkers=2 --minWorkers=1",
+    "typecheck": "tsc --noEmit"
+  },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.2.1",
     "@nowcrew/cli": "0.4.17",
@@ -39,12 +47,5 @@
     "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",
-    "test:release-critical": "vitest run test/automatic-daemon-installer.test.ts test/automatic-install-target.test.ts test/automatic-service-migration.test.ts test/computer-cli.test.ts test/computer-service.test.ts test/computer-setup-client.test.ts test/computer-setup-orchestration.test.ts test/computer-setup.test.ts test/daemon-release-version.test.ts test/daemon-update-controller.test.ts test/daemon-update-eligibility.test.ts test/daemon-updater.test.ts test/execution-protocol.test.ts test/machine-info.test.ts --maxWorkers=2 --minWorkers=1",
-    "typecheck": "tsc --noEmit"
   }
-}
+}