@avasapp/agent-bridge 0.1.0

package/dist/expo/index.cjs

@@ -0,0 +1,62 @@
+"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/expo/index.ts
+var expo_exports = {};
+__export(expo_exports, {
+  expoTransport: () => expoTransport
+});
+module.exports = __toCommonJS(expo_exports);
+var import_devtools = require("expo/devtools");
+
+// src/shared/protocol.ts
+var PLUGIN_NAME = "agent-bridge";
+
+// src/expo/index.ts
+function expoTransport() {
+  return {
+    name: "expo",
+    start(context) {
+      let closed = false;
+      let client = null;
+      const subscriptions = [];
+      void (0, import_devtools.getDevToolsPluginClientAsync)(PLUGIN_NAME).then((c) => {
+        if (closed) {
+          void c.closeAsync();
+          return;
+        }
+        client = c;
+        const announce = () => c.sendMessage("hello:reply", context.info());
+        subscriptions.push(c.addMessageListener("hello", announce));
+        subscriptions.push(
+          c.addMessageListener("call", async (call) => {
+            if (call.to && call.to !== context.info().deviceId) return;
+            c.sendMessage("result", await context.dispatch(call));
+          })
+        );
+        announce();
+      });
+      return () => {
+        closed = true;
+        for (const s of subscriptions) s.remove();
+        void client?.closeAsync();
+      };
+    }
+  };
+}

package/dist/expo/index.d.cts

@@ -0,0 +1,9 @@
+import { a as Transport } from '../types-C6DUUHnB.cjs';
+
+/**
+ * Plain JSON over Expo's dev-tools plugin socket: no string evaluation, emoji
+ * and async tools just work. Needs the Expo CLI dev server.
+ */
+declare function expoTransport(): Transport;
+
+export { Transport, expoTransport };

package/dist/network/index.cjs

@@ -0,0 +1,568 @@
+"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/network/index.ts
+var network_exports = {};
+__export(network_exports, {
+  installNetwork: () => installNetwork,
+  mock: () => mock,
+  mockRequests: () => mockRequests,
+  networkTools: () => networkTools
+});
+module.exports = __toCommonJS(network_exports);
+
+// src/network/body.ts
+var MAX_BODY = 2048;
+function formatBody(text) {
+  if (text === void 0 || text === "") return void 0;
+  let out = text;
+  try {
+    out = JSON.stringify(JSON.parse(text));
+  } catch {
+  }
+  return out.length > MAX_BODY ? `${out.slice(0, MAX_BODY)}\u2026 (+${out.length - MAX_BODY} chars)` : out;
+}
+function bodyText(body) {
+  if (body === void 0 || body === null) return void 0;
+  if (typeof body === "string") return body;
+  if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams)
+    return body.toString();
+  if (typeof FormData !== "undefined" && body instanceof FormData)
+    return "[FormData]";
+  if (typeof Blob !== "undefined" && body instanceof Blob)
+    return `[Blob ${body.size} bytes]`;
+  if (body instanceof ArrayBuffer || ArrayBuffer.isView(body))
+    return `[binary ${body.byteLength} bytes]`;
+  return String(body);
+}
+function isTextual(contentType) {
+  if (!contentType) return true;
+  if (/event-stream/i.test(contentType)) return false;
+  return /json|text|xml|javascript|x-www-form-urlencoded/i.test(contentType);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/network/state.ts
+var LOG_SIZE = 100;
+var KEY = /* @__PURE__ */ Symbol.for("@avasapp/agent-bridge/network");
+function networkState() {
+  const g = globalThis;
+  g[KEY] ?? (g[KEY] = {
+    installed: false,
+    log: [],
+    nextLogId: 1,
+    mocks: [],
+    nextSeq: 1,
+    insideFetch: 0,
+    devHost: null,
+    skip: [],
+    uninstall: []
+  });
+  return g[KEY];
+}
+var URL_PARTS = /^(?:[a-z][a-z0-9+.-]*:)?(?:\/\/([^/?#]*))?([^?#]*)/i;
+var hostOf = (url) => URL_PARTS.exec(url)?.[1] ?? "";
+var pathOf = (url) => URL_PARTS.exec(url)?.[2] ?? "";
+var DEV_PATH = /^\/(symbolicate|logs|status|hot|message|inspector|expo-dev-plugins|_expo)(\/.*)?$|\.(bundle|map)$/;
+function isSkipped(state, url) {
+  const host = hostOf(url);
+  if (state.devHost && host === state.devHost) return true;
+  if (DEV_PATH.test(pathOf(url))) return true;
+  return state.skip.some(
+    (rule) => typeof rule === "string" ? url.includes(rule) : rule.test(url)
+  );
+}
+function deriveDevHost() {
+  try {
+    const rn = require("react-native");
+    const module2 = rn.TurboModuleRegistry?.get?.("SourceCode") ?? rn.NativeModules?.SourceCode;
+    const scriptURL = module2?.getConstants?.().scriptURL ?? module2?.scriptURL;
+    return typeof scriptURL === "string" && /^https?:/i.test(scriptURL) ? hostOf(scriptURL) || null : null;
+  } catch {
+    return null;
+  }
+}
+function startEntry(state, fields) {
+  const entry = {
+    id: state.nextLogId++,
+    ...fields,
+    ms: 0,
+    pending: true,
+    started: Date.now()
+  };
+  if (entry.requestBody === void 0) delete entry.requestBody;
+  state.log.push(entry);
+  if (state.log.length > LOG_SIZE)
+    state.log.splice(0, state.log.length - LOG_SIZE);
+  return entry;
+}
+function finishEntry(entry, fields) {
+  entry.ms = Date.now() - entry.started;
+  delete entry.pending;
+  for (const [key, value] of Object.entries(fields))
+    if (value !== void 0) entry[key] = value;
+}
+function publicEntry(entry) {
+  const { started, ...rest } = entry;
+  return rest.pending && started !== void 0 ? { ...rest, ms: Date.now() - started } : rest;
+}
+function urlTest(url) {
+  if (typeof url === "string") return (u) => u.includes(url);
+  const regex = url instanceof RegExp ? url : new RegExp(url.regex, url.flags);
+  return (u) => {
+    regex.lastIndex = 0;
+    return regex.test(u);
+  };
+}
+function compileMatch(match) {
+  const spec = typeof match === "string" ? { url: match } : match;
+  if (!spec || spec.url === void 0)
+    throw new Error("A mock needs a match: a URL substring or { url, method? }");
+  const testUrl = urlTest(spec.url);
+  const method = spec.method?.toUpperCase();
+  return (m, u) => (!method || method === m) && testUrl(u);
+}
+function addMock(state, source, match, response, options = {}) {
+  if (!response || typeof response !== "object" && typeof response !== "function")
+    throw new Error("A mock needs a response: { status?, json?, body?, headers? }, { offline: true } or a handler");
+  const seq = state.nextSeq++;
+  const id = options.id ?? `${source}-${seq}`;
+  removeMocks(state, (m) => m.id === id);
+  const mock2 = {
+    id,
+    source,
+    match,
+    response,
+    times: options.times,
+    delayMs: options.delayMs ?? 0,
+    hits: 0,
+    seq,
+    test: compileMatch(match)
+  };
+  state.mocks.push(mock2);
+  return mock2;
+}
+function removeMocks(state, which) {
+  const before = state.mocks.length;
+  state.mocks = state.mocks.filter((m) => !which(m));
+  return before - state.mocks.length;
+}
+var mockOrder = (a, b) => Number(b.source === "agent") - Number(a.source === "agent") || b.seq - a.seq;
+function matchingMocks(state, method, url) {
+  return state.mocks.filter((m) => m.test(method, url)).sort(mockOrder);
+}
+async function answer(state, candidates, request) {
+  for (const mock2 of candidates) {
+    if (!state.mocks.includes(mock2)) continue;
+    const response = typeof mock2.response === "function" ? await mock2.response(await request()) : mock2.response;
+    if (!response) continue;
+    mock2.hits += 1;
+    if (mock2.times !== void 0 && mock2.hits >= mock2.times)
+      removeMocks(state, (m) => m === mock2);
+    return { mock: mock2, response };
+  }
+  return null;
+}
+function mockRequest(method, url, headers, body) {
+  return {
+    method,
+    url,
+    headers,
+    body,
+    json: () => {
+      try {
+        return body === void 0 ? void 0 : JSON.parse(body);
+      } catch {
+        return void 0;
+      }
+    }
+  };
+}
+function responseParts(response) {
+  const r = response;
+  const status = r.status ?? 200;
+  if (r.json !== void 0)
+    return {
+      status,
+      text: JSON.stringify(r.json),
+      headers: { "content-type": "application/json", ...r.headers }
+    };
+  return { status, text: r.body ?? "", headers: { ...r.headers } };
+}
+var isOffline = (response) => response.offline === true;
+var OFFLINE_MESSAGE = "Network request failed";
+var sleep = (ms) => ms > 0 ? new Promise((resolve) => setTimeout(resolve, ms)) : Promise.resolve();
+
+// src/network/fetch.ts
+function headersRecord(headers) {
+  const out = {};
+  if (!headers) return out;
+  const h = headers;
+  if (Array.isArray(headers)) {
+    for (const [key, value] of headers) out[String(key).toLowerCase()] = String(value);
+  } else if (typeof h.forEach === "function") {
+    h.forEach((value, key) => {
+      out[key.toLowerCase()] = value;
+    });
+  } else {
+    for (const [key, value] of Object.entries(headers))
+      out[key.toLowerCase()] = String(value);
+  }
+  return out;
+}
+var nullBody = (status) => [101, 204, 205, 304].includes(status);
+function mockedResponse(response) {
+  const { status, text, headers } = responseParts(response);
+  const body = nullBody(status) ? null : text;
+  if (typeof Response !== "undefined")
+    return new Response(body, { status, headers });
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    statusText: "",
+    url: "",
+    headers: { get: (name) => headers[name.toLowerCase()] ?? null },
+    text: async () => text,
+    json: async () => JSON.parse(text),
+    clone() {
+      return mockedResponse(response);
+    }
+  };
+}
+function abortError() {
+  const error = new Error("Aborted");
+  error.name = "AbortError";
+  return error;
+}
+function patchFetch(state) {
+  const g = globalThis;
+  const original = g.fetch;
+  if (typeof original !== "function") return null;
+  const callOriginal = (input, init) => {
+    state.insideFetch += 1;
+    try {
+      return original.call(globalThis, input, init);
+    } finally {
+      state.insideFetch -= 1;
+    }
+  };
+  const wrapped = function fetch(input, init) {
+    const req = typeof input === "object" && input ? input : {};
+    const url = typeof input === "string" ? input : req.url ?? String(input);
+    if (isSkipped(state, url)) return callOriginal(input, init);
+    const method = String(init?.method ?? req.method ?? "GET").toUpperCase();
+    const requestBody = bodyText(init?.body);
+    const entry = startEntry(state, {
+      method,
+      url,
+      requestBody: formatBody(requestBody)
+    });
+    const real = () => {
+      let promise;
+      try {
+        promise = callOriginal(input, init);
+      } catch (error) {
+        finishEntry(entry, { error: errorMessage(error) });
+        throw error;
+      }
+      return promise.then(
+        (res) => {
+          finishEntry(entry, { status: res.status });
+          const type = res.headers?.get?.("content-type");
+          if (isTextual(type) && typeof res.clone === "function") {
+            res.clone().text().then((text) => {
+              const body = formatBody(text);
+              if (body !== void 0) entry.responseBody = body;
+            }).catch(() => {
+            });
+          }
+          return res;
+        },
+        (error) => {
+          finishEntry(entry, { error: errorMessage(error) });
+          throw error;
+        }
+      );
+    };
+    const candidates = matchingMocks(state, method, url);
+    if (!candidates.length) return real();
+    const request = async () => {
+      let body = requestBody;
+      if (body === void 0 && init?.body === void 0 && req.clone) {
+        body = await req.clone().text().catch(() => void 0);
+      }
+      return mockRequest(
+        method,
+        url,
+        headersRecord(init?.headers ?? req.headers),
+        body || void 0
+      );
+    };
+    const answered = answer(state, candidates, request).catch((error) => {
+      entry.mocked = true;
+      finishEntry(entry, { error: errorMessage(error) });
+      throw error;
+    });
+    return answered.then(async (hit) => {
+      if (!hit) return real();
+      entry.mocked = true;
+      await sleep(hit.mock.delayMs);
+      if (init?.signal?.aborted) {
+        finishEntry(entry, { error: "aborted" });
+        throw abortError();
+      }
+      if (isOffline(hit.response)) {
+        finishEntry(entry, { error: `${OFFLINE_MESSAGE} (mocked offline)` });
+        throw new TypeError(OFFLINE_MESSAGE);
+      }
+      const { status, text } = responseParts(hit.response);
+      finishEntry(entry, { status, responseBody: formatBody(text) });
+      return mockedResponse(hit.response);
+    });
+  };
+  g.fetch = wrapped;
+  return () => {
+    if (g.fetch === wrapped) g.fetch = original;
+  };
+}
+
+// src/network/xhr.ts
+var META = /* @__PURE__ */ Symbol("agent-bridge.xhr");
+var isRN = (xhr) => typeof xhr.__didReceiveResponse === "function" && typeof xhr.__didCompleteResponse === "function";
+function responseTextOf(xhr) {
+  try {
+    if (xhr.responseType === "" || xhr.responseType === "text") return xhr.responseText;
+    if (xhr.responseType === "json") return JSON.stringify(xhr.response);
+  } catch {
+  }
+  return void 0;
+}
+function track(xhr, entry) {
+  let error;
+  xhr.addEventListener("error", () => error = OFFLINE_MESSAGE);
+  xhr.addEventListener("timeout", () => error = "timed out");
+  xhr.addEventListener("abort", () => error = "aborted");
+  xhr.addEventListener("loadend", () => {
+    finishEntry(entry, {
+      status: error ? void 0 : xhr.status,
+      error,
+      responseBody: error ? void 0 : formatBody(responseTextOf(xhr))
+    });
+  });
+}
+var fakeRequestId = 0;
+function fire(xhr, type) {
+  const Ctor = (type === "readystatechange" ? void 0 : globalThis.ProgressEvent) ?? globalThis.Event;
+  xhr.dispatchEvent(new Ctor(type));
+}
+function respond(xhr, hit, url) {
+  const offline = isOffline(hit.response);
+  const { status, text, headers } = responseParts(hit.response);
+  if (isRN(xhr)) {
+    const id = -++fakeRequestId;
+    xhr.__didCreateRequest(id);
+    if (offline) return xhr.__didCompleteResponse(id, OFFLINE_MESSAGE, false);
+    xhr.__didReceiveResponse(id, status, headers, url);
+    if (xhr.responseType === "arraybuffer" && typeof btoa === "function") {
+      xhr.__didReceiveData(id, btoa(unescape(encodeURIComponent(text))));
+    } else if (xhr.responseType !== "blob") {
+      xhr.__didReceiveData(id, text);
+    }
+    return xhr.__didCompleteResponse(id, "", false);
+  }
+  const define = (values) => {
+    for (const [key, value] of Object.entries(values))
+      Object.defineProperty(xhr, key, { value, configurable: true });
+  };
+  const lower = Object.fromEntries(
+    Object.entries(headers).map(([k, v]) => [k.toLowerCase(), v])
+  );
+  let response = text;
+  if (xhr.responseType === "json") {
+    try {
+      response = JSON.parse(text);
+    } catch {
+      response = null;
+    }
+  }
+  define({
+    readyState: 4,
+    status: offline ? 0 : status,
+    statusText: "",
+    responseURL: url,
+    responseText: offline ? "" : text,
+    response: offline ? "" : response,
+    getAllResponseHeaders: () => offline ? "" : Object.entries(lower).map(([k, v]) => `${k}: ${v}\r
+`).join(""),
+    getResponseHeader: (name) => lower[name.toLowerCase()] ?? null
+  });
+  fire(xhr, "readystatechange");
+  fire(xhr, offline ? "error" : "load");
+  fire(xhr, "loadend");
+}
+function patchXhr(state) {
+  const XHR = globalThis.XMLHttpRequest;
+  if (typeof XHR !== "function") return null;
+  const proto = XHR.prototype;
+  const { open, send, setRequestHeader, abort } = proto;
+  proto.open = function(method, url, ...rest) {
+    this[META] = {
+      method: String(method).toUpperCase(),
+      url: String(url),
+      // Opened by the patched fetch's own original: fetch logs it already.
+      internal: state.insideFetch > 0,
+      headers: {}
+    };
+    return open.call(this, method, url, ...rest);
+  };
+  proto.setRequestHeader = function(name, value) {
+    const meta = this[META];
+    if (meta) meta.headers[name.toLowerCase()] = value;
+    return setRequestHeader.call(this, name, value);
+  };
+  proto.abort = function() {
+    const meta = this[META];
+    if (meta) meta.aborted = true;
+    return abort.call(this);
+  };
+  proto.send = function(body) {
+    const meta = this[META];
+    if (!meta || meta.internal || isSkipped(state, meta.url))
+      return send.call(this, body);
+    const { method, url } = meta;
+    const text = bodyText(body);
+    const entry = startEntry(state, {
+      method,
+      url,
+      requestBody: formatBody(text)
+    });
+    const candidates = matchingMocks(state, method, url);
+    if (!candidates.length) {
+      track(this, entry);
+      return send.call(this, body);
+    }
+    const request = async () => mockRequest(method, url, meta.headers, text);
+    answer(state, candidates, request).then(
+      async (hit) => {
+        if (!hit) {
+          track(this, entry);
+          return send.call(this, body);
+        }
+        entry.mocked = true;
+        await sleep(hit.mock.delayMs);
+        if (meta.aborted) {
+          finishEntry(entry, { error: "aborted" });
+          return;
+        }
+        const offline = isOffline(hit.response);
+        const { status, text: out } = responseParts(hit.response);
+        finishEntry(
+          entry,
+          offline ? { error: `${OFFLINE_MESSAGE} (mocked offline)` } : { status, responseBody: formatBody(out) }
+        );
+        respond(this, hit, url);
+      },
+      (error) => {
+        entry.mocked = true;
+        finishEntry(entry, { error: errorMessage(error) });
+        respond(this, { mock: candidates[0], response: { offline: true } }, url);
+      }
+    );
+  };
+  return () => {
+    Object.assign(proto, { open, send, setRequestHeader, abort });
+  };
+}
+
+// src/network/index.ts
+function installNetwork() {
+  const state = networkState();
+  if (state.installed) return;
+  state.installed = true;
+  state.devHost = deriveDevHost();
+  for (const undo of [patchXhr(state), patchFetch(state)])
+    if (undo) state.uninstall.push(undo);
+}
+function mock(match, response, options) {
+  installNetwork();
+  const state = networkState();
+  const { id } = addMock(state, "app", match, response, options);
+  return { id, remove: () => removeMocks(state, (m) => m.id === id) > 0 };
+}
+function mockRequests(routes) {
+  const added = routes.map((r) => mock(r.match, r.response, r.options));
+  return () => {
+    for (const m of added) m.remove();
+  };
+}
+var describeMock = (m) => ({
+  id: m.id,
+  source: m.source,
+  match: m.match instanceof RegExp ? String(m.match) : m.match,
+  response: typeof m.response === "function" ? "[handler]" : m.response,
+  times: m.times,
+  hits: m.hits,
+  delayMs: m.delayMs || void 0
+});
+function networkTools(options = {}) {
+  installNetwork();
+  const state = networkState();
+  if (options.skip) state.skip = options.skip;
+  const isAgent = (m) => m.source === "agent";
+  return {
+    "net.log": {
+      description: "Recent requests, newest first: method, url, status, ms, bodies (~2 KB), error, mocked. Filter by url substring or method; clear: true empties the log after reading.",
+      run: (filter = {}) => {
+        const method = filter.method?.toUpperCase();
+        const entries = state.log.filter(
+          (e) => (!filter.url || e.url.includes(filter.url)) && (!method || e.method === method)
+        ).reverse().slice(0, filter.limit ?? 20).map(publicEntry);
+        if (filter.clear) state.log.length = 0;
+        return entries;
+      }
+    },
+    "net.mock": {
+      description: 'Answer matching requests with a canned response until unmocked. match: "/path" or { url: string | { regex }, method? }. response: { status?, json?, body?, headers? } or { offline: true }. options: { times?, delayMs? }.',
+      run: (match, response, mockOptions = {}) => {
+        if (typeof response !== "object" || response === null)
+          throw new Error("response must be an object, e.g. { status: 500 }");
+        const { times, delayMs } = mockOptions;
+        return { id: addMock(state, "agent", match, response, { times, delayMs }).id };
+      }
+    },
+    "net.mocks": {
+      description: "Active mocks, agent and app, in the order they are tried.",
+      run: () => [...state.mocks].sort(mockOrder).map(describeMock)
+    },
+    "net.unmock": {
+      description: "Remove one agent mock by id, or every agent mock when no id. Returns how many.",
+      run: (id) => removeMocks(state, (m) => isAgent(m) && (id === void 0 || m.id === id))
+    },
+    "net.clear": {
+      description: "Empty the request log. Returns how many entries it held.",
+      run: () => state.log.splice(0).length
+    },
+    "net.restore": {
+      description: "Undo the agent's network changes: remove agent mocks, keep the app's. Returns how many were removed.",
+      run: () => removeMocks(state, isAgent)
+    }
+  };
+}