doer-agent 0.4.1 → 0.4.3

package/dist/agent-jetstream.js

@@ -0,0 +1,120 @@
+import { AckPolicy, connect, DeliverPolicy, JSONCodec, RetentionPolicy, StorageType, } from "nats";
+export function normalizeNatsServers(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => typeof item === "string").map((v) => v.trim()).filter((v) => v.length > 0);
+}
+export function normalizeNatsToken(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const auth = value;
+    const token = typeof auth.token === "string" ? auth.token.trim() : "";
+    return token.length > 0 ? token : null;
+}
+function formatNatsStatusData(value) {
+    if (value === null || value === undefined) {
+        return "null";
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+async function ensureJetStreamInfra(args) {
+    const streamInfo = await args.jsm.streams.info(args.stream).catch(() => null);
+    if (!streamInfo) {
+        await args.jsm.streams.add({
+            name: args.stream,
+            subjects: [args.subject],
+            storage: StorageType.File,
+            retention: RetentionPolicy.Limits,
+        });
+    }
+    if (args.durable) {
+        const consumerInfo = await args.jsm.consumers.info(args.stream, args.durable).catch(() => null);
+        if (!consumerInfo) {
+            await args.jsm.consumers.add(args.stream, {
+                durable_name: args.durable,
+                ack_policy: AckPolicy.Explicit,
+                deliver_policy: DeliverPolicy.All,
+                filter_subject: args.subject,
+                ack_wait: 30_000_000_000,
+            });
+        }
+    }
+}
+async function initJetStreamContext(args) {
+    const sanitized = args.sanitizeUserId(args.userId);
+    const stream = `DOER_AGENT_EVENTS_${sanitized}`;
+    const subject = `doer.agent.events.${sanitized}`;
+    const durable = `doer-agent-uploader-${sanitized}`;
+    const nc = await connect(args.token ? { servers: args.servers, token: args.token } : { servers: args.servers });
+    const jsm = await nc.jetstreamManager();
+    await ensureJetStreamInfra({ jsm, stream, subject, durable });
+    void (async () => {
+        try {
+            for await (const status of nc.status()) {
+                const statusType = typeof status.type === "string" ? status.type : "unknown";
+                if (statusType === "pingTimer") {
+                    continue;
+                }
+                const statusData = formatNatsStatusData(status.data);
+                args.onInfraError("nats status type=" + statusType + " data=" + statusData);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            args.onInfraError(`nats status loop ended: ${message}`);
+        }
+    })();
+    return {
+        nc,
+        js: nc.jetstream(),
+        jsm,
+        codec: JSONCodec(),
+        subject,
+        stream,
+        durable,
+        servers: args.servers,
+    };
+}
+export async function connectBootstrapWithRetry(args) {
+    let attempt = 0;
+    while (true) {
+        attempt += 1;
+        try {
+            const natsBootstrap = await args.postJson(`${args.serverBaseUrl}/api/agent/nats`, {
+                userId: args.userId,
+                agentToken: args.agentToken,
+            });
+            const bootstrapRecord = natsBootstrap;
+            const natsServers = normalizeNatsServers(bootstrapRecord.servers);
+            if (natsServers.length === 0) {
+                throw new Error("No NATS servers configured by server");
+            }
+            const natsToken = normalizeNatsToken(bootstrapRecord.auth);
+            const jetstream = await initJetStreamContext({
+                userId: args.userId,
+                servers: natsServers,
+                token: natsToken,
+                sanitizeUserId: args.sanitizeUserId,
+                onInfraError: args.onInfraError,
+            });
+            args.onInfraError(`bootstrap ok servers=${natsServers.length} eventStream=${jetstream.stream} eventSubject=${jetstream.subject}`);
+            return { natsBootstrap, jetstream };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const retryMs = Math.min(30_000, 1000 * Math.max(1, attempt));
+            args.onError(`bootstrap failed: ${message} (retry in ${Math.floor(retryMs / 1000)}s, attempt=${attempt})`);
+            await args.sleep(retryMs);
+        }
+    }
+}

package/dist/agent-run-execution.js

@@ -0,0 +1,39 @@
+import path from "node:path";
+import { mkdir } from "node:fs/promises";
+export async function prepareCommandExecution(args) {
+    const shellPath = args.resolveShellPath();
+    const taskWorkspace = args.resolveTaskWorkspace(args.cwd);
+    const codexHome = args.resolveCodexHomePath();
+    await mkdir(codexHome, { recursive: true });
+    const codexAuth = await args.prepareCodexAuthBundle(args.codexAuthBundle);
+    const localAgentSettings = await args.readAgentSettingsConfig({ workspaceRoot: args.resolveWorkspaceRoot() });
+    const baseTaskEnvPatch = {
+        CODEX_HOME: codexHome,
+        DOER_USER_ID: args.userId,
+        DOER_AGENT_TASK_ID: args.taskId,
+        ...args.buildAgentSettingsEnvPatch(localAgentSettings),
+        ...args.runtimeEnvPatch,
+        ...(codexAuth?.envPatch ?? {}),
+        WORKSPACE: taskWorkspace,
+    };
+    const taskGitEnv = await args.prepareTaskGitEnv({
+        cwd: taskWorkspace,
+        baseEnvPatch: baseTaskEnvPatch,
+    });
+    const runtimeBinPath = path.join(args.agentProjectDir, "runtime/bin");
+    const taskPath = [runtimeBinPath, process.env.PATH || ""].filter(Boolean).join(path.delimiter);
+    return {
+        shellPath,
+        taskWorkspace,
+        taskPath,
+        env: {
+            ...process.env,
+            ...baseTaskEnvPatch,
+            ...taskGitEnv.envPatch,
+            PATH: taskPath,
+        },
+        taskGitMeta: taskGitEnv.meta ?? {},
+        codexAuthMeta: codexAuth?.meta ?? { codexAuthSynced: false },
+        codexAuthCleanup: codexAuth?.cleanup ?? (async () => { }),
+    };
+}

package/dist/agent-run-lifecycle.js

@@ -0,0 +1,67 @@
+export function createPendingRunSessionTracker(args) {
+    let closed = false;
+    let timer = null;
+    const stop = () => {
+        closed = true;
+        if (timer) {
+            clearInterval(timer);
+            timer = null;
+        }
+    };
+    const poll = async () => {
+        if (closed || args.task.sessionId) {
+            stop();
+            return;
+        }
+        const detected = await args.detectPendingRunSession().catch(() => null);
+        if (!detected) {
+            return;
+        }
+        await args.updateRunSessionMetadata(detected).catch(() => undefined);
+        if (args.task.sessionId) {
+            stop();
+        }
+    };
+    const start = () => {
+        if (closed || args.task.sessionId || timer) {
+            return;
+        }
+        timer = setInterval(() => {
+            void poll();
+        }, args.pollIntervalMs ?? 1000);
+    };
+    return { poll, start, stop };
+}
+export function attachManagedRunProcessLifecycle(args) {
+    args.child.once("error", (error) => {
+        args.stopPendingSessionPoll();
+        const message = error instanceof Error ? error.message : String(error);
+        args.task.status = "failed";
+        args.task.error = message;
+        args.task.finishedAt = args.formatTimestamp();
+        args.publishImmediateRunEvent({ nc: args.nc, userId: args.task.userId, task: args.task });
+        args.publishImmediateRunEvent({ nc: args.nc, userId: args.task.userId, task: args.task, type: "run.finished" });
+        void args.removeRunTask(args.task.id).catch(() => undefined);
+        void args.releaseRunStartSlot({ runId: args.task.id, sessionId: args.task.sessionId }).catch(() => undefined);
+        void args.codexAuthCleanup().catch(() => undefined);
+        args.writeRunStatus(args.task.id, `failed error=${message}`);
+    });
+    args.child.once("close", async (code, signal) => {
+        args.stopPendingSessionPoll();
+        const latest = await args.getStoredRun(args.task.id).catch(() => null);
+        if (latest?.cancelRequested) {
+            args.task.cancelRequested = true;
+        }
+        args.task.resultExitCode = typeof code === "number" ? code : null;
+        args.task.resultSignal = signal;
+        args.task.finishedAt = args.formatTimestamp();
+        args.task.status = args.task.cancelRequested ? "canceled" : (args.task.resultExitCode ?? 1) === 0 ? "completed" : "failed";
+        args.task.error = args.task.status === "failed" ? `Command exited with code ${args.task.resultExitCode ?? "null"}` : null;
+        args.publishImmediateRunEvent({ nc: args.nc, userId: args.task.userId, task: args.task });
+        args.publishImmediateRunEvent({ nc: args.nc, userId: args.task.userId, task: args.task, type: "run.finished" });
+        void args.removeRunTask(args.task.id).catch(() => undefined);
+        void args.releaseRunStartSlot({ runId: args.task.id, sessionId: args.task.sessionId }).catch(() => undefined);
+        void args.codexAuthCleanup().catch(() => undefined);
+        args.writeRunStatus(args.task.id, `completed status=${args.task.status} exitCode=${args.task.resultExitCode ?? "null"} signal=${args.task.resultSignal ?? "null"}`);
+    });
+}

package/dist/agent-run-rpc.js

@@ -0,0 +1,93 @@
+import { StringCodec } from "nats";
+const runRpcCodec = StringCodec();
+export function normalizeRunRpcRequest(args) {
+    const requestId = typeof args.request.requestId === "string" ? args.request.requestId.trim() : "";
+    if (!requestId) {
+        throw new Error("missing requestId");
+    }
+    const requestAgentId = typeof args.request.agentId === "string" ? args.request.agentId.trim() : "";
+    if (!requestAgentId || requestAgentId !== args.agentId) {
+        throw new Error("agent id mismatch");
+    }
+    const actionRaw = typeof args.request.action === "string" ? args.request.action.trim() : "";
+    const action = actionRaw === "cancel" || actionRaw === "get" || actionRaw === "list" ? actionRaw : "start";
+    const responseSubject = typeof args.request.responseSubject === "string" ? args.request.responseSubject.trim() : "";
+    if (!responseSubject) {
+        throw new Error("missing responseSubject");
+    }
+    const runId = typeof args.request.runId === "string" && args.request.runId.trim() ? args.request.runId.trim() : null;
+    const prompt = typeof args.request.prompt === "string" && args.request.prompt.trim() ? args.request.prompt.trim() : null;
+    const imagePaths = args.normalizeImagePaths(args.request.imagePaths);
+    const sessionId = typeof args.request.sessionId === "string" && args.request.sessionId.trim() ? args.request.sessionId.trim() : null;
+    const model = args.normalizeModel(args.request.model);
+    if (action === "start" && !prompt) {
+        throw new Error("missing prompt");
+    }
+    if ((action === "get" || action === "cancel") && !runId) {
+        throw new Error("missing runId");
+    }
+    const cwd = typeof args.request.cwd === "string" && args.request.cwd.trim() ? args.request.cwd.trim() : null;
+    const sinceSeqRaw = Number(args.request.sinceSeq);
+    const sinceSeq = Number.isInteger(sinceSeqRaw) && sinceSeqRaw >= 0 ? sinceSeqRaw : null;
+    const limitRaw = Number(args.request.limit);
+    const limit = Number.isFinite(limitRaw) ? Math.max(1, Math.min(Math.floor(limitRaw), 200)) : 50;
+    return {
+        requestId,
+        action,
+        runId,
+        prompt,
+        imagePaths,
+        sessionId,
+        model,
+        cwd,
+        responseSubject,
+        sinceSeq,
+        limit,
+        runtimeEnvPatch: args.normalizeEnvPatch(args.request.runtimeEnvPatch),
+        codexAuthBundle: args.normalizeCodexAuthBundle(args.request.codexAuth),
+    };
+}
+export function publishRunRpcResponse(args) {
+    args.nc.publish(args.responseSubject, runRpcCodec.encode(JSON.stringify(args.payload)));
+}
+export async function handleNonStartRunRpc(args) {
+    const { request } = args;
+    if (request.action === "list") {
+        const merged = (await args.listPersistedRunTasks())
+            .map((task) => args.cloneRunTask(task))
+            .sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt))
+            .slice(0, request.limit);
+        publishRunRpcResponse({
+            nc: args.nc,
+            responseSubject: request.responseSubject,
+            payload: { requestId: request.requestId, ok: true, tasks: merged },
+        });
+        return;
+    }
+    const stored = request.runId ? await args.getStoredRun(request.runId) : null;
+    if (!stored || stored.agentId !== args.agentId || stored.userId !== args.userId) {
+        throw new Error("Run not found");
+    }
+    if (request.action === "cancel") {
+        if (stored.processPid === null) {
+            throw new Error("Run pid not found");
+        }
+        stored.cancelRequested = true;
+        stored.updatedAt = args.formatTimestamp();
+        await args.persistRunTask(stored);
+        args.publishImmediateRunEvent(stored);
+        args.writeRunStatus(stored.id, `cancel requested pid=${stored.processPid}`);
+        args.sendSignalToPid(stored.processPid, "SIGINT");
+        publishRunRpcResponse({
+            nc: args.nc,
+            responseSubject: request.responseSubject,
+            payload: { requestId: request.requestId, ok: true, task: args.cloneRunTask(stored) },
+        });
+        return;
+    }
+    publishRunRpcResponse({
+        nc: args.nc,
+        responseSubject: request.responseSubject,
+        payload: { requestId: request.requestId, ok: true, task: args.cloneRunTask(stored, request.sinceSeq) },
+    });
+}

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;
+}