@avasapp/agent-bridge 0.2.0 → 0.3.0

package/dist/network/index.cjs

@@ -22,11 +22,78 @@ var network_exports = {};
 __export(network_exports, {
   installNetwork: () => installNetwork,
   mock: () => mock,
+  mockApi: () => mockApi,
   mockRequests: () => mockRequests,
-  networkTools: () => networkTools
+  networkTools: () => networkTools,
+  strictNetwork: () => strictNetwork
 });
 module.exports = __toCommonJS(network_exports);
 
+// src/network/api.ts
+var escape = (s) => s.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+var ROUTE = /^(?:([A-Za-z]+)\s+)?(\/\S*)$/;
+function compileRoute(baseUrl, route) {
+  const parsed = ROUTE.exec(route.trim());
+  if (!parsed)
+    throw new Error(`Bad route "${route}": use "METHOD /path" or "/path"`);
+  const [, method, path] = parsed;
+  const names = [];
+  const pattern = path.split(/(:[A-Za-z_][A-Za-z0-9_]*|\*)/).map((part) => {
+    if (part === "*") {
+      names.push("*");
+      return "([^?#]*)";
+    }
+    if (part.startsWith(":")) {
+      names.push(part.slice(1));
+      return "([^/?#]+)";
+    }
+    return escape(part);
+  }).join("");
+  const base = baseUrl ? escape(baseUrl.replace(/\/+$/, "")) : "(?:[a-z][a-z0-9+.-]*://[^/?#]*)?";
+  return {
+    method: method?.toUpperCase(),
+    regex: new RegExp(`^${base}${pattern}(?:[?#].*)?$`, "i"),
+    names
+  };
+}
+function queryOf(url) {
+  const search = /\?([^#]*)/.exec(url)?.[1];
+  const out = {};
+  if (!search) return out;
+  for (const pair of search.split("&")) {
+    if (!pair) continue;
+    const [key, value = ""] = pair.split("=");
+    const decode = (s) => {
+      try {
+        return decodeURIComponent(s.replace(/\+/g, " "));
+      } catch {
+        return s;
+      }
+    };
+    out[decode(key)] = decode(value);
+  }
+  return out;
+}
+function apiRoutes(baseUrl, routes, options = {}) {
+  const { id, ...mockOptions } = options;
+  return Object.entries(routes).map(([route, response]) => {
+    const { method, regex, names } = compileRoute(baseUrl, route);
+    const match = { url: regex, method };
+    const handler = typeof response === "function" ? (request) => {
+      const values = regex.exec(request.url)?.slice(1) ?? [];
+      const params = Object.fromEntries(
+        names.map((name, i) => [name, decodeURIComponent(values[i] ?? "")])
+      );
+      return response({ ...request, params, query: queryOf(request.url) });
+    } : response;
+    return {
+      match,
+      response: handler,
+      options: { ...mockOptions, ...id && { id: `${id} ${route}` } }
+    };
+  });
+}
+
 // src/network/body.ts
 var MAX_BODY = 2048;
 function formatBody(text) {
@@ -74,7 +141,10 @@ function networkState() {
     insideFetch: 0,
     devHost: null,
     skip: [],
-    uninstall: []
+    uninstall: [],
+    strictApp: [],
+    strictAgent: null,
+    blocked: /* @__PURE__ */ new Map()
   });
   return g[KEY];
 }
@@ -207,6 +277,41 @@ function responseParts(response) {
     };
   return { status, text: r.body ?? "", headers: { ...r.headers } };
 }
+function strictRule(options = {}) {
+  const allow = options.allow ?? [];
+  if (!Array.isArray(allow))
+    throw new Error("allow must be a list of URL substrings or regexes");
+  return {
+    allow: allow.map((rule) => urlTest(rule)),
+    allowShown: allow.map(
+      (rule) => typeof rule === "string" ? rule : String(rule instanceof RegExp ? rule : new RegExp(rule.regex, rule.flags))
+    ),
+    status: options.status ?? 501,
+    offline: options.offline === true
+  };
+}
+function strictRules(state) {
+  if (state.strictAgent === false) return [];
+  return state.strictAgent ? [state.strictAgent, ...state.strictApp] : state.strictApp;
+}
+var BLOCKED_HEADER = "x-agent-bridge";
+function blockedResponse(state, method, url) {
+  const rules = strictRules(state);
+  if (!rules.length || rules.some((r) => r.allow.some((test) => test(url))))
+    return null;
+  const key = `${method} ${url}`;
+  const seen = state.blocked.get(key);
+  if (seen) seen.count += 1;
+  else state.blocked.set(key, { method, url, count: 1 });
+  const error = `agent-bridge strict network: no mock for ${key}`;
+  console.error(`${error}. Mock it, or allow it in strict mode.`);
+  if (rules[0].offline) return { offline: true };
+  return {
+    status: rules[0].status,
+    json: { error },
+    headers: { [BLOCKED_HEADER]: "blocked" }
+  };
+}
 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();
@@ -302,8 +407,20 @@ function patchFetch(state) {
         }
       );
     };
+    const passOn = () => {
+      const blocked = blockedResponse(state, method, url);
+      if (!blocked) return real();
+      entry.blocked = true;
+      if (isOffline(blocked)) {
+        finishEntry(entry, { error: `${OFFLINE_MESSAGE} (strict network)` });
+        return Promise.reject(new TypeError(OFFLINE_MESSAGE));
+      }
+      const { status, text } = responseParts(blocked);
+      finishEntry(entry, { status, responseBody: formatBody(text) });
+      return Promise.resolve(mockedResponse(blocked));
+    };
     const candidates = matchingMocks(state, method, url);
-    if (!candidates.length) return real();
+    if (!candidates.length) return passOn();
     const request = async () => {
       let body = requestBody;
       if (body === void 0 && init?.body === void 0 && req.clone) {
@@ -322,7 +439,7 @@ function patchFetch(state) {
       throw error;
     });
     return answered.then(async (hit) => {
-      if (!hit) return real();
+      if (!hit) return passOn();
       entry.mocked = true;
       await sleep(hit.mock.delayMs);
       if (init?.signal?.aborted) {
@@ -373,9 +490,9 @@ 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);
+function respond(xhr, mocked, url) {
+  const offline = isOffline(mocked);
+  const { status, text, headers } = responseParts(mocked);
   if (isRN(xhr)) {
     const id = -++fakeRequestId;
     xhr.__didCreateRequest(id);
@@ -454,18 +571,28 @@ function patchXhr(state) {
       url,
       requestBody: formatBody(text)
     });
+    const passOn = () => {
+      const blocked = blockedResponse(state, method, url);
+      if (!blocked) {
+        track(this, entry);
+        return send.call(this, body);
+      }
+      const { status, text: out } = responseParts(blocked);
+      entry.blocked = true;
+      finishEntry(
+        entry,
+        isOffline(blocked) ? { error: `${OFFLINE_MESSAGE} (strict network)` } : { status, responseBody: formatBody(out) }
+      );
+      void Promise.resolve().then(() => {
+        if (!meta.aborted) respond(this, blocked, url);
+      });
+    };
     const candidates = matchingMocks(state, method, url);
-    if (!candidates.length) {
-      track(this, entry);
-      return send.call(this, body);
-    }
+    if (!candidates.length) return passOn();
     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);
-        }
+        if (!hit) return passOn();
         entry.mocked = true;
         await sleep(hit.mock.delayMs);
         if (meta.aborted) {
@@ -478,12 +605,12 @@ function patchXhr(state) {
           entry,
           offline ? { error: `${OFFLINE_MESSAGE} (mocked offline)` } : { status, responseBody: formatBody(out) }
         );
-        respond(this, hit, url);
+        respond(this, hit.response, url);
       },
       (error) => {
         entry.mocked = true;
         finishEntry(entry, { error: errorMessage(error) });
-        respond(this, { mock: candidates[0], response: { offline: true } }, url);
+        respond(this, { offline: true }, url);
       }
     );
   };
@@ -513,6 +640,18 @@ function mockRequests(routes) {
     for (const m of added) m.remove();
   };
 }
+function mockApi(baseUrl, routes, options) {
+  return mockRequests(apiRoutes(baseUrl, routes, options));
+}
+function strictNetwork(options = {}) {
+  installNetwork();
+  const state = networkState();
+  const rule = strictRule(options);
+  state.strictApp.push(rule);
+  return () => {
+    state.strictApp = state.strictApp.filter((r) => r !== rule);
+  };
+}
 var describeMock = (m) => ({
   id: m.id,
   source: m.source,
@@ -556,13 +695,39 @@ function networkTools(options = {}) {
       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.strict": {
+      description: "Strict mode: requests no mock answers fail with a 501 (or like offline) instead of reaching a server. [true | false | { allow?: [substring | { regex }], status?, offline? }] sets it for the agent, [null] follows the app again; no args reads it. Returns { strict, source, allow, blocked }.",
+      run: (...args) => {
+        if (args.length) {
+          const value = args[0];
+          if (value === null || value === void 0) state.strictAgent = null;
+          else if (value === false) state.strictAgent = false;
+          else if (value === true) state.strictAgent = strictRule();
+          else if (typeof value === "object") state.strictAgent = strictRule(value);
+          else throw new Error("Pass true, false, null or { allow?, status?, offline? }");
+        }
+        const rules = strictRules(state);
+        return {
+          strict: rules.length > 0,
+          source: state.strictAgent !== null ? "agent" : rules.length ? "app" : null,
+          allow: rules.flatMap((r) => r.allowShown),
+          blocked: [...state.blocked.values()].slice(-20).reverse()
+        };
+      }
+    },
     "net.clear": {
-      description: "Empty the request log. Returns how many entries it held.",
-      run: () => state.log.splice(0).length
+      description: "Empty the request log and the strict-mode blocked list. Returns how many log entries it held.",
+      run: () => {
+        state.blocked.clear();
+        return 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)
+      description: "Undo the agent's network changes: remove agent mocks and its net.strict setting, keep the app's. Returns how many mocks were removed.",
+      run: () => {
+        state.strictAgent = null;
+        return removeMocks(state, isAgent);
+      }
     }
   };
 }

package/dist/network/index.d.cts

@@ -1,4 +1,4 @@
-import { T as Tools } from '../types-C6DUUHnB.cjs';
+import { T as Tools } from '../types-6kKQsLC1.cjs';
 
 /** Which requests a mock answers. A bare string is a URL substring. */
 type MockMatch = string | {
@@ -57,6 +57,33 @@ type LogEntry = {
     responseBody?: string;
     error?: string;
     mocked?: boolean;
+    /** Failed by strict mode: no mock answered it. */
+    blocked?: boolean;
+};
+type StrictOptions = {
+    /** URLs strict mode lets through to the network: substrings or RegExps. */
+    allow?: Array<string | RegExp>;
+    /** Status of the error response. Default 501. */
+    status?: number;
+    /** Fail like a network failure instead of answering with a status. */
+    offline?: boolean;
+};
+
+/** What a `mockApi` handler sees: the request, plus its path params and query. */
+type ApiRequest = MockRequest & {
+    /** `:name` segments of the route, and `*` as "*". */
+    params: Record<string, string>;
+    query: Record<string, string>;
+};
+type ApiHandler = (request: ApiRequest) => MockResponse | undefined | Promise<MockResponse | undefined>;
+/** "METHOD /path" (or "/path" for any method) → a response or a handler. */
+type ApiRoutes = Record<string, MockResponse | ApiHandler>;
+type MockApiOptions = Omit<MockOptions, 'id'> & {
+    /**
+     * Registering again with the same id replaces these routes (handy with
+     * Fast Refresh). Each route's mock id is `<id> <METHOD /path>`.
+     */
+    id?: string;
 };
 
 /**
@@ -75,6 +102,22 @@ declare function mock(match: MockMatch, response: MockResponse | MockHandler, op
 };
 /** Registers several app mocks. Returns a function that removes them. */
 declare function mockRequests(routes: MockRoute[]): () => void;
+/**
+ * Answers many endpoints under one base URL, e.g. a scenario's fixtures:
+ * `mockApi(API, { 'GET /me': { json: user }, 'GET /plants/:id': ({ params }) => ... })`.
+ * `:name` matches a path segment and `*` the rest; the query string is ignored.
+ * Pass '' as the base URL to match the path on any host. Returns a function
+ * that removes the routes.
+ */
+declare function mockApi(baseUrl: string, routes: ApiRoutes, options?: MockApiOptions): () => void;
+/**
+ * Strict mode: a fetch or XMLHttpRequest that no mock answers fails with an
+ * error response (501 by default, or like offline with `offline: true`) and
+ * a console error naming it, instead of
+ * reaching a server. Only JS requests: native networking (images, native
+ * SDKs, WebSockets) isn't covered. Returns a function that turns it off.
+ */
+declare function strictNetwork(options?: StrictOptions): () => void;
 type NetworkToolsOptions = {
     /** Extra URLs never to log or mock: substrings or RegExps. */
     skip?: Array<string | RegExp>;
@@ -82,4 +125,4 @@ type NetworkToolsOptions = {
 /** Read the request log and mock responses: `net.*`. */
 declare function networkTools(options?: NetworkToolsOptions): Tools;
 
-export { type LogEntry, type MockHandler, type MockMatch, type MockOptions, type MockRequest, type MockResponse, type MockRoute, type NetworkToolsOptions, installNetwork, mock, mockRequests, networkTools };
+export { type ApiHandler, type ApiRequest, type ApiRoutes, type LogEntry, type MockApiOptions, type MockHandler, type MockMatch, type MockOptions, type MockRequest, type MockResponse, type MockRoute, type NetworkToolsOptions, type StrictOptions, installNetwork, mock, mockApi, mockRequests, networkTools, strictNetwork };

package/dist/noop/index.cjs

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var noop_exports = {};
 __export(noop_exports, {
   cdpTransport: () => cdpTransport,
+  createGate: () => createGate,
   settle: () => settle,
   startAgentBridge: () => startAgentBridge,
   useAgentBridge: () => useAgentBridge
@@ -34,3 +35,11 @@ var useAgentBridge = () => {
 };
 var cdpTransport = inert;
 var settle = () => Promise.resolve({ commits: 0, ms: 0 });
+var createGate = (name) => ({
+  name,
+  closed: false,
+  close: () => () => {
+  },
+  subscribe: () => () => {
+  }
+});

package/dist/noop/network.cjs

@@ -22,8 +22,10 @@ var network_exports = {};
 __export(network_exports, {
   installNetwork: () => installNetwork,
   mock: () => mock,
+  mockApi: () => mockApi,
   mockRequests: () => mockRequests,
-  networkTools: () => networkTools
+  networkTools: () => networkTools,
+  strictNetwork: () => strictNetwork
 });
 module.exports = __toCommonJS(network_exports);
 var installNetwork = () => {
@@ -32,3 +34,7 @@ var mock = () => ({ id: "", remove: () => false });
 var mockRequests = () => () => {
 };
 var networkTools = () => ({});
+var mockApi = () => () => {
+};
+var strictNetwork = () => () => {
+};

package/dist/realtime/index.d.cts

@@ -1,4 +1,4 @@
-import { T as Tools } from '../types-C6DUUHnB.cjs';
+import { T as Tools } from '../types-6kKQsLC1.cjs';
 
 /** How a message shows up in `realtime.log`. */
 type MessageSummary = {