npm - @agentic-surfaces/server - Versions diffs - 0.1.29 → 0.1.31 - Mend

@agentic-surfaces/server 0.1.29 → 0.1.31

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/dist/editor/assets/{index-HQKltIcN.css → index-D-uLRZZ-.css} +1 -1
package/dist/editor/assets/index-DeFJLzQ_.js +298 -0
package/dist/editor/index.html +2 -2
package/dist/http.d.ts +7 -0
package/dist/http.js +94 -14
package/dist/serve.d.ts +2 -0
package/dist/serve.js +7 -2
package/dist/streaming-observer.d.ts +10 -1
package/dist/streaming-observer.js +47 -5
package/package.json +2 -2
package/dist/editor/assets/index-kTJFLfkQ.js +0 -298

package/dist/editor/index.html CHANGED Viewed

@@ -4,8 +4,8 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>agentic-surfaces — workflow editor</title>
-    <script type="module" crossorigin src="/assets/index-kTJFLfkQ.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-HQKltIcN.css">
+    <script type="module" crossorigin src="/assets/index-DeFJLzQ_.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-D-uLRZZ-.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/http.d.ts CHANGED Viewed

@@ -56,6 +56,13 @@ export interface ServerOptions {
     };
     /** Best-effort claude.ai plan usage provider, surfaced (cached) at GET /api/usage. */
     planUsage?: () => Promise<PlanUsage | null>;
+    /**
+     * Hot-reload hook (POST /api/reload). Re-scans the workflows + agents dirs and project config,
+     * rebuilds the in-memory workflow map, and re-registers the scheduler in place. Returns the new
+     * workflow set so the server can serve it from /api/workflows and /api/run without a restart.
+     * When omitted, POST /api/reload is 405 (reload not available in this mode, e.g. run-once).
+     */
+    onReload?: () => Promise<Workflow[]> | Workflow[];
 }
 /** Build an http.Server that serves the workflow-engine API and optional static files. */
 export declare function createServer(opts: ServerOptions): http.Server;

package/dist/http.js CHANGED Viewed

@@ -13,6 +13,14 @@ function json(res, data, status = 200) {
 function notFound(res) {
     json(res, { error: "not found" }, 404);
 }
+/** Max characters of an agent's instructions body we put on the wire — bounded so a long
+ *  definition can't bloat the payload (mirrors streaming-observer's OUTPUT_PREVIEW_CAP). */
+const AGENT_BODY_CAP = 16_000;
+function capBody(s) {
+    return s.length > AGENT_BODY_CAP
+        ? `${s.slice(0, AGENT_BODY_CAP)}\n…(${s.length - AGENT_BODY_CAP} more chars truncated)`
+        : s;
+}
 function sseHeaders(res) {
     res.writeHead(200, {
         "Content-Type": "text/event-stream",
@@ -26,8 +34,15 @@ function writeEvent(res, event) {
 }
 /** Build an http.Server that serves the workflow-engine API and optional static files. */
 export function createServer(opts) {
-    const { observer, workflows = [], staticDir, onRun, config, agents = [], cache, pause, planUsage } = opts;
-    const workflowByName = new Map(workflows.map((w) => [w.name, w]));
+    const { observer, staticDir, onRun, config, agents = [], cache, pause, planUsage, onReload, } = opts;
+    // Live workflow set — mutable so POST /api/reload (+ the fs.watch reload path) can swap it in
+    // place without a server restart. /api/workflows, /api/run, and the graph view all read from here.
+    let workflows = opts.workflows ?? [];
+    let workflowByName = new Map(workflows.map((w) => [w.name, w]));
+    function setWorkflows(next) {
+        workflows = next;
+        workflowByName = new Map(next.map((w) => [w.name, w]));
+    }
     // Cache plan usage briefly — the experimental SDK call spins up a session, so don't hit it per request.
     let usageCache = null;
     const PLAN_USAGE_TTL_MS = 5 * 60_000;
@@ -92,7 +107,9 @@ export function createServer(opts) {
                 json: "application/json",
                 woff2: "font/woff2",
             };
-            res.writeHead(200, { "Content-Type": mime[ext] ?? "application/octet-stream" });
+            res.writeHead(200, {
+                "Content-Type": mime[ext] ?? "application/octet-stream",
+            });
             res.end(buf);
             return true;
         }
@@ -105,17 +122,40 @@ export function createServer(opts) {
         const pathname = url.pathname;
         // CORS preflight
         if (req.method === "OPTIONS") {
-            res.writeHead(204, { "Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "*" });
+            res.writeHead(204, {
+                "Access-Control-Allow-Origin": "*",
+                "Access-Control-Allow-Headers": "*",
+            });
             res.end();
             return;
         }
         // ── API routes ──────────────────────────────────────────────────────────
         if (pathname === "/api/workflows") {
+            // Sub-flow detection: scan ALL workflows' `task.foreach` nodes for the sub-workflow they
+            // fan out into (`config.workflow`), and record which parent(s) invoke each one. A workflow
+            // with a non-empty `invokedBy` is a "sub-flow" — it only runs per-item from a parent and
+            // needs that parent's payload, so the dashboard renders it nested + non-runnable.
+            const invokedBy = new Map();
+            for (const w of workflows) {
+                for (const n of w.nodes) {
+                    if (n.type !== "task.foreach")
+                        continue;
+                    const target = n.config.workflow;
+                    if (typeof target !== "string" || target.trim() === "")
+                        continue;
+                    const parents = invokedBy.get(target) ?? [];
+                    if (!parents.includes(w.name))
+                        parents.push(w.name);
+                    invokedBy.set(target, parents);
+                }
+            }
             json(res, workflows.map((w) => {
                 const triggerType = w.nodes.find((n) => n.type.startsWith("trigger."))?.type ?? null;
                 return {
                     name: w.name,
                     title: w.title ?? w.name,
+                    // Sidebar grouping (explicit `group:` field or the file's subdir path; undefined = ungrouped).
+                    group: w.group,
                     nodeCount: w.nodes.length,
                     triggerType,
                     // Full graph so the editor can render each workflow without a second fetch.
@@ -125,10 +165,31 @@ export function createServer(opts) {
                     // needs a payload (the editor prompts for one); entry workflows run with no payload.
                     runnable: Boolean(onRun),
                     needsPayload: triggerType === "trigger.command",
+                    // Names of workflows whose `task.foreach` fans out into this one (empty = entry/top-level).
+                    invokedBy: invokedBy.get(w.name) ?? [],
                 };
             }));
             return;
         }
+        // Hot-reload the workflow set (re-scan dirs, rebuild map, re-register the scheduler) without a
+        // restart. The CLI supplies onReload; it returns the freshly-loaded workflows, which we swap into
+        // the live set and broadcast to connected dashboards so they re-fetch.
+        if (pathname === "/api/reload" && req.method === "POST") {
+            if (!onReload) {
+                json(res, { error: "reload is not enabled on this server" }, 405);
+                return;
+            }
+            try {
+                const next = await onReload();
+                setWorkflows(next);
+                observer.notifyWorkflowsChanged();
+                json(res, { reloaded: next.length, workflows: next.map((w) => w.name) }, 200);
+            }
+            catch (err) {
+                json(res, { error: err instanceof Error ? err.message : String(err) }, 500);
+            }
+            return;
+        }
         // Trigger a run from the UI. Fire-and-forget: progress streams via /api/events.
         if (pathname === "/api/run" && req.method === "POST") {
             if (!onRun) {
@@ -136,7 +197,9 @@ export function createServer(opts) {
                 return;
             }
             let body = "";
-            req.on("data", (c) => { body += c; });
+            req.on("data", (c) => {
+                body += c;
+            });
             req.on("end", () => {
                 let parsed;
                 try {
@@ -153,18 +216,25 @@ export function createServer(opts) {
                 }
                 // Don't await — the run streams over SSE; a thrown error is reported
                 // there (and logged by the runner), so the server keeps serving.
-                Promise.resolve(onRun(name, parsed.payload)).catch(() => { });
+                Promise.resolve(onRun(name, parsed.payload)).catch(() => {
+                    /* surfaced via observer */
+                });
                 json(res, { started: name }, 202);
             });
             return;
         }
         // Platform-wide play/pause. GET reports state; POST /api/pause|resume toggles the scheduler.
-        if (pathname === "/api/state" && (req.method === "GET" || req.method === undefined)) {
-            json(res, { paused: pause ? pause.isPaused() : false, controllable: Boolean(pause) });
+        if (pathname === "/api/state" &&
+            (req.method === "GET" || req.method === undefined)) {
+            json(res, {
+                paused: pause ? pause.isPaused() : false,
+                controllable: Boolean(pause),
+            });
             return;
         }
         // Best-effort claude.ai plan usage (session + weekly windows) for the spend/balance box.
-        if (pathname === "/api/usage" && (req.method === "GET" || req.method === undefined)) {
+        if (pathname === "/api/usage" &&
+            (req.method === "GET" || req.method === undefined)) {
             const data = await getCachedPlanUsage();
             json(res, data ?? { available: false });
             return;
@@ -188,7 +258,8 @@ export function createServer(opts) {
             return;
         }
         // Inspect / clear the engine seen-cache (debugging dedup state).
-        if (pathname === "/api/cache" && (req.method === "GET" || req.method === undefined)) {
+        if (pathname === "/api/cache" &&
+            (req.method === "GET" || req.method === undefined)) {
             json(res, cache ? cache.entries() : { seen: [], cursors: [] });
             return;
         }
@@ -198,7 +269,9 @@ export function createServer(opts) {
                 return;
             }
             let body = "";
-            req.on("data", (c) => { body += c; });
+            req.on("data", (c) => {
+                body += c;
+            });
             req.on("end", () => {
                 let key;
                 try {
@@ -222,10 +295,17 @@ export function createServer(opts) {
             return;
         }
         if (pathname === "/api/agents") {
-            // Metadata only — not the full instructions body.
+            // Metadata + parsed frontmatter + the instructions body (capped), so the
+            // node-detail view can show an agent node's full definition file.
             json(res, agents.map((a) => ({
-                name: a.name, model: a.model, effort: a.effort,
-                commands: a.commands ?? null, fallback: a.fallback ?? null,
+                name: a.name,
+                model: a.model,
+                effort: a.effort,
+                profile: a.profile ?? null,
+                commands: a.commands ?? null,
+                fallback: a.fallback ?? null,
+                mcpServers: a.mcpServers ?? null,
+                instructions: capBody(a.instructions ?? ""),
             })));
             return;
         }

package/dist/serve.d.ts CHANGED Viewed

@@ -46,6 +46,8 @@ export interface ServeOptions {
     };
     /** Best-effort claude.ai plan usage provider, surfaced (cached) at GET /api/usage. */
     planUsage?: () => Promise<import("@agentic-surfaces/core").PlanUsage | null>;
+    /** Hot-reload hook (POST /api/reload): re-scan + rebuild the workflow set + scheduler in place. */
+    onReload?: () => Promise<Workflow[]> | Workflow[];
 }
 /**
  * Locate the built editor assets to serve. Checks, in order:

package/dist/serve.js CHANGED Viewed

@@ -31,7 +31,10 @@ export function serve(opts = {}) {
     const host = opts.host ?? "127.0.0.1";
     const staticDir = opts.staticDir ?? resolveEditorDir();
     const server = createServer({
-        observer, port, host, staticDir,
+        observer,
+        port,
+        host,
+        staticDir,
         workflows: opts.workflows,
         onRun: opts.onRun,
         config: opts.config,
@@ -39,6 +42,7 @@ export function serve(opts = {}) {
         cache: opts.cache,
         pause: opts.pause,
         planUsage: opts.planUsage,
+        onReload: opts.onReload,
     });
     server.listen(port, host, () => {
         console.log(`[flow-server] listening on http://${host}:${port}`);
@@ -53,7 +57,8 @@ export function serve(opts = {}) {
 // Only run when executed directly as a script (not when imported as a module).
 const isMain = typeof process !== "undefined" &&
     process.argv[1] != null &&
-    (process.argv[1].endsWith("serve.js") || process.argv[1].endsWith("flow-server"));
+    (process.argv[1].endsWith("serve.js") ||
+        process.argv[1].endsWith("flow-server"));
 if (isMain) {
     const port = parseInt(process.env["PORT"] ?? "4000", 10);
     const staticDir = process.env["STATIC_DIR"];

package/dist/streaming-observer.d.ts CHANGED Viewed

@@ -1,7 +1,7 @@
 import type { RunObserver } from "@agentic-surfaces/core";
 /** A single SSE-ready event that the HTTP layer will broadcast. */
 export interface RunEvent {
-    type: "run:start" | "node:start" | "node:finish" | "node:activity" | "run:finish";
+    type: "run:start" | "node:start" | "node:finish" | "node:activity" | "run:finish" | "workflows:changed";
     workflow: string;
     /** Which run this event belongs to (from the executor) — lets the UI separate concurrent runs. */
     runId?: string;
@@ -29,6 +29,15 @@ export declare class StreamingObserver implements RunObserver {
     private events;
     private listeners;
     private emit;
+    /** Deliver an event to every listener, isolating bad listeners. */
+    private fanout;
+    /**
+     * Notify connected clients that the loaded workflow set changed (after a reload),
+     * so the dashboard re-fetches /api/workflows + refreshes the open graph. This is a
+     * transient signal, NOT part of the run history, so it is fanned out live but NOT
+     * pushed onto the buffer (it must not replay on every SSE reconnect).
+     */
+    notifyWorkflowsChanged(): void;
     /** Subscribe to all future events. Returns an unsubscribe function. */
     subscribe(listener: (event: RunEvent) => void): () => void;
     /** Return a snapshot of all buffered events (safe to call at any time). */

package/dist/streaming-observer.js CHANGED Viewed

@@ -24,7 +24,9 @@ function runLabel(payload) {
 function extractUsage(output) {
     if (output && typeof output === "object" && "usage" in output) {
         const u = output.usage;
-        if (u && typeof u === "object" && typeof u.totalTokens === "number") {
+        if (u &&
+            typeof u === "object" &&
+            typeof u.totalTokens === "number") {
             return u;
         }
     }
@@ -57,6 +59,10 @@ export class StreamingObserver {
     listeners = [];
     emit(event) {
         this.events.push(event);
+        this.fanout(event);
+    }
+    /** Deliver an event to every listener, isolating bad listeners. */
+    fanout(event) {
         for (const listener of this.listeners) {
             try {
                 listener(event);
@@ -66,6 +72,15 @@ export class StreamingObserver {
             }
         }
     }
+    /**
+     * Notify connected clients that the loaded workflow set changed (after a reload),
+     * so the dashboard re-fetches /api/workflows + refreshes the open graph. This is a
+     * transient signal, NOT part of the run history, so it is fanned out live but NOT
+     * pushed onto the buffer (it must not replay on every SSE reconnect).
+     */
+    notifyWorkflowsChanged() {
+        this.fanout({ type: "workflows:changed", workflow: "", ts: Date.now() });
+    }
     /** Subscribe to all future events. Returns an unsubscribe function. */
     subscribe(listener) {
         this.listeners.push(listener);
@@ -83,15 +98,34 @@ export class StreamingObserver {
     }
     // ── RunObserver interface ──────────────────────────────────────────────────
     onRunStart(workflow, payload, runId) {
-        this.emit({ type: "run:start", workflow, runId, label: runLabel(payload), ts: Date.now() });
+        this.emit({
+            type: "run:start",
+            workflow,
+            runId,
+            label: runLabel(payload),
+            ts: Date.now(),
+        });
     }
     onNodeStart(nodeId, runId) {
         // workflow name is unknown at this call-site in the core interface;
         // emit a placeholder so the shape stays consistent.
-        this.emit({ type: "node:start", workflow: "", runId, nodeId, ts: Date.now() });
+        this.emit({
+            type: "node:start",
+            workflow: "",
+            runId,
+            nodeId,
+            ts: Date.now(),
+        });
     }
     onNodeActivity(nodeId, activity, runId) {
-        this.emit({ type: "node:activity", workflow: "", runId, nodeId, meta: activity, ts: Date.now() });
+        this.emit({
+            type: "node:activity",
+            workflow: "",
+            runId,
+            nodeId,
+            meta: activity,
+            ts: Date.now(),
+        });
     }
     onNodeFinish(nodeId, status, meta, runId) {
         // Normalize meta to { output?, error? }. `output` is the node's result (capped for the
@@ -103,7 +137,15 @@ export class StreamingObserver {
             output: "output" in m ? previewOutput(m.output) : undefined,
             usage: extractUsage(m.output),
         };
-        this.emit({ type: "node:finish", workflow: "", runId, nodeId, status, meta: wireMeta, ts: Date.now() });
+        this.emit({
+            type: "node:finish",
+            workflow: "",
+            runId,
+            nodeId,
+            status,
+            meta: wireMeta,
+            ts: Date.now(),
+        });
     }
     onRunFinish(workflow, status, runId) {
         this.emit({ type: "run:finish", workflow, runId, status, ts: Date.now() });

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@agentic-surfaces/server",
-  "version": "0.1.29",
+  "version": "0.1.31",
   "type": "module",
   "license": "MIT",
   "publishConfig": {
@@ -22,7 +22,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@agentic-surfaces/core": "0.1.29"
+    "@agentic-surfaces/core": "0.1.31"
   },
   "repository": {
     "type": "git",