claude4arc 0.5.0

package/host/host.js

@@ -0,0 +1,368 @@
+import net from "node:net";
+import fs from "node:fs";
+import { execFileSync } from "node:child_process";
+import { STATE_DIR, LOG_PATH } from "../lib/paths.js";
+import { browserForExecutable, socketPath, LEGACY_SOCKET } from "../lib/browsers.js";
+import { rotateLog, pruneScreenshots, pruneTempFiles } from "../lib/housekeeping.js";
+import { blockedBy, readBlocklist } from "../lib/blocklist.js";
+
+fs.mkdirSync(STATE_DIR, { recursive: true, mode: 0o700 });
+await rotateLog().catch(() => {});
+pruneScreenshots().catch(() => {});
+pruneTempFiles().catch(() => {});
+
+function log(...parts) {
+  fs.appendFileSync(LOG_PATH, `${new Date().toISOString()} ${parts.join(" ")}\n`);
+}
+
+let extensionInfo = null;
+let nextId = 1;
+const pending = new Map();
+const clients = new Set();
+const attached = new Set();
+const dialogs = new Map();
+const autoDialogTabs = new Set();
+const handledDialogs = new Map();
+const sessions = new Map();
+const shims = new Map();
+const autoAttached = new Set();
+const shimScripts = new Map();
+
+const debuggee = (tabId, sessionId) => (sessionId ? { tabId, sessionId } : tabId);
+const send = (tabId, sessionId, method, params = {}) => callExtension("debugger.send", [debuggee(tabId, sessionId), method, params]);
+
+const popupLinks = new Map();
+
+const POPUP_SHIM = `(() => {
+  if (Object.prototype.hasOwnProperty.call(window, "__arcOpenerLink")) return;
+  Object.defineProperty(window, "__arcOpenerLink", { value: true });
+  const send = (payload) => {
+    try {
+      window.__arcOpener(JSON.stringify(payload));
+    } catch {}
+  };
+  const opener = {
+    closed: false,
+    focus() {},
+    blur() {},
+    postMessage(data, targetOrigin) {
+      send({ type: "message", data, targetOrigin: String(targetOrigin ?? "*"), origin: location.origin });
+    },
+  };
+  Object.defineProperty(window, "opener", { get: () => opener, set() {}, configurable: true });
+  window.close = function close() {
+    send({ type: "close" });
+  };
+})();`;
+
+const OPENER_CALL = `function (action, id, data, origin) {
+  const shim = globalThis.__arcShim;
+  if (!shim) return false;
+  if (action === "deliver") return shim.deliver(id, data, origin);
+  if (action === "close") return shim.closeStub(id);
+  if (action === "url") return shim.setStubUrl(id, data);
+  return false;
+}`;
+
+async function linkPopup(popupTabId, link) {
+  await attach(popupTabId);
+  popupLinks.set(popupTabId, link);
+  await send(popupTabId, null, "Page.enable").catch(() => {});
+  await send(popupTabId, null, "Runtime.enable").catch(() => {});
+  await send(popupTabId, null, "Runtime.addBinding", { name: "__arcOpener" });
+  await send(popupTabId, null, "Page.addScriptToEvaluateOnNewDocument", { source: POPUP_SHIM, runImmediately: true });
+  return true;
+}
+
+async function callOpener(link, action, data = null, origin = null) {
+  const global = await send(link.tabId, null, "Runtime.evaluate", { expression: "globalThis" }).catch(() => null);
+  const objectId = global?.result?.objectId;
+  if (!objectId) return;
+  await send(link.tabId, null, "Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration: OPENER_CALL,
+    arguments: [{ value: action }, { value: link.stubId }, { value: data }, { value: origin }],
+    returnByValue: true,
+  }).catch(() => {});
+  await send(link.tabId, null, "Runtime.releaseObject", { objectId }).catch(() => {});
+}
+
+function onPopupEvent(message) {
+  const link = popupLinks.get(message.tabId);
+  if (!link || message.sessionId) return;
+  if (message.method === "Runtime.bindingCalled" && message.params.name === "__arcOpener") {
+    let payload;
+    try {
+      payload = JSON.parse(message.params.payload);
+    } catch {
+      return;
+    }
+    if (payload.type === "message") callOpener(link, "deliver", payload.data, payload.origin);
+    if (payload.type === "close") {
+      callOpener(link, "close");
+      callExtension("tabs.remove", [message.tabId]).catch(() => {});
+    }
+  }
+  if (message.method === "Page.frameNavigated" && !message.params.frame?.parentId) callOpener(link, "url", message.params.frame.url);
+}
+
+async function injectShim(tabId, sessionId) {
+  const shim = shims.get(tabId);
+  if (!shim) return;
+  if (!sessionId) {
+    await send(tabId, null, "Page.setInterceptFileChooserDialog", { enabled: true }).catch(() => {});
+    await send(tabId, null, "Emulation.setFocusEmulationEnabled", { enabled: true }).catch(() => {});
+  }
+  const key = `${tabId}:${sessionId ?? "root"}`;
+  const previous = shimScripts.get(key);
+  if (previous?.source === shim) return;
+  if (previous) await send(tabId, sessionId, "Page.removeScriptToEvaluateOnNewDocument", { identifier: previous.identifier }).catch(() => {});
+  await send(tabId, sessionId, "Page.enable").catch(() => {});
+  const result = await send(tabId, sessionId, "Page.addScriptToEvaluateOnNewDocument", { source: shim, runImmediately: true }).catch(() => null);
+  if (result?.identifier) shimScripts.set(key, { source: shim, identifier: result.identifier });
+}
+
+async function prepareSession(tabId, sessionId) {
+  await send(tabId, sessionId, "Target.setAutoAttach", { autoAttach: true, waitForDebuggerOnStart: false, flatten: true }).catch(() => {});
+  await injectShim(tabId, sessionId);
+}
+
+async function enableAutoAttach(tabId, refresh) {
+  if (autoAttached.has(tabId) && !refresh) return;
+  autoAttached.add(tabId);
+  if (refresh) {
+    sessions.delete(tabId);
+    await send(tabId, null, "Target.setAutoAttach", { autoAttach: false, waitForDebuggerOnStart: false, flatten: true }).catch(() => {});
+  }
+  await send(tabId, null, "Target.setAutoAttach", { autoAttach: true, waitForDebuggerOnStart: false, flatten: true }).catch(() => {});
+}
+
+function forgetTab(tabId) {
+  attached.delete(tabId);
+  dialogs.delete(tabId);
+  autoDialogTabs.delete(tabId);
+  handledDialogs.delete(tabId);
+  sessions.delete(tabId);
+  shims.delete(tabId);
+  autoAttached.delete(tabId);
+  for (const key of shimScripts.keys()) if (key.startsWith(`${tabId}:`)) shimScripts.delete(key);
+  popupLinks.delete(tabId);
+}
+
+function sendToExtension(message) {
+  const body = Buffer.from(JSON.stringify(message));
+  const header = Buffer.alloc(4);
+  header.writeUInt32LE(body.length, 0);
+  process.stdout.write(Buffer.concat([header, body]));
+}
+
+function sendToClient(client, message) {
+  if (!client.destroyed) client.write(JSON.stringify(message) + "\n");
+}
+
+function callExtension(api, args) {
+  return new Promise((resolve, reject) => {
+    const id = nextId++;
+    pending.set(id, { resolve, reject });
+    sendToExtension({ id, api, args });
+  });
+}
+
+function onExtensionMessage(message) {
+  if (message.type === "hello") {
+    extensionInfo = { version: message.version, connectedAt: new Date().toISOString() };
+    log("extension hello", message.version);
+    return;
+  }
+  if (message.type) {
+    if (message.type === "tabRemoved" && popupLinks.has(message.tabId)) callOpener(popupLinks.get(message.tabId), "close");
+    if (message.type === "detached" || message.type === "tabRemoved") forgetTab(message.tabId);
+    if (message.type === "event") onPopupEvent(message);
+    if (message.method === "Page.frameNavigated" && !message.sessionId && !message.params.frame?.parentId && autoDialogTabs.has(message.tabId)) {
+      const pattern = blockedBy(message.params.frame.url, readBlocklist());
+      if (pattern) {
+        log("blocked", message.tabId, pattern);
+        send(message.tabId, null, "Page.navigate", { url: "about:blank" }).catch(() => {});
+      }
+    }
+    if (message.method === "Target.attachedToTarget") {
+      const info = message.params.targetInfo;
+      const tabSessions = sessions.get(message.tabId) ?? new Map();
+      for (const [sessionId, entry] of tabSessions) if (entry.targetId === info.targetId) tabSessions.delete(sessionId);
+      tabSessions.set(message.params.sessionId, { sessionId: message.params.sessionId, targetId: info.targetId, type: info.type, url: info.url, parent: message.sessionId ?? null });
+      sessions.set(message.tabId, tabSessions);
+      if (info.type === "iframe") prepareSession(message.tabId, message.params.sessionId);
+    }
+    if (message.method === "Target.detachedFromTarget") {
+      sessions.get(message.tabId)?.delete(message.params.sessionId);
+      shimScripts.delete(`${message.tabId}:${message.params.sessionId}`);
+    }
+    if (message.method === "Page.javascriptDialogOpening") {
+      if (autoDialogTabs.has(message.tabId)) {
+        const accept = message.params.type === "beforeunload";
+        send(message.tabId, message.sessionId, "Page.handleJavaScriptDialog", { accept }).catch(() => {});
+        const log = handledDialogs.get(message.tabId) ?? [];
+        log.push({ type: message.params.type, message: message.params.message, accepted: accept, native: true });
+        handledDialogs.set(message.tabId, log.slice(-20));
+      } else {
+        dialogs.set(message.tabId, message.params);
+      }
+    }
+    if (message.method === "Page.javascriptDialogClosed") dialogs.delete(message.tabId);
+    if (message.method === "Page.fileChooserOpened" && autoDialogTabs.has(message.tabId)) {
+      const log = handledDialogs.get(message.tabId) ?? [];
+      log.push({ type: "filechooser", message: "", accepted: false, native: true });
+      handledDialogs.set(message.tabId, log.slice(-20));
+    }
+    for (const client of clients) sendToClient(client, message);
+    return;
+  }
+  const entry = pending.get(message.id);
+  if (!entry) return;
+  pending.delete(message.id);
+  if (message.error) entry.reject(new Error(message.error));
+  else entry.resolve(message.result);
+}
+
+let buffer = Buffer.alloc(0);
+process.stdin.on("data", (chunk) => {
+  buffer = Buffer.concat([buffer, chunk]);
+  while (buffer.length >= 4) {
+    const length = buffer.readUInt32LE(0);
+    if (buffer.length < 4 + length) break;
+    const body = buffer.subarray(4, 4 + length).toString("utf8");
+    buffer = buffer.subarray(4 + length);
+    try {
+      onExtensionMessage(JSON.parse(body));
+    } catch (error) {
+      log("bad message from extension", error.message);
+    }
+  }
+});
+
+process.stdin.on("end", () => {
+  log("extension disconnected");
+  shutdown();
+});
+
+async function attach(tabId) {
+  if (attached.has(tabId)) {
+    await enableAutoAttach(tabId, false);
+    return { already: true };
+  }
+  try {
+    await callExtension("debugger.attach", [tabId]);
+    attached.add(tabId);
+    await enableAutoAttach(tabId, false);
+    return { already: false };
+  } catch (error) {
+    if (!/already attached/i.test(error.message)) throw error;
+    attached.add(tabId);
+    await enableAutoAttach(tabId, true);
+    return { already: true };
+  }
+}
+
+async function onClientRequest(client, request) {
+  const { id, api, args = [] } = request;
+  try {
+    let result;
+    if (api === "host.status") {
+      result = { host: { pid: process.pid, node: process.version, browser: BROWSER }, extension: extensionInfo, attached: [...attached] };
+    } else if (api === "host.dialog") {
+      result = dialogs.get(args[0]) ?? null;
+    } else if (api === "host.autoDialogs") {
+      if (args[1]) {
+        autoDialogTabs.add(args[0]);
+        if (args[2]) shims.set(args[0], args[2]);
+        await injectShim(args[0], null);
+        for (const sessionId of sessions.get(args[0])?.keys() ?? []) await injectShim(args[0], sessionId);
+      } else {
+        autoDialogTabs.delete(args[0]);
+        shims.delete(args[0]);
+      }
+      result = true;
+    } else if (api === "host.linkPopup") {
+      result = await linkPopup(args[0], args[1]);
+    } else if (api === "host.sessions") {
+      result = [...(sessions.get(args[0])?.values() ?? [])];
+    } else if (api === "host.handledDialogs") {
+      result = handledDialogs.get(args[0]) ?? [];
+      handledDialogs.delete(args[0]);
+    } else if (api === "debugger.attach") {
+      result = await attach(args[0]);
+    } else {
+      if (api === "debugger.detach") forgetTab(args[0]);
+      result = await callExtension(api, args);
+      if (api === "debugger.send" && args[1] === "Page.handleJavaScriptDialog") dialogs.delete(args[0]);
+    }
+    sendToClient(client, { id, result });
+  } catch (error) {
+    sendToClient(client, { id, error: error.message });
+  }
+}
+
+function onClientClose(client) {
+  clients.delete(client);
+}
+
+function launchingBrowser() {
+  if (process.env.CLAUDE4ARC_HOST_BROWSER) return process.env.CLAUDE4ARC_HOST_BROWSER;
+  try {
+    const executable = execFileSync("ps", ["-o", "comm=", "-p", String(process.ppid)], { encoding: "utf8" }).trim();
+    return browserForExecutable(executable)?.key ?? "browser";
+  } catch {
+    return "browser";
+  }
+}
+
+const BROWSER = launchingBrowser();
+const SOCKET_PATH = socketPath(BROWSER);
+
+try {
+  fs.unlinkSync(SOCKET_PATH);
+} catch {}
+try {
+  if (BROWSER === "arc" && fs.lstatSync(LEGACY_SOCKET).isSocket()) fs.unlinkSync(LEGACY_SOCKET);
+} catch {}
+
+const server = net.createServer((client) => {
+  clients.add(client);
+  let text = "";
+  client.setEncoding("utf8");
+  client.on("data", (chunk) => {
+    text += chunk;
+    let index;
+    while ((index = text.indexOf("\n")) >= 0) {
+      const line = text.slice(0, index);
+      text = text.slice(index + 1);
+      if (!line.trim()) continue;
+      try {
+        onClientRequest(client, JSON.parse(line));
+      } catch (error) {
+        log("bad message from client", error.message);
+      }
+    }
+  });
+  client.on("close", () => onClientClose(client));
+  client.on("error", () => {});
+});
+
+let socketInode = null;
+
+server.listen(SOCKET_PATH, () => {
+  fs.chmodSync(SOCKET_PATH, 0o600);
+  socketInode = fs.statSync(SOCKET_PATH).ino;
+  log("host listening", process.pid, BROWSER);
+});
+
+function shutdown() {
+  server.close();
+  try {
+    if (fs.statSync(SOCKET_PATH).ino === socketInode) fs.unlinkSync(SOCKET_PATH);
+  } catch {}
+  process.exit(0);
+}
+
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);

package/lib/blocklist.js

@@ -0,0 +1,52 @@
+import { readConfig, updateConfig, CONFIG_PATH } from "./config.js";
+
+export { CONFIG_PATH };
+
+export function normalizePattern(raw) {
+  const value = String(raw ?? "")
+    .trim()
+    .toLowerCase()
+    .replace(/^[a-z][a-z0-9+.-]*:\/\//, "")
+    .replace(/^\*\./, "")
+    .replace(/^www\./, "")
+    .replace(/\/+$/, "");
+  if (!value || /\s/.test(value) || value.startsWith("/")) throw new Error(`Not a site pattern: "${raw}". Use a domain such as chase.com or mail.google.com/mail.`);
+  return value;
+}
+
+export function blockedBy(url, patterns) {
+  if (!patterns?.length) return null;
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return null;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+  const host = parsed.hostname.toLowerCase();
+  const pathname = parsed.pathname.toLowerCase();
+  for (const pattern of patterns) {
+    const slash = pattern.indexOf("/");
+    const domain = slash < 0 ? pattern : pattern.slice(0, slash);
+    const prefix = slash < 0 ? "" : pattern.slice(slash);
+    const hostMatches = host === domain || host.endsWith(`.${domain}`);
+    if (hostMatches && (!prefix || pathname === prefix || pathname.startsWith(prefix.endsWith("/") ? prefix : `${prefix}/`))) return pattern;
+  }
+  return null;
+}
+
+export function readBlocklist() {
+  const list = readConfig().blockedSites;
+  return Array.isArray(list) ? list.filter((item) => typeof item === "string") : [];
+}
+
+export function writeBlocklist(list) {
+  return updateConfig({ blockedSites: [...new Set(list)].sort() }).blockedSites;
+}
+
+export function blockedError(url, pattern) {
+  const error = new Error(`${url} is on the claude4arc blocklist (${pattern}). Ask the user to do this themselves.`);
+  error.fatal = true;
+  error.blocked = true;
+  return error;
+}

package/lib/browsers.js

@@ -0,0 +1,56 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { STATE_DIR } from "./paths.js";
+
+const SUPPORT = path.join(os.homedir(), "Library", "Application Support");
+
+export const BROWSERS = [
+  { key: "arc", name: "Arc", bundle: "Arc.app", process: "Arc", hostDirs: ["Google/Chrome"], extensionsPage: "arc://extensions" },
+  { key: "dia", name: "Dia", bundle: "Dia.app", process: "Dia", hostDirs: ["Google/Chrome", "Dia/User Data"], extensionsPage: "chrome://extensions" },
+  { key: "chrome", name: "Google Chrome", bundle: "Google Chrome.app", process: "Google Chrome", hostDirs: ["Google/Chrome"], extensionsPage: "chrome://extensions" },
+  { key: "brave", name: "Brave", bundle: "Brave Browser.app", process: "Brave Browser", hostDirs: ["BraveSoftware/Brave-Browser"], extensionsPage: "brave://extensions" },
+  { key: "edge", name: "Microsoft Edge", bundle: "Microsoft Edge.app", process: "Microsoft Edge", hostDirs: ["Microsoft Edge"], extensionsPage: "edge://extensions" },
+  { key: "chromium", name: "Chromium", bundle: "Chromium.app", process: "Chromium", hostDirs: ["Chromium"], extensionsPage: "chrome://extensions" },
+];
+
+export const LEGACY_SOCKET = path.join(STATE_DIR, "bridge.sock");
+
+export function browserByKey(key) {
+  const browser = BROWSERS.find((item) => item.key === String(key ?? "").toLowerCase());
+  if (!browser) throw new Error(`Unknown browser "${key}". Supported: ${BROWSERS.map((item) => item.key).join(", ")}.`);
+  return browser;
+}
+
+export function browserForExecutable(executable) {
+  return BROWSERS.find((browser) => String(executable ?? "").includes(`/${browser.bundle}/`)) ?? null;
+}
+
+export function hostManifestDirs(browser) {
+  return browser.hostDirs.map((dir) => path.join(SUPPORT, dir, "NativeMessagingHosts"));
+}
+
+export function isInstalled(browser) {
+  return [path.join("/Applications", browser.bundle), path.join(os.homedir(), "Applications", browser.bundle)].some((app) => fs.existsSync(app));
+}
+
+export function installedBrowsers() {
+  return BROWSERS.filter(isInstalled);
+}
+
+export function socketPath(key) {
+  return path.join(STATE_DIR, `${key}.sock`);
+}
+
+export function socketCandidates(preferred) {
+  if (preferred) {
+    const browser = browserByKey(preferred);
+    return browser.key === "arc" ? [socketPath("arc"), LEGACY_SOCKET] : [socketPath(browser.key)];
+  }
+  return [...BROWSERS.map((browser) => socketPath(browser.key)), LEGACY_SOCKET];
+}
+
+export function browserOfSocket(file) {
+  if (file === LEGACY_SOCKET) return "arc";
+  return path.basename(file, ".sock");
+}

package/lib/client.js

@@ -0,0 +1,89 @@
+import fs from "node:fs";
+import net from "node:net";
+import { browserByKey, browserOfSocket, socketCandidates } from "./browsers.js";
+
+export class BridgeError extends Error {}
+
+function connectTo(file) {
+  return new Promise((resolve, reject) => {
+    const socket = net.createConnection(file);
+    socket.once("connect", () => resolve(socket));
+    socket.once("error", reject);
+  });
+}
+
+export class Bridge {
+  static async connect({ browser } = {}) {
+    const preferred = browser ?? process.env.CLAUDE4ARC_BROWSER ?? null;
+    const candidates = socketCandidates(preferred).filter((file) => fs.existsSync(file));
+    let lastError = null;
+    for (const file of candidates) {
+      try {
+        return new Bridge(await connectTo(file), browserOfSocket(file));
+      } catch (error) {
+        lastError = error;
+      }
+    }
+    const name = preferred ? browserByKey(preferred).name : "Arc or another supported browser";
+    if (!lastError || lastError.code === "ENOENT" || lastError.code === "ECONNREFUSED") {
+      throw new BridgeError(
+        `The claude4arc bridge is not running. Make sure ${name} is open and the "claude4arc" extension is enabled. Run \`claude4arc doctor\` for details.`,
+      );
+    }
+    throw new BridgeError(`Cannot connect to the claude4arc bridge: ${lastError.message}`);
+  }
+
+  constructor(socket, browser = "arc") {
+    this.socket = socket;
+    this.browser = browser;
+    this.nextId = 1;
+    this.pending = new Map();
+    this.listeners = new Set();
+    let text = "";
+    socket.setEncoding("utf8");
+    socket.on("data", (chunk) => {
+      text += chunk;
+      let index;
+      while ((index = text.indexOf("\n")) >= 0) {
+        const line = text.slice(0, index);
+        text = text.slice(index + 1);
+        if (line.trim()) this.#dispatch(JSON.parse(line));
+      }
+    });
+    socket.on("close", () => {
+      for (const { reject } of this.pending.values()) {
+        reject(new BridgeError("The claude4arc bridge connection closed"));
+      }
+      this.pending.clear();
+    });
+  }
+
+  #dispatch(message) {
+    if (message.type) {
+      for (const listener of this.listeners) listener(message);
+      return;
+    }
+    const entry = this.pending.get(message.id);
+    if (!entry) return;
+    this.pending.delete(message.id);
+    if (message.error) entry.reject(new BridgeError(message.error));
+    else entry.resolve(message.result);
+  }
+
+  call(api, ...args) {
+    return new Promise((resolve, reject) => {
+      const id = this.nextId++;
+      this.pending.set(id, { resolve, reject });
+      this.socket.write(JSON.stringify({ id, api, args }) + "\n");
+    });
+  }
+
+  on(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  close() {
+    this.socket.end();
+  }
+}