@pikku/core 0.12.13 → 0.12.15

package/src/wirings/cli/cli-runner.test.ts

@@ -369,15 +369,16 @@ describe('CLI Runner', () => {
       assert.strictEqual(programs['my-cli'].middleware[0], middleware)
     })
 
-    test('should throw error when CLI metadata not found', () => {
+    test('should skip when CLI metadata not found', () => {
       pikkuState(null, 'cli', 'meta', { programs: {}, renderers: {} })
 
-      assert.throws(() => {
-        wireCLI({
-          program: 'nonexistent',
-          commands: {},
-        })
-      }, /CLI metadata not found for program 'nonexistent'/)
+      wireCLI({
+        program: 'nonexistent',
+        commands: {},
+      })
+
+      const programs = pikkuState(null, 'cli', 'programs')
+      assert.strictEqual(programs['nonexistent'], undefined)
     })
   })
 

package/src/wirings/cli/cli-runner.ts

@@ -1,4 +1,4 @@
-import { NotFoundError, PikkuMissingMetaError } from '../../errors/errors.js'
+import { NotFoundError } from '../../errors/errors.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
 import { pikkuState } from '../../pikku-state.js'
 import type {
@@ -66,9 +66,10 @@ export const wireCLI = <
   const cliMeta = pikkuState(null, 'cli', 'meta') || {}
 
   if (!cliMeta.programs?.[cli.program]) {
-    throw new PikkuMissingMetaError(
-      `CLI metadata not found for program '${cli.program}'`
+    console.warn(
+      `[pikku] Skipping CLI program '${cli.program}' — metadata not found. Consider moving this wiring to its own file.`
     )
+    return
   }
 
   // Get existing programs state and add this program
@@ -191,7 +192,7 @@ function registerCLICommands(
       }
     }
 
-    addFunction(funcName, unwrapFunc(command))
+    addFunction(funcName, unwrapFunc(command), currentMeta?.packageName)
 
     // Register renderer if provided
     if (typeof command === 'object' && command.render) {

package/src/wirings/cli/command-parser.ts

@@ -6,6 +6,11 @@ import type {
   CLIOption,
 } from './cli.types.js'
 
+/** Convert kebab-case to camelCase: "from-plan" → "fromPlan" */
+function toCamelCase(str: string): string {
+  return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase())
+}
+
 /**
  * Result of parsing CLI arguments
  */
@@ -117,11 +122,11 @@ export function parseCLIArguments(
     const arg = args[currentIndex]
 
     if (arg.startsWith('--')) {
-      // Long option
+      // Long option (--from-plan → fromPlan)
       const equalIndex = arg.indexOf('=')
       if (equalIndex > 0) {
         // --option=value format
-        const key = arg.slice(2, equalIndex)
+        const key = toCamelCase(arg.slice(2, equalIndex))
         const optionDef = availableOptions[key]
 
         // Unknown options are allowed for forward compatibility
@@ -129,7 +134,7 @@ export function parseCLIArguments(
         optionArgs[key] = parseOptionValue(value, optionDef)
       } else {
         // --option value format
-        const key = arg.slice(2)
+        const key = toCamelCase(arg.slice(2))
         const optionDef = availableOptions[key]
 
         // Unknown options are allowed for forward compatibility

package/src/wirings/http/http-runner.ts

@@ -21,7 +21,7 @@ import type {
   PikkuWire,
   PikkuWiringTypes,
 } from '../../types/core.types.js'
-import { NotFoundError, PikkuMissingMetaError } from '../../errors/errors.js'
+import { NotFoundError } from '../../errors/errors.js'
 import {
   closeWireServices,
   createWeakUID,
@@ -33,10 +33,6 @@ import {
 } from '../../pikku-state.js'
 import { PikkuSessionService } from '../../services/user-session-service.js'
 import { getErrorResponse } from '../../errors/error-handler.js'
-import {
-  PikkuCredentialWireService,
-  createMiddlewareCredentialWireProps,
-} from '../../services/credential-wire-service.js'
 import { handleHTTPError } from '../../handle-error.js'
 import { pikkuState } from '../../pikku-state.js'
 import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js'
@@ -184,9 +180,14 @@ export const wireHTTP = <
   const httpMeta = pikkuState(null, 'http', 'meta')
   const routeMeta = httpMeta[httpWiring.method][httpWiring.route]
   if (!routeMeta) {
-    throw new PikkuMissingMetaError(
-      `Missing generated metadata for HTTP route '${httpWiring.method.toUpperCase()} ${httpWiring.route}'`
+    // In deploy units with filtered metadata, wiring files may include
+    // routes for functions not in this unit. This happens when multiple
+    // wirings share a file — split them into separate files for better
+    // tree-shaking.
+    console.warn(
+      `[pikku] Skipping HTTP route '${httpWiring.method.toUpperCase()} ${httpWiring.route}' — metadata not found. Consider moving this wiring to its own file.`
     )
+    return
   }
   if (httpWiring.func) {
     addFunction(routeMeta.pikkuFuncId, httpWiring.func)
@@ -303,7 +304,6 @@ const executeRoute = async (
   }
 ) => {
   const userSession = new PikkuSessionService<CoreUserSession>()
-  const credentialWire = new PikkuCredentialWireService()
   const { params, route, meta } = matchedRoute
   const { singletonServices, createWireServices, skipUserSession, requestId } =
     services
@@ -376,13 +376,13 @@ const executeRoute = async (
   }
 
   const wire: PikkuWire = {
+    traceId: requestId,
     http,
     channel,
     session: userSession.get() as CoreUserSession | undefined,
     setSession: (s: any) => userSession.setInitial(s),
     getSession: () => userSession.get(),
     hasSessionChanged: () => userSession.sessionChanged,
-    ...createMiddlewareCredentialWireProps(credentialWire),
   }
 
   result = await runPikkuFunc(
@@ -402,7 +402,6 @@ const executeRoute = async (
       tags: route.tags,
       wire,
       sessionService: userSession,
-      credentialWireService: credentialWire,
       packageName: meta.packageName,
     }
   )
@@ -496,6 +495,7 @@ export const fetchData = async <In, Out>(
     bubbleErrors = false,
     exposeErrors = false,
     generateRequestId,
+    traceId: externalTraceId,
   }: RunHTTPWiringOptions = {}
 ): Promise<Out | void> => {
   const singletonServices = getSingletonServices()
@@ -506,11 +506,20 @@ export const fetchData = async <In, Out>(
   // Combine the request and response into one wire object
   const pikkuRequest =
     request instanceof Request ? new PikkuFetchHTTPRequest(request) : request
-  let requestId: string | null = null
-  try {
-    requestId = pikkuRequest.header('x-request-id')
-  } catch {}
+
+  // Resolve traceId: external (e.g. CF-Ray) > x-request-id header > generated
+  let requestId: string | null = externalTraceId ?? null
+  if (!requestId) {
+    try {
+      requestId = pikkuRequest.header('x-request-id')
+    } catch {}
+  }
   requestId = requestId || generateRequestId?.() || createWeakUID()
+
+  // Scoped logger for HTTP runner internal logging (error handling, route matching)
+  // Functions/middleware receive singletonServices.logger directly for compatibility
+  const scopedLogger =
+    singletonServices.logger.scope?.(requestId) ?? singletonServices.logger
   const http = createHTTPWire(pikkuRequest, response)
   const apiType = http!.request!.method()
   const apiRoute = http!.request!.path()
@@ -533,7 +542,7 @@ export const fetchData = async <In, Out>(
         response.status(204).json(undefined as any)
         return
       }
-      singletonServices.logger.info({
+      scopedLogger.info({
         message: 'Route not found',
         apiRoute,
         apiType,
@@ -558,7 +567,7 @@ export const fetchData = async <In, Out>(
   } catch (e: any) {
     if (matchedRoute?.route.sse) {
       // For SSE routes, send error through the stream since the response is already in stream mode
-      singletonServices.logger.error(e instanceof Error ? e.message : e)
+      scopedLogger.error(e instanceof Error ? e.message : e)
       try {
         const errorResponse = getErrorResponse(e)
         response.arrayBuffer(
@@ -569,7 +578,7 @@ export const fetchData = async <In, Out>(
         )
         response.arrayBuffer(JSON.stringify({ type: 'done' }))
       } catch (streamErr: any) {
-        singletonServices.logger.error(
+        scopedLogger.error(
           `SSE error while sending error payload: ${streamErr instanceof Error ? streamErr.message : String(streamErr)}`
         )
       }
@@ -579,7 +588,7 @@ export const fetchData = async <In, Out>(
         e,
         http,
         requestId,
-        singletonServices.logger,
+        scopedLogger,
         logWarningsForStatusCodes,
         respondWith404,
         bubbleErrors,

package/src/wirings/http/http.types.ts

@@ -37,6 +37,8 @@ export type RunHTTPWiringOptions = Partial<{
   bubbleErrors: boolean
   exposeErrors: boolean
   generateRequestId: () => string
+  /** Pre-resolved trace ID (e.g. CF-Ray). Falls back to x-request-id header or generated ID. */
+  traceId: string
 }>
 
 /**

package/src/wirings/mcp/mcp-runner.ts

@@ -20,16 +20,11 @@ import {
 } from '../../pikku-state.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
 import { resolveNamespace } from '../rpc/rpc-runner.js'
-import {
-  BadRequestError,
-  NotFoundError,
-  PikkuMissingMetaError,
-} from '../../errors/errors.js'
+import { BadRequestError, NotFoundError } from '../../errors/errors.js'
 import {
   PikkuSessionService,
   createMiddlewareSessionWireProps,
 } from '../../services/user-session-service.js'
-
 export class MCPError extends Error {
   constructor(public readonly error: JsonRpcErrorResponse) {
     super(error?.message || 'MCP Error')
@@ -58,9 +53,10 @@ export const wireMCPResource = <
   const resourcesMeta = pikkuState(null, 'mcp', 'resourcesMeta')
   const mcpResourceMeta = resourcesMeta[mcpResource.uri]
   if (!mcpResourceMeta) {
-    throw new PikkuMissingMetaError(
-      `Missing generated metadata for MCP resource '${mcpResource.uri}'`
+    console.warn(
+      `[pikku] Skipping MCP resource '${mcpResource.uri}' — metadata not found. Consider moving this wiring to its own file.`
     )
+    return
   }
   addFunction(mcpResourceMeta.pikkuFuncId, mcpResource.func as any)
   const resources = pikkuState(null, 'mcp', 'resources')
@@ -80,9 +76,10 @@ export const wireMCPPrompt = <
   const promptsMeta = pikkuState(null, 'mcp', 'promptsMeta')
   const mcpPromptMeta = promptsMeta[mcpPrompt.name]
   if (!mcpPromptMeta) {
-    throw new PikkuMissingMetaError(
-      `Missing generated metadata for MCP prompt '${mcpPrompt.name}'`
+    console.warn(
+      `[pikku] Skipping MCP prompt '${mcpPrompt.name}' — metadata not found. Consider moving this wiring to its own file.`
     )
+    return
   }
   addFunction(mcpPromptMeta.pikkuFuncId, mcpPrompt.func as any)
   const prompts = pikkuState(null, 'mcp', 'prompts')

package/src/wirings/queue/queue-runner.test.ts

@@ -72,7 +72,7 @@ describe('wireQueueWorker', () => {
     assert.equal(registrations.get('test-queue'), mockWorker)
   })
 
-  test('should throw error when processor metadata not found', () => {
+  test('should skip when queue worker metadata not found', () => {
     const mockWorker: CoreQueueWorker = {
       name: 'missing-meta-queue',
       func: {
@@ -81,16 +81,10 @@ describe('wireQueueWorker', () => {
       },
     }
 
-    assert.throws(
-      () => wireQueueWorker(mockWorker),
-      (error: any) => {
-        assert(
-          error.message.includes('Missing generated metadata for queue worker')
-        )
-        assert(error.message.includes('missing-meta-queue'))
-        return true
-      }
-    )
+    wireQueueWorker(mockWorker)
+
+    const registrations = pikkuState(null, 'queue', 'registrations')
+    assert.equal(registrations.has('missing-meta-queue'), false)
   })
 
   test('should wire worker with middleware and tags', () => {

package/src/wirings/queue/queue-runner.ts

@@ -12,7 +12,6 @@ import {
   pikkuState,
 } from '../../pikku-state.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
-
 /**
  * Error class for queue processor not found
  */
@@ -59,9 +58,10 @@ export const wireQueueWorker = <
   const meta = pikkuState(null, 'queue', 'meta')
   const processorMeta = meta[queueWorker.name]
   if (!processorMeta) {
-    throw new PikkuMissingMetaError(
-      `Missing generated metadata for queue worker '${queueWorker.name}'`
+    console.warn(
+      `[pikku] Skipping queue worker '${queueWorker.name}' — metadata not found. Consider moving this wiring to its own file.`
     )
+    return
   }
 
   // Register the function with pikku
@@ -105,13 +105,19 @@ export async function removeQueueWorker(name: string): Promise<void> {
 export async function runQueueJob({
   job,
   updateProgress,
+  traceId,
 }: {
   job: QueueJob
   updateProgress?: (progress: number | string | object) => Promise<void>
+  /** Pre-resolved trace ID (e.g. from queue message metadata) */
+  traceId?: string
 }): Promise<void> {
   const singletonServices = getSingletonServices()
   const createWireServices = getCreateWireServices()
-  const logger = singletonServices.logger
+  const resolvedTraceId = traceId ?? `q-${job.id}`
+  const logger =
+    singletonServices.logger.scope?.(resolvedTraceId) ??
+    singletonServices.logger
 
   const meta = pikkuState(null, 'queue', 'meta')
   const processorMeta = meta[job.queueName]
@@ -132,6 +138,7 @@ export async function runQueueJob({
   const queue: PikkuQueue = {
     queueName: job.queueName,
     jobId: job.id,
+    pikkuUserId: job.pikkuUserId,
     updateProgress:
       updateProgress ||
       (async (progress: number | string | object) => {
@@ -150,6 +157,7 @@ export async function runQueueJob({
     logger.info(`Processing job ${job.id} in queue ${job.queueName}`)
 
     const wire: PikkuWire = {
+      traceId: resolvedTraceId,
       queue,
     }
 

package/src/wirings/queue/queue.types.ts

@@ -96,6 +96,8 @@ export interface QueueJob<T = any, R = any> {
   result?: R
   waitForCompletion?: (ttl?: number) => Promise<R>
   metadata?: () => Promise<QueueJobMetadata> | QueueJobMetadata
+  /** Pikku user ID propagated from the job producer */
+  pikkuUserId?: string
 }
 
 /**
@@ -109,6 +111,8 @@ export interface JobOptions {
   removeOnComplete?: number
   removeOnFail?: number
   jobId?: string
+  /** Pikku user ID to propagate to the queue worker for credential resolution */
+  pikkuUserId?: string
 }
 
 /**
@@ -180,6 +184,8 @@ export interface PikkuQueue {
   queueName: string
   /** The current job ID */
   jobId: string
+  /** Pikku user ID propagated from the job producer for credential resolution */
+  pikkuUserId?: string
   /** Update job progress (0-100 or custom value) */
   updateProgress: (progress: number | string | object) => Promise<void>
   /** Fail the current job with optional reason */

package/src/wirings/rpc/rpc-runner.ts

@@ -7,7 +7,6 @@ import { ForbiddenError } from '../../errors/errors.js'
 import { PikkuError, addError } from '../../errors/error-handler.js'
 import type { PikkuRPC, ResolvedFunction } from './rpc-types.js'
 import { parseVersionedId } from '../../version.js'
-import { encryptJSON } from '../../crypto-utils.js'
 
 export class RPCNotFoundError extends PikkuError {
   public readonly rpcName: string
@@ -118,23 +117,51 @@ export class ContextAwareRPCService {
         : undefined,
     }
 
-    // Check if it's a namespaced function call (e.g., 'stripe:createCharge')
+    // Check addon namespace first (e.g. 'stripe:createCharge')
     if (funcName.includes(':')) {
-      return this.invokeAddonFunction<In, Out>(funcName, data, updatedWire)
+      try {
+        return await this.invokeAddonFunction<In, Out>(
+          funcName,
+          data,
+          updatedWire
+        )
+      } catch (addonErr) {
+        if (!(addonErr instanceof RPCNotFoundError)) throw addonErr
+        // Not an addon — fall through to local lookup
+      }
     }
 
-    // Main package function
-    return runPikkuFunc<In, Out>(
-      'rpc',
-      funcName,
-      getPikkuFunctionName(funcName),
-      {
-        auth: this.options.requiresAuth,
-        singletonServices: this.services,
-        data: () => data,
-        wire: updatedWire,
+    // Try local function, then fall back to deployment service (remote)
+    try {
+      return await runPikkuFunc<In, Out>(
+        'rpc',
+        funcName,
+        getPikkuFunctionName(funcName),
+        {
+          auth: this.options.requiresAuth,
+          singletonServices: this.services,
+          data: () => data,
+          wire: updatedWire,
+        }
+      )
+    } catch (e) {
+      if (e instanceof RPCNotFoundError) {
+        // Fall back to deployment service (e.g. CF service binding, Lambda Invoke)
+        if (this.services.deploymentService) {
+          const session =
+            this.wire.getSession && typeof this.wire.getSession === 'function'
+              ? await this.wire.getSession()
+              : (this.wire as any).session
+          return this.services.deploymentService.invoke(
+            funcName,
+            data,
+            session,
+            this.wire.traceId
+          ) as Promise<Out>
+        }
       }
-    )
+      throw e
+    }
   }
 
   /**
@@ -151,10 +178,7 @@ export class ContextAwareRPCService {
     // Resolve namespace to package name
     const resolved = resolveNamespace(namespacedFunction)
     if (!resolved) {
-      throw new Error(
-        `Unknown namespace in function reference: ${namespacedFunction}. ` +
-          `Make sure the package is registered in addons config.`
-      )
+      throw new RPCNotFoundError(namespacedFunction)
     }
 
     // Get the function meta from the addon package
@@ -162,10 +186,7 @@ export class ContextAwareRPCService {
     const addonFunctionMeta = pikkuState(resolved.package, 'function', 'meta')
     const funcMeta = addonFunctionMeta[resolved.function]
     if (!funcMeta) {
-      throw new Error(
-        `Function '${resolved.function}' not found in package '${resolved.package}'. ` +
-          `Available functions: ${Object.keys(addonFunctionMeta).join(', ') || '(none)'}`
-      )
+      throw new RPCNotFoundError(namespacedFunction)
     }
     const funcName = funcMeta.pikkuFuncId || resolved.function
 
@@ -210,17 +231,33 @@ export class ContextAwareRPCService {
       return this.invokeAddonFunction<In, Out>(rpcName, data, mergedWire)
     }
 
-    return runPikkuFunc<In, Out>(
-      'rpc',
-      rpcName,
-      getPikkuFunctionName(rpcName),
-      {
-        auth: this.options.requiresAuth,
-        singletonServices: this.services,
-        data: () => data,
-        wire: mergedWire,
+    try {
+      return await runPikkuFunc<In, Out>(
+        'rpc',
+        rpcName,
+        getPikkuFunctionName(rpcName),
+        {
+          auth: this.options.requiresAuth,
+          singletonServices: this.services,
+          data: () => data,
+          wire: mergedWire,
+        }
+      )
+    } catch (e) {
+      if (e instanceof RPCNotFoundError && this.services.deploymentService) {
+        const session =
+          this.wire.getSession && typeof this.wire.getSession === 'function'
+            ? await this.wire.getSession()
+            : (this.wire as any).session
+        return this.services.deploymentService.invoke(
+          rpcName,
+          data,
+          session,
+          this.wire.traceId
+        ) as Promise<Out>
       }
-    )
+      throw e
+    }
   }
 
   public async startWorkflow<In = any>(
@@ -239,6 +276,7 @@ export class ContextAwareRPCService {
       type: this.wire.wireType ?? 'unknown',
       id: this.wire.wireId,
       ...(parentRunId ? { parentRunId } : {}),
+      ...(this.wire.pikkuUserId ? { pikkuUserId: this.wire.pikkuUserId } : {}),
     }
     return this.services.workflowService.startWorkflow(
       workflowName,
@@ -306,9 +344,14 @@ export class ContextAwareRPCService {
         approvals: { toolCallId: string; approved: boolean }[],
         expectedAgentName?: string
       ) => {
-        const result = await resumeAIAgentSync(runId, approvals, {
-          sessionService: this.options.sessionService,
-        }, expectedAgentName)
+        const result = await resumeAIAgentSync(
+          runId,
+          approvals,
+          {
+            sessionService: this.options.sessionService,
+          },
+          expectedAgentName
+        )
         return {
           runId: result.runId,
           result: result.object ?? result.text,
@@ -326,94 +369,24 @@ export class ContextAwareRPCService {
     funcName: string,
     data: In
   ): Promise<Out> {
-    let endpoint: string | undefined
-    const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-    }
-
-    const colonIndex = funcName.indexOf(':')
-    if (colonIndex !== -1) {
-      const namespace = funcName.substring(0, colonIndex)
-      const addons = pikkuState(null, 'addons', 'packages')
-      const pkgConfig = addons.get(namespace)
-      endpoint = pkgConfig?.rpcEndpoint
-    }
-
-    if (!endpoint && this.services.deploymentService) {
-      const deployments =
-        await this.services.deploymentService.findFunction(funcName)
-      if (deployments.length > 0) {
-        endpoint = deployments[0].endpoint
-      }
-    }
-
-    if (!endpoint) {
+    if (!this.services.deploymentService) {
       throw new Error(
-        `No endpoint configured for remote RPC: ${funcName}. ` +
-          `Configure rpcEndpoint in addons config or set up a DeploymentService.`
+        `No DeploymentService configured for remote RPC: ${funcName}. ` +
+          `Set up a DeploymentService to enable remote function calls.`
       )
     }
 
-    let secret: string | undefined
-    if (this.services.secrets) {
-      try {
-        secret = await this.services.secrets.getSecret('PIKKU_REMOTE_SECRET')
-      } catch {}
-    }
-    if (secret) {
-      if (!this.services.jwt) {
-        throw new Error(
-          'PIKKU_REMOTE_SECRET is set but JWT service is not available'
-        )
-      }
-      const session =
-        this.wire.getSession && typeof this.wire.getSession === 'function'
-          ? await this.wire.getSession()
-          : (this.wire as any).session
-      const sessionEnc = session
-        ? await encryptJSON(secret, { session })
-        : undefined
-      const token = await this.services.jwt.encode(
-        { value: 5, unit: 'minute' },
-        {
-          aud: 'pikku-remote',
-          fn: funcName,
-          iat: Date.now(),
-          session: sessionEnc,
-        }
-      )
-      headers.Authorization = `Bearer ${token}`
-    }
+    const session =
+      this.wire.getSession && typeof this.wire.getSession === 'function'
+        ? await this.wire.getSession()
+        : (this.wire as any).session
 
-    const url = `${endpoint}/rpc/${encodeURIComponent(funcName)}`
-    const timeoutMs = 30_000
-    const response = await fetch(url, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify({ data }),
-      signal: AbortSignal.timeout(timeoutMs),
-    })
-
-    if (!response.ok) {
-      let errorBody: string
-      try {
-        errorBody = JSON.stringify(await response.json())
-      } catch {
-        errorBody = await response.text()
-      }
-      throw new Error(
-        `Remote RPC call failed: ${response.status} ${response.statusText}. ${errorBody}`
-      )
-    }
-
-    try {
-      return (await response.json()) as Out
-    } catch {
-      const text = await response.text()
-      throw new Error(
-        `Remote RPC call returned non-JSON response: ${response.status} ${response.statusText}. ${text}`
-      )
-    }
+    return this.services.deploymentService.invoke(
+      funcName,
+      data,
+      session,
+      this.wire.traceId
+    ) as Promise<Out>
   }
 }