@pikku/inspector 0.12.0 → 0.12.2

package/src/add/add-rpc-invocations.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript'
-import { InspectorState, InspectorLogger } from '../types.js'
+import type { InspectorState, InspectorLogger } from '../types.js'
 
 /**
  * Helper to extract namespace from a namespaced function reference like 'ext:hello'
@@ -14,31 +14,31 @@ function extractNamespace(functionRef: string): string | null {
 
 /**
  * Scan for rpc.invoke() calls to track which functions are actually being invoked
- * Also detects external package usage via:
+ * Also detects addon usage via:
  * - Namespaced calls: rpc.invoke('namespace:function')
- * - External helper: external('namespace:function')
+ * - Addon helper: addon('namespace:function')
  */
 export function addRPCInvocations(
   node: ts.Node,
   state: InspectorState,
   logger: InspectorLogger
 ) {
-  // Look for call expressions: external('ext:hello') or rpc.invoke('...')
+  // Look for call expressions: addon('ext:hello') or rpc.invoke('...')
   if (ts.isCallExpression(node)) {
     const { expression, arguments: args } = node
 
-    // Check for external('namespace:function') calls
-    if (ts.isIdentifier(expression) && expression.text === 'external') {
+    // Check for addon('namespace:function') calls
+    if (ts.isIdentifier(expression) && expression.text === 'addon') {
       const [firstArg] = args
       if (firstArg && ts.isStringLiteral(firstArg)) {
         const functionRef = firstArg.text
-        logger.debug(`• Found external() call: ${functionRef}`)
+        logger.debug(`• Found addon() call: ${functionRef}`)
         state.rpc.invokedFunctions.add(functionRef)
 
         const namespace = extractNamespace(functionRef)
         if (namespace) {
-          logger.debug(`  → External package detected: ${namespace}`)
-          state.rpc.usedExternalPackages.add(namespace)
+          logger.debug(`  → Addon detected: ${namespace}`)
+          state.rpc.usedAddons.add(namespace)
         }
       }
     }
@@ -76,8 +76,8 @@ export function addRPCInvocations(
 
           const namespace = extractNamespace(functionRef)
           if (namespace) {
-            logger.debug(`  → External package detected: ${namespace}`)
-            state.rpc.usedExternalPackages.add(namespace)
+            logger.debug(`  → Addon detected: ${namespace}`)
+            state.rpc.usedAddons.add(namespace)
           }
         }
         // Handle template literals like `function-${name}`

package/src/add/add-schedule.ts

@@ -3,7 +3,7 @@ import {
   getPropertyValue,
   getCommonWireMetaData,
 } from '../utils/get-property-value.js'
-import { AddWiring } from '../types.js'
+import type { AddWiring } from '../types.js'
 import {
   extractFunctionName,
   makeContextBasedId,

package/src/add/add-secret.ts

@@ -3,7 +3,7 @@ import {
   getPropertyValue,
   getArrayPropertyValue,
 } from '../utils/get-property-value.js'
-import { AddWiring } from '../types.js'
+import type { AddWiring } from '../types.js'
 import { ErrorCode } from '../error-codes.js'
 import { createAddKeyedWiring } from './add-keyed-wiring.js'
 

package/src/add/add-trigger.ts

@@ -3,7 +3,7 @@ import {
   getPropertyValue,
   getCommonWireMetaData,
 } from '../utils/get-property-value.js'
-import { AddWiring } from '../types.js'
+import type { AddWiring } from '../types.js'
 import {
   extractFunctionName,
   makeContextBasedId,
@@ -11,7 +11,7 @@ import {
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
 import { resolveMiddleware } from '../utils/middleware.js'
 import { extractWireNames } from '../utils/post-process.js'
-import { resolveExternalPackageName } from '../utils/resolve-external-package.js'
+import { resolveAddonName } from '../utils/resolve-addon-package.js'
 
 import { ErrorCode } from '../error-codes.js'
 export const addTrigger: AddWiring = (
@@ -138,10 +138,10 @@ const addWireTriggerSource: (
   }
 
   if (ts.isIdentifier(funcInitializer)) {
-    const packageName = resolveExternalPackageName(
+    const packageName = resolveAddonName(
       funcInitializer,
       checker,
-      options.externalPackages
+      state.rpc.wireAddonDeclarations
     )
     state.triggers.sourceMeta[nameValue] = {
       name: nameValue,

package/src/add/add-wire-addon.ts

@@ -0,0 +1,80 @@
+import * as ts from 'typescript'
+import type { InspectorState, InspectorLogger } from '../types.js'
+
+function parseStringRecord(
+  obj: ts.ObjectLiteralExpression
+): Record<string, string> {
+  const result: Record<string, string> = {}
+  for (const prop of obj.properties) {
+    if (!ts.isPropertyAssignment(prop)) continue
+    const keyNode = prop.name
+    const key = ts.isIdentifier(keyNode)
+      ? keyNode.text
+      : ts.isStringLiteral(keyNode)
+        ? keyNode.text
+        : undefined
+    if (key && ts.isStringLiteral(prop.initializer)) {
+      result[key] = prop.initializer.text
+    }
+  }
+  return result
+}
+
+/**
+ * Detect wireAddon({ name: '...', package: '...' }) call expressions and
+ * populate state.rpc.wireAddonDeclarations and state.rpc.usedAddons.
+ */
+export function addWireAddon(
+  node: ts.Node,
+  state: InspectorState,
+  logger: InspectorLogger
+) {
+  if (!ts.isCallExpression(node)) return
+
+  const { expression, arguments: args } = node
+  if (!ts.isIdentifier(expression) || expression.text !== 'wireAddon') return
+
+  const [firstArg] = args
+  if (!firstArg || !ts.isObjectLiteralExpression(firstArg)) return
+
+  let name: string | undefined
+  let pkg: string | undefined
+  let rpcEndpoint: string | undefined
+  let secretOverrides: Record<string, string> | undefined
+  let variableOverrides: Record<string, string> | undefined
+
+  for (const prop of firstArg.properties) {
+    if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue
+
+    const key = prop.name.text
+    if (key === 'name' && ts.isStringLiteral(prop.initializer)) {
+      name = prop.initializer.text
+    } else if (key === 'package' && ts.isStringLiteral(prop.initializer)) {
+      pkg = prop.initializer.text
+    } else if (key === 'rpcEndpoint' && ts.isStringLiteral(prop.initializer)) {
+      rpcEndpoint = prop.initializer.text
+    } else if (
+      key === 'secretOverrides' &&
+      ts.isObjectLiteralExpression(prop.initializer)
+    ) {
+      secretOverrides = parseStringRecord(prop.initializer)
+    } else if (
+      key === 'variableOverrides' &&
+      ts.isObjectLiteralExpression(prop.initializer)
+    ) {
+      variableOverrides = parseStringRecord(prop.initializer)
+    }
+  }
+
+  if (!name || !pkg) return
+
+  logger.debug(`• Found wireAddon: ${name} → ${pkg}`)
+  state.rpc.wireAddonDeclarations.set(name, {
+    package: pkg,
+    rpcEndpoint,
+    secretOverrides,
+    variableOverrides,
+  })
+  state.rpc.usedAddons.add(name)
+  state.rpc.wireAddonFiles.add(node.getSourceFile().fileName)
+}

package/src/add/add-workflow.ts

@@ -1,9 +1,9 @@
 import * as ts from 'typescript'
-import { AddWiring, InspectorState } from '../types.js'
+import type { AddWiring, InspectorState } from '../types.js'
 import { extractFunctionName } from '../utils/extract-function-name.js'
 import { extractFunctionNode } from '../utils/extract-function-node.js'
 import { ErrorCode } from '../error-codes.js'
-import { WorkflowStepMeta, WorkflowContext } from '@pikku/core/workflow'
+import type { WorkflowStepMeta, WorkflowContext } from '@pikku/core/workflow'
 import {
   extractStringLiteral,
   isStringLike,

package/src/error-codes.ts

@@ -39,6 +39,7 @@ export enum ErrorCode {
   // HTTP Route errors
   ROUTE_PARAM_MISMATCH = 'PKU571',
   ROUTE_QUERY_MISMATCH = 'PKU572',
+  AUTH_DISABLED_REQUIRES_SESSIONLESS = 'PKU573',
 
   // Middleware/Permission errors
   MIDDLEWARE_HANDLER_INVALID = 'PKU685',

package/src/index.ts

@@ -19,6 +19,7 @@ export {
 } from './utils/contract-hashes.js'
 export type {
   ContractEntry,
+  VersionHashEntry,
   VersionValidateError,
   VersionManifest,
   VersionManifestEntry,

package/src/inspector.ts

@@ -2,14 +2,19 @@ import * as ts from 'typescript'
 import { performance } from 'perf_hooks'
 import { visitSetup, visitRoutes } from './visit.js'
 import { TypesMap } from './types-map.js'
-import { InspectorState, InspectorLogger, InspectorOptions } from './types.js'
+import type {
+  InspectorState,
+  InspectorLogger,
+  InspectorOptions,
+} from './types.js'
 import { getFilesAndMethods } from './utils/get-files-and-methods.js'
 import { findCommonAncestor } from './utils/find-root-dir.js'
 import {
   aggregateRequiredServices,
-  validateSecretOverrides,
   validateAgentModels,
   validateAgentOverrides,
+  validateSecretOverrides,
+  validateVariableOverrides,
   computeResolvedIOTypes,
   computeMiddlewareGroupsMeta,
   computePermissionsGroupsMeta,
@@ -17,7 +22,7 @@ import {
   computeDiagnostics,
 } from './utils/post-process.js'
 import { generateOpenAPISpec } from './utils/serialize-openapi-json.js'
-import { pikkuState } from '@pikku/core'
+import { pikkuState } from '@pikku/core/internal'
 import { resolveLatestVersions } from './utils/resolve-versions.js'
 import { finalizeWorkflows } from './utils/workflow/graph/finalize-workflows.js'
 import {
@@ -78,6 +83,10 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
       files: new Set(),
       meta: {},
     },
+    gateways: {
+      meta: {},
+      files: new Set(),
+    },
     triggers: {
       meta: {},
       sourceMeta: {},
@@ -104,7 +113,9 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
       exposedMeta: {},
       exposedFiles: new Map(),
       invokedFunctions: new Set(),
-      usedExternalPackages: new Set(),
+      usedAddons: new Set(),
+      wireAddonDeclarations: new Map(),
+      wireAddonFiles: new Set(),
     },
     mcpEndpoints: {
       resourcesMeta: {},
@@ -312,9 +323,10 @@ export const inspect = async (
       )
     }
 
-    validateSecretOverrides(logger, state, options.externalPackages)
     validateAgentModels(logger, state, options.modelConfig)
     validateAgentOverrides(logger, state, options.modelConfig)
+    validateSecretOverrides(logger, state)
+    validateVariableOverrides(logger, state)
   }
 
   return state

package/src/types.ts

@@ -1,25 +1,30 @@
-import * as ts from 'typescript'
-import { ChannelsMeta } from '@pikku/core/channel'
-import { HTTPWiringsMeta } from '@pikku/core/http'
-import { ScheduledTasksMeta } from '@pikku/core/scheduler'
-import { TriggerMeta, TriggerSourceMeta } from '@pikku/core/trigger'
-import { QueueWorkersMeta } from '@pikku/core/queue'
-import { WorkflowsMeta } from '@pikku/core/workflow'
-import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp'
-import { AIAgentMeta } from '@pikku/core/ai-agent'
-import { CLIMeta } from '@pikku/core/cli'
-import { NodesMeta } from '@pikku/core/node'
-import { SecretDefinitions } from '@pikku/core/secret'
-import { VariableDefinitions } from '@pikku/core/variable'
-import { TypesMap } from './types-map.js'
-import {
+import type * as ts from 'typescript'
+import type { ChannelsMeta } from '@pikku/core/channel'
+import type { GatewaysMeta } from '@pikku/core/gateway'
+import type { HTTPWiringsMeta } from '@pikku/core/http'
+import type { ScheduledTasksMeta } from '@pikku/core/scheduler'
+import type { TriggerMeta, TriggerSourceMeta } from '@pikku/core/trigger'
+import type { QueueWorkersMeta } from '@pikku/core/queue'
+import type { WorkflowsMeta } from '@pikku/core/workflow'
+import type {
+  MCPResourceMeta,
+  MCPToolMeta,
+  MCPPromptMeta,
+} from '@pikku/core/mcp'
+import type { AIAgentMeta } from '@pikku/core/ai-agent'
+import type { CLIMeta } from '@pikku/core/cli'
+import type { NodesMeta } from '@pikku/core/node'
+import type { SecretDefinitions } from '@pikku/core/secret'
+import type { VariableDefinitions } from '@pikku/core/variable'
+import type { TypesMap } from './types-map.js'
+import type {
   FunctionsMeta,
   FunctionServicesMeta,
   FunctionWiresMeta,
   JSONValue,
 } from '@pikku/core'
 import type { OpenAPISpecInfo } from './utils/serialize-openapi-json.js'
-import { ErrorCode } from './error-codes.js'
+import type { ErrorCode } from './error-codes.js'
 import type {
   VersionManifest,
   VersionValidateError,
@@ -170,7 +175,7 @@ export type InspectorFilters = {
   httpMethods?: string[] // HTTP methods: "GET", "POST", "DELETE", etc.
 }
 
-export type ExternalPackageConfig = {
+export type AddonConfig = {
   package: string
   rpcEndpoint?: string
   secretOverrides?: Record<string, string>
@@ -193,14 +198,13 @@ export type InspectorModelConfig = {
 export type InspectorOptions = Partial<{
   setupOnly: boolean
   rootDir: string
-  isExternalPackage: boolean
+  isAddon: boolean
   types: Partial<{
     configFileType: string
     userSessionType: string
     singletonServicesFactoryType: string
     wireServicesFactoryType: string
   }>
-  externalPackages: Record<string, ExternalPackageConfig>
   schemaConfig: {
     tsconfig: string
     schemasFromTypes?: string[]
@@ -300,6 +304,10 @@ export interface InspectorState {
   http: InspectorHTTPState
   functions: InspectorFunctionState
   channels: InspectorChannelState
+  gateways: {
+    meta: GatewaysMeta
+    files: Set<string>
+  }
   triggers: {
     meta: TriggerMeta
     sourceMeta: TriggerSourceMeta
@@ -326,7 +334,17 @@ export interface InspectorState {
     exposedMeta: Record<string, string>
     exposedFiles: Map<string, { path: string; exportedName: string }>
     invokedFunctions: Set<string>
-    usedExternalPackages: Set<string>
+    usedAddons: Set<string>
+    wireAddonDeclarations: Map<
+      string,
+      {
+        package: string
+        rpcEndpoint?: string
+        secretOverrides?: Record<string, string>
+        variableOverrides?: Record<string, string>
+      }
+    >
+    wireAddonFiles: Set<string>
   }
   mcpEndpoints: {
     resourcesMeta: MCPResourceMeta

package/src/utils/compute-required-schemas.ts

@@ -22,7 +22,7 @@ export function computeRequiredSchemas(
 ): Set<string> {
   return new Set<string>([
     ...Object.values(functionsMeta)
-      .map(({ inputs, outputs }) => {
+      .flatMap(({ inputs, outputs }) => {
         const types: (string | undefined)[] = []
         if (inputs?.[0]) {
           try {
@@ -40,7 +40,6 @@ export function computeRequiredSchemas(
         }
         return types
       })
-      .flat()
       .filter((s): s is string => !!s && !PRIMITIVE_TYPES.has(s)),
     ...typesMap.customTypes.keys(),
     ...(additionalTypes || []),

package/src/utils/contract-hashes.test.ts

@@ -16,12 +16,22 @@ import { ErrorCode } from '../error-codes.js'
 function makeContracts(
   entries: Record<
     string,
-    { functionKey: string; version: number; contractHash: string }
+    {
+      functionKey: string
+      version: number
+      contractHash: string
+      inputHash?: string
+      outputHash?: string
+    }
   >
 ): Map<string, ContractEntry> {
   const map = new Map<string, ContractEntry>()
   for (const [id, entry] of Object.entries(entries)) {
-    map.set(id, entry)
+    map.set(id, {
+      ...entry,
+      inputHash: entry.inputHash ?? entry.contractHash.slice(0, 8),
+      outputHash: entry.outputHash ?? entry.contractHash.slice(0, 8),
+    })
   }
   return map
 }
@@ -414,11 +424,16 @@ describe('updateManifest', () => {
         functionKey: 'createUser',
         version: 1,
         contractHash: 'abc',
+        inputHash: 'in123456',
+        outputHash: 'out1234',
       },
     })
     const result = updateManifest(manifest, contracts)
     assert.strictEqual(result.contracts.createUser.latest, 1)
-    assert.strictEqual(result.contracts.createUser.versions['1'], 'abc')
+    assert.deepStrictEqual(result.contracts.createUser.versions['1'], {
+      inputHash: 'in123456',
+      outputHash: 'out1234',
+    })
   })
 
   test('adds new version to existing function and updates latest', () => {
@@ -433,17 +448,27 @@ describe('updateManifest', () => {
         functionKey: 'createUser',
         version: 1,
         contractHash: 'aaa',
+        inputHash: 'inaaa123',
+        outputHash: 'outaaa12',
       },
       'createUser@v2': {
         functionKey: 'createUser',
         version: 2,
         contractHash: 'bbb',
+        inputHash: 'inbbb123',
+        outputHash: 'outbbb12',
       },
     })
     const result = updateManifest(manifest, contracts)
     assert.strictEqual(result.contracts.createUser.latest, 2)
-    assert.strictEqual(result.contracts.createUser.versions['2'], 'bbb')
-    assert.strictEqual(result.contracts.createUser.versions['1'], 'aaa')
+    assert.deepStrictEqual(result.contracts.createUser.versions['2'], {
+      inputHash: 'inbbb123',
+      outputHash: 'outbbb12',
+    })
+    assert.deepStrictEqual(result.contracts.createUser.versions['1'], {
+      inputHash: 'inaaa123',
+      outputHash: 'outaaa12',
+    })
   })
 
   test('preserves deleted functions', () => {