@pikku/cli 0.12.43 → 0.12.45

package/dist/src/functions/wirings/emails/pikku-command-emails.js

@@ -8,18 +8,57 @@ import { serializeEmailsModule } from './serialize-emails.js';
 function sha256(input) {
     return createHash('sha256').update(input).digest('hex');
 }
-function extractVariables(...sources) {
+function resolveLocaleString(strings, dottedPath) {
+    let current = strings;
+    for (const segment of dottedPath.split('.')) {
+        if (!current || typeof current !== 'object' || !(segment in current))
+            return undefined;
+        current = current[segment];
+    }
+    return typeof current === 'string' ? current : undefined;
+}
+// Variables a template actually references — scoped to the locale keys and
+// partials it uses (transitively), not every string in the shared locale file.
+function collectTemplateVariables(rootSources, locales, partials) {
     const variables = new Set();
-    for (const source of sources) {
+    const visited = new Set();
+    const queue = [...rootSources];
+    while (queue.length > 0) {
+        const source = queue.shift();
+        if (!source)
+            continue;
         for (const match of source.matchAll(/\{\{\s*([^}]+?)\s*\}\}/g)) {
             const key = String(match[1]).trim();
-            if (!key || key === 'content' || key.startsWith('>'))
+            if (!key)
+                continue;
+            if (key.startsWith('>')) {
+                const name = key.slice(1).trim();
+                if (!visited.has(`partial:${name}`)) {
+                    visited.add(`partial:${name}`);
+                    if (partials[name])
+                        queue.push(partials[name]);
+                }
                 continue;
+            }
             const rootKey = key.split('.')[0];
-            if (rootKey === 't' || rootKey === 'theme' || rootKey === 'locale')
+            if (rootKey === 'content' ||
+                rootKey === 'subject' ||
+                rootKey === 'theme' ||
+                rootKey === 'locale') {
                 continue;
-            if (rootKey === 'subject')
+            }
+            if (rootKey === 't') {
+                const path = key.split('.').slice(1).join('.');
+                if (!path || visited.has(`t:${path}`))
+                    continue;
+                visited.add(`t:${path}`);
+                for (const strings of Object.values(locales)) {
+                    const resolved = resolveLocaleString(strings, path);
+                    if (resolved)
+                        queue.push(resolved);
+                }
                 continue;
+            }
             variables.add(rootKey);
         }
     }
@@ -37,18 +76,6 @@ function stableStringify(value) {
     }
     return JSON.stringify(value);
 }
-function collectStringLeaves(value) {
-    if (typeof value === 'string') {
-        return [value];
-    }
-    if (Array.isArray(value)) {
-        return value.flatMap((item) => collectStringLeaves(item));
-    }
-    if (value && typeof value === 'object') {
-        return Object.values(value).flatMap((nested) => collectStringLeaves(nested));
-    }
-    return [];
-}
 export const pikkuEmails = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
         return generateEmailsArtifacts(logger, config);
@@ -116,8 +143,10 @@ export async function generateEmailsArtifacts(logger, config) {
             readFile(join(emailDir, 'templates', `${templateName}.subject.txt`), 'utf8'),
             readFile(join(emailDir, 'templates', `${templateName}.text.txt`), 'utf8').catch(() => ''),
         ]);
-        const localeSources = Object.values(locales).flatMap((strings) => collectStringLeaves(strings));
-        const variables = extractVariables(html, subject, text, ...Object.values(partials), ...localeSources);
+        // layout.html wraps every template at render time (see serialize-emails),
+        // so include it as a discovery root or layout-only variables get dropped.
+        const layout = partials.layout ?? '';
+        const variables = collectTemplateVariables([html, subject, text, layout], locales, partials);
         const hashes = Object.fromEntries(Object.entries(locales).map(([locale, strings]) => {
             const localePayload = stableStringify({
                 templateName,

package/dist/src/functions/wirings/functions/pikku-command-function-types-split.js

@@ -4,6 +4,7 @@ import { checkRequiredTypes } from '../../../utils/check-required-types.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeFunctionTypes } from './serialize-function-types.js';
+import { serializeAddonRefs } from './serialize-addon-refs.js';
 export const pikkuFunctionTypesSplit = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }, data) => {
         const visitState = await getInspectorState(false, true, data?.bootstrap ?? false);
@@ -22,7 +23,12 @@ export const pikkuFunctionTypesSplit = pikkuSessionlessFunc({
             ? `import type { ${pikkuConfigType.type} } from '${getFileImportRelativePath(functionTypesFile, pikkuConfigType.typePath, packageMappings)}'`
             : '// Config type not found, will use fallback';
         const content = serializeFunctionTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(functionTypesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${wireServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, wireServicesType.typePath, packageMappings)}'`, wireServicesType.type, `import type { TypedPikkuRPC, FlattenedRPCMap } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`, `import type { RequiredSingletonServices, RequiredWireServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`, configTypeImport, config.addonName, undefined, typeof config.addon === 'object' ? config.addon?.categories : undefined);
-        await writeFileInDir(logger, functionTypesFile, content);
+        const addonRefs = serializeAddonRefs({
+            addonHttp: visitState.exportedContracts.addonHttp,
+            addonChannel: visitState.exportedContracts.addonChannel,
+            addonCli: visitState.exportedContracts.addonCli,
+        });
+        await writeFileInDir(logger, functionTypesFile, `${content}\n${addonRefs}`);
     },
     middleware: [
         logCommandInfoAndTime({

package/dist/src/functions/wirings/functions/serialize-addon-refs.d.ts

@@ -0,0 +1,14 @@
+interface AddonContracts {
+    addonHttp: Record<string, Record<string, any>>;
+    addonChannel: Record<string, Record<string, any>>;
+    addonCli: Record<string, Record<string, any>>;
+}
+/**
+ * Emit the addon contract reference helpers (refHTTP / refChannel / refCLI)
+ * mirroring `ref`. Each helper indexes a generated const map whose functions
+ * are pre-bound to ref('namespace:fn') RPC proxies, so type-checking and
+ * runtime wiring resolve from the same artifact. basePath can be overridden
+ * per HTTP reference; otherwise the addon contract's own basePath is preserved.
+ */
+export declare const serializeAddonRefs: (state: AddonContracts) => string;
+export {};

package/dist/src/functions/wirings/functions/serialize-addon-refs.js

@@ -0,0 +1,129 @@
+const refFunc = (pikkuFuncId) => `ref(${JSON.stringify(pikkuFuncId)})`;
+const isHttpRouteConfig = (value) => value &&
+    typeof value === 'object' &&
+    'method' in value &&
+    'route' in value &&
+    'func' in value;
+const isHttpRouteGroup = (value) => value &&
+    typeof value === 'object' &&
+    'routes' in value &&
+    !('method' in value);
+const serializeHttpRouteMap = (routes) => {
+    const entries = Object.entries(routes).map(([key, value]) => {
+        if (isHttpRouteConfig(value)) {
+            const parts = [];
+            for (const [field, fieldValue] of Object.entries(value)) {
+                if (field === 'func') {
+                    parts.push(`func: ${refFunc(fieldValue.pikkuFuncId)}`);
+                    continue;
+                }
+                if (fieldValue === null || fieldValue === undefined)
+                    continue;
+                parts.push(`${JSON.stringify(field)}: ${JSON.stringify(fieldValue)}`);
+            }
+            return `${JSON.stringify(key)}: { ${parts.join(', ')} }`;
+        }
+        if (isHttpRouteGroup(value)) {
+            const parts = [];
+            if (value.basePath) {
+                parts.push(`basePath: ${JSON.stringify(value.basePath)}`);
+            }
+            if (Array.isArray(value.tags) && value.tags.length > 0) {
+                parts.push(`tags: ${JSON.stringify(value.tags)}`);
+            }
+            if (value.auth !== undefined && value.auth !== null) {
+                parts.push(`auth: ${JSON.stringify(value.auth)}`);
+            }
+            parts.push(`routes: ${serializeHttpRouteMap(value.routes)}`);
+            return `${JSON.stringify(key)}: { ${parts.join(', ')} }`;
+        }
+        return `${JSON.stringify(key)}: ${serializeHttpRouteMap(value)}`;
+    });
+    return `{ ${entries.join(', ')} }`;
+};
+const serializeHttpContract = (contract) => {
+    const parts = [];
+    if (contract.basePath) {
+        parts.push(`basePath: ${JSON.stringify(contract.basePath)}`);
+    }
+    if (Array.isArray(contract.tags) && contract.tags.length > 0) {
+        parts.push(`tags: ${JSON.stringify(contract.tags)}`);
+    }
+    if (contract.auth !== undefined && contract.auth !== null) {
+        parts.push(`auth: ${JSON.stringify(contract.auth)}`);
+    }
+    parts.push(`routes: ${serializeHttpRouteMap(contract.routes ?? {})}`);
+    return `{ ${parts.join(', ')} }`;
+};
+const serializeChannelContract = (contract) => {
+    const entries = Object.entries(contract).map(([action, value]) => `${JSON.stringify(action)}: { func: ${refFunc(value.pikkuFuncId)} }`);
+    return `{ ${entries.join(', ')} }`;
+};
+const serializeCliContract = (contract) => {
+    const entries = Object.entries(contract).map(([command, value]) => {
+        const parts = [`func: ${refFunc(value.pikkuFuncId)}`];
+        if (Array.isArray(value.positionals) && value.positionals.length > 0) {
+            parts.push(`positionals: ${JSON.stringify(value.positionals)}`);
+        }
+        parts.push(`options: ${JSON.stringify(value.options ?? {})}`);
+        return `${JSON.stringify(command)}: { ${parts.join(', ')} }`;
+    });
+    return `{ ${entries.join(', ')} }`;
+};
+const serializeMap = (namespaces, serializeContract) => {
+    const entries = [];
+    for (const [namespace, contracts] of Object.entries(namespaces)) {
+        for (const [contractName, contract] of Object.entries(contracts)) {
+            const key = `${namespace}:${contractName}`;
+            entries.push(`  ${JSON.stringify(key)}: ${serializeContract(contract)},`);
+        }
+    }
+    return entries.length > 0 ? `{\n${entries.join('\n')}\n}` : '{}';
+};
+/**
+ * Emit the addon contract reference helpers (refHTTP / refChannel / refCLI)
+ * mirroring `ref`. Each helper indexes a generated const map whose functions
+ * are pre-bound to ref('namespace:fn') RPC proxies, so type-checking and
+ * runtime wiring resolve from the same artifact. basePath can be overridden
+ * per HTTP reference; otherwise the addon contract's own basePath is preserved.
+ */
+export const serializeAddonRefs = (state) => {
+    const exported = state ?? {
+        addonHttp: {},
+        addonChannel: {},
+        addonCli: {},
+    };
+    const httpMap = serializeMap(exported.addonHttp ?? {}, serializeHttpContract);
+    const channelMap = serializeMap(exported.addonChannel ?? {}, serializeChannelContract);
+    const cliMap = serializeMap(exported.addonCli ?? {}, serializeCliContract);
+    return `
+/**
+ * Addon contract references. Generated from each wired addon's published
+ * contract metadata — no addon source is imported. Functions are proxied via
+ * ref() (RPC) exactly like ref('namespace:fn').
+ */
+const __addonHttp = ${httpMap} as const
+const __addonChannel = ${channelMap} as const
+const __addonCli = ${cliMap} as const
+
+export const refHTTP = <Name extends keyof typeof __addonHttp>(
+  name: Name,
+  options?: { basePath?: string }
+): (typeof __addonHttp)[Name] => {
+  const contract = __addonHttp[name] as any
+  return (
+    options?.basePath !== undefined
+      ? { ...contract, basePath: options.basePath }
+      : contract
+  ) as (typeof __addonHttp)[Name]
+}
+
+export const refChannel = <Name extends keyof typeof __addonChannel>(
+  name: Name
+): (typeof __addonChannel)[Name] => __addonChannel[name]
+
+export const refCLI = <Name extends keyof typeof __addonCli>(
+  name: Name
+): (typeof __addonCli)[Name] => __addonCli[name]
+`;
+};

package/dist/src/functions/wirings/http/pikku-command-http-routes.js

@@ -7,21 +7,36 @@ import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verb
 export const pikkuCommandHTTP = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        const { httpWiringsFile, httpWiringMetaFile, httpWiringMetaJsonFile, packageMappings, schema, } = config;
-        const { http } = visitState;
-        if (http.files.size === 0 || Object.keys(http.meta).length === 0) {
+        const { httpWiringsFile, httpWiringMetaFile, httpWiringMetaJsonFile, httpContractsMetaJsonFile, httpContractsMetaFile, packageMappings, schema, } = config;
+        const { http, exportedContracts } = visitState;
+        const hasHTTPContracts = Object.keys(exportedContracts.http).length > 0;
+        if ((http.files.size === 0 || Object.keys(http.meta).length === 0) &&
+            !hasHTTPContracts) {
             return undefined;
         }
+        // The bootstrap imports httpWiringsFile and httpWiringMetaFile whenever
+        // this command reports HTTP as active (truthy return), so both must
+        // always be written once past the guard above — including the
+        // contracts-only or synthetic-route case where there are no local
+        // wireHTTP source files (http.files is empty). Skipping either leaves the
+        // bootstrap importing a file that was never generated and the per-unit
+        // deploy bundle fails to resolve it.
         await writeFileInDir(logger, httpWiringsFile, serializeFileImports('wireHTTP', httpWiringsFile, http.files, packageMappings));
-        // Write minimal JSON (runtime-only fields)
         const minimalMeta = stripVerboseFields(http.meta);
         await writeFileInDir(logger, httpWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
-        // Write verbose JSON only if it has additional fields
         if (hasVerboseFields(http.meta)) {
             const verbosePath = httpWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
             await writeFileInDir(logger, verbosePath, JSON.stringify(http.meta, null, 2));
         }
-        // Generate TypeScript file that imports the minimal JSON
+        await writeFileInDir(logger, httpContractsMetaJsonFile, JSON.stringify(exportedContracts.http, null, 2));
+        if (hasHTTPContracts) {
+            const contractsJsonImportPath = getFileImportRelativePath(httpContractsMetaFile, httpContractsMetaJsonFile, packageMappings);
+            const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+            const contractsImportStatement = supportsImportAttributes
+                ? `import contractsMeta from '${contractsJsonImportPath}' with { type: 'json' }`
+                : `import contractsMeta from '${contractsJsonImportPath}'`;
+            await writeFileInDir(logger, httpContractsMetaFile, `${contractsImportStatement}\nexport default contractsMeta`);
+        }
         const jsonImportPath = getFileImportRelativePath(httpWiringMetaFile, httpWiringMetaJsonFile, packageMappings);
         const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
         const importStatement = supportsImportAttributes

package/dist/src/functions/wirings/http/serialize-typed-http-map.js

@@ -58,6 +58,18 @@ function generateHTTPWirings(routesMeta, resolvedIOTypes, requiredTypes) {
             }
             const resolved = resolvedIOTypes[pikkuFuncId];
             if (!resolved) {
+                if (meta.packageName) {
+                    // Addon functions aren't in the consumer's local resolvedIOTypes, but
+                    // their real types are reachable through the generated FlattenedRPCMap
+                    // (the addon's RPC map is merged in under its namespace). Adding these
+                    // to requiredTypes triggers the FlattenedRPCMap import below.
+                    const inputType = `FlattenedRPCMap['${pikkuFuncId}']['input']`;
+                    const outputType = `FlattenedRPCMap['${pikkuFuncId}']['output']`;
+                    requiredTypes.add(inputType);
+                    requiredTypes.add(outputType);
+                    routesObj[route][method] = { inputType, outputType };
+                    continue;
+                }
                 throw new Error(`Function ${pikkuFuncId} not found in resolvedIOTypes. Please check your configuration.`);
             }
             requiredTypes.add(resolved.inputType);

package/dist/src/functions/workflows/all.workflow.js

@@ -189,6 +189,13 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
                 allImports.push(config.triggersWiringMetaFile, config.triggerSourcesMetaFile, config.triggersWiringFile);
             }
         }
+        if (config.addon) {
+            await Promise.all([
+                workflow.do('HTTP', 'pikkuCommandHTTP', null),
+                workflow.do('Channels', 'pikkuCommandChannels', null),
+                workflow.do('CLI', 'pikkuCLI', null),
+            ]);
+        }
         const hasFunctionRegistrations = await workflow.do('Functions', 'pikkuFunctions', null);
         allImports.push(config.functionsMetaFile);
         if (hasFunctionRegistrations) {

package/dist/src/scaffold/rpc-remote.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.43
+ * This file was generated by @pikku/cli@0.12.45
  */
 /**
  * Auto-generated remote internal RPC queue worker and HTTP endpoint

package/dist/src/services/cli-logger-forwarder.service.d.ts

@@ -1,7 +1,7 @@
 import type { Logger } from '@pikku/core/services';
 import { LogLevel } from '@pikku/core/services';
 import type { PikkuChannel } from '@pikku/core/channel';
-import type { ErrorCode } from '@pikku/inspector';
+import type { ErrorCode, CodedDiagnostic, DiagnosticSeverity } from '@pikku/inspector';
 /**
  * Log message structure sent through the channel
  */
@@ -29,6 +29,9 @@ export declare class CLILoggerForwarder implements Logger {
     warn(messageOrObj: string | Record<string, any>, ..._meta: any[]): void;
     debug(message: string, ..._meta: any[]): void;
     trace(message: string, ..._meta: any[]): void;
+    diagnostic({ severity, code, message }: CodedDiagnostic): void;
     critical(code: ErrorCode, message: string): void;
     hasCriticalErrors(): boolean;
+    hasBlockingDiagnostics(): boolean;
+    blockingSeverities(): DiagnosticSeverity[];
 }

package/dist/src/services/cli-logger-forwarder.service.js

@@ -59,13 +59,31 @@ export class CLILoggerForwarder {
     trace(message, ..._meta) {
         this.log('trace', LogLevel.trace, message);
     }
-    critical(code, message) {
+    diagnostic({ severity, code, message }) {
+        // Delegate tracking to the underlying CLILogger so the build gate still
+        // sees diagnostics emitted through the forwarder, then forward to the
+        // channel for display.
+        ;
+        this.logger.diagnostic?.({ severity, code, message });
         const url = `https://pikku.dev/docs/pikku-cli/errors/${code.toLowerCase()}`;
         const formattedMessage = `[${code}] ${message}\n  → ${url}`;
-        this.error(formattedMessage);
+        if (severity === 'warn')
+            this.warn(formattedMessage);
+        else
+            this.error(formattedMessage);
+    }
+    critical(code, message) {
+        this.diagnostic({ severity: 'critical', code, message });
     }
     hasCriticalErrors() {
         // The underlying logger (CLILogger) tracks critical errors
         return this.logger.hasCriticalErrors?.() ?? false;
     }
+    hasBlockingDiagnostics() {
+        // The underlying logger (CLILogger) owns failOn + diagnostic tracking
+        return this.logger.hasBlockingDiagnostics?.() ?? false;
+    }
+    blockingSeverities() {
+        return this.logger.blockingSeverities?.() ?? [];
+    }
 }

package/dist/src/services/cli-logger.service.d.ts

@@ -1,11 +1,12 @@
 import type { Logger } from '@pikku/core/services';
 import { LogLevel } from '@pikku/core/services';
-import type { ErrorCode } from '@pikku/inspector';
+import type { ErrorCode, DiagnosticSeverity, CodedDiagnostic } from '@pikku/inspector';
 export type CLIOutputMode = 'text' | 'json';
 export declare class CLILogger implements Logger {
     private silent;
     private level;
-    private criticalErrors;
+    private diagnostics;
+    private failOn;
     private outputMode;
     private jsonFlushHookRegistered;
     constructor({ logLogo, silent, }: {
@@ -42,7 +43,20 @@ export declare class CLILogger implements Logger {
         type?: string;
         data?: Record<string, unknown>;
     }): void;
+    diagnostic({ severity, code, message }: CodedDiagnostic): void;
+    /** Sugar for `diagnostic({ severity: 'critical', code, message })`. */
     critical(code: ErrorCode, message: string): void;
+    /**
+     * Configure which severities fail the build. Critical is always included.
+     */
+    setFailOn(severities: Iterable<DiagnosticSeverity>): void;
     hasCriticalErrors(): boolean;
+    /**
+     * True if any tracked diagnostic matches a severity configured to fail the
+     * build (default: critical only).
+     */
+    hasBlockingDiagnostics(): boolean;
+    /** Distinct severities among tracked diagnostics that would fail the build. */
+    blockingSeverities(): DiagnosticSeverity[];
     logLogo(): void;
 }

package/dist/src/services/cli-logger.service.js

@@ -9,7 +9,12 @@ const ANSI_ESCAPE_REGEX = /\x1B\[[0-?]*[ -/]*[@-~]/g;
 export class CLILogger {
     silent;
     level = LogLevel.info; // default to info level
-    criticalErrors = [];
+    diagnostics = [];
+    // Severities that should fail the build. Critical always blocks; error/warn
+    // are opt-in via --fail-on-error / --fail-on-warn.
+    failOn = new Set([
+        'critical',
+    ]);
     outputMode = 'text';
     jsonFlushHookRegistered = false;
     constructor({ logLogo, silent = false, }) {
@@ -138,14 +143,37 @@ export class CLILogger {
         const data = typeof message === 'string' ? undefined : message.data;
         this.emit('debug', msg, type, undefined, data);
     }
-    critical(code, message) {
+    diagnostic({ severity, code, message }) {
         const url = `${BASE_ERROR_URL}/${code.toLowerCase()}`;
         const formattedMessage = `[${code}] ${message}\n  → ${url}`;
-        this.criticalErrors.push(formattedMessage);
-        this.emit('critical', formattedMessage, undefined, code);
+        this.diagnostics.push({ severity, code, message });
+        // critical → bold red, error → red, warn → yellow. Always printed so the
+        // issue surfaces even when it doesn't fail the build.
+        this.emit(severity, formattedMessage, undefined, code);
+    }
+    /** Sugar for `diagnostic({ severity: 'critical', code, message })`. */
+    critical(code, message) {
+        this.diagnostic({ severity: 'critical', code, message });
+    }
+    /**
+     * Configure which severities fail the build. Critical is always included.
+     */
+    setFailOn(severities) {
+        this.failOn = new Set(['critical', ...severities]);
     }
     hasCriticalErrors() {
-        return this.criticalErrors.length > 0;
+        return this.diagnostics.some((d) => d.severity === 'critical');
+    }
+    /**
+     * True if any tracked diagnostic matches a severity configured to fail the
+     * build (default: critical only).
+     */
+    hasBlockingDiagnostics() {
+        return this.diagnostics.some((d) => this.failOn.has(d.severity));
+    }
+    /** Distinct severities among tracked diagnostics that would fail the build. */
+    blockingSeverities() {
+        return [...this.failOn].filter((s) => this.diagnostics.some((d) => d.severity === s));
     }
     logLogo() {
         if (this.silent || this.outputMode === 'json')

package/dist/src/services.js

@@ -79,6 +79,13 @@ export const createConfig = async (_variablesService, data) => {
     }
     logger.setLevel(logLevel);
     logger.setSilent(isSilent);
+    // Build gate: critical always fails; --fail-on-warn implies --fail-on-error.
+    const extraFailOn = [];
+    if (data.failOnWarn)
+        extraFailOn.push('warn', 'error');
+    else if (data.failOnError)
+        extraFailOn.push('error');
+    logger.setFailOn(extraFailOn);
     // Display logo unless in silent mode
     if (!isSilent && outputMode !== 'json') {
         logger.logLogo();

package/dist/src/utils/pikku-cli-config.js

@@ -137,6 +137,12 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.httpWiringMetaJsonFile) {
             result.httpWiringMetaJsonFile = join(httpDir, 'pikku-http-wirings-meta.gen.json');
         }
+        if (!result.httpContractsMetaJsonFile) {
+            result.httpContractsMetaJsonFile = join(httpDir, 'pikku-http-contracts-meta.gen.json');
+        }
+        if (!result.httpContractsMetaFile) {
+            result.httpContractsMetaFile = join(httpDir, 'pikku-http-contracts-meta.gen.ts');
+        }
         if (!result.httpMapDeclarationFile) {
             result.httpMapDeclarationFile = join(httpDir, 'pikku-http-wirings-map.gen.d.ts');
         }
@@ -158,6 +164,12 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.channelsWiringMetaJsonFile) {
             result.channelsWiringMetaJsonFile = join(channelDir, 'pikku-channels-meta.gen.json');
         }
+        if (!result.channelContractsMetaJsonFile) {
+            result.channelContractsMetaJsonFile = join(channelDir, 'pikku-channel-contracts-meta.gen.json');
+        }
+        if (!result.channelContractsMetaFile) {
+            result.channelContractsMetaFile = join(channelDir, 'pikku-channel-contracts-meta.gen.ts');
+        }
         if (!result.channelsMapDeclarationFile) {
             result.channelsMapDeclarationFile = join(channelDir, 'pikku-channels-map.gen.d.ts');
         }
@@ -348,6 +360,12 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.cliWiringMetaJsonFile) {
             result.cliWiringMetaJsonFile = join(cliDir, 'pikku-cli-wirings-meta.gen.json');
         }
+        if (!result.cliContractsMetaJsonFile) {
+            result.cliContractsMetaJsonFile = join(cliDir, 'pikku-cli-contracts-meta.gen.json');
+        }
+        if (!result.cliContractsMetaFile) {
+            result.cliContractsMetaFile = join(cliDir, 'pikku-cli-contracts-meta.gen.ts');
+        }
         if (!result.cliBootstrapFile) {
             result.cliBootstrapFile = join(cliDir, 'pikku-cli-bootstrap.gen.ts');
         }