doer-agent 0.1.0

package/dist/apply-patch.js

@@ -0,0 +1,260 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+const BEGIN_MARKER = "*** Begin Patch";
+const END_MARKER = "*** End Patch";
+const ADD_FILE_PREFIX = "*** Add File: ";
+const DELETE_FILE_PREFIX = "*** Delete File: ";
+const UPDATE_FILE_PREFIX = "*** Update File: ";
+const MOVE_TO_PREFIX = "*** Move to: ";
+const EOF_MARKER = "*** End of File";
+function fail(message) {
+    throw new Error(message);
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+async function readPatchFromInput() {
+    const argv = process.argv.slice(2);
+    if (argv.length === 1) {
+        return argv[0] ?? "";
+    }
+    if (argv.length > 1) {
+        fail("apply_patch accepts exactly one argument or stdin.");
+    }
+    if (process.stdin.isTTY) {
+        fail("Usage: apply_patch 'PATCH' or echo 'PATCH' | apply_patch");
+    }
+    return await readStdin();
+}
+function normalizePatchText(value) {
+    return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function splitPatchLines(value) {
+    const normalized = normalizePatchText(value);
+    const lines = normalized.split("\n");
+    while (lines.length > 0 && lines[lines.length - 1] === "") {
+        lines.pop();
+    }
+    return lines;
+}
+function validateRelativePath(filePath) {
+    const trimmed = filePath.trim();
+    if (!trimmed) {
+        fail("Patch path is empty.");
+    }
+    if (path.isAbsolute(trimmed)) {
+        fail(`Absolute paths are not allowed: ${trimmed}`);
+    }
+    const normalized = path.posix.normalize(trimmed.replace(/\\/g, "/"));
+    if (normalized.startsWith("../") || normalized === "..") {
+        fail(`Path escapes workspace: ${trimmed}`);
+    }
+    return normalized;
+}
+function parseUpdateChunks(lines) {
+    const chunks = [];
+    let current = [];
+    for (const line of lines) {
+        if (line === EOF_MARKER) {
+            continue;
+        }
+        if (line.startsWith("@@")) {
+            if (current.length > 0) {
+                chunks.push({ lines: current });
+                current = [];
+            }
+            continue;
+        }
+        if (!/^[ +\-]/.test(line)) {
+            fail(`Unsupported patch line: ${line}`);
+        }
+        current.push(line);
+    }
+    if (current.length > 0) {
+        chunks.push({ lines: current });
+    }
+    return chunks;
+}
+function parsePatch(text) {
+    const lines = splitPatchLines(text);
+    if (lines[0] !== BEGIN_MARKER) {
+        fail("Patch must start with '*** Begin Patch'.");
+    }
+    if (lines[lines.length - 1] !== END_MARKER) {
+        fail("Patch must end with '*** End Patch'.");
+    }
+    const ops = [];
+    let index = 1;
+    while (index < lines.length - 1) {
+        const line = lines[index] ?? "";
+        if (line.startsWith(ADD_FILE_PREFIX)) {
+            const filePath = validateRelativePath(line.slice(ADD_FILE_PREFIX.length));
+            index += 1;
+            const addLines = [];
+            while (index < lines.length - 1) {
+                const next = lines[index] ?? "";
+                if (next.startsWith("*** ")) {
+                    break;
+                }
+                if (!next.startsWith("+")) {
+                    fail(`Add file lines must start with '+': ${next}`);
+                }
+                addLines.push(next.slice(1));
+                index += 1;
+            }
+            ops.push({ type: "add", filePath, lines: addLines });
+            continue;
+        }
+        if (line.startsWith(DELETE_FILE_PREFIX)) {
+            const filePath = validateRelativePath(line.slice(DELETE_FILE_PREFIX.length));
+            index += 1;
+            ops.push({ type: "delete", filePath });
+            continue;
+        }
+        if (line.startsWith(UPDATE_FILE_PREFIX)) {
+            const filePath = validateRelativePath(line.slice(UPDATE_FILE_PREFIX.length));
+            index += 1;
+            let moveTo = null;
+            if ((lines[index] ?? "").startsWith(MOVE_TO_PREFIX)) {
+                moveTo = validateRelativePath((lines[index] ?? "").slice(MOVE_TO_PREFIX.length));
+                index += 1;
+            }
+            const updateLines = [];
+            while (index < lines.length - 1) {
+                const next = lines[index] ?? "";
+                if (next.startsWith(ADD_FILE_PREFIX) ||
+                    next.startsWith(DELETE_FILE_PREFIX) ||
+                    next.startsWith(UPDATE_FILE_PREFIX)) {
+                    break;
+                }
+                updateLines.push(next);
+                index += 1;
+            }
+            ops.push({ type: "update", filePath, moveTo, chunks: parseUpdateChunks(updateLines) });
+            continue;
+        }
+        fail(`Unsupported patch header: ${line}`);
+    }
+    return ops;
+}
+function splitFileContent(content) {
+    const hadTrailingNewline = content.endsWith("\n");
+    const normalized = normalizePatchText(content);
+    let lines = normalized.split("\n");
+    if (hadTrailingNewline) {
+        lines = lines.slice(0, -1);
+    }
+    return { lines, hadTrailingNewline };
+}
+function joinFileContent(lines, trailingNewline) {
+    const body = lines.join("\n");
+    return trailingNewline && lines.length > 0 ? `${body}\n` : body;
+}
+function findSequence(source, needle, start) {
+    if (needle.length === 0) {
+        return start;
+    }
+    for (let i = start; i <= source.length - needle.length; i += 1) {
+        let matched = true;
+        for (let j = 0; j < needle.length; j += 1) {
+            if (source[i + j] !== needle[j]) {
+                matched = false;
+                break;
+            }
+        }
+        if (matched) {
+            return i;
+        }
+    }
+    return -1;
+}
+function applyChunksToLines(originalLines, chunks) {
+    const output = [];
+    let cursor = 0;
+    for (const chunk of chunks) {
+        const oldLines = [];
+        const newLines = [];
+        for (const line of chunk.lines) {
+            const marker = line[0];
+            const value = line.slice(1);
+            if (marker === " ") {
+                oldLines.push(value);
+                newLines.push(value);
+            }
+            else if (marker === "-") {
+                oldLines.push(value);
+            }
+            else if (marker === "+") {
+                newLines.push(value);
+            }
+        }
+        const matchIndex = findSequence(originalLines, oldLines, cursor);
+        if (matchIndex < 0) {
+            fail(`Failed to match patch context near: ${oldLines[0] ?? "<insert>"}`);
+        }
+        output.push(...originalLines.slice(cursor, matchIndex));
+        output.push(...newLines);
+        cursor = matchIndex + oldLines.length;
+    }
+    output.push(...originalLines.slice(cursor));
+    return output;
+}
+async function ensureParentDir(filePath) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+}
+async function applyAddOp(cwd, op) {
+    const absPath = path.join(cwd, op.filePath);
+    try {
+        await fs.stat(absPath);
+        fail(`File already exists: ${op.filePath}`);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    await ensureParentDir(absPath);
+    await fs.writeFile(absPath, joinFileContent(op.lines, op.lines.length > 0), "utf8");
+}
+async function applyDeleteOp(cwd, op) {
+    const absPath = path.join(cwd, op.filePath);
+    await fs.unlink(absPath);
+}
+async function applyUpdateOp(cwd, op) {
+    const sourcePath = path.join(cwd, op.filePath);
+    const sourceText = await fs.readFile(sourcePath, "utf8");
+    const { lines: originalLines, hadTrailingNewline } = splitFileContent(sourceText);
+    const nextLines = applyChunksToLines(originalLines, op.chunks);
+    const nextPath = path.join(cwd, op.moveTo ?? op.filePath);
+    await ensureParentDir(nextPath);
+    await fs.writeFile(nextPath, joinFileContent(nextLines, hadTrailingNewline), "utf8");
+    if (op.moveTo && op.moveTo !== op.filePath) {
+        await fs.unlink(sourcePath);
+    }
+}
+async function main() {
+    const patchText = await readPatchFromInput();
+    const ops = parsePatch(patchText);
+    const cwd = process.cwd();
+    for (const op of ops) {
+        if (op.type === "add") {
+            await applyAddOp(cwd, op);
+        }
+        else if (op.type === "delete") {
+            await applyDeleteOp(cwd, op);
+        }
+        else {
+            await applyUpdateOp(cwd, op);
+        }
+    }
+    process.stdout.write(`Applied patch to ${ops.length} file(s).\n`);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exitCode = 1;
+});

package/dist/cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./agent.js";

package/dist/codex-cli.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import { existsSync, realpathSync } from "node:fs";
+import { delimiter, join } from "node:path";
+import { spawn } from "node:child_process";
+function isWindows() {
+    return process.platform === "win32";
+}
+function candidatesFor(baseDir) {
+    if (isWindows()) {
+        return [join(baseDir, "codex.cmd"), join(baseDir, "codex.exe"), join(baseDir, "codex")];
+    }
+    return [join(baseDir, "codex")];
+}
+function resolveSelf() {
+    const selfPath = process.argv[1];
+    if (!selfPath)
+        return null;
+    try {
+        return realpathSync(selfPath);
+    }
+    catch {
+        return selfPath;
+    }
+}
+function findCodexBinary() {
+    const pathValue = process.env.PATH ?? "";
+    const dirs = pathValue.split(delimiter).filter(Boolean);
+    const self = resolveSelf();
+    for (const dir of dirs) {
+        for (const candidate of candidatesFor(dir)) {
+            if (!existsSync(candidate))
+                continue;
+            try {
+                const resolved = realpathSync(candidate);
+                if (self && resolved === self)
+                    continue;
+            }
+            catch {
+                // no-op
+            }
+            return candidate;
+        }
+    }
+    return null;
+}
+const binary = findCodexBinary();
+if (!binary) {
+    console.error("Unable to find a real 'codex' binary in PATH.");
+    console.error("Install Codex CLI first, or set PATH so another codex binary is discoverable.");
+    process.exit(1);
+}
+const child = spawn(binary, process.argv.slice(2), {
+    stdio: "inherit",
+    env: process.env,
+});
+child.on("error", (error) => {
+    console.error(`Failed to execute codex: ${error.message}`);
+    process.exit(1);
+});
+child.on("exit", (code, signal) => {
+    if (signal) {
+        process.kill(process.pid, signal);
+        return;
+    }
+    process.exit(code ?? 1);
+});

package/dist/playwright-mcp-call-cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./playwright-mcp-call.js";

package/dist/playwright-mcp-call.js

@@ -0,0 +1,103 @@
+import { Buffer } from "node:buffer";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+function parseArgs(argv) {
+    const parsed = { tool: "", argsBase64: "" };
+    for (let i = 0; i < argv.length; i += 1) {
+        const token = argv[i];
+        if (token === "--tool") {
+            parsed.tool = (argv[i + 1] || "").trim();
+            i += 1;
+            continue;
+        }
+        if (token === "--args-base64") {
+            parsed.argsBase64 = (argv[i + 1] || "").trim();
+            i += 1;
+        }
+    }
+    return parsed;
+}
+function resolveProxyPath() {
+    const candidates = [
+        path.join(process.cwd(), "agent/runtime/bin/doer-mcp-proxy"),
+        path.join(process.cwd(), "runtime/bin/doer-mcp-proxy"),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return "";
+}
+function resolveSocketPath() {
+    const explicit = (process.env.DOER_MCP_SOCKET || "").trim();
+    if (explicit) {
+        return explicit;
+    }
+    const stateDir = (process.env.DOER_AGENT_STATE_DIR || "").trim() || path.join(homedir(), ".doer-agent");
+    return path.join(stateDir, "playwright-mcp-daemon", "playwright-mcp.sock");
+}
+function decodeToolArgs(argsBase64) {
+    if (!argsBase64) {
+        return {};
+    }
+    const raw = Buffer.from(argsBase64, "base64").toString("utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("decoded tool arguments must be a JSON object");
+    }
+    return parsed;
+}
+async function main() {
+    const { tool, argsBase64 } = parseArgs(process.argv.slice(2));
+    if (!tool) {
+        throw new Error("--tool is required");
+    }
+    const proxyPath = resolveProxyPath();
+    if (!proxyPath) {
+        throw new Error("doer-mcp-proxy binary not found");
+    }
+    const socketPath = resolveSocketPath();
+    const toolArgs = decodeToolArgs(argsBase64);
+    const transport = new StdioClientTransport({
+        command: proxyPath,
+        args: [],
+        env: {
+            ...process.env,
+            DOER_MCP_SOCKET: socketPath,
+        },
+        stderr: "pipe",
+    });
+    const client = new Client({
+        name: "doer-agent-playwright-mcp-runner",
+        version: "0.1.0",
+    }, {
+        capabilities: {},
+    });
+    try {
+        await client.connect(transport);
+        const result = await client.callTool({
+            name: tool,
+            arguments: toolArgs,
+        });
+        process.stdout.write(`${JSON.stringify({
+            ok: true,
+            tool,
+            content: result.content ?? null,
+            isError: result.isError === true,
+            structuredContent: result.structuredContent ?? null,
+            result,
+        })}\n`);
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${JSON.stringify({ ok: false, error: message })}\n`);
+    process.exit(1);
+});

package/dist/playwright-mcp-daemon.js

@@ -0,0 +1,175 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, rm } from "node:fs/promises";
+import net from "node:net";
+import path from "node:path";
+function parseInteger(value, fallback) {
+    const normalized = value?.trim();
+    if (!normalized) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(normalized, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+const socketPath = process.env.DOER_PLAYWRIGHT_MCP_DAEMON_SOCKET?.trim() || "";
+const targetCommand = process.env.DOER_PLAYWRIGHT_MCP_TARGET_COMMAND?.trim() || "";
+const idleTtlSeconds = parseInteger(process.env.DOER_PLAYWRIGHT_MCP_DAEMON_IDLE_TTL_SECONDS, 10800);
+let targetArgs = [];
+try {
+    const parsed = JSON.parse(process.env.DOER_PLAYWRIGHT_MCP_TARGET_ARGS_JSON || "[]");
+    if (Array.isArray(parsed) && parsed.every((item) => typeof item === "string")) {
+        targetArgs = parsed;
+    }
+}
+catch {
+    targetArgs = [];
+}
+let targetEnvPatch = {};
+try {
+    const parsed = JSON.parse(process.env.DOER_PLAYWRIGHT_MCP_TARGET_ENV_JSON || "{}");
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        targetEnvPatch = Object.fromEntries(Object.entries(parsed).flatMap(([key, value]) => (typeof value === "string" ? [[key, value]] : [])));
+    }
+}
+catch {
+    targetEnvPatch = {};
+}
+if (!socketPath) {
+    process.stderr.write("playwright-mcp-daemon error: DOER_PLAYWRIGHT_MCP_DAEMON_SOCKET is required\n");
+    process.exit(1);
+}
+if (!targetCommand) {
+    process.stderr.write("playwright-mcp-daemon error: DOER_PLAYWRIGHT_MCP_TARGET_COMMAND is required\n");
+    process.exit(1);
+}
+let child = null;
+let activeClient = null;
+let shuttingDown = false;
+let lastActivityAt = Date.now();
+const idleTtlMs = idleTtlSeconds * 1000;
+function markActivity() {
+    lastActivityAt = Date.now();
+}
+function spawnTargetIfNeeded() {
+    if (child) {
+        return;
+    }
+    child = spawn(targetCommand, targetArgs, {
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env, ...targetEnvPatch },
+    });
+    child.stdout.on("data", (chunk) => {
+        markActivity();
+        if (activeClient && !activeClient.destroyed) {
+            activeClient.write(chunk);
+        }
+    });
+    child.stderr.on("data", (chunk) => {
+        process.stderr.write(chunk);
+    });
+    child.on("exit", () => {
+        child = null;
+        if (activeClient && !activeClient.destroyed) {
+            activeClient.end();
+            activeClient = null;
+        }
+        markActivity();
+    });
+}
+async function shutdown(server) {
+    if (shuttingDown) {
+        return;
+    }
+    shuttingDown = true;
+    if (activeClient && !activeClient.destroyed) {
+        activeClient.destroy();
+        activeClient = null;
+    }
+    if (child) {
+        child.kill("SIGTERM");
+        await new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                if (child) {
+                    child.kill("SIGKILL");
+                }
+                resolve();
+            }, 2000);
+            timeout.unref?.();
+            child?.once("exit", () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+        child = null;
+    }
+    await new Promise((resolve) => server.close(() => resolve()));
+    if (existsSync(socketPath)) {
+        await rm(socketPath, { force: true });
+    }
+    process.exit(0);
+}
+async function main() {
+    await mkdir(path.dirname(socketPath), { recursive: true });
+    if (existsSync(socketPath)) {
+        await rm(socketPath, { force: true });
+    }
+    const server = net.createServer((socket) => {
+        if (activeClient && !activeClient.destroyed) {
+            socket.end();
+            return;
+        }
+        activeClient = socket;
+        markActivity();
+        spawnTargetIfNeeded();
+        socket.on("data", (chunk) => {
+            markActivity();
+            spawnTargetIfNeeded();
+            if (child && !child.killed) {
+                child.stdin.write(chunk);
+            }
+        });
+        socket.on("close", () => {
+            if (activeClient === socket) {
+                activeClient = null;
+            }
+            markActivity();
+        });
+        socket.on("error", () => {
+            if (activeClient === socket) {
+                activeClient = null;
+            }
+            markActivity();
+        });
+    });
+    server.on("error", (error) => {
+        process.stderr.write(`playwright-mcp-daemon error: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exit(1);
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(socketPath, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    const interval = setInterval(() => {
+        if (shuttingDown) {
+            return;
+        }
+        if (activeClient && !activeClient.destroyed) {
+            return;
+        }
+        if (Date.now() - lastActivityAt < idleTtlMs) {
+            return;
+        }
+        void shutdown(server);
+    }, 30000);
+    interval.unref?.();
+    process.on("SIGTERM", () => {
+        void shutdown(server);
+    });
+    process.on("SIGINT", () => {
+        void shutdown(server);
+    });
+}
+void main();

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "doer-agent",
+  "version": "0.1.0",
+  "description": "Reverse-polling agent runtime for doer",
+  "type": "module",
+  "main": "dist/agent.js",
+  "bin": {
+    "doer-agent": "dist/cli.js",
+    "playwright-mcp-call": "dist/playwright-mcp-call-cli.js",
+    "codex": "dist/codex-cli.js"
+  },
+  "files": [
+    "dist",
+    "runtime",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && chmod +x dist/cli.js dist/playwright-mcp-call-cli.js dist/codex-cli.js",
+    "start": "node --import tsx src/agent.ts",
+    "start:dist": "node dist/agent.js",
+    "codex": "codex",
+    "playwright-mcp-call": "node --import tsx src/playwright-mcp-call.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@openai/codex-sdk": "^0.115.0",
+    "@playwright/mcp": "0.0.68",
+    "nats": "^2.29.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "tsx": "^4.21.0",
+    "typescript": "^5"
+  }
+}

package/runtime/bin/apply_patch

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(cd "$SCRIPT_DIR/../.." && pwd)"
+exec node --import "$PROJECT_DIR/node_modules/tsx/dist/loader.mjs" "$PROJECT_DIR/src/apply-patch.ts" "$@"

package/runtime/bin/doer-mcp-proxy

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+import net from "node:net";
+
+function debugLog(...parts) {
+  const now = new Date().toISOString();
+  process.stderr.write(`[doer-mcp-proxy][${now}] ${parts.join(" ")}\n`);
+}
+
+const socketPath = (process.env.DOER_MCP_SOCKET || "").trim();
+
+if (!socketPath) {
+  process.stderr.write("doer-mcp-proxy error: DOER_MCP_SOCKET is not set\n");
+  process.exit(1);
+}
+
+debugLog("connecting", `socket=${socketPath}`);
+const socket = net.createConnection(socketPath);
+
+socket.on("connect", () => {
+  debugLog("connected");
+  process.stdin.pipe(socket);
+  socket.pipe(process.stdout);
+});
+
+socket.on("error", (error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`doer-mcp-proxy error: ${message}\n`);
+  process.exit(1);
+});
+
+socket.on("close", () => {
+  debugLog("closed");
+  process.exit(0);
+});
+
+process.stdin.on("error", () => {
+  socket.destroy();
+});