@pikku/cli 0.12.32 → 0.12.34

package/dist/src/functions/db/zod-codegen.js

@@ -67,14 +67,67 @@ function emitZodModule(tables) {
     }
     return `${lines.join('\n')}\n`;
 }
+/**
+ * Resolve a Kysely field type to a `{ schema, generated }` pair, where `schema`
+ * is the zod expression for the *row* (select) shape and `generated` is true
+ * when the column is optional on insert.
+ *
+ * `db-codegen` emits two field shapes depending on a column's classification:
+ *   - public columns →  `Generated<T>`, bare `T`, `T | null`, or a public
+ *                       bool/date column as `Generated<ColumnType<base, rw, rw>>`
+ *   - private/pii/secret columns (the default is `private`) →
+ *                       `ColumnType<Brand<base> | null, insert | undefined, update>`
+ *                       where Brand is `Private` | `Pii` | `Secret`.
+ *
+ * For `ColumnType<Select, Insert, Update>` the row schema comes from `Select`
+ * and the column is insert-optional when `Insert` admits `undefined` (Kysely's
+ * encoding for default/auto/generated columns).
+ */
 function zodForType(tsType) {
-    const generatedMatch = tsType.match(/^Generated<(.+)>$/);
-    const generated = generatedMatch !== null;
-    let inner = generated ? generatedMatch[1].trim() : tsType;
+    let inner = tsType.trim();
+    let generated = false;
+    // Peel a single `Generated<…>` wrapper. For public bool/date columns this
+    // wraps a `ColumnType<…>`, so the unwrapped inner is handled below.
+    const generatedMatch = inner.match(/^Generated<(.+)>$/);
+    if (generatedMatch) {
+        generated = true;
+        inner = generatedMatch[1].trim();
+    }
+    // `ColumnType<Select, Insert, Update>` — classified columns and wrapped
+    // public bool/date columns. Row schema from Select; optional from Insert.
+    if (inner.startsWith('ColumnType<') && inner.endsWith('>')) {
+        const args = splitGenericArgs(inner.slice('ColumnType<'.length, -1));
+        const selectT = args[0]?.trim() ?? 'unknown';
+        const insertT = args[1]?.trim() ?? '';
+        if (unionIncludesUndefined(insertT)) {
+            generated = true;
+        }
+        return { schema: scalarSchema(selectT), generated };
+    }
+    return { schema: scalarSchema(inner), generated };
+}
+/**
+ * Resolve a scalar/select type expression to a zod expression. Handles a
+ * trailing `| null`, classification brands (`Private`/`Pii`/`Secret`), arrays,
+ * and the known scalar bases. Unknown bases fall back to `z.unknown()` so
+ * generation stays total.
+ */
+function scalarSchema(tsType) {
+    let inner = tsType.trim();
+    // Defensive: a Select arg may itself be `Generated<…>` in older schemas.
+    const generatedMatch = inner.match(/^Generated<(.+)>$/);
+    if (generatedMatch) {
+        inner = generatedMatch[1].trim();
+    }
     const nullable = inner.endsWith(' | null');
     if (nullable) {
         inner = inner.slice(0, -' | null'.length).trim();
     }
+    // Unwrap a classification brand: `Private<T>` / `Pii<T>` / `Secret<T>` → T.
+    const brandMatch = inner.match(/^(?:Private|Pii|Secret)<(.+)>$/);
+    if (brandMatch) {
+        inner = brandMatch[1].trim();
+    }
     let schema;
     switch (inner) {
         case 'string':
@@ -94,8 +147,7 @@ function zodForType(tsType) {
             break;
         default:
             if (inner.endsWith('[]')) {
-                const item = zodForType(inner.slice(0, -2).trim()).schema;
-                schema = `z.array(${item})`;
+                schema = `z.array(${scalarSchema(inner.slice(0, -2).trim())})`;
             }
             else {
                 schema = 'z.unknown()';
@@ -105,5 +157,28 @@ function zodForType(tsType) {
     if (nullable) {
         schema += '.nullable()';
     }
-    return { schema, generated };
+    return schema;
+}
+/** Split the generic argument list of `Foo<a, b, c>` on top-level commas. */
+function splitGenericArgs(args) {
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < args.length; i++) {
+        const char = args[i];
+        if (char === '<')
+            depth++;
+        else if (char === '>')
+            depth--;
+        else if (char === ',' && depth === 0) {
+            parts.push(args.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(args.slice(start));
+    return parts;
+}
+/** True when a union type expression contains `undefined` as a top-level member. */
+function unionIncludesUndefined(union) {
+    return union.split('|').some((member) => member.trim() === 'undefined');
 }

package/dist/src/functions/wirings/console/serialize-console-functions.js

@@ -99,6 +99,12 @@ export const consoleRoutes = defineHTTPRoutes({
       sse: true,
       func: ref('console:streamWorkflowRun'),
     },
+    functionTestsStream: {
+      route: '/function-tests/stream',
+      method: 'get',
+      sse: true,
+      func: ref('console:streamFunctionTests'),
+    },
   },
 })
 

package/dist/src/functions/wirings/mcp/pikku-command-mcp-json.js

@@ -5,7 +5,7 @@ import { serializeMCPJson } from '@pikku/inspector';
 export const pikkuMCPJSON = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const state = await getInspectorState();
-        const mcpJsonFile = config.clientFiles?.mcpJsonFile;
+        const mcpJsonFile = config.mcpJsonFile ?? config.clientFiles?.mcpJsonFile;
         if (mcpJsonFile) {
             const mcpJson = serializeMCPJson(logger, state);
             await writeFileInDir(logger, mcpJsonFile, mcpJson, {

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

@@ -133,6 +133,14 @@ export class PikkuRPC {
             return await this.pikkuFetch.post(\`${globalHTTPPrefix}/rpc/agent/\${String(agentName)}/approve\` as never, input) as any
         },
     }
+
+    subscribeToSSE<T = unknown>(
+        path: string,
+        handler: (event: T) => void,
+        onError?: (err: unknown) => void
+    ): { close: () => void } {
+        return this.pikkuFetch.subscribeToSSE(path, handler, onError)
+    }
 }
 
 export const pikkuRPC = new PikkuRPC();

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

@@ -208,8 +208,8 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
             if (gateways) {
                 allImports.push(config.gatewaysWiringFile);
             }
+            await workflow.do('MCP JSON', 'pikkuMCPJSON', null);
             if (mcp) {
-                await workflow.do('MCP JSON', 'pikkuMCPJSON', null);
                 allImports.push(config.mcpWiringsMetaFile, config.mcpWiringsFile);
             }
             if (cli) {

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

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

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

@@ -309,6 +309,9 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.mcpTypesFile) {
             result.mcpTypesFile = join(mcpDir, 'pikku-mcp-types.gen.ts');
         }
+        if (!result.mcpJsonFile) {
+            result.mcpJsonFile = join(mcpDir, 'mcp.gen.json');
+        }
         // AI Agent
         const agentDir = join(result.outDir, 'agent');
         if (!result.agentWiringsFile) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.12.32",
+  "version": "0.12.34",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "imports": {
@@ -26,13 +26,13 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^4.3.1",
-    "@pikku/core": "^0.12.29",
+    "@pikku/core": "^0.12.31",
     "@pikku/deploy-cloudflare": "^0.12.3",
-    "@pikku/fetch": "^0.12.2",
-    "@pikku/inspector": "^0.12.15",
+    "@pikku/fetch": "^0.12.3",
+    "@pikku/inspector": "^0.12.19",
     "@pikku/kysely": "^0.12.14",
     "@pikku/kysely-node-sqlite": "^0.12.1",
-    "@pikku/node-http-server": "^0.12.1",
+    "@pikku/node-http-server": "^0.12.2",
     "@pikku/openapi-parser": "^0.12.10",
     "@pikku/schedule": "^0.12.0",
     "@pikku/ws": "^0.12.2",

package/skills/pikku-workflow/SKILL.md

@@ -47,7 +47,7 @@ const myWorkflow = pikkuWorkflowFunc<InputType, OutputType>(
 ### Workflow Step Types
 
 ```typescript
-// RPC step — execute a Pikku function as a queue job
+// RPC step — run a named Pikku function as a step
 // workflow.do(stepName, funcName, data, options?)
 const result = await workflow.do(
   'Create profile',
@@ -58,11 +58,40 @@ const result = await workflow.do(
   { retries: 3, retryDelay: '1s' }
 )
 
-// Inline step — immediate execution, cached for replay
+// Inline closure step — immediate execution, cached for replay
 // workflow.do(stepName, asyncFn)
 const result = await workflow.do('Generate message', async () => {
   return `Welcome, ${data.email}!`
 })
+```
+
+### Step execution: inline vs queue dispatch
+
+Whether a step runs **inline** (same process/session, no queue round-trip) or is **dispatched to the queue** is decided **purely by the step's function** — there is no workflow-level or per-call `inline` flag.
+
+- **Steps default to inline.** Most steps don't need their own worker; running them inline avoids a queue round-trip per step, so a normally-started workflow executes its whole chain in one orchestrator pass.
+- **`inline: false` opts a function out.** Set `inline: false` on the **function config** (`pikkuFunc` / `pikkuSessionlessFunc`, same level as `auth`/`expose`) to dispatch that step via the queue — for expensive/long-running steps that deserve their own worker, retry isolation, and concurrency limits. It is **not** a `workflow.do(...)` option (those are only `retries`/`retryDelay`/`description`).
+
+The rule (`dispatchStep`):
+
+| Function `inline` | `queueService` present? | Result |
+|---|---|---|
+| default / `true` | any | **inline** |
+| `false` | yes | **queued** (own worker) |
+| `false` | no | **inline + a `logger.warn`** (misconfiguration: can't dispatch) |
+
+```typescript
+// Push this one expensive step onto the queue; every other step stays inline:
+export const renderLargeReport = pikkuSessionlessFunc({
+  inline: false, // dispatch via queue instead of running inline
+  input: ReportInput,
+  output: ReportOutput,
+  func: async (services, data) => { /* ... */ },
+})
+```
+
+- **Run-level `inline` is separate** and only controls whether the *whole run* executes in-process without queue infrastructure (it's set automatically when there is no `queueService`, or via `startWorkflow(..., { inline: true })`). It governs sleep handling, **not** per-step dispatch — step dispatch is always per-function.
+- `inline: false` requires a `queueService`; without one the step still runs (so the workflow progresses) but emits a `logger.warn` so the misconfiguration is visible.
 
 // Sleep — durable pause (duration: '5min', '1h', '30s', '1d')
 await workflow.sleep('Wait 5 minutes', '5min')