@pikku/inspector 0.12.11 → 0.12.12

package/src/add/add-gateway.ts

@@ -70,7 +70,11 @@ export const addGateway: AddWiring = (
   }
 
   const packageName = ts.isIdentifier(funcInitializer)
-    ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+    ? resolveAddonName(
+        funcInitializer,
+        checker,
+        state.rpc.wireAddonDeclarations
+      )
     : null
 
   if (!nameValue || !typeValue) {

package/src/add/add-http-route.ts

@@ -273,12 +273,32 @@ export function registerHTTPRoute({
 
   const input = fnMeta.inputs?.[0] || null
 
-  // Validate that route params and query params exist in function input type
-  if (params.length > 0 || query.length > 0) {
-    const inputTypes = state.typesLookup.get(funcName)
+  const getRouteInputKeys = (): string[] | null => {
+    const targetFuncName = refAddonTarget ?? funcName
+    const inputTypes = state.typesLookup.get(targetFuncName)
     if (inputTypes && inputTypes.length > 0) {
-      const inputKeys = extractTypeKeys(inputTypes[0])
+      return extractTypeKeys(inputTypes[0])
+    }
+
+    const targetMeta = resolveFunctionMeta(state, targetFuncName)
+    if (targetMeta?.inputSchemaName) {
+      const schema = state.schemas[targetMeta.inputSchemaName] as any
+      const properties = schema?.properties
+      if (properties && typeof properties === 'object') {
+        return Object.keys(properties)
+      }
+    }
 
+    return null
+  }
+
+  // Validate that route params and query params exist in function input type
+  if (params.length > 0 || query.length > 0) {
+    const inputKeys = getRouteInputKeys()
+    if (!inputKeys) {
+      // Input shape isn't inspectable at this phase (e.g. addon ref or opaque handler).
+      // Skip param/query validation rather than emitting a false positive.
+    } else {
       // Check path params
       if (params.length > 0) {
         const missingParams = params.filter((p) => !inputKeys.includes(p))
@@ -286,7 +306,7 @@ export function registerHTTPRoute({
           logger.critical(
             ErrorCode.ROUTE_PARAM_MISMATCH,
             `Route '${fullRoute}' has path parameter(s) [${missingParams.join(', ')}] ` +
-              `not found in function '${funcName}' input type. ` +
+              `not found in function '${refAddonTarget ?? funcName}' input type. ` +
               `Input type has: [${inputKeys.join(', ')}]`
           )
           return
@@ -300,7 +320,7 @@ export function registerHTTPRoute({
           logger.critical(
             ErrorCode.ROUTE_QUERY_MISMATCH,
             `Route '${fullRoute}' has query parameter(s) [${missingQuery.join(', ')}] ` +
-              `not found in function '${funcName}' input type. ` +
+              `not found in function '${refAddonTarget ?? funcName}' input type. ` +
               `Input type has: [${inputKeys.join(', ')}]`
           )
           return

package/src/add/add-keyed-wiring.ts

@@ -1,5 +1,8 @@
 import * as ts from 'typescript'
-import { getPropertyValue } from '../utils/get-property-value.js'
+import {
+  getPropertyValue,
+  assertStringLiteralProperty,
+} from '../utils/get-property-value.js'
 import type { AddWiring, InspectorState } from '../types.js'
 import { ErrorCode } from '../error-codes.js'
 import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js'
@@ -39,6 +42,9 @@ export const createAddKeyedWiring = (config: KeyedWiringConfig): AddWiring => {
     if (ts.isObjectLiteralExpression(firstArg)) {
       const obj = firstArg
 
+      assertStringLiteralProperty(obj, 'name', config.label, logger)
+      assertStringLiteralProperty(obj, config.idField, config.label, logger)
+
       const nameValue = getPropertyValue(obj, 'name') as string | null
       const displayNameValue = getPropertyValue(obj, 'displayName') as
         | string

package/src/add/add-mcp-prompt.ts

@@ -74,7 +74,11 @@ export const addMCPPrompt: AddWiring = (
     }
 
     const packageName = ts.isIdentifier(funcInitializer)
-      ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+      ? resolveAddonName(
+          funcInitializer,
+          checker,
+          state.rpc.wireAddonDeclarations
+        )
       : null
 
     ensureFunctionMetadata(

package/src/add/add-mcp-resource.ts

@@ -83,7 +83,11 @@ export const addMCPResource: AddWiring = (
     }
 
     const packageName = ts.isIdentifier(funcInitializer)
-      ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+      ? resolveAddonName(
+          funcInitializer,
+          checker,
+          state.rpc.wireAddonDeclarations
+        )
       : null
 
     ensureFunctionMetadata(

package/src/add/add-middleware.ts

@@ -245,7 +245,7 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
     return
   }
 
-  if (expression.text === 'addMiddleware') {
+  if (expression.text === 'addTagMiddleware') {
     const tagArg = args[0]
     const middlewareArrayArg = args[1]
 
@@ -257,13 +257,13 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
     }
 
     if (!tag) {
-      logger.warn(`• addMiddleware call without valid tag string`)
+      logger.warn(`• addTagMiddleware call without valid tag string`)
       return
     }
 
     if (!ts.isArrayLiteralExpression(middlewareArrayArg)) {
       logger.error(
-        `• addMiddleware('${tag}', ...) must have a literal array as second argument`
+        `• addTagMiddleware('${tag}', ...) must have a literal array as second argument`
       )
       return
     }
@@ -329,7 +329,7 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
     if (!isFactory && exportedName) {
       logger.warn(
         `• Middleware group '${exportedName}' for tag '${tag}' is not wrapped in a factory function. ` +
-          `For tree-shaking, use: export const ${exportedName} = () => addMiddleware('${tag}', [...])`
+          `For tree-shaking, use: export const ${exportedName} = () => addTagMiddleware('${tag}', [...])`
       )
     }
 
@@ -352,6 +352,43 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
     return
   }
 
+  if (expression.text === 'addGlobalMiddleware') {
+    const middlewareArrayArg = args[0]
+    if (
+      !middlewareArrayArg ||
+      !ts.isArrayLiteralExpression(middlewareArrayArg)
+    ) {
+      logger.error(
+        `• addGlobalMiddleware(...) must have a literal array as its only argument`
+      )
+      return
+    }
+    const refs = extractMiddlewareRefs(
+      middlewareArrayArg,
+      checker,
+      state.rootDir
+    )
+    const definitionIds = refs.map((r) => r.definitionId)
+    if (definitionIds.length > 0) {
+      renameTempDefinitions(state, definitionIds, 'global', 'middleware')
+    }
+    const sourceFile = node.getSourceFile().fileName
+    for (let i = 0; i < refs.length; i++) {
+      const instanceId = makeContextBasedId('global', 'middleware', String(i))
+      state.middleware.instances[instanceId] = {
+        definitionId: definitionIds[i],
+        sourceFile,
+        position: node.getStart(),
+        isFactoryCall: refs[i].isFactoryCall,
+      }
+    }
+    // Without this, bootstrap codegen's "import every file with a wire-call"
+    // pass skips middleware-only files and the registration never runs.
+    state.http.files.add(sourceFile)
+    logger.debug(`• Found global middleware group with ${refs.length} entries`)
+    return
+  }
+
   if (expression.text === 'addHTTPMiddleware') {
     const patternArg = args[0]
     const middlewareArrayArg = args[1]
@@ -452,6 +489,7 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
       instanceIds,
       isFactory,
     })
+    state.http.files.add(sourceFile)
 
     logger.debug(
       `• Found HTTP route middleware group: ${pattern} -> [${instanceIds.join(', ')}] (${isFactory ? 'factory' : 'direct'})`

package/src/add/add-permission.ts

@@ -45,7 +45,7 @@ function isInsidePermissionContainer(node: ts.Node): boolean {
       ts.isCallExpression(current) &&
       ts.isIdentifier(current.expression) &&
       (current.expression.text === 'pikkuPermissionFactory' ||
-        current.expression.text === 'addPermission' ||
+        current.expression.text === 'addTagPermission' ||
         current.expression.text === 'addHTTPPermission')
     ) {
       return true
@@ -338,9 +338,9 @@ export const addPermission: AddWiring = (logger, node, checker, state) => {
 
   // Handle addPermission('tag', [permission1, permission2])
   // Supports two patterns:
-  // 1. export const x = () => addPermission('tag', [...])  (factory - tree-shakeable)
-  // 2. export const x = addPermission('tag', [...])  (direct - no tree-shaking)
-  if (expression.text === 'addPermission') {
+  // 1. export const x = () => addTagPermission('tag', [...])  (factory - tree-shakeable)
+  // 2. export const x = addTagPermission('tag', [...])  (direct - no tree-shaking)
+  if (expression.text === 'addTagPermission') {
     const tagArg = args[0]
     const permissionsArrayArg = args[1]
 
@@ -353,7 +353,7 @@ export const addPermission: AddWiring = (logger, node, checker, state) => {
     }
 
     if (!tag) {
-      logger.warn(`• addPermission call without valid tag string`)
+      logger.warn(`• addTagPermission call without valid tag string`)
       return
     }
 
@@ -363,7 +363,7 @@ export const addPermission: AddWiring = (logger, node, checker, state) => {
       !ts.isObjectLiteralExpression(permissionsArrayArg)
     ) {
       logger.error(
-        `• addPermission('${tag}', ...) must have a literal array or object as second argument`
+        `• addTagPermission('${tag}', ...) must have a literal array or object as second argument`
       )
       return
     }
@@ -416,7 +416,7 @@ export const addPermission: AddWiring = (logger, node, checker, state) => {
     if (!isFactory && exportedName) {
       logger.warn(
         `• Permission group '${exportedName}' for tag '${tag}' is not wrapped in a factory function. ` +
-          `For tree-shaking, use: export const ${exportedName} = () => addPermission('${tag}', [...])`
+          `For tree-shaking, use: export const ${exportedName} = () => addTagPermission('${tag}', [...])`
       )
     }
 

package/src/add/add-schedule.ts

@@ -73,7 +73,11 @@ export const addSchedule: AddWiring = (
     }
 
     const packageName = ts.isIdentifier(funcInitializer)
-      ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+      ? resolveAddonName(
+          funcInitializer,
+          checker,
+          state.rpc.wireAddonDeclarations
+        )
       : null
 
     if (!nameValue || !scheduleValue) {

package/src/add/add-workflow-graph.ts

@@ -357,6 +357,8 @@ function extractGraphFromNewFormat(
       input: {},
       next: undefined,
       onError: undefined,
+      retries: undefined,
+      retryDelay: undefined,
     }
   }
 
@@ -382,6 +384,8 @@ function extractGraphFromNewFormat(
           nodes[nodeId].next = nodeConfig.next
           nodes[nodeId].onError = nodeConfig.onError
           nodes[nodeId].input = nodeConfig.input
+          nodes[nodeId].retries = nodeConfig.retries
+          nodes[nodeId].retryDelay = nodeConfig.retryDelay
         }
       }
     }
@@ -400,10 +404,14 @@ function extractNodeConfigFromObject(
   next: any
   onError: any
   input: Record<string, any>
+  retries: number | undefined
+  retryDelay: string | number | undefined
 } {
   let next: any = undefined
   let onError: any = undefined
   let input: Record<string, any> = {}
+  let retries: number | undefined = undefined
+  let retryDelay: string | number | undefined = undefined
 
   for (const prop of obj.properties) {
     if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue
@@ -416,10 +424,20 @@ function extractNodeConfigFromObject(
       onError = extractNextConfig(prop.initializer, checker)
     } else if (propName === 'input') {
       input = extractInputMapping(prop.initializer, checker)
+    } else if (propName === 'retries') {
+      if (ts.isNumericLiteral(prop.initializer)) {
+        retries = Number(prop.initializer.text)
+      }
+    } else if (propName === 'retryDelay') {
+      if (ts.isNumericLiteral(prop.initializer)) {
+        retryDelay = Number(prop.initializer.text)
+      } else if (ts.isStringLiteral(prop.initializer)) {
+        retryDelay = prop.initializer.text
+      }
     }
   }
 
-  return { next, onError, input }
+  return { next, onError, input, retries, retryDelay }
 }
 
 /**

package/src/add/wire-name-literal.test.ts

@@ -0,0 +1,114 @@
+import { strict as assert } from 'assert'
+import { describe, test } from 'node:test'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { inspect } from '../inspector.js'
+import { ErrorCode } from '../error-codes.js'
+import type { InspectorLogger } from '../types.js'
+
+const makeLogger = (criticals: Array<{ code: ErrorCode; message: string }>) =>
+  ({
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    critical: (code: ErrorCode, message: string) => {
+      criticals.push({ code, message })
+    },
+    hasCriticalErrors: () => criticals.length > 0,
+  }) satisfies InspectorLogger
+
+describe('wiring name must be a string literal', () => {
+  test('logs a critical error when a queue worker name is a const reference', async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-nonliteral-name-'))
+    const file = join(rootDir, 'queue.ts')
+
+    await writeFile(
+      file,
+      [
+        "import { pikkuSessionlessFunc, wireQueueWorker } from '@pikku/core'",
+        'const QUEUE_NAME = "stripe-webhook-event"',
+        'export const handler = pikkuSessionlessFunc({',
+        '  func: async () => ({ ok: true })',
+        '})',
+        'wireQueueWorker({',
+        '  name: QUEUE_NAME,',
+        '  func: handler,',
+        '})',
+      ].join('\n')
+    )
+
+    const criticals: Array<{ code: ErrorCode; message: string }> = []
+    try {
+      await inspect(makeLogger(criticals), [file], { rootDir })
+      const hit = criticals.find(
+        (entry) => entry.code === ErrorCode.NON_LITERAL_WIRE_NAME
+      )
+      assert.ok(hit, 'expected NON_LITERAL_WIRE_NAME critical')
+      assert.match(hit!.message, /QUEUE_NAME/)
+    } finally {
+      await rm(rootDir, { recursive: true, force: true })
+    }
+  })
+
+  test('logs a critical error when a secret id is a const reference', async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-nonliteral-secret-'))
+    const file = join(rootDir, 'secret.ts')
+
+    await writeFile(
+      file,
+      [
+        "import { wireSecret } from '@pikku/core'",
+        'const SECRET_ID = "STRIPE_SECRET_KEY"',
+        'wireSecret({',
+        '  secretId: SECRET_ID,',
+        "  name: 'Stripe secret key',",
+        "  displayName: 'Stripe secret key',",
+        '})',
+      ].join('\n')
+    )
+
+    const criticals: Array<{ code: ErrorCode; message: string }> = []
+    try {
+      await inspect(makeLogger(criticals), [file], { rootDir })
+      const hit = criticals.find(
+        (entry) => entry.code === ErrorCode.NON_LITERAL_WIRE_NAME
+      )
+      assert.ok(hit, 'expected NON_LITERAL_WIRE_NAME critical')
+      assert.match(hit!.message, /SECRET_ID/)
+    } finally {
+      await rm(rootDir, { recursive: true, force: true })
+    }
+  })
+
+  test('does not flag a queue worker whose name is an inline literal', async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-literal-name-'))
+    const file = join(rootDir, 'queue.ts')
+
+    await writeFile(
+      file,
+      [
+        "import { pikkuSessionlessFunc, wireQueueWorker } from '@pikku/core'",
+        'export const handler = pikkuSessionlessFunc({',
+        '  func: async () => ({ ok: true })',
+        '})',
+        'wireQueueWorker({',
+        "  name: 'stripe-webhook-event',",
+        '  func: handler,',
+        '})',
+      ].join('\n')
+    )
+
+    const criticals: Array<{ code: ErrorCode; message: string }> = []
+    try {
+      await inspect(makeLogger(criticals), [file], { rootDir })
+      const hit = criticals.find(
+        (entry) => entry.code === ErrorCode.NON_LITERAL_WIRE_NAME
+      )
+      assert.equal(hit, undefined)
+    } finally {
+      await rm(rootDir, { recursive: true, force: true })
+    }
+  })
+})

package/src/error-codes.ts

@@ -10,6 +10,7 @@
 export enum ErrorCode {
   // Validation errors
   MISSING_NAME = 'PKU111',
+  NON_LITERAL_WIRE_NAME = 'PKU118',
   MISSING_DESCRIPTION = 'PKU123',
   INVALID_VALUE = 'PKU124',
   MISSING_URI = 'PKU220',

package/src/index.ts

@@ -9,6 +9,7 @@ export {
 } from './utils/serialize-inspector-state.js'
 export type { SerializableInspectorState } from './utils/serialize-inspector-state.js'
 export { filterInspectorState } from './utils/filter-inspector-state.js'
+export { resolveDeployTarget } from './utils/resolve-deploy-target.js'
 export {
   generateCustomTypes,
   sanitizeTypeName,

package/src/inspector.ts

@@ -12,7 +12,6 @@ import { findCommonAncestor } from './utils/find-root-dir.js'
 import {
   aggregateRequiredServices,
   validateAgentModels,
-  validateAgentOverrides,
   validateSecretOverrides,
   validateVariableOverrides,
   validateCredentialOverrides,
@@ -250,8 +249,6 @@ export const inspect = async (
   const rootDir = options.rootDir || findCommonAncestor(routeFiles)
 
   const startSourceFiles = performance.now()
-  // Filter source files to only include files within the project rootDir
-  // This prevents picking up types from external packages (including workspace symlinks)
   const sourceFiles = program
     .getSourceFiles()
     .filter((sf) => sf.fileName.startsWith(rootDir))
@@ -354,8 +351,7 @@ export const inspect = async (
       )
     }
 
-    validateAgentModels(logger, state, options.modelConfig)
-    validateAgentOverrides(logger, state, options.modelConfig)
+    validateAgentModels(logger, state)
     validateSecretOverrides(logger, state)
     validateVariableOverrides(logger, state)
     validateCredentialOverrides(logger, state)

package/src/types.ts

@@ -179,10 +179,28 @@ export interface InspectorPermissionState {
 export type InspectorFilters = {
   names?: string[] // Wildcard support: "email-*" matches "email-worker", "email-sender"
   tags?: string[]
-  types?: string[]
+  wires?: string[]
   directories?: string[]
   httpRoutes?: string[] // HTTP route patterns: "/api/*", "/webhooks/*"
   httpMethods?: string[] // HTTP methods: "GET", "POST", "DELETE", etc.
+
+  excludeNames?: string[]
+  excludeTags?: string[]
+  excludeWires?: string[]
+  excludeDirectories?: string[]
+  excludeHttpRoutes?: string[]
+  excludeHttpMethods?: string[]
+
+  // Keep only functions whose effective deploy target is in this list.
+  // A function's effective target is its explicit `deploy` field, or
+  // 'server' if any of its services are listed in `serverlessIncompatible`,
+  // otherwise 'serverless'.
+  target?: Array<'serverless' | 'server'>
+  excludeTarget?: Array<'serverless' | 'server'>
+  // Service names that, when consumed by a function, force its target
+  // to 'server'. Sourced from `pikku.config.json` →
+  // `deploy.serverlessIncompatible`. Used only when deploy filters are set.
+  serverlessIncompatible?: string[]
 }
 
 export type AddonConfig = {
@@ -192,19 +210,6 @@ export type AddonConfig = {
   forceInclude?: boolean
 }
 
-export type ModelConfigEntry =
-  | string
-  | { model: string; temperature?: number; maxSteps?: number }
-
-export type InspectorModelConfig = {
-  models?: Record<string, ModelConfigEntry>
-  agentDefaults?: { temperature?: number; maxSteps?: number }
-  agentOverrides?: Record<
-    string,
-    { model?: string; temperature?: number; maxSteps?: number }
-  >
-}
-
 export type InspectorOptions = Partial<{
   setupOnly: boolean
   rootDir: string
@@ -225,7 +230,6 @@ export type InspectorOptions = Partial<{
   }
   tags: string[]
   manifest: VersionManifest
-  modelConfig: InspectorModelConfig
   oldProgram: ts.Program | undefined
 }>
 

package/src/utils/extract-function-name.ts

@@ -444,6 +444,14 @@ export function extractFunctionName(
   }
 
   if (result.version !== null) {
+    // Strip trailing VN suffix if it matches the version (e.g. createCardV1 + version:1 → createCard@v1)
+    const vSuffix = `V${result.version}`
+    if (
+      result.pikkuFuncId.endsWith(vSuffix) &&
+      result.pikkuFuncId.length > vSuffix.length
+    ) {
+      result.pikkuFuncId = result.pikkuFuncId.slice(0, -vSuffix.length)
+    }
     result.pikkuFuncId = formatVersionedId(result.pikkuFuncId, result.version)
   }