@pikku/inspector 0.12.7 → 0.12.9

package/dist/utils/filter-inspector-state.js

@@ -139,6 +139,10 @@ export function filterInspectorState(state, filters, logger) {
             (!filters.httpMethods || filters.httpMethods.length === 0))) {
         return state;
     }
+    // Snapshot the original workflow graph meta before filtering prunes it
+    const originalGraphMeta = {
+        ...(state.workflows?.graphMeta ?? {}),
+    };
     // Create a shallow copy with new Maps/Sets to avoid mutating the original
     const filteredState = {
         ...state,
@@ -149,11 +153,21 @@ export function filterInspectorState(state, filters, logger) {
             usedMiddleware: new Set(),
             usedPermissions: new Set(),
         },
+        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(), // 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)),
@@ -186,6 +200,14 @@ export function filterInspectorState(state, filters, logger) {
             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)),
@@ -216,16 +238,33 @@ export function filterInspectorState(state, filters, logger) {
                 // Track used functions/middleware/permissions
                 if (routeMeta.pikkuFuncId) {
                     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) => filteredState.serviceAggregation.usedMiddleware.add(name));
                 extractWireNames(routeMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
             }
         }
     }
-    // Repopulate http.files if any routes remain
-    const hasHttpRoutes = Object.values(filteredState.http.meta).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[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).some((routes) => Object.keys(routes).length > 0);
+        if (hasHttpRoutes) {
+            filteredState.http.files = new Set(state.http.files);
+        }
     }
     // Filter channels
     for (const name of Object.keys(filteredState.channels.meta)) {
@@ -239,9 +278,30 @@ export function filterInspectorState(state, filters, logger) {
             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);
             }
+            if (channelMeta.connect?.pikkuFuncId) {
+                filteredState.serviceAggregation.usedFunctions.add(channelMeta.connect.pikkuFuncId);
+            }
+            if (channelMeta.disconnect?.pikkuFuncId) {
+                filteredState.serviceAggregation.usedFunctions.add(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) => filteredState.serviceAggregation.usedMiddleware.add(name));
             extractWireNames(channelMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
         }
@@ -307,6 +367,10 @@ export function filterInspectorState(state, filters, logger) {
         else {
             if (workerMeta.pikkuFuncId) {
                 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) => filteredState.serviceAggregation.usedMiddleware.add(name));
         }
@@ -444,11 +508,39 @@ export function filterInspectorState(state, filters, logger) {
     if (hasCliPrograms || hasCliRenderers) {
         filteredState.cli.files = new Set(state.cli.files);
     }
-    // Post-filter version expansion: include all versions of matched functions
+    // 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',
+            name: funcId,
+            tags: funcMeta.tags,
+            filePath,
+        }, logger);
+        if (matches) {
+            filteredState.serviceAggregation.usedFunctions.add(funcId);
+        }
+    }
+    // Post-filter version expansion: when an unversioned base name is matched,
+    // include all its versions. Specific version matches (e.g. analyzeData@v1)
+    // do NOT expand to include other versions.
     const includedBaseNames = new Set();
     for (const funcId of filteredState.serviceAggregation.usedFunctions) {
-        const { baseName } = parseVersionedId(funcId);
-        includedBaseNames.add(baseName);
+        const { baseName, version } = parseVersionedId(funcId);
+        if (version === null) {
+            includedBaseNames.add(baseName);
+        }
     }
     if (includedBaseNames.size > 0) {
         for (const funcId of Object.keys(state.functions.meta)) {
@@ -458,6 +550,117 @@ export function filterInspectorState(state, filters, logger) {
             }
         }
     }
+    // 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 = [];
+            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();
+        for (const funcMeta of Object.values(filteredState.functions.meta)) {
+            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;
+            if (!survivingFuncIds.has(rpcName))
+                continue;
+            const isInline = node.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;

package/dist/utils/load-addon-functions-meta.js

@@ -34,6 +34,53 @@ export async function loadAddonFunctionsMeta(logger, state) {
                     }
                 }
             }
+            // 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(secretsMeta)) {
+                    const existing = state.secrets.definitions.find((d) => 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(variablesMeta)) {
+                    const existing = state.variables.definitions.find((d) => 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) {
             logger.warn(`Failed to load addon function metadata for '${namespace}' (${decl.package}): ${error.message}`);

package/dist/utils/post-process.js

@@ -160,6 +160,69 @@ export function aggregateRequiredServices(state) {
             }
         });
     }
+    // 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) => 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;
+            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(logger, state) {
     const { wireAddonDeclarations } = state.rpc;

package/dist/utils/resolve-versions.js

@@ -66,13 +66,43 @@ export function resolveLatestVersions(state, logger) {
             if (state.rpc.exposedMeta[baseName] === oldId) {
                 state.rpc.exposedMeta[baseName] = newId;
             }
+            updateWiringReferences(state, oldId, newId);
         }
         else {
             const latest = group.explicit.reduce((a, b) => a.version > b.version ? a : b);
             state.rpc.internalMeta[baseName] = latest.id;
         }
+        if (state.rpc.exposedMeta[baseName]) {
+            const latestId = state.rpc.internalMeta[baseName];
+            state.rpc.exposedMeta[baseName] = latestId;
+            for (const entry of group.explicit) {
+                state.rpc.exposedMeta[entry.id] = entry.id;
+                const fileEntry = state.rpc.internalFiles.get(entry.id);
+                if (fileEntry) {
+                    state.rpc.exposedFiles.set(entry.id, fileEntry);
+                }
+            }
+            if (group.unversioned) {
+                state.rpc.exposedMeta[latestId] = latestId;
+                const fileEntry = state.rpc.internalFiles.get(latestId);
+                if (fileEntry) {
+                    state.rpc.exposedFiles.set(latestId, fileEntry);
+                }
+            }
+        }
         for (const entry of group.explicit) {
             state.rpc.invokedFunctions.add(entry.id);
         }
     }
 }
+function updateWiringReferences(state, oldId, newId) {
+    if (state.http) {
+        for (const methods of Object.values(state.http.meta)) {
+            for (const meta of Object.values(methods)) {
+                if (meta.pikkuFuncId === oldId) {
+                    meta.pikkuFuncId = newId;
+                }
+            }
+        }
+    }
+}