doer-agent 0.4.7 → 0.4.9

package/README.md

@@ -142,6 +142,6 @@ curl -X POST 'http://localhost:2020/api/users/<userId>/agent/secret' \
 
 ## 참고
 
-- `runtime/`에는 실행 보조 스크립트가 들어 있습니다.
+- `runtime/`에는 Git 인증 등 실행 보조 스크립트가 들어 있습니다.
 - Playwright MCP 프록시는 에이전트 상태 디렉터리(`~/.doer-agent`) 아래 소켓을 사용합니다.
 - 이 저장소에는 예전 README에 있던 `scripts/build.sh`, `scripts/publish.sh`, `docker-compose.dev.yml`이 없습니다. 현재 문서는 실제 파일 구조 기준으로 정리되어 있습니다.

package/dist/agent-codex-cli.js

@@ -1,4 +1,6 @@
 import { spawn, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
 const ANSI_RE = /\u001b\[[0-9;]*m/g;
 function shellSingleQuote(value) {
     return `'${value.replace(/'/g, `'"'"'`)}'`;
@@ -6,6 +8,9 @@ function shellSingleQuote(value) {
 function toTomlStringLiteral(value) {
     return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
 }
+function toTomlStringArray(values) {
+    return `[${values.map((value) => toTomlStringLiteral(value)).join(", ")}]`;
+}
 function hasDirectCodexBinary() {
     const result = spawnSync("bash", ["-lc", "command -v codex >/dev/null 2>&1"], {
         stdio: "ignore",
@@ -27,6 +32,7 @@ export function buildManagedCodexArgs(args) {
         ...(args.modelInstructionsFile
             ? ["--config", `model_instructions_file=${toTomlStringLiteral(args.modelInstructionsFile)}`]
             : []),
+        ...(args.configOverrides ?? []),
     ];
     const imageArgs = args.imagePaths.flatMap((imagePath) => ["--image", imagePath]);
     return [
@@ -39,6 +45,26 @@ export function buildManagedCodexArgs(args) {
             : ["exec", ...imageArgs, ...promptArgs]),
     ];
 }
+export function buildDaemonMcpConfigArgs(args) {
+    const serverName = args.serverName?.trim() || "doer_daemon";
+    const distEntry = path.join(args.agentProjectDir, "dist", "daemon-mcp-server.js");
+    const srcEntry = path.join(args.agentProjectDir, "src", "daemon-mcp-server.ts");
+    const tsxLoaderPath = path.join(args.agentProjectDir, "node_modules", "tsx", "dist", "loader.mjs");
+    const command = process.execPath;
+    const commandArgs = existsSync(distEntry)
+        ? [distEntry, "--workspace-root", args.workspaceRoot]
+        : ["--import", tsxLoaderPath, srcEntry, "--workspace-root", args.workspaceRoot];
+    return [
+        "--config",
+        `mcp_servers.${serverName}.command=${toTomlStringLiteral(command)}`,
+        "--config",
+        `mcp_servers.${serverName}.args=${toTomlStringArray(commandArgs)}`,
+        "--config",
+        `mcp_servers.${serverName}.env.DOER_DAEMON_WORKSPACE_ROOT=${toTomlStringLiteral(args.workspaceRoot)}`,
+        "--config",
+        `mcp_servers.${serverName}.enabled=true`,
+    ];
+}
 export function buildLocalCodexCliCommand(args) {
     const quotedArgs = args.map(shellSingleQuote).join(" ");
     const direct = `exec codex ${quotedArgs}`;

package/dist/agent-daemon-rpc.js

@@ -0,0 +1,481 @@
+import { spawn } from "node:child_process";
+import crypto from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { StringCodec } from "nats";
+import { buildAgentSettingsEnvPatch } from "./agent-settings.js";
+import { normalizeEnvPatch, sleep } from "./agent-runtime-utils.js";
+import { sendSignalToPid } from "./agent-task-execution.js";
+const daemonRpcCodec = StringCodec();
+const DAEMON_ID_PATTERN = /^[A-Za-z0-9_-]{6,32}$/;
+function getDaemonsRoot(workspaceRoot) {
+    return path.join(workspaceRoot, ".doer-agent", "daemons");
+}
+function getDaemonDir(workspaceRoot, daemonId) {
+    return path.join(getDaemonsRoot(workspaceRoot), daemonId);
+}
+function getDaemonStatePath(workspaceRoot, daemonId) {
+    return path.join(getDaemonDir(workspaceRoot, daemonId), "state.json");
+}
+function getDaemonEventsPath(workspaceRoot, daemonId) {
+    return path.join(getDaemonDir(workspaceRoot, daemonId), "events.jsonl");
+}
+function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || (pid ?? 0) <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function createDaemonId() {
+    return crypto.randomBytes(9).toString("base64url").slice(0, 12);
+}
+function normalizeAction(value) {
+    if (value === "list" || value === "inspect" || value === "start" || value === "stop" || value === "restart" || value === "delete" || value === "logs") {
+        return value;
+    }
+    throw new Error("unsupported action");
+}
+function normalizeDaemonId(value) {
+    const daemonId = typeof value === "string" ? value.trim() : "";
+    if (!DAEMON_ID_PATTERN.test(daemonId)) {
+        throw new Error("invalid daemonId");
+    }
+    return daemonId;
+}
+function normalizeCommand(value) {
+    const command = typeof value === "string" ? value.trim() : "";
+    if (!command) {
+        throw new Error("command is required");
+    }
+    return command;
+}
+function normalizeLabel(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const label = value.trim();
+    return label ? label.slice(0, 120) : null;
+}
+function normalizeLimit(value, fallback) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric)) {
+        return fallback;
+    }
+    return Math.max(1, Math.min(Math.floor(numeric), 1000));
+}
+function normalizeStateRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const row = value;
+    const id = typeof row.id === "string" ? row.id.trim() : "";
+    const command = typeof row.command === "string" ? row.command.trim() : "";
+    const cwd = typeof row.cwd === "string" ? row.cwd.trim() : "";
+    const startedAt = typeof row.startedAt === "string" ? row.startedAt.trim() : "";
+    const label = typeof row.label === "string" && row.label.trim() ? row.label.trim() : null;
+    const stoppedAt = typeof row.stoppedAt === "string" && row.stoppedAt.trim() ? row.stoppedAt.trim() : null;
+    const pid = typeof row.pid === "number" && Number.isInteger(row.pid) && row.pid > 0 ? row.pid : null;
+    const runnerPid = typeof row.runnerPid === "number" && Number.isInteger(row.runnerPid) && row.runnerPid > 0 ? row.runnerPid : null;
+    const lastExitCode = typeof row.lastExitCode === "number" && Number.isInteger(row.lastExitCode) ? row.lastExitCode : null;
+    if (!DAEMON_ID_PATTERN.test(id) || !command || !cwd || !startedAt) {
+        return null;
+    }
+    return {
+        id,
+        label,
+        command,
+        cwd,
+        pid,
+        runnerPid,
+        startedAt,
+        stoppedAt,
+        lastExitCode,
+    };
+}
+function normalizeLogEvent(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const row = value;
+    const ts = typeof row.ts === "string" ? row.ts.trim() : "";
+    const type = row.type === "start" ||
+        row.type === "stdout" ||
+        row.type === "stderr" ||
+        row.type === "heartbeat" ||
+        row.type === "exit" ||
+        row.type === "signal" ||
+        row.type === "error"
+        ? row.type
+        : null;
+    if (!ts || !type) {
+        return null;
+    }
+    return {
+        ts,
+        type,
+        text: typeof row.text === "string" ? row.text : null,
+        pid: typeof row.pid === "number" && Number.isInteger(row.pid) && row.pid > 0 ? row.pid : null,
+        code: typeof row.code === "number" && Number.isInteger(row.code) ? row.code : null,
+        signal: typeof row.signal === "string" && row.signal.trim() ? row.signal.trim() : null,
+    };
+}
+async function readDaemonState(workspaceRoot, daemonId) {
+    const raw = await readFile(getDaemonStatePath(workspaceRoot, daemonId), "utf8").catch(() => null);
+    if (!raw) {
+        return null;
+    }
+    const parsed = JSON.parse(raw);
+    return normalizeStateRecord(parsed);
+}
+async function writeDaemonState(workspaceRoot, state) {
+    await mkdir(getDaemonDir(workspaceRoot, state.id), { recursive: true });
+    await writeFile(getDaemonStatePath(workspaceRoot, state.id), `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+function toDaemonSnapshot(state) {
+    const runnerAlive = isPidAlive(state.runnerPid);
+    const processAlive = isPidAlive(state.pid);
+    const status = runnerAlive || processAlive ? "running" : state.lastExitCode !== null && state.lastExitCode !== 0 ? "failed" : "stopped";
+    return {
+        ...state,
+        status,
+        displayName: state.label ?? state.command,
+    };
+}
+async function readJsonlTail(filePath, limit) {
+    const raw = await readFile(filePath, "utf8").catch(() => "");
+    if (!raw) {
+        return [];
+    }
+    return raw
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .slice(-limit)
+        .map((line) => {
+        try {
+            return normalizeLogEvent(JSON.parse(line));
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((event) => Boolean(event));
+}
+function resolveDaemonRunnerEntry(agentProjectDir) {
+    const distEntry = path.join(agentProjectDir, "dist", "daemon-log-runner.js");
+    const srcEntry = path.join(agentProjectDir, "src", "daemon-log-runner.ts");
+    const tsxLoaderPath = path.join(agentProjectDir, "node_modules", "tsx", "dist", "loader.mjs");
+    if (existsSync(distEntry)) {
+        return {
+            command: process.execPath,
+            args: [distEntry],
+        };
+    }
+    return {
+        command: process.execPath,
+        args: ["--import", tsxLoaderPath, srcEntry],
+    };
+}
+export async function listAgentDaemonsLocal(workspaceRoot) {
+    const root = getDaemonsRoot(workspaceRoot);
+    const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
+    const states = await Promise.all(entries
+        .filter((entry) => entry.isDirectory() && DAEMON_ID_PATTERN.test(entry.name))
+        .map(async (entry) => readDaemonState(workspaceRoot, entry.name)));
+    return states
+        .filter((state) => Boolean(state))
+        .map((state) => toDaemonSnapshot(state))
+        .sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+}
+export async function getAgentDaemonLocal(workspaceRoot, daemonId) {
+    const state = await readDaemonState(workspaceRoot, daemonId);
+    if (!state) {
+        throw new Error("daemon not found");
+    }
+    return toDaemonSnapshot(state);
+}
+export async function stopAgentDaemonLocal(workspaceRoot, daemonId) {
+    const state = await readDaemonState(workspaceRoot, daemonId);
+    if (!state) {
+        throw new Error("daemon not found");
+    }
+    const targetPid = isPidAlive(state.runnerPid) ? state.runnerPid : state.pid;
+    if (!targetPid) {
+        const stopped = {
+            ...state,
+            pid: null,
+            runnerPid: null,
+            stoppedAt: state.stoppedAt ?? new Date().toISOString(),
+        };
+        await writeDaemonState(workspaceRoot, stopped);
+        return toDaemonSnapshot(stopped);
+    }
+    try {
+        sendSignalToPid(targetPid, "SIGTERM");
+    }
+    catch {
+        // Ignore and fall through to polling.
+    }
+    for (let index = 0; index < 30; index += 1) {
+        await sleep(100);
+        const latest = await readDaemonState(workspaceRoot, daemonId);
+        if (!latest || (!isPidAlive(latest.runnerPid) && !isPidAlive(latest.pid))) {
+            return latest ? toDaemonSnapshot(latest) : toDaemonSnapshot({
+                ...state,
+                pid: null,
+                runnerPid: null,
+                stoppedAt: new Date().toISOString(),
+            });
+        }
+    }
+    try {
+        sendSignalToPid(targetPid, "SIGKILL");
+    }
+    catch {
+        // noop
+    }
+    for (let index = 0; index < 15; index += 1) {
+        await sleep(100);
+        const latest = await readDaemonState(workspaceRoot, daemonId);
+        if (!latest || (!isPidAlive(latest.runnerPid) && !isPidAlive(latest.pid))) {
+            return latest ? toDaemonSnapshot(latest) : toDaemonSnapshot({
+                ...state,
+                pid: null,
+                runnerPid: null,
+                stoppedAt: new Date().toISOString(),
+            });
+        }
+    }
+    throw new Error("failed to stop daemon");
+}
+async function spawnDaemonLocal(args) {
+    const daemonId = args.daemonId ?? createDaemonId();
+    const daemonDir = getDaemonDir(args.workspaceRoot, daemonId);
+    const statePath = getDaemonStatePath(args.workspaceRoot, daemonId);
+    const eventsPath = getDaemonEventsPath(args.workspaceRoot, daemonId);
+    await mkdir(daemonDir, { recursive: true });
+    await mkdir(path.join(args.workspaceRoot, ".codex"), { recursive: true });
+    const settings = await args.readAgentSettingsConfig({ workspaceRoot: args.workspaceRoot });
+    const runtimeBinPath = path.join(args.agentProjectDir, "runtime/bin");
+    const baseState = {
+        id: daemonId,
+        label: args.label,
+        command: args.command,
+        cwd: args.cwd,
+        pid: null,
+        runnerPid: null,
+        startedAt: new Date().toISOString(),
+        stoppedAt: null,
+        lastExitCode: null,
+    };
+    await writeDaemonState(args.workspaceRoot, baseState);
+    const env = {
+        ...process.env,
+        ...buildAgentSettingsEnvPatch(settings),
+        ...args.envPatch,
+        WORKSPACE: args.cwd,
+        CODEX_HOME: path.join(args.workspaceRoot, ".codex"),
+        PATH: [runtimeBinPath, process.env.PATH || ""].filter(Boolean).join(path.delimiter),
+        DOER_DAEMON_ID: daemonId,
+        DOER_DAEMON_COMMAND: args.command,
+        DOER_DAEMON_CWD: args.cwd,
+        DOER_DAEMON_STATE_PATH: statePath,
+        DOER_DAEMON_EVENTS_PATH: eventsPath,
+        DOER_DAEMON_SHELL_PATH: args.resolveShellPath(),
+    };
+    const runner = resolveDaemonRunnerEntry(args.agentProjectDir);
+    const child = spawn(runner.command, runner.args, {
+        cwd: args.cwd,
+        env,
+        detached: process.platform !== "win32",
+        stdio: "ignore",
+    });
+    if (typeof child.pid !== "number" || child.pid <= 0) {
+        throw new Error("failed to start daemon process");
+    }
+    child.unref();
+    await writeDaemonState(args.workspaceRoot, {
+        ...baseState,
+        runnerPid: child.pid,
+    });
+    for (let index = 0; index < 20; index += 1) {
+        await sleep(50);
+        const latest = await readDaemonState(args.workspaceRoot, daemonId);
+        if (latest && (latest.pid || latest.lastExitCode !== null)) {
+            return toDaemonSnapshot(latest);
+        }
+    }
+    const latest = await readDaemonState(args.workspaceRoot, daemonId);
+    return toDaemonSnapshot(latest ?? { ...baseState, runnerPid: child.pid });
+}
+export async function startAgentDaemonLocal(args) {
+    return await spawnDaemonLocal({
+        workspaceRoot: args.workspaceRoot,
+        agentProjectDir: args.agentProjectDir,
+        command: normalizeCommand(args.request.command),
+        cwd: args.resolveTaskWorkspace(typeof args.request.cwd === "string" ? args.request.cwd : null),
+        label: normalizeLabel(args.request.label),
+        envPatch: normalizeEnvPatch(args.request.envPatch),
+        resolveShellPath: args.resolveShellPath,
+        readAgentSettingsConfig: args.readAgentSettingsConfig,
+    });
+}
+export async function restartAgentDaemonLocal(args) {
+    const state = await readDaemonState(args.workspaceRoot, args.daemonId);
+    if (!state) {
+        throw new Error("daemon not found");
+    }
+    if (isPidAlive(state.runnerPid) || isPidAlive(state.pid)) {
+        await stopAgentDaemonLocal(args.workspaceRoot, args.daemonId);
+    }
+    return await spawnDaemonLocal({
+        workspaceRoot: args.workspaceRoot,
+        agentProjectDir: args.agentProjectDir,
+        daemonId: state.id,
+        command: state.command,
+        cwd: state.cwd,
+        label: state.label,
+        envPatch: {},
+        resolveShellPath: args.resolveShellPath,
+        readAgentSettingsConfig: args.readAgentSettingsConfig,
+    });
+}
+export async function deleteAgentDaemonLocal(workspaceRoot, daemonId) {
+    const state = await readDaemonState(workspaceRoot, daemonId);
+    if (!state) {
+        return;
+    }
+    if (isPidAlive(state.runnerPid) || isPidAlive(state.pid)) {
+        await stopAgentDaemonLocal(workspaceRoot, daemonId);
+    }
+    await rm(getDaemonDir(workspaceRoot, daemonId), { recursive: true, force: true });
+}
+export async function readAgentDaemonLogsLocal(args) {
+    const state = await readDaemonState(args.workspaceRoot, args.daemonId);
+    if (!state) {
+        throw new Error("daemon not found");
+    }
+    const limit = normalizeLimit(args.limit, 100);
+    return {
+        daemon: toDaemonSnapshot(state),
+        events: await readJsonlTail(getDaemonEventsPath(args.workspaceRoot, args.daemonId), limit),
+    };
+}
+async function executeDaemonRpc(args) {
+    const action = normalizeAction(args.request.action);
+    if (action === "list") {
+        return {
+            ok: true,
+            action,
+            daemons: await listAgentDaemonsLocal(args.workspaceRoot),
+        };
+    }
+    if (action === "inspect") {
+        const daemonId = normalizeDaemonId(args.request.daemonId);
+        return {
+            ok: true,
+            action,
+            daemon: await getAgentDaemonLocal(args.workspaceRoot, daemonId),
+        };
+    }
+    if (action === "start") {
+        return {
+            ok: true,
+            action,
+            daemon: await startAgentDaemonLocal({
+                workspaceRoot: args.workspaceRoot,
+                agentProjectDir: args.agentProjectDir,
+                request: args.request,
+                resolveShellPath: args.resolveShellPath,
+                resolveTaskWorkspace: args.resolveTaskWorkspace,
+                readAgentSettingsConfig: args.readAgentSettingsConfig,
+            }),
+        };
+    }
+    const daemonId = normalizeDaemonId(args.request.daemonId);
+    if (action === "stop") {
+        return {
+            ok: true,
+            action,
+            daemon: await stopAgentDaemonLocal(args.workspaceRoot, daemonId),
+        };
+    }
+    if (action === "restart") {
+        return {
+            ok: true,
+            action,
+            daemon: await restartAgentDaemonLocal({
+                workspaceRoot: args.workspaceRoot,
+                agentProjectDir: args.agentProjectDir,
+                daemonId,
+                resolveShellPath: args.resolveShellPath,
+                readAgentSettingsConfig: args.readAgentSettingsConfig,
+            }),
+        };
+    }
+    if (action === "delete") {
+        await deleteAgentDaemonLocal(args.workspaceRoot, daemonId);
+        return {
+            ok: true,
+            action,
+            daemonId,
+        };
+    }
+    const limit = normalizeLimit(args.request.limit, 100);
+    return {
+        ok: true,
+        action,
+        ...(await readAgentDaemonLogsLocal({ workspaceRoot: args.workspaceRoot, daemonId, limit })),
+        limit,
+    };
+}
+export async function handleDaemonRpcMessage(args) {
+    let requestId = "unknown";
+    try {
+        const request = JSON.parse(daemonRpcCodec.decode(args.msg.data));
+        requestId = typeof request.requestId === "string" ? request.requestId : "unknown";
+        const payload = await executeDaemonRpc({
+            workspaceRoot: args.workspaceRoot,
+            agentProjectDir: args.agentProjectDir,
+            request,
+            resolveShellPath: args.resolveShellPath,
+            resolveTaskWorkspace: args.resolveTaskWorkspace,
+            readAgentSettingsConfig: args.readAgentSettingsConfig,
+        });
+        args.msg.respond(daemonRpcCodec.encode(JSON.stringify({ requestId, ...payload })));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        args.onError?.(`daemon rpc failed requestId=${requestId} error=${message}`);
+        args.msg.respond(daemonRpcCodec.encode(JSON.stringify({ requestId, ok: false, error: message })));
+    }
+}
+export function subscribeToDaemonRpc(args) {
+    args.nc.subscribe(args.subject, {
+        callback: (error, msg) => {
+            if (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                args.onError(`daemon rpc subscription error: ${message}`);
+                return;
+            }
+            void handleDaemonRpcMessage({
+                msg,
+                nc: args.nc,
+                workspaceRoot: args.workspaceRoot,
+                agentProjectDir: args.agentProjectDir,
+                resolveShellPath: args.resolveShellPath,
+                resolveTaskWorkspace: args.resolveTaskWorkspace,
+                readAgentSettingsConfig: args.readAgentSettingsConfig,
+                onError: args.onError,
+            });
+        },
+    });
+    args.onInfo(`daemon rpc subscribed subject=${args.subject}`);
+}

package/dist/agent-run-state.js

@@ -72,10 +72,68 @@ function buildImmediateRunEvent(task, type) {
         finishedAt: task.finishedAt,
     };
 }
-export async function resetRunsDir(workspaceRoot) {
+function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || (pid ?? 0) <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = error?.code;
+        return code === "EPERM";
+    }
+}
+async function removePathIfStale(pathToRemove, pid) {
+    if (isPidAlive(pid)) {
+        return;
+    }
+    await rm(pathToRemove, { recursive: true, force: true }).catch(() => undefined);
+}
+export async function pruneStaleRunsDir(workspaceRoot) {
     const dir = await resolveRunsDir(workspaceRoot);
-    await rm(dir, { recursive: true, force: true }).catch(() => undefined);
-    await mkdir(dir, { recursive: true });
+    const names = await readdir(dir).catch(() => []);
+    for (const name of names) {
+        const entryPath = path.join(dir, name);
+        if (name === "locks") {
+            const lockNames = await readdir(entryPath).catch(() => []);
+            for (const lockName of lockNames) {
+                const lockPath = path.join(entryPath, lockName);
+                const contents = await readFile(lockPath, "utf8").catch(() => null);
+                if (!contents) {
+                    await rm(lockPath, { recursive: true, force: true }).catch(() => undefined);
+                    continue;
+                }
+                let pid = null;
+                try {
+                    const parsed = JSON.parse(contents);
+                    pid = typeof parsed.pid === "number" && Number.isInteger(parsed.pid) && parsed.pid > 0 ? parsed.pid : null;
+                }
+                catch {
+                    pid = null;
+                }
+                await removePathIfStale(lockPath, pid);
+            }
+            continue;
+        }
+        if (!name.endsWith(".json")) {
+            continue;
+        }
+        const contents = await readFile(entryPath, "utf8").catch(() => null);
+        if (!contents) {
+            await rm(entryPath, { recursive: true, force: true }).catch(() => undefined);
+            continue;
+        }
+        let task = null;
+        try {
+            task = normalizePersistedRunTask(JSON.parse(contents));
+        }
+        catch {
+            task = null;
+        }
+        await removePathIfStale(entryPath, task?.processPid ?? null);
+    }
 }
 export async function persistRunTask(workspaceRoot, task) {
     const dir = await resolveRunsDir(workspaceRoot);

package/dist/agent-runtime-utils.js

@@ -28,6 +28,9 @@ export function buildAgentSkillRpcSubject(userId, agentId) {
 export function buildAgentFsRpcSubject(userId, agentId) {
     return `doer.agent.fs.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
 }
+export function buildAgentDaemonRpcSubject(userId, agentId) {
+    return `doer.agent.daemon.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
+}
 export function parseBootstrapTaskConfig(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return null;

package/dist/agent.js

@@ -6,17 +6,18 @@ import { buildAgentSettingsEnvPatch, readAgentModelInstructions, readAgentSettin
 import { handleFsRpcMessage } from "./agent-fs-rpc.js";
 import { handleGitRpcMessage } from "./agent-git-rpc.js";
 import { subscribeToCodexAuthRpc } from "./agent-codex-auth-rpc.js";
-import { buildManagedCodexArgs, createLocalCodexCliTools, normalizeCodexModel, normalizeShellRpcCodexAuthBundle, spawnManagedCodexCommand, } from "./agent-codex-cli.js";
+import { subscribeToDaemonRpc } from "./agent-daemon-rpc.js";
+import { buildDaemonMcpConfigArgs, buildManagedCodexArgs, createLocalCodexCliTools, normalizeCodexModel, normalizeShellRpcCodexAuthBundle, spawnManagedCodexCommand, } from "./agent-codex-cli.js";
 import { connectBootstrapWithRetry } from "./agent-jetstream.js";
 import { prepareCommandExecution } from "./agent-run-execution.js";
 import { attachManagedRunProcessLifecycle, createPendingRunSessionTracker } from "./agent-run-lifecycle.js";
-import { claimRunStartSlot, cloneRunTask, getStoredRun, listPersistedRunTasks, persistRunTask, publishImmediateRunEvent, releaseRunStartSlot, resetRunsDir, removeRunTask, updateRunStartSlotSession, } from "./agent-run-state.js";
+import { claimRunStartSlot, cloneRunTask, getStoredRun, listPersistedRunTasks, persistRunTask, publishImmediateRunEvent, pruneStaleRunsDir, releaseRunStartSlot, removeRunTask, updateRunStartSlotSession, } from "./agent-run-state.js";
 import { runConnectedAgentSession } from "./agent-session-loop.js";
 import { subscribeToSkillRpc } from "./agent-skill-rpc.js";
 import { prepareCodexAuthBundle, sendSignalToPid, sendSignalToTaskProcess, } from "./agent-task-execution.js";
 import { collectSessionJsonlFiles, detectPendingRunSession, findSessionFilePathBySessionId, stopAllSessionWatchers, subscribeToSessionRpc, } from "./agent-session-rpc.js";
 import { handleNonStartRunRpc, normalizeRunRpcRequest, publishRunRpcResponse, } from "./agent-run-rpc.js";
-import { buildAgentCodexAuthRpcSubject, buildAgentFsRpcSubject, buildAgentGitRpcSubject, buildAgentRunEventsSubject, buildAgentRunRpcSubject, buildAgentSessionRpcSubject, buildAgentSettingsRpcSubject, buildAgentSkillRpcSubject, formatLocalTimestamp, normalizeEnvPatch, filterValidRunImagePaths, normalizeRunImagePaths, parseArgs, resolveAgentVersion, resolveArgOrEnv, resolveContainerReachableServerBaseUrl, sanitizeUserId, sleep, writeRunStatus, writeRunStream, } from "./agent-runtime-utils.js";
+import { buildAgentCodexAuthRpcSubject, buildAgentDaemonRpcSubject, buildAgentFsRpcSubject, buildAgentGitRpcSubject, buildAgentRunEventsSubject, buildAgentRunRpcSubject, buildAgentSessionRpcSubject, buildAgentSettingsRpcSubject, buildAgentSkillRpcSubject, formatLocalTimestamp, normalizeEnvPatch, filterValidRunImagePaths, normalizeRunImagePaths, parseArgs, resolveAgentVersion, resolveArgOrEnv, resolveContainerReachableServerBaseUrl, sanitizeUserId, sleep, writeRunStatus, writeRunStream, } from "./agent-runtime-utils.js";
 import { createRuntimeEnvHelpers } from "./agent-runtime-env.js";
 import { createEventPersistenceHelpers, heartbeatAgentSession, postJson, } from "./agent-runtime-io.js";
 import { handleSettingsRpcMessage } from "./agent-settings-rpc.js";
@@ -273,6 +274,10 @@ async function handleRunRpcMessage(args) {
                         model: request.model,
                         personality: localAgentSettings.general.personality,
                         modelInstructionsFile: customInstructions ? resolveAgentModelInstructionsFilePath(workspaceRoot) : null,
+                        configOverrides: buildDaemonMcpConfigArgs({
+                            agentProjectDir: AGENT_PROJECT_DIR,
+                            workspaceRoot,
+                        }),
                     }),
                     cwd: request.cwd,
                     runtimeEnvPatch: request.runtimeEnvPatch,
@@ -406,7 +411,8 @@ async function main() {
     process.env.WORKSPACE = startupWorkspaceRoot;
     process.env.CODEX_HOME = path.join(startupWorkspaceRoot, ".codex");
     await mkdir(process.env.CODEX_HOME, { recursive: true }).catch(() => undefined);
-    await resetRunsDir(resolveWorkspaceRoot());
+    // Preserve run state for processes that are still alive after an agent restart.
+    await pruneStaleRunsDir(resolveWorkspaceRoot());
     const serverBaseUrlRaw = resolveArgOrEnv(args, ["server", "url"], ["DOER_AGENT_SERVER"], DEFAULT_SERVER_BASE_URL);
     const requestedServerBaseUrl = serverBaseUrlRaw.replace(/\/$/, "");
     const serverBaseUrl = resolveContainerReachableServerBaseUrl(requestedServerBaseUrl);
@@ -472,6 +478,17 @@ async function main() {
                     agentId: initialAgentId,
                     agentToken,
                 });
+                subscribeToDaemonRpc({
+                    nc: jetstream.nc,
+                    subject: buildAgentDaemonRpcSubject(userId, initialAgentId),
+                    workspaceRoot: resolveWorkspaceRoot(),
+                    agentProjectDir: AGENT_PROJECT_DIR,
+                    resolveShellPath: runtimeEnvHelpers.resolveShellPath,
+                    resolveTaskWorkspace: runtimeEnvHelpers.resolveTaskWorkspace,
+                    readAgentSettingsConfig,
+                    onInfo: writeAgentInfo,
+                    onError: writeAgentError,
+                });
                 subscribeToSessionRpc({
                     nc: jetstream.nc,
                     subject: buildAgentSessionRpcSubject(userId, initialAgentId),

package/dist/daemon-log-runner.js

@@ -0,0 +1,212 @@
+import { spawn } from "node:child_process";
+import { appendFile, readFile, writeFile } from "node:fs/promises";
+const DEFAULT_HEARTBEAT_MS = 15_000;
+function readRequiredEnv(name) {
+    const value = process.env[name]?.trim() || "";
+    if (!value) {
+        throw new Error(`${name} is required`);
+    }
+    return value;
+}
+function readHeartbeatIntervalMs() {
+    const raw = process.env.DOER_DAEMON_HEARTBEAT_MS?.trim();
+    if (!raw) {
+        return DEFAULT_HEARTBEAT_MS;
+    }
+    const numeric = Number(raw);
+    if (!Number.isFinite(numeric) || numeric < 1_000) {
+        return DEFAULT_HEARTBEAT_MS;
+    }
+    return Math.floor(numeric);
+}
+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, onActivity) {
+    if (!stream) {
+        return;
+    }
+    stream.setEncoding("utf8");
+    let pending = "";
+    stream.on("data", (chunk) => {
+        onActivity?.();
+        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 heartbeatIntervalMs = readHeartbeatIntervalMs();
+    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,
+    });
+    let lastActivityAt = Date.now();
+    const markActivity = () => {
+        lastActivityAt = Date.now();
+    };
+    attachLineLogger(child.stdout, "stdout", eventsPath, child.pid, markActivity);
+    attachLineLogger(child.stderr, "stderr", eventsPath, child.pid, markActivity);
+    const heartbeatTimer = setInterval(() => {
+        if (child.exitCode !== null || child.killed) {
+            return;
+        }
+        const idleMs = Date.now() - lastActivityAt;
+        if (idleMs < heartbeatIntervalMs) {
+            return;
+        }
+        lastActivityAt = Date.now();
+        void appendEvent(eventsPath, {
+            type: "heartbeat",
+            pid: child.pid,
+            text: `[doer-daemon] heartbeat: process still running without new output for ${Math.max(1, Math.round(idleMs / 1000))}s`,
+        });
+    }, heartbeatIntervalMs);
+    heartbeatTimer.unref?.();
+    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 {
+                clearInterval(heartbeatTimer);
+                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) {
+                clearInterval(heartbeatTimer);
+                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.7",
+  "version": "0.4.9",
   "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" "$@"