@pikku/inspector 0.12.10 → 0.12.12

package/src/utils/filter-utils.ts

@@ -61,7 +61,8 @@ export const matchesFilters = (
   if (
     (!filters.names || filters.names.length === 0) &&
     (!filters.tags || filters.tags.length === 0) &&
-    (!filters.types || filters.types.length === 0) &&
+    (!filters.wires || filters.wires.length === 0) &&
+    (!filters.excludeWires || filters.excludeWires.length === 0) &&
     (!filters.directories || filters.directories.length === 0) &&
     (!filters.httpRoutes || filters.httpRoutes.length === 0) &&
     (!filters.httpMethods || filters.httpMethods.length === 0)
@@ -69,10 +70,18 @@ export const matchesFilters = (
     return true
   }
 
-  // Check type filter
-  if (filters.types && filters.types.length > 0) {
-    if (!filters.types.includes(meta.type)) {
-      logger.debug(`⒡ Filtered by type: ${meta.type}:${meta.name}`)
+  // Check wire include filter
+  if (filters.wires && filters.wires.length > 0) {
+    if (!filters.wires.includes(meta.type)) {
+      logger.debug(`⒡ Filtered by wire include: ${meta.type}:${meta.name}`)
+      return false
+    }
+  }
+
+  // Check wire exclude filter
+  if (filters.excludeWires && filters.excludeWires.length > 0) {
+    if (filters.excludeWires.includes(meta.type)) {
+      logger.debug(`⒡ Filtered by wire exclude: ${meta.type}:${meta.name}`)
       return false
     }
   }

package/src/utils/get-property-value.ts

@@ -27,6 +27,44 @@ export const getArrayPropertyValue = (
   return null
 }
 
+/**
+ * Wiring identity fields (`name`, `secretId`, `variableId`, …) are read
+ * STATICALLY from source — a const or variable reference is keyed by its
+ * identifier text, not its runtime value, so the wiring is silently skipped at
+ * runtime (`metadata not found`). If the named property exists but is not an
+ * inline literal, raise a fatal diagnostic so the build fails instead.
+ */
+export const assertStringLiteralProperty = (
+  obj: ts.ObjectLiteralExpression,
+  propertyName: string,
+  wiringType: string,
+  logger?: { critical: (code: ErrorCode, message: string) => void }
+): void => {
+  const property = obj.properties.find(
+    (p) =>
+      ts.isPropertyAssignment(p) &&
+      ts.isIdentifier(p.name) &&
+      p.name.text === propertyName
+  )
+  if (!property || !ts.isPropertyAssignment(property)) {
+    return
+  }
+  const init = property.initializer
+  const isStaticLiteral =
+    ts.isStringLiteral(init) ||
+    ts.isNoSubstitutionTemplateLiteral(init) ||
+    ts.isNumericLiteral(init)
+  if (isStaticLiteral) {
+    return
+  }
+  const errorMsg = `${wiringType} has a non-literal '${propertyName}': \`${init.getText()}\`. Wiring identity fields must be inline string literals — the inspector reads them statically from source, so a const or variable reference is keyed by its identifier text and the wiring is silently skipped at runtime. Inline the literal instead, e.g. ${propertyName}: 'my-wiring-name'.`
+  if (logger) {
+    logger.critical(ErrorCode.NON_LITERAL_WIRE_NAME, errorMsg)
+  } else {
+    console.error(errorMsg)
+  }
+}
+
 export const getPropertyValue = (
   obj: ts.ObjectLiteralExpression,
   propertyName: string
@@ -117,6 +155,8 @@ export const getCommonWireMetaData = (
     errors?: string[]
   } = {}
 
+  assertStringLiteralProperty(obj, 'name', wiringType, logger)
+
   obj.properties.forEach((prop) => {
     if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
       const propName = prop.name.text

package/src/utils/post-process.ts

@@ -2,7 +2,6 @@ import type {
   InspectorState,
   InspectorLogger,
   InspectorOptions,
-  InspectorModelConfig,
   MiddlewareGroupMeta,
   InspectorDiagnostic,
 } from '../types.js'
@@ -538,11 +537,8 @@ export function computeRequiredSchemas(
 
 export function validateAgentModels(
   logger: InspectorLogger,
-  state: InspectorState | Omit<InspectorState, 'typesLookup'>,
-  modelConfig?: InspectorModelConfig
+  state: InspectorState | Omit<InspectorState, 'typesLookup'>
 ): void {
-  const aliases = modelConfig?.models ?? {}
-
   for (const [, meta] of Object.entries(state.agents.agentsMeta)) {
     const model = meta.model
     if (!model) {
@@ -552,41 +548,10 @@ export function validateAgentModels(
       )
       continue
     }
-    if (model.includes('/')) continue
-    if (!aliases[model]) {
-      const available = Object.keys(aliases)
-      logger.critical(
-        ErrorCode.INVALID_MODEL,
-        `AI agent '${meta.name}' uses model alias '${model}' which is not defined in pikku.config.json models. ` +
-          `Available aliases: ${available.join(', ') || 'none'}`
-      )
-    }
-  }
-}
-
-export function validateAgentOverrides(
-  logger: InspectorLogger,
-  state: InspectorState | Omit<InspectorState, 'typesLookup'>,
-  modelConfig?: InspectorModelConfig
-): void {
-  const overrides = modelConfig?.agentOverrides ?? {}
-  const aliases = modelConfig?.models ?? {}
-  const agentNames = new Set(
-    Object.values(state.agents.agentsMeta).map((m) => m.name)
-  )
-
-  for (const [agentName, override] of Object.entries(overrides)) {
-    if (!agentNames.has(agentName)) {
-      logger.warn(`agentOverrides references unknown agent '${agentName}'`)
-    }
-    if (
-      override.model &&
-      !override.model.includes('/') &&
-      !aliases[override.model]
-    ) {
+    if (!model.includes('/')) {
       logger.critical(
         ErrorCode.INVALID_MODEL,
-        `agentOverrides['${agentName}'].model uses alias '${override.model}' which is not defined in models.`
+        `AI agent '${meta.name}' uses model '${model}', which must be provider-qualified as '<provider>/<model>' (e.g. 'openai/gpt-4').`
       )
     }
   }

package/src/utils/resolve-addon-package.ts

@@ -1,13 +1,43 @@
 import * as ts from 'typescript'
+import { existsSync, readFileSync } from 'fs'
+import { dirname, join, parse } from 'path'
+
+const packageNameCache = new Map<string, string | null>()
+
+const findPackageNameForFile = (filePath: string): string | null => {
+  if (packageNameCache.has(filePath)) {
+    return packageNameCache.get(filePath)!
+  }
+  const root = parse(filePath).root
+  let dir = dirname(filePath)
+  while (dir && dir !== root) {
+    const pkgPath = join(dir, 'package.json')
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'))
+        const name = typeof pkg.name === 'string' ? pkg.name : null
+        packageNameCache.set(filePath, name)
+        return name
+      } catch {
+        packageNameCache.set(filePath, null)
+        return null
+      }
+    }
+    const parent = dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+  packageNameCache.set(filePath, null)
+  return null
+}
 
 /**
  * Resolve the addon package name from an imported identifier.
  * Checks if the identifier's import module specifier matches any
- * configured addon package.
- *
- * This is a general utility — any wire handler that processes a `func`
- * property can use it to detect when the function comes from an
- * addon package.
+ * configured addon package — and if the import is relative (because
+ * the identifier resolves to a source file inside the addon package
+ * itself), walks up to the nearest package.json to obtain the real
+ * package name.
  */
 export const resolveAddonName = (
   identifier: ts.Identifier,
@@ -31,18 +61,39 @@ export const resolveAddonName = (
   if (!sym) return null
 
   const decl = sym.declarations?.[0]
-  if (!decl || !ts.isImportSpecifier(decl)) return null
+  if (!decl) return null
+
+  let candidatePackage: string | null = null
 
-  // ImportSpecifier -> NamedImports -> ImportClause -> ImportDeclaration
-  const importDecl = decl.parent?.parent?.parent
-  if (!importDecl || !ts.isImportDeclaration(importDecl)) return null
-  if (!ts.isStringLiteral(importDecl.moduleSpecifier)) return null
+  if (ts.isImportSpecifier(decl)) {
+    // ImportSpecifier -> NamedImports -> ImportClause -> ImportDeclaration
+    const importDecl = decl.parent?.parent?.parent
+    if (
+      importDecl &&
+      ts.isImportDeclaration(importDecl) &&
+      ts.isStringLiteral(importDecl.moduleSpecifier)
+    ) {
+      candidatePackage = importDecl.moduleSpecifier.text
+    }
+  }
 
-  const moduleSpecifier = importDecl.moduleSpecifier.text
+  // Bare package import path
+  if (candidatePackage && !candidatePackage.startsWith('.')) {
+    for (const addonDecl of wireAddonDeclarations.values()) {
+      if (addonDecl.package === candidatePackage) return addonDecl.package
+    }
+  }
 
-  for (const addonDecl of wireAddonDeclarations.values()) {
-    if (addonDecl.package === moduleSpecifier) {
-      return addonDecl.package
+  // Fall back to package.json lookup based on the declaration's source file.
+  // This catches the case where the identifier resolves into an addon
+  // package's own internal source (relative import inside that package).
+  const declFile = decl.getSourceFile()?.fileName
+  if (declFile) {
+    const pkgName = findPackageNameForFile(declFile)
+    if (pkgName) {
+      for (const addonDecl of wireAddonDeclarations.values()) {
+        if (addonDecl.package === pkgName) return addonDecl.package
+      }
     }
   }
 

package/src/utils/resolve-deploy-target.test.ts

@@ -0,0 +1,105 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert'
+import {
+  IncompatibleDeployTargetError,
+  resolveDeployTarget,
+} from './resolve-deploy-target.js'
+
+describe('resolveDeployTarget', () => {
+  test('default → serverless', () => {
+    assert.strictEqual(resolveDeployTarget({}, new Set()), 'serverless')
+  })
+
+  test('explicit deploy: server → server', () => {
+    assert.strictEqual(
+      resolveDeployTarget({ deploy: 'server' }, new Set()),
+      'server'
+    )
+  })
+
+  test('explicit deploy: serverless with no incompatible svc → serverless', () => {
+    assert.strictEqual(
+      resolveDeployTarget(
+        { deploy: 'serverless', services: { services: ['kysely'] } as any },
+        new Set(['fs'])
+      ),
+      'serverless'
+    )
+  })
+
+  test('serverlessIncompatible service forces server even without deploy flag', () => {
+    assert.strictEqual(
+      resolveDeployTarget(
+        { services: { services: ['metaService'] } as any },
+        new Set(['metaService'])
+      ),
+      'server'
+    )
+  })
+
+  test('serverlessIncompatible takes precedence over explicit deploy: server', () => {
+    assert.strictEqual(
+      resolveDeployTarget(
+        {
+          deploy: 'server',
+          services: { services: ['metaService'] } as any,
+        },
+        new Set(['metaService'])
+      ),
+      'server'
+    )
+  })
+
+  test('explicit deploy: serverless + incompatible svc → throws', () => {
+    assert.throws(
+      () =>
+        resolveDeployTarget(
+          {
+            deploy: 'serverless',
+            services: { services: ['metaService', 'unrelated'] } as any,
+          },
+          new Set(['metaService']),
+          'myFunction'
+        ),
+      (err: unknown) => {
+        assert.ok(err instanceof IncompatibleDeployTargetError)
+        assert.strictEqual(err.functionName, 'myFunction')
+        assert.deepStrictEqual(err.incompatibleServices, ['metaService'])
+        assert.match(err.message, /serverless-incompatible/)
+        assert.match(err.message, /myFunction/)
+        return true
+      }
+    )
+  })
+
+  test('multiple incompatible services are all reported', () => {
+    assert.throws(
+      () =>
+        resolveDeployTarget(
+          {
+            deploy: 'serverless',
+            services: {
+              services: ['metaService', 'localContent'],
+            } as any,
+          },
+          new Set(['metaService', 'localContent']),
+          'multiSvc'
+        ),
+      (err: unknown) => {
+        assert.ok(err instanceof IncompatibleDeployTargetError)
+        assert.deepStrictEqual(err.incompatibleServices, [
+          'metaService',
+          'localContent',
+        ])
+        return true
+      }
+    )
+  })
+
+  test('handles funcMeta with no services field', () => {
+    assert.strictEqual(
+      resolveDeployTarget({ deploy: 'server' }, new Set(['metaService'])),
+      'server'
+    )
+  })
+})

package/src/utils/resolve-deploy-target.ts

@@ -0,0 +1,63 @@
+import type { FunctionMeta } from '@pikku/core'
+
+/**
+ * Thrown when a function's explicit `deploy: 'serverless'` conflicts
+ * with one of its services being declared `serverlessIncompatible`.
+ * The user has to either remove the explicit flag (let it auto-resolve
+ * to 'server'), or set `deploy: 'server'` explicitly.
+ */
+export class IncompatibleDeployTargetError extends Error {
+  constructor(
+    public readonly functionName: string,
+    public readonly incompatibleServices: string[]
+  ) {
+    super(
+      `Function '${functionName}' is declared deploy: 'serverless' but uses ` +
+        `serverless-incompatible service(s) [${incompatibleServices.join(', ')}]. ` +
+        `Either remove deploy: 'serverless' (will auto-resolve to 'server'), ` +
+        `or set deploy: 'server' explicitly.`
+    )
+    this.name = 'IncompatibleDeployTargetError'
+  }
+}
+
+/**
+ * Determine the effective deploy target for a function.
+ *
+ * Resolution order:
+ *   1. If any of the function's services is in `serverlessIncompatible`:
+ *      - throw if the function explicitly declares `deploy: 'serverless'`
+ *      - otherwise target is 'server'
+ *   2. Explicit `funcMeta.deploy: 'serverless' | 'server'`
+ *   3. Default 'serverless'
+ *
+ * Used both by the per-unit deploy analyzer (when bucketing functions
+ * into deployment units) and by `filterInspectorState` (when
+ * `pikku all --deploy <target>` is used to emit a target-scoped set
+ * of gen files).
+ */
+export function resolveDeployTarget(
+  funcMeta: Pick<FunctionMeta, 'deploy' | 'services'>,
+  serverlessIncompatible: Set<string>,
+  functionName = '<unknown>'
+): 'serverless' | 'server' {
+  // Service compatibility wins over the explicit flag — a serverless
+  // bundle of a function that needs (e.g.) node:fs would crash at runtime.
+  const incompatibleHits: string[] = []
+  if (funcMeta.services?.services) {
+    for (const svc of funcMeta.services.services) {
+      if (serverlessIncompatible.has(svc)) incompatibleHits.push(svc)
+    }
+  }
+
+  if (incompatibleHits.length > 0) {
+    if (funcMeta.deploy === 'serverless') {
+      throw new IncompatibleDeployTargetError(functionName, incompatibleHits)
+    }
+    return 'server'
+  }
+
+  if (funcMeta.deploy === 'server') return 'server'
+  if (funcMeta.deploy === 'serverless') return 'serverless'
+  return 'serverless'
+}

package/src/utils/resolve-versions.test.ts

@@ -387,4 +387,112 @@ describe('resolveLatestVersions', () => {
     assert.strictEqual(state.rpc.internalFiles.has('createUser'), false)
     assert.ok(state.rpc.internalFiles.has('createUser@v2'))
   })
+
+  test('rewrites CLI, channel, scheduler, queue and MCP funcId references when an unversioned function gets an implicit version', () => {
+    const state = makeState({
+      'listCards@v1': { pikkuFuncId: 'listCards@v1', version: 1 },
+      listCards: { pikkuFuncId: 'listCards' },
+    })
+    // CLI command (+ nested subcommand) referencing the unversioned function
+    state.cli = {
+      meta: {
+        programs: {
+          kanban: {
+            name: 'kanban',
+            commands: {
+              list: { pikkuFuncId: 'listCards' },
+              cards: {
+                pikkuFuncId: 'listCards',
+                subcommands: { all: { pikkuFuncId: 'listCards' } },
+              },
+            },
+          },
+        },
+        renderers: {},
+      },
+    } as any
+    // Channel slots + action-routed message wiring
+    state.channels = {
+      meta: {
+        cli: {
+          name: 'cli',
+          route: '/cli/kanban',
+          input: null,
+          connect: null,
+          disconnect: null,
+          message: { pikkuFuncId: 'listCards' },
+          messageWirings: {
+            command: { list: { pikkuFuncId: 'listCards' } },
+          },
+        },
+      },
+      files: new Set(),
+    } as any
+    state.scheduledTasks = {
+      meta: {
+        tick: { name: 'tick', schedule: '* * * * *', pikkuFuncId: 'listCards' },
+      },
+      files: new Set(),
+    } as any
+    state.queueWorkers = {
+      meta: { worker: { name: 'worker', pikkuFuncId: 'listCards' } },
+      files: new Set(),
+    } as any
+    state.mcpEndpoints = {
+      resourcesMeta: { res: { pikkuFuncId: 'listCards' } },
+      toolsMeta: { tool: { pikkuFuncId: 'listCards' } },
+      promptsMeta: { prompt: { pikkuFuncId: 'listCards' } },
+      files: new Set(),
+    } as any
+    state.triggers = {
+      meta: { cardCreated: { name: 'cardCreated' } },
+      sourceMeta: {
+        cardCreated: { name: 'cardCreated', pikkuFuncId: 'listCards' },
+      },
+      files: new Set(),
+    } as any
+    const { logger } = makeLogger()
+
+    resolveLatestVersions(state, logger)
+
+    // unversioned listCards becomes the implicit latest (v2)
+    assert.ok(state.functions.meta['listCards@v2'])
+    const program = (state as any).cli.meta.programs.kanban
+    assert.strictEqual(program.commands.list.pikkuFuncId, 'listCards@v2')
+    assert.strictEqual(program.commands.cards.pikkuFuncId, 'listCards@v2')
+    assert.strictEqual(
+      program.commands.cards.subcommands.all.pikkuFuncId,
+      'listCards@v2'
+    )
+    const channel = (state as any).channels.meta.cli
+    assert.strictEqual(channel.message.pikkuFuncId, 'listCards@v2')
+    assert.strictEqual(
+      channel.messageWirings.command.list.pikkuFuncId,
+      'listCards@v2'
+    )
+    assert.strictEqual(
+      (state as any).scheduledTasks.meta.tick.pikkuFuncId,
+      'listCards@v2'
+    )
+    assert.strictEqual(
+      (state as any).queueWorkers.meta.worker.pikkuFuncId,
+      'listCards@v2'
+    )
+    assert.strictEqual(
+      (state as any).mcpEndpoints.resourcesMeta.res.pikkuFuncId,
+      'listCards@v2'
+    )
+    assert.strictEqual(
+      (state as any).mcpEndpoints.toolsMeta.tool.pikkuFuncId,
+      'listCards@v2'
+    )
+    assert.strictEqual(
+      (state as any).mcpEndpoints.promptsMeta.prompt.pikkuFuncId,
+      'listCards@v2'
+    )
+    assert.strictEqual(
+      (state as any).triggers.sourceMeta.cardCreated.pikkuFuncId,
+      'listCards@v2'
+    )
+  })
 })

package/src/utils/resolve-versions.ts

@@ -1,4 +1,5 @@
 import { parseVersionedId, formatVersionedId } from '@pikku/core'
+import type { CLICommandMeta } from '@pikku/core/cli'
 import type { InspectorState, InspectorLogger } from '../types.js'
 import { ErrorCode } from '../error-codes.js'
 
@@ -130,6 +131,7 @@ function updateWiringReferences(
   oldId: string,
   newId: string
 ): void {
+  // HTTP routes
   if (state.http) {
     for (const methods of Object.values(state.http.meta)) {
       for (const meta of Object.values(methods)) {
@@ -139,4 +141,88 @@ function updateWiringReferences(
       }
     }
   }
+
+  // Channels: connect/disconnect/message slots + action-routed message wirings
+  if (state.channels) {
+    for (const channel of Object.values(state.channels.meta)) {
+      for (const slot of [
+        channel.connect,
+        channel.disconnect,
+        channel.message,
+      ]) {
+        if (slot && slot.pikkuFuncId === oldId) {
+          slot.pikkuFuncId = newId
+        }
+      }
+      for (const routes of Object.values(channel.messageWirings)) {
+        for (const message of Object.values(routes)) {
+          if (message.pikkuFuncId === oldId) {
+            message.pikkuFuncId = newId
+          }
+        }
+      }
+    }
+  }
+
+  // CLI programs: commands and nested subcommands. This also covers
+  // CLI-over-channel generation, which reads command funcIds from this meta.
+  if (state.cli) {
+    const updateCommands = (commands: Record<string, CLICommandMeta>): void => {
+      for (const command of Object.values(commands)) {
+        if (command.pikkuFuncId === oldId) {
+          command.pikkuFuncId = newId
+        }
+        if (command.subcommands) {
+          updateCommands(command.subcommands)
+        }
+      }
+    }
+    for (const program of Object.values(state.cli.meta.programs)) {
+      updateCommands(program.commands)
+    }
+  }
+
+  // Scheduled tasks
+  if (state.scheduledTasks) {
+    for (const task of Object.values(state.scheduledTasks.meta)) {
+      if (task.pikkuFuncId === oldId) {
+        task.pikkuFuncId = newId
+      }
+    }
+  }
+
+  // Queue workers
+  if (state.queueWorkers) {
+    for (const worker of Object.values(state.queueWorkers.meta)) {
+      if (worker.pikkuFuncId === oldId) {
+        worker.pikkuFuncId = newId
+      }
+    }
+  }
+
+  // Trigger sources (TriggerSourceMeta carries the handler's pikkuFuncId).
+  // Gateways/workflows/agents reference functions by bare rpc name and are
+  // resolved at runtime via state.rpc.internalMeta, so they need no rewrite here.
+  if (state.triggers) {
+    for (const source of Object.values(state.triggers.sourceMeta)) {
+      if (source.pikkuFuncId === oldId) {
+        source.pikkuFuncId = newId
+      }
+    }
+  }
+
+  // MCP resources, tools, and prompts
+  if (state.mcpEndpoints) {
+    for (const collection of [
+      state.mcpEndpoints.resourcesMeta,
+      state.mcpEndpoints.toolsMeta,
+      state.mcpEndpoints.promptsMeta,
+    ]) {
+      for (const endpoint of Object.values(collection)) {
+        if (endpoint.pikkuFuncId === oldId) {
+          endpoint.pikkuFuncId = newId
+        }
+      }
+    }
+  }
 }