@pikku/cli 0.12.144 → 0.12.151

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

@@ -1,4 +1,6 @@
-import { basename, join, relative } from 'node:path';
+import { basename, isAbsolute, join, relative } from 'node:path';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
 import { readFile } from 'node:fs/promises';
 import { existsSync, readFileSync } from 'node:fs';
 import { pikkuSessionlessFunc } from '#pikku/function';
@@ -89,6 +91,36 @@ async function resolveProjectId(projectDir) {
     }
     return sanitizeProjectId(basename(projectDir));
 }
+/**
+ * A deploy provider is a dependency of the project being deployed, which is
+ * what the "is not installed" error asks the user to add. A bare
+ * `import(packageName)` resolves from the CLI's own location instead, and only
+ * found the provider because yarn hoisted every workspace package to a shared
+ * root. An isolated node_modules layout (bun, pnpm) gives the CLI only what the
+ * CLI declares, so the provider has to be resolved against the project.
+ *
+ * Only an absolute path counts as having resolved to the project's own copy: a
+ * configured provider may also be a URL, and a runtime whose `require.resolve`
+ * hands a bare specifier straight back for its own built-ins has resolved
+ * nothing. Both of those import as written.
+ */
+const importProviderPackage = async (packageName, projectDir) => {
+    const require = createRequire(join(projectDir ?? process.cwd(), 'package.json'));
+    try {
+        const resolved = require.resolve(packageName);
+        if (isAbsolute(resolved)) {
+            return await import(pathToFileURL(resolved).href);
+        }
+    }
+    catch (e) {
+        const err = e;
+        if (err?.code !== 'ERR_MODULE_NOT_FOUND' &&
+            err?.code !== 'MODULE_NOT_FOUND') {
+            throw e;
+        }
+    }
+    return await import(packageName);
+};
 export async function resolveProvider(config, providerName, options) {
     const name = providerName ?? config?.deploy?.defaultProvider ?? 'cloudflare';
     const providers = config?.deploy?.providers ?? {
@@ -103,7 +135,7 @@ export async function resolveProvider(config, providerName, options) {
     }
     const adapterExportName = name.charAt(0).toUpperCase() + name.slice(1) + 'ProviderAdapter';
     try {
-        const mod = await import(packageName);
+        const mod = await importProviderPackage(packageName, options?.projectDir);
         if (typeof mod.createAdapter === 'function') {
             return mod.createAdapter(options);
         }
@@ -116,7 +148,7 @@ export async function resolveProvider(config, providerName, options) {
         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 new Error(`Deploy provider '${packageName}' is not installed. Add ${packageName} to this project's dependencies.`);
         }
         throw e;
     }
@@ -217,6 +249,7 @@ export const deployApply = pikkuSessionlessFunc({
             inspectorState,
             serverlessIncompatible: config.deploy?.serverlessIncompatible,
             defaultTarget: config.deploy?.defaultTarget,
+            grouping: config.deploy?.grouping,
             globalHTTPPrefix: config.globalHTTPPrefix,
             getEntryContext,
             frontend: config.frontend,

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

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

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

@@ -3,14 +3,14 @@ export declare const deployPlan: import("#pikku/function").PikkuFunctionConfig<{
     provider?: string;
     runtime?: string;
     debugArtifacts?: boolean;
-}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunction<{
     resultFile?: string;
     provider?: string;
     runtime?: string;
     debugArtifacts?: boolean;
-}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<{
     resultFile?: string;
     provider?: string;
     runtime?: string;
     debugArtifacts?: boolean;
-}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;

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

@@ -49,6 +49,7 @@ export const deployPlan = pikkuSessionlessFunc({
         const projectId = await resolveProjectId(projectDir);
         const provider = await resolveProvider(config, data?.provider, {
             runtime: data?.runtime,
+            projectDir,
         });
         const result = await runBuildPipeline({
             projectDir,
@@ -57,6 +58,7 @@ export const deployPlan = pikkuSessionlessFunc({
             inspectorState,
             serverlessIncompatible: config.deploy?.serverlessIncompatible,
             defaultTarget: config.deploy?.defaultTarget,
+            grouping: config.deploy?.grouping,
             globalHTTPPrefix: config.globalHTTPPrefix,
             getEntryContext,
             frontend: config.frontend,

package/dist/src/functions/commands/dev-agent-runner.d.ts

@@ -17,13 +17,15 @@ import type { AgentRunnerService } from '@pikku/core/services';
  * configured (agents stay disabled, with the clear downstream error) or when
  * the SDK packages cannot be loaded from either place.
  *
- * Audio does not work here: `@ai-sdk/openai-compatible` exposes only
- * language/embedding/image models, so a voice agent under `pikku dev` throws
- * `Provider does not support transcription models`. Fixing that means the full
- * `@ai-sdk/openai` provider, which assumes OpenAI's own request specifics — a
- * bad default for a path whose entire purpose is fronting arbitrary gateways.
- * If it becomes worth it, delegate just `transcription`/`speech` to the full
- * provider and leave everything else on this one.
+ * Audio comes from a second provider. `@ai-sdk/openai-compatible` exposes only
+ * language/embedding/image models, so `transcription`/`speech` are delegated to
+ * the full `@ai-sdk/openai` provider pointed at the same base URL, and nothing
+ * else is: that provider assumes OpenAI's own request specifics, which is a bad
+ * default for a path whose whole purpose is fronting arbitrary gateways. Its
+ * `/v1/audio/*` shape, on the other hand, is what a gateway implements if it
+ * carries audio at all — routing OpenAI-compatible chat is no promise that it
+ * does. When it cannot be resolved, or the gateway has no audio endpoints
+ * behind it, audio is unavailable and the rest still works.
  */
 export declare function createDevAgentRunner({ logger, projectRoot, variables, }: {
     logger: Logger;

package/dist/src/functions/commands/dev-agent-runner.js

@@ -17,13 +17,15 @@ import { pathToFileURL } from 'url';
  * configured (agents stay disabled, with the clear downstream error) or when
  * the SDK packages cannot be loaded from either place.
  *
- * Audio does not work here: `@ai-sdk/openai-compatible` exposes only
- * language/embedding/image models, so a voice agent under `pikku dev` throws
- * `Provider does not support transcription models`. Fixing that means the full
- * `@ai-sdk/openai` provider, which assumes OpenAI's own request specifics — a
- * bad default for a path whose entire purpose is fronting arbitrary gateways.
- * If it becomes worth it, delegate just `transcription`/`speech` to the full
- * provider and leave everything else on this one.
+ * Audio comes from a second provider. `@ai-sdk/openai-compatible` exposes only
+ * language/embedding/image models, so `transcription`/`speech` are delegated to
+ * the full `@ai-sdk/openai` provider pointed at the same base URL, and nothing
+ * else is: that provider assumes OpenAI's own request specifics, which is a bad
+ * default for a path whose whole purpose is fronting arbitrary gateways. Its
+ * `/v1/audio/*` shape, on the other hand, is what a gateway implements if it
+ * carries audio at all — routing OpenAI-compatible chat is no promise that it
+ * does. When it cannot be resolved, or the gateway has no audio endpoints
+ * behind it, audio is unavailable and the rest still works.
  */
 export async function createDevAgentRunner({ logger, projectRoot, variables, }) {
     // Pair the URL with its matching key — coalescing each var independently could
@@ -98,10 +100,14 @@ export async function createDevAgentRunner({ logger, projectRoot, variables, })
     };
     let VercelAgentRunner;
     let createOpenAICompatible;
+    // Which of the two copies `loadPair` settled on. The audio provider has to
+    // come from the same one, for the reason PAIR exists at all.
+    let pairFromProject = false;
     try {
         const [runnerModule, providerModule, resolved] = await loadPair();
         ({ VercelAgentRunner } = runnerModule);
         ({ createOpenAICompatible } = providerModule);
+        pairFromProject = resolved !== undefined;
         const [runnerSpec, providerSpec] = (resolved ?? []).map(providerSpecVersion);
         if (runnerSpec &&
             providerSpec &&
@@ -114,6 +120,30 @@ export async function createDevAgentRunner({ logger, projectRoot, variables, })
         logger.warn(`pikku dev: AI provider env is set but the AI SDK packages could not be loaded — AI agents disabled: ${error instanceof Error ? error.message : String(error)}`);
         return undefined;
     }
+    // Optional, and resolved from whichever copy the pair came from — NOT
+    // "project first, then ours". Mixing the two is the same failure PAIR
+    // guards against: an audio model built against one `@ai-sdk/provider` handed
+    // to a runner built against another is refused at the first transcribe or
+    // speak call, by an error naming the model rather than the two packages that
+    // disagree. When the pair fell back to the CLI's copies, so does this; when
+    // the project's own were used and it has no `@ai-sdk/openai` of its own,
+    // audio stays off rather than borrowing ours.
+    let createOpenAIProvider;
+    const audioFrom = pairFromProject
+        ? resolveFromProject('@ai-sdk/openai')
+        : '@ai-sdk/openai';
+    if (!audioFrom) {
+        logger.debug(`pikku dev: @ai-sdk/openai could not be resolved from ${join(projectRoot, 'package.json')}, alongside the AI SDK copies in use, so speech-to-text and text-to-speech are unavailable`);
+    }
+    else {
+        try {
+            ;
+            ({ createOpenAI: createOpenAIProvider } = await import(audioFrom));
+        }
+        catch (error) {
+            logger.debug(`pikku dev: @ai-sdk/openai could not be loaded, so speech-to-text and text-to-speech are unavailable: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     // One provider under '*', so every prefix a model might name resolves to the
     // proxy — including ones nobody thought to list. This was a hardcoded array
     // of seven names, which silently excluded everything else.
@@ -126,14 +156,28 @@ export async function createDevAgentRunner({ logger, projectRoot, variables, })
     // fronting this URL that is worth calling speaks `json_schema`; the ones that
     // do not now fail loudly on the first schema'd call, which is the outcome we
     // want over silently ignoring the schema.
-    const buildProviders = (key) => ({
-        '*': createOpenAICompatible({
+    // Attached onto the compatible provider rather than replacing it with a plain
+    // object of named methods: the provider is callable, and `getModel` takes a
+    // callable's fast path for language models, so every other kind keeps
+    // resolving exactly as it did.
+    const buildProviders = (key) => {
+        const provider = createOpenAICompatible({
             name: 'pikku-dev',
             baseURL,
             apiKey: key,
             supportsStructuredOutputs: true,
-        }),
-    });
-    logger.info(`pikku dev: AI agent runner wired to ${baseURL}`);
+        });
+        if (createOpenAIProvider) {
+            const audio = createOpenAIProvider({
+                name: 'pikku-dev-audio',
+                baseURL,
+                apiKey: key,
+            });
+            provider.transcription = (modelId) => audio.transcription(modelId);
+            provider.speech = (modelId) => audio.speech(modelId);
+        }
+        return { '*': provider };
+    };
+    logger.info(`pikku dev: AI agent runner wired to ${baseURL}${createOpenAIProvider ? '' : ' (no audio — @ai-sdk/openai not resolvable)'}`);
     return new VercelAgentRunner(buildProviders(apiKey), buildProviders);
 }

package/dist/src/functions/commands/dev.d.ts

@@ -5,18 +5,18 @@ export declare const dev: import("#pikku/function").PikkuFunctionConfig<{
     coverage?: boolean;
     test?: boolean;
     model?: string;
-}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunction<{
     port?: string;
     watch?: boolean;
     hmr?: boolean;
     coverage?: boolean;
     test?: boolean;
     model?: string;
-}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<{
     port?: string;
     watch?: boolean;
     hmr?: boolean;
     coverage?: boolean;
     test?: boolean;
     model?: string;
-}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;

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

@@ -4,10 +4,12 @@ import { pikkuSessionlessFunc } from '#pikku/function';
 import chokidar from 'chokidar';
 import { pikkuDevReloader, reloadGeneratedMeta, reconcileAddonRegistry, } from '@pikku/core/dev';
 import { InMemoryQueueService, QueueWebhookService } from '@pikku/core/services';
+import { flattenScopeDefinitions } from '@pikku/core/scope';
+import { flattenSystemRoleDefinitions } from '@pikku/core/role';
 import { ConsoleLogger, LocalEmailService, LocalCredentialService, spy, InMemoryAgentRunStateService, } from '@pikku/core/services';
 import { InMemoryTriggerService } from '@pikku/core/services';
 import { InMemoryWorkflowService } from '@pikku/core/services';
-import { KyselyAgentStorageService, KyselyAgentRunStateService, KyselyAgentRunService, } from '@pikku/kysely';
+import { KyselyAgentStorageService, KyselyAgentRunStateService, KyselyAgentRunService, KyselyAnalyticsService, KyselyFeatureFlagStore, KyselyScopeService, KyselyWebhookService, } from '@pikku/kysely';
 import { stopSingletonServices } from '@pikku/core/utils';
 import { pikkuState } from '@pikku/core/state';
 import { wireAgentScorerQueueWorkers } from '@pikku/core/agent-scorer';
@@ -16,6 +18,7 @@ import { LocalContent, } from '@pikku/core/services/local-content';
 import { InMemorySchedulerService } from '@pikku/schedule';
 import { resolveDb, createKysely, parseDatabaseUrl, } from '../db/local-db.js';
 import { loadUserBootstrap, loadUserModule } from './load-user-project.js';
+import { initOrWarn } from './init-or-warn.js';
 import { registerScenarioInstrumentation } from '../wirings/scenarios/register-scenario-instrumentation.js';
 import { startCoverageService } from './start-coverage.js';
 import { resolveDevEnvironmentName } from './environment.js';
@@ -170,6 +173,7 @@ export const dev = pikkuSessionlessFunc({
         };
         const contentSigningJWT = createEphemeralContentSigningJWT();
         const localContent = new LocalContent(localContentConfig, logger, contentSigningJWT);
+        const requiredServices = inspectorState.serviceAggregation.requiredServices;
         const schedulerService = new InMemorySchedulerService();
         const agentStorage = kysely
             ? new KyselyAgentStorageService(kysely)
@@ -185,6 +189,34 @@ export const dev = pikkuSessionlessFunc({
         if ('init' in agentRunState && typeof agentRunState.init === 'function') {
             await agentRunState.init();
         }
+        // Flags and analytics get the same local database the rest of the services
+        // do, so a flag an operator flips in the console survives a restart and a
+        // declared event lands somewhere a query can reach.
+        //
+        // Dropped with a warning rather than thrown on, unlike the agent services
+        // above: both tables are generated from a declaration the project may have
+        // added since it last migrated, and neither absence is worse than what a
+        // project has today — an unregistered flag source resolves every gate open,
+        // and analytics without a service falls back to the logger. Failing the
+        // boot instead would turn adding one `featureFlag:` into a dead dev server.
+        const featureFlags = kysely
+            ? await initOrWarn(new KyselyFeatureFlagStore(kysely), 'featureFlags', logger)
+            : undefined;
+        const analyticsService = kysely
+            ? await initOrWarn(new KyselyAnalyticsService(kysely), 'analyticsService', logger)
+            : undefined;
+        // Gated on `requiredServices` rather than on `kysely` alone, because that is
+        // the same set `pikku db generate` filters the runtime schemas by: a project
+        // that never asks for `scopeService` has no scope tables, and `init()` here
+        // would fail its boot over a service nothing uses.
+        const scopeService = kysely && requiredServices.has('scopeService')
+            ? new KyselyScopeService(kysely)
+            : undefined;
+        if (scopeService) {
+            await scopeService.init();
+            await scopeService.syncScopes(flattenScopeDefinitions(inspectorState.scopes.definitions));
+            await scopeService.syncSystemRoles(flattenSystemRoleDefinitions(inspectorState.systemRoles.definitions));
+        }
         // InMemoryWorkflowService implements both the workflowService and
         // workflowRunService surfaces (listRuns/getRun live on it). Expose the
         // single instance under both names so addons like @pikku/addon-console
@@ -195,10 +227,12 @@ export const dev = pikkuSessionlessFunc({
         // has no equivalent, so construct one from env or agents 503 with
         // AIProviderNotConfiguredError. The template forwards injected services
         // (`...existingServices`) so this reaches getSingletonServices().
-        // Only when the project declares agents — otherwise the runner's
-        // missing-SDK warning fires spuriously for projects with global AI env.
+        // Only when the project actually reaches for one — a declared agent, or a
+        // function destructuring `agentRunner` for a one-shot vision / speech call.
+        // Otherwise the runner's missing-SDK warning fires spuriously for every
+        // project that happens to have AI env set.
         const hasAgents = Object.keys(inspectorState.agents.agentsMeta).length > 0;
-        const agentRunner = hasAgents
+        const agentRunner = hasAgents || requiredServices.has('agentRunner')
             ? await createDevAgentRunner({
                 logger,
                 projectRoot: config.rootDir,
@@ -210,6 +244,15 @@ export const dev = pikkuSessionlessFunc({
         // function-side broadcasts reach the sockets the transport holds.
         const eventHub = await devServerRunner.createEventHub();
         const devQueueService = new InMemoryQueueService();
+        // The queue-only service delivers but keeps no history, so the console's
+        // webhooks page is empty on a project that has the tables for it. Same
+        // `requiredServices` gate as the scope service above.
+        const devWebhookService = kysely && requiredServices.has('webhookService')
+            ? new KyselyWebhookService(devQueueService, kysely)
+            : new QueueWebhookService(devQueueService);
+        if (devWebhookService instanceof KyselyWebhookService) {
+            await devWebhookService.init();
+        }
         const inMemoryServices = {
             logger: devLogger,
             ...(agentRunner ? { agentRunner } : {}),
@@ -220,7 +263,8 @@ export const dev = pikkuSessionlessFunc({
             ...(coverageService ? { coverageService } : {}),
             schedulerService,
             queueService: devQueueService,
-            webhookService: new QueueWebhookService(devQueueService),
+            webhookService: devWebhookService,
+            ...(scopeService ? { scopeService } : {}),
             workflowService,
             workflowRunService: workflowService,
             triggerService: new InMemoryTriggerService(),
@@ -228,6 +272,8 @@ export const dev = pikkuSessionlessFunc({
             agentStorage,
             agentRunState,
             agentRunService,
+            ...(featureFlags ? { featureFlags } : {}),
+            ...(analyticsService ? { analyticsService } : {}),
             eventHub,
             ...(kysely ? { kysely } : {}),
             content: localContent,
@@ -252,6 +298,14 @@ export const dev = pikkuSessionlessFunc({
             return m[serverLifecycleFactory.variable];
         };
         const consoleMount = await resolveConsoleMount();
+        // Appended, not assigned: an app's own config may already declare mounts
+        // for its frontend, and dev is where that frontend is meant to be served.
+        // Replacing them meant the console being present silently unmounted the
+        // app, which is the one combination every project has.
+        const staticMounts = [
+            ...(userConfig.staticMounts ?? []),
+            ...(consoleMount ? [consoleMount] : []),
+        ];
         /**
          * Hand the server the generated MCP manifest so it actually serves MCP.
          *
@@ -290,7 +344,7 @@ export const dev = pikkuSessionlessFunc({
             hostname: bindHostname,
             port: resolvedPort,
             content: localContentConfig,
-            ...(consoleMount ? { staticMounts: [consoleMount] } : {}),
+            ...(staticMounts.length > 0 ? { staticMounts } : {}),
         }, logger, { contentSigningJWT, mcpJson });
         const lifecycle = await loadLifecycle();
         await pikkuServer.init();

package/dist/src/functions/commands/dist.d.ts

@@ -21,8 +21,8 @@ export type DistCopy = {
 export declare const planDistCopies: (rootDir: string, distDir: string, files: string[]) => DistCopy[];
 export declare const pikkuDist: import("#pikku/function").PikkuFunctionConfig<{
     distDir?: string;
-}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunction<{
     distDir?: string;
-}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<{
     distDir?: string;
-}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;

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

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import { cp, mkdir, readdir } from 'node:fs/promises';
 import { dirname, join, relative, resolve } from 'node:path';
-import ts from 'typescript';
+import { readTsconfigOutDir } from '@pikku/inspector';
 import { pikkuSessionlessFunc } from '#pikku/function';
 /**
  * `tsc` compiles a `.ts` and emits it. Everything else it either reads without
@@ -28,19 +28,12 @@ export const planDistCopies = (rootDir, distDir, files) => {
         to: join(distDir, relative(rootDir, from)),
     }));
 };
-const readTsOutDir = (tsconfig) => {
-    const parsed = ts.getParsedCommandLineOfConfigFile(tsconfig, {}, {
-        ...ts.sys,
-        onUnRecoverableConfigFileDiagnostic: () => { },
-    });
-    return parsed?.options.outDir;
-};
 export const pikkuDist = pikkuSessionlessFunc({
     func: async ({ logger, config }, data) => {
         const { rootDir, outDir, srcDirectories, tsconfig } = config;
         const distDir = data.distDir
             ? resolve(rootDir, data.distDir)
-            : readTsOutDir(resolve(rootDir, tsconfig));
+            : readTsconfigOutDir(resolve(rootDir, tsconfig));
         if (!distDir) {
             logger.error(`${tsconfig} sets no compilerOptions.outDir, so there is nowhere to copy to. Set one, or pass --dist-dir.`);
             process.exit(1);

package/dist/src/functions/commands/doc.d.ts

@@ -4,19 +4,19 @@ export declare const doc: import("#pikku/function").PikkuFunctionConfig<{
     addon?: boolean;
 }, {
     text: string;
-}, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
+}, "rpc" | "session", import("#pikku/function").PikkuFunction<{
     topics?: string[];
     ai?: boolean;
     addon?: boolean;
 }, {
     text: string;
-}, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
+}, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<{
     topics?: string[];
     ai?: boolean;
     addon?: boolean;
 }, {
     text: string;
-}, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+}, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;
 export declare const renderDoc: (_services: unknown, { text }: {
     text: string;
 }) => void;

package/dist/src/functions/commands/emails-init.d.ts

@@ -1,5 +1,5 @@
 type EmailsInitInput = {
     force?: boolean;
 };
-export declare const pikkuEmailsInit: import("#pikku/function").PikkuFunctionConfig<EmailsInitInput, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<EmailsInitInput, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<EmailsInitInput, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const pikkuEmailsInit: import("#pikku/function").PikkuFunctionConfig<EmailsInitInput, void, "rpc" | "session", import("#pikku/function").PikkuFunction<EmailsInitInput, void, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<EmailsInitInput, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;
 export {};

package/dist/src/functions/commands/enable.d.ts

@@ -1,9 +1,9 @@
-export declare const enableRpc: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
-export declare const enableConsole: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
-export declare const enableScenarios: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
-export declare const enableAgent: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
-export declare const enableWorkflow: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
-export declare const enableEvents: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
-export declare const enableRemoteRpc: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
-export declare const enableRemoteJobs: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
-export declare const enableWebhook: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const enableRpc: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;
+export declare const enableConsole: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;
+export declare const enableScenarios: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;
+export declare const enableAgent: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;
+export declare const enableWorkflow: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;
+export declare const enableEvents: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;
+export declare const enableRemoteRpc: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;
+export declare const enableRemoteJobs: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;
+export declare const enableWebhook: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;

package/dist/src/functions/commands/import-n8n.d.ts

@@ -1,10 +1,10 @@
 export declare const pikkuImportN8n: import("#pikku/function").PikkuFunctionConfig<{
     file: string;
     out?: string;
-}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunction<{
     file: string;
     out?: string;
-}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<{
     file: string;
     out?: string;
-}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;

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

@@ -2,8 +2,8 @@ type InfoInput = {
     limit?: string;
     verbose?: boolean;
 };
-export declare const pikkuInfoFunctions: import("#pikku/function").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
-export declare const pikkuInfoTags: import("#pikku/function").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
-export declare const pikkuInfoMiddleware: import("#pikku/function").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
-export declare const pikkuInfoPermissions: import("#pikku/function").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const pikkuInfoFunctions: import("#pikku/function").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku/function").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;
+export declare const pikkuInfoTags: import("#pikku/function").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku/function").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;
+export declare const pikkuInfoMiddleware: import("#pikku/function").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku/function").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;
+export declare const pikkuInfoPermissions: import("#pikku/function").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku/function").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;
 export {};

package/dist/src/functions/commands/init-or-warn.d.ts

@@ -0,0 +1,19 @@
+import type { Logger } from '@pikku/core/services';
+/**
+ * Bring a database-backed service up, or say why the dev server is doing
+ * without it.
+ *
+ * `init()` on these services is a check, not a create — the runtime never
+ * issues DDL, so a project whose migrations predate the declaration that needs
+ * the tables gets a throw. For a service the dev server supplies on the
+ * project's behalf that throw would be an ambush: the project never asked for
+ * it, and the failure lands on `pikku dev` rather than on the code that changed.
+ *
+ * So the service is dropped and the reason is printed. The caller decides
+ * whether that is survivable — it is only used where absence degrades to what
+ * the project already had, never where something would silently do the wrong
+ * thing.
+ */
+export declare const initOrWarn: <T extends {
+    init(): Promise<void>;
+}>(service: T, name: string, logger: Logger) => Promise<T | undefined>;

package/dist/src/functions/commands/init-or-warn.js

@@ -0,0 +1,25 @@
+/**
+ * Bring a database-backed service up, or say why the dev server is doing
+ * without it.
+ *
+ * `init()` on these services is a check, not a create — the runtime never
+ * issues DDL, so a project whose migrations predate the declaration that needs
+ * the tables gets a throw. For a service the dev server supplies on the
+ * project's behalf that throw would be an ambush: the project never asked for
+ * it, and the failure lands on `pikku dev` rather than on the code that changed.
+ *
+ * So the service is dropped and the reason is printed. The caller decides
+ * whether that is survivable — it is only used where absence degrades to what
+ * the project already had, never where something would silently do the wrong
+ * thing.
+ */
+export const initOrWarn = async (service, name, logger) => {
+    try {
+        await service.init();
+        return service;
+    }
+    catch (error) {
+        logger.warn(`Running without '${name}': ${error instanceof Error ? error.message : String(error)}`);
+        return undefined;
+    }
+};