@nowcrew/daemon 0.6.102 → 0.6.103

package/dist/codex-home-launch.js

@@ -0,0 +1,7 @@
+import { awaitWithCancellation } from "./runtime-cancellation.js";
+import { materializeDefaultCodexHome } from "./runtimes/codex-home.js";
+export async function materializePrivateCodexHome(input) {
+    if (input.runtime !== "codex" || input.mode !== "private")
+        return;
+    await awaitWithCancellation((input.materialize ?? materializeDefaultCodexHome)(input.homeDir, input.sourceHome, input.sessionId), input.cancellation);
+}

package/dist/codex-home-mode-controller.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { daemonHome, loadProfile, saveProfile } from "./computer-profile.js";
+const MessageSchema = z.object({
+    type: z.literal("daemon:codex-home-mode"),
+    operationId: z.string().uuid(),
+    mode: z.enum(["shared", "private"]),
+}).strict();
+export function createCodexHomeModeController(input) {
+    let running = null;
+    const handled = new Set();
+    const fail = (operationId, errorCode) => {
+        input.sendStatus({ type: "daemon:codex-home-mode-status", operationId, status: "failed", errorCode });
+    };
+    const execute = async (message) => {
+        if (input.profileName === undefined) {
+            fail(message.operationId, "profile_unavailable");
+            return;
+        }
+        if (input.isBusy()) {
+            fail(message.operationId, "busy");
+            return;
+        }
+        input.sendStatus({ type: "daemon:codex-home-mode-status", operationId: message.operationId, status: "saving" });
+        try {
+            const home = input.profileHome ?? daemonHome();
+            const profile = await loadProfile(input.profileName, home);
+            await saveProfile({ ...profile, codexHomeMode: message.mode }, home);
+        }
+        catch {
+            fail(message.operationId, "save_failed");
+            return;
+        }
+        input.sendStatus({ type: "daemon:codex-home-mode-status", operationId: message.operationId, status: "restarting" });
+        try {
+            const serviceSpec = await input.getServiceSpec();
+            if (serviceSpec === null) {
+                fail(message.operationId, "restart_failed");
+                return;
+            }
+            const handoff = input.scheduleRestart(serviceSpec);
+            void handoff.failed.then(() => fail(message.operationId, "restart_failed"), () => fail(message.operationId, "restart_failed"));
+        }
+        catch {
+            fail(message.operationId, "restart_failed");
+        }
+    };
+    return {
+        handle: async (raw) => {
+            const parsed = MessageSchema.safeParse(raw);
+            if (!parsed.success)
+                return false;
+            if (handled.has(parsed.data.operationId))
+                return true;
+            if (running !== null) {
+                fail(parsed.data.operationId, "busy");
+                handled.add(parsed.data.operationId);
+                return true;
+            }
+            running = execute(parsed.data).finally(() => {
+                handled.add(parsed.data.operationId);
+                running = null;
+            });
+            await running;
+            return true;
+        },
+        drain: async () => { await running; },
+    };
+}

package/dist/daemon-migration-controller.js

@@ -0,0 +1,210 @@
+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";
+import { buildStorageMigrationMappings, createSafeServiceManifest, CredentialMaterialError, } from "./storage-migration-manifest.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);
+}
+function legacyLocalHome(input) {
+    return resolve(input.userHome ?? homedir(), ".crew");
+}
+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) {
+    // Validate and project service identity before creating any backup bytes. A descriptor containing
+    // a token must stop the migration before it can be copied into the local backup root.
+    const safeService = createSafeServiceManifest({
+        spec: service.spec,
+        snapshot: service.snapshot,
+        managedRecord: service.managedRecord,
+    });
+    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 daemonFiles = await hashedFiles(resolve(backup, "daemon-home"));
+    const agentFiles = await hashedFiles(resolve(backup, "agents-root"));
+    const mappings = buildStorageMigrationMappings({ daemonFiles, agentFiles });
+    await writeFile(resolve(backup, "manifest.json"), `${JSON.stringify({
+        version: 2,
+        migrationId: id,
+        profile: input.profileName,
+        daemonHome: input.currentDaemonHome,
+        agentsRoot: input.currentAgentsRoot,
+        service: safeService,
+        mappings,
+    }, null, 2)}\n`, { mode: 0o600 });
+    return backup;
+}
+async function cleanupCurrentServiceDefault(spec, input) {
+    const userHome = input.userHome ?? homedir();
+    const records = await readManagedServiceRegistry({ userHome, localHome: legacyLocalHome(input) });
+    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, localHome: legacyLocalHome(input) } });
+        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;
+            let currentRegistryUrl;
+            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");
+                currentRegistryUrl = currentProfile.registryUrl;
+                const target = resolveAutomaticInstallTarget({
+                    serverUrl: input.serverUrl,
+                    requestedProfile: message.targetProfile,
+                    userHome,
+                    platform,
+                    // This controller migrates the legacy service layout; the new local-home
+                    // standard is handled by the storage migration controller.
+                    requestedLocalHomeMode: "legacy",
+                });
+                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, localHome: legacyLocalHome(input) })))();
+                    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, error instanceof CredentialMaterialError ? "credential_material" : "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, error instanceof CredentialMaterialError ? "credential_material" : "backup_failed", error);
+                return;
+            }
+            const install = input.install ?? installDaemonAutomatically;
+            try {
+                const result = await install({
+                    serverUrl: input.serverUrl,
+                    machineToken: input.machineToken,
+                    requestedProfile: message.targetProfile,
+                    ...(currentRegistryUrl === undefined ? {} : { requestedRegistryUrl: currentRegistryUrl }),
+                });
+                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/execution-runner.js

@@ -709,9 +709,11 @@ export async function runExecution(config, input, dependencies) {
                     catch { /* best-effort activity omitted when its envelope cannot fit */ }
                 },
             } : {}),
-            ...(spec.reporting.streamConsole ? {
+            ...(spec.reporting.streamConsole || credential.observability ? {
                 onConsole: (chunk) => {
-                    if (firstOutputTimer !== undefined) {
+                    if (!spec.reporting.streamConsole && chunk.payload?.kind !== "agent_observation")
+                        return;
+                    if (chunk.payload?.kind !== "agent_observation" && firstOutputTimer !== undefined) {
                         clearTimeout(firstOutputTimer);
                         firstOutputTimer = undefined;
                     }
@@ -859,6 +861,7 @@ export async function runExecution(config, input, dependencies) {
             return appendAgentMemoryContext(base, recalledMemory, Math.max(Buffer.byteLength(base, "utf8"), baseSystemPromptBudget - (context.reservedPromptBytes ?? 0)));
         };
         const localInput = {
+            ...(credential.observability ? { observability: credential.observability } : {}),
             executionId: spec.executionId,
             handle: spec.agent.handle,
             channelId: spec.context.channelId,

package/dist/local-executor.js

@@ -46,6 +46,7 @@ import { commitLocalMemoryResultAfterExit, initializeLocalMemoryV2ForWorkspace,
 import { prepareLocalMemoryPrompt } from "./local-memory/prompt.js";
 import { reportLocalMemoryV2Deferred, resolveLocalMemoryV2Rollout } from "./local-memory/rollout.js";
 import { localMemoryV2Environment } from "./config.js";
+import { observationEnvironment, safeRuntimeObservation } from "./runtime-observation.js";
 export class RuntimeRunningCallbackTimeoutError extends Error {
     constructor(runtime, timeoutMs) {
         super(`${runtime} runtime-running callback timed out after ${timeoutMs}ms`);
@@ -592,7 +593,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 systemPromptPath: workspace.systemPromptPath,
                 systemPrompt: effectiveSystemPrompt,
                 wakePrompt,
-                env: runtimeEnv,
+                env: observationEnvironment(runtimeEnv, input.observability),
                 effectivePermission: input.effectivePermission,
                 ...(launchModel === undefined ? {} : { model: launchModel }),
                 ...(launchReasoning === undefined ? {} : { reasoning: launchReasoning }),
@@ -787,6 +788,12 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             const event = parseLine(line);
             if (!event)
                 return;
+            if (typeof event === "object" && "type" in event && event.type === "nowwork.observation") {
+                const payload = safeRuntimeObservation(event.observation, input.observability);
+                if (payload)
+                    callbacks.onConsole?.({ stream: "system", text: "", payload });
+                return;
+            }
             nativeThreadContext?.observe(event);
             localMemoryTelemetry?.observe(event);
             if (isRuntimeReadyEvent(runtime.name, event))

package/dist/project-skills/capability.js

@@ -0,0 +1,109 @@
+import { PROJECT_SKILLS_CAPABILITY, PROJECT_SKILL_PROJECTION_V2_CAPABILITY, } from "./types.js";
+export function projectSkillV2RolloutReady(platform, readiness) {
+    const platformReady = platform === "darwin"
+        || platform === "linux"
+        || (platform === "win32" && readiness.nativeWindowsSmokePassed);
+    return platformReady
+        && readiness.runtimeRootStorePrimitiveReady
+        && readiness.runtimeRootStoreRecoveryReady
+        && readiness.leaseRecoveryReady
+        && readiness.controllerReady
+        && readiness.executionHandlerReady
+        && readiness.codexAdapterReady
+        && readiness.claudeAdapterReady;
+}
+export function effectiveProjectSkillCapabilities(capabilities, projectSkillsReady, projectSkillV2Ready) {
+    const projectSkillCapabilitiesReady = projectSkillsReady && projectSkillV2Ready;
+    if (!projectSkillCapabilitiesReady
+        && !capabilities.includes(PROJECT_SKILLS_CAPABILITY)
+        && !capabilities.includes(PROJECT_SKILL_PROJECTION_V2_CAPABILITY)
+        && Object.isFrozen(capabilities))
+        return capabilities;
+    const filtered = capabilities.filter((capability) => capability !== PROJECT_SKILL_PROJECTION_V2_CAPABILITY
+        && (projectSkillCapabilitiesReady || capability !== PROJECT_SKILLS_CAPABILITY));
+    if (!projectSkillCapabilitiesReady || !filtered.includes(PROJECT_SKILLS_CAPABILITY)) {
+        return Object.freeze(filtered);
+    }
+    const v1Index = filtered.indexOf(PROJECT_SKILLS_CAPABILITY);
+    return Object.freeze([
+        ...filtered.slice(0, v1Index + 1),
+        PROJECT_SKILL_PROJECTION_V2_CAPABILITY,
+        ...filtered.slice(v1Index + 1),
+    ]);
+}
+export function withProjectSkillCapabilityStatus(value, status) {
+    return {
+        ...value,
+        projectSkillsStatus: status,
+        capabilities: status === "ready"
+            ? value.capabilities
+            : effectiveProjectSkillCapabilities(value.capabilities, false, false),
+    };
+}
+const settleReadinessGate = async (operation) => {
+    try {
+        return await operation() === true;
+    }
+    catch {
+        return false;
+    }
+};
+export async function createProjectSkillConnectionCapabilitySnapshot(input) {
+    const runtimeRootStorePrimitiveReady = await settleReadinessGate(input.probeRuntimeRootStorePrimitive);
+    const controllerReady = await settleReadinessGate(input.initializeController);
+    const recoveryReady = await settleReadinessGate(input.recoverRuntimeRootsAndLeases);
+    const readiness = Object.freeze({
+        runtimeRootStorePrimitiveReady,
+        runtimeRootStoreRecoveryReady: recoveryReady,
+        leaseRecoveryReady: recoveryReady,
+        controllerReady,
+        executionHandlerReady: true,
+        codexAdapterReady: true,
+        claudeAdapterReady: true,
+        nativeWindowsSmokePassed: false,
+    });
+    const projectSkillsReady = projectSkillV2RolloutReady(input.platform, readiness);
+    return Object.freeze({
+        capabilities: effectiveProjectSkillCapabilities(input.baseCapabilities, projectSkillsReady, projectSkillsReady),
+        projectSkillsReady,
+        readiness,
+    });
+}
+export async function prepareProjectSkillConnectionCapabilities(input) {
+    const snapshot = await createProjectSkillConnectionCapabilitySnapshot({
+        ...input,
+        baseCapabilities: [...input.baseCapabilities, ...await input.additionalCapabilities()],
+    });
+    input.applyReadiness(snapshot.projectSkillsReady);
+    return snapshot.capabilities;
+}
+export function createProjectSkillControllerReadiness(input) {
+    let status = "initializing";
+    let initialization = null;
+    const ensure = () => {
+        if (status === "ready")
+            return Promise.resolve(true);
+        if (initialization !== null)
+            return initialization;
+        status = "initializing";
+        const attempt = input.initialize().then(() => {
+            status = "ready";
+            return true;
+        }, (error) => {
+            status = "unavailable";
+            input.onUnavailable(error);
+            return false;
+        }).finally(() => {
+            if (initialization === attempt)
+                initialization = null;
+            input.onSettled();
+        });
+        initialization = attempt;
+        return attempt;
+    };
+    return Object.freeze({
+        status: () => status,
+        ensure,
+        applyPreflight: (ready) => { status = ready ? "ready" : "unavailable"; },
+    });
+}

package/dist/project-skills/controller-convergence.js

@@ -0,0 +1,57 @@
+import { ProjectProjectionError, } from "./reconciler.js";
+export const MAX_REMEMBERED_PROJECT_SKILL_AGENTS = 64;
+const compareBinary = (left, right) => {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+};
+const copySnapshot = (snapshot) => Object.freeze({
+    bindings: Object.freeze(snapshot.bindings.map((binding) => Object.freeze({ ...binding }))),
+    generation: snapshot.generation,
+});
+export function createProjectSkillSnapshotEpoch(maxEntries = MAX_REMEMBERED_PROJECT_SKILL_AGENTS) {
+    if (!Number.isSafeInteger(maxEntries) || maxEntries < 1) {
+        throw new ProjectProjectionError("skill_projection_failed");
+    }
+    const snapshots = new Map();
+    return Object.freeze({
+        begin() {
+            snapshots.clear();
+        },
+        remember(handle, snapshot) {
+            const previous = snapshots.get(handle);
+            if (previous !== undefined && snapshot.generation < previous.generation)
+                return;
+            if (previous === undefined && snapshots.size >= maxEntries) {
+                throw new ProjectProjectionError("skill_projection_failed");
+            }
+            snapshots.set(handle, copySnapshot(snapshot));
+        },
+        forget(handle) {
+            snapshots.delete(handle);
+        },
+        entries() {
+            return Object.freeze([...snapshots.entries()]
+                .sort(([left], [right]) => compareBinary(left, right))
+                .map(([handle, snapshot]) => Object.freeze([handle, copySnapshot(snapshot)])));
+        },
+    });
+}
+const stableErrorCode = (reason) => reason?.code === "skill_projection_snapshot_corrupt"
+    ? "skill_projection_snapshot_corrupt"
+    : "skill_projection_failed";
+export function toPathPrivateConvergenceResults(entries, results) {
+    return Object.freeze(entries.map(([handle], index) => {
+        const result = results[index];
+        if (result?.status === "fulfilled") {
+            return Object.freeze({ handle, status: "fulfilled" });
+        }
+        return Object.freeze({
+            handle,
+            status: "rejected",
+            errorCode: stableErrorCode(result?.reason),
+        });
+    }));
+}