@pikku/cli 0.12.20 → 0.12.22

package/dist/src/functions/wirings/realtime/serialize-realtime-client.js

@@ -0,0 +1,337 @@
+/**
+ * Generates the client-side `realtime.gen.ts`.
+ *
+ * `PikkuRealtime` mirrors the `PikkuRPC` pattern: it wraps the project's
+ * generated `PikkuFetch` (so server URL + auth come from one place) and
+ * exposes:
+ *
+ *   - `subscribe(topic, handler)` / `unsubscribe(topic)` — typed pub/sub
+ *     over the websocket at `/events`. Multi-topic per connection.
+ *   - `subscribeToTopic(topic, handler)` — same shape but via SSE
+ *     (one EventSource per topic, auto-cleanup on close).
+ *   - `subscribeToSSE(path, handler)` — generic SSE subscribe for any
+ *     `sse: true` route (workflow streams, agent streams, etc.).
+ *   - `connectToChannel(channelRoute, protocols?)` — open a raw WebSocket
+ *     for any wireChannel route, ready to wrap in
+ *     `PikkuWebSocket<'channel-name'>` for typed subscribe/send.
+ *
+ * Topic types come from `EventHubTopics` if the user supplies an import
+ * via `clientFiles.realtimeEventHubTopicsImport`. Otherwise topics fall
+ * back to `Record<string, unknown>`.
+ */
+export const serializeRealtimeClient = (topicsImport, fetchImportPath) => {
+    const topicsTypeImport = topicsImport
+        ? buildImportLine(topicsImport)
+        : `// No EventHubTopics import configured. Set clientFiles.realtimeEventHubTopicsImport
+// in pikku.config.json (e.g. \"../types/eventhub-topics.js#EventHubTopics\")
+// to get fully-typed subscribe/unsubscribe.
+type EventHubTopics = Record<string, unknown>`;
+    return `/**
+ * Generated by @pikku/cli — do not edit.
+ * Regenerate with \`pikku all\` (or \`pikku realtime\`).
+ */
+import { CorePikkuFetch } from '@pikku/fetch'
+import { PikkuFetch } from '${fetchImportPath}'
+${topicsTypeImport}
+
+type Handler<T> = (data: T) => void
+
+interface RealtimeOptions {
+  /** Auto-reconnect with backoff (default: true) */
+  reconnect?: boolean
+  /** Initial reconnect delay in ms (default: 500) */
+  reconnectDelayMs?: number
+  /** Cap on reconnect delay (default: 10_000) */
+  reconnectMaxDelayMs?: number
+}
+
+/**
+ * Realtime client. Mirrors the PikkuRPC pattern: wraps a PikkuFetch so
+ * the server URL + auth are configured once and shared across transports.
+ *
+ * \`\`\`ts
+ * const pikku = createPikku(PikkuFetch, PikkuRPC, { serverUrl: 'http://localhost:3000' })
+ * const realtime = new PikkuRealtime()
+ * realtime.setPikkuFetch(pikku.fetch)
+ *
+ * const off = realtime.subscribe('todo-created', ({ todo }) => { ... })
+ * // later: off(); realtime.close()
+ * \`\`\`
+ */
+export class PikkuRealtime {
+  /** The underlying HTTP client used to derive server URL + auth */
+  pikkuFetch = new PikkuFetch()
+
+  private ws: WebSocket | null = null
+  private readonly handlers = new Map<string, Set<Handler<any>>>()
+  private readonly options: Required<RealtimeOptions>
+  private reconnectAttempt = 0
+  private closed = false
+  private connectScheduled = false
+
+  constructor(options: RealtimeOptions = {}) {
+    this.options = {
+      reconnect: options.reconnect ?? true,
+      reconnectDelayMs: options.reconnectDelayMs ?? 500,
+      reconnectMaxDelayMs: options.reconnectMaxDelayMs ?? 10_000,
+    }
+  }
+
+  /**
+   * Use a shared PikkuFetch instance (typically from \`createPikku(...)\`).
+   * The realtime client picks up its server URL + auth from this fetch,
+   * so you only configure connection details in one place.
+   */
+  setPikkuFetch(pikkuFetch: PikkuFetch): void {
+    this.pikkuFetch = pikkuFetch
+  }
+
+  /** Sets the base server URL on the underlying PikkuFetch. */
+  setServerUrl(serverUrl: string): void {
+    this.pikkuFetch.setServerUrl(serverUrl)
+  }
+
+  /** Sets the JWT for auth on transports that send headers (SSE). */
+  setAuthorizationJWT(jwt: string | null): void {
+    this.pikkuFetch.setAuthorizationJWT(jwt)
+  }
+
+  /** Sets the API key for auth on transports that send headers (SSE). */
+  setAPIKey(apiKey: string | null): void {
+    this.pikkuFetch.setAPIKey(apiKey)
+  }
+
+  /**
+   * Subscribe to a typed event topic over the websocket. Returns an
+   * \`unsubscribe\` function. Auto-reconnects re-send subscriptions.
+   */
+  subscribe<K extends keyof EventHubTopics & string>(
+    topic: K,
+    handler: Handler<EventHubTopics[K]>
+  ): () => void {
+    const set = this.handlers.get(topic) ?? new Set<Handler<any>>()
+    if (set.size === 0) {
+      this.send({ action: 'subscribe', topic })
+    }
+    set.add(handler)
+    this.handlers.set(topic, set)
+    this.ensureConnected()
+    return () => this.unsubscribe(topic, handler)
+  }
+
+  unsubscribe<K extends keyof EventHubTopics & string>(
+    topic: K,
+    handler?: Handler<EventHubTopics[K]>
+  ): void {
+    const set = this.handlers.get(topic)
+    if (!set) return
+    if (handler) set.delete(handler)
+    else set.clear()
+    if (set.size === 0) {
+      this.handlers.delete(topic)
+      this.send({ action: 'unsubscribe', topic })
+    }
+  }
+
+  /**
+   * SSE alternative for a single topic stream. One EventSource per topic;
+   * close the returned object to unsubscribe (the server cleans up
+   * automatically on disconnect).
+   */
+  subscribeToTopic<K extends keyof EventHubTopics & string>(
+    topic: K,
+    handler: Handler<EventHubTopics[K]>
+  ): { close: () => void } {
+    return this.subscribeToSSE<EventHubTopics[K]>(
+      \`/events/\${encodeURIComponent(topic)}\`,
+      handler
+    )
+  }
+
+  /**
+   * Generic SSE subscribe. Use for any \`sse: true\` HTTP route in your
+   * project. Caller supplies the path (with any params/query) — the base
+   * URL comes from the wrapped PikkuFetch.
+   *
+   * \`\`\`ts
+   * const sub = realtime.subscribeToSSE<{ progress: number }>(
+   *   \`/workflow-run/\${runId}/stream\`,
+   *   (e) => setProgress(e.progress)
+   * )
+   * \`\`\`
+   */
+  subscribeToSSE<T = unknown>(
+    path: string,
+    handler: Handler<T>,
+    onError?: (err: unknown) => void
+  ): { close: () => void } {
+    const controller = new AbortController()
+    const closed = { value: false }
+
+    const run = async () => {
+      try {
+        const response = await (this.pikkuFetch as CorePikkuFetch).fetch(
+          path,
+          'GET',
+          null,
+          {
+            headers: { Accept: 'text/event-stream' },
+            signal: controller.signal,
+          }
+        )
+        if (!response.ok || !response.body) {
+          throw new Error(\`SSE request failed: \${response.status}\`)
+        }
+
+        const reader = response.body
+          .pipeThrough(new TextDecoderStream())
+          .getReader()
+        let buffer = ''
+
+        while (!closed.value) {
+          const { done, value } = await reader.read()
+          if (done) break
+          buffer += value
+
+          let sep: number
+          while ((sep = buffer.indexOf('\\n\\n')) !== -1) {
+            const raw = buffer.slice(0, sep)
+            buffer = buffer.slice(sep + 2)
+
+            const dataLines = raw
+              .split('\\n')
+              .filter((l) => l.startsWith('data:'))
+              .map((l) => l.slice(5).trimStart())
+            if (dataLines.length === 0) continue
+            const data = dataLines.join('\\n')
+
+            try {
+              handler(JSON.parse(data) as T)
+            } catch {
+              // Ignore malformed events
+            }
+          }
+        }
+      } catch (err) {
+        if (closed.value) return
+        if (onError) onError(err)
+      }
+    }
+
+    void run()
+
+    return {
+      close: () => {
+        closed.value = true
+        controller.abort()
+      },
+    }
+  }
+
+  /**
+   * Open a raw WebSocket against one of the project's wireChannel routes.
+   * Wrap the returned socket in \`PikkuWebSocket<'channel-name'>\` from the
+   * generated websocket client for typed subscribe/send.
+   */
+  connectToChannel(
+    channelPath: string,
+    protocols?: string | string[]
+  ): WebSocket {
+    return new WebSocket(this.resolveWsUrl(channelPath), protocols)
+  }
+
+  /** Disconnect the events websocket and clear all subscriptions. */
+  close(): void {
+    this.closed = true
+    this.handlers.clear()
+    this.ws?.close()
+    this.ws = null
+  }
+
+  private ensureConnected() {
+    if (this.ws || this.connectScheduled || this.closed) return
+    this.connect()
+  }
+
+  private connect() {
+    if (this.closed) return
+    this.connectScheduled = false
+    const url = this.resolveWsUrl('/events')
+    this.ws = new WebSocket(url)
+    this.ws.onopen = () => {
+      this.reconnectAttempt = 0
+      for (const topic of this.handlers.keys()) {
+        this.send({ action: 'subscribe', topic })
+      }
+    }
+    this.ws.onmessage = (e: MessageEvent) => {
+      let payload: unknown
+      try {
+        payload =
+          typeof e.data === 'string' ? JSON.parse(e.data) : (e.data as unknown)
+      } catch {
+        return
+      }
+      if (
+        payload &&
+        typeof payload === 'object' &&
+        'topic' in (payload as any) &&
+        typeof (payload as any).topic === 'string'
+      ) {
+        const { topic, data } = payload as { topic: string; data: unknown }
+        const set = this.handlers.get(topic)
+        if (set) for (const h of set) h(data)
+      }
+    }
+    this.ws.onclose = () => {
+      this.ws = null
+      if (this.closed || !this.options.reconnect) return
+      const delay = Math.min(
+        this.options.reconnectDelayMs * 2 ** this.reconnectAttempt,
+        this.options.reconnectMaxDelayMs
+      )
+      this.reconnectAttempt += 1
+      this.connectScheduled = true
+      setTimeout(() => this.connect(), delay)
+    }
+    this.ws.onerror = () => {
+      this.ws?.close()
+    }
+  }
+
+  private send(message: { action: 'subscribe' | 'unsubscribe'; topic: string }) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(message))
+    }
+    // If not open, onopen replays current handler keys.
+  }
+
+  private resolveHttpUrl(path: string): string {
+    const base = this.pikkuFetch.getServerUrl()
+    if (!base) {
+      throw new Error(
+        'PikkuRealtime: no server URL — call setServerUrl(...) or setPikkuFetch(...) first.'
+      )
+    }
+    return \`\${base}\${path.startsWith('/') ? path : \`/\${path}\`}\`
+  }
+
+  private resolveWsUrl(path: string): string {
+    const httpUrl = this.resolveHttpUrl(path)
+    return httpUrl.replace(/^http/i, 'ws')
+  }
+}
+`;
+};
+function buildImportLine(spec) {
+    const hashIdx = spec.lastIndexOf('#');
+    if (hashIdx === -1) {
+        return `import type { EventHubTopics } from '${spec}'`;
+    }
+    const path = spec.slice(0, hashIdx);
+    const typeName = spec.slice(hashIdx + 1);
+    if (typeName === 'EventHubTopics') {
+        return `import type { EventHubTopics } from '${path}'`;
+    }
+    return `import type { ${typeName} as EventHubTopics } from '${path}'`;
+}

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

@@ -1 +1 @@
-export declare const pikkuPublicRPC: 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 pikkuPublicRPC: 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/rpc/pikku-command-public-rpc.js

@@ -4,7 +4,11 @@ import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializePublicRPC } from './serialize-public-rpc.js';
 export const pikkuPublicRPC = pikkuSessionlessFunc({
-    func: async ({ logger, config }) => {
+    func: async ({ logger, config, variables }) => {
+        const deployCodegenFlag = await variables.get('PIKKU_DEPLOY_CODEGEN');
+        if (deployCodegenFlag === '1') {
+            return false;
+        }
         if (config.scaffold?.rpc) {
             const pathToPikkuTypes = getFileImportRelativePath(config.publicRpcFile, config.typesDeclarationFile, config.packageMappings);
             await writeFileInDir(logger, config.publicRpcFile, serializePublicRPC(pathToPikkuTypes, config.scaffold.rpc === 'auth', config.globalHTTPPrefix || ''));

package/dist/src/functions/wirings/rpc/pikku-command-react-query.d.ts

@@ -1 +1 @@
-export declare const pikkuReactQuery: 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 pikkuReactQuery: 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/rpc/pikku-command-remote-rpc.d.ts

@@ -1 +1 @@
-export declare const pikkuRemoteRPC: 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 pikkuRemoteRPC: 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/rpc/pikku-command-remote-rpc.js

@@ -4,7 +4,11 @@ import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeRemoteRPC } from './serialize-remote-rpc.js';
 export const pikkuRemoteRPC = pikkuSessionlessFunc({
-    func: async ({ logger, config }) => {
+    func: async ({ logger, config, variables }) => {
+        const deployCodegenFlag = await variables.get('PIKKU_DEPLOY_CODEGEN');
+        if (deployCodegenFlag === '1') {
+            return false;
+        }
         if (config.remoteRpcWorkersFile) {
             const pathToPikkuTypes = getFileImportRelativePath(config.remoteRpcWorkersFile, config.typesDeclarationFile, config.packageMappings);
             await writeFileInDir(logger, config.remoteRpcWorkersFile, serializeRemoteRPC(pathToPikkuTypes));

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

@@ -1 +1 @@
-export declare const pikkuRPCClient: 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 pikkuRPCClient: 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/rpc/pikku-command-rpc-client.js

@@ -16,7 +16,9 @@ export const pikkuRPCClient = pikkuSessionlessFunc({
             return;
         }
         const rpcMapDeclarationPath = getFileImportRelativePath(rpcWiringsFile, rpcMapDeclarationFile, packageMappings);
-        const content = [serializeRPCWrapper(rpcMapDeclarationPath, config.globalHTTPPrefix || '')];
+        const content = [
+            serializeRPCWrapper(rpcMapDeclarationPath, config.globalHTTPPrefix || ''),
+        ];
         await writeFileInDir(logger, rpcWiringsFile, content.join('\n'));
     },
     middleware: [

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

@@ -1,2 +1,2 @@
-export declare const pikkuRPCInternalMap: 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 pikkuRPCExposedMap: 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 pikkuRPCInternalMap: 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>;
+export declare const pikkuRPCExposedMap: 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/rpc/pikku-command-rpc.d.ts

@@ -1 +1,2 @@
-export declare const pikkuRPC: 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 function filterInternalRPCMeta(internalMeta: Record<string, string>, functionsMeta: Record<string, unknown>): Record<string, string>;
+export declare const pikkuRPC: 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/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/rpc/serialize-typed-rpc-map.js

@@ -41,13 +41,13 @@ ${addonImports}
 ${mergedRPCMap}
 
 export type RPCInvoke = <Name extends keyof FlattenedRPCMap>(
-  ...args: FlattenedRPCMap[Name]['input'] extends void | null
+  ...args: IsVoidishInput<FlattenedRPCMap[Name]['input']> extends true
     ? [name: Name]
     : [name: Name, data: FlattenedRPCMap[Name]['input']]
 ) => Promise<FlattenedRPCMap[Name]['output']>
 
 export type RPCRemote = <Name extends keyof FlattenedRPCMap>(
-  ...args: FlattenedRPCMap[Name]['input'] extends void | null
+  ...args: IsVoidishInput<FlattenedRPCMap[Name]['input']> extends true
     ? [name: Name]
     : [name: Name, data: FlattenedRPCMap[Name]['input']]
 ) => Promise<FlattenedRPCMap[Name]['output']>
@@ -117,6 +117,13 @@ function generateMergedRPCMap(wireAddonDeclarations) {
         return `
 // No addon packages, use RPCMap directly
 export type FlattenedRPCMap = RPCMap
+
+type IsAny<T> = 0 extends (1 & T) ? true : false
+type IsVoidishInput<T> = IsAny<T> extends true
+  ? false
+  : [T] extends [void | null | undefined]
+    ? true
+    : false
 `;
     }
     // TypeScript utility to flatten namespaced RPC maps
@@ -131,6 +138,13 @@ export type FlattenedRPCMap =
   RPCMap${Array.from(wireAddonDeclarations.keys())
         .map((namespace) => ` & PrefixKeys<${toPascalCase(namespace)}RPCMap, '${namespace}'>`)
         .join('')}
+
+type IsAny<T> = 0 extends (1 & T) ? true : false
+type IsVoidishInput<T> = IsAny<T> extends true
+  ? false
+  : [T] extends [void | null | undefined]
+    ? true
+    : false
 `;
     return utilityTypes;
 }

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 {};