@hasna/browser 0.4.1 → 0.4.3

package/dist/mcp/index.js

@@ -10657,7 +10657,42 @@ async function launchTui(command, options = {}) {
       waitUntil: "domcontentloaded"
     });
     await page.waitForSelector(".xterm-screen", { timeout: 1e4 });
-    return { ttydProcess, port, browser, page };
+    let resolvedTheme = "dark";
+    const requestedTheme = options.theme ?? "system";
+    if (requestedTheme === "light") {
+      resolvedTheme = "light";
+    } else if (requestedTheme === "dark") {
+      resolvedTheme = "dark";
+    } else {
+      try {
+        const result = execSync2("defaults read -g AppleInterfaceStyle 2>/dev/null", { encoding: "utf8" }).trim();
+        resolvedTheme = result === "Dark" ? "dark" : "light";
+      } catch {
+        resolvedTheme = "light";
+      }
+    }
+    const themeColors = THEMES[resolvedTheme];
+    await page.evaluate((theme) => {
+      const term = window.term ?? window.terminal;
+      if (term?.options) {
+        term.options.theme = theme;
+      }
+      document.body.style.backgroundColor = theme.background;
+      const container = document.getElementById("terminal-container");
+      if (container)
+        container.style.backgroundColor = theme.background;
+      const viewport2 = document.querySelector(".xterm-viewport");
+      if (viewport2)
+        viewport2.style.backgroundColor = theme.background;
+    }, themeColors);
+    if (options.fontSize) {
+      await page.evaluate((size) => {
+        const term = window.term ?? window.terminal;
+        if (term?.options)
+          term.options.fontSize = size;
+      }, options.fontSize);
+    }
+    return { ttydProcess, port, browser, page, theme: resolvedTheme };
   } catch (err) {
     ttydProcess.kill();
     throw err;
@@ -10674,11 +10709,57 @@ async function closeTui(session) {
     session.ttydProcess.kill("SIGTERM");
   } catch {}
 }
-var DEFAULT_TTYD_PORT_START = 7780, nextPort;
+var DEFAULT_TTYD_PORT_START = 7780, nextPort, THEMES;
 var init_tui = __esm(() => {
   init_types();
   init_playwright();
   nextPort = DEFAULT_TTYD_PORT_START;
+  THEMES = {
+    dark: {
+      background: "#1e1e1e",
+      foreground: "#d4d4d4",
+      cursor: "#d4d4d4",
+      selectionBackground: "#264f78",
+      black: "#1e1e1e",
+      red: "#f44747",
+      green: "#6a9955",
+      yellow: "#d7ba7d",
+      blue: "#569cd6",
+      magenta: "#c586c0",
+      cyan: "#4ec9b0",
+      white: "#d4d4d4",
+      brightBlack: "#808080",
+      brightRed: "#f44747",
+      brightGreen: "#6a9955",
+      brightYellow: "#d7ba7d",
+      brightBlue: "#569cd6",
+      brightMagenta: "#c586c0",
+      brightCyan: "#4ec9b0",
+      brightWhite: "#ffffff"
+    },
+    light: {
+      background: "#ffffff",
+      foreground: "#1e1e1e",
+      cursor: "#1e1e1e",
+      selectionBackground: "#add6ff",
+      black: "#1e1e1e",
+      red: "#cd3131",
+      green: "#008000",
+      yellow: "#795e26",
+      blue: "#0451a5",
+      magenta: "#af00db",
+      cyan: "#0598bc",
+      white: "#d4d4d4",
+      brightBlack: "#808080",
+      brightRed: "#cd3131",
+      brightGreen: "#008000",
+      brightYellow: "#795e26",
+      brightBlue: "#0451a5",
+      brightMagenta: "#af00db",
+      brightCyan: "#0598bc",
+      brightWhite: "#ffffff"
+    }
+  };
 });
 
 // src/engines/selector.ts
@@ -12111,7 +12192,9 @@ async function createSession2(opts = {}) {
     const command = opts.startUrl ?? "bash";
     const tuiSess = await launchTui(command, {
       headless: opts.headless ?? true,
-      viewport: opts.viewport
+      viewport: opts.viewport,
+      theme: opts.tuiTheme ?? "system",
+      fontSize: opts.tuiFontSize
     });
     browser = tuiSess.browser;
     page = tuiSess.page;
@@ -43815,12 +43898,26 @@ function resolveSessionId(sessionId) {
 
 // src/mcp/sessions.ts
 function register(server) {
-  server.tool("browser_session_create", "Create a new browser session. If agent_id is set and already has an active session, returns the existing one (use force_new to override). If session_id is omitted on other tools, the single active session is auto-selected. Use cdp_url to attach to an already-running Chrome instance.", {
-    engine: exports_external.enum(["playwright", "cdp", "lightpanda", "bun", "tui", "auto"]).optional().default("auto"),
-    use_case: exports_external.string().optional(),
+  server.tool("browser_session_create", `Create a new browser session. Returns a session object with an id you must pass to other tools.
+
+ENGINES:
+- "auto" (default): picks the best engine for your use case automatically
+- "playwright": full browser automation \u2014 forms, SPAs, auth flows, multi-tab
+- "cdp": Chrome DevTools Protocol \u2014 network monitoring, perf profiling, script injection
+- "lightpanda": fast headless for static pages
+- "bun": native Bun.WebView \u2014 fastest for screenshots and scraping
+- "tui": terminal UI testing \u2014 launches a CLI/TUI app (Ink, Blessed, Bubbletea, etc.) via ttyd and connects Playwright to it. Pass the shell command as start_url (e.g. "htop", "bun run app.tsx"). All browser tools (screenshot, click, type, wait) work on the terminal. Use tui_theme to control dark/light appearance.
+
+TIPS:
+- If agent_id is set and already has an active session, returns the existing one (use force_new to override)
+- If session_id is omitted on other tools, the single active session is auto-selected
+- Use cdp_url to attach to an already-running Chrome instance
+- For TUI sessions: start_url is the shell command to run, NOT a URL`, {
+    engine: exports_external.enum(["playwright", "cdp", "lightpanda", "bun", "tui", "auto"]).optional().default("auto").describe("Browser engine. Use 'tui' for terminal/CLI app testing \u2014 pass the command as start_url"),
+    use_case: exports_external.string().optional().describe("Hint for auto engine selection: scrape, screenshot, form, auth, network, har, perf, terminal, tui"),
     project_id: exports_external.string().optional(),
     agent_id: exports_external.string().optional(),
-    start_url: exports_external.string().optional(),
+    start_url: exports_external.string().optional().describe("URL to navigate to, OR for engine='tui': the shell command to run (e.g. 'htop', 'bun run app.tsx')"),
     headless: exports_external.boolean().optional().default(true),
     viewport_width: exports_external.number().optional().default(1280),
     viewport_height: exports_external.number().optional().default(720),
@@ -43829,8 +43926,10 @@ function register(server) {
     storage_state: exports_external.string().optional().describe("Name of saved storage state to load (restores cookies/auth from previous session)"),
     force_new: exports_external.boolean().optional().default(false).describe("Force create a new session even if agent already has one"),
     tags: exports_external.array(exports_external.string()).optional(),
-    cdp_url: exports_external.string().optional().describe("Connect to existing Chrome via CDP (e.g. http://localhost:9222). Start Chrome with --remote-debugging-port=9222")
-  }, async ({ engine, use_case, project_id, agent_id, start_url, headless, viewport_width, viewport_height, stealth, auto_gallery, storage_state, force_new, tags, cdp_url }) => {
+    cdp_url: exports_external.string().optional().describe("Connect to existing Chrome via CDP (e.g. http://localhost:9222). Start Chrome with --remote-debugging-port=9222"),
+    tui_theme: exports_external.enum(["dark", "light", "system"]).optional().default("system").describe("TUI engine only: terminal color theme. 'system' auto-detects OS dark/light mode. Choose 'light' for light backgrounds or 'dark' for dark backgrounds."),
+    tui_font_size: exports_external.number().optional().default(14).describe("TUI engine only: terminal font size in pixels (default: 14). Larger = more readable screenshots, smaller = more content visible.")
+  }, async ({ engine, use_case, project_id, agent_id, start_url, headless, viewport_width, viewport_height, stealth, auto_gallery, storage_state, force_new, tags, cdp_url, tui_theme, tui_font_size }) => {
     try {
       if (agent_id && !force_new) {
         const existing = getActiveSessionForAgent2(agent_id);
@@ -43848,7 +43947,9 @@ function register(server) {
         stealth,
         autoGallery: auto_gallery,
         storageState: storage_state,
-        cdpUrl: cdp_url
+        cdpUrl: cdp_url,
+        tuiTheme: tui_theme,
+        tuiFontSize: tui_font_size
       });
       if (tags?.length) {
         const { addSessionTag: addSessionTag2 } = await Promise.resolve().then(() => (init_sessions(), exports_sessions));
@@ -46027,6 +46128,18 @@ function register7(server) {
           { tool: "browser_tab_switch", description: "Switch to a tab by index" },
           { tool: "browser_tab_close", description: "Close a tab by index" }
         ],
+        TUI: [
+          { tool: "browser_tui_send_keys", description: "Send keystrokes (ctrl+c, arrow_up, tab, enter, etc.)" },
+          { tool: "browser_tui_send_text", description: "Type text + optional Enter (most common TUI interaction)" },
+          { tool: "browser_tui_resize", description: "Resize terminal cols/rows mid-session" },
+          { tool: "browser_tui_get_text", description: "Get terminal text buffer (full or row range)" },
+          { tool: "browser_tui_wait_for_text", description: "Wait for text to appear in terminal output" },
+          { tool: "browser_tui_get_cursor", description: "Get cursor position (row, col)" },
+          { tool: "browser_tui_assert", description: "Assert terminal conditions (text contains, row N contains, cursor at)" },
+          { tool: "browser_tui_snapshot", description: "Structured terminal snapshot (rows array, cursor, dimensions)" },
+          { tool: "browser_tui_record_start", description: "Start recording terminal as asciicast" },
+          { tool: "browser_tui_record_stop", description: "Stop recording, return asciicast v2 JSON" }
+        ],
         Meta: [
           { tool: "browser_check", description: "RECOMMENDED: One-call page summary with diagnostics" },
           { tool: "browser_version", description: "Show running binary version and tool count" },
@@ -46431,6 +46544,408 @@ function register8(server) {
   register7(server);
 }
 
+// src/mcp/tui.ts
+var KEY_MAP = {
+  "ctrl+c": "\x03",
+  "ctrl+d": "\x04",
+  "ctrl+z": "\x1A",
+  "ctrl+l": "\f",
+  "ctrl+a": "\x01",
+  "ctrl+e": "\x05",
+  "ctrl+k": "\v",
+  "ctrl+u": "\x15",
+  "ctrl+w": "\x17",
+  "ctrl+r": "\x12",
+  "ctrl+p": "\x10",
+  "ctrl+n": "\x0E",
+  enter: "Enter",
+  tab: "Tab",
+  escape: "Escape",
+  esc: "Escape",
+  backspace: "Backspace",
+  delete: "Delete",
+  space: " ",
+  up: "ArrowUp",
+  down: "ArrowDown",
+  left: "ArrowLeft",
+  right: "ArrowRight",
+  arrow_up: "ArrowUp",
+  arrow_down: "ArrowDown",
+  arrow_left: "ArrowLeft",
+  arrow_right: "ArrowRight",
+  home: "Home",
+  end: "End",
+  page_up: "PageUp",
+  page_down: "PageDown",
+  f1: "F1",
+  f2: "F2",
+  f3: "F3",
+  f4: "F4",
+  f5: "F5",
+  f6: "F6",
+  f7: "F7",
+  f8: "F8",
+  f9: "F9",
+  f10: "F10",
+  f11: "F11",
+  f12: "F12"
+};
+function assertTuiSession(sessionId) {
+  const { getSessionEngine: getSessionEngine2 } = (init_session(), __toCommonJS(exports_session));
+  const engine = getSessionEngine2(sessionId);
+  if (engine !== "tui") {
+    throw new Error(`browser_tui_* tools require a TUI session (engine="tui"), but this session uses engine="${engine}". Create a TUI session with: browser_session_create(engine="tui", start_url="your-command")`);
+  }
+}
+async function getTermText(page, startRow, endRow) {
+  const result = await page.evaluate((args) => {
+    const [sr, er] = args;
+    const term = window.term ?? window.terminal;
+    if (!term?.buffer?.active)
+      return { text: "", rows: [], row_count: 0 };
+    const buf = term.buffer.active;
+    const allRows = [];
+    for (let i = 0;i < buf.length; i++) {
+      const line = buf.getLine(i);
+      if (line)
+        allRows.push(line.translateToString(true));
+    }
+    const start = sr ?? 0;
+    const end = er ?? allRows.length;
+    const filtered = allRows.slice(start, end);
+    return { text: filtered.join(`
+`).trimEnd(), rows: filtered, row_count: allRows.length };
+  }, [startRow, endRow]);
+  return result;
+}
+var activeRecordings2 = new Map;
+function register9(server) {
+  server.tool("browser_tui_send_keys", `Send keystrokes to a TUI terminal session. Use friendly key names.
+
+SUPPORTED KEYS:
+- Control: ctrl+c, ctrl+d, ctrl+z, ctrl+l, ctrl+a, ctrl+e, ctrl+k, ctrl+u, ctrl+w, ctrl+r
+- Navigation: enter, tab, escape, backspace, delete, space
+- Arrows: up, down, left, right (or arrow_up, arrow_down, arrow_left, arrow_right)
+- Function: f1-f12
+- Position: home, end, page_up, page_down
+
+Pass multiple keys as a comma-separated string: "tab,tab,enter" or "ctrl+c"
+For typing text, use browser_tui_send_text instead.`, {
+    session_id: exports_external.string().optional(),
+    keys: exports_external.string().describe("Comma-separated key names: 'enter', 'ctrl+c', 'tab,tab,enter', 'arrow_down,arrow_down,enter'")
+  }, async ({ session_id, keys }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      assertTuiSession(sid);
+      const page = getSessionPage(sid);
+      const keyList = keys.split(",").map((k) => k.trim().toLowerCase());
+      const sent = [];
+      for (const key of keyList) {
+        const mapped = KEY_MAP[key];
+        if (mapped) {
+          if (mapped.length === 1 && mapped.charCodeAt(0) < 32) {
+            await page.keyboard.insertText(mapped);
+          } else {
+            await page.keyboard.press(mapped);
+          }
+          sent.push(key);
+        } else {
+          await page.keyboard.press(key);
+          sent.push(key);
+        }
+      }
+      return json({ sent, count: sent.length });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_tui_send_text", `Type text into a TUI terminal and optionally press Enter. This is the most common way to interact with terminal apps.
+
+Examples:
+- Send a command: text="ls -la", press_enter=true
+- Type without executing: text="partial input", press_enter=false
+- Send to a prompt: text="yes", press_enter=true`, {
+    session_id: exports_external.string().optional(),
+    text: exports_external.string().describe("Text to type into the terminal"),
+    press_enter: exports_external.boolean().optional().default(true).describe("Press Enter after typing (default: true)")
+  }, async ({ session_id, text, press_enter }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      assertTuiSession(sid);
+      const page = getSessionPage(sid);
+      const textarea = await page.$(".xterm-helper-textarea");
+      if (textarea) {
+        await textarea.type(text);
+      } else {
+        await page.keyboard.type(text);
+      }
+      if (press_enter) {
+        await page.keyboard.press("Enter");
+      }
+      return json({ typed: text, pressed_enter: press_enter });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_tui_resize", "Resize the terminal to a specific number of columns and rows. Useful for testing responsive TUI layouts at different terminal sizes.", {
+    session_id: exports_external.string().optional(),
+    cols: exports_external.number().describe("Number of columns (e.g. 80, 120, 200)"),
+    rows: exports_external.number().describe("Number of rows (e.g. 24, 40, 50)")
+  }, async ({ session_id, cols, rows }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      assertTuiSession(sid);
+      const page = getSessionPage(sid);
+      const result = await page.evaluate((args) => {
+        const [c, r] = args;
+        const term = window.term ?? window.terminal;
+        if (!term)
+          return { resized: false, error: "No terminal instance found" };
+        term.resize(c, r);
+        return { resized: true, cols: c, rows: r };
+      }, [cols, rows]);
+      return json(result);
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_tui_get_text", `Get the text content from the terminal buffer. Returns all visible text, or a specific row range.
+
+Use this to read what the terminal is currently displaying. For waiting until specific text appears, use browser_tui_wait_for_text instead.`, {
+    session_id: exports_external.string().optional(),
+    start_row: exports_external.number().optional().describe("First row to read (0-indexed, default: 0)"),
+    end_row: exports_external.number().optional().describe("Last row (exclusive). Omit for all rows.")
+  }, async ({ session_id, start_row, end_row }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      assertTuiSession(sid);
+      const page = getSessionPage(sid);
+      const result = await getTermText(page, start_row, end_row);
+      return json(result);
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_tui_wait_for_text", `Wait for specific text to appear in the terminal output. Polls the terminal buffer until the text is found or timeout is reached.
+
+Use this after sending a command to wait for its output, or to wait for a TUI app to finish loading.`, {
+    session_id: exports_external.string().optional(),
+    text: exports_external.string().describe("Text to wait for (substring match)"),
+    timeout_ms: exports_external.number().optional().default(30000).describe("Timeout in milliseconds (default: 30000)")
+  }, async ({ session_id, text, timeout_ms }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      assertTuiSession(sid);
+      const page = getSessionPage(sid);
+      const start = Date.now();
+      while (Date.now() - start < timeout_ms) {
+        const result = await getTermText(page);
+        if (result.text.includes(text)) {
+          return json({ found: true, elapsed_ms: Date.now() - start, terminal_text: result.text });
+        }
+        await new Promise((r) => setTimeout(r, 250));
+      }
+      const finalText = await getTermText(page);
+      return json({ found: false, elapsed_ms: timeout_ms, terminal_text: finalText.text });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_tui_get_cursor", "Get the current cursor position (row and column) in the terminal.", {
+    session_id: exports_external.string().optional()
+  }, async ({ session_id }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      assertTuiSession(sid);
+      const page = getSessionPage(sid);
+      const cursor = await page.evaluate(() => {
+        const term = window.term ?? window.terminal;
+        if (!term?.buffer?.active)
+          return null;
+        return { row: term.buffer.active.cursorY, col: term.buffer.active.cursorX };
+      });
+      if (!cursor)
+        return err(new Error("Could not read cursor position \u2014 no terminal instance"));
+      return json(cursor);
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_tui_assert", `Assert conditions on the terminal state. Chain multiple conditions with AND.
+
+CONDITION SYNTAX:
+- "text contains X"        \u2014 terminal buffer contains substring X
+- "row N contains X"       \u2014 row N (0-indexed) contains substring X
+- "cursor at R,C"          \u2014 cursor is at row R, column C
+- "row_count > N"          \u2014 total rows greater than N
+- "row_count == N"         \u2014 total rows equals N
+
+Example: "text contains hello AND row 0 contains $ AND cursor at 1,0"`, {
+    session_id: exports_external.string().optional(),
+    condition: exports_external.string().describe("Assertion condition(s), joined with AND")
+  }, async ({ session_id, condition }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      assertTuiSession(sid);
+      const page = getSessionPage(sid);
+      const termData = await getTermText(page);
+      const cursor = await page.evaluate(() => {
+        const term = window.term ?? window.terminal;
+        if (!term?.buffer?.active)
+          return { row: -1, col: -1 };
+        return { row: term.buffer.active.cursorY, col: term.buffer.active.cursorX };
+      });
+      const checks = [];
+      let allPassed = true;
+      for (const part of condition.split(/\s+AND\s+/i)) {
+        const trimmed = part.trim();
+        let result = false;
+        if (/^text\s+contains\s+/i.test(trimmed)) {
+          const needle = trimmed.replace(/^text\s+contains\s+/i, "").replace(/^["']|["']$/g, "");
+          result = termData.text.includes(needle);
+        } else if (/^row\s+(\d+)\s+contains\s+/i.test(trimmed)) {
+          const match = trimmed.match(/^row\s+(\d+)\s+contains\s+(.+)/i);
+          if (match) {
+            const rowIdx = parseInt(match[1]);
+            const needle = match[2].replace(/^["']|["']$/g, "");
+            result = (termData.rows[rowIdx] ?? "").includes(needle);
+          }
+        } else if (/^cursor\s+at\s+(\d+)\s*,\s*(\d+)/i.test(trimmed)) {
+          const match = trimmed.match(/^cursor\s+at\s+(\d+)\s*,\s*(\d+)/i);
+          if (match) {
+            result = cursor.row === parseInt(match[1]) && cursor.col === parseInt(match[2]);
+          }
+        } else if (/^row_count\s*(>|>=|<|<=|==|!=)\s*(\d+)/i.test(trimmed)) {
+          const match = trimmed.match(/^row_count\s*(>|>=|<|<=|==|!=)\s*(\d+)/i);
+          if (match) {
+            const op = match[1];
+            const n = parseInt(match[2]);
+            const count = termData.row_count;
+            result = op === ">" ? count > n : op === ">=" ? count >= n : op === "<" ? count < n : op === "<=" ? count <= n : op === "==" ? count === n : count !== n;
+          }
+        }
+        checks.push({ assertion: trimmed, result });
+        if (!result)
+          allPassed = false;
+      }
+      return json({ passed: allPassed, checks, cursor, row_count: termData.row_count });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_tui_snapshot", "Capture a structured snapshot of the terminal buffer: all rows as an array, cursor position, dimensions, and theme. Useful for comparing terminal state before and after actions.", {
+    session_id: exports_external.string().optional()
+  }, async ({ session_id }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      assertTuiSession(sid);
+      const page = getSessionPage(sid);
+      const snapshot = await page.evaluate(() => {
+        const term = window.term ?? window.terminal;
+        if (!term?.buffer?.active)
+          return null;
+        const buf = term.buffer.active;
+        const rows = [];
+        for (let i = 0;i < buf.length; i++) {
+          const line = buf.getLine(i);
+          if (line)
+            rows.push(line.translateToString(true));
+        }
+        return {
+          rows,
+          cols: term.cols,
+          total_rows: term.rows,
+          buffer_length: buf.length,
+          cursor_row: buf.cursorY,
+          cursor_col: buf.cursorX,
+          font_size: term.options?.fontSize,
+          theme: term.options?.theme?.background === "#ffffff" ? "light" : "dark"
+        };
+      });
+      if (!snapshot)
+        return err(new Error("Could not capture snapshot \u2014 no terminal instance"));
+      return json(snapshot);
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_tui_record_start", "Start recording the terminal session as an asciicast v2 file (asciinema-compatible). Polls the terminal buffer at an interval and captures changes.", {
+    session_id: exports_external.string().optional(),
+    interval_ms: exports_external.number().optional().default(500).describe("Polling interval in ms (default: 500)")
+  }, async ({ session_id, interval_ms }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      assertTuiSession(sid);
+      const page = getSessionPage(sid);
+      if (activeRecordings2.has(sid)) {
+        return err(new Error("Recording already active for this session. Stop it first with browser_tui_record_stop."));
+      }
+      const dims = await page.evaluate(() => {
+        const term = window.term ?? window.terminal;
+        return term ? { cols: term.cols, rows: term.rows } : { cols: 80, rows: 24 };
+      });
+      const initialText = (await getTermText(page)).text;
+      const recording = {
+        sessionId: sid,
+        startTime: Date.now(),
+        cols: dims.cols,
+        rows: dims.rows,
+        events: [],
+        lastText: initialText,
+        intervalId: setInterval(async () => {
+          try {
+            const current = await getTermText(page);
+            if (current.text !== recording.lastText) {
+              const elapsed = (Date.now() - recording.startTime) / 1000;
+              recording.events.push([elapsed, "o", current.text.slice(recording.lastText.length) || current.text]);
+              recording.lastText = current.text;
+            }
+          } catch {}
+        }, interval_ms)
+      };
+      activeRecordings2.set(sid, recording);
+      return json({ recording: true, session_id: sid, interval_ms, cols: dims.cols, rows: dims.rows });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_tui_record_stop", "Stop recording and return the asciicast v2 JSON. Compatible with asciinema player.", {
+    session_id: exports_external.string().optional()
+  }, async ({ session_id }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      const recording = activeRecordings2.get(sid);
+      if (!recording)
+        return err(new Error("No active recording for this session"));
+      clearInterval(recording.intervalId);
+      activeRecordings2.delete(sid);
+      const duration = (Date.now() - recording.startTime) / 1000;
+      const header = {
+        version: 2,
+        width: recording.cols,
+        height: recording.rows,
+        timestamp: Math.floor(recording.startTime / 1000),
+        duration,
+        env: { TERM: "xterm-256color", SHELL: "/bin/bash" }
+      };
+      const lines = [JSON.stringify(header)];
+      for (const [time, type2, data] of recording.events) {
+        lines.push(JSON.stringify([time, type2, data]));
+      }
+      const asciicast = lines.join(`
+`);
+      return json({
+        format: "asciicast_v2",
+        duration_seconds: Math.round(duration * 10) / 10,
+        event_count: recording.events.length,
+        asciicast
+      });
+    } catch (e) {
+      return err(e);
+    }
+  });
+}
+
 // src/mcp/index.ts
 init_schema();
 var _pkg = JSON.parse(readFileSync11(join20(import.meta.dir, "../../package.json"), "utf8"));
@@ -46443,6 +46958,7 @@ register2(server);
 register3(server);
 register4(server);
 register8(server);
+register9(server);
 server.tool("send_feedback", "Send feedback about this service", { message: exports_external.string(), email: exports_external.string().optional(), category: exports_external.enum(["bug", "feature", "general"]).optional() }, async (params) => {
   try {
     const db2 = getDatabase();

package/dist/mcp/meta.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"meta.d.ts","sourceRoot":"","sources":["../../src/mcp/meta.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA8CzE,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,QAq7BzC"}
+{"version":3,"file":"meta.d.ts","sourceRoot":"","sources":["../../src/mcp/meta.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA8CzE,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,QAi8BzC"}

package/dist/mcp/sessions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../src/mcp/sessions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAgCzE,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,QAoXzC"}
+{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../src/mcp/sessions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAgCzE,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,QA2YzC"}

package/dist/mcp/tui.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function register(server: McpServer): void;
+//# sourceMappingURL=tui.d.ts.map

package/dist/mcp/tui.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tui.d.ts","sourceRoot":"","sources":["../../src/mcp/tui.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA4FzE,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,QA2ZzC"}