@anybrowser/cli 0.0.0-stage → 0.1.0

package/dist/connect.js

@@ -0,0 +1,195 @@
+import { spawn } from "node:child_process";
+import { chmodSync, closeSync, mkdirSync, openSync, readFileSync, statSync, unlinkSync, writeSync, } from "node:fs";
+import { createConnection } from "node:net";
+import { fileURLToPath } from "node:url";
+import { assertSocketPathFits } from "./paths.js";
+const DEFAULT_SPAWN_WAIT_MS = 10000;
+/**
+ * How long `ensureDaemon` waits to connect to (or spawn and connect to) the
+ * daemon before giving up, configurable for tests. Mirrors
+ * `ANYBROWSER_STOP_WAIT_MS` in cli.ts. Invalid values (non-numeric, zero,
+ * negative) fall back to the default.
+ */
+function spawnWaitMs(env = process.env) {
+    const raw = env["ANYBROWSER_SPAWN_WAIT_MS"];
+    if (raw === undefined || raw.trim() === "") {
+        return DEFAULT_SPAWN_WAIT_MS;
+    }
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_SPAWN_WAIT_MS;
+}
+/** Lock is considered stale once it is this old, regardless of its contents. */
+const LOCK_MAX_AGE_MS = 15000;
+/** Lock is considered stale if it's empty/unreadable and at least this old. */
+const LOCK_EMPTY_GRACE_MS = 2000;
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function pollIntervalMs() {
+    return 50 + Math.floor(Math.random() * 50);
+}
+/** Tries once to connect to the daemon socket. Resolves null instead of throwing on any failure. */
+export function connectOnce(socketPath) {
+    return new Promise((resolve) => {
+        const socket = createConnection(socketPath);
+        const onConnect = () => {
+            cleanup();
+            resolve(socket);
+        };
+        const onError = () => {
+            cleanup();
+            socket.destroy();
+            resolve(null);
+        };
+        const cleanup = () => {
+            socket.off("connect", onConnect);
+            socket.off("error", onError);
+        };
+        socket.once("connect", onConnect);
+        socket.once("error", onError);
+    });
+}
+function tryCreateLockFile(lockPath) {
+    let fd;
+    try {
+        fd = openSync(lockPath, "wx");
+    }
+    catch (error) {
+        if (error.code === "EEXIST") {
+            return "busy";
+        }
+        throw error;
+    }
+    try {
+        writeSync(fd, String(process.pid));
+    }
+    finally {
+        closeSync(fd);
+    }
+    return "acquired";
+}
+function removeLockFile(lockPath) {
+    try {
+        unlinkSync(lockPath);
+    }
+    catch {
+        // best effort: nothing useful to do if it's already gone or unremovable
+    }
+}
+/** Whether the spawn lock at `lockPath` looks abandoned and safe to remove. */
+function isLockStale(lockPath) {
+    let stat;
+    try {
+        stat = statSync(lockPath);
+    }
+    catch {
+        return false; // gone already; nothing to clean up
+    }
+    const ageMs = Date.now() - stat.mtimeMs;
+    if (ageMs > LOCK_MAX_AGE_MS) {
+        return true;
+    }
+    let content;
+    try {
+        content = readFileSync(lockPath, "utf8");
+    }
+    catch {
+        return ageMs > LOCK_EMPTY_GRACE_MS;
+    }
+    const trimmed = content.trim();
+    if (trimmed.length === 0) {
+        return ageMs > LOCK_EMPTY_GRACE_MS;
+    }
+    const pid = Number(trimmed);
+    if (!Number.isInteger(pid)) {
+        return ageMs > LOCK_EMPTY_GRACE_MS;
+    }
+    try {
+        process.kill(pid, 0);
+        return false; // still alive
+    }
+    catch (error) {
+        return error.code === "ESRCH";
+    }
+}
+async function spawnDaemonProcess(paths) {
+    const cliPath = fileURLToPath(new URL("./cli.js", import.meta.url));
+    const logFd = openSync(paths.log, "a");
+    try {
+        const child = spawn(process.execPath, [cliPath, "daemon"], {
+            detached: true,
+            stdio: ["ignore", logFd, logFd],
+        });
+        child.unref();
+    }
+    finally {
+        closeSync(logFd);
+    }
+}
+function displayLogPath(paths, env = process.env) {
+    if (env["ANYBROWSER_HOME"]?.trim()) {
+        return paths.log;
+    }
+    return "~/.anybrowser/daemon.log";
+}
+/**
+ * Returns a socket connected to the daemon, spawning it first if nothing is
+ * listening yet. Safe to call concurrently from many processes: exactly one
+ * spawns the daemon (via an O_EXCL lock file), the rest wait for it.
+ */
+export async function ensureDaemon(paths, deadlineMs = spawnWaitMs()) {
+    assertSocketPathFits(paths.socket);
+    // First run: the state directory (e.g. ~/.anybrowser) may not exist yet.
+    // Create it before anything below needs to open the lock or log file
+    // inside it.
+    mkdirSync(paths.home, { recursive: true, mode: 0o700 });
+    chmodSync(paths.home, 0o700);
+    const deadline = Date.now() + deadlineMs;
+    for (;;) {
+        const connected = await connectOnce(paths.socket);
+        if (connected) {
+            return connected;
+        }
+        if (Date.now() >= deadline) {
+            break;
+        }
+        const lockAttempt = tryCreateLockFile(paths.lock);
+        if (lockAttempt === "acquired") {
+            try {
+                await spawnDaemonProcess(paths);
+                while (Date.now() < deadline) {
+                    const socket = await connectOnce(paths.socket);
+                    if (socket) {
+                        return socket;
+                    }
+                    await delay(pollIntervalMs());
+                }
+                break;
+            }
+            finally {
+                removeLockFile(paths.lock);
+            }
+        }
+        // Someone else holds the lock: wait for them, but reclaim a stale lock.
+        let staleDetected = false;
+        while (Date.now() < deadline) {
+            const socket = await connectOnce(paths.socket);
+            if (socket) {
+                return socket;
+            }
+            if (isLockStale(paths.lock)) {
+                removeLockFile(paths.lock);
+                staleDetected = true;
+                break;
+            }
+            await delay(pollIntervalMs());
+        }
+        if (!staleDetected) {
+            break;
+        }
+        // loop back around and try to acquire the lock ourselves
+    }
+    throw new Error(`anyb: could not connect to or start the daemon within ${deadlineMs}ms. ` +
+        `Check the log at ${displayLogPath(paths)}`);
+}
+//# sourceMappingURL=connect.js.map

package/dist/connect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.js","sourceRoot":"","sources":["../src/connect.ts"],"names":[],"mappings":"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"}

package/dist/daemon.js

@@ -0,0 +1,475 @@
+import { chmodSync, existsSync, mkdirSync, unlinkSync } from "node:fs";
+import { createConnection, createServer } from "node:net";
+import { Server as McpServer } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from "@modelcontextprotocol/sdk/types.js";
+import { assertSocketPathFits } from "./paths.js";
+import { formatErrorLine, formatStatusLine, formatStopAckLine, parseHelloLine, } from "./hello.js";
+import { readVersion } from "./version.js";
+import { SocketTransport } from "./transport.js";
+import { BrowserContextRouter, BrowserSession, ProfileHeadlessRunningError, ProfileUrlBlockedError, } from "./browser.js";
+import { addProfileWithDetection, allowedOriginsProblem, listProfiles, listProfilesWithBadList, profileExists, readProfile, } from "./profile.js";
+import { resolveIdleMs } from "./idle.js";
+const DAEMON_STATUS_TOOL = {
+    name: "daemon_status",
+    description: "Report this daemon's version, pid, uptime, and connected MCP session count.",
+    inputSchema: {
+        type: "object",
+        properties: {},
+        additionalProperties: false,
+    },
+};
+const PROFILE_LIST_TOOL = {
+    name: "profile_list",
+    description: "List every anybrowser profile: id, browser, headless, allowedOrigins (the sites the profile is restricted to, or null for no restriction), and whether it is currently running.",
+    inputSchema: {
+        type: "object",
+        properties: {},
+        additionalProperties: false,
+    },
+};
+const PROFILE_CREATE_TOOL = {
+    name: "profile_create",
+    description: "Create a new anybrowser profile. `browser` is one of chrome, chromium, brave, edge, arc, vivaldi, opera. Returns the new profile's id.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "A lowercase slug, e.g. 'work'. Composed into the id as '<name>-in-<browser>'.",
+            },
+            browser: {
+                type: "string",
+                description: "chrome | chromium | brave | edge | arc | vivaldi | opera",
+            },
+            headless: {
+                type: "boolean",
+                description: "Defaults to false.",
+            },
+        },
+        required: ["name", "browser"],
+        additionalProperties: false,
+    },
+};
+const PROFILE_STATUS_TOOL = {
+    name: "profile_status",
+    description: "Report a profile's running state, tab count (when running), headless flag, browser, and allowedOrigins (the sites the profile is restricted to, or null for no restriction).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            profile: { type: "string", description: "The profile id." },
+        },
+        required: ["profile"],
+        additionalProperties: false,
+    },
+};
+const PROFILE_LOGIN_TOOL = {
+    name: "profile_login",
+    description: "Open `url` in a new, foregrounded tab of `profile`'s browser (launching it headed if not already running), so a human can log in. Returns immediately; ask the user to log in, then verify with a snapshot.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            profile: { type: "string", description: "The profile id." },
+            url: { type: "string", description: "The URL to open for login." },
+        },
+        required: ["profile", "url"],
+        additionalProperties: false,
+    },
+};
+const DAEMON_TOOLS = [
+    DAEMON_STATUS_TOOL,
+    PROFILE_LIST_TOOL,
+    PROFILE_CREATE_TOOL,
+    PROFILE_STATUS_TOOL,
+    PROFILE_LOGIN_TOOL,
+];
+/** Bytes we'll buffer looking for the hello line's newline before giving up on a connection. */
+const MAX_HELLO_LINE_BYTES = 4096;
+function log(event) {
+    process.stderr.write(`[anyb daemon] ${new Date().toISOString()} ${event}\n`);
+}
+function buildStatus(state) {
+    return {
+        version: state.version,
+        pid: process.pid,
+        uptimeSeconds: (Date.now() - state.startedAt) / 1000,
+        sessions: state.sessions.size,
+        profiles: state.browserRouter.runningProfileIds(),
+        idleMs: state.idleMs,
+    };
+}
+/**
+ * Clears any pending idle-exit timer, e.g. because a session just connected
+ * or the daemon is shutting down for another reason.
+ */
+function clearIdleExitTimer(state) {
+    if (state.idleExitTimer !== undefined) {
+        clearTimeout(state.idleExitTimer);
+        state.idleExitTimer = undefined;
+    }
+}
+/**
+ * Re-arms the "exit for idleness" timer whenever sessions.size is (or just
+ * became) zero. A session connecting cancels it (see startMcpSession); this
+ * is called again on every session close so the countdown restarts from that
+ * moment, not from whenever the daemon happened to start.
+ *
+ * Idling is disabled entirely when `idleMs` is null (ANYBROWSER_IDLE_MS=off).
+ */
+function armIdleExitTimer(state) {
+    clearIdleExitTimer(state);
+    if (state.idleMs === null || state.sessions.size > 0 || state.shuttingDown) {
+        return;
+    }
+    state.idleExitTimer = setTimeout(() => {
+        // Re-check at fire time: a session may have connected in the interim.
+        if (state.sessions.size === 0 && !state.shuttingDown) {
+            log(`idle exit: no sessions connected for ${state.idleMs}ms`);
+            void shutdown(state, 0);
+        }
+    }, state.idleMs);
+}
+/** Connects to `socketPath` just to see whether anything answers. Never throws. */
+function probeSocket(socketPath) {
+    return new Promise((resolve) => {
+        const socket = createConnection(socketPath);
+        const finish = (alive) => {
+            socket.removeAllListeners();
+            socket.destroy();
+            resolve(alive);
+        };
+        socket.once("connect", () => finish(true));
+        socket.once("error", () => finish(false));
+    });
+}
+/**
+ * If daemon.sock exists and something is listening on it, another daemon
+ * already owns this state dir: exit quietly. If it exists but nothing
+ * answers, it's a stale leftover: remove it and let the caller bind fresh.
+ */
+async function claimSocketOrExit(paths) {
+    if (!existsSync(paths.socket)) {
+        return;
+    }
+    const alive = await probeSocket(paths.socket);
+    if (alive) {
+        log("another daemon is already live on this socket; exiting");
+        process.exit(0);
+    }
+    try {
+        unlinkSync(paths.socket);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+}
+function startMcpSession(socket, initialData, state, clientVersion) {
+    state.sessions.add(socket);
+    clearIdleExitTimer(state);
+    log(`session open (client version ${clientVersion}, sessions=${state.sessions.size})`);
+    const browserSession = new BrowserSession(state.browserRouter);
+    socket.on("close", () => {
+        state.sessions.delete(socket);
+        log(`session close (sessions=${state.sessions.size})`);
+        armIdleExitTimer(state);
+        // Its tabs go with it; the browser stays (the daemon owns its lifetime).
+        browserSession.dispose().catch((error) => {
+            log(`session tab cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    });
+    // No 'error' listener here: attachHelloHandler already installed the one
+    // permanent listener for this socket's whole life (see its comment), so
+    // adding a second one here would log every socket error twice.
+    try {
+        const transport = new SocketTransport(socket, initialData);
+        const server = new McpServer({ name: "anybrowser", version: state.version }, { capabilities: { tools: {} } });
+        server.setRequestHandler(ListToolsRequestSchema, async () => {
+            const browserTools = await browserSession.listTools();
+            return { tools: [...DAEMON_TOOLS, ...browserTools] };
+        });
+        server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            if (request.params.name === "daemon_status") {
+                return {
+                    content: [{ type: "text", text: JSON.stringify(buildStatus(state)) }],
+                };
+            }
+            if (request.params.name === "profile_list") {
+                const profiles = listProfiles(state.paths).map((profile) => ({
+                    id: profile.id,
+                    browser: profile.browser,
+                    headless: profile.headless,
+                    allowedOrigins: profile.allowedOrigins,
+                    running: state.browserRouter.runningProfileIds().includes(profile.id),
+                }));
+                const broken = listProfilesWithBadList(state.paths).map(({ id, problem }) => ({ id, error: problem }));
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify([...profiles, ...broken]),
+                        },
+                    ],
+                };
+            }
+            if (request.params.name === "profile_create") {
+                const args = (request.params.arguments ?? {});
+                if (args.allowedOrigins !== undefined) {
+                    // The allowed-sites list is a human guard rail, like `headless`
+                    // (decision 7). Failing loudly beats ignoring it: an agent that
+                    // thought it had pinned a profile would act as if it were safe.
+                    return {
+                        isError: true,
+                        content: [
+                            {
+                                type: "text",
+                                text: "profile_create cannot set an allowed-sites list; only the user can, with 'anyb profile add <name> <browser> --allow <list>' or 'anyb profile set <id> allowedOrigins=<list>'",
+                            },
+                        ],
+                    };
+                }
+                if (typeof args.name !== "string" || typeof args.browser !== "string") {
+                    return {
+                        isError: true,
+                        content: [
+                            {
+                                type: "text",
+                                text: "profile_create requires string 'name' and 'browser'",
+                            },
+                        ],
+                    };
+                }
+                const outcome = addProfileWithDetection(state.paths, {
+                    name: args.name,
+                    browser: args.browser,
+                    headless: args.headless === true,
+                });
+                if (!outcome.ok) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: outcome.message }],
+                    };
+                }
+                return { content: [{ type: "text", text: outcome.id }] };
+            }
+            if (request.params.name === "profile_status") {
+                const args = (request.params.arguments ?? {});
+                if (typeof args.profile !== "string" || args.profile.length === 0) {
+                    throw new McpError(ErrorCode.InvalidParams, "profile_status requires a string 'profile' argument");
+                }
+                if (!profileExists(state.paths, args.profile)) {
+                    throw new McpError(ErrorCode.InvalidParams, `unknown profile '${args.profile}'`);
+                }
+                const problem = allowedOriginsProblem(state.paths, args.profile);
+                if (problem) {
+                    return {
+                        isError: true,
+                        content: [
+                            {
+                                type: "text",
+                                text: `Profile '${args.profile}': ${problem}. The last list read stays in force while the daemon runs. Ask the user to fix profile.json outside the agent.`,
+                            },
+                        ],
+                    };
+                }
+                const stored = readProfile(state.paths, args.profile);
+                const runningContext = state.browserRouter.runningContext(args.profile);
+                const idleForMs = state.browserRouter.idleForMs(args.profile);
+                const status = {
+                    running: runningContext !== undefined,
+                    headless: stored.headless,
+                    browser: stored.browser,
+                    allowedOrigins: stored.allowedOrigins,
+                    ...(runningContext
+                        ? {
+                            tabCount: runningContext.pages().length,
+                            ...(idleForMs !== undefined ? { idleForMs } : {}),
+                        }
+                        : {}),
+                };
+                return { content: [{ type: "text", text: JSON.stringify(status) }] };
+            }
+            if (request.params.name === "profile_login") {
+                const args = (request.params.arguments ?? {});
+                if (typeof args.profile !== "string" ||
+                    args.profile.length === 0 ||
+                    typeof args.url !== "string" ||
+                    args.url.length === 0) {
+                    throw new McpError(ErrorCode.InvalidParams, "profile_login requires string 'profile' and 'url' arguments");
+                }
+                if (!profileExists(state.paths, args.profile)) {
+                    throw new McpError(ErrorCode.InvalidParams, `unknown profile '${args.profile}'`);
+                }
+                try {
+                    await state.browserRouter.loginLaunch(args.profile, args.url);
+                }
+                catch (error) {
+                    if (error instanceof ProfileHeadlessRunningError ||
+                        error instanceof ProfileUrlBlockedError) {
+                        return {
+                            isError: true,
+                            content: [{ type: "text", text: error.message }],
+                        };
+                    }
+                    throw error;
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Opened ${args.url} in a new tab for profile '${args.profile}'. Ask the user to log in, then verify with a snapshot.`,
+                        },
+                    ],
+                };
+            }
+            return browserSession.callTool(request.params.name, (request.params.arguments ?? {}));
+        });
+        server.connect(transport).catch((error) => {
+            log(`session error: ${error instanceof Error ? error.message : String(error)}`);
+            socket.destroy();
+        });
+    }
+    catch (error) {
+        log(`session error: ${error instanceof Error ? error.message : String(error)}`);
+        socket.destroy();
+    }
+}
+function handleHello(socket, line, rest, state) {
+    const parsed = parseHelloLine(line);
+    if (!parsed.ok) {
+        log(`bad hello: ${parsed.error}`);
+        socket.end(formatErrorLine(parsed.error));
+        return;
+    }
+    switch (parsed.role) {
+        case "status":
+            socket.end(formatStatusLine(buildStatus(state)));
+            return;
+        case "stop":
+            socket.write(formatStopAckLine(), () => {
+                socket.end(() => {
+                    void shutdown(state, 0);
+                });
+            });
+            return;
+        case "mcp":
+            startMcpSession(socket, rest, state, parsed.version);
+            return;
+    }
+}
+function attachHelloHandler(socket, state) {
+    let buffered = Buffer.alloc(0);
+    // Every accepted socket must have an 'error' listener for its whole life:
+    // Node treats an unhandled 'error' event as fatal to the process. A reply
+    // write can fail (e.g. EPIPE) after the hello-parsing phase is done, once
+    // control has moved on to handleHello/startMcpSession, so this listener is
+    // never removed - unlike the hello-parsing 'data'/'close' listeners below,
+    // which are only needed until the hello line is read.
+    socket.on("error", (error) => {
+        log(`session error: ${error.message}`);
+    });
+    const cleanup = () => {
+        socket.off("data", onData);
+        socket.off("close", onClose);
+    };
+    const onClose = () => cleanup();
+    const onData = (chunk) => {
+        buffered = buffered.length === 0 ? chunk : Buffer.concat([buffered, chunk]);
+        const newlineIndex = buffered.indexOf(0x0a);
+        if (newlineIndex === -1) {
+            if (buffered.length > MAX_HELLO_LINE_BYTES) {
+                log("bad hello: first line too long");
+                socket.destroy();
+            }
+            return;
+        }
+        cleanup();
+        const line = buffered
+            .subarray(0, newlineIndex)
+            .toString("utf8")
+            .replace(/\r$/, "");
+        const rest = buffered.subarray(newlineIndex + 1);
+        handleHello(socket, line, rest, state);
+    };
+    socket.on("data", onData);
+    socket.on("close", onClose);
+}
+async function shutdown(state, exitCode) {
+    if (state.shuttingDown) {
+        return;
+    }
+    state.shuttingDown = true;
+    clearIdleExitTimer(state);
+    log("stop: shutting down");
+    state.server.close();
+    for (const session of state.sessions) {
+        session.destroy();
+    }
+    state.sessions.clear();
+    // Close every open browser context (flushing its cookie store etc. to
+    // disk) BEFORE removing the socket file: a caller of `anyb stop` waits for
+    // the socket to disappear as its signal that shutdown is complete (see
+    // cli.ts's runStopCommand), so the socket must not vanish until a script
+    // that immediately inspects the profile directory afterwards sees a
+    // flushed cookie store.
+    await state.browserRouter.closeAll();
+    try {
+        unlinkSync(state.paths.socket);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            log(`stop: failed to remove socket: ${error.message}`);
+        }
+    }
+    log("stop: done");
+    process.exit(exitCode);
+}
+/** Runs the daemon in the foreground. Resolves once it is listening; keeps running until shutdown. */
+export async function runDaemon(paths) {
+    // Playwright's own switch for NOT forcing loopback through a browser's proxy.
+    // The allowed-sites proxy must see local servers too, and the check upstream
+    // is plain truthiness (even "0" disables forcing), so only deleting it is safe.
+    delete process.env["PLAYWRIGHT_DISABLE_FORCED_CHROMIUM_PROXIED_LOOPBACK"];
+    assertSocketPathFits(paths.socket);
+    log(`start pid=${process.pid} version=${readVersion()}`);
+    mkdirSync(paths.home, { recursive: true, mode: 0o700 });
+    chmodSync(paths.home, 0o700);
+    await claimSocketOrExit(paths);
+    const version = readVersion();
+    const server = createServer();
+    const idleMs = resolveIdleMs(paths);
+    const state = {
+        paths,
+        version,
+        startedAt: Date.now(),
+        sessions: new Set(),
+        server,
+        shuttingDown: false,
+        browserRouter: new BrowserContextRouter(paths, log, idleMs),
+        idleMs,
+        idleExitTimer: undefined,
+    };
+    log(`idle: idleMs=${idleMs === null ? "off" : idleMs}`);
+    // No session has connected yet, so the countdown to an idle exit starts
+    // from daemon startup itself (see armIdleExitTimer's doc comment).
+    armIdleExitTimer(state);
+    server.on("connection", (socket) => {
+        attachHelloHandler(socket, state);
+    });
+    server.on("error", (error) => {
+        log(`server error: ${error.message}`);
+    });
+    await new Promise((resolve, reject) => {
+        const onError = (error) => reject(error);
+        server.once("error", onError);
+        server.listen(paths.socket, () => {
+            server.off("error", onError);
+            resolve();
+        });
+    });
+    chmodSync(paths.socket, 0o600);
+    log(`listening on ${paths.socket}`);
+    process.on("SIGTERM", () => void shutdown(state, 0));
+    process.on("SIGINT", () => void shutdown(state, 0));
+}
+//# sourceMappingURL=daemon.js.map