@avasapp/agent-bridge 0.1.0

package/dist/runtime/index.cjs

@@ -0,0 +1,933 @@
+"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/runtime/index.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  RUNTIME_MARKER: () => RUNTIME_MARKER,
+  cdpTransport: () => cdpTransport,
+  settle: () => settle,
+  startAgentBridge: () => startAgentBridge,
+  useAgentBridge: () => useAgentBridge
+});
+module.exports = __toCommonJS(runtime_exports);
+var import_react = require("react");
+var import_react_native2 = require("react-native");
+
+// src/shared/protocol.ts
+var PROTOCOL_VERSION = 1;
+var RUNTIME_MARKER = "@avasapp/agent-bridge/runtime";
+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/runtime/tools/bridge.ts
+function bridgeTools(listTools) {
+  return {
+    "bridge.ping": {
+      description: "Round-trip check. Returns the app clock.",
+      run: () => ({ pong: true, at: Date.now() })
+    },
+    "bridge.tools": {
+      description: "Every tool this app exposes.",
+      run: listTools
+    }
+  };
+}
+
+// src/runtime/tools/logs.ts
+function logTools(logs) {
+  return {
+    "bridge.logs": {
+      description: 'Errors and warnings the app logged, newest last. Options: {level: "error"|"warn"|"all", limit, clear}.',
+      run: (options = {}) => {
+        const entries = logs.read(options);
+        if (options.clear) logs.clear();
+        return entries;
+      }
+    }
+  };
+}
+
+// src/runtime/tools/restore.ts
+var SUFFIX = ".restore";
+var SELF = "bridge.restore";
+function restoreTools(getTools) {
+  return {
+    [SELF]: {
+      description: "Undo what the agent changed: runs every *.restore tool in name order and returns each result or error.",
+      run: async () => {
+        const tools = getTools();
+        const results = {};
+        const names = Object.keys(tools).filter((name) => name.endsWith(SUFFIX) && name !== SELF).sort();
+        for (const name of names) {
+          const definition = tools[name];
+          const run = typeof definition === "function" ? definition : definition.run;
+          try {
+            results[name] = await run();
+          } catch (error) {
+            results[name] = {
+              error: error instanceof Error ? error.message : String(error)
+            };
+          }
+        }
+        return results;
+      }
+    }
+  };
+}
+
+// src/runtime/tools/screen.ts
+var import_react_native = require("react-native");
+
+// src/runtime/find-text-core.ts
+var HOST_COMPONENT = 5;
+var HOST_TEXT = 6;
+function fiberRoots(hook2) {
+  if (!hook2?.getFiberRoots) return [];
+  const roots = [];
+  for (const id of hook2.renderers.keys()) {
+    for (const root of hook2.getFiberRoots(id)) roots.push(root.current);
+  }
+  return roots;
+}
+function measureHost(host) {
+  const node = host.stateNode;
+  if (node && "getBoundingClientRect" in node) {
+    const displayed = node.checkVisibility ? node.checkVisibility() : (node.getClientRects?.().length ?? 1) > 0;
+    if (!displayed) return null;
+    const r = node.getBoundingClientRect();
+    return { x: r.x, y: r.y, width: r.width, height: r.height };
+  }
+  const ui = globalThis.nativeFabricUIManager;
+  const shadowNode = node?.node;
+  if (!ui || !shadowNode) return null;
+  let rect = null;
+  ui.measureInWindow(shadowNode, (x, y, width, height) => {
+    rect = { x, y, width, height };
+  });
+  return rect;
+}
+function textOf(fiber) {
+  if (fiber.tag === HOST_TEXT && typeof fiber.memoizedProps === "string") {
+    let host = fiber.return;
+    while (host && host.tag !== HOST_COMPONENT) host = host.return;
+    return { text: fiber.memoizedProps, host };
+  }
+  const children = fiber.memoizedProps?.children;
+  if (fiber.tag === HOST_COMPONENT && !fiber.child && (typeof children === "string" || typeof children === "number")) {
+    return { text: String(children), host: fiber };
+  }
+  return null;
+}
+function inActiveScreen(fiber) {
+  for (let f = fiber; f; f = f.return) {
+    if (f.tag !== HOST_COMPONENT) continue;
+    const props = f.memoizedProps;
+    if (props?.activityState === 0) return false;
+  }
+  return true;
+}
+function findTextInTree(roots, text, window, options = {}) {
+  const stack = [...roots];
+  const matches = [];
+  while (stack.length) {
+    const fiber = stack.pop();
+    const found = textOf(fiber);
+    if (found && (options.exact ? found.text === text : found.text.includes(text))) {
+      const rect = found.host ? measureHost(found.host) : null;
+      const onScreen = !!rect && inActiveScreen(fiber) && rect.width > 0 && rect.height > 0 && rect.x < window.width && rect.y < window.height && rect.x + rect.width > 0 && rect.y + rect.height > 0;
+      matches.push({ text: found.text, rect, onScreen });
+    }
+    if (fiber.child) stack.push(fiber.child);
+    if (fiber.sibling) stack.push(fiber.sibling);
+  }
+  return {
+    found: matches.length,
+    onScreen: matches.filter((m) => m.onScreen).length,
+    matches
+  };
+}
+
+// src/runtime/screen/elements.ts
+var propsOf = (fiber) => fiber.memoizedProps && typeof fiber.memoizedProps === "object" ? fiber.memoizedProps : null;
+var isFn = (v) => typeof v === "function";
+var isInputProps = (p) => isFn(p.onChangeText) || isFn(p.onChange) && ("value" in p || "defaultValue" in p || "placeholder" in p);
+var interesting = (p) => isFn(p.onPress) || isInputProps(p) || typeof p.testID === "string";
+var ICON_GLYPHS = /[\uE000-\uF8FF]/g;
+function firstHost(fiber) {
+  if (fiber.tag === HOST_COMPONENT) return fiber;
+  const stack = fiber.child ? [fiber.child] : [];
+  while (stack.length) {
+    const f = stack.pop();
+    if (f.tag === HOST_COMPONENT) return f;
+    if (f.sibling) stack.push(f.sibling);
+    if (f.child) stack.push(f.child);
+  }
+  return null;
+}
+function absorb(rec, fiber, p) {
+  const e = rec.element;
+  if (!rec.input && isInputProps(p)) rec.input = fiber;
+  if (!rec.press && isFn(p.onPress)) rec.press = fiber;
+  const fill = (key, v) => {
+    if (e[key] === void 0 && typeof v === "string") e[key] = v;
+  };
+  fill("testID", p.testID);
+  fill("label", p.accessibilityLabel ?? p["aria-label"]);
+  fill("role", p.accessibilityRole ?? p.role);
+  fill("placeholder", p.placeholder);
+  if (e.value === void 0 && ("value" in p || "defaultValue" in p)) {
+    const v = p.value ?? p.defaultValue;
+    if (v != null) e.value = String(v);
+  }
+  if (rec.maxLength === void 0 && typeof p.maxLength === "number")
+    rec.maxLength = p.maxLength;
+  if (p.editable === false || p.readOnly === true) e.editable = false;
+  const state = p.accessibilityState;
+  if (p.disabled === true || state?.disabled === true || p["aria-disabled"] === true)
+    e.disabled = true;
+}
+function isOnScreen(rect, window) {
+  return !!rect && rect.width > 0 && rect.height > 0 && rect.x < window.width && rect.y < window.height && rect.x + rect.width > 0 && rect.y + rect.height > 0;
+}
+var round = (r) => r && {
+  x: Math.round(r.x),
+  y: Math.round(r.y),
+  width: Math.round(r.width),
+  height: Math.round(r.height)
+};
+var handles = (control, p, name) => !!control && isFn(p[name]) && propsOf(control)?.[name] === p[name];
+function sameControl(rec, p) {
+  for (let r = rec; r; r = r.parent) {
+    if (!r.press && !r.input) continue;
+    const same = handles(r.press, p, "onPress") || handles(r.input, p, "onChangeText") || handles(r.input, p, "onChange");
+    return same ? r : null;
+  }
+  return null;
+}
+function absorbChain(rec, fiber, host) {
+  for (let f = fiber; f; f = f.child) {
+    const p = propsOf(f);
+    if (p) absorb(rec, f, p);
+    if (f === host) break;
+  }
+}
+function collectElements(roots, window) {
+  const byHost = /* @__PURE__ */ new Map();
+  const order = [];
+  const recFor = (fiber, host, parent) => {
+    let rec = byHost.get(host);
+    if (rec) return rec;
+    rec = {
+      element: { kind: "view", rect: null },
+      onScreen: false,
+      fiber,
+      host,
+      press: null,
+      input: null,
+      parent,
+      parts: []
+    };
+    absorbChain(rec, fiber, host);
+    byHost.set(host, rec);
+    order.push(rec);
+    return rec;
+  };
+  const buttonOf = (rec) => {
+    for (let r = rec; r; r = r.parent) if (r.press) return r;
+    return null;
+  };
+  const stack = roots.map((fiber) => ({ fiber, rec: null }));
+  while (stack.length) {
+    const { fiber, rec: parentRec } = stack.pop();
+    if (fiber.sibling) stack.push({ fiber: fiber.sibling, rec: parentRec });
+    const p = propsOf(fiber);
+    if (fiber.tag === HOST_COMPONENT && p?.activityState === 0) continue;
+    let rec = parentRec;
+    if (p && interesting(p)) {
+      const host = firstHost(fiber);
+      const same = host && !byHost.has(host) ? sameControl(parentRec, p) : null;
+      if (host && same) {
+        byHost.set(host, same);
+        same.host = host;
+        absorbChain(same, fiber, host);
+        rec = same;
+      } else if (host) {
+        rec = recFor(fiber, host, parentRec);
+        absorb(rec, fiber, p);
+      }
+    }
+    const found = textOf(fiber);
+    if (found?.host) {
+      const owner = buttonOf(rec) ?? recFor(found.host, found.host, rec);
+      const last = owner.parts[owner.parts.length - 1];
+      if (last?.host === found.host) last.text += found.text;
+      else owner.parts.push({ host: found.host, text: found.text });
+    }
+    if (fiber.child) stack.push({ fiber: fiber.child, rec });
+  }
+  for (const rec of order) {
+    const e = rec.element;
+    const text = rec.parts.map((part) => part.text.replace(ICON_GLYPHS, "").replace(/\s+/g, " ").trim()).filter(Boolean).join(" ");
+    if (text) e.text = text;
+    e.kind = rec.input ? "input" : rec.press ? "button" : rec.parts.length ? "text" : "view";
+    if (e.kind === "input" && e.editable === void 0) e.editable = true;
+    const rect = measureHost(rec.host);
+    e.rect = round(rect);
+    rec.onScreen = isOnScreen(rect, window);
+  }
+  return order.filter(
+    (rec) => rec.element.kind !== "text" || rec.element.text !== void 0
+  );
+}
+function pressFiberOf(found) {
+  if (found.press) return found.press;
+  for (let f = found.fiber.return; f; f = f.return) {
+    const p = propsOf(f);
+    if (p && isFn(p.onPress)) return f;
+  }
+  return null;
+}
+
+// src/runtime/screen/targets.ts
+function tiers(target) {
+  if (typeof target === "string") {
+    return [
+      (e) => e.testID === target,
+      (e) => e.label === target,
+      (e) => e.placeholder === target,
+      (e) => e.text === target,
+      (e) => !!e.text?.includes(target)
+    ];
+  }
+  const { testID, label, placeholder, text } = target;
+  const fields = (e) => (testID === void 0 || e.testID === testID) && (label === void 0 || e.label === label) && (placeholder === void 0 || e.placeholder === placeholder);
+  if (text === void 0) return [fields];
+  return [
+    (e) => fields(e) && e.text === text,
+    (e) => fields(e) && !!e.text?.includes(text)
+  ];
+}
+function matchTarget(found, target) {
+  for (const test of tiers(target)) {
+    const matches = found.filter((f) => test(f.element));
+    if (matches.length) return matches;
+  }
+  return [];
+}
+var indexOf = (target) => typeof target === "object" ? target.index : void 0;
+var clip = (s) => s.length > 40 ? `${s.slice(0, 39)}\u2026` : s;
+function describe(e) {
+  const bits = [e.kind];
+  if (e.testID) bits.push(`#${e.testID}`);
+  if (e.text) bits.push(JSON.stringify(clip(e.text)));
+  if (e.label && e.label !== e.text) bits.push(`label=${JSON.stringify(clip(e.label))}`);
+  if (e.placeholder) bits.push(`placeholder=${JSON.stringify(clip(e.placeholder))}`);
+  if (e.value !== void 0) bits.push(`value=${JSON.stringify(clip(e.value))}`);
+  if (e.disabled) bits.push("disabled");
+  return bits.join(" ");
+}
+var showTarget = (target) => JSON.stringify(target);
+function onScreenSummary(found, max = 15) {
+  const on = found.filter((f) => f.onScreen);
+  if (!on.length) return "nothing";
+  const shown = on.slice(0, max).map((f) => describe(f.element));
+  if (on.length > max) shown.push(`+${on.length - max} more`);
+  return shown.join("; ");
+}
+function resolveTarget(found, target, prefer) {
+  let matches = matchTarget(
+    found.filter((f) => f.onScreen),
+    target
+  );
+  if (!matches.length) {
+    const hidden = matchTarget(found, target)[0];
+    if (hidden)
+      throw new Error(
+        `${showTarget(target)} matches ${describe(hidden.element)}, which is not on screen`
+      );
+    throw new Error(
+      `Nothing on screen matches ${showTarget(target)}. On screen: ${onScreenSummary(found)}`
+    );
+  }
+  const preferred = prefer ? matches.filter(prefer) : [];
+  if (preferred.length) matches = preferred;
+  const index = indexOf(target);
+  if (index !== void 0) {
+    const pick = matches[index];
+    if (!pick)
+      throw new Error(
+        `${showTarget(target)} has ${matches.length} match(es); index ${index} is out of range`
+      );
+    return pick;
+  }
+  if (matches.length > 1) {
+    const list = matches.slice(0, 10).map((f, i) => `${i}: ${describe(f.element)}`).join("; ");
+    throw new Error(
+      `${showTarget(target)} matches ${matches.length} elements; pass { index } or a narrower target. ${list}`
+    );
+  }
+  return matches[0];
+}
+
+// src/runtime/screen/actions.ts
+var handler = (fiber, name) => {
+  const fn = propsOf(fiber)?.[name];
+  return typeof fn === "function" ? fn : null;
+};
+var noop = () => {
+};
+var event = (nativeEvent, target) => ({
+  nativeEvent,
+  target,
+  currentTarget: target,
+  timeStamp: Date.now(),
+  preventDefault: noop,
+  stopPropagation: noop,
+  isDefaultPrevented: () => false,
+  isPropagationStopped: () => false,
+  persist: noop
+});
+var eventCount = 0;
+function fillInput(found, text, options = {}) {
+  const input = found.input;
+  if (!input) throw new Error(`${describe(found.element)} is not a text input`);
+  if (found.element.editable === false)
+    throw new Error(`${describe(found.element)} is not editable`);
+  const { maxLength } = found;
+  const value = maxLength === void 0 ? text : text.slice(0, Math.max(0, maxLength));
+  const target = { value };
+  handler(input, "onFocus")?.(event({ text: value }, target));
+  handler(input, "onChangeText")?.(value);
+  eventCount += 1;
+  handler(input, "onChange")?.(event({ text: value, eventCount }, target));
+  if (options.submit)
+    handler(input, "onSubmitEditing")?.(event({ text: value }, target));
+  handler(input, "onBlur")?.(event({ text: value }, target));
+  return value;
+}
+var center = (rect) => rect ? { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 } : { x: 0, y: 0 };
+function pressElement(found) {
+  const fiber = pressFiberOf(found);
+  if (!fiber) throw new Error(`${describe(found.element)} has no onPress`);
+  if (found.element.disabled || propsOf(fiber)?.disabled === true)
+    throw new Error(`${describe(found.element)} is disabled`);
+  const { x, y } = center(found.element.rect);
+  const e = () => event({
+    locationX: found.element.rect ? found.element.rect.width / 2 : 0,
+    locationY: found.element.rect ? found.element.rect.height / 2 : 0,
+    pageX: x,
+    pageY: y,
+    timestamp: Date.now()
+  });
+  handler(fiber, "onPressIn")?.(e());
+  handler(fiber, "onPress")?.(e());
+  handler(fiber, "onPressOut")?.(e());
+}
+
+// src/runtime/screen/settle.ts
+var STATE = /* @__PURE__ */ Symbol.for("@avasapp/agent-bridge/commits");
+var UPDATE_LANES = (1 << 22) - 1;
+var hook = () => globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+var now = () => performance.now();
+function install() {
+  const h = hook();
+  if (!h) return null;
+  const current = h.onCommitFiberRoot;
+  const existing = current?.[STATE];
+  if (existing) return existing;
+  const state = { commits: 0, listeners: /* @__PURE__ */ new Set() };
+  const wrapped = function(...args) {
+    state.commits += 1;
+    for (const listener of state.listeners) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+    return current?.apply(this, args);
+  };
+  Object.defineProperty(wrapped, STATE, { value: state });
+  h.onCommitFiberRoot = wrapped;
+  return state;
+}
+function onCommit(listener) {
+  const state = install();
+  state?.listeners.add(listener);
+  return () => state?.listeners.delete(listener);
+}
+function busy() {
+  const h = hook();
+  if (!h?.renderers || !h.getFiberRoots) return false;
+  for (const id of h.renderers.keys()) {
+    for (const root of h.getFiberRoots(id)) {
+      const pending = root.pendingLanes;
+      if (typeof pending !== "number") continue;
+      if (pending & ~(root.suspendedLanes ?? 0) & UPDATE_LANES) return true;
+    }
+  }
+  return false;
+}
+var frame = () => new Promise((resolve) => {
+  const raf = globalThis.requestAnimationFrame;
+  if (raf) raf(() => resolve());
+  else setTimeout(resolve, 16);
+});
+async function settle(options = {}) {
+  const maxMs = options.maxMs ?? 500;
+  const t0 = now();
+  const state = install();
+  const start = state?.commits ?? 0;
+  const result = () => ({
+    commits: (state?.commits ?? 0) - start,
+    ms: Math.round((now() - t0) * 100) / 100
+  });
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  if (!state) return result();
+  let seen = state.commits;
+  if (seen === start && !busy()) return result();
+  while (now() - t0 < maxMs) {
+    await frame();
+    if (state.commits === seen && !busy()) break;
+    seen = state.commits;
+  }
+  return result();
+}
+
+// src/runtime/screen/wait-for.ts
+var POLL_MS = 50;
+function waitForTarget(collect, target, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 5e3;
+  const t0 = performance.now();
+  const ms = () => Math.round((performance.now() - t0) * 100) / 100;
+  return new Promise((resolve, reject) => {
+    let queued = false;
+    let finished = false;
+    const finish = () => {
+      finished = true;
+      unsubscribe();
+      clearInterval(timer);
+    };
+    const check = () => {
+      queued = false;
+      if (finished) return;
+      try {
+        const found = collect();
+        const matches = matchTarget(
+          found.filter((f) => f.onScreen),
+          target
+        );
+        const hit = matches[indexOf(target) ?? 0];
+        if (options.gone ? !hit : hit) {
+          finish();
+          resolve(hit ? { ms: ms(), element: hit.element } : { ms: ms() });
+        } else if (performance.now() - t0 >= timeoutMs) {
+          finish();
+          const what = options.gone ? "to disappear" : "to appear";
+          reject(
+            new Error(
+              `Timed out after ${timeoutMs} ms waiting for ${showTarget(target)} ${what}. On screen: ${onScreenSummary(found)}`
+            )
+          );
+        }
+      } catch (error) {
+        finish();
+        reject(error);
+      }
+    };
+    const unsubscribe = onCommit(() => {
+      if (queued) return;
+      queued = true;
+      void Promise.resolve().then(check);
+    });
+    const timer = setInterval(check, POLL_MS);
+    check();
+  });
+}
+
+// src/runtime/screen/index.ts
+function createScreen(env) {
+  const collect = () => collectElements(env.roots(), env.window());
+  const refresh = (found) => {
+    const node = found.host.stateNode;
+    const again = collect().find(
+      (f) => f.host === found.host || node != null && f.host.stateNode === node
+    );
+    return (again ?? found).element;
+  };
+  return {
+    snapshot(options = {}) {
+      const found = collect();
+      if (!options.all)
+        return { elements: found.filter((f) => f.onScreen).map((f) => f.element) };
+      return {
+        elements: found.map((f) => ({ ...f.element, onScreen: f.onScreen }))
+      };
+    },
+    async fill(target, text, options = {}) {
+      const found = resolveTarget(collect(), target, (f) => !!f.input);
+      const filled = fillInput(found, String(text), options);
+      await settle();
+      return { filled, element: refresh(found) };
+    },
+    async press(target) {
+      const found = resolveTarget(collect(), target, (f) => !!f.press);
+      pressElement(found);
+      await settle();
+      return found.element;
+    },
+    waitFor: (target, options) => waitForTarget(collect, target, options)
+  };
+}
+
+// src/runtime/tools/screen.ts
+var devToolsHook = () => globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+function screenTools() {
+  const screen = createScreen({
+    roots: () => fiberRoots(devToolsHook()),
+    window: () => import_react_native.Dimensions.get("window")
+  });
+  return {
+    "screen.findText": {
+      description: "Find rendered text (substring, or exact with {exact:true}) and whether it is on screen. Ignores inactive tabs and screens.",
+      run: (text, options) => findTextInTree(
+        fiberRoots(devToolsHook()),
+        text,
+        import_react_native.Dimensions.get("window"),
+        options
+      )
+    },
+    "screen.snapshot": {
+      description: "Buttons, inputs, text and testID views on screen, with rects. {all:true} adds off-screen ones.",
+      run: (options) => screen.snapshot(options)
+    },
+    "screen.fill": {
+      description: "Type into an input by testID, label, placeholder or text, then wait for the render. {submit:true} also submits.",
+      run: (target, text, options) => screen.fill(target, text, options)
+    },
+    "screen.press": {
+      description: "Press a button by testID, label or text, then wait for the render.",
+      run: (target) => screen.press(target)
+    },
+    "screen.waitFor": {
+      description: "Wait until a target is on screen, or gone with {gone:true}. Default timeout 5000 ms.",
+      run: (target, options) => screen.waitFor(target, options)
+    }
+  };
+}
+
+// src/runtime/builtin-tools.ts
+function builtinTools(listTools, getTools, logs) {
+  return {
+    ...bridgeTools(listTools),
+    ...logTools(logs),
+    ...restoreTools(getTools),
+    ...screenTools()
+  };
+}
+
+// src/runtime/cdp-transport.ts
+function cdpTransport() {
+  return {
+    name: "cdp",
+    start(context) {
+      const g = globalThis;
+      const entry = {
+        info: () => toAsciiJson(context.info()),
+        dispatch: (payload) => {
+          const call = JSON.parse(payload);
+          void context.dispatch(call).then((result) => {
+            const reply = g[CDP_REPLY_BINDING];
+            if (typeof reply === "function") reply(toAsciiJson(result));
+          });
+          return call.id;
+        }
+      };
+      g[CDP_GLOBAL] = entry;
+      return () => {
+        if (g[CDP_GLOBAL] === entry) delete g[CDP_GLOBAL];
+      };
+    }
+  };
+}
+
+// src/runtime/logs.ts
+var CAPACITY = 200;
+var STACK_LINES = 10;
+var MESSAGE_CHARS = 2e3;
+function createLogCapture(now2 = Date.now) {
+  const buffer = [];
+  const running = [];
+  let seq = 0;
+  let sent = 0;
+  let lastTool;
+  return {
+    record(level, args) {
+      const entry = { level, ...formatArgs(args), at: now2() };
+      const during = running[running.length - 1];
+      if (during) entry.during = during;
+      else if (lastTool) entry.after = lastTool;
+      buffer.push({ seq: ++seq, entry });
+      if (buffer.length > CAPACITY) buffer.shift();
+    },
+    begin(tool) {
+      running.push(tool);
+      let done = false;
+      return () => {
+        if (done) return;
+        done = true;
+        running.splice(running.lastIndexOf(tool), 1);
+        lastTool = tool;
+      };
+    },
+    takeErrors() {
+      const since = sent;
+      sent = seq;
+      return buffer.filter((b) => b.seq > since && b.entry.level === "error").map((b) => b.entry);
+    },
+    read({ level = "all", limit } = {}) {
+      const entries = buffer.map((b) => b.entry).filter((e) => level === "all" || e.level === level);
+      return limit !== void 0 ? entries.slice(-limit) : entries;
+    },
+    clear() {
+      buffer.length = 0;
+    }
+  };
+}
+function formatArgs(args) {
+  const rest = [...args];
+  const parts = [];
+  if (typeof rest[0] === "string" && rest[0].includes("%")) {
+    const format = rest.shift();
+    parts.push(
+      format.replace(/%([sdifoOc%])/g, (match, type) => {
+        if (type === "%") return "%";
+        if (!rest.length) return match;
+        const arg = rest.shift();
+        if (type === "c") return "";
+        if (type === "d" || type === "i") return String(Math.trunc(Number(arg)));
+        if (type === "f") return String(Number(arg));
+        return describe2(arg);
+      })
+    );
+  }
+  parts.push(...rest.map(describe2));
+  const error = args.find((a) => a instanceof Error);
+  const message = parts.join(" ");
+  return {
+    message: message.length > MESSAGE_CHARS ? `${message.slice(0, MESSAGE_CHARS)}...` : message,
+    ...error?.stack ? { stack: trimStack(error.stack) } : {}
+  };
+}
+function describe2(value) {
+  if (typeof value === "string") return value;
+  if (value instanceof Error) return `${value.name}: ${value.message}`;
+  if (value === void 0 || typeof value === "function") return String(value);
+  try {
+    const json = JSON.stringify(value);
+    if (json === void 0) return String(value);
+    return json.length > 200 ? `${json.slice(0, 200)}...` : json;
+  } catch {
+    return String(value);
+  }
+}
+var trimStack = (stack) => stack.split("\n").slice(0, STACK_LINES).join("\n");
+function installLogHooks(capture, env) {
+  let quiet = 0;
+  let active = true;
+  const record = (level, args) => {
+    if (!active || quiet) return;
+    quiet++;
+    try {
+      capture.record(level, args);
+    } catch {
+    } finally {
+      quiet--;
+    }
+  };
+  const { console } = env;
+  const originals = { error: console.error, warn: console.warn };
+  const wrappers = {
+    error: (...args) => {
+      record("error", args);
+      originals.error.apply(console, args);
+    },
+    warn: (...args) => {
+      record("warn", args);
+      originals.warn.apply(console, args);
+    }
+  };
+  console.error = wrappers.error;
+  console.warn = wrappers.warn;
+  const errorUtils = env.ErrorUtils;
+  const originalHandler = errorUtils?.getGlobalHandler();
+  const handler2 = (error, isFatal) => {
+    record("error", [error]);
+    quiet++;
+    try {
+      originalHandler?.(error, isFatal);
+    } finally {
+      quiet--;
+    }
+  };
+  if (errorUtils) errorUtils.setGlobalHandler(handler2);
+  const onError = (event2) => record("error", [event2.error ?? event2.message]);
+  const onRejection = (event2) => record("error", ["Unhandled promise rejection:", event2.reason]);
+  const listens = typeof env.addEventListener === "function" && typeof env.removeEventListener === "function";
+  if (listens) {
+    env.addEventListener?.("error", onError);
+    env.addEventListener?.("unhandledrejection", onRejection);
+  }
+  return () => {
+    active = false;
+    if (console.error === wrappers.error) console.error = originals.error;
+    if (console.warn === wrappers.warn) console.warn = originals.warn;
+    if (errorUtils && originalHandler && errorUtils.getGlobalHandler() === handler2)
+      errorUtils.setGlobalHandler(originalHandler);
+    if (listens) {
+      env.removeEventListener?.("error", onError);
+      env.removeEventListener?.("unhandledrejection", onRejection);
+    }
+  };
+}
+var STATE2 = /* @__PURE__ */ Symbol.for("@avasapp/agent-bridge/logs");
+function startLogCapture(env = globalThis) {
+  const holder = env;
+  const state = holder[STATE2] ?? (holder[STATE2] = { capture: createLogCapture(), users: 0 });
+  if (state.users++ === 0) state.uninstall = installLogHooks(state.capture, env);
+  let stopped = false;
+  return {
+    capture: state.capture,
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      if (--state.users === 0) {
+        state.uninstall?.();
+        state.uninstall = void 0;
+      }
+    }
+  };
+}
+
+// src/runtime/to-json.ts
+function toJson(value) {
+  if (value === void 0) return null;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const text = JSON.stringify(value, (_key, v) => {
+    if (typeof v === "bigint") return v.toString();
+    if (typeof v === "function" || typeof v === "symbol") return void 0;
+    if (v instanceof Error) return { name: v.name, message: v.message };
+    if (v instanceof Map) return Object.fromEntries(v);
+    if (v instanceof Set) return [...v];
+    if (v && typeof v === "object") {
+      if (seen.has(v)) return "[Circular]";
+      seen.add(v);
+    }
+    return v;
+  });
+  return text === void 0 ? null : JSON.parse(text);
+}
+
+// src/runtime/registry.ts
+function unwrap(definition) {
+  return typeof definition === "function" ? { run: definition } : definition;
+}
+function createRegistry(getTools, logs) {
+  const list = () => Object.entries(getTools()).map(([name, definition]) => ({
+    name,
+    description: unwrap(definition).description
+  })).sort((a, b) => a.name.localeCompare(b.name));
+  async function dispatch(call, from) {
+    const end = logs?.begin(call.tool);
+    const result = await run(call, from).finally(end);
+    const errors = logs?.takeErrors();
+    return errors?.length ? { ...result, logs: errors } : result;
+  }
+  async function run(call, from) {
+    const t0 = performance.now();
+    const ms = () => Math.round((performance.now() - t0) * 100) / 100;
+    try {
+      const definition = getTools()[call.tool];
+      if (!definition) {
+        const known = list().map((t) => t.name).join(", ");
+        throw new Error(`Unknown tool "${call.tool}". Known: ${known}`);
+      }
+      const value = await unwrap(definition).run(...call.args ?? []);
+      return { id: call.id, from, ok: true, value: toJson(value), ms: ms() };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { id: call.id, from, ok: false, error: message, ms: ms() };
+    }
+  }
+  return { list, dispatch };
+}
+
+// src/runtime/index.ts
+var randomId = () => Math.random().toString(36).slice(2, 10);
+function startAgentBridge(options = {}) {
+  const deviceId = randomId();
+  const userTools = () => typeof options.tools === "function" ? options.tools() : options.tools ?? {};
+  const logs = startLogCapture();
+  const allTools = () => ({
+    ...builtinTools(() => registry.list(), allTools, logs.capture),
+    ...userTools()
+  });
+  const registry = createRegistry(allTools, logs.capture);
+  const info = () => ({
+    deviceId,
+    name: options.name ?? import_react_native2.Platform.OS,
+    platform: import_react_native2.Platform.OS,
+    protocol: PROTOCOL_VERSION,
+    tools: registry.list()
+  });
+  const context = {
+    info,
+    dispatch: (call) => registry.dispatch(call, deviceId)
+  };
+  const stops = (options.transports ?? [cdpTransport()]).map(
+    (t) => t.start(context)
+  );
+  return () => {
+    for (const stop of stops) stop();
+    logs.stop();
+  };
+}
+function useAgentBridge(options = {}) {
+  const latest = (0, import_react.useRef)(options);
+  (0, import_react.useEffect)(() => {
+    latest.current = options;
+  });
+  (0, import_react.useEffect)(() => {
+    const { transports, name } = latest.current;
+    return startAgentBridge({
+      name,
+      transports,
+      tools: () => {
+        const { tools } = latest.current;
+        return typeof tools === "function" ? tools() : tools ?? {};
+      }
+    });
+  }, []);
+}