@xdelivered/emberflow 0.2.0

package/src/store/agentClient.test.ts

@@ -0,0 +1,103 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { cancelAgent, fetchAgentDiff, fetchAvailableAgents, revertAgent, startAgent } from './agentClient';
+import type { AgentIntent } from './agentClient';
+
+afterEach(() => vi.unstubAllGlobals());
+
+const intent: AgentIntent = { action: 'edit-flow', flowId: 'f1', instruction: 'do the thing' };
+
+describe('startAgent', () => {
+  it('posts the intent and returns the agent run id', async () => {
+    const fetchMock = vi.fn(async () => ({
+      ok: true,
+      json: async () => ({ agentRunId: 'run-1' }),
+    }));
+    vi.stubGlobal('fetch', fetchMock);
+
+    const id = await startAgent(intent, { model: 'gpt-5' });
+
+    expect(id).toBe('run-1');
+    expect(fetchMock).toHaveBeenCalledWith(
+      '/api/agent',
+      expect.objectContaining({
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ intent, model: 'gpt-5' }),
+      }),
+    );
+  });
+
+  it('throws with the server error message on failure', async () => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async () => ({ ok: false, status: 400, json: async () => ({ error: 'bad intent' }) })),
+    );
+    await expect(startAgent(intent)).rejects.toThrow('bad intent');
+  });
+});
+
+describe('fetchAgentDiff', () => {
+  it('returns the parsed diff body', async () => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async () => ({ ok: true, json: async () => ({ diff: 'diff --git', files: ['a.json'] }) })),
+    );
+    expect(await fetchAgentDiff('run-1')).toEqual({ diff: 'diff --git', files: ['a.json'] });
+  });
+
+  it('throws on a non-ok response', async () => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async () => ({ ok: false, status: 404, json: async () => ({ error: 'Unknown agent run: run-1' }) })),
+    );
+    await expect(fetchAgentDiff('run-1')).rejects.toThrow('Unknown agent run: run-1');
+  });
+});
+
+describe('revertAgent', () => {
+  it('POSTs to revert and returns the reverted file list', async () => {
+    const fetchMock = vi.fn(async () => ({
+      ok: true,
+      json: async () => ({ reverted: ['flows/hello.json'] }),
+    }));
+    vi.stubGlobal('fetch', fetchMock);
+
+    expect(await revertAgent('run-1')).toEqual({ reverted: ['flows/hello.json'] });
+    expect(fetchMock).toHaveBeenCalledWith('/api/agent/run-1/revert', { method: 'POST' });
+  });
+});
+
+describe('fetchAvailableAgents', () => {
+  it('returns the detected agent list with versions', async () => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async () => ({ ok: true, json: async () => ({ agents: [{ kind: 'codex', version: '0.142.5' }] }) })),
+    );
+    expect(await fetchAvailableAgents()).toEqual([{ kind: 'codex', version: '0.142.5' }]);
+  });
+
+  it('returns [] on a non-ok response', async () => {
+    vi.stubGlobal('fetch', vi.fn(async () => ({ ok: false })));
+    expect(await fetchAvailableAgents()).toEqual([]);
+  });
+
+  it('returns [] when the server is unreachable', async () => {
+    vi.stubGlobal('fetch', vi.fn(async () => { throw new Error('down'); }));
+    expect(await fetchAvailableAgents()).toEqual([]);
+  });
+});
+
+describe('cancelAgent', () => {
+  it('POSTs to cancel', async () => {
+    const fetchMock = vi.fn(async () => ({ ok: true, json: async () => ({ cancelled: true }) }));
+    vi.stubGlobal('fetch', fetchMock);
+
+    await cancelAgent('run-1');
+    expect(fetchMock).toHaveBeenCalledWith('/api/agent/run-1/cancel', { method: 'POST' });
+  });
+
+  it('swallows fetch failures', async () => {
+    vi.stubGlobal('fetch', vi.fn(async () => { throw new Error('down'); }));
+    await expect(cancelAgent('run-1')).resolves.toBeUndefined();
+  });
+});

package/src/store/agentClient.ts

@@ -0,0 +1,131 @@
+/**
+ * Client for the agent-run API (server/agents/*), reached through the Vite
+ * proxy at /api → 127.0.0.1:8092, same-origin as serverRunner.ts/nodeMeta.ts.
+ *
+ * NOTE ON DUPLICATION: the browser bundle cannot import from server/ (it's a
+ * Node-only tree), so `AgentEvent`/`AgentKind` (mirroring server/agents/types.ts)
+ * and `AgentIntent` (mirroring server/agents/prompt.ts) are duplicated here.
+ * Keep this shape in sync by hand if the server types change.
+ */
+
+const BASE = '/api';
+
+export type AgentKind = 'codex' | 'claude';
+
+export interface DetectedAgent {
+  kind: AgentKind;
+  version: string | null;
+}
+
+export interface AgentEvent {
+  type: 'started' | 'message' | 'command' | 'mcp' | 'approval-request' | 'done' | 'error';
+  text?: string; // message/error text
+  command?: string; // for 'command'
+  commandStatus?: 'in_progress' | 'completed' | 'failed';
+  exitCode?: number | null; // for 'command'
+  output?: string; // command aggregated output OR an mcp call's result
+  toolUseId?: string; // for 'command'/'mcp' (Claude) — correlates a tool_use with its later tool_result
+  approvalId?: string; // for 'approval-request' (Claude)
+  usage?: Record<string, number>; // for 'done'
+  mcpServer?: string; // for 'mcp' — e.g. 'emberflow'
+  mcpTool?: string; // for 'mcp' — e.g. 'run_operation'
+  mcpStatus?: 'in_progress' | 'completed' | 'failed';
+}
+
+export type AgentIntent =
+  | { action: 'new-scenario'; flowId: string; instruction: string }
+  | { action: 'edit-node'; flowId: string; nodeId: string; instruction: string }
+  | { action: 'edit-flow'; flowId: string; instruction: string; scaffold?: boolean }
+  | { action: 'new-operation'; location: string; instruction: string }
+  | { action: 'setup-auth'; environment: string; instruction: string }
+  | { action: 'setup-environments'; instruction: string }
+  | { action: 'scout-infrastructure'; instruction: string }
+  | { action: 'cover-operation'; flowId: string; instruction: string }
+  | { action: 'ask'; flowId?: string; instruction: string };
+
+export interface StartAgentOptions {
+  agent?: AgentKind;
+  model?: string;
+  reasoning?: 'low' | 'medium' | 'high';
+}
+
+/** GET /agent/available — which agent CLIs the server detected on PATH, and their versions. Returns [] if unreachable. */
+export async function fetchAvailableAgents(): Promise<DetectedAgent[]> {
+  try {
+    const response = await fetch(`${BASE}/agent/available`);
+    if (!response.ok) return [];
+    const { agents } = (await response.json()) as { agents: DetectedAgent[] };
+    return agents ?? [];
+  } catch {
+    return [];
+  }
+}
+
+/** 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 }),
+  });
+  if (!response.ok) {
+    const body = (await response.json().catch(() => ({}))) as { error?: string };
+    throw new Error(body.error ?? `Failed to start agent (HTTP ${response.status})`);
+  }
+  const { agentRunId } = (await response.json()) as { agentRunId: string };
+  return agentRunId;
+}
+
+/**
+ * Subscribe to an agent run's SSE stream at /agent/:id/events. Each server
+ * event carries its own `type` field mirrored in `data`, so we listen for
+ * every AgentEvent type and hand the parsed payload straight to `onEvent`.
+ * Returns an unsubscribe function.
+ */
+export function streamAgent(agentRunId: string, onEvent: (event: AgentEvent) => void): () => void {
+  const source = new EventSource(`${BASE}/agent/${agentRunId}/events`);
+  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;
+      onEvent(data);
+      if (type === 'done' || type === 'error') source.close();
+    });
+  }
+  source.onerror = () => {
+    if (source.readyState === EventSource.CLOSED) {
+      onEvent({ type: 'error', text: 'Lost connection to the agent event stream' });
+    }
+  };
+  return () => source.close();
+}
+
+export interface AgentDiffResult {
+  diff: string;
+  files: string[];
+}
+
+/** GET /agent/:id/diff */
+export async function fetchAgentDiff(agentRunId: string): Promise<AgentDiffResult> {
+  const response = await fetch(`${BASE}/agent/${agentRunId}/diff`);
+  if (!response.ok) {
+    const body = (await response.json().catch(() => ({}))) as { error?: string };
+    throw new Error(body.error ?? `Failed to fetch agent diff (HTTP ${response.status})`);
+  }
+  return (await response.json()) as AgentDiffResult;
+}
+
+/** POST /agent/:id/revert — returns the list of reverted file paths. */
+export async function revertAgent(agentRunId: string): Promise<{ reverted: string[] }> {
+  const response = await fetch(`${BASE}/agent/${agentRunId}/revert`, { method: 'POST' });
+  if (!response.ok) {
+    const body = (await response.json().catch(() => ({}))) as { error?: string };
+    throw new Error(body.error ?? `Failed to revert agent run (HTTP ${response.status})`);
+  }
+  return (await response.json()) as { reverted: string[] };
+}
+
+/** POST /agent/:id/cancel */
+export async function cancelAgent(agentRunId: string): Promise<void> {
+  await fetch(`${BASE}/agent/${agentRunId}/cancel`, { method: 'POST' }).catch(() => undefined);
+}

package/src/store/apiTree.test.ts

@@ -0,0 +1,17 @@
+import { expect, it } from 'vitest';
+import { buildApiTree } from './apiTree';
+
+it('groups operations into APIs and nested folders, sorted', () => {
+  const tree = buildApiTree([
+    { id: 'a', name: 'Create', path: 'claims/claims/create', http: { method: 'POST', path: '/claims' } },
+    { id: 'b', name: 'Get', path: 'claims/claims/get', http: { method: 'GET', path: '/claims/:id' } },
+    { id: 'c', name: 'Charge', path: 'billing/charge' },
+  ]);
+  expect(tree.map((a) => a.name)).toEqual(['billing', 'claims']); // sorted
+  const claims = tree.find((a) => a.name === 'claims')!;
+  expect(claims.folders[0].name).toBe('claims');
+  expect(claims.folders[0].operations.map((o) => o.id)).toEqual(['a', 'b']); // Create, Get by name
+  expect(claims.folders[0].operations[0].method).toBe('POST');
+  const billing = tree.find((a) => a.name === 'billing')!;
+  expect(billing.operations.map((o) => o.id)).toEqual(['c']); // no folder → directly under api
+});

package/src/store/apiTree.ts

@@ -0,0 +1,73 @@
+export interface OpItem {
+  id: string;
+  name: string;
+  path: string;
+  method?: string;
+  httpPath?: string;
+}
+
+export interface ApiTreeNode {
+  name: string;
+  folders: ApiTreeNode[];
+  operations: OpItem[];
+}
+
+interface OpInput {
+  id: string;
+  name: string;
+  path: string;
+  http?: { method: string; path: string };
+}
+
+function getOrCreateChild(node: ApiTreeNode, name: string): ApiTreeNode {
+  let child = node.folders.find((f) => f.name === name);
+  if (!child) {
+    child = { name, folders: [], operations: [] };
+    node.folders.push(child);
+  }
+  return child;
+}
+
+function sortTree(node: ApiTreeNode): void {
+  node.folders.sort((a, b) => a.name.localeCompare(b.name));
+  node.operations.sort((a, b) => a.name.localeCompare(b.name));
+  for (const folder of node.folders) {
+    sortTree(folder);
+  }
+}
+
+export function buildApiTree(ops: OpInput[]): ApiTreeNode[] {
+  const apis = new Map<string, ApiTreeNode>();
+
+  for (const op of ops) {
+    const segments = op.path.split('/').filter(Boolean);
+    if (segments.length === 0) continue;
+    const [apiName, ...rest] = segments;
+    const folderSegments = rest.slice(0, -1);
+
+    let api = apis.get(apiName);
+    if (!api) {
+      api = { name: apiName, folders: [], operations: [] };
+      apis.set(apiName, api);
+    }
+
+    let node = api;
+    for (const segment of folderSegments) {
+      node = getOrCreateChild(node, segment);
+    }
+
+    const item: OpItem = {
+      id: op.id,
+      name: op.name,
+      path: op.path,
+      method: op.http?.method,
+      httpPath: op.http?.path,
+    };
+    node.operations.push(item);
+  }
+
+  const tree = Array.from(apis.values());
+  tree.forEach(sortTree);
+  tree.sort((a, b) => a.name.localeCompare(b.name));
+  return tree;
+}