@pikku/cli 0.11.3 → 0.12.1

package/src/functions/wirings/cli/pikku-command-cli-entry.ts

@@ -1,216 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { writeFileInDir } from '../../../utils/file-writer.js'
-import { checkRequiredTypes } from '../../../utils/check-required-types.js'
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import { join } from 'node:path'
-import { serializeLocalCLIBootstrap } from './serialize-local-cli-bootstrap.js'
-import { serializeChannelCLI } from './serialize-channel-cli.js'
-import {
-  serializeChannelCLIClient,
-  collectRendererNames,
-} from './serialize-channel-cli-client.js'
-import { existsSync } from 'fs'
-import { rm } from 'fs/promises'
-import { ErrorCode } from '@pikku/inspector'
-
-export const pikkuCLIEntry: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config, getInspectorState }) => {
-    const visitState = await getInspectorState()
-
-    // Check if CLI entrypoints are configured
-    if (
-      !config.cli?.entrypoints ||
-      Object.keys(config.cli.entrypoints).length === 0
-    ) {
-      logger.info({
-        message:
-          'No CLI entrypoints configured in config.cli.entrypoints, skipping CLI bootstrap generation',
-        type: 'skip',
-      })
-      return
-    }
-
-    // Generate bootstrap files for each configured entrypoint
-    for (const [programName, entrypointConfigs] of Object.entries(
-      config.cli.entrypoints
-    )) {
-      const programMeta = visitState.cli.meta.programs[programName]
-
-      if (!programMeta) {
-        logger.warn(
-          `CLI program '${programName}' not found in metadata, skipping`
-        )
-        continue
-      }
-
-      // Normalize to array
-      const configs = Array.isArray(entrypointConfigs)
-        ? entrypointConfigs
-        : [entrypointConfigs]
-
-      for (const entrypointConfig of configs) {
-        // Normalize entrypoint config to get type
-        const entrypointType =
-          typeof entrypointConfig === 'string'
-            ? 'local'
-            : entrypointConfig.type || 'local'
-
-        // Handle channel type entrypoint
-        if (entrypointType === 'channel') {
-          if (
-            typeof entrypointConfig === 'string' ||
-            entrypointConfig.type !== 'channel'
-          ) {
-            throw new Error('Channel entrypoint must be a channel type object')
-          }
-
-          const channelWirePath = entrypointConfig.wirePath
-          const channelClientPath = entrypointConfig.path
-          const channelName = entrypointConfig.name
-          const channelRoute = entrypointConfig.route
-
-          const channelWireFile = join(config.rootDir, channelWirePath)
-
-          const channelCode = serializeChannelCLI(
-            programName,
-            programMeta,
-            channelWireFile,
-            visitState.functions.files,
-            config.packageMappings,
-            config.channelsTypesFile,
-            config.functionTypesFile,
-            channelName,
-            channelRoute
-          )
-
-          await writeFileInDir(logger, channelWireFile, channelCode)
-          logger.debug(
-            `Serialized CLI channel for ${programName}: ${channelWireFile}`
-          )
-
-          // Generate client code if clientPath is provided
-          if (channelClientPath) {
-            const channelClientFile = join(config.rootDir, channelClientPath)
-
-            // Validate that renderers don't depend on services (client-side renderers can't access server services)
-            const rendererNames = collectRendererNames(programMeta)
-            const problematicRenderers: Array<{
-              name: string
-              services: string[]
-            }> = []
-
-            for (const rendererName of rendererNames) {
-              const rendererMeta = visitState.cli.meta.renderers[rendererName]
-              if (rendererMeta?.services?.services?.length > 0) {
-                problematicRenderers.push({
-                  name: rendererName,
-                  services: rendererMeta.services.services,
-                })
-              }
-            }
-
-            // If any renderers depend on services, abort client generation
-            if (problematicRenderers.length > 0) {
-              const details = problematicRenderers
-                .map(
-                  (r) => `  - ${r.name} depends on: ${r.services.join(', ')}`
-                )
-                .join('\n')
-
-              logger.critical(
-                ErrorCode.CLI_CLIENTSIDE_RENDERER_HAS_SERVICES,
-                `Cannot generate CLI channel client for '${programName}': renderers cannot depend on services (client-side execution)\n${details}\n\nRenderers used in CLI-over-channel must be service-free since they execute on the client.`
-              )
-
-              // Delete existing client file if it exists
-              if (existsSync(channelClientFile)) {
-                await rm(channelClientFile)
-                logger.debug(
-                  `Deleted existing CLI channel client: ${channelClientFile}`
-                )
-              }
-
-              continue
-            }
-
-            const clientCode = serializeChannelCLIClient(
-              programName,
-              programMeta,
-              channelClientFile,
-              config,
-              config.bootstrapFile,
-              channelRoute,
-              visitState.cli.meta.renderers
-            )
-
-            await writeFileInDir(logger, channelClientFile, clientCode)
-            logger.debug(
-              `Serialized CLI channel client for ${programName}: ${channelClientFile}`
-            )
-          }
-
-          continue
-        }
-
-        // Handle local CLI type entrypoint (default)
-        const entrypointPath =
-          typeof entrypointConfig === 'string'
-            ? entrypointConfig
-            : entrypointConfig.type === 'local'
-              ? entrypointConfig.path
-              : undefined
-
-        if (!entrypointPath) {
-          throw new Error(
-            `CLI entrypoint must have a path: ${JSON.stringify(entrypointConfig)}`
-          )
-        }
-
-        const bootstrapFile = join(config.rootDir, entrypointPath)
-
-        // Get service factories for local mode
-        // Check for required types
-        checkRequiredTypes(visitState.filesAndMethodsErrors, {
-          config: true,
-          singletonServicesFactory: true,
-          wireServicesFactory: true,
-        })
-
-        const {
-          pikkuConfigFactory,
-          singletonServicesFactory,
-          wireServicesFactory,
-        } = visitState.filesAndMethods
-
-        if (
-          !pikkuConfigFactory ||
-          !singletonServicesFactory ||
-          !wireServicesFactory
-        ) {
-          throw new Error('Required types not found')
-        }
-
-        const bootstrapCode = serializeLocalCLIBootstrap(
-          programName,
-          programMeta,
-          bootstrapFile,
-          config,
-          pikkuConfigFactory,
-          singletonServicesFactory,
-          wireServicesFactory
-        )
-
-        await writeFileInDir(logger, bootstrapFile, bootstrapCode)
-        logger.debug(
-          `Serialized CLI bootstrap for ${programName}: ${bootstrapFile}`
-        )
-      }
-    }
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Serializing CLI',
-      commandEnd: 'Serialized CLI',
-    }),
-  ],
-})

package/src/functions/wirings/cli/pikku-command-cli-types.ts

@@ -1,48 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { writeFileInDir } from '../../../utils/file-writer.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import { serializeCLITypes } from './serialize-cli-types.js'
-import { checkRequiredTypes } from '../../../utils/check-required-types.js'
-
-export const pikkuCLITypes: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config, getInspectorState }) => {
-    const { cliTypesFile, functionTypesFile, packageMappings } = config
-    const visitState = await getInspectorState()
-
-    const functionTypesImportPath = getFileImportRelativePath(
-      cliTypesFile,
-      functionTypesFile,
-      packageMappings
-    )
-
-    // Check for required types
-    checkRequiredTypes(visitState.filesAndMethodsErrors, {
-      userSessionType: true,
-      wireServiceType: true,
-      singletonServicesType: true,
-    })
-
-    const { userSessionType, singletonServicesType } =
-      visitState.filesAndMethods
-
-    if (!userSessionType || !singletonServicesType) {
-      throw new Error('Required types not found')
-    }
-
-    const content = serializeCLITypes(
-      functionTypesImportPath,
-      `import type { ${userSessionType.type} } from '${getFileImportRelativePath(cliTypesFile, userSessionType.typePath, packageMappings)}'`,
-      userSessionType.type,
-      `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(cliTypesFile, singletonServicesType.typePath, packageMappings)}'`,
-      singletonServicesType.type
-    )
-    await writeFileInDir(logger, cliTypesFile, content)
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Creating CLI types',
-      commandEnd: 'Created CLI types',
-    }),
-  ],
-})

package/src/functions/wirings/cli/pikku-command-cli.ts

@@ -1,81 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { serializeFileImports } from '../../../utils/file-imports-serializer.js'
-import { writeFileInDir } from '../../../utils/file-writer.js'
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import {
-  stripVerboseFields,
-  hasVerboseFields,
-} from '../../../utils/strip-verbose-meta.js'
-
-export const pikkuCLI: any = pikkuSessionlessFunc<void, boolean | undefined>({
-  func: async ({ logger, config, getInspectorState }) => {
-    const visitState = await getInspectorState()
-    const {
-      cliWiringsFile,
-      cliWiringMetaFile,
-      cliWiringMetaJsonFile,
-      packageMappings,
-      schema,
-    } = config
-    const { cli } = visitState
-
-    // Generate CLI wirings file
-    await writeFileInDir(
-      logger,
-      cliWiringsFile,
-      serializeFileImports(
-        'wireCLI',
-        cliWiringsFile,
-        cli.files,
-        packageMappings
-      )
-    )
-
-    // Write minimal JSON (runtime-only fields)
-    const minimalMeta = stripVerboseFields(cli.meta)
-    await writeFileInDir(
-      logger,
-      cliWiringMetaJsonFile,
-      JSON.stringify(minimalMeta, null, 2)
-    )
-
-    // Write verbose JSON only if it has additional fields
-    if (hasVerboseFields(cli.meta)) {
-      const verbosePath = cliWiringMetaJsonFile.replace(
-        /\.gen\.json$/,
-        '-verbose.gen.json'
-      )
-      await writeFileInDir(
-        logger,
-        verbosePath,
-        JSON.stringify(cli.meta, null, 2)
-      )
-    }
-
-    const jsonImportPath = getFileImportRelativePath(
-      cliWiringMetaFile,
-      cliWiringMetaJsonFile,
-      packageMappings
-    )
-
-    const supportsImportAttributes = schema?.supportsImportAttributes ?? false
-    const importStatement = supportsImportAttributes
-      ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-      : `import metaData from '${jsonImportPath}'`
-
-    await writeFileInDir(
-      logger,
-      cliWiringMetaFile,
-      `import { pikkuState } from '@pikku/core'\nimport { CLIMeta } from '@pikku/core/cli'\n${importStatement}\npikkuState(null, 'cli', 'meta', metaData as CLIMeta)`
-    )
-
-    return true
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Finding CLI commands',
-      commandEnd: 'Found CLI commands',
-    }),
-  ],
-})

package/src/functions/wirings/cli/serialize-channel-cli-client.ts

@@ -1,184 +0,0 @@
-import { CLIProgramMeta, CLICommandMeta } from '@pikku/core/cli'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import { Config } from '../../../../types/application-types.js'
-
-/**
- * Collect all unique renderer names from CLI metadata (populated by inspector)
- */
-export function collectRendererNames(programMeta: CLIProgramMeta): Set<string> {
-  const rendererNames = new Set<string>()
-
-  // Add program-level default renderer
-  if (programMeta.defaultRenderName) {
-    rendererNames.add(programMeta.defaultRenderName)
-  }
-
-  // Recursively collect renderer names from commands
-  function collectFromCommand(command: CLICommandMeta): void {
-    if (command.renderName) {
-      rendererNames.add(command.renderName)
-    }
-
-    // Recursively process subcommands
-    if (command.subcommands) {
-      for (const subCommand of Object.values(command.subcommands)) {
-        collectFromCommand(subCommand)
-      }
-    }
-  }
-
-  // Process all commands
-  for (const command of Object.values(programMeta.commands)) {
-    collectFromCommand(command)
-  }
-
-  return rendererNames
-}
-
-/**
- * Build a renderers map for CLI commands
- */
-function buildRenderersMap(programMeta: CLIProgramMeta): string {
-  const entries: string[] = []
-
-  // Build map entries for each command that has a renderer
-  function addCommandRenderer(command: CLICommandMeta, path: string[]): void {
-    const commandId = path.join('.')
-    if (command.renderName) {
-      entries.push(`    '${commandId}': ${command.renderName}`)
-    }
-
-    // Recursively process subcommands
-    if (command.subcommands) {
-      for (const [subName, subCommand] of Object.entries(command.subcommands)) {
-        addCommandRenderer(subCommand, [...path, subName])
-      }
-    }
-  }
-
-  // Process all commands
-  for (const [commandName, command] of Object.entries(programMeta.commands)) {
-    addCommandRenderer(command, [commandName])
-  }
-
-  if (entries.length === 0) {
-    return '{}'
-  }
-
-  return `{\n${entries.join(',\n')}\n  }`
-}
-
-/**
- * Serializes a CLI-over-Channel client bootstrap file
- * Similar to local CLI bootstrap but uses WebSocket connection
- */
-export function serializeChannelCLIClient(
-  programName: string,
-  programMeta: CLIProgramMeta,
-  clientFile: string,
-  config: Config,
-  cliBootstrapPath: string,
-  channelRoute?: string,
-  renderersMeta?: Record<string, any>
-): string {
-  const capitalizedName =
-    programName.charAt(0).toUpperCase() + programName.slice(1).replace(/-/g, '')
-  const finalChannelRoute = channelRoute || `/cli/${programName}`
-
-  // Get relative import path to CLI bootstrap (for metadata)
-  const bootstrapImportPath = getFileImportRelativePath(
-    clientFile,
-    cliBootstrapPath,
-    config.packageMappings
-  )
-
-  // Collect all unique renderer names from CLI metadata (populated by inspector)
-  const rendererNames = collectRendererNames(programMeta)
-
-  // Generate renderer imports from their source files
-  let rendererImports = ''
-  if (rendererNames.size > 0 && renderersMeta) {
-    const importsByFile = new Map<string, string[]>()
-
-    for (const rendererName of rendererNames) {
-      const meta = renderersMeta[rendererName]
-      if (meta?.exportedName && meta?.filePath) {
-        const relativePath = getFileImportRelativePath(
-          clientFile,
-          meta.filePath,
-          config.packageMappings
-        )
-        if (!importsByFile.has(relativePath)) {
-          importsByFile.set(relativePath, [])
-        }
-        importsByFile.get(relativePath)!.push(meta.exportedName)
-      }
-    }
-
-    // Generate import statements
-    for (const [path, names] of importsByFile) {
-      rendererImports += `import { ${names.join(', ')} } from '${path}'\n`
-    }
-  }
-
-  // Build renderers map
-  const renderersMap = buildRenderersMap(programMeta)
-
-  // Determine default renderer
-  const defaultRendererCode = programMeta.defaultRenderName
-    ? `,\n    defaultRenderer: ${programMeta.defaultRenderName}`
-    : ''
-
-  return `
-import { executeCLIViaChannel } from '@pikku/core/cli/channel'
-import { CorePikkuWebsocket } from '@pikku/websocket'
-import '${bootstrapImportPath}'
-${rendererImports}
-/**
- * ${capitalizedName} CLI Client (via WebSocket Channel)
- * Executes CLI commands over a WebSocket connection
- */
-export async function ${capitalizedName}CLIClient(
-  ws: WebSocket,
-  args?: string[]
-): Promise<void> {
-  // Create Pikku WebSocket wrapper
-  const pikkuWS = new CorePikkuWebsocket(ws)
-
-  // Register renderers for CLI commands
-  const renderers = ${renderersMap}
-
-  await executeCLIViaChannel({
-    programName: '${programName}',
-    pikkuWS,
-    args,
-    renderers${defaultRendererCode},
-  })
-}
-
-// Export as default for easy importing
-export default ${capitalizedName}CLIClient
-
-// For direct execution (if this file is run directly)
-if (import.meta.url === \`file://\${process.argv[1]}\`) {
-  const url = process.env.PIKKU_WS_URL || 'ws://localhost:4002${finalChannelRoute}'
-
-  // Create WebSocket instance
-  let WebSocketImpl: any
-  if (typeof WebSocket !== 'undefined') {
-    WebSocketImpl = WebSocket
-  } else {
-    // Node.js environment - dynamically import 'ws'
-    const wsModule = await import('ws')
-    WebSocketImpl = wsModule.default
-  }
-
-  const ws = new WebSocketImpl(url) as WebSocket
-  ${capitalizedName}CLIClient(ws, process.argv.slice(2)).catch(error => {
-    console.error('Fatal channel CLI error:', error)
-    // TODO: We get an error code even when it exists cleanly, investigate
-    // process.exit(1)
-  })
-}
-`
-}

package/src/functions/wirings/cli/serialize-channel-cli.ts

@@ -1,134 +0,0 @@
-import { CLIProgramMeta } from '@pikku/core/cli'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-
-/**
- * Serializes a wireChannel call from CLI metadata
- * This creates a WebSocket backend for all CLI commands
- */
-export function serializeChannelCLI(
-  programName: string,
-  programMeta: CLIProgramMeta,
-  channelFile: string,
-  functionFiles: Map<string, { path: string; exportedName: string }>,
-  packageMappings: Record<string, string>,
-  channelTypesFile: string,
-  functionTypesFile: string,
-  channelName?: string,
-  channelRoute?: string
-): string {
-  const finalChannelName = channelName || `${programName}-cli`
-  const finalChannelRoute = channelRoute || `/cli/${programName}`
-  // Flatten all commands into a single routing map
-  const commandMap: Record<
-    string,
-    { pikkuFuncName: string; importPath?: string }
-  > = {}
-
-  const collectCommands = (
-    commands: Record<string, any>,
-    path: string[] = []
-  ) => {
-    for (const [name, cmd] of Object.entries(commands)) {
-      const fullPath = [...path, name]
-      const commandKey = fullPath.join('.')
-
-      if (cmd.pikkuFuncName) {
-        commandMap[commandKey] = {
-          pikkuFuncName: cmd.pikkuFuncName,
-        }
-      }
-
-      // Recursively process subcommands
-      if (cmd.subcommands) {
-        collectCommands(cmd.subcommands, fullPath)
-      }
-    }
-  }
-
-  collectCommands(programMeta.commands)
-
-  // Generate imports from function file locations
-  const funcNames = [
-    ...new Set(Object.values(commandMap).map((v) => v.pikkuFuncName)),
-  ]
-  const imports = funcNames
-    .map((pikkuFuncName) => {
-      const fileInfo = functionFiles.get(pikkuFuncName)
-      if (!fileInfo) {
-        throw new Error(`Function not found in files map: ${pikkuFuncName}`)
-      }
-
-      const importPath = getFileImportRelativePath(
-        channelFile,
-        fileInfo.path,
-        packageMappings
-      )
-      return `import { ${fileInfo.exportedName} } from '${importPath}'`
-    })
-    .join('\n')
-
-  // Get relative path to channel types file
-  const channelTypesPath = getFileImportRelativePath(
-    channelFile,
-    channelTypesFile,
-    packageMappings
-  )
-
-  // Get relative path to function types file
-  const functionTypesPath = getFileImportRelativePath(
-    channelFile,
-    functionTypesFile,
-    packageMappings
-  )
-
-  return `/**
- * WebSocket channel backend for '${programName}' CLI commands
- */
-import { wireChannel } from '${channelTypesPath}'
-import { pikkuMiddleware } from '${functionTypesPath}'
-${imports}
-
-// Middleware to close the channel after CLI command completes
-const cliCloseOnComplete = pikkuMiddleware(async (_services, { channel }, next) => {
-  const closeChannel = () => {
-    setTimeout(async () => {
-      try {
-        // This gives time for the response to be sent before closing
-        await channel?.close()
-      } catch (err) {
-        // Ignore errors on close
-      }
-    }, 200)
-  }
-  
-  try {
-    const result = await next()
-    closeChannel()
-    return result
-  } catch (error) {
-    closeChannel()
-    throw error
-  }
-})
-
-wireChannel({
-  name: '${finalChannelName}',
-  route: '${finalChannelRoute}',
-  auth: false,
-  onMessageWiring: {
-    command: {
-${Object.entries(commandMap)
-  .map(
-    ([commandKey, { pikkuFuncName }]) =>
-      `      '${commandKey}': {
-        func: ${pikkuFuncName},
-        middleware: [cliCloseOnComplete],
-      }`
-  )
-  .join(',\n')}
-    }
-  },
-  tags: ['cli', '${programName}']
-})
-`
-}