@classytic/arc 2.15.3 → 2.16.0

package/dist/integrations/streamline.mjs

@@ -1,6 +1,22 @@
 import { f as createError, i as NotFoundError, r as ForbiddenError } from "../errors-j4aJm1Wg.mjs";
+import fp from "fastify-plugin";
 //#region src/integrations/streamline.ts
 /**
+* Streamline >= 2.3.3 dead-letter discriminator. The run.status stays
+* `'failed'`; the discrimination is `error.code`:
+*   - `'stale_heartbeat'` — sweeper terminated; transient crash signal.
+*   - `'dead_lettered'`   — exceeded `maxStaleRecoveries`; permanent.
+*   - `'VERSION_MISMATCH'` — engine deployed a step graph the run can't
+*     resume against; admin must rewind / migrate / cancel.
+*
+* Hosts switch on `error.code` for dashboards / alerting.
+*/
+const STREAMLINE_FAILURE_CODES = {
+	STALE_HEARTBEAT: "stale_heartbeat",
+	DEAD_LETTERED: "dead_lettered",
+	VERSION_MISMATCH: "VERSION_MISMATCH"
+};
+/**
 * Full event list published on a streamline workflow's internal `eventBus`
 * (tracks streamline 2.3's `EventPayloadMap` in
 * `@classytic/streamline/src/core/events.ts`).
@@ -44,6 +60,7 @@ const STREAMLINE_TERMINAL_EVENTS = [
 ];
 const streamlinePluginImpl = async (fastify, options) => {
 	const { workflows, prefix = "/workflows", auth = true, bridgeEvents = true, enableStreaming = false, enableHookEndpoint = false, tenantResolver, bypassTenantResolver, permissions: perms } = options;
+	const routeScope = prefix;
 	const bridgeBus = options.bridgeBusEvents ?? false;
 	const registry = /* @__PURE__ */ new Map();
 	for (const wf of workflows) {
@@ -70,10 +87,35 @@ const streamlinePluginImpl = async (fastify, options) => {
 		return check(request);
 	};
 	for (const [id, wf] of registry) {
-		const routePrefix = `${prefix}/${id}`;
+		const routePrefix = `${routeScope}/${id}`;
 		fastify.post(`${routePrefix}/start`, { preHandler: authPreHandler }, async (request, reply) => {
 			if (!await checkPerm("start", request)) throw new ForbiddenError();
-			const { input, meta, idempotencyKey, priority } = request.body ?? {};
+			const body = request.body;
+			if (body !== null && body !== void 0 && typeof body !== "object") throw createError(422, `[Arc/Streamline] '/${id}/start' body must be a JSON object.`, {
+				code: "arc.streamline.invalid_body",
+				workflowId: id
+			});
+			const envelopeKeys = new Set([
+				"input",
+				"meta",
+				"idempotencyKey",
+				"priority"
+			]);
+			const bodyRecord = body ?? {};
+			const unknownKeys = Object.keys(bodyRecord).filter((k) => !envelopeKeys.has(k));
+			const hasInputKey = Object.hasOwn(bodyRecord, "input");
+			if (unknownKeys.length > 0 && !hasInputKey) throw createError(422, `[Arc/Streamline] '/${id}/start' expects '{ input: {...} }'. Got top-level keys [${unknownKeys.join(", ")}] but no 'input' key. Wrap your workflow payload: { "input": { ${unknownKeys.map((k) => `"${k}": ...`).join(", ")} } }.`, {
+				code: "arc.streamline.missing_input_envelope",
+				workflowId: id,
+				received: unknownKeys,
+				expected: "input"
+			});
+			if (unknownKeys.length > 0) throw createError(422, `[Arc/Streamline] '/${id}/start' got unknown top-level keys [${unknownKeys.join(", ")}]. Allowed envelope keys: input, meta, idempotencyKey, priority. Did you mean to nest these under 'input'?`, {
+				code: "arc.streamline.unknown_envelope_keys",
+				workflowId: id,
+				unknown: unknownKeys
+			});
+			const { input, meta, idempotencyKey, priority } = bodyRecord;
 			const tenantOpts = resolveTenantOpts(request);
 			const run = await wf.start(input, {
 				meta,
@@ -161,6 +203,24 @@ const streamlinePluginImpl = async (fastify, options) => {
 			const { runId } = request.params;
 			return await wf.engine.execute(runId);
 		});
+		const deleteRepo = wf.container?.repository;
+		const repoDeleteFn = deleteRepo?.delete;
+		const repoGetByIdFn = deleteRepo?.getById;
+		if (repoDeleteFn && repoGetByIdFn) fastify.delete(`${routePrefix}/runs/:runId`, { preHandler: authPreHandler }, async (request, reply) => {
+			if (!await checkPerm("cancel", request)) throw new ForbiddenError();
+			const { runId } = request.params;
+			const tenantOpts = resolveTenantOpts(request);
+			const repoOpts = {
+				...tenantOpts.tenantId !== void 0 ? { tenantId: tenantOpts.tenantId } : {},
+				...tenantOpts.bypassTenant ? { bypassTenant: true } : {}
+			};
+			if (!await repoGetByIdFn(runId, repoOpts)) throw new NotFoundError(`Workflow run ${runId} not found`);
+			try {
+				await wf.cancel(runId);
+			} catch {}
+			await repoDeleteFn(runId, repoOpts);
+			return reply.status(204).send();
+		});
 		if (wf.engine.waitFor) fastify.get(`${routePrefix}/runs/:runId/wait`, { preHandler: authPreHandler }, async (request, _reply) => {
 			if (!await checkPerm("get", request)) throw new ForbiddenError();
 			const { runId } = request.params;
@@ -239,7 +299,7 @@ const streamlinePluginImpl = async (fastify, options) => {
 	}
 	if (enableHookEndpoint) {
 		let resumeHookFn;
-		fastify.post(`${prefix}/hooks/:token`, { preHandler: authPreHandler }, async (request, _reply) => {
+		fastify.post(`${routeScope}/hooks/:token`, { preHandler: authPreHandler }, async (request, _reply) => {
 			if (!resumeHookFn) resumeHookFn = (await import("@classytic/streamline")).resumeHook;
 			const { token } = request.params;
 			const result = await resumeHookFn(token, request.body);
@@ -249,7 +309,7 @@ const streamlinePluginImpl = async (fastify, options) => {
 			};
 		});
 	}
-	fastify.get(prefix, { preHandler: authPreHandler }, async () => {
+	fastify.get(routeScope || "/", { preHandler: authPreHandler }, async () => {
 		return Array.from(registry.entries()).map(([id, wf]) => ({
 			id,
 			name: wf.definition.name ?? id,
@@ -257,10 +317,23 @@ const streamlinePluginImpl = async (fastify, options) => {
 		}));
 	});
 	fastify.addHook("onClose", async () => {
-		for (const wf of registry.values()) wf.shutdown?.();
+		for (const wf of registry.values()) {
+			wf.shutdown?.();
+			wf.container?.dispose?.();
+		}
 	});
 };
-/** Pluggable streamline integration for Arc */
-const streamlinePlugin = streamlinePluginImpl;
+/**
+* Pluggable streamline integration for Arc.
+*
+* Wrapped in `fastify-plugin` so Fastify treats `options.prefix` as a
+* plain plugin option (NOT an encapsulation prefix). Without the wrapper,
+* Fastify would prepend `options.prefix` to every route, then the plugin
+* code would prepend it again — the duplicate-prefix bug.
+*/
+const streamlinePlugin = fp(streamlinePluginImpl, {
+	name: "streamline-routes",
+	fastify: "5.x"
+});
 //#endregion
-export { STREAMLINE_BUS_EVENTS, STREAMLINE_TERMINAL_EVENTS, streamlinePlugin };
+export { STREAMLINE_BUS_EVENTS, STREAMLINE_FAILURE_CODES, STREAMLINE_TERMINAL_EVENTS, streamlinePlugin };

package/dist/integrations/websocket-redis.d.mts

@@ -1,4 +1,4 @@
-import { c as WebSocketAdapter } from "../websocket-ChC2rqe1.mjs";
+import { c as WebSocketAdapter } from "../websocket-BkjeGZRn.mjs";
 
 //#region src/integrations/websocket-redis.d.ts
 interface RedisLike {

package/dist/integrations/websocket.d.mts

@@ -1,2 +1,2 @@
-import { a as WebSocketMessage, c as WebSocketAdapter, i as WebSocketClient, n as websocketPlugin, o as WebSocketPluginOptions, r as AuthResult, s as LocalWebSocketAdapter, t as RoomManager } from "../websocket-ChC2rqe1.mjs";
+import { a as WebSocketMessage, c as WebSocketAdapter, i as WebSocketClient, n as websocketPlugin, o as WebSocketPluginOptions, r as AuthResult, s as LocalWebSocketAdapter, t as RoomManager } from "../websocket-BkjeGZRn.mjs";
 export { AuthResult, LocalWebSocketAdapter, RoomManager, WebSocketAdapter, WebSocketClient, WebSocketMessage, WebSocketPluginOptions, websocketPlugin };

package/dist/integrations/websocket.mjs

@@ -375,6 +375,7 @@ const websocketPluginImpl = async (fastify, options) => {
 		if (room.startsWith("org:")) {
 			const parts = room.split(":");
 			const orgId = parts[1];
+			if (!orgId) return;
 			const actualRoom = parts.slice(2).join(":");
 			rooms.broadcastToOrg(orgId, actualRoom, message);
 		} else rooms.broadcast(room, message);

package/dist/loadResourcesFromEntry-BLMEI2Xa.mjs

@@ -0,0 +1,51 @@
+import { t as ResourceRegistry } from "./ResourceRegistry-f48hFk3m.mjs";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+//#region src/cli/utils/loadResourcesFromEntry.ts
+/**
+* Shared loader for CLI commands that need to read a host's resource graph
+* from a built entry file (`introspect`, `docs`, `describe`).
+*
+* Each command historically duplicated the same dance: `pathToFileURL` →
+* dynamic `import()` → walk the module's exports → match anything that
+* looks structurally like a `ResourceDefinition` (carries `name`,
+* `_registryMeta`, `toPlugin`) → register into a fresh `ResourceRegistry`.
+* Extracting the duplication here means a future signature change to
+* the registry surface or the resource-shape sentinel only touches one
+* spot.
+*
+* The structural match (vs `instanceof ResourceDefinition`) is deliberate:
+* the host's entry file is a compiled `dist/` artifact that may have been
+* built against a different arc minor version, so a class-identity check
+* would reject genuinely-compatible objects across version drift.
+*/
+/**
+* Load the host's entry file, walk its exports, and register every
+* `ResourceDefinition`-shaped value into a fresh `ResourceRegistry`.
+*
+* Returns `{ registry, registered }`:
+*   - `registry` is populated and ready to query (`getAll()`, `getStats()`,
+*     `getIntrospection()`).
+*   - `registered` is the count — callers can short-circuit with a
+*     friendly "no resources found" message when it's zero.
+*/
+async function loadResourcesFromEntry(entryPath) {
+	const entryModule = await import(pathToFileURL(resolve(process.cwd(), entryPath)).href);
+	const registry = new ResourceRegistry();
+	let registered = 0;
+	const tryRegister = (value) => {
+		if (value && typeof value === "object" && "name" in value && "_registryMeta" in value && "toPlugin" in value) {
+			const resourceLike = value;
+			registry.register(resourceLike, resourceLike._registryMeta ?? {});
+			registered++;
+		}
+	};
+	for (const exported of Object.values(entryModule)) if (Array.isArray(exported)) for (const entry of exported) tryRegister(entry);
+	else tryRegister(exported);
+	return {
+		registry,
+		registered
+	};
+}
+//#endregion
+export { loadResourcesFromEntry as t };