@pikku/inspector 0.12.75 → 0.12.82

package/src/add/add-mcp-prompt.ts

@@ -1,157 +0,0 @@
-import * as ts from 'typescript'
-import {
-  getPropertyValue,
-  getCommonWireMetaData,
-} from '../utils/get-property-value.js'
-import { extractWireNames } from '../utils/post-process.js'
-import { ensureFunctionMetadata } from '../utils/ensure-function-metadata.js'
-import type { AddWiring } from '../types.js'
-import {
-  extractFunctionName,
-  makeContextBasedId,
-} from '../utils/extract-function-name.js'
-import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
-import { resolveMiddleware } from '../utils/middleware.js'
-import { resolvePermissions } from '../utils/permissions.js'
-import { resolveAddonName } from '../utils/resolve-addon-package.js'
-import { ErrorCode } from '../error-codes.js'
-
-export const addMCPPrompt: AddWiring = (
-  logger,
-  node,
-  checker,
-  state,
-  options
-) => {
-  if (!ts.isCallExpression(node)) {
-    return
-  }
-
-  const args = node.arguments
-  const firstArg = args[0]
-  const expression = node.expression
-
-  // Check if the call is to wireMCPPrompt
-  if (!ts.isIdentifier(expression) || expression.text !== 'wireMCPPrompt') {
-    return
-  }
-
-  if (!firstArg) {
-    return
-  }
-
-  if (ts.isObjectLiteralExpression(firstArg)) {
-    const obj = firstArg
-
-    const nameValue = getPropertyValue(obj, 'name') as string | null
-    const { disabled, tags, summary, description, errors } =
-      getCommonWireMetaData(obj, 'MCP prompt', nameValue, logger, checker)
-
-    if (disabled) return
-
-    const funcInitializer = getPropertyAssignmentInitializer(
-      obj,
-      'func',
-      true,
-      checker
-    )
-    if (!funcInitializer) {
-      logger.critical(
-        ErrorCode.MISSING_FUNC,
-        `No valid 'func' property for MCP prompt '${nameValue}'.`
-      )
-      return
-    }
-
-    const extracted = extractFunctionName(
-      funcInitializer,
-      checker,
-      state.rootDir
-    )
-    let pikkuFuncId = extracted.pikkuFuncId
-    if (pikkuFuncId.startsWith('__temp_') && nameValue) {
-      pikkuFuncId = makeContextBasedId('mcp', 'prompt', nameValue)
-    }
-
-    const packageName = ts.isIdentifier(funcInitializer)
-      ? resolveAddonName(
-          funcInitializer,
-          checker,
-          state.rpc.wireAddonDeclarations
-        )
-      : null
-
-    ensureFunctionMetadata(
-      state,
-      pikkuFuncId,
-      nameValue || undefined,
-      funcInitializer,
-      checker,
-      extracted.isHelper
-    )
-
-    if (!nameValue) {
-      logger.critical(
-        ErrorCode.MISSING_NAME,
-        "MCP prompt is missing the required 'name' property."
-      )
-      return
-    }
-
-    if (!description) {
-      logger.critical(
-        ErrorCode.MISSING_DESCRIPTION,
-        `MCP prompt '${nameValue}' is missing a description.`
-      )
-      return
-    }
-
-    // lookup existing function metadata
-    const fnMeta = state.functions.meta[pikkuFuncId]
-    if (!fnMeta) {
-      logger.critical(
-        ErrorCode.FUNCTION_METADATA_NOT_FOUND,
-        `No function metadata found for '${pikkuFuncId}'.`
-      )
-      return
-    }
-    const inputSchema = fnMeta.inputs?.[0] || null
-    const outputSchema = fnMeta.outputs?.[0] || null
-
-    if (!fnMeta.outputSchemaName) {
-      fnMeta.outputSchemaName = 'MCPPromptResponse'
-      fnMeta.outputs = ['MCPPromptResponse']
-    }
-
-    // --- resolve middleware ---
-    const middleware = resolveMiddleware(state, obj, tags, checker)
-
-    // --- resolve permissions ---
-    const permissions = resolvePermissions(state, obj, tags, checker)
-
-    // --- track used functions/middleware/permissions for service aggregation ---
-    state.serviceAggregation.usedFunctions.add(pikkuFuncId)
-    extractWireNames(middleware).forEach((name) =>
-      state.serviceAggregation.usedMiddleware.add(name)
-    )
-    extractWireNames(permissions).forEach((name) =>
-      state.serviceAggregation.usedPermissions.add(name)
-    )
-
-    state.mcpEndpoints.files.add(node.getSourceFile().fileName)
-
-    state.mcpEndpoints.promptsMeta[nameValue] = {
-      pikkuFuncId,
-      ...(packageName && { packageName }),
-      name: nameValue,
-      description,
-      summary,
-      errors,
-      tags,
-      inputSchema,
-      outputSchema,
-      arguments: [], // Will be populated by CLI during serialization
-      middleware,
-    }
-  }
-}

package/src/add/add-mcp-resource.ts

@@ -1,175 +0,0 @@
-import * as ts from 'typescript'
-import {
-  getPropertyValue,
-  getCommonWireMetaData,
-} from '../utils/get-property-value.js'
-import { extractWireNames } from '../utils/post-process.js'
-import { ensureFunctionMetadata } from '../utils/ensure-function-metadata.js'
-import type { AddWiring } from '../types.js'
-import {
-  extractFunctionName,
-  makeContextBasedId,
-} from '../utils/extract-function-name.js'
-import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
-import { resolveMiddleware } from '../utils/middleware.js'
-import { resolvePermissions } from '../utils/permissions.js'
-import { resolveAddonName } from '../utils/resolve-addon-package.js'
-import { ErrorCode } from '../error-codes.js'
-
-export const addMCPResource: AddWiring = (
-  logger,
-  node,
-  checker,
-  state,
-  options
-) => {
-  if (!ts.isCallExpression(node)) {
-    return
-  }
-
-  const args = node.arguments
-  const firstArg = args[0]
-  const expression = node.expression
-
-  // Check if the call is to wireMCPResource
-  if (!ts.isIdentifier(expression) || expression.text !== 'wireMCPResource') {
-    return
-  }
-
-  if (!firstArg) {
-    return
-  }
-
-  if (ts.isObjectLiteralExpression(firstArg)) {
-    const obj = firstArg
-
-    const uriValue = getPropertyValue(obj, 'uri') as string | null
-    const titleValue = getPropertyValue(obj, 'title') as string | null
-    const { disabled, tags, summary, description, errors } =
-      getCommonWireMetaData(obj, 'MCP resource', uriValue, logger, checker)
-
-    if (disabled) return
-
-    const streamingValue = getPropertyValue(obj, 'streaming') as boolean | null
-
-    if (streamingValue === true) {
-      logger.warn(
-        `MCP resource '${uriValue}' has streaming enabled, but streaming is not yet supported.`
-      )
-    }
-
-    const funcInitializer = getPropertyAssignmentInitializer(
-      obj,
-      'func',
-      true,
-      checker
-    )
-    if (!funcInitializer) {
-      logger.critical(
-        ErrorCode.MISSING_FUNC,
-        `No valid 'func' property for MCP resource '${uriValue}'.`
-      )
-      return
-    }
-
-    const extracted = extractFunctionName(
-      funcInitializer,
-      checker,
-      state.rootDir
-    )
-    let pikkuFuncId = extracted.pikkuFuncId
-    if (pikkuFuncId.startsWith('__temp_') && uriValue) {
-      pikkuFuncId = makeContextBasedId('mcp', 'resource', uriValue)
-    }
-
-    const packageName = ts.isIdentifier(funcInitializer)
-      ? resolveAddonName(
-          funcInitializer,
-          checker,
-          state.rpc.wireAddonDeclarations
-        )
-      : null
-
-    ensureFunctionMetadata(
-      state,
-      pikkuFuncId,
-      uriValue || undefined,
-      funcInitializer,
-      checker,
-      extracted.isHelper
-    )
-
-    if (!uriValue) {
-      logger.critical(
-        ErrorCode.MISSING_URI,
-        "MCP resource is missing the required 'uri' property."
-      )
-      return
-    }
-
-    if (!titleValue) {
-      logger.critical(
-        ErrorCode.MISSING_TITLE,
-        `MCP resource '${uriValue}' is missing the required 'title' property.`
-      )
-      return
-    }
-
-    if (!description) {
-      logger.critical(
-        ErrorCode.MISSING_DESCRIPTION,
-        `MCP resource '${uriValue}' is missing a description.`
-      )
-      return
-    }
-
-    // lookup existing function metadata
-    const fnMeta = state.functions.meta[pikkuFuncId]
-    if (!fnMeta) {
-      logger.critical(
-        ErrorCode.FUNCTION_METADATA_NOT_FOUND,
-        `No function metadata found for '${pikkuFuncId}'.`
-      )
-      return
-    }
-    const inputSchema = fnMeta.inputs?.[0] || null
-    const outputSchema = fnMeta.outputs?.[0] || null
-
-    if (!fnMeta.outputSchemaName) {
-      fnMeta.outputSchemaName = 'MCPResourceResponse'
-      fnMeta.outputs = ['MCPResourceResponse']
-    }
-
-    // --- resolve middleware ---
-    const middleware = resolveMiddleware(state, obj, tags, checker)
-
-    // --- resolve permissions ---
-    const permissions = resolvePermissions(state, obj, tags, checker)
-
-    // --- track used functions/middleware/permissions for service aggregation ---
-    state.serviceAggregation.usedFunctions.add(pikkuFuncId)
-    extractWireNames(middleware).forEach((name) =>
-      state.serviceAggregation.usedMiddleware.add(name)
-    )
-    extractWireNames(permissions).forEach((name) =>
-      state.serviceAggregation.usedPermissions.add(name)
-    )
-
-    state.mcpEndpoints.files.add(node.getSourceFile().fileName)
-
-    state.mcpEndpoints.resourcesMeta[uriValue] = {
-      pikkuFuncId,
-      ...(packageName && { packageName }),
-      uri: uriValue,
-      title: titleValue,
-      description,
-      summary,
-      errors,
-      ...(streamingValue !== null && { streaming: streamingValue }),
-      tags,
-      inputSchema,
-      outputSchema,
-      middleware,
-    }
-  }
-}

package/src/add/add-middleware.test.ts

@@ -1,196 +0,0 @@
-import { strict as assert } from 'assert'
-import { describe, test } from 'node:test'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { inspect } from '../inspector.js'
-import type { ErrorCode } from '../error-codes.js'
-import type { InspectorLogger, MiddlewareGroupMeta } from '../types.js'
-
-const makeLogger = (criticals: Array<{ code: ErrorCode; message: string }>) =>
-  ({
-    debug: () => {},
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    diagnostic: ({ code, message }) => {
-      criticals.push({ code, message })
-    },
-    critical: (code: ErrorCode, message: string) => {
-      criticals.push({ code, message })
-    },
-    hasCriticalErrors: () => criticals.length > 0,
-  }) satisfies InspectorLogger
-
-/** Every file that registered middleware for one pattern or tag. */
-const sourceFiles = (group: MiddlewareGroupMeta | undefined): string[] =>
-  group
-    ? [
-        group.sourceFile,
-        ...(group.additionalRegistrations ?? []).map((r) => r.sourceFile),
-      ]
-    : []
-
-/** Runs the inspector over files written into a throwaway directory. */
-const withProject = async (
-  prefix: string,
-  files: Record<string, string[]>,
-  assertions: (state: Awaited<ReturnType<typeof inspect>>) => void
-) => {
-  const rootDir = await mkdtemp(join(tmpdir(), prefix))
-  const paths: string[] = []
-  for (const [name, lines] of Object.entries(files)) {
-    const path = join(rootDir, name)
-    await writeFile(path, lines.join('\n'))
-    paths.push(path)
-  }
-  try {
-    assertions(await inspect(makeLogger([]), paths, { rootDir }))
-  } finally {
-    await rm(rootDir, { recursive: true, force: true })
-  }
-}
-
-describe('addMiddleware inspector', () => {
-  describe('two files registering the same HTTP pattern', () => {
-    // The group is keyed by pattern, so the second call used to overwrite the
-    // first. Codegen emits imports from what is stored, so the losing file was
-    // never imported and its middleware never registered — an app could lose
-    // its session bridge to an unrelated '*' group and see nothing go wrong
-    // until a request arrived without a session.
-    const project = {
-      'session.ts': [
-        "import { addHTTPMiddleware, pikkuMiddleware } from '#pikku'",
-        'export const sessionMiddleware = () =>',
-        "  addHTTPMiddleware('*', [",
-        '    pikkuMiddleware(async (_s, _w, next) => next()),',
-        '  ])',
-      ],
-      'logging.ts': [
-        "import { addHTTPMiddleware, pikkuMiddleware } from '#pikku'",
-        'export const loggingMiddleware = () =>',
-        "  addHTTPMiddleware('*', [",
-        '    pikkuMiddleware(async (_s, _w, next) => next()),',
-        '  ])',
-      ],
-    }
-
-    test('keeps both registrations', async () => {
-      await withProject('pikku-mw-http-collide-', project, (state) => {
-        const group = state.http.routeMiddleware.get('*')
-        assert.ok(group, "expected a group for '*'")
-        assert.equal(
-          sourceFiles(group).length,
-          2,
-          'both files must survive, or one middleware silently stops running'
-        )
-      })
-    })
-
-    test('keeps both export names, so both can be imported', async () => {
-      await withProject('pikku-mw-http-names-', project, (state) => {
-        const group = state.http.routeMiddleware.get('*')!
-        const names = [
-          group.exportName,
-          ...(group.additionalRegistrations ?? []).map((r) => r.exportName),
-        ]
-        assert.deepEqual(names.sort(), [
-          'loggingMiddleware',
-          'sessionMiddleware',
-        ])
-      })
-    })
-
-    test('unions the services both registrations need', async () => {
-      await withProject('pikku-mw-http-services-', project, (state) => {
-        const group = state.http.routeMiddleware.get('*')!
-        assert.equal(
-          new Set(group.services.services).size,
-          group.services.services.length,
-          'services must not repeat when two groups merge'
-        )
-      })
-    })
-  })
-
-  test('a single registration is unchanged', async () => {
-    await withProject(
-      'pikku-mw-http-single-',
-      {
-        'session.ts': [
-          "import { addHTTPMiddleware, pikkuMiddleware } from '#pikku'",
-          'export const sessionMiddleware = () =>',
-          "  addHTTPMiddleware('*', [",
-          '    pikkuMiddleware(async (_s, _w, next) => next()),',
-          '  ])',
-        ],
-      },
-      (state) => {
-        const group = state.http.routeMiddleware.get('*')!
-        assert.equal(group.exportName, 'sessionMiddleware')
-        assert.equal(
-          group.additionalRegistrations,
-          undefined,
-          'nothing to merge means nothing extra to serialize'
-        )
-      }
-    )
-  })
-
-  test('different patterns stay separate groups', async () => {
-    await withProject(
-      'pikku-mw-http-distinct-',
-      {
-        'session.ts': [
-          "import { addHTTPMiddleware, pikkuMiddleware } from '#pikku'",
-          'export const sessionMiddleware = () =>',
-          "  addHTTPMiddleware('*', [",
-          '    pikkuMiddleware(async (_s, _w, next) => next()),',
-          '  ])',
-        ],
-        'api.ts': [
-          "import { addHTTPMiddleware, pikkuMiddleware } from '#pikku'",
-          'export const apiMiddleware = () =>',
-          "  addHTTPMiddleware('/api/*', [",
-          '    pikkuMiddleware(async (_s, _w, next) => next()),',
-          '  ])',
-        ],
-      },
-      (state) => {
-        assert.equal(sourceFiles(state.http.routeMiddleware.get('*')).length, 1)
-        assert.equal(
-          sourceFiles(state.http.routeMiddleware.get('/api/*')).length,
-          1
-        )
-      }
-    )
-  })
-
-  test('two files registering the same tag keep both registrations', async () => {
-    await withProject(
-      'pikku-mw-tag-collide-',
-      {
-        'session.ts': [
-          "import { addTagMiddleware, pikkuMiddleware } from '#pikku'",
-          'export const sessionTag = () =>',
-          "  addTagMiddleware('api', [",
-          '    pikkuMiddleware(async (_s, _w, next) => next()),',
-          '  ])',
-        ],
-        'logging.ts': [
-          "import { addTagMiddleware, pikkuMiddleware } from '#pikku'",
-          'export const loggingTag = () =>',
-          "  addTagMiddleware('api', [",
-          '    pikkuMiddleware(async (_s, _w, next) => next()),',
-          '  ])',
-        ],
-      },
-      (state) => {
-        assert.equal(
-          sourceFiles(state.middleware.tagMiddleware.get('api')).length,
-          2
-        )
-      }
-    )
-  })
-})