doer-agent 0.1.7 → 0.1.9

package/dist/agent.js

@@ -1,7 +1,6 @@
 import { spawn, spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { AckPolicy, connect, DeliverPolicy, JSONCodec, RetentionPolicy, StorageType } from "nats";
@@ -11,6 +10,7 @@ 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;
 function sanitizeUserId(userId) {
     const normalized = userId.trim().replace(/[^a-zA-Z0-9_-]/g, "_");
     return normalized.length > 0 ? normalized : "anonymous";
@@ -135,7 +135,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";
@@ -509,6 +510,30 @@ function resolveShellPath() {
     }
     throw new Error("No shell executable found. Set SHELL env or install /bin/sh (or bash).");
 }
+function resolveTaskWorkspace(rawCwd) {
+    const workspaceRoot = workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
+    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 postJson(url, body) {
     const res = await fetch(url, {
         method: "POST",
@@ -714,6 +739,7 @@ async function runTask(args) {
         userId: args.userId,
     };
     const shellPath = resolveShellPath();
+    const taskWorkspace = resolveTaskWorkspace(args.cwd);
     const runtimeConfig = await prepareTaskRuntimeConfig({
         serverBaseUrl: args.serverBaseUrl,
         taskId: args.taskId,
@@ -726,7 +752,6 @@ async function runTask(args) {
         userId: args.userId,
         agentToken: args.agentToken,
     });
-    const taskWorkspace = args.cwd || process.env.WORKSPACE?.trim() || process.cwd();
     const baseTaskEnvPatch = {
         ...(runtimeConfig?.envPatch ?? {}),
         ...(codexAuth?.envPatch ?? {}),
@@ -747,7 +772,8 @@ async function runTask(args) {
             pid: process.pid,
             startedAt: formatLocalTimestamp(),
             command: args.command,
-            cwd: args.cwd,
+            cwd: taskWorkspace,
+            requestedCwd: args.cwd,
             shell: shellPath,
             ...(runtimeConfig?.meta ?? { runtimeConfigSynced: false }),
             ...(codexAuth?.meta ?? { codexAuthSynced: false }),
@@ -763,7 +789,7 @@ async function runTask(args) {
         const runtimeBinPath = path.join(AGENT_PROJECT_DIR, "runtime/bin");
         const taskPath = [runtimeBinPath, process.env.PATH || ""].filter(Boolean).join(path.delimiter);
         const child = spawn(args.command, {
-            cwd: args.cwd || process.cwd(),
+            cwd: taskWorkspace,
             shell: shellPath,
             detached: process.platform !== "win32",
             env: {
@@ -934,9 +960,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);

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.7",
+  "version": "0.1.9",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",