@pikku/cli 0.12.85 → 0.12.86

package/dist/src/functions/wirings/ai-agent/serialize-public-agent.js

@@ -1,28 +1,69 @@
 export const serializePublicAgent = (pathToPikkuTypes, requireAuth = true, globalHTTPPrefix = '') => {
     const authFlag = requireAuth ? 'true' : 'false';
-    // Emitted inline at each call site rather than as a shared named alias: the
-    // schema extractor only reads type literals in the generic position, and
-    // synthesises the schema name from the function name. Behind a named alias it
-    // records an `inputSchemaName` with no schema behind it, and every agent call
-    // then fails at runtime with MissingSchemaError.
-    const callerInput = `{
-    agentName: string
-    message: string
-    threadId: string
-    resourceId: string
-    attachments?: {
-      type: 'image' | 'file'
-      data?: string
-      url?: string
-      mediaType?: string
-      filename?: string
-    }[]
-    model?: string
-    temperature?: number
-    context?: string
-  }`;
-    return `import { canAccessThread, threadOwnerConstraint } from '@pikku/core/ai-agent'
+    const schemas = `/**
+ * Auto-generated public agent schemas
+ * Do not edit manually - regenerate with 'npx pikku'
+ */
+import { z } from 'zod'
+
+export const Attachment = z.object({
+  type: z.enum(['image', 'file']),
+  data: z.string().optional(),
+  url: z.string().optional(),
+  mediaType: z.string().optional(),
+  filename: z.string().optional(),
+})
+
+export const AgentCall = z.object({
+  agentName: z.string(),
+  message: z.string(),
+  threadId: z.string(),
+  resourceId: z.string(),
+  attachments: z.array(Attachment).optional(),
+  model: z.string().optional(),
+  temperature: z.number().optional(),
+  context: z.string().optional(),
+})
+
+export const AgentApproval = z.object({
+  agentName: z.string(),
+  runId: z.string(),
+  approvals: z.array(
+    z.object({ toolCallId: z.string(), approved: z.boolean() })
+  ),
+})
+
+export const AgentResume = z.object({
+  agentName: z.string(),
+  runId: z.string(),
+  toolCallId: z.string(),
+  approved: z.boolean(),
+})
+
+export const ThreadsQuery = z.object({
+  agentName: z.string().optional(),
+  resourceId: z.string().optional(),
+  limit: z.number().optional(),
+  offset: z.number().optional(),
+})
+
+export const ThreadRef = z.object({
+  threadId: z.string(),
+  resourceId: z.string().optional(),
+})
+
+export const ThreadDeleted = z.object({ deleted: z.boolean() })
+`;
+    const functions = `import { canAccessThread, threadOwnerConstraint } from '@pikku/core/ai-agent'
 import { pikkuSessionlessFunc, pikkuPermission, defineHTTPRoutes, wireHTTPRoutes } from '${pathToPikkuTypes}'
+import {
+  AgentCall,
+  AgentApproval,
+  AgentResume,
+  ThreadsQuery,
+  ThreadRef,
+  ThreadDeleted,
+} from './agent.schemas.gen.js'
 
 /**
  * Thread reads are keyed by a caller-supplied \`threadId\`, so ownership cannot
@@ -39,9 +80,10 @@ export const isThreadOwner = pikkuPermission<{ threadId: string }>(
   }
 )
 
-export const agentCaller = pikkuSessionlessFunc<${callerInput}, unknown>({
+export const agentCaller = pikkuSessionlessFunc({
   tags: ['pikku'],
   auth: ${authFlag},
+  input: AgentCall,
   func: async (_services, data, { rpc }) => {
     return await rpc.agent.run(data.agentName as any, {
       message: data.message,
@@ -55,9 +97,10 @@ export const agentCaller = pikkuSessionlessFunc<${callerInput}, unknown>({
   },
 })
 
-export const agentStreamCaller = pikkuSessionlessFunc<${callerInput}, void>({
+export const agentStreamCaller = pikkuSessionlessFunc({
   tags: ['pikku'],
   auth: ${authFlag},
+  input: AgentCall,
   func: async (_services, data, { rpc }) => {
     await rpc.agent.stream(data.agentName as any, {
       message: data.message,
@@ -71,23 +114,19 @@ export const agentStreamCaller = pikkuSessionlessFunc<${callerInput}, void>({
   },
 })
 
-export const agentApproveCaller = pikkuSessionlessFunc<
-  { agentName: string; runId: string; approvals: { toolCallId: string; approved: boolean }[] },
-  unknown
->({
+export const agentApproveCaller = pikkuSessionlessFunc({
   tags: ['pikku'],
   auth: ${authFlag},
+  input: AgentApproval,
   func: async (_services, { runId, approvals, agentName }, { rpc }) => {
     return await rpc.agent.approve(runId, approvals, agentName)
   },
 })
 
-export const agentResumeCaller = pikkuSessionlessFunc<
-  { agentName: string; runId: string; toolCallId: string; approved: boolean },
-  void
->({
+export const agentResumeCaller = pikkuSessionlessFunc({
   tags: ['pikku'],
   auth: ${authFlag},
+  input: AgentResume,
   func: async (_services, data, { rpc }) => {
     await rpc.agent.resume(data.runId, {
       toolCallId: data.toolCallId,
@@ -96,11 +135,9 @@ export const agentResumeCaller = pikkuSessionlessFunc<
   },
 })
 
-export const getAgentThreads = pikkuSessionlessFunc<
-  { agentName?: string; resourceId?: string; limit?: number; offset?: number },
-  any[]
->({
+export const getAgentThreads = pikkuSessionlessFunc({
   tags: ['pikku', 'pikku:agent'],
+  input: ThreadsQuery,
   title: 'Get Agent Threads',
   description:
     'Returns the caller\\'s AI agent threads from storage. Accepts optional filters: agentName, resourceId, limit, and offset for pagination.',
@@ -119,11 +156,9 @@ export const getAgentThreads = pikkuSessionlessFunc<
   },
 })
 
-export const getAgentThreadMessages = pikkuSessionlessFunc<
-  { threadId: string; resourceId?: string },
-  any[]
->({
+export const getAgentThreadMessages = pikkuSessionlessFunc({
   tags: ['pikku', 'pikku:agent'],
+  input: ThreadRef,
   title: 'Get Agent Thread Messages',
   description:
     'Returns all messages for a given AI agent thread, ordered by creation time.',
@@ -135,11 +170,9 @@ export const getAgentThreadMessages = pikkuSessionlessFunc<
   },
 })
 
-export const getAgentThreadRuns = pikkuSessionlessFunc<
-  { threadId: string; resourceId?: string },
-  any[]
->({
+export const getAgentThreadRuns = pikkuSessionlessFunc({
   tags: ['pikku', 'pikku:agent'],
+  input: ThreadRef,
   title: 'Get Agent Thread Runs',
   description:
     'Returns the run history for a given AI agent thread, ordered by creation time.',
@@ -151,11 +184,10 @@ export const getAgentThreadRuns = pikkuSessionlessFunc<
   },
 })
 
-export const deleteAgentThread = pikkuSessionlessFunc<
-  { threadId: string; resourceId?: string },
-  { deleted: boolean }
->({
+export const deleteAgentThread = pikkuSessionlessFunc({
   tags: ['pikku', 'pikku:agent'],
+  input: ThreadRef,
+  output: ThreadDeleted,
   title: 'Delete Agent Thread',
   description:
     'Deletes an AI agent thread and all of its persisted state.',
@@ -199,4 +231,5 @@ export const agentRoutes = defineHTTPRoutes({
 
 wireHTTPRoutes({ routes: { agent: agentRoutes } })
 `;
+    return { schemas, functions };
 };

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

@@ -4,6 +4,7 @@ import { rm } from 'node:fs/promises';
 import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { removeLegacyScaffoldFile } from '../../../utils/remove-legacy-scaffold-file.js';
 import { serializeAuthGen } from './serialize-auth-gen.js';
 import { serializeAuthTypes, serializeAuthTypesBootstrap, } from './serialize-auth-types.js';
 import { serializeAuthMeta } from './serialize-auth-meta.js';
@@ -49,6 +50,9 @@ export const pikkuAuth = pikkuSessionlessFunc({
         else if (existsSync(middlewareFile)) {
             await rm(middlewareFile, { force: true });
         }
+        for (const file of [authFile, secretsFile, middlewareFile]) {
+            await removeLegacyScaffoldFile(file);
+        }
         // Static metadata of the enabled providers/plugins for the console SSO page,
         // following the `*-meta.gen.json` convention. Read at runtime by the console
         // getAuthProviders function instead of a runtime registry.

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

@@ -3,6 +3,7 @@ import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { projectDeclaresBetterAuth } from '../../../utils/detect-better-auth.js';
+import { removeLegacyScaffoldFile } from '../../../utils/remove-legacy-scaffold-file.js';
 import { serializeConsoleFunctions } from './serialize-console-functions.js';
 export const pikkuConsoleFunctions = pikkuSessionlessFunc({
     func: async ({ logger, config, variables }) => {
@@ -10,7 +11,7 @@ export const pikkuConsoleFunctions = pikkuSessionlessFunc({
         if (deployCodegenFlag === '1') {
             return false;
         }
-        if (config.scaffold?.console) {
+        if (config.scaffold?.console && config.consoleSchemasFile) {
             // Every console RPC now requires an authenticated session (the console is
             // an admin surface), so scaffolding it without an auth strategy produces a
             // console that 403s on every call. Better Auth is the supported strategy —
@@ -25,7 +26,10 @@ export const pikkuConsoleFunctions = pikkuSessionlessFunc({
             }
             const pathToPikkuTypes = getFileImportRelativePath(config.consoleFunctionsFile, config.typesDeclarationFile, config.packageMappings);
             const pathToAgentTypes = getFileImportRelativePath(config.consoleFunctionsFile, config.agentTypesFile, config.packageMappings);
-            await writeFileInDir(logger, config.consoleFunctionsFile, serializeConsoleFunctions(pathToPikkuTypes, pathToAgentTypes, config.globalHTTPPrefix || ''));
+            const { schemas, functions } = serializeConsoleFunctions(pathToPikkuTypes, pathToAgentTypes, config.globalHTTPPrefix || '');
+            await writeFileInDir(logger, config.consoleSchemasFile, schemas);
+            await writeFileInDir(logger, config.consoleFunctionsFile, functions);
+            await removeLegacyScaffoldFile(config.consoleFunctionsFile);
             return true;
         }
         return false;

package/dist/src/functions/wirings/console/serialize-console-functions.d.ts

@@ -1 +1,5 @@
-export declare const serializeConsoleFunctions: (pathToPikkuTypes: string, _pathToAgentTypes: string, globalHTTPPrefix?: string) => string;
+export interface ConsoleGenOutput {
+    schemas: string;
+    functions: string;
+}
+export declare const serializeConsoleFunctions: (pathToPikkuTypes: string, _pathToAgentTypes: string, globalHTTPPrefix?: string) => ConsoleGenOutput;

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

@@ -1,28 +1,62 @@
 export const serializeConsoleFunctions = (pathToPikkuTypes, _pathToAgentTypes, globalHTTPPrefix = '') => {
-    return `import { pikkuFunc, defineHTTPRoutes, wireHTTPRoutes, ref, wireAddon } from '${pathToPikkuTypes}'
+    const schemas = `/**
+ * Auto-generated console function schemas
+ * Do not edit manually - regenerate with 'npx pikku'
+ */
+import { z } from 'zod'
 
-export const pikkuConsoleSetSecret = pikkuFunc<{
-  secretId: string
-  value: unknown
-}, {
-  success: boolean
-}>({
+export const SecretRef = z.object({ secretId: z.string() })
+
+export const SetSecret = z.object({
+  secretId: z.string(),
+  value: z.unknown(),
+})
+
+export const VariableRef = z.object({ variableId: z.string() })
+
+export const SetVariable = z.object({
+  variableId: z.string(),
+  value: z.unknown(),
+})
+
+export const ValueResult = z.object({
+  exists: z.boolean(),
+  value: z.unknown().nullable(),
+})
+
+export const Exists = z.object({ exists: z.boolean() })
+
+export const Success = z.object({ success: z.boolean() })
+`;
+    const functions = `import { pikkuFunc, defineHTTPRoutes, wireHTTPRoutes, ref, wireAddon } from '${pathToPikkuTypes}'
+import {
+  SecretRef,
+  SetSecret,
+  VariableRef,
+  SetVariable,
+  ValueResult,
+  Exists,
+  Success,
+} from './console.schemas.gen.js'
+
+export const pikkuConsoleSetSecret = pikkuFunc({
   tags: ['pikku'],
   description: 'Set the value of a secret',
   expose: true,
+  input: SetSecret,
+  output: Success,
   func: async ({ secrets }, { secretId, value }) => {
     await secrets.setSecret(secretId, value)
     return { success: true }
   },
 })
 
-export const pikkuConsoleGetVariable = pikkuFunc<
-  { variableId: string },
-  { exists: boolean; value: unknown | null }
->({
+export const pikkuConsoleGetVariable = pikkuFunc({
   tags: ['pikku'],
   description: 'Get the current value of a variable',
   expose: true,
+  input: VariableRef,
+  output: ValueResult,
   func: async ({ variables }, { variableId }) => {
     const exists = await variables.has(variableId)
     if (!exists) {
@@ -38,13 +72,12 @@ export const pikkuConsoleGetVariable = pikkuFunc<
   },
 })
 
-export const pikkuConsoleSetVariable = pikkuFunc<
-  { variableId: string; value: unknown },
-  { success: boolean }
->({
+export const pikkuConsoleSetVariable = pikkuFunc({
   tags: ['pikku'],
   description: 'Set the value of a variable',
   expose: true,
+  input: SetVariable,
+  output: Success,
   func: async ({ variables }, { variableId, value }) => {
     if (typeof value === 'string') {
       await variables.set(variableId, value)
@@ -55,26 +88,24 @@ export const pikkuConsoleSetVariable = pikkuFunc<
   },
 })
 
-export const pikkuConsoleHasSecret = pikkuFunc<
-  { secretId: string },
-  { exists: boolean }
->({
+export const pikkuConsoleHasSecret = pikkuFunc({
   tags: ['pikku'],
   description: 'Check if a secret exists without reading its value',
   expose: true,
+  input: SecretRef,
+  output: Exists,
   func: async ({ secrets }, { secretId }) => {
     const exists = await secrets.hasSecret(secretId)
     return { exists }
   },
 })
 
-export const pikkuConsoleGetSecret = pikkuFunc<
-  { secretId: string },
-  { exists: boolean; value: unknown | null }
->({
+export const pikkuConsoleGetSecret = pikkuFunc({
   tags: ['pikku'],
   description: 'Get the current value of a secret',
   expose: true,
+  input: SecretRef,
+  output: ValueResult,
   func: async ({ secrets }, { secretId }) => {
     const exists = await secrets.hasSecret(secretId)
     if (!exists) {
@@ -107,4 +138,5 @@ export const consoleRoutes = defineHTTPRoutes({
 wireAddon({ name: 'console', package: '@pikku/addon-console' })
 wireHTTPRoutes({ basePath: '${globalHTTPPrefix}', routes: { console: consoleRoutes } })
 `;
+    return { schemas, functions };
 };

package/dist/src/functions/wirings/functions/schemas.js

@@ -4,7 +4,16 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 export const pikkuSchemas = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        if (Object.keys(visitState.schemas).length === 0) {
+        // Bodies missing while functions still DECLARE schemas means the inspection pass
+        // was partial. Writing from it would empty register.gen.ts and delete the files
+        // behind schemas that are still required — unregistering the whole app off a bad
+        // read. Leave the previous output alone.
+        //
+        // Zero REQUIRED schemas is a different thing entirely and must still be written:
+        // that is a project whose last schema was removed, and it is the case where the
+        // files left by earlier runs have to be cleared.
+        if (visitState.requiredSchemas.size > 0 &&
+            Object.keys(visitState.schemas).length === 0) {
             return undefined;
         }
         await saveSchemas(logger, config.schemaDirectory, visitState.schemas, visitState.requiredSchemas, config.schema?.supportsImportAttributes ?? true, config.addonName || null);

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

@@ -2,12 +2,14 @@ import { pikkuSessionlessFunc } from '#pikku';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { removeLegacyScaffoldFile } from '../../../utils/remove-legacy-scaffold-file.js';
 import { serializeGraphWirings } from './serialize-graph-wirings.js';
 export const pikkuGraphWirings = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
         if (config.scaffold?.graph && config.graphWiringsFile) {
             const pathToPikkuTypes = getFileImportRelativePath(config.graphWiringsFile, config.typesDeclarationFile, config.packageMappings);
             await writeFileInDir(logger, config.graphWiringsFile, serializeGraphWirings(pathToPikkuTypes));
+            await removeLegacyScaffoldFile(config.graphWiringsFile);
             return true;
         }
         return false;

package/dist/src/functions/wirings/realtime/pikku-command-events-scaffold.js

@@ -2,10 +2,13 @@ import { pikkuSessionlessFunc } from '#pikku';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { removeLegacyScaffoldFile } from '../../../utils/remove-legacy-scaffold-file.js';
 import { serializeEventsScaffold } from './serialize-events-scaffold.js';
 export const pikkuEventsScaffold = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        if (!config.scaffold?.events || !config.eventsChannelFile) {
+        if (!config.scaffold?.events ||
+            !config.eventsChannelFile ||
+            !config.eventsSchemasFile) {
             logger.debug({
                 message: 'Skipping events scaffold (set scaffold.events in pikku.config.json to enable).',
                 type: 'skip',
@@ -14,7 +17,10 @@ export const pikkuEventsScaffold = pikkuSessionlessFunc({
         }
         const authRequired = config.scaffold.events === 'auth';
         const pikkuTypesImportPath = getFileImportRelativePath(config.eventsChannelFile, config.typesDeclarationFile, config.packageMappings);
-        await writeFileInDir(logger, config.eventsChannelFile, serializeEventsScaffold(authRequired, pikkuTypesImportPath));
+        const { schemas, functions } = serializeEventsScaffold(authRequired, pikkuTypesImportPath);
+        await writeFileInDir(logger, config.eventsSchemasFile, schemas);
+        await writeFileInDir(logger, config.eventsChannelFile, functions);
+        await removeLegacyScaffoldFile(config.eventsChannelFile);
         return true;
     },
     middleware: [

package/dist/src/functions/wirings/realtime/serialize-events-scaffold.d.ts

@@ -1,3 +1,7 @@
+export interface EventsGenOutput {
+    schemas: string;
+    functions: string;
+}
 /**
  * Generates the server-side `events.gen.ts` scaffold.
  *
@@ -16,8 +20,5 @@
  * Both routes call `eventHub.subscribe`/`unsubscribe` with the channel id;
  * publish-side ergonomics (envelope shape) are documented in the
  * pikku-realtime skill.
- *
- * Uses TypeScript generics (not named Zod schema constants) so schemas and
- * wiring calls can safely coexist in a single generated file.
  */
-export declare const serializeEventsScaffold: (authRequired: boolean, pikkuTypesImportPath: string) => string;
+export declare const serializeEventsScaffold: (authRequired: boolean, pikkuTypesImportPath: string) => EventsGenOutput;

package/dist/src/functions/wirings/realtime/serialize-events-scaffold.js

@@ -16,19 +16,25 @@
  * Both routes call `eventHub.subscribe`/`unsubscribe` with the channel id;
  * publish-side ergonomics (envelope shape) are documented in the
  * pikku-realtime skill.
- *
- * Uses TypeScript generics (not named Zod schema constants) so schemas and
- * wiring calls can safely coexist in a single generated file.
  */
 export const serializeEventsScaffold = (authRequired, pikkuTypesImportPath) => {
     const auth = authRequired ? 'true' : 'false';
-    return `import {
+    const schemas = `/**
+ * Auto-generated realtime event schemas
+ * Do not edit manually - regenerate with 'npx pikku'
+ */
+import { z } from 'zod'
+
+export const TopicRef = z.object({ topic: z.string() })
+`;
+    const functions = `import {
   pikkuChannelFunc,
   pikkuSessionlessFunc,
   wireChannel,
   wireHTTP,
   defineChannelRoutes,
 } from '${pikkuTypesImportPath}'
+import { TopicRef } from './events.schemas.gen.js'
 
 /**
  * Topic envelope clients receive: \`{ topic, data }\`. Functions that publish
@@ -40,13 +46,15 @@ export const serializeEventsScaffold = (authRequired, pikkuTypesImportPath) => {
  * the duplication; pick whichever style your project prefers.
  */
 
-export const realtimeSubscribe = pikkuChannelFunc<{ topic: string }>({
+export const realtimeSubscribe = pikkuChannelFunc({
+  input: TopicRef,
   func: async ({ eventHub }, { topic }, { channel }) => {
     await eventHub?.subscribe(topic, channel.channelId)
   },
 })
 
-export const realtimeUnsubscribe = pikkuChannelFunc<{ topic: string }>({
+export const realtimeUnsubscribe = pikkuChannelFunc({
+  input: TopicRef,
   func: async ({ eventHub }, { topic }, { channel }) => {
     await eventHub?.unsubscribe(topic, channel.channelId)
   },
@@ -74,7 +82,8 @@ wireChannel({
  * SSE per-topic stream. One connection = one subscription. The eventHub
  * cleans up automatically when the channel closes (onChannelClosed).
  */
-export const realtimeEventStream = pikkuSessionlessFunc<{ topic: string }, void>({
+export const realtimeEventStream = pikkuSessionlessFunc({
+  input: TopicRef,
   description: 'Auto-generated SSE stream for a single event-hub topic',
   func: async ({ eventHub }, { topic }, { channel }) => {
     if (!channel) {
@@ -95,4 +104,5 @@ wireHTTP({
   tags: ['pikku:realtime', 'sse'],
 })
 `;
+    return { schemas, functions };
 };

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

@@ -2,6 +2,7 @@ import { pikkuSessionlessFunc } from '#pikku';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { removeLegacyScaffoldFile } from '../../../utils/remove-legacy-scaffold-file.js';
 import { serializePublicRPC } from './serialize-public-rpc.js';
 export const pikkuPublicRPC = pikkuSessionlessFunc({
     func: async ({ logger, config, variables }) => {
@@ -9,9 +10,12 @@ export const pikkuPublicRPC = pikkuSessionlessFunc({
         if (deployCodegenFlag === '1') {
             return false;
         }
-        if (config.scaffold?.rpc) {
+        if (config.scaffold?.rpc && config.publicRpcSchemasFile) {
             const pathToPikkuTypes = getFileImportRelativePath(config.publicRpcFile, config.typesDeclarationFile, config.packageMappings);
-            await writeFileInDir(logger, config.publicRpcFile, serializePublicRPC(pathToPikkuTypes, config.scaffold.rpc === 'auth', config.globalHTTPPrefix || ''));
+            const { schemas, functions } = serializePublicRPC(pathToPikkuTypes, config.scaffold.rpc === 'auth', config.globalHTTPPrefix || '');
+            await writeFileInDir(logger, config.publicRpcSchemasFile, schemas);
+            await writeFileInDir(logger, config.publicRpcFile, functions);
+            await removeLegacyScaffoldFile(config.publicRpcFile);
             return true;
         }
         return false;

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

@@ -2,6 +2,7 @@ import { pikkuSessionlessFunc } from '#pikku';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { removeLegacyScaffoldFile } from '../../../utils/remove-legacy-scaffold-file.js';
 import { serializeRemoteRPC } from './serialize-remote-rpc.js';
 export const pikkuRemoteRPC = pikkuSessionlessFunc({
     func: async ({ logger, config, variables }) => {
@@ -9,9 +10,12 @@ export const pikkuRemoteRPC = pikkuSessionlessFunc({
         if (deployCodegenFlag === '1') {
             return false;
         }
-        if (config.remoteRpcWorkersFile) {
+        if (config.remoteRpcWorkersFile && config.remoteRpcSchemasFile) {
             const pathToPikkuTypes = getFileImportRelativePath(config.remoteRpcWorkersFile, config.typesDeclarationFile, config.packageMappings);
-            await writeFileInDir(logger, config.remoteRpcWorkersFile, serializeRemoteRPC(pathToPikkuTypes));
+            const { schemas, functions } = serializeRemoteRPC(pathToPikkuTypes);
+            await writeFileInDir(logger, config.remoteRpcSchemasFile, schemas);
+            await writeFileInDir(logger, config.remoteRpcWorkersFile, functions);
+            await removeLegacyScaffoldFile(config.remoteRpcWorkersFile);
             return true;
         }
         return false;

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

@@ -1,4 +1,8 @@
+export interface PublicRPCGenOutput {
+    schemas: string;
+    functions: string;
+}
 /**
  * Generate public RPC HTTP endpoint
  */
-export declare const serializePublicRPC: (pathToPikkuTypes: string, requireAuth?: boolean, globalHTTPPrefix?: string) => string;
+export declare const serializePublicRPC: (pathToPikkuTypes: string, requireAuth?: boolean, globalHTTPPrefix?: string) => PublicRPCGenOutput;

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

@@ -3,18 +3,28 @@
  */
 export const serializePublicRPC = (pathToPikkuTypes, requireAuth = true, globalHTTPPrefix = '') => {
     const authFlag = requireAuth ? 'true' : 'false';
-    return `/**
+    const schemas = `/**
+ * Auto-generated public RPC endpoint schemas
+ * Do not edit manually - regenerate with 'npx pikku'
+ */
+import { z } from 'zod'
+
+export const RPCCall = z.object({
+  rpcName: z.string(),
+  data: z.unknown().optional(),
+})
+`;
+    const functions = `/**
  * Auto-generated public RPC HTTP endpoint
  * Do not edit manually - regenerate with 'npx pikku'
  */
 import { pikkuSessionlessFunc, wireHTTP } from '${pathToPikkuTypes}'
+import { RPCCall } from './rpc-public.schemas.gen.js'
 
-export const rpcCaller = pikkuSessionlessFunc<
-  { rpcName: string; data?: unknown },
-  unknown
->({
+export const rpcCaller = pikkuSessionlessFunc({
   tags: ['pikku'],
   auth: ${authFlag},
+  input: RPCCall,
   func: async (_services, { rpcName, data }, { rpc }) => {
     return await rpc.exposed(rpcName, data)
   },
@@ -28,4 +38,5 @@ wireHTTP({
   func: rpcCaller,
 })
 `;
+    return { schemas, functions };
 };

package/dist/src/functions/wirings/rpc/serialize-remote-rpc.d.ts

@@ -1,4 +1,8 @@
+export interface RemoteRPCGenOutput {
+    schemas: string;
+    functions: string;
+}
 /**
  * Generate remote internal RPC queue worker and HTTP endpoint
  */
-export declare const serializeRemoteRPC: (pathToPikkuTypes: string) => string;
+export declare const serializeRemoteRPC: (pathToPikkuTypes: string) => RemoteRPCGenOutput;