@sanohiro/casty 0.5.0

package/bin/casty.js

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+// casty - TTY web browser using raw CDP and Kitty graphics protocol
+
+import { startBrowser, setupPage, startScreencast, stopScreencast } from '../lib/browser.js';
+import { sendFrame, resetFrameCache, clearScreen, hideCursor, showCursor, cleanup as cleanupTmp, transport } from '../lib/kitty.js';
+import { enableMouse, disableMouse, startInputHandling } from '../lib/input.js';
+import { loadKeyBindings } from '../lib/keys.js';
+import { loadConfig } from '../lib/config.js';
+
+const config = loadConfig();
+const bindings = loadKeyBindings();
+const url = process.argv[2] || config.homeUrl;
+
+const TERM_QUERY_TIMEOUT = 1000;  // CSI 14t response timeout (ms)
+
+// Delayed capture timings after page navigation (ms)
+const DELAYED_CAPTURE_MS = [0, 300, 1000];
+
+// Reference cell size (96 DPI, standard terminal font)
+// Larger cells → zoom in, smaller cells → zoom out
+const REF_CELL_WIDTH = 8;
+
+// Auto-calculate zoom from cell size
+function calcZoom(cellWidth) {
+  return cellWidth / REF_CELL_WIDTH;
+}
+
+// Query terminal pixel size via CSI 14t
+// keepAlive: true when called during operation (SIGWINCH) — don't touch stdin state
+function queryTermPixelSize({ keepAlive = false } = {}) {
+  if (!process.stdin.isTTY) return Promise.resolve(null);
+
+  const { promise, resolve } = Promise.withResolvers();
+  const wasRaw = process.stdin.isRaw;
+  const timeout = setTimeout(() => {
+    process.stdin.removeListener('data', onData);
+    if (!keepAlive) {
+      process.stdin.setRawMode(wasRaw);
+      process.stdin.pause();
+    }
+    resolve(null);
+  }, TERM_QUERY_TIMEOUT);
+
+  if (!keepAlive) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+  }
+
+  let buf = '';
+  const onData = (data) => {
+    buf += data.toString();
+    const match = buf.match(/\x1b\[4;(\d+);(\d+)t/);
+    if (match) {
+      clearTimeout(timeout);
+      process.stdin.removeListener('data', onData);
+      if (!keepAlive) process.stdin.setRawMode(wasRaw);
+      resolve({ height: parseInt(match[1]), width: parseInt(match[2]) });
+    }
+  };
+  process.stdin.on('data', onData);
+
+  process.stdout.write('\x1b[14t');
+  return promise;
+}
+
+// Get terminal info
+// keepAlive: true during operation (SIGWINCH) to avoid killing stdin
+async function getTermInfo({ keepAlive = false } = {}) {
+  const cols = process.stdout.columns || 80;
+  const rows = process.stdout.rows || 24;
+
+  const pixelSize = await queryTermPixelSize({ keepAlive });
+  if (pixelSize) {
+    const cellWidth = pixelSize.width / cols;
+    const cellHeight = pixelSize.height / rows;
+    const zoom = calcZoom(cellWidth);
+    return { cols, rows, width: pixelSize.width, height: pixelSize.height, cellWidth, cellHeight, zoom };
+  }
+
+  const cellWidth = parseInt(process.env.CASTY_CELL_WIDTH) || 10;
+  const cellHeight = parseInt(process.env.CASTY_CELL_HEIGHT) || 20;
+  const zoom = calcZoom(cellWidth);
+  return {
+    cols, rows,
+    width: cols * cellWidth,
+    height: rows * cellHeight,
+    cellWidth, cellHeight, zoom,
+  };
+}
+
+async function main() {
+  // Phase 1: Launch Chrome and get terminal info in parallel
+  // getTermInfo() must complete fully (prevent CSI 14t response leak)
+  const browserP = startBrowser();
+  const term = await getTermInfo();
+  const browser = await browserP;
+
+  // Reserve line 1 for URL bar, use the rest for browser display
+  const barHeight = Math.round(term.cellHeight);
+  const viewHeight = term.height - barHeight;
+
+  // Phase 2: CDP connection + page setup
+  const { client, cssWidth, cssHeight } = await setupPage(browser, { ...term, height: viewHeight });
+  const chromeProcess = browser.proc;
+
+  // Log WebSocket errors to stderr (prevent unhandled crash)
+  client.on('error', (err) => { console.error('casty: CDP error:', err.message); });
+
+  // Navigate immediately (before screencast) to avoid showing previous session's page
+  client.send('Page.navigate', { url }).catch(e => console.error('casty: navigate error:', e.message));
+
+  let renderPaused = false;
+  const pauseRender = (p = true) => { renderPaused = p; };
+
+  hideCursor();
+  clearScreen();
+  enableMouse();
+
+  // Mouse coordinates in device pixels
+  // Chrome headless-shell ignores deviceScaleFactor for Input.dispatchMouseEvent
+  const cssCellW = term.cellWidth;
+  const cssCellH = term.cellHeight;
+  // format: auto → PNG for inline, JPEG (adaptive) for file transfer
+  // jpeg mode: fast JPEG during activity, PNG refinement when static
+  const fmt = config.format || 'auto';
+  const screenshotFormat = fmt === 'auto'
+    ? (transport === 'file' ? 'jpeg' : 'png')
+    : fmt;
+
+  console.error(`casty: ${term.width}x${term.height} cell=${term.cellWidth.toFixed(0)}x${term.cellHeight.toFixed(0)} zoom=${term.zoom.toFixed(2)} transport=${transport} format=${screenshotFormat}${screenshotFormat === 'jpeg' ? ' (adaptive)' : ''}`);
+
+  // Frame callback for screencast / captureScreenshot
+  // sendFrame includes cursor positioning (single write)
+  function onFrame(data) {
+    if (renderPaused) return;
+    sendFrame(data);
+    urlBar.renderIfDirty();
+  }
+
+  // Phase 3: Start screencast
+  let { forceCapture, cleanup: screencastCleanup } = await startScreencast(client, {
+    width: cssWidth,
+    height: cssHeight,
+    format: screenshotFormat,
+    onFrame,
+  });
+
+  const urlBar = startInputHandling(client, cssCellW, cssCellH, bindings, pauseRender, forceCapture);
+  urlBar.render();
+
+  // Force capture on page load events (debounced — multiple events fire close together)
+  let delayedTimers = [];
+  function delayedCapture() {
+    for (const t of delayedTimers) clearTimeout(t);
+    delayedTimers = [];
+    for (const ms of DELAYED_CAPTURE_MS) {
+      if (ms === 0) forceCapture();
+      else delayedTimers.push(setTimeout(() => forceCapture(), ms));
+    }
+  }
+  client.on('Page.domContentEventFired', delayedCapture);
+  client.on('Page.loadEventFired', delayedCapture);
+  client.on('Page.frameNavigated', ({ frame }) => {
+    if (!frame.parentId) delayedCapture(); // Main frame only
+  });
+
+  let shuttingDown = false;
+  async function shutdown() {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    console.error('casty: shutting down...');
+    renderPaused = true;           // Stop rendering first
+    try {
+      await stopScreencast(client, screencastCleanup);  // Stop screencast (disables pending captures)
+      await client.send('Browser.close').catch(() => {});
+    } catch {}
+    client.close();
+    chromeProcess.kill();
+    disableMouse();
+    showCursor();
+    try { process.stdin.setRawMode(false); } catch {}
+    clearScreen();                 // Clear after everything is stopped — no re-render risk
+    cleanupTmp();
+    process.exit(0);
+  }
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  // SIGWINCH: Follow resize + font size changes
+  // Debounced (150ms) + guarded with pending flag to catch late resizes
+  let resizeTimer = null;
+  let resizing = false;
+  let pendingResize = false;
+  process.on('SIGWINCH', () => {
+    clearTimeout(resizeTimer);
+    resizeTimer = setTimeout(handleResize, 150);
+  });
+  async function handleResize() {
+    if (resizing) { pendingResize = true; return; }
+    resizing = true;
+    try {
+      const t = await getTermInfo({ keepAlive: true });
+      const vh = t.height - Math.round(t.cellHeight);
+      const cw = Math.round(t.width / t.zoom);
+      const ch = Math.round(vh / t.zoom);
+      console.error(`casty: resize ${cw}x${ch} (dev:${t.width}x${vh}) zoom:${t.zoom.toFixed(2)}`);
+
+      urlBar.updateCellSize(t.cellWidth, t.cellHeight);
+      clearScreen();
+      resetFrameCache();
+
+      await stopScreencast(client, screencastCleanup);
+      await client.send('Emulation.setDeviceMetricsOverride', {
+        width: cw, height: ch, deviceScaleFactor: t.zoom, mobile: false,
+      });
+
+      ({ forceCapture, cleanup: screencastCleanup } = await startScreencast(client, {
+        width: cw,
+        height: ch,
+        format: screenshotFormat,
+        onFrame,
+      }));
+    } catch (err) {
+      console.error('casty: resize error:', err.message);
+    }
+    resizing = false;
+    if (pendingResize) {
+      pendingResize = false;
+      handleResize();
+    }
+  }
+}
+
+try {
+  await main();
+} catch (err) {
+  // Restore stdin from raw mode (prevent CSI 14t response leak)
+  try { process.stdin.setRawMode(false); process.stdin.pause(); } catch {}
+  console.error('casty: error:', err.message);
+  disableMouse();
+  showCursor();
+  cleanupTmp();
+  process.exit(1);
+}

package/lib/bookmarks.js

@@ -0,0 +1,32 @@
+// Bookmarks
+// Reads ~/.casty/bookmarks.json, searchable via /b in the address bar
+
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { loadJsonFile } from './config.js';
+
+const bookmarkPath = join(homedir(), '.casty', 'bookmarks.json');
+
+// Load bookmarks (normalized to [{ name, url }, ...])
+export function loadBookmarks() {
+  const data = loadJsonFile(bookmarkPath, []);
+  // { "name": "url", ... } object format
+  if (!Array.isArray(data) && typeof data === 'object') {
+    return Object.entries(data).map(([name, url]) => ({ name, url }));
+  }
+  // [{ name, url }, ...] array format
+  if (Array.isArray(data)) {
+    return data.filter(e => e.name && e.url);
+  }
+  return [];
+}
+
+// Search bookmarks by query (case-insensitive partial match on name/URL)
+export function searchBookmarks(query) {
+  const bookmarks = loadBookmarks();
+  if (!query) return bookmarks;
+  const q = query.toLowerCase();
+  return bookmarks.filter(b =>
+    b.name.toLowerCase().includes(q) || b.url.toLowerCase().includes(q)
+  );
+}

package/lib/browser.js

@@ -0,0 +1,305 @@
+// Raw CDP browser control
+// Runtime.enable must never be sent
+
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { CDPClient } from './cdp.js';
+import { launchChrome } from './chrome.js';
+import { loadConfig } from './config.js';
+
+const CHROME_VERSION = '145.0.7632.6';
+const USER_AGENT = `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${CHROME_VERSION} Safari/537.36`;
+const PROFILE_DIR = join(homedir(), '.casty', 'profile');
+
+// WEBGL_debug_renderer_info extension constants
+const GL_UNMASKED_VENDOR   = 0x9245; // UNMASKED_VENDOR_WEBGL
+const GL_UNMASKED_RENDERER = 0x9246; // UNMASKED_RENDERER_WEBGL
+
+// Screencast settings (low-res stream for change detection)
+const SCREENCAST_SCALE     = 4;    // Downscale factor (1/4 resolution)
+const SCREENCAST_NTH_FRAME = 1;    // Every frame (no decimation, faster change detection)
+
+// Capture control
+const CAPTURE_MIN_INTERVAL = 50;   // ms (~20fps)
+const CAPTURE_STUCK_RESET  = 5000; // Reset stuck capturing flag (ms)
+
+// Build stealth script with locale-dependent language settings
+// lang: primary language (e.g. "ja", "en-US")
+function buildStealthScript(lang) {
+  // Build Accept-Language style list: primary, then en-US/en fallbacks
+  const langBase = lang.split('-')[0]; // "ja", "en", "zh", etc.
+  const languages = [lang];
+  if (lang !== 'en-US' && lang !== 'en') {
+    languages.push('en-US', 'en');
+  } else if (lang === 'en-US') {
+    languages.push('en');
+  }
+  const langArray = JSON.stringify(languages);
+
+  return `
+// navigator.plugins (headless exposes empty array)
+Object.defineProperty(navigator, 'plugins', {
+  get: () => {
+    const arr = [
+      { name: 'Chrome PDF Plugin', filename: 'internal-pdf-viewer', description: 'Portable Document Format' },
+      { name: 'Chrome PDF Viewer', filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai', description: '' },
+      { name: 'Native Client', filename: 'internal-nacl-plugin', description: '' },
+    ];
+    arr.refresh = () => {};
+    return arr;
+  },
+});
+
+// navigator.mimeTypes
+Object.defineProperty(navigator, 'mimeTypes', {
+  get: () => {
+    const arr = [
+      { type: 'application/pdf', suffixes: 'pdf', description: 'Portable Document Format' },
+    ];
+    arr.refresh = () => {};
+    return arr;
+  },
+});
+
+// navigator.languages (derived from system locale or config)
+Object.defineProperty(navigator, 'languages', {
+  get: () => ${langArray},
+});
+
+// navigator.language
+Object.defineProperty(navigator, 'language', {
+  get: () => '${lang}',
+});
+
+// window.chrome (undefined in headless)
+if (!window.chrome) {
+  window.chrome = {
+    app: { isInstalled: false, InstallState: { DISABLED: 'disabled', INSTALLED: 'installed', NOT_INSTALLED: 'not_installed' }, RunningState: { CANNOT_RUN: 'cannot_run', READY_TO_RUN: 'ready_to_run', RUNNING: 'running' } },
+    runtime: { OnInstalledReason: {}, OnRestartRequiredReason: {}, PlatformArch: {}, PlatformNaclArch: {}, PlatformOs: {}, RequestUpdateCheckStatus: {}, connect: function(){}, id: undefined, sendMessage: function(){} },
+    csi: function() { return {}; },
+    loadTimes: function() { return {}; },
+  };
+}
+
+// Permissions API (headless behaves differently)
+const origQuery = navigator.permissions.query.bind(navigator.permissions);
+navigator.permissions.query = (params) => {
+  if (params.name === 'notifications') {
+    return Promise.resolve({ state: Notification.permission });
+  }
+  return origQuery(params);
+};
+
+// WebGL vendor/renderer (hide SwiftShader)
+// 0x9245 = UNMASKED_VENDOR_WEBGL, 0x9246 = UNMASKED_RENDERER_WEBGL
+const getParam = WebGLRenderingContext.prototype.getParameter;
+WebGLRenderingContext.prototype.getParameter = function(p) {
+  if (p === 0x9245) return 'Google Inc. (Apple)';
+  if (p === 0x9246) return 'ANGLE (Apple, Apple M1, OpenGL 4.1)';
+  return getParam.call(this, p);
+};
+
+// navigator.connection (can be undefined in headless)
+if (!navigator.connection) {
+  Object.defineProperty(navigator, 'connection', {
+    get: () => ({ effectiveType: '4g', rtt: 50, downlink: 10, saveData: false }),
+  });
+}
+`;
+}
+
+// Build Accept-Language header from primary language
+function buildAcceptLanguage(lang) {
+  if (lang === 'en-US') return 'en-US,en;q=0.9';
+  if (lang === 'en') return 'en';
+  return `${lang},en-US;q=0.9,en;q=0.8`;
+}
+
+
+// HTTP GET → JSON (using global fetch)
+async function fetchJson(url) {
+  const res = await fetch(url);
+  if (!res.ok) return null;
+  try { return await res.json(); }
+  catch { return null; }
+}
+
+// Phase 1: Launch Chrome only (no terminal info needed, for parallel execution)
+export async function startBrowser() {
+  return launchChrome({ userDataDir: PROFILE_DIR });
+}
+
+// Phase 2: CDP connection + page setup (navigation is done by the caller)
+// Tries /json/new first, then /json/list, then Target.createTarget via browser CDP
+export async function setupPage({ port, wsUrl }, { width, height, zoom = 1 } = {}) {
+  const config = loadConfig();
+  const lang = config.language;
+  const baseUrl = `http://127.0.0.1:${port}`;
+
+  // Try /json/new (single HTTP request, fastest)
+  let target = await fetchJson(`${baseUrl}/json/new?about:blank`);
+  if (!target?.webSocketDebuggerUrl) {
+    // Check /json/list for existing pages
+    const targets = await fetchJson(`${baseUrl}/json/list`);
+    target = targets?.find(t => t.type === 'page');
+  }
+  if (!target?.webSocketDebuggerUrl) {
+    // Fallback: create page via browser CDP (headless-shell needs this)
+    const browserClient = new CDPClient();
+    await browserClient.connect(wsUrl);
+    const { targetId } = await browserClient.send('Target.createTarget', { url: 'about:blank' });
+    browserClient.close();
+    // Construct WS URL directly from targetId (avoids extra /json/list HTTP request)
+    target = { webSocketDebuggerUrl: `ws://127.0.0.1:${port}/devtools/page/${targetId}` };
+  }
+
+  const client = new CDPClient();
+  await client.connect(target.webSocketDebuggerUrl);
+
+  const cssWidth = Math.round(width / zoom);
+  const cssHeight = Math.round(height / zoom);
+
+  // Run CDP commands in parallel (all must complete before navigation)
+  await Promise.all([
+    client.send('Page.enable'),
+    client.send('Emulation.setDeviceMetricsOverride', {
+      width: cssWidth, height: cssHeight, deviceScaleFactor: zoom, mobile: false,
+    }),
+    client.send('Network.setUserAgentOverride', {
+      userAgent: USER_AGENT, platform: 'MacIntel',
+      acceptLanguage: buildAcceptLanguage(lang),
+    }),
+    client.send('Page.addScriptToEvaluateOnNewDocument', { source: buildStealthScript(lang) }),
+    client.send('Browser.setDownloadBehavior', {
+      behavior: 'allowAndName', downloadPath: join(homedir(), 'Downloads'),
+      eventsEnabled: true,
+    }),
+  ]);
+
+  return { client, cssWidth, cssHeight };
+}
+
+// Adaptive frame capture with quality refinement:
+//
+// Screencast at 1/4 resolution as change-detection trigger,
+// then Page.captureScreenshot for full DPR-aware hi-res frame.
+// CAPTURE_MIN_INTERVAL throttles to keep CPU usage low.
+//
+// Adaptive format (JPEG → PNG refinement):
+//   During rapid updates: JPEG for speed (3-5x smaller than PNG)
+//   After activity stops: PNG refinement for crisp text (lossless)
+//   Only active when format='jpeg'; PNG mode is already lossless.
+//
+// format: 'jpeg' (file transfer, adaptive) or 'png' (inline, always lossless)
+export async function startScreencast(client, { width, height, onFrame, format = 'png', quality = 85 }) {
+  let capturing = false;
+  let lastCaptureTime = 0;
+  let throttleTimer = null;
+  let refineTimer = null;
+
+  // Fast capture opts (configured format)
+  const fastOpts = { format, optimizeForSpeed: true, captureBeyondViewport: false };
+  if (format === 'jpeg') fastOpts.quality = quality;
+
+  // PNG refinement opts (lossless, for crisp text after activity stops)
+  const REFINE_DELAY = 500; // ms after last frame update
+  const refineOpts = format === 'jpeg'
+    ? { format: 'png', captureBeyondViewport: false }
+    : null;
+
+  // PNG refinement: capture one lossless frame after activity settles
+  async function refineCapture() {
+    if (capturing) return;
+    capturing = true;
+    try {
+      const { data } = await client.send('Page.captureScreenshot', refineOpts);
+      if (data) onFrame(data);
+    } catch {}
+    lastCaptureTime = Date.now();
+    capturing = false;
+  }
+
+  function scheduleRefine() {
+    if (!refineOpts) return;
+    clearTimeout(refineTimer);
+    refineTimer = setTimeout(refineCapture, REFINE_DELAY);
+  }
+
+  async function capture() {
+    if (capturing) return;
+
+    const now = Date.now();
+    const elapsed = now - lastCaptureTime;
+    if (elapsed < CAPTURE_MIN_INTERVAL) {
+      if (!throttleTimer) {
+        throttleTimer = setTimeout(() => {
+          throttleTimer = null;
+          capture();
+        }, CAPTURE_MIN_INTERVAL - elapsed);
+      }
+      return;
+    }
+
+    capturing = true;
+    lastCaptureTime = Date.now();
+    try {
+      const { data } = await client.send('Page.captureScreenshot', fastOpts);
+      if (data) onFrame(data);
+    } catch {}
+    capturing = false;
+    scheduleRefine();
+  }
+
+  function onScreencastFrame({ data, sessionId }) {
+    client.send('Page.screencastFrameAck', { sessionId }).catch(() => {});
+    capture();
+  }
+  client.on('Page.screencastFrame', onScreencastFrame);
+
+  // Low-res change-detection screencast + hi-res captureScreenshot
+  await client.send('Page.startScreencast', {
+    format: 'jpeg',
+    quality: 30,
+    maxWidth: Math.round(width / SCREENCAST_SCALE),
+    maxHeight: Math.round(height / SCREENCAST_SCALE),
+    everyNthFrame: SCREENCAST_NTH_FRAME,
+  });
+
+  // Capture first frame immediately
+  capture();
+
+  // Force capture (bypasses throttle, always uses captureScreenshot)
+  async function forceCapture() {
+    if (capturing) return;
+    capturing = true;
+    try {
+      const { data } = await client.send('Page.captureScreenshot', fastOpts);
+      if (data) onFrame(data);
+    } catch {}
+    lastCaptureTime = Date.now();
+    capturing = false;
+    scheduleRefine();
+  }
+
+  // Prevent stuck capturing flag
+  const stuckInterval = setInterval(() => { capturing = false; }, CAPTURE_STUCK_RESET);
+
+  function cleanup() {
+    clearInterval(stuckInterval);
+    clearTimeout(throttleTimer);
+    clearTimeout(refineTimer);
+    client.removeListener('Page.screencastFrame', onScreencastFrame);
+  }
+
+  return { forceCapture, cleanup };
+}
+
+// Stop frame capture (cleanupFn from startScreencast return value)
+export async function stopScreencast(client, cleanupFn) {
+  try {
+    if (cleanupFn) cleanupFn();
+    await client.send('Page.stopScreencast');
+  } catch {
+    // Ignore if already closed
+  }
+}

package/lib/cdp.js

@@ -0,0 +1,76 @@
+// CDP WebSocket client
+// Lightweight CDP client that never sends Runtime.enable
+
+import { EventEmitter, once } from 'node:events';
+import WebSocket from 'ws';
+
+const CDP_TIMEOUT = 10000; // ms — reject pending commands after this
+
+export class CDPClient extends EventEmitter {
+  constructor() {
+    super();
+    this._ws = null;
+    this._id = 0;
+    this._pending = new Map();
+  }
+
+  // Connect via WebSocket
+  async connect(wsUrl) {
+    this._ws = new WebSocket(wsUrl, { perMessageDeflate: false });
+    this._ws.on('message', (data) => {
+      let msg;
+      try { msg = JSON.parse(data); }
+      catch { return; } // Ignore non-JSON frames
+      if (msg.id !== undefined) {
+        // Command response
+        const p = this._pending.get(msg.id);
+        if (p) {
+          clearTimeout(p.timer);
+          this._pending.delete(msg.id);
+          if (msg.error) p.reject(new Error(msg.error.message));
+          else p.resolve(msg.result || {});
+        }
+      } else if (msg.method) {
+        // CDP event
+        this.emit(msg.method, msg.params || {});
+      }
+    });
+    this._ws.on('close', () => this.emit('close'));
+    this._ws.on('error', (err) => this.emit('error', err));
+    // once() rejects on 'error' if it fires before 'open'
+    await once(this._ws, 'open');
+  }
+
+  // Send CDP command (with timeout to prevent forever-pending)
+  send(method, params = {}) {
+    const id = ++this._id;
+    const { promise, resolve, reject } = Promise.withResolvers();
+    const timer = setTimeout(() => {
+      this._pending.delete(id);
+      reject(new Error(`CDP timeout: ${method}`));
+    }, CDP_TIMEOUT);
+    this._pending.set(id, { resolve, reject, timer });
+    try {
+      this._ws.send(JSON.stringify({ id, method, params }));
+    } catch (err) {
+      // ws.send() can throw synchronously if socket is closed
+      clearTimeout(timer);
+      this._pending.delete(id);
+      reject(err);
+    }
+    return promise;
+  }
+
+  // Disconnect
+  close() {
+    if (this._ws) {
+      this._ws.close();
+      this._ws = null;
+    }
+    for (const p of this._pending.values()) {
+      clearTimeout(p.timer);
+      p.reject(new Error('Connection closed'));
+    }
+    this._pending.clear();
+  }
+}