@pikku/inspector 0.12.6 → 0.12.8

package/src/utils/filter-inspector-state.ts

@@ -191,6 +191,11 @@ export function filterInspectorState(
     return state
   }
 
+  // Snapshot the original workflow graph meta before filtering prunes it
+  const originalGraphMeta = {
+    ...((state as InspectorState).workflows?.graphMeta ?? {}),
+  }
+
   // Create a shallow copy with new Maps/Sets to avoid mutating the original
   const filteredState = {
     ...state,
@@ -201,11 +206,21 @@ export function filterInspectorState(
       usedMiddleware: new Set<string>(),
       usedPermissions: new Set<string>(),
     },
+    functions: {
+      ...state.functions,
+      meta: JSON.parse(JSON.stringify(state.functions.meta)), // Deep clone to avoid mutating original
+      files: new Map(state.functions.files),
+    },
     http: {
       ...state.http,
       meta: JSON.parse(JSON.stringify(state.http.meta)), // Deep clone metadata
       files: new Set<string>(), // Will be repopulated with filtered files
     },
+    workflows: {
+      ...state.workflows,
+      graphMeta: JSON.parse(JSON.stringify(state.workflows?.graphMeta ?? {})),
+      meta: JSON.parse(JSON.stringify(state.workflows?.meta ?? {})),
+    },
     channels: {
       ...state.channels,
       meta: JSON.parse(JSON.stringify(state.channels.meta)),
@@ -240,6 +255,14 @@ export function filterInspectorState(
       agentsMeta: JSON.parse(JSON.stringify(state.agents?.agentsMeta ?? {})),
       files: new Map(),
     },
+    rpc: {
+      ...state.rpc,
+      internalMeta: { ...state.rpc.internalMeta }, // Clone to avoid mutating original
+      internalFiles: new Map(state.rpc.internalFiles),
+      exposedMeta: { ...state.rpc.exposedMeta },
+      exposedFiles: new Map(state.rpc.exposedFiles),
+      invokedFunctions: new Set(state.rpc.invokedFunctions),
+    },
     cli: {
       ...state.cli,
       meta: JSON.parse(JSON.stringify(state.cli.meta)),
@@ -280,6 +303,14 @@ export function filterInspectorState(
           filteredState.serviceAggregation.usedFunctions.add(
             routeMeta.pikkuFuncId
           )
+          // For workflow/agent routes, also add the base name
+          // so the workflow/agent definition survives pruning
+          const colonIdx = routeMeta.pikkuFuncId.indexOf(':')
+          if (colonIdx !== -1) {
+            filteredState.serviceAggregation.usedFunctions.add(
+              routeMeta.pikkuFuncId.slice(colonIdx + 1)
+            )
+          }
         }
         extractWireNames(routeMeta.middleware).forEach((name: string) =>
           filteredState.serviceAggregation.usedMiddleware.add(name)
@@ -291,12 +322,28 @@ export function filterInspectorState(
     }
   }
 
-  // Repopulate http.files if any routes remain
-  const hasHttpRoutes = Object.values(
-    filteredState.http.meta as Record<string, any>
-  ).some((routes) => Object.keys(routes).length > 0)
-  if (hasHttpRoutes) {
-    filteredState.http.files = new Set(state.http.files)
+  // Repopulate http.files with only files that have surviving routes
+  for (const method of Object.keys(filteredState.http.meta)) {
+    const routes = (
+      filteredState.http.meta as Record<
+        string,
+        Record<string, { sourceFile?: string }>
+      >
+    )[method]
+    for (const routeMeta of Object.values(routes)) {
+      if (routeMeta.sourceFile) {
+        filteredState.http.files.add(routeMeta.sourceFile)
+      }
+    }
+  }
+  // Fallback: if no sourceFile info available but routes exist, include all files
+  if (filteredState.http.files.size === 0) {
+    const hasHttpRoutes = Object.values(
+      filteredState.http.meta as Record<string, Record<string, unknown>>
+    ).some((routes) => Object.keys(routes).length > 0)
+    if (hasHttpRoutes) {
+      filteredState.http.files = new Set(state.http.files)
+    }
   }
 
   // Filter channels
@@ -315,11 +362,40 @@ export function filterInspectorState(
     if (!matches) {
       delete filteredState.channels.meta[name]
     } else {
-      if (channelMeta.pikkuFuncId) {
+      // Add all functions referenced by this channel
+      if ('pikkuFuncId' in channelMeta && channelMeta.pikkuFuncId) {
+        filteredState.serviceAggregation.usedFunctions.add(
+          channelMeta.pikkuFuncId as string
+        )
+      }
+      if (channelMeta.connect?.pikkuFuncId) {
+        filteredState.serviceAggregation.usedFunctions.add(
+          channelMeta.connect.pikkuFuncId
+        )
+      }
+      if (channelMeta.disconnect?.pikkuFuncId) {
         filteredState.serviceAggregation.usedFunctions.add(
-          channelMeta.pikkuFuncId
+          channelMeta.disconnect.pikkuFuncId
         )
       }
+      if (channelMeta.message?.pikkuFuncId) {
+        filteredState.serviceAggregation.usedFunctions.add(
+          channelMeta.message.pikkuFuncId
+        )
+      }
+      if (channelMeta.messageWirings) {
+        for (const groupKey of Object.keys(channelMeta.messageWirings)) {
+          const commands = channelMeta.messageWirings[groupKey]
+          for (const cmdKey of Object.keys(commands)) {
+            const wiring = commands[cmdKey]
+            if (wiring.pikkuFuncId) {
+              filteredState.serviceAggregation.usedFunctions.add(
+                wiring.pikkuFuncId
+              )
+            }
+          }
+        }
+      }
       extractWireNames(channelMeta.middleware).forEach((name: string) =>
         filteredState.serviceAggregation.usedMiddleware.add(name)
       )
@@ -413,6 +489,12 @@ export function filterInspectorState(
         filteredState.serviceAggregation.usedFunctions.add(
           workerMeta.pikkuFuncId
         )
+        const colonIdx = workerMeta.pikkuFuncId.indexOf(':')
+        if (colonIdx !== -1) {
+          filteredState.serviceAggregation.usedFunctions.add(
+            workerMeta.pikkuFuncId.slice(colonIdx + 1)
+          )
+        }
       }
       extractWireNames(workerMeta.middleware).forEach((name: string) =>
         filteredState.serviceAggregation.usedMiddleware.add(name)
@@ -616,6 +698,38 @@ export function filterInspectorState(
     filteredState.cli.files = new Set(state.cli.files)
   }
 
+  // Direct function filtering: functions that match the names/tags/directories
+  // filters should be included even if no wiring (HTTP, scheduler, etc.) references them.
+  // This ensures standalone RPC-callable functions survive filtering.
+  // Only run when function-level filters are active — httpRoutes/httpMethods work
+  // through the HTTP wiring pass which already adds the right functions.
+  const hasFunctionLevelFilters =
+    (filters.names && filters.names.length > 0) ||
+    (filters.tags && filters.tags.length > 0) ||
+    (filters.directories && filters.directories.length > 0)
+
+  for (const funcId of Object.keys(filteredState.functions.meta)) {
+    if (!hasFunctionLevelFilters) break
+    const funcMeta = filteredState.functions.meta[funcId]
+    const funcFile = filteredState.functions.files.get(funcId)
+    const filePath = funcFile?.path
+
+    const matches = matchesFilters(
+      filters,
+      {
+        type: 'rpc' as PikkuWiringTypes,
+        name: funcId,
+        tags: funcMeta.tags,
+        filePath,
+      },
+      logger
+    )
+
+    if (matches) {
+      filteredState.serviceAggregation.usedFunctions.add(funcId)
+    }
+  }
+
   // Post-filter version expansion: include all versions of matched functions
   const includedBaseNames = new Set<string>()
   for (const funcId of filteredState.serviceAggregation.usedFunctions) {
@@ -631,6 +745,123 @@ export function filterInspectorState(
     }
   }
 
+  // Prune functions.meta and functions.files to only include used functions
+  if (filteredState.serviceAggregation.usedFunctions.size > 0) {
+    for (const funcId of Object.keys(filteredState.functions.meta)) {
+      if (!filteredState.serviceAggregation.usedFunctions.has(funcId)) {
+        delete filteredState.functions.meta[funcId]
+        filteredState.functions.files.delete(funcId)
+      }
+    }
+
+    // Prune channels whose functions were filtered out
+    for (const name of Object.keys(filteredState.channels.meta)) {
+      const channelMeta = filteredState.channels.meta[name]
+      // Check if any of the channel's functions are in the used set
+      const channelFuncIds: string[] = []
+      if (channelMeta.connect?.pikkuFuncId)
+        channelFuncIds.push(channelMeta.connect.pikkuFuncId)
+      if (channelMeta.disconnect?.pikkuFuncId)
+        channelFuncIds.push(channelMeta.disconnect.pikkuFuncId)
+      if (channelMeta.message?.pikkuFuncId)
+        channelFuncIds.push(channelMeta.message.pikkuFuncId)
+      if (channelMeta.messageWirings) {
+        for (const groupKey of Object.keys(channelMeta.messageWirings)) {
+          const commands = channelMeta.messageWirings[groupKey]
+          for (const cmdKey of Object.keys(commands)) {
+            const wiring = commands[cmdKey]
+            if (wiring.pikkuFuncId) channelFuncIds.push(wiring.pikkuFuncId)
+          }
+        }
+      }
+      const hasUsedFunc = channelFuncIds.some((id) =>
+        filteredState.serviceAggregation.usedFunctions.has(id)
+      )
+      if (channelFuncIds.length > 0 && !hasUsedFunc) {
+        delete filteredState.channels.meta[name]
+      }
+    }
+
+    // Prune workflow graphs whose function was filtered out
+    const workflowKeys = new Set([
+      ...Object.keys(filteredState.workflows.graphMeta),
+      ...Object.keys(filteredState.workflows.meta),
+    ])
+    for (const name of workflowKeys) {
+      const graphMeta = filteredState.workflows.graphMeta[name]
+      const workflowMeta = filteredState.workflows.meta[name]
+      // Check both graphMeta.pikkuFuncId and meta.pikkuFuncId
+      const pikkuFuncId = graphMeta?.pikkuFuncId ?? workflowMeta?.pikkuFuncId
+      if (
+        pikkuFuncId &&
+        !filteredState.serviceAggregation.usedFunctions.has(pikkuFuncId)
+      ) {
+        delete filteredState.workflows.graphMeta[name]
+        delete filteredState.workflows.meta[name]
+      } else if (!pikkuFuncId) {
+        // No function ID found — prune it
+        delete filteredState.workflows.graphMeta[name]
+        delete filteredState.workflows.meta[name]
+      }
+    }
+
+    // Prune RPC meta to only include entries whose target function survived
+    const survivingFuncIds = new Set(Object.keys(filteredState.functions.meta))
+    for (const key of Object.keys(filteredState.rpc.internalMeta)) {
+      const targetFuncId = filteredState.rpc.internalMeta[key]
+      if (!survivingFuncIds.has(targetFuncId) && !survivingFuncIds.has(key)) {
+        delete filteredState.rpc.internalMeta[key]
+        filteredState.rpc.internalFiles.delete(key)
+      }
+    }
+    for (const key of Object.keys(filteredState.rpc.exposedMeta)) {
+      const targetFuncId = filteredState.rpc.exposedMeta[key]
+      if (!survivingFuncIds.has(targetFuncId) && !survivingFuncIds.has(key)) {
+        delete filteredState.rpc.exposedMeta[key]
+        filteredState.rpc.exposedFiles.delete(key)
+      }
+    }
+    // Prune invokedFunctions to match surviving functions
+    for (const funcId of filteredState.rpc.invokedFunctions) {
+      if (!survivingFuncIds.has(funcId)) {
+        filteredState.rpc.invokedFunctions.delete(funcId)
+      }
+    }
+  }
+
+  // Recompute requiredSchemas based on pruned functions.meta
+  if (filteredState.serviceAggregation.usedFunctions.size > 0) {
+    const prunedSchemas = new Set<string>()
+    for (const funcMeta of Object.values(
+      filteredState.functions.meta
+    ) as Array<{ inputs?: string[]; outputs?: string[] }>) {
+      if (funcMeta.inputs?.[0]) prunedSchemas.add(funcMeta.inputs[0])
+      if (funcMeta.outputs?.[0]) prunedSchemas.add(funcMeta.outputs[0])
+    }
+    filteredState.requiredSchemas = prunedSchemas
+  }
+
+  // If any surviving function is a non-inline workflow step, the unit needs
+  // workflowService + queueService even though the function doesn't use them.
+  // Check the ORIGINAL graph meta (before filtering pruned it).
+  const survivingFuncIds = new Set(Object.keys(filteredState.functions.meta))
+  // Use the snapshot taken before filtering
+  for (const graph of Object.values(originalGraphMeta)) {
+    if (!graph.nodes) continue
+    for (const node of Object.values(graph.nodes)) {
+      if (!('rpcName' in node) || !node.rpcName) continue
+      const rpcName = node.rpcName as string
+      if (!survivingFuncIds.has(rpcName)) continue
+      const isInline =
+        (node as { options?: { async?: boolean } }).options?.async !== true &&
+        graph.inline === true
+      if (!isInline) {
+        filteredState.serviceAggregation.requiredServices.add('workflowService')
+        filteredState.serviceAggregation.requiredServices.add('queueService')
+      }
+    }
+  }
+
   // Recalculate requiredServices based on filtered functions/middleware/permissions
   // Need to cast to InspectorState temporarily for aggregateRequiredServices
   const stateForAggregation = filteredState as InspectorState

package/src/utils/load-addon-functions-meta.ts

@@ -45,6 +45,65 @@ export async function loadAddonFunctionsMeta(
           }
         }
       }
+      // Load addon secrets meta
+      try {
+        const secretsMetaPath = require.resolve(
+          `${decl.package}/.pikku/secrets/pikku-secrets-meta.gen.json`
+        )
+        const secretsRaw = await readFile(secretsMetaPath, 'utf-8')
+        const secretsMeta = JSON.parse(secretsRaw)
+        for (const [key, def] of Object.entries<any>(secretsMeta)) {
+          const existing = state.secrets.definitions.find(
+            (d: any) => d.name === key
+          )
+          if (!existing) {
+            state.secrets.definitions.push(def)
+            logger.debug(`Loaded addon secret '${key}' from ${decl.package}`)
+          }
+        }
+      } catch {
+        // No secrets meta — that's fine
+      }
+
+      // Load addon variables meta
+      try {
+        const variablesMetaPath = require.resolve(
+          `${decl.package}/.pikku/variables/pikku-variables-meta.gen.json`
+        )
+        const variablesRaw = await readFile(variablesMetaPath, 'utf-8')
+        const variablesMeta = JSON.parse(variablesRaw)
+        for (const [key, def] of Object.entries<any>(variablesMeta)) {
+          const existing = state.variables.definitions.find(
+            (d: any) => d.name === key
+          )
+          if (!existing) {
+            state.variables.definitions.push(def)
+            logger.debug(`Loaded addon variable '${key}' from ${decl.package}`)
+          }
+        }
+      } catch {
+        // No variables meta — that's fine
+      }
+      // Load addon required parent services from pikku-services.gen
+      try {
+        const servicesGenPath = require.resolve(
+          `${decl.package}/.pikku/pikku-services.gen.js`
+        )
+        const servicesModule = await import(servicesGenPath)
+        if (
+          servicesModule.requiredParentServices &&
+          Array.isArray(servicesModule.requiredParentServices)
+        ) {
+          for (const service of servicesModule.requiredParentServices) {
+            state.addonRequiredParentServices.push(service)
+          }
+          logger.debug(
+            `Loaded ${servicesModule.requiredParentServices.length} required parent services for '${namespace}' from ${decl.package}`
+          )
+        }
+      } catch {
+        // No services gen — addon may not have requiredParentServices
+      }
     } catch (error: any) {
       logger.warn(
         `Failed to load addon function metadata for '${namespace}' (${decl.package}): ${error.message}`

package/src/utils/post-process.ts

@@ -221,6 +221,80 @@ export function aggregateRequiredServices(
       }
     })
   }
+
+  // 6. Implicit platform services required by wiring types
+  // Workflows need workflowService + workflowRunService + schedulerService + queueService.
+  // Check workflow definitions, graph meta, AND helper functions (workflowStart:*, etc.)
+  // that wrap workflow operations but don't destructure the services.
+  const hasWorkflows =
+    Object.keys(state.workflows.graphMeta).length > 0 ||
+    Object.keys(state.workflows.meta).length > 0 ||
+    Object.keys(state.functions.meta).some(
+      (id) =>
+        id.startsWith('workflowStart:') ||
+        id.startsWith('workflowStatus:') ||
+        id.startsWith('workflow:')
+    )
+  if (hasWorkflows) {
+    requiredServices.add('workflowService')
+    requiredServices.add('workflowRunService')
+    requiredServices.add('schedulerService')
+    requiredServices.add('queueService')
+  }
+
+  // 6b. Inject synthetic queue workers for workflow graph steps.
+  // Each workflow gets an orchestrator queue and per-step queues.
+  // Without these, the PikkuWorkflowService constructor can't find
+  // per-workflow queue entries and falls back to shared queue names.
+  for (const [, graph] of Object.entries(state.workflows.graphMeta)) {
+    if (!graph.nodes || !graph.name) continue
+
+    const toKebab = (s: string) =>
+      s
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+        .toLowerCase()
+
+    // Orchestrator queue
+    const orchQueueName = `wf-orchestrator-${toKebab(graph.name)}`
+    if (!state.queueWorkers.meta[orchQueueName]) {
+      state.queueWorkers.meta[orchQueueName] = {
+        name: orchQueueName,
+        pikkuFuncId: `pikkuWorkflowOrchestrator:${graph.name}`,
+      }
+    }
+
+    // Per-step queues
+    for (const node of Object.values(graph.nodes)) {
+      if (!('rpcName' in node) || !node.rpcName) continue
+      const rpcName = node.rpcName as string
+      const stepQueueName = `wf-step-${toKebab(rpcName)}`
+      if (!state.queueWorkers.meta[stepQueueName]) {
+        state.queueWorkers.meta[stepQueueName] = {
+          name: stepQueueName,
+          pikkuFuncId: `pikkuWorkflowWorker:${rpcName}`,
+        }
+      }
+    }
+  }
+
+  // AI agents need aiStorage + aiRunState + agentRunService + aiAgentRunner
+  if (Object.keys(state.agents.agentsMeta).length > 0) {
+    requiredServices.add('aiStorage')
+    requiredServices.add('aiRunState')
+    requiredServices.add('agentRunService')
+    requiredServices.add('aiAgentRunner')
+  }
+
+  // Channels need eventHub for pub/sub
+  if (Object.keys(state.channels.meta).length > 0) {
+    requiredServices.add('eventHub')
+  }
+
+  // 7. Services that addons need from the parent project
+  for (const service of state.addonRequiredParentServices ?? []) {
+    requiredServices.add(service)
+  }
 }
 
 export function validateSecretOverrides(