@nowcrew/daemon 0.5.12 → 0.5.14

package/README.md

@@ -0,0 +1,77 @@
+# NowWork Daemon
+
+The daemon is NowWork's local execution adapter. It holds a machine credential, keeps one control-plane
+WebSocket open, and launches coding runtimes on that machine. Product policy remains on the server.
+
+## Run
+
+Use the connection command generated by **Add Computer**:
+
+```bash
+npx @nowcrew/daemon@latest --server-url https://nowwork.example --api-key sk_machine_...
+```
+
+The process stays resident and reconnects with backoff. For local development, run
+`pnpm --filter @nowcrew/daemon daemon`. `crew-daemon run --agent <handle> --channel <id>` is the legacy
+manual one-shot entry.
+
+## Execution Boundary
+
+The server selects the machine and sends a validated `execution:start` containing:
+
+- fully rendered system and wake prompts;
+- runtime/model/reasoning and timeout;
+- requested permission and channel/thread identifiers;
+- reporting flags for final text, activity, and console streams.
+
+The daemon intersects requested permission with local policy, checks advertised resource limits, prepares
+the local workspace/environment, and launches only a built-in runtime adapter (`claude`, `codex`, or
+`kimi`). It does not decide collaboration rules, scheduled output policy, fallback delivery, or thread
+behavior. Those are server responsibilities.
+
+Protocol support and limits are advertised in `machine:hello`. Unknown required protocol semantics are
+rejected before side effects. Protocol-0 `agent:start` remains only for the server-governed compatibility
+window.
+
+## Reliability
+
+Protocol-v1 lifecycle is `accepted → started → completed`, followed by a server
+`execution:completion-ack`. Reconnect uses `execution:sync`; cancellation uses `execution:cancel`.
+Activity and console frames are best-effort, while lifecycle and terminal effects are durable on the
+server.
+
+Before accepting work, the daemon writes a local journal entry under:
+
+```text
+<CREW_AGENTS_ROOT>/.crew/executions/<executionId>.json
+```
+
+`CREW_AGENTS_ROOT` defaults to `~/.crew/agents`. On restart, accepted entries become interrupted failures;
+running supervisors are identity-checked and terminated before interruption is reported. A lock prevents
+two daemon processes from sharing one journal.
+
+## Local Policy
+
+Useful environment controls:
+
+```text
+CREW_RUNTIME_SAFE=1
+CREW_EXECUTION_MAX_PROMPT_BYTES=256000
+CREW_EXECUTION_MAX_TIMEOUT_MS=3600000
+CREW_EXECUTION_MAX_EVENT_BYTES=64000
+CREW_MAX_PARALLEL=4
+CREW_EXECUTION_MAX_QUEUED_PER_AGENT=32
+```
+
+Local policy can reduce server-requested access and limits; it cannot grant more access than requested.
+Provider credentials and configured environment are prepared locally and never carried in execution
+control frames.
+
+## Code Map
+
+- `src/serve.ts`: connection, negotiation, routing, sync, and legacy boundary.
+- `src/execution-runner.ts`: spec admission and lifecycle reporting.
+- `src/local-executor.ts` and `src/execution-supervisor.ts`: runtime process boundary.
+- `src/execution-journal.ts`: crash-safe local execution facts.
+- `src/runner.ts`: protocol-0 compatibility runner.
+- `src/runtimes/`: built-in runtime adapters.

package/dist/config.js

@@ -4,8 +4,38 @@ import { dirname, resolve } from "node:path";
 import { homedir } from "node:os";
 import { createRequire } from "node:module";
 import { detectDaemonLang, translateDaemon } from "./i18n.js";
+export const DEFAULT_EXECUTION_LIMITS = Object.freeze({
+    maxPromptBytes: 256_000,
+    maxTimeoutMs: 3_600_000,
+    maxEventBytes: 64_000,
+    maxParallelPerAgent: 4,
+    maxQueuedPerAgent: 32,
+});
+// Fits the largest mandatory v1 lifecycle envelope (UUID + timestamps + outcome facts) with margin.
+export const MIN_EXECUTION_EVENT_BYTES = 512;
+export const MAX_EXECUTION_TIMEOUT_MS = 2_147_483_647;
 export class ConfigError extends Error {
 }
+function positiveIntegerEnv(env, field, fallback) {
+    const raw = env[field];
+    const value = raw === undefined ? fallback : Number(raw);
+    if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
+        throw new ConfigError(`${field} must be a finite positive integer`);
+    }
+    return value;
+}
+function integerEnvAtLeast(env, field, fallback, minimum) {
+    const value = positiveIntegerEnv(env, field, fallback);
+    if (value < minimum)
+        throw new ConfigError(`${field} must be at least ${minimum}`);
+    return value;
+}
+function integerEnvAtMost(env, field, fallback, maximum) {
+    const value = positiveIntegerEnv(env, field, fallback);
+    if (value > maximum)
+        throw new ConfigError(`${field} must be at most ${maximum}`);
+    return value;
+}
 function defaultCliPath() {
     // 已发布场景(npx):crew CLI 是 daemon 的依赖,从 node_modules 解析 @nowcrew/cli。
     try {
@@ -24,6 +54,13 @@ export function loadConfig(env = process.env) {
         const lang = detectDaemonLang(env);
         throw new ConfigError(translateDaemon(lang, "Missing CREW_MACHINE_TOKEN (sk_machine_*, printed by seed)"));
     }
+    const executionLimits = Object.freeze({
+        maxPromptBytes: positiveIntegerEnv(env, "CREW_EXECUTION_MAX_PROMPT_BYTES", DEFAULT_EXECUTION_LIMITS.maxPromptBytes),
+        maxTimeoutMs: integerEnvAtMost(env, "CREW_EXECUTION_MAX_TIMEOUT_MS", DEFAULT_EXECUTION_LIMITS.maxTimeoutMs, MAX_EXECUTION_TIMEOUT_MS),
+        maxEventBytes: integerEnvAtLeast(env, "CREW_EXECUTION_MAX_EVENT_BYTES", DEFAULT_EXECUTION_LIMITS.maxEventBytes, MIN_EXECUTION_EVENT_BYTES),
+        maxParallelPerAgent: positiveIntegerEnv(env, "CREW_MAX_PARALLEL", DEFAULT_EXECUTION_LIMITS.maxParallelPerAgent),
+        maxQueuedPerAgent: positiveIntegerEnv(env, "CREW_EXECUTION_MAX_QUEUED_PER_AGENT", DEFAULT_EXECUTION_LIMITS.maxQueuedPerAgent),
+    });
     return {
         serverUrl,
         machineToken,
@@ -38,5 +75,6 @@ export function loadConfig(env = process.env) {
         sessionSoftTokens: env.CREW_SESSION_SOFT_TOKENS != null ? Number(env.CREW_SESSION_SOFT_TOKENS) : 90_000,
         sessionMaxTurns: env.CREW_SESSION_MAX_TURNS != null ? Number(env.CREW_SESSION_MAX_TURNS) : 30,
         productName: env.CREW_PRODUCT_NAME ?? "nowwork",
+        executionLimits,
     };
 }

package/dist/execution-event-limit.js

@@ -0,0 +1,59 @@
+import { DaemonToServerExecutionFrameSchema, } from "./execution-protocol.js";
+export function executionFrameBytes(frame) {
+    return Buffer.byteLength(JSON.stringify(frame), "utf8");
+}
+function withBoundedString(frame, field, maxBytes, optional, minimumCharacters = 0) {
+    const raw = frame[field];
+    if (typeof raw !== "string" || executionFrameBytes(frame) <= maxBytes)
+        return frame;
+    const characters = Array.from(raw);
+    let low = 0;
+    let high = characters.length;
+    let best = null;
+    while (low <= high) {
+        const middle = Math.floor((low + high) / 2);
+        const candidate = { ...frame, [field]: characters.slice(0, middle).join("") };
+        if (middle >= minimumCharacters && executionFrameBytes(candidate) <= maxBytes) {
+            best = candidate;
+            low = middle + 1;
+        }
+        else {
+            high = middle - 1;
+        }
+    }
+    if (best !== null && (!optional || best[field] !== ""))
+        return best;
+    if (optional) {
+        const { [field]: _omitted, ...withoutField } = frame;
+        return withoutField;
+    }
+    return best ?? frame;
+}
+export function boundExecutionFrame(input, maxBytes) {
+    if (executionFrameBytes(input) <= maxBytes)
+        return input;
+    let frame = { ...input };
+    if (input.type === "execution:activity") {
+        frame = withBoundedString(frame, "detail", maxBytes, false);
+    }
+    else if (input.type === "execution:console") {
+        frame = withBoundedString(frame, "text", maxBytes, false);
+    }
+    else if (input.type === "execution:rejected") {
+        frame = withBoundedString(frame, "message", maxBytes, true);
+    }
+    else if (input.type === "execution:completed") {
+        for (const field of ["finalText", "errorMessage", "model", "terminationSignal"]) {
+            frame = withBoundedString(frame, field, maxBytes, true);
+        }
+        if (executionFrameBytes(frame) > maxBytes && "usage" in frame) {
+            const { usage: _usage, ...withoutUsage } = frame;
+            frame = withoutUsage;
+        }
+        frame = withBoundedString(frame, "errorCode", maxBytes, false, 1);
+    }
+    if (executionFrameBytes(frame) > maxBytes) {
+        throw new RangeError(`Mandatory ${input.type} envelope exceeds maxEventBytes=${maxBytes}`);
+    }
+    return DaemonToServerExecutionFrameSchema.parse(frame);
+}

package/dist/execution-journal-lock.js

@@ -0,0 +1,262 @@
+import { mkdir, open, readFile, readdir, rename, rm, rmdir, stat, unlink, } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+import { z } from "zod";
+const OwnerSchema = z.object({
+    pid: z.number().int().positive(),
+    processIdentity: z.string().min(1),
+    token: z.string().uuid(),
+}).strict();
+export class JournalLockedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "JournalLockedError";
+    }
+}
+export class JournalLockCorruptionError extends Error {
+    constructor(path, cause) {
+        super(`Invalid execution journal lock: ${path}`, { cause });
+        this.name = "JournalLockCorruptionError";
+    }
+}
+export const defaultJournalLockFileSystem = {
+    mkdir,
+    readFile: (path) => readFile(path, "utf8"),
+    readdir,
+    rename,
+    rm,
+    rmdir,
+    stat,
+    unlink,
+    writeDurableFile: async (path, contents) => {
+        const handle = await open(path, "wx", 0o600);
+        try {
+            await handle.writeFile(contents, "utf8");
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+    },
+};
+const defaultRegistry = { leases: new Map() };
+export function createJournalLeaseRegistry() {
+    return { leases: new Map() };
+}
+const codeOf = (error) => error instanceof Error && "code" in error ? error.code : undefined;
+function processLeaseMap(registry) {
+    return registry.leases;
+}
+export function createJournalLease(options) {
+    const fileSystem = options.fileSystem ?? defaultJournalLockFileSystem;
+    const registry = processLeaseMap(options.registry ?? defaultRegistry);
+    const now = options.now ?? (() => new Date());
+    const orphanGraceMs = options.orphanGraceMs ?? 30_000;
+    const lockDirectory = join(options.directory, ".journal.lock");
+    let attached = false;
+    let status = "open";
+    const ownerFileName = (token) => `owner.${token}.json`;
+    const parseOwner = async (fileName) => {
+        const path = join(lockDirectory, fileName);
+        try {
+            const owner = OwnerSchema.parse(JSON.parse(await fileSystem.readFile(path)));
+            if (fileName !== ownerFileName(owner.token))
+                throw new Error("owner token does not match filename");
+            return owner;
+        }
+        catch (error) {
+            throw new JournalLockCorruptionError(path, error);
+        }
+    };
+    const readOwner = async () => {
+        let names;
+        try {
+            names = (await fileSystem.readdir(lockDirectory)).map(String).sort();
+        }
+        catch (error) {
+            if (codeOf(error) === "ENOENT")
+                return null;
+            throw error;
+        }
+        if (names.length === 0) {
+            const lockStat = await fileSystem.stat(lockDirectory);
+            if (now().valueOf() - lockStat.mtimeMs < orphanGraceMs) {
+                throw new JournalLockedError("Execution journal lock owner installation is in progress");
+            }
+            try {
+                await fileSystem.rmdir(lockDirectory);
+                await options.syncDirectory(options.directory);
+            }
+            catch (error) {
+                if (codeOf(error) !== "ENOENT" && codeOf(error) !== "ENOTEMPTY")
+                    throw error;
+            }
+            return null;
+        }
+        if (names.length !== 1 || !/^owner\.[0-9a-f-]+\.json$/i.test(names[0])) {
+            throw new JournalLockCorruptionError(lockDirectory, new Error("lock directory must contain one owner"));
+        }
+        return { owner: await parseOwner(names[0]), fileName: names[0] };
+    };
+    const validateInstalledOwner = async (lease) => {
+        const observed = await readOwner();
+        if (observed === null
+            || observed.fileName !== lease.ownerFile
+            || JSON.stringify(observed.owner) !== JSON.stringify(lease.owner)) {
+            throw new JournalLockCorruptionError(lockDirectory, new Error("installed owner changed"));
+        }
+    };
+    const finishInstall = async (lease) => {
+        if (!lease.ownerInstalled) {
+            try {
+                await fileSystem.rename(lease.ownerTemp, join(lockDirectory, lease.ownerFile));
+            }
+            catch (error) {
+                if (codeOf(error) !== "ENOENT")
+                    throw error;
+                await validateInstalledOwner(lease);
+            }
+            lease.ownerInstalled = true;
+        }
+        await validateInstalledOwner(lease);
+        if (!lease.lockDirectorySynced) {
+            await options.syncDirectory(lockDirectory);
+            lease.lockDirectorySynced = true;
+        }
+        if (!lease.executionsDirectorySynced) {
+            await options.syncDirectory(options.directory);
+            lease.executionsDirectorySynced = true;
+        }
+        await fileSystem.rm(lease.ownerTemp, { force: true }).catch(() => undefined);
+    };
+    const install = async () => {
+        const token = randomUUID();
+        const owner = OwnerSchema.parse({
+            pid: options.currentPid,
+            processIdentity: await options.captureCurrentIdentity(),
+            token,
+        });
+        const ownerTemp = join(options.directory, `.journal-owner.${token}.tmp`);
+        await fileSystem.writeDurableFile(ownerTemp, `${JSON.stringify(owner)}\n`);
+        try {
+            for (;;) {
+                try {
+                    await fileSystem.mkdir(lockDirectory);
+                    const lease = {
+                        owner,
+                        ownerFile: ownerFileName(token),
+                        ownerTemp,
+                        refs: 1,
+                        ownerInstalled: false,
+                        lockDirectorySynced: false,
+                        executionsDirectorySynced: false,
+                        releasing: false,
+                        ownerRemoved: false,
+                        lockDirectoryRemoved: false,
+                        releaseSynced: false,
+                    };
+                    registry.set(options.directory, lease);
+                    attached = true;
+                    await finishInstall(lease);
+                    return lease;
+                }
+                catch (error) {
+                    if (codeOf(error) !== "EEXIST")
+                        throw error;
+                }
+                const observed = await readOwner();
+                if (observed === null)
+                    continue;
+                const identity = await options.inspectIdentity(observed.owner.pid);
+                if (identity === observed.owner.processIdentity) {
+                    throw new JournalLockedError(`Execution journal is locked by process ${observed.owner.pid}`);
+                }
+                await options.hooks?.beforeRemoveObservedOwner?.(observed.owner);
+                try {
+                    await fileSystem.unlink(join(lockDirectory, observed.fileName));
+                }
+                catch (error) {
+                    if (codeOf(error) !== "ENOENT")
+                        throw error;
+                    continue;
+                }
+                try {
+                    await fileSystem.rmdir(lockDirectory);
+                    await options.syncDirectory(options.directory);
+                }
+                catch (error) {
+                    if (codeOf(error) !== "ENOENT" && codeOf(error) !== "ENOTEMPTY")
+                        throw error;
+                }
+            }
+        }
+        finally {
+            if (!attached)
+                await fileSystem.rm(ownerTemp, { force: true }).catch(() => undefined);
+        }
+    };
+    const acquire = async () => {
+        if (status !== "open")
+            throw new JournalLockedError(`Journal lease is ${status}`);
+        if (attached) {
+            const lease = registry.get(options.directory);
+            if (lease === undefined)
+                throw new JournalLockedError("In-process journal lease is missing");
+            await finishInstall(lease);
+            return;
+        }
+        const existing = registry.get(options.directory);
+        if (existing !== undefined) {
+            if (existing.releasing)
+                throw new JournalLockedError("Journal lease release is pending");
+            await finishInstall(existing);
+            existing.refs += 1;
+            attached = true;
+            return;
+        }
+        await install();
+    };
+    const close = async () => {
+        if (status === "closed")
+            return;
+        if (!attached) {
+            status = "closed";
+            return;
+        }
+        const lease = registry.get(options.directory);
+        if (lease === undefined)
+            throw new JournalLockedError("In-process journal lease is missing");
+        if (status === "open" && lease.refs > 1) {
+            lease.refs -= 1;
+            attached = false;
+            status = "closed";
+            return;
+        }
+        status = "closing";
+        lease.releasing = true;
+        if (!lease.ownerRemoved) {
+            await fileSystem.unlink(join(lockDirectory, lease.ownerFile));
+            lease.ownerRemoved = true;
+        }
+        if (!lease.lockDirectoryRemoved) {
+            await fileSystem.rmdir(lockDirectory);
+            lease.lockDirectoryRemoved = true;
+        }
+        if (!lease.releaseSynced) {
+            await options.syncDirectory(options.directory);
+            lease.releaseSynced = true;
+        }
+        lease.refs -= 1;
+        registry.delete(options.directory);
+        attached = false;
+        status = "closed";
+    };
+    return {
+        acquire,
+        assertUsable: () => {
+            if (status !== "open")
+                throw new JournalLockedError(`Execution journal lease is ${status}`);
+        },
+        close,
+    };
+}