@avasapp/agent-bridge 0.1.0 → 0.2.0

package/dist/adapters/socket-io.cjs

@@ -0,0 +1,317 @@
+"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/socket-io.ts
+var socket_io_exports = {};
+__export(socket_io_exports, {
+  socketIoTools: () => socketIoTools
+});
+module.exports = __toCommonJS(socket_io_exports);
+
+// src/realtime/patch.ts
+var list = (names) => Array.isArray(names) ? names : [names];
+var sameKey = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+function split(args) {
+  const last = args[args.length - 1];
+  return typeof last === "function" ? { key: args.slice(0, -1), listener: last } : { key: args };
+}
+function tapListeners(tap, target, options) {
+  const methods = target;
+  const tracked = [];
+  const spread = options.message === "args";
+  for (const name of list(options.add)) {
+    const add = methods[name];
+    if (typeof add !== "function") continue;
+    methods[name] = function(...args) {
+      const { key, listener: original } = split(args);
+      const channel = original && options.channel(key);
+      if (!original || channel === void 0) return add.apply(this, args);
+      const accepts = options.accepts;
+      const { listener, unsubscribe } = tap.wrap(
+        channel,
+        (message, ...rest) => spread ? original.apply(target, message) : original.call(target, message, ...rest),
+        accepts ? { accepts: (m) => accepts(key, m) } : {}
+      );
+      const wrapped = spread ? (...received) => listener(received) : (message, ...rest) => listener(message, ...rest);
+      tracked.push({ key, original, wrapped, unsubscribe });
+      return add.apply(this, [...key, wrapped]);
+    };
+  }
+  for (const name of list(options.remove)) {
+    const remove = methods[name];
+    if (typeof remove !== "function") continue;
+    methods[name] = function(...args) {
+      const { key, listener } = split(args);
+      const hits = tracked.filter(
+        (t) => (!listener || t.original === listener || t.original.fn === listener) && (!key.length || sameKey(t.key, key))
+      );
+      for (const hit of hits) {
+        tracked.splice(tracked.indexOf(hit), 1);
+        hit.unsubscribe();
+      }
+      if (!listener || !hits.length) return remove.apply(this, args);
+      let result;
+      for (const hit of hits) result = remove.apply(this, [...hit.key, hit.wrapped]);
+      return result;
+    };
+  }
+}
+function fakeableConnection(target, options) {
+  const methods = target;
+  const events = methods?.[options.events];
+  if (!methods || typeof events !== "function") return void 0;
+  const read = options.read ?? String;
+  const write = options.write ?? ((state) => state);
+  const values = methods;
+  let fake = null;
+  let real = values[options.property];
+  const readReal = () => read(options.fakeProperty === false ? values[options.property] : real);
+  if (options.fakeProperty !== false)
+    Object.defineProperty(target, options.property, {
+      configurable: true,
+      enumerable: true,
+      get: () => fake === null ? real : write(fake),
+      set: (value) => {
+        real = value;
+      }
+    });
+  methods[options.events] = function(...args) {
+    return fake === null ? events.apply(this, args) : void 0;
+  };
+  const emit = (...args) => void events.apply(target, args);
+  return {
+    state: readReal,
+    states: options.states,
+    live: options.live,
+    fake: (state, previous) => {
+      fake = state;
+      const current = state ?? readReal();
+      if (current !== previous)
+        options.announce(emit, { current, previous, faked: state !== null });
+    }
+  };
+}
+function realtimeAdapter(install) {
+  const taps = /* @__PURE__ */ new WeakMap();
+  return (client, options = {}) => {
+    let tools = taps.get(client);
+    if (!tools) taps.set(client, tools = install(client, options).tools);
+    return tools;
+  };
+}
+
+// src/realtime/tap.ts
+var LOG_SIZE = 50;
+var ALL = "*";
+var defaultDescribe = (message) => {
+  const id = message?.id;
+  return typeof id === "string" ? { data: message, id } : { data: message };
+};
+var sameMessage = (a, b) => a === b || Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((v, i) => v === b[i]);
+function createRealtimeTap(options = {}) {
+  const ns = options.namespace ?? "realtime";
+  const describe = options.describe ?? defaultDescribe;
+  const toMessage = options.toMessage ?? ((values) => values[0]);
+  const connection = options.connection;
+  const live = connection?.live ?? "connected";
+  const channels = /* @__PURE__ */ new Map();
+  const mutes = /* @__PURE__ */ new Map();
+  const log = [];
+  const last = /* @__PURE__ */ new Map();
+  let injectedCount = 0;
+  let faked = null;
+  const muteFor = (channel) => mutes.get(channel) ?? mutes.get(ALL);
+  const liveChannels = () => [...channels.keys()].join(", ") || "none";
+  function record(channel, message, injected, dropped) {
+    log.push({
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      channel,
+      ...describe(message),
+      injected,
+      ...dropped && { dropped }
+    });
+    if (log.length > LOG_SIZE) log.splice(0, log.length - LOG_SIZE);
+  }
+  function receive(channel, entry, message, rest) {
+    const previous = last.get(channel);
+    const dropped = muteFor(channel) ? "muted" : faked !== null && faked !== live ? "connection" : void 0;
+    if (previous && !previous.seen.has(entry) && sameMessage(previous.message, message)) {
+      previous.seen.add(entry);
+    } else {
+      last.set(channel, { message, seen: /* @__PURE__ */ new Set([entry]) });
+      record(channel, message, false, dropped);
+    }
+    if (!dropped) entry.deliver(message, ...rest);
+  }
+  const wrap = (channel, listener, wrapOptions = {}) => {
+    const entry = {
+      deliver: listener,
+      accepts: wrapOptions.accepts
+    };
+    let entries = channels.get(channel);
+    if (!entries) channels.set(channel, entries = /* @__PURE__ */ new Set());
+    entries.add(entry);
+    return {
+      listener: (message, ...rest) => receive(channel, entry, message, rest),
+      unsubscribe: () => {
+        const current = channels.get(channel);
+        if (!current?.delete(entry) || current.size) return;
+        channels.delete(channel);
+        last.delete(channel);
+      }
+    };
+  };
+  function setMute(channel, mute) {
+    if (typeof channel !== "string" || !channel)
+      throw new Error(`Pass a channel name, or "${ALL}" for every channel`);
+    if (mute) mutes.set(channel, mute);
+    else if (channel === ALL) mutes.clear();
+    else mutes.delete(channel);
+    return { muted: [...mutes.keys()] };
+  }
+  function setConnection(conn, state) {
+    const shown = faked ?? conn.state();
+    if (state !== null && typeof state !== "string")
+      throw new Error('Pass a state such as "disconnected", or null for the real one');
+    if (state !== null && conn.states && !conn.states.includes(state))
+      throw new Error(
+        `Unknown state "${state}". Known: ${conn.states.join(", ")}`
+      );
+    if (state === faked) return;
+    faked = state;
+    conn.fake(state, shown);
+  }
+  const tools = {
+    [`${ns}.channels`]: {
+      description: "Channels the app listens on: listener count, muted, and what the library says about each.",
+      run: () => [...channels].map(([name, entries]) => ({
+        name,
+        listeners: entries.size,
+        muted: Boolean(muteFor(name)),
+        ...options.channelInfo?.(name)
+      }))
+    },
+    [`${ns}.log`]: {
+      description: `Recent messages, real and injected, newest first (last ${LOG_SIZE}). Filter: { channel?, event?, limit? }; clear: true empties the log after reading.`,
+      run: (filter = {}) => {
+        const entries = log.filter(
+          (e) => (!filter.channel || e.channel === filter.channel) && (!filter.event || e.event === filter.event)
+        ).reverse().slice(0, filter.limit ?? 20);
+        if (filter.clear) log.length = 0;
+        return entries;
+      }
+    },
+    [`${ns}.emit`]: {
+      description: "Deliver a fake message to every listener on a channel: [channel, message]. Runs the app's own handlers. Returns { id, delivered }.",
+      run: (channel, ...values) => {
+        const entries = channels.get(channel);
+        if (!entries?.size)
+          throw new Error(
+            `Nothing listens on "${channel}". Live channels: ${liveChannels()}`
+          );
+        injectedCount += 1;
+        const message = toMessage(values, {
+          channel,
+          id: `agent-bridge-${injectedCount}`
+        });
+        const id = describe(message).id;
+        if (muteFor(channel)?.dropInjected) {
+          record(channel, message, true, "muted");
+          return { id, delivered: 0 };
+        }
+        record(channel, message, true);
+        let delivered = 0;
+        for (const entry of [...entries]) {
+          if (entry.accepts && !entry.accepts(message)) continue;
+          entry.deliver(message);
+          delivered += 1;
+        }
+        return { id, delivered };
+      }
+    },
+    [`${ns}.mute`]: {
+      description: `Drop real messages on a channel ("${ALL}" for all) until unmuted. Injected messages still get through unless { dropInjected: true }.`,
+      run: (channel, muteOptions = {}) => setMute(channel, { dropInjected: Boolean(muteOptions.dropInjected) })
+    },
+    [`${ns}.unmute`]: {
+      description: `Stop dropping messages on a channel ("${ALL}" for all).`,
+      run: (channel) => setMute(channel, null)
+    },
+    [`${ns}.restore`]: {
+      description: "Undo the agent: unmute every channel and go back to the real connection state.",
+      run: () => {
+        const unmuted = [...mutes.keys()];
+        mutes.clear();
+        const connectionFaked = faked !== null;
+        if (connection && connectionFaked) setConnection(connection, null);
+        return { unmuted, connectionFaked };
+      }
+    }
+  };
+  if (connection)
+    tools[`${ns}.connection`] = {
+      description: `The connection state, or fake one: [state] shows the app that state${connection.states ? ` (${connection.states.join(", ")})` : ""} and drops real messages unless it is "${live}"; [null] goes back to the real one.`,
+      run: (...args) => {
+        if (args.length) setConnection(connection, args[0] ?? null);
+        return { state: faked ?? connection.state(), real: connection.state(), faked: faked !== null };
+      }
+    };
+  return { wrap, tools };
+}
+
+// src/adapters/socket-io.ts
+var RESERVED = /* @__PURE__ */ new Set([
+  "connect",
+  "connect_error",
+  "disconnect",
+  "disconnecting",
+  "newListener",
+  "removeListener"
+]);
+var socketIoTools = realtimeAdapter(
+  (socket, options) => {
+    const tap = createRealtimeTap({
+      namespace: options.namespace,
+      // The last argument is an ack callback when the server asked for one.
+      describe: (args) => {
+        const values = args.filter((a) => typeof a !== "function");
+        return { data: values.length === 1 ? values[0] : values };
+      },
+      toMessage: (values) => values,
+      // socket.io-client announces lifecycle events with emitReserved.
+      connection: fakeableConnection(socket, {
+        property: "connected",
+        events: "emitReserved",
+        states: ["connected", "disconnected"],
+        read: (connected) => connected ? "connected" : "disconnected",
+        // socket.io reads `connected` to decide whether to deliver incoming
+        // events and send outgoing ones; faking it would hold them back.
+        fakeProperty: false,
+        announce: (emit, { current }) => current === "connected" ? emit("connect") : emit("disconnect", "transport close")
+      })
+    });
+    tapListeners(tap, socket, {
+      add: ["on", "addEventListener"],
+      remove: ["off", "removeListener", "removeAllListeners", "removeEventListener"],
+      channel: ([event]) => typeof event === "string" && !RESERVED.has(event) ? event : void 0,
+      message: "args"
+    });
+    return tap;
+  }
+);

package/dist/adapters/socket-io.d.cts

@@ -0,0 +1,21 @@
+import { T as Tools } from '../types-C6DUUHnB.cjs';
+
+type Listener = (...args: any[]) => void;
+/** A socket.io client socket (`io(url)`), typed structurally. */
+type SocketLike = {
+    on(event: string, listener: Listener): unknown;
+    off(event?: string, listener?: Listener): unknown;
+    connected?: boolean;
+};
+type SocketIoToolsOptions = {
+    /** Tool name prefix. Defaults to "realtime". */
+    namespace?: string;
+};
+/**
+ * See, fake and drop socket.io events: `realtime.*`, where a channel is an
+ * event name. Patches the socket, so call it where you create the socket,
+ * before the app adds listeners. Calling it again with the same socket is free.
+ */
+declare const socketIoTools: (client: SocketLike, options?: SocketIoToolsOptions | undefined) => Tools;
+
+export { type SocketIoToolsOptions, type SocketLike, socketIoTools };

package/dist/{chunk-UEWFQWCY.js → chunk-LBYZ5JHF.js}

@@ -174,6 +174,8 @@ async function connectExpo(metro, device, discoveryMs = 600) {
 
 // src/client/cdp.ts
 import WebSocket2 from "ws";
+var CannotEvaluate = class extends Error {
+};
 var targetLabel = (t) => `${t.title}${t.deviceName ? ` [${t.deviceName}]` : ""}`;
 async function connectCdp(metro, device) {
   const target = pickOne(await listCdpTargets(metro), device, targetLabel);
@@ -220,6 +222,7 @@ async function connectCdp(metro, device) {
       expression,
       returnByValue: true
     });
+    if (message.error?.code === -32601) throw new CannotEvaluate();
     const details = message.result?.exceptionDetails;
     if (details) {
       const text = details.exception?.description ?? details.text ?? "evaluation failed";
@@ -234,10 +237,10 @@ async function connectCdp(metro, device) {
     info = JSON.parse(
       String(await evaluate(`${CDP_GLOBAL}.info()`))
     );
-  } catch {
+  } catch (error) {
     ws.close();
     throw new Error(
-      `agent-bridge isn't running in ${targetLabel(target)}. Is useAgentBridge mounted in a dev build?`
+      error instanceof CannotEvaluate ? `The debugger for ${targetLabel(target)} can't run code (no Runtime.evaluate, as in Expo Go on Android). Use --transport expo, or a dev build.` : `agent-bridge isn't running in ${targetLabel(target)}. Is useAgentBridge mounted in a dev build?`
     );
   }
   return {

package/dist/cli.js

@@ -19,7 +19,7 @@ import {
   sessionRequest,
   stateDir,
   writePrivate
-} from "./chunk-UEWFQWCY.js";
+} from "./chunk-LBYZ5JHF.js";
 
 // src/cli.ts
 import { readFile } from "fs/promises";

package/dist/client/index.cjs

@@ -213,6 +213,8 @@ async function connectExpo(metro, device, discoveryMs = 600) {
 
 // src/client/cdp.ts
 var import_ws2 = __toESM(require("ws"), 1);
+var CannotEvaluate = class extends Error {
+};
 var targetLabel = (t) => `${t.title}${t.deviceName ? ` [${t.deviceName}]` : ""}`;
 async function connectCdp(metro, device) {
   const target = pickOne(await listCdpTargets(metro), device, targetLabel);
@@ -259,6 +261,7 @@ async function connectCdp(metro, device) {
       expression,
       returnByValue: true
     });
+    if (message.error?.code === -32601) throw new CannotEvaluate();
     const details = message.result?.exceptionDetails;
     if (details) {
       const text = details.exception?.description ?? details.text ?? "evaluation failed";
@@ -273,10 +276,10 @@ async function connectCdp(metro, device) {
     info = JSON.parse(
       String(await evaluate(`${CDP_GLOBAL}.info()`))
     );
-  } catch {
+  } catch (error) {
     ws.close();
     throw new Error(
-      `agent-bridge isn't running in ${targetLabel(target)}. Is useAgentBridge mounted in a dev build?`
+      error instanceof CannotEvaluate ? `The debugger for ${targetLabel(target)} can't run code (no Runtime.evaluate, as in Expo Go on Android). Use --transport expo, or a dev build.` : `agent-bridge isn't running in ${targetLabel(target)}. Is useAgentBridge mounted in a dev build?`
     );
   }
   return {

package/dist/client/index.js

@@ -4,7 +4,7 @@ import {
   connectSession,
   listDevices,
   listSessions
-} from "../chunk-UEWFQWCY.js";
+} from "../chunk-LBYZ5JHF.js";
 export {
   AgentBridgeCallError,
   connect,

package/dist/noop/ably.cjs

@@ -0,0 +1,26 @@
+"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/noop/ably.ts
+var ably_exports = {};
+__export(ably_exports, {
+  ablyTools: () => ablyTools
+});
+module.exports = __toCommonJS(ably_exports);
+var ablyTools = () => ({});

package/dist/noop/realtime.cjs

@@ -0,0 +1,40 @@
+"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/noop/realtime.ts
+var realtime_exports = {};
+__export(realtime_exports, {
+  createRealtimeTap: () => createRealtimeTap,
+  fakeableConnection: () => fakeableConnection,
+  realtimeAdapter: () => realtimeAdapter,
+  tapListeners: () => tapListeners
+});
+module.exports = __toCommonJS(realtime_exports);
+var createRealtimeTap = () => ({
+  wrap: (_channel, listener) => ({
+    listener,
+    unsubscribe: () => {
+    }
+  }),
+  tools: {}
+});
+var tapListeners = () => {
+};
+var fakeableConnection = () => void 0;
+var realtimeAdapter = () => () => ({});

package/dist/noop/socket-io.cjs

@@ -0,0 +1,26 @@
+"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/noop/socket-io.ts
+var socket_io_exports = {};
+__export(socket_io_exports, {
+  socketIoTools: () => socketIoTools
+});
+module.exports = __toCommonJS(socket_io_exports);
+var socketIoTools = () => ({});