@pikku/inspector 0.12.4 → 0.12.5

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## 0.12.0
 
+## 0.12.5
+
+### Patch Changes
+
+- 65eccc6: Cache Zod schema generation between re-inspection passes and batch imports by source file. Schemas are cached using a fingerprint of schemaLookup entries + file mtimes, so reinspections skip Zod generation entirely when schemas haven't changed. Source file imports are grouped so each file is imported once instead of per-schema. Reduces `pikku all` from ~5 minutes to ~13 seconds on projects with many Zod schemas.
+- 0f59432: Add per-user credential system with CredentialService, OAuth2 route handlers, and KyselyCredentialService with envelope encryption
+- Updated dependencies [0f59432]
+- Updated dependencies [52b64d1]
+  - @pikku/core@0.12.10
+
 ## 0.12.4
 
 ### Patch Changes

package/dist/add/add-credential.d.ts

@@ -0,0 +1,2 @@
+import type { AddWiring } from '../types.js';
+export declare const addCredential: AddWiring;

package/dist/add/add-credential.js

@@ -0,0 +1,118 @@
+import * as ts from 'typescript';
+import { getPropertyValue, getArrayPropertyValue, } from '../utils/get-property-value.js';
+import { ErrorCode } from '../error-codes.js';
+import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js';
+export const addCredential = (logger, node, checker, state, _options) => {
+    if (!ts.isCallExpression(node)) {
+        return;
+    }
+    const args = node.arguments;
+    const firstArg = args[0];
+    const expression = node.expression;
+    if (!ts.isIdentifier(expression) || expression.text !== 'wireCredential') {
+        return;
+    }
+    if (!firstArg) {
+        return;
+    }
+    if (ts.isObjectLiteralExpression(firstArg)) {
+        const obj = firstArg;
+        const nameValue = getPropertyValue(obj, 'name');
+        const displayNameValue = getPropertyValue(obj, 'displayName');
+        const descriptionValue = getPropertyValue(obj, 'description');
+        const typeValue = getPropertyValue(obj, 'type');
+        if (!nameValue) {
+            logger.critical(ErrorCode.MISSING_NAME, "Credential is missing the required 'name' property.");
+            return;
+        }
+        if (!displayNameValue) {
+            logger.critical(ErrorCode.MISSING_NAME, `Credential '${nameValue}' is missing the required 'displayName' property.`);
+            return;
+        }
+        if (!typeValue || (typeValue !== 'singleton' && typeValue !== 'wire')) {
+            logger.critical(ErrorCode.MISSING_NAME, `Credential '${nameValue}' is missing or has invalid 'type' property. Must be 'singleton' or 'wire'.`);
+            return;
+        }
+        let schemaVariableName = null;
+        let schemaSourceFile = null;
+        let schemaIdentifier = null;
+        for (const prop of obj.properties) {
+            if (ts.isPropertyAssignment(prop) &&
+                ts.isIdentifier(prop.name) &&
+                prop.name.text === 'schema') {
+                if (ts.isIdentifier(prop.initializer)) {
+                    schemaVariableName = prop.initializer.text;
+                    schemaIdentifier = prop.initializer;
+                    const symbol = checker.getSymbolAtLocation(prop.initializer);
+                    if (symbol) {
+                        const decl = symbol.valueDeclaration || symbol.declarations?.[0];
+                        if (decl) {
+                            if (ts.isImportSpecifier(decl)) {
+                                const aliasedSymbol = checker.getAliasedSymbol(symbol);
+                                if (aliasedSymbol) {
+                                    const aliasedDecl = aliasedSymbol.valueDeclaration ||
+                                        aliasedSymbol.declarations?.[0];
+                                    if (aliasedDecl) {
+                                        schemaSourceFile = aliasedDecl.getSourceFile().fileName;
+                                    }
+                                }
+                            }
+                            else {
+                                schemaSourceFile = decl.getSourceFile().fileName;
+                            }
+                        }
+                    }
+                }
+                break;
+            }
+        }
+        let oauth2 = undefined;
+        const oauth2Prop = obj.properties.find((p) => ts.isPropertyAssignment(p) &&
+            ts.isIdentifier(p.name) &&
+            p.name.text === 'oauth2');
+        if (oauth2Prop &&
+            ts.isPropertyAssignment(oauth2Prop) &&
+            ts.isObjectLiteralExpression(oauth2Prop.initializer)) {
+            const oauth2Obj = oauth2Prop.initializer;
+            const appCredentialSecretId = getPropertyValue(oauth2Obj, 'appCredentialSecretId');
+            const tokenSecretId = getPropertyValue(oauth2Obj, 'tokenSecretId');
+            const authorizationUrl = getPropertyValue(oauth2Obj, 'authorizationUrl');
+            const tokenUrl = getPropertyValue(oauth2Obj, 'tokenUrl');
+            const scopes = getArrayPropertyValue(oauth2Obj, 'scopes');
+            const pkce = getPropertyValue(oauth2Obj, 'pkce');
+            if (appCredentialSecretId && authorizationUrl && tokenUrl && scopes) {
+                oauth2 = {
+                    appCredentialSecretId,
+                    tokenSecretId: tokenSecretId || undefined,
+                    authorizationUrl,
+                    tokenUrl,
+                    scopes,
+                    pkce: pkce || undefined,
+                };
+            }
+        }
+        const sourceFile = node.getSourceFile().fileName;
+        state.credentials.files.add(sourceFile);
+        let schemaLookupName;
+        if (schemaVariableName && schemaSourceFile && schemaIdentifier) {
+            const vendor = detectSchemaVendorOrError(schemaIdentifier, checker, logger, `Credential '${nameValue}'`, schemaSourceFile);
+            if (vendor) {
+                schemaLookupName = `CredentialSchema_${nameValue}`;
+                state.schemaLookup.set(schemaLookupName, {
+                    variableName: schemaVariableName,
+                    sourceFile: schemaSourceFile,
+                    vendor,
+                });
+            }
+        }
+        state.credentials.definitions.push({
+            name: nameValue,
+            displayName: displayNameValue,
+            description: descriptionValue || undefined,
+            type: typeValue,
+            schema: schemaLookupName,
+            oauth2,
+            sourceFile,
+        });
+    }
+};

package/dist/add/add-secret.d.ts

@@ -1,3 +1 @@
-import type { AddWiring } from '../types.js';
-export declare const addSecret: AddWiring;
-export declare const addOAuth2Credential: AddWiring;
+export declare const addSecret: import("../types.js").AddWiring;

package/dist/add/add-secret.js

@@ -1,6 +1,3 @@
-import * as ts from 'typescript';
-import { getPropertyValue, getArrayPropertyValue, } from '../utils/get-property-value.js';
-import { ErrorCode } from '../error-codes.js';
 import { createAddKeyedWiring } from './add-keyed-wiring.js';
 export const addSecret = createAddKeyedWiring({
     functionName: 'wireSecret',
@@ -9,74 +6,3 @@ export const addSecret = createAddKeyedWiring({
     schemaPrefix: 'SecretSchema',
     getState: (state) => state.secrets,
 });
-export const addOAuth2Credential = (logger, node, _checker, state, _options) => {
-    if (!ts.isCallExpression(node)) {
-        return;
-    }
-    const args = node.arguments;
-    const firstArg = args[0];
-    const expression = node.expression;
-    if (!ts.isIdentifier(expression) ||
-        expression.text !== 'wireOAuth2Credential') {
-        return;
-    }
-    if (!firstArg) {
-        return;
-    }
-    if (ts.isObjectLiteralExpression(firstArg)) {
-        const obj = firstArg;
-        const nameValue = getPropertyValue(obj, 'name');
-        const displayNameValue = getPropertyValue(obj, 'displayName');
-        const descriptionValue = getPropertyValue(obj, 'description');
-        const secretIdValue = getPropertyValue(obj, 'secretId');
-        const tokenSecretIdValue = getPropertyValue(obj, 'tokenSecretId');
-        const authorizationUrlValue = getPropertyValue(obj, 'authorizationUrl');
-        const tokenUrlValue = getPropertyValue(obj, 'tokenUrl');
-        const scopesValue = getArrayPropertyValue(obj, 'scopes');
-        const pkceValue = getPropertyValue(obj, 'pkce');
-        if (!nameValue) {
-            logger.critical(ErrorCode.MISSING_NAME, "OAuth2 Credential is missing the required 'name' property.");
-            return;
-        }
-        if (!displayNameValue) {
-            logger.critical(ErrorCode.MISSING_NAME, `OAuth2 Credential '${nameValue}' is missing the required 'displayName' property.`);
-            return;
-        }
-        if (!secretIdValue) {
-            logger.critical(ErrorCode.MISSING_NAME, `OAuth2 Credential '${nameValue}' is missing the required 'secretId' property.`);
-            return;
-        }
-        if (!tokenSecretIdValue) {
-            logger.critical(ErrorCode.MISSING_NAME, `OAuth2 Credential '${nameValue}' is missing the required 'tokenSecretId' property.`);
-            return;
-        }
-        if (!authorizationUrlValue) {
-            logger.critical(ErrorCode.MISSING_NAME, `OAuth2 Credential '${nameValue}' is missing the required 'authorizationUrl' property.`);
-            return;
-        }
-        if (!tokenUrlValue) {
-            logger.critical(ErrorCode.MISSING_NAME, `OAuth2 Credential '${nameValue}' is missing the required 'tokenUrl' property.`);
-            return;
-        }
-        if (!scopesValue || scopesValue.length === 0) {
-            logger.critical(ErrorCode.MISSING_NAME, `OAuth2 Credential '${nameValue}' is missing the required 'scopes' property.`);
-            return;
-        }
-        const sourceFile = node.getSourceFile().fileName;
-        state.secrets.files.add(sourceFile);
-        state.secrets.definitions.push({
-            name: nameValue,
-            displayName: displayNameValue,
-            description: descriptionValue || undefined,
-            secretId: secretIdValue,
-            oauth2: {
-                tokenSecretId: tokenSecretIdValue,
-                authorizationUrl: authorizationUrlValue,
-                tokenUrl: tokenUrlValue,
-                scopes: scopesValue,
-                pkce: pkceValue || undefined,
-            },
-            sourceFile,
-        });
-    }
-};

package/dist/inspector.js

@@ -118,6 +118,10 @@ export function getInitialInspectorState(rootDir) {
             definitions: [],
             files: new Set(),
         },
+        credentials: {
+            definitions: [],
+            files: new Set(),
+        },
         variables: {
             definitions: [],
             files: new Set(),

package/dist/types.d.ts

@@ -11,6 +11,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 { FunctionsMeta, FunctionServicesMeta, FunctionWiresMeta, JSONValue } from '@pikku/core';
@@ -349,6 +350,10 @@ export interface InspectorState {
         definitions: SecretDefinitions;
         files: Set<string>;
     };
+    credentials: {
+        definitions: CredentialDefinitions;
+        files: Set<string>;
+    };
     variables: {
         definitions: VariableDefinitions;
         files: Set<string>;

package/dist/utils/serialize-inspector-state.d.ts

@@ -205,6 +205,10 @@ export interface SerializableInspectorState {
         definitions: InspectorState['secrets']['definitions'];
         files: string[];
     };
+    credentials: {
+        definitions: InspectorState['credentials']['definitions'];
+        files: string[];
+    };
     variables: {
         definitions: InspectorState['variables']['definitions'];
         files: string[];

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

@@ -101,6 +101,10 @@ export function serializeInspectorState(state) {
             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),
@@ -244,6 +248,10 @@ export function deserializeInspectorState(data) {
             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 || []),

package/dist/visit.js

@@ -17,7 +17,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';
@@ -41,7 +42,7 @@ export const visitSetup = (logger, checker, node, state, options) => {
 export const visitRoutes = (logger, checker, node, state, options) => {
     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);
     addHTTPRoutes(logger, node, checker, state, options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.4",
+  "version": "0.12.5",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "type": "module",
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^4.3.1",
-    "@pikku/core": "^0.12.9",
+    "@pikku/core": "^0.12.10",
     "path-to-regexp": "^8.3.0",
     "ts-json-schema-generator": "^2.5.0",
     "tsx": "^4.21.0",

package/src/add/add-credential.ts

@@ -0,0 +1,178 @@
+import * as ts from 'typescript'
+import {
+  getPropertyValue,
+  getArrayPropertyValue,
+} from '../utils/get-property-value.js'
+import type { AddWiring } from '../types.js'
+import { ErrorCode } from '../error-codes.js'
+import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js'
+
+export const addCredential: AddWiring = (
+  logger,
+  node,
+  checker,
+  state,
+  _options
+) => {
+  if (!ts.isCallExpression(node)) {
+    return
+  }
+
+  const args = node.arguments
+  const firstArg = args[0]
+  const expression = node.expression
+
+  if (!ts.isIdentifier(expression) || expression.text !== 'wireCredential') {
+    return
+  }
+
+  if (!firstArg) {
+    return
+  }
+
+  if (ts.isObjectLiteralExpression(firstArg)) {
+    const obj = firstArg
+
+    const nameValue = getPropertyValue(obj, 'name') as string | null
+    const displayNameValue = getPropertyValue(obj, 'displayName') as
+      | string
+      | null
+    const descriptionValue = getPropertyValue(obj, 'description') as
+      | string
+      | null
+    const typeValue = getPropertyValue(obj, 'type') as string | null
+
+    if (!nameValue) {
+      logger.critical(
+        ErrorCode.MISSING_NAME,
+        "Credential is missing the required 'name' property."
+      )
+      return
+    }
+
+    if (!displayNameValue) {
+      logger.critical(
+        ErrorCode.MISSING_NAME,
+        `Credential '${nameValue}' is missing the required 'displayName' property.`
+      )
+      return
+    }
+
+    if (!typeValue || (typeValue !== 'singleton' && typeValue !== 'wire')) {
+      logger.critical(
+        ErrorCode.MISSING_NAME,
+        `Credential '${nameValue}' is missing or has invalid 'type' property. Must be 'singleton' or 'wire'.`
+      )
+      return
+    }
+
+    let schemaVariableName: string | null = null
+    let schemaSourceFile: string | null = null
+    let schemaIdentifier: ts.Identifier | null = null
+    for (const prop of obj.properties) {
+      if (
+        ts.isPropertyAssignment(prop) &&
+        ts.isIdentifier(prop.name) &&
+        prop.name.text === 'schema'
+      ) {
+        if (ts.isIdentifier(prop.initializer)) {
+          schemaVariableName = prop.initializer.text
+          schemaIdentifier = prop.initializer
+
+          const symbol = checker.getSymbolAtLocation(prop.initializer)
+          if (symbol) {
+            const decl = symbol.valueDeclaration || symbol.declarations?.[0]
+            if (decl) {
+              if (ts.isImportSpecifier(decl)) {
+                const aliasedSymbol = checker.getAliasedSymbol(symbol)
+                if (aliasedSymbol) {
+                  const aliasedDecl =
+                    aliasedSymbol.valueDeclaration ||
+                    aliasedSymbol.declarations?.[0]
+                  if (aliasedDecl) {
+                    schemaSourceFile = aliasedDecl.getSourceFile().fileName
+                  }
+                }
+              } else {
+                schemaSourceFile = decl.getSourceFile().fileName
+              }
+            }
+          }
+        }
+        break
+      }
+    }
+
+    let oauth2: any = undefined
+    const oauth2Prop = obj.properties.find(
+      (p) =>
+        ts.isPropertyAssignment(p) &&
+        ts.isIdentifier(p.name) &&
+        p.name.text === 'oauth2'
+    )
+    if (
+      oauth2Prop &&
+      ts.isPropertyAssignment(oauth2Prop) &&
+      ts.isObjectLiteralExpression(oauth2Prop.initializer)
+    ) {
+      const oauth2Obj = oauth2Prop.initializer
+      const appCredentialSecretId = getPropertyValue(
+        oauth2Obj,
+        'appCredentialSecretId'
+      ) as string | null
+      const tokenSecretId = getPropertyValue(oauth2Obj, 'tokenSecretId') as
+        | string
+        | null
+      const authorizationUrl = getPropertyValue(
+        oauth2Obj,
+        'authorizationUrl'
+      ) as string | null
+      const tokenUrl = getPropertyValue(oauth2Obj, 'tokenUrl') as string | null
+      const scopes = getArrayPropertyValue(oauth2Obj, 'scopes')
+      const pkce = getPropertyValue(oauth2Obj, 'pkce') as boolean | null
+
+      if (appCredentialSecretId && authorizationUrl && tokenUrl && scopes) {
+        oauth2 = {
+          appCredentialSecretId,
+          tokenSecretId: tokenSecretId || undefined,
+          authorizationUrl,
+          tokenUrl,
+          scopes,
+          pkce: pkce || undefined,
+        }
+      }
+    }
+
+    const sourceFile = node.getSourceFile().fileName
+    state.credentials.files.add(sourceFile)
+
+    let schemaLookupName: string | undefined
+    if (schemaVariableName && schemaSourceFile && schemaIdentifier) {
+      const vendor = detectSchemaVendorOrError(
+        schemaIdentifier,
+        checker,
+        logger,
+        `Credential '${nameValue}'`,
+        schemaSourceFile
+      )
+      if (vendor) {
+        schemaLookupName = `CredentialSchema_${nameValue}`
+        state.schemaLookup.set(schemaLookupName, {
+          variableName: schemaVariableName,
+          sourceFile: schemaSourceFile,
+          vendor,
+        })
+      }
+    }
+
+    state.credentials.definitions.push({
+      name: nameValue,
+      displayName: displayNameValue,
+      description: descriptionValue || undefined,
+      type: typeValue as 'singleton' | 'wire',
+      schema: schemaLookupName,
+      oauth2,
+      sourceFile,
+    })
+  }
+}

package/src/add/add-secret.ts

@@ -1,10 +1,3 @@
-import * as ts from 'typescript'
-import {
-  getPropertyValue,
-  getArrayPropertyValue,
-} from '../utils/get-property-value.js'
-import type { AddWiring } from '../types.js'
-import { ErrorCode } from '../error-codes.js'
 import { createAddKeyedWiring } from './add-keyed-wiring.js'
 
 export const addSecret = createAddKeyedWiring({
@@ -14,127 +7,3 @@ export const addSecret = createAddKeyedWiring({
   schemaPrefix: 'SecretSchema',
   getState: (state) => state.secrets,
 })
-
-export const addOAuth2Credential: AddWiring = (
-  logger,
-  node,
-  _checker,
-  state,
-  _options
-) => {
-  if (!ts.isCallExpression(node)) {
-    return
-  }
-
-  const args = node.arguments
-  const firstArg = args[0]
-  const expression = node.expression
-
-  if (
-    !ts.isIdentifier(expression) ||
-    expression.text !== 'wireOAuth2Credential'
-  ) {
-    return
-  }
-
-  if (!firstArg) {
-    return
-  }
-
-  if (ts.isObjectLiteralExpression(firstArg)) {
-    const obj = firstArg
-
-    const nameValue = getPropertyValue(obj, 'name') as string | null
-    const displayNameValue = getPropertyValue(obj, 'displayName') as
-      | string
-      | null
-    const descriptionValue = getPropertyValue(obj, 'description') as
-      | string
-      | null
-    const secretIdValue = getPropertyValue(obj, 'secretId') as string | null
-    const tokenSecretIdValue = getPropertyValue(obj, 'tokenSecretId') as
-      | string
-      | null
-    const authorizationUrlValue = getPropertyValue(obj, 'authorizationUrl') as
-      | string
-      | null
-    const tokenUrlValue = getPropertyValue(obj, 'tokenUrl') as string | null
-    const scopesValue = getArrayPropertyValue(obj, 'scopes')
-    const pkceValue = getPropertyValue(obj, 'pkce') as boolean | null
-
-    if (!nameValue) {
-      logger.critical(
-        ErrorCode.MISSING_NAME,
-        "OAuth2 Credential is missing the required 'name' property."
-      )
-      return
-    }
-
-    if (!displayNameValue) {
-      logger.critical(
-        ErrorCode.MISSING_NAME,
-        `OAuth2 Credential '${nameValue}' is missing the required 'displayName' property.`
-      )
-      return
-    }
-
-    if (!secretIdValue) {
-      logger.critical(
-        ErrorCode.MISSING_NAME,
-        `OAuth2 Credential '${nameValue}' is missing the required 'secretId' property.`
-      )
-      return
-    }
-
-    if (!tokenSecretIdValue) {
-      logger.critical(
-        ErrorCode.MISSING_NAME,
-        `OAuth2 Credential '${nameValue}' is missing the required 'tokenSecretId' property.`
-      )
-      return
-    }
-
-    if (!authorizationUrlValue) {
-      logger.critical(
-        ErrorCode.MISSING_NAME,
-        `OAuth2 Credential '${nameValue}' is missing the required 'authorizationUrl' property.`
-      )
-      return
-    }
-
-    if (!tokenUrlValue) {
-      logger.critical(
-        ErrorCode.MISSING_NAME,
-        `OAuth2 Credential '${nameValue}' is missing the required 'tokenUrl' property.`
-      )
-      return
-    }
-
-    if (!scopesValue || scopesValue.length === 0) {
-      logger.critical(
-        ErrorCode.MISSING_NAME,
-        `OAuth2 Credential '${nameValue}' is missing the required 'scopes' property.`
-      )
-      return
-    }
-
-    const sourceFile = node.getSourceFile().fileName
-
-    state.secrets.files.add(sourceFile)
-
-    state.secrets.definitions.push({
-      name: nameValue,
-      displayName: displayNameValue,
-      description: descriptionValue || undefined,
-      secretId: secretIdValue,
-      oauth2: {
-        tokenSecretId: tokenSecretIdValue,
-        authorizationUrl: authorizationUrlValue,
-        tokenUrl: tokenUrlValue,
-        scopes: scopesValue,
-        pkce: pkceValue || undefined,
-      },
-      sourceFile,
-    })
-  }
-}

package/src/inspector.ts

@@ -148,6 +148,10 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
       definitions: [],
       files: new Set(),
     },
+    credentials: {
+      definitions: [],
+      files: new Set(),
+    },
     variables: {
       definitions: [],
       files: new Set(),

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 {
@@ -379,6 +380,10 @@ export interface InspectorState {
     definitions: SecretDefinitions
     files: Set<string>
   }
+  credentials: {
+    definitions: CredentialDefinitions
+    files: Set<string>
+  }
   variables: {
     definitions: VariableDefinitions
     files: Set<string>