@keystrokehq/cli 0.0.1

package/dist/build-agents-BmM_AsSd-BGi9wtzt.mjs

@@ -0,0 +1,514 @@
+#!/usr/bin/env node
+
+import { n as readOptionalJsonSchemaKeys, t as manifestToDeclaredCredentialRequirement } from "./_manifest-JSRE3H8k.mjs";
+import { t as AgentVersionManifestSchema } from "./agent-manifest-CDnbkR2f.mjs";
+import { i as createAgentSandboxPackage, n as AGENT_VM_PI_SKILLS_ROOT, r as AGENT_VM_TOOLS_RUNTIME_RELATIVE_PATH, t as AGENT_VM_HOST_CALL_RELATIVE_PATH } from "./agent-bundle-package-DWV6B_5q-BtV7Xycc.mjs";
+import { t as readCredentialKeysFromSchemaObject } from "./read-credential-keys-77a91T8M-KA0Iw0Z1.mjs";
+import { t as bundleSandboxAgentTarget } from "./workflow-bundler-BPiqVscj-X1PFFAuP.mjs";
+import { builtinModules } from "node:module";
+import { lstat, readFile, readdir, realpath } from "node:fs/promises";
+import path from "node:path";
+import * as crypto from "node:crypto";
+import { createHash } from "node:crypto";
+import { performance } from "node:perf_hooks";
+//#region ../../packages/workflow-core/src/sandbox/host-call-stub-source.ts
+const HOST_CALL_STUB_SOURCE = [
+	"const __pendingHostCalls = new Map();",
+	"let __hostCallCounter = 0;",
+	"const __DEFAULT_HOST_CALL_STUB_TIMEOUT_MS = 6 * 60 * 1000;",
+	"const __HOST_CALL_NOTIFY_PREFIX = \"__keystroke_host_call__:\";",
+	"const __pi = globalThis.pi;",
+	"const __onCommand =",
+	"  __pi && typeof __pi.onCommand === \"function\" ? __pi.onCommand.bind(__pi) : null;",
+	"const __emitHostCallEvent =",
+	"  __pi && typeof __pi.emit === \"function\"",
+	"    ? (event) => __pi.emit(event)",
+	"    : (event, ui) => {",
+	"        if (!ui || typeof ui.notify !== \"function\") {",
+	"          throw new Error(\"Host call transport is unavailable\");",
+	"        }",
+	"        ui.notify(`${__HOST_CALL_NOTIFY_PREFIX}${JSON.stringify(event)}`);",
+	"      };",
+	"const __supportsHostCallResponses = __onCommand !== null;",
+	"",
+	"export async function __keystrokeHostCall(toolCallId, payload, opts = {}) {",
+	"  const id = `hc_${++__hostCallCounter}`;",
+	"  const timeoutMs = opts.timeoutMs ?? __DEFAULT_HOST_CALL_STUB_TIMEOUT_MS;",
+	"  const traceContext = opts.traceparent",
+	"    ? { traceparent: opts.traceparent, tracestate: opts.tracestate ?? undefined }",
+	"    : null;",
+	"",
+	"  return new Promise((resolve, reject) => {",
+	"    if (!__supportsHostCallResponses) {",
+	"      try {",
+	"        __emitHostCallEvent({",
+	"          type: 'host_call_request',",
+	"          id,",
+	"          toolCallId,",
+	"          traceContext,",
+	"          payload,",
+	"        }, opts.ui);",
+	"        resolve(toFireAndForgetReceipt(payload));",
+	"      } catch (error) {",
+	"        reject(error);",
+	"      }",
+	"      return;",
+	"    }",
+	"",
+	"    const timer = setTimeout(() => {",
+	"      __pendingHostCalls.delete(id);",
+	"      reject(new HostCallStubTimeoutError(id, timeoutMs));",
+	"    }, timeoutMs);",
+	"    __pendingHostCalls.set(id, {",
+	"      resolve: (value) => {",
+	"        clearTimeout(timer);",
+	"        resolve(value);",
+	"      },",
+	"      reject: (error) => {",
+	"        clearTimeout(timer);",
+	"        reject(error);",
+	"      },",
+	"    });",
+	"",
+	"    try {",
+	"      __emitHostCallEvent({",
+	"        type: 'host_call_request',",
+	"        id,",
+	"        toolCallId,",
+	"        traceContext,",
+	"        payload,",
+	"      }, opts.ui);",
+	"    } catch (error) {",
+	"      __pendingHostCalls.delete(id);",
+	"      clearTimeout(timer);",
+	"      reject(error);",
+	"    }",
+	"  });",
+	"}",
+	"",
+	"if (__supportsHostCallResponses) {",
+	"__onCommand('host_call_response', (cmd) => {",
+	"  const pending = __pendingHostCalls.get(cmd.id);",
+	"  if (!pending) return;",
+	"  __pendingHostCalls.delete(cmd.id);",
+	"",
+	"  switch (cmd.result.status) {",
+	"    case 'completed':",
+	"      return pending.resolve({ kind: 'completed', output: cmd.result.output });",
+	"    case 'failed':",
+	"      return pending.reject(asError(cmd.result.error));",
+	"    case 'cancelled':",
+	"      return pending.reject(new HostCallCancelledError());",
+	"    case 'timeout':",
+	"      return pending.reject(new HostCallTimeoutError());",
+	"    case 'yield':",
+	"      return pending.resolve({ kind: 'yield', receipt: cmd.result.yieldReceipt });",
+	"    case 'cred-wait':",
+	"      return pending.resolve({ kind: 'cred-wait', envelope: cmd.result.envelope });",
+	"  }",
+	"});",
+	"}",
+	"",
+	"function toFireAndForgetReceipt(payload) {",
+	"  if (payload && payload.kind === \"child-workflow\") {",
+	"    return {",
+	"      kind: \"yield\",",
+	"      receipt: {",
+	"        pending: true,",
+	"        kind: \"workflow\",",
+	"        reason: \"Workflow tool started and will continue asynchronously.\",",
+	"        _instruction:",
+	"          \"Tell the user the workflow is still running in the background, then end your turn. The platform will resume when it completes.\",",
+	"      },",
+	"    };",
+	"  }",
+	"",
+	"  return {",
+	"    kind: \"yield\",",
+	"    receipt: {",
+	"      pending: true,",
+	"      kind: payload && payload.kind ? payload.kind : \"host-call\",",
+	"      reason: \"Host call started and will continue asynchronously.\",",
+	"    },",
+	"  };",
+	"}",
+	"",
+	"class HostCallCancelledError extends Error {",
+	"  constructor() {",
+	"    super('Host call cancelled');",
+	"    this.name = 'HostCallCancelledError';",
+	"  }",
+	"}",
+	"",
+	"class HostCallTimeoutError extends Error {",
+	"  constructor() {",
+	"    super('Host call timed out');",
+	"    this.name = 'HostCallTimeoutError';",
+	"  }",
+	"}",
+	"",
+	"class HostCallStubTimeoutError extends Error {",
+	"  constructor(id, timeoutMs) {",
+	"    super(`Host call ${id} did not receive a host response within ${timeoutMs}ms`);",
+	"    this.name = 'HostCallStubTimeoutError';",
+	"    this.hostCallId = id;",
+	"    this.timeoutMs = timeoutMs;",
+	"  }",
+	"}",
+	"",
+	"function asError(envelope) {",
+	"  const error = new Error(envelope.message);",
+	"  error.name = envelope.name;",
+	"  error.code = envelope.code;",
+	"  error.category = envelope.category;",
+	"  error.details = envelope.details;",
+	"  return error;",
+	"}"
+].join("\n");
+//#endregion
+//#region ../../packages/workflow-builder/dist/build-agents-BmM_AsSd.mjs
+const STAGED_LOCAL_SOURCES_PREFIX = ".keystroke/staged-local-sources";
+function normalizeRelativeSandboxPath(targetPath) {
+	const normalized = path.posix.normalize(targetPath);
+	if (normalized.length === 0 || normalized === "." || normalized === ".." || normalized.startsWith("../") || path.posix.isAbsolute(normalized)) throw new Error(`Sandbox bootstrap path must stay relative to the sandbox root: ${targetPath}`);
+	return normalized;
+}
+function resolveLocalSourceTarget(sourcePath) {
+	return normalizeRelativeSandboxPath(path.posix.join(STAGED_LOCAL_SOURCES_PREFIX, path.posix.basename(sourcePath)));
+}
+function toBootstrapMode(mode) {
+	const normalizedMode = mode & 511;
+	return normalizedMode > 0 ? normalizedMode : void 0;
+}
+function resolveLocalFilesystemPath(projectRoot, sourcePath) {
+	const normalizedSourcePath = sourcePath.startsWith("file://") ? sourcePath.slice(7) : sourcePath;
+	return path.isAbsolute(normalizedSourcePath) ? normalizedSourcePath : path.resolve(projectRoot, normalizedSourcePath);
+}
+async function collectBootstrapFilesFromPath(params) {
+	const stats = await lstat(params.absolutePath).catch((error) => {
+		if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
+		throw error;
+	});
+	if (!stats) return [];
+	if (stats.isSymbolicLink()) {
+		const resolvedPath = await realpath(params.absolutePath).catch((error) => {
+			if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
+			throw error;
+		});
+		if (!resolvedPath) return [];
+		return collectBootstrapFilesFromPath({
+			absolutePath: resolvedPath,
+			targetPath: params.targetPath
+		});
+	}
+	if (stats.isDirectory()) {
+		const entries = await readdir(params.absolutePath, { withFileTypes: true }).catch((error) => {
+			if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
+			throw error;
+		});
+		if (!entries) return [];
+		const sortedEntries = [...entries].sort((left, right) => left.name.localeCompare(right.name));
+		const nested = [];
+		for (const entry of sortedEntries) nested.push(await collectBootstrapFilesFromPath({
+			absolutePath: path.join(params.absolutePath, entry.name),
+			targetPath: normalizeRelativeSandboxPath(path.posix.join(params.targetPath, entry.name))
+		}));
+		return nested.flat();
+	}
+	if (stats.isFile()) {
+		const content = await readFile(params.absolutePath).catch((error) => {
+			if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
+			throw error;
+		});
+		if (!content) return [];
+		return [{
+			path: params.targetPath,
+			content,
+			mode: toBootstrapMode(stats.mode),
+			restoreBehavior: "overwrite"
+		}];
+	}
+	throw new Error(`Unsupported sandbox file source type at ${params.absolutePath}`);
+}
+async function resolveSkillSourceDirectory(projectRoot, skillPath) {
+	const absolutePath = resolveLocalFilesystemPath(projectRoot, skillPath);
+	const stats = await lstat(absolutePath).catch((error) => {
+		if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
+		throw error;
+	});
+	if (!stats) throw new Error(`Skill source path not found: ${skillPath}`);
+	if (stats.isSymbolicLink()) {
+		const resolvedPath = await realpath(absolutePath).catch((error) => {
+			if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
+			throw error;
+		});
+		if (!resolvedPath) throw new Error(`Skill source path not found: ${skillPath}`);
+		return resolveSkillSourceDirectory(projectRoot, resolvedPath);
+	}
+	if (!stats.isDirectory()) throw new Error(`Skill source path must point to a directory containing SKILL.md: ${skillPath}`);
+	const skillManifestStats = await lstat(path.join(absolutePath, "SKILL.md")).catch((error) => {
+		if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
+		throw error;
+	});
+	if (!skillManifestStats || !skillManifestStats.isFile()) throw new Error(`Skill source directory must contain SKILL.md: ${skillPath}`);
+	return absolutePath;
+}
+function resolveSkillSourceTarget(absolutePath) {
+	const skillDirName = path.basename(path.resolve(absolutePath));
+	const relativeSkillsRoot = path.posix.relative("/home/user", AGENT_VM_PI_SKILLS_ROOT);
+	return normalizeRelativeSandboxPath(path.posix.join(relativeSkillsRoot, skillDirName));
+}
+async function collectSandboxSourceFiles(projectRoot, source) {
+	if (source.type === "local") return collectBootstrapFilesFromPath({
+		absolutePath: resolveLocalFilesystemPath(projectRoot, source.path),
+		targetPath: resolveLocalSourceTarget(source.path)
+	});
+	return [];
+}
+async function collectSkillSourceFiles(projectRoot, skill) {
+	const absolutePath = await resolveSkillSourceDirectory(projectRoot, skill.path);
+	return collectBootstrapFilesFromPath({
+		absolutePath,
+		targetPath: resolveSkillSourceTarget(absolutePath)
+	});
+}
+async function buildAgentSandboxPackage(params) {
+	const sourceFiles = await Promise.all((params.agentManifest.sandbox?.fileSources ?? []).map((source) => collectSandboxSourceFiles(params.projectRoot, source)));
+	const skillFiles = await Promise.all((params.agentManifest.skills ?? []).map((skill) => collectSkillSourceFiles(params.projectRoot, skill)));
+	const bootstrapFiles = [
+		{
+			path: AGENT_VM_TOOLS_RUNTIME_RELATIVE_PATH,
+			content: params.bundleCode,
+			restoreBehavior: "overwrite"
+		},
+		{
+			path: AGENT_VM_HOST_CALL_RELATIVE_PATH,
+			content: HOST_CALL_STUB_SOURCE,
+			restoreBehavior: "overwrite"
+		},
+		...sourceFiles.flat(),
+		...skillFiles.flat()
+	];
+	const packageBuffer = await createAgentSandboxPackage(bootstrapFiles);
+	return {
+		bootstrapFiles,
+		packageBuffer,
+		packageHash: createHash("sha256").update(packageBuffer).digest("hex"),
+		packageSize: packageBuffer.byteLength
+	};
+}
+function schemaFingerprintForManifestCredentialSet(credentialSet) {
+	const { schemaFingerprint } = manifestToDeclaredCredentialRequirement(credentialSet);
+	if (!schemaFingerprint) throw new Error(`Cannot compute schema fingerprint for credential set "${credentialSet.resolvedCredentialSetId}"`);
+	return schemaFingerprint;
+}
+function createSessionRuntimePlacement() {
+	return {
+		cwd: "/home/user",
+		piRoot: "/home/user/.pi"
+	};
+}
+/**
+* Builds the sandbox block carried on the deployment manifest. Includes the
+* inputs the executor's bootstrap + runtime stages read:
+*   - `setupCommands` (top-level) — runs once, marker-gated, cacheable.
+*   - `runtime.runCommands` — runs every boot.
+*   - `runtime.{workdir, env}` — VM placement and env.
+*   - `fileSources` — local sources baked into the bundle, git sources
+*     cloned in-VM during bootstrap.
+*/
+function createSandboxBlock(agentManifest) {
+	const sandbox = agentManifest.sandbox;
+	if (!sandbox) return void 0;
+	const setupCommands = sandbox.setupCommands ? [...sandbox.setupCommands] : [];
+	const fileSources = sandbox.fileSources ? [...sandbox.fileSources] : [];
+	return {
+		...sandbox.runtime ? { runtime: {
+			runCommands: sandbox.runtime.runCommands ?? [],
+			env: sandbox.runtime.env ?? {},
+			...sandbox.runtime.workdir ? { workdir: sandbox.runtime.workdir } : {}
+		} } : {},
+		...setupCommands.length > 0 ? { setupCommands } : {},
+		...fileSources.length > 0 ? { fileSources } : {}
+	};
+}
+function createResolvedMcpServers(agentManifest) {
+	if (agentManifest.mcpServers.length === 0) return;
+	return agentManifest.mcpServers.map((server) => {
+		if (server.credentialSets.length > 0 && !server.credentialInjection) throw new Error(`MCP server "${server.id}" must define credentialInjection to be deployable in Pi sessions.`);
+		return {
+			id: server.id,
+			name: server.name,
+			...server.description ? { description: server.description } : {},
+			transport: server.transport,
+			credentialSets: server.credentialSets.map((credentialSet) => ({
+				id: credentialSet.id,
+				resolvedId: credentialSet.resolvedCredentialSetId,
+				credentialKeys: readCredentialKeysFromSchemaObject(credentialSet.auth),
+				schemaFingerprint: schemaFingerprintForManifestCredentialSet(credentialSet)
+			})),
+			...server.credentialInjection ? { credentialInjection: server.credentialInjection } : {}
+		};
+	});
+}
+function createAgentVersionManifest(discoveredWorkflow, agentManifest, toolEnrichments, bundle) {
+	const bundleHash = crypto.createHash("sha256").update(bundle.code).digest("hex");
+	const sandboxBlock = createSandboxBlock(agentManifest);
+	const runtimeCredentialSets = agentManifest.credentialSets ?? [];
+	return AgentVersionManifestSchema.parse({
+		agentId: agentManifest.authoredAgentId,
+		authoredAgentId: agentManifest.authoredAgentId,
+		agentName: agentManifest.name,
+		displayName: agentManifest.name,
+		runtimeKind: agentManifest.runtimeKind,
+		exportName: discoveredWorkflow.exportName,
+		mode: "sandbox",
+		bundleHash,
+		bundleSize: bundle.size,
+		runtime: {
+			mode: "pi_session",
+			placement: createSessionRuntimePlacement()
+		},
+		...sandboxBlock ? { sandbox: sandboxBlock } : {},
+		...agentManifest.systemPrompt !== void 0 ? { systemPrompt: agentManifest.systemPrompt } : {},
+		...agentManifest.model !== void 0 ? { model: agentManifest.model } : {},
+		...agentManifest.thinkingLevel !== void 0 ? { thinkingLevel: agentManifest.thinkingLevel } : {},
+		...agentManifest.maxSteps !== void 0 ? { maxSteps: agentManifest.maxSteps } : {},
+		enableMemory: agentManifest.enableMemory,
+		enableDatabase: agentManifest.enableDatabase,
+		...agentManifest.input !== void 0 ? { inputSchema: agentManifest.input } : {},
+		...agentManifest.output !== void 0 ? { outputSchema: agentManifest.output } : {},
+		...agentManifest.tools.length > 0 ? { tools: agentManifest.tools.map((tool) => {
+			const enrichment = toolEnrichments[tool.id];
+			const credentialSets = enrichment?.credentialSets ?? (tool.credentialSets && tool.credentialSets.length > 0 ? tool.credentialSets : void 0);
+			return {
+				toolName: tool.id,
+				...tool.description ? { description: tool.description } : {},
+				sourceKind: tool.sourceKind,
+				...tool.authoredOperationId ? { authoredOperationId: tool.authoredOperationId } : {},
+				...tool.authoredWorkflowId ? { authoredWorkflowId: tool.authoredWorkflowId } : {},
+				...enrichment?.dispatch ? { dispatch: enrichment.dispatch } : {},
+				...enrichment?.invocation ? { invocation: enrichment.invocation } : {},
+				...tool.largeResultMode ? { largeResultMode: tool.largeResultMode } : {},
+				...tool.midSessionSnapshot !== void 0 ? { midSessionSnapshot: tool.midSessionSnapshot } : {},
+				...enrichment?.suspensions ? { suspensions: enrichment.suspensions } : {},
+				...credentialSets ? { credentialSets } : {},
+				...enrichment?.outputSchemaIsTabular !== void 0 ? { outputSchemaIsTabular: enrichment.outputSchemaIsTabular } : {}
+			};
+		}) } : {},
+		...runtimeCredentialSets.length > 0 ? { credentialSets: runtimeCredentialSets.map((credentialSet) => {
+			const optionalCredentialKeys = readOptionalJsonSchemaKeys(credentialSet.auth);
+			return {
+				resolvedId: credentialSet.resolvedCredentialSetId,
+				credentialKeys: readCredentialKeysFromSchemaObject(credentialSet.auth),
+				schemaFingerprint: schemaFingerprintForManifestCredentialSet(credentialSet),
+				...optionalCredentialKeys.length > 0 ? { optionalCredentialKeys } : {},
+				...credentialSet.proxy ? { proxy: credentialSet.proxy } : {},
+				...credentialSet.needsRawSecret === true ? { needsRawSecret: true } : {}
+			};
+		}) } : {},
+		...agentManifest.mcpServers.length > 0 ? { mcpServers: createResolvedMcpServers(agentManifest) } : {},
+		...agentManifest.messaging && agentManifest.messaging.length > 0 ? { messaging: agentManifest.messaging.map((gateway) => ({
+			id: gateway.id,
+			name: gateway.name,
+			provider: gateway.provider,
+			mode: gateway.mode,
+			credentialSet: {
+				resolvedId: gateway.credentialSet.resolvedCredentialSetId,
+				credentialKeys: readCredentialKeysFromSchemaObject(gateway.credentialSet.auth),
+				schemaFingerprint: schemaFingerprintForManifestCredentialSet(gateway.credentialSet)
+			},
+			...gateway.appRef ? { appRef: gateway.appRef } : {}
+		})) } : {}
+	});
+}
+async function buildAgentArtifact(options) {
+	const totalStartedAt = performance.now();
+	const { manifest: authoredAgentManifest } = options.agentMetadata;
+	const bundle = await bundleSandboxAgentTarget({
+		filePath: options.discoveredWorkflow.resolvedFilePath,
+		localExportName: options.discoveredWorkflow.localExportName,
+		projectRoot: options.projectRoot,
+		external: [
+			/^node:/,
+			...builtinModules,
+			/^@swc\//,
+			/\.node$/
+		],
+		sourceMap: options.sourceMaps
+	});
+	const sandboxPackage = await buildAgentSandboxPackage({
+		agentManifest: authoredAgentManifest,
+		bundleCode: bundle.code,
+		projectRoot: options.projectRoot
+	});
+	const bundleMs = performance.now() - totalStartedAt - options.agentMetadata.timing.importMs;
+	const versionManifest = createAgentVersionManifest(options.discoveredWorkflow, authoredAgentManifest, options.agentMetadata.toolEnrichments, {
+		code: bundle.code,
+		size: bundle.size
+	});
+	return {
+		agent: {
+			bindingKey: options.discoveredWorkflow.bindingKey,
+			exportFilePath: options.discoveredWorkflow.exportFilePath,
+			resolvedFilePath: options.discoveredWorkflow.resolvedFilePath,
+			exportName: options.discoveredWorkflow.exportName,
+			localExportName: options.discoveredWorkflow.localExportName,
+			agentId: versionManifest.agentId,
+			agentName: versionManifest.agentName
+		},
+		manifest: versionManifest,
+		bundle: {
+			code: bundle.code,
+			sourceMap: bundle.sourceMap,
+			hash: bundle.hash,
+			...bundle.sourceMapHash ? { sourceMapHash: bundle.sourceMapHash } : {},
+			localDependencies: bundle.localDependencies,
+			externalImports: bundle.externalImports,
+			size: bundle.size
+		},
+		sandboxPackage: {
+			buffer: sandboxPackage.packageBuffer,
+			size: sandboxPackage.packageSize,
+			hash: sandboxPackage.packageHash
+		},
+		timing: {
+			importMs: options.agentMetadata.timing.importMs,
+			manifestMs: options.agentMetadata.timing.manifestMs,
+			bundleMs,
+			totalMs: performance.now() - totalStartedAt
+		}
+	};
+}
+async function buildAgentArtifacts(options) {
+	const agentArtifacts = [];
+	const failures = [];
+	for (const entry of options.entries) try {
+		agentArtifacts.push(await buildAgentArtifact({
+			discoveredWorkflow: entry.discoveredWorkflow,
+			agentMetadata: entry.agentMetadata,
+			projectRoot: options.projectRoot
+		}));
+	} catch (error) {
+		failures.push({
+			kind: "agent",
+			agent: {
+				bindingKey: entry.discoveredWorkflow.bindingKey,
+				exportFilePath: entry.discoveredWorkflow.exportFilePath,
+				resolvedFilePath: entry.discoveredWorkflow.resolvedFilePath,
+				exportName: entry.discoveredWorkflow.exportName,
+				localExportName: entry.discoveredWorkflow.localExportName,
+				agentId: entry.discoveredWorkflow.exportName,
+				agentName: entry.discoveredWorkflow.exportName
+			},
+			phase: "bundle",
+			error: `Agent bundle failed: ${error instanceof Error ? error.message : String(error)}`
+		});
+	}
+	return {
+		agentArtifacts,
+		failures
+	};
+}
+//#endregion
+export { buildAgentArtifacts };