@sanohiro/casty 0.5.0

package/lib/chrome.js

@@ -0,0 +1,155 @@
+// Chrome process launch and binary detection
+
+import { spawn, execFileSync } from 'node:child_process';
+import { readdirSync, existsSync, rmSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const BROWSERS_DIR = join(homedir(), '.casty', 'browsers');
+const IS_ARM_LINUX = process.platform === 'linux' && process.arch === 'arm64';
+
+// Recursively search for headless shell binary in a Playwright-style directory
+// Binary name varies by version: chrome-headless-shell or headless_shell
+const HEADLESS_BINS = ['chrome-headless-shell', 'headless_shell'];
+function findBinInDir(base) {
+  try {
+    for (const name of HEADLESS_BINS) {
+      // Check directly under base
+      const direct = join(base, name);
+      if (existsSync(direct) && statSync(direct).isFile()) return direct;
+    }
+    // Search subdirectories
+    for (const sub of readdirSync(base)) {
+      for (const name of HEADLESS_BINS) {
+        const bin = join(base, sub, name);
+        if (existsSync(bin) && statSync(bin).isFile()) return bin;
+      }
+    }
+  } catch {}
+  return null;
+}
+
+// Detect Chrome binary
+// Returns: { bin, headless } — headless=true means system Chrome (needs --headless=new)
+export function findChrome() {
+  if (existsSync(BROWSERS_DIR)) {
+    const entries = readdirSync(BROWSERS_DIR).sort().reverse();
+
+    // 1. Chrome for Testing headless-shell (x86_64 only, skip ARM64 Linux)
+    if (!IS_ARM_LINUX) {
+      for (const dir of entries) {
+        if (!dir.startsWith('chrome-headless-shell-')) continue;
+        const bin = join(BROWSERS_DIR, dir, 'chrome-headless-shell');
+        if (existsSync(bin)) return { bin, headless: false };
+      }
+    }
+
+    // 2. Playwright format (all platforms)
+    for (const dir of entries) {
+      if (!dir.startsWith('chromium_headless_shell-')) continue;
+      const bin = findBinInDir(join(BROWSERS_DIR, dir));
+      if (bin) return { bin, headless: false };
+    }
+  }
+
+  // 3. System Chrome/Chromium (fallback)
+  const candidates = [
+    'chromium-browser', 'chromium', 'google-chrome-stable', 'google-chrome',
+  ];
+  for (const name of candidates) {
+    try {
+      const path = execFileSync('which', [name], { encoding: 'utf8' }).trim();
+      if (path) return { bin: path, headless: true };
+    } catch {}
+  }
+
+  return null;
+}
+
+// Prevent profile bloat (delete caches/DBs except cookies/localStorage)
+// Chrome processes these on startup, so accumulation slows launch dramatically
+function cleanProfile(userDataDir) {
+  const def = join(userDataDir, 'Default');
+  if (!existsSync(def)) return;
+  const KEEP = new Set([
+    'Cookies', 'Cookies-journal',
+    'Local Storage',
+    'Preferences', 'Secure Preferences',
+  ]);
+  try {
+    for (const entry of readdirSync(def)) {
+      if (KEEP.has(entry)) continue;
+      rmSync(join(def, entry), { recursive: true, force: true });
+    }
+  } catch {}
+}
+
+// Launch Chrome, return DevTools WebSocket URL
+export function launchChrome({ userDataDir, windowSize, args = [] } = {}) {
+  cleanProfile(userDataDir);
+  const chrome = findChrome();
+  if (!chrome) throw new Error('Chrome not found. Install chromium-browser or run ./bin/casty to install.');
+
+  const chromeArgs = [
+    '--remote-debugging-port=0',
+    '--no-first-run',
+    '--no-default-browser-check',
+    '--disable-blink-features=AutomationControlled',
+    '--auto-grant-permissions',
+    '--disable-component-update',
+    '--disable-default-apps',
+    '--disable-sync',
+    // Media playback (autoplay without user gesture in headless)
+    '--autoplay-policy=no-user-gesture-required',
+    '--disable-backgrounding-occluded-windows',
+    '--disable-features=PreloadMediaEngagementData,MediaEngagementBypassAutoplayPolicies',
+    // Reduce startup overhead
+    '--disable-breakpad',
+    '--disable-extensions',
+    '--disable-background-networking',
+    '--disable-background-timer-throttling',
+    '--disable-renderer-backgrounding',
+    '--metrics-recording-only',
+    '--password-store=basic',
+    '--use-mock-keychain',
+    `--user-data-dir=${userDataDir}`,
+  ];
+  // System Chrome needs --headless=new (headless-shell doesn't)
+  if (chrome.headless) {
+    chromeArgs.push('--headless=new');
+  }
+  // Linux often lacks sandbox support (VMs, containers, etc.)
+  if (process.platform === 'linux') {
+    chromeArgs.push('--no-sandbox', '--disable-dev-shm-usage');
+  }
+  if (windowSize) {
+    chromeArgs.push(`--window-size=${windowSize.width},${windowSize.height}`);
+  }
+  chromeArgs.push(...args);
+
+  const proc = spawn(chrome.bin, chromeArgs, {
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+
+  // Extract DevTools URL from stderr
+  const { promise, resolve, reject } = Promise.withResolvers();
+  let stderr = '';
+  const timeout = setTimeout(() => reject(new Error('Chrome startup timeout')), 15000);
+
+  proc.stderr.on('data', (chunk) => {
+    stderr += chunk.toString();
+    const m = stderr.match(/DevTools listening on (ws:\/\/[^\s]+)/);
+    if (m) {
+      clearTimeout(timeout);
+      const wsUrl = m[1];
+      const portMatch = wsUrl.match(/:(\d+)\//);
+      const port = portMatch ? parseInt(portMatch[1]) : 0;
+      resolve({ proc, wsUrl, port });
+    }
+  });
+
+  proc.on('error', (err) => { clearTimeout(timeout); reject(err); });
+  proc.on('exit', (code) => { clearTimeout(timeout); reject(new Error(`Chrome exited with code ${code}\n${stderr}`)); });
+
+  return promise;
+}

package/lib/config.js

@@ -0,0 +1,43 @@
+// Configuration
+// Customizable via ~/.casty/config.json (falls back to defaults)
+
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+// Safely load and parse a JSON file (returns fallback on parse error or missing file)
+export function loadJsonFile(filePath, fallback) {
+  try { return JSON.parse(readFileSync(filePath, 'utf8')); }
+  catch { return fallback; }
+}
+
+const configPath = join(homedir(), '.casty', 'config.json');
+
+// Detect system locale (e.g. "en-US", "ja", "zh-CN")
+function detectLocale() {
+  // Intl API gives the most reliable result
+  try {
+    const locale = Intl.DateTimeFormat().resolvedOptions().locale;
+    if (locale) return locale;
+  } catch {}
+  // Fallback to environment variables
+  const env = process.env.LANG || process.env.LC_ALL || process.env.LC_MESSAGES || '';
+  const m = env.match(/^([a-z]{2}(?:[_-][A-Z]{2})?)/);
+  return m ? m[1].replace('_', '-') : 'en-US';
+}
+
+const DEFAULTS = {
+  homeUrl: 'https://github.com/sanohiro/casty',
+  searchUrl: 'https://www.google.com/search?q=',
+  transport: 'auto', // 'auto' | 'file' | 'inline'
+  format: 'auto',    // 'auto' | 'png' | 'jpeg'
+  language: detectLocale(), // System locale (override: "en-US", "ja", etc.)
+};
+
+let _cache = null;
+
+export function loadConfig() {
+  if (_cache) return _cache;
+  _cache = { ...DEFAULTS, ...loadJsonFile(configPath, {}) };
+  return _cache;
+}

package/lib/hints.js

@@ -0,0 +1,255 @@
+// Vimium-style hint mode
+// Alt+F shows labels on clickable/focusable elements, select by typing the label
+
+const HINT_CHARS = ['a', 's', 'd', 'f', 'j', 'k', 'l'];
+const MAX_HINTS = HINT_CHARS.length * HINT_CHARS.length; // 49
+
+// Collect elements + generate labels + inject overlay in a single evaluate call
+function makeCollectAndOverlayScript(hintChars, maxHints) {
+  return `(() => {
+  try {
+    const old = document.getElementById('__casty_hints');
+    if (old) old.remove();
+
+    const CLICKABLE = 'a, button, [role="button"], [onclick], summary, [role="link"], [role="tab"], [tabindex]';
+    const FOCUSABLE = 'input, textarea, select, [contenteditable]';
+    const all = document.querySelectorAll(CLICKABLE + ', ' + FOCUSABLE);
+
+    const elems = [];
+    for (const el of all) {
+      if (elems.length >= ${maxHints}) break;
+      if (el.offsetParent === null && getComputedStyle(el).position !== 'fixed') continue;
+      const rect = el.getBoundingClientRect();
+      if (rect.width === 0 || rect.height === 0) continue;
+      if (rect.bottom < 0 || rect.top > window.innerHeight) continue;
+      if (rect.right < 0 || rect.left > window.innerWidth) continue;
+
+      const isFocusable = el.matches('input, textarea, select, [contenteditable]');
+      elems.push({
+        x: Math.round(rect.left),
+        y: Math.round(rect.top),
+        cx: Math.round(rect.left + rect.width / 2),
+        cy: Math.round(rect.top + rect.height / 2),
+        type: isFocusable ? 'focus' : 'click',
+      });
+    }
+
+    if (elems.length === 0) return JSON.stringify([]);
+
+    // Generate labels
+    const chars = ${JSON.stringify(hintChars)};
+    const labels = [];
+    if (elems.length <= chars.length) {
+      for (let i = 0; i < elems.length; i++) labels.push(chars[i]);
+    } else {
+      for (const c1 of chars) {
+        for (const c2 of chars) {
+          labels.push(c1 + c2);
+          if (labels.length >= elems.length) break;
+        }
+        if (labels.length >= elems.length) break;
+      }
+    }
+
+    // Inject overlay
+    const container = document.createElement('div');
+    container.id = '__casty_hints';
+    container.style.cssText = 'position:fixed;top:0;left:0;width:0;height:0;z-index:2147483647;pointer-events:none;';
+    for (let i = 0; i < elems.length; i++) {
+      const h = elems[i];
+      h.label = labels[i];
+      const span = document.createElement('span');
+      span.textContent = labels[i].toUpperCase();
+      span.dataset.label = labels[i];
+      span.style.cssText = 'position:fixed;background:#FFEE00;color:#000;font:bold 12px monospace;border:1px solid #C38A00;border-radius:3px;padding:0 2px;z-index:2147483647;pointer-events:none;line-height:1.4;'
+        + 'left:' + h.x + 'px;top:' + h.y + 'px;';
+      container.appendChild(span);
+    }
+    document.documentElement.appendChild(container);
+
+    return JSON.stringify(elems);
+  } catch (e) {
+    return JSON.stringify([]);
+  }
+})()`;
+}
+
+const COLLECT_OVERLAY_SCRIPT = makeCollectAndOverlayScript(HINT_CHARS, MAX_HINTS);
+
+// Dim non-matching labels
+function makeDimScript(buffer) {
+  return `(() => {
+    const c = document.getElementById('__casty_hints');
+    if (!c) return;
+    for (const span of c.children) {
+      const label = span.dataset.label;
+      span.style.opacity = label.startsWith('${buffer}') ? '1' : '0.2';
+    }
+  })()`;
+}
+
+// Remove overlay script
+const REMOVE_OVERLAY_SCRIPT = `(() => {
+  const el = document.getElementById('__casty_hints');
+  if (el) el.remove();
+})()`;
+
+export class HintMode {
+  constructor(forceCapture) {
+    this.active = false;
+    this.buffer = '';
+    this._resolve = null;
+    this._client = null;
+    this._hints = [];
+    this._rawForceCapture = forceCapture || (() => {});
+  }
+
+  // Ensure frame capture after DOM changes (immediate + delayed retry)
+  _forceCapture() {
+    this._rawForceCapture();
+    setTimeout(() => this._rawForceCapture(), 200);
+  }
+
+  // Start hint mode — waits until user selects or cancels
+  async start(client) {
+    this._client = client;
+    this.buffer = '';
+
+    // Single evaluate: collect elements + generate labels + inject overlay
+    let hints;
+    try {
+      const { result } = await client.send('Runtime.evaluate', {
+        expression: COLLECT_OVERLAY_SCRIPT,
+      });
+      hints = JSON.parse(result.value);
+    } catch (e) {
+      console.error(`casty: hints failed: ${e.message}`);
+      return;
+    }
+
+    if (!hints || hints.length === 0) {
+      console.error('casty: hints: no elements found');
+      return;
+    }
+
+    console.error(`casty: hints: ${hints.length} elements`);
+    this._hints = hints;
+    this.active = true;
+    this._forceCapture();
+
+    const { promise, resolve } = Promise.withResolvers();
+    this._resolve = resolve;
+    return promise;
+  }
+
+  // Handle input (only called while active)
+  async handleInput(str) {
+    if (!this.active) return false;
+
+    // Escape → cancel
+    if (str === '\x1b') {
+      await this._cancel();
+      return true;
+    }
+
+    // Backspace → remove last buffer char
+    if (str === '\x7f' || str === '\x08') {
+      if (this.buffer.length > 0) {
+        this.buffer = this.buffer.slice(0, -1);
+        await this._updateDim();
+      }
+      return true;
+    }
+
+    // Ignore non-hint characters
+    const ch = str.toLowerCase();
+    if (ch.length !== 1 || !HINT_CHARS.includes(ch)) {
+      return true;
+    }
+
+    this.buffer += ch;
+
+    // Exact match check
+    const exact = this._hints.find(h => h.label === this.buffer);
+    if (exact) {
+      await this._selectHint(exact);
+      return true;
+    }
+
+    // Prefix match check
+    const partial = this._hints.some(h => h.label.startsWith(this.buffer));
+    if (!partial) {
+      this.buffer = '';
+      await this._updateDim();
+      return true;
+    }
+
+    // Partial match — dim non-matching labels
+    await this._updateDim();
+    return true;
+  }
+
+  async _updateDim() {
+    try {
+      await this._client.send('Runtime.evaluate', {
+        expression: this.buffer ? makeDimScript(this.buffer) : makeDimScript(''),
+      });
+      this._forceCapture();
+    } catch {}
+  }
+
+  async _selectHint(hint) {
+    await this._removeOverlay();
+
+    if (hint.type === 'focus') {
+      try {
+        await this._client.send('Runtime.evaluate', {
+          expression: `(() => {
+            const all = document.querySelectorAll('input, textarea, select, [contenteditable]');
+            for (const el of all) {
+              const r = el.getBoundingClientRect();
+              if (Math.round(r.left + r.width/2) === ${hint.cx} && Math.round(r.top + r.height/2) === ${hint.cy}) {
+                el.focus();
+                el.click();
+                break;
+              }
+            }
+          })()`,
+        });
+      } catch {}
+    } else {
+      try {
+        await this._client.send('Input.dispatchMouseEvent', {
+          type: 'mousePressed', x: hint.cx, y: hint.cy, button: 'left', clickCount: 1,
+        });
+        await this._client.send('Input.dispatchMouseEvent', {
+          type: 'mouseReleased', x: hint.cx, y: hint.cy, button: 'left',
+        });
+      } catch {}
+    }
+
+    this._done();
+    this._forceCapture();
+  }
+
+  async _cancel() {
+    await this._removeOverlay();
+    this._done();
+    this._forceCapture();
+  }
+
+  _done() {
+    this.active = false;
+    this.buffer = '';
+    this._hints = [];
+    if (this._resolve) { this._resolve(); this._resolve = null; }
+  }
+
+  async _removeOverlay() {
+    try {
+      await this._client.send('Runtime.evaluate', {
+        expression: REMOVE_OVERLAY_SCRIPT,
+      });
+    } catch {}
+  }
+}