@jackwener/opencli 1.0.0 → 1.0.3

package/dist/scripts/framework.js

@@ -0,0 +1,21 @@
+/**
+ * Injected script for detecting frontend frameworks (Vue, React, Next, Nuxt, etc.)
+ */
+export function detectFramework() {
+    const r = {};
+    try {
+        const app = document.querySelector('#app');
+        r.vue3 = !!(app && app.__vue_app__);
+        r.vue2 = !!(app && app.__vue__);
+        r.react = !!window.__REACT_DEVTOOLS_GLOBAL_HOOK__ || !!document.querySelector('[data-reactroot]');
+        r.nextjs = !!window.__NEXT_DATA__;
+        r.nuxt = !!window.__NUXT__;
+        if (r.vue3 && app.__vue_app__) {
+            const gp = app.__vue_app__.config?.globalProperties;
+            r.pinia = !!(gp && gp.$pinia);
+            r.vuex = !!(gp && gp.$store);
+        }
+    }
+    catch { }
+    return r;
+}

package/dist/scripts/interact.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Injected script for interactive fuzzing (clicking elements to trigger lazy loading)
+ */
+export declare function interactFuzz(): Promise<number>;

package/dist/scripts/interact.js

@@ -0,0 +1,20 @@
+/**
+ * Injected script for interactive fuzzing (clicking elements to trigger lazy loading)
+ */
+export async function interactFuzz() {
+    const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+    const clickables = Array.from(document.querySelectorAll('button, [role="button"], [role="tab"], .tab, .btn, a[href="javascript:void(0)"], a[href="#"]')).slice(0, 15); // limit to a small number to avoid endless loops
+    let clicked = 0;
+    for (const el of clickables) {
+        try {
+            const rect = el.getBoundingClientRect();
+            if (rect.width > 0 && rect.height > 0) {
+                el.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, view: window }));
+                clicked++;
+                await sleep(300); // give it time to trigger network
+            }
+        }
+        catch { }
+    }
+    return clicked;
+}

package/dist/scripts/store.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Injected script for discovering Pinia or Vuex stores and their actions/state representations
+ */
+export declare function discoverStores(): {
+    type: string;
+    id: string;
+    actions: string[];
+    stateKeys: string[];
+}[];

package/dist/scripts/store.js

@@ -0,0 +1,44 @@
+/**
+ * Injected script for discovering Pinia or Vuex stores and their actions/state representations
+ */
+export function discoverStores() {
+    const stores = [];
+    try {
+        const app = document.querySelector('#app');
+        if (!app?.__vue_app__)
+            return stores;
+        const gp = app.__vue_app__.config?.globalProperties;
+        // Pinia stores
+        const pinia = gp?.$pinia;
+        if (pinia?._s) {
+            pinia._s.forEach((store, id) => {
+                const actions = [];
+                const stateKeys = [];
+                for (const k in store) {
+                    try {
+                        if (k.startsWith('$') || k.startsWith('_'))
+                            continue;
+                        if (typeof store[k] === 'function')
+                            actions.push(k);
+                        else
+                            stateKeys.push(k);
+                    }
+                    catch { }
+                }
+                stores.push({ type: 'pinia', id, actions: actions.slice(0, 20), stateKeys: stateKeys.slice(0, 15) });
+            });
+        }
+        // Vuex store modules
+        const vuex = gp?.$store;
+        if (vuex?._modules?.root?._children) {
+            const children = vuex._modules.root._children;
+            for (const [modName, mod] of Object.entries(children)) {
+                const actions = Object.keys(mod._rawModule?.actions ?? {}).slice(0, 20);
+                const stateKeys = Object.keys(mod.state ?? {}).slice(0, 15);
+                stores.push({ type: 'vuex', id: modName, actions, stateKeys });
+            }
+        }
+    }
+    catch { }
+    return stores;
+}

package/dist/setup.js

@@ -7,7 +7,7 @@
 import chalk from 'chalk';
 import { checkDaemonStatus } from './browser/discover.js';
 import { checkConnectivity } from './doctor.js';
-import { PlaywrightMCP } from './browser/index.js';
+import { BrowserBridge } from './browser/index.js';
 export async function runSetup(opts = {}) {
     console.log();
     console.log(chalk.bold('  opencli setup') + chalk.dim(' — browser bridge configuration'));
@@ -23,7 +23,7 @@ export async function runSetup(opts = {}) {
         console.log(chalk.dim('    The daemon starts automatically when you run a browser command.'));
         console.log(chalk.dim('    Starting daemon now...'));
         // Try to spawn daemon
-        const mcp = new PlaywrightMCP();
+        const mcp = new BrowserBridge();
         try {
             await mcp.connect({ timeout: 5 });
             await mcp.close();

package/dist/synthesize.js

@@ -108,7 +108,7 @@ function buildEvaluateScript(url, itemPath, endpoint) {
     }
     return [
         '(async () => {',
-        `  const res = await fetch('${url}', {`,
+        `  const res = await fetch(${JSON.stringify(url)}, {`,
         `    credentials: 'include'`,
         '  });',
         '  const data = await res.json();',

package/extension/dist/background.js

@@ -0,0 +1,392 @@
+const DAEMON_PORT = 19825;
+const DAEMON_HOST = "localhost";
+const DAEMON_WS_URL = `ws://${DAEMON_HOST}:${DAEMON_PORT}/ext`;
+const WS_RECONNECT_BASE_DELAY = 2e3;
+const WS_RECONNECT_MAX_DELAY = 6e4;
+
+const attached = /* @__PURE__ */ new Set();
+async function ensureAttached(tabId) {
+  if (attached.has(tabId)) return;
+  try {
+    await chrome.debugger.attach({ tabId }, "1.3");
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (msg.includes("Another debugger is already attached")) {
+      try {
+        await chrome.debugger.detach({ tabId });
+      } catch {
+      }
+      try {
+        await chrome.debugger.attach({ tabId }, "1.3");
+      } catch {
+        throw new Error(`attach failed: ${msg}`);
+      }
+    } else {
+      throw new Error(`attach failed: ${msg}`);
+    }
+  }
+  attached.add(tabId);
+  try {
+    await chrome.debugger.sendCommand({ tabId }, "Runtime.enable");
+  } catch {
+  }
+}
+async function evaluate(tabId, expression) {
+  await ensureAttached(tabId);
+  const result = await chrome.debugger.sendCommand({ tabId }, "Runtime.evaluate", {
+    expression,
+    returnByValue: true,
+    awaitPromise: true
+  });
+  if (result.exceptionDetails) {
+    const errMsg = result.exceptionDetails.exception?.description || result.exceptionDetails.text || "Eval error";
+    throw new Error(errMsg);
+  }
+  return result.result?.value;
+}
+const evaluateAsync = evaluate;
+async function screenshot(tabId, options = {}) {
+  await ensureAttached(tabId);
+  const format = options.format ?? "png";
+  if (options.fullPage) {
+    const metrics = await chrome.debugger.sendCommand({ tabId }, "Page.getLayoutMetrics");
+    const size = metrics.cssContentSize || metrics.contentSize;
+    if (size) {
+      await chrome.debugger.sendCommand({ tabId }, "Emulation.setDeviceMetricsOverride", {
+        mobile: false,
+        width: Math.ceil(size.width),
+        height: Math.ceil(size.height),
+        deviceScaleFactor: 1
+      });
+    }
+  }
+  try {
+    const params = { format };
+    if (format === "jpeg" && options.quality !== void 0) {
+      params.quality = Math.max(0, Math.min(100, options.quality));
+    }
+    const result = await chrome.debugger.sendCommand({ tabId }, "Page.captureScreenshot", params);
+    return result.data;
+  } finally {
+    if (options.fullPage) {
+      await chrome.debugger.sendCommand({ tabId }, "Emulation.clearDeviceMetricsOverride").catch(() => {
+      });
+    }
+  }
+}
+function detach(tabId) {
+  if (!attached.has(tabId)) return;
+  attached.delete(tabId);
+  try {
+    chrome.debugger.detach({ tabId });
+  } catch {
+  }
+}
+function registerListeners() {
+  chrome.tabs.onRemoved.addListener((tabId) => {
+    attached.delete(tabId);
+  });
+  chrome.debugger.onDetach.addListener((source) => {
+    if (source.tabId) attached.delete(source.tabId);
+  });
+}
+
+let ws = null;
+let reconnectTimer = null;
+let reconnectAttempts = 0;
+const _origLog = console.log.bind(console);
+const _origWarn = console.warn.bind(console);
+const _origError = console.error.bind(console);
+function forwardLog(level, args) {
+  if (!ws || ws.readyState !== WebSocket.OPEN) return;
+  try {
+    const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+    ws.send(JSON.stringify({ type: "log", level, msg, ts: Date.now() }));
+  } catch {
+  }
+}
+console.log = (...args) => {
+  _origLog(...args);
+  forwardLog("info", args);
+};
+console.warn = (...args) => {
+  _origWarn(...args);
+  forwardLog("warn", args);
+};
+console.error = (...args) => {
+  _origError(...args);
+  forwardLog("error", args);
+};
+function connect() {
+  if (ws?.readyState === WebSocket.OPEN || ws?.readyState === WebSocket.CONNECTING) return;
+  try {
+    ws = new WebSocket(DAEMON_WS_URL);
+  } catch {
+    scheduleReconnect();
+    return;
+  }
+  ws.onopen = () => {
+    console.log("[opencli] Connected to daemon");
+    reconnectAttempts = 0;
+    if (reconnectTimer) {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+  };
+  ws.onmessage = async (event) => {
+    try {
+      const command = JSON.parse(event.data);
+      const result = await handleCommand(command);
+      ws?.send(JSON.stringify(result));
+    } catch (err) {
+      console.error("[opencli] Message handling error:", err);
+    }
+  };
+  ws.onclose = () => {
+    console.log("[opencli] Disconnected from daemon");
+    ws = null;
+    scheduleReconnect();
+  };
+  ws.onerror = () => {
+    ws?.close();
+  };
+}
+function scheduleReconnect() {
+  if (reconnectTimer) return;
+  reconnectAttempts++;
+  const delay = Math.min(WS_RECONNECT_BASE_DELAY * Math.pow(2, reconnectAttempts - 1), WS_RECONNECT_MAX_DELAY);
+  reconnectTimer = setTimeout(() => {
+    reconnectTimer = null;
+    connect();
+  }, delay);
+}
+let automationWindowId = null;
+let windowIdleTimer = null;
+const WINDOW_IDLE_TIMEOUT = 3e4;
+function resetWindowIdleTimer() {
+  if (windowIdleTimer) clearTimeout(windowIdleTimer);
+  windowIdleTimer = setTimeout(async () => {
+    if (automationWindowId !== null) {
+      try {
+        await chrome.windows.remove(automationWindowId);
+        console.log(`[opencli] Automation window ${automationWindowId} closed (idle timeout)`);
+      } catch {
+      }
+      automationWindowId = null;
+    }
+    windowIdleTimer = null;
+  }, WINDOW_IDLE_TIMEOUT);
+}
+async function getAutomationWindow() {
+  if (automationWindowId !== null) {
+    try {
+      await chrome.windows.get(automationWindowId);
+      return automationWindowId;
+    } catch {
+      automationWindowId = null;
+    }
+  }
+  const win = await chrome.windows.create({
+    url: "about:blank",
+    focused: false,
+    width: 1280,
+    height: 900,
+    type: "normal"
+  });
+  automationWindowId = win.id;
+  console.log(`[opencli] Created automation window ${automationWindowId}`);
+  return automationWindowId;
+}
+chrome.windows.onRemoved.addListener((windowId) => {
+  if (windowId === automationWindowId) {
+    console.log("[opencli] Automation window closed");
+    automationWindowId = null;
+    if (windowIdleTimer) {
+      clearTimeout(windowIdleTimer);
+      windowIdleTimer = null;
+    }
+  }
+});
+let initialized = false;
+function initialize() {
+  if (initialized) return;
+  initialized = true;
+  chrome.alarms.create("keepalive", { periodInMinutes: 0.4 });
+  registerListeners();
+  connect();
+  console.log("[opencli] OpenCLI extension initialized");
+}
+chrome.runtime.onInstalled.addListener(() => {
+  initialize();
+});
+chrome.runtime.onStartup.addListener(() => {
+  initialize();
+});
+chrome.alarms.onAlarm.addListener((alarm) => {
+  if (alarm.name === "keepalive") connect();
+});
+async function handleCommand(cmd) {
+  resetWindowIdleTimer();
+  try {
+    switch (cmd.action) {
+      case "exec":
+        return await handleExec(cmd);
+      case "navigate":
+        return await handleNavigate(cmd);
+      case "tabs":
+        return await handleTabs(cmd);
+      case "cookies":
+        return await handleCookies(cmd);
+      case "screenshot":
+        return await handleScreenshot(cmd);
+      case "close-window":
+        return await handleCloseWindow(cmd);
+      default:
+        return { id: cmd.id, ok: false, error: `Unknown action: ${cmd.action}` };
+    }
+  } catch (err) {
+    return {
+      id: cmd.id,
+      ok: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function isWebUrl(url) {
+  if (!url) return false;
+  return !url.startsWith("chrome://") && !url.startsWith("chrome-extension://");
+}
+async function resolveTabId(tabId) {
+  if (tabId !== void 0) return tabId;
+  const windowId = await getAutomationWindow();
+  const tabs = await chrome.tabs.query({ windowId });
+  const webTab = tabs.find((t) => t.id && isWebUrl(t.url));
+  if (webTab?.id) return webTab.id;
+  if (tabs.length > 0 && tabs[0]?.id) return tabs[0].id;
+  const newTab = await chrome.tabs.create({ windowId, url: "about:blank", active: true });
+  if (!newTab.id) throw new Error("Failed to create tab in automation window");
+  return newTab.id;
+}
+async function handleExec(cmd) {
+  if (!cmd.code) return { id: cmd.id, ok: false, error: "Missing code" };
+  const tabId = await resolveTabId(cmd.tabId);
+  try {
+    const data = await evaluateAsync(tabId, cmd.code);
+    return { id: cmd.id, ok: true, data };
+  } catch (err) {
+    return { id: cmd.id, ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function handleNavigate(cmd) {
+  if (!cmd.url) return { id: cmd.id, ok: false, error: "Missing url" };
+  const tabId = await resolveTabId(cmd.tabId);
+  await chrome.tabs.update(tabId, { url: cmd.url });
+  await new Promise((resolve) => {
+    chrome.tabs.get(tabId).then((tab2) => {
+      if (tab2.status === "complete") {
+        resolve();
+        return;
+      }
+      const listener = (id, info) => {
+        if (id === tabId && info.status === "complete") {
+          chrome.tabs.onUpdated.removeListener(listener);
+          resolve();
+        }
+      };
+      chrome.tabs.onUpdated.addListener(listener);
+      setTimeout(() => {
+        chrome.tabs.onUpdated.removeListener(listener);
+        resolve();
+      }, 15e3);
+    });
+  });
+  const tab = await chrome.tabs.get(tabId);
+  return { id: cmd.id, ok: true, data: { title: tab.title, url: tab.url, tabId } };
+}
+async function handleTabs(cmd) {
+  switch (cmd.op) {
+    case "list": {
+      const tabs = await chrome.tabs.query({});
+      const data = tabs.filter((t) => isWebUrl(t.url)).map((t, i) => ({
+        index: i,
+        tabId: t.id,
+        url: t.url,
+        title: t.title,
+        active: t.active
+      }));
+      return { id: cmd.id, ok: true, data };
+    }
+    case "new": {
+      const tab = await chrome.tabs.create({ url: cmd.url, active: true });
+      return { id: cmd.id, ok: true, data: { tabId: tab.id, url: tab.url } };
+    }
+    case "close": {
+      if (cmd.index !== void 0) {
+        const tabs = await chrome.tabs.query({});
+        const target = tabs[cmd.index];
+        if (!target?.id) return { id: cmd.id, ok: false, error: `Tab index ${cmd.index} not found` };
+        await chrome.tabs.remove(target.id);
+        detach(target.id);
+        return { id: cmd.id, ok: true, data: { closed: target.id } };
+      }
+      const tabId = await resolveTabId(cmd.tabId);
+      await chrome.tabs.remove(tabId);
+      detach(tabId);
+      return { id: cmd.id, ok: true, data: { closed: tabId } };
+    }
+    case "select": {
+      if (cmd.index === void 0 && cmd.tabId === void 0)
+        return { id: cmd.id, ok: false, error: "Missing index or tabId" };
+      if (cmd.tabId !== void 0) {
+        await chrome.tabs.update(cmd.tabId, { active: true });
+        return { id: cmd.id, ok: true, data: { selected: cmd.tabId } };
+      }
+      const tabs = await chrome.tabs.query({});
+      const target = tabs[cmd.index];
+      if (!target?.id) return { id: cmd.id, ok: false, error: `Tab index ${cmd.index} not found` };
+      await chrome.tabs.update(target.id, { active: true });
+      return { id: cmd.id, ok: true, data: { selected: target.id } };
+    }
+    default:
+      return { id: cmd.id, ok: false, error: `Unknown tabs op: ${cmd.op}` };
+  }
+}
+async function handleCookies(cmd) {
+  const details = {};
+  if (cmd.domain) details.domain = cmd.domain;
+  if (cmd.url) details.url = cmd.url;
+  const cookies = await chrome.cookies.getAll(details);
+  const data = cookies.map((c) => ({
+    name: c.name,
+    value: c.value,
+    domain: c.domain,
+    path: c.path,
+    secure: c.secure,
+    httpOnly: c.httpOnly,
+    expirationDate: c.expirationDate
+  }));
+  return { id: cmd.id, ok: true, data };
+}
+async function handleScreenshot(cmd) {
+  const tabId = await resolveTabId(cmd.tabId);
+  try {
+    const data = await screenshot(tabId, {
+      format: cmd.format,
+      quality: cmd.quality,
+      fullPage: cmd.fullPage
+    });
+    return { id: cmd.id, ok: true, data };
+  } catch (err) {
+    return { id: cmd.id, ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function handleCloseWindow(cmd) {
+  if (automationWindowId !== null) {
+    try {
+      await chrome.windows.remove(automationWindowId);
+    } catch {
+    }
+    automationWindowId = null;
+  }
+  return { id: cmd.id, ok: true, data: { closed: true } };
+}

package/extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
-  "name": "opencli Browser Bridge",
-  "version": "0.1.0",
+  "name": "OpenCLI",
+  "version": "0.2.0",
   "description": "Bridge between opencli CLI and your browser — execute commands, read cookies, manage tabs.",
   "permissions": [
     "debugger",
@@ -21,7 +21,7 @@
     "128": "icons/icon-128.png"
   },
   "action": {
-    "default_title": "opencli Browser Bridge",
+    "default_title": "OpenCLI",
     "default_icon": {
       "16": "icons/icon-16.png",
       "32": "icons/icon-32.png"

package/extension/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencli-extension",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "private": true,
   "type": "module",
   "scripts": {