doer-agent 0.1.6 → 0.1.8

package/README.md

@@ -11,7 +11,6 @@
 주요 엔트리 포인트:
 
 - `doer-agent`: 에이전트 본체 CLI
-- `playwright-mcp-call`: Playwright MCP 호출용 CLI
 - `codex`: Codex 래퍼 CLI
 
 ## 요구 사항

package/dist/agent.js

@@ -1,14 +1,10 @@
 import { spawn, spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import net from "node:net";
-import { arch, homedir } from "node:os";
+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";
-const PLAYWRIGHT_SKIP_BROWSER_GC = "1";
-const PLAYWRIGHT_MCP_DAEMON_IDLE_TTL_SECONDS_DEFAULT = 10800;
-const PLAYWRIGHT_MCP_DAEMON_SIGNATURE_VERSION = "2026-03-15";
 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, "..");
@@ -144,18 +140,6 @@ function resolveCodexHomePath() {
 function parseEnvBoolean(value) {
     return value?.trim().toLowerCase() === "true";
 }
-function parseEnvStringArray(value) {
-    if (!value?.trim()) {
-        return [];
-    }
-    try {
-        const parsed = JSON.parse(value);
-        return Array.isArray(parsed) && parsed.every((item) => typeof item === "string") ? parsed : [];
-    }
-    catch {
-        return [];
-    }
-}
 function parseEnvInteger(value, fallback) {
     const normalized = value?.trim();
     if (!normalized) {
@@ -164,211 +148,6 @@ function parseEnvInteger(value, fallback) {
     const parsed = Number.parseInt(normalized, 10);
     return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
-function resolvePlaywrightMcpProxyPath() {
-    const candidates = [
-        path.join(AGENT_PROJECT_DIR, "runtime/bin/doer-mcp-proxy"),
-        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 "";
-}
-const PLAYWRIGHT_MCP_PROXY_LAUNCHER_PATH = path.join(AGENT_PROJECT_DIR, "runtime/bin/playwright-mcp-proxy-launcher.sh");
-function resolvePlaywrightMcpDaemonStatePaths() {
-    const daemonDir = path.join(resolveAgentStateDir(), "playwright-mcp-daemon");
-    return {
-        daemonDir,
-        socketPath: path.join(daemonDir, "playwright-mcp.sock"),
-        pidPath: path.join(daemonDir, "daemon.pid"),
-        metaPath: path.join(daemonDir, "daemon-meta.json"),
-    };
-}
-function parseEnvAssignmentArgs(values) {
-    const envPatch = {};
-    for (const value of values) {
-        const separatorIndex = value.indexOf("=");
-        if (separatorIndex <= 0) {
-            continue;
-        }
-        const key = value.slice(0, separatorIndex).trim();
-        const envValue = value.slice(separatorIndex + 1);
-        if (!key) {
-            continue;
-        }
-        envPatch[key] = envValue;
-    }
-    return envPatch;
-}
-function escapeShellArg(value) {
-    return `'${value.replace(/'/g, `'\"'\"'`)}'`;
-}
-async function readPidFile(pidPath) {
-    const raw = await readFile(pidPath, "utf8").catch(() => "");
-    const parsed = Number.parseInt(raw.trim(), 10);
-    return Number.isInteger(parsed) && parsed > 1 ? parsed : null;
-}
-function isProcessAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function waitForPlaywrightMcpSocketReady(socketPath, timeoutMs) {
-    const startedAt = Date.now();
-    while (Date.now() - startedAt <= timeoutMs) {
-        const isReady = await new Promise((resolve) => {
-            const socket = net.createConnection({ path: socketPath });
-            let settled = false;
-            const finish = (value) => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                resolve(value);
-            };
-            socket.once("connect", () => {
-                socket.end();
-                finish(true);
-            });
-            socket.once("error", () => {
-                finish(false);
-            });
-            setTimeout(() => {
-                socket.destroy();
-                finish(false);
-            }, 250).unref?.();
-        });
-        if (isReady) {
-            return true;
-        }
-        await sleep(120);
-    }
-    return false;
-}
-async function stopPlaywrightMcpDaemon(paths) {
-    const pid = await readPidFile(paths.pidPath);
-    if (pid && isProcessAlive(pid)) {
-        try {
-            process.kill(pid, "SIGTERM");
-        }
-        catch {
-            // ignore
-        }
-        const waitStartedAt = Date.now();
-        while (Date.now() - waitStartedAt < 1800 && isProcessAlive(pid)) {
-            await sleep(120);
-        }
-        if (isProcessAlive(pid)) {
-            try {
-                process.kill(pid, "SIGKILL");
-            }
-            catch {
-                // ignore
-            }
-        }
-    }
-    await Promise.all([
-        rename(paths.socketPath, `${paths.socketPath}.stale.${Date.now()}`).catch(() => undefined),
-        rename(paths.pidPath, `${paths.pidPath}.stale.${Date.now()}`).catch(() => undefined),
-        rename(paths.metaPath, `${paths.metaPath}.stale.${Date.now()}`).catch(() => undefined),
-    ]);
-}
-async function ensureManagedPlaywrightMcpDaemon(args) {
-    const paths = resolvePlaywrightMcpDaemonStatePaths();
-    await mkdir(paths.daemonDir, { recursive: true });
-    const daemonCommand = args.command;
-    const targetEnvPatch = parseEnvAssignmentArgs(args.browserEnvArgs);
-    const daemonCommandArgs = args.daemonArgs;
-    const signature = JSON.stringify({
-        version: PLAYWRIGHT_MCP_DAEMON_SIGNATURE_VERSION,
-        daemonCommand,
-        daemonCommandArgs,
-        targetEnvPatch,
-        idleTtlSeconds: parseEnvInteger(process.env.DOER_PLAYWRIGHT_MCP_DAEMON_IDLE_TTL_SECONDS, PLAYWRIGHT_MCP_DAEMON_IDLE_TTL_SECONDS_DEFAULT),
-    });
-    const existingMetaRaw = await readFile(paths.metaPath, "utf8").catch(() => "");
-    let existingMeta = null;
-    if (existingMetaRaw) {
-        try {
-            existingMeta = JSON.parse(existingMetaRaw);
-        }
-        catch {
-            existingMeta = null;
-        }
-    }
-    const existingPid = await readPidFile(paths.pidPath);
-    if (existingMeta?.signature === signature
-        && existingPid
-        && isProcessAlive(existingPid)
-        && await waitForPlaywrightMcpSocketReady(paths.socketPath, 350)) {
-        return paths.socketPath;
-    }
-    await stopPlaywrightMcpDaemon(paths);
-    const daemonScriptPath = path.join(AGENT_MODULE_DIR, "playwright-mcp-daemon.ts");
-    const idleTtlSeconds = String(parseEnvInteger(process.env.DOER_PLAYWRIGHT_MCP_DAEMON_IDLE_TTL_SECONDS, PLAYWRIGHT_MCP_DAEMON_IDLE_TTL_SECONDS_DEFAULT));
-    const child = spawn(process.execPath, ["--import", "tsx", daemonScriptPath], {
-        cwd: AGENT_PROJECT_DIR,
-        detached: true,
-        stdio: "ignore",
-        env: {
-            ...process.env,
-            DOER_PLAYWRIGHT_MCP_DAEMON_SOCKET: paths.socketPath,
-            DOER_PLAYWRIGHT_MCP_DAEMON_IDLE_TTL_SECONDS: idleTtlSeconds,
-            DOER_PLAYWRIGHT_MCP_TARGET_COMMAND: daemonCommand,
-            DOER_PLAYWRIGHT_MCP_TARGET_ARGS_JSON: JSON.stringify(daemonCommandArgs),
-            DOER_PLAYWRIGHT_MCP_TARGET_ENV_JSON: JSON.stringify(targetEnvPatch),
-        },
-    });
-    child.unref();
-    if (!child.pid) {
-        throw new Error("failed to start playwright mcp daemon: missing pid");
-    }
-    await writeFile(paths.pidPath, `${child.pid}\n`, "utf8");
-    await writeFile(paths.metaPath, `${JSON.stringify({ signature, pid: child.pid, socketPath: paths.socketPath, updatedAt: new Date().toISOString() }, null, 2)}\n`, "utf8");
-    const ready = await waitForPlaywrightMcpSocketReady(paths.socketPath, 6000);
-    if (!ready) {
-        throw new Error(`playwright mcp daemon socket not ready: ${paths.socketPath}`);
-    }
-    return paths.socketPath;
-}
-async function ensureCodexPlaywrightMcpLauncher() {
-    const browserEnvArgs = [
-        `PLAYWRIGHT_SKIP_BROWSER_GC=${PLAYWRIGHT_SKIP_BROWSER_GC}`,
-    ];
-    const daemonArgsFromEnv = parseEnvStringArray(process.env.DOER_PLAYWRIGHT_MCP_DAEMON_ARGS_JSON);
-    const [daemonCommandFromArgs, ...daemonArgsRest] = daemonArgsFromEnv;
-    const daemonCommand = daemonCommandFromArgs || "npx";
-    let daemonArgs = daemonCommandFromArgs && daemonArgsFromEnv.length > 0
-        ? daemonArgsRest
-        : ["-y", "@playwright/mcp"];
-    const hasBrowserOption = daemonArgs.some((arg) => arg === "--browser" || arg.startsWith("--browser="));
-    if (arch() === "arm64" && !hasBrowserOption) {
-        daemonArgs = [...daemonArgs, "--browser", "chromium"];
-    }
-    const hasNoSandboxOption = daemonArgs.some((arg) => arg === "--no-sandbox");
-    if (typeof process.getuid === "function" && process.getuid() === 0 && !hasNoSandboxOption) {
-        daemonArgs = [...daemonArgs, "--no-sandbox"];
-    }
-    const socketPath = await ensureManagedPlaywrightMcpDaemon({
-        command: daemonCommand,
-        daemonArgs,
-        browserEnvArgs,
-    });
-    if (!existsSync(PLAYWRIGHT_MCP_PROXY_LAUNCHER_PATH)) {
-        throw new Error(`playwright mcp proxy launcher script not found: ${PLAYWRIGHT_MCP_PROXY_LAUNCHER_PATH}`);
-    }
-    return PLAYWRIGHT_MCP_PROXY_LAUNCHER_PATH;
-}
-function resolveAgentStateDir() {
-    return process.env.DOER_AGENT_STATE_DIR?.trim() || path.join(homedir(), ".doer-agent");
-}
 function resolveContainerReachableServerBaseUrl(serverBaseUrl) {
     return serverBaseUrl;
 }
@@ -730,6 +509,30 @@ 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 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",
@@ -935,6 +738,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,
@@ -947,7 +751,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 ?? {}),
@@ -957,10 +760,6 @@ async function runTask(args) {
         cwd: taskWorkspace,
         baseEnvPatch: baseTaskEnvPatch,
     });
-    await ensureCodexPlaywrightMcpLauncher();
-    const codexMcpEnvPatch = {
-        PLAYWRIGHT_SKIP_BROWSER_GC: PLAYWRIGHT_SKIP_BROWSER_GC,
-    };
     await recordAgentEvent({ jetstream: args.jetstream,
         serverBaseUrl: args.serverBaseUrl,
         taskId: args.taskId,
@@ -972,7 +771,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 }),
@@ -988,14 +788,13 @@ 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: {
                 ...process.env,
                 ...baseTaskEnvPatch,
                 ...taskGitEnv.envPatch,
-                ...codexMcpEnvPatch,
                 PATH: taskPath,
                 DOER_AGENT_TOKEN: args.agentToken,
             },

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "doer-agent",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "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": [
@@ -18,17 +17,15 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json && chmod +x dist/cli.js dist/playwright-mcp-call-cli.js dist/codex-cli.js",
+    "build": "tsc -p tsconfig.build.json && chmod +x dist/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": {

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

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

package/dist/playwright-mcp-call.js

@@ -1,103 +0,0 @@
-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

@@ -1,175 +0,0 @@
-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/runtime/bin/playwright-mcp-proxy-launcher.sh

@@ -1,15 +0,0 @@
-#!/bin/sh
-set -eu
-SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
-if [ -z "${DOER_MCP_SOCKET:-}" ]; then
-  if [ -n "${DOER_AGENT_STATE_DIR:-}" ]; then
-    DOER_MCP_SOCKET="$DOER_AGENT_STATE_DIR/playwright-mcp-daemon/playwright-mcp.sock"
-  elif [ -n "${HOME:-}" ]; then
-    DOER_MCP_SOCKET="$HOME/.doer-agent/playwright-mcp-daemon/playwright-mcp.sock"
-  else
-    echo "playwright-mcp-proxy-launcher.sh: DOER_MCP_SOCKET is not set and neither DOER_AGENT_STATE_DIR nor HOME is available" >&2
-    exit 1
-  fi
-fi
-export DOER_MCP_SOCKET
-exec "$SCRIPT_DIR/doer-mcp-proxy" "$@"