@different-ai/opencode-browser 2.1.0 → 3.0.0

package/src/plugin.ts

@@ -1,672 +0,0 @@
-/**
- * OpenCode Browser Plugin
- *
- * OpenCode Plugin (this) <--WebSocket:19222--> Chrome Extension
- *
- * Notes
- * - Uses a lock file so only one OpenCode session owns the browser.
- * - Supports a *soft takeover* (SIGUSR1) so we don't have to kill OpenCode.
- */
-
-import type { Plugin } from "@opencode-ai/plugin";
-import { tool } from "@opencode-ai/plugin";
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-
-const WS_PORT = 19222;
-const BASE_DIR = join(homedir(), ".opencode-browser");
-const LOCK_FILE = join(BASE_DIR, "lock.json");
-const SCREENSHOTS_DIR = join(BASE_DIR, "screenshots");
-
-// If a session hasn't used the browser in this long, allow soft takeover by default.
-const LOCK_TTL_MS = 2 * 60 * 60 * 1000; // 2 hours
-
-mkdirSync(BASE_DIR, { recursive: true });
-mkdirSync(SCREENSHOTS_DIR, { recursive: true });
-
-// Session state
-const sessionId = Math.random().toString(36).slice(2);
-const pid = process.pid;
-let ws: WebSocket | null = null;
-let isConnected = false;
-let server: ReturnType<typeof Bun.serve> | null = null;
-let pendingRequests = new Map<number, { resolve: (v: any) => void; reject: (e: Error) => void }>();
-let requestId = 0;
-
-interface LockInfo {
-  pid: number;
-  sessionId: string;
-  startedAt: string;
-  lastUsedAt: string;
-  cwd: string;
-}
-
-function nowIso(): string {
-  return new Date().toISOString();
-}
-
-function readLock(): LockInfo | null {
-  try {
-    if (!existsSync(LOCK_FILE)) return null;
-    return JSON.parse(readFileSync(LOCK_FILE, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-
-function writeLock(): void {
-  writeFileSync(
-    LOCK_FILE,
-    JSON.stringify(
-      {
-        pid,
-        sessionId,
-        startedAt: nowIso(),
-        lastUsedAt: nowIso(),
-        cwd: process.cwd(),
-      } satisfies LockInfo,
-      null,
-      2
-    ) + "\n"
-  );
-}
-
-function touchLock(): void {
-  const lock = readLock();
-  if (!lock) return;
-  if (lock.sessionId !== sessionId) return;
-
-  try {
-    writeFileSync(
-      LOCK_FILE,
-      JSON.stringify(
-        {
-          ...lock,
-          lastUsedAt: nowIso(),
-        } satisfies LockInfo,
-        null,
-        2
-      ) + "\n"
-    );
-  } catch {
-    // Ignore
-  }
-}
-
-function releaseLock(): void {
-  try {
-    const lock = readLock();
-    if (lock && lock.sessionId === sessionId) {
-      unlinkSync(LOCK_FILE);
-    }
-  } catch {
-    // Ignore
-  }
-}
-
-function isProcessAlive(targetPid: number): boolean {
-  try {
-    process.kill(targetPid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function lockAgeMs(lock: LockInfo): number {
-  const ts = lock.lastUsedAt || lock.startedAt;
-  const n = Date.parse(ts);
-  if (Number.isNaN(n)) return Number.POSITIVE_INFINITY;
-  return Date.now() - n;
-}
-
-function isLockExpired(lock: LockInfo): boolean {
-  return lockAgeMs(lock) > LOCK_TTL_MS;
-}
-
-function isPortFree(port: number): boolean {
-  try {
-    // If we can connect, something is already listening.
-    const testSocket = Bun.connect({ port, timeout: 300 });
-    testSocket.end();
-    return false;
-  } catch (e) {
-    if ((e as any).code === "ECONNREFUSED") return true;
-    return false;
-  }
-}
-
-function stopBrowserServer(): void {
-  try {
-    (ws as any)?.close?.();
-  } catch {
-    // Ignore
-  }
-  ws = null;
-  isConnected = false;
-
-  try {
-    server?.stop();
-  } catch {
-    // Ignore
-  }
-  server = null;
-}
-
-function startServer(): boolean {
-  if (server) return true;
-  if (!isPortFree(WS_PORT)) return false;
-
-  try {
-    server = Bun.serve({
-      port: WS_PORT,
-      fetch(req, server) {
-        if (server.upgrade(req)) return;
-        return new Response("OpenCode Browser Plugin", { status: 200 });
-      },
-      websocket: {
-        open(wsClient) {
-          console.error(`[browser-plugin] Chrome extension connected`);
-          ws = wsClient as unknown as WebSocket;
-          isConnected = true;
-        },
-        close() {
-          console.error(`[browser-plugin] Chrome extension disconnected`);
-          ws = null;
-          isConnected = false;
-        },
-        message(_wsClient, data) {
-          try {
-            const message = JSON.parse(data.toString());
-            handleMessage(message);
-          } catch (e) {
-            console.error(`[browser-plugin] Parse error:`, e);
-          }
-        },
-      },
-    });
-
-    console.error(`[browser-plugin] WebSocket server listening on port ${WS_PORT}`);
-    return true;
-  } catch (e) {
-    console.error(`[browser-plugin] Failed to start server:`, e);
-    return false;
-  }
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-async function waitForExtensionConnection(timeoutMs: number): Promise<boolean> {
-  const start = Date.now();
-  while (Date.now() - start < timeoutMs) {
-    if (isConnected) return true;
-    await sleep(100);
-  }
-  return isConnected;
-}
-
-async function requestSessionRelease(targetPid: number, opts?: { timeoutMs?: number }): Promise<{ success: boolean; error?: string }> {
-  const timeoutMs = opts?.timeoutMs ?? 3000;
-
-  try {
-    // SIGUSR1 is treated as "release browser lock + stop server".
-    // This does NOT terminate OpenCode.
-    process.kill(targetPid, "SIGUSR1");
-  } catch (e) {
-    return { success: false, error: e instanceof Error ? e.message : String(e) };
-  }
-
-  const start = Date.now();
-  while (Date.now() - start < timeoutMs) {
-    const lock = readLock();
-    const lockCleared = !lock || lock.pid !== targetPid;
-    const portCleared = isPortFree(WS_PORT);
-
-    if (lockCleared && portCleared) return { success: true };
-    await sleep(100);
-  }
-
-  return {
-    success: false,
-    error: `Timed out waiting for PID ${targetPid} to release browser`,
-  };
-}
-
-async function forceKillSession(targetPid: number): Promise<{ success: boolean; error?: string }> {
-  try {
-    process.kill(targetPid, "SIGTERM");
-    let attempts = 0;
-    while (isProcessAlive(targetPid) && attempts < 20) {
-      await sleep(100);
-      attempts++;
-    }
-    if (isProcessAlive(targetPid)) {
-      process.kill(targetPid, "SIGKILL");
-    }
-    return { success: true };
-  } catch (e) {
-    return { success: false, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-
-function handleMessage(message: { type: string; id?: number; result?: any; error?: any }): void {
-  if (message.type === "tool_response" && message.id !== undefined) {
-    const pending = pendingRequests.get(message.id);
-    if (!pending) return;
-
-    pendingRequests.delete(message.id);
-    if (message.error) {
-      pending.reject(new Error(message.error.content || String(message.error)));
-    } else {
-      pending.resolve(message.result?.content);
-    }
-  }
-}
-
-function sendToChrome(message: any): boolean {
-  if (ws && isConnected) {
-    (ws as any).send(JSON.stringify(message));
-    return true;
-  }
-  return false;
-}
-
-async function performTakeover(): Promise<string> {
-  const lock = readLock();
-
-  if (!lock) {
-    writeLock();
-  } else if (lock.sessionId === sessionId) {
-    // Already ours.
-  } else if (!isProcessAlive(lock.pid)) {
-    // Dead PID -> stale.
-    console.error(`[browser-plugin] Cleaning stale lock from dead PID ${lock.pid}`);
-    writeLock();
-  } else {
-    const ageMinutes = Math.round(lockAgeMs(lock) / 60000);
-    console.error(
-      `[browser-plugin] Requesting release from PID ${lock.pid} (last used ${ageMinutes}m ago)...`
-    );
-    const released = await requestSessionRelease(lock.pid, { timeoutMs: 4000 });
-    if (!released.success) {
-      throw new Error(
-        `Failed to takeover without killing OpenCode: ${released.error}. ` +
-          `Try again, or use browser_force_kill_session as last resort.`
-      );
-    }
-    console.error(`[browser-plugin] Previous session released gracefully.`);
-    writeLock();
-  }
-
-  touchLock();
-
-  if (!server) {
-    if (!startServer()) {
-      throw new Error("Failed to start WebSocket server after takeover.");
-    }
-  }
-
-  const ok = await waitForExtensionConnection(3000);
-  if (!ok) {
-    throw new Error("Took over lock but Chrome extension did not connect.");
-  }
-
-  return "Browser now connected to this session.";
-}
-
-async function ensureLockAndServer(): Promise<void> {
-  const existingLock = readLock();
-
-  if (!existingLock) {
-    writeLock();
-  } else if (existingLock.sessionId === sessionId) {
-    // Already ours.
-  } else if (!isProcessAlive(existingLock.pid)) {
-    // Stale lock (dead PID).
-    console.error(`[browser-plugin] Cleaning stale lock from dead PID ${existingLock.pid}`);
-    writeLock();
-  } else {
-    // Another session holds the lock - attempt automatic soft takeover
-    const ageMinutes = Math.round(lockAgeMs(existingLock) / 60000);
-    console.error(
-      `[browser-plugin] Browser locked by PID ${existingLock.pid} (last used ${ageMinutes}m ago). Attempting auto-takeover...`
-    );
-
-    const released = await requestSessionRelease(existingLock.pid, { timeoutMs: 4000 });
-    if (released.success) {
-      console.error(`[browser-plugin] Auto-takeover succeeded. Previous session released gracefully.`);
-      writeLock();
-    } else {
-      // Soft takeover failed - provide helpful error
-      const expired = isLockExpired(existingLock);
-      const why = expired ? "expired" : "active";
-      throw new Error(
-        `Browser locked by another session (PID ${existingLock.pid}, ${why}). ` +
-          `Auto-takeover failed: ${released.error}. ` +
-          `Use browser_force_kill_session as last resort, or browser_status for details.`
-      );
-    }
-  }
-
-  touchLock();
-
-  if (!server) {
-    if (!startServer()) {
-      throw new Error("Failed to start WebSocket server. Port may be in use.");
-    }
-  }
-
-  if (!isConnected) {
-    const ok = await waitForExtensionConnection(3000);
-    if (!ok) {
-      throw new Error(
-        "Chrome extension not connected. Make sure Chrome is running with the OpenCode Browser extension enabled."
-      );
-    }
-  }
-}
-
-async function executeCommand(toolName: string, args: Record<string, any>): Promise<any> {
-  await ensureLockAndServer();
-
-  const id = ++requestId;
-  touchLock();
-
-  return new Promise((resolve, reject) => {
-    pendingRequests.set(id, { resolve, reject });
-
-    sendToChrome({
-      type: "tool_request",
-      id,
-      tool: toolName,
-      args,
-    });
-
-    setTimeout(() => {
-      if (!pendingRequests.has(id)) return;
-      pendingRequests.delete(id);
-      reject(new Error("Tool execution timed out after 60 seconds"));
-    }, 60000);
-  });
-}
-
-// ============================================================================
-// Cleanup / Signals
-// ============================================================================
-
-// Soft release: do NOT exit the OpenCode process.
-process.on("SIGUSR1", () => {
-  console.error(`[browser-plugin] SIGUSR1: releasing lock + stopping server`);
-  releaseLock();
-  stopBrowserServer();
-});
-
-process.on("SIGTERM", () => {
-  releaseLock();
-  stopBrowserServer();
-  process.exit(0);
-});
-
-process.on("SIGINT", () => {
-  releaseLock();
-  stopBrowserServer();
-  process.exit(0);
-});
-
-process.on("exit", () => {
-  releaseLock();
-});
-
-// ============================================================================
-// Plugin Export
-// ============================================================================
-
-export const BrowserPlugin: Plugin = async (_ctx) => {
-  console.error(`[browser-plugin] Initializing (session ${sessionId})`);
-
-  return {
-    tool: {
-      browser_status: tool({
-        description:
-          "Check if browser is available or locked by another session. Returns connection status and lock info.",
-        args: {},
-        async execute() {
-          const lock = readLock();
-
-          if (!lock) {
-            return "Browser available (no active session)";
-          }
-
-          if (lock.sessionId === sessionId) {
-            return (
-              `Browser connected (this session)\n` +
-              `PID: ${pid}\n` +
-              `Started: ${lock.startedAt}\n` +
-              `Last used: ${lock.lastUsedAt}\n` +
-              `Extension: ${isConnected ? "connected" : "not connected"}`
-            );
-          }
-
-          const alive = isProcessAlive(lock.pid);
-          const ageMinutes = Math.round(lockAgeMs(lock) / 60000);
-          const expired = isLockExpired(lock);
-
-          if (!alive) {
-            return `Browser available (stale lock from dead PID ${lock.pid} will be auto-cleaned on next command)`;
-          }
-
-          return (
-            `Browser locked by another session\n` +
-            `PID: ${lock.pid}\n` +
-            `Session: ${lock.sessionId}\n` +
-            `Started: ${lock.startedAt}\n` +
-            `Last used: ${lock.lastUsedAt} (~${ageMinutes}m ago)${expired ? " [expired]" : ""}\n` +
-            `Working directory: ${lock.cwd}\n\n` +
-            `Use browser_takeover to request release (no kill), or browser_force_kill_session as last resort.`
-          );
-        },
-      }),
-
-      browser_release: tool({
-        description: "Release browser lock and stop the server for this session.",
-        args: {},
-        async execute() {
-          const lock = readLock();
-          if (lock && lock.sessionId !== sessionId) {
-            throw new Error("This session does not own the browser lock.");
-          }
-
-          releaseLock();
-          stopBrowserServer();
-          return "Released browser lock for this session.";
-        },
-      }),
-
-      browser_takeover: tool({
-        description:
-          "Request the session holding the browser lock to release it (no process kill), then take over.",
-        args: {},
-        async execute() {
-          return await performTakeover();
-        },
-      }),
-
-      browser_kill_session: tool({
-        description:
-          "(Deprecated name) Soft takeover without killing OpenCode. Prefer browser_takeover.",
-        args: {},
-        async execute() {
-          // Keep backward compatibility: old callers use this.
-          return await performTakeover();
-        },
-      }),
-
-      browser_force_kill_session: tool({
-        description: "Force kill the session holding the browser lock (last resort).",
-        args: {},
-        async execute() {
-          const lock = readLock();
-
-          if (!lock) {
-            writeLock();
-            return "No active session. Browser now connected to this session.";
-          }
-
-          if (lock.sessionId === sessionId) {
-            return "This session already owns the browser.";
-          }
-
-          if (!isProcessAlive(lock.pid)) {
-            writeLock();
-            return `Cleaned stale lock (PID ${lock.pid} was dead). Browser now connected to this session.`;
-          }
-
-          const result = await forceKillSession(lock.pid);
-          if (!result.success) {
-            throw new Error(`Failed to force kill session: ${result.error}`);
-          }
-
-          // Best-effort cleanup; then take lock.
-          try {
-            unlinkSync(LOCK_FILE);
-          } catch {
-            // Ignore
-          }
-
-          writeLock();
-
-          if (!server) {
-            if (!startServer()) {
-              throw new Error("Failed to start WebSocket server after force kill.");
-            }
-          }
-
-          const ok = await waitForExtensionConnection(3000);
-          if (!ok) {
-            throw new Error("Force-killed lock holder but Chrome extension did not connect.");
-          }
-
-          return `Force-killed session ${lock.sessionId} (PID ${lock.pid}). Browser now connected to this session.`;
-        },
-      }),
-
-      browser_navigate: tool({
-        description: "Navigate to a URL in browser",
-        args: {
-          url: tool.schema.string({ description: "The URL to navigate to" }),
-          tabId: tool.schema.optional(tool.schema.number({ description: "Optional tab ID" })),
-        },
-        async execute(args) {
-          return await executeCommand("navigate", args);
-        },
-      }),
-
-      browser_click: tool({
-        description: "Click an element on page using a CSS selector",
-        args: {
-          selector: tool.schema.string({ description: "CSS selector for element to click" }),
-          tabId: tool.schema.optional(tool.schema.number({ description: "Optional tab ID" })),
-        },
-        async execute(args) {
-          return await executeCommand("click", args);
-        },
-      }),
-
-      browser_type: tool({
-        description: "Type text into an input element",
-        args: {
-          selector: tool.schema.string({ description: "CSS selector for input element" }),
-          text: tool.schema.string({ description: "Text to type" }),
-          clear: tool.schema.optional(tool.schema.boolean({ description: "Clear field before typing" })),
-          tabId: tool.schema.optional(tool.schema.number({ description: "Optional tab ID" })),
-        },
-        async execute(args) {
-          return await executeCommand("type", args);
-        },
-      }),
-
-      browser_screenshot: tool({
-        description: "Take a screenshot of the current page. Saves to ~/.opencode-browser/screenshots/",
-        args: {
-          tabId: tool.schema.optional(tool.schema.number({ description: "Optional tab ID" })),
-          name: tool.schema.optional(
-            tool.schema.string({ description: "Optional name for screenshot file (without extension)" })
-          ),
-        },
-        async execute(args: { tabId?: number; name?: string }) {
-          const result = await executeCommand("screenshot", args);
-
-          if (result && typeof result === "string" && result.startsWith("data:image")) {
-            const base64Data = result.replace(/^data:image\/\w+;base64,/, "");
-            const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-            const filename = args.name ? `${args.name}.png` : `screenshot-${timestamp}.png`;
-            const filepath = join(SCREENSHOTS_DIR, filename);
-
-            writeFileSync(filepath, Buffer.from(base64Data, "base64"));
-            return `Screenshot saved: ${filepath}`;
-          }
-
-          return result;
-        },
-      }),
-
-      browser_snapshot: tool({
-        description:
-          "Get an accessibility tree snapshot of the page. Returns interactive elements with selectors for clicking.",
-        args: {
-          tabId: tool.schema.optional(tool.schema.number({ description: "Optional tab ID" })),
-        },
-        async execute(args) {
-          return await executeCommand("snapshot", args);
-        },
-      }),
-
-      browser_get_tabs: tool({
-        description: "List all open browser tabs",
-        args: {},
-        async execute() {
-          return await executeCommand("get_tabs", {});
-        },
-      }),
-
-      browser_scroll: tool({
-        description: "Scroll the page or scroll an element into view",
-        args: {
-          selector: tool.schema.optional(tool.schema.string({ description: "CSS selector to scroll into view" })),
-          x: tool.schema.optional(tool.schema.number({ description: "Horizontal scroll amount in pixels" })),
-          y: tool.schema.optional(tool.schema.number({ description: "Vertical scroll amount in pixels" })),
-          tabId: tool.schema.optional(tool.schema.number({ description: "Optional tab ID" })),
-        },
-        async execute(args) {
-          return await executeCommand("scroll", args);
-        },
-      }),
-
-      browser_wait: tool({
-        description: "Wait for a specified duration",
-        args: {
-          ms: tool.schema.optional(tool.schema.number({ description: "Milliseconds to wait (default: 1000)" })),
-        },
-        async execute(args) {
-          return await executeCommand("wait", args);
-        },
-      }),
-
-      browser_execute: tool({
-        description: "Execute JavaScript code in the page context and return the result",
-        args: {
-          code: tool.schema.string({ description: "JavaScript code to execute" }),
-          tabId: tool.schema.optional(tool.schema.number({ description: "Optional tab ID" })),
-        },
-        async execute(args) {
-          return await executeCommand("execute_script", args);
-        },
-      }),
-    },
-  };
-};
-
-export default BrowserPlugin;