npm - blokctl - Versions diffs - 1.2.0 → 1.4.0 - Mend

blokctl 1.2.0 → 1.4.0

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 (693) hide show

package/dist/scaffold-repo/triggers/http/src/nodes/examples/chat-ui/index.html ADDED Viewed

@@ -0,0 +1,228 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title><%= title %></title>
+<style>
+  :root {
+    color-scheme: light dark;
+    --bg: #0b0d12;
+    --panel: #14171f;
+    --border: #232a36;
+    --text: #e6e9ef;
+    --muted: #8a91a0;
+    --accent: #7c5cff;
+    --user-bubble: #2a3144;
+    --asst-bubble: #161a24;
+  }
+  * { box-sizing: border-box; }
+  html, body { height: 100%; margin: 0; }
+  body {
+    font-family: ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+    background: var(--bg);
+    color: var(--text);
+    display: flex;
+    flex-direction: column;
+  }
+  header {
+    padding: 14px 20px;
+    border-bottom: 1px solid var(--border);
+    display: flex;
+    align-items: baseline;
+    gap: 12px;
+  }
+  header h1 { margin: 0; font-size: 16px; font-weight: 600; letter-spacing: -0.01em; }
+  header .muted { color: var(--muted); font-size: 12px; }
+  header .status { margin-left: auto; font-size: 12px; color: var(--muted); }
+  header .status .dot { display: inline-block; width: 8px; height: 8px; border-radius: 50%; background: #6b7280; margin-right: 6px; vertical-align: 1px; }
+  header .status.connected .dot { background: #10b981; }
+  main {
+    flex: 1;
+    overflow-y: auto;
+    padding: 24px 20px 16px;
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+    max-width: 760px;
+    width: 100%;
+    margin: 0 auto;
+  }
+  .msg { padding: 10px 14px; border-radius: 12px; max-width: 80%; line-height: 1.45; white-space: pre-wrap; word-wrap: break-word; }
+  .msg.user { align-self: flex-end; background: var(--user-bubble); }
+  .msg.assistant { align-self: flex-start; background: var(--asst-bubble); border: 1px solid var(--border); }
+  .msg.assistant.streaming::after { content: "▍"; color: var(--accent); margin-left: 2px; animation: pulse 1s infinite; }
+  @keyframes pulse { 50% { opacity: 0.3; } }
+  .empty { color: var(--muted); text-align: center; margin: 60px 0; font-size: 14px; }
+  footer {
+    border-top: 1px solid var(--border);
+    padding: 12px 20px;
+    background: var(--panel);
+  }
+  .composer { max-width: 760px; margin: 0 auto; display: flex; gap: 10px; align-items: flex-end; }
+  textarea {
+    flex: 1;
+    background: var(--bg);
+    color: var(--text);
+    border: 1px solid var(--border);
+    border-radius: 10px;
+    padding: 10px 12px;
+    font: inherit;
+    resize: none;
+    min-height: 44px;
+    max-height: 200px;
+    outline: none;
+  }
+  textarea:focus { border-color: var(--accent); }
+  button {
+    background: var(--accent);
+    color: white;
+    border: none;
+    padding: 10px 18px;
+    border-radius: 10px;
+    font: inherit;
+    font-weight: 500;
+    cursor: pointer;
+    height: 44px;
+  }
+  button:disabled { opacity: 0.5; cursor: not-allowed; }
+</style>
+</head>
+<body>
+<header>
+  <h1><%= title %></h1>
+  <span class="muted">SSE + LLM streaming demo</span>
+  <span class="status" id="status"><span class="dot"></span><span id="status-text">connecting…</span></span>
+</header>
+<main id="messages">
+  <div class="empty" id="empty">Say hi to kick off a streaming chat. Tokens arrive over SSE from the Blok bus.</div>
+</main>
+<footer>
+  <form class="composer" id="composer">
+    <textarea id="input" placeholder="Type a message and press Enter…" rows="1"></textarea>
+    <button type="submit" id="send">Send</button>
+  </form>
+</footer>
+<script>
+(function () {
+  const ENDPOINT_BASE = <%- JSON.stringify(endpointBase) %>;
+  const PERSIST_SESSION = <%- persistSession ? "true" : "false" %>;
+  const BODY_MODE = <%- JSON.stringify(bodyMode) %>;
+  const SESSION_STORAGE_KEY = "blok-chat-session:" + ENDPOINT_BASE;
+  function newSessionId() {
+    return (crypto.randomUUID && crypto.randomUUID()) || ("s-" + Math.random().toString(36).slice(2));
+  }
+  let sessionId;
+  if (PERSIST_SESSION) {
+    try {
+      sessionId = localStorage.getItem(SESSION_STORAGE_KEY) || newSessionId();
+      localStorage.setItem(SESSION_STORAGE_KEY, sessionId);
+    } catch { sessionId = newSessionId(); }
+  } else {
+    sessionId = newSessionId();
+  }
+  const messagesEl = document.getElementById("messages");
+  const emptyEl = document.getElementById("empty");
+  const inputEl = document.getElementById("input");
+  const sendBtn = document.getElementById("send");
+  const composer = document.getElementById("composer");
+  const statusEl = document.getElementById("status");
+  const statusText = document.getElementById("status-text");
+  // running conversation history; sent in full on every POST so the
+  // LLM sees prior turns. Production code would persist this server-side.
+  const history = [];
+  let activeAssistantEl = null;
+  function appendMessage(role, content) {
+    if (emptyEl) emptyEl.remove();
+    const el = document.createElement("div");
+    el.className = "msg " + role;
+    el.textContent = content;
+    messagesEl.appendChild(el);
+    messagesEl.scrollTop = messagesEl.scrollHeight;
+    return el;
+  }
+  function setStatus(connected, label) {
+    statusEl.classList.toggle("connected", !!connected);
+    statusText.textContent = label;
+  }
+  // Open EventSource — receives streamed tokens for THIS session
+  const es = new EventSource("/sse" + ENDPOINT_BASE + "/" + sessionId);
+  es.addEventListener("open", () => setStatus(true, "connected"));
+  es.addEventListener("error", () => setStatus(false, "reconnecting…"));
+  es.addEventListener("token", (ev) => {
+    try {
+      const { delta } = JSON.parse(ev.data);
+      if (!activeAssistantEl) {
+        activeAssistantEl = appendMessage("assistant", "");
+        activeAssistantEl.classList.add("streaming");
+      }
+      activeAssistantEl.textContent += delta;
+      messagesEl.scrollTop = messagesEl.scrollHeight;
+    } catch (e) { console.error("bad token frame:", ev.data); }
+  });
+  es.addEventListener("done", (ev) => {
+    if (activeAssistantEl) {
+      activeAssistantEl.classList.remove("streaming");
+      try {
+        const { fullText } = JSON.parse(ev.data);
+        if (typeof fullText === "string") {
+          activeAssistantEl.textContent = fullText;
+          history.push({ role: "assistant", content: fullText });
+        }
+      } catch {}
+      activeAssistantEl = null;
+    }
+    sendBtn.disabled = false;
+    inputEl.focus();
+  });
+  async function send(text) {
+    if (!text.trim()) return;
+    history.push({ role: "user", content: text });
+    appendMessage("user", text);
+    inputEl.value = "";
+    inputEl.style.height = "auto";
+    sendBtn.disabled = true;
+    try {
+      const body = BODY_MODE === "message"
+        ? { message: text }
+        : { messages: history };
+      const res = await fetch(ENDPOINT_BASE + "/" + sessionId + "/message", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+      });
+      if (!res.ok) {
+        const err = await res.text();
+        appendMessage("assistant", "[error] " + err.slice(0, 200));
+        sendBtn.disabled = false;
+      }
+    } catch (e) {
+      appendMessage("assistant", "[network error] " + e.message);
+      sendBtn.disabled = false;
+    }
+  }
+  composer.addEventListener("submit", (ev) => {
+    ev.preventDefault();
+    send(inputEl.value);
+  });
+  inputEl.addEventListener("keydown", (ev) => {
+    if (ev.key === "Enter" && !ev.shiftKey) {
+      ev.preventDefault();
+      send(inputEl.value);
+    }
+  });
+  inputEl.addEventListener("input", () => {
+    inputEl.style.height = "auto";
+    inputEl.style.height = Math.min(200, inputEl.scrollHeight) + "px";
+  });
+  inputEl.focus();
+})();
+</script>
+</body>
+</html>

package/dist/scaffold-repo/triggers/http/src/nodes/examples/chat-ui/index.ts ADDED Viewed

@@ -0,0 +1,65 @@
+import fs from "node:fs";
+import path from "node:path";
+import { defineNode } from "@blokjs/runner";
+import type { Context } from "@blokjs/shared";
+import ejs from "ejs";
+import { z } from "zod";
+/**
+ * chat-ui — renders a self-contained HTML chat client backed by the
+ * Blok SSE bus + a streaming LLM workflow.
+ *
+ * Parameterized so the same node powers BOTH the v0.6.7 stateless chat
+ * (`/chat`) AND the v0.6.8 Redis-memory chat (`/chat-memory`):
+ *
+ *   - `endpointBase` switches the HTTP POST + SSE URLs (default "/chat" →
+ *     POSTs to /chat/:sid/message, opens EventSource at /sse/chat/:sid).
+ *   - `title` rewrites the page <title> + <h1>.
+ *   - `persistSession=true` stores the generated sessionId in
+ *     localStorage so reloading the tab continues the conversation —
+ *     required for any memory variant to feel like a real chat. Default
+ *     false (preserves the v0.6.7 ephemeral-per-tab behavior).
+ *   - `bodyMode="messages"` (default) ships the full client-side history
+ *     array on every POST (server is stateless). `bodyMode="message"`
+ *     ships only the latest user message — server reconstructs history
+ *     from its own store.
+ */
+const rootDir = path.resolve(__dirname, ".");
+const root = (relPath: string) => path.resolve(rootDir, relPath);
+export default defineNode({
+	name: "chat-ui",
+	description: "Renders the Blok chat demo page (vanilla HTML + EventSource + fetch).",
+	contentType: "text/html",
+	input: z.object({
+		endpointBase: z
+			.string()
+			.default("/chat")
+			.describe(
+				'URL prefix for POST + SSE endpoints. Default "/chat" → POSTs to /chat/:sid/message + EventSource on /sse/chat/:sid.',
+			),
+		title: z.string().default("Blok Chat").describe("Page <title> + <h1>."),
+		persistSession: z
+			.boolean()
+			.default(false)
+			.describe(
+				"Persist sessionId in localStorage so reload continues the same conversation. Required for memory variants.",
+			),
+		bodyMode: z
+			.enum(["messages", "message"])
+			.default("messages")
+			.describe(
+				"POST body shape — `messages` sends full client history; `message` sends only the latest user turn (server reconstructs).",
+			),
+	}),
+	output: z.string(),
+	async execute(_ctx: Context, input) {
+		const content = fs.readFileSync(root("index.html"), "utf8");
+		return ejs.render(content, {
+			endpointBase: input.endpointBase,
+			title: input.title,
+			persistSession: input.persistSession,
+			bodyMode: input.bodyMode,
+		});
+	},
+});

package/dist/scaffold-repo/triggers/http/src/nodes/examples/index.ts ADDED Viewed

@@ -0,0 +1,14 @@
+import ChatUI from "./chat-ui";
+// The example-node bundle registered into --examples scaffolds (via the
+// generated src/Nodes.ts) and auto-discovered by the trigger's own boot.
+// Keep this in lock-step with the shipped example workflows: a node with no
+// workflow referencing it is dead weight in every project (the 2026-07 purge
+// removed 17 such orphans — db-manager, dashboard-generator, workflow-docs,
+// mastra-agent, etc. — see git history to resurrect any of them WITH a
+// registered workflow).
+const ExampleNodes = {
+	"chat-ui": ChatUI,
+};
+export default ExampleNodes;

package/dist/scaffold-repo/triggers/http/src/nodes/runtime-bridge/index.ts ADDED Viewed

@@ -0,0 +1,84 @@
+import { type JsonLikeObject, defineNode } from "@blokjs/runner";
+import type { Context } from "@blokjs/shared";
+import { z } from "zod";
+/**
+ * RuntimeBridge node — forwards execution to an external SDK container via HTTP.
+ *
+ * Constructs an ExecutionRequest from the current ctx.response.data,
+ * POSTs it to the SDK container's /execute endpoint, and returns
+ * the ExecutionResult.data.
+ */
+export default defineNode({
+	name: "runtime-bridge",
+	description: "Forwards execution to an external SDK container via HTTP",
+	input: z.object({
+		url: z.string(),
+		node_name: z.string(),
+	}),
+	output: z.record(z.unknown()),
+	async execute(ctx: Context, input) {
+		// Get the chain data from previous step's output
+		const chainData = (ctx.response?.data as JsonLikeObject) || {};
+		// Construct the ExecutionRequest per the SDK HTTP contract
+		const executionRequest = {
+			node: {
+				name: input.node_name,
+				type: "default",
+				config: {},
+			},
+			context: {
+				id: ctx.id || "cross-runtime-chain",
+				workflow_name: ctx.workflow_name || "cross-runtime-chain",
+				workflow_path: ctx.workflow_path || "/cross-runtime-chain",
+				request: {
+					body: chainData,
+					headers: {},
+					params: {},
+					query: {},
+					method: "POST",
+					url: "/execute",
+					cookies: {},
+					baseUrl: "",
+				},
+				response: {
+					data: null,
+					contentType: "application/json",
+					success: true,
+					error: null,
+				},
+				vars: {},
+				env: {},
+			},
+		};
+		// POST to the SDK container
+		const fetchResponse = await fetch(`${input.url}/execute`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(executionRequest),
+		});
+		if (!fetchResponse.ok) {
+			throw new Error(
+				`SDK container at ${input.url} returned HTTP ${fetchResponse.status}: ${fetchResponse.statusText}`,
+			);
+		}
+		const result = (await fetchResponse.json()) as {
+			success: boolean;
+			data: JsonLikeObject;
+			errors?: unknown;
+		};
+		if (!result.success) {
+			throw new Error(`SDK node "${input.node_name}" at ${input.url} failed: ${JSON.stringify(result.errors)}`);
+		}
+		return result.data as Record<string, unknown>;
+	},
+});

package/dist/scaffold-repo/triggers/http/src/runner/HonoTraceRouterAdapter.ts ADDED Viewed

@@ -0,0 +1,199 @@
+/**
+ * Adapter that bridges the TraceRouter interface from @blokjs/runner to Hono.
+ *
+ * The core/runner package defines a TraceRouter interface that matches Express's
+ * Router API surface (use, get, post, put, delete). This adapter implements that
+ * interface by wrapping each registered handler into a Hono route handler that:
+ *   1. Builds a TraceRequest from the Hono context + raw Node.js IncomingMessage
+ *   2. Builds a TraceResponse that writes to the raw Node.js ServerResponse
+ *   3. Returns RESPONSE_ALREADY_SENT so Hono doesn't try to write its own response
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { HttpBindings } from "@hono/node-server";
+import { RESPONSE_ALREADY_SENT } from "@hono/node-server/utils/response";
+import { Hono } from "hono";
+type AppBindings = { Bindings: HttpBindings };
+/** Mirrors the TraceRequest interface in core/runner/src/tracing/TraceRouter.ts */
+interface TraceRequest {
+	method: string;
+	params: Record<string, string>;
+	query: Record<string, string | undefined>;
+	headers: Record<string, string | string[] | undefined>;
+	body?: unknown;
+	on(event: string, listener: () => void): void;
+}
+/** Mirrors the TraceResponse interface in core/runner/src/tracing/TraceRouter.ts */
+interface TraceResponse {
+	setHeader(name: string, value: string): void;
+	status(code: number): TraceResponse;
+	json(body: unknown): void;
+	write(chunk: string): boolean;
+	end(): void;
+	sendStatus(code: number): void;
+	flushHeaders(): void;
+}
+/**
+ * Build a TraceRequest from a Hono context and the raw Node.js request.
+ */
+function buildTraceRequest(
+	incoming: IncomingMessage,
+	method: string,
+	params: Record<string, string>,
+	query: Record<string, string | undefined>,
+	headers: Record<string, string | string[] | undefined>,
+	body?: unknown,
+): TraceRequest {
+	return {
+		method,
+		params,
+		query,
+		headers,
+		body,
+		on(event: string, listener: () => void) {
+			incoming.on(event, listener);
+		},
+	};
+}
+/**
+ * Build a TraceResponse that wraps the raw Node.js ServerResponse.
+ */
+function buildTraceResponse(outgoing: ServerResponse): TraceResponse {
+	let statusCode = 200;
+	const traceRes: TraceResponse = {
+		setHeader(name: string, value: string) {
+			if (!outgoing.headersSent) {
+				outgoing.setHeader(name, value);
+			}
+		},
+		status(code: number) {
+			statusCode = code;
+			return traceRes;
+		},
+		json(body: unknown) {
+			if (!outgoing.headersSent) {
+				outgoing.writeHead(statusCode, { "Content-Type": "application/json" });
+			}
+			outgoing.end(JSON.stringify(body));
+		},
+		write(chunk: string) {
+			return outgoing.write(chunk);
+		},
+		end() {
+			outgoing.end();
+		},
+		sendStatus(code: number) {
+			outgoing.writeHead(code);
+			outgoing.end();
+		},
+		flushHeaders() {
+			if (!outgoing.headersSent) {
+				outgoing.writeHead(statusCode);
+			}
+			if (typeof outgoing.flushHeaders === "function") {
+				outgoing.flushHeaders();
+			}
+		},
+	};
+	return traceRes;
+}
+type TraceHandler = (req: TraceRequest, res: TraceResponse) => void;
+type TraceMiddleware = (req: TraceRequest, res: TraceResponse, next: () => void) => void;
+/**
+ * Creates a Hono sub-app that adapts the TraceRouter interface.
+ *
+ * Returns:
+ * - `traceAdapter`: Object implementing the TraceRouter interface (use/get/post/put/delete)
+ * - `traceApp`: The Hono sub-app to be mounted on the main app
+ */
+export function createTraceRouterAdapter() {
+	const traceApp = new Hono<AppBindings>();
+	// Store middleware to run before each handler
+	const middlewares: TraceMiddleware[] = [];
+	function wrapHandler(handler: TraceHandler) {
+		return async (c: import("hono").Context<AppBindings>) => {
+			const incoming = c.env.incoming;
+			const outgoing = c.env.outgoing;
+			const url = new URL(c.req.url);
+			const query: Record<string, string | undefined> = {};
+			for (const [key, value] of url.searchParams.entries()) {
+				query[key] = value;
+			}
+			// Parse body for POST/PUT requests
+			let body: unknown;
+			if (c.req.method === "POST" || c.req.method === "PUT") {
+				try {
+					body = await c.req.json();
+				} catch {
+					body = undefined;
+				}
+			}
+			const traceReq = buildTraceRequest(
+				incoming,
+				c.req.method,
+				(c.req.param() as Record<string, string>) || {},
+				query,
+				Object.fromEntries([...c.req.raw.headers.entries()].map(([k, v]) => [k, v])),
+				body,
+			);
+			const traceRes = buildTraceResponse(outgoing);
+			// Run middleware chain
+			let middlewareIndex = 0;
+			const runMiddleware = (): Promise<void> => {
+				return new Promise<void>((resolve) => {
+					if (middlewareIndex >= middlewares.length) {
+						resolve();
+						return;
+					}
+					const mw = middlewares[middlewareIndex++];
+					mw(traceReq, traceRes, () => {
+						runMiddleware().then(resolve);
+					});
+				});
+			};
+			await runMiddleware();
+			// Call the route handler
+			handler(traceReq, traceRes);
+			// The handler writes directly to outgoing — tell Hono not to send its own response
+			return RESPONSE_ALREADY_SENT;
+		};
+	}
+	const traceAdapter = {
+		use(handler: TraceMiddleware) {
+			middlewares.push(handler);
+		},
+		get(path: string, handler: TraceHandler) {
+			traceApp.get(path, wrapHandler(handler));
+		},
+		post(path: string, handler: TraceHandler) {
+			traceApp.post(path, wrapHandler(handler));
+		},
+		put(path: string, handler: TraceHandler) {
+			traceApp.put(path, wrapHandler(handler));
+		},
+		delete(path: string, handler: TraceHandler) {
+			traceApp.delete(path, wrapHandler(handler));
+		},
+	};
+	return { traceAdapter, traceApp };
+}