@nowcrew/daemon 0.6.16 → 0.6.18

package/dist/agent-ability/runtime-context.js

@@ -135,5 +135,11 @@ export async function loadAgentAbilityRuntimeContext(agentRoot, trainingRoot, ab
         `- ${join(trainingRoot, "workspace")}`,
         "Eval assets are provenance only and are not injected into task context.",
     ].join("\n");
-    return { prompt, instructionBytes, memoryBytes, skillCount: skills.length };
+    return {
+        prompt,
+        instructionBytes,
+        memoryBytes,
+        skillCount: skills.length,
+        skillRoot: join(trainingRoot, "skills"),
+    };
 }

package/dist/atomic-private-write.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { chmod, mkdir, rename, rm, writeFile } from "node:fs/promises";
+import { chmod, mkdir, open, rename, rm, unlink, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 export async function atomicPrivateWrite(path, content, beforeCommit) {
     const directory = dirname(path);
@@ -16,3 +16,56 @@ export async function atomicPrivateWrite(path, content, beforeCommit) {
         await rm(temporary, { force: true });
     }
 }
+const durableFileSystem = (options) => ({
+    chmod: options.fs?.chmod ?? chmod,
+    open: options.fs?.open ?? open,
+    rename: options.fs?.rename ?? rename,
+    rm: options.fs?.rm ?? rm,
+    unlink: options.fs?.unlink ?? unlink,
+});
+const syncDirectory = async (directory, fs) => {
+    const handle = await fs.open(directory, "r");
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+};
+/** Persists prior directory-entry mutations in an existing directory. */
+export async function durableDirectorySync(directory, options = {}) {
+    await syncDirectory(directory, durableFileSystem(options));
+}
+/**
+ * Atomically replaces a private file below an existing parent and does not resolve until both the
+ * new file contents and parent-directory rename are durable. Callers may therefore use resolution
+ * as a write-ahead boundary before mutating other filesystem state. Windows callers must remain
+ * capability-gated until native directory-fsync behavior is validated.
+ */
+export async function durableAtomicPrivateWrite(path, content, options = {}) {
+    const fs = durableFileSystem(options);
+    const directory = options.parentDirectory ?? dirname(path);
+    await fs.chmod(directory, 0o700);
+    const temporary = `${path}.${(options.randomId ?? randomUUID)()}.tmp`;
+    let handle = null;
+    try {
+        handle = await fs.open(temporary, "wx", 0o600);
+        await handle.writeFile(content, "utf8");
+        await handle.sync();
+        await handle.close();
+        handle = null;
+        await fs.rename(temporary, path);
+        await syncDirectory(directory, fs);
+    }
+    finally {
+        if (handle !== null)
+            await handle.close().catch(() => undefined);
+        await fs.rm(temporary, { force: true });
+    }
+}
+/** Removes a durable journal record and persists the directory-entry deletion. */
+export async function durablePrivateUnlink(path, options = {}) {
+    const fs = durableFileSystem(options);
+    await fs.unlink(path);
+    await syncDirectory(options.parentDirectory ?? dirname(path), fs);
+}

package/dist/automatic-install-target.js

@@ -1,4 +1,5 @@
 import { posix, win32 } from "node:path";
+import { profileLayout, validateLocalInstanceName } from "./profile-layout.js";
 const PROFILE_NAME = /^[a-z0-9][a-z0-9_-]{0,47}$/;
 const KNOWN_TARGETS = {
     "nowwork-in.nowcoder.com": {
@@ -46,23 +47,51 @@ function requireCustomProfile(hostname, value) {
     }
     return value;
 }
+function knownTargetForProfile(environment, requestedProfile, input, parsed) {
+    const paths = input.platform === "win32" ? win32 : posix;
+    const legacyProfile = environment;
+    if (requestedProfile === undefined || requestedProfile === legacyProfile) {
+        return Object.freeze({
+            kind: "known",
+            profile: legacyProfile,
+            serverUrl: normalizedServerUrl(parsed),
+            daemonHome: paths.join(input.userHome, ".crew", environment === "in" ? "daemon" : "daemon-dev"),
+            agentsRoot: paths.join(input.userHome, ".crew", environment === "in" ? "agents" : "agents-dev"),
+            npmPrefix: paths.join(input.userHome, ".crew", "daemon-runtimes", legacyProfile),
+        });
+    }
+    if (requestedProfile === "in" || requestedProfile === "dev") {
+        throw new Error(`Server hostname '${new URL(input.serverUrl).hostname}' requires profile '${legacyProfile}'`);
+    }
+    const prefix = `nw-${environment}-`;
+    if (!requestedProfile.startsWith(prefix)) {
+        throw new Error(`Server hostname '${new URL(input.serverUrl).hostname}' requires profile '${prefix}<local-name>'`);
+    }
+    const localInstanceName = validateLocalInstanceName(requestedProfile.slice(prefix.length));
+    const layout = profileLayout({
+        environment,
+        localInstanceName,
+        userHome: input.userHome,
+        platform: input.platform,
+    });
+    return Object.freeze({
+        kind: "known",
+        environment,
+        localInstanceName,
+        profile: layout.profile,
+        serverUrl: normalizedServerUrl(parsed),
+        daemonHome: layout.daemonHome,
+        agentsRoot: layout.agentsRoot,
+        npmPrefix: layout.npmPrefix,
+    });
+}
 export function resolveAutomaticInstallTarget(input) {
     const parsed = parseServerUrl(input.serverUrl);
     const hostname = parsed.hostname.toLowerCase();
     const paths = input.platform === "win32" ? win32 : posix;
     const known = KNOWN_TARGETS[hostname];
     if (known !== undefined) {
-        if (input.requestedProfile !== undefined && input.requestedProfile !== known.profile) {
-            throw new Error(`Server hostname '${hostname}' requires profile '${known.profile}'`);
-        }
-        return Object.freeze({
-            kind: "known",
-            profile: known.profile,
-            serverUrl: normalizedServerUrl(parsed),
-            daemonHome: paths.join(input.userHome, ".crew", known.daemonDirectory),
-            agentsRoot: paths.join(input.userHome, ".crew", known.agentsDirectory),
-            npmPrefix: paths.join(input.userHome, ".crew", "daemon-runtimes", known.profile),
-        });
+        return knownTargetForProfile(known.profile, input.requestedProfile, input, parsed);
     }
     const profile = requireCustomProfile(hostname, input.requestedProfile);
     return Object.freeze({

package/dist/console.js

@@ -17,6 +17,7 @@ import { buildFilePreview, buildSnippetDiff } from "./console-payload.js";
 import { parseUnifiedDiff } from "./unified-diff.js";
 import { buildJsonResult } from "./json-result.js";
 import { buildCollapsedResult } from "./console-collapse.js";
+import { boundedCodexPlan, codexPlanText } from "./runtimes/codex-contract.js";
 /** 单条工具返回正文上限(超出截断并标注),避免单条把终端/DB 撑爆。 */
 export const TOOL_RESULT_CAP = 4000;
 /** 工具输入摘要上限(标题行那一段)。 */
@@ -273,6 +274,14 @@ export function toConsoleLines(event) {
     if (e.type === "thread.started") {
         return [{ stream: "system", text: `● ${td("Codex session started")}` }];
     }
+    if (e.type === "turn.plan.updated") {
+        const plan = boundedCodexPlan(e.plan);
+        return plan === null ? [] : [{
+                stream: "tool",
+                text: `⏺ ${td("Plan updated")} (${plan.length})`,
+                payload: { kind: "plan", plan: codexPlanText(plan) },
+            }];
+    }
     if (e.type === "item.completed" && e.item) {
         return codexItemChunks(e.item, td);
     }

package/dist/control-plane-url.js

@@ -1,13 +1,13 @@
 import { executionBackendCapability } from "./execution-backend.js";
 import { daemonCapabilities, EXECUTION_PROTOCOL } from "./machine-info.js";
 import { PROJECT_SKILLS_CAPABILITY } from "./project-skills/types.js";
-export function buildControlPlaneUrl(serverUrl, machineToken, runtimePlatform = process.platform, jobObjectProbe, projectSkillsAvailable = true) {
+export function buildControlPlaneUrl(serverUrl, machineToken, runtimePlatform = process.platform, jobObjectProbe, projectSkillsAvailable = true, capabilities = daemonCapabilities(runtimePlatform)) {
     const query = new URLSearchParams({ key: machineToken });
     if (executionBackendCapability(runtimePlatform, jobObjectProbe).supported) {
         query.set("execution_min", String(EXECUTION_PROTOCOL.min));
         query.set("execution_max", String(EXECUTION_PROTOCOL.max));
     }
-    for (const capability of daemonCapabilities(runtimePlatform)) {
+    for (const capability of capabilities) {
         if (capability !== PROJECT_SKILLS_CAPABILITY || projectSkillsAvailable) {
             query.append("capability", capability);
         }

package/dist/daemon-migration-controller.js

@@ -0,0 +1,198 @@
+import { createHash } from "node:crypto";
+import { cp, lstat, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { isAbsolute, relative, resolve } from "node:path";
+import { z } from "zod";
+import { loadProfile } from "./computer-profile.js";
+import { builtDaemonEntry } from "./computer-cli.js";
+import { installDaemonAutomatically } from "./automatic-daemon-installer.js";
+import { buildServiceSpec, captureExactService, serviceStatus, systemCommandRunner } from "./computer-service.js";
+import { readManagedServiceRegistry } from "./managed-service-registry.js";
+import { uninstallManagedService } from "./managed-service-lifecycle.js";
+import { resolveAutomaticInstallTarget } from "./automatic-install-target.js";
+const MigrationMessageSchema = z.object({
+    type: z.literal("daemon:migrate"),
+    migrationId: z.string().uuid(),
+    targetProfile: z.string().regex(/^[a-z0-9][a-z0-9_-]{0,47}$/),
+    targetDaemonHome: z.string().min(1),
+    targetAgentsRoot: z.string().min(1),
+}).strict();
+function migrationBackupRoot(input, id) {
+    return resolve(input.backupRoot ?? resolve(input.userHome ?? homedir(), ".crew", "migration-backups"), id);
+}
+async function assertEmptyOrMissing(path) {
+    try {
+        const entries = await readdir(path);
+        if (entries.length > 0)
+            throw new Error(`target path is not empty: ${path}`);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+async function hashedFiles(root, directory = root) {
+    const entries = await readdir(directory, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const path = resolve(directory, entry.name);
+        const stat = await lstat(path);
+        if (stat.isSymbolicLink())
+            throw new Error(`backup source contains a symbolic link: ${relative(root, path)}`);
+        if (stat.isDirectory())
+            files.push(...await hashedFiles(root, path));
+        else if (stat.isFile())
+            files.push({ path: relative(root, path), sha256: createHash("sha256").update(await readFile(path)).digest("hex") });
+    }
+    return files;
+}
+async function backupAndCopy(input, id, targetHome, targetAgents, service) {
+    const backup = migrationBackupRoot(input, id);
+    await mkdir(backup, { recursive: true, mode: 0o700 });
+    await cp(input.currentDaemonHome, resolve(backup, "daemon-home"), { recursive: true, force: false });
+    await cp(input.currentAgentsRoot, resolve(backup, "agents-root"), { recursive: true, force: false });
+    await cp(input.currentDaemonHome, targetHome, { recursive: true, force: false });
+    await cp(input.currentAgentsRoot, targetAgents, { recursive: true, force: false });
+    const files = [
+        ...(await hashedFiles(resolve(backup, "daemon-home"))).map((file) => ({ ...file, path: `daemon-home/${file.path}` })),
+        ...(await hashedFiles(resolve(backup, "agents-root"))).map((file) => ({ ...file, path: `agents-root/${file.path}` })),
+    ];
+    await writeFile(resolve(backup, "manifest.json"), `${JSON.stringify({
+        version: 1,
+        migrationId: id,
+        profile: input.profileName,
+        daemonHome: input.currentDaemonHome,
+        agentsRoot: input.currentAgentsRoot,
+        service: {
+            id: service.spec.id,
+            platform: service.spec.platform,
+            descriptorPath: service.spec.descriptorPath,
+            descriptor: service.spec.descriptor,
+            daemonCommand: service.spec.daemonCommand,
+            installed: service.snapshot.installed,
+            running: service.snapshot.running,
+            managedRecord: service.managedRecord,
+        },
+        files,
+    }, null, 2)}\n`, { mode: 0o600 });
+    return backup;
+}
+async function cleanupCurrentServiceDefault(spec, input) {
+    const userHome = input.userHome ?? homedir();
+    const records = await readManagedServiceRegistry({ userHome });
+    const record = records.find((candidate) => candidate.profile === spec.profile && candidate.daemonHome === input.currentDaemonHome);
+    if (record !== undefined && (spec.platform === "darwin" || spec.platform === "linux")) {
+        await uninstallManagedService({ spec, record, runner: systemCommandRunner, registry: { userHome } });
+        return;
+    }
+    // Windows and legacy descriptors are handled by the normal CLI/service lifecycle.
+    const { uninstallService } = await import("./computer-service.js");
+    const status = await serviceStatus(spec, systemCommandRunner);
+    if (status.installed)
+        await uninstallService(spec, systemCommandRunner);
+}
+export function createDaemonMigrationController(input) {
+    const handled = new Set();
+    let running = null;
+    const sendFailure = (id, errorCode, error) => {
+        input.sendStatus({ type: "daemon:migration-status", migrationId: id, status: "failed", errorCode, errorMessage: error instanceof Error ? error.message : String(error) });
+    };
+    const execute = async (raw) => {
+        const parsed = MigrationMessageSchema.safeParse(raw);
+        if (!parsed.success)
+            return false;
+        const message = parsed.data;
+        if (handled.has(message.migrationId))
+            return true;
+        if (running !== null) {
+            sendFailure(message.migrationId, "target_conflict", new Error("another migration is already running"));
+            return true;
+        }
+        running = (async () => {
+            input.sendStatus({ type: "daemon:migration-status", migrationId: message.migrationId, status: "preflight" });
+            if (input.isBusy()) {
+                sendFailure(message.migrationId, "runtime_busy", new Error("active executions must finish before migration"));
+                return;
+            }
+            const platform = input.platform ?? process.platform;
+            const userHome = input.userHome ?? homedir();
+            let targetPath;
+            let targetAgents;
+            let currentSpec;
+            let currentService;
+            let managedRecord = null;
+            try {
+                const currentProfile = await (input.loadCurrentProfile ?? loadProfile)(input.profileName, input.currentDaemonHome);
+                if (currentProfile.machineToken !== input.machineToken)
+                    throw new Error("active profile token does not match this daemon");
+                const target = resolveAutomaticInstallTarget({ serverUrl: input.serverUrl, requestedProfile: message.targetProfile, userHome, platform });
+                if (!isAbsolute(message.targetDaemonHome) || !isAbsolute(message.targetAgentsRoot)
+                    || resolve(message.targetDaemonHome) !== resolve(target.daemonHome)
+                    || resolve(message.targetAgentsRoot) !== resolve(target.agentsRoot))
+                    throw new Error("requested target does not match the standard profile layout");
+                targetPath = resolve(target.daemonHome);
+                targetAgents = resolve(target.agentsRoot);
+                await assertEmptyOrMissing(targetPath);
+                await assertEmptyOrMissing(targetAgents);
+                currentSpec = buildServiceSpec({ platform, profile: input.profileName, userHome, uid: process.getuid?.(), nodePath: process.execPath, entryPath: builtDaemonEntry(), profileHome: input.currentDaemonHome });
+                const exact = await (input.captureCurrentService ?? ((spec) => captureExactService(spec, systemCommandRunner)))(currentSpec);
+                if (!exact.installed || !exact.running || !exact.exact)
+                    throw new Error("current managed service identity is not exact and running");
+                currentService = { installed: exact.installed, running: exact.running };
+                if (platform === "darwin" || platform === "linux") {
+                    const records = await (input.readManagedRecords ?? (() => readManagedServiceRegistry({ userHome })))();
+                    managedRecord = records.find((record) => record.serviceId === currentSpec.id && record.profile === input.profileName && record.daemonHome === input.currentDaemonHome) ?? null;
+                    if (managedRecord === null)
+                        throw new Error("current managed service registry record is missing");
+                }
+            }
+            catch (error) {
+                sendFailure(message.migrationId, "target_conflict", error);
+                return;
+            }
+            input.sendStatus({ type: "daemon:migration-status", migrationId: message.migrationId, status: "backing_up" });
+            let backupPath;
+            try {
+                backupPath = await backupAndCopy(input, message.migrationId, targetPath, targetAgents, { spec: currentSpec, snapshot: currentService, managedRecord });
+                input.sendStatus({ type: "daemon:migration-status", migrationId: message.migrationId, status: "installing", backupPath });
+            }
+            catch (error) {
+                await Promise.allSettled([rm(targetPath, { recursive: true, force: true }), rm(targetAgents, { recursive: true, force: true })]);
+                sendFailure(message.migrationId, "backup_failed", error);
+                return;
+            }
+            const install = input.install ?? installDaemonAutomatically;
+            try {
+                const result = await install({
+                    serverUrl: input.serverUrl,
+                    machineToken: input.machineToken,
+                    requestedProfile: message.targetProfile,
+                });
+                if (result.profile !== message.targetProfile || result.serviceId.length === 0) {
+                    throw new Error("target service identity did not match the requested profile");
+                }
+            }
+            catch (error) {
+                await Promise.allSettled([rm(targetPath, { recursive: true, force: true }), rm(targetAgents, { recursive: true, force: true })]);
+                sendFailure(message.migrationId, "install_failed", error);
+                return;
+            }
+            input.sendStatus({ type: "daemon:migration-status", migrationId: message.migrationId, status: "restarting" });
+            try {
+                await (input.cleanupCurrentService ?? ((spec) => cleanupCurrentServiceDefault(spec, input)))(currentSpec);
+            }
+            catch (error) {
+                const targetSpec = buildServiceSpec({ platform, profile: message.targetProfile, userHome, uid: process.getuid?.(), nodePath: process.execPath, entryPath: builtDaemonEntry(), profileHome: targetPath });
+                await (input.cleanupTargetService ?? ((spec) => cleanupCurrentServiceDefault(spec, { ...input, profileName: message.targetProfile, currentDaemonHome: targetPath })))(targetSpec).catch(() => undefined);
+                sendFailure(message.migrationId, "service_cleanup_failed", error);
+                return;
+            }
+        })().finally(() => {
+            handled.add(message.migrationId);
+            running = null;
+        });
+        await running;
+        return true;
+    };
+    return { handle: execute, drain: async () => { await running; } };
+}

package/dist/daemon-migration-wiring.js

@@ -0,0 +1,22 @@
+import { daemonHome } from "./computer-profile.js";
+import { createDaemonMigrationController } from "./daemon-migration-controller.js";
+export function createServeMigrationController(input) {
+    if (input.profileName === undefined)
+        return null;
+    return createDaemonMigrationController({
+        serverUrl: input.config.serverUrl,
+        machineToken: input.config.machineToken,
+        profileName: input.profileName,
+        currentDaemonHome: daemonHome(),
+        currentAgentsRoot: input.config.agentsRoot,
+        isBusy: input.isBusy,
+        sendStatus: input.sendStatus,
+    });
+}
+export async function handleMigrationControlMessage(controller, decoded) {
+    if (controller === null || typeof decoded !== "object" || decoded === null
+        || !("type" in decoded) || decoded.type !== "daemon:migrate")
+        return false;
+    await controller.handle(decoded);
+    return true;
+}

package/dist/daemon-update-eligibility.js

@@ -13,7 +13,7 @@ import { assertRegistryCoversDescriptors, listManagedServiceDescriptorPaths, man
 export async function managedDaemonCapabilities(eligibility) {
     try {
         return (await eligibility()).eligible
-            ? ["daemon_update_v1", "daemon_restart_v1"]
+            ? ["daemon_update_v1", "daemon_restart_v1", "daemon_layout_migration_v1"]
             : [];
     }
     catch {

package/dist/directory-projection-identity.js

@@ -0,0 +1,32 @@
+import { lstat } from "node:fs/promises";
+const errorCode = (error) => error.code;
+/** Reads one directory identity without narrowing filesystem bigint values through JavaScript numbers. */
+export const readExactDirectoryIdentity = async (path, statPath = lstat) => {
+    try {
+        const info = await statPath(path, { bigint: true });
+        if (!info.isDirectory() || info.isSymbolicLink()) {
+            throw new Error("directory_projection_artifact_unmanaged");
+        }
+        return Object.freeze({
+            dev: String(info.dev),
+            ino: String(info.ino),
+            birthtimeNs: String(info.birthtimeNs),
+        });
+    }
+    catch (error) {
+        if (errorCode(error) === "ENOENT")
+            return null;
+        throw error;
+    }
+};
+export const sameExactDirectoryIdentity = (left, right) => left.dev === right.dev
+    && left.ino === right.ino
+    && left.birthtimeNs === right.birthtimeNs;
+export const validExactDirectoryIdentity = (value) => {
+    const candidate = value;
+    return candidate !== null
+        && typeof candidate === "object"
+        && typeof candidate.dev === "string"
+        && typeof candidate.ino === "string"
+        && typeof candidate.birthtimeNs === "string";
+};