@pikku/cli 0.12.21 → 0.12.23

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

@@ -2,17 +2,23 @@ import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+export function filterInternalRPCMeta(internalMeta, functionsMeta) {
+    const filteredInternalMeta = {};
+    for (const [key, value] of Object.entries(internalMeta)) {
+        if (key in functionsMeta || value in functionsMeta) {
+            filteredInternalMeta[key] = value;
+        }
+    }
+    return filteredInternalMeta;
+}
 export const pikkuRPC = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { rpc, functions } = await getInspectorState();
         const { rpcInternalWiringMetaFile, rpcInternalWiringMetaJsonFile, packageMappings, schema, } = config;
-        // Filter internal RPC meta to only include functions in the filtered meta
-        const filteredInternalMeta = {};
-        for (const [key, value] of Object.entries(rpc.internalMeta)) {
-            if (key in functions.meta) {
-                filteredInternalMeta[key] = value;
-            }
-        }
+        // Keep direct function ids and unversioned aliases whose target function
+        // survived filtering. Without the second check, aliases like `listCards`
+        // get dropped even though `listCards@v2` still exists.
+        const filteredInternalMeta = filterInternalRPCMeta(rpc.internalMeta, functions.meta);
         if (Object.keys(filteredInternalMeta).length > 0) {
             await writeFileInDir(logger, rpcInternalWiringMetaJsonFile, JSON.stringify(filteredInternalMeta, null, 2));
             const jsonImportPath = getFileImportRelativePath(rpcInternalWiringMetaFile, rpcInternalWiringMetaJsonFile, packageMappings);

package/dist/src/functions/wirings/rpc/serialize-public-rpc.js

@@ -13,6 +13,7 @@ export const rpcCaller = pikkuSessionlessFunc<
   { rpcName: string; data?: unknown },
   unknown
 >({
+  tags: ['pikku'],
   auth: ${authFlag},
   func: async (_services, { rpcName, data }, { rpc }) => {
     return await rpc.exposed(rpcName, data)

package/dist/src/functions/wirings/rpc/serialize-react-query-hooks.js

@@ -98,7 +98,7 @@ export const usePikkuInfiniteQuery = <Name extends PaginatedKeys>(
   const rpc = usePikkuRPC<{ invoke: RPCInvoke }>()
   return useInfiniteQuery({
     queryKey: [name, data] as const,
-    queryFn: ({ pageParam }: { pageParam: string | undefined }) => rpc.invoke(name, { ...data, nextCursor: pageParam } as FlattenedRPCMap[Name]['input']),
+    queryFn: ({ pageParam }: { pageParam: string | undefined }) => rpc.invoke(name, { ...data, nextCursor: pageParam } as unknown as FlattenedRPCMap[Name]['input']),
     initialPageParam: undefined as string | undefined,
     getNextPageParam: (lastPage: FlattenedRPCMap[Name]['output']) => (lastPage as { nextCursor?: string }).nextCursor ?? undefined,
     ...options,

package/dist/src/functions/wirings/rpc/serialize-remote-rpc.js

@@ -6,19 +6,25 @@ export const serializeRemoteRPC = (pathToPikkuTypes) => {
  * Auto-generated remote internal RPC queue worker and HTTP endpoint
  * Do not edit manually - regenerate with 'npx pikku'
  */
-import { pikkuSessionlessFunc, wireHTTP } from '${pathToPikkuTypes}'
+import { pikkuSessionlessFunc, wireHTTP, wireQueueWorker } from '${pathToPikkuTypes}'
 import { pikkuRemoteAuthMiddleware } from '@pikku/core/middleware'
 
 export const remoteRPCHandler = pikkuSessionlessFunc<
   { rpcName: string, data?: unknown },
   unknown
 >({
+  tags: ['pikku'],
   func: async (_services, { rpcName, data }, { rpc }) => {
     return await (rpc.invoke as any)(rpcName, data)
   },
   remote: true,
 })
 
+wireQueueWorker({
+  name: 'pikku-remote-internal-rpc',
+  func: remoteRPCHandler,
+})
+
 wireHTTP({
   route: '/remote/rpc/:rpcName',
   method: 'post',

package/dist/src/functions/wirings/scheduler/pikku-command-scheduler-types.d.ts

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

package/dist/src/functions/wirings/scheduler/pikku-command-scheduler.d.ts

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

package/dist/src/functions/wirings/secrets/pikku-command-secrets.d.ts

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

package/dist/src/functions/wirings/triggers/pikku-command-trigger-types.d.ts

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

package/dist/src/functions/wirings/triggers/pikku-command-trigger-types.js

@@ -6,7 +6,7 @@ import { serializeTriggerTypes } from './serialize-trigger-types.js';
 export const pikkuTriggerTypes = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { triggersTypesFile, packageMappings } = config;
-        const visitState = await getInspectorState();
+        const visitState = await getInspectorState(false, true);
         const { singletonServicesType } = visitState.filesAndMethods;
         if (!singletonServicesType) {
             throw new Error('SingletonServices type not found');

package/dist/src/functions/wirings/triggers/pikku-command-trigger.d.ts

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

package/dist/src/functions/wirings/variables/pikku-command-variables.d.ts

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

package/dist/src/functions/wirings/workflow/pikku-command-workflow-routes.d.ts

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

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

@@ -5,7 +5,7 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializeWorkflowRoutes } from './serialize-workflow-routes.js';
 export const pikkuWorkflowRoutes = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        if (config.workflowRoutesFile) {
+        if (config.scaffold?.workflow && config.workflowRoutesFile) {
             const pathToPikkuTypes = getFileImportRelativePath(config.workflowRoutesFile, config.typesDeclarationFile, config.packageMappings);
             await writeFileInDir(logger, config.workflowRoutesFile, serializeWorkflowRoutes(pathToPikkuTypes, config.scaffold?.workflow === 'auth'));
             return true;

package/dist/src/functions/wirings/workflow/pikku-command-workflow.d.ts

@@ -1 +1,5 @@
-export declare const pikkuWorkflow: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+type WorkflowCommandInput = {
+    bootstrap?: boolean;
+};
+export declare const pikkuWorkflow: import("#pikku").PikkuFunctionConfig<WorkflowCommandInput, boolean | undefined, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<WorkflowCommandInput, boolean | undefined, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<WorkflowCommandInput, boolean | undefined, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export {};

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

@@ -5,13 +5,17 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializeWorkflowTypes } from './serialize-workflow-types.js';
 import { serializeWorkflowRegistration } from './serialize-workflow-registration.js';
 import { serializeWorkflowMap } from './serialize-workflow-map.js';
+import { serializeWorkflowBootstrapMap } from './serialize-workflow-bootstrap-map.js';
 import { serializeWorkflowMeta } from './serialize-workflow-meta.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
 import { join } from 'path';
 export const pikkuWorkflow = pikkuSessionlessFunc({
-    func: async ({ logger, config, getInspectorState }) => {
-        const visitState = await getInspectorState();
+    func: async ({ logger, config, getInspectorState }, input) => {
+        const bootstrap = input?.bootstrap === true;
+        const visitState = bootstrap
+            ? await getInspectorState(false, true, false)
+            : await getInspectorState();
         const { workflowsWiringFile, workflowsWiringMetaFile, workflowMetaDir, workflowMapDeclarationFile, workflowTypesFile, functionTypesFile, packageMappings, schema, } = config;
         const { workflows, functions: functionState } = visitState;
         const { typesMap } = functionState;
@@ -24,7 +28,15 @@ export const pikkuWorkflow = pikkuSessionlessFunc({
         const hasRelevantWorkflows = allWorkflowNames.length > 0;
         const hasWorkflows = hasRelevantWorkflows;
         if (hasWorkflows) {
-            const hasWorkflowState = visitState.serviceAggregation.allSingletonServices.includes('workflowService');
+            const singletonServices = visitState.serviceAggregation.allSingletonServices.length > 0
+                ? visitState.serviceAggregation.allSingletonServices
+                : visitState.typesLookup?.get('SingletonServices')?.[0]
+                    ? visitState.typesLookup
+                        .get('SingletonServices')[0]
+                        .getProperties()
+                        .map((symbol) => symbol.getName())
+                    : [];
+            const hasWorkflowState = singletonServices.includes('workflowService');
             if (!hasWorkflowState) {
                 logger.critical(ErrorCode.WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED, 'Workflows detected but workflowService service not configured. Please add workflowService to your singleton services');
                 throw new Error('WorkflowState service not configured but workflows are defined');
@@ -50,7 +62,9 @@ export const pikkuWorkflow = pikkuSessionlessFunc({
         const rpcMapImportPath = getFileImportRelativePath(workflowTypesFile, config.rpcInternalMapDeclarationFile, packageMappings);
         const workflowMapImportPath = getFileImportRelativePath(workflowTypesFile, workflowMapDeclarationFile, packageMappings);
         await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath, rpcMapImportPath, workflowMapImportPath));
-        await writeFileInDir(logger, workflowMapDeclarationFile, serializeWorkflowMap(logger, workflowMapDeclarationFile, packageMappings, typesMap, functionState.meta, workflows.meta, workflows.graphMeta, visitState.rpc?.wireAddonDeclarations));
+        await writeFileInDir(logger, workflowMapDeclarationFile, bootstrap
+            ? serializeWorkflowBootstrapMap(workflows.meta, workflows.graphMeta)
+            : serializeWorkflowMap(logger, workflowMapDeclarationFile, packageMappings, typesMap, functionState.meta, workflows.meta, workflows.graphMeta, visitState.rpc?.wireAddonDeclarations));
         return hasWorkflows;
     },
     middleware: [

package/dist/src/functions/wirings/workflow/serialize-workflow-bootstrap-map.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowsMeta } from '@pikku/core/workflow';
+import type { SerializedWorkflowGraphs } from '@pikku/inspector/workflow-graph';
+export declare const serializeWorkflowBootstrapMap: (workflowsMeta: WorkflowsMeta, graphMeta: SerializedWorkflowGraphs) => string;

package/dist/src/functions/wirings/workflow/serialize-workflow-bootstrap-map.js

@@ -0,0 +1,40 @@
+export const serializeWorkflowBootstrapMap = (workflowsMeta, graphMeta) => {
+    const workflowEntries = Object.keys(workflowsMeta)
+        .sort()
+        .map((workflowName) => `  readonly '${workflowName}': WorkflowHandler<unknown, unknown>,`)
+        .join('\n');
+    const graphEntries = Object.entries(graphMeta)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([graphName, graph]) => {
+        const nodeEntries = Object.keys(graph.nodes)
+            .sort()
+            .map((nodeId) => `    readonly '${nodeId}': GraphNodeHandler<unknown>,`)
+            .join('\n');
+        return `  readonly '${graphName}': {\n${nodeEntries}\n  },`;
+    })
+        .join('\n');
+    return `/**
+ * Bootstrap-safe workflow type map.
+ * Full input/output types are populated by the later \`pikku all\` pass.
+ */
+
+interface WorkflowHandler<I, O> {
+  input: I;
+  output: O;
+}
+
+interface GraphNodeHandler<I> {
+  input: I;
+}
+
+export type WorkflowMap = {
+${workflowEntries}
+};
+
+export type GraphsMap = {
+${graphEntries}
+};
+
+export type FlattenedWorkflowMap = WorkflowMap
+`;
+};

package/dist/src/functions/wirings/workflow/serialize-workflow-routes.js

@@ -23,8 +23,13 @@ export const workflowStarter = pikkuSessionlessFunc<
   { workflowName: string; data?: unknown },
   { runId: string }
 >({
+  tags: ['pikku'],
   auth: ${authFlag},
-  func: async (_services, { workflowName, data }, { rpc }) => {
+  // workflowService is destructured (even though we delegate via rpc) so the
+  // analyzer assigns workflow-state capability to this unit — without it,
+  // rpc.startWorkflow() runs against a container missing workflowService.
+  func: async ({ workflowService }, { workflowName, data }, { rpc }) => {
+    assertWorkflowService(workflowService)
     return await rpc.startWorkflow(workflowName as any, (data ?? {}) as any)
   },
 })
@@ -33,6 +38,7 @@ export const workflowRunner = pikkuSessionlessFunc<
   { workflowName: string; data?: unknown },
   unknown
 >({
+  tags: ['pikku'],
   auth: ${authFlag},
   func: async ({ workflowService }, { workflowName, data }, { rpc }) => {
     assertWorkflowService(workflowService)
@@ -44,6 +50,7 @@ export const workflowStatusChecker = pikkuSessionlessFunc<
   { workflowName: string; runId: string },
   WorkflowRunStatus
 >({
+  tags: ['pikku'],
   auth: ${authFlag},
   func: async ({ workflowService }, { runId }) => {
     assertWorkflowService(workflowService)
@@ -61,6 +68,7 @@ export const workflowStatusStream = pikkuSessionlessFunc<
   { workflowName: string; runId: string },
   unknown
 >({
+  tags: ['pikku'],
   auth: ${authFlag},
   func: async ({ workflowRunService }, { runId }, { channel }) => {
     assertWorkflowRunService(workflowRunService)
@@ -147,6 +155,7 @@ export const workflowStatusStreamFull = pikkuSessionlessFunc<
   { workflowName: string; runId: string },
   unknown
 >({
+  tags: ['pikku'],
   auth: ${authFlag},
   func: async ({ workflowRunService }, { runId }, { channel }) => {
     assertWorkflowRunService(workflowRunService)
@@ -234,7 +243,10 @@ export const graphStarter = pikkuSessionlessFunc<
   { runId: string }
 >({
   auth: ${authFlag},
-  func: async (_services, { workflowName, nodeId, data }, { rpc }) => {
+  // See workflowStarter — destructure workflowService so the analyzer
+  // assigns workflow-state capability to this unit.
+  func: async ({ workflowService }, { workflowName, nodeId, data }, { rpc }) => {
+    assertWorkflowService(workflowService)
     return await rpc.startWorkflow(workflowName as any, (data ?? {}) as any, { startNode: nodeId })
   },
 })

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

@@ -14,6 +14,11 @@ const scaffoldFiles = (config) => {
             file: config.publicAgentFile,
             generator: 'pikkuPublicAgent',
         });
+    if (config.scaffold?.events && config.eventsChannelFile)
+        files.push({
+            file: config.eventsChannelFile,
+            generator: 'pikkuEventsScaffold',
+        });
     return files;
 };
 export const allWorkflow = pikkuWorkflowComplexFunc({
@@ -23,20 +28,30 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
         let typesDeclarationFileExists = true;
         if (!existsSync(config.outDir)) {
             logger.debug(`• .pikku directory not found, running bootstrap first...`);
-            await workflow.do('Bootstrap inspect', async () => getInspectorState(false, false, true));
+            await workflow.do('Bootstrap inspect', async () => getInspectorState(false, true, true));
+            await workflow.do('Bootstrap function types split', 'pikkuFunctionTypesSplit', null);
             await workflow.do('Bootstrap function types', 'pikkuFunctionTypes', null);
+            await workflow.do('Bootstrap addon types', 'pikkuAddonTypes', {
+                bootstrap: true,
+            });
             await Promise.all([
-                workflow.do('Bootstrap function types split', 'pikkuFunctionTypesSplit', null),
                 workflow.do('Bootstrap HTTP types', 'pikkuHTTPTypes', null),
                 workflow.do('Bootstrap channel types', 'pikkuChannelTypes', null),
                 workflow.do('Bootstrap scheduler types', 'pikkuSchedulerTypes', null),
                 workflow.do('Bootstrap queue types', 'pikkuQueueTypes', null),
-                workflow.do('Bootstrap workflow', 'pikkuWorkflow', null),
+                workflow.do('Bootstrap workflow', 'pikkuWorkflow', {
+                    bootstrap: true,
+                }),
+                workflow.do('Bootstrap Trigger types', 'pikkuTriggerTypes', null),
                 workflow.do('Bootstrap MCP types', 'pikkuMCPTypes', null),
                 workflow.do('Bootstrap AI agent types', 'pikkuAIAgentTypes', null),
-                workflow.do('Bootstrap CLI types', 'pikkuCLITypes', null),
             ]);
-            await workflow.do('Bootstrap re-inspect', async () => getInspectorState(true));
+            await workflow.do('Bootstrap Node types', 'pikkuNodeTypes', null);
+            await workflow.do('Bootstrap Secret definition types', 'pikkuSecretDefinitionTypes', null);
+            await workflow.do('Bootstrap CLI types', 'pikkuCLITypes', {
+                bootstrap: true,
+            });
+            await workflow.do('Bootstrap re-inspect', async () => getInspectorState(true, true));
         }
         if (!existsSync(config.typesDeclarationFile)) {
             typesDeclarationFileExists = false;
@@ -59,9 +74,13 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
             workflow.do('AI agent types', 'pikkuAIAgentTypes', null),
         ];
         if (!config.addon) {
-            typeGenerators.push(workflow.do('HTTP types', 'pikkuHTTPTypes', null), workflow.do('Channel types', 'pikkuChannelTypes', null), workflow.do('Scheduler types', 'pikkuSchedulerTypes', null), workflow.do('Queue types', 'pikkuQueueTypes', null), workflow.do('MCP types', 'pikkuMCPTypes', null), workflow.do('CLI types', 'pikkuCLITypes', null));
+            typeGenerators.push(workflow.do('HTTP types', 'pikkuHTTPTypes', null), workflow.do('Channel types', 'pikkuChannelTypes', null), workflow.do('Scheduler types', 'pikkuSchedulerTypes', null), workflow.do('Queue types', 'pikkuQueueTypes', null), workflow.do('MCP types', 'pikkuMCPTypes', null));
         }
         await Promise.all(typeGenerators);
+        await workflow.do('Node types', 'pikkuNodeTypes', null);
+        if (!config.addon) {
+            await workflow.do('CLI types', 'pikkuCLITypes', null);
+        }
         const [middleware, permissions] = await Promise.all([
             workflow.do('Middleware', 'pikkuMiddleware', null),
             workflow.do('Permissions', 'pikkuPermissions', null),
@@ -91,7 +110,7 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
         await Promise.all([
             workflow.do('Public RPC', 'pikkuPublicRPC', null),
             workflow.do('Console functions', 'pikkuConsoleFunctions', null),
-            workflow.do('Node types', 'pikkuNodeTypes', null),
+            workflow.do('Events scaffold', 'pikkuEventsScaffold', null),
             workflow.do('Secret definition types', 'pikkuSecretDefinitionTypes', null),
             workflow.do('Secrets', 'pikkuSecrets', null),
             workflow.do('Credentials', 'pikkuCredentials', null),
@@ -138,6 +157,8 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
                     workflow.do('Fetch', 'pikkuFetch', null),
                     workflow.do('RPC client', 'pikkuRPCClient', null),
                     workflow.do('React query', 'pikkuReactQuery', null),
+                    workflow.do('TanStack Start', 'pikkuTanStackStart', null),
+                    workflow.do('Realtime client', 'pikkuRealtime', null),
                 ]);
                 allImports.push(config.httpWiringMetaFile, config.httpWiringsFile);
             }
@@ -186,8 +207,20 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
                 allImports.push(config.mcpWiringsMetaFile, config.mcpWiringsFile);
             }
             if (cli) {
-                await workflow.do('CLI entry', 'pikkuCLIEntry', null);
+                const cliChannelGenerated = await workflow.do('CLI entry', 'pikkuCLIEntry', null);
                 allImports.push(config.cliWiringMetaFile, config.cliWiringsFile);
+                if (cliChannelGenerated) {
+                    await workflow.do('Re-inspect after CLI channel', async () => getInspectorState(true));
+                    const cliChannels = await workflow.do('Channels after CLI', 'pikkuCommandChannels', null);
+                    await workflow.do('Functions after CLI', 'pikkuFunctions', null);
+                    await workflow.do('Schemas after CLI', 'pikkuSchemas', null);
+                    if (cliChannels) {
+                        await workflow.do('Channels map after CLI', 'pikkuChannelsMap', null);
+                        if (!channels) {
+                            allImports.push(config.channelsWiringMetaFile, config.channelsWiringFile);
+                        }
+                    }
+                }
             }
         }
         await workflow.do('Nodes meta', 'pikkuNodesMeta', null);

package/dist/src/scaffold/rpc-remote.gen.d.ts

@@ -1,10 +1,10 @@
 export declare const remoteRPCHandler: import("../../.pikku/pikku-types.gen.js").PikkuFunctionConfig<{
     rpcName: string;
     data?: unknown;
-}, unknown, "session" | "rpc", import("../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
+}, unknown, "rpc" | "session", import("../../.pikku/pikku-types.gen.js").PikkuFunctionSessionless<{
     rpcName: string;
     data?: unknown;
-}, unknown, "session" | "rpc", import("../../types/application-types.js").Services> | import("../../.pikku/pikku-types.gen.js").PikkuFunction<{
+}, unknown, "rpc" | "session", import("../../types/application-types.js").Services> | import("../../.pikku/pikku-types.gen.js").PikkuFunction<{
     rpcName: string;
     data?: unknown;
-}, unknown, "session" | "rpc", import("../../types/application-types.js").Services>, undefined, undefined>;
+}, unknown, "rpc" | "session", import("../../types/application-types.js").Services>, undefined, undefined>;

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

@@ -1,18 +1,23 @@
 /**
- * This file was generated by @pikku/cli@0.12.21
+ * This file was generated by @pikku/cli@0.12.23
  */
 /**
  * Auto-generated remote internal RPC queue worker and HTTP endpoint
  * Do not edit manually - regenerate with 'npx pikku'
  */
-import { pikkuSessionlessFunc, wireHTTP } from '../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc, wireHTTP, wireQueueWorker } from '../../.pikku/pikku-types.gen.js';
 import { pikkuRemoteAuthMiddleware } from '@pikku/core/middleware';
 export const remoteRPCHandler = pikkuSessionlessFunc({
+    tags: ['pikku'],
     func: async (_services, { rpcName, data }, { rpc }) => {
         return await rpc.invoke(rpcName, data);
     },
     remote: true,
 });
+wireQueueWorker({
+    name: 'pikku-remote-internal-rpc',
+    func: remoteRPCHandler,
+});
 wireHTTP({
     route: '/remote/rpc/:rpcName',
     method: 'post',

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

@@ -45,5 +45,4 @@ export declare class CLILogger implements Logger {
     critical(code: ErrorCode, message: string): void;
     hasCriticalErrors(): boolean;
     logLogo(): void;
-    private primary;
 }

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

@@ -1,18 +1,14 @@
 import chalk from 'chalk';
 import { LogLevel } from '@pikku/core/services';
-const logo = `
- ______ _ _     _
-(_____ (_) |   | |
- _____) )| |  _| |  _ _   _
-|  ____/ | |_/ ) |_/ ) | | |
-| |    | |  _ (|  _ (|  _ (| |_| |
-|_|    |_|_| _)_| _)____/
-`;
+// Compact one-line wordmark — the old multi-line ASCII art got cropped in
+// short/narrow AI-agent panes. Coloured directly (not via the blue `info`
+// path) so the cyan/bold render correctly.
+const logo = `${chalk.cyan('◇◆')} ${chalk.bold('pikku')} ${chalk.cyan.bold('::')}`;
 const BASE_ERROR_URL = 'https://pikku.dev/docs/pikku-cli/errors';
 const ANSI_ESCAPE_REGEX = /\x1B\[[0-?]*[ -/]*[@-~]/g;
 export class CLILogger {
     silent;
-    level = LogLevel.warn; // default to warn level
+    level = LogLevel.info; // default to info level
     criticalErrors = [];
     outputMode = 'text';
     jsonFlushHookRegistered = false;
@@ -54,7 +50,10 @@ export class CLILogger {
         return str;
     }
     writeJSONLine(payload) {
-        process.stdout.write(`${JSON.stringify(payload)}\n`);
+        // Logs go to stderr so stdout is reserved for command data output.
+        // This lets consumers pipe `pikku <cmd> --json | jq` or
+        // `pikku meta context --json | pikku plan ingest -` without log noise.
+        process.stderr.write(`${JSON.stringify(payload)}\n`);
     }
     ensureJSONFlushHook() {
         if (this.jsonFlushHookRegistered)
@@ -149,17 +148,8 @@ export class CLILogger {
         return this.criticalErrors.length > 0;
     }
     logLogo() {
-        this.primary(logo);
-        // // When running from dist/, __filename is dist/src/services/cli-logger.service.js
-        // // So we need to go up 3 levels: dist/src/services -> dist/src -> dist -> package.json
-        // const packageJson = JSON.parse(
-        //   readFileSync(`${dirname(__filename)}/../../../package.json`, 'utf-8')
-        // )
-        // this.primary(`⚙️  Welcome to the Pikku CLI (v${packageJson.version})\n`)
-    }
-    primary(message) {
-        if (!this.silent) {
-            this.emit('info', message);
-        }
+        if (this.silent || this.outputMode === 'json')
+            return;
+        console.log(`\n${logo}\n`);
     }
 }