doer-agent 0.1.8 → 0.2.0

package/dist/agent.js

@@ -1,16 +1,18 @@
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync, statSync } from "node:fs";
-import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
+import { chmod, mkdir, open, readFile, readdir, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { AckPolicy, connect, DeliverPolicy, JSONCodec, RetentionPolicy, StorageType } from "nats";
+import { AckPolicy, connect, DeliverPolicy, JSONCodec, RetentionPolicy, StorageType, StringCodec } from "nats";
 const DEFAULT_SERVER_BASE_URL = "https://doer.cranix.net";
 const AGENT_MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 const AGENT_PROJECT_DIR = path.join(AGENT_MODULE_DIR, "..");
 const AGENT_PACKAGE_JSON_PATH = path.join(AGENT_PROJECT_DIR, "package.json");
 let activeTaskLogContext = null;
 const activeTaskCancelRequests = new Map();
+let workspaceRootOverride = null;
+const fsRpcCodec = StringCodec();
+const shellRpcCodec = StringCodec();
 function sanitizeUserId(userId) {
     const normalized = userId.trim().replace(/[^a-zA-Z0-9_-]/g, "_");
     return normalized.length > 0 ? normalized : "anonymous";
@@ -135,7 +137,8 @@ async function initJetStreamContext(args) {
     };
 }
 function resolveCodexHomePath() {
-    return path.join(homedir(), ".codex");
+    const workspaceRoot = workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
+    return path.join(workspaceRoot, ".codex");
 }
 function parseEnvBoolean(value) {
     return value?.trim().toLowerCase() === "true";
@@ -510,7 +513,7 @@ function resolveShellPath() {
     throw new Error("No shell executable found. Set SHELL env or install /bin/sh (or bash).");
 }
 function resolveTaskWorkspace(rawCwd) {
-    const workspaceRoot = process.env.WORKSPACE?.trim() || process.cwd();
+    const workspaceRoot = workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
     const requestedCwd = rawCwd?.trim() || "";
     const resolvedCwd = requestedCwd
         ? path.isAbsolute(requestedCwd)
@@ -533,6 +536,341 @@ function resolveTaskWorkspace(rawCwd) {
     }
     return resolvedCwd;
 }
+function buildAgentFsRpcSubject(userId, agentId) {
+    return `doer.agent.fs.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
+}
+function buildAgentShellRpcSubject(userId, agentId) {
+    return `doer.agent.shell.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
+}
+function normalizeFsRpcPath(rawPath) {
+    const root = workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
+    const raw = typeof rawPath === "string" && rawPath.trim() ? rawPath.trim() : ".";
+    const normalizedRaw = raw.replace(/\\/g, "/");
+    const useAbsolute = path.isAbsolute(normalizedRaw);
+    const rel = normalizedRaw.replace(/^\/+/, "") || ".";
+    const abs = useAbsolute ? path.resolve(normalizedRaw) : path.resolve(root, rel);
+    if (!useAbsolute && abs !== root && !abs.startsWith(root + path.sep)) {
+        throw new Error("path escapes workspace root");
+    }
+    const formatPath = (target) => {
+        if (useAbsolute) {
+            return target.split(path.sep).join("/") || "/";
+        }
+        return path.relative(root, target).split(path.sep).join("/") || ".";
+    };
+    return { abs, formatPath };
+}
+function parseFsRpcAction(value) {
+    if (value === "list" || value === "stat" || value === "fetch_file" || value === "read_text") {
+        return value;
+    }
+    throw new Error("unsupported action");
+}
+function normalizeFsRpcNumber(value, fallback) {
+    const n = Number(value);
+    if (!Number.isFinite(n)) {
+        return fallback;
+    }
+    return Math.floor(n);
+}
+async function executeFsRpc(args) {
+    const action = parseFsRpcAction(args.request.action);
+    const { abs, formatPath } = normalizeFsRpcPath(args.request.path);
+    if (action === "stat") {
+        const entry = await stat(abs);
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            kind: entry.isDirectory() ? "dir" : "file",
+            size: entry.size,
+            mtimeMs: entry.mtimeMs,
+        };
+    }
+    if (action === "list") {
+        const entry = await stat(abs);
+        if (!entry.isDirectory()) {
+            throw new Error("path is not a directory");
+        }
+        const limit = Math.max(1, Math.min(normalizeFsRpcNumber(args.request.limit, 200), 1000));
+        const rows = await readdir(abs, { withFileTypes: true });
+        const items = await Promise.all(rows.map(async (row) => {
+            const child = path.join(abs, row.name);
+            const childStat = await stat(child);
+            return {
+                name: row.name,
+                path: formatPath(child),
+                kind: row.isDirectory() ? "dir" : "file",
+                size: childStat.size,
+                mtimeMs: childStat.mtimeMs,
+            };
+        }));
+        items.sort((a, b) => (a.kind === b.kind ? a.name.localeCompare(b.name) : a.kind === "dir" ? -1 : 1));
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            items: items.slice(0, limit),
+            truncated: items.length > limit,
+            total: items.length,
+        };
+    }
+    if (action === "fetch_file") {
+        const entry = await stat(abs);
+        if (!entry.isFile()) {
+            throw new Error("path is not a file");
+        }
+        const uploadUrl = typeof args.request.uploadUrl === "string" ? args.request.uploadUrl : "";
+        const chatId = typeof args.request.chatId === "string" ? args.request.chatId : "";
+        const agentId = typeof args.request.agentId === "string" ? args.request.agentId : "";
+        if (!uploadUrl || !chatId || !agentId) {
+            throw new Error("missing upload parameters");
+        }
+        const data = await readFile(abs);
+        const fileName = path.basename(abs) || "file";
+        const form = new FormData();
+        form.append("file", new File([data], fileName));
+        form.append("chatId", chatId);
+        form.append("agentId", agentId);
+        const response = await fetch(uploadUrl, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${args.agentToken}` },
+            body: form,
+        });
+        const text = await response.text();
+        let upload = {};
+        try {
+            upload = JSON.parse(text || "{}");
+        }
+        catch {
+            upload = {};
+        }
+        if (!response.ok) {
+            const message = typeof upload.error === "string" ? upload.error : `upload failed: ${response.status}`;
+            throw new Error(message);
+        }
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            size: entry.size,
+            upload,
+        };
+    }
+    const entry = await stat(abs);
+    if (!entry.isFile()) {
+        throw new Error("path is not a file");
+    }
+    const offset = Math.max(0, normalizeFsRpcNumber(args.request.offset, 0));
+    const length = Math.max(1, Math.min(normalizeFsRpcNumber(args.request.length, 65536), 262144));
+    const encoding = typeof args.request.encoding === "string" && args.request.encoding ? args.request.encoding : "utf8";
+    const fd = await open(abs, "r");
+    try {
+        const buffer = Buffer.alloc(length);
+        const readResult = await fd.read(buffer, 0, length, offset);
+        const slice = buffer.subarray(0, readResult.bytesRead);
+        try {
+            const text = slice.toString(encoding);
+            return {
+                ok: true,
+                action,
+                path: formatPath(abs),
+                offset,
+                length: readResult.bytesRead,
+                totalSize: entry.size,
+                eof: offset + readResult.bytesRead >= entry.size,
+                encoding,
+                text,
+                bytesRead: readResult.bytesRead,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "failed to decode text";
+            return {
+                ok: false,
+                action,
+                path: formatPath(abs),
+                error: message,
+            };
+        }
+    }
+    finally {
+        await fd.close();
+    }
+}
+async function handleFsRpcMessage(args) {
+    let payload = {};
+    try {
+        payload = JSON.parse(fsRpcCodec.decode(args.msg.data));
+        if (typeof payload.agentId === "string" && payload.agentId.trim() && payload.agentId !== args.agentId) {
+            throw new Error("agent id mismatch");
+        }
+        const result = await executeFsRpc({ request: payload, agentToken: args.agentToken });
+        args.msg.respond(fsRpcCodec.encode(JSON.stringify(result)));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "unknown error";
+        const action = typeof payload.action === "string" ? payload.action : "";
+        const response = {
+            ok: false,
+            action,
+            path: typeof payload.path === "string" ? payload.path : ".",
+            error: message,
+        };
+        args.msg.respond(fsRpcCodec.encode(JSON.stringify(response)));
+        writeAgentError(`fs rpc failed action=${action || "unknown"} error=${message}`);
+    }
+}
+function subscribeToFsRpc(args) {
+    const subject = buildAgentFsRpcSubject(args.userId, args.agentId);
+    args.jetstream.nc.subscribe(subject, {
+        callback: (error, msg) => {
+            if (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                writeAgentError(`fs rpc subscription error: ${message}`);
+                return;
+            }
+            void handleFsRpcMessage({
+                msg,
+                serverBaseUrl: args.serverBaseUrl,
+                userId: args.userId,
+                agentId: args.agentId,
+                agentToken: args.agentToken,
+            });
+        },
+    });
+    writeAgentInfo(`fs rpc subscribed subject=${subject}`);
+}
+function normalizeShellRpcRequest(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) {
+        throw new Error("missing agentId");
+    }
+    if (requestAgentId !== args.agentId) {
+        throw new Error("agent id mismatch");
+    }
+    const command = typeof args.request.command === "string" ? args.request.command.trim() : "";
+    if (!command) {
+        throw new Error("missing command");
+    }
+    const responseSubject = typeof args.request.responseSubject === "string" ? args.request.responseSubject.trim() : "";
+    if (!responseSubject) {
+        throw new Error("missing responseSubject");
+    }
+    const cwd = typeof args.request.cwd === "string" && args.request.cwd.trim() ? args.request.cwd.trim() : null;
+    const timeoutRaw = Number(args.request.timeoutMs);
+    const timeoutMs = Number.isFinite(timeoutRaw) ? Math.max(1000, Math.min(Math.floor(timeoutRaw), 300000)) : 30000;
+    return { requestId, command, cwd, timeoutMs, responseSubject };
+}
+function publishShellRpcResponse(args) {
+    args.nc.publish(args.responseSubject, shellRpcCodec.encode(JSON.stringify(args.payload)));
+}
+async function handleShellRpcMessage(args) {
+    let requestId = "unknown";
+    let responseSubject = "";
+    let stdout = "";
+    let stderr = "";
+    try {
+        const payload = JSON.parse(shellRpcCodec.decode(args.msg.data));
+        const request = normalizeShellRpcRequest({ request: payload, agentId: args.agentId });
+        requestId = request.requestId;
+        responseSubject = request.responseSubject;
+        const shellPath = resolveShellPath();
+        const taskWorkspace = resolveTaskWorkspace(request.cwd);
+        const runtimeBinPath = path.join(AGENT_PROJECT_DIR, "runtime/bin");
+        const taskPath = [runtimeBinPath, process.env.PATH || ""].filter(Boolean).join(path.delimiter);
+        const child = spawn(request.command, {
+            cwd: taskWorkspace,
+            shell: shellPath,
+            detached: process.platform !== "win32",
+            env: {
+                ...process.env,
+                WORKSPACE: taskWorkspace,
+                PATH: taskPath,
+            },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        let timedOut = false;
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            sendSignalToTaskProcess(child, "SIGTERM");
+            setTimeout(() => {
+                sendSignalToTaskProcess(child, "SIGKILL");
+            }, 1000).unref?.();
+        }, request.timeoutMs);
+        timeout.unref?.();
+        const result = await new Promise((resolve, reject) => {
+            child.once("error", reject);
+            child.once("close", (code, signal) => {
+                resolve({ exitCode: typeof code === "number" ? code : null, signal });
+            });
+        }).finally(() => {
+            clearTimeout(timeout);
+        });
+        publishShellRpcResponse({
+            nc: args.jetstream.nc,
+            responseSubject,
+            payload: {
+                requestId,
+                ok: !timedOut,
+                exitCode: result.exitCode,
+                signal: result.signal,
+                stdout,
+                stderr,
+                ...(timedOut ? { error: `Command timed out after ${request.timeoutMs}ms` } : {}),
+            },
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (responseSubject) {
+            publishShellRpcResponse({
+                nc: args.jetstream.nc,
+                responseSubject,
+                payload: {
+                    requestId,
+                    ok: false,
+                    exitCode: null,
+                    signal: null,
+                    stdout,
+                    stderr,
+                    error: message,
+                },
+            });
+        }
+        writeAgentError(`shell rpc failed requestId=${requestId} error=${message}`);
+    }
+}
+function subscribeToShellRpc(args) {
+    const subject = buildAgentShellRpcSubject(args.userId, args.agentId);
+    args.jetstream.nc.subscribe(subject, {
+        callback: (error, msg) => {
+            if (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                writeAgentError(`shell rpc subscription error: ${message}`);
+                return;
+            }
+            void handleShellRpcMessage({
+                msg,
+                jetstream: args.jetstream,
+                agentId: args.agentId,
+            });
+        },
+    });
+    writeAgentInfo(`shell rpc subscribed subject=${subject}`);
+}
 async function postJson(url, body) {
     const res = await fetch(url, {
         method: "POST",
@@ -959,9 +1297,9 @@ async function connectBootstrapWithRetry(args) {
 async function main() {
     const args = parseArgs(process.argv.slice(2));
     const workspaceDir = resolveArgOrEnv(args, ["workspace-dir", "workspaceDir"], ["WORKSPACE"]);
-    if (workspaceDir) {
-        process.chdir(path.resolve(workspaceDir));
-    }
+    const startupWorkspaceRoot = path.resolve(workspaceDir || process.cwd());
+    workspaceRootOverride = startupWorkspaceRoot;
+    process.chdir(startupWorkspaceRoot);
     const serverBaseUrlRaw = resolveArgOrEnv(args, ["server", "url"], ["DOER_AGENT_SERVER"], DEFAULT_SERVER_BASE_URL);
     const requestedServerBaseUrl = serverBaseUrlRaw.replace(/\/$/, "");
     const serverBaseUrl = resolveContainerReachableServerBaseUrl(requestedServerBaseUrl);
@@ -979,12 +1317,16 @@ async function main() {
     });
     const maxConcurrency = Math.max(1, parseEnvInteger(process.env.DOER_AGENT_MAX_CONCURRENCY, 5));
     const agentVersion = await resolveAgentVersion();
+    const initialAgentId = typeof natsBootstrap.agentId === "string" ? natsBootstrap.agentId : "";
+    if (!initialAgentId) {
+        throw new Error("agent id missing from bootstrap");
+    }
     process.stdout.write(`\n[doer-agent v${agentVersion}]\n`);
     if (!usesDefaultServer) {
         process.stdout.write(`- server: ${serverBaseUrl}\n`);
     }
     process.stdout.write(`- userId: ${userId}\n`);
-    process.stdout.write(`- agentId: ${typeof natsBootstrap.agentId === "string" ? natsBootstrap.agentId : "unknown"}\n`);
+    process.stdout.write(`- agentId: ${initialAgentId}\n`);
     process.stdout.write(`\n- transport: nats\n`);
     process.stdout.write(`- natsServers: ${jetstream.servers.join(",")}\n`);
     process.stdout.write(`- natsStream: ${jetstream.stream}\n`);
@@ -1037,6 +1379,18 @@ async function main() {
         const taskPromise = taskPromiseFactory();
         trackInFlight(taskPromise);
     }
+    subscribeToFsRpc({
+        jetstream,
+        serverBaseUrl,
+        userId,
+        agentId: initialAgentId,
+        agentToken,
+    });
+    subscribeToShellRpc({
+        jetstream,
+        userId,
+        agentId: initialAgentId,
+    });
     for (const pendingTaskId of pendingTaskIds) {
         await waitForAvailableSlot();
         scheduleTask(async () => {
@@ -1166,6 +1520,22 @@ async function main() {
             natsBootstrap = refreshed.natsBootstrap;
             pendingTaskIds = refreshed.pendingTaskIds;
             jetstream = refreshed.jetstream;
+            const refreshedAgentId = typeof natsBootstrap.agentId === "string" ? natsBootstrap.agentId : "";
+            if (!refreshedAgentId) {
+                throw new Error("agent id missing from refreshed bootstrap");
+            }
+            subscribeToFsRpc({
+                jetstream,
+                serverBaseUrl,
+                userId,
+                agentId: refreshedAgentId,
+                agentToken,
+            });
+            subscribeToShellRpc({
+                jetstream,
+                userId,
+                agentId: refreshedAgentId,
+            });
             for (const pendingTaskId of pendingTaskIds) {
                 await waitForAvailableSlot();
                 scheduleTask(async () => {

package/dist/playwright-cdp.js

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+import { Buffer } from "node:buffer";
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { chromium } from "playwright-core";
+function printHelp() {
+    console.log(`playwright-cdp
+
+Usage:
+  PLAYWRIGHT_CDP_ENDPOINT=http://127.0.0.1:9222 \
+  playwright-cdp --tool <tool> --args-base64 <base64>
+
+  playwright-cdp \
+    --endpoint http://127.0.0.1:9222 \
+    --tool browser_navigate \
+    --args '{"url":"https://example.com"}'
+
+Tools:
+  browser_list_tabs
+  browser_navigate
+  browser_click
+  browser_type
+  browser_screenshot
+  browser_get_html
+  browser_get_text
+  browser_eval
+`);
+}
+function parseArgs(argv) {
+    const options = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const token = argv[i];
+        if (!token.startsWith("--"))
+            continue;
+        const key = token.slice(2);
+        const next = argv[i + 1];
+        if (!next || next.startsWith("--")) {
+            options[key] = true;
+            continue;
+        }
+        options[key] = next;
+        i += 1;
+    }
+    return options;
+}
+function requiredOption(options, key) {
+    const value = options[key];
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`--${key} is required`);
+    }
+    return value.trim();
+}
+function optionalOption(options, key) {
+    const value = options[key];
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function readEndpoint(options) {
+    return optionalOption(options, "endpoint")
+        ?? process.env.PLAYWRIGHT_CDP_ENDPOINT
+        ?? process.env.CDP_ENDPOINT
+        ?? "";
+}
+function readTimeout(options) {
+    const raw = optionalOption(options, "timeout");
+    if (!raw)
+        return 10000;
+    const value = Number.parseInt(raw, 10);
+    if (Number.isNaN(value) || value < 0) {
+        throw new Error("--timeout must be a non-negative integer");
+    }
+    return value;
+}
+function readPayload(options) {
+    const argsJson = optionalOption(options, "args");
+    const argsBase64 = optionalOption(options, "args-base64");
+    if (!argsJson && !argsBase64) {
+        throw new Error("--args or --args-base64 is required");
+    }
+    const raw = argsJson ?? Buffer.from(argsBase64, "base64").toString("utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("tool args must decode to a JSON object");
+    }
+    return parsed;
+}
+function asString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function asBoolean(value) {
+    return value === true || value === "true";
+}
+function selectorFrom(args) {
+    return asString(args.selector)
+        ?? asString(args.locator)
+        ?? asString(args.query)
+        ?? (() => { throw new Error("selector is required in args"); })();
+}
+async function resolvePage(browser, args) {
+    const contexts = browser.contexts();
+    const context = contexts[0] ?? (await browser.newContext());
+    if (asBoolean(args.newPage)) {
+        return context.newPage();
+    }
+    const pageIndexRaw = args.pageIndex;
+    const pageIndex = typeof pageIndexRaw === "number" ? pageIndexRaw : 0;
+    const pages = context.pages();
+    return pages[pageIndex] ?? pages[0] ?? context.newPage();
+}
+async function main() {
+    const options = parseArgs(process.argv.slice(2));
+    if (options.help === true || options.h === true) {
+        printHelp();
+        return;
+    }
+    const endpoint = readEndpoint(options);
+    if (!endpoint) {
+        throw new Error("CDP endpoint is required via --endpoint or PLAYWRIGHT_CDP_ENDPOINT");
+    }
+    const tool = requiredOption(options, "tool");
+    const args = readPayload(options);
+    const timeout = readTimeout(options);
+    const browser = await chromium.connectOverCDP(endpoint, { timeout });
+    try {
+        if (tool === "browser_list_tabs") {
+            const payload = browser.contexts().map((context, contextIndex) => ({
+                contextIndex,
+                pages: context.pages().map((page, pageIndex) => ({
+                    pageIndex,
+                    url: page.url(),
+                })),
+            }));
+            console.log(JSON.stringify({ tool, result: payload }, null, 2));
+            return;
+        }
+        const page = await resolvePage(browser, args);
+        switch (tool) {
+            case "browser_navigate": {
+                const url = asString(args.url);
+                if (!url)
+                    throw new Error("url is required in args");
+                await page.goto(url, { waitUntil: "domcontentloaded", timeout });
+                console.log(JSON.stringify({ tool, url: page.url(), title: await page.title() }, null, 2));
+                return;
+            }
+            case "browser_click": {
+                const selector = selectorFrom(args);
+                await page.locator(selector).click({ timeout });
+                console.log(JSON.stringify({ tool, selector, url: page.url() }, null, 2));
+                return;
+            }
+            case "browser_type": {
+                const selector = selectorFrom(args);
+                const text = asString(args.text) ?? asString(args.value);
+                if (!text)
+                    throw new Error("text is required in args");
+                await page.locator(selector).fill(text, { timeout });
+                console.log(JSON.stringify({ tool, selector, length: text.length }, null, 2));
+                return;
+            }
+            case "browser_screenshot": {
+                const out = asString(args.path) ?? asString(args.out) ?? path.join("artifacts", `playwright-cdp-${Date.now()}.png`);
+                await mkdir(path.dirname(out), { recursive: true });
+                await page.screenshot({ path: out, fullPage: true });
+                console.log(JSON.stringify({ tool, path: path.resolve(out), url: page.url() }, null, 2));
+                return;
+            }
+            case "browser_get_html": {
+                const selector = asString(args.selector) ?? asString(args.locator);
+                const html = selector ? await page.locator(selector).innerHTML({ timeout }) : await page.content();
+                console.log(html);
+                return;
+            }
+            case "browser_get_text": {
+                const selector = asString(args.selector) ?? asString(args.locator) ?? "body";
+                const text = await page.locator(selector).innerText({ timeout });
+                console.log(text);
+                return;
+            }
+            case "browser_eval": {
+                const expression = asString(args.expression) ?? asString(args.expr);
+                if (!expression)
+                    throw new Error("expression is required in args");
+                const value = await page.evaluate((source) => globalThis.eval(source), expression);
+                console.log(JSON.stringify({ tool, value }, null, 2));
+                return;
+            }
+            default:
+                throw new Error(`unsupported tool: ${tool}`);
+        }
+    }
+    finally {
+        await browser.close();
+    }
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doer-agent",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",