@avasapp/agent-bridge 0.1.0

package/dist/adapters/zustand.cjs

@@ -0,0 +1,97 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/adapters/zustand.ts
+var zustand_exports = {};
+__export(zustand_exports, {
+  storeTools: () => storeTools
+});
+module.exports = __toCommonJS(zustand_exports);
+var snapshots = /* @__PURE__ */ new WeakMap();
+var isObject = (value) => typeof value === "object" && value !== null;
+function pick(value, path) {
+  if (!path) return value;
+  return path.split(".").reduce(
+    (v, k) => v?.[k],
+    value
+  );
+}
+function restore(store, snapshot) {
+  const current = store.getState();
+  if (!isObject(snapshot) || !isObject(current)) {
+    store.setState(snapshot, true);
+    return;
+  }
+  const actions = Object.fromEntries(
+    Object.entries(current).filter(([, v]) => typeof v === "function")
+  );
+  store.setState({ ...snapshot, ...actions }, true);
+}
+function storeTools(stores) {
+  const get = (name) => {
+    const store = stores[name];
+    if (!store)
+      throw new Error(
+        `Unknown store "${name}". Known: ${Object.keys(stores).join(", ")}`
+      );
+    return store;
+  };
+  const beforeChange = (store) => {
+    if (!snapshots.has(store)) snapshots.set(store, store.getState());
+  };
+  return {
+    "store.list": {
+      description: "Store names.",
+      run: () => Object.keys(stores)
+    },
+    "store.get": {
+      description: 'State of a store, or one dotted path inside it (e.g. "auth.isLoggedIn").',
+      run: (name, path) => pick(get(name).getState(), path)
+    },
+    "store.set": {
+      description: "Shallow-merge a partial into a store.",
+      run: (name, partial) => {
+        const store = get(name);
+        beforeChange(store);
+        store.setState(partial);
+        return store.getState();
+      }
+    },
+    "store.call": {
+      description: 'Call an action on a store, e.g. ("settings", "setColorScheme", "dark").',
+      run: (name, action, ...args) => {
+        const store = get(name);
+        const fn = store.getState()[action];
+        if (typeof fn !== "function")
+          throw new Error(`Store "${name}" has no action "${action}"`);
+        beforeChange(store);
+        return fn(...args);
+      }
+    },
+    "store.restore": {
+      description: "Undo the agent: put back each store changed with store.set or store.call. Returns their names.",
+      run: () => Object.entries(stores).flatMap(([name, store]) => {
+        if (!snapshots.has(store)) return [];
+        restore(store, snapshots.get(store));
+        snapshots.delete(store);
+        return [name];
+      })
+    }
+  };
+}

package/dist/adapters/zustand.d.cts

@@ -0,0 +1,15 @@
+import { T as Tools } from '../types-C6DUUHnB.cjs';
+
+/** Anything with zustand's store shape. */
+type StoreLike = {
+    getState: () => unknown;
+    /**
+     * `replace: true` swaps the whole state, as zustand's setState does. Method
+     * syntax, so zustand's overloads (replace: false | true) still fit.
+     */
+    setState(partial: Record<string, unknown>, replace?: boolean): void;
+};
+/** Read, merge into, and call actions on named stores. */
+declare function storeTools(stores: Record<string, StoreLike>): Tools;
+
+export { type StoreLike, storeTools };

package/dist/chunk-UEWFQWCY.js

@@ -0,0 +1,575 @@
+// src/client/discover.ts
+var DEFAULT_METRO = "localhost:8081";
+function metroHost(metro) {
+  return (metro ?? process.env.AGENT_BRIDGE_METRO ?? DEFAULT_METRO).replace(/^https?:\/\//, "").replace(/\/+$/, "");
+}
+async function expoHostUri(metro) {
+  try {
+    const res = await fetch(`http://${metro}/`, {
+      headers: {
+        "expo-platform": "ios",
+        accept: "application/expo+json,application/json"
+      },
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!res.ok) return null;
+    const manifest = await res.json();
+    return manifest.extra?.expoClient?.hostUri ?? manifest.extra?.expoGo?.debuggerHost ?? manifest.hostUri ?? null;
+  } catch {
+    return null;
+  }
+}
+async function listCdpTargets(metro) {
+  const res = await fetch(`http://${metro}/json/list`, {
+    signal: AbortSignal.timeout(3e3)
+  });
+  if (!res.ok)
+    throw new Error(
+      `Metro at ${metro} answered /json/list with HTTP ${res.status}`
+    );
+  return await res.json();
+}
+function pickOne(items, filter, label) {
+  const matching = filter ? items.filter(
+    (item) => label(item).toLowerCase().includes(filter.toLowerCase())
+  ) : items;
+  const connected = items.map(label).join("; ") || "none";
+  if (matching.length === 0) {
+    throw new Error(
+      filter ? `No app matches "${filter}". Connected: ${connected}` : "No app is connected to Metro."
+    );
+  }
+  if (matching.length > 1 && !filter) {
+    throw new Error(
+      `${matching.length} apps are connected; pick one with --device. Connected: ${connected}`
+    );
+  }
+  return matching[0];
+}
+
+// src/shared/protocol.ts
+var RUNTIME_MARKER = "@avasapp/agent-bridge/runtime";
+var PLUGIN_NAME = "agent-bridge";
+var CDP_GLOBAL = "__AGENT_BRIDGE__";
+var CDP_REPLY_BINDING = "__agentBridgeReply";
+function toAsciiJson(value) {
+  return JSON.stringify(value).replace(
+    /[\u007f-￿]/g,
+    (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`
+  );
+}
+
+// src/client/connection.ts
+import WebSocket from "ws";
+function openSocket(url, headers) {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(url, headers ? { headers } : void 0);
+    let opened = false;
+    ws.on("error", (event) => {
+      if (opened) return;
+      const message = event?.message ?? String(event);
+      reject(new Error(`Could not open ${url}: ${message}`));
+    });
+    ws.once("close", () => {
+      if (!opened) reject(new Error(`${url} closed before opening`));
+    });
+    ws.once("open", () => {
+      opened = true;
+      resolve(ws);
+    });
+  });
+}
+var newCallId = () => `c${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+function createPending() {
+  const waiting = /* @__PURE__ */ new Map();
+  return {
+    wait(id, tool, timeoutMs) {
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          waiting.delete(id);
+          reject(new Error(`No reply to "${tool}" within ${timeoutMs} ms`));
+        }, timeoutMs);
+        waiting.set(id, (result) => {
+          clearTimeout(timer);
+          waiting.delete(id);
+          resolve(result);
+        });
+      });
+    },
+    settle(result) {
+      waiting.get(result.id)?.(result);
+    },
+    failAll(reason) {
+      for (const [id, done] of waiting) {
+        done({ id, from: "", ok: false, error: reason, ms: 0 });
+      }
+    }
+  };
+}
+
+// src/client/expo.ts
+var deviceLabel = (d) => `${d.name} (${d.platform}, ${d.deviceId})`;
+async function openBroadcast(metro, discoveryMs) {
+  const ws = await openSocket(`ws://${metro}/expo-dev-plugins/broadcast`);
+  const devices = /* @__PURE__ */ new Map();
+  const pending = createPending();
+  ws.on("message", (data, isBinary) => {
+    if (isBinary) return;
+    let frame;
+    try {
+      frame = JSON.parse(String(data));
+    } catch {
+      return;
+    }
+    if (frame.messageKey?.pluginName !== PLUGIN_NAME) return;
+    if (frame.messageKey.method === "hello:reply") {
+      const info = frame.payload;
+      devices.set(info.deviceId, info);
+    } else if (frame.messageKey.method === "result") {
+      pending.settle(frame.payload);
+    }
+  });
+  ws.on("close", () => pending.failAll("Expo's dev-tools socket closed"));
+  const send = (method, payload) => ws.send(
+    JSON.stringify({
+      messageKey: { pluginName: PLUGIN_NAME, method },
+      payload
+    })
+  );
+  send("hello", {});
+  await new Promise((r) => setTimeout(r, discoveryMs));
+  return { ws, devices, pending, send };
+}
+async function listExpoDevices(metro, discoveryMs = 600) {
+  const { ws, devices } = await openBroadcast(metro, discoveryMs);
+  ws.close();
+  return [...devices.values()];
+}
+async function connectExpo(metro, device, discoveryMs = 600) {
+  const { ws, devices, pending, send } = await openBroadcast(metro, discoveryMs);
+  let info;
+  try {
+    info = pickOne([...devices.values()], device, deviceLabel);
+  } catch (error) {
+    ws.close();
+    throw error;
+  }
+  return {
+    transport: "expo",
+    device: info,
+    call(tool, args, timeoutMs) {
+      const call = {
+        id: newCallId(),
+        tool,
+        args,
+        to: info.deviceId
+      };
+      const reply = pending.wait(call.id, tool, timeoutMs);
+      send("call", call);
+      return reply;
+    },
+    close: () => ws.close()
+  };
+}
+
+// src/client/cdp.ts
+import WebSocket2 from "ws";
+var targetLabel = (t) => `${t.title}${t.deviceName ? ` [${t.deviceName}]` : ""}`;
+async function connectCdp(metro, device) {
+  const target = pickOne(await listCdpTargets(metro), device, targetLabel);
+  const hostUri = await expoHostUri(metro);
+  const port = metro.split(":")[1] ?? "8081";
+  const origin = hostUri ? `http://${hostUri}` : `http://localhost:${port}`;
+  const closedEarly = `Metro closed the debugger socket. Origin sent: ${origin}. Is that the host Metro advertises?`;
+  const ws = await openSocket(target.webSocketDebuggerUrl, {
+    Origin: origin
+  }).catch(() => {
+    throw new Error(closedEarly);
+  });
+  let seq = 0;
+  let answered = false;
+  const commands = /* @__PURE__ */ new Map();
+  const pending = createPending();
+  ws.on("message", (data) => {
+    const message = JSON.parse(String(data));
+    if (message.id && commands.has(message.id)) {
+      answered = true;
+      commands.get(message.id)?.resolve(message);
+      commands.delete(message.id);
+    } else if (message.method === "Runtime.bindingCalled" && message.params?.name === CDP_REPLY_BINDING) {
+      pending.settle(JSON.parse(message.params.payload));
+    }
+  });
+  ws.on("close", () => {
+    const reason = answered ? "The debugger socket closed" : closedEarly;
+    for (const command of commands.values()) command.reject(new Error(reason));
+    commands.clear();
+    pending.failAll(reason);
+  });
+  const send = (method, params = {}) => new Promise((resolve, reject) => {
+    if (ws.readyState !== WebSocket2.OPEN) {
+      reject(new Error(answered ? "The debugger socket closed" : closedEarly));
+      return;
+    }
+    const id = ++seq;
+    commands.set(id, { resolve, reject });
+    ws.send(JSON.stringify({ id, method, params }));
+  });
+  const evaluate = async (expression) => {
+    const message = await send("Runtime.evaluate", {
+      expression,
+      returnByValue: true
+    });
+    const details = message.result?.exceptionDetails;
+    if (details) {
+      const text = details.exception?.description ?? details.text ?? "evaluation failed";
+      throw new Error(text.split("\n")[0]);
+    }
+    return message.result?.result?.value;
+  };
+  await send("Runtime.enable");
+  await send("Runtime.addBinding", { name: CDP_REPLY_BINDING });
+  let info;
+  try {
+    info = JSON.parse(
+      String(await evaluate(`${CDP_GLOBAL}.info()`))
+    );
+  } catch {
+    ws.close();
+    throw new Error(
+      `agent-bridge isn't running in ${targetLabel(target)}. Is useAgentBridge mounted in a dev build?`
+    );
+  }
+  return {
+    transport: "cdp",
+    device: { ...info, name: `${info.name} (${targetLabel(target)})` },
+    async call(tool, args, timeoutMs) {
+      const call = { id: newCallId(), tool, args };
+      const reply = pending.wait(call.id, tool, timeoutMs);
+      try {
+        await evaluate(
+          `${CDP_GLOBAL}.dispatch(${JSON.stringify(toAsciiJson(call))})`
+        );
+      } catch (error) {
+        pending.settle({
+          id: call.id,
+          from: info.deviceId,
+          ok: false,
+          error: String(error),
+          ms: 0
+        });
+      }
+      return reply;
+    },
+    close: () => ws.close()
+  };
+}
+
+// src/client/open.ts
+async function openConnection(options = {}) {
+  const metro = metroHost(options.metro);
+  const want = options.transport ?? "auto";
+  let expoError;
+  if (want !== "cdp") {
+    try {
+      return await connectExpo(metro, options.device);
+    } catch (error) {
+      if (want === "expo") throw error;
+      expoError = error;
+    }
+  }
+  try {
+    return await connectCdp(metro, options.device);
+  } catch (error) {
+    const expoNote = expoError ? ` (Expo socket: ${String(expoError)})` : "";
+    throw new Error(
+      `${error instanceof Error ? error.message : String(error)}${expoNote}`
+    );
+  }
+}
+
+// src/client/session/client.ts
+import { createConnection } from "net";
+import { createInterface } from "readline";
+
+// src/client/session/state.ts
+import { createHash } from "crypto";
+import {
+  chmodSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { tmpdir, userInfo } from "os";
+import { join } from "path";
+var uid = () => process.getuid?.() ?? userInfo().username;
+function privateDir(dir) {
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  const stat = lstatSync(dir);
+  if (!stat.isDirectory())
+    throw new Error(`${dir} is not a directory; remove it and retry`);
+  if (process.getuid && stat.uid !== process.getuid())
+    throw new Error(`${dir} belongs to another user; refusing to use it`);
+  if (process.platform !== "win32" && (stat.mode & 63) !== 0)
+    chmodSync(dir, 448);
+  return dir;
+}
+function stateDir() {
+  return privateDir(
+    process.env.AGENT_BRIDGE_STATE_DIR ?? (process.env.XDG_RUNTIME_DIR ? join(process.env.XDG_RUNTIME_DIR, "agent-bridge") : join(tmpdir(), `agent-bridge-${uid()}`))
+  );
+}
+var shortHash = (text) => createHash("sha256").update(text).digest("hex").slice(0, 16);
+function socketPath(name, dir) {
+  if (process.platform === "win32")
+    return `\\\\.\\pipe\\agent-bridge-${shortHash(dir)}-${name}`;
+  const path = join(dir, `${name}.sock`);
+  if (Buffer.byteLength(path) <= 100) return path;
+  const short = privateDir(`/tmp/agent-bridge-${uid()}`);
+  return join(short, `${shortHash(path)}.sock`);
+}
+var sessionFiles = (name, dir = stateDir()) => ({
+  state: join(dir, `${name}.json`),
+  error: join(dir, `${name}.error`),
+  log: join(dir, `${name}.log`),
+  socket: socketPath(name, dir)
+});
+function checkName(name) {
+  if (!/^[\w.-]{1,40}$/.test(name))
+    throw new Error(
+      `Session name "${name}" must be 1-40 letters, digits, ".", "_" or "-"`
+    );
+  return name;
+}
+function parseDuration(text) {
+  const match = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h)?$/.exec(text.trim());
+  if (!match) throw new Error(`Can't read duration "${text}"; try 15m or 90s`);
+  const units = { s: 1e3, m: 6e4, h: 36e5 };
+  return Math.round(Number(match[1]) * (units[match[2] ?? "ms"] ?? 1));
+}
+function formatDuration(ms) {
+  const s = Math.max(0, Math.round(ms / 1e3));
+  if (s < 60) return `${s}s`;
+  if (s < 3600)
+    return `${Math.floor(s / 60)}m${String(s % 60).padStart(2, "0")}s`;
+  return `${Math.floor(s / 3600)}h${String(Math.floor(s / 60) % 60).padStart(2, "0")}m`;
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function writePrivate(file, text) {
+  writeFileSync(file, text, { mode: 384 });
+}
+function removeSessionFiles(name, dir = stateDir()) {
+  const files = sessionFiles(name, dir);
+  rmSync(files.state, { force: true });
+  if (process.platform !== "win32") rmSync(files.socket, { force: true });
+}
+function readState(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function listSessions(dir = stateDir()) {
+  const live = [];
+  for (const entry of readdirSync(dir)) {
+    if (!entry.endsWith(".json")) continue;
+    const state = readState(join(dir, entry));
+    if (!state) continue;
+    if (isAlive(state.pid)) live.push(state);
+    else removeSessionFiles(state.name, dir);
+  }
+  return live.sort((a, b) => a.startedAt - b.startedAt);
+}
+function readSession(name, dir = stateDir()) {
+  return listSessions(dir).find((s) => s.name === name) ?? null;
+}
+function pickSession(filter) {
+  if (filter.name) {
+    const named = readSession(checkName(filter.name));
+    if (!named) throw new Error(`No session named "${filter.name}" is running`);
+    return named;
+  }
+  const device = filter.device?.toLowerCase();
+  const matching = listSessions().filter(
+    (s) => s.metro === filter.metro && (!device || s.device.name.toLowerCase().includes(device) || s.device.deviceId.toLowerCase().includes(device)) && (!filter.transport || filter.transport === "auto" || filter.transport === s.transport)
+  );
+  return matching.length === 1 ? matching[0] : null;
+}
+
+// src/client/session/client.ts
+function openSessionLink(state) {
+  return new Promise((resolve, reject) => {
+    const socket = createConnection(state.socket);
+    const waiting = /* @__PURE__ */ new Map();
+    let seq = 0;
+    let open = false;
+    const gone = `Session "${state.name}" closed the connection`;
+    socket.once("connect", () => {
+      open = true;
+      resolve({
+        request: (req) => new Promise((done, fail) => {
+          if (socket.destroyed || socket.writableEnded) {
+            fail(new Error(gone));
+            return;
+          }
+          const id = ++seq;
+          waiting.set(id, done);
+          socket.write(`${JSON.stringify({ ...req, id })}
+`);
+        }),
+        close: () => socket.end()
+      });
+    });
+    socket.on("error", (error) => {
+      if (!open)
+        reject(
+          new Error(
+            `Session "${state.name}" isn't answering on ${state.socket}: ${error.message}`
+          )
+        );
+    });
+    socket.on("close", () => {
+      for (const [id, done] of waiting) done({ id, error: gone });
+      waiting.clear();
+    });
+    createInterface({ input: socket }).on("line", (line) => {
+      const res = JSON.parse(line);
+      waiting.get(res.id)?.(res);
+      waiting.delete(res.id);
+    });
+  });
+}
+async function sessionRequest(state, req) {
+  const link = await openSessionLink(state);
+  try {
+    return await link.request(req);
+  } finally {
+    link.close();
+  }
+}
+async function connectSession(options = {}) {
+  const state = pickSession({
+    name: options.name ?? process.env.AGENT_BRIDGE_SESSION,
+    metro: metroHost(options.metro),
+    device: options.device,
+    transport: options.transport
+  });
+  if (!state)
+    throw new Error(
+      "No single session matches. Start one with `agent-bridge session start`, or name it."
+    );
+  const link = await openSessionLink(state);
+  const info = await link.request({ op: "info" });
+  if (info.error || !info.device || !info.transport) {
+    link.close();
+    throw new Error(info.error ?? `Session "${state.name}" sent no device`);
+  }
+  const device = info.device;
+  const timed = async (tool, ...args) => {
+    const res = await link.request({
+      op: "call",
+      tool,
+      args,
+      timeoutMs: options.timeoutMs
+    });
+    if (res.error || !res.result) throw new Error(res.error ?? "No result");
+    const result = res.result;
+    const logs = result.logs ?? [];
+    if (!result.ok) throw new AgentBridgeCallError(tool, result.error, logs);
+    const { id: _id, from: _from, ok: _ok, ms: appMs, value, ...extra } = result;
+    return { ...extra, value, ms: res.ms ?? 0, appMs, logs };
+  };
+  return {
+    session: info.state ?? state,
+    transport: info.transport,
+    device,
+    timed,
+    call: async (tool, ...args) => (await timed(tool, ...args)).value,
+    tools: () => device.tools,
+    close: link.close
+  };
+}
+
+// src/client/index.ts
+var AgentBridgeCallError = class extends Error {
+  constructor(tool, message, logs = []) {
+    super(`${tool}: ${message}`);
+    this.tool = tool;
+    this.logs = logs;
+    this.name = "AgentBridgeCallError";
+  }
+  tool;
+  logs;
+};
+async function connect(options = {}) {
+  const timeoutMs = options.timeoutMs ?? 1e4;
+  const conn = await openConnection(options);
+  const timed = async (tool, ...args) => {
+    const t0 = performance.now();
+    const result = await conn.call(tool, args, timeoutMs);
+    const ms = performance.now() - t0;
+    const logs = result.logs ?? [];
+    if (!result.ok) throw new AgentBridgeCallError(tool, result.error, logs);
+    return { value: result.value, ms, appMs: result.ms, logs };
+  };
+  return {
+    transport: conn.transport,
+    device: conn.device,
+    timed,
+    call: async (tool, ...args) => (await timed(tool, ...args)).value,
+    tools: () => conn.device.tools,
+    close: conn.close
+  };
+}
+async function listDevices(options = {}) {
+  const metro = metroHost(options.metro);
+  const [expo, cdp] = await Promise.all([
+    listExpoDevices(metro).catch(() => []),
+    listCdpTargets(metro).catch(() => [])
+  ]);
+  return [
+    ...expo.map((d) => ({
+      transport: "expo",
+      name: d.name,
+      deviceId: d.deviceId,
+      tools: d.tools.length
+    })),
+    ...cdp.map((t) => ({
+      transport: "cdp",
+      name: `${t.title}${t.deviceName ? ` [${t.deviceName}]` : ""}`
+    }))
+  ];
+}
+
+export {
+  metroHost,
+  RUNTIME_MARKER,
+  openConnection,
+  stateDir,
+  sessionFiles,
+  checkName,
+  parseDuration,
+  formatDuration,
+  isAlive,
+  writePrivate,
+  removeSessionFiles,
+  listSessions,
+  readSession,
+  pickSession,
+  sessionRequest,
+  connectSession,
+  AgentBridgeCallError,
+  connect,
+  listDevices
+};