/** * Edge Kit Browser v3 — browsing the way a human does it. * * Local branch overlay: EDGE_KIT_NATIVE_FIXES (pending review in 'native-fixes'). * * Design: agents perceive with `see` (visible text + numbered actionable * elements, across shadow DOM and dialogs), act like a person (`click` a * numbered element or the text they can read, `type` into a field by its * human label, `press` keys, `scroll`, wait for content to appear), verify * with `screenshot`, and organize work in tabs. * * Live-attach-first: if a DevTools-enabled Edge is already listening we * attach to it (and "close" only detaches — we never close a borrowed * browser). Otherwise we launch: the user's real Edge profile with * realProfile:true, or the persistent kit profile. Raw CDP, zero deps. */ import os from 'node:os'; import path from 'node:path'; import net from 'node:net'; import { spawn, exec } from 'node:child_process'; import { promises as fs } from 'node:fs'; // schemastery ships inside the app bundle; a profile-linked package cannot // resolve it by bare name, so import it from the running installation (the // very file the Web search plugin loads). If that ever fails to resolve, the // kit still works — only the settings page stays hidden. /* EDGE_KIT_NATIVE_PORTABILITY: resolve schemastery from the running DeepSeek Harness * installation instead of a hardcoded per-user path. Candidate roots cover Electron's * resources directory (with app.asar), a resources folder beside the executable, and the * per-user install location; the CommonJS build is tried before the ES module build. If * none resolves the kit still runs and only the settings page stays hidden. */ let z = null; try { await (async () => { const [{ createRequire }, { pathToFileURL }, pathMod] = await Promise.all([ import('node:module'), import('node:url'), import('node:path'), ]); const requireFromHere = createRequire(import.meta.url); const roots = []; try { if (process.resourcesPath) roots.push(process.resourcesPath); } catch { /* not Electron */ } try { roots.push(pathMod.join(pathMod.dirname(process.execPath), 'resources')); } catch { /* no execPath */ } if (process.env.LOCALAPPDATA) roots.push(pathMod.join(process.env.LOCALAPPDATA, 'Programs', 'DeepSeek Harness', 'resources')); for (const root of roots) { const base = pathMod.join(root, 'app.asar', 'dsh', 'node_modules', '@deepseek-ai', 'schemastery'); try { const cjs = requireFromHere(pathMod.join(base, 'lib', 'index.cjs')); z = (cjs && (cjs.default || cjs)) || null; } catch { /* try the ES module build next */ } if (z) break; try { const esm = await import(pathToFileURL(pathMod.join(base, 'lib', 'index.mjs')).href); z = (esm && (esm.default || esm)) || null; } catch { /* try the next candidate root */ } if (z) break; } })(); } catch { z = null; } export const inject = ['tools', 'web']; /** * Persistent defaults, editable on this plugin's native settings page in * DeepSeek (Plugins > Edge Kit Browser) — the same surface the Web search * plugin uses. Every field is volatile, so saving on the page updates the kit * live without a restart and the running browser session survives. Per-call * tool arguments still override these values. */ export const Config = z && z.object({ realProfile: z.boolean() .description('Use your everyday signed-in Edge profile when launching, so saved logins and cookies are available. Turn off to browse in a fresh, isolated Edge Kit profile.') .default(true).volatile(), port: z.number() .description('DevTools port Edge Kit launches Edge with, and attaches to when a debuggable Edge is already listening.') .step(1).min(1).max(65535).default(9444).volatile(), headless: z.boolean() .description('Start Edge without a visible window. Leave off so browsing behaves like a person looking at a screen.') .default(false).volatile(), profileDir: z.string() .description('Where an isolated Edge Kit profile lives when using your signed-in profile is off. Leave blank for the default location.') .volatile(), executablePath: z.string() .description('Full path to msedge.exe. Leave blank to use Edge in its default install locations.') .volatile(), seeTextCap: z.number() .description('How much visible page text the see action returns before truncating (200-6000 characters).') .step(1).min(200).max(6000).default(2200).volatile(), searchEngine: z.string() .description('Which search engine the kit drives for native web_search: "google" or "bing".') .default('google').volatile(), browser: z.string() .description('Which browser the kit launches by default: "edge", "chrome", or "firefox". The launch action can still pick another per call.') .default('edge').volatile(), proxyChain: z.string() .description('Proxy applied to every launch: "ip:port", or comma-separated hops "ip:port,ip:port" — two or more chain through an in-kit local forwarder. The proxy action can test candidates and swap this live.') .volatile(), fetchTextCap: z.number() .description('Maximum characters of rendered page text returned by native web_fetch (it reads pages through your browser, so JavaScript sites work and bot walls pass).') .step(1).min(1000).max(60000).default(20000).volatile(), }); let cfg = null; // bound by apply(); volatile fields are read through .get() const cfgVal = (field, fallback) => { const f = cfg?.[field]; if (f === undefined || f === null) return fallback; const v = typeof f.get === 'function' ? f.get() : f; return v === undefined || v === '' ? fallback : v; }; const effectivePort = (args) => (Number.isInteger(args?.port) ? args.port : cfgVal('port', 9444)); const settingsSnapshot = () => ({ realProfile: cfgVal('realProfile', true), port: cfgVal('port', 9444), headless: cfgVal('headless', false), profileDir: cfgVal('profileDir', ''), executablePath: cfgVal('executablePath', ''), seeTextCap: cfgVal('seeTextCap', 2200), browser: cfgVal('browser', 'edge'), proxyChain: cfgVal('proxyChain', ''), }); const DEFAULT_PORT = 9444; const KIT_PROFILE = path.join(os.homedir(), '.dsh', 'browser-profiles', 'edge-kit'); // Real signed-in profiles per platform (Windows / Linux / macOS layouts). const REAL_PROFILE = process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, 'Microsoft', 'Edge', 'User Data') : process.platform === 'linux' ? path.join(os.homedir(), '.config', 'microsoft-edge') : process.platform === 'darwin' ? path.join(os.homedir(), 'Library', 'Application Support', 'Microsoft Edge') : null; const CHROME_REAL_PROFILE = process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, 'Google', 'Chrome', 'User Data') : process.platform === 'linux' ? path.join(os.homedir(), '.config', 'google-chrome') : process.platform === 'darwin' ? path.join(os.homedir(), 'Library', 'Application Support', 'Google', 'Chrome') : null; const FF_PROFILES_ROOT = process.env.APPDATA ? path.join(process.env.APPDATA, 'Mozilla', 'Firefox') : process.platform === 'linux' || process.platform === 'darwin' ? path.join(os.homedir(), '.mozilla', 'firefox') : null; const IS_WIN = process.platform === 'win32'; const BROWSER_CANDIDATES = { edge: IS_WIN ? [ 'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe', 'C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe', ] : process.platform === 'darwin' ? [ '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge', ] : [ '/opt/microsoft/msedge/msedge', '/usr/bin/microsoft-edge', '/usr/bin/microsoft-edge-stable', '/opt/edge/msedge', ], chrome: IS_WIN ? [ 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe', 'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe', process.env.LOCALAPPDATA + '\\Google\\Chrome\\Application\\chrome.exe', ] : process.platform === 'darwin' ? [ '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', ] : [ '/opt/google/chrome/chrome', '/usr/bin/google-chrome', '/usr/bin/google-chrome-stable', '/usr/bin/chromium', '/usr/bin/chromium-browser', '/snap/bin/chromium', ], firefox: IS_WIN ? [ 'C:\\Program Files\\Mozilla Firefox\\firefox.exe', 'C:\\Program Files (x86)\\Mozilla Firefox\\firefox.exe', process.env.LOCALAPPDATA + '\\Mozilla Firefox\\firefox.exe', ] : process.platform === 'darwin' ? [ '/Applications/Firefox.app/Contents/MacOS/firefox', ] : [ '/usr/lib/firefox/firefox', '/usr/bin/firefox', '/snap/bin/firefox', ], }; const kindOf = (exe) => /firefox/i.test(exe) ? 'firefox' : /edge/i.test(exe) ? 'edge' : /chrom/i.test(exe) ? 'chrome' : 'edge'; // Firefox's real profile is whichever profiles.ini marks Default=1. async function ffDefaultProfile() { if (!FF_PROFILES_ROOT) return null; try { const ini = await fs.readFile(path.join(FF_PROFILES_ROOT, 'profiles.ini'), 'utf8'); let cur = null, pick = null, pickPath = null, pickRel = 1; for (const line of ini.split(/\r?\n/)) { const s = line.trim(); if (s.startsWith('[')) { cur = s.slice(1, -1); continue; } const m = /^(Path|Default|IsRelative)=(.*)$/i.exec(s); if (!m || !cur?.startsWith('Profile')) continue; const key = m[1].toLowerCase(), val = m[2].trim(); if (key === 'default' && val === '1') pick = cur; if (key === 'path' && pick === cur) pickPath = val; if (key === 'path' && pick === cur && pickPath) pickRel = pickRel; // keep default relative=1 if (key === 'isrelative' && pick === cur) pickRel = Number(val) || 0; } if (!pickPath) return null; return pickRel ? path.join(FF_PROFILES_ROOT, pickPath) : pickPath; } catch { return null; } } let session = null; // { ws, port, child, headless, profileDir, attached, sessionId, targetId } let lastElements = []; // numbered elements from the most recent see, with rects let nextId = 1; const pending = new Map(); const eventHooks = new Set(); function requireSession() { if (!session || session.ws.readyState !== 1) { throw new Error('no active Edge session; call "launch" or "attach" first'); } return session; } function send(method, params = {}, sessionId) { const s = requireSession(); if (s.engine === 'bidi') return (async () => { if (!s.bidiReady) await bidiHandshake(); return bidiSend(method, params, sessionId === null ? undefined : (sessionId ?? s.sessionId)); })(); const { ws } = s; const id = nextId++; const sid = sessionId === null ? undefined : (sessionId ?? session.sessionId); return new Promise((resolve, reject) => { const timer = setTimeout(() => { pending.delete(id); reject(new Error(`CDP timeout: ${method}`)); }, 30000); pending.set(id, { resolve, reject, timer }); const frame = { id, method, params }; if (sid !== undefined) frame.sessionId = sid; ws.send(JSON.stringify(frame)); }); } function onMessage(raw) { let msg; try { msg = JSON.parse(raw); } catch { return; } if (msg.id && pending.has(msg.id)) { const { resolve, reject, timer } = pending.get(msg.id); pending.delete(msg.id); clearTimeout(timer); if (msg.error) reject(new Error(typeof msg.error === 'string' ? `BiDi ${msg.error}: ${msg.message || ''}` : `CDP ${msg.error.code}: ${msg.error.message}`)); else resolve(msg.result); return; } if (msg.method) { if (session && session.engine === 'bidi') { if (msg.method === 'browsingContext.load' || msg.method === 'browsingContext.domContentLoaded' || msg.method === 'browsingContext.navigationComplete') { for (const hook of [...eventHooks]) hook({ method: 'Page.loadEventFired', sessionId: msg.params && msg.params.context }); } return; } for (const hook of [...eventHooks]) hook(msg); } } async function probePort(port) { try { const res = await fetch(`http://127.0.0.1:${port}/json/version`); if (res.ok) return await res.json(); // Firefox answers here with its httpd.js server and 404s the CDP HTTP // endpoints — its debug dialect is WebDriver BiDi over ws://…/session. if (res.status === 404) { const root = await fetch(`http://127.0.0.1:${port}/`).catch(() => null); if (root && (await root.text().catch(() => '')).includes('httpd.js')) return { bidi: true, Browser: 'Firefox (BiDi)' }; } return null; } catch { return null; } } async function connect(port) { const info = await probePort(port); if (!info) throw new Error(`no DevTools endpoint on port ${port}`); const ws = new WebSocket(info.bidi ? `ws://127.0.0.1:${port}/session` : info.webSocketDebuggerUrl); await new Promise((resolve, reject) => { ws.addEventListener('open', resolve, { once: true }); ws.addEventListener('error', () => reject(new Error('DevTools WebSocket connect failed')), { once: true }); setTimeout(() => reject(new Error('DevTools WebSocket open timeout')), 10000); }); ws.addEventListener('message', (e) => onMessage(typeof e.data === 'string' ? e.data : String(e.data))); return { ws, info }; } /* ── WebDriver BiDi adapter (Firefox speaks BiDi, not CDP, on its debug port). * Only the dialect changes: every call the kit makes maps 1:1 onto a BiDi * command, and responses are rewritten back into CDP shapes so the rest of * the kit never learns which engine is underneath. */ function decr(v) { if (!v || typeof v !== 'object') return v; switch (v.type) { case 'undefined': case 'null': return undefined; case 'string': case 'number': case 'boolean': return v.value; case 'bigint': return Number(v.value); case 'array': return (v.value || []).map(decr); case 'object': { const o = {}; for (const [k, val] of v.value || []) o[k] = decr(val); return o; } default: return v.value ?? null; } } function bidiCall(m, p) { const { ws } = requireSession(); const id = nextId++; return new Promise((resolve, reject) => { const timer = setTimeout(() => { pending.delete(id); reject(new Error(`BiDi timeout: ${m}`)); }, 30000); pending.set(id, { resolve, reject, timer }); ws.send(JSON.stringify({ id, method: m, params: p || {} })); }); } const KEYBI = { Enter: '\uE006', Tab: '\uE004', Space: ' ', Backspace: '\uE003', Escape: '\uE00C', Delete: '\uE017', Insert: '\uE016', PageUp: '\uE00E', PageDown: '\uE00F', ArrowUp: '\uE013', ArrowDown: '\uE015', ArrowLeft: '\uE012', ArrowRight: '\uE014', Home: '\uE010', End: '\uE011', Shift: '\uE008', Control: '\uE009', Alt: '\uE00A' }; // Named keys (Enter/Delete/…) must win over their one-character text form: a // "keyDown" value of '\r' is not the Enter key in WebDriver BiDi, and named keys // like Delete have no text at all. Character keys fall back to the typed text. const keyVal = (params) => { const named = KEYBI[params.code || params.key]; if (named) return named; if (typeof params.text === 'string' && params.text.length === 1 && params.text !== '\r') return params.text; if (typeof params.code === 'string' && /^Key[A-Z]$/.test(params.code)) return params.code.slice(3).toLowerCase(); if (typeof params.code === 'string' && /^Digit[0-9]$/.test(params.code)) return params.code.slice(5); return typeof params.key === 'string' ? params.key : ' '; }; async function bidiSend(method, params, sid) { const ctx = sid ?? session.context; const pointer = (label, actions) => bidiCall('input.performActions', { context: ctx, actions: [{ type: label, id: label === 'key' ? 'k' : 'm', ...(label === 'pointer' ? { parameters: { pointerType: 'mouse' } } : {}), actions }] }); switch (method) { case 'Page.enable': await bidiCall('session.subscribe', { events: ['browsingContext.load', 'browsingContext.domContentLoaded'] }); return {}; case 'Page.disable': return {}; case 'Page.bringToFront': try { await bidiCall('browsingContext.activate', { context: ctx }); } catch { /* detached? */ } return {}; case 'Page.navigate': await bidiCall('browsingContext.navigate', { url: params.url, context: ctx }); return {}; case 'Page.captureScreenshot': { // Firefox builds vary: newer clip wants {type:'box',…}, format may be // omitted (png default). Try plain, then legacy, then explicit shapes. const base = { context: ctx, ...(params.clip ? { clip: { type: 'box', ...params.clip, scale: params.clip.scale ?? 1 } } : {}) }; let lastErr; for (const shape of [base, { ...base, format: 'png' }, { context: ctx }, { context: ctx, format: 'png' }]) { try { return await bidiCall('browsingContext.captureScreenshot', shape); } catch (e) { lastErr = e; } } throw lastErr; } case 'Target.getTargets': { const r = await bidiCall('browsingContext.getTree', {}); return { targetInfos: (r.contexts || []).map((c) => ({ targetId: c.context, url: c.url || '', title: '', type: 'page' })) }; } case 'Target.attachToTarget': session.context = params.targetId; return { sessionId: params.targetId }; case 'Target.createTarget': { // Firefox's browsingContext.create ignores an inline URL: create the tab // first and navigate it explicitly, then wait for the load to settle. const wanted = typeof params.url === 'string' && params.url ? params.url : 'about:blank'; const r = await bidiCall('browsingContext.create', { type: 'tab' }); if (wanted !== 'about:blank') { try { await bidiCall('browsingContext.navigate', { url: wanted, context: r.context, wait: 'complete' }); } catch { /* about:blank tab is usable */ } } return { targetId: r.context }; } case 'Target.closeTarget': await bidiCall('browsingContext.close', { context: params.targetId }); return {}; case 'Runtime.evaluate': { // Firefox's remote agent reads the draft-style `expression` param; the // BiDi standard name rides along for other implementations. const r = await bidiCall('script.evaluate', { expression: params.expression, functionDeclaration: `async function() { return eval(${JSON.stringify(params.expression)}); }`, awaitPromise: true, target: { context: ctx }, }); if (r.exceptionDetails) return { exceptionDetails: { text: r.exceptionDetails.text || JSON.stringify(r.exceptionDetails.stacktrace || {}) } }; return { result: { value: decr(r.result) } }; } // Firefox rejects the draft `{type:'text'}` key action; type by dispatching // one keyDown/keyUp pair per code point (real input events, keeps focus and // selection behaviour), which is what BiDi actually supports. case 'Input.insertText': { const acts = []; for (const ch of [...String(params.text)]) { const value = ch === '\n' ? '\r' : ch; acts.push({ type: 'keyDown', value }, { type: 'keyUp', value }); } if (acts.length) await pointer('key', acts); return {}; } case 'Input.dispatchKeyEvent': { const v = keyVal(params); const acts = params.type === 'keyUp' ? [{ type: 'keyUp', value: v }] : params.type === 'keyDown' ? [{ type: 'keyDown', value: v }, { type: 'keyUp', value: v }] : [{ type: 'keyDown', value: v }]; await pointer('key', acts); return {}; } case 'Input.dispatchMouseEvent': { const acts = []; if (params.type === 'mouseMoved' || params.type === 'mousePressed') acts.push({ type: 'pointerMove', x: params.x, y: params.y, duration: 10 }); if (params.type === 'mousePressed') acts.push({ type: 'pointerDown', button: 0 }); if (params.type === 'mouseReleased') acts.push({ type: 'pointerUp', x: params.x, y: params.y, button: 0 }); await pointer('pointer', acts); return {}; } case 'session.end': try { await bidiCall('session.end', {}); } catch { /* no session */ } return {}; case 'Browser.close': try { await bidiCall('browser.close', {}); } catch { /* browser gone */ } return {}; default: return {}; } } async function pageTargets() { const { targetInfos } = await send('Target.getTargets', {}, null); return targetInfos.filter((t) => t.type === 'page' && !t.url.startsWith('devtools://')); } async function attachTo(targetId) { const prev = session.sessionId; const { sessionId } = await send('Target.attachToTarget', { targetId, flatten: true }, null); session.sessionId = sessionId; session.targetId = targetId; if (prev !== sessionId) await send('Page.enable', {}); } async function attachToPage() { const pages = await pageTargets(); if (!pages.length) { const created = await send('Target.createTarget', { url: 'about:blank' }, null); await attachTo(created.targetId); return; } await attachTo(pages[0].targetId); } async function evaluate(expression) { const r = await send('Runtime.evaluate', { expression, returnByValue: true, awaitPromise: true }); if (r.exceptionDetails) throw new Error(`page script error: ${r.exceptionDetails.text}`); return r.result?.value; } async function waitForLoad(timeoutMs = 15000) { const loaded = new Promise((resolve) => { let done = false, poll = null; const finish = (how) => { if (done) return; done = true; clearTimeout(timer); clearInterval(poll); eventHooks.delete(hook); resolve(how); }; const hook = (msg) => { if (msg.method === 'Page.loadEventFired' && msg.sessionId === session?.sessionId) finish('load'); }; eventHooks.add(hook); const timer = setTimeout(() => finish('timeout'), timeoutMs); // BiDi (Firefox) can fire the load event before a freshly created tab is // attached/subscribed, so an event-only wait misses it and burns the whole // timeout (newTab took ~15 s before this). Poll the document state as a // fast second signal. poll = setInterval(async () => { if (session?.engine !== 'bidi' || done) return; try { if ((await evaluate('document.readyState')) === 'complete') finish('readyState'); } catch { /* navigating */ } }, 250); }); const how = await loaded; await new Promise((r) => setTimeout(r, 400)); // settle for hydration const ready = await evaluate('document.readyState').catch(() => 'unknown'); return { loadEvent: how, readyState: ready }; } async function waitForPort(port, timeoutMs) { const deadline = Date.now() + timeoutMs; while (Date.now() < deadline) { if (await probePort(port)) return true; await new Promise((r) => setTimeout(r, 400)); } return false; } async function findEdge(explicit, kind = 'edge') { const cand = BROWSER_CANDIDATES[kind] || BROWSER_CANDIDATES.edge; for (const p of [explicit, ...cand]) { if (!p) continue; try { await fs.access(p); return p; } catch { /* next */ } } return null; } async function bidiHandshake() { // Firefox's BiDi (remote agent) requires a real WebDriver session: // session.status answers, but commands only work after session.new // with capabilities — empirically probed against Firefox 158. await bidiCall('session.status', {}); let r; try { r = await bidiCall('session.new', { capabilities: { alwaysMatch: {}, firstMatch: [{}] } }); } catch (e) { // Firefox allows one BiDi session; a previous detach or another client can // hold it, and a bare WebSocket close does not release it. if (/Maximum number of active sessions/i.test(String((e && e.message) || ''))) { throw new Error('Firefox already has an active WebDriver BiDi session (a previous detach or another client left it behind). Restart that Firefox instance, then retry.'); } throw e; } session.bidiSessionId = r && r.sessionId; session.bidiReady = true; } async function attachOnly(port) { const { ws, info } = await connect(port); session = { ws, port, child: null, headless: null, profileDir: null, attached: true, kind: 'unknown', engine: info.bidi ? 'bidi' : 'cdp' }; try { await attachToPage(); } catch (error) { // Never leave a half-attached session behind: status would report // running:true with no active tab for every later call. try { ws.close(); } catch { /* already gone */ } session = null; throw error; } } async function doLaunch(args) { const port = effectivePort(args); if (session && session.port === port && session.ws.readyState === 1) { return { ok: true, note: 'already running', port: session.port }; } if (await probePort(port)) { await attachOnly(port); return { ok: true, attached: true, note: `attached to the browser already listening on ${port} (live mode)`, port }; } const wantedKind = String(args.browser || cfgVal('browser', 'edge')).toLowerCase(); const explicit = args.executablePath || cfgVal('executablePath', '') || undefined; const executable = await findEdge(explicit, explicit ? kindOf(explicit) : wantedKind); if (!executable) throw new Error(`${wantedKind} not found; pass executablePath.`); const kind = kindOf(executable); const useReal = args.realProfile ?? cfgVal('realProfile', true); const realFor = kind === 'edge' ? REAL_PROFILE : kind === 'chrome' ? CHROME_REAL_PROFILE : await ffDefaultProfile(); const kitDir = kind === 'edge' ? KIT_PROFILE : `${KIT_PROFILE}-${kind}`; const profileDir = typeof args.profileDir === 'string' && args.profileDir ? args.profileDir : (useReal && realFor ? realFor : cfgVal('profileDir', '') || kitDir); await fs.mkdir(profileDir, { recursive: true }); const headless = args.headless ?? cfgVal('headless', false); const proxyFlag = await launchProxyFlag(args); // The kit owns browser proxy state entirely: a system/v2ray proxy never // leaks into the launched browser, and a proxy-less launch is explicit // about going direct (--no-proxy-server / network.proxy.type=0). const childEnv = { ...process.env }; for (const k of ['HTTP_PROXY', 'HTTPS_PROXY', 'ALL_PROXY', 'NO_PROXY', 'http_proxy', 'https_proxy', 'all_proxy', 'no_proxy']) delete childEnv[k]; const child = spawn(executable, kind === 'firefox' ? [ `-remote-debugging-port=${port}`, '-profile', profileDir, '-no-remote', ...(headless ? ['-headless'] : []), // Firefox's -proxy-server takes host:port, not an http:// URL; a // proxy-less launch states direct traffic explicitly (network.proxy.type=0). ...(proxyFlag ? ['-proxy-server', proxyFlag.replace(/^https?:\/\//, '')] : ['-preferences', '{"network.proxy.type":0}']), 'about:blank', ] : [ `--remote-debugging-port=${port}`, `--user-data-dir=${profileDir}`, '--no-first-run', '--no-default-browser-check', // Server/console sessions treat windows as occluded and stop painting, // which starves surface-based screenshots and throttles timers. '--disable-features=CalculateNativeWinOcclusion', '--disable-backgrounding-occluded-windows', '--disable-renderer-backgrounding', ...(headless ? ['--headless=new'] : []), ...(proxyFlag ? [`--proxy-server=${proxyFlag}`] : ['--no-proxy-server']), 'about:blank', ], { stdio: 'ignore', detached: false, env: childEnv }); if (!(await waitForPort(port, 25000))) { child.kill(); throw new Error('browser started but the DevTools port never opened. If your everyday browser is running without a debug port it owns this profile: pass relaunch:true (closes it and reopens it debuggable), or use a different profileDir.'); } const { ws, info } = await connect(port); session = { ws, port, child, headless, profileDir, attached: false, kind, engine: info.bidi ? 'bidi' : 'cdp', launchArgs: { browser: kind, executablePath: executable, profileDir, headless, port } }; await attachToPage(); return { ok: true, launched: true, headless, port, profileDir, realProfile: profileDir === realFor, browser: kind, executable }; } async function ensureActive(args) { if (session && session.ws.readyState === 1) return; const port = effectivePort(args); if (await probePort(port)) { await attachOnly(port); return; } await doLaunch(args ?? {}); } /* ── Proxy engine: routes all browser traffic (including the web seam) through * free proxies. One hop is handed straight to the browser; two or more chain * through an in-kit local CONNECT forwarder (browser → 127.0.0.1 → hop1 → * hop2 → … → origin). Candidates are verified by fetching an IP echo through * them, so "working" means the exit IP literally proves the route. */ const parseProxy = (s) => { const m = /^(?:https?:\/\/)?([\w.-]+):(\d{1,5})$/.exec(String(s).trim()); return m ? { host: m[1], port: Number(m[2]) } : null; }; const chainLabel = (h) => `${h.host}:${h.port}`; let chainHolder = null; // multi-hop mode: { hops, server, endpoint, raw } let activeProxy = null; // single-hop mode: 'host:port' given to the browser function netConnect(host, port, timeoutMs) { return new Promise((resolve, reject) => { const s = net.connect({ host, port }); const t = setTimeout(() => { s.destroy(); reject(new Error(`connect ${host}:${port} timeout`)); }, timeoutMs); s.once('connect', () => { clearTimeout(t); resolve(s); }); s.once('error', (e) => { clearTimeout(t); reject(e); }); }); } function hopConnect200(sock, carry, host, port, timeoutMs) { return new Promise((resolve) => { let buf = carry || ''; const cleanup = () => { clearTimeout(timer); sock.removeListener('data', onData); sock.removeListener('error', onError); }; const timer = setTimeout(() => { cleanup(); resolve({ ok: false, rest: '', reason: 'timeout' }); }, timeoutMs); const onData = (d) => { buf += d.toString('latin1'); const i = buf.indexOf('\r\n\r\n'); if (i < 0) { if (buf.length > 16384) { cleanup(); resolve({ ok: false, rest: '', reason: 'bad headers' }); } return; } cleanup(); const m = /^HTTP\/1\.[01] (\d{3})/.exec(buf); resolve({ ok: !!m && m[1] === '200', rest: buf.slice(i + 4), reason: m ? `status ${m[1]}` : 'not http' }); }; const onError = () => { cleanup(); resolve({ ok: false, rest: '', reason: 'socket error' }); }; sock.on('data', onData); sock.on('error', onError); sock.write(`CONNECT ${host}:${port} HTTP/1.1\r\nHost: ${host}:${port}\r\nProxy-Connection: keep-alive\r\n\r\n`); }); } async function chainTunnel(hops, targetHost, targetPort, timeoutMs = 9000) { const sock = await netConnect(hops[0].host, hops[0].port, timeoutMs); let carry = ''; for (const [th, tp] of [...hops.slice(1).map((h) => [h.host, h.port]), [targetHost, targetPort]]) { const r = await hopConnect200(sock, carry, th, tp, timeoutMs); carry = ''; if (!r.ok) { sock.destroy(); throw new Error(`proxy ${chainLabel(hops[0])}: CONNECT ${th}:${tp} -> ${r.reason}`); } carry = r.rest; } return { sock, carry }; } async function proxyHttpGet(hops, url, timeoutMs = 9000) { const m = /^https?:\/\/([^/:]+)(?::(\d+))?(\/[^\s]*)?$/i.exec(url); if (!m) throw new Error('bad proxy-probe url'); const host = m[1]; const port = m[2] ? Number(m[2]) : 80; const path = m[3] || '/'; const direct = hops.length === 1 && port === 80; let sock, carry = ''; if (direct) sock = await netConnect(hops[0].host, hops[0].port, timeoutMs); else ({ sock, carry } = await chainTunnel(hops, host, port, timeoutMs)); return await new Promise((resolve, reject) => { let buf = ''; const fin = (err) => { if (done) return; done = true; if (err) { sock.destroy(); reject(err); return; } const im = /^HTTP\/1\.[01] (\d{3})/.exec(buf); const bi = buf.indexOf('\r\n\r\n'); resolve({ status: im ? Number(im[1]) : 0, body: (bi >= 0 ? buf.slice(bi + 4) : buf).trim().split(/\r?\n/)[0] }); }; let done = false; sock.setTimeout(timeoutMs, () => fin(new Error('proxy read timeout'))); sock.on('data', (d) => { buf += d.toString('latin1'); }); sock.on('end', () => fin()); sock.on('close', () => fin()); sock.on('error', (e) => fin(e)); // Single hop over http: absolute-form forward GET — every HTTP proxy does // this, including the free ones that refuse CONNECT (common on IR lists). // Chaining uses the CONNECT nesting chainTunnel speaks. sock.write(`${direct ? `GET ${url}` : `GET ${path}`} HTTP/1.1\r\nHost: ${host}\r\nUser-Agent: edge-kit/3.6\r\nAccept: */*\r\nConnection: close\r\n\r\n`); if (carry) sock.write(Buffer.from(carry, 'latin1')); }); } const ECHOES = ['http://checkip.amazonaws.com/', 'http://ifconfig.me/ip', 'http://ipinfo.io/json']; async function echoLadder(hops) { // Free proxies share exit IPs, so any one echo service can rate-limit (429); // the ladder keeps verification honest as long as one echo answers. for (const url of ECHOES) { try { const r = await proxyHttpGet(hops, url); if (r.status !== 200) continue; let ip = null, country = null, org = null; try { const j = JSON.parse(r.body); ip = j.ip; country = j.country; org = j.org; } catch { if (/^[0-9a-fA-F:.]{4,45}$/.test(r.body)) ip = r.body; } if (ip) return { ip, country, org }; } catch { /* next echo */ } } return null; } let directEgress; async function directEgressOf() { // node fetch never reads HTTP_PROXY/v2ray — this is the machine's true exit. if (directEgress === undefined) { directEgress = null; try { const r = await fetch('http://checkip.amazonaws.com/', { signal: AbortSignal.timeout(7000) }); directEgress = (await r.text()).trim().split(/\s/)[0] || null; } catch { /* offline */ } } return directEgress; } async function probeCandidate(h) { const t0 = Date.now(); const [e, own] = await Promise.all([echoLadder([h]), directEgressOf()]); if (!e) return { ok: false, reason: 'no echo (dead or blocking)', ms: Date.now() - t0 }; if (own && (e.ip === own || e.ip.startsWith(own.split('.').slice(0, 2).join('.') + '.'))) { return { ok: false, reason: `transparent (exit ${e.ip} is your own network — routing through it changes nothing)`, ms: Date.now() - t0 }; } return { ok: true, ip: e.ip, country: e.country, as: e.org, ms: Date.now() - t0 }; } const pipeBoth = (a, b) => { a.on('data', (c) => { if (!b.write(c)) a.pause(); }); b.on('drain', () => a.resume()); a.on('end', () => { try { b.end(); } catch { /* gone */ } }); a.on('error', () => { try { b.destroy(); } catch { /* gone */ } }); a.on('close', () => { try { b.destroy(); } catch { /* gone */ } }); }; function startChainServer(hops) { return new Promise((resolve, reject) => { const server = net.createServer((client) => { client.on('error', () => { try { client.destroy(); } catch { /* gone */ } }); let buf = ''; const onData = (d) => { buf += d.toString('latin1'); const i = buf.indexOf('\r\n\r\n'); if (i < 0) { if (buf.length > 65536) client.destroy(); return; } client.removeListener('data', onData); // A dead proxy hop makes chainTunnel throw inside handle(). Never leave // that rejection floating: it surfaces as an unhandledRejection and the // DSH host treats plugin errors as fatal load failures (crash 2026-11-08 // 20:31: proxy 34.43.46.91:80 CONNECT -> 503 took the whole host down). // Fail only this browser connection instead. void handle(client, buf.slice(0, i), buf.slice(i + 4)).catch(() => { try { client.write('HTTP/1.1 502 Bad Gateway\r\nProxy-Chain: tunnel failed\r\nContent-Length: 0\r\nConnection: close\r\n\r\n'); } catch { /* gone */ } try { client.destroy(); } catch { /* gone */ } }); }; client.on('data', onData); }); const handle = async (client, head, rest) => { const [method, target] = head.split('\r\n')[0].split(' '); let host, port, rewritten = null; if (method === 'CONNECT') { const p = target.split(':'); host = p[0]; port = Number(p[1]); if (!host || !port) throw new Error('bad CONNECT target'); } else { const m = /^(?:https?:)?\/\/([^/:?#]+)(?::(\d+))?(\/[^\s]*)?/i.exec(target) || /^(?:https?:)?\/\/([^/:?#]+)(?::(\d+))?$/i.exec(target); if (!m) throw new Error('bad forward target'); host = m[1]; port = m[2] ? Number(m[2]) : 80; rewritten = `${method} ${m[3] || '/'} HTTP/1.1${head.slice(head.indexOf('\r\n'))}\r\n\r\n`; } const { sock, carry } = await chainTunnel(hops, host, port, 10000); client.write('HTTP/1.1 200 Connection Established\r\n\r\n'); if (rewritten) sock.write(Buffer.concat([Buffer.from(rewritten, 'latin1'), Buffer.from(rest, 'latin1')])); else if (carry) sock.write(Buffer.from(carry, 'latin1')); pipeBoth(client, sock); pipeBoth(sock, client); }; server.on('error', reject); server.listen(0, '127.0.0.1', () => resolve(server)); }); } const stopChain = () => { if (chainHolder) { try { chainHolder.server.close(); } catch { /* gone */ } chainHolder = null; } }; async function ensureHolder(hops) { stopChain(); activeProxy = null; if (hops.length < 2) { activeProxy = chainLabel(hops[0]); return null; } const server = await startChainServer(hops); chainHolder = { hops, server, mode: 'chain', raw: hops.map(chainLabel).join(','), endpoint: `http://127.0.0.1:${server.address().port}` }; return chainHolder; } async function launchProxyFlag(args) { if (chainHolder) return chainHolder.endpoint; if (activeProxy) return `http://${activeProxy}`; const raw = typeof args.proxyChain === 'string' && args.proxyChain.trim() ? args.proxyChain.trim() : String(cfgVal('proxyChain', '') || '').trim(); if (!raw) return null; const hops = raw.split(',').map(parseProxy).filter(Boolean); if (!hops.length) return null; const held = await ensureHolder(hops); return held ? held.endpoint : `http://${activeProxy}`; } const activeProxyView = () => chainHolder ? { chain: chainHolder.hops.map(chainLabel), mode: 'chain', endpoint: chainHolder.endpoint } : (activeProxy ? { chain: [activeProxy], mode: 'single' } : null); async function egressVia(hops) { const t0 = Date.now(); const e = await echoLadder(hops); return e ? { ok: true, ip: e.ip, country: e.country, as: e.org, ms: Date.now() - t0 } : { ok: false, error: 'no echo back', ms: Date.now() - t0 }; } async function restartSession() { const la = session && session.launchArgs ? session.launchArgs : null; if (!session || session.attached || !la) return false; const { child, ws, engine, kind } = session; // Close the browser itself before dropping the socket: for Firefox the spawn // handle is only the Windows launcher, so killing it can orphan the browser // and leave Firefox's single BiDi session registered (the next session.new // then fails with "Maximum number of active sessions"). try { ws.send(JSON.stringify({ id: nextId++, method: engine === 'bidi' ? 'browser.close' : 'Browser.close', params: {} })); } catch { /* gone */ } await new Promise((r) => setTimeout(r, 300)); session = null; try { ws.close(); } catch { /* gone */ } if (child && child.exitCode === null) child.kill(); const port = la.port || effectivePort(la); const waitFree = async (ms) => { const t0 = Date.now(); while (await probePort(port) && Date.now() - t0 < ms) await new Promise((r) => setTimeout(r, 400)); return !(await probePort(port)); }; if (!(await waitFree(6000))) { // A survivor browser (Edge startup-boost, profile handoff, leftover window) // retook the port without our new flags — a fresh spawn would merge into it // and silently lose proxy routing. For Chromium, kill instances of this // browser kind (same semantics as relaunch:true; logins survive, windows // reopen). Firefox refuses: taskkill would close every Firefox window. if (kind === 'firefox') return false; const exe = kind === 'chrome' ? 'chrome' : 'msedge'; const killCmd = process.platform === 'win32' ? `taskkill /IM ${exe}.exe /F` : `pkill -9 -x ${exe}`; await new Promise((r) => exec(killCmd, () => r())); if (!(await waitFree(8000))) return false; } await doLaunch(la); return true; } async function mouseClick(x, y, clickCount = 1) { for (const type of ['mousePressed', 'mouseReleased']) { await send('Input.dispatchMouseEvent', { type, x, y, button: 'left', clickCount, buttons: type === 'mousePressed' ? 1 : 0 }, session.sessionId); } } async function mouseDrag(fromX, fromY, toX, toY, steps = 12) { await send('Input.dispatchMouseEvent', { type: 'mouseMoved', x: fromX, y: fromY }, session.sessionId); await send('Input.dispatchMouseEvent', { type: 'mousePressed', x: fromX, y: fromY, button: 'left', clickCount: 1, buttons: 1 }, session.sessionId); for (let i = 1; i <= steps; i++) { await send('Input.dispatchMouseEvent', { type: 'mouseMoved', x: fromX + (toX - fromX) * i / steps, y: fromY + (toY - fromY) * i / steps, button: 'left', buttons: 1 }, session.sessionId); await new Promise((r) => setTimeout(r, 16)); } await send('Input.dispatchMouseEvent', { type: 'mouseReleased', x: toX, y: toY, button: 'left', clickCount: 1 }, session.sessionId); } const KEYCODES = { Enter: [13, 13], Tab: [9, 9], Escape: [27, 27], Space: [32, 32], Backspace: [8, 8], Delete: [46, 46], ArrowLeft: [37, 37], ArrowUp: [38, 38], ArrowRight: [39, 39], ArrowDown: [40, 40], Home: [36, 36], End: [35, 35], PageUp: [33, 33], PageDown: [34, 34], Shift: [16, 16], Control: [17, 17], Alt: [18, 18], }; for (let c = 0; c < 26; c++) KEYCODES['Key' + String.fromCharCode(65 + c)] = [65 + c, 65 + c]; for (let d = 0; d < 10; d++) KEYCODES['Digit' + d] = [48 + d, 48 + d]; async function pressKey(key, times = 1) { // Normalize the requested key: named keys are case-insensitive ("Space" and // "space" are the same key), and the character-carrying keys (Space, Enter) // must carry their real character in `key`/`text` — CDP otherwise reports an // empty event.key for the named form and games/forms never see the key. const requested = String(key); const named = Object.keys(KEYCODES).find((candidate) => candidate.toLowerCase() === requested.toLowerCase()); const keyName = named || requested; const vk = KEYCODES[keyName] || [requested.length === 1 ? requested.toUpperCase().charCodeAt(0) : 0, 0]; const code = KEYCODES[keyName] ? keyName : (requested.length === 1 ? `Key${requested.toUpperCase()}` : ''); const char = keyName === 'Space' ? ' ' : keyName === 'Enter' ? '\r' : (requested.length === 1 ? requested : undefined); const base = { key: keyName === 'Space' ? ' ' : keyName, code, windowsVirtualKeyCode: vk[0], nativeVirtualKeyCode: vk[1] }; for (let i = 0; i < times; i++) { await send('Input.dispatchKeyEvent', { type: char !== undefined ? 'keyDown' : 'rawKeyDown', ...base, ...(char !== undefined ? { text: char } : {}) }, session.sessionId); await send('Input.dispatchKeyEvent', { type: 'keyUp', ...base }, session.sessionId).catch(async () => { await send('Input.dispatchKeyEvent', { type: 'keyUp', ...base }, session.sessionId); }); if (times > 1) await new Promise((r) => setTimeout(r, 90)); } } async function captureShot(saveTo, clip) { await send('Page.bringToFront', {}).catch(() => {}); const params = { format: 'png', fromSurface: false }; if (clip) params.clip = { ...clip, scale: 1 }; let data; try { ({ data } = await send('Page.captureScreenshot', params)); } catch { ({ data } = await send('Page.captureScreenshot', { format: 'png', ...(clip ? { clip: { ...clip, scale: 1 } } : {}) })); } const buffer = Buffer.from(data, 'base64'); const file = saveTo || path.join(os.tmpdir(), `edge-kit-shot-${Date.now()}.png`); await fs.mkdir(path.dirname(file), { recursive: true }); await fs.writeFile(file, buffer); return { path: file, bytes: buffer.length }; } /** Shared in-page walker: shadow-piercing visibility, naming, and element catalog. */ const WALKER = ` const vis = (el) => { const r = el.getBoundingClientRect(); if (r.width < 4 || r.height < 4) return null; try { const cs = getComputedStyle(el); if (cs.visibility === 'hidden' || cs.display === 'none' || cs.opacity === '0') return null; } catch { } return r; }; const clean = (s) => String(s || '').replace(/\\s+/g, ' ').trim(); const nameOf = (el) => clean(el.getAttribute('aria-label')).slice(0, 70) || clean(el.innerText).slice(0, 70) || clean(el.getAttribute('placeholder')) || clean(el.getAttribute('title')) || clean(el.getAttribute('alt')) || clean(el.value) || ''; const isInter = (el) => { const tag = el.tagName.toLowerCase(); const role = (el.getAttribute('role') || '').toLowerCase(); if (['button', 'summary'].includes(tag)) return true; if (tag === 'a' && el.hasAttribute('href')) return true; if (['input', 'textarea', 'select'].includes(tag) && el.type !== 'hidden') return true; if (el.isContentEditable) return true; return ['button', 'link', 'textbox', 'searchbox', 'checkbox', 'radio', 'combobox', 'menuitem', 'tab', 'option'].includes(role); }; `; async function seeOnce(opts = {}) { const js = `(async () => { ${WALKER} const els = []; const seen = new Set(); function walk(root) { for (const el of root.querySelectorAll('*')) { if (el.shadowRoot) walk(el.shadowRoot); if (!isInter(el)) continue; const r = vis(el); if (!r) continue; const name = nameOf(el); const tag = el.tagName.toLowerCase(); const key = tag + '|' + (el.getAttribute('role') || '') + '|' + name; if (seen.has(key)) continue; seen.add(key); els.push({ role: (el.getAttribute('role') || (tag === 'a' ? 'link' : tag)), name, x: Math.round(r.x + r.width / 2), y: Math.round(r.y + r.height / 2), el }); if (els.length >= 60) return; } } walk(document); let text = document.body ? clean(document.body.innerText) : ''; function xt(root) { for (const el of root.querySelectorAll('*')) { if (el.shadowRoot) { text += ' ' + clean(el.shadowRoot.textContent); xt(el.shadowRoot); } } } xt(document); const dialogs = []; function dwalk(root) { for (const el of root.querySelectorAll('[role="dialog"],[role="alertdialog"],dialog')) { if (el.shadowRoot) dwalk(el.shadowRoot); const r = vis(el); if (!r) continue; dialogs.push(clean(el.innerText).slice(0, 160)); } } dwalk(document); // Keep the live element references from this see so click{index} can // re-resolve its row after scrolling or DOM movement instead of firing at a // stale, cached coordinate (which silently no-ops on a moved page). try { window.__edgeKitElements = els.map((entry) => entry.el); } catch { } return { url: location.href, title: document.title, text: text.slice(0, ${Math.min(opts.maxText ?? cfgVal('seeTextCap', 2200), 6000)}), elements: els.map(({ role, name, x, y }) => ({ role, name, x, y })), dialogs: [...new Set(dialogs)].slice(0, 4) }; })()`; return evaluate(js); } async function findByName(needle) { const js = `(() => { ${WALKER} const want = ${JSON.stringify(String(needle).toLowerCase())}; let best = null; function walk(root) { for (const el of root.querySelectorAll('*')) { if (el.shadowRoot) walk(el.shadowRoot); if (!isInter(el) && !el.matches('a,button,input,textarea,select,summary,[role],[jsaction],[contenteditable]')) continue; const label = nameOf(el).toLowerCase(); if (!label.includes(want)) continue; const r = vis(el); if (!r) continue; const score = (label === want ? 0 : label.startsWith(want) ? 1 : 2) + (isInter(el) ? 0 : 5); if (!best || score < best.score) best = { score, x: r.x + r.width / 2, y: r.y + r.height / 2, name: nameOf(el) }; } } walk(document); return best; })()`; return evaluate(js); } async function focusField(by) { const js = `(() => { ${WALKER} const want = ${JSON.stringify(String(by).toLowerCase())}; const labelOf = (el) => { const names = [el.getAttribute('aria-label'), el.getAttribute('placeholder'), el.getAttribute('title'), el.name || null]; if (el.labels) for (const l of el.labels) names.push(l.innerText); if (el.id) { const l = document.querySelector('label[for="' + el.id + '"]'); if (l) names.push(l.innerText); } return names.map(clean).filter(Boolean).join(' ').toLowerCase(); }; let best = null; function walk(root) { for (const el of root.querySelectorAll('*')) { if (el.shadowRoot) walk(el.shadowRoot); if (!el.matches('input,textarea,select,[contenteditable="true"]')) continue; if (el.type === 'hidden' || el.disabled) continue; const hay = labelOf(el); if (!hay.includes(want)) continue; const r = vis(el); if (!r) continue; const score = hay === want ? 0 : 1; if (!best || score < best.score) best = { score, el }; } } walk(document); if (!best) return null; best.el.scrollIntoView({ block: 'center' }); best.el.focus(); return document.activeElement === best.el ? nameOf(best.el) || ${JSON.stringify(by)} : 'focused-by-invoke'; })()`; return evaluate(js); } async function pageInfo() { return { url: await evaluate('location.href').catch(() => null), title: await evaluate('document.title').catch(() => null) }; } async function run(args) { const action = typeof args?.action === 'string' ? args.action : 'status'; switch (action) { case 'launch': { if (args.relaunch) { // Take over a profile-owning browser we do not control (or do): close // its instances, then spawn a fresh debuggable one. Session restore // brings the user's tabs back on the reopened browser. Only the engine // being relaunched is touched, and Firefox refuses outright because // taskkill would close every Firefox window the user has open. const relKind = args.executablePath ? kindOf(args.executablePath) : String(args.browser || cfgVal('browser', 'edge')).toLowerCase(); if (relKind === 'firefox') throw new Error('relaunch is not supported for Firefox: it would kill every Firefox window. Use an isolated profileDir, or close that Firefox yourself.'); try { session?.ws?.close(); } catch { /* gone */ } session = null; await new Promise((res) => exec(`taskkill /IM ${relKind === 'chrome' ? 'chrome.exe' : 'msedge.exe'} /F`, () => res())); await new Promise((r) => setTimeout(r, 1800)); } return doLaunch(args); } case 'attach': { const port = effectivePort(args); // Firefox allows exactly one WebDriver BiDi session. Re-attaching to a // browser this process already drives would open a second socket against // that single session, fail the handshake, and strand the browser with no // owner (neither relaunch nor close could reach it). Report the existing // connection instead. if (session && session.port === port && session.ws.readyState === 1) { return { ok: true, attached: true, port, liveMode: !!session.attached, alreadyConnected: true, note: 'already connected to this browser in this process' }; } await attachOnly(port); return { ok: true, attached: true, port, liveMode: true }; } case 'status': { const settings = settingsSnapshot(); if (session && session.ws.readyState === 1) { return { ok: true, running: true, liveMode: session.attached, port: session.port, headless: session.headless, childPid: session.child?.pid ?? null, profileDir: session.profileDir, proxy: activeProxyView(), settings, ...await pageInfo() }; } const occupied = !!(await probePort(effectivePort(args))); return { ok: true, running: false, portOccupied: occupied, settings }; } case 'tabs': { await ensureActive(args); const pages = await pageTargets(); return { ok: true, current: session.targetId, tabs: pages.map((t, i) => ({ i, targetId: t.targetId, url: t.url, title: t.title, current: t.targetId === session.targetId })) }; } case 'newTab': { await ensureActive(args); const { targetId } = await send('Target.createTarget', { url: typeof args.url === 'string' ? args.url : 'about:blank' }, null); await attachTo(targetId); if (typeof args.url === 'string' && args.url !== 'about:blank') await waitForLoad(); return { ok: true, ...await pageInfo() }; } case 'switchTab': { await ensureActive(args); const pages = await pageTargets(); const t = Number.isInteger(args.index) ? pages[args.index] : pages.find((p) => p.targetId === args.targetId); if (!t) return { ok: false, error: 'tab not found', tabs: pages.map((p, i) => ({ i, url: p.url })) }; await attachTo(t.targetId); return { ok: true, ...await pageInfo() }; } case 'closeTab': { await ensureActive(args); const pages = await pageTargets(); const t = Number.isInteger(args.index) ? pages[args.index] : pages.find((p) => p.targetId === args.targetId); if (!t) return { ok: false, error: 'tab not found' }; await send('Target.closeTarget', { targetId: t.targetId }, null); const rest = await pageTargets(); if (t.targetId === session.targetId) { if (rest.length) await attachTo(rest[0].targetId); else session = null; } return { ok: true, remaining: rest.length }; } case 'goto': { if (typeof args.url !== 'string' || !args.url) throw new Error('goto needs a url'); await ensureActive(args); await send('Page.navigate', { url: args.url }); const load = await waitForLoad(); return { ok: true, ...await pageInfo(), ...load }; } case 'back': case 'forward': case 'reload': { await ensureActive(args); const hist = action === 'back' ? 'history.back()' : action === 'forward' ? 'history.forward()' : 'location.reload()'; await evaluate(hist); await waitForLoad().catch(() => ({})); return { ok: true, ...await pageInfo() }; } case 'see': { await ensureActive(args); const snap = await seeOnce(args); lastElements = snap.elements.map((e) => ({ x: e.x, y: e.y, role: e.role, name: e.name })); return { ok: true, url: snap.url, title: snap.title, text: snap.text, dialogs: snap.dialogs, elements: snap.elements.map((e, i) => ({ i, role: e.role, name: e.name })) }; } case 'click': { await ensureActive(args); let point = null; if (Number.isInteger(args.index)) { const e = lastElements[args.index]; if (!e) return { ok: false, error: `no element #${args.index} in the last see; call see first` }; // Re-resolve the element captured by the most recent see: scroll it into // view and measure it again, so a scrolled or re-laid-out page cannot // turn the click into a silent miss at a stale coordinate. point = await evaluate(`(() => { const list = window.__edgeKitElements || []; const el = list[${Number(args.index)}]; if (!el || !el.isConnected) return null; el.scrollIntoView({ block: 'center' }); const r = el.getBoundingClientRect(); return { x: r.x + r.width / 2, y: r.y + r.height / 2, name: (el.innerText || el.getAttribute('aria-label') || '').trim().slice(0, 60) }; })()`); if (!point) { lastElements = []; return { ok: false, error: `element #${args.index} from the last see is gone; call see again` }; } } else if (typeof args.text === 'string' && args.text) { point = await findByName(args.text); } else if (typeof args.selector === 'string' && args.selector) { point = await evaluate(`(() => { const el = document.querySelector(${JSON.stringify(args.selector)}); if (!el) return null; el.scrollIntoView({ block: 'center' }); const r = el.getBoundingClientRect(); return { x: r.x + r.width / 2, y: r.y + r.height / 2, name: (el.innerText || '').trim().slice(0, 60) }; })()`); } if (!point) return { ok: false, error: 'nothing matched; call see to list what is clickable' }; await mouseClick(point.x, point.y); await new Promise((r) => setTimeout(r, 500)); return { ok: true, clicked: point.name || args.text || args.selector, ...await pageInfo() }; } case 'type': { await ensureActive(args); if (typeof args.text !== 'string') throw new Error('type needs text'); if (args.selector) { const ok = await evaluate(`(() => { const el = document.querySelector(${JSON.stringify(String(args.selector))}); if (!el) return false; el.scrollIntoView({ block: 'center' }); el.focus(); return document.activeElement === el; })()`); if (!ok) return { ok: false, error: `selector not focusable: ${args.selector}` }; } else if (typeof args.into === 'string' && args.into) { const label = await focusField(args.into); if (!label) return { ok: false, error: `no field labeled like ${JSON.stringify(args.into)}; call see` }; } await send('Input.insertText', { text: args.text }, session.sessionId); if (args.submit === true) { const base = { key: 'Enter', code: 'Enter', windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13 }; await send('Input.dispatchKeyEvent', { type: 'keyDown', ...base, text: '\r' }, session.sessionId); await send('Input.dispatchKeyEvent', { type: 'keyUp', ...base }, session.sessionId); await waitForLoad().catch(() => ({})); } return { ok: true, typed: args.text.length, submitted: args.submit === true, ...await pageInfo() }; } case 'press': { await ensureActive(args); const key = typeof args.key === 'string' ? args.key : 'Enter'; await pressKey(key, Math.min(Number.isInteger(args.times) ? args.times : 1, 50)); await new Promise((r) => setTimeout(r, 400)); return { ok: true, key, ...await pageInfo() }; } case 'clickAt': { await ensureActive(args); const x = Number(args.x), y = Number(args.y); if (!Number.isFinite(x) || !Number.isFinite(y)) throw new Error('clickAt needs numeric x and y'); await mouseClick(x, y); await new Promise((r) => setTimeout(r, 300)); return { ok: true, clickedAt: { x, y }, ...await pageInfo() }; } case 'drag': { await ensureActive(args); const x = Number(args.x), y = Number(args.y), toX = Number(args.toX), toY = Number(args.toY); if (![x, y, toX, toY].every(Number.isFinite)) throw new Error('drag needs x, y, toX, toY'); await mouseDrag(x, y, toX, toY); return { ok: true, dragged: { from: { x, y }, to: { x: toX, y: toY } }, ...await pageInfo() }; } case 'video': { await ensureActive(args); const vi = Number.isInteger(args.video) ? args.video : 0; const op = typeof args.op === 'string' ? args.op : 'status'; const to = Number(args.to); const js = `(async () => { const vs = [...document.querySelectorAll('video')]; const v = vs[${vi}]; if (v) { ${op === 'play' ? 'v.muted = true; await v.play().catch(() => {});' : ''} ${op === 'pause' ? 'v.pause();' : ''} ${op === 'seek' ? `v.currentTime = ${Number.isFinite(to) ? to : 0};` : ''} ${op === 'rate' ? `v.playbackRate = ${Number.isFinite(to) ? Math.min(Math.max(to, 0.1), 8) : 1};` : ''} } return { page: { url: location.href, title: document.title }, videos: vs.map((v) => { const r = v.getBoundingClientRect(); return { playing: !v.paused && !v.ended, paused: v.paused, ended: v.ended, currentTime: Math.round(v.currentTime * 100) / 100, duration: v.duration || 0, muted: v.muted, volume: v.volume, rate: v.playbackRate, ready: v.readyState, rect: { x: Math.round(r.x), y: Math.round(r.y), w: Math.round(r.width), h: Math.round(r.height) }, src: (v.currentSrc || v.src || '').slice(0, 160) }; }) }; })()`; const state = await evaluate(js); const shotsN = Math.min(Number.isInteger(args.shots) ? args.shots : 0, 12); const every = Math.min(Number.isInteger(args.every) ? args.every : 1000, 20000); const shots = []; for (let i = 0; i < shotsN; i++) { const rect = state.videos[vi] && state.videos[vi].rect; const file = path.join(os.homedir(), 'Documents', 'deepseek-harness', 'default-workspace', `edge-kit-video-${Date.now()}-${i}.png`); const clip = rect && rect.w > 4 && rect.h > 4 ? { x: rect.x, y: rect.y, width: rect.w, height: rect.h } : undefined; shots.push(await captureShot(file, clip)); if (i < shotsN - 1) await new Promise((r) => setTimeout(r, every)); } return { ok: true, ...state, shots }; } case 'scroll': { await ensureActive(args); const dir = args.direction === 'up' ? -1 : 1; const px = Math.min(Number.isInteger(args.amount) ? args.amount : 600, 4000); await evaluate(`window.scrollBy(0, ${dir * px}); 'ok'`); return { ok: true, direction: dir > 0 ? 'down' : 'up', px }; } case 'waitFor': { await ensureActive(args); const timeoutMs = Math.min(Number.isInteger(args.timeoutMs) ? args.timeoutMs : 10000, 30000); const js = `(async () => { ${WALKER} const needle = ${JSON.stringify(typeof args.text === 'string' ? args.text.toLowerCase() : '')}; const sel = ${JSON.stringify(typeof args.selector === 'string' ? args.selector : '')}; const start = Date.now(); const hasText = () => { let found = (document.body ? document.body.innerText : '').toLowerCase().includes(needle); if (found || !needle) return found; const stack = [document]; while (stack.length) { const root = stack.pop(); for (const el of root.querySelectorAll('*')) { if (el.shadowRoot) { stack.push(el.shadowRoot); if (needle && el.shadowRoot.textContent.toLowerCase().includes(needle)) return true; } } } return false; }; while (Date.now() - start < ${timeoutMs}) { if (sel && document.querySelector(sel)) return { found: true, how: 'selector', ms: Date.now() - start }; if (needle && hasText()) return { found: true, how: 'text', ms: Date.now() - start }; await new Promise((r) => setTimeout(r, 250)); } return { found: false, ms: Date.now() - start }; })()`; const r = await evaluate(js); return { ok: true, ...r, ...await pageInfo() }; } case 'eval': { await ensureActive(args); if (typeof args.script !== 'string') throw new Error('eval needs a script'); return { ok: true, result: await evaluate(`(async () => { ${args.script} })()`) }; } case 'screenshot': { await ensureActive(args); const saveTo = typeof args.saveTo === 'string' && path.isAbsolute(args.saveTo) ? args.saveTo : undefined; return { ok: true, ...await captureShot(saveTo) }; } case 'wait': { const ms = Math.min(Number.isInteger(args.ms) ? args.ms : 1000, 20000); await new Promise((r) => setTimeout(r, ms)); return { ok: true, waited: ms }; } case 'proxy': { const raw = String(args.proxyChain || '').trim(); const entries = raw.split(/[\s,;]+/).map(parseProxy).filter(Boolean); const op = ['auto', 'set', 'status', 'clear'].includes(args.op) ? args.op : (entries.length ? 'auto' : 'status'); if (op === 'clear') { stopChain(); activeProxy = null; const relaunched = await restartSession(); return { ok: true, cleared: true, relaunched, note: 'proxy removed; relaunch to route traffic direct' }; } if (op === 'status') { const view = activeProxyView(); const live = view ? await egressVia(view.mode === 'chain' ? chainHolder.hops : [parseProxy(activeProxy)]) : null; return { ok: true, active: view && { ...view, exit: live }, settings: settingsSnapshot() }; } if (!entries.length) return { ok: false, error: 'proxy: pass proxyChain "ip:port[,ip:port,...]" (auto tests candidates; set installs the list as the chain)' }; const tested = await Promise.all(entries.map(async (h) => ({ hop: h, ...(await probeCandidate(h)) }))); const working = tested.filter((t) => t.ok).sort((a, b) => a.ms - b.ms); if (!working.length) return { ok: false, tested: entries.length, results: tested.map((t) => ({ proxy: chainLabel(t.hop), reason: t.reason, ms: t.ms })) }; const pick = working[0]; let hops; if (op === 'set') hops = entries; else { hops = [pick.hop]; if (args.chainTo) { const second = parseProxy(args.chainTo); if (second) hops.push(second); } } let note = null; let exit = null; if (hops.length > 1) { exit = await egressVia(hops); if (!exit.ok) { if (op === 'set') return { ok: false, error: `chain ${hops.map(chainLabel).join(' -> ')} rejected: ${exit.error || 'no echo'} (fastest single hop: ${chainLabel(pick.hop)}, exit ${pick.ip})` }; note = `chain ${hops.map(chainLabel).join(' -> ')} rejected (${exit.error || 'no echo'}) — applied the fastest single hop instead`; hops = [pick.hop]; } } await ensureHolder(hops); const relaunched = await restartSession(); const view = activeProxyView(); if (!exit) exit = await egressVia(hops); return { ok: true, ...(note ? { note } : {}), active: { ...(view || {}), exit }, chosen: { proxy: chainLabel(pick.hop), ip: pick.ip, country: pick.country, ms: pick.ms }, relaunched, tested: entries.length, working: working.map((w) => ({ proxy: chainLabel(w.hop), ip: w.ip, country: w.country, ms: w.ms })).slice(0, 12), }; } case 'close': { if (!session) return { ok: true, note: 'no active session' }; const { child, attached, ws } = session; if (attached) { // Firefox keeps its single BiDi session registered after a bare // WebSocket close, so detach by ending that session first (the browser // itself is borrowed and stays up). try { if (session.engine === 'bidi' && session.bidiReady) await send('session.end', {}, null); } catch { /* best effort */ } session = null; try { ws.close(); } catch { /* already gone */ } return { ok: true, detached: true, note: 'left the borrowed browser running (live mode)' }; } await Promise.race([ send('Browser.close', {}, null).catch(() => {}), new Promise((r) => setTimeout(r, 1500)), ]); /* EDGE_KIT_NATIVE_CLOSE_FIX: clear the session only after Browser.close was sent; the * upstream order cleared it first, so send() threw and close leaked the browser. */ session = null; if (child && child.exitCode === null) child.kill(); try { ws.close(); } catch { /* already gone */ } return { ok: true, closed: true }; } default: return { ok: false, error: `unknown action: ${action}` }; } } /* ── Native web providers (Exa-style): the harness web seam, pinned to this * plugin by cordis.patch.yml, serves web_search / web_fetch through your * real signed-in Edge — full JS rendering and a home fingerprint, so content * that plain HTTP fetchers get wall-Blocked on still comes back clean. */ async function withPage(navigateTo, extract, signal) { if (!session || session.ws.readyState !== 1) { if (!initLock) initLock = (async () => { try { await doLaunch({}); } catch (e) { // Seam calls have nobody to ask for a relaunch: if the signed-in // profile is locked by the everyday Edge, degrade to the kit profile. if (cfgVal('realProfile', true)) { await doLaunch({ profileDir: cfgVal('profileDir', '') || KIT_PROFILE }); return; } throw e; } })().finally(() => { initLock = null; }); await initLock; } const { targetId } = await send('Target.createTarget', { url: 'about:blank' }, null); const { sessionId: sid } = await send('Target.attachToTarget', { targetId, flatten: true }, null); try { await send('Page.enable', {}, sid); await send('Page.navigate', { url: navigateTo }, sid); const deadline = Date.now() + 20000; while (Date.now() < deadline) { if (signal && signal.aborted) throw new Error('web request aborted'); const r = await send('Runtime.evaluate', { expression: 'document.readyState', returnByValue: true }, sid); if (r.result && r.result.value === 'complete') break; await new Promise((res) => setTimeout(res, 400)); } await new Promise((res) => setTimeout(res, 600)); // let hydration settle const r = await send('Runtime.evaluate', { expression: extract, returnByValue: true, awaitPromise: true }, sid); if (r.exceptionDetails) throw new Error(`page script error: ${r.exceptionDetails.text}`); return r.result ? r.result.value : undefined; } finally { await send('Target.closeTarget', { targetId }, null).catch(() => {}); } } let initLock = null; /* EDGE_KIT_NATIVE_PORTABILITY: keep the activation probe under the current user's * home directory instead of a hardcoded developer path. */ const PROBE_FILE = path.join(os.homedir(), 'Documents', 'deepseek-harness', 'default-workspace', 'edge-kit-seam-probe.json'); let probed = false; const FETCH_EXTRACT = `(async () => { let status = 200; try { const n = performance.getEntriesByType('navigation')[0]; if (n && typeof n.responseStatus === 'number') status = n.responseStatus; } catch {} return { url: location.href, status, text: document.body ? document.body.innerText : '' }; })()`; const SEARCH_EXTRACT = `(() => { const clean = (s) => String(s || '').replace(/\\s+/g, ' ').trim(); const out = []; const seen = new Set(); const selfUrl = (u) => /^https?:\\/\\/(?:www\\.)?(?:bing|google|duckduckgo)\\./i.test(u); // Organic result headlines come in both directions now: heading inside the // link (Google: a > h3) AND link inside the heading (Bing: h2 > a). Match // both — engine class names drift, the heading/link nesting does not. for (const node of document.querySelectorAll('h2 a, h3 a, a h2, a h3')) { if (out.length >= 20) break; const link = node.matches('a') ? node : node.closest('a'); if (!link) continue; let url = link.href; if (/^\\/(url|link)\\?/.test(url)) { const m = url.match(/[?&](?:url|q)=([^&]+)/); if (m) { try { url = decodeURIComponent(m[1]); } catch {} } } if (!/^https?:/i.test(url) || seen.has(url) || selfUrl(url)) continue; const title = clean(link.innerText); if (!title || title.length < 4) continue; const box = link.closest('li,div.g,div.tF2Cxc,li.b_algo,div.b_title,div[class*=result]') || link.parentElement; let snippet = box ? clean(box.innerText) : ''; if (snippet.startsWith(title)) snippet = snippet.slice(title.length).trim(); seen.add(url); out.push({ url, title: title.slice(0, 200), ...(snippet ? { snippet: snippet.slice(0, 400) } : {}) }); } return { sources: out, page: { url: location.href, title: clean(document.title) } }; })()`; const edgeFetchProvider = { id: 'edge-kit', available: () => true, async fetch(request, signal) { const r = await withPage(request.url, FETCH_EXTRACT, signal) || {}; const cap = cfgVal('fetchTextCap', 20000); let text = String(r.text || ''); const truncated = text.length > cap; if (truncated) text = text.slice(0, cap); return { url: r.url || request.url, statusCode: r.status || 200, body: { kind: 'text', content: text }, truncated }; }, }; const edgeSearchProvider = { id: 'edge-kit', available: () => true, async search(request, signal) { const n = Math.min(Math.max(request.maxResults ?? 10, 1), 20); const q = encodeURIComponent(request.query); const engine = cfgVal('searchEngine', 'google') === 'bing' ? 'bing' : 'google'; const build = (e) => e === 'bing' ? `https://www.bing.com/search?q=${q}&count=${Math.min(n * 2, 30)}` : `https://www.google.com/search?q=${q}&num=${Math.min(n * 2, 20)}`; const r = (await withPage(build(engine), SEARCH_EXTRACT, signal)) || {}; let sources = (r.sources || []).slice(0, n); let page = r.page || {}; if (!sources.length) { // Engine layouts and consent walls differ; an agent's search should // survive either. Try the other engine once before reporting empty. const alt = (await withPage(build(engine === 'bing' ? 'google' : 'bing'), SEARCH_EXTRACT, signal)) || {}; sources = (alt.sources || []).slice(0, n); if (alt.page) page = alt.page; } return { sources, truncated: false, ...(sources.length || !page.url ? {} : { content: 'edge-kit search parsed no results; landed on ' + page.url + ' (title: ' + (page.title || 'none') + ')' }), }; }, }; export function apply(ctx, config) { cfg = config; // One-time activation probe: run the seam's own fetch/search against this // provider and record the outcome, proving selection + rendering end to end. if (!probed) { probed = true; setTimeout(async () => { const out = { at: new Date().toISOString() }; try { const f = await ctx.web.fetch({ url: 'https://quotes.toscrape.com/js/' }); out.fetch = { url: f.url, statusCode: f.statusCode, kind: f.body.kind, length: f.body.content.length, truncated: f.truncated, sample: f.body.content.slice(0, 220) }; } catch (e) { out.fetchError = String((e && e.message) || e); } try { const s = await ctx.web.search({ query: 'deepseek harness', maxResults: 3 }); out.search = { count: s.sources.length, urls: s.sources.slice(0, 3).map((x) => x.url), content: s.content }; } catch (e) { out.searchError = String((e && e.message) || e); } try { await fs.writeFile(PROBE_FILE, JSON.stringify(out, null, 2)); } catch { /* probe file optional */ } }, 400); } ctx.effect(() => { // The seam disposes provider registrations with the registering fiber, // so they must live inside this effect, not at apply scope. const offSearch = ctx.web.registerSearchProvider(edgeSearchProvider); const offFetch = ctx.web.registerFetchProvider(edgeFetchProvider); const dispose = ctx.tools.register({ name: 'edge_kit_browser', description: 'Edge Kit Browser — browse like a human in Edge, Chrome, or Firefox. Flow: see (read the ' + 'page: text + numbered elements, shadow-DOM aware) then act: click {index|text|selector}, ' + 'clickAt {x,y}, drag {x,y,toX,toY}, type {into,text,submit?}, press {key,times}, scroll; ' + 'understand video: video {video?, op:status|play|pause|seek|rate, to?, shots?, every?} ' + 'returns playback state and PNG frames of the player; route traffic: proxy ' + '{op:auto|set|status|clear, proxyChain:"ip:port[,ip:port]", chainTo?} verifies candidates with an ' + 'IP echo, moves the browser onto the fastest working proxy, and chains hops through a local ' + 'forwarder (exit IP reported); verify with waitFor {text|selector} ' + 'or screenshot; navigate with goto/back/forward/reload; organize with tabs/newTab/' + 'switchTab/closeTab. Session: launch (browser: edge|chrome|firefox; live-attaches to a ' + 'running debuggable browser first; realProfile:true keeps your logins; relaunch:true ' + 'restarts your browser debuggable), attach, status, wait {ms}, eval {script}, close ' + '(detaches from borrowed browsers, never closes them).', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['launch', 'attach', 'status', 'tabs', 'newTab', 'switchTab', 'closeTab', 'goto', 'back', 'forward', 'reload', 'see', 'click', 'clickAt', 'drag', 'video', 'type', 'press', 'scroll', 'waitFor', 'eval', 'screenshot', 'wait', 'proxy', 'close'], description: 'What to do.', }, url: { type: 'string', description: 'goto/newTab: address to open.' }, headless: { type: 'boolean', description: 'launch only: start hidden (default false = visible, like a person).' }, port: { type: 'integer', description: 'DevTools port (default comes from the Edge Kit settings page).' }, profileDir: { type: 'string', description: 'launch only: user-data-dir override.' }, realProfile: { type: 'boolean', description: 'launch only: use your everyday Edge profile (keeps all your logins). Default comes from the Edge Kit settings page.' }, relaunch: { type: 'boolean', description: 'launch only: restart a running profile-owning Edge so it becomes debuggable.' }, executablePath: { type: 'string', description: 'launch only: msedge.exe path override.' }, index: { type: 'integer', description: 'click: element number from the most recent see. switchTab/closeTab: tab number from tabs.' }, targetId: { type: 'string', description: 'switchTab/closeTab: exact target id.' }, text: { type: 'string', description: 'click: visible text to click. type: text to enter. waitFor: text to wait for.' }, into: { type: 'string', description: 'type: human label of the field (label/placeholder/aria-label).' }, submit: { type: 'boolean', description: 'type: press Enter after typing.' }, selector: { type: 'string', description: 'click: CSS selector (light DOM). waitFor: selector to wait for.' }, script: { type: 'string', description: 'eval: JS statements (await allowed).' }, key: { type: 'string', description: 'press: key name (default Enter).' }, direction: { type: 'string', enum: ['up', 'down'], description: 'scroll direction.' }, amount: { type: 'integer', description: 'scroll pixels (default 600).' }, ms: { type: 'integer', description: 'wait: milliseconds.' }, timeoutMs: { type: 'integer', description: 'waitFor: max milliseconds (default 10000).' }, maxText: { type: 'integer', description: 'see: page-text cap (default 2200).' }, saveTo: { type: 'string', description: 'screenshot: absolute PNG path to write.' }, browser: { type: 'string', enum: ['edge', 'chrome', 'firefox'], description: 'launch: which browser to start (default comes from the settings page).' }, x: { type: 'integer', description: 'clickAt/drag: x coordinate.' }, y: { type: 'integer', description: 'clickAt/drag: y coordinate.' }, toX: { type: 'integer', description: 'drag: destination x.' }, toY: { type: 'integer', description: 'drag: destination y.' }, times: { type: 'integer', description: 'press: repeat the key this many times (games).' }, video: { type: 'integer', description: 'video: which video element on the page (0 = first).' }, op: { type: 'string', enum: ['status', 'play', 'pause', 'seek', 'rate', 'auto', 'set', 'clear'], description: 'video: what to do. proxy: auto (test list, use fastest working), set (use list as-is), status, clear.' }, to: { type: 'number', description: 'video seek: seconds; video rate: playback speed.' }, shots: { type: 'integer', description: 'video: also capture this many PNG frames (max 12).' }, every: { type: 'integer', description: 'video: milliseconds between frames (default 1000).' }, proxyChain: { type: 'string', description: 'proxy: comma-separated ip:port list — candidates for op "auto", or the exact chain for op "set" (2+ hops chain through the in-kit local forwarder).' }, chainTo: { type: 'string', description: 'proxy auto: chain this extra ip:port hop behind the winning proxy.' }, }, additionalProperties: false, }, output: { schema: { type: 'object' }, render: (args, value) => [{ type: 'text', text: JSON.stringify(value, null, 2) }], }, execute: async (args) => run(args), }); return () => { // Release the browser this plugin owns — or only the BiDi session when the // browser is borrowed. Killing the spawn handle alone is not enough for // Firefox (it is only the Windows launcher), so the browser could outlive // the host with its single BiDi session still registered. const ending = session; try { if (ending && ending.attached && ending.engine === 'bidi' && ending.bidiReady) { ending.ws.send(JSON.stringify({ id: nextId++, method: 'session.end', params: {} })); } else if (ending && !ending.attached && ending.ws.readyState === 1) { ending.ws.send(JSON.stringify({ id: nextId++, method: ending.engine === 'bidi' ? 'browser.close' : 'Browser.close', params: {} })); } } catch { /* already gone */ } try { ending?.child?.kill(); } catch { /* already gone */ } try { ending?.ws?.close(); } catch { /* already gone */ } session = null; lastElements = []; cfg = null; offSearch(); offFetch(); dispose(); stopChain(); }; }); }