@introspection-ai/recipes 0.13.0 → 0.14.0

package/dist/mcp-chunks/chunk-DHBE7UBH.js

@@ -0,0 +1,750 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  buildToolDoc
+} from "./chunk-MZ2NARG7.js";
+import {
+  buildEmbeddedSchemaMap
+} from "./chunk-XANPGTLI.js";
+import {
+  parsePositiveInteger
+} from "./chunk-BNV3TPE4.js";
+import {
+  MCPORTER_VERSION
+} from "./chunk-4SQKWYFF.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/generate/flag-parser.js
+function extractGeneratorFlags(args, options = {}) {
+  const result = {};
+  let index = 0;
+  while (index < args.length) {
+    const token = args[index];
+    if (!token) {
+      index += 1;
+      continue;
+    }
+    if (token === "--runtime") {
+      const value = args[index + 1];
+      if (value !== "node" && value !== "bun") {
+        throw new Error("--runtime must be 'node' or 'bun'.");
+      }
+      result.runtime = value;
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === "--timeout") {
+      const raw = args[index + 1];
+      if (!raw) {
+        throw new Error("Flag '--timeout' requires a value.");
+      }
+      const parsed = parsePositiveInteger(raw);
+      if (parsed === void 0) {
+        throw new Error("--timeout must be a positive integer.");
+      }
+      result.timeout = parsed;
+      args.splice(index, 2);
+      continue;
+    }
+    if (options.allowIncludeOptional && (token === "--include-optional" || token === "--all-parameters")) {
+      result.includeOptional = true;
+      args.splice(index, 1);
+      continue;
+    }
+    index += 1;
+  }
+  return result;
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/generate/template.js
+import { realpathSync } from "node:fs";
+import fs2 from "node:fs/promises";
+import path from "node:path";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/generate/fs-helpers.js
+import fs from "node:fs/promises";
+async function markExecutable(filePath) {
+  try {
+    await fs.chmod(filePath, 493);
+  } catch (error) {
+    if (!shouldIgnorePosixPermissionError(error)) {
+      throw error;
+    }
+  }
+}
+async function safeCopyFile(sourcePath, targetPath) {
+  try {
+    await fs.copyFile(sourcePath, targetPath);
+    return;
+  } catch (error) {
+    if (!shouldIgnorePosixPermissionError(error)) {
+      throw error;
+    }
+  }
+  const data = await fs.readFile(sourcePath);
+  await fs.writeFile(targetPath, data);
+}
+function shouldIgnorePosixPermissionError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const code = error.code;
+  return code === "EPERM" || code === "EINVAL" || code === "ENOSYS" || code === "EACCES";
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/generate/template-help.js
+function renderEmbeddedHelpSource() {
+  return `function configureGeneratedCommandHelp(command: Command): void {
+	command.configureHelp({
+		commandUsage(target) {
+			const usage = (target.name() + ' ' + target.usage()).trim() || target.name();
+			return supportsAnsiColor ? tint.bold(usage) : usage;
+		},
+		optionTerm(option) {
+			const term = option.flags ?? '';
+			return supportsAnsiColor ? tint.bold(term) : term;
+		},
+		optionDescription(option) {
+			const description = option.description ?? '';
+			return supportsAnsiColor ? tint.extraDim(description) : description;
+		},
+	});
+}
+
+function configureToolCommandHelps(): void {
+	program.commands.forEach((cmd) => {
+		if (cmd.name() === '__mcporter_inspect') {
+			return;
+		}
+		configureGeneratedCommandHelp(cmd);
+	});
+}
+
+function renderStandaloneHelp(): string {
+	const colorfulTitle = tint.bold(embeddedName) + ' ' + tint.dim('\u2014 ' + embeddedDescription);
+	const plainTitle = embeddedName + ' \u2014 ' + embeddedDescription;
+	const title = supportsAnsiColor ? colorfulTitle : plainTitle;
+	const lines = [title, '', 'Usage: ' + embeddedName + ' <command> [options]', ''];
+	if (generatorTools) {
+		lines.push(formatEmbeddedTools());
+	}
+	lines.push('', formatGlobalFlags(), '', formatQuickStart());
+	if (generatorInfo) {
+		lines.push('', tint.extraDim(generatorInfo));
+	}
+	return lines.join('\\n') + '\\n';
+}
+
+program.helpInformation = () => renderStandaloneHelp();
+
+function formatEmbeddedTools(): string {
+	const header = supportsAnsiColor ? tint.bold('Embedded tools') : 'Embedded tools';
+	if (!generatorTools.length) {
+		return header;
+	}
+	const lines = [header];
+	generatorTools.forEach((entry) => {
+		const renderedDesc = entry.description
+			? supportsAnsiColor
+				? tint.extraDim(entry.description)
+				: entry.description
+			: undefined;
+		const base = renderedDesc ? entry.name + ' - ' + renderedDesc : entry.name;
+		lines.push('  ' + base);
+		if (entry.flags) {
+			const renderedFlags = supportsAnsiColor ? tint.extraDim(entry.flags) : entry.flags;
+			lines.push('    ' + renderedFlags);
+		}
+		lines.push('');
+	});
+	if (lines[lines.length - 1] === '') {
+		lines.pop();
+	}
+	return lines.join('\\n');
+}
+
+function formatGlobalFlags(): string {
+	const header = supportsAnsiColor ? tint.bold('Global flags') : 'Global flags';
+	const entries = [
+		['-t, --timeout <ms>', 'Call timeout in milliseconds'],
+		['-o, --output <format>', 'text | markdown | json | raw (default text)'],
+	];
+	const formatted = entries.map(([flag, summary]) => '  ' + flag.padEnd(28) + summary);
+	return [header, ...formatted].join('\\n');
+}
+
+function formatQuickStart(): string {
+  const header = supportsAnsiColor ? tint.bold('Quick start') : 'Quick start';
+  const examples = quickStartExamples();
+  if (!examples.length) {
+    return header;
+  }
+  const formatted = examples.map(([cmd, note]) => '  ' + cmd + '\\n    ' + tint.dim('# ' + note));
+  return [header, ...formatted].join('\\n');
+}
+
+function quickStartExamples(): Array<[string, string]> {
+  const examples: Array<[string, string]> = [];
+  const commandMap = new Map<string, string>();
+  program.commands.forEach((cmd) => {
+    const name = cmd.name();
+    if (name !== '__mcporter_inspect') {
+      commandMap.set(name, name);
+    }
+  });
+  const embedded = Array.isArray(generatorTools) ? generatorTools : [];
+  for (const entry of embedded.slice(0, 3)) {
+    const commandName = commandMap.get(entry.name) ?? entry.name;
+    const flags = entry.flags ? ' ' + entry.flags.replace(/<[^>]+>/g, '<value>') : '';
+    examples.push([embeddedName + ' ' + commandName + flags, 'invoke ' + commandName]);
+  }
+  if (!examples.length) {
+    examples.push([embeddedName + ' <tool> --key value', 'invoke a tool with flags']);
+  }
+  return examples;
+}
+`;
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/generate/stable-json.js
+function stableJsonStringify(value, space) {
+  const json = JSON.stringify(sortJsonValue(value), void 0, space);
+  if (json === void 0) {
+    throw new TypeError("Cannot serialize unsupported JSON root value.");
+  }
+  return json;
+}
+function sortJsonValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => sortJsonValue(entry));
+  }
+  if (!isPlainObject(value)) {
+    return value;
+  }
+  const result = {};
+  for (const key of Object.keys(value).toSorted()) {
+    const entry = value[key];
+    if (entry !== void 0) {
+      result[key] = sortJsonValue(entry);
+    }
+  }
+  return result;
+}
+function isPlainObject(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/generate/template.js
+async function writeTemplate(input) {
+  const resolvedOutput = input.outputPath ? path.resolve(input.outputPath) : path.resolve(process.cwd(), `${input.serverName}.ts`);
+  const runtimeScriptPath = input.runtimeScriptPath ? path.resolve(input.runtimeScriptPath) : resolvedOutput;
+  await fs2.mkdir(path.dirname(resolvedOutput), { recursive: true });
+  await fs2.writeFile(resolvedOutput, renderTemplate({ ...input, outputPath: resolvedOutput, runtimeScriptPath }), "utf8");
+  await markExecutable(resolvedOutput);
+  return resolvedOutput;
+}
+async function readPackageMetadata() {
+  const packageJsonPath = path.resolve(process.cwd(), "package.json");
+  try {
+    const buffer = await fs2.readFile(packageJsonPath, "utf8");
+    const pkg = JSON.parse(buffer);
+    return {
+      name: pkg.name ?? "mcporter",
+      version: pkg.version ?? "0.0.0"
+    };
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+    return { name: "mcporter", version: MCPORTER_VERSION };
+  }
+}
+function renderTemplate({ runtimeKind, timeoutMs, definition, serverName, tools, generator, metadata, outputPath, runtimeScriptPath }) {
+  const imports = [
+    "import path from 'node:path';",
+    "import { fileURLToPath } from 'node:url';",
+    "import { Command } from 'commander';",
+    "import { createGeneratedKeepAliveRuntime, createRuntime, createServerProxy, handleDaemonCli } from 'mcporter';",
+    "import { createCallResult } from 'mcporter';"
+  ].join("\n");
+  const embedded = stableJsonStringify(JSON.parse(JSON.stringify(definition, (_key, value) => value instanceof URL ? value.toString() : value)), 2);
+  const relativeStdioCwd = computeRelativeStdioCwd(definition, runtimeScriptPath ?? outputPath);
+  const generatorHeader = `Generated by ${generator.name}@${generator.version} \u2014 https://github.com/openclaw/mcporter`;
+  const toolDocs = tools.map((tool) => ({
+    tool,
+    doc: buildToolDoc({
+      serverName,
+      toolName: tool.tool.name,
+      description: tool.tool.description,
+      outputSchema: tool.tool.outputSchema,
+      options: tool.options,
+      requiredOnly: true,
+      colorize: false,
+      flagExtras: [{ text: "--raw <json>" }]
+    })
+  }));
+  const renderedTools = toolDocs.map((entry) => Object.assign(renderToolCommand(entry.tool, timeoutMs, serverName, entry.doc), {
+    doc: entry.doc,
+    tool: entry.tool
+  }));
+  assertUniqueGeneratedCommandNames(renderedTools);
+  const toolHelp = renderedTools.map((entry) => ({
+    name: entry.commandName,
+    description: entry.tool.tool.description ?? "",
+    usage: entry.doc.flagUsage ? `${entry.commandName} ${entry.doc.flagUsage}` : void 0,
+    flags: entry.doc.flagUsage ?? ""
+  }));
+  const generatorHeaderLiteral = JSON.stringify(generatorHeader);
+  const toolHelpLiteral = stableJsonStringify(toolHelp, 2);
+  const embeddedSchemas = stableJsonStringify(buildEmbeddedSchemaMap(tools), 2);
+  const embeddedMetadata = stableJsonStringify(metadata, 2);
+  const toolBlocks = renderedTools.map((entry) => entry.block).join("\n\n");
+  const signatureMap = Object.fromEntries(renderedTools.map((entry) => [entry.commandName, entry.tsSignature]));
+  const signatureMapLiteral = stableJsonStringify(signatureMap, 2);
+  const generatedHeaderComment = `// @generated by ${generator.name}@${generator.version}. DO NOT EDIT.`;
+  return `#!/usr/bin/env ${runtimeKind === "bun" ? "bun" : "node"}
+${generatedHeaderComment}
+${imports}
+
+const __mcpScriptDir = path.dirname(fileURLToPath(import.meta.url));
+const __mcpRelativeStdioCwd: string | null = ${JSON.stringify(relativeStdioCwd)};
+const embeddedServer = ${embedded} as const;
+const embeddedSchemas = ${embeddedSchemas} as const;
+const embeddedName = ${JSON.stringify(serverName)};
+const embeddedDescription = ${JSON.stringify(definition.description ?? `Standalone CLI for the ${serverName} MCP server.`)};
+const generatorInfo = ${generatorHeaderLiteral};
+const generatorTools = ${toolHelpLiteral} as const;
+const embeddedMetadata = ${embeddedMetadata} as const;
+const artifactKind = determineArtifactKind();
+const program = new Command();
+program.name(embeddedName);
+program.description(embeddedDescription);
+program.option('-t, --timeout <ms>', 'Call timeout in milliseconds', (value) => parseInt(value, 10), ${timeoutMs});
+program.option('-o, --output <format>', 'Output format: text|markdown|json|raw', 'text');
+const commandSignatures: Record<string, string> = ${signatureMapLiteral};
+program.configureHelp({
+	commandTerm(cmd) {
+		const term = cmd.name();
+		return commandSignatures[term] ?? cmd.name();
+	},
+});
+program.showSuggestionAfterError(true);
+
+${toolBlocks}
+
+program
+	.command('__mcporter_inspect', { hidden: true })
+	.description('Internal metadata printer for mcporter inspect-cli.')
+	.action(() => {
+		const payload = buildMetadataPayload();
+		console.log(JSON.stringify(payload, null, 2));
+	});
+
+configureToolCommandHelps();
+
+const FORCE_COLOR = process.env.FORCE_COLOR?.toLowerCase();
+const forceDisableColor = FORCE_COLOR === '0' || FORCE_COLOR === 'false';
+const forceEnableColor = FORCE_COLOR === '1' || FORCE_COLOR === 'true' || FORCE_COLOR === '2' || FORCE_COLOR === '3';
+const hasNoColor = process.env.NO_COLOR !== undefined;
+const stdoutStream = process.stdout as NodeJS.WriteStream | undefined;
+const supportsAnsiColor = !hasNoColor && (forceEnableColor || (!forceDisableColor && Boolean(stdoutStream?.isTTY)));
+
+const tint = {
+	bold(text: string): string {
+		return supportsAnsiColor ? '\x1B[1m' + text + '\x1B[0m' : text;
+	},
+	dim(text: string): string {
+		return supportsAnsiColor ? '\x1B[90m' + text + '\x1B[0m' : text;
+	},
+	extraDim(text: string): string {
+		return supportsAnsiColor ? '\x1B[38;5;244m' + text + '\x1B[0m' : text;
+	},
+};
+
+${renderEmbeddedHelpSource()}
+
+function printResult(result: unknown, format: string) {
+	const wrapped = createCallResult(result);
+	const rawPayload = unwrapRawPayload(wrapped.raw);
+	switch (format) {
+		case 'json': {
+			const json = wrapped.json();
+			if (json !== null) {
+				console.log(JSON.stringify(json, null, 2));
+				return;
+			}
+			console.log(JSON.stringify(rawPayload, null, 2));
+			return;
+		}
+		case 'markdown': {
+			const markdown = wrapped.markdown();
+			if (markdown) {
+				console.log(markdown);
+				return;
+			}
+			break;
+		}
+		case 'raw': {
+			console.log(JSON.stringify(rawPayload, null, 2));
+			return;
+		}
+	}
+	const text = wrapped.text();
+	if (text) {
+		console.log(text);
+	} else {
+		console.log(JSON.stringify(rawPayload, null, 2));
+	}
+}
+
+function unwrapRawPayload(value: unknown): unknown {
+	if (value && typeof value === 'object' && 'raw' in value) {
+		return (value as { raw: unknown }).raw;
+	}
+	return value;
+}
+
+function parseArrayOption(value: string, itemType: 'string' | 'number' | 'boolean' | 'json') {
+	const trimmed = value.trim();
+	if (trimmed.startsWith('[')) {
+		const parsed = JSON.parse(trimmed);
+		if (!Array.isArray(parsed)) {
+			throw new Error('Expected a JSON array.');
+		}
+		return parsed;
+	}
+	if (itemType === 'json') {
+		const parsed = JSON.parse('[' + value + ']');
+		if (!Array.isArray(parsed)) {
+			throw new Error('Expected JSON array items.');
+		}
+		return parsed;
+	}
+	const values = value.split(',').map((entry) => entry.trim());
+	if (itemType === 'number') {
+		return values.map((entry) => parseFiniteNumber(entry));
+	}
+	if (itemType === 'boolean') {
+		return values.map((entry) => entry !== 'false');
+	}
+	return values;
+}
+
+function parseFiniteNumber(value: string): number {
+	const trimmed = value.trim();
+	const parsed = Number(trimmed);
+	if (trimmed === '' || !Number.isFinite(parsed)) {
+		throw new Error('Expected a finite number.');
+	}
+	return parsed;
+}
+
+function normalizeEmbeddedServer(server: typeof embeddedServer) {
+	const base = { ...server } as Record<string, unknown>;
+	if ((server.command as any).kind === 'http') {
+		const urlRaw = (server.command as any).url;
+		const urlValue = typeof urlRaw === 'string' ? urlRaw : String(urlRaw);
+		return {
+			...base,
+			command: {
+				...(server.command as Record<string, unknown>),
+				url: new URL(urlValue),
+			},
+		};
+	}
+	if ((server.command as any).kind === 'stdio') {
+		const stdio = server.command as Record<string, unknown>;
+		const resolvedCwd =
+			__mcpRelativeStdioCwd !== null
+				? path.resolve(__mcpScriptDir, __mcpRelativeStdioCwd)
+				: typeof stdio.cwd === 'string' && stdio.cwd.length > 0
+					? stdio.cwd
+					: undefined;
+		return {
+			...base,
+			command: {
+				...stdio,
+				args: [ ...((server.command as any).args ?? []) ],
+				...(resolvedCwd !== undefined ? { cwd: resolvedCwd } : {}),
+			},
+		};
+	}
+	return base;
+}
+
+function determineArtifactKind(): 'template' | 'bundle' | 'binary' {
+	const scriptPath = typeof process !== 'undefined' && Array.isArray(process.argv) ? process.argv[1] ?? '' : '';
+	if (scriptPath.endsWith('.ts')) {
+		return 'template';
+	}
+	if (scriptPath.endsWith('.js') || scriptPath.endsWith('.mjs') || scriptPath.endsWith('.cjs')) {
+		return 'bundle';
+	}
+	return 'binary';
+}
+
+function resolveArtifactPath(): string {
+	if (typeof process !== 'undefined' && Array.isArray(process.argv) && process.argv.length > 1) {
+		const script = process.argv[1];
+		if (script) {
+			return script;
+		}
+	}
+	return embeddedMetadata.artifact.path;
+}
+
+function buildMetadataPayload() {
+	const invocation = { ...embeddedMetadata.invocation };
+	const path = resolveArtifactPath();
+	if (artifactKind === 'template' && path) {
+		invocation.outputPath = invocation.outputPath ?? path;
+	} else if (artifactKind === 'bundle' && path) {
+		invocation.bundle = invocation.bundle ?? path;
+	} else if (artifactKind === 'binary' && path) {
+		invocation.compile = invocation.compile ?? path;
+	}
+	return {
+		...embeddedMetadata,
+		artifact: {
+			path,
+			kind: artifactKind,
+		},
+		invocation,
+	};
+}
+
+async function ensureRuntime() {
+	const server = normalizeEmbeddedServer(embeddedServer);
+	const baseRuntime = await createRuntime({
+		servers: [server as any],
+	});
+	return await createGeneratedKeepAliveRuntime(baseRuntime, server as any);
+}
+
+async function invokeWithTimeout<T>(call: Promise<T>, timeout: number): Promise<T> {
+	if (!Number.isFinite(timeout) || timeout <= 0) {
+		return await call;
+	}
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	try {
+		return await Promise.race([
+			call,
+			new Promise<never>((_, reject) => {
+				timer = setTimeout(() => {
+					reject(new Error('Call timed out after ' + timeout + 'ms.'));
+				}, timeout);
+			}),
+		]);
+	} finally {
+		if (timer) {
+			clearTimeout(timer);
+		}
+	}
+}
+
+function parseGeneratedDaemonInvocation(rawArgs: string[]): { args: string[]; configPath: string; rootDir?: string } | null {
+	const args = [...rawArgs];
+	let configPath: string | undefined;
+	let rootDir: string | undefined;
+	while (args.length > 0) {
+		const token = args[0];
+		if (token === '--config') {
+			args.shift();
+			configPath = args.shift();
+			continue;
+		}
+		if (token?.startsWith('--config=')) {
+			args.shift();
+			configPath = token.slice('--config='.length);
+			continue;
+		}
+		if (token === '--root') {
+			args.shift();
+			rootDir = args.shift();
+			continue;
+		}
+		if (token?.startsWith('--root=')) {
+			args.shift();
+			rootDir = token.slice('--root='.length);
+			continue;
+		}
+		break;
+	}
+	if (args[0] !== 'daemon') {
+		return null;
+	}
+	if (!configPath) {
+		throw new Error('Generated daemon invocation is missing --config.');
+	}
+	return { args: args.slice(1), configPath, rootDir };
+}
+
+async function runCli(): Promise<void> {
+	const args = process.argv.slice(2);
+	const daemonInvocation = parseGeneratedDaemonInvocation(args);
+	if (daemonInvocation) {
+		await handleDaemonCli([...daemonInvocation.args], {
+			configPath: daemonInvocation.configPath,
+			configExplicit: true,
+			rootDir: daemonInvocation.rootDir,
+		});
+		return;
+	}
+	if (args.length === 0) {
+		program.outputHelp();
+		return;
+	}
+	await program.parseAsync(process.argv);
+}
+
+if (process.env.MCPORTER_DISABLE_AUTORUN !== '1') {
+	runCli().catch((error) => {
+		const message = error instanceof Error ? error.message : String(error);
+		console.error(message);
+		process.exit(1);
+	});
+}
+`;
+}
+function renderToolCommand(tool, defaultTimeout, serverName, existingDoc) {
+  const commandName = tool.tool.name.replace(/[^a-zA-Z0-9-]/g, "-");
+  const description = tool.tool.description ?? `Invoke the ${tool.tool.name} tool.`;
+  const doc = existingDoc ?? buildToolDoc({
+    serverName,
+    toolName: tool.tool.name,
+    description: tool.tool.description,
+    outputSchema: tool.tool.outputSchema,
+    options: tool.options,
+    requiredOnly: true,
+    colorize: false,
+    flagExtras: [{ text: "--raw <json>" }]
+  });
+  const buildArgs = tool.options.map((option) => {
+    const camelCaseProp = option.cliName.split("-").filter(Boolean).map((segment, index) => index === 0 ? segment : `${segment.charAt(0).toUpperCase()}${segment.slice(1)}`).join("");
+    const source = `cmdOpts.${camelCaseProp}`;
+    return `if (${source} !== undefined) args.${option.property} = ${source};`;
+  }).join("\n		");
+  const requiredChecks = tool.options.filter((option) => option.required).map((option) => {
+    const camelCaseProp = option.cliName.split("-").filter(Boolean).map((segment, index) => index === 0 ? segment : `${segment.charAt(0).toUpperCase()}${segment.slice(1)}`).join("");
+    return { option, camelCaseProp };
+  });
+  const requiredValidation = requiredChecks.length > 0 ? `const missingRequired = [${requiredChecks.map(({ option, camelCaseProp }) => `{ value: cmdOpts.${camelCaseProp}, flag: ${JSON.stringify(`--${option.cliName}`)} }`).join(", ")}].filter((entry) => entry.value === undefined || (typeof entry.value === 'string' && entry.value.trim() === '')).map((entry) => entry.flag);
+			if (missingRequired.length > 0) {
+				throw new Error('Missing required option' + (missingRequired.length === 1 ? '' : 's') + ': ' + missingRequired.join(', '));
+			}` : "";
+  const flagUsage = doc.flagUsage;
+  const optionLines = doc.optionDocs.map((entry) => renderOption(entry)).join("\n");
+  const summary = flagUsage ? `${commandName} ${flagUsage}` : commandName;
+  const signature = summary;
+  const usageSnippet = flagUsage ? `.usage(${JSON.stringify(flagUsage)})
+` : "";
+  const tsSignature = doc.tsSignature;
+  const exampleText = doc.examples[0];
+  const exampleSnippet = exampleText ? `
+	.addHelpText('after', () => '\\nExample:\\n  ' + ${JSON.stringify(exampleText)})` : "";
+  const optionalSnippet = doc.optionalSummary ? `
+	.addHelpText('afterAll', () => '\\n' + ${JSON.stringify(doc.optionalSummary)} + '\\n')` : "";
+  const aliasSnippet = tool.tool.name !== commandName ? `
+	.alias(${JSON.stringify(tool.tool.name)})` : "";
+  const block = `program
+	.command(${JSON.stringify(commandName)})
+	.summary(${JSON.stringify(summary)})
+	.description(${JSON.stringify(description)})
+${usageSnippet ? `	${usageSnippet}` : ""}	.option('--raw <json>', 'Provide raw JSON arguments to the tool, bypassing flag parsing.')
+${optionLines ? `
+${optionLines}` : ""}
+${aliasSnippet ? `	${aliasSnippet}` : ""}	.action(async (cmdOpts) => {
+		const globalOptions = program.opts();
+		const runtimeContext = await ensureRuntime();
+		const runtime = runtimeContext.runtime;
+		const serverName = embeddedName;
+		const proxy = createServerProxy(runtime, serverName, {
+			initialSchemas: embeddedSchemas,
+		});
+		try {
+			const args = cmdOpts.raw ? JSON.parse(cmdOpts.raw) : ({} as Record<string, unknown>);
+			if (!cmdOpts.raw) {
+				${requiredValidation}
+				${buildArgs}
+			}
+			const call = (proxy.${tool.methodName} as any)(args);
+			const result = await invokeWithTimeout(call, globalOptions.timeout || ${defaultTimeout});
+			printResult(result, globalOptions.output ?? 'text');
+		} finally {
+			await runtimeContext.close(serverName).catch(() => {});
+		}
+	})${exampleSnippet}${optionalSnippet};`;
+  return { block, commandName, signature, tsSignature };
+}
+function renderOption(optionDoc) {
+  const parser = optionParser(optionDoc.option);
+  return `	.option(${JSON.stringify(optionDoc.flagLabel)}, ${JSON.stringify(optionDoc.description)}${parser ? `, ${parser}` : ""})`;
+}
+function computeRelativeStdioCwd(definition, outputPath) {
+  if (!outputPath || definition.command.kind !== "stdio") {
+    return null;
+  }
+  const rawCwd = definition.command.cwd;
+  if (typeof rawCwd === "string" && path.isAbsolute(rawCwd)) {
+    return null;
+  }
+  const baseCwd = typeof rawCwd === "string" && rawCwd.length > 0 ? rawCwd : process.cwd();
+  const absoluteCwd = realpathIfExists(path.resolve(process.cwd(), baseCwd));
+  const outputDir = realpathIfExists(path.dirname(path.resolve(outputPath)));
+  const relative = path.relative(outputDir, absoluteCwd);
+  if (path.isAbsolute(relative)) {
+    return null;
+  }
+  return relative === "" ? "." : relative;
+}
+function realpathIfExists(value) {
+  try {
+    return realpathSync.native(value);
+  } catch {
+    return value;
+  }
+}
+function optionParser(option) {
+  switch (option.type) {
+    case "number":
+      return "(value) => parseFiniteNumber(value)";
+    case "boolean":
+      return "(value) => value !== 'false'";
+    case "object":
+      return "(value) => JSON.parse(value)";
+    case "array":
+      switch (option.arrayItemType) {
+        case "number":
+          return "(value) => parseArrayOption(value, 'number')";
+        case "boolean":
+          return "(value) => parseArrayOption(value, 'boolean')";
+        case "object":
+          return "(value) => parseArrayOption(value, 'json')";
+        default:
+          return "(value) => parseArrayOption(value, 'string')";
+      }
+    default:
+      return void 0;
+  }
+}
+function assertUniqueGeneratedCommandNames(tools) {
+  const commands = /* @__PURE__ */ new Map();
+  for (const entry of tools) {
+    const previous = commands.get(entry.commandName);
+    if (previous) {
+      throw new Error(`Generated command name collision '${entry.commandName}' for tools '${previous}' and '${entry.tool.tool.name}'.`);
+    }
+    commands.set(entry.commandName, entry.tool.tool.name);
+  }
+}
+
+export {
+  extractGeneratorFlags,
+  markExecutable,
+  safeCopyFile,
+  stableJsonStringify,
+  writeTemplate,
+  readPackageMetadata
+};