@keystrokehq/cli 0.0.137 → 0.0.139

package/dist/dist-Efdscyea.mjs

@@ -0,0 +1,676 @@
+#!/usr/bin/env node
+import { _ as string, c as _function, d as custom, f as discriminatedUnion, h as object, i as walkTypeScriptFiles, l as array, n as discoverModuleFileEntries, o as ZodType, p as literal, r as entryIdFromFile, v as union, x as toJSONSchema } from "./discovery-DV7FkTRA-BFmtZG9u.mjs";
+import { X as PromptInputSchema, Z as PromptResponseSchema, et as ROUTE_MANIFEST_REL_PATH, wt as normalizeCredentialList } from "./dist-B27Z3YpE.mjs";
+import { dirname, join, relative, sep } from "node:path";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+//#region ../../packages/manifest/dist/index.mjs
+function isManifestAgent(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const agent = value;
+	return typeof agent.slug === "string" && agent.slug.trim().length > 0 && typeof agent.buildRuntime === "function" && typeof agent.model === "string" && typeof agent.systemPrompt === "string";
+}
+function validateManifestAgent(value, filePath) {
+	if (!isManifestAgent(value)) throw new Error(`${filePath} must default-export defineAgent(...)`);
+	return value;
+}
+function normalizeWebhookEndpoint(endpoint) {
+	return endpoint.replace(/^\/+|\/+$/g, "").replace(/^triggers\/?/, "");
+}
+function agentRouteFromKey(key) {
+	return `/agents/${key}`;
+}
+function agentSessionsListPath(route) {
+	return `${route}/sessions`;
+}
+function agentSessionDetailPath(route) {
+	return `${route}/sessions/:sessionId`;
+}
+function workflowRouteFromKey(key) {
+	return `/workflows/${key}`;
+}
+function workflowRunsListPath(route) {
+	return `${route}/runs`;
+}
+function workflowRunDetailPath(route) {
+	return `${route}/runs/:runId`;
+}
+function triggerRunsListPath(attachmentKey) {
+	return `/triggers/${attachmentKey}/runs`;
+}
+function triggerRunDetailPath(attachmentKey) {
+	return `/triggers/${attachmentKey}/runs/:runId`;
+}
+function pollRouteFromKey(attachmentKey) {
+	return `/triggers/${attachmentKey}/poll`;
+}
+function pollGroupRouteFromId(pollId) {
+	return `/triggers/polls/${pollId}/run`;
+}
+function webhookRouteFromEndpoint(endpoint) {
+	const normalized = normalizeWebhookEndpoint(endpoint);
+	if (!normalized) throw new Error("Webhook endpoint must not be empty");
+	return `/triggers/${normalized}`;
+}
+async function discoverAgentEntries(agentsDir) {
+	const files = await discoverModuleFileEntries(agentsDir, {
+		nestedEntry: "agent",
+		duplicateLabel: "agent module file"
+	});
+	const entries = [];
+	for (const { filePath, moduleFile } of files) {
+		const agent = await importAgentDefinition(filePath);
+		entries.push({
+			key: agent.slug,
+			route: agentRouteFromKey(agent.slug),
+			filePath,
+			moduleFile
+		});
+	}
+	return entries;
+}
+async function importAgentDefinition(filePath) {
+	return validateManifestAgent((await import(pathToFileURL(filePath).href)).default, filePath);
+}
+const ACTION = Symbol.for("keystroke.action");
+function isManifestAction(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return ACTION in value && value[ACTION] === true;
+}
+function getManifestActionCredentialRequirements(action) {
+	return Array.isArray(action.credentials) ? action.credentials : void 0;
+}
+function countAgentCredentials(agent) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const tool of agent.tools ?? []) {
+		const record = tool;
+		const requirements = isManifestAction(tool) ? getManifestActionCredentialRequirements(tool) : "credentials" in record && Array.isArray(record.credentials) ? record.credentials : void 0;
+		if (!requirements?.length) continue;
+		for (const requirement of normalizeCredentialList(requirements)) keys.add(requirement.key);
+	}
+	return keys.size;
+}
+const SKIP_DIRS = new Set([".git", "node_modules"]);
+function toPosix$1(path) {
+	return path.split(sep).join("/");
+}
+function parseSkillFrontmatter(raw) {
+	const match = raw.match(/^---\s*\n([\s\S]*?)\n---/);
+	if (!match) return {};
+	const out = {};
+	for (const line of match[1]?.split("\n") ?? []) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const colon = trimmed.indexOf(":");
+		if (colon < 0) continue;
+		const key = trimmed.slice(0, colon).trim();
+		let value = trimmed.slice(colon + 1).trim();
+		if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+		if (key === "name") out.name = value;
+		else if (key === "description") out.description = value;
+	}
+	return out;
+}
+function walkSkillFiles(root, dir, out) {
+	for (const name of readdirSync(dir).sort()) {
+		const absolute = join(dir, name);
+		const stats = statSync(absolute);
+		if (stats.isDirectory()) {
+			if (SKIP_DIRS.has(name)) continue;
+			walkSkillFiles(root, absolute, out);
+			continue;
+		}
+		if (!stats.isFile() || name !== "SKILL.md") continue;
+		const moduleFile = toPosix$1(relative(root, absolute));
+		const slug = toPosix$1(relative(join(root, "src", "skills"), absolute)).replace(/\/?SKILL\.md$/, "");
+		if (!slug) continue;
+		const frontmatter = parseSkillFrontmatter(readFileSync(absolute, "utf8"));
+		out.push({
+			slug,
+			name: frontmatter.name,
+			description: frontmatter.description,
+			moduleFile
+		});
+	}
+}
+/** Discover skill metadata from src/skills SKILL.md files for the route manifest. */
+function discoverSkillManifestEntries(projectRoot) {
+	const skillsDir = join(projectRoot, "src", "skills");
+	if (!statSync(skillsDir, { throwIfNoEntry: false })?.isDirectory()) return [];
+	const entries = [];
+	walkSkillFiles(projectRoot, skillsDir, entries);
+	return entries;
+}
+function schemaToJson(schema) {
+	return toJSONSchema(schema, { target: "openapi-3.0" });
+}
+function collectIntegrationKeys(integrations) {
+	return integrations.map((integration) => integration.key);
+}
+function serializeRouteManifest(manifest) {
+	return manifest.map((entry) => {
+		switch (entry.kind) {
+			case "health": return entry;
+			case "agent": return {
+				kind: entry.kind,
+				method: entry.method,
+				path: entry.path,
+				agentSlug: entry.agentSlug,
+				moduleFile: entry.moduleFile,
+				name: entry.name,
+				description: entry.description,
+				model: entry.model,
+				systemPrompt: entry.systemPrompt,
+				toolCount: entry.toolCount,
+				credentialCount: entry.credentialCount,
+				requestSchema: schemaToJson(entry.request),
+				responseSchema: schemaToJson(entry.response)
+			};
+			case "workflow": return {
+				kind: entry.kind,
+				method: entry.method,
+				path: entry.path,
+				workflowSlug: entry.workflowSlug,
+				workflowName: entry.workflowName,
+				description: entry.description,
+				subscribable: entry.subscribable,
+				moduleFile: entry.moduleFile,
+				requestSchema: schemaToJson(entry.request),
+				responseSchema: schemaToJson(entry.response)
+			};
+			case "trigger-webhook": return {
+				kind: entry.kind,
+				method: entry.method,
+				path: entry.path,
+				attachmentIds: entry.attachmentIds,
+				moduleFile: entry.moduleFile,
+				requestSchema: schemaToJson(entry.request),
+				attachmentSchemas: Object.fromEntries(Object.entries(entry.attachmentSchemas).map(([attachmentKey, schemas]) => [attachmentKey, {
+					requestSchema: schemaToJson(schemas.request),
+					...schemas.filter ? { filterSchema: schemaToJson(schemas.filter) } : {}
+				}])),
+				responseSchema: schemaToJson(entry.response)
+			};
+			case "trigger-poll": return {
+				kind: entry.kind,
+				method: entry.method,
+				path: entry.path,
+				attachmentId: entry.attachmentId,
+				moduleFile: entry.moduleFile,
+				schedule: entry.schedule,
+				responseSchema: schemaToJson(entry.response)
+			};
+			case "trigger-poll-group": return {
+				kind: entry.kind,
+				method: entry.method,
+				path: entry.path,
+				pollId: entry.pollId,
+				attachmentIds: entry.attachmentIds,
+				moduleFile: entry.moduleFile,
+				schedule: entry.schedule,
+				responseSchema: schemaToJson(entry.response)
+			};
+			case "plugin": return {
+				kind: entry.kind,
+				method: entry.method,
+				path: entry.path,
+				plugin: entry.plugin
+			};
+			default: return entry;
+		}
+	});
+}
+function toStoredRouteManifest(manifest, options) {
+	return {
+		version: 1,
+		entries: serializeRouteManifest(manifest),
+		skills: options?.skills ?? [],
+		integrations: options?.integrations
+	};
+}
+function buildStoredRouteManifestFromContext(ctx) {
+	const integrations = ctx.options?.integrations ?? ctx.options?.plugins?.map((plugin) => ({
+		key: plugin.name,
+		mount: plugin.register
+	})) ?? [];
+	return toStoredRouteManifest(ctx.manifest, {
+		integrations: collectIntegrationKeys(integrations),
+		skills: ctx.skills ?? (ctx.projectRoot ? discoverSkillManifestEntries(ctx.projectRoot) : void 0) ?? []
+	});
+}
+function persistStoredRouteManifest(projectRoot, manifest) {
+	const path = join(projectRoot, ROUTE_MANIFEST_REL_PATH);
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify(manifest, null, 2)}\n`);
+}
+const WORKFLOW = Symbol.for("keystroke.workflow");
+function isManifestWorkflow(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if (!(WORKFLOW in value) || value[WORKFLOW] !== true) return false;
+	const workflow = value;
+	return typeof workflow.slug === "string" && workflow.slug.trim().length > 0 && workflow.input instanceof Object && "safeParse" in workflow.input && workflow.output instanceof Object && "safeParse" in workflow.output;
+}
+function validateManifestWorkflow(value, filePath) {
+	if (!isManifestWorkflow(value)) throw new Error(`${filePath} must default-export defineWorkflow(...)`);
+	return value;
+}
+const TRIGGER_ATTACHMENT = Symbol.for("keystroke.triggerAttachment");
+const zodSchema = custom((value) => value instanceof ZodType, "must be a Zod schema");
+const cronScheduleSchema = string().trim().min(1, "cron schedule must be a non-empty string");
+const workflowSchema = custom((value) => isManifestWorkflow(value), "must be defineWorkflow(...)");
+const agentSchema = custom((value) => typeof value === "object" && value !== null && typeof value.slug === "string" && value.slug.trim().length > 0 && typeof value.prompt === "function", "must be defineAgent(...)");
+const promptSchema = union([string(), _function()]);
+const baseSourceShape = {
+	key: string().trim().min(1),
+	attach: _function()
+};
+const triggerSourceSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("webhook"),
+		...baseSourceShape,
+		endpoint: string().min(1),
+		request: zodSchema,
+		filter: zodSchema.optional(),
+		passes: _function()
+	}),
+	object({
+		kind: literal("cron"),
+		...baseSourceShape,
+		schedule: cronScheduleSchema
+	}),
+	object({
+		kind: literal("poll"),
+		...baseSourceShape,
+		id: string().optional(),
+		schedule: cronScheduleSchema,
+		run: _function(),
+		filters: array(_function()),
+		passes: _function()
+	})
+]);
+const triggerAttachmentCoreSchema = discriminatedUnion("target", [object({
+	key: string().trim().min(1),
+	source: triggerSourceSchema,
+	target: literal("workflow"),
+	workflow: workflowSchema,
+	transform: _function().optional()
+}), object({
+	key: string().trim().min(1),
+	source: triggerSourceSchema,
+	target: literal("agent"),
+	agent: agentSchema,
+	prompt: promptSchema
+})]);
+function isManifestTriggerAttachment(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if (!(TRIGGER_ATTACHMENT in value) || value[TRIGGER_ATTACHMENT] !== true) return false;
+	return triggerAttachmentCoreSchema.safeParse(value).success;
+}
+function validateManifestTriggerAttachment(value, filePath) {
+	if (!isManifestTriggerAttachment(value)) throw new Error(`${filePath} must default-export a trigger attachment from .attach({ workflow }) or .attach({ agent, prompt })`);
+	return value;
+}
+function shouldDiscoverTriggerFile(triggersDir, filePath) {
+	return !relative(triggersDir, filePath).split(sep).includes("sources");
+}
+async function discoverTriggerAttachments(triggersDir) {
+	const files = await discoverModuleFileEntries(triggersDir, {
+		nestedEntry: "trigger",
+		duplicateLabel: "trigger module file",
+		shouldDiscoverFile: (filePath) => shouldDiscoverTriggerFile(triggersDir, filePath)
+	});
+	const attachments = [];
+	for (const { filePath, moduleFile } of files) {
+		const attachment = await importTriggerAttachment(filePath);
+		attachments.push({
+			key: attachment.key,
+			filePath,
+			moduleFile,
+			attachment
+		});
+	}
+	return attachments;
+}
+function validateImportedTriggerAttachment(def, filePath) {
+	return validateManifestTriggerAttachment(def, filePath);
+}
+async function importTriggerAttachment(filePath) {
+	return validateImportedTriggerAttachment((await import(pathToFileURL(filePath).href)).default, filePath);
+}
+function pollGroupId(discovered) {
+	const source = discovered.attachment.source;
+	if (source.kind !== "poll") throw new Error(`Attachment "${discovered.key}" is not a poll trigger`);
+	return source.id ?? source.key;
+}
+function buildPollGroups(attachments) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const discovered of attachments) {
+		if (discovered.attachment.source.kind !== "poll") continue;
+		const id = pollGroupId(discovered);
+		const group = byId.get(id) ?? [];
+		group.push(discovered);
+		byId.set(id, group);
+	}
+	return [...byId.entries()].map(([id, groupAttachments]) => ({
+		id,
+		attachments: groupAttachments
+	}));
+}
+function buildWebhookBindingsByRoute(attachments, handlerOptionsFor) {
+	const webhookBindingsByRoute = /* @__PURE__ */ new Map();
+	for (const discovered of attachments) {
+		const source = discovered.attachment.source;
+		if (source.kind !== "webhook") continue;
+		const route = webhookRouteFromEndpoint(source.endpoint);
+		const bindings = webhookBindingsByRoute.get(route) ?? [];
+		bindings.push({
+			discovered,
+			options: handlerOptionsFor(discovered.key)
+		});
+		webhookBindingsByRoute.set(route, bindings);
+	}
+	return webhookBindingsByRoute;
+}
+function webhookSchemaEntriesFromBindings(bindings) {
+	return bindings.flatMap((binding) => {
+		const source = binding.discovered.attachment.source;
+		if (source.kind !== "webhook") return [];
+		return [{
+			attachmentKey: binding.discovered.key,
+			request: source.request,
+			...source.filter ? { filter: source.filter } : {}
+		}];
+	});
+}
+function webhookMatchSchemaForBindings(bindings) {
+	const schemas = bindings.flatMap((binding) => {
+		const source = binding.discovered.attachment.source;
+		return source.kind === "webhook" ? [source.request] : [];
+	});
+	if (schemas.length === 0) throw new Error("Webhook bindings require at least one webhook source");
+	if (schemas.length === 1) return schemas[0];
+	return union(schemas);
+}
+function webhookManifestAttachmentSchemasFromBindings(bindings) {
+	return Object.fromEntries(webhookSchemaEntriesFromBindings(bindings).map((entry) => [entry.attachmentKey, {
+		request: entry.request,
+		...entry.filter ? { filter: entry.filter } : {}
+	}]));
+}
+async function discoverWorkflowEntries(workflowsDir) {
+	const files = await discoverModuleFileEntries(workflowsDir, {
+		nestedEntry: "workflow",
+		duplicateLabel: "workflow module file"
+	});
+	const entries = [];
+	for (const { filePath, moduleFile } of files) {
+		const definition = await importWorkflowDefinition(filePath);
+		entries.push({
+			key: definition.slug,
+			route: workflowRouteFromKey(definition.slug),
+			filePath,
+			moduleFile
+		});
+	}
+	return entries;
+}
+function validateImportedWorkflowDefinition(def, filePath) {
+	return validateManifestWorkflow(def, filePath);
+}
+async function importWorkflowDefinition(filePath) {
+	return validateImportedWorkflowDefinition((await import(pathToFileURL(filePath).href)).default, filePath);
+}
+async function discoverWorkflows(workflowsDir) {
+	const entries = await discoverWorkflowEntries(workflowsDir);
+	const workflows = [];
+	for (const entry of entries) {
+		const definition = await importWorkflowDefinition(entry.filePath);
+		workflows.push({
+			key: definition.slug,
+			route: workflowRouteFromKey(definition.slug),
+			filePath: entry.filePath,
+			definition
+		});
+	}
+	return workflows;
+}
+function resolveDistModuleDirs(projectRoot) {
+	const distBase = join(projectRoot, "dist");
+	if (!existsSync(distBase)) throw new Error(`Build output missing at ${distBase}. Run keystroke build before emitting the route manifest.`);
+	return {
+		agentsDir: join(distBase, "agents"),
+		workflowsDir: join(distBase, "workflows"),
+		triggersDir: join(distBase, "triggers")
+	};
+}
+function toPosix(path) {
+	return path.split(sep).join("/");
+}
+/**
+* Resolve manifest moduleFile values to project-root-relative source paths.
+*
+* Discovery runs over compiled `dist/` modules, so the raw moduleFile is a
+* dist-relative `.mjs` path. Dist entries are named by their source entry id
+* (`team/escalation.mjs` ← `src/agents/team/escalation/agent.ts`), so walking
+* the matching source dir by the same id rules recovers the source path. Falls
+* back to the dist-relative value when no source file matches (e.g. building
+* a dist-only artifact with no `src/`).
+*/
+var SourceModuleFileResolver = class {
+	projectRoot;
+	mapsByKind = /* @__PURE__ */ new Map();
+	constructor(projectRoot) {
+		this.projectRoot = projectRoot;
+	}
+	async sourceMapFor(kindDir, nestedEntry) {
+		const existing = this.mapsByKind.get(kindDir);
+		if (existing) return existing;
+		const map = /* @__PURE__ */ new Map();
+		const sourceDir = join(this.projectRoot, "src", kindDir);
+		for (const filePath of await walkTypeScriptFiles(sourceDir)) {
+			const id = entryIdFromFile(sourceDir, filePath, { nestedEntry });
+			if (id) map.set(id, toPosix(relative(this.projectRoot, filePath)));
+		}
+		this.mapsByKind.set(kindDir, map);
+		return map;
+	}
+	async resolve(kindDir, nestedEntry, distDir, distFilePath) {
+		const fallback = toPosix(relative(distDir, distFilePath));
+		const id = entryIdFromFile(distDir, distFilePath, { nestedEntry });
+		if (!id) return fallback;
+		return (await this.sourceMapFor(kindDir, nestedEntry)).get(id) ?? fallback;
+	}
+};
+/** Build a stored route manifest from compiled dist/ modules without starting a server. */
+async function buildStoredRouteManifestForProject(projectRoot) {
+	const previousRoot = process.env.KEYSTROKE_ROOT;
+	process.env.KEYSTROKE_ROOT = projectRoot;
+	try {
+		const dirs = resolveDistModuleDirs(projectRoot);
+		const sourcePaths = new SourceModuleFileResolver(projectRoot);
+		const manifest = [{
+			kind: "health",
+			method: "GET",
+			path: "/health"
+		}];
+		const agentEntries = await discoverAgentEntries(dirs.agentsDir);
+		for (const entry of agentEntries) {
+			const agent = await importAgentDefinition(entry.filePath);
+			const moduleFile = await sourcePaths.resolve("agents", "agent", dirs.agentsDir, entry.filePath);
+			manifest.push({
+				kind: "agent",
+				method: "POST",
+				path: entry.route,
+				agentSlug: agent.slug,
+				moduleFile,
+				name: agent.name,
+				description: agent.description,
+				model: agent.model,
+				systemPrompt: agent.systemPrompt,
+				toolCount: agent.tools?.length ?? 0,
+				credentialCount: countAgentCredentials(agent),
+				request: PromptInputSchema,
+				response: PromptResponseSchema
+			});
+			manifest.push({
+				kind: "agent-sessions-list",
+				method: "GET",
+				path: agentSessionsListPath(entry.route),
+				agentSlug: entry.key,
+				moduleFile
+			});
+			manifest.push({
+				kind: "agent-session-detail",
+				method: "GET",
+				path: agentSessionDetailPath(entry.route),
+				agentSlug: entry.key,
+				moduleFile
+			});
+		}
+		const workflows = await discoverWorkflows(dirs.workflowsDir);
+		for (const workflow of workflows) {
+			const route = workflowRouteFromKey(workflow.key);
+			const moduleFile = await sourcePaths.resolve("workflows", "workflow", dirs.workflowsDir, workflow.filePath);
+			manifest.push({
+				kind: "workflow",
+				method: "POST",
+				path: route,
+				workflowSlug: workflow.definition.slug,
+				workflowName: workflow.definition.name,
+				description: workflow.definition.description,
+				subscribable: workflow.definition.subscription?.mode === "subscribable",
+				moduleFile,
+				request: workflow.definition.input,
+				response: workflow.definition.output
+			});
+			manifest.push({
+				kind: "workflow-runs-list",
+				method: "GET",
+				path: workflowRunsListPath(route),
+				workflowSlug: workflow.definition.slug,
+				workflowName: workflow.definition.name,
+				moduleFile
+			});
+			manifest.push({
+				kind: "workflow-run-detail",
+				method: "GET",
+				path: workflowRunDetailPath(route),
+				workflowSlug: workflow.definition.slug,
+				workflowName: workflow.definition.name,
+				moduleFile
+			});
+		}
+		const attachments = await discoverTriggerAttachments(dirs.triggersDir);
+		const discoveredByKey = new Map(attachments.map((attachment) => [attachment.key, attachment]));
+		const pollGroups = buildPollGroups(attachments);
+		for (const discovered of discoveredByKey.values()) {
+			const source = discovered.attachment.source;
+			const moduleFile = await sourcePaths.resolve("triggers", "trigger", dirs.triggersDir, discovered.filePath);
+			if (source.kind === "cron") {
+				manifest.push({
+					kind: "cron-schedule",
+					attachmentId: discovered.key,
+					moduleFile,
+					schedule: source.schedule
+				});
+				continue;
+			}
+			if (source.kind === "poll") {
+				const route = pollRouteFromKey(source.key);
+				manifest.push({
+					kind: "trigger-poll",
+					method: "POST",
+					path: route,
+					attachmentId: discovered.key,
+					moduleFile,
+					schedule: source.schedule,
+					response: PromptResponseSchema
+				});
+				manifest.push({
+					kind: "trigger-runs-list",
+					method: "GET",
+					path: triggerRunsListPath(discovered.key),
+					attachmentId: discovered.key,
+					moduleFile
+				});
+				manifest.push({
+					kind: "trigger-run-detail",
+					method: "GET",
+					path: triggerRunDetailPath(discovered.key),
+					attachmentId: discovered.key,
+					moduleFile
+				});
+				continue;
+			}
+			if (source.kind === "webhook") {
+				const route = webhookRouteFromEndpoint(source.endpoint);
+				const bindings = buildWebhookBindingsByRoute(discoveredByKey.values(), () => ({
+					execution: { attachmentKey: discovered.key },
+					attachmentKey: discovered.key
+				})).get(route) ?? [{
+					discovered,
+					options: { attachmentKey: discovered.key }
+				}];
+				manifest.push({
+					kind: "trigger-webhook",
+					method: "POST",
+					path: route,
+					attachmentIds: bindings.map(({ discovered: row }) => row.key),
+					moduleFile,
+					request: webhookMatchSchemaForBindings(bindings),
+					attachmentSchemas: webhookManifestAttachmentSchemasFromBindings(bindings),
+					response: PromptResponseSchema
+				});
+				for (const { discovered: row } of bindings) {
+					const rowModuleFile = await sourcePaths.resolve("triggers", "trigger", dirs.triggersDir, row.filePath);
+					manifest.push({
+						kind: "trigger-runs-list",
+						method: "GET",
+						path: triggerRunsListPath(row.key),
+						attachmentId: row.key,
+						moduleFile: rowModuleFile
+					});
+					manifest.push({
+						kind: "trigger-run-detail",
+						method: "GET",
+						path: triggerRunDetailPath(row.key),
+						attachmentId: row.key,
+						moduleFile: rowModuleFile
+					});
+				}
+			}
+		}
+		for (const group of pollGroups) {
+			if (group.attachments.length <= 1) continue;
+			const first = group.attachments[0];
+			const source = first.attachment.source;
+			manifest.push({
+				kind: "trigger-poll-group",
+				method: "POST",
+				path: pollGroupRouteFromId(group.id),
+				pollId: group.id,
+				attachmentIds: group.attachments.map((attachment) => attachment.key),
+				moduleFile: await sourcePaths.resolve("triggers", "trigger", dirs.triggersDir, first.filePath),
+				schedule: source.kind === "poll" ? source.schedule : "",
+				response: PromptResponseSchema
+			});
+		}
+		return buildStoredRouteManifestFromContext({
+			manifest,
+			options: {},
+			projectRoot,
+			skills: discoverSkillManifestEntries(projectRoot)
+		});
+	} finally {
+		if (previousRoot === void 0) delete process.env.KEYSTROKE_ROOT;
+		else process.env.KEYSTROKE_ROOT = previousRoot;
+	}
+}
+/** Write `dist/.keystroke/route-manifest.json` for the project. */
+async function emitStoredRouteManifestForProject(projectRoot) {
+	persistStoredRouteManifest(projectRoot, await buildStoredRouteManifestForProject(projectRoot));
+}
+//#endregion
+export { emitStoredRouteManifestForProject };
+
+//# sourceMappingURL=dist-Efdscyea.mjs.map