doer-agent 0.4.2 → 0.4.4

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