@toolfactory.dev/core 1.0.0-rc

package/out/codegen/mcp-host-product-runtime.js

@@ -0,0 +1,413 @@
+/** Parameter name when GeneratedHostModule is required only for db2ai branches (api2ai → eslint _ prefix). */
+export function generatedModuleParam(product) {
+    return product === 'api2ai' ? '_generated' : 'generated';
+}
+export function hostCoreTypes(product) {
+    if (product === 'db2ai') {
+        return `
+type DatabaseDialect = 'postgres' | 'mysql' | 'mariadb' | 'sqlserver' | 'oracle';
+
+/** Host context inside MCP server templates. Tool modules use DbHostContext; this wider shape is shared across stdio/HTTP hosts. */
+type ApiLikeHostContext = {
+    baseUrl?: string;
+    connectionString?: string;
+    databaseDialect?: DatabaseDialect;
+    credential?: string;
+    upstreamCredential?: string;
+    credentials?: unknown;
+};
+
+type VerifyCredentialInput = {
+    inboundCredential: string;
+};
+
+type VerifyCredentialResult = {
+    upstreamCredential: string;
+    credentials: unknown;
+};
+
+type VerifyCredentialFn = (input: VerifyCredentialInput) => Promise<VerifyCredentialResult>;
+
+type GeneratedHostModule = {
+    generatedTools: Array<{ toolName: string; title?: string; description: string; access?: string }>;
+    invokeTool: (
+        toolName: string,
+        args?: Record<string, unknown>,
+        hostContext?: unknown
+    ) => Promise<unknown>;
+    inputZodByTool?: Record<string, unknown>;
+    mcpServerName?: string;
+    mcpServerVersion?: string;
+    requiresAuth: boolean;
+    connectionEnv?: string;
+    databaseDialect?: DatabaseDialect;
+    verifyCredential?: VerifyCredentialFn;
+};`.trim();
+    }
+    return `
+/** Host context inside MCP server templates. Tool modules use ApiHostContext; this wider shape is shared across stdio/HTTP hosts. */
+type ApiLikeHostContext = {
+    baseUrl?: string;
+    credential?: string;
+    upstreamCredential?: string;
+    credentials?: unknown;
+};
+
+type VerifyCredentialInput = {
+    inboundCredential: string;
+};
+
+type VerifyCredentialResult = {
+    upstreamCredential: string;
+    credentials: unknown;
+};
+
+type VerifyCredentialFn = (input: VerifyCredentialInput) => Promise<VerifyCredentialResult>;
+
+type GeneratedHostModule = {
+    generatedTools: Array<{ toolName: string; title?: string; description: string; access?: string }>;
+    invokeTool: (
+        toolName: string,
+        args?: Record<string, unknown>,
+        hostContext?: unknown
+    ) => Promise<unknown>;
+    inputZodByTool?: Record<string, unknown>;
+    mcpServerName?: string;
+    mcpServerVersion?: string;
+    requiresAuth: boolean;
+    verifyCredential?: VerifyCredentialFn;
+};`.trim();
+}
+export function dbOnlyHelperFunctions(product) {
+    if (product === 'api2ai') {
+        return '';
+    }
+    return `
+function parseDatabaseDialect(value: unknown): DatabaseDialect | undefined {
+    return value === 'postgres' || value === 'mysql' || value === 'mariadb' || value === 'sqlserver' || value === 'oracle'
+        ? value
+        : undefined;
+}
+
+function isExpectedDatabaseUrl(connectionString: string, dialect: DatabaseDialect): boolean {
+    if (dialect === 'mysql') {
+        return connectionString.startsWith('mysql://');
+    }
+    if (dialect === 'mariadb') {
+        return connectionString.startsWith('mariadb://');
+    }
+    if (dialect === 'sqlserver') {
+        return (
+            connectionString.startsWith('sqlserver://') ||
+            connectionString.startsWith('mssql://') ||
+            /^Server=/i.test(connectionString)
+        );
+    }
+    if (dialect === 'oracle') {
+        return connectionString.startsWith('oracle://');
+    }
+    return connectionString.startsWith('postgresql://') || connectionString.startsWith('postgres://');
+}`.trim();
+}
+function readVerifyCredentialExports() {
+    return `
+    const verifyCredential = imported.verifyCredential;
+    const verifyCredentialFn =
+        typeof verifyCredential === 'function' ? (verifyCredential as VerifyCredentialFn) : undefined;`.trim();
+}
+export function readGeneratedModuleTail(product) {
+    if (product === 'db2ai') {
+        return `
+    const connectionEnv = imported.connectionEnv;
+    ${readVerifyCredentialExports()}
+    return {
+        generatedTools: generatedTools as Array<{ toolName: string; title?: string; description: string }>,
+        invokeTool: invokeTool as (
+            toolName: string,
+            args?: Record<string, unknown>,
+            hostContext?: unknown
+        ) => Promise<unknown>,
+        inputZodByTool:
+            inputZodByTool && typeof inputZodByTool === 'object' && !Array.isArray(inputZodByTool)
+                ? (inputZodByTool as Record<string, unknown>)
+                : undefined,
+        mcpServerName: typeof mcpServerName === 'string' ? mcpServerName : undefined,
+        mcpServerVersion: typeof mcpServerVersion === 'string' ? mcpServerVersion : undefined,
+        requiresAuth: imported.requiresAuth === true,
+        connectionEnv: typeof connectionEnv === 'string' ? connectionEnv : undefined,
+        databaseDialect: parseDatabaseDialect(imported.databaseDialect),
+        verifyCredential: verifyCredentialFn
+    };`.trim();
+    }
+    return `
+    ${readVerifyCredentialExports()}
+    return {
+        generatedTools: generatedTools as Array<{ toolName: string; title?: string; description: string }>,
+        invokeTool: invokeTool as (
+            toolName: string,
+            args?: Record<string, unknown>,
+            hostContext?: unknown
+        ) => Promise<unknown>,
+        inputZodByTool:
+            inputZodByTool && typeof inputZodByTool === 'object' && !Array.isArray(inputZodByTool)
+                ? (inputZodByTool as Record<string, unknown>)
+                : undefined,
+        mcpServerName: typeof mcpServerName === 'string' ? mcpServerName : undefined,
+        mcpServerVersion: typeof mcpServerVersion === 'string' ? mcpServerVersion : undefined,
+        requiresAuth: imported.requiresAuth === true,
+        verifyCredential: verifyCredentialFn
+    };`.trim();
+}
+function dbConnectionStartupCheck() {
+    return `
+        const connectionString = process.env[generated.connectionEnv]?.trim();
+        if (!connectionString) {
+            throw new Error(
+                'Environment variable "' + generated.connectionEnv + '" is missing or empty (database env from .db2ai).'
+            );
+        }
+        const dialect: DatabaseDialect = generated.databaseDialect ?? 'postgres';
+        if (!isExpectedDatabaseUrl(connectionString, dialect)) {
+            throw new Error(
+                'Environment variable "' +
+                    generated.connectionEnv +
+                    '" does not match generated database dialect "' +
+                    dialect +
+                    '".'
+            );
+        }`;
+}
+function dbConnectionEnvValidationBlock() {
+    return `
+        const connectionString = process.env[generated.connectionEnv]?.trim();
+        if (!connectionString) {
+            throw new Error(
+                'Missing database URL. Set environment variable "' + generated.connectionEnv + '" (from .db2ai).'
+            );
+        }
+        const dialect: DatabaseDialect = generated.databaseDialect ?? 'postgres';
+        if (!isExpectedDatabaseUrl(connectionString, dialect)) {
+            throw new Error(
+                'Database URL from "' + generated.connectionEnv + '" does not match dialect "' + dialect + '".'
+            );
+        }`;
+}
+function dbConnectionResolveReturn() {
+    return `${dbConnectionEnvValidationBlock()}
+        return { connectionString, databaseDialect: dialect, credential: c };`;
+}
+function dbConnectionResolveReturnForOAuth() {
+    return `${dbConnectionEnvValidationBlock()}
+        return { connectionString, databaseDialect: dialect, credential: upstreamCredential, upstreamCredential, credentials };`;
+}
+export function withDbConnectionHostContextFn(product) {
+    if (product !== 'db2ai') {
+        return `
+function withDbConnectionHostContext(
+    _generated: GeneratedHostModule,
+    context: ApiLikeHostContext
+): ApiLikeHostContext {
+    return context;
+}`.trim();
+    }
+    return `
+function withDbConnectionHostContext(
+    generated: GeneratedHostModule,
+    context: ApiLikeHostContext
+): ApiLikeHostContext {
+    if (!generated.connectionEnv) {
+        return context;
+    }${dbConnectionEnvValidationBlock()}
+    return { ...context, connectionString, databaseDialect: dialect };
+}`.trim();
+}
+export function validateHostAtStartupFn(product) {
+    const dbBranch = product === 'db2ai'
+        ? `if (generated.connectionEnv) {${dbConnectionStartupCheck()}
+    } else {`
+        : '';
+    const closeDbBranch = product === 'db2ai' ? `}` : '';
+    return `
+function validateHostAtStartup(hostConfig: HostRuntimeConfig, generated: GeneratedHostModule): void {
+    ${dbBranch}
+    const baseUrlKey = hostConfig.baseUrlEnvKey?.trim();
+    if (!baseUrlKey) {
+        throw new Error('Required: --base-url-env <ENV_VAR_NAME>');
+    }
+    const baseUrl = process.env[baseUrlKey]?.trim();
+    if (!baseUrl) {
+        throw new Error(
+            'Environment variable "' + baseUrlKey + '" is missing or empty (required by --base-url-env).'
+        );
+    }
+    ${closeDbBranch}
+    if (generated.requiresAuth && !hostConfig.authEnvKey?.trim()) {
+        throw new Error('Generated tools require auth; pass --auth-env <ENV_VAR_NAME> on the MCP host.');
+    }
+    if (generated.requiresAuth && typeof generated.verifyCredential !== 'function') {
+        throw new Error(
+            'Generated tools require auth; implement verify*Credentials in src/hooks/${product}/<module>/ and re-export from generated tools.'
+        );
+    }
+}`.trim();
+}
+export function resolveHostContextForCallFn(product) {
+    const dbBranch = product === 'db2ai'
+        ? `if (generated.connectionEnv) {
+        ${dbConnectionResolveReturn()}
+    }`
+        : '';
+    return `
+async function resolveHostContextForCall(
+    hostConfig: HostRuntimeConfig,
+    ${generatedModuleParam(product)}: GeneratedHostModule
+): Promise<ApiLikeHostContext> {
+    const credential = readCredentialFromEnv(hostConfig.authEnvKey);
+    const { credential: c } = resolveRelayHostCredential(credential);
+    ${dbBranch}
+    const baseUrlKey = hostConfig.baseUrlEnvKey?.trim();
+    const baseUrl = baseUrlKey ? process.env[baseUrlKey]?.trim() : undefined;
+    if (!baseUrl) {
+        throw new Error('Missing host base URL. Pass --base-url-env on stdio-mcp-server.js and set the variable.');
+    }
+    return { baseUrl, credential: c };
+}`.trim();
+}
+export function validateHttpMcpHostAtStartupFn(product) {
+    const dbBranch = product === 'db2ai'
+        ? `if (generated.connectionEnv) {${dbConnectionStartupCheck()}
+    } else {`
+        : '';
+    const closeDbBranch = product === 'db2ai' ? `}` : '';
+    return `
+function validateHttpMcpHostAtStartup(
+    httpHostConfig: HttpMcpHostRuntimeConfig,
+    ${generatedModuleParam(product)}: GeneratedHostModule
+): void {
+    ${dbBranch}
+    const baseUrlKey = httpHostConfig.baseUrlEnvKey?.trim();
+    if (!baseUrlKey) {
+        throw new Error('Required: --base-url-env <ENV_VAR_NAME>');
+    }
+    const baseUrl = process.env[baseUrlKey]?.trim();
+    if (!baseUrl) {
+        throw new Error(
+            'Environment variable "' + baseUrlKey + '" is missing or empty (required by --base-url-env).'
+        );
+    }
+    ${closeDbBranch}
+    if (${generatedModuleParam(product)}.requiresAuth && typeof ${generatedModuleParam(product)}.verifyCredential !== 'function') {
+        throw new Error(
+            'Generated tools require auth; implement verify*Credentials in src/hooks/${product}/<module>/ and re-export from generated tools.'
+        );
+    }
+}`.trim();
+}
+export function resolveHostContextForHttpCallFn(product, httpMcpProfile) {
+    const readCredential = httpMcpProfile === 'public'
+        ? `const credential = undefined;`
+        : `const headerName = readAuthHeaderNameFromEnv();
+    let credential = readCredentialFromHttpHeaders(incomingHeaders, headerName);
+    if (!credential?.trim()) {
+        credential = readCredentialFromEnv(httpHostConfig.authEnvKey);
+    }`;
+    const dbBranch = product === 'db2ai'
+        ? `if (generated.connectionEnv) {
+        ${dbConnectionResolveReturn()}
+    }`
+        : '';
+    return `
+async function resolveHostContextForHttpCall(
+    httpHostConfig: HttpMcpHostRuntimeConfig,
+    ${generatedModuleParam(product)}: GeneratedHostModule,
+    ${httpMcpProfile === 'public' ? '_incomingHeaders' : 'incomingHeaders'}: Record<string, string | string[] | undefined>
+): Promise<ApiLikeHostContext> {
+    ${readCredential}
+    const { credential: c } = resolveRelayHostCredential(credential);
+    ${dbBranch}
+    const baseUrlKey = httpHostConfig.baseUrlEnvKey?.trim();
+    const baseUrl = baseUrlKey ? process.env[baseUrlKey]?.trim() : undefined;
+    if (!baseUrl) {
+        throw new Error(
+            'Missing host base URL. Pass --base-url-env on HTTP MCP host and set the variable.'
+        );
+    }
+    return { baseUrl, credential: c };
+}`.trim();
+}
+export function validateOAuthHttpHostAtStartupFn(product) {
+    const dbBranch = product === 'db2ai'
+        ? `if (generated.connectionEnv) {${dbConnectionStartupCheck()}
+    } else {`
+        : '';
+    const closeDbBranch = product === 'db2ai' ? `}` : '';
+    return `
+async function validateOAuthHttpHostAtStartup(
+    httpHostConfig: OAuthHttpHostRuntimeConfig,
+    ${generatedModuleParam(product)}: GeneratedHostModule
+): Promise<void> {
+    if (${generatedModuleParam(product)}.requiresAuth && typeof ${generatedModuleParam(product)}.verifyCredential !== 'function') {
+        throw new Error(
+            'Generated tools require auth; implement verify*Credentials in src/hooks/${product}/<module>/ and re-export from generated tools.'
+        );
+    }
+    ${dbBranch}
+    const baseUrlKey = httpHostConfig.baseUrlEnvKey?.trim();
+    if (!baseUrlKey) {
+        throw new Error('Required: --base-url-env <ENV_VAR_NAME>');
+    }
+    const baseUrl = process.env[baseUrlKey]?.trim();
+    if (!baseUrl) {
+        throw new Error(
+            'Environment variable "' + baseUrlKey + '" is missing or empty (required by --base-url-env).'
+        );
+    }
+    ${closeDbBranch}
+}`.trim();
+}
+export function resolveHostContextForOAuthSessionDbBranch(product) {
+    if (product === 'api2ai') {
+        return '';
+    }
+    return `if (generated.connectionEnv) {${dbConnectionResolveReturnForOAuth()}
+    }`;
+}
+/** Skip baseUrl for db2ai modules that export connectionEnv (.db2ai SQL tools). */
+export function oauthHostContextBaseUrlFieldsFn(product) {
+    const generatedParam = generatedModuleParam(product);
+    if (product === 'db2ai') {
+        return `
+function oauthHostContextBaseUrlFields(
+    httpHostConfig: OAuthHttpHostRuntimeConfig,
+    ${generatedParam}: GeneratedHostModule
+): Pick<ApiLikeHostContext, 'baseUrl'> {
+    if (${generatedParam}.connectionEnv) {
+        return {};
+    }
+    return { baseUrl: resolveOAuthHostBaseUrl(httpHostConfig) };
+}`.trim();
+    }
+    return `
+function oauthHostContextBaseUrlFields(
+    httpHostConfig: OAuthHttpHostRuntimeConfig,
+    _generated: GeneratedHostModule
+): Pick<ApiLikeHostContext, 'baseUrl'> {
+    return { baseUrl: resolveOAuthHostBaseUrl(httpHostConfig) };
+}`.trim();
+}
+export function requireBaseUrlEnvArgvCheck(product, hostConfigExpr) {
+    if (product === 'db2ai') {
+        return `if (!generated.connectionEnv && !${hostConfigExpr}) {
+        throw new Error(
+            'Required: --base-url-env <ENV_VAR_NAME> for HTTP/OpenAPI tools, or export connectionEnv from a .db2ai module.'
+        );
+    }`;
+    }
+    return `if (!${hostConfigExpr}) {
+        throw new Error('Required: --base-url-env <ENV_VAR_NAME>');
+    }`;
+}
+/** @deprecated use validateHttpMcpHostAtStartupFn */
+export function validateStatelessHttpHostAtStartupFn(product) {
+    return validateHttpMcpHostAtStartupFn(product);
+}

package/out/codegen/project-bootstrap.d.ts

@@ -0,0 +1,29 @@
+import type { McpHostProduct } from './mcp-host-product-runtime.js';
+export { resolveGeneratedCliDir, resolveGeneratedToolsPath, resolveHostProductFromGeneratedToolsPath } from './generated-layout.js';
+export type ProjectBootstrapConfig = {
+    generatorImplementationDir: string;
+    /** api2ai: HTTP/OpenAPI hosts only. db2ai: adds connectionEnv / database URL validation. Default api2ai. */
+    hostProduct?: McpHostProduct;
+    embedHomeEnv?: string;
+    fallbackProjectName: string;
+    requiredRuntimeDeps: readonly string[];
+    dependencyVersionFallbacks?: Record<string, string>;
+    resolvePackageRoot?: (generatorImplementationDir: string) => string;
+    missingDepsMessage?: (packageJsonPath: string, missing: readonly string[]) => string;
+};
+export declare function resolveBootstrapProjectRootFromSource(sourcePath: string): string;
+export declare function writeGeneratedStdioMcpHost(cliDir: string, config?: ProjectBootstrapConfig, projectRoot?: string): string;
+export declare function writeGeneratedPublicHttpMcpHost(cliDir: string, config?: ProjectBootstrapConfig, projectRoot?: string): string;
+export declare function writeGeneratedPassthroughHttpMcpHost(cliDir: string, config?: ProjectBootstrapConfig, projectRoot?: string): string;
+/** Writes public and passthrough HTTP MCP hosts. */
+export declare function writeGeneratedHttpMcpHosts(cliDir: string, config?: ProjectBootstrapConfig, projectRoot?: string): {
+    publicHttpMcpHostPath: string;
+    passthroughHttpMcpHostPath: string;
+};
+export declare function writeGeneratedOAuthHttpMcpHost(cliDir: string, config?: ProjectBootstrapConfig, projectRoot?: string): string;
+export declare function resolveMcpServerIdentityFromDestination(destinationTsPath: string, config: ProjectBootstrapConfig): {
+    name: string;
+    version: string;
+};
+export declare function writeMinimalPackageJsonIfAbsent(projectRoot: string, config: ProjectBootstrapConfig): void;
+export declare function ensureParentDir(destination: string): void;

package/out/codegen/project-bootstrap.js

@@ -0,0 +1,153 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { renderStdioMcpServerSource } from './render-stdio-mcp-server.js';
+import { renderOAuthHttpMcpServerSource } from './render-oauth-http-mcp-server.js';
+import { renderPassthroughHttpMcpServerSource, renderPublicHttpMcpServerSource } from './render-http-mcp-server.js';
+import { loggingAdapterImportForCliFile, resolveProjectRootFromGeneratedCliDir } from './generated-layout.js';
+export { resolveGeneratedCliDir, resolveGeneratedToolsPath, resolveHostProductFromGeneratedToolsPath } from './generated-layout.js';
+function resolveEmbedHomeDirectory(config) {
+    const raw = config.embedHomeEnv ? process.env[config.embedHomeEnv]?.trim() : undefined;
+    return raw ? path.resolve(raw) : undefined;
+}
+export function resolveBootstrapProjectRootFromSource(sourcePath) {
+    return path.dirname(path.resolve(sourcePath));
+}
+function resolveCliPackageRoot(config) {
+    const embed = resolveEmbedHomeDirectory(config);
+    if (embed) {
+        return embed;
+    }
+    return (config.resolvePackageRoot?.(config.generatorImplementationDir) ??
+        path.resolve(config.generatorImplementationDir, '..'));
+}
+function resolveCliPackageJsonPathForVersions(config) {
+    return path.join(resolveCliPackageRoot(config), 'package.json');
+}
+function resolveHostWriteContext(cliDir, config, projectRoot) {
+    const product = config?.hostProduct ?? 'api2ai';
+    const root = projectRoot ?? resolveProjectRootFromGeneratedCliDir(cliDir);
+    return { product, root };
+}
+export function writeGeneratedStdioMcpHost(cliDir, config, projectRoot) {
+    if (!fs.existsSync(cliDir)) {
+        fs.mkdirSync(cliDir, { recursive: true });
+    }
+    const dest = path.join(cliDir, 'stdio-mcp-server.ts');
+    const { product, root } = resolveHostWriteContext(cliDir, config, projectRoot);
+    const loggingImport = loggingAdapterImportForCliFile(dest, root);
+    fs.writeFileSync(dest, renderStdioMcpServerSource(product, loggingImport), 'utf-8');
+    return dest;
+}
+export function writeGeneratedPublicHttpMcpHost(cliDir, config, projectRoot) {
+    if (!fs.existsSync(cliDir)) {
+        fs.mkdirSync(cliDir, { recursive: true });
+    }
+    const dest = path.join(cliDir, 'public-http-mcp-server.ts');
+    const { product, root } = resolveHostWriteContext(cliDir, config, projectRoot);
+    const loggingImport = loggingAdapterImportForCliFile(dest, root);
+    fs.writeFileSync(dest, renderPublicHttpMcpServerSource(product, loggingImport), 'utf-8');
+    return dest;
+}
+export function writeGeneratedPassthroughHttpMcpHost(cliDir, config, projectRoot) {
+    if (!fs.existsSync(cliDir)) {
+        fs.mkdirSync(cliDir, { recursive: true });
+    }
+    const dest = path.join(cliDir, 'passthrough-http-mcp-server.ts');
+    const { product, root } = resolveHostWriteContext(cliDir, config, projectRoot);
+    const loggingImport = loggingAdapterImportForCliFile(dest, root);
+    fs.writeFileSync(dest, renderPassthroughHttpMcpServerSource(product, loggingImport), 'utf-8');
+    return dest;
+}
+/** Writes public and passthrough HTTP MCP hosts. */
+export function writeGeneratedHttpMcpHosts(cliDir, config, projectRoot) {
+    return {
+        publicHttpMcpHostPath: writeGeneratedPublicHttpMcpHost(cliDir, config, projectRoot),
+        passthroughHttpMcpHostPath: writeGeneratedPassthroughHttpMcpHost(cliDir, config, projectRoot)
+    };
+}
+export function writeGeneratedOAuthHttpMcpHost(cliDir, config, projectRoot) {
+    if (!fs.existsSync(cliDir)) {
+        fs.mkdirSync(cliDir, { recursive: true });
+    }
+    const dest = path.join(cliDir, 'oauth-http-mcp-server.ts');
+    const { product, root } = resolveHostWriteContext(cliDir, config, projectRoot);
+    const loggingImport = loggingAdapterImportForCliFile(dest, root);
+    fs.writeFileSync(dest, renderOAuthHttpMcpServerSource(product, loggingImport), 'utf-8');
+    return dest;
+}
+function readCliPackageJson(config) {
+    const p = resolveCliPackageJsonPathForVersions(config);
+    const raw = fs.readFileSync(p, 'utf-8');
+    const pkg = JSON.parse(raw);
+    return {
+        version: typeof pkg.version === 'string' ? pkg.version : '0.0.1',
+        dependencies: pkg.dependencies
+    };
+}
+function readCliVersionsForBootstrap(config) {
+    const pkg = readCliPackageJson(config);
+    const out = {};
+    for (const dep of config.requiredRuntimeDeps) {
+        out[dep] = pkg.dependencies?.[dep] ?? config.dependencyVersionFallbacks?.[dep] ?? '*';
+    }
+    return out;
+}
+export function resolveMcpServerIdentityFromDestination(destinationTsPath, config) {
+    const pkg = readCliPackageJson(config);
+    return {
+        name: path.parse(destinationTsPath).name,
+        version: pkg.version
+    };
+}
+function warnIfPackageJsonMissingMcpDeps(packageJsonDir, config) {
+    const pjsonPath = path.join(packageJsonDir, 'package.json');
+    if (!fs.existsSync(pjsonPath)) {
+        return;
+    }
+    let pkg;
+    try {
+        pkg = JSON.parse(fs.readFileSync(pjsonPath, 'utf-8'));
+    }
+    catch {
+        return;
+    }
+    if (!pkg || typeof pkg !== 'object') {
+        return;
+    }
+    const rec = pkg;
+    const merged = {
+        ...(rec.optionalDependencies ?? {}),
+        ...(rec.dependencies ?? {})
+    };
+    const missing = config.requiredRuntimeDeps.filter((key) => merged[key] === undefined);
+    if (missing.length > 0) {
+        console.warn(config.missingDepsMessage?.(pjsonPath, missing) ??
+            `[generate] "${pjsonPath}": install runtime dependencies: ${missing.join(', ')} (npm install), then generated/<product>/cli/stdio-mcp-server.js can run.`);
+    }
+}
+export function writeMinimalPackageJsonIfAbsent(projectRoot, config) {
+    const dest = path.join(projectRoot, 'package.json');
+    if (fs.existsSync(dest)) {
+        warnIfPackageJsonMissingMcpDeps(projectRoot, config);
+        return;
+    }
+    const versionsByDep = readCliVersionsForBootstrap(config);
+    const slug = path
+        .basename(projectRoot)
+        .replace(/[^a-zA-Z0-9-]/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 80) || config.fallbackProjectName;
+    const body = {
+        name: slug,
+        private: true,
+        type: 'module',
+        dependencies: versionsByDep
+    };
+    fs.writeFileSync(dest, `${JSON.stringify(body, null, 4)}\n`, 'utf-8');
+}
+export function ensureParentDir(destination) {
+    const destinationDir = path.dirname(destination);
+    if (!fs.existsSync(destinationDir)) {
+        fs.mkdirSync(destinationDir, { recursive: true });
+    }
+}

package/out/codegen/render-http-mcp-server.d.ts

@@ -0,0 +1,3 @@
+import { type McpHostProduct } from './mcp-host-product-runtime.js';
+export declare function renderPublicHttpMcpServerSource(product: McpHostProduct | undefined, loggingImport: string): string;
+export declare function renderPassthroughHttpMcpServerSource(product: McpHostProduct | undefined, loggingImport: string): string;