doer-agent 0.6.2 → 0.6.4

package/dist/agent-maintenance-rpc.js

@@ -0,0 +1,161 @@
+import { execFile } from "node:child_process";
+import { spawn } from "node:child_process";
+import { promisify } from "node:util";
+import { StringCodec } from "nats";
+import { resolveAgentVersion } from "./agent-runtime-utils.js";
+const execFileAsync = promisify(execFile);
+const maintenanceRpcCodec = StringCodec();
+function normalizeAction(value) {
+    if (value === "info" || value === "update/check" || value === "update/restart") {
+        return value;
+    }
+    throw new Error("unsupported action");
+}
+function parseSemver(value) {
+    const match = value.trim().match(/^v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/);
+    if (!match) {
+        return null;
+    }
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function compareSemver(a, b) {
+    const left = parseSemver(a);
+    const right = parseSemver(b);
+    if (!left || !right) {
+        return null;
+    }
+    for (let index = 0; index < 3; index += 1) {
+        if (left[index] !== right[index]) {
+            return left[index] - right[index];
+        }
+    }
+    return 0;
+}
+async function resolveLatestPackageVersion() {
+    try {
+        const { stdout } = await execFileAsync("npm", ["view", "doer-agent", "version"], {
+            timeout: 15_000,
+            maxBuffer: 1024 * 64,
+        });
+        const version = stdout.trim().split(/\s+/)[0]?.trim() || "";
+        return version || null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveUpdateCommand(command) {
+    const rawCommand = command?.trim() || "";
+    if (!rawCommand) {
+        return null;
+    }
+    const replaced = rawCommand.replace(/(^|\s)npx(\s+-y)?\s+(?:doer-agent(?:@[^\s]+)?|\.)\b/, (_match, prefix, yesFlag) => `${prefix}npx${yesFlag ?? " -y"} doer-agent@latest`);
+    return replaced !== rawCommand ? replaced : null;
+}
+function shellQuote(value) {
+    if (/^[A-Za-z0-9_./:=@+-]+$/.test(value)) {
+        return value;
+    }
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function buildFallbackUpdateCommand() {
+    const workspace = process.env.WORKSPACE?.trim() || process.cwd();
+    const args = process.argv.slice(2).map(shellQuote).join(" ");
+    return [`WORKSPACE=${shellQuote(workspace)}`, "npx -y doer-agent@latest", args].filter(Boolean).join(" ");
+}
+async function resolveMaintenanceInfo(agentPackageJsonPath) {
+    const currentVersion = await resolveAgentVersion(agentPackageJsonPath);
+    const latestVersion = await resolveLatestPackageVersion();
+    const updateComparison = latestVersion ? compareSemver(currentVersion, latestVersion) : null;
+    const launchCommand = process.env.DOER_AGENT_LAUNCH_COMMAND?.trim() || process.env.DOER_DAEMON_COMMAND?.trim() || "";
+    const updateCommand = resolveUpdateCommand(launchCommand) ?? buildFallbackUpdateCommand();
+    return {
+        currentVersion,
+        latestVersion,
+        updateAvailable: updateComparison === null ? null : updateComparison < 0,
+        packageName: "doer-agent",
+        nodeVersion: process.version,
+        command: launchCommand || updateCommand,
+        updateCommand,
+        cwd: process.env.DOER_AGENT_LAUNCH_CWD?.trim() || process.env.DOER_DAEMON_CWD?.trim() || process.cwd(),
+        startedAt: new Date(Number(process.env.DOER_AGENT_STARTED_AT_MS || Date.now())).toISOString(),
+        canRestartToLatest: Boolean(updateCommand),
+    };
+}
+function scheduleRestartToLatest(command, cwd) {
+    setTimeout(() => {
+        const env = { ...process.env };
+        delete env.DOER_DAEMON_ID;
+        delete env.DOER_DAEMON_COMMAND;
+        delete env.DOER_DAEMON_CWD;
+        delete env.DOER_DAEMON_STATE_PATH;
+        delete env.DOER_DAEMON_EVENTS_PATH;
+        delete env.DOER_DAEMON_SHELL_PATH;
+        delete env.DOER_AGENT_LAUNCH_COMMAND;
+        delete env.DOER_AGENT_LAUNCH_CWD;
+        delete env.DOER_AGENT_LAUNCH_SHELL;
+        const child = spawn(command, {
+            cwd,
+            env,
+            shell: process.env.DOER_AGENT_LAUNCH_SHELL || process.env.DOER_DAEMON_SHELL_PATH || process.env.SHELL || true,
+            detached: true,
+            stdio: "ignore",
+        });
+        child.unref();
+        setTimeout(() => {
+            process.exit(0);
+        }, 250);
+    }, 250);
+}
+function publicMaintenanceInfo(info) {
+    return {
+        ...info,
+        command: null,
+        updateCommand: null,
+    };
+}
+export async function handleMaintenanceRpcMessage(args) {
+    let requestId = "unknown";
+    try {
+        const request = JSON.parse(maintenanceRpcCodec.decode(args.msg.data));
+        requestId = typeof request.requestId === "string" ? request.requestId : "unknown";
+        const action = normalizeAction(request.action);
+        const info = await resolveMaintenanceInfo(args.agentPackageJsonPath);
+        if (action === "update/restart") {
+            if (!info.updateCommand) {
+                throw new Error("agent was not started with a supported npx doer-agent command");
+            }
+            scheduleRestartToLatest(info.updateCommand, info.cwd);
+        }
+        args.msg.respond(maintenanceRpcCodec.encode(JSON.stringify({
+            requestId,
+            ok: true,
+            action,
+            info: publicMaintenanceInfo(info),
+            restartScheduled: action === "update/restart",
+        })));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        args.onError?.(`maintenance rpc failed requestId=${requestId} error=${message}`);
+        args.msg.respond(maintenanceRpcCodec.encode(JSON.stringify({ requestId, ok: false, error: message })));
+    }
+}
+export function subscribeToMaintenanceRpc(args) {
+    args.nc.subscribe(args.subject, {
+        callback: (error, msg) => {
+            if (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                args.onError(`maintenance rpc subscription error: ${message}`);
+                return;
+            }
+            void handleMaintenanceRpcMessage({
+                msg,
+                nc: args.nc,
+                agentPackageJsonPath: args.agentPackageJsonPath,
+                onError: args.onError,
+            });
+        },
+    });
+    args.onInfo(`maintenance rpc subscribed subject=${args.subject}`);
+}

package/dist/agent-runtime-utils.js

@@ -25,6 +25,9 @@ export function buildAgentFsRpcSubject(userId, agentId) {
 export function buildAgentDaemonRpcSubject(userId, agentId) {
     return `doer.agent.daemon.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
 }
+export function buildAgentMaintenanceRpcSubject(userId, agentId) {
+    return `doer.agent.maintenance.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
+}
 export function parseBootstrapTaskConfig(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return null;

package/dist/agent.js

@@ -12,8 +12,9 @@ import { createLocalCodexCliTools } from "./agent-codex-cli.js";
 import { connectBootstrapWithRetry } from "./agent-jetstream.js";
 import { runConnectedAgentSession } from "./agent-session-loop.js";
 import { subscribeToSkillRpc } from "./agent-skill-rpc.js";
+import { subscribeToMaintenanceRpc } from "./agent-maintenance-rpc.js";
 import { sendSignalToTaskProcess } from "./agent-task-execution.js";
-import { buildAgentCodexAppEventsSubject, buildAgentCodexAppRpcSubject, buildAgentDaemonRpcSubject, buildAgentFsRpcSubject, buildAgentGitRpcSubject, buildAgentSettingsRpcSubject, buildAgentSkillRpcSubject, formatLocalTimestamp, parseArgs, resolveAgentVersion, resolveArgOrEnv, resolveContainerReachableServerBaseUrl, sanitizeUserId, sleep, } from "./agent-runtime-utils.js";
+import { buildAgentCodexAppEventsSubject, buildAgentCodexAppRpcSubject, buildAgentDaemonRpcSubject, buildAgentFsRpcSubject, buildAgentGitRpcSubject, buildAgentMaintenanceRpcSubject, buildAgentSettingsRpcSubject, buildAgentSkillRpcSubject, formatLocalTimestamp, parseArgs, resolveAgentVersion, resolveArgOrEnv, resolveContainerReachableServerBaseUrl, sanitizeUserId, sleep, } from "./agent-runtime-utils.js";
 import { createRuntimeEnvHelpers } from "./agent-runtime-env.js";
 import { createEventPersistenceHelpers, heartbeatAgentSession, postJson, } from "./agent-runtime-io.js";
 import { handleSettingsRpcMessage } from "./agent-settings-rpc.js";
@@ -162,6 +163,7 @@ async function main() {
     process.chdir(startupWorkspaceRoot);
     process.env.WORKSPACE = startupWorkspaceRoot;
     process.env.CODEX_HOME = path.join(startupWorkspaceRoot, ".codex");
+    process.env.DOER_AGENT_STARTED_AT_MS = String(Date.now());
     await mkdir(process.env.CODEX_HOME, { recursive: true }).catch(() => undefined);
     const serverBaseUrlRaw = resolveArgOrEnv(args, ["server", "url"], ["DOER_AGENT_SERVER"], DEFAULT_SERVER_BASE_URL);
     const requestedServerBaseUrl = serverBaseUrlRaw.replace(/\/$/, "");
@@ -293,6 +295,13 @@ async function main() {
                     onInfo: writeAgentInfo,
                     onError: writeAgentError,
                 });
+                subscribeToMaintenanceRpc({
+                    nc: jetstream.nc,
+                    subject: buildAgentMaintenanceRpcSubject(userId, initialAgentId),
+                    agentPackageJsonPath: AGENT_PACKAGE_JSON_PATH,
+                    onInfo: writeAgentInfo,
+                    onError: writeAgentError,
+                });
             },
             onInfraError: writeAgentInfraError,
             sleep,

package/dist/codex-app-server-client.js

@@ -1,5 +1,17 @@
 import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import path from "node:path";
 import { createInterface } from "node:readline";
+const require = createRequire(import.meta.url);
+function resolveCodexCliBinPath() {
+    const packageJsonPath = require.resolve("@openai/codex/package.json");
+    const packageJson = require(packageJsonPath);
+    const codexBin = packageJson.bin?.codex;
+    if (!codexBin) {
+        throw new Error("@openai/codex package does not expose a codex binary");
+    }
+    return path.resolve(path.dirname(packageJsonPath), codexBin);
+}
 export class CodexAppServerClient {
     options;
     child = null;
@@ -46,7 +58,7 @@ export class CodexAppServerClient {
         }
     }
     async startInner() {
-        this.child = spawn("codex", this.options.args, {
+        this.child = spawn(process.execPath, [resolveCodexCliBinPath(), ...this.options.args], {
             cwd: this.options.cwd,
             env: this.options.env,
             stdio: ["pipe", "pipe", "pipe"],

package/dist/codex-app-server-manager.js

@@ -28,6 +28,7 @@ async function buildCodexAppServerArgs(args) {
             agentProjectDir: args.agentProjectDir,
             workspaceRoot: args.workspaceRoot,
         }),
+        ...buildFeatureArg(true, "goals"),
         ...buildFeatureArg(args.settings.codex.computerUseEnabled, "computer_use"),
         ...buildFeatureArg(args.settings.codex.browserUseEnabled, "browser_use"),
         "--listen",

package/dist/daemon-log-runner.js

@@ -62,6 +62,9 @@ async function main() {
     const cwd = readRequiredEnv("DOER_DAEMON_CWD");
     const shellPath = readRequiredEnv("DOER_DAEMON_SHELL_PATH");
     const childEnv = { ...process.env };
+    childEnv.DOER_AGENT_LAUNCH_COMMAND = command;
+    childEnv.DOER_AGENT_LAUNCH_CWD = cwd;
+    childEnv.DOER_AGENT_LAUNCH_SHELL = shellPath;
     delete childEnv.DOER_DAEMON_STATE_PATH;
     delete childEnv.DOER_DAEMON_EVENTS_PATH;
     delete childEnv.DOER_DAEMON_COMMAND;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doer-agent",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",
@@ -24,13 +24,14 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.27.1",
-    "@openai/codex-sdk": "^0.128.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@openai/codex": "^0.129.0",
+    "@openai/codex-sdk": "^0.129.0",
     "nats": "^2.29.3",
-    "tar": "^7.5.13"
+    "tar": "^7.5.15"
   },
   "devDependencies": {
-    "@types/node": "^20",
+    "@types/node": "^20.19.40",
     "tsx": "^4.21.0",
     "typescript": "^5"
   }