@avasapp/agent-bridge 0.1.0 → 0.3.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-6kKQsLC1.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/adapters/tanstack-query.d.cts

@@ -1,5 +1,5 @@
 import { QueryClient } from '@tanstack/query-core';
-import { T as Tools } from '../types-C6DUUHnB.cjs';
+import { T as Tools } from '../types-6kKQsLC1.cjs';
 
 /**
  * Read and seed the TanStack Query cache. `query.pin` keeps a seed in place:

package/dist/adapters/zustand.d.cts

@@ -1,4 +1,4 @@
-import { T as Tools } from '../types-C6DUUHnB.cjs';
+import { T as Tools } from '../types-6kKQsLC1.cjs';
 
 /** Anything with zustand's store shape. */
 type StoreLike = {

package/dist/{chunk-UEWFQWCY.js → chunk-S2FYN2R5.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 {
@@ -288,6 +291,119 @@ async function openConnection(options = {}) {
   }
 }
 
+// src/client/log-lines.ts
+function logLine(entry) {
+  const where = entry.during ? ` during ${entry.during}` : entry.after ? ` after ${entry.after}` : "";
+  const first = entry.message.split("\n")[0] ?? "";
+  const text = first.length > 300 ? `${first.slice(0, 300)}...` : first;
+  return `! ${entry.level}${where}: ${text}`;
+}
+
+// src/client/flow.ts
+function flowScenarios(flow) {
+  const declared = [
+    ...flow.scenario === void 0 ? [] : [flow.scenario],
+    ...flow.scenarios ?? []
+  ];
+  return declared.map((s) => {
+    if (typeof s === "string") return { name: s };
+    if (s && typeof s === "object" && typeof s.name === "string") return s;
+    throw new Error(
+      `A flow's scenario is a name or { name, options }, not ${JSON.stringify(s)}`
+    );
+  });
+}
+function parseScenarioFlag(value) {
+  const at = value.indexOf("=");
+  if (at === -1) return { name: value };
+  const name = value.slice(0, at);
+  const raw = value.slice(at + 1);
+  try {
+    return { name, options: JSON.parse(raw) };
+  } catch {
+    throw new Error(
+      `--scenario ${name}: the options after "=" must be JSON, got ${raw}`
+    );
+  }
+}
+function mergeScenarios(declared, extra) {
+  const names = new Set(extra.map((s) => s.name));
+  return [...declared.filter((s) => !names.has(s.name)), ...extra];
+}
+var failedLogs = (error) => error instanceof AgentBridgeCallError ? error.logs : [];
+async function runFlow(bridge, flow, options = {}) {
+  const print = options.print ?? console.log;
+  const needs = mergeScenarios(flowScenarios(flow), options.scenarios ?? []);
+  let n = 0;
+  let total = 0;
+  let errors = 0;
+  const t0 = performance.now();
+  const report = (logs) => {
+    errors += logs.length;
+    for (const e of logs) print(`   ${logLine(e)}`);
+  };
+  const timed = async (tool, ...args) => {
+    try {
+      const result = await bridge.timed(tool, ...args);
+      report(result.logs);
+      return result;
+    } catch (error) {
+      report(failedLogs(error));
+      throw error;
+    }
+  };
+  const call = async (tool, ...args) => (await timed(tool, ...args)).value;
+  const step = async (label, tool, ...args) => {
+    const { value, ms, logs } = await bridge.timed(tool, ...args).catch((error) => {
+      report(failedLogs(error));
+      throw error;
+    });
+    total += ms;
+    print(
+      `${String(++n).padStart(2, "0")} ${label.padEnd(30)} ${ms.toFixed(1).padStart(7)} ms`
+    );
+    report(logs);
+    return value;
+  };
+  const restoreErrors = [];
+  const applied = {};
+  if (needs.length && !bridge.tools().some((t) => t.name === "scenario.apply"))
+    throw new Error(
+      `The flow needs scenario "${needs[0].name}", but the app defines none: pass \`scenarios\` to useAgentBridge.`
+    );
+  try {
+    for (const { name, options: options2 } of needs) {
+      const args = options2 === void 0 ? [name] : [name, options2];
+      applied[name] = await step(`scenario ${name}`, "scenario.apply", ...args);
+    }
+    await flow.default({
+      bridge: { ...bridge, timed, call },
+      call,
+      step,
+      scenarios: applied
+    });
+  } finally {
+    if (needs.length) {
+      try {
+        const result = await step("restore", "bridge.restore");
+        for (const [name, value] of Object.entries(result ?? {})) {
+          const error = value?.error;
+          if (error !== void 0) restoreErrors.push(`${name}: ${String(error)}`);
+        }
+      } catch (error) {
+        restoreErrors.push(
+          `bridge.restore: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      for (const e of restoreErrors) print(`   ! restore failed: ${e}`);
+    }
+  }
+  print(
+    `${n} steps, ${total.toFixed(1)} ms in calls, ${(performance.now() - t0).toFixed(0)} ms wall (${bridge.transport})${errors ? `, ${errors} error${errors === 1 ? "" : "s"}` : ""}`
+  );
+  return { steps: n, errors, restoreErrors };
+}
+
 // src/client/session/client.ts
 import { createConnection } from "net";
 import { createInterface } from "readline";
@@ -556,6 +672,10 @@ export {
   metroHost,
   RUNTIME_MARKER,
   openConnection,
+  logLine,
+  flowScenarios,
+  parseScenarioFlag,
+  runFlow,
   stateDir,
   sessionFiles,
   checkName,

package/dist/cli.js

@@ -5,21 +5,25 @@ import {
   checkName,
   connect,
   connectSession,
+  flowScenarios,
   formatDuration,
   isAlive,
   listDevices,
   listSessions,
+  logLine,
   metroHost,
   openConnection,
   parseDuration,
+  parseScenarioFlag,
   pickSession,
   readSession,
   removeSessionFiles,
+  runFlow,
   sessionFiles,
   sessionRequest,
   stateDir,
   writePrivate
-} from "./chunk-UEWFQWCY.js";
+} from "./chunk-S2FYN2R5.js";
 
 // src/cli.ts
 import { readFile } from "fs/promises";
@@ -27,14 +31,6 @@ import { resolve } from "path";
 import { pathToFileURL } from "url";
 import { parseArgs } from "util";
 
-// src/client/log-lines.ts
-function logLine(entry) {
-  const where = entry.during ? ` during ${entry.during}` : entry.after ? ` after ${entry.after}` : "";
-  const first = entry.message.split("\n")[0] ?? "";
-  const text = first.length > 300 ? `${first.slice(0, 300)}...` : first;
-  return `! ${entry.level}${where}: ${text}`;
-}
-
 // src/client/session/cli.ts
 import { spawn } from "child_process";
 import { existsSync, readFileSync, rmSync as rmSync2 } from "fs";
@@ -480,6 +476,9 @@ Usage
   agent-bridge tools                      Tools the app exposes
   agent-bridge call <tool> [args]         Call a tool. args: a JSON array, or one JSON value
   agent-bridge run <flow.mjs|.ts>         Run a flow: export default async ({ step, call }) => {}
+                                          export const scenario = 'signedIn' applies it first
+                                          and runs bridge.restore after, even on failure
+  agent-bridge scenarios                  Scenarios the app defines (scenario.apply applies one)
   agent-bridge assert-absent <files...>   Fail if a release bundle contains the bridge
 
 Sessions: one connection for all of an agent's calls
@@ -494,6 +493,8 @@ Options
   --transport <name>     auto (default), expo or cdp
   --timeout <ms>         Per-call timeout (default 10000)
   --strict               run: exit non-zero if the app logged an error
+  --scenario <name>      run: also apply this scenario (repeatable). Options as
+                         JSON after "=": --scenario 'signedIn={"user":{"name":"Ada"}}'
   --session <name>       Use this session (env AGENT_BRIDGE_SESSION)
   --no-session           Connect directly even if a session is running
 `;
@@ -517,6 +518,7 @@ async function main() {
       transport: { type: "string" },
       timeout: { type: "string" },
       strict: { type: "boolean" },
+      scenario: { type: "string", multiple: true },
       name: { type: "string" },
       idle: { type: "string" },
       keep: { type: "boolean" },
@@ -583,47 +585,34 @@ async function main() {
       const [file] = rest;
       if (!file) throw new Error("Usage: agent-bridge run <flow file>");
       const flow = await import(pathToFileURL(resolve(file)).href);
+      flowScenarios(flow);
+      const extra = (values.scenario ?? []).map(parseScenarioFlag);
       return withBridge(async (bridge) => {
-        let n = 0;
-        let total = 0;
-        let errors = 0;
-        const t0 = performance.now();
-        const report = (logs) => {
-          errors += logs.length;
-          for (const e of logs) console.log(`   ${logLine(e)}`);
-        };
-        const timed = async (tool, ...args) => {
-          try {
-            const result = await bridge.timed(tool, ...args);
-            report(result.logs);
-            return result;
-          } catch (error) {
-            report(failedLogs(error));
-            throw error;
-          }
-        };
-        const call = async (tool, ...args) => (await timed(tool, ...args)).value;
-        const step = async (label, tool, ...args) => {
-          const { value, ms, logs } = await bridge.timed(tool, ...args).catch(
-            (error) => {
-              report(failedLogs(error));
-              throw error;
-            }
+        const { errors, restoreErrors } = await runFlow(bridge, flow, {
+          scenarios: extra
+        });
+        if (values.strict && errors || restoreErrors.length)
+          process.exitCode = 1;
+      });
+    }
+    case "scenarios":
+      return withBridge(async (bridge) => {
+        if (!bridge.tools().some((t) => t.name === "scenario.list")) {
+          console.log(
+            `${bridge.device.name} defines no scenarios (pass \`scenarios\` to useAgentBridge).`
           );
-          total += ms;
+          return;
+        }
+        const list2 = await bridge.call("scenario.list");
+        console.log(`${bridge.device.name} via ${bridge.transport}`);
+        for (const s of list2) {
           console.log(
-            `${String(++n).padStart(2, "0")} ${label.padEnd(30)} ${ms.toFixed(1).padStart(7)} ms`
+            `  ${s.name.padEnd(20)} ${s.active ? "(active) " : ""}${s.description ?? ""}`
           );
-          report(logs);
-          return value;
-        };
-        await flow.default({ bridge: { ...bridge, timed, call }, call, step });
-        console.log(
-          `${n} steps, ${total.toFixed(1)} ms in calls, ${(performance.now() - t0).toFixed(0)} ms wall (${bridge.transport})${errors ? `, ${errors} error${errors === 1 ? "" : "s"}` : ""}`
-        );
-        if (values.strict && errors) process.exitCode = 1;
+          if (s.options)
+            console.log(`  ${"".padEnd(20)} options: ${JSON.stringify(s.options)}`);
+        }
       });
-    }
     case "session":
       return sessionCommand(rest[0], values);
     case DAEMON_COMMAND: