@happyvertical/smrt-cli 0.40.65 → 0.40.67

package/dist/{commands-Bkdk2-S5.js → commands-BMFrPkA-.js}

@@ -3,7 +3,7 @@ import { createRequire } from "node:module";
 import * as fs from "node:fs";
 import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
 import * as path from "node:path";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { ObjectRegistry, SchemaComparer, createQualifiedName, generateDDLForEngine, getClassName, isQualifiedName, migratePostgresSystemTimestamps, parseQualifiedName, planPostgresSystemTimestampMigrations } from "@happyvertical/smrt-core";
 import { loadExternalManifestSync } from "@happyvertical/smrt-core/manifest";
@@ -15,7 +15,7 @@ import { toSnakeCase } from "@happyvertical/smrt-core/utils";
 import { readAgentModuleDocs } from "@happyvertical/smrt-core/knowledge";
 import { MCPGenerator } from "@happyvertical/smrt-core/generators";
 import { generateDeclarationsFromCLI } from "@happyvertical/smrt-core/prebuild";
-import { execSync, spawn, spawnSync } from "node:child_process";
+import { execFileSync, execSync, spawn, spawnSync } from "node:child_process";
 import https from "node:https";
 import { homedir, tmpdir } from "node:os";
 import { extract } from "tar";
@@ -5132,7 +5132,7 @@ function detectInitTarget(projectRoot) {
 	const packageJson = readJson(packageJsonPath);
 	return typeof packageJson.name === "string" && packageJson.name.startsWith("@happyvertical/smrt-") && existsSync(resolve(projectRoot, "src/svelte")) ? "package" : "app";
 }
-function detectPackageManager(projectRoot) {
+function detectPackageManager$1(projectRoot) {
 	if (existsSync(resolve(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
 	if (existsSync(resolve(projectRoot, "yarn.lock"))) return "yarn";
 	return "npm";
@@ -5159,7 +5159,7 @@ function ensurePlaygroundPlugin(viteConfigPath) {
 	writeFileSync(viteConfigPath, source);
 	return true;
 }
-function runCommand(command, args, cwd) {
+function runCommand$1(command, args, cwd) {
 	return new Promise((resolvePromise, reject) => {
 		spawn(command, args, {
 			cwd,
@@ -5304,16 +5304,16 @@ var playgroundCommands = {
 				const workspaceRoot = findSmrtWorkspaceRoot(projectRoot);
 				if (!workspaceRoot) throw new Error("Could not determine workspace root");
 				console.log("\nStarting the shared SMRT playground host...\n");
-				await runCommand("pnpm", [
+				await runCommand$1("pnpm", [
 					"--dir",
 					join(workspaceRoot, "packages/smrt-playground/host"),
 					"dev"
 				], workspaceRoot);
 				return;
 			}
-			const packageManager = detectPackageManager(projectRoot);
+			const packageManager = detectPackageManager$1(projectRoot);
 			console.log("\nStarting your app dev server with the local playground route...\n");
-			await runCommand(packageManager, packageManager === "npm" ? ["run", "dev"] : ["dev"], projectRoot);
+			await runCommand$1(packageManager, packageManager === "npm" ? ["run", "dev"] : ["dev"], projectRoot);
 		}
 	}
 };
@@ -7770,4 +7770,273 @@ export default testManifest;
 	export: exportCommand
 };
 //#endregion
-export { dispatchCommands, docsCommands, generateCommands, gitCommands, gnodeCommands, initCommands, playgroundCommands, utilityCommands };
+//#region src/commands/workbench.ts
+/**
+* Workbench Commands
+*
+* Shared SMRT package/project workbench host launcher.
+*/
+var workbenchRuntimePromise = null;
+function packageManagerEntryMatches(command, entryPath) {
+	return {
+		npm: [
+			"npm-cli.js",
+			"npm.cjs",
+			"npm.js"
+		],
+		pnpm: ["pnpm.cjs", "pnpm.js"],
+		yarn: ["yarn.cjs", "yarn.js"]
+	}[command]?.includes(basename(entryPath).toLowerCase()) ?? false;
+}
+function resolveWindowsCommandShimEntry(command) {
+	let shimPaths;
+	try {
+		shimPaths = execFileSync("where.exe", [`${command}.cmd`], {
+			encoding: "utf8",
+			windowsHide: true
+		});
+	} catch {
+		return null;
+	}
+	const shimPath = shimPaths.split(/\r?\n/).map((entry) => entry.trim()).find(Boolean);
+	if (!shimPath || !existsSync(shimPath)) return null;
+	try {
+		const packageRoot = realpathSync(join(dirname(shimPath), "node_modules", command));
+		const shim = readFileSync(shimPath, "utf8");
+		for (const match of shim.matchAll(/(?:%dp0%|%~dp0)([^"\r\n]*?\.(?:cjs|mjs|js))/gi)) {
+			const relativeEntry = match[1]?.replace(/^[\\/]+/, "").replace(/[\\/]+/g, sep);
+			if (!relativeEntry) continue;
+			const entryPath = resolve(dirname(shimPath), relativeEntry);
+			const realEntryPath = existsSync(entryPath) ? realpathSync(entryPath) : null;
+			if (realEntryPath?.startsWith(`${packageRoot}${sep}`) && packageManagerEntryMatches(command, realEntryPath)) return realEntryPath;
+		}
+	} catch {
+		return null;
+	}
+	return null;
+}
+function windowsPackageManagerInvocation(command, args) {
+	const nodeRoot = dirname(process.execPath);
+	const bundledEntry = command === "npm" ? join(nodeRoot, "node_modules", "npm", "bin", "npm-cli.js") : join(nodeRoot, "node_modules", "corepack", "dist", `${command}.js`);
+	if (existsSync(bundledEntry)) return {
+		command: process.execPath,
+		args: [bundledEntry, ...args]
+	};
+	const shimEntry = resolveWindowsCommandShimEntry(command);
+	if (shimEntry) return {
+		command: process.execPath,
+		args: [shimEntry, ...args]
+	};
+	return {
+		command: `${command}.exe`,
+		args
+	};
+}
+function findWorkspaceWorkbenchRoot(cwd) {
+	let current = resolve(cwd);
+	while (true) {
+		if (existsSync(join(current, "packages", "smrt-workbench", "host", "package.json"))) return current;
+		const parent = dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+function findInstalledWorkbenchPackageRoot(cwd) {
+	let current = resolve(cwd);
+	while (true) {
+		const packageRoot = join(current, "node_modules", "@happyvertical", "smrt-workbench");
+		if (existsSync(join(packageRoot, "package.json"))) return packageRoot;
+		const parent = dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+function findYarnPnpRoot(cwd) {
+	let current = resolve(cwd);
+	while (true) {
+		if (existsSync(join(current, ".pnp.cjs")) || existsSync(join(current, ".pnp.js"))) return current;
+		const parent = dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+function resolveInstalledWorkbenchEntry(cwd) {
+	const packageRoot = findInstalledWorkbenchPackageRoot(cwd);
+	const entryPath = packageRoot ? join(packageRoot, "dist", "index.js") : null;
+	return entryPath && existsSync(entryPath) ? entryPath : null;
+}
+function loadWorkbenchRuntime(cwd) {
+	if (!workbenchRuntimePromise) {
+		const installedEntry = resolveInstalledWorkbenchEntry(cwd);
+		const workspaceRoot = findWorkspaceWorkbenchRoot(cwd);
+		if (!installedEntry && !workspaceRoot && findYarnPnpRoot(cwd)) return Promise.reject(/* @__PURE__ */ new Error("SMRT workbench requires Yarn to use nodeLinker: node-modules; Yarn Plug’n’Play does not expose the browser host as a physical directory."));
+		workbenchRuntimePromise = installedEntry ? import(pathToFileURL(installedEntry).href) : importWorkspaceModule({
+			packageName: "@happyvertical/smrt-workbench",
+			sourceEntry: "packages/smrt-workbench/src/index.ts",
+			distEntry: "packages/smrt-workbench/dist/index.js",
+			purpose: "SMRT workbench CLI commands"
+		});
+	}
+	return workbenchRuntimePromise;
+}
+function runCommand(command, args, cwd, env) {
+	return new Promise((resolvePromise, reject) => {
+		const invocation = process.platform === "win32" ? windowsPackageManagerInvocation(command, args) : {
+			command,
+			args
+		};
+		const child = spawn(invocation.command, invocation.args, {
+			cwd,
+			env,
+			stdio: "inherit",
+			shell: false
+		});
+		child.on("error", reject);
+		child.on("exit", (code) => {
+			if (code === 0) {
+				resolvePromise();
+				return;
+			}
+			reject(/* @__PURE__ */ new Error(`${command} exited with code ${code ?? 1}`));
+		});
+	});
+}
+function resolveWorkbenchPort(value) {
+	const port = value ?? "5570";
+	if (!/^[1-9]\d*$/.test(port)) throw new Error(`Invalid workbench port "${port}". Expected an integer from 1 to 65535.`);
+	const numericPort = Number(port);
+	if (!Number.isSafeInteger(numericPort) || numericPort > 65535) throw new Error(`Invalid workbench port "${port}". Expected an integer from 1 to 65535.`);
+	return String(numericPort);
+}
+function workbenchUrlHost(host) {
+	return host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+}
+function normalizeWorkbenchHost(host) {
+	return host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+}
+function isLoopbackHost(host) {
+	return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]";
+}
+function resolveInstalledWorkbenchHostDir(cwd) {
+	const packageRoot = findInstalledWorkbenchPackageRoot(cwd);
+	if (!packageRoot) return null;
+	const hostDir = join(packageRoot, "host");
+	return existsSync(join(hostDir, "package.json")) ? hostDir : null;
+}
+function resolveWorkspaceWorkbenchHostDir(workspaceRoot) {
+	const hostDir = join(workspaceRoot, "packages", "smrt-workbench", "host");
+	return existsSync(join(hostDir, "package.json")) ? hostDir : null;
+}
+function detectPackageManager(projectRoot) {
+	let current = resolve(projectRoot);
+	while (true) {
+		if (existsSync(join(current, "pnpm-lock.yaml"))) return "pnpm";
+		if (existsSync(join(current, "yarn.lock"))) return "yarn";
+		const packageJsonPath = join(current, "package.json");
+		if (existsSync(packageJsonPath)) try {
+			const packageManager = JSON.parse(readFileSync(packageJsonPath, "utf8")).packageManager;
+			if (typeof packageManager === "string") {
+				if (packageManager.startsWith("pnpm@")) return "pnpm";
+				if (packageManager.startsWith("yarn@")) return "yarn";
+				if (packageManager.startsWith("npm@")) return "npm";
+			}
+		} catch {}
+		const parent = dirname(current);
+		if (parent === current) return "npm";
+		current = parent;
+	}
+}
+function workbenchDevCommand(packageManager, hostDir, host, port) {
+	if (packageManager === "pnpm") return {
+		command: "pnpm",
+		args: [
+			"--dir",
+			hostDir,
+			"dev",
+			"--host",
+			host,
+			"--port",
+			port,
+			"--strictPort"
+		]
+	};
+	if (packageManager === "yarn") return {
+		command: "yarn",
+		args: [
+			"--cwd",
+			hostDir,
+			"dev",
+			"--host",
+			host,
+			"--port",
+			port,
+			"--strictPort"
+		]
+	};
+	return {
+		command: "npm",
+		args: [
+			"--prefix",
+			hostDir,
+			"run",
+			"dev",
+			"--",
+			"--host",
+			host,
+			"--port",
+			port,
+			"--strictPort"
+		]
+	};
+}
+var workbenchCommands = { "workbench:dev": {
+	name: "workbench:dev",
+	description: "Run the shared SMRT workbench host for the current scope",
+	args: [],
+	options: {
+		package: {
+			type: "string",
+			description: "Focus the workbench to a package name"
+		},
+		port: {
+			type: "string",
+			description: "Workbench dev server port",
+			default: "5570"
+		},
+		host: {
+			type: "string",
+			description: "Workbench dev server host",
+			default: "127.0.0.1"
+		},
+		"allow-remote": {
+			type: "boolean",
+			description: "Acknowledge that a non-loopback host exposes local project sources",
+			default: false
+		}
+	},
+	handler: async (_args, options) => {
+		const cwd = process.cwd();
+		const scope = (await loadWorkbenchRuntime(cwd)).resolveWorkbenchScope(cwd, { packageName: options.package });
+		const workspaceRoot = findWorkspaceWorkbenchRoot(cwd);
+		const hostDir = (workspaceRoot ? resolveWorkspaceWorkbenchHostDir(workspaceRoot) : null) || resolveInstalledWorkbenchHostDir(cwd);
+		if (!hostDir) throw new Error("Could not locate @happyvertical/smrt-workbench host files. Install @happyvertical/smrt-workbench or run from the SMRT workspace.");
+		const requestedHost = options.host || "127.0.0.1";
+		const host = normalizeWorkbenchHost(requestedHost);
+		if (!isLoopbackHost(host) && !options["allow-remote"]) throw new Error(`Refusing to expose the workbench on non-loopback host "${requestedHost}". Re-run with --allow-remote only on a trusted network.`);
+		const port = resolveWorkbenchPort(options.port);
+		const url = `http://${workbenchUrlHost(host)}:${port}/`;
+		const env = {
+			...process.env,
+			SMRT_WORKBENCH_CWD: cwd,
+			SMRT_WORKBENCH_PROJECT_ROOT: scope.projectRoot,
+			SMRT_WORKBENCH_PACKAGE: scope.packageName || "",
+			SMRT_WORKBENCH_ALLOW_REMOTE: options["allow-remote"] ? "1" : ""
+		};
+		console.log(`\nStarting SMRT workbench (${scope.mode} scope) at ${url}\n`);
+		if (scope.packageName) console.log(`Focused package: ${scope.packageName}\n`);
+		const devCommand = workbenchDevCommand(workspaceRoot ? "pnpm" : detectPackageManager(scope.projectRoot), resolve(hostDir), host, port);
+		await runCommand(devCommand.command, devCommand.args, scope.projectRoot, env);
+	}
+} };
+//#endregion
+export { dispatchCommands, docsCommands, generateCommands, gitCommands, gnodeCommands, initCommands, playgroundCommands, utilityCommands, workbenchCommands };

package/dist/index.js

@@ -46,62 +46,70 @@ var _utilityCommands = null;
 var _dispatchCommands = null;
 var _docsCommands = null;
 var _playgroundCommands = null;
+var _workbenchCommands = null;
 async function getGnodeCommands() {
 	if (!_gnodeCommands) {
-		const { gnodeCommands } = await import("./commands-Bkdk2-S5.js");
+		const { gnodeCommands } = await import("./commands-BMFrPkA-.js");
 		_gnodeCommands = gnodeCommands;
 	}
 	return _gnodeCommands;
 }
 async function getGitCommands() {
 	if (!_gitCommands) {
-		const { gitCommands } = await import("./commands-Bkdk2-S5.js");
+		const { gitCommands } = await import("./commands-BMFrPkA-.js");
 		_gitCommands = gitCommands;
 	}
 	return _gitCommands;
 }
 async function getGenerateCommands() {
 	if (!_generateCommands) {
-		const { generateCommands } = await import("./commands-Bkdk2-S5.js");
+		const { generateCommands } = await import("./commands-BMFrPkA-.js");
 		_generateCommands = generateCommands;
 	}
 	return _generateCommands;
 }
 async function getInitCommands() {
 	if (!_initCommands) {
-		const { initCommands } = await import("./commands-Bkdk2-S5.js");
+		const { initCommands } = await import("./commands-BMFrPkA-.js");
 		_initCommands = initCommands;
 	}
 	return _initCommands;
 }
 async function getUtilityCommands() {
 	if (!_utilityCommands) {
-		const { utilityCommands } = await import("./commands-Bkdk2-S5.js");
+		const { utilityCommands } = await import("./commands-BMFrPkA-.js");
 		_utilityCommands = utilityCommands;
 	}
 	return _utilityCommands;
 }
 async function getDispatchCommands() {
 	if (!_dispatchCommands) {
-		const { dispatchCommands } = await import("./commands-Bkdk2-S5.js");
+		const { dispatchCommands } = await import("./commands-BMFrPkA-.js");
 		_dispatchCommands = dispatchCommands;
 	}
 	return _dispatchCommands;
 }
 async function getDocsCommands() {
 	if (!_docsCommands) {
-		const { docsCommands } = await import("./commands-Bkdk2-S5.js");
+		const { docsCommands } = await import("./commands-BMFrPkA-.js");
 		_docsCommands = docsCommands;
 	}
 	return _docsCommands;
 }
 async function getPlaygroundCommands() {
 	if (!_playgroundCommands) {
-		const { playgroundCommands } = await import("./commands-Bkdk2-S5.js");
+		const { playgroundCommands } = await import("./commands-BMFrPkA-.js");
 		_playgroundCommands = playgroundCommands;
 	}
 	return _playgroundCommands;
 }
+async function getWorkbenchCommands() {
+	if (!_workbenchCommands) {
+		const { workbenchCommands } = await import("./commands-BMFrPkA-.js");
+		_workbenchCommands = workbenchCommands;
+	}
+	return _workbenchCommands;
+}
 function collectRepeatableOptionValues(argv, optionName) {
 	const flag = `--${optionName}`;
 	const inlinePrefix = `${flag}=`;
@@ -447,7 +455,8 @@ var CLIGenerator = class {
 			"dispatch",
 			"docs",
 			"git",
-			"playground"
+			"playground",
+			"workbench"
 		])).has(firstArg)) return [combinedCommand, ...argv.slice(2)];
 		const registeredClasses = ObjectRegistry.getAllClasses();
 		if (Array.from(registeredClasses.values()).some((info) => (info.name || "").toLowerCase() === firstArg.toLowerCase())) return [combinedCommand, ...argv.slice(2)];
@@ -792,7 +801,7 @@ var CLIGenerator = class {
 				return;
 			}
 		}
-		const [gnodeCommands, generateCommands, gitCommands, initCommands, utilityCommands, dispatchCommands, docsCommands, playgroundCommands] = await Promise.all([
+		const [gnodeCommands, generateCommands, gitCommands, initCommands, utilityCommands, dispatchCommands, docsCommands, playgroundCommands, workbenchCommands] = await Promise.all([
 			getGnodeCommands(),
 			getGenerateCommands(),
 			getGitCommands(),
@@ -800,7 +809,8 @@ var CLIGenerator = class {
 			getUtilityCommands(),
 			getDispatchCommands(),
 			getDocsCommands(),
-			getPlaygroundCommands()
+			getPlaygroundCommands(),
+			getWorkbenchCommands()
 		]);
 		const builtInCommands = {
 			...gnodeCommands,
@@ -810,7 +820,8 @@ var CLIGenerator = class {
 			...utilityCommands,
 			...dispatchCommands,
 			...docsCommands,
-			...playgroundCommands
+			...playgroundCommands,
+			...workbenchCommands
 		};
 		const builtInCommand = builtInCommands[parsed.command] ?? Object.values(builtInCommands).find((cmd) => cmd.name === parsed.command || cmd.aliases?.includes(parsed.command ?? ""));
 		if (builtInCommand) {
@@ -1030,7 +1041,7 @@ var CLIGenerator = class {
 		console.log(`${this.config.name} v${this.config.version}`);
 		console.log(this.config.description);
 		console.log();
-		const [gnodeCommands, generateCommands, gitCommands, initCommands, utilityCommands, dispatchCommands, docsCommands, playgroundCommands] = await Promise.all([
+		const [gnodeCommands, generateCommands, gitCommands, initCommands, utilityCommands, dispatchCommands, docsCommands, playgroundCommands, workbenchCommands] = await Promise.all([
 			getGnodeCommands(),
 			getGenerateCommands(),
 			getGitCommands(),
@@ -1038,7 +1049,8 @@ var CLIGenerator = class {
 			getUtilityCommands(),
 			getDispatchCommands(),
 			getDocsCommands(),
-			getPlaygroundCommands()
+			getPlaygroundCommands(),
+			getWorkbenchCommands()
 		]);
 		console.log("Project Setup:");
 		for (const command of Object.values(initCommands)) this.showCommandHelp(command);
@@ -1046,6 +1058,9 @@ var CLIGenerator = class {
 		console.log("Playground:");
 		for (const command of Object.values(playgroundCommands)) this.showCommandHelp(command);
 		console.log();
+		console.log("Workbench:");
+		for (const command of Object.values(workbenchCommands)) this.showCommandHelp(command);
+		console.log();
 		console.log("Utility Commands:");
 		for (const command of Object.values(utilityCommands)) this.showCommandHelp(command);
 		console.log();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happyvertical/smrt-cli",
-  "version": "0.40.65",
+  "version": "0.40.67",
   "description": "Developer CLI for SMRT framework - introspection, testing, and project management",
   "type": "module",
   "main": "./dist/index.js",
@@ -24,20 +24,20 @@
     }
   },
   "dependencies": {
-    "@happyvertical/ai": "^0.86.1",
-    "@happyvertical/files": "^0.86.1",
-    "@happyvertical/logger": "^0.86.1",
-    "@happyvertical/sql": "^0.86.1",
-    "@happyvertical/utils": "^0.86.1",
+    "@happyvertical/ai": "^0.86.3",
+    "@happyvertical/files": "^0.86.3",
+    "@happyvertical/logger": "^0.86.3",
+    "@happyvertical/sql": "^0.86.3",
+    "@happyvertical/utils": "^0.86.3",
     "acorn": "^8.17.0",
     "fast-glob": "3.3.3",
     "tar": "^7.5.19",
-    "@happyvertical/smrt-agents": "0.40.65",
-    "@happyvertical/smrt-config": "0.40.65",
-    "@happyvertical/smrt-core": "0.40.65",
-    "@happyvertical/smrt-dev-mcp": "0.40.65",
-    "@happyvertical/smrt-types": "0.40.65",
-    "@happyvertical/smrt-playground": "0.40.65"
+    "@happyvertical/smrt-agents": "0.40.67",
+    "@happyvertical/smrt-config": "0.40.67",
+    "@happyvertical/smrt-core": "0.40.67",
+    "@happyvertical/smrt-dev-mcp": "0.40.67",
+    "@happyvertical/smrt-playground": "0.40.67",
+    "@happyvertical/smrt-types": "0.40.67"
   },
   "devDependencies": {
     "@types/node": "24.13.2",