@keystrokehq/cli 0.0.1

package/dist/workflow-bundler-BPiqVscj-X1PFFAuP.mjs

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+
+import { n as identifierName, o as parseSourceFile, r as isNode } from "./oxc-B3KI3rf_-n9d1hKNq.mjs";
+import { r as formatEnvAccessError, t as createEnvAccessPlugin } from "./detect-env-access-CwkOYeYM-D_BCZqV6.mjs";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import * as path$1 from "node:path";
+import { createHash } from "node:crypto";
+import { rolldown } from "rolldown";
+//#region ../../packages/workflow-builder/dist/workflow-bundler-BPiqVscj.mjs
+function getDefaultExternal() {
+	return [
+		/^node:/,
+		"@swc/core",
+		/^@swc\/core-/,
+		/^@swc\/wasm/,
+		"playwright-core"
+	];
+}
+function createVirtualEntry(filePath, localExportName) {
+	return `${localExportName === "default" ? `export { default } from ${JSON.stringify(filePath)};` : `export { ${localExportName} as default } from ${JSON.stringify(filePath)};`}\nexport * from ${JSON.stringify(filePath)};`;
+}
+function tryResolveRelativeModule(source, importer) {
+	if (!importer || !source.startsWith("./") && !source.startsWith("../")) return null;
+	const importerDir = path$1.dirname(importer);
+	const basePath = path$1.resolve(importerDir, source);
+	const candidates = [
+		basePath,
+		`${basePath}.ts`,
+		`${basePath}.tsx`,
+		`${basePath}.mts`,
+		`${basePath}.js`,
+		`${basePath}.mjs`,
+		path$1.join(basePath, "index.ts"),
+		path$1.join(basePath, "index.tsx"),
+		path$1.join(basePath, "index.mts"),
+		path$1.join(basePath, "index.js"),
+		path$1.join(basePath, "index.mjs")
+	];
+	for (const candidate of candidates) try {
+		if (existsSync(candidate)) return realpathSync.native(candidate);
+	} catch {}
+	return null;
+}
+function collectRuntimeExportNames(resolvedFilePath) {
+	const sourceFile = parseSourceFile(resolvedFilePath, readFileSync(resolvedFilePath, "utf-8"));
+	const exportNames = /* @__PURE__ */ new Set();
+	for (const statement of sourceFile.statements) {
+		const declaration = statement.declaration;
+		if (statement.type === "ExportNamedDeclaration" && isNode(declaration)) {
+			if (Array.isArray(declaration.declarations)) {
+				for (const declarator of declaration.declarations) {
+					if (!isNode(declarator)) continue;
+					const localName = identifierName(declarator.id);
+					if (localName) exportNames.add(localName);
+				}
+				continue;
+			}
+			const localName = identifierName(declaration.id);
+			if (localName) exportNames.add(localName);
+			continue;
+		}
+		if (statement.type === "ExportNamedDeclaration" && Array.isArray(statement.specifiers)) for (const specifier of statement.specifiers) {
+			if (!isNode(specifier) || specifier.type !== "ExportSpecifier") continue;
+			const exportName = identifierName(specifier.exported) ?? identifierName(specifier.local);
+			if (exportName) exportNames.add(exportName);
+		}
+	}
+	return Array.from(exportNames).sort((left, right) => left.localeCompare(right));
+}
+function createDelegateStubModule(exports, resolvedFilePath) {
+	const lines = [
+		`import { Agent, Workflow } from '@keystroke/workflow-core';`,
+		`import { z } from 'zod';`,
+		""
+	];
+	for (const entry of exports) {
+		const binding = entry.exportName === "default" ? "__default_export__" : entry.exportName;
+		if (entry.kind === "workflow") lines.push(`const ${binding} = new Workflow({`, `  id: ${JSON.stringify(entry.authoredId)},`, `  name: ${JSON.stringify(entry.displayName)},`, `  input: z.unknown(),`, `  output: z.unknown(),`, `  run: async () => { throw new Error('Workflow delegate stub should never execute directly'); },`, `});`);
+		else lines.push(`const ${binding} = new Agent({`, `  id: ${JSON.stringify(entry.authoredId)},`, `  name: ${JSON.stringify(entry.displayName)},`, `  systemPrompt: 'workflow-delegate-stub',`, `  model: 'keystroke/delegate-stub',`, `  input: z.unknown(),`, `  output: z.unknown(),`, `});`);
+		if (entry.exportName === "default") lines.push(`export default ${binding};`);
+		else lines.push(`export { ${binding} };`);
+		lines.push("");
+	}
+	const delegatedExportNames = new Set(exports.map((entry) => entry.exportName));
+	const passthroughExportNames = collectRuntimeExportNames(resolvedFilePath).filter((exportName) => !delegatedExportNames.has(exportName));
+	for (const exportName of passthroughExportNames) {
+		lines.push(`const ${exportName} = z.unknown();`);
+		lines.push(`export { ${exportName} };`);
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+async function bundleTarget(options) {
+	const trackedDependencies = /* @__PURE__ */ new Set();
+	const entryId = "\0virtual:workflow-builder-entry";
+	const exportReference = createVirtualEntry(options.filePath, options.localExportName);
+	const envViolations = [];
+	const delegateStubPrefix = "\0keystroke:delegate-stub:";
+	const bundle = await rolldown({
+		input: entryId,
+		platform: "node",
+		external: options.external ?? getDefaultExternal(),
+		treeshake: true,
+		plugins: [createEnvAccessPlugin(envViolations, options.projectRoot), {
+			name: "workflow-entry",
+			resolveId(source, importer) {
+				if (source === entryId) return entryId;
+				if (options.delegateRegistry) {
+					const resolvedPath = tryResolveRelativeModule(source, importer);
+					if (resolvedPath && options.delegateRegistry[resolvedPath]) return `${delegateStubPrefix}${resolvedPath}`;
+				}
+				return null;
+			},
+			load(id) {
+				if (id === entryId) return exportReference;
+				if (id.startsWith(delegateStubPrefix)) {
+					const resolvedPath = id.slice(25);
+					return createDelegateStubModule(options.delegateRegistry?.[resolvedPath] ?? [], resolvedPath);
+				}
+				return null;
+			},
+			moduleParsed(moduleInfo) {
+				if (!moduleInfo.id.includes("node_modules") && !moduleInfo.id.includes("\0")) trackedDependencies.add(moduleInfo.id);
+			}
+		}]
+	});
+	try {
+		const { output } = await bundle.generate({
+			codeSplitting: false,
+			format: "esm",
+			sourcemap: options.minify ? false : options.sourceMap ?? true,
+			minify: options.minify ?? false,
+			banner: options.agentCompatibilityBanner ? ["import { createRequire as __cr } from \"node:module\"; var require = __cr(import.meta.url);", "if (typeof globalThis.self === \"undefined\") globalThis.self = globalThis;"].join("\n") : void 0
+		});
+		if (envViolations.length > 0) throw new Error(formatEnvAccessError(envViolations));
+		const chunks = output.filter((candidate) => candidate.type === "chunk");
+		if (chunks.length !== 1) throw new Error(`Workflow bundle must produce exactly one chunk for ${options.filePath}`);
+		const [chunk] = chunks;
+		if (!chunk) throw new Error(`Expected rolldown to generate a chunk for ${options.filePath}`);
+		const sourceMap = chunk.map ? chunk.map.toString() : null;
+		return {
+			code: chunk.code,
+			sourceMap,
+			hash: createHash("sha256").update(chunk.code).digest("hex"),
+			...sourceMap ? { sourceMapHash: createHash("sha256").update(sourceMap).digest("hex") } : {},
+			localDependencies: Array.from(trackedDependencies).sort((left, right) => left.localeCompare(right)),
+			externalImports: [...new Set([...chunk.imports, ...chunk.dynamicImports])].sort((left, right) => left.localeCompare(right)),
+			size: Buffer.byteLength(chunk.code)
+		};
+	} finally {
+		await bundle.close();
+	}
+}
+async function bundleWorkflowTarget(options) {
+	return bundleTarget({
+		...options,
+		agentCompatibilityBanner: false
+	});
+}
+async function bundleSandboxAgentTarget(options) {
+	return bundleTarget({
+		...options,
+		agentCompatibilityBanner: true
+	});
+}
+//#endregion
+export { bundleWorkflowTarget as n, bundleSandboxAgentTarget as t };