@xdelivered/emberflow 0.2.0 → 0.5.0

package/src/lib/runbookModel.ts

@@ -1,6 +1,6 @@
-import type { WorkflowDefinition, WorkflowEdge } from '../engine';
-import { computeLoopRegions, topoSort, type LoopRegion } from '../engine';
-import type { NodeRegistry } from '../engine';
+import type { WorkflowDefinition, WorkflowEdge } from '../engine/types';
+import { computeLoopRegions, topoSort, type LoopRegion } from '../engine/validation';
+import type { NodeRegistry } from '../engine/registry';
 import { firstSentence, simpleNodeDescription } from './registerLens';
 
 export interface RunbookStep {

package/src/lib/runbookProjection.test.ts

@@ -209,6 +209,49 @@ describe('projectRunbook', () => {
     expect(proj.steps.get('onStep')!.tech).toBe(`#2 Http · 50ms · ERROR: ${'x'.repeat(80)}`);
   });
 
+  it('drilled view: outcome and receipt match caller-prefixed child log ids (`caller/nodeId`); undrilled does not', () => {
+    const doc = makeDoc();
+    const run = makeRun({
+      nodeStates: {
+        onStep: {
+          status: 'succeeded',
+          startedAt: '2026-01-01T00:00:00.000Z',
+          completedAt: '2026-01-01T00:00:00.100Z',
+          input: { a: 1 },
+          output: { x: 1 },
+        },
+      },
+    });
+    // How a drilled subflow child's logs arrive: nodeId prefixed with the
+    // caller chain (`sub/onStep`, nested per level).
+    const logs: LogLine[] = [
+      { timestamp: 't1', level: 'debug', runId: 'run-1', nodeId: 'sub/onStep', message: '#4 ▶ execute' },
+      { timestamp: 't2', level: 'info', runId: 'run-1', nodeId: 'sub/onStep', message: 'child outcome' },
+    ];
+
+    const drilled = projectRunbook(doc, run, logs, [], FLOW_ID, true);
+    expect(drilled.steps.get('onStep')!.outcome).toBe('child outcome');
+    expect(drilled.steps.get('onStep')!.tech).toBe('#4 Http · 100ms · in[a] → out[x]');
+
+    // Undrilled: suffix matching stays off so a parent node can never pick
+    // up a same-named child's prefixed lines.
+    const plain = projectRunbook(doc, run, logs, [], FLOW_ID);
+    expect(plain.steps.get('onStep')!.outcome).toBe('');
+    expect(plain.steps.get('onStep')!.tech).toBe('Http · 100ms · in[a] → out[x]');
+  });
+
+  it('drilled view: a plain (unprefixed) id must not suffix-match another node ending with the same segment', () => {
+    const doc = makeDoc();
+    const logs: LogLine[] = [
+      // `sub/onStep` ends with `/onStep` but NOT with `/Step` etc.; also an
+      // exact-id line for a different node must not bleed over.
+      { timestamp: 't1', level: 'info', runId: 'run-1', nodeId: 'cond', message: 'cond outcome' },
+    ];
+    const drilled = projectRunbook(doc, makeRun(), logs, [], FLOW_ID, true);
+    expect(drilled.steps.get('onStep')!.outcome).toBe('');
+    expect(drilled.steps.get('cond')!.outcome).toBe('cond outcome');
+  });
+
   it('tech line: no receipt yet means no #N prefix', () => {
     const doc = makeDoc();
     const run = makeRun({ nodeStates: { onStep: { status: 'idle' } } });

package/src/lib/runbookProjection.ts

@@ -56,10 +56,24 @@ function fieldList(value: unknown, label: string): string {
   return `${label}[${shown.join(',')}]`;
 }
 
-function lastInfoOutcome(logs: LogLine[], nodeId: string): string {
+/**
+ * Whether a log line belongs to the given node. A drilled-in subflow child's
+ * log lines carry nodeIds prefixed with the caller chain
+ * (`${callerNodeId}/${childNodeId}`, nested per level — see subflowRunner),
+ * while the drilled view's runbook uses the raw child ids, so when projecting
+ * a drilled child flow a suffix match after a slash also counts. Kept behind
+ * `drilled` so an undriled parent view can never match a child's prefixed
+ * line against a same-named parent node.
+ */
+function lineIsFor(line: LogLine, nodeId: string, drilled: boolean): boolean {
+  if (line.nodeId === nodeId) return true;
+  return drilled && !!line.nodeId && line.nodeId.endsWith(`/${nodeId}`);
+}
+
+function lastInfoOutcome(logs: LogLine[], nodeId: string, drilled: boolean): string {
   for (let i = logs.length - 1; i >= 0; i--) {
     const line = logs[i];
-    if (line.nodeId === nodeId && line.level === 'info') return line.message;
+    if (lineIsFor(line, nodeId, drilled) && line.level === 'info') return line.message;
   }
   return '';
 }
@@ -72,10 +86,10 @@ function lastInfoOutcome(logs: LogLine[], nodeId: string): string {
  * iteration); null when the node has no receipt yet (never executed).
  */
 const RECEIPT_RE = /^#(\d+) ▶ execute/;
-function receiptSeq(logs: LogLine[], nodeId: string): string | null {
+function receiptSeq(logs: LogLine[], nodeId: string, drilled: boolean): string | null {
   for (let i = logs.length - 1; i >= 0; i--) {
     const line = logs[i];
-    if (line.nodeId === nodeId && line.level === 'debug') {
+    if (lineIsFor(line, nodeId, drilled) && line.level === 'debug') {
       const match = RECEIPT_RE.exec(line.message);
       if (match) return match[1];
     }
@@ -152,6 +166,9 @@ export function projectRunbook(
   logs: LogLine[],
   history: RunHistoryEntry[],
   flowId: string,
+  /** True when projecting a drilled-in subflow child view: log lines then
+   *  also match by `…/${nodeId}` suffix (child log ids are caller-prefixed). */
+  drilled = false,
 ): RunbookProjection {
   // ── steps ──
   const steps = new Map<string, StepProjection>();
@@ -160,10 +177,13 @@ export function projectRunbook(
     const status = statusOf(state);
     // A failed node's outcome line is its error, not the last info log (which
     // may be stale from a prior successful attempt or simply absent).
-    const outcome = status === 'failed' ? state?.error || lastInfoOutcome(logs, nodeId) : lastInfoOutcome(logs, nodeId);
+    const outcome =
+      status === 'failed'
+        ? state?.error || lastInfoOutcome(logs, nodeId, drilled)
+        : lastInfoOutcome(logs, nodeId, drilled);
     const durationMs = durationOf(state);
     // `#N` receipt prefix once the node has executed; bare type name before that.
-    const seq = receiptSeq(logs, nodeId);
+    const seq = receiptSeq(logs, nodeId, drilled);
     const prefix = seq ? `#${seq} ` : '';
     const ms = `${durationMs ?? 0}ms`;
     let tech: string;

package/src/nodes/index.ts

@@ -8,9 +8,16 @@ import { registerPradarNodesModule } from './pradar';
 import { registerResponseNodes } from './response';
 import { registerRequireAuthNode } from './requireAuth';
 
-/** All built-in nodes: login examples, Open-Meteo weather, anomaly-detection API, EV charging demo, HTTP Response, requireAuth. */
-export function createDefaultRegistry(delayMs?: number): NodeRegistry {
-  const registry = createLoginRegistry(delayMs);
+/**
+ * All built-in nodes: login examples, Open-Meteo weather, anomaly-detection API, EV charging demo, HTTP Response, requireAuth.
+ * `opts.captureSourceRefs` is threaded from SERVER callers only (buildRegistries)
+ * — this function is shared with the browser bundle, where capture stays off.
+ */
+export function createDefaultRegistry(
+  delayMs?: number,
+  opts?: { captureSourceRefs?: boolean },
+): NodeRegistry {
+  const registry = createLoginRegistry(delayMs, opts);
   registerWeatherNodes(registry);
   registerAnomalyNodes(registry);
   registerFlowControlNodes(registry);

package/src/nodes/login.ts

@@ -12,8 +12,11 @@ function usernamePart(userId: string): string {
  * `delayMs` is injected into every implementation via `await sleep(delayMs)`
  * so tests can run with no delay by passing `0`.
  */
-export function createLoginRegistry(delayMs = 300): NodeRegistry {
-  const registry = new NodeRegistry();
+export function createLoginRegistry(
+  delayMs = 300,
+  opts?: { captureSourceRefs?: boolean },
+): NodeRegistry {
+  const registry = new NodeRegistry(opts);
 
   registry.register(
     {

package/src/store/agentClient.ts

@@ -40,6 +40,7 @@ export type AgentIntent =
   | { action: 'setup-auth'; environment: string; instruction: string }
   | { action: 'setup-environments'; instruction: string }
   | { action: 'scout-infrastructure'; instruction: string }
+  | { action: 'guided-setup'; instruction: string }
   | { action: 'cover-operation'; flowId: string; instruction: string }
   | { action: 'ask'; flowId?: string; instruction: string };
 
@@ -63,11 +64,18 @@ export async function fetchAvailableAgents(): Promise<DetectedAgent[]> {
 
 /** POST /agent — start an agent run, returns its id. */
 export async function startAgent(intent: AgentIntent, opts?: StartAgentOptions): Promise<string> {
-  const response = await fetch(`${BASE}/agent`, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json' },
-    body: JSON.stringify({ intent, ...opts }),
-  });
+  let response: Response;
+  try {
+    response = await fetch(`${BASE}/agent`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ intent, ...opts }),
+    });
+  } catch {
+    // fetch rejects with a bare "Failed to fetch" on network errors — say what
+    // that actually means here and what to do about it.
+    throw new Error('Could not reach the runner — check it is still running, then try again.');
+  }
   if (!response.ok) {
     const body = (await response.json().catch(() => ({}))) as { error?: string };
     throw new Error(body.error ?? `Failed to start agent (HTTP ${response.status})`);
@@ -84,16 +92,27 @@ export async function startAgent(intent: AgentIntent, opts?: StartAgentOptions):
  */
 export function streamAgent(agentRunId: string, onEvent: (event: AgentEvent) => void): () => void {
   const source = new EventSource(`${BASE}/agent/${agentRunId}/events`);
+  // Set once the server delivers the run's terminal event — from then on any
+  // connection-level error (the server closing the response right after) is
+  // expected, not a lost stream, so onerror must stay quiet.
+  let sawTerminal = false;
   const types: AgentEvent['type'][] = ['started', 'message', 'command', 'mcp', 'approval-request', 'done', 'error'];
   for (const type of types) {
     source.addEventListener(type, (event) => {
-      const data = JSON.parse((event as MessageEvent).data) as AgentEvent;
+      // EventSource dispatches its CONNECTION errors as `error` events too —
+      // those carry no data, unlike the server's named `event: error` payloads.
+      const raw = (event as MessageEvent).data as string | undefined;
+      if (raw === undefined) return;
+      const data = JSON.parse(raw) as AgentEvent;
       onEvent(data);
-      if (type === 'done' || type === 'error') source.close();
+      if (type === 'done' || type === 'error') {
+        sawTerminal = true;
+        source.close();
+      }
     });
   }
   source.onerror = () => {
-    if (source.readyState === EventSource.CLOSED) {
+    if (!sawTerminal && source.readyState === EventSource.CLOSED) {
       onEvent({ type: 'error', text: 'Lost connection to the agent event stream' });
     }
   };

package/src/store/apiTree.ts

@@ -71,3 +71,15 @@ export function buildApiTree(ops: OpInput[]): ApiTreeNode[] {
   tree.sort((a, b) => a.name.localeCompare(b.name));
   return tree;
 }
+
+/** Flatten an API tree into every API/folder path (e.g. 'default', 'billing', 'billing/charges'). */
+export function flattenLocations(tree: ApiTreeNode[]): string[] {
+  const paths: string[] = [];
+  const walk = (node: ApiTreeNode, prefix: string) => {
+    const path = prefix ? `${prefix}/${node.name}` : node.name;
+    paths.push(path);
+    for (const folder of node.folders) walk(folder, path);
+  };
+  for (const api of tree) walk(api, '');
+  return paths;
+}