doer-agent 0.4.1 → 0.4.3

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

package/dist/agent-runtime-utils.js

@@ -0,0 +1,253 @@
+import { readFile } from "node:fs/promises";
+export function sanitizeUserId(userId) {
+    const normalized = userId.trim().replace(/[^a-zA-Z0-9_-]/g, "_");
+    return normalized.length > 0 ? normalized : "anonymous";
+}
+export function buildAgentRunRpcSubject(userId, agentId) {
+    return `doer.agent.run.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
+}
+export function buildAgentRunEventsSubject(userId, agentId) {
+    return `doer.agent.run.events.${sanitizeUserId(userId)}.${agentId.trim()}`;
+}
+export function buildAgentSessionRpcSubject(userId, agentId) {
+    return `doer.agent.session.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
+}
+export function buildAgentCodexAuthRpcSubject(userId, agentId) {
+    return `doer.agent.codex.auth.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
+}
+export function buildAgentSettingsRpcSubject(userId, agentId) {
+    return `doer.agent.settings.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
+}
+export function buildAgentGitRpcSubject(userId, agentId) {
+    return `doer.agent.git.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
+}
+export function buildAgentSkillRpcSubject(userId, agentId) {
+    return `doer.agent.skill.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
+}
+export function buildAgentFsRpcSubject(userId, agentId) {
+    return `doer.agent.fs.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
+}
+export function parseBootstrapTaskConfig(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const task = value;
+    const stream = typeof task.stream === "string" ? task.stream.trim() : "";
+    const subject = typeof task.subject === "string" ? task.subject.trim() : "";
+    const durable = typeof task.durable === "string" ? task.durable.trim() : "";
+    if (!stream || !subject || !durable) {
+        return null;
+    }
+    return { stream, subject, durable };
+}
+export function normalizeTaskIds(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const out = [];
+    for (const item of value) {
+        if (typeof item !== "string") {
+            continue;
+        }
+        const id = item.trim();
+        if (!id) {
+            continue;
+        }
+        out.push(id);
+    }
+    return out;
+}
+export function normalizeEnvPatch(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {};
+    }
+    const out = {};
+    for (const [key, raw] of Object.entries(value)) {
+        if (typeof raw !== "string") {
+            continue;
+        }
+        const normalizedKey = key.trim();
+        if (!normalizedKey) {
+            continue;
+        }
+        out[normalizedKey] = raw;
+    }
+    return out;
+}
+export function normalizeRunImagePaths(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const seen = new Set();
+    const out = [];
+    for (const item of value) {
+        if (typeof item !== "string") {
+            continue;
+        }
+        const normalized = item.trim();
+        if (!normalized || seen.has(normalized)) {
+            continue;
+        }
+        seen.add(normalized);
+        out.push(normalized);
+    }
+    return out;
+}
+export function fatalExit(message, error, writeAgentError) {
+    const detail = error instanceof Error ? error.message : typeof error === "string" ? error : error ? String(error) : "";
+    const full = detail ? `${message}: ${detail}` : message;
+    writeAgentError(`fatal: ${full}`);
+    process.exit(1);
+}
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function writeTaskStream(taskId, stream, chunk) {
+    const target = stream === "stdout" ? process.stdout : process.stderr;
+    const lines = chunk.replace(/\r/g, "\n").split("\n");
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (line.length === 0 && i === lines.length - 1) {
+            continue;
+        }
+        target.write(`[doer-agent][task=${taskId}][${stream}] ${line}\n`);
+    }
+}
+export function writeTaskUpload(taskId, message) {
+    process.stdout.write(`[doer-agent][task=${taskId}][upload] ${message}\n`);
+}
+export function writeRpcStream(requestId, stream, chunk) {
+    const target = stream === "stdout" ? process.stdout : process.stderr;
+    const lines = chunk.replace(/\r/g, "\n").split("\n");
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (line.length === 0 && i === lines.length - 1) {
+            continue;
+        }
+        target.write(`[doer-agent][rpc=${requestId}][${stream}] ${line}\n`);
+    }
+}
+export function writeRpcStatus(requestId, message) {
+    process.stdout.write(`[doer-agent][rpc=${requestId}][status] ${message}\n`);
+}
+export function writeRunStatus(runId, message) {
+    process.stdout.write(`[doer-agent][run=${runId}][status] ${message}\n`);
+}
+export function writeRunStream(runId, stream, chunk) {
+    const target = stream === "stdout" ? process.stdout : process.stderr;
+    const lines = chunk.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (!line && index === lines.length - 1) {
+            continue;
+        }
+        target.write(`[doer-agent][run=${runId}][${stream}] ${line}\n`);
+    }
+}
+function resolveLogTimeZone() {
+    const configured = process.env.DOER_AGENT_LOG_TIMEZONE?.trim() || process.env.TZ?.trim();
+    return configured && configured.length > 0 ? configured : "Asia/Seoul";
+}
+function resolveTimeZoneOffsetString(date, timeZone) {
+    try {
+        const parts = new Intl.DateTimeFormat("en-US", {
+            timeZone,
+            timeZoneName: "shortOffset",
+            hour: "2-digit",
+            minute: "2-digit",
+            hour12: false,
+        }).formatToParts(date);
+        const token = parts.find((part) => part.type === "timeZoneName")?.value || "GMT+0";
+        const matched = token.match(/GMT([+-]\d{1,2})(?::?(\d{2}))?/i);
+        if (!matched) {
+            return "+00:00";
+        }
+        const hourRaw = matched[1] || "+0";
+        const minuteRaw = matched[2] || "00";
+        const sign = hourRaw.startsWith("-") ? "-" : "+";
+        const absHour = String(Math.abs(Number.parseInt(hourRaw, 10))).padStart(2, "0");
+        const absMinute = String(Math.abs(Number.parseInt(minuteRaw, 10))).padStart(2, "0");
+        return `${sign}${absHour}:${absMinute}`;
+    }
+    catch {
+        return "+00:00";
+    }
+}
+export function formatLocalTimestamp(date = new Date()) {
+    const timeZone = resolveLogTimeZone();
+    try {
+        const parts = new Intl.DateTimeFormat("en-CA", {
+            timeZone,
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            second: "2-digit",
+            hour12: false,
+        }).formatToParts(date);
+        const pick = (type) => {
+            return parts.find((part) => part.type === type)?.value || "00";
+        };
+        const year = pick("year");
+        const month = pick("month");
+        const day = pick("day");
+        const hours = pick("hour");
+        const minutes = pick("minute");
+        const seconds = pick("second");
+        const ms = String(date.getMilliseconds()).padStart(3, "0");
+        const offset = resolveTimeZoneOffsetString(date, timeZone);
+        return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${ms}${offset}`;
+    }
+    catch {
+        return date.toISOString();
+    }
+}
+export function parseArgs(argv) {
+    const out = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const key = argv[i];
+        if (!key.startsWith("--")) {
+            continue;
+        }
+        const value = argv[i + 1];
+        if (typeof value === "string" && !value.startsWith("--")) {
+            out[key.slice(2)] = value;
+            i += 1;
+            continue;
+        }
+        out[key.slice(2)] = "true";
+    }
+    return out;
+}
+export function resolveArgOrEnv(args, argKeys, envKeys, fallback = "") {
+    for (const key of argKeys) {
+        const value = args[key]?.trim();
+        if (value) {
+            return value;
+        }
+    }
+    for (const key of envKeys) {
+        const value = process.env[key]?.trim();
+        if (value) {
+            return value;
+        }
+    }
+    return fallback;
+}
+export function resolveContainerReachableServerBaseUrl(serverBaseUrl) {
+    return serverBaseUrl;
+}
+export async function resolveAgentVersion(packageJsonPath) {
+    const raw = await readFile(packageJsonPath, "utf8").catch(() => "");
+    if (!raw) {
+        return "unknown";
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed.version === "string" && parsed.version.trim() ? parsed.version.trim() : "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}

package/dist/agent-session-loop.js

@@ -0,0 +1,53 @@
+export async function runConnectedAgentSession(args) {
+    let heartbeatFailures = 0;
+    let heartbeatInFlight = false;
+    let sessionInvalidated = false;
+    const invalidateAgentSession = (reason) => {
+        if (sessionInvalidated) {
+            return;
+        }
+        sessionInvalidated = true;
+        args.onInfraError(`closing nats session: ${reason}`);
+        void args.jetstream.nc.close().catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            args.onInfraError(`failed to close nats session: ${message}`);
+        });
+    };
+    const heartbeatTimer = setInterval(() => {
+        if (heartbeatInFlight || sessionInvalidated) {
+            return;
+        }
+        heartbeatInFlight = true;
+        void args.heartbeatAgentSession({
+            nc: args.jetstream.nc,
+            serverBaseUrl: args.serverBaseUrl,
+            userId: args.userId,
+            agentToken: args.agentToken,
+        })
+            .then(() => {
+            heartbeatInFlight = false;
+            if (heartbeatFailures > 0) {
+                args.onInfraError(`heartbeat reconnected at=${args.formatTimestamp()}`);
+            }
+            heartbeatFailures = 0;
+        })
+            .catch((error) => {
+            heartbeatInFlight = false;
+            const message = error instanceof Error ? error.message : String(error);
+            heartbeatFailures += 1;
+            if (heartbeatFailures > 1) {
+                args.onInfraError(`heartbeat failed: ${message} (count=${heartbeatFailures}/${args.heartbeatFailureThreshold})`);
+            }
+            if (heartbeatFailures >= args.heartbeatFailureThreshold) {
+                invalidateAgentSession(`heartbeat failure threshold reached at=${args.formatTimestamp()}`);
+            }
+        });
+    }, args.heartbeatIntervalMs);
+    args.subscribeAll();
+    const closeError = await args.jetstream.nc.closed();
+    clearInterval(heartbeatTimer);
+    args.stopAllSessionWatchers();
+    const detail = closeError instanceof Error ? closeError.message : "clean close";
+    args.onInfraError(`nats session ended: ${detail}; reconnecting`);
+    await args.sleep(1000);
+}