@happyvertical/smrt-cli 0.55.9 → 0.55.11

package/dist/{commands-NBDTnB3h.js → commands-pbRVQvix.js}

@@ -1,28 +1,30 @@
 import { t as resolveManifestEntryPackageName } from "./index.js";
 import { a as redactDatabaseUrlsInText, i as quoteIdentifier, r as formatDatabaseDisplayUrl, t as closeDatabaseConnection } from "./db-command-utils-Cn8tjy7N.js";
+import { a as readCookbookSource, d as downloadPackage, f as extractTarball, g as applyCookbook, h as COOKBOOK_CONFIG_FILE, i as printApplyResult, m as ApplyError, n as asList, o as validateCookbookSource, p as lookupPackage, r as cliVersion, t as createCookbookApplier } from "./apply-BNDIdixP.js";
 import { t as DEFAULT_CLI_CONFIG } from "./config-CdJRSMRi.js";
 import { addMcpAppsRuntime, assertMcpAppsPluginName, configureMcpAppsConsumerRegistry, mcpAppsCommands, scaffoldMcpAppsPackage, validateMcpAppsPackage } from "./mcp-apps-packaging-CixRnxz_.js";
 import { createRequire } from "node:module";
 import * as fs from "node:fs";
-import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { createReadStream, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import * as path from "node:path";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, extname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { ObjectRegistry, SchemaComparer, checkLiveSchemaParity, collectForeignKeyOrphanCounts, createQualifiedName, ensureDeferredSystemTableCompatibility, generateDDLForEngine, getClassName, isQualifiedName, isSmrtCollectionExtendsName, migratePostgresSystemTimestamps, parseQualifiedName, planForeignKeyCreation, planPostgresSystemTimestampMigrations } from "@happyvertical/smrt-core";
 import { loadExternalManifestSync } from "@happyvertical/smrt-core/manifest";
-import { execFileSync, execSync, spawn, spawnSync } from "node:child_process";
+import { execFile, execFileSync, execSync, spawn, spawnSync } from "node:child_process";
 import { homedir, tmpdir } from "node:os";
-import { createHash } from "node:crypto";
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+import { extract } from "tar";
 import { access, cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { createLogger } from "@happyvertical/logger";
 import glob from "fast-glob";
-import { getPackageConfig } from "@happyvertical/smrt-config";
+import { getPackageConfig, loadConfig, toAIClientOptions, tryResolveConfiguredAIProvider } from "@happyvertical/smrt-config";
 import { toSnakeCase as toSnakeCase$1 } from "@happyvertical/smrt-core/utils";
 import { checkKnowledgeGraphFreshness, discoverScopedPackageDirectories, readAgentModuleDocs, readPackageAgentDoc, resolveAgentModuleDocPaths } from "@happyvertical/smrt-core/knowledge";
 import { MCPGenerator } from "@happyvertical/smrt-core/generators";
 import { generateDeclarationsFromCLI } from "@happyvertical/smrt-core/prebuild";
 import https from "node:https";
-import { extract } from "tar";
+import { createServer } from "node:http";
 import { importWorkspaceModule } from "@happyvertical/smrt-core/utils/import-workspace-module";
 import { renderForeignKeyAddStatements } from "@happyvertical/smrt-core/schema";
 import { FRAMEWORK_BASE_TABLE_NAMES, backfillLegacyQualifiedNames, buildIntegerWidthTableStatements, collectIntegerWidthTargets, collectNullEqualIndexTargets, countLegacyQualifiedNameReferences, dropFrameworkBaseTables, migrateNullEqualIndexes, nullEqualIndexStatements, parsePostgresTimeoutMs, planFrameworkBaseTableDrop, preflightIntegerWidthWidening, preflightNullEqualIndexes, widenIntegerColumnsToBigInt } from "@happyvertical/smrt-core/migrations";
@@ -175,6 +177,143 @@ var configExportCommand = {
 	}
 };
 //#endregion
+//#region src/commands/cookbook.ts
+/**
+* `smrt cookbook validate|apply` (#3748). See `agents/cookbook.md`.
+*/
+async function loadAndValidate(source, options, dir) {
+	return validateCookbookSource(await readCookbookSource(source), {
+		dir,
+		manifests: asList(options.manifests),
+		registry: !options["no-registry"]
+	});
+}
+function printReport(source, report, json) {
+	if (json) {
+		console.log(JSON.stringify({
+			ok: report.ok,
+			source,
+			errors: report.errors,
+			warnings: report.warnings,
+			packages: report.packages
+		}, null, 2));
+		return;
+	}
+	for (const warning of report.warnings) console.warn(`warning: ${warning}`);
+	if (report.ok) {
+		console.log(`${source} is a valid cookbook (${report.packages.length} package(s))`);
+		return;
+	}
+	console.error(`${source} is not a valid cookbook:`);
+	for (const error of report.errors) console.error(`  - ${error}`);
+}
+var sharedOptions = {
+	json: {
+		type: "boolean",
+		description: "Print machine-readable JSON",
+		default: false
+	},
+	manifests: {
+		type: "string",
+		description: "Extra package manifests (file or directory); repeatable. Searched before the workspace, node_modules and the registry",
+		multiple: true
+	},
+	"no-registry": {
+		type: "boolean",
+		description: "Do not fetch manifests of uninstalled packages from the registry",
+		default: false
+	}
+};
+var cookbookCommands = {
+	"cookbook validate": {
+		name: "cookbook validate",
+		description: "Validate a cookbook (file or URL) against cookbook/v1 and the recipe manifests",
+		args: ["file"],
+		options: sharedOptions,
+		handler: async (args, options) => {
+			const source = args[0];
+			if (!source) {
+				console.error("Usage: smrt cookbook validate <file|url> [--json]");
+				process.exit(2);
+			}
+			let report;
+			try {
+				report = await loadAndValidate(source, options, process.cwd());
+			} catch (error) {
+				console.error(error instanceof Error ? error.message : String(error));
+				process.exit(1);
+			}
+			printReport(source, report, options.json);
+			if (!report.ok) process.exit(1);
+		}
+	},
+	"cookbook apply": {
+		name: "cookbook apply",
+		description: "Create a project from a cookbook (smrt-start template), or update one with --into",
+		args: ["file", "dir"],
+		options: {
+			...sharedOptions,
+			template: {
+				type: "string",
+				description: "Project template: a local path, github:owner/repo[#ref], or a git URL (default github:happyvertical/smrt-start)"
+			},
+			into: {
+				type: "boolean",
+				description: "Apply to an existing project (dir, default: current directory)",
+				default: false
+			},
+			"dry-run": {
+				type: "boolean",
+				description: "Print the planned changes without writing anything",
+				default: false
+			},
+			"no-install": {
+				type: "boolean",
+				description: "Skip the package install",
+				default: false
+			}
+		},
+		handler: async (args, options) => {
+			const [source, dir] = args;
+			if (!source) {
+				console.error("Usage: smrt cookbook apply <file|url> [dir] [--into] [--template <t>] [--dry-run] [--no-install]");
+				process.exit(2);
+			}
+			try {
+				const report = await loadAndValidate(source, options, resolve(dir ?? "."));
+				if (!report.ok || !report.cookbook) {
+					printReport(source, report, options.json);
+					process.exit(1);
+				}
+				const result = applyCookbook({
+					cookbook: report.cookbook,
+					packages: report.packages,
+					dir,
+					into: options.into,
+					template: options.template,
+					dryRun: options["dry-run"],
+					install: !options["no-install"],
+					cliVersion: cliVersion()
+				});
+				if (options.json) {
+					console.log(JSON.stringify({
+						...result,
+						warnings: report.warnings
+					}, null, 2));
+					return;
+				}
+				printApplyResult(result, report.warnings);
+			} catch (error) {
+				if (error instanceof ApplyError) {
+					console.error(error.message);
+					process.exit(1);
+				}
+				throw error;
+			}
+		}
+	}
+};
+//#endregion
 //#region src/discovery/manifest-discovery.ts
 /**
 * Manifest Discovery System
@@ -6768,6 +6907,617 @@ var initCommands = { init: {
 	}
 } };
 //#endregion
+//#region src/commands/kitchen/planner.ts
+/**
+* Locating the planner for `smrt kitchen` (#3750).
+*
+* The planner package (`@happyvertical/smrt-planner`) carries a ~70 MB static
+* app, so the CLI does not depend on it. It is found, in order:
+*
+* 1. `--planner <dir>`: a packaged checkout (`pnpm package` in the planner repo).
+* 2. A cached copy under the user cache dir, one directory per version.
+* 3. The registry that owns the `@happyvertical` scope: the newest version is
+*    downloaded and extracted into the cache (no install, no dependencies).
+*
+* If none is available the error says how to fix it.
+*/
+var PLANNER_PACKAGE = "@happyvertical/smrt-planner";
+var PlannerError = class extends Error {};
+/**
+* Where downloaded planners live: `$SMRT_CACHE_DIR/planner`, else the platform
+* user cache (`$XDG_CACHE_HOME`, `~/Library/Caches`, `%LOCALAPPDATA%`, `~/.cache`)
+* `/smrt/planner`. Each version is a subdirectory.
+*/
+function plannerCacheDir(env = process.env) {
+	if (env.SMRT_CACHE_DIR) return join(env.SMRT_CACHE_DIR, "planner");
+	return join(env.XDG_CACHE_HOME || (process.platform === "darwin" ? join(homedir(), "Library", "Caches") : process.platform === "win32" ? env.LOCALAPPDATA || join(homedir(), "AppData", "Local") : join(homedir(), ".cache")), "smrt", "planner");
+}
+function exportTarget(value) {
+	if (typeof value === "string") return value;
+	if (value && typeof value === "object") {
+		const record = value;
+		return exportTarget(record.default ?? record.import);
+	}
+}
+/** Validate a package directory as a packaged planner. */
+function inspectPlanner(root, source) {
+	const dir = resolve(root);
+	let pkg;
+	try {
+		pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf-8"));
+	} catch {
+		throw new PlannerError(`${dir} is not a planner package (no readable package.json)`);
+	}
+	if (pkg.name !== "@happyvertical/smrt-planner") throw new PlannerError(`${dir} is not ${PLANNER_PACKAGE} (package name is ${pkg.name ?? "missing"})`);
+	const exportsMap = pkg.exports;
+	const core = exportTarget(exportsMap?.["./core"]);
+	const coreFile = core ? resolve(dir, core) : "";
+	const appDir = join(dir, "app");
+	if (!core || !existsSync(coreFile) || !existsSync(join(appDir, "index.html"))) throw new PlannerError(`${dir} is not packaged (missing ${!core || !existsSync(coreFile) ? "dist/core" : "app/index.html"}); run \`pnpm package\` in the planner checkout`);
+	return {
+		root: dir,
+		appDir,
+		coreFile,
+		version: pkg.version,
+		source
+	};
+}
+var versionParts = (v) => v.split(/[.-]/).map((p) => /^\d+$/.test(p) ? Number(p) : p);
+function compareVersions(a, b) {
+	const x = versionParts(a);
+	const y = versionParts(b);
+	for (let i = 0; i < Math.max(x.length, y.length); i += 1) {
+		const l = x[i] ?? 0;
+		const r = y[i] ?? 0;
+		if (l === r) continue;
+		if (typeof l === "number" && typeof r === "number") return l - r;
+		return String(l) < String(r) ? -1 : 1;
+	}
+	return 0;
+}
+function cachedVersions(cache) {
+	if (!existsSync(cache)) return [];
+	return readdirSync(cache).filter((name) => existsSync(join(cache, name, "package", "package.json"))).sort(compareVersions);
+}
+function tryInspect(root) {
+	try {
+		return inspectPlanner(root, "cache");
+	} catch {
+		return;
+	}
+}
+/** Find the planner: `--planner`, the cache, then the registry. */
+async function resolvePlanner(options = {}) {
+	const log = options.log ?? (() => {});
+	if (options.planner) return inspectPlanner(options.planner, "local");
+	const cache = options.cacheDir ?? plannerCacheDir();
+	const found = await lookupPackage(PLANNER_PACKAGE, {
+		dir: options.dir,
+		...options.registry
+	});
+	if (found?.version) {
+		const target = join(cache, found.version);
+		const cached = tryInspect(join(target, "package"));
+		if (cached) return cached;
+		log(`Downloading the planner ${found.version} (about 70 MB, cached after)…`);
+		const tarball = await downloadPackage(found, options.registry?.fetchImpl);
+		if (tarball) {
+			mkdirSync(cache, { recursive: true });
+			const work = mkdtempSync(join(cache, ".download-"));
+			try {
+				await extractTarball(tarball.data, work);
+				rmSync(target, {
+					recursive: true,
+					force: true
+				});
+				renameSync(work, target);
+				const installed = inspectPlanner(join(target, "package"), "registry");
+				log(`Planner ${found.version} cached in ${target}`);
+				return installed;
+			} catch (error) {
+				rmSync(work, {
+					recursive: true,
+					force: true
+				});
+				throw error instanceof PlannerError ? error : new PlannerError(`Could not unpack ${PLANNER_PACKAGE}@${found.version}: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+	}
+	for (const version of cachedVersions(cache).reverse()) {
+		const cached = tryInspect(join(cache, version, "package"));
+		if (cached) {
+			log(`Could not reach the registry; using the cached planner ${version}`);
+			return cached;
+		}
+	}
+	throw new PlannerError(`The planner (${PLANNER_PACKAGE}) is not available: it is not in ${cache} and the registry for the @happyvertical scope did not provide it.\nCheck your network and .npmrc, or point at a packaged checkout with --planner <dir> (run \`pnpm package\` in the planner repo).`);
+}
+/** Import the planner's plain-Node `./core`. */
+async function loadPlannerCore(install) {
+	try {
+		return await import(
+			/* @vite-ignore */
+			pathToFileURL(install.coreFile).href
+);
+	} catch (error) {
+		throw new PlannerError(`Could not load the planner core from ${install.coreFile}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+//#endregion
+//#region src/commands/kitchen/ai.ts
+/**
+* The language model behind `smrt kitchen`'s chat endpoint (#3750): the
+* user's configured `@happyvertical/ai` provider, resolved the way the rest of
+* s-m-r-t resolves it (the `ai` block of `smrt.config.ts`, then `SMRT_AI_*`,
+* then the provider's own key variable such as `OPENAI_API_KEY`).
+*/
+async function defaultCreateClient(options) {
+	const { getAI } = await import("@happyvertical/ai");
+	return getAI(options);
+}
+/**
+* The configured model, or null when no provider is configured (the kitchen
+* then runs the planner's in-browser model instead).
+*/
+async function resolveKitchenAI(options = {}) {
+	const searchFrom = options.dir && existsSync(resolve(options.dir)) ? resolve(options.dir) : process.cwd();
+	try {
+		await loadConfig({ searchFrom });
+	} catch {}
+	const resolved = tryResolveConfiguredAIProvider({ env: options.env });
+	if (!resolved?.provider) return null;
+	const client = await (options.createClient ?? defaultCreateClient)(toAIClientOptions(resolved));
+	return {
+		label: `${resolved.provider}${resolved.model ? ` (${resolved.model})` : ""}`,
+		async chat(messages) {
+			return (await client.chat(messages, { temperature: 0 })).content;
+		}
+	};
+}
+//#endregion
+//#region src/commands/kitchen/server.ts
+/**
+* The local server behind `smrt kitchen` (#3750): the planner's static app,
+* the host-mode chat endpoint, and the one endpoint that receives the cookbook.
+*
+* It only ever listens on 127.0.0.1 (a random port) and every request must
+* carry a `Host` of this server, which defeats DNS rebinding. State-changing
+* requests are same-origin JSON; the cookbook also needs the one-time token.
+*/
+var CHAT_PATH = "/api/planner/chat";
+var COOKBOOK_PATH = "/api/kitchen/cookbook";
+var CHAT_LIMIT = 256 * 1024;
+var COOKBOOK_LIMIT = 2 * 1024 * 1024;
+var TYPES = {
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".mjs": "text/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".webmanifest": "application/manifest+json",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".webp": "image/webp",
+	".gif": "image/gif",
+	".ico": "image/x-icon",
+	".wasm": "application/wasm",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".txt": "text/plain; charset=utf-8",
+	".map": "application/json"
+};
+var HttpError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+	}
+};
+function sendJson(res, status, body) {
+	const text = JSON.stringify(body);
+	res.writeHead(status, {
+		"content-type": "application/json; charset=utf-8",
+		"content-length": Buffer.byteLength(text),
+		"cache-control": "no-store"
+	});
+	res.end(text);
+}
+async function readBody(req, limit) {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of req) {
+		size += chunk.length;
+		if (size > limit) throw new HttpError(413, "The request body is too large.");
+		chunks.push(chunk);
+	}
+	return Buffer.concat(chunks).toString("utf-8");
+}
+async function startKitchenServer(options) {
+	const log = options.log ?? (() => {});
+	const token = options.token ?? randomBytes(32).toString("base64url");
+	const mode = options.ai ? "host" : "browser";
+	const appRoot = normalize(options.planner.appDir);
+	let port = 0;
+	let applying = false;
+	let applied = false;
+	let resolveApplied;
+	const appliedPromise = new Promise((resolve) => {
+		resolveApplied = resolve;
+	});
+	const origins = () => [`http://127.0.0.1:${port}`, `http://localhost:${port}`];
+	const config = () => ({
+		inference: mode === "host" ? {
+			mode: "host",
+			host: { endpoint: CHAT_PATH }
+		} : { mode: "browser" },
+		kitchen: {
+			endpoint: COOKBOOK_PATH,
+			token
+		}
+	});
+	function checkToken(supplied) {
+		if (!supplied) return false;
+		const a = Buffer.from(supplied);
+		const b = Buffer.from(token);
+		return a.length === b.length && timingSafeEqual(a, b);
+	}
+	/** A browser POST states its origin; it must be this server's own. */
+	function checkOrigin(req, required) {
+		const origin = req.headers.origin;
+		if (origin === void 0) {
+			if (required) throw new HttpError(403, "Same-origin requests only.");
+			return;
+		}
+		if (!origins().includes(origin)) throw new HttpError(403, "Same-origin requests only.");
+	}
+	function requireJson(req) {
+		if (!/^application\/json\b/i.test(req.headers["content-type"] ?? "")) throw new HttpError(415, "Send application/json.");
+	}
+	async function chat(req, res) {
+		if (!options.ai) throw new HttpError(503, "No AI provider is configured.");
+		checkOrigin(req, false);
+		requireJson(req);
+		let body;
+		try {
+			body = JSON.parse(await readBody(req, CHAT_LIMIT));
+		} catch (error) {
+			if (error instanceof HttpError) throw error;
+			throw new HttpError(400, "The body is not valid JSON.");
+		}
+		const parsed = options.core.parseHostRequest(body);
+		if (!parsed.ok) throw new HttpError(400, parsed.error);
+		const { system, messages } = options.core.buildHostPrompt(parsed.request);
+		let text;
+		try {
+			text = await options.ai.chat([{
+				role: "system",
+				content: system
+			}, ...messages]);
+		} catch (error) {
+			log(`The model could not answer: ${error instanceof Error ? error.message : String(error)}`);
+			throw new HttpError(502, "The model could not answer.");
+		}
+		const reply = options.core.parseHostReply(text);
+		if (reply.issues.length) log(`planner reply: ${reply.issues.join("; ")}`);
+		sendJson(res, 200, reply.reply);
+	}
+	async function cookbook(req, res) {
+		checkOrigin(req, true);
+		requireJson(req);
+		if (applied || !checkToken(req.headers["x-kitchen-token"])) throw new HttpError(401, "Missing or wrong kitchen token.");
+		if (applying) throw new HttpError(409, "A cookbook is already being applied.");
+		applying = true;
+		try {
+			const text = await readBody(req, COOKBOOK_LIMIT);
+			log("Received a cookbook from the planner.");
+			const outcome = await options.apply(text);
+			if (!outcome.ok) {
+				log(`Not applied: ${outcome.errors.join("; ")}`);
+				sendJson(res, outcome.status, {
+					ok: false,
+					errors: outcome.errors
+				});
+				return;
+			}
+			applied = true;
+			res.once("close", () => resolveApplied(outcome.body));
+			sendJson(res, 200, outcome.body);
+		} finally {
+			applying = false;
+		}
+	}
+	function serveStatic(req, res, path) {
+		let relative;
+		try {
+			relative = decodeURIComponent(path);
+		} catch {
+			throw new HttpError(400, "Bad path.");
+		}
+		if (relative.includes("\0")) throw new HttpError(400, "Bad path.");
+		let file = normalize(join(appRoot, relative));
+		if (file !== appRoot && !file.startsWith(appRoot + sep)) throw new HttpError(403, "Forbidden.");
+		let stat = statSync(file, { throwIfNoEntry: false });
+		if (stat?.isDirectory()) {
+			file = join(file, "index.html");
+			stat = statSync(file, { throwIfNoEntry: false });
+		}
+		if (!stat?.isFile()) throw new HttpError(404, "Not found.");
+		res.writeHead(200, {
+			"content-type": TYPES[extname(file).toLowerCase()] ?? "application/octet-stream",
+			"content-length": stat.size,
+			"cache-control": path.includes("/_app/immutable/") ? "public, max-age=31536000, immutable" : "no-cache"
+		});
+		if (req.method === "HEAD") {
+			res.end();
+			return;
+		}
+		createReadStream(file).pipe(res);
+	}
+	const server = createServer(async (req, res) => {
+		res.setHeader("x-content-type-options", "nosniff");
+		res.setHeader("referrer-policy", "no-referrer");
+		try {
+			if (!origins().some((o) => o.endsWith(`//${req.headers.host}`))) throw new HttpError(403, "Unexpected Host.");
+			const path = (req.url ?? "/").split("?")[0];
+			const get = req.method === "GET" || req.method === "HEAD";
+			if (path === "/planner.config.json" && get) sendJson(res, 200, config());
+			else if (path === "/api/planner/chat" && req.method === "POST") await chat(req, res);
+			else if (path === "/api/kitchen/cookbook" && req.method === "POST") await cookbook(req, res);
+			else if (get) serveStatic(req, res, path);
+			else throw new HttpError(405, "Method not allowed.");
+		} catch (error) {
+			const status = error instanceof HttpError ? error.status : 500;
+			const message = error instanceof HttpError ? error.message : "Server error.";
+			if (!(error instanceof HttpError)) log(`server error: ${error instanceof Error ? error.message : String(error)}`);
+			if (res.headersSent) res.destroy();
+			else if (req.url?.startsWith("/api/")) sendJson(res, status, {
+				ok: false,
+				error: message,
+				errors: [message]
+			});
+			else {
+				res.writeHead(status, { "content-type": "text/plain; charset=utf-8" });
+				res.end(message);
+			}
+		}
+	});
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(options.port ?? 0, "127.0.0.1", () => resolve());
+	});
+	port = server.address().port;
+	return {
+		url: `http://127.0.0.1:${port}/`,
+		port,
+		token,
+		mode,
+		applied: appliedPromise,
+		close: () => new Promise((resolve) => {
+			server.close(() => resolve());
+			server.closeAllConnections();
+		})
+	};
+}
+//#endregion
+//#region src/commands/kitchen/run.ts
+/**
+* `smrt kitchen [dir]` (#3750): find the planner, serve it on localhost, let
+* the visitor chat their way to a cookbook, apply what they send into `dir`.
+*/
+/** The target must be new (absent or empty) or an existing kitchen project. */
+function checkTargetDir(dir) {
+	if (!existsSync(dir) || readdirSync(dir).length === 0) return;
+	if (existsSync(join(dir, "smrt.cookbook.json")) && existsSync(join(dir, "package.json"))) return;
+	throw new PlannerError(`${dir} is not empty and holds no ${COOKBOOK_CONFIG_FILE}; pick an empty directory (smrt kitchen <dir>)`);
+}
+function openInBrowser(url) {
+	const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", [
+		"/c",
+		"start",
+		"",
+		url
+	]] : ["xdg-open", [url]];
+	execFile(command, args, { windowsHide: true }, () => {});
+}
+/** Run the kitchen until a cookbook was applied. Returns what was written. */
+async function runKitchen(options) {
+	const log = options.log ?? console.log;
+	const dir = resolve(options.dir);
+	checkTargetDir(dir);
+	const planner = options.overrides?.planner ?? await resolvePlanner({
+		planner: options.planner,
+		dir,
+		log
+	});
+	const core = options.overrides?.core ?? await loadPlannerCore(planner);
+	const ai = options.overrides && "ai" in options.overrides ? options.overrides.ai ?? null : await resolveKitchenAI({ dir });
+	const server = await startKitchenServer({
+		planner,
+		core,
+		ai,
+		apply: options.overrides?.apply ?? createCookbookApplier({
+			dir,
+			template: options.template,
+			install: options.install,
+			manifests: options.manifests,
+			registry: options.registry,
+			log
+		}),
+		port: options.port,
+		token: options.overrides?.token,
+		log
+	});
+	try {
+		log(`Planner ${planner.version ?? ""} (${planner.source}) at ${server.url}`.replace("  ", " "));
+		log(ai ? `Chat is answered by ${ai.label}.` : "No AI provider is configured (set an `ai` block in smrt.config.ts, SMRT_AI_PROVIDER, or e.g. OPENAI_API_KEY), so the planner runs its in-browser model. You can also build the cookbook by hand.");
+		log(`Project directory: ${dir}`);
+		log("Build your app in the planner, then choose \"Send to kitchen\". Ctrl-C to stop.");
+		options.onReady?.(server);
+		if (options.open) (options.overrides?.openBrowser ?? openInBrowser)(server.url);
+		return await (options.stop ? Promise.race([server.applied, options.stop]) : server.applied);
+	} finally {
+		await server.close();
+	}
+}
+//#endregion
+//#region src/commands/kitchen.ts
+/**
+* `smrt kitchen [dir]` and `smrt kitchen apply <url|file> [dir]` (#3750).
+* See `agents/kitchen.md`.
+*/
+/** Ctrl-C and SIGTERM stop the kitchen cleanly (the server is closed in `finally`). */
+function stopOnSignal() {
+	let dispose = () => {};
+	const stop = new Promise((_, reject) => {
+		const onSignal = (signal) => {
+			reject(new KitchenStopped(signal));
+		};
+		process.once("SIGINT", onSignal);
+		process.once("SIGTERM", onSignal);
+		dispose = () => {
+			process.off("SIGINT", onSignal);
+			process.off("SIGTERM", onSignal);
+		};
+	});
+	stop.catch(() => {});
+	return {
+		stop,
+		dispose
+	};
+}
+var KitchenStopped = class extends Error {
+	signal;
+	constructor(signal) {
+		super(`stopped by ${signal}`);
+		this.signal = signal;
+	}
+};
+var kitchenCommands = {
+	kitchen: {
+		name: "kitchen",
+		description: "Run the planner on localhost, chat your way to a cookbook, and apply it into [dir]",
+		args: ["dir"],
+		options: {
+			planner: {
+				type: "string",
+				description: "Use a packaged planner checkout (run `pnpm package` there) instead of the cached registry copy"
+			},
+			template: {
+				type: "string",
+				description: "Project template: a local path, github:owner/repo[#ref], or a git URL (default github:happyvertical/smrt-start)"
+			},
+			"no-open": {
+				type: "boolean",
+				description: "Do not open the browser; print the address only",
+				default: false
+			},
+			"no-install": {
+				type: "boolean",
+				description: "Skip the package install after the project is written",
+				default: false
+			},
+			manifests: {
+				type: "string",
+				description: "Extra package manifests (file or directory); repeatable. Searched before the workspace, node_modules and the registry",
+				multiple: true
+			},
+			"no-registry": {
+				type: "boolean",
+				description: "Do not fetch manifests of uninstalled packages from the registry",
+				default: false
+			},
+			port: {
+				type: "number",
+				description: "Listen on this port (default: a random free port)"
+			}
+		},
+		handler: async (args, options) => {
+			const dir = resolve(args[0] ?? ".");
+			const { stop, dispose } = stopOnSignal();
+			try {
+				const applied = await runKitchen({
+					dir,
+					planner: options.planner,
+					template: options.template,
+					install: !options["no-install"],
+					open: !options["no-open"],
+					manifests: asList(options.manifests),
+					registry: !options["no-registry"],
+					port: options.port === void 0 ? void 0 : Number(options.port),
+					stop
+				});
+				console.log(`\nDone: ${applied.mode === "new" ? "created" : "updated"} the project in ${applied.dir}`);
+				if (applied.added.length) console.log(`  packages added: ${applied.added.join(", ")}`);
+				console.log("\nNext steps:");
+				for (const step of applied.nextSteps) console.log(`  ${step}`);
+				console.log("  pnpm dev");
+			} catch (error) {
+				if (error instanceof KitchenStopped) {
+					console.log("\nKitchen closed.");
+					process.exitCode = 130;
+					return;
+				}
+				if (error instanceof PlannerError || error instanceof ApplyError) {
+					console.error(error.message);
+					process.exit(1);
+				}
+				throw error;
+			} finally {
+				dispose();
+			}
+		}
+	},
+	"kitchen mcp": {
+		name: "kitchen mcp",
+		description: "Serve the Kitchen planning tools over stdio MCP for a local agent plugin (ChatGPT, Codex, Claude); no model or credential is used",
+		args: [],
+		options: {
+			template: {
+				type: "string",
+				description: "Default project template for apply_plan (default github:happyvertical/smrt-start)"
+			},
+			manifests: {
+				type: "string",
+				description: "Extra package manifests (file or directory); repeatable. Searched before the workspace, node_modules and the registry",
+				multiple: true
+			},
+			"no-registry": {
+				type: "boolean",
+				description: "Do not fetch manifests of uninstalled packages from the registry",
+				default: false
+			},
+			packages: {
+				type: "string",
+				description: "Extra smrt packages whose recipes to offer (name or @scope/name); repeatable",
+				multiple: true
+			},
+			library: {
+				type: "string",
+				description: "Directory of extra <id>.cookbook.json starting points; repeatable",
+				multiple: true
+			}
+		},
+		handler: async (_args, options) => {
+			const { runKitchenMcp } = await import("./server-Dp096tZj.js");
+			await runKitchenMcp({
+				dir: process.cwd(),
+				template: options.template,
+				manifests: asList(options.manifests),
+				registry: !options["no-registry"],
+				packages: asList(options.packages),
+				library: asList(options.library)
+			});
+		}
+	},
+	"kitchen apply": {
+		...cookbookCommands["cookbook apply"],
+		name: "kitchen apply",
+		description: "Apply a cookbook made elsewhere (file, cookbook URL or plan.s-m-r-t.dev plan URL) to a new project; same as `cookbook apply`"
+	}
+};
+//#endregion
 //#region src/commands/playground.ts
 /**
 * Playground Commands
@@ -7137,7 +7887,7 @@ var dbMaterializeTenantHierarchyCommand = {
 			if (!config.database?.url || config.database.url === ":memory:") throw new Error("Database configuration required for db:materialize-tenant-hierarchy. Configure database.url in smrt.config.ts (or DATABASE_URL).");
 			const dbType = config.database.type || "sqlite";
 			const { getDatabase } = await import("@happyvertical/sql");
-			const { materializeTenantHierarchy, TenantHierarchyMaterializationError } = await import("./dist-B-kbXFDM.js");
+			const { materializeTenantHierarchy, TenantHierarchyMaterializationError } = await import("./dist-BsRSQ_hE.js");
 			db = await getDatabase({
 				type: dbType,
 				url: config.database.url
@@ -7346,7 +8096,7 @@ var dbMigrateLedgerAccountsCommand = {
 			if (dbType !== "postgres") throw new Error("db:migrate-ledger-accounts currently supports PostgreSQL only; no changes were made. See the smrt-ledgers README for SQLite.");
 			await autoDiscoverAndLoad();
 			const { getDatabase } = await import("@happyvertical/sql");
-			const { migrateLedgerAccountsTable, planLedgerAccountsTableMove } = await import("./dist-DuVZ0o9F.js");
+			const { migrateLedgerAccountsTable, planLedgerAccountsTableMove } = await import("./dist-CYVIKmvy.js");
 			db = await getDatabase({
 				type: dbType,
 				url: config.database.url
@@ -11579,4 +12329,4 @@ var workbenchCommands = { "workbench:dev": {
 	}
 } };
 //#endregion
-export { dispatchCommands, docsCommands, generateCommands, gitCommands, gnodeCommands, initCommands, playgroundCommands, utilityCommands, workbenchCommands };
+export { cookbookCommands, dispatchCommands, docsCommands, generateCommands, gitCommands, gnodeCommands, initCommands, kitchenCommands, playgroundCommands, utilityCommands, workbenchCommands };