@pikku/inspector 0.12.75 → 0.12.81

package/src/utils/serialize-mcp-json.ts

@@ -1,150 +0,0 @@
-import type { InspectorLogger, InspectorState } from '../types.js'
-import type { JSONValue } from '@pikku/core/utils'
-import { resolveFunctionMeta } from './resolve-function-meta.js'
-
-interface MCPEndpoint {
-  uri?: string
-  name: string
-  description?: string
-  parameters?: JSONValue
-  returns?: JSONValue
-  streaming?: boolean
-}
-
-export const serializeMCPJson = (
-  logger: InspectorLogger,
-  state: InspectorState
-): string => {
-  const { mcpEndpoints, functions, schemas } = state
-  const { typesMap } = functions
-  const { resourcesMeta, toolsMeta, promptsMeta } = mcpEndpoints
-
-  const tools: MCPEndpoint[] = []
-  const resources: MCPEndpoint[] = []
-  const prompts: any[] = []
-
-  const loadSchema = (typeName: string | undefined): JSONValue | undefined => {
-    if (
-      !typeName ||
-      [
-        'boolean',
-        'string',
-        'number',
-        'null',
-        'undefined',
-        'void',
-        'unknown',
-        'never',
-      ].includes(typeName)
-    ) {
-      return undefined
-    }
-
-    // Try local typesMap first, fall back to direct schema lookup (for addon types)
-    let uniqueName: string | undefined
-    try {
-      uniqueName = typesMap.getUniqueName(typeName)
-    } catch {
-      // Type not in local typesMap — try direct schema lookup (addon schemas)
-      uniqueName = typeName
-    }
-
-    const schema = schemas[uniqueName]
-    if (!schema) {
-      logger.warn(
-        `Serialize MCP: Could not find schema for type: ${uniqueName}`
-      )
-      return undefined
-    }
-
-    return schema
-  }
-
-  for (const [name, endpointMeta] of Object.entries(resourcesMeta)) {
-    const functionMeta = resolveFunctionMeta(state, endpointMeta.pikkuFuncId)
-    if (!functionMeta) {
-      logger.warn(
-        `Function ${endpointMeta.pikkuFuncId} not found in functionsMeta. Skipping resource ${name}.`
-      )
-      continue
-    }
-
-    const inputType = functionMeta.inputs?.[0]
-    const outputType = functionMeta.outputs?.[0]
-
-    const parameters = loadSchema(inputType)
-    const returns = loadSchema(outputType)
-
-    resources.push({
-      uri: name,
-      name,
-      description: endpointMeta.description,
-      ...(parameters && { parameters }),
-      ...(returns && { returns }),
-      ...(endpointMeta.streaming && { streaming: true }),
-    })
-  }
-
-  for (const [name, endpointMeta] of Object.entries(toolsMeta)) {
-    const functionMeta = resolveFunctionMeta(state, endpointMeta.pikkuFuncId)
-    if (!functionMeta) {
-      logger.warn(
-        `Function ${endpointMeta.pikkuFuncId} not found in functionsMeta. Skipping tool ${name}.`
-      )
-      continue
-    }
-
-    const inputType = functionMeta.inputs?.[0]
-    const outputType = functionMeta.outputs?.[0]
-
-    const parameters = loadSchema(inputType)
-    const returns = loadSchema(outputType)
-
-    tools.push({
-      name,
-      description: endpointMeta.description,
-      ...(parameters && { parameters }),
-      ...(returns && { returns }),
-      ...(endpointMeta.streaming && { streaming: true }),
-    })
-  }
-
-  for (const [name, endpointMeta] of Object.entries(promptsMeta)) {
-    const functionMeta = resolveFunctionMeta(state, endpointMeta.pikkuFuncId)
-    if (!functionMeta) {
-      logger.warn(
-        `Function ${endpointMeta.pikkuFuncId} not found in functionsMeta. Skipping prompt ${name}.`
-      )
-      continue
-    }
-
-    const inputType = functionMeta.inputs?.[0]
-    const inputSchema = loadSchema(inputType)
-
-    const argumentsArray: any[] = []
-    if (
-      inputSchema &&
-      typeof inputSchema === 'object' &&
-      !(inputSchema instanceof Array)
-    ) {
-      const properties = inputSchema.properties as Record<string, any>
-      const required = (inputSchema.required as string[]) || []
-
-      for (const [propName, propSchema] of Object.entries(properties)) {
-        argumentsArray.push({
-          name: propName,
-          description: propSchema.description || `${propName} parameter`,
-          required: required.includes(propName),
-        })
-      }
-    }
-
-    prompts.push({
-      name,
-      description: endpointMeta.description,
-      arguments: argumentsArray,
-    })
-  }
-
-  return JSON.stringify({ tools, resources, prompts }, null, 2)
-}

package/src/utils/serialize-middleware-groups-meta.ts

@@ -1,36 +0,0 @@
-import type { InspectorState, MiddlewareGroupMeta } from '../types.js'
-
-const serializeGroupMap = (
-  groupMap: Map<string, MiddlewareGroupMeta>
-): Record<string, any> => {
-  const result: Record<string, any> = {}
-  for (const [key, meta] of groupMap.entries()) {
-    result[key] = {
-      exportName: meta.exportName,
-      sourceFile: meta.sourceFile,
-      position: meta.position,
-      services: meta.services,
-      count: meta.count,
-      instanceIds: meta.instanceIds,
-      isFactory: meta.isFactory,
-      ...(meta.additionalRegistrations && {
-        additionalRegistrations: meta.additionalRegistrations,
-      }),
-    }
-  }
-  return result
-}
-
-export const serializeMiddlewareGroupsMeta = (state: InspectorState) => {
-  return {
-    definitions: state.middleware.definitions,
-    instances: state.middleware.instances,
-    httpGroups: serializeGroupMap(state.http.routeMiddleware),
-    tagGroups: serializeGroupMap(state.middleware.tagMiddleware),
-    channelMiddleware: {
-      definitions: state.channelMiddleware.definitions,
-      instances: state.channelMiddleware.instances,
-      tagGroups: serializeGroupMap(state.channelMiddleware.tagMiddleware),
-    },
-  }
-}

package/src/utils/serialize-openapi-json.ts

@@ -1,277 +0,0 @@
-import type { FunctionsMeta } from '@pikku/core/services'
-import type { HTTPWiringsMeta } from '@pikku/core/http'
-import type { InspectorLogger } from '../types.js'
-import _convertSchema from '@openapi-contrib/json-schema-to-openapi-schema'
-const convertSchema =
-  'default' in _convertSchema ? (_convertSchema.default as any) : _convertSchema
-
-interface ErrorDetails {
-  status: number
-  message: string
-}
-
-interface OpenAPISpec {
-  openapi: string
-  info: {
-    title: string
-    version: string
-    description?: string
-    termsOfService?: string
-    contact?: {
-      name?: string
-      url?: string
-      email?: string
-    }
-    license?: {
-      name: string
-      url?: string
-    }
-  }
-  servers: { url: string; description?: string }[]
-  paths: Record<string, any>
-  components: {
-    schemas: Record<string, any>
-    responses?: Record<string, any>
-    parameters?: Record<string, any>
-    examples?: Record<string, any>
-    requestBodies?: Record<string, any>
-    headers?: Record<string, any>
-    securitySchemes?: Record<string, any>
-  }
-  security?: { [key: string]: any[] }[]
-  tags?: { name: string; description?: string }[]
-  externalDocs?: {
-    description?: string
-    url: string
-  }
-}
-
-export interface OpenAPISpecInfo {
-  info: {
-    title: string
-    version: string
-    description: string
-    termsOfService?: string
-    contact?: {
-      name?: string
-      url?: string
-      email?: string
-    }
-    license?: {
-      name: string
-      url?: string
-    }
-  }
-  servers: { url: string; description?: string }[]
-  tags?: { name: string; description?: string }[]
-  externalDocs?: {
-    description?: string
-    url: string
-  }
-  securitySchemes?: Record<string, any>
-  security?: { [key: string]: any[] }[]
-}
-
-const getErrorResponseForConstructorName = (
-  constructorName: string,
-  errors: Map<any, ErrorDetails>
-) => {
-  const entries = Array.from(errors.entries())
-  const foundError = entries.find(([e]) => e.name === constructorName)
-  if (foundError) {
-    return foundError[1]
-  }
-  return undefined
-}
-
-const convertSchemasToBodyPayloads = async (
-  functionsMeta: FunctionsMeta,
-  routesMeta: HTTPWiringsMeta,
-  schemas: Record<string, any>
-) => {
-  const requiredSchemas = new Set<string>()
-  for (const routeMeta of Object.values(routesMeta)) {
-    for (const { inputTypes, pikkuFuncId } of Object.values(routeMeta)) {
-      const output = functionsMeta[pikkuFuncId]?.outputs?.[0]
-      if (inputTypes?.body) {
-        requiredSchemas.add(inputTypes?.body)
-      }
-      if (output) {
-        requiredSchemas.add(output)
-      }
-    }
-  }
-
-  const convertedEntries = await Promise.all(
-    Object.entries(schemas).map(async ([key, schema]) => {
-      if (requiredSchemas.has(key)) {
-        const convertedSchema = await convertSchema(schema, {
-          convertUnreferencedDefinitions: false,
-          dereference: { circular: 'ignore' },
-        })
-        return [key, convertedSchema]
-      }
-      return
-    })
-  )
-  return Object.fromEntries(convertedEntries.filter((s) => !!s))
-}
-
-export async function generateOpenAPISpec(
-  logger: InspectorLogger,
-  functionsMeta: FunctionsMeta,
-  httpMeta: HTTPWiringsMeta,
-  schemas: Record<string, any>,
-  additionalInfo: OpenAPISpecInfo,
-  errors?: Map<any, ErrorDetails>
-): Promise<OpenAPISpec> {
-  const paths: Record<string, any> = {}
-  const errorsMap = errors ?? new Map()
-
-  for (const routeMeta of Object.values(httpMeta)) {
-    for (const meta of Object.values(routeMeta)) {
-      const {
-        route,
-        method,
-        inputTypes,
-        pikkuFuncId,
-        params,
-        query,
-        errors,
-        description,
-        tags,
-      } = meta
-      const functionMeta = functionsMeta[pikkuFuncId]
-      if (!functionMeta) {
-        logger.error(
-          `• No function metadata found for '${pikkuFuncId}' in route '${route}'.`
-        )
-        continue
-      }
-
-      const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined
-
-      const path = route.replace(/:(\w+)/g, '{$1}')
-
-      if (!paths[path]) {
-        paths[path] = {}
-      }
-
-      const responses = {}
-      errors?.forEach((error) => {
-        const errorResponse = getErrorResponseForConstructorName(
-          error,
-          errorsMap
-        )
-        if (errorResponse) {
-          responses[errorResponse.status] = {
-            description: errorResponse.message,
-          }
-        }
-      })
-
-      const operation: any = {
-        description:
-          description ||
-          `This endpoint handles the ${method.toUpperCase()} request for the route ${route}.`,
-        tags: tags || [route.split('/')[1] || 'default'],
-        parameters: [],
-        responses: {
-          ...responses,
-          '200': {
-            description: 'Successful response',
-            content: output
-              ? {
-                  'application/json': {
-                    schema:
-                      typeof output === 'string' &&
-                      ['boolean', 'string', 'number'].includes(output)
-                        ? { type: output }
-                        : { $ref: `#/components/schemas/${output}` },
-                  },
-                }
-              : undefined,
-          },
-        },
-      }
-
-      const bodyType = inputTypes?.body
-      if (bodyType) {
-        operation.requestBody = {
-          required: true,
-          content: {
-            'application/json': {
-              schema:
-                typeof bodyType === 'string' &&
-                ['boolean', 'string', 'number'].includes(bodyType)
-                  ? { type: bodyType }
-                  : { $ref: `#/components/schemas/${bodyType}` },
-            },
-          },
-        }
-      }
-
-      if (params) {
-        operation.parameters = params.map((param) => ({
-          name: param,
-          in: 'path',
-          required: true,
-          schema: { type: 'string' },
-        }))
-      }
-
-      if (query) {
-        operation.parameters.push(
-          ...query.map((query) => ({
-            name: query,
-            in: 'query',
-            required: false,
-            schema: { type: 'string' },
-          }))
-        )
-      }
-
-      paths[path][method] = operation
-    }
-  }
-
-  return {
-    openapi: '3.1.0',
-    info: additionalInfo.info,
-    servers: additionalInfo.servers,
-    paths,
-    components: {
-      schemas: await convertSchemasToBodyPayloads(
-        functionsMeta,
-        httpMeta,
-        schemas
-      ),
-      responses: {},
-      parameters: {},
-      examples: {},
-      requestBodies: {},
-      headers: {},
-      securitySchemes: additionalInfo.securitySchemes || {
-        ApiKeyAuth: {
-          type: 'apiKey',
-          in: 'header',
-          name: 'x-api-key',
-        },
-        BearerAuth: {
-          type: 'http',
-          scheme: 'bearer',
-        },
-      },
-    },
-    security: additionalInfo.security || [
-      {
-        ApiKeyAuth: [],
-      },
-      {
-        BearerAuth: [],
-      },
-    ],
-    tags: additionalInfo.tags,
-    externalDocs: additionalInfo.externalDocs,
-  }
-}

package/src/utils/serialize-permissions-groups-meta.ts

@@ -1,7 +0,0 @@
-import type { InspectorState } from '../types.js'
-
-export const serializePermissionsGroupsMeta = (state: InspectorState) => {
-  return {
-    definitions: state.permissions.definitions,
-  }
-}

package/src/utils/single-declaration.ts

@@ -1,57 +0,0 @@
-import type { ErrorCode } from '../error-codes.js'
-import type { InspectorLogger } from '../types.js'
-
-/**
- * Claims the one call site a single-declaration construct is allowed.
- *
- * `definePersonas` takes a keyed object, so one call already declares as many
- * entries as you like. Letting the call itself repeat buys nothing and costs
- * the thing that matters: a single place to read the declared set from, and a
- * single place to add to it. The same rule `pikkuBetterAuth` has had all along.
- *
- * A second call in the SAME file is refused too — "the file" is not an answer
- * to "where do I add a persona?" when the file holds two calls, so allowing it
- * would keep the ambiguity the rule exists to remove.
- *
- * A generated file is exempt, and never claims the slot either. The rule exists
- * to name the one place a person adds to, and nobody adds to a file the CLI
- * rewrites on the next run — `pikku-personas.gen.ts` would otherwise make every
- * project that scaffolds one unbuildable, and take the app's own declaration
- * down with it.
- *
- * `defineScope` and `defineSystemRole` held this rule too, briefly, and do not
- * until the `admin` tree stops being app-declared. The exemption above is not
- * enough for them: the CLI generates a `defineScope` in `user-admin.gen.ts` and
- * `@pikku/addon-console` spells the same tree out again in a hand-written file,
- * so two non-generated declarations remain and the build still fails. The fix
- * is for `admin` to be a default scope nobody declares, and the rule comes back
- * for scopes and roles once that lands.
- *
- * @param files - The construct's `files` set, which doubles as the claim.
- * @returns true when the caller holds the claim and should carry on.
- */
-export const claimSingleDeclaration = (
-  logger: InspectorLogger,
-  files: Set<string>,
-  code: ErrorCode,
-  helper: string,
-  sourceFile: string
-): boolean => {
-  if (sourceFile.endsWith('.gen.ts')) {
-    return true
-  }
-
-  const [first] = files
-  if (first === undefined) {
-    files.add(sourceFile)
-    return true
-  }
-
-  logger.critical(
-    code,
-    first === sourceFile
-      ? `Only one ${helper}(...) is allowed per codebase, so there is one place to read the declarations from and one place to add to. Found a second call in ${sourceFile}. Declare them all in one call.`
-      : `Only one ${helper}(...) is allowed per codebase, so there is one place to read the declarations from and one place to add to. Found a second in ${sourceFile} (first: ${first}). Declare them all in one call.`
-  )
-  return false
-}

package/src/utils/type-utils.ts

@@ -1,145 +0,0 @@
-import * as ts from 'typescript'
-
-export const extractTypeKeys = (type: ts.Type): string[] => {
-  return type.getProperties().map((symbol) => symbol.getName())
-}
-
-/**
- * Resolve an identifier or call expression to the actual function declaration
- */
-export function resolveFunctionDeclaration(
-  node: ts.Node,
-  checker: ts.TypeChecker
-): ts.Node | null {
-  // If it's already a function-like node, return it
-  if (
-    ts.isFunctionDeclaration(node) ||
-    ts.isFunctionExpression(node) ||
-    ts.isArrowFunction(node)
-  ) {
-    return node
-  }
-
-  // If it's a call expression (e.g., pikkuWorkflowFunc(...)), get its first argument
-  if (ts.isCallExpression(node) && node.arguments.length > 0) {
-    const firstArg = node.arguments[0]
-    if (ts.isFunctionExpression(firstArg) || ts.isArrowFunction(firstArg)) {
-      return firstArg
-    }
-  }
-
-  // If it's an identifier, resolve to declaration
-  if (ts.isIdentifier(node)) {
-    const symbol = checker.getSymbolAtLocation(node)
-    if (!symbol) return null
-
-    // Try valueDeclaration first, then fallback to declarations[0]
-    const decl = symbol.valueDeclaration || symbol.declarations?.[0]
-    if (!decl) return null
-
-    // If it's an import specifier, resolve the aliased symbol
-    if (ts.isImportSpecifier(decl)) {
-      const aliasedSymbol = checker.getAliasedSymbol(symbol)
-      if (aliasedSymbol) {
-        const aliasedDecl =
-          aliasedSymbol.valueDeclaration || aliasedSymbol.declarations?.[0]
-        if (aliasedDecl) {
-          // For variable declarations, get the initializer
-          if (
-            ts.isVariableDeclaration(aliasedDecl) &&
-            aliasedDecl.initializer
-          ) {
-            return resolveFunctionDeclaration(aliasedDecl.initializer, checker)
-          }
-          // For function declarations, return directly
-          if (ts.isFunctionDeclaration(aliasedDecl)) {
-            return aliasedDecl
-          }
-        }
-      }
-    }
-
-    // If it's a variable declaration, get the initializer
-    if (ts.isVariableDeclaration(decl) && decl.initializer) {
-      return resolveFunctionDeclaration(decl.initializer, checker)
-    }
-
-    // If it's a function declaration
-    if (ts.isFunctionDeclaration(decl)) {
-      return decl
-    }
-  }
-
-  return null
-}
-
-export function getPropertyAssignmentInitializer(
-  obj: ts.ObjectLiteralExpression,
-  propName: string,
-  followShorthand = false,
-  checker?: ts.TypeChecker
-): ts.Expression | undefined {
-  for (const prop of obj.properties) {
-    // ①  foo: () => {}
-    if (
-      ts.isPropertyAssignment(prop) &&
-      ts.isIdentifier(prop.name) &&
-      prop.name.text === propName
-    ) {
-      return prop.initializer
-    }
-
-    // ②  foo() { … }
-    if (
-      ts.isMethodDeclaration(prop) &&
-      ts.isIdentifier(prop.name) &&
-      prop.name.text === propName
-    ) {
-      return prop.name // the method node *is* the function
-    }
-
-    // ③  { foo }  (shorthand)
-    if (
-      followShorthand &&
-      ts.isShorthandPropertyAssignment(prop) &&
-      prop.name.text === propName
-    ) {
-      if (!checker) return prop.name // best effort without a checker
-
-      // Use the proper TypeScript API for shorthand property resolution
-      let sym = checker.getShorthandAssignmentValueSymbol(prop)
-      if (sym && sym.flags & ts.SymbolFlags.Alias) {
-        sym = checker.getAliasedSymbol(sym)
-      }
-
-      const decl = sym?.declarations?.[0]
-
-      // const foo = () => {} or const foo = pikkuFunc(...)
-      if (
-        decl &&
-        ts.isVariableDeclaration(decl) &&
-        decl.initializer &&
-        (ts.isArrowFunction(decl.initializer) ||
-          ts.isFunctionExpression(decl.initializer) ||
-          ts.isCallExpression(decl.initializer))
-      ) {
-        return decl.initializer
-      }
-
-      // function foo() {}
-      if (
-        decl &&
-        (ts.isFunctionDeclaration(decl) ||
-          ts.isArrowFunction(decl) ||
-          ts.isFunctionExpression(decl))
-      ) {
-        return decl as ts.Expression
-      }
-
-      // fallback – just give back the identifier
-      return prop.name
-    }
-  }
-
-  return undefined
-}

package/src/utils/validate-auth-sessionless.ts

@@ -1,30 +0,0 @@
-import type * as ts from 'typescript'
-import { getPropertyValue } from './get-property-value.js'
-import { ErrorCode } from '../error-codes.js'
-import type { InspectorLogger, InspectorState } from '../types.js'
-import { resolveFunctionMeta } from './resolve-function-meta.js'
-
-export function validateAuthSessionless(
-  logger: InspectorLogger,
-  obj: ts.ObjectLiteralExpression,
-  state: InspectorState,
-  funcName: string,
-  wireDescription: string,
-  inheritedAuth?: boolean
-): boolean {
-  const fnMeta = resolveFunctionMeta(state, funcName)
-  if (!fnMeta) return true
-
-  const routeAuth = getPropertyValue(obj, 'auth')
-  const resolvedAuth =
-    routeAuth === true || routeAuth === false ? routeAuth : inheritedAuth
-  if (resolvedAuth === false && fnMeta.sessionless === false) {
-    logger.critical(
-      ErrorCode.AUTH_DISABLED_REQUIRES_SESSIONLESS,
-      `${wireDescription} has auth disabled but function '${funcName}' uses pikkuFunc (requires session). Use pikkuSessionlessFunc instead.`
-    )
-    return false
-  }
-
-  return true
-}