doer-agent 0.4.2 → 0.4.4

package/dist/agent-run-state.js

@@ -0,0 +1,229 @@
+import { mkdir, open, readFile, readdir, rename, rm, unlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { StringCodec } from "nats";
+const runEventsCodec = StringCodec();
+async function resolveRunsDir(workspaceRoot) {
+    const dir = path.join(workspaceRoot, ".doer-agent", "runs");
+    await mkdir(dir, { recursive: true });
+    return dir;
+}
+function sanitizeRunLockSegment(value) {
+    return value.trim().replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 160) || "lock";
+}
+async function resolveRunLocksDir(workspaceRoot) {
+    const dir = path.join(await resolveRunsDir(workspaceRoot), "locks");
+    await mkdir(dir, { recursive: true });
+    return dir;
+}
+async function resolveRunStartLockPath(args) {
+    const dir = await resolveRunLocksDir(args.workspaceRoot);
+    if (typeof args.sessionId === "string" && args.sessionId.trim()) {
+        return path.join(dir, `session__${sanitizeRunLockSegment(args.sessionId)}.lock`);
+    }
+    return path.join(dir, "pending_new_session.lock");
+}
+function normalizePersistedRunTask(value) {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    const record = value;
+    const id = typeof record.runId === "string" && record.runId.trim()
+        ? record.runId.trim()
+        : typeof record.id === "string" && record.id.trim()
+            ? record.id.trim()
+            : "";
+    const userId = typeof record.userId === "string" ? record.userId : "";
+    const agentId = typeof record.agentId === "string" ? record.agentId : "";
+    const status = record.status;
+    if (!id || !userId || !agentId || !["queued", "running", "completed", "failed", "canceled"].includes(String(status))) {
+        return null;
+    }
+    return {
+        id,
+        userId,
+        agentId,
+        processPid: typeof record.processPid === "number" ? record.processPid : null,
+        sessionId: typeof record.sessionId === "string" && record.sessionId.trim() ? record.sessionId.trim() : null,
+        sessionFilePath: typeof record.sessionFilePath === "string" && record.sessionFilePath.trim() ? record.sessionFilePath.trim() : null,
+        status: status,
+        cancelRequested: Boolean(record.cancelRequested),
+        resultExitCode: typeof record.resultExitCode === "number" ? record.resultExitCode : null,
+        resultSignal: typeof record.resultSignal === "string" && record.resultSignal.trim() ? record.resultSignal.trim() : null,
+        error: typeof record.error === "string" && record.error.trim() ? record.error : null,
+        createdAt: typeof record.createdAt === "string" ? record.createdAt : "",
+        updatedAt: typeof record.updatedAt === "string" ? record.updatedAt : "",
+        startedAt: typeof record.startedAt === "string" && record.startedAt.trim() ? record.startedAt : null,
+        finishedAt: typeof record.finishedAt === "string" && record.finishedAt.trim() ? record.finishedAt : null,
+    };
+}
+function buildImmediateRunEvent(task, type) {
+    return {
+        type,
+        agentId: task.agentId,
+        sessionId: task.sessionId,
+        filePath: task.sessionFilePath,
+        runId: task.id,
+        updatedAt: task.updatedAt,
+        status: task.status,
+        cancelRequested: task.cancelRequested,
+        resultExitCode: task.resultExitCode,
+        resultSignal: task.resultSignal,
+        error: task.error,
+        finishedAt: task.finishedAt,
+    };
+}
+export async function resetRunsDir(workspaceRoot) {
+    const dir = await resolveRunsDir(workspaceRoot);
+    await rm(dir, { recursive: true, force: true }).catch(() => undefined);
+    await mkdir(dir, { recursive: true });
+}
+export async function persistRunTask(workspaceRoot, task) {
+    const dir = await resolveRunsDir(workspaceRoot);
+    const payload = {
+        runId: task.id,
+        agentId: task.agentId,
+        userId: task.userId,
+        processPid: task.processPid,
+        sessionId: task.sessionId,
+        sessionFilePath: task.sessionFilePath,
+        status: task.status,
+        cancelRequested: task.cancelRequested,
+        resultExitCode: task.resultExitCode,
+        resultSignal: task.resultSignal,
+        createdAt: task.createdAt,
+        updatedAt: task.updatedAt,
+        startedAt: task.startedAt,
+        finishedAt: task.finishedAt,
+        error: task.error,
+    };
+    await writeFile(path.join(dir, `${task.id}.json`), `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}
+export async function removeRunTask(workspaceRoot, runId) {
+    const dir = await resolveRunsDir(workspaceRoot);
+    await unlink(path.join(dir, `${runId}.json`)).catch(() => undefined);
+}
+export async function claimRunStartSlot(args) {
+    const lockPath = await resolveRunStartLockPath(args);
+    try {
+        const handle = await open(lockPath, "wx");
+        try {
+            const payload = {
+                runId: args.runId,
+                sessionId: typeof args.sessionId === "string" && args.sessionId.trim() ? args.sessionId.trim() : null,
+                pid: process.pid,
+                createdAt: args.formatTimestamp(),
+            };
+            await handle.writeFile(`${JSON.stringify(payload, null, 2)}\n`, "utf8");
+        }
+        finally {
+            await handle.close().catch(() => undefined);
+        }
+    }
+    catch (error) {
+        if (error?.code === "EEXIST") {
+            const lockContents = await readFile(lockPath, "utf8").catch(() => "");
+            const existingRunId = (() => {
+                try {
+                    const parsed = JSON.parse(lockContents);
+                    return typeof parsed.runId === "string" && parsed.runId.trim() ? parsed.runId.trim() : null;
+                }
+                catch {
+                    return null;
+                }
+            })();
+            throw new Error(existingRunId ? `Another run is already active: ${existingRunId}` : "Another run is already active");
+        }
+        throw error;
+    }
+}
+export async function updateRunStartSlotSession(args) {
+    const nextSessionId = args.sessionId.trim();
+    if (!nextSessionId) {
+        return;
+    }
+    const previousSessionId = typeof args.previousSessionId === "string" && args.previousSessionId.trim() ? args.previousSessionId.trim() : null;
+    if (previousSessionId === nextSessionId) {
+        return;
+    }
+    const currentPath = await resolveRunStartLockPath({
+        workspaceRoot: args.workspaceRoot,
+        runId: args.runId,
+        sessionId: previousSessionId,
+    });
+    const nextPath = await resolveRunStartLockPath({
+        workspaceRoot: args.workspaceRoot,
+        runId: args.runId,
+        sessionId: nextSessionId,
+    });
+    if (currentPath === nextPath) {
+        return;
+    }
+    try {
+        await rename(currentPath, nextPath);
+    }
+    catch (error) {
+        const code = error?.code;
+        if (code === "ENOENT") {
+            return;
+        }
+        if (code === "EEXIST") {
+            throw new Error(`Another run is already active for session: ${nextSessionId}`);
+        }
+        throw error;
+    }
+    const payload = {
+        runId: args.runId,
+        sessionId: nextSessionId,
+        pid: process.pid,
+        createdAt: args.formatTimestamp(),
+    };
+    await writeFile(nextPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}
+export async function releaseRunStartSlot(args) {
+    const paths = new Set();
+    paths.add(await resolveRunStartLockPath({ workspaceRoot: args.workspaceRoot, runId: args.runId, sessionId: args.sessionId ?? null }));
+    paths.add(await resolveRunStartLockPath({ workspaceRoot: args.workspaceRoot, runId: args.runId, sessionId: null }));
+    for (const lockPath of paths) {
+        await unlink(lockPath).catch(() => undefined);
+    }
+}
+export function cloneRunTask(task, _sinceSeq) {
+    return { ...task };
+}
+export function publishImmediateRunEvent(args) {
+    args.nc.publish(args.buildRunEventsSubject(args.userId, args.task.agentId), runEventsCodec.encode(JSON.stringify(buildImmediateRunEvent(args.task, args.type ?? "run.changed"))));
+}
+export async function listPersistedRunTasks(workspaceRoot) {
+    const dir = await resolveRunsDir(workspaceRoot);
+    const names = await readdir(dir).catch(() => []);
+    const tasks = await Promise.all(names
+        .filter((name) => name.endsWith(".json"))
+        .map(async (name) => {
+        const raw = await readFile(path.join(dir, name), "utf8").catch(() => null);
+        if (!raw) {
+            return null;
+        }
+        try {
+            return normalizePersistedRunTask(JSON.parse(raw));
+        }
+        catch {
+            return null;
+        }
+    }));
+    return tasks.filter((task) => task !== null);
+}
+export async function getStoredRun(workspaceRoot, runId) {
+    const persisted = await readFile(path.join(await resolveRunsDir(workspaceRoot), `${runId}.json`), "utf8").catch(() => null);
+    if (persisted) {
+        try {
+            const parsed = normalizePersistedRunTask(JSON.parse(persisted));
+            if (parsed) {
+                return parsed;
+            }
+        }
+        catch {
+            // Ignore malformed persisted state.
+        }
+    }
+    return null;
+}

package/dist/agent-runtime-env.js

@@ -0,0 +1,147 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, statSync } from "node:fs";
+import { chmod, mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+function pickFirstNonEmpty(values) {
+    for (const value of values) {
+        if (typeof value !== "string") {
+            continue;
+        }
+        const normalized = value.trim();
+        if (normalized) {
+            return normalized;
+        }
+    }
+    return "";
+}
+async function ensureGitAskpassScript(agentProjectDir) {
+    const binDir = path.join(agentProjectDir, "runtime/bin");
+    const scriptPath = path.join(binDir, "git-askpass.sh");
+    const scriptBody = `#!/bin/sh
+case "$1" in
+  *Username*) printf "%s\\n" "x-access-token" ;;
+  *Password*) printf "%s\\n" "\${GITHUB_TOKEN:-\${GH_TOKEN:-}}" ;;
+  *) printf "\\n" ;;
+esac
+`;
+    await mkdir(binDir, { recursive: true });
+    await writeFile(scriptPath, scriptBody, "utf8");
+    await chmod(scriptPath, 0o700).catch(() => undefined);
+    return scriptPath;
+}
+function applyGitIdentityIfPossible(args) {
+    if (!args.cwd) {
+        return false;
+    }
+    const inRepo = spawnSync("git", ["rev-parse", "--is-inside-work-tree"], {
+        cwd: args.cwd,
+        stdio: "ignore",
+    });
+    if (inRepo.status !== 0) {
+        return false;
+    }
+    const setName = spawnSync("git", ["config", "--local", "user.name", args.userName], {
+        cwd: args.cwd,
+        stdio: "ignore",
+    });
+    if (setName.status !== 0) {
+        return false;
+    }
+    const setEmail = spawnSync("git", ["config", "--local", "user.email", args.userEmail], {
+        cwd: args.cwd,
+        stdio: "ignore",
+    });
+    return setEmail.status === 0;
+}
+export function createRuntimeEnvHelpers(args) {
+    function resolveCodexHomePath() {
+        return path.join(args.resolveWorkspaceRoot(), ".codex");
+    }
+    function resolveShellPath() {
+        if (process.platform === "win32") {
+            return process.env.ComSpec || "cmd.exe";
+        }
+        const candidates = [process.env.SHELL, "/bin/bash", "/usr/bin/bash", "/bin/sh", "/usr/bin/sh"].filter((value) => typeof value === "string" && value.trim().length > 0);
+        for (const candidate of candidates) {
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        throw new Error("No shell executable found. Set SHELL env or install /bin/sh (or bash).");
+    }
+    function resolveTaskWorkspace(rawCwd) {
+        const workspaceRoot = args.resolveWorkspaceRoot();
+        const requestedCwd = rawCwd?.trim() || "";
+        const resolvedCwd = requestedCwd
+            ? path.isAbsolute(requestedCwd)
+                ? path.resolve(requestedCwd)
+                : path.resolve(workspaceRoot, requestedCwd)
+            : workspaceRoot;
+        if (!existsSync(resolvedCwd)) {
+            throw new Error(`Invalid cwd: ${requestedCwd || "(empty)"} resolved to ${resolvedCwd} (path does not exist)`);
+        }
+        let stats;
+        try {
+            stats = statSync(resolvedCwd);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Invalid cwd: ${requestedCwd || "(empty)"} resolved to ${resolvedCwd} (${message})`);
+        }
+        if (!stats.isDirectory()) {
+            throw new Error(`Invalid cwd: ${requestedCwd || "(empty)"} resolved to ${resolvedCwd} (not a directory)`);
+        }
+        return resolvedCwd;
+    }
+    async function prepareTaskGitEnv(prepareArgs) {
+        const envPatch = {
+            GIT_TERMINAL_PROMPT: "0",
+            GCM_INTERACTIVE: "Never",
+        };
+        const githubToken = pickFirstNonEmpty([
+            prepareArgs.baseEnvPatch.GITHUB_TOKEN,
+            prepareArgs.baseEnvPatch.GH_TOKEN,
+            process.env.GITHUB_TOKEN,
+            process.env.GH_TOKEN,
+        ]);
+        if (githubToken) {
+            envPatch.GITHUB_TOKEN = githubToken;
+            envPatch.GH_TOKEN = githubToken;
+            envPatch.GIT_ASKPASS_REQUIRE = "force";
+            envPatch.GIT_ASKPASS = await ensureGitAskpassScript(args.agentProjectDir);
+        }
+        const userName = pickFirstNonEmpty([
+            prepareArgs.baseEnvPatch.DOER_GIT_USER_NAME,
+            prepareArgs.baseEnvPatch.GIT_USER_NAME,
+            prepareArgs.baseEnvPatch.GIT_AUTHOR_NAME,
+            prepareArgs.baseEnvPatch.GIT_COMMITTER_NAME,
+        ]);
+        const userEmail = pickFirstNonEmpty([
+            prepareArgs.baseEnvPatch.DOER_GIT_USER_EMAIL,
+            prepareArgs.baseEnvPatch.GIT_USER_EMAIL,
+            prepareArgs.baseEnvPatch.GIT_AUTHOR_EMAIL,
+            prepareArgs.baseEnvPatch.GIT_COMMITTER_EMAIL,
+        ]);
+        const gitIdentityApplied = userName && userEmail
+            ? applyGitIdentityIfPossible({
+                cwd: prepareArgs.cwd,
+                userName,
+                userEmail,
+            })
+            : false;
+        return {
+            envPatch,
+            meta: {
+                gitAskpassEnabled: Boolean(envPatch.GIT_ASKPASS),
+                gitIdentityApplied,
+                gitIdentityProvided: Boolean(userName && userEmail),
+            },
+        };
+    }
+    return {
+        resolveCodexHomePath,
+        resolveShellPath,
+        resolveTaskWorkspace,
+        prepareTaskGitEnv,
+    };
+}

package/dist/agent-runtime-io.js

@@ -0,0 +1,112 @@
+export async function postJson(url, body) {
+    const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    const text = await res.text();
+    let data = {};
+    if (text) {
+        try {
+            data = JSON.parse(text);
+        }
+        catch {
+            data = {};
+        }
+    }
+    if (!res.ok) {
+        const errObj = (data && typeof data === "object" ? data : {});
+        const message = typeof errObj.error === "string" ? errObj.error : `HTTP ${res.status}`;
+        throw new Error(message);
+    }
+    return data;
+}
+export async function getJson(url) {
+    const res = await fetch(url);
+    const text = await res.text();
+    let data = {};
+    if (text) {
+        try {
+            data = JSON.parse(text);
+        }
+        catch {
+            data = {};
+        }
+    }
+    if (!res.ok) {
+        const errObj = (data && typeof data === "object" ? data : {});
+        const message = typeof errObj.error === "string" ? errObj.error : `HTTP ${res.status}`;
+        throw new Error(message);
+    }
+    return data;
+}
+export function createEventPersistenceHelpers(args) {
+    const nextEventSeqByTask = new Map();
+    async function recordAgentEvent(recordArgs) {
+        await args.publishEvent(recordArgs);
+    }
+    function reserveNextEventSeq(taskId) {
+        const current = nextEventSeqByTask.get(taskId) ?? 1;
+        nextEventSeqByTask.set(taskId, current + 1);
+        return current;
+    }
+    function emitAgentMetaLog(level, message) {
+        const ctx = args.getActiveTaskLogContext();
+        if (!ctx) {
+            return;
+        }
+        const seq = reserveNextEventSeq(ctx.taskId);
+        void recordAgentEvent({
+            jetstream: ctx.jetstream,
+            serverBaseUrl: ctx.serverBaseUrl,
+            taskId: ctx.taskId,
+            userId: ctx.userId,
+            type: "meta",
+            seq,
+            payload: {
+                channel: "agent",
+                level,
+                message,
+                at: args.formatTimestamp(),
+            },
+        }).catch((error) => {
+            const detail = error instanceof Error ? error.message : String(error);
+            process.stderr.write(`[doer-agent] meta log persist failed task=${ctx.taskId}: ${detail}\n`);
+        });
+    }
+    function persistEventOrFatal(persistArgs) {
+        void (async () => {
+            let attempt = 0;
+            let delayMs = 150;
+            while (attempt < 3) {
+                attempt += 1;
+                try {
+                    await recordAgentEvent(persistArgs);
+                    return;
+                }
+                catch (error) {
+                    if (attempt >= 3) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        args.onError(`task=${persistArgs.taskId} ${persistArgs.context}: ${message} (dropped after ${attempt} attempts)`);
+                        return;
+                    }
+                    await args.sleep(delayMs);
+                    delayMs *= 2;
+                }
+            }
+        })();
+    }
+    return {
+        reserveNextEventSeq,
+        emitAgentMetaLog,
+        recordAgentEvent,
+        persistEventOrFatal,
+    };
+}
+export async function heartbeatAgentSession(args) {
+    await args.nc.flush();
+    await args.postJson(`${args.serverBaseUrl}/api/agent/heartbeat`, {
+        userId: args.userId,
+        agentToken: args.agentToken,
+    });
+}