@pikku/inspector 0.12.3 → 0.12.5

package/src/types.ts

@@ -15,6 +15,7 @@ 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 { CredentialDefinitions } from '@pikku/core/credential'
 import type { VariableDefinitions } from '@pikku/core/variable'
 import type { TypesMap } from './types-map.js'
 import type {
@@ -225,6 +226,7 @@ export type InspectorOptions = Partial<{
   tags: string[]
   manifest: VersionManifest
   modelConfig: InspectorModelConfig
+  oldProgram: ts.Program | undefined
 }>
 
 export interface InspectorLogger {
@@ -378,6 +380,10 @@ export interface InspectorState {
     definitions: SecretDefinitions
     files: Set<string>
   }
+  credentials: {
+    definitions: CredentialDefinitions
+    files: Set<string>
+  }
   variables: {
     definitions: VariableDefinitions
     files: Set<string>
@@ -420,4 +426,5 @@ export interface InspectorState {
   openAPISpec: Record<string, any> | null
   diagnostics: InspectorDiagnostic[]
   addonFunctions: Record<string, FunctionsMeta> // namespace -> addon's function metadata
+  program: ts.Program | null // Retained for incremental re-inspection
 }

package/src/utils/custom-types-generator.ts

@@ -16,6 +16,7 @@ export function generateCustomTypes(
   requiredTypes: Set<string>
 ) {
   const typeDeclarations = Array.from(typesMap.customTypes.entries())
+    .sort(([a], [b]) => a.localeCompare(b))
     .filter(([_name, { type }]) => {
       const hasUndefinedGeneric =
         /\b(Name|In|Out|Key)\b/.test(type) && /\[.*\]/.test(type)

package/src/utils/post-process.ts

@@ -492,6 +492,65 @@ export function validateAgentOverrides(
   }
 }
 
+/**
+ * Validates that Zod schemas and wiring side-effects (wireHTTPRoutes,
+ * addPermission, addHTTPMiddleware, etc.) do not coexist in the same file.
+ *
+ * The CLI uses tsImport to extract Zod schemas at runtime, which executes
+ * all top-level code in the file. Wiring calls crash during this process
+ * because the pikku state metadata doesn't exist in the CLI context.
+ */
+export function validateSchemaWiringSeparation(
+  logger: InspectorLogger,
+  state: InspectorState
+): void {
+  // Collect files that contain schemas
+  const schemaFiles = new Set<string>()
+  for (const ref of state.schemaLookup.values()) {
+    schemaFiles.add(ref.sourceFile)
+  }
+
+  // Collect files that contain wiring side-effects
+  const wiringFiles = new Set<string>()
+
+  // HTTP route wirings
+  for (const file of state.http.files) {
+    wiringFiles.add(file)
+  }
+
+  // Permission wirings (addPermission calls)
+  for (const meta of state.permissions.tagPermissions.values()) {
+    wiringFiles.add(meta.sourceFile)
+  }
+  for (const meta of state.http.routePermissions.values()) {
+    wiringFiles.add(meta.sourceFile)
+  }
+
+  // Middleware wirings (addHTTPMiddleware calls)
+  for (const meta of state.http.routeMiddleware.values()) {
+    wiringFiles.add(meta.sourceFile)
+  }
+  for (const meta of state.middleware.tagMiddleware.values()) {
+    wiringFiles.add(meta.sourceFile)
+  }
+
+  // Check for overlap
+  for (const file of schemaFiles) {
+    if (wiringFiles.has(file)) {
+      const schemas = Array.from(state.schemaLookup.entries())
+        .filter(([, ref]) => ref.sourceFile === file)
+        .map(([name]) => name)
+
+      logger.critical(
+        ErrorCode.SCHEMA_AND_WIRING_COLOCATED,
+        `File '${file}' contains both Zod schemas (${schemas.join(', ')}) and wiring calls (wireHTTPRoutes, addPermission, etc.). ` +
+          `These must be in separate files because the CLI imports schema files at runtime, which triggers wiring side-effects that crash without server context. ` +
+          `Move the route/wiring definitions to a dedicated wiring file.`
+      )
+    }
+  }
+}
+
 export function computeDiagnostics(state: InspectorState): void {
   const diagnostics: InspectorDiagnostic[] = []
 

package/src/utils/schema-generator.ts

@@ -63,24 +63,37 @@ function primitiveTypeToSchema(typeStr: string): JSONValue | null {
   return null
 }
 
+// Cached state for schema program reuse across inspect() calls
+let cachedSchemaProgram: ts.Program | undefined
+let cachedParsedConfig: ts.ParsedCommandLine | undefined
+let cachedTsconfigPath: string | undefined
+let cachedCustomTypesContent: string | undefined
+let cachedTSSchemas: Record<string, JSONValue> | undefined
+
 function createProgramWithVirtualFile(
   tsconfig: string,
   virtualFilePath: string,
   virtualFileContent: string
 ): ts.Program {
   const configPath = resolve(tsconfig)
-  const configFile = ts.readConfigFile(configPath, ts.sys.readFile)
-  const basePath = dirname(configPath)
-  const parsedConfig = ts.parseJsonConfigFileContent(
-    configFile.config,
-    ts.sys,
-    basePath
-  )
+
+  // Cache the parsed tsconfig — it doesn't change between runs
+  if (!cachedParsedConfig || cachedTsconfigPath !== configPath) {
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile)
+    const basePath = dirname(configPath)
+    cachedParsedConfig = ts.parseJsonConfigFileContent(
+      configFile.config,
+      ts.sys,
+      basePath
+    )
+    cachedTsconfigPath = configPath
+    cachedSchemaProgram = undefined
+  }
 
   const resolvedVirtualPath = resolve(virtualFilePath)
-  const fileNames = [...parsedConfig.fileNames, resolvedVirtualPath]
+  const fileNames = [...cachedParsedConfig.fileNames, resolvedVirtualPath]
 
-  const defaultHost = ts.createCompilerHost(parsedConfig.options)
+  const defaultHost = ts.createCompilerHost(cachedParsedConfig.options)
   const customHost: ts.CompilerHost = {
     ...defaultHost,
     getSourceFile(
@@ -113,7 +126,14 @@ function createProgramWithVirtualFile(
     },
   }
 
-  return ts.createProgram(fileNames, parsedConfig.options, customHost)
+  const program = ts.createProgram(
+    fileNames,
+    cachedParsedConfig.options,
+    customHost,
+    cachedSchemaProgram // reuse previous program for incremental compilation
+  )
+  cachedSchemaProgram = program
+  return program
 }
 
 function generateTSSchemas(
@@ -313,6 +333,11 @@ export async function generateAllSchemas(
     requiredTypes
   )
 
+  if (cachedTSSchemas && cachedCustomTypesContent === customTypesContent) {
+    logger.debug('Reusing cached TS schemas (types unchanged)')
+    return { ...cachedTSSchemas, ...zodSchemas }
+  }
+
   const tsSchemas = generateTSSchemas(
     logger,
     config.tsconfig,
@@ -325,5 +350,8 @@ export async function generateAllSchemas(
     state.schemaLookup
   )
 
+  cachedCustomTypesContent = customTypesContent
+  cachedTSSchemas = tsSchemas
+
   return { ...tsSchemas, ...zodSchemas }
 }

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

@@ -183,6 +183,10 @@ export interface SerializableInspectorState {
     definitions: InspectorState['secrets']['definitions']
     files: string[]
   }
+  credentials: {
+    definitions: InspectorState['credentials']['definitions']
+    files: string[]
+  }
   variables: {
     definitions: InspectorState['variables']['definitions']
     files: string[]
@@ -380,6 +384,10 @@ export function serializeInspectorState(
       definitions: state.secrets.definitions,
       files: Array.from(state.secrets.files),
     },
+    credentials: {
+      definitions: state.credentials.definitions,
+      files: Array.from(state.credentials.files),
+    },
     variables: {
       definitions: state.variables.definitions,
       files: Array.from(state.variables.files),
@@ -548,6 +556,10 @@ export function deserializeInspectorState(
       definitions: data.secrets?.definitions || [],
       files: new Set(data.secrets?.files || []),
     },
+    credentials: {
+      definitions: data.credentials?.definitions || [],
+      files: new Set(data.credentials?.files || []),
+    },
     variables: {
       definitions: data.variables?.definitions || [],
       files: new Set(data.variables?.files || []),
@@ -596,5 +608,6 @@ export function deserializeInspectorState(
     openAPISpec: data.openAPISpec || null,
     diagnostics: data.diagnostics || [],
     addonFunctions: data.addonFunctions || {},
+    program: null,
   }
 }

package/src/utils/workflow/graph/convert-dsl-to-graph.ts

@@ -400,6 +400,7 @@ export function convertDslToGraph(
     source,
     description: meta.description,
     tags: meta.tags,
+    inline: meta.inline,
     context: meta.context,
     nodes: nodesRecord,
     entryNodeIds,

package/src/utils/workflow/graph/workflow-graph.types.ts

@@ -192,6 +192,8 @@ export interface SerializedWorkflowGraph {
   description?: string
   /** Tags for organization */
   tags?: string[]
+  /** If true, workflow always executes inline without queues */
+  inline?: boolean
   /** Workflow context/state variables (from Zod schema) */
   context?: WorkflowContext
   /** Serialized nodes */

package/src/visit.ts

@@ -22,7 +22,8 @@ import { addWireAddon } from './add/add-wire-addon.js'
 import { addMiddleware } from './add/add-middleware.js'
 import { addPermission } from './add/add-permission.js'
 import { addCLI, addCLIRenderers } from './add/add-cli.js'
-import { addSecret, addOAuth2Credential } from './add/add-secret.js'
+import { addSecret } from './add/add-secret.js'
+import { addCredential } from './add/add-credential.js'
 import { addVariable } from './add/add-variable.js'
 import { addWorkflowGraph } from './add/add-workflow-graph.js'
 import { addAIAgent } from './add/add-ai-agent.js'
@@ -105,7 +106,7 @@ export const visitRoutes = (
 ) => {
   addFunctions(logger, node, checker, state, options)
   addSecret(logger, node, checker, state, options)
-  addOAuth2Credential(logger, node, checker, state, options)
+  addCredential(logger, node, checker, state, options)
   addVariable(logger, node, checker, state, options)
 
   addHTTPRoute(logger, node, checker, state, options)