doer-agent 0.5.8 → 0.6.0

package/dist/agent-bundled-skills.js

@@ -0,0 +1,79 @@
+import path from "node:path";
+import { mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+const MANAGED_MARKER = "<!-- managed-by: doer-agent bundled-skill -->";
+const LEGACY_MANAGED_SKILLS_DIRS = [".doer", "doer-managed"];
+async function pathExists(target) {
+    try {
+        await stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function shouldWriteManagedSkill(targetFile) {
+    if (!(await pathExists(targetFile))) {
+        return true;
+    }
+    const current = await readFile(targetFile, "utf8").catch(() => "");
+    return current.includes(MANAGED_MARKER);
+}
+function withManagedMarker(source) {
+    const normalizedSource = source.trimEnd();
+    if (normalizedSource.includes(MANAGED_MARKER)) {
+        return `${normalizedSource}\n`;
+    }
+    const frontmatterMatch = normalizedSource.match(/^(---\n[\s\S]*?\n---)(\n?)([\s\S]*)$/);
+    if (frontmatterMatch) {
+        const [, frontmatter, , body] = frontmatterMatch;
+        return `${frontmatter}\n${MANAGED_MARKER}\n${body.replace(/^\n/, "")}\n`;
+    }
+    return `${MANAGED_MARKER}\n${normalizedSource}\n`;
+}
+async function removeLegacyManagedSkill(args) {
+    for (const legacyRoot of LEGACY_MANAGED_SKILLS_DIRS) {
+        const legacySkillDir = path.join(args.codexHome, "skills", legacyRoot, args.skillName);
+        const legacySkillFile = path.join(legacySkillDir, "SKILL.md");
+        if (!(await pathExists(legacySkillFile))) {
+            continue;
+        }
+        const current = await readFile(legacySkillFile, "utf8").catch(() => "");
+        if (!current.includes(MANAGED_MARKER)) {
+            continue;
+        }
+        await rm(legacySkillDir, { recursive: true, force: true });
+        args.onInfo?.(`legacy bundled skill removed name=${args.skillName} path=.codex/skills/${legacyRoot}/${args.skillName}`);
+    }
+}
+export async function ensureBundledDoerSkills(args) {
+    const sourceRootExists = await pathExists(args.bundledSkillsRoot);
+    if (!sourceRootExists) {
+        return;
+    }
+    const entries = await readdir(args.bundledSkillsRoot, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name.startsWith(".")) {
+            continue;
+        }
+        const sourceSkillDir = path.join(args.bundledSkillsRoot, entry.name);
+        const sourceSkillFile = path.join(sourceSkillDir, "SKILL.md");
+        const targetSkillDir = path.join(args.codexHome, "skills", entry.name);
+        const targetSkillFile = path.join(targetSkillDir, "SKILL.md");
+        try {
+            const source = await readFile(sourceSkillFile, "utf8");
+            if (!(await shouldWriteManagedSkill(targetSkillFile))) {
+                args.onInfo?.(`bundled skill skipped name=${entry.name} reason=user-managed-target`);
+                continue;
+            }
+            const managedSource = withManagedMarker(source);
+            await mkdir(targetSkillDir, { recursive: true });
+            await writeFile(targetSkillFile, managedSource, "utf8");
+            await removeLegacyManagedSkill({ codexHome: args.codexHome, skillName: entry.name, onInfo: args.onInfo });
+            args.onInfo?.(`bundled skill synced name=${entry.name} path=.codex/skills/${entry.name}/SKILL.md`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "unknown error";
+            args.onError?.(`bundled skill sync failed name=${entry.name} error=${message}`);
+        }
+    }
+}

package/dist/agent-codex-app-rpc.js

@@ -0,0 +1,63 @@
+import { StringCodec } from "nats";
+const codexAppRpcCodec = StringCodec();
+function normalizeCodexAppRpcRequest(args) {
+    const requestId = typeof args.request.requestId === "string" ? args.request.requestId.trim() : "";
+    const requestAgentId = typeof args.request.agentId === "string" ? args.request.agentId.trim() : "";
+    const actionRaw = typeof args.request.action === "string" ? args.request.action.trim() : "";
+    const method = typeof args.request.method === "string" ? args.request.method.trim() : "";
+    if (!requestId || !requestAgentId || requestAgentId !== args.agentId || actionRaw !== "request" || !method) {
+        throw new Error("invalid codex app rpc request");
+    }
+    return {
+        requestId,
+        action: "request",
+        method,
+        params: args.request.params,
+    };
+}
+async function handleCodexAppRpcMessage(args) {
+    let requestId = "unknown";
+    try {
+        const payload = JSON.parse(codexAppRpcCodec.decode(args.msg.data));
+        const request = normalizeCodexAppRpcRequest({ request: payload, agentId: args.agentId });
+        requestId = request.requestId;
+        const result = await args.manager.request(request.method, request.params);
+        args.msg.respond(codexAppRpcCodec.encode(JSON.stringify({
+            requestId,
+            ok: true,
+            result,
+        })));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        args.onError(`codex app rpc failed requestId=${requestId} error=${message}`);
+        args.msg.respond(codexAppRpcCodec.encode(JSON.stringify({
+            requestId,
+            ok: false,
+            error: message,
+        })));
+    }
+}
+export function subscribeToCodexAppRpc(args) {
+    args.nc.closed().finally(() => {
+        void args.manager.stop().catch(() => undefined);
+    });
+    args.nc.subscribe(args.subject, {
+        callback: (error, msg) => {
+            if (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                args.onError(`codex app rpc subscription error: ${message}`);
+                return;
+            }
+            void handleCodexAppRpcMessage({
+                msg,
+                nc: args.nc,
+                agentId: args.agentId,
+                manager: args.manager,
+                onInfo: args.onInfo,
+                onError: args.onError,
+            });
+        },
+    });
+    args.onInfo(`codex app rpc subscribed subject=${args.subject} eventsSubject=${args.eventsSubject}`);
+}

package/dist/agent-codex-auth-rpc.js

@@ -1,188 +1,114 @@
-import { spawn } from "node:child_process";
-import { unlink } from "node:fs/promises";
-import path from "node:path";
 import { StringCodec } from "nats";
 const codexAuthRpcCodec = StringCodec();
-let pendingCodexDeviceAuth = null;
-function parseCodexDeviceAuthOutput(raw, stripAnsi) {
-    const text = stripAnsi(raw);
-    const urlMatch = text.match(/https?:\/\/[^\s]+/i);
-    const codeMatch = text.match(/\b[A-Z0-9]{4,}(?:-[A-Z0-9]{4,})+\b/);
-    return {
-        verificationUri: urlMatch?.[0] ?? null,
-        userCode: codeMatch?.[0] ?? null,
-    };
+let pendingCodexAppLogin = null;
+function recordValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
 }
-function pendingCodexDeviceAuthMessage(state, stripAnsi) {
-    const parsed = parseCodexDeviceAuthOutput(state.output, stripAnsi);
-    if (parsed.verificationUri && parsed.userCode) {
-        return `Waiting for approval. Enter code ${parsed.userCode} at ${parsed.verificationUri}`;
+function normalizeCodexAuthRpcRequest(args) {
+    const requestId = stringValue(args.request.requestId) ?? "";
+    const responseSubject = stringValue(args.request.responseSubject) ?? "";
+    const requestAgentId = stringValue(args.request.agentId) ?? "";
+    const actionRaw = stringValue(args.request.action) ?? "";
+    const action = actionRaw === "start" || actionRaw === "logout" || actionRaw === "login_api_key" ? actionRaw : "status";
+    const apiKey = stringValue(args.request.apiKey);
+    if (!requestId || !responseSubject || !requestAgentId || requestAgentId !== args.agentId) {
+        throw new Error("invalid codex auth rpc request");
     }
-    return stripAnsi(state.output).trim() || "Waiting for approval";
+    if (action === "login_api_key" && !apiKey) {
+        throw new Error("api key is required");
+    }
+    return { requestId, responseSubject, action, apiKey };
 }
-async function getLocalCodexLoginStatus(args) {
-    const result = await args.runLocalCodexCli(["login", "status"], 5000);
-    const merged = args.stripAnsi([result.stdout, result.stderr].filter(Boolean).join("\n")).trim();
-    return {
-        loggedIn: (result.code ?? 1) === 0,
-        output: merged || ((result.code ?? 1) === 0 ? "Logged in" : "Not logged in"),
-    };
+function publishCodexAuthRpcResponse(args) {
+    args.nc.publish(args.responseSubject, codexAuthRpcCodec.encode(JSON.stringify(args.payload)));
 }
-async function waitForCodexDeviceCode(state, timeoutMs, stripAnsi) {
-    const startedAt = Date.now();
-    while (Date.now() - startedAt < timeoutMs) {
-        const parsed = parseCodexDeviceAuthOutput(state.output, stripAnsi);
-        if (parsed.verificationUri && parsed.userCode) {
-            return;
-        }
-        if (state.child.exitCode !== null) {
-            return;
-        }
-        await new Promise((resolve) => setTimeout(resolve, 100));
+function formatAccountStatus(result) {
+    const response = recordValue(result);
+    const account = recordValue(response?.account);
+    if (!account) {
+        return { loggedIn: false, output: "Not logged in" };
     }
-}
-async function startLocalCodexDeviceAuth(args) {
-    if (pendingCodexDeviceAuth && pendingCodexDeviceAuth.child.exitCode === null) {
-        const parsed = parseCodexDeviceAuthOutput(pendingCodexDeviceAuth.output, args.stripAnsi);
+    const type = stringValue(account.type);
+    if (type === "chatgpt") {
+        const email = stringValue(account.email);
+        const planType = stringValue(account.planType);
         return {
-            loggedIn: false,
-            output: pendingCodexDeviceAuthMessage(pendingCodexDeviceAuth, args.stripAnsi),
-            verificationUri: parsed.verificationUri,
-            userCode: parsed.userCode,
+            loggedIn: true,
+            output: `Logged in${email ? ` as ${email}` : ""}${planType ? ` (${planType})` : ""}`,
         };
     }
-    const child = spawn(args.buildLocalCodexCliCommand(["login", "--device-auth"]), {
-        cwd: args.workspaceRoot,
-        shell: args.resolveShellPath(),
-        detached: process.platform !== "win32",
-        env: {
-            ...process.env,
-            WORKSPACE: args.workspaceRoot,
-            CODEX_HOME: args.resolveCodexHomePath(),
-        },
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    child.stdout?.setEncoding("utf8");
-    child.stderr?.setEncoding("utf8");
-    const state = { child, output: "" };
-    pendingCodexDeviceAuth = state;
-    const appendOutput = (chunk) => {
-        state.output += chunk;
-    };
-    child.stdout?.on("data", appendOutput);
-    child.stderr?.on("data", appendOutput);
-    child.once("exit", () => {
-        if (pendingCodexDeviceAuth === state) {
-            pendingCodexDeviceAuth = null;
-        }
-    });
-    await waitForCodexDeviceCode(state, 8000, args.stripAnsi);
-    const parsed = parseCodexDeviceAuthOutput(state.output, args.stripAnsi);
-    if ((!parsed.verificationUri || !parsed.userCode) && state.child.exitCode !== null) {
-        throw new Error("Failed to read device code from Codex CLI");
+    if (type === "apiKey") {
+        return { loggedIn: true, output: "Logged in with API key" };
     }
-    return {
-        loggedIn: false,
-        output: pendingCodexDeviceAuthMessage(state, args.stripAnsi),
-        verificationUri: parsed.verificationUri,
-        userCode: parsed.userCode,
-    };
+    return { loggedIn: true, output: "Logged in" };
 }
-async function startLocalCodexLogin(args) {
-    const child = spawn(args.buildLocalCodexCliCommand(["login"]), {
-        cwd: args.workspaceRoot,
-        shell: args.resolveShellPath(),
-        detached: process.platform !== "win32",
-        env: {
-            ...process.env,
-            WORKSPACE: args.workspaceRoot,
-            CODEX_HOME: args.resolveCodexHomePath(),
-        },
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    let output = "";
-    child.stdout?.setEncoding("utf8");
-    child.stderr?.setEncoding("utf8");
-    child.stdout?.on("data", (chunk) => {
-        output += chunk;
-    });
-    child.stderr?.on("data", (chunk) => {
-        output += chunk;
-    });
-    const result = await new Promise((resolve, reject) => {
-        child.once("error", reject);
-        child.once("exit", (code) => resolve({ code, output }));
-    });
-    const normalized = args.stripAnsi(result.output).trim();
-    const parsed = parseCodexDeviceAuthOutput(result.output, args.stripAnsi);
-    if ((result.code ?? 1) === 0) {
-        const status = await args.getLocalCodexLoginStatus().catch(() => null);
+function formatPendingLogin() {
+    const pending = pendingCodexAppLogin;
+    if (!pending) {
+        return { loggedIn: false, output: "Not logged in" };
+    }
+    if (pending.verificationUri && pending.userCode) {
         return {
-            loggedIn: status?.loggedIn === true,
-            output: status?.output || normalized || "Login started",
-            verificationUri: parsed.verificationUri,
-            userCode: parsed.userCode,
+            loggedIn: false,
+            output: `Waiting for approval. Enter code ${pending.userCode} at ${pending.verificationUri}`,
+            verificationUri: pending.verificationUri,
+            userCode: pending.userCode,
         };
     }
-    throw new Error(normalized || `Codex login failed with code ${result.code ?? "null"}`);
+    if (pending.verificationUri) {
+        return {
+            loggedIn: false,
+            output: `Waiting for approval at ${pending.verificationUri}`,
+            verificationUri: pending.verificationUri,
+            userCode: null,
+        };
+    }
+    return { loggedIn: false, output: "Waiting for approval", verificationUri: null, userCode: null };
 }
-async function loginLocalCodexWithApiKey(args) {
-    const result = await args.runLocalCodexCliWithInput(["login", "--with-api-key"], args.apiKey, 15000);
-    const normalized = args.stripAnsi([result.stdout, result.stderr].filter(Boolean).join("\n")).trim();
-    if ((result.code ?? 1) !== 0) {
-        throw new Error(normalized || `Codex API key login failed with code ${result.code ?? "null"}`);
+async function readCodexAccount(manager) {
+    const status = formatAccountStatus(await manager.request("account/read", { refreshToken: false }));
+    if (status.loggedIn) {
+        pendingCodexAppLogin = null;
     }
-    const status = await args.getLocalCodexLoginStatus().catch(() => null);
-    return {
-        loggedIn: status?.loggedIn === true,
-        output: status?.output || normalized || "Logged in",
-        verificationUri: null,
-        userCode: null,
-    };
+    return status;
 }
-async function logoutLocalCodexAuth(args) {
-    if (pendingCodexDeviceAuth && pendingCodexDeviceAuth.child.exitCode === null) {
-        args.sendSignalToTaskProcess(pendingCodexDeviceAuth.child, "SIGTERM");
-        setTimeout(() => {
-            if (pendingCodexDeviceAuth?.child.exitCode === null) {
-                args.sendSignalToTaskProcess(pendingCodexDeviceAuth.child, "SIGKILL");
-            }
-        }, 1000);
-        pendingCodexDeviceAuth = null;
+async function startCodexDeviceLogin(manager) {
+    const status = await readCodexAccount(manager);
+    if (status.loggedIn) {
+        return status;
     }
-    const result = await args.runLocalCodexCli(["logout"], 5000);
-    let merged = args.stripAnsi([result.stdout, result.stderr].filter(Boolean).join("\n")).trim();
-    const statusAfterLogout = await args.getLocalCodexLoginStatus().catch(() => null);
-    if (statusAfterLogout?.loggedIn) {
-        const authFile = path.join(args.resolveCodexHomePath(), "auth.json");
-        await unlink(authFile).catch(() => undefined);
-        const statusAfterDelete = await args.getLocalCodexLoginStatus().catch(() => null);
-        if (statusAfterDelete?.output) {
-            merged = [merged, statusAfterDelete.output].filter(Boolean).join("\n");
-        }
+    if (pendingCodexAppLogin) {
+        return formatPendingLogin();
+    }
+    const result = recordValue(await manager.request("account/login/start", { type: "chatgptDeviceCode" }));
+    const loginId = stringValue(result?.loginId);
+    if (!loginId) {
+        throw new Error("Codex app-server did not return a login id");
     }
-    return {
-        loggedIn: false,
-        output: merged || "Logged out",
+    pendingCodexAppLogin = {
+        loginId,
+        verificationUri: stringValue(result?.verificationUrl),
+        userCode: stringValue(result?.userCode),
     };
+    return formatPendingLogin();
 }
-function normalizeCodexAuthRpcRequest(args) {
-    const requestId = typeof args.request.requestId === "string" ? args.request.requestId.trim() : "";
-    const responseSubject = typeof args.request.responseSubject === "string" ? args.request.responseSubject.trim() : "";
-    const requestAgentId = typeof args.request.agentId === "string" ? args.request.agentId.trim() : "";
-    const actionRaw = typeof args.request.action === "string" ? args.request.action.trim() : "";
-    const action = actionRaw === "start" || actionRaw === "logout" || actionRaw === "login_api_key" ? actionRaw : "status";
-    const apiKey = typeof args.request.apiKey === "string" && args.request.apiKey.trim() ? args.request.apiKey.trim() : null;
-    if (!requestId || !responseSubject || !requestAgentId || requestAgentId !== args.agentId) {
-        throw new Error("invalid codex auth rpc request");
-    }
-    if (action === "login_api_key" && !apiKey) {
-        throw new Error("api key is required");
-    }
-    return { requestId, responseSubject, action, apiKey };
+async function loginCodexWithApiKey(args) {
+    await args.manager.request("account/login/start", { type: "apiKey", apiKey: args.apiKey });
+    pendingCodexAppLogin = null;
+    const status = await readCodexAccount(args.manager);
+    return status.loggedIn ? status : { loggedIn: true, output: "Logged in with API key" };
 }
-function publishCodexAuthRpcResponse(args) {
-    args.nc.publish(args.responseSubject, codexAuthRpcCodec.encode(JSON.stringify(args.payload)));
+async function logoutCodexAccount(manager) {
+    const pending = pendingCodexAppLogin;
+    pendingCodexAppLogin = null;
+    if (pending) {
+        await manager.request("account/login/cancel", { loginId: pending.loginId }).catch(() => undefined);
+    }
+    await manager.request("account/logout", undefined);
+    return { loggedIn: false, output: "Logged out" };
 }
 async function handleCodexAuthRpcMessage(args) {
     let requestId = "unknown";
@@ -192,81 +118,20 @@ async function handleCodexAuthRpcMessage(args) {
         const request = normalizeCodexAuthRpcRequest({ request: payload, agentId: args.agentId });
         requestId = request.requestId;
         responseSubject = request.responseSubject;
-        const getStatus = () => getLocalCodexLoginStatus({
-            runLocalCodexCli: args.runLocalCodexCli,
-            stripAnsi: args.stripAnsi,
-        });
-        let result = null;
+        let result;
         if (request.action === "login_api_key") {
-            result = await loginLocalCodexWithApiKey({
-                apiKey: request.apiKey ?? "",
-                runLocalCodexCliWithInput: args.runLocalCodexCliWithInput,
-                stripAnsi: args.stripAnsi,
-                getLocalCodexLoginStatus: getStatus,
-            });
+            result = await loginCodexWithApiKey({ manager: args.manager, apiKey: request.apiKey ?? "" });
         }
         else if (request.action === "start") {
-            const status = await getStatus();
-            if (status.loggedIn) {
-                result = { loggedIn: true, output: status.output };
-            }
-            else {
-                try {
-                    result = await startLocalCodexDeviceAuth({
-                        workspaceRoot: args.workspaceRoot,
-                        buildLocalCodexCliCommand: args.buildLocalCodexCliCommand,
-                        resolveShellPath: args.resolveShellPath,
-                        resolveCodexHomePath: args.resolveCodexHomePath,
-                        stripAnsi: args.stripAnsi,
-                    });
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    const normalized = message.toLowerCase();
-                    if (normalized.includes("operation not permitted") ||
-                        normalized.includes("failed to read device code") ||
-                        normalized.includes("panic") ||
-                        normalized.includes("null object")) {
-                        result = await startLocalCodexLogin({
-                            workspaceRoot: args.workspaceRoot,
-                            buildLocalCodexCliCommand: args.buildLocalCodexCliCommand,
-                            resolveShellPath: args.resolveShellPath,
-                            resolveCodexHomePath: args.resolveCodexHomePath,
-                            stripAnsi: args.stripAnsi,
-                            getLocalCodexLoginStatus: getStatus,
-                        });
-                    }
-                    else {
-                        throw error;
-                    }
-                }
-            }
+            result = await startCodexDeviceLogin(args.manager);
         }
         else if (request.action === "logout") {
-            result = await logoutLocalCodexAuth({
-                sendSignalToTaskProcess: args.sendSignalToTaskProcess,
-                runLocalCodexCli: args.runLocalCodexCli,
-                stripAnsi: args.stripAnsi,
-                resolveCodexHomePath: args.resolveCodexHomePath,
-                getLocalCodexLoginStatus: getStatus,
-            });
+            result = await logoutCodexAccount(args.manager);
         }
         else {
-            const status = await getStatus();
-            if (status.loggedIn) {
-                result = { loggedIn: true, output: status.output };
-            }
-            else if (pendingCodexDeviceAuth && pendingCodexDeviceAuth.child.exitCode === null) {
-                const parsed = parseCodexDeviceAuthOutput(pendingCodexDeviceAuth.output, args.stripAnsi);
-                result = {
-                    loggedIn: false,
-                    output: pendingCodexDeviceAuthMessage(pendingCodexDeviceAuth, args.stripAnsi),
-                    verificationUri: parsed.verificationUri,
-                    userCode: parsed.userCode,
-                };
-            }
-            else {
-                result = { loggedIn: false, output: status.output || "Not logged in" };
+            result = await readCodexAccount(args.manager);
+            if (!result.loggedIn && pendingCodexAppLogin) {
+                result = formatPendingLogin();
             }
         }
         publishCodexAuthRpcResponse({
@@ -306,14 +171,7 @@ export function subscribeToCodexAuthRpc(args) {
                 msg,
                 nc: args.nc,
                 agentId: args.agentId,
-                workspaceRoot: args.workspaceRoot,
-                buildLocalCodexCliCommand: args.buildLocalCodexCliCommand,
-                resolveShellPath: args.resolveShellPath,
-                resolveCodexHomePath: args.resolveCodexHomePath,
-                runLocalCodexCli: args.runLocalCodexCli,
-                runLocalCodexCliWithInput: args.runLocalCodexCliWithInput,
-                sendSignalToTaskProcess: args.sendSignalToTaskProcess,
-                stripAnsi: args.stripAnsi,
+                manager: args.manager,
                 onError: args.onError,
             });
         },

package/dist/agent-codex-cli.js

@@ -55,16 +55,6 @@ export function buildDaemonMcpConfigArgs(args) {
         workspaceRootEnvName: "DOER_DAEMON_WORKSPACE_ROOT",
     });
 }
-export function buildDatabaseMcpConfigArgs(args) {
-    return buildWorkspaceMcpConfigArgs({
-        agentProjectDir: args.agentProjectDir,
-        workspaceRoot: args.workspaceRoot,
-        serverName: args.serverName?.trim() || "doer_database",
-        distEntryRelativePath: path.join("dist", "db-mcp-server.js"),
-        srcEntryRelativePath: path.join("src", "db-mcp-server.ts"),
-        workspaceRootEnvName: "DOER_DB_WORKSPACE_ROOT",
-    });
-}
 function buildWorkspaceMcpConfigArgs(args) {
     const serverName = args.serverName.trim();
     const distEntry = path.join(args.agentProjectDir, args.distEntryRelativePath);
@@ -240,7 +230,7 @@ export function normalizeShellRpcCodexAuthBundle(value) {
     }
     const row = value;
     const authJson = typeof row.authJson === "string" ? row.authJson : null;
-    const authMode = row.authMode === "oauth" ? "oauth" : row.authMode === "api_key" ? "api_key" : undefined;
+    const authMode = row.authMode === "chatgpt" ? "chatgpt" : row.authMode === "api_key" ? "api_key" : undefined;
     const apiKey = typeof row.apiKey === "string" || row.apiKey === null ? row.apiKey : undefined;
     if (!authJson && authMode !== "api_key" && apiKey === undefined) {
         return null;

package/dist/agent-runtime-utils.js

@@ -4,17 +4,11 @@ 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 buildAgentCodexAppRpcSubject(userId, agentId) {
+    return `doer.agent.codex.app.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 buildAgentCodexAppEventsSubject(userId, agentId) {
+    return `doer.agent.codex.app.events.${sanitizeUserId(userId)}.${agentId.trim()}`;
 }
 export function buildAgentSettingsRpcSubject(userId, agentId) {
     return `doer.agent.settings.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
@@ -78,25 +72,6 @@ export function normalizeEnvPatch(value) {
     }
     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;
-}
 const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
 const crc32Table = (() => {
     const table = new Uint32Array(256);
@@ -162,28 +137,6 @@ export function validateImageBytes(filePath, bytes) {
     }
     return null;
 }
-export async function filterValidRunImagePaths(args) {
-    const valid = [];
-    for (const imagePath of args.imagePaths) {
-        const absPath = path.isAbsolute(imagePath) ? imagePath : path.resolve(args.workspaceRoot, imagePath);
-        let bytes;
-        try {
-            bytes = await readFile(absPath);
-        }
-        catch (error) {
-            const reason = error instanceof Error ? error.message : "failed to read image";
-            args.onInvalidImage?.(imagePath, reason);
-            continue;
-        }
-        const validationError = validateImageBytes(absPath, bytes);
-        if (validationError) {
-            args.onInvalidImage?.(imagePath, validationError);
-            continue;
-        }
-        valid.push(imagePath);
-    }
-    return valid;
-}
 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;
@@ -207,20 +160,6 @@ export function writeRpcStream(requestId, stream, chunk) {
         target.write(`[doer-agent][rpc=${requestId}][${stream}] ${line}\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";

package/dist/agent-session-loop.js

@@ -46,7 +46,6 @@ export async function runConnectedAgentSession(args) {
     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);