@nowcrew/daemon 0.5.14 → 0.5.16

package/README.md

@@ -15,6 +15,57 @@ The process stays resident and reconnects with backoff. For local development, r
 `pnpm --filter @nowcrew/daemon daemon`. `crew-daemon run --agent <handle> --channel <id>` is the legacy
 manual one-shot entry.
 
+## Computer Profiles And Service Lifecycle
+
+Persist a named connection without putting its machine token in shell history or service arguments:
+
+```bash
+printf '%s' "$CREW_MACHINE_TOKEN" | crew-daemon profile save work \
+  --server-url https://nowwork.example --token-stdin
+crew-daemon profile list
+crew-daemon profile show work        # reports configured=true; never prints the token
+crew-daemon serve --profile work
+```
+
+Profile files live under `~/.crew/daemon/profiles`. Unix writes use mode `0600`; Windows tokens are
+encrypted with CurrentUser DPAPI and the profile ACL is restricted to the current user. Windows refuses
+legacy plaintext profiles and fails the save if DPAPI or ACL hardening is unavailable.
+
+Install and operate the profile as a user service:
+
+```bash
+npm install --global @nowcrew/daemon@latest
+crew-daemon install --profile work
+crew-daemon start --profile work
+crew-daemon status --profile work
+crew-daemon doctor --profile work
+crew-daemon restart --profile work
+crew-daemon stop --profile work
+crew-daemon uninstall --profile work
+crew-daemon profile remove work
+```
+
+Lifecycle installation is intentionally refused from an `npx`/temporary cache entry because the service
+must keep a stable executable path across cache cleanup and upgrades.
+
+macOS uses a user LaunchAgent, Linux uses a systemd user unit, and Windows uses Task Scheduler at logon.
+On macOS `install` writes the plist, `start` bootstraps it, and `stop` boots it out, so `KeepAlive` cannot
+silently resurrect a stopped daemon. Always use `status` as the source of truth instead of assuming that
+an install or start request proves the process is running.
+Profiles also capture the install-time runtime `PATH`, so user-installed CLIs remain discoverable under
+minimal service-manager environments. Service descriptions contain only `serve --profile work` and the
+non-secret profile directory; the token and PATH are read by the daemon at runtime and never appear in service arguments. Lifecycle commands fail
+when the native manager rejects an operation. Windows status uses the
+locale-independent `Get-ScheduledTask.State` enum and reports healthy only for `Running`. Its scheduled
+task has no execution time limit, runs on battery, and restarts after failures.
+
+Upgrade the global daemon package, optionally restarting one installed profile afterward:
+
+```bash
+crew-daemon upgrade
+crew-daemon upgrade --profile work
+```
+
 ## Execution Boundary
 
 The server selects the machine and sends a validated `execution:start` containing:
@@ -29,9 +80,12 @@ the local workspace/environment, and launches only a built-in runtime adapter (`
 `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.
+Protocol support and limits are advertised in `machine:hello`. `runtimes` reports every recognized CLI
+found on `PATH`; `executionRuntimes` separately reports the installed CLIs backed by a complete built-in
+adapter. The server must use the latter for admission and treats the former as diagnostic inventory only.
+Old daemons that omit `executionRuntimes` are conservatively interpreted as the intersection of installed
+CLIs and server-supported adapters. Unknown required protocol semantics are rejected before side effects.
+Protocol-0 `agent:start` remains only for the server-governed compatibility window.
 
 ## Reliability
 

package/dist/bound-im-decision.js

@@ -0,0 +1,22 @@
+import { readFile, unlink } from "node:fs/promises";
+import { join } from "node:path";
+export function boundImDecisionFilePath(runDir) {
+    return join(runDir, ".bound-im-decision.json");
+}
+export async function resetBoundImDecisionFile(path) {
+    await unlink(path).catch((error) => {
+        if (error.code !== "ENOENT")
+            throw error;
+    });
+}
+export async function readBoundImDecisionFile(path) {
+    try {
+        const parsed = JSON.parse(await readFile(path, "utf8"));
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        return parsed.decision === "notify" ? { decision: "notify" } : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/computer-cli.js

@@ -0,0 +1,214 @@
+import { parseArgs } from "node:util";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { daemonHome, listProfiles, loadProfile, profileIsPrivate, profilePath, publicProfile, removeProfile, saveProfile, windowsDpapiProtector, } from "./computer-profile.js";
+import { buildServiceSpec, doctorService, hardenWindowsProfile, installService, serviceAction, serviceStatus, systemCommandRunner, uninstallService, upgradeDaemon, windowsProfileIsPrivate, } from "./computer-service.js";
+import { detectDaemonLang, formatDaemonText } from "./i18n.js";
+const COMPUTER_COMMANDS = new Set(["profile", "doctor", "install", "uninstall", "start", "stop", "restart", "status", "upgrade"]);
+export function builtDaemonEntry(moduleUrl = import.meta.url) {
+    return moduleUrl.endsWith(".js")
+        ? fileURLToPath(new URL("./main.js", moduleUrl))
+        : "";
+}
+function defaults() {
+    const npmCommand = process.platform === "win32" ? "npm.cmd" : "npm";
+    return {
+        env: process.env,
+        platform: process.platform,
+        userHome: homedir(),
+        uid: process.getuid?.(),
+        nodePath: process.execPath,
+        entryPath: builtDaemonEntry(),
+        runner: systemCommandRunner,
+        ...(process.platform === "win32" ? { profileProtector: windowsDpapiProtector } : {}),
+        resolveGlobalNodeModules: async () => {
+            const result = await systemCommandRunner(npmCommand, ["root", "--global"]);
+            if (result.exitCode !== 0 || !result.stdout.trim()) {
+                throw new Error(`Unable to locate global npm modules: ${result.stderr.trim() || `exit ${result.exitCode}`}`);
+            }
+            return result.stdout.trim();
+        },
+        readStdin: async () => {
+            if (process.stdin.isTTY)
+                throw new Error("--token-stdin requires a token on standard input");
+            const chunks = [];
+            for await (const chunk of process.stdin)
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            return Buffer.concat(chunks).toString("utf8");
+        },
+        stdout: (text) => process.stdout.write(text),
+        stderr: (text) => process.stderr.write(text),
+    };
+}
+export function isGlobalDaemonEntry(entryPath, globalNodeModules) {
+    return resolve(entryPath) === resolve(globalNodeModules, "@nowcrew", "daemon", "dist", "main.js");
+}
+function usage(td) {
+    return [
+        td("Computer lifecycle:"),
+        "  crew-daemon profile save <name> --server-url <url> [--agents-root <path>] [--token-stdin]",
+        "  crew-daemon profile list|show|remove [<name>]",
+        "  crew-daemon doctor|install|uninstall|start|stop|restart|status --profile <name>",
+        "  crew-daemon upgrade [--profile <name>]",
+        "",
+        td("profile save reads the machine token from CREW_MACHINE_TOKEN, or stdin with --token-stdin."),
+    ].join("\n") + "\n";
+}
+function requireValue(value, name, td) {
+    if (!value)
+        throw new Error(td("Missing {{name}}", { name }));
+    return value;
+}
+export async function runComputerCommand(argv, overrides = {}) {
+    const command = argv[0];
+    if (!command || !COMPUTER_COMMANDS.has(command))
+        return null;
+    const deps = { ...defaults(), ...overrides };
+    const lang = detectDaemonLang(deps.env);
+    const td = (message, values) => formatDaemonText(lang, message, values);
+    try {
+        const parsed = parseArgs({
+            args: [...argv],
+            allowPositionals: true,
+            strict: true,
+            options: {
+                profile: { type: "string" },
+                "server-url": { type: "string" },
+                "agents-root": { type: "string" },
+                "token-stdin": { type: "boolean", default: false },
+                help: { type: "boolean", short: "h", default: false },
+            },
+        });
+        if (parsed.values.help) {
+            deps.stdout(usage(td));
+            return 0;
+        }
+        const [, action, positionalName] = parsed.positionals;
+        const home = daemonHome(deps.env);
+        const profileStorage = {
+            platform: deps.platform,
+            ...(deps.profileProtector ? { protector: deps.profileProtector } : {}),
+            ...(deps.platform === "win32"
+                ? { harden: (path) => hardenWindowsProfile(path, deps.runner) }
+                : {}),
+        };
+        if (command === "profile") {
+            if (action === "list") {
+                deps.stdout(`${JSON.stringify(await listProfiles(home), null, 2)}\n`);
+                return 0;
+            }
+            const name = requireValue(positionalName, "profile name", td);
+            if (action === "show") {
+                deps.stdout(`${JSON.stringify(publicProfile(await loadProfile(name, home, profileStorage)), null, 2)}\n`);
+                return 0;
+            }
+            if (action === "remove") {
+                await loadProfile(name, home, profileStorage);
+                const spec = buildServiceSpec({
+                    ...deps, profile: name, profileHome: home,
+                });
+                const status = await serviceStatus(spec, deps.runner);
+                if (status.installed)
+                    throw new Error(td("Service '{{id}}' is still installed; uninstall it before removing the profile", { id: spec.id }));
+                await removeProfile(name, home);
+                deps.stdout(`${td("Removed profile '{{name}}'.", { name })}\n`);
+                return 0;
+            }
+            if (action !== "save")
+                throw new Error(td("Expected profile save, list, show, or remove"));
+            const fromStdin = parsed.values["token-stdin"];
+            if (fromStdin && deps.env.CREW_MACHINE_TOKEN) {
+                throw new Error(td("Choose one token source: CREW_MACHINE_TOKEN or --token-stdin"));
+            }
+            const machineToken = (fromStdin ? await deps.readStdin() : deps.env.CREW_MACHINE_TOKEN)?.trim();
+            if (!machineToken)
+                throw new Error(td("Missing machine token; use CREW_MACHINE_TOKEN or --token-stdin"));
+            await saveProfile({
+                name,
+                serverUrl: requireValue(parsed.values["server-url"], "--server-url", td),
+                machineToken,
+                ...(parsed.values["agents-root"] ? { agentsRoot: resolve(parsed.values["agents-root"]) } : {}),
+                ...(deps.env.PATH ? { runtimePath: deps.env.PATH } : {}),
+            }, home, profileStorage);
+            deps.stdout(`${td("Saved profile '{{name}}' with private credentials.", { name })}\n`);
+            return 0;
+        }
+        const profileName = parsed.values.profile;
+        if (command === "upgrade") {
+            const spec = profileName
+                ? buildServiceSpec({
+                    ...deps,
+                    profile: (await loadProfile(profileName, home, profileStorage)).name,
+                    profileHome: home,
+                })
+                : null;
+            if (spec) {
+                if (!isGlobalDaemonEntry(deps.entryPath, await deps.resolveGlobalNodeModules())) {
+                    throw new Error(td("Service lifecycle requires a global @nowcrew/daemon install; run npm install --global @nowcrew/daemon@latest"));
+                }
+                const before = await serviceStatus(spec, deps.runner);
+                if (!before.installed)
+                    throw new Error(td("Service '{{id}}' is not installed", { id: spec.id }));
+            }
+            await upgradeDaemon(deps.platform, deps.runner);
+            if (profileName) {
+                await serviceAction(spec, "restart", deps.runner);
+                deps.stdout(`${td("Upgraded daemon and restart request accepted for '{{name}}'. Verify with status.", { name: profileName })}\n`);
+            }
+            else {
+                deps.stdout(`${td("Upgraded daemon. Installed services were not restarted; pass --profile to restart one.")}\n`);
+            }
+            return 0;
+        }
+        const name = requireValue(profileName, "--profile", td);
+        await loadProfile(name, home, profileStorage);
+        if (!deps.entryPath.endsWith(".js")) {
+            throw new Error(td("Service lifecycle requires the built daemon entry (.js), not a TypeScript development entry"));
+        }
+        const spec = buildServiceSpec({
+            ...deps, profile: name, profileHome: home,
+        });
+        if (command === "install") {
+            if (!isGlobalDaemonEntry(deps.entryPath, await deps.resolveGlobalNodeModules())) {
+                throw new Error(td("Service lifecycle requires a global @nowcrew/daemon install; run npm install --global @nowcrew/daemon@latest"));
+            }
+            await installService(spec, deps.runner);
+            deps.stdout(`${td("Installed '{{id}}'. Use status to confirm runtime state.", { id: spec.id })}\n`);
+            return 0;
+        }
+        if (command === "uninstall") {
+            await uninstallService(spec, deps.runner);
+            deps.stdout(`${td("Uninstalled '{{id}}'.", { id: spec.id })}\n`);
+            return 0;
+        }
+        if (command === "start" || command === "stop" || command === "restart") {
+            await serviceAction(spec, command, deps.runner);
+            deps.stdout(`${td("{{action}} request accepted for '{{id}}'. Verify with status.", {
+                action: command,
+                id: spec.id,
+            })}\n`);
+            return 0;
+        }
+        if (command === "status") {
+            const status = await serviceStatus(spec, deps.runner);
+            deps.stdout(`${JSON.stringify({ installed: status.installed, loaded: status.loaded, running: status.running, detail: (status.stdout || status.stderr).trim() }, null, 2)}\n`);
+            return status.installed && status.running ? 0 : 3;
+        }
+        if (command === "doctor") {
+            const privateFile = deps.platform === "win32"
+                ? await windowsProfileIsPrivate(profilePath(name, home), deps.runner)
+                : await profileIsPrivate(name, home, deps.platform);
+            const checks = await doctorService(spec, privateFile, deps.runner);
+            const registered = (await serviceStatus(spec, deps.runner)).installed;
+            deps.stdout(`${JSON.stringify({ checks, registered }, null, 2)}\n`);
+            return checks.every((check) => check.ok) ? 0 : 4;
+        }
+        deps.stderr(usage(td));
+        return 2;
+    }
+    catch (error) {
+        deps.stderr(`crew-daemon: ${td(error.message)}\n`);
+        return 1;
+    }
+}

package/dist/computer-profile.js

@@ -0,0 +1,195 @@
+import { access, chmod, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import { z } from "zod";
+const PROFILE_NAME = /^[a-z0-9][a-z0-9_-]{0,47}$/;
+const ServerUrlSchema = z.string().url().max(2048).refine((value) => {
+    const url = new URL(value);
+    return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password;
+}, "serverUrl must be an HTTP(S) URL without embedded credentials");
+const ProfileSchema = z.object({
+    version: z.literal(1),
+    name: z.string().regex(PROFILE_NAME),
+    serverUrl: ServerUrlSchema,
+    machineToken: z.string().startsWith("sk_machine_").max(4096),
+    agentsRoot: z.string().min(1).optional(),
+    runtimePath: z.string().min(1).max(32768).refine((value) => !value.includes("\0") && !value.includes("\n") && !value.includes("\r"), "runtimePath must be a single line").optional(),
+}).strict();
+const StoredPlainProfileSchema = ProfileSchema;
+const StoredProtectedProfileSchema = ProfileSchema.omit({ machineToken: true }).extend({
+    machineTokenProtected: z.object({
+        scheme: z.literal("dpapi-current-user"),
+        ciphertext: z.string().min(1).max(16384),
+    }).strict(),
+}).strict();
+const StoredProfileSchema = z.union([StoredPlainProfileSchema, StoredProtectedProfileSchema]);
+export function daemonHome(env = process.env) {
+    return resolve(env.CREW_DAEMON_HOME ?? resolve(homedir(), ".crew/daemon"));
+}
+export function validateProfileName(name) {
+    if (!PROFILE_NAME.test(name)) {
+        throw new Error("profile name must match [a-z0-9][a-z0-9_-]{0,47}");
+    }
+    return name;
+}
+export function profilePath(name, home = daemonHome()) {
+    return resolve(home, "profiles", `${validateProfileName(name)}.json`);
+}
+async function atomicPrivateWrite(path, content, beforeCommit) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await chmod(dirname(path), 0o700);
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, content, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        await beforeCommit?.(temporary);
+        await rename(temporary, path);
+        await chmod(path, 0o600);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+const DPAPI_PROTECT = "$p=[Console]::In.ReadToEnd();$b=[Text.Encoding]::UTF8.GetBytes($p);$e=[Security.Cryptography.ProtectedData]::Protect($b,$null,[Security.Cryptography.DataProtectionScope]::CurrentUser);[Convert]::ToBase64String($e)";
+const DPAPI_UNPROTECT = "$p=[Console]::In.ReadToEnd();$b=[Convert]::FromBase64String($p);$d=[Security.Cryptography.ProtectedData]::Unprotect($b,$null,[Security.Cryptography.DataProtectionScope]::CurrentUser);[Console]::Out.Write([Text.Encoding]::UTF8.GetString($d))";
+async function powershellStdin(script, input) {
+    return new Promise((resolvePromise, reject) => {
+        const child = spawn("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        const stdout = [];
+        const stderr = [];
+        child.stdout.on("data", (chunk) => stdout.push(chunk));
+        child.stderr.on("data", (chunk) => stderr.push(chunk));
+        child.once("error", reject);
+        child.once("close", (code) => {
+            if (code !== 0) {
+                reject(new Error(`Windows DPAPI operation failed: ${Buffer.concat(stderr).toString("utf8").trim() || `exit ${code}`}`));
+                return;
+            }
+            resolvePromise(Buffer.concat(stdout).toString("utf8").trim());
+        });
+        child.stdin.end(input);
+    });
+}
+export const windowsDpapiProtector = {
+    protect: (plaintext) => powershellStdin(DPAPI_PROTECT, plaintext),
+    unprotect: (ciphertext) => powershellStdin(DPAPI_UNPROTECT, ciphertext),
+};
+function storageOptions(options) {
+    const platform = options.platform ?? process.platform;
+    return {
+        platform,
+        ...(options.protector ? { protector: options.protector } : platform === "win32" ? { protector: windowsDpapiProtector } : {}),
+        ...(options.harden ? { harden: options.harden } : {}),
+    };
+}
+export async function saveProfile(input, home = daemonHome(), options = {}) {
+    const profile = ProfileSchema.parse({ version: 1, ...input });
+    const configured = storageOptions(options);
+    if (configured.platform === "win32") {
+        if (!configured.protector)
+            throw new Error("Windows profile storage requires CurrentUser DPAPI");
+        if (!configured.harden)
+            throw new Error("Windows profile storage requires ACL hardening");
+        const ciphertext = await configured.protector.protect(profile.machineToken);
+        if (!ciphertext)
+            throw new Error("Windows DPAPI returned an empty ciphertext");
+        const stored = StoredProtectedProfileSchema.parse({
+            version: 1,
+            name: profile.name,
+            serverUrl: profile.serverUrl,
+            ...(profile.agentsRoot ? { agentsRoot: profile.agentsRoot } : {}),
+            ...(profile.runtimePath ? { runtimePath: profile.runtimePath } : {}),
+            machineTokenProtected: { scheme: "dpapi-current-user", ciphertext },
+        });
+        await atomicPrivateWrite(profilePath(profile.name, home), `${JSON.stringify(stored, null, 2)}\n`, configured.harden);
+    }
+    else {
+        await atomicPrivateWrite(profilePath(profile.name, home), `${JSON.stringify(profile, null, 2)}\n`);
+    }
+    return profile;
+}
+export async function loadProfile(name, home = daemonHome(), options = {}) {
+    const path = profilePath(name, home);
+    try {
+        const stored = StoredProfileSchema.parse(JSON.parse(await readFile(path, "utf8")));
+        const configured = storageOptions(options);
+        if (configured.platform === "win32") {
+            if (!("machineTokenProtected" in stored)) {
+                throw new Error(`Computer profile '${name}' contains a plaintext token and is refused on Windows`);
+            }
+            if (!configured.protector)
+                throw new Error("Windows profile storage requires CurrentUser DPAPI");
+            return ProfileSchema.parse({
+                version: stored.version,
+                name: stored.name,
+                serverUrl: stored.serverUrl,
+                ...(stored.agentsRoot ? { agentsRoot: stored.agentsRoot } : {}),
+                ...(stored.runtimePath ? { runtimePath: stored.runtimePath } : {}),
+                machineToken: await configured.protector.unprotect(stored.machineTokenProtected.ciphertext),
+            });
+        }
+        if (!("machineToken" in stored)) {
+            throw new Error(`Computer profile '${name}' is DPAPI-protected and can only be loaded by its Windows user`);
+        }
+        return stored;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new Error(`Computer profile '${name}' does not exist`);
+        }
+        throw error;
+    }
+}
+export async function listProfiles(home = daemonHome()) {
+    const root = resolve(home, "profiles");
+    try {
+        const entries = await readdir(root, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map((entry) => entry.name.slice(0, -5))
+            .filter((name) => PROFILE_NAME.test(name))
+            .sort();
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+export async function removeProfile(name, home = daemonHome()) {
+    await rm(profilePath(name, home), { force: true });
+}
+export async function profileIsPrivate(name, home = daemonHome(), platform = process.platform) {
+    const path = profilePath(name, home);
+    await access(path, constants.R_OK);
+    if (platform === "win32") {
+        const stored = StoredProfileSchema.parse(JSON.parse(await readFile(path, "utf8")));
+        return "machineTokenProtected" in stored && stored.machineTokenProtected.scheme === "dpapi-current-user";
+    }
+    const { mode } = await stat(path);
+    return (mode & 0o077) === 0;
+}
+export function publicProfile(profile) {
+    return {
+        version: profile.version,
+        name: profile.name,
+        serverUrl: profile.serverUrl,
+        machineTokenConfigured: true,
+        ...(profile.agentsRoot ? { agentsRoot: profile.agentsRoot } : {}),
+    };
+}
+export function applyProfileToEnv(profile, env) {
+    env.CREW_SERVER_URL = profile.serverUrl;
+    env.CREW_MACHINE_TOKEN = profile.machineToken;
+    if (profile.agentsRoot)
+        env.CREW_AGENTS_ROOT = profile.agentsRoot;
+    else
+        delete env.CREW_AGENTS_ROOT;
+    if (profile.runtimePath)
+        env.PATH = profile.runtimePath;
+}