@pikku/cli 0.11.2 → 0.12.0

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

@@ -11,6 +11,9 @@ import { pikkuSessionlessFunc, wireQueueWorker } from '${pathToPikkuTypes}'
 /**
  * Generic remote RPC worker that invokes any internal RPC by name
  * This is used for executing internal RPCs via a queue or HTTP (e.g., scheduled tasks, background jobs, internal services)
+ *
+ * TODO: Security risk - this allows any RPC to be invoked by name. Should validate
+ * that rpcName is in an allowlist of permitted internal RPCs to prevent unauthorized access.
  */
 export const pikkuRemoteInternalRPC = pikkuSessionlessFunc<
   { rpcName: string, data?: any },
@@ -19,11 +22,11 @@ export const pikkuRemoteInternalRPC = pikkuSessionlessFunc<
   func: async (_services, { rpcName, data }, { rpc }) => {
     return await (rpc.invoke as any)(rpcName, data)
   },
-  internal: true,
+  remote: true,
 })
 
 wireQueueWorker({
-  queueName: 'pikku-remote-internal-rpc',
+  name: 'pikku-remote-internal-rpc',
   func: pikkuRemoteInternalRPC,
 })
 `;

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

@@ -1,11 +1,11 @@
 export const serializeRPCWrapper = (rpcMapPath) => {
     return `
 import { PikkuFetch } from "./pikku-fetch.gen.js"
-import type { RPCInvoke } from '${rpcMapPath}'
+import type { RPCInvoke, TypedAgent } from '${rpcMapPath}'
 
 /**
- * PikkuRPC provides a type-safe client for making Remote Procedure Calls (RPC) 
- * to your Pikku server. It wraps the underlying HTTP client and provides a 
+ * PikkuRPC provides a type-safe client for making Remote Procedure Calls (RPC)
+ * to your Pikku server. It wraps the underlying HTTP client and provides a
  * simple interface for invoking server-side functions.
  */
 export class PikkuRPC {
@@ -15,7 +15,7 @@ export class PikkuRPC {
     /**
      * Sets a custom PikkuFetch instance to use for RPC calls.
      * This allows you to configure custom settings or use a shared client instance.
-     * 
+     *
      * @param pikkuFetch - The PikkuFetch instance to use
      */
     setPikkuFetch(pikkuFetch: PikkuFetch): void {
@@ -24,7 +24,7 @@ export class PikkuRPC {
 
     /**
      * Sets the base server URL for all RPC calls.
-     * 
+     *
      * @param serverUrl - The base URL of your Pikku server (e.g., 'https://api.example.com')
      */
     setServerUrl(serverUrl: string): void {
@@ -33,7 +33,7 @@ export class PikkuRPC {
 
     /**
      * Sets the JWT token for authorization on all RPC calls.
-     * 
+     *
      * @param jwt - The JWT token to use for authorization, or null to remove authorization
      */
     setAuthorizationJWT(jwt: string | null): void {
@@ -42,7 +42,7 @@ export class PikkuRPC {
 
     /**
      * Sets the API key for authorization on all RPC calls.
-     * 
+     *
      * @param apiKey - The API key to use for authorization, or null to remove the API key
      */
     setAPIKey(apiKey: string | null): void {
@@ -59,7 +59,18 @@ export class PikkuRPC {
      * @returns A promise that resolves with the function's return value
      */
     invoke: RPCInvoke = async (rpcName, data) => {
-       return await this.pikkuFetch.post(\`/rpc/\${rpcName}\` as any, { rpcName, data }) as any
+       return await this.pikkuFetch.post(\`/rpc/\${String(rpcName)}\` as never, { rpcName: String(rpcName), data }) as any
+    }
+
+    /**
+     * Invokes an AI agent on the server.
+     *
+     * @param agentName - The name of the agent to invoke
+     * @param input - The agent input (message, threadId, resourceId)
+     * @returns A promise that resolves with the agent's output
+     */
+    agent: TypedAgent = async (agentName, input) => {
+       return await this.pikkuFetch.post(\`/rpc/agent/\${String(agentName)}\` as never, input) as any
     }
 }
 

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

@@ -1,3 +1,6 @@
-import { TypesMap } from '@pikku/inspector';
-import { FunctionsMeta } from '@pikku/core';
-export declare const serializeTypedRPCMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, rpcMeta: Record<string, string>) => string;
+import { TypesMap, ExternalPackageConfig } from '@pikku/inspector';
+import { Logger } from '@pikku/core/services';
+export declare const serializeTypedRPCMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, rpcMeta: Record<string, string>, resolvedIOTypes: Record<string, {
+    inputType: string;
+    outputType: string;
+}>, externalPackages?: Record<string, ExternalPackageConfig>, workflowMapPath?: string, agentMapPath?: string) => string;

package/dist/src/functions/wirings/rpc/serialize-typed-rpc-map.js

@@ -1,16 +1,35 @@
 import { serializeImportMap } from '../../../utils/serialize-import-map.js';
-import { generateCustomTypes } from '../../../utils/custom-types-generator.js';
-export const serializeTypedRPCMap = (relativeToPath, packageMappings, typesMap, functionsMeta, rpcMeta) => {
+import { generateCustomTypes, } from '@pikku/inspector';
+export const serializeTypedRPCMap = (logger, relativeToPath, packageMappings, typesMap, rpcMeta, resolvedIOTypes, externalPackages, workflowMapPath, agentMapPath) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
-    const serializedRPCs = generateRPCs(rpcMeta, functionsMeta, typesMap, requiredTypes);
-    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    const serializedRPCs = generateRPCs(rpcMeta, resolvedIOTypes, requiredTypes);
+    const mcpTypes = [
+        'MCPResourceResponse',
+        'MCPToolResponse',
+        'MCPPromptResponse',
+    ];
+    const usedMcpTypes = mcpTypes.filter((t) => requiredTypes.has(t));
+    const mcpImport = usedMcpTypes.length > 0
+        ? `import type { ${usedMcpTypes.join(', ')} } from '@pikku/core/mcp'`
+        : '';
+    for (const t of usedMcpTypes) {
+        requiredTypes.delete(t);
+    }
+    const serializedImportMap = serializeImportMap(logger, relativeToPath, packageMappings, typesMap, requiredTypes);
+    const serializedCustomTypesDeclarationsOnly = serializedCustomTypes
+        .split('\n')
+        .filter((line) => !line.startsWith('import '))
+        .join('\n');
+    const externalPackageImports = generateExternalPackageImports(externalPackages, relativeToPath);
+    const mergedRPCMap = generateMergedRPCMap(externalPackages);
     return `/**
  * This provides the structure needed for typescript to be aware of RPCs and their return types
  */
-    
+
+${mcpImport}
 ${serializedImportMap}
-${serializedCustomTypes}
+${serializedCustomTypesDeclarationsOnly}
 
 interface RPCHandler<I, O> {
     input: I;
@@ -18,68 +37,120 @@ interface RPCHandler<I, O> {
 }
 
 ${serializedRPCs}
+${externalPackageImports}
+${mergedRPCMap}
+
+export type RPCInvoke = <Name extends keyof FlattenedRPCMap>(
+  name: Name,
+  data: FlattenedRPCMap[Name]['input']
+) => Promise<FlattenedRPCMap[Name]['output']>
 
-export type RPCInvoke = <Name extends keyof RPCMap>(
+export type RPCRemote = <Name extends keyof FlattenedRPCMap>(
   name: Name,
-  data: RPCMap[Name]['input'],
-  options?: {
-    location?: 'local' | 'remote' | 'auto'
-  }
-) => Promise<RPCMap[Name]['output']>
+  data: FlattenedRPCMap[Name]['input']
+) => Promise<FlattenedRPCMap[Name]['output']>
 
-// Import WorkflowMap for workflow typing
-import type { WorkflowMap } from '../workflow/pikku-workflow-map.gen.js'
+${workflowMapPath ? `import type { WorkflowMap } from '${workflowMapPath}'` : `type WorkflowMap = {}`}
 
-export type TypedPikkuRPC = {
-  depth: number;
-  global: boolean;
-  invoke: RPCInvoke;
-  invokeExposed: (name: string, data: any) => Promise<any>;
-  startWorkflow: <Name extends keyof WorkflowMap>(
-    name: Name,
-    input: WorkflowMap[Name]['input']
-  ) => Promise<{ runId: string }>;
+${agentMapPath ? `import type { AgentMap } from '${agentMapPath}'` : `type AgentMap = {}`}
+${generateExternalAgentImports(externalPackages)}
+${generateMergedAgentMap(externalPackages)}
+
+import type { PikkuRPC } from '@pikku/core/rpc'
+
+interface AIAgentInput {
+  message: string
+  threadId: string
+  resourceId: string
 }
+
+type TypedStartWorkflow = <Name extends keyof WorkflowMap>(
+  name: Name,
+  input: WorkflowMap[Name]['input'],
+  options?: { startNode?: string }
+) => Promise<{ runId: string }>
+
+type TypedAgent = <Name extends keyof FlattenedAgentMap>(
+  name: Name,
+  input: AIAgentInput
+) => Promise<{ runId: string; result: FlattenedAgentMap[Name]['output']; usage: { inputTokens: number; outputTokens: number } }>
+
+export type TypedPikkuRPC = PikkuRPC<RPCInvoke, RPCRemote, TypedStartWorkflow, TypedAgent>
   `;
 };
-function generateRPCs(rpcMeta, functionsMeta, typesMap, requiredTypes) {
-    // Initialize an object to collect RPCs
+function generateExternalPackageImports(externalPackages, relativeToPath) {
+    if (!externalPackages || Object.keys(externalPackages).length === 0) {
+        return '';
+    }
+    let imports = '\n// External package RPC maps\n';
+    for (const [namespace, config] of Object.entries(externalPackages)) {
+        // Import the RPCMap from each external package's internal RPC map
+        // Use .js extension - package.json exports will resolve to .d.ts for types
+        imports += `import type { RPCMap as ${toPascalCase(namespace)}RPCMap } from '${config.package}/.pikku/rpc/pikku-rpc-wirings-map.internal.gen.js'\n`;
+    }
+    return imports;
+}
+function generateMergedRPCMap(externalPackages) {
+    if (!externalPackages || Object.keys(externalPackages).length === 0) {
+        return `
+// No external packages, use RPCMap directly
+export type FlattenedRPCMap = RPCMap
+`;
+    }
+    // TypeScript utility to flatten namespaced RPC maps
+    const utilityTypes = `
+// Utility type to prefix keys with namespace
+type PrefixKeys<T, Prefix extends string> = {
+  [K in keyof T as \`\${Prefix}:\${string & K}\`]: T[K]
+}
+
+// Merge all RPC maps with namespace prefixes
+export type FlattenedRPCMap =
+  RPCMap${Object.keys(externalPackages)
+        .map((namespace) => ` & PrefixKeys<${toPascalCase(namespace)}RPCMap, '${namespace}'>`)
+        .join('')}
+`;
+    return utilityTypes;
+}
+function toPascalCase(str) {
+    return str
+        .split(/[-_]/)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join('');
+}
+function generateExternalAgentImports(externalPackages) {
+    if (!externalPackages || Object.keys(externalPackages).length === 0) {
+        return '';
+    }
+    let imports = '\n// External package Agent maps\n';
+    for (const [namespace, config] of Object.entries(externalPackages)) {
+        imports += `import type { AgentMap as ${toPascalCase(namespace)}AgentMap } from '${config.package}/.pikku/agent/pikku-agent-map.gen.d.js'\n`;
+    }
+    return imports;
+}
+function generateMergedAgentMap(externalPackages) {
+    if (!externalPackages || Object.keys(externalPackages).length === 0) {
+        return `
+type FlattenedAgentMap = AgentMap
+`;
+    }
+    return `
+type FlattenedAgentMap =
+  AgentMap${Object.keys(externalPackages)
+        .map((namespace) => ` & PrefixKeys<${toPascalCase(namespace)}AgentMap, '${namespace}'>`)
+        .join('')}
+`;
+}
+function generateRPCs(rpcMeta, resolvedIOTypes, requiredTypes) {
     const rpcsObj = {};
-    // Iterate through RPC metadata
-    for (const [funcName, pikkuFuncName] of Object.entries(rpcMeta)) {
-        const functionMeta = functionsMeta[pikkuFuncName];
-        if (!functionMeta) {
-            throw new Error(`Function ${funcName} not found in functionsMeta. Please check your configuration.`);
-        }
-        const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
-        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
-        // Store the input and output types for RPCHandler
-        // Use 'any' for types not in typesMap (e.g., inline types in generated workflow workers)
-        let inputType = 'null';
-        if (input) {
-            try {
-                inputType = typesMap.getTypeMeta(input).uniqueName;
-            }
-            catch {
-                inputType = 'any';
-            }
-        }
-        let outputType = 'null';
-        if (output) {
-            try {
-                outputType = typesMap.getTypeMeta(output).uniqueName;
-            }
-            catch {
-                outputType = 'any';
-            }
+    for (const [funcName, pikkuFuncId] of Object.entries(rpcMeta)) {
+        const resolved = resolvedIOTypes[pikkuFuncId];
+        if (!resolved) {
+            throw new Error(`Function ${pikkuFuncId} not found in resolvedIOTypes. Please check your configuration.`);
         }
-        requiredTypes.add(inputType);
-        requiredTypes.add(outputType);
-        // Add RPC entry
-        rpcsObj[funcName] = {
-            inputType,
-            outputType,
-        };
+        requiredTypes.add(resolved.inputType);
+        requiredTypes.add(resolved.outputType);
+        rpcsObj[funcName] = resolved;
     }
     // Build the RPCs object as a string
     let rpcsStr = 'export type RPCMap = {\n';

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

@@ -1 +1 @@
-export declare const pikkuSchedulerTypes: any;
+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>;

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';

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

@@ -1 +1 @@
-export declare const pikkuScheduler: any;
+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>;

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

@@ -1,15 +1,24 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeSchedulerMeta, serializeSchedulerMetaTS, } from './serialize-scheduler-meta.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
 export const pikkuScheduler = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
         const { schedulersWiringFile, schedulersWiringMetaFile, schedulersWiringMetaJsonFile, packageMappings, schema, } = config;
         const { scheduledTasks } = visitState;
-        await writeFileInDir(logger, schedulersWiringMetaJsonFile, JSON.stringify(serializeSchedulerMeta(scheduledTasks.meta), null, 2));
+        const fullMeta = serializeSchedulerMeta(scheduledTasks.meta);
+        // Write minimal JSON (runtime-only fields)
+        const minimalMeta = stripVerboseFields(fullMeta);
+        await writeFileInDir(logger, schedulersWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
+        // Write verbose JSON only if it has additional fields
+        if (hasVerboseFields(fullMeta)) {
+            const verbosePath = schedulersWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
+            await writeFileInDir(logger, verbosePath, JSON.stringify(fullMeta, null, 2));
+        }
         const jsonImportPath = getFileImportRelativePath(schedulersWiringMetaFile, schedulersWiringMetaJsonFile, packageMappings);
         await writeFileInDir(logger, schedulersWiringMetaFile, serializeSchedulerMetaTS(scheduledTasks.meta, jsonImportPath, schema?.supportsImportAttributes ?? false));
         await writeFileInDir(logger, schedulersWiringFile, serializeFileImports('addScheduledTasks', schedulersWiringFile, scheduledTasks.files, packageMappings));

package/dist/src/functions/wirings/scheduler/serialize-scheduler-meta.d.ts

@@ -1,3 +1,3 @@
 import { ScheduledTasksMeta } from '@pikku/core/scheduler';
 export declare const serializeSchedulerMeta: (scheduledTasksMeta: ScheduledTasksMeta) => ScheduledTasksMeta;
-export declare const serializeSchedulerMetaTS: (scheduledTasksMeta: ScheduledTasksMeta, jsonImportPath: string, supportsImportAttributes: any) => string;
+export declare const serializeSchedulerMetaTS: (scheduledTasksMeta: ScheduledTasksMeta, jsonImportPath: string, supportsImportAttributes: boolean) => string;

package/dist/src/functions/wirings/scheduler/serialize-scheduler-meta.js

@@ -1,20 +1,21 @@
+import { serializeMetaTS } from '../../../utils/serialize-meta-ts.js';
 export const serializeSchedulerMeta = (scheduledTasksMeta) => {
     return scheduledTasksMeta;
 };
 export const serializeSchedulerMetaTS = (scheduledTasksMeta, jsonImportPath, supportsImportAttributes) => {
-    const importStatement = supportsImportAttributes
-        ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-        : `import metaData from '${jsonImportPath}'`;
-    const serializedOutput = [];
-    serializedOutput.push("import { pikkuState } from '@pikku/core'");
-    serializedOutput.push("import { ScheduledTasksMeta } from '@pikku/core/scheduler'");
-    serializedOutput.push(importStatement);
-    serializedOutput.push('');
-    serializedOutput.push("pikkuState('scheduler', 'meta', metaData as ScheduledTasksMeta)");
-    serializedOutput.push('');
+    const base = serializeMetaTS({
+        jsonImportPath,
+        supportsImportAttributes,
+        pikkuStateNamespace: 'scheduler',
+        pikkuStateKey: 'meta',
+        metaTypeImport: '@pikku/core/scheduler',
+        metaTypeName: 'ScheduledTasksMeta',
+    });
     const scheduledTasksMetaValues = Object.values(scheduledTasksMeta);
     if (scheduledTasksMetaValues.length > 0) {
-        serializedOutput.push(`export type ScheduledTaskNames = '${scheduledTasksMetaValues.map((s) => s.name).join("' | '")}'`);
+        return (base +
+            '\n\n' +
+            `export type ScheduledTaskNames = '${scheduledTasksMetaValues.map((s) => s.name).join("' | '")}'`);
     }
-    return serializedOutput.join('\n');
+    return base;
 };

package/dist/src/functions/wirings/scheduler/serialize-scheduler-types.js

@@ -22,7 +22,7 @@ type SchedulerWiring = CoreScheduledTask<PikkuFunctionConfig<void, void, 'sessio
  * @param task - Scheduled task definition with cron expression and handler
  */
 export const wireScheduler = (task: SchedulerWiring) => {
-  wireSchedulerCore(task as any) // TODO
+  wireSchedulerCore(task as any)
 }
 `;
 };

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

@@ -0,0 +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>;

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

@@ -0,0 +1,31 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeSecretsTypes } from './serialize-secrets-types.js';
+import { validateAndBuildSecretDefinitionsMeta } from '@pikku/core/secret';
+export const pikkuSecrets = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const { secretsFile, secretsMetaJsonFile, packageMappings } = config;
+        if (!secretsFile) {
+            return;
+        }
+        const state = await getInspectorState();
+        const content = serializeSecretsTypes({
+            definitions: state.secrets.definitions,
+            schemaLookup: state.schemaLookup,
+            secretsFile,
+            packageMappings,
+        });
+        await writeFileInDir(logger, secretsFile, content);
+        if (secretsMetaJsonFile) {
+            const meta = validateAndBuildSecretDefinitionsMeta(state.secrets.definitions, state.schemaLookup);
+            await writeFileInDir(logger, secretsMetaJsonFile, JSON.stringify(meta, null, 2));
+        }
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating PikkuSecrets types',
+            commandEnd: 'Created PikkuSecrets types',
+        }),
+    ],
+});

package/dist/src/functions/wirings/secrets/serialize-secrets-types.d.ts

@@ -0,0 +1,9 @@
+import { SecretDefinitions } from '@pikku/core/secret';
+import { SchemaRef } from '@pikku/inspector';
+export interface SerializeSecretsOptions {
+    definitions: SecretDefinitions;
+    schemaLookup: Map<string, SchemaRef>;
+    secretsFile: string;
+    packageMappings: Record<string, string>;
+}
+export declare const serializeSecretsTypes: ({ definitions, schemaLookup, secretsFile, packageMappings, }: SerializeSecretsOptions) => string;

package/dist/src/functions/wirings/secrets/serialize-secrets-types.js

@@ -0,0 +1,64 @@
+import { validateAndBuildSecretDefinitionsMeta } from '@pikku/core/secret';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+export const serializeSecretsTypes = ({ definitions, schemaLookup, secretsFile, packageMappings, }) => {
+    const secrets = validateAndBuildSecretDefinitionsMeta(definitions, schemaLookup);
+    const credentialEntries = Object.entries(secrets);
+    const schemaImports = new Map();
+    let needsOAuth2Types = false;
+    let needsZod = false;
+    const mapEntries = [];
+    const metaEntries = [];
+    for (const [name, meta] of credentialEntries) {
+        if (meta.oauth2) {
+            needsOAuth2Types = true;
+            mapEntries.push(`  '${meta.secretId}': OAuth2AppCredential`);
+            mapEntries.push(`  '${meta.oauth2.tokenSecretId}': OAuth2Token`);
+            metaEntries.push(`  '${meta.secretId}': { name: '${name}', displayName: '${meta.displayName}', oauth2: { tokenSecretId: '${meta.oauth2.tokenSecretId}' } }`);
+            metaEntries.push(`  '${meta.oauth2.tokenSecretId}': { name: '${name}_tokens', displayName: '${meta.displayName} Tokens' }`);
+        }
+        else if (meta.schema && typeof meta.schema === 'string') {
+            const schemaRef = schemaLookup.get(meta.schema);
+            if (schemaRef) {
+                needsZod = true;
+                if (!schemaImports.has(schemaRef.sourceFile)) {
+                    schemaImports.set(schemaRef.sourceFile, new Set());
+                }
+                schemaImports.get(schemaRef.sourceFile).add(schemaRef.variableName);
+                mapEntries.push(`  '${meta.secretId}': z.infer<typeof ${schemaRef.variableName}>`);
+                metaEntries.push(`  '${meta.secretId}': { name: '${name}', displayName: '${meta.displayName}' }`);
+            }
+        }
+    }
+    const imports = [];
+    imports.push(`import { TypedSecretService as CoreTypedSecretService, type CredentialMeta } from '@pikku/core/services'`);
+    imports.push(`import type { SecretService } from '@pikku/core/services'`);
+    if (needsZod) {
+        imports.push(`import type { z } from 'zod'`);
+    }
+    if (needsOAuth2Types) {
+        imports.push(`import type { OAuth2AppCredential, OAuth2Token } from '@pikku/core/oauth2'`);
+    }
+    for (const [sourceFile, variableNames] of schemaImports) {
+        const importPath = getFileImportRelativePath(secretsFile, sourceFile, packageMappings);
+        const vars = Array.from(variableNames).join(', ');
+        imports.push(`import { ${vars} } from '${importPath}'`);
+    }
+    return `${imports.join('\n')}
+
+export interface CredentialsMap {
+${mapEntries.join('\n')}
+}
+
+export type SecretId = keyof CredentialsMap
+
+const CREDENTIALS_META: Record<string, CredentialMeta> = {
+${metaEntries.join(',\n')}
+}
+
+export class TypedSecretService extends CoreTypedSecretService<CredentialsMap> {
+  constructor(secrets: SecretService) {
+    super(secrets, CREDENTIALS_META)
+  }
+}
+`;
+};

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

@@ -0,0 +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>;

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

@@ -0,0 +1,24 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+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 { singletonServicesType } = visitState.filesAndMethods;
+        if (!singletonServicesType) {
+            throw new Error('SingletonServices type not found');
+        }
+        const singletonServicesTypeImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(triggersTypesFile, singletonServicesType.typePath, packageMappings)}'`;
+        const content = serializeTriggerTypes(singletonServicesTypeImport, singletonServicesType.type);
+        await writeFileInDir(logger, triggersTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating trigger types',
+            commandEnd: 'Created trigger types',
+        }),
+    ],
+});

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

@@ -0,0 +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>;

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

@@ -0,0 +1,40 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeTriggerMeta, serializeTriggerMetaTS, serializeTriggerSourceMeta, serializeTriggerSourceMetaTS, } from './serialize-trigger-meta.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
+export const pikkuTrigger = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        const { triggersWiringFile, triggersWiringMetaFile, triggersWiringMetaJsonFile, triggerSourcesMetaFile, triggerSourcesMetaJsonFile, packageMappings, schema, } = config;
+        const { triggers } = visitState;
+        if (Object.keys(triggers.meta).length === 0) {
+            return undefined;
+        }
+        const fullMeta = serializeTriggerMeta(triggers.meta);
+        // Write minimal JSON (runtime-only fields)
+        const minimalMeta = stripVerboseFields(fullMeta);
+        await writeFileInDir(logger, triggersWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
+        // Write verbose JSON only if it has additional fields
+        if (hasVerboseFields(fullMeta)) {
+            const verbosePath = triggersWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
+            await writeFileInDir(logger, verbosePath, JSON.stringify(fullMeta, null, 2));
+        }
+        const jsonImportPath = getFileImportRelativePath(triggersWiringMetaFile, triggersWiringMetaJsonFile, packageMappings);
+        await writeFileInDir(logger, triggersWiringMetaFile, serializeTriggerMetaTS(triggers.meta, jsonImportPath, schema?.supportsImportAttributes ?? false));
+        await writeFileInDir(logger, triggersWiringFile, serializeFileImports('wireTrigger', triggersWiringFile, triggers.files, packageMappings));
+        const sourceMetaJson = serializeTriggerSourceMeta(triggers.sourceMeta);
+        await writeFileInDir(logger, triggerSourcesMetaJsonFile, JSON.stringify(sourceMetaJson, null, 2));
+        const sourceMetaJsonImportPath = getFileImportRelativePath(triggerSourcesMetaFile, triggerSourcesMetaJsonFile, packageMappings);
+        await writeFileInDir(logger, triggerSourcesMetaFile, serializeTriggerSourceMetaTS(triggers.sourceMeta, sourceMetaJsonImportPath, schema?.supportsImportAttributes ?? false));
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Finding triggers',
+            commandEnd: 'Found triggers',
+        }),
+    ],
+});

package/dist/src/functions/wirings/triggers/serialize-trigger-meta.d.ts

@@ -0,0 +1,5 @@
+import { TriggerMeta, TriggerSourceMeta } from '@pikku/core/trigger';
+export declare const serializeTriggerMeta: (triggerMeta: TriggerMeta) => TriggerMeta;
+export declare const serializeTriggerMetaTS: (triggerMeta: TriggerMeta, jsonImportPath: string, supportsImportAttributes: boolean) => string;
+export declare const serializeTriggerSourceMeta: (sourceMeta: TriggerSourceMeta) => TriggerSourceMeta;
+export declare const serializeTriggerSourceMetaTS: (sourceMeta: TriggerSourceMeta, jsonImportPath: string, supportsImportAttributes: boolean) => string;