@pikku/cli 0.12.14 → 0.12.16

package/dist/src/functions/commands/deploy-apply.js

@@ -0,0 +1,206 @@
+import { basename, join, relative } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { pikkuSessionlessFunc } from '#pikku';
+import { runBuildPipeline } from '../../deploy/build-pipeline.js';
+function toRelativeImport(fromDir, toFile) {
+    let rel = relative(fromDir, toFile).replace(/\\/g, '/');
+    if (!rel.startsWith('.'))
+        rel = `./${rel}`;
+    return rel.replace(/\.ts$/, '.js');
+}
+export function getEntryContext(unitDir, pikkuDir, unit, inspectorState) {
+    const bootstrapRelative = relative(unitDir, join(pikkuDir, 'pikku-bootstrap.gen.js'));
+    const bootstrapPath = bootstrapRelative.startsWith('./') || bootstrapRelative.startsWith('../')
+        ? bootstrapRelative
+        : `./${bootstrapRelative}`;
+    const { pikkuConfigFactory, singletonServicesFactory, singletonServicesType, } = inspectorState.filesAndMethods;
+    if (!pikkuConfigFactory || !singletonServicesFactory) {
+        throw new Error('Cannot generate deploy entries: createConfig and createSingletonServices must be defined in your project');
+    }
+    const configRelative = toRelativeImport(unitDir, pikkuConfigFactory.file);
+    const servicesRelative = toRelativeImport(unitDir, singletonServicesFactory.file);
+    const singletonServicesImport = singletonServicesType
+        ? `import type { ${singletonServicesType.type} } from '${toRelativeImport(unitDir, singletonServicesType.typePath)}'`
+        : '';
+    const servicesType = singletonServicesType
+        ? `Partial<${singletonServicesType.type}>`
+        : 'Record<string, unknown>';
+    return {
+        unit,
+        unitDir,
+        bootstrapPath,
+        configImport: `import { ${pikkuConfigFactory.variable} } from '${configRelative}'`,
+        configVar: pikkuConfigFactory.variable,
+        servicesImport: `import { ${singletonServicesFactory.variable} } from '${servicesRelative}'`,
+        servicesVar: singletonServicesFactory.variable,
+        singletonServicesImport,
+        servicesType,
+    };
+}
+function sanitizeProjectId(raw) {
+    return (raw
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '') || 'pikku-project');
+}
+async function resolveProjectId(projectDir) {
+    try {
+        const pkg = JSON.parse(await readFile(join(projectDir, 'package.json'), 'utf-8'));
+        if (pkg.name) {
+            const name = pkg.name.replace(/^@[^/]+\//, '');
+            return sanitizeProjectId(name);
+        }
+    }
+    catch (e) {
+        const err = e;
+        if (err?.code !== 'ENOENT') {
+            console.warn(`Warning: failed to read package.json: ${err?.message ?? e}`);
+        }
+    }
+    return sanitizeProjectId(basename(projectDir));
+}
+export async function resolveProvider(config, providerName) {
+    const name = providerName ?? config?.deploy?.defaultProvider ?? 'cloudflare';
+    const providers = config?.deploy?.providers ?? {
+        cloudflare: '@pikku/deploy-cloudflare',
+        serverless: '@pikku/deploy-serverless',
+        azure: '@pikku/deploy-azure',
+        standalone: '@pikku/deploy-standalone',
+    };
+    const packageName = providers[name];
+    if (!packageName) {
+        throw new Error(`Unknown deploy provider: '${name}'. Available: ${Object.keys(providers).join(', ')}`);
+    }
+    const adapterExportName = name.charAt(0).toUpperCase() + name.slice(1) + 'ProviderAdapter';
+    try {
+        const mod = await import(packageName);
+        if (typeof mod.createAdapter === 'function') {
+            return mod.createAdapter();
+        }
+        if (typeof mod[adapterExportName] === 'function') {
+            return new mod[adapterExportName]();
+        }
+        throw new Error(`Deploy provider '${packageName}' does not export createAdapter() or ${adapterExportName}`);
+    }
+    catch (e) {
+        const err = e;
+        if (err?.code === 'ERR_MODULE_NOT_FOUND' ||
+            err?.code === 'MODULE_NOT_FOUND') {
+            throw new Error(`Deploy provider '${packageName}' is not installed. Run: yarn add ${packageName}`);
+        }
+        throw e;
+    }
+}
+const ANSI = {
+    green: '\x1b[32m',
+    red: '\x1b[31m',
+    bold: '\x1b[1m',
+    reset: '\x1b[0m',
+};
+async function writeResultFile(resultFile, result) {
+    if (resultFile) {
+        const { writeFile } = await import('node:fs/promises');
+        await writeFile(resultFile, JSON.stringify(result, null, 2), 'utf-8');
+    }
+}
+async function runDeploy(provider, providerDir, logger, resultFile) {
+    if (typeof provider.deploy !== 'function') {
+        logger.error(`Provider '${provider.name}' does not support deploy.`);
+        await writeResultFile(resultFile, {
+            success: false,
+            errors: [{ step: 'provider', error: 'No deploy support' }],
+        });
+        process.exit(1);
+    }
+    logger.info(`Deploying via ${provider.name}...`);
+    let deployResult;
+    try {
+        deployResult = await provider.deploy({
+            buildDir: providerDir,
+            logger,
+            onProgress: (_step, _detail) => {
+                process.stdout.write(` ${ANSI.green}done${ANSI.reset}\n`);
+            },
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        deployResult = {
+            success: false,
+            errors: [{ step: 'deploy', error: message }],
+        };
+    }
+    await writeResultFile(resultFile, deployResult);
+    console.log('');
+    if (deployResult.success) {
+        logger.info(`${ANSI.green}${ANSI.bold}Deployment complete.${ANSI.reset}`);
+        logger.info(`  ${deployResult.workersDeployed?.length ?? 0} units deployed, ${deployResult.resourcesCreated?.length ?? 0} resources created`);
+    }
+    else {
+        logger.error(`Deployment finished with ${deployResult.errors.length} error(s):`);
+        for (const e of deployResult.errors) {
+            logger.error(`  ${e.step}: ${e.error}`);
+        }
+    }
+}
+export const deployApply = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }, data) => {
+        const projectDir = config.rootDir;
+        const provider = await resolveProvider(config, data?.provider);
+        const fromPlan = data?.fromPlan ?? false;
+        const resultFile = data?.resultFile;
+        if (fromPlan) {
+            // Skip build pipeline — deploy from existing plan output
+            const { join } = await import('node:path');
+            const { existsSync } = await import('node:fs');
+            const providerDir = join(projectDir, '.deploy', provider.deployDirName);
+            const infraPath = join(providerDir, 'infra.json');
+            if (!existsSync(infraPath)) {
+                logger.error(`No plan found at ${providerDir}. Run 'pikku deploy plan' first.`);
+                await writeResultFile(resultFile, {
+                    success: false,
+                    errors: [{ step: 'plan', error: 'No plan found' }],
+                });
+                process.exit(1);
+            }
+            await runDeploy(provider, providerDir, logger, resultFile);
+            return;
+        }
+        // Full build + deploy pipeline
+        const inspectorState = await getInspectorState(true);
+        const projectId = await resolveProjectId(projectDir);
+        const buildResult = await runBuildPipeline({
+            projectDir,
+            projectId,
+            provider,
+            inspectorState,
+            serverlessIncompatible: config.deploy?.serverlessIncompatible,
+            getEntryContext,
+            logger,
+        });
+        if (buildResult.manifest.units.length === 0) {
+            logger.info('No deployment units found. Nothing to deploy.');
+            await writeResultFile(resultFile, {
+                success: true,
+                workersDeployed: [],
+                resourcesCreated: [],
+                errors: [],
+            });
+            return;
+        }
+        const { providerDir, bundled } = buildResult;
+        if (typeof provider.deploy === 'function') {
+            await runDeploy(provider, providerDir, logger, resultFile);
+        }
+        else {
+            logger.info(`${ANSI.green}${ANSI.bold}Build complete.${ANSI.reset}`);
+            logger.info(`  ${bundled.length} functions bundled to ${ANSI.bold}${providerDir}${ANSI.reset}`);
+            await writeResultFile(resultFile, {
+                success: true,
+                buildOnly: true,
+                unitCount: bundled.length,
+            });
+        }
+    },
+});

package/dist/src/functions/commands/deploy-info.d.ts

@@ -0,0 +1 @@
+export declare const deployInfo: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/deploy-info.js

@@ -0,0 +1,122 @@
+import { basename, join } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { pikkuVoidFunc } from '#pikku';
+import { analyzeDeployment } from '../../deploy/analyzer/index.js';
+const ANSI = {
+    green: '\x1b[32m',
+    blue: '\x1b[34m',
+    yellow: '\x1b[33m',
+    dim: '\x1b[2m',
+    bold: '\x1b[1m',
+    reset: '\x1b[0m',
+};
+const ROLE_COLORS = {
+    function: ANSI.blue,
+    mcp: '\x1b[35m', // magenta
+    agent: '\x1b[33m', // yellow
+    channel: ANSI.dim,
+    'workflow-step': '\x1b[34m',
+    workflow: '\x1b[34m',
+};
+function padRight(str, len) {
+    return str + ' '.repeat(Math.max(0, len - str.length));
+}
+function sanitizeProjectId(raw) {
+    return (raw
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '') || 'pikku-project');
+}
+async function resolveProjectId(projectDir) {
+    try {
+        const pkg = JSON.parse(await readFile(join(projectDir, 'package.json'), 'utf-8'));
+        if (pkg.name) {
+            const name = pkg.name.replace(/^@[^/]+\//, '');
+            return sanitizeProjectId(name);
+        }
+    }
+    catch { }
+    return sanitizeProjectId(basename(projectDir));
+}
+export const deployInfo = pikkuVoidFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        logger.info('Analyzing project...');
+        const inspectorState = await getInspectorState(true);
+        const projectId = await resolveProjectId(config.rootDir);
+        const manifest = analyzeDeployment(inspectorState, { projectId });
+        console.log('');
+        console.log(`${ANSI.bold}Project:${ANSI.reset} ${manifest.projectId}`);
+        console.log('');
+        // Units
+        console.log(`${ANSI.bold}Units (${manifest.units.length}):${ANSI.reset}`);
+        for (const u of manifest.units) {
+            const color = ROLE_COLORS[u.role] ?? ANSI.dim;
+            const fns = u.functionIds.join(', ');
+            console.log(`  ${color}${padRight(u.role, 22)}${ANSI.reset} ${ANSI.bold}${padRight(u.name, 30)}${ANSI.reset} ${ANSI.dim}[${fns}]${ANSI.reset}`);
+            for (const handler of u.handlers) {
+                if (handler.type === 'fetch' && handler.routes.length > 0) {
+                    for (const route of handler.routes) {
+                        console.log(`    ${ANSI.dim}${route.method} ${route.route}${ANSI.reset}`);
+                    }
+                }
+                else if (handler.type === 'queue') {
+                    console.log(`    ${ANSI.dim}queue: ${handler.queueName}${ANSI.reset}`);
+                }
+                else if (handler.type === 'scheduled') {
+                    console.log(`    ${ANSI.dim}cron: ${handler.schedule}${ANSI.reset}`);
+                }
+            }
+        }
+        // Queues
+        if (manifest.queues.length > 0) {
+            console.log('');
+            console.log(`${ANSI.bold}Queues (${manifest.queues.length}):${ANSI.reset}`);
+            for (const q of manifest.queues) {
+                console.log(`  ${padRight(q.name, 30)} ${ANSI.dim}-> ${q.consumerUnit}${ANSI.reset}`);
+            }
+        }
+        // Scheduled tasks
+        if (manifest.scheduledTasks.length > 0) {
+            console.log('');
+            console.log(`${ANSI.bold}Scheduled Tasks (${manifest.scheduledTasks.length}):${ANSI.reset}`);
+            for (const t of manifest.scheduledTasks) {
+                console.log(`  ${padRight(t.name, 30)} ${ANSI.dim}${t.schedule} -> ${t.unitName}${ANSI.reset}`);
+            }
+        }
+        // Channels
+        if (manifest.channels.length > 0) {
+            console.log('');
+            console.log(`${ANSI.bold}Channels (${manifest.channels.length}):${ANSI.reset}`);
+            for (const c of manifest.channels) {
+                console.log(`  ${padRight(c.name, 30)} ${ANSI.dim}${c.route} -> ${c.unitName}${ANSI.reset}`);
+            }
+        }
+        // Agents
+        if (manifest.agents.length > 0) {
+            console.log('');
+            console.log(`${ANSI.bold}Agents (${manifest.agents.length}):${ANSI.reset}`);
+            for (const a of manifest.agents) {
+                const tools = a.toolFunctionIds.join(', ');
+                console.log(`  ${padRight(a.name, 30)} ${ANSI.dim}[${tools}]${ANSI.reset}`);
+            }
+        }
+        // Secrets
+        if (manifest.secrets.length > 0) {
+            console.log('');
+            console.log(`${ANSI.bold}Required Secrets (${manifest.secrets.length}):${ANSI.reset}`);
+            for (const s of manifest.secrets) {
+                console.log(`  ${ANSI.yellow}${s.secretId}${ANSI.reset}`);
+            }
+        }
+        // Variables
+        if (manifest.variables.length > 0) {
+            console.log('');
+            console.log(`${ANSI.bold}Variables (${manifest.variables.length}):${ANSI.reset}`);
+            for (const v of manifest.variables) {
+                console.log(`  ${v.variableId}${ANSI.dim} (${v.displayName})${ANSI.reset}`);
+            }
+        }
+        console.log('');
+    },
+});

package/dist/src/functions/commands/deploy-plan.d.ts

@@ -0,0 +1,10 @@
+export declare const deployPlan: import("#pikku").PikkuFunctionConfig<{
+    resultFile?: string;
+    provider?: string;
+}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+    resultFile?: string;
+    provider?: string;
+}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    resultFile?: string;
+    provider?: string;
+}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/deploy-plan.js

@@ -0,0 +1,96 @@
+import { basename, join } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { pikkuSessionlessFunc } from '#pikku';
+import { generatePlan } from '../../deploy/plan/index.js';
+import { formatPlan } from '../../deploy/plan/formatter.js';
+import { runBuildPipeline } from '../../deploy/build-pipeline.js';
+import { resolveProvider, getEntryContext } from './deploy-apply.js';
+function sanitizeProjectId(raw) {
+    return (raw
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '') || 'pikku-project');
+}
+async function resolveProjectId(projectDir) {
+    try {
+        const pkg = JSON.parse(await readFile(join(projectDir, 'package.json'), 'utf-8'));
+        if (pkg.name) {
+            const name = pkg.name.replace(/^@[^/]+\//, '');
+            return sanitizeProjectId(name);
+        }
+    }
+    catch { }
+    return sanitizeProjectId(basename(projectDir));
+}
+function createEmptyProvider() {
+    return {
+        async getCurrentState() {
+            return {
+                units: [],
+                queues: [],
+                scheduledTasks: [],
+                secrets: [],
+                variables: {},
+            };
+        },
+        async applyChange() {
+            throw new Error('Plan mode — apply not available');
+        },
+        async hasActiveWork() {
+            return { active: false, pendingCount: 0 };
+        },
+    };
+}
+export const deployPlan = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }, data) => {
+        const projectDir = config.rootDir;
+        const inspectorState = await getInspectorState(true);
+        const projectId = await resolveProjectId(projectDir);
+        const provider = await resolveProvider(config, data?.provider);
+        const result = await runBuildPipeline({
+            projectDir,
+            projectId,
+            provider,
+            inspectorState,
+            serverlessIncompatible: config.deploy?.serverlessIncompatible,
+            getEntryContext,
+            logger,
+        });
+        if (result.manifest.units.length === 0) {
+            logger.info('No deployment units found.');
+            return;
+        }
+        // Show plan
+        const deployProvider = createEmptyProvider();
+        const currentState = await deployProvider.getCurrentState(result.manifest.projectId);
+        const plan = await generatePlan(result.manifest, currentState, deployProvider);
+        console.log('');
+        console.log(formatPlan(plan));
+        console.log('');
+        // Summary
+        let totalSize = 0;
+        for (const b of result.bundled)
+            totalSize += b.bundleSizeBytes;
+        const formatBytes = (bytes) => bytes < 1024
+            ? `${bytes}B`
+            : bytes < 1024 * 1024
+                ? `${(bytes / 1024).toFixed(1)}KB`
+                : `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+        logger.info(`${result.bundled.length} workers bundled (${formatBytes(totalSize)} total)`);
+        logger.info(`Output: ${result.providerDir}`);
+        // Write result file if --result-file is set (used by Fabric build pipeline)
+        const resultFile = data?.resultFile;
+        if (resultFile) {
+            const { writeFile } = await import('node:fs/promises');
+            await writeFile(resultFile, JSON.stringify({
+                success: result.bundleErrors.length === 0,
+                providerDir: result.providerDir,
+                unitCount: result.bundled.length,
+                totalSizeBytes: totalSize,
+                errors: result.bundleErrors,
+                manifest: result.manifest,
+            }, null, 2), 'utf-8');
+        }
+    },
+});

package/dist/src/functions/commands/enable.js

@@ -8,7 +8,7 @@ const FEATURE_DEFAULTS = {
     workflow: 'auth',
 };
 async function enableFeature(feature, logger, config, data) {
-    const noAuth = data?.['no-auth'] ?? false;
+    const noAuth = data?.noAuth ?? false;
     const configPath = join(config.configDir, 'pikku.config.json');
     const raw = await readFile(configPath, 'utf-8');
     const json = JSON.parse(raw);

package/dist/src/functions/commands/new-addon.d.ts

@@ -11,6 +11,7 @@ export declare const pikkuNewAddon: import("#pikku").PikkuFunctionConfig<{
     test?: boolean;
     openapi?: string;
     mcp?: boolean;
+    camelCase?: boolean;
 }, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
     name: string;
     displayName?: string;
@@ -24,6 +25,7 @@ export declare const pikkuNewAddon: import("#pikku").PikkuFunctionConfig<{
     test?: boolean;
     openapi?: string;
     mcp?: boolean;
+    camelCase?: boolean;
 }, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
     name: string;
     displayName?: string;
@@ -37,4 +39,5 @@ export declare const pikkuNewAddon: import("#pikku").PikkuFunctionConfig<{
     test?: boolean;
     openapi?: string;
     mcp?: boolean;
+    camelCase?: boolean;
 }, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/new-addon.js

@@ -5,7 +5,7 @@ import { createEmptyManifest, saveManifest, } from '../../utils/contract-version
 import { pikkuSessionlessFunc } from '#pikku';
 import { parseOpenAPISpec, computeContractHash, generateAddonFromOpenAPI, } from '@pikku/openapi-parser';
 function toCamelCase(str) {
-    return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    return str.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
 }
 function toPascalCase(str) {
     const camel = toCamelCase(str);
@@ -14,6 +14,69 @@ function toPascalCase(str) {
 function toScreamingSnake(str) {
     return str.replace(/-/g, '_').toUpperCase();
 }
+const TLD_SEGMENTS = new Set([
+    'com',
+    'io',
+    'org',
+    'net',
+    'co',
+    'dev',
+    'app',
+    'us',
+    'uk',
+    'eu',
+    'de',
+    'fr',
+    'nl',
+    'ch',
+    'ca',
+    'au',
+    'gov',
+    'edu',
+    'local',
+    'cloud',
+    'ai',
+    'fm',
+    'tv',
+    'me',
+    'cc',
+    'info',
+    'biz',
+    'xyz',
+    'tech',
+    'space',
+    'online',
+    'site',
+    'store',
+    'ac',
+    'int',
+    'mil',
+    'ninja',
+    'guru',
+]);
+function sanitizeAddonName(raw) {
+    const dotParts = raw.toLowerCase().split('.');
+    const kept = [];
+    for (const part of dotParts) {
+        const clean = part.replace(/^-|-$/g, '');
+        if (TLD_SEGMENTS.has(clean))
+            continue;
+        const hyphenIdx = part.indexOf('-');
+        if (hyphenIdx > 0 && TLD_SEGMENTS.has(part.slice(0, hyphenIdx))) {
+            kept.push(part.slice(hyphenIdx + 1));
+            continue;
+        }
+        kept.push(part);
+    }
+    let name = kept
+        .join('-')
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+    if (name && /^[0-9]/.test(name))
+        name = `x${name}`;
+    return name || raw;
+}
 function getAddonFiles(vars, flags) {
     const { name, camelName, pascalName, screamingName, displayName, description, category, } = vars;
     const files = {};
@@ -112,7 +175,7 @@ ${description}
 `;
     // src/services.ts
     if (flags.credential && flags.credential !== 'oauth2') {
-        // Per-user credential: use createWireServices with wire.getCredentials()
+        // Per-user credential: use createWireServices with wire.getCredential()
         const credField = flags.credential === 'bearer' ? 'token' : 'apiKey';
         files['src/services.ts'] =
             `import { ${pascalName}Service } from './${name}-api.service.js'
@@ -120,8 +183,7 @@ import { pikkuAddonWireServices } from '#pikku'
 
 export const createWireServices = pikkuAddonWireServices(
   async ({ variables }, wire) => {
-    const credentials = wire.getCredentials()
-    const cred = credentials['${camelName}'] as { ${credField}: string } | undefined
+    const cred = await wire.getCredential<{ ${credField}: string }>('${camelName}')
     if (!cred?.${credField}) {
       throw new Error('Missing ${camelName} credential')
     }
@@ -701,7 +763,8 @@ async function writeFiles(baseDir, files) {
     return written;
 }
 export const pikkuNewAddon = pikkuSessionlessFunc({
-    func: async ({ logger, config }, { name, displayName, description, category = 'General', dir, secret = false, variable = false, oauth = false, credential, test = true, openapi, mcp = false, }) => {
+    func: async ({ logger, config }, { name, displayName, description, category = 'General', dir, secret = false, variable = false, oauth = false, credential, test = true, openapi, mcp = false, camelCase = false, }) => {
+        name = sanitizeAddonName(name);
         if (!/^[a-z][a-z0-9_-]*$/.test(name)) {
             logger.error(`Invalid addon name "${name}": must start with a lowercase letter and contain only lowercase alphanumerics, hyphens, and underscores`);
             process.exit(1);
@@ -748,6 +811,7 @@ export const pikkuNewAddon = pikkuSessionlessFunc({
                 secret: (secret || effectiveOAuth) && !credentialType,
                 credential: credentialType,
                 mcp,
+                camelCase,
             });
             Object.assign(addonFiles, openapiFiles);
             // Inject openapi metadata into pikku.config.json
@@ -758,6 +822,7 @@ export const pikkuNewAddon = pikkuSessionlessFunc({
             config.addon.openapi = {
                 version: spec.info.version,
                 hash: computeContractHash(spec),
+                ...(camelCase ? { camelCase: true } : {}),
             };
             addonFiles['pikku.config.json'] = JSON.stringify(config, null, 2);
         }

package/dist/src/functions/commands/pikku-command-bootstrap.js

@@ -1,3 +1,4 @@
+import { join, dirname } from 'node:path';
 import { pikkuSessionlessFunc } from '#pikku';
 import { getFileImportRelativePath } from '../../utils/file-import-path.js';
 import { writeFileInDir } from '../../utils/file-writer.js';
@@ -13,26 +14,35 @@ export const pikkuBootstrap = pikkuSessionlessFunc({
         const wireAddonFileImports = Array.from(stateBeforeBootstrap.rpc?.wireAddonFiles ?? []).map((to) => `import '${getFileImportRelativePath(config.bootstrapFile, to, config.packageMappings)}'`);
         const localImports = allImports.map((to) => `import '${getFileImportRelativePath(config.bootstrapFile, to, config.packageMappings)}'`);
         const addonImports = addonBootstraps.map((packagePath) => `import '${packagePath}'`);
-        const packageNameArg = config.addonName ? `'${config.addonName}'` : 'null';
-        const metaDirRegistration = `import { pikkuState as __pikkuState } from '@pikku/core/internal'
-try {
-  const { fileURLToPath: __fileURLToPath } = await import('url')
-  const { dirname: __dirname } = await import('path')
-  __pikkuState(${packageNameArg}, 'package', 'metaDir', __dirname(__fileURLToPath(import.meta.url)))
-} catch {}
-`;
-        const allBootstrapImports = metaDirRegistration +
-            [...localImports, ...wireAddonFileImports, ...addonImports]
-                .sort((a, b) => {
-                const aMeta = a.includes('meta');
-                const bMeta = b.includes('meta');
-                if (aMeta && !bMeta)
-                    return -1;
-                if (!aMeta && bMeta)
-                    return 1;
-                return 0;
-            })
-                .join('\n');
+        const outDir = dirname(config.bootstrapFile);
+        const metaServiceFile = join(outDir, 'pikku-meta-service.gen.ts');
+        const escapedOutDir = outDir.replace(/\\/g, '/').replace(/'/g, "\\'");
+        const metaServiceContent = [
+            `import { LocalMetaService } from '@pikku/core/services/local-meta'`,
+            ``,
+            `export class PikkuMetaService extends LocalMetaService {`,
+            `  constructor() {`,
+            `    super('${escapedOutDir}')`,
+            `  }`,
+            `}`,
+            ``,
+        ].join('\n');
+        await writeFileInDir(logger, metaServiceFile, metaServiceContent);
+        const allBootstrapImports = [
+            ...localImports,
+            ...wireAddonFileImports,
+            ...addonImports,
+        ]
+            .sort((a, b) => {
+            const aMeta = a.includes('meta');
+            const bMeta = b.includes('meta');
+            if (aMeta && !bMeta)
+                return -1;
+            if (!aMeta && bMeta)
+                return 1;
+            return 0;
+        })
+            .join('\n');
         await writeFileInDir(logger, config.bootstrapFile, allBootstrapImports);
     },
 });

package/dist/src/functions/runtimes/nextjs/pikku-command-nextjs.js

@@ -35,10 +35,14 @@ export const pikkuNext = pikkuSessionlessFunc({
             if (!pikkuConfigFactory || !singletonServicesFactory) {
                 throw new Error('Required types not found');
             }
-            const pikkuConfigImport = `import { ${pikkuConfigFactory.variable} as createConfig } from '${getFileImportRelativePath(nextBackendFile, pikkuConfigFactory.file, packageMappings)}'`;
-            const singletonServicesImport = `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${getFileImportRelativePath(nextBackendFile, singletonServicesFactory.file, packageMappings)}'`;
+            const configAlias = pikkuConfigFactory.variable === 'createConfig' ? '' : ' as createConfig';
+            const servicesAlias = singletonServicesFactory.variable === 'createSingletonServices'
+                ? ''
+                : ' as createSingletonServices';
+            const pikkuConfigImport = `import { ${pikkuConfigFactory.variable}${configAlias} } from '${getFileImportRelativePath(nextBackendFile, pikkuConfigFactory.file, packageMappings)}'`;
+            const singletonServicesImport = `import { ${singletonServicesFactory.variable}${servicesAlias} } from '${getFileImportRelativePath(nextBackendFile, singletonServicesFactory.file, packageMappings)}'`;
             const wireServicesImport = wireServicesFactory
-                ? `import { ${wireServicesFactory.variable} as createWireServices } from '${getFileImportRelativePath(nextBackendFile, wireServicesFactory.file, packageMappings)}'`
+                ? `import { ${wireServicesFactory.variable}${wireServicesFactory.variable === 'createWireServices' ? '' : ' as createWireServices'} } from '${getFileImportRelativePath(nextBackendFile, wireServicesFactory.file, packageMappings)}'`
                 : '';
             const bootstrapPath = getFileImportRelativePath(nextBackendFile, config.bootstrapFile, packageMappings);
             const routesMapDeclarationPath = getFileImportRelativePath(nextBackendFile, httpMapDeclarationFile, packageMappings);