@xdelivered/emberflow 0.2.0 → 0.5.0

package/src/store/nodeMeta.ts

@@ -1,7 +1,15 @@
 import type { NodeDefinition } from '../engine';
 
-/** A runner node definition plus its implementation source (for display). */
-export type NodeMeta = NodeDefinition & { source?: string };
+/**
+ * A runner node definition plus its implementation source (for display) and
+ * provenance: `sourceRef` (repo-relative registering file + line) when the
+ * node is project-owned, `builtin: true` when registered from the package.
+ */
+export type NodeMeta = NodeDefinition & {
+  source?: string;
+  sourceRef?: { file: string; line?: number };
+  builtin?: boolean;
+};
 
 /**
  * Fetch the runner's node metadata (GET /api/nodes, same-origin via the

package/src/store/serverRunner.ts

@@ -14,7 +14,10 @@ export interface ErrorHandlerTag {
 }
 
 export interface ServerRunHandlers {
-  onNodeState(nodeId: string, state: NodeRunState): void;
+  /** `workflowId` is the flow the node belongs to: the root flow for parent
+   *  nodes, a child flow's id for nodes executed inside a drilled subflow
+   *  (stepped runs stream child states on the root run's SSE). */
+  onNodeState(workflowId: string, nodeId: string, state: NodeRunState): void;
   onLog(line: LogLine): void;
   onFinished(run: WorkflowRun, errorHandler?: ErrorHandlerTag): void;
   onError(message: string): void;
@@ -336,11 +339,58 @@ export async function startServerRun(
   return runId;
 }
 
-export async function stepServerRun(runId: string): Promise<boolean> {
+/** Request to run a single node in isolation on the runner (POST /node-run). */
+export interface NodeRunRequest {
+  type: string;
+  input: Record<string, unknown>;
+  config?: Record<string, unknown>;
+  environment?: string;
+  safeMode?: boolean;
+  /** Required to equal `environment` when running unsafe against a protected env. */
+  confirm?: string;
+}
+
+/** The runner's isolated node-run result (output redacted, logs captured). */
+export interface NodeRunResult {
+  output?: unknown;
+  error?: string;
+  logs: LogLine[];
+}
+
+/**
+ * Run one node in isolation on the runner: the runner resolves the environment's
+ * secrets/vars, honours safe mode, executes the node's implementation in-process
+ * and redacts the output. Throws on transport failure (runner offline) and on a
+ * non-2xx response (unknown type → 404, bad request → 400).
+ */
+export async function runNodeOnServer(req: NodeRunRequest): Promise<NodeRunResult> {
+  const response = await fetch(`${BASE}/node-run`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(req),
+  });
+  if (!response.ok) {
+    const body = (await response.json().catch(() => ({}))) as { error?: string };
+    throw new Error(body.error ?? `Node run failed (HTTP ${response.status})`);
+  }
+  return (await response.json()) as NodeRunResult;
+}
+
+/** One step of a stepped run. `done` mirrors the old boolean contract;
+ *  stepping onto a Subflow node reports `entered` (the child flow's id plus
+ *  the PARENT's Subflow node id — the entered step itself executes no child
+ *  node), and completing a drilled child reports `exited` (which can co-occur
+ *  with `done` when the child was the last node, or when the child failed). */
+export interface StepResult {
+  done: boolean;
+  entered?: { workflowId: string; nodeId: string };
+  exited?: true;
+}
+
+export async function stepServerRun(runId: string): Promise<StepResult> {
   const response = await fetch(`${BASE}/runs/${runId}/step`, { method: 'POST' });
   if (!response.ok) throw new Error(`Step failed (HTTP ${response.status})`);
-  const { done } = (await response.json()) as { done: boolean };
-  return done;
+  return (await response.json()) as StepResult;
 }
 
 export async function cancelServerRun(runId: string): Promise<void> {
@@ -353,10 +403,11 @@ export function subscribeServerRun(runId: string, handlers: ServerRunHandlers):
 
   source.addEventListener('nodeState', (event) => {
     const data = JSON.parse((event as MessageEvent).data) as {
+      workflowId: string;
       nodeId: string;
       state: NodeRunState;
     };
-    handlers.onNodeState(data.nodeId, data.state);
+    handlers.onNodeState(data.workflowId, data.nodeId, data.state);
   });
   source.addEventListener('log', (event) => {
     const data = JSON.parse((event as MessageEvent).data) as { line: LogLine };

package/src/store/setupClient.ts

@@ -14,6 +14,9 @@ const BASE = '/api';
 
 export interface SetupStatus {
   agents: DetectedAgent[];
+  /** Whether the project root is inside a git repo — agent features snapshot
+   *  changes with git, so the checklist requires this before enabling them. */
+  git: { repo: boolean };
   environments: {
     configured: boolean;
     count: number;
@@ -30,14 +33,16 @@ export interface SetupStatus {
 
 /**
  * Progress across the Welcome checklist's rows, mirrored from
- * WelcomeChecklist's per-row status logic. Powers the StatusBar setup chip;
+ * deriveChecklist's per-row status logic. Powers the StatusBar setup chip;
  * keep in step if rows are added or their completion rules change.
  */
 export function setupProgress(status: SetupStatus): { done: number; total: number } {
+  // NOTE: secrets & auth deliberately have no row (matches deriveChecklist) —
+  // they live in the Manage Environment dialog, not onboarding.
   const rows = [
+    status.git.repo,
     status.agents.length > 0,
     status.environments.configured,
-    status.environments.configured && status.environments.anyAuthConfigured,
     status.skills.claude || status.skills.codex,
     status.infrastructure.present,
     status.ops.count > 1,

package/src/store/sourceNavClient.ts

@@ -0,0 +1,48 @@
+/**
+ * Client for the runner's source navigator (GET /source-file), reached through
+ * the Vite proxy at /api → 127.0.0.1:8092, same-origin as setupClient.ts.
+ * Powers the Inspector's source-reference navigation (SourceNavigator).
+ *
+ * Types are imported TYPE-ONLY from server/sourceNav.ts — erased at build, so
+ * the browser bundle never pulls server code, and the shapes can't drift.
+ */
+import type { SourceFilePayload } from '../../server/sourceNav';
+
+export type {
+  SourceFilePayload,
+  SourceDeclaration,
+  SourceImport,
+  SourceReexport,
+  Resolution,
+} from '../../server/sourceNav';
+
+/** A fetch outcome the navigator can render either way — payload or error text. */
+export type SourceFileFetchResult =
+  | { ok: true; payload: SourceFilePayload }
+  | { ok: false; error: string };
+
+const BASE = '/api';
+
+/**
+ * GET /source-file?path=<repo-relative>. Never throws — errors come back as
+ * `{ok:false}` with status-aware text: 400 → denied, 404 → missing, network
+ * failure → runner unreachable.
+ */
+export async function fetchSourceFile(path: string): Promise<SourceFileFetchResult> {
+  try {
+    const response = await fetch(`${BASE}/source-file?${new URLSearchParams({ path })}`);
+    if (response.ok) {
+      return { ok: true, payload: (await response.json()) as SourceFilePayload };
+    }
+    const body = (await response.json().catch(() => ({}))) as { error?: string };
+    if (response.status === 400) {
+      return { ok: false, error: `Access denied: ${body.error ?? 'path not servable'}` };
+    }
+    if (response.status === 404) {
+      return { ok: false, error: `File not found: ${path}` };
+    }
+    return { ok: false, error: body.error ?? `Source fetch failed (HTTP ${response.status})` };
+  } catch {
+    return { ok: false, error: 'Runner unreachable — start the runner to view source' };
+  }
+}

package/src/store/updateClient.ts

@@ -0,0 +1,50 @@
+/**
+ * Client for the package update notifier (GET /update-status) and one-click
+ * updater (POST /update), reached through the Vite proxy at /api →
+ * 127.0.0.1:8092 — same-origin pattern as setupClient.ts.
+ *
+ * Shapes mirror server/index.ts's /update-status and /update responses by
+ * hand (the browser bundle can't import from server/).
+ */
+
+const BASE = '/api';
+
+export interface UpdateStatus {
+  current: string;
+  /** Absent when the registry check was unavailable. */
+  latest?: string;
+  updateAvailable: boolean;
+}
+
+export interface UpdateResult {
+  ok: boolean;
+  /** True after a successful install — the runner must restart to pick it up. */
+  restartRequired?: boolean;
+  error?: string;
+}
+
+/** GET /update-status — null when the runner is unreachable or errors. */
+export async function fetchUpdateStatus(): Promise<UpdateStatus | null> {
+  try {
+    const response = await fetch(`${BASE}/update-status`);
+    if (!response.ok) return null;
+    return (await response.json()) as UpdateStatus;
+  } catch {
+    return null;
+  }
+}
+
+/** POST /update — runs npm install on the runner. Never throws. */
+export async function postUpdate(): Promise<UpdateResult> {
+  try {
+    const response = await fetch(`${BASE}/update`, { method: 'POST' });
+    const body = (await response.json().catch(() => ({}))) as UpdateResult;
+    return {
+      ok: response.ok && body.ok === true,
+      ...(body.restartRequired !== undefined ? { restartRequired: body.restartRequired } : {}),
+      ...(body.error !== undefined ? { error: body.error } : {}),
+    };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : 'Update request failed' };
+  }
+}