doer-agent 0.4.6 → 0.4.8

package/dist/daemon-log-runner.js

@@ -0,0 +1,176 @@
+import { spawn } from "node:child_process";
+import { appendFile, readFile, writeFile } from "node:fs/promises";
+function readRequiredEnv(name) {
+    const value = process.env[name]?.trim() || "";
+    if (!value) {
+        throw new Error(`${name} is required`);
+    }
+    return value;
+}
+async function readState(statePath) {
+    const raw = await readFile(statePath, "utf8");
+    return JSON.parse(raw);
+}
+async function writeState(statePath, state) {
+    await writeFile(statePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+async function appendEvent(eventsPath, event) {
+    const row = {
+        ts: new Date().toISOString(),
+        type: event.type,
+        text: event.text ?? null,
+        pid: typeof event.pid === "number" && event.pid > 0 ? event.pid : null,
+        code: typeof event.code === "number" ? event.code : null,
+        signal: event.signal?.trim() || null,
+    };
+    await appendFile(eventsPath, `${JSON.stringify(row)}\n`, "utf8");
+}
+function attachLineLogger(stream, type, eventsPath, pid) {
+    if (!stream) {
+        return;
+    }
+    stream.setEncoding("utf8");
+    let pending = "";
+    stream.on("data", (chunk) => {
+        pending += chunk;
+        const lines = pending.split(/\r\n|\n|\r/);
+        pending = lines.pop() ?? "";
+        for (const line of lines) {
+            void appendEvent(eventsPath, {
+                type,
+                text: line,
+                pid,
+            });
+        }
+    });
+    stream.on("end", () => {
+        if (!pending) {
+            return;
+        }
+        void appendEvent(eventsPath, {
+            type,
+            text: pending,
+            pid,
+        });
+        pending = "";
+    });
+}
+async function main() {
+    const statePath = readRequiredEnv("DOER_DAEMON_STATE_PATH");
+    const eventsPath = readRequiredEnv("DOER_DAEMON_EVENTS_PATH");
+    const command = readRequiredEnv("DOER_DAEMON_COMMAND");
+    const cwd = readRequiredEnv("DOER_DAEMON_CWD");
+    const shellPath = readRequiredEnv("DOER_DAEMON_SHELL_PATH");
+    const childEnv = { ...process.env };
+    delete childEnv.DOER_DAEMON_STATE_PATH;
+    delete childEnv.DOER_DAEMON_EVENTS_PATH;
+    delete childEnv.DOER_DAEMON_COMMAND;
+    delete childEnv.DOER_DAEMON_CWD;
+    delete childEnv.DOER_DAEMON_SHELL_PATH;
+    let state = await readState(statePath);
+    state = {
+        ...state,
+        runnerPid: process.pid,
+    };
+    await writeState(statePath, state);
+    const child = spawn(command, {
+        cwd,
+        env: childEnv,
+        shell: shellPath,
+        detached: false,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (typeof child.pid !== "number" || child.pid <= 0) {
+        throw new Error("failed to spawn daemon child");
+    }
+    state = {
+        ...state,
+        pid: child.pid,
+        stoppedAt: null,
+        lastExitCode: null,
+    };
+    await writeState(statePath, state);
+    await appendEvent(eventsPath, {
+        type: "start",
+        pid: child.pid,
+    });
+    attachLineLogger(child.stdout, "stdout", eventsPath, child.pid);
+    attachLineLogger(child.stderr, "stderr", eventsPath, child.pid);
+    const forwardSignal = (signal) => {
+        if (child.exitCode !== null || child.killed) {
+            return;
+        }
+        try {
+            child.kill(signal);
+        }
+        catch {
+            // ignore forwarding failures
+        }
+    };
+    const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+    for (const signal of signals) {
+        process.on(signal, () => {
+            void appendEvent(eventsPath, {
+                type: "signal",
+                pid: child.pid,
+                signal,
+            });
+            forwardSignal(signal);
+        });
+    }
+    await new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("exit", async (code, signal) => {
+            try {
+                const latest = await readState(statePath);
+                await writeState(statePath, {
+                    ...latest,
+                    pid: null,
+                    runnerPid: null,
+                    stoppedAt: new Date().toISOString(),
+                    lastExitCode: typeof code === "number" ? code : null,
+                });
+                await appendEvent(eventsPath, {
+                    type: code === 0 ? "exit" : "error",
+                    pid: child.pid,
+                    code,
+                    signal,
+                    text: signal ? `process exited due to ${signal}` : code === 0 ? "process exited cleanly" : `process exited with code ${code}`,
+                });
+                resolve();
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    });
+}
+main().catch(async (error) => {
+    const eventsPath = process.env.DOER_DAEMON_EVENTS_PATH?.trim();
+    const statePath = process.env.DOER_DAEMON_STATE_PATH?.trim();
+    const message = error instanceof Error ? error.stack || error.message : String(error);
+    if (eventsPath) {
+        await appendEvent(eventsPath, {
+            type: "error",
+            pid: process.pid,
+            text: message,
+        }).catch(() => undefined);
+    }
+    if (statePath) {
+        try {
+            const state = await readState(statePath);
+            await writeState(statePath, {
+                ...state,
+                pid: null,
+                runnerPid: null,
+                stoppedAt: new Date().toISOString(),
+                lastExitCode: state.lastExitCode ?? 1,
+            });
+        }
+        catch {
+            // ignore
+        }
+    }
+    process.stderr.write(`${message}\n`);
+    process.exit(1);
+});

package/dist/daemon-mcp-server.js

@@ -0,0 +1,166 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import * as z from "zod/v4";
+import { deleteAgentDaemonLocal, listAgentDaemonsLocal, readAgentDaemonLogsLocal, restartAgentDaemonLocal, startAgentDaemonLocal, stopAgentDaemonLocal, } from "./agent-daemon-rpc.js";
+import { readAgentSettingsConfig } from "./agent-settings.js";
+import { createRuntimeEnvHelpers } from "./agent-runtime-env.js";
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const AGENT_PROJECT_DIR = path.join(MODULE_DIR, "..");
+function parseWorkspaceRoot(argv) {
+    const flagIndex = argv.findIndex((token) => token === "--workspace-root");
+    const flagValue = flagIndex >= 0 ? argv[flagIndex + 1] : "";
+    const envValue = process.env.DOER_DAEMON_WORKSPACE_ROOT?.trim() || process.env.WORKSPACE?.trim() || process.cwd();
+    return path.resolve((flagValue || envValue || process.cwd()).trim());
+}
+function formatJson(value) {
+    return JSON.stringify(value, null, 2);
+}
+async function main() {
+    const workspaceRoot = parseWorkspaceRoot(process.argv.slice(2));
+    const runtimeEnvHelpers = createRuntimeEnvHelpers({
+        resolveWorkspaceRoot: () => workspaceRoot,
+        agentProjectDir: AGENT_PROJECT_DIR,
+    });
+    const server = new McpServer({
+        name: "doer-daemon",
+        version: "0.1.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+        instructions: "Manage long-lived workspace daemons. Use these tools to list, start, stop, and inspect daemon logs.",
+    });
+    server.registerTool("daemon_list", {
+        description: "List daemons managed for the current workspace.",
+        inputSchema: {},
+    }, async () => {
+        const daemons = await listAgentDaemonsLocal(workspaceRoot);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: formatJson({ daemons }),
+                },
+            ],
+            structuredContent: { daemons },
+        };
+    });
+    server.registerTool("daemon_start", {
+        description: "Start a new long-lived daemon process for the current workspace.",
+        inputSchema: {
+            command: z.string().min(1).describe("Shell command to run, such as `npm run dev`."),
+            cwd: z.string().optional().describe("Optional working directory relative to the workspace root."),
+            label: z.string().optional().describe("Optional UI label for the daemon."),
+        },
+    }, async ({ command, cwd, label }) => {
+        const daemon = await startAgentDaemonLocal({
+            workspaceRoot,
+            agentProjectDir: AGENT_PROJECT_DIR,
+            request: {
+                command,
+                cwd: cwd ?? ".",
+                label,
+            },
+            resolveShellPath: runtimeEnvHelpers.resolveShellPath,
+            resolveTaskWorkspace: runtimeEnvHelpers.resolveTaskWorkspace,
+            readAgentSettingsConfig,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: formatJson({ daemon }),
+                },
+            ],
+            structuredContent: { daemon },
+        };
+    });
+    server.registerTool("daemon_stop", {
+        description: "Stop a running daemon by id.",
+        inputSchema: {
+            id: z.string().min(1).describe("Daemon id returned by daemon_list or daemon_start."),
+        },
+    }, async ({ id }) => {
+        const daemon = await stopAgentDaemonLocal(workspaceRoot, id);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: formatJson({ daemon }),
+                },
+            ],
+            structuredContent: { daemon },
+        };
+    });
+    server.registerTool("daemon_restart", {
+        description: "Restart a daemon by id.",
+        inputSchema: {
+            id: z.string().min(1).describe("Daemon id returned by daemon_list or daemon_start."),
+        },
+    }, async ({ id }) => {
+        const daemon = await restartAgentDaemonLocal({
+            workspaceRoot,
+            agentProjectDir: AGENT_PROJECT_DIR,
+            daemonId: id,
+            resolveShellPath: runtimeEnvHelpers.resolveShellPath,
+            readAgentSettingsConfig,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: formatJson({ daemon }),
+                },
+            ],
+            structuredContent: { daemon },
+        };
+    });
+    server.registerTool("daemon_delete", {
+        description: "Delete a daemon by id, stopping it first if needed.",
+        inputSchema: {
+            id: z.string().min(1).describe("Daemon id returned by daemon_list or daemon_start."),
+        },
+    }, async ({ id }) => {
+        await deleteAgentDaemonLocal(workspaceRoot, id);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: formatJson({ deleted: true, daemonId: id }),
+                },
+            ],
+            structuredContent: { deleted: true, daemonId: id },
+        };
+    });
+    server.registerTool("daemon_logs", {
+        description: "Read recent tail log events for a daemon.",
+        inputSchema: {
+            id: z.string().min(1).describe("Daemon id returned by daemon_list or daemon_start."),
+            limit: z.number().int().min(1).max(1000).optional().describe("Maximum number of recent log lines to read."),
+        },
+    }, async ({ id, limit }) => {
+        const logs = await readAgentDaemonLogsLocal({
+            workspaceRoot,
+            daemonId: id,
+            limit,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: formatJson(logs),
+                },
+            ],
+            structuredContent: logs,
+        };
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.stack || error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doer-agent",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",

package/runtime/bin/apply_patch

@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_DIR="$(cd "$SCRIPT_DIR/../.." && pwd)"
-exec node "$PROJECT_DIR/dist/apply-patch.js" "$@"