@xdelivered/emberflow 0.2.0 → 0.4.0

package/server/index.ts

@@ -1,4 +1,5 @@
 import { existsSync, watch } from 'node:fs';
+import { randomUUID } from 'node:crypto';
 import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -9,6 +10,7 @@ import {
   mergeMocks,
   validateFlow,
   verifyArtifact,
+  type LogLine,
   type ScenarioDefinition,
   type WorkflowDefinition,
 } from '../src/engine';
@@ -32,8 +34,9 @@ import { buildApiStore, buildRegistries, requireProjectWhenExplicit } from './pr
 import { nodesPayload } from './nodesPayload';
 import { openBrowser } from './openBrowser';
 import { AgentRunManager, AgentStartError } from './agents/runManager';
+import { isGitRepo } from './agents/gitScope';
 import { isMountablePath } from './pathGuard';
-import { detectAgents } from './agents/detect';
+import { detectAgentsCached } from './agents/detect';
 import type { AgentEvent } from './agents/types';
 import type { AgentIntent } from './agents/prompt';
 import { ExpressAdapter } from './runtime/expressAdapter';
@@ -44,6 +47,7 @@ import { isPathWithin } from './pathSafety';
 import { attachCredential } from './authAttach';
 import { redactSecrets } from './redact';
 import { runScenarioSuiteFor, ScenarioTestUsageError } from './testRunner';
+import { checkForUpdate, isLinkedInstall, ownVersion, runNpmInstall } from './updateCheck';
 import { diagnoseOperation } from '../src/engine/diagnostics';
 import { seedParamDefaults } from './normalizeFlow';
 
@@ -160,6 +164,27 @@ const agentRuns = new AgentRunManager(
   // Fresh per run: re-read emberflow/infrastructure.json so a scout that ran
   // earlier this session primes later prompts. Malformed → null (agent guesses).
   () => loadInfrastructure(project ? project.root : projectDir),
+  // Runner-verified setup snapshot for guided-setup prompts: the same facts
+  // /setup-status reports, computed fresh at run start, so the agent starts
+  // from KNOWN state instead of probing for it.
+  () => {
+    const root = project ? project.root : process.cwd();
+    let envs = environmentsFile;
+    try {
+      envs = loadEnvironments(root);
+    } catch {
+      /* keep last good */
+    }
+    const ops = apiStore.list();
+    return {
+      gitRepo: isGitRepo(root),
+      skillsInstalled: skillInstalled(root, 'claude') || skillInstalled(root, 'codex'),
+      environmentsConfigured: envs.configured,
+      infrastructurePresent: readInfrastructure() !== null,
+      opCount: ops.length,
+      onlyHello: ops.length === 1 && ops[0]?.id === 'default/hello',
+    };
+  },
 );
 
 // Hot-reload agent-authored nodes: watch the project's config and rebuild the
@@ -717,6 +742,8 @@ api.post('/runs', async (req: Request, res: Response) => {
       input: effectiveInput,
       mockRun,
       mocks: effectiveMocks,
+      // Step-mode runs get drill-in subflow stepping (see RunRegistry.step).
+      stepped: mode === 'step',
     }));
   } catch (err) {
     res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
@@ -731,23 +758,101 @@ api.post('/runs', async (req: Request, res: Response) => {
   res.status(201).json({ runId });
 });
 
+// Run a single node in isolation (studio's "Run node" affordance). Executes the
+// node's implementation in-process against the resolved environment's
+// secrets/vars, honouring safe mode via resolveRunSafety, and redacts the
+// output through the same choke point runs use. Unknown type → 404. The studio
+// bundles no implementations, so this is the ONLY path to a lone node run.
+api.post('/node-run', async (req: Request, res: Response) => {
+  const { type, input, config, environment, safeMode, confirm } = req.body ?? {};
+  if (typeof type !== 'string' || type.length === 0) {
+    res.status(400).json({ error: 'Body must include a node "type"' });
+    return;
+  }
+  if (input !== undefined && (typeof input !== 'object' || input === null || Array.isArray(input))) {
+    res.status(400).json({ error: 'input must be a plain object' });
+    return;
+  }
+  if (config !== undefined && (typeof config !== 'object' || config === null || Array.isArray(config))) {
+    res.status(400).json({ error: 'config must be a plain object' });
+    return;
+  }
+  if (environment !== undefined && typeof environment !== 'string') {
+    res.status(400).json({ error: 'environment must be a string' });
+    return;
+  }
+  if (safeMode !== undefined && typeof safeMode !== 'boolean') {
+    res.status(400).json({ error: 'safeMode must be a boolean' });
+    return;
+  }
+  if (!runs.executionRegistry.has(type)) {
+    res.status(404).json({ error: `Unknown node type: ${type}` });
+    return;
+  }
+  const environmentName = environment ?? environmentsFile.defaultEnvironment;
+  const environmentDef = environmentsFile.environments[environmentName];
+  if (!environmentDef) {
+    res.status(400).json({ error: `Unknown environment: '${environmentName}'` });
+    return;
+  }
+  const safety = resolveRunSafety(environmentName, environmentDef, { safeMode, confirm });
+  if (!safety.ok) {
+    res.status(400).json({ error: safety.error });
+    return;
+  }
+
+  const { implementation } = runs.executionRegistry.get(type);
+  const runId = `node-run-${randomUUID().slice(0, 8)}`;
+  const logs: LogLine[] = [];
+  const log = (level: LogLine['level'], message: string): void => {
+    logs.push({ timestamp: new Date().toISOString(), level, runId, message });
+  };
+  const nodeInput = (input ?? {}) as Record<string, unknown>;
+
+  let result: { output?: unknown; error?: string; logs: LogLine[] };
+  try {
+    const output = await implementation({
+      input: nodeInput,
+      config: (config ?? {}) as Record<string, unknown>,
+      secrets: environmentDef.secrets,
+      vars: environmentDef.vars,
+      environment: environmentName,
+      safeMode: safety.safeMode,
+      runInput: nodeInput,
+      log,
+      // A node run in isolation has no flow context to resolve child workflows.
+      runSubflow: async () => ({
+        status: 'failed',
+        error: 'Subflow nodes cannot be run in isolation — run the whole operation instead',
+      }),
+    });
+    result = { output, logs };
+  } catch (err) {
+    result = { error: err instanceof Error ? err.message : String(err), logs };
+  }
+  // Redact secret values from the output AND captured logs before responding.
+  res.json(redactSecrets(result, environmentDef.secrets));
+});
+
 api.post('/runs/:id/step', async (req, res) => {
-  const handle = runs.get(req.params.id);
-  if (!handle) {
+  // Drill-aware composite step: stepping INTO a Subflow reports
+  // `entered: { workflowId, nodeId }`, completing the child reports
+  // `exited: true` (see RunRegistry.step). Plain steps report just `done`.
+  const result = await runs.step(req.params.id);
+  if (!result) {
     res.status(404).json({ error: `Unknown run: ${req.params.id}` });
     return;
   }
-  const more = await handle.step();
-  res.json({ done: !more });
+  res.json(result);
 });
 
 api.post('/runs/:id/cancel', (req, res) => {
-  const handle = runs.get(req.params.id);
-  if (!handle) {
+  // Drill-aware: a stepped run drilled into subflows also cancels every
+  // stacked child and unblocks the parent executions (see RunRegistry.cancel).
+  if (!runs.cancel(req.params.id)) {
     res.status(404).json({ error: `Unknown run: ${req.params.id}` });
     return;
   }
-  handle.cancel();
   res.status(204).end();
 });
 
@@ -773,7 +878,7 @@ api.get('/runs/:id/events', (req, res) => {
 });
 
 api.get('/agent/available', (_req: Request, res: Response) => {
-  res.json({ agents: detectAgents() });
+  res.json({ agents: detectAgentsCached() });
 });
 
 // First-run onboarding aggregate for the Welcome checklist (studio's
@@ -796,7 +901,10 @@ api.get('/setup-status', (_req: Request, res: Response) => {
   // A pristine project ships exactly the single `default/hello` example op.
   const onlyHello = ops.length === 1 && ops[0]?.id === 'default/hello';
   res.json({
-    agents: detectAgents(),
+    agents: detectAgentsCached(),
+    // Agent features snapshot changes with git (server/agents/runManager.ts);
+    // the checklist gates them on this. Same notion gitScope's isGitRepo uses.
+    git: { repo: isGitRepo(root) },
     environments: {
       configured: envs.configured,
       // The synthesized "local" fallback is "no environments yet" — report 0.
@@ -826,6 +934,53 @@ function skillInstalled(root: string, harness: 'claude' | 'codex'): boolean {
   );
 }
 
+// Package update notifier: the studio asks once per page load; checkForUpdate
+// caches registry hits for an hour and fails silent — an unreachable registry
+// (or a pre-publish package) just reports "no update".
+api.get('/update-status', async (_req: Request, res: Response) => {
+  const current = ownVersion() ?? '0.0.0';
+  const check = await checkForUpdate(current);
+  if (!check) {
+    res.json({ current, updateAvailable: false });
+    return;
+  }
+  res.json(check);
+});
+
+// One-click updater: npm-installs the latest package into the consumer
+// project. Single-flight — a second click while npm runs gets a 409, not a
+// second npm process fighting over node_modules.
+let updateInFlight = false;
+api.post('/update', async (_req: Request, res: Response) => {
+  if (!project) {
+    res.status(400).json({ ok: false, error: 'not a consumer project — no project is loaded to update' });
+    return;
+  }
+  if (isLinkedInstall(project.root)) {
+    res.status(400).json({
+      ok: false,
+      error:
+        'node_modules/@xdelivered/emberflow is a symlink (file:/npm-link dev setup) — refusing to npm install over it',
+    });
+    return;
+  }
+  if (updateInFlight) {
+    res.status(409).json({ ok: false, error: 'update already running' });
+    return;
+  }
+  updateInFlight = true;
+  try {
+    const result = await runNpmInstall(project.root);
+    if (result.ok) {
+      res.json({ ok: true, restartRequired: true });
+    } else {
+      res.status(500).json({ ok: false, error: result.error });
+    }
+  } finally {
+    updateInFlight = false;
+  }
+});
+
 /** The /setup-status `infrastructure` field: presence + a shallow summary. */
 function infraStatus(): { present: boolean; scannedAt?: string; itemCount?: number } {
   const manifest = readInfrastructure();
@@ -855,11 +1010,12 @@ api.post('/agent', (req: Request, res: Response) => {
     intent.action !== 'setup-auth' &&
     intent.action !== 'setup-environments' &&
     intent.action !== 'scout-infrastructure' &&
+    intent.action !== 'guided-setup' &&
     intent.action !== 'cover-operation' &&
     intent.action !== 'ask'
   ) {
     res.status(400).json({
-      error: `Unsupported intent.action: ${intent.action}. Must be one of new-scenario, edit-node, edit-flow, new-operation, setup-auth, setup-environments, scout-infrastructure, cover-operation, ask.`,
+      error: `Unsupported intent.action: ${intent.action}. Must be one of new-scenario, edit-node, edit-flow, new-operation, setup-auth, setup-environments, scout-infrastructure, guided-setup, cover-operation, ask.`,
     });
     return;
   }
@@ -873,7 +1029,11 @@ api.post('/agent', (req: Request, res: Response) => {
       res.status(400).json({ error: 'Body must include intent: { action: "setup-auth", environment, instruction }' });
       return;
     }
-  } else if (intent.action === 'setup-environments' || intent.action === 'scout-infrastructure') {
+  } else if (
+    intent.action === 'setup-environments' ||
+    intent.action === 'scout-infrastructure' ||
+    intent.action === 'guided-setup'
+  ) {
     // instruction alone is required, already validated above; no flowId/environment needed.
   } else if (intent.action === 'ask') {
     if (intent.flowId !== undefined && typeof intent.flowId !== 'string') {
@@ -975,7 +1135,7 @@ const operationRunEnv = {
 // operation whose http.path collides with one of these would silently never
 // be reached (the internal route, registered first, always wins) — guarded
 // against below rather than left as a silent trap.
-const RESERVED_ROOT_PATHS = ['/healthz', '/nodes', '/samples', '/environments', '/workflows', '/runs', '/agent', '/serving'];
+const RESERVED_ROOT_PATHS = ['/healthz', '/nodes', '/samples', '/environments', '/workflows', '/runs', '/node-run', '/agent', '/serving'];
 
 function collidesWithReservedPath(path: string): boolean {
   return RESERVED_ROOT_PATHS.some((reserved) => path === reserved || path.startsWith(`${reserved}/`));
@@ -1097,6 +1257,22 @@ if (serveStudio) {
   }
 }
 
+// Agent CLIs and node executions must not outlive the runner: agents are
+// spawned detached (their own process group), so without this a killed runner
+// leaves an orphaned agent editing the project — and possibly writing files
+// long after the studio is gone (observed in the wild). Cancel everything,
+// then exit.
+for (const signal of ['SIGINT', 'SIGTERM'] as const) {
+  process.on(signal, () => {
+    try {
+      agentRuns.shutdown();
+      runs.shutdown();
+    } finally {
+      process.exit(0);
+    }
+  });
+}
+
 app.listen(PORT, HOST, () => {
   console.log(`[emberflow-runner] listening on http://${HOST}:${PORT} — ${runs.nodeCount} nodes registered`);
   if (serveStudio) {

package/server/nodeRun.test.ts

@@ -0,0 +1,189 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { spawn, type ChildProcess } from 'node:child_process';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+// Verifies POST /node-run: the studio's "Run node" affordance runs a single
+// node in-process on the runner (execution moved server-side; the studio bundles
+// no node implementations). Boots the actual runner subprocess against a scratch
+// project dir, mirroring runsAuth.test.ts / apiMount.test.ts.
+
+let proc: ChildProcess;
+const PORT = 8155;
+const base = `http://127.0.0.1:${PORT}`;
+let projectDir: string;
+
+async function waitHealthy(url: string, tries = 40): Promise<void> {
+  for (let i = 0; i < tries; i++) {
+    try {
+      if ((await fetch(url)).ok) return;
+    } catch {
+      /* not up yet */
+    }
+    await new Promise((r) => setTimeout(r, 150));
+  }
+  throw new Error('runner did not become healthy');
+}
+
+function bootRunner(port: number, env: Record<string, string | undefined>): ChildProcess {
+  return spawn('npx', ['tsx', 'server/index.ts'], {
+    env: { ...process.env, EMBERFLOW_RUNNER_PORT: String(port), ...env },
+    stdio: 'ignore',
+  });
+}
+
+async function nodeRun(body: unknown): Promise<{ status: number; json: any }> {
+  const res = await fetch(`${base}/api/node-run`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  return { status: res.status, json: await res.json().catch(() => undefined) };
+}
+
+// Fixture secret value — looks like a real credential to redaction logic
+// (>= 6 chars) but is clearly a test fixture, never a live secret.
+const FIXTURE_SECRET = 'fixture-secret-123';
+
+beforeAll(async () => {
+  projectDir = mkdtempSync(join(tmpdir(), 'noderun-'));
+  mkdirSync(join(projectDir, 'emberflow', 'apis', 'default'), { recursive: true });
+  writeFileSync(
+    join(projectDir, 'emberflow.config.mjs'),
+    `export default {
+  registerNodes(registry) {
+    // Embeds a secret in its output AND in a log line — exercises redaction
+    // across both response fields.
+    registry.register(
+      { type: 'EchoSecret', label: 'Echo Secret', traceKind: 'pure', inputSchema: { fields: [] } },
+      async (ctx) => {
+        ctx.log('info', \`fetched key \${ctx.secrets.API_KEY}\`);
+        return { message: \`key is \${ctx.secrets.API_KEY}\` };
+      },
+    );
+    // Throws with the secret embedded in the error message — exercises
+    // redaction on the error path.
+    registry.register(
+      { type: 'ThrowSecret', label: 'Throw Secret', traceKind: 'pure', inputSchema: { fields: [] } },
+      async (ctx) => {
+        throw new Error(\`boom \${ctx.secrets.API_KEY}\`);
+      },
+    );
+    // Echoes ctx.safeMode so tests can observe the resolved safety mode.
+    registry.register(
+      { type: 'EchoSafeMode', label: 'Echo Safe Mode', traceKind: 'pure', inputSchema: { fields: [] } },
+      async (ctx) => ({ safeMode: ctx.safeMode }),
+    );
+  },
+};\n`,
+  );
+  writeFileSync(
+    join(projectDir, 'emberflow.environments.json'),
+    JSON.stringify({
+      defaultEnvironment: 'local',
+      environments: {
+        local: { vars: {}, secrets: {} },
+        leaky: { vars: {}, secrets: { API_KEY: FIXTURE_SECRET } },
+        prod: { protected: true, vars: {}, secrets: {} },
+      },
+    }),
+  );
+
+  proc = bootRunner(PORT, { EMBERFLOW_PROJECT: projectDir });
+  await waitHealthy(`${base}/healthz`);
+}, 20_000);
+
+afterAll(() => {
+  proc?.kill();
+  if (projectDir) rmSync(projectDir, { recursive: true, force: true });
+});
+
+describe('POST /node-run', () => {
+  it('runs a single built-in node in-process and returns its output + logs', async () => {
+    // CheckPlan is a pure built-in: input.user.plan -> { plan, features } + a log.
+    const { status, json } = await nodeRun({
+      type: 'CheckPlan',
+      input: { user: { plan: 'pro' } },
+    });
+    expect(status).toBe(200);
+    expect(json.output).toEqual({ plan: 'pro', features: ['sso', 'audit-log', 'priority-support'] });
+    expect(json.error).toBeUndefined();
+    expect(json.logs.some((l: { message: string }) => l.message.includes('pro'))).toBe(true);
+  });
+
+  it('404s for an unknown node type', async () => {
+    const { status, json } = await nodeRun({ type: 'NoSuchNode', input: {} });
+    expect(status).toBe(404);
+    expect(json.error).toContain('Unknown node type');
+  });
+
+  it('400s when the body omits a node type', async () => {
+    const { status } = await nodeRun({ input: {} });
+    expect(status).toBe(400);
+  });
+
+  it('400s for an unknown environment', async () => {
+    const { status, json } = await nodeRun({
+      type: 'CheckPlan',
+      input: { user: {} },
+      environment: 'ghost',
+    });
+    expect(status).toBe(400);
+    expect(json.error).toContain('Unknown environment');
+  });
+});
+
+describe('POST /node-run redacts secrets at the boundary', () => {
+  it('redacts a secret value embedded in the output and logs, never leaking the raw value', async () => {
+    const { status, json } = await nodeRun({ type: 'EchoSecret', input: {}, environment: 'leaky' });
+    expect(status).toBe(200);
+    expect(json.error).toBeUndefined();
+
+    expect(json.output.message).toContain('«secret:API_KEY»');
+    expect(json.output.message).not.toContain(FIXTURE_SECRET);
+
+    const logMessages = json.logs.map((l: { message: string }) => l.message).join('\n');
+    expect(logMessages).toContain('«secret:API_KEY»');
+    expect(logMessages).not.toContain(FIXTURE_SECRET);
+  });
+
+  it('redacts a secret value embedded in a thrown error message', async () => {
+    const { status, json } = await nodeRun({ type: 'ThrowSecret', input: {}, environment: 'leaky' });
+    expect(status).toBe(200);
+    expect(json.output).toBeUndefined();
+    expect(json.error).toContain('«secret:API_KEY»');
+    expect(json.error).not.toContain(FIXTURE_SECRET);
+  });
+});
+
+describe('POST /node-run gates unsafe runs on protected environments', () => {
+  it('400s an explicit safeMode:false on a protected environment without a matching confirm', async () => {
+    const { status, json } = await nodeRun({
+      type: 'EchoSafeMode',
+      input: {},
+      environment: 'prod',
+      safeMode: false,
+    });
+    expect(status).toBe(400);
+    expect(json.error).toContain("unsafe run on protected environment 'prod' requires confirm");
+  });
+
+  it('accepts safeMode:false on a protected environment with the matching confirm, and the node observes it', async () => {
+    const { status, json } = await nodeRun({
+      type: 'EchoSafeMode',
+      input: {},
+      environment: 'prod',
+      safeMode: false,
+      confirm: 'prod',
+    });
+    expect(status).toBe(200);
+    expect(json.output).toEqual({ safeMode: false });
+  });
+
+  it('defaults to safeMode:true on a protected environment when unspecified', async () => {
+    const { status, json } = await nodeRun({ type: 'EchoSafeMode', input: {}, environment: 'prod' });
+    expect(status).toBe(200);
+    expect(json.output).toEqual({ safeMode: true });
+  });
+});