@pikku/cli 0.7.7 → 0.8.1

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # @pikku/cli
 
+## 0.8.1
+
+### Patch Changes
+
+- 44e3ff4: feat: enhance CLI filtering with type and directory filters
+
+  - Add --types filter to filter by PikkuEventTypes (http, channel, queue, scheduler, rpc, mcp)
+  - Add --directories filter to filter by file paths/directories
+  - All filters (tags, types, directories) now work together with AND logic
+  - Add comprehensive logging interface to inspector package
+  - Add comprehensive test suite for matchesFilters function
+  - Support cross-platform path handling
+
+- 7c592b8: feat: support for required services and improved service configuration
+
+  This release includes several enhancements to service management and configuration:
+
+  - Added support for required services configuration
+  - Improved service discovery and registration
+  - Added typed RPC clients for service communication
+  - Updated middleware to run per function
+
+- Updated dependencies [3261090]
+- Updated dependencies [44e3ff4]
+- Updated dependencies [7c592b8]
+- Updated dependencies [30a082f]
+  - @pikku/core@0.8.1
+  - @pikku/inspector@0.8.1
+
+## 0.8.0
+
+### Major Features
+
+- **Model Context Protocol (MCP) Support**: Complete MCP implementation with automatic generation of MCP JSON specifications, resources, tools, and prompts
+- **Queue System**: Added queue support
+- **RPC (Remote Procedure Calls)**: Added typed RPC call generation with local and remote procedure support
+- **Multiple Bootstrap Files**: Added support for generating different transport-specific bootstrap files
+- **Service Destructuring Analysis**: Added service destructuring analysis for better code generation
+- **Bootstrap Files**: Added support for generating transport-specific bootstrap files
+- **Service Destructuring**: Added service destructuring analysis for better code organization
+- **Error Handling**: Improved error handling for complex type generation
+- **Performance**: Optimized code generation for large projects with multiple event types
+
 ## 0.7.7
 
 ### Patch Changes

package/bin/pikku-all.ts

@@ -1,67 +1,77 @@
 import { Command } from 'commander'
 import {
+  CLILogger,
   getFileImportRelativePath,
-  logInfo,
-  logPikkuLogo,
   PikkuCLIOptions,
   writeFileInDir,
-} from '../src/utils/utils.js'
+} from '../src/utils.js'
 import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { pikkuHTTP } from './pikku-http-routes.js'
-import { pikkuFunctionTypes } from './pikku-function-types.js'
-import { pikkuHTTPMap } from './pikku-http-map.js'
+import { pikkuHTTP } from '../src/events/http/pikku-command-http-routes.js'
+import { pikkuFunctionTypes } from '../src/events/functions/pikku-command-function-types.js'
+import { pikkuHTTPMap } from '../src/events/http/pikku-command-http-map.js'
 import { existsSync } from 'fs'
-import { pikkuFetch } from './pikku-fetch.js'
-import { pikkuChannelsMap } from './pikku-channels-map.js'
-import { pikkuChannels } from './pikku-channels.js'
-import { pikkuNext } from './pikku-nextjs.js'
-import { pikkuOpenAPI } from './pikku-openapi.js'
-import { pikkuScheduler } from './pikku-scheduler.js'
-import { pikkuSchemas } from './pikku-schemas.js'
-import { pikkuWebSocket } from './pikku-websocket.js'
+import { pikkuChannelsMap } from '../src/events/channels/pikku-command-channels-map.js'
+import { pikkuChannels } from '../src/events/channels/pikku-command-channels.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
 import chokidar from 'chokidar'
-import { pikkuFunctions } from './pikku-functions.js'
-import { pikkuRPC } from './pikku-rpc.js'
-import { pikkuRPCMap } from './pikku-rpc-map.js'
-import { PikkuEventTypes } from '@pikku/core'
-
-const runAll = async (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
-  const boostrapImports: Partial<
-    Record<PikkuEventTypes, { meta: string[]; events: string[] }>
-  > & { all: { meta: string[]; events: string[] } } = {
-    all: { meta: [], events: [] },
-  }
+import { pikkuFunctions } from '../src/events/functions/pikku-command-functions.js'
+import { pikkuServices } from '../src/events/functions/pikku-command-services.js'
+import { pikkuRPC } from '../src/events/rpc/pikku-command-rpc.js'
+import { pikkuRPCMap } from '../src/events/rpc/pikku-command-rpc-map.js'
+import { pikkuQueue } from '../src/events/queue/pikku-command-queue.js'
+import { pikkuQueueMap } from '../src/events/queue/pikku-command-queue-map.js'
+import { pikkuFetch } from '../src/events/fetch/index.js'
+import { pikkuRPCClient } from '../src/events/rpc/pikku-command-rpc-client.js'
+import { pikkuWebSocketTyped } from '../src/events/channels/pikku-command-websocket-typed.js'
+import { pikkuOpenAPI } from '../src/events/http/pikku-command-openapi.js'
+import { pikkuMCP } from '../src/events/mcp/pikku-command-mcp.js'
+import { pikkuQueueService } from '../src/events/queue/pikku-command-queue-service.js'
+import { pikkuScheduler } from '../src/events/scheduler/pikku-command-scheduler.js'
+import { pikkuSchemas } from '../src/schemas.js'
+import { pikkuMCPJSON } from '../src/events/mcp/pikku-command-mcp-json.js'
+import { pikkuNext } from '../src/runtimes/nextjs/pikku-command-nextjs.js'
 
-  const addImport = (
-    from: string,
-    type: 'meta' | 'events' | 'other',
-    addTo?: PikkuEventTypes[]
-  ) => {
-    const statement = `import '${getFileImportRelativePath(cliConfig.bootstrapFile, from, cliConfig.packageMappings)}'`
-    if (type === 'meta') {
-      boostrapImports.all.meta.push(statement)
-    } else {
-      boostrapImports.all.events.push(statement)
-    }
-
-    for (const transport of Object.keys(PikkuEventTypes)) {
-      if (!addTo || addTo?.includes(transport as PikkuEventTypes)) {
-        boostrapImports[transport] = boostrapImports[transport] || {
-          meta: [],
-          events: [],
-        }
-        if (type === 'meta') {
-          boostrapImports[transport].meta.push(statement)
-        } else {
-          boostrapImports[transport].events.push(statement)
-        }
-      }
-    }
+const generateBootstrapFile = async (
+  logger: CLILogger,
+  cliConfig: PikkuCLIConfig,
+  bootstrapFile: string,
+  specificImports: string[],
+  schemas?: boolean
+) => {
+  // Common imports that every bootstrap file needs
+  const commonImports = [cliConfig.functionsMetaFile, cliConfig.functionsFile]
+
+  // Add schema if it exists
+  if (schemas) {
+    commonImports.push(`${cliConfig.schemaDirectory}/register.gen.ts`)
   }
 
+  // Combine common imports with specific imports
+  const allImports = [...commonImports, ...specificImports]
+
+  await writeFileInDir(
+    logger,
+    bootstrapFile,
+    allImports
+      .map(
+        (to) =>
+          `import '${getFileImportRelativePath(bootstrapFile, to, cliConfig.packageMappings)}'`
+      )
+      .sort((to) => (to.includes('meta') ? -1 : 1)) // Ensure meta files are at the top
+      .join('\n')
+  )
+}
+
+const runAll = async (
+  logger: CLILogger,
+  cliConfig: PikkuCLIConfig,
+  options: PikkuCLIOptions
+) => {
+  const allImports: string[] = []
+
   let typesDeclarationFileExists = true
   let visitState = await inspectorGlob(
+    logger,
     cliConfig.rootDir,
     cliConfig.srcDirectories,
     cliConfig.filters
@@ -70,80 +80,158 @@ const runAll = async (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
   if (!existsSync(cliConfig.typesDeclarationFile)) {
     typesDeclarationFileExists = false
   }
-  await pikkuFunctionTypes(cliConfig, options, visitState)
+  await pikkuFunctionTypes(logger, cliConfig, visitState, options)
 
   // This is needed since the addHTTPRoute function will add the routes to the visitState
   if (!typesDeclarationFileExists) {
-    logInfo(`• Type file first created, inspecting again...\x1b[0m`)
+    logger.info(`• Type file first created, inspecting again...\x1b[0m`)
     visitState = await inspectorGlob(
+      logger,
       cliConfig.rootDir,
       cliConfig.srcDirectories,
       cliConfig.filters
     )
   }
 
-  const functions = pikkuFunctions(cliConfig, visitState)
+  const functions = pikkuFunctions(logger, cliConfig, visitState)
   if (!functions) {
-    logInfo(`• No functions found, skipping remaining steps...\x1b[0m`)
+    logger.info(`• No functions found, skipping remaining steps...\x1b[0m`)
     process.exit(1)
   }
-  addImport(cliConfig.functionsMetaFile, 'meta')
-  addImport(cliConfig.functionsFile, 'events')
 
-  await pikkuRPC(cliConfig, visitState)
-  await pikkuRPCMap(cliConfig, visitState)
-  addImport(cliConfig.rpcMetaFile, 'meta', [PikkuEventTypes.rpc])
+  // Base imports for all bootstrap files
+  allImports.push(cliConfig.functionsMetaFile, cliConfig.functionsFile)
+
+  // Generate services map
+  await pikkuServices(logger, cliConfig, visitState)
 
-  const schemas = await pikkuSchemas(cliConfig, visitState)
+  await pikkuRPC(logger, cliConfig, visitState)
+  await pikkuRPCMap(logger, cliConfig, visitState)
+  await pikkuRPCClient(logger, cliConfig)
+  allImports.push(cliConfig.rpcMetaFile)
+
+  const schemas = await pikkuSchemas(logger, cliConfig, visitState)
   if (schemas) {
-    addImport(`${cliConfig.schemaDirectory}/register.gen.ts`, 'other')
+    allImports.push(`${cliConfig.schemaDirectory}/register.gen.ts`)
   }
 
-  const http = await pikkuHTTP(cliConfig, visitState)
+  // RPC bootstrap is always generated since RPC is always present
+  await generateBootstrapFile(
+    logger,
+    cliConfig,
+    cliConfig.bootstrapFiles.rpc,
+    [cliConfig.rpcMetaFile],
+    schemas
+  )
+
+  const http = await pikkuHTTP(logger, cliConfig, visitState)
   if (http) {
-    await pikkuHTTPMap(cliConfig, visitState)
-    await pikkuFetch(cliConfig)
-    addImport(cliConfig.httpRoutesMetaFile, 'meta', [PikkuEventTypes.http])
-    addImport(cliConfig.httpRoutesFile, 'events', [PikkuEventTypes.http])
+    await pikkuHTTPMap(logger, cliConfig, visitState)
+    await pikkuFetch(logger, cliConfig)
+    allImports.push(cliConfig.httpRoutesMetaFile, cliConfig.httpRoutesFile)
+
+    await generateBootstrapFile(
+      logger,
+      cliConfig,
+      cliConfig.bootstrapFiles.http,
+      [cliConfig.httpRoutesMetaFile, cliConfig.httpRoutesFile],
+      schemas
+    )
   }
 
-  const scheduled = await pikkuScheduler(cliConfig, visitState)
-  if (scheduled) {
-    addImport(cliConfig.schedulersMetaFile, 'meta', [PikkuEventTypes.scheduled])
-    addImport(cliConfig.schedulersFile, 'events', [PikkuEventTypes.scheduled])
+  const scheduler = await pikkuScheduler(logger, cliConfig, visitState)
+  if (scheduler) {
+    allImports.push(cliConfig.schedulersMetaFile, cliConfig.schedulersFile)
+
+    await generateBootstrapFile(
+      logger,
+      cliConfig,
+      cliConfig.bootstrapFiles.scheduler,
+      [cliConfig.schedulersMetaFile, cliConfig.schedulersFile],
+      schemas
+    )
+  }
+
+  const queues = await pikkuQueue(logger, cliConfig, visitState)
+  if (queues) {
+    await pikkuQueueMap(logger, cliConfig, visitState)
+    await pikkuQueueService(logger, cliConfig)
+    allImports.push(cliConfig.queueWorkersMetaFile, cliConfig.queueWorkersFile)
+
+    await generateBootstrapFile(
+      logger,
+      cliConfig,
+      cliConfig.bootstrapFiles.queue,
+      [cliConfig.queueWorkersMetaFile, cliConfig.queueWorkersFile],
+      schemas
+    )
   }
 
-  const channels = await pikkuChannels(cliConfig, visitState)
+  const channels = await pikkuChannels(logger, cliConfig, visitState)
   if (channels) {
-    await pikkuChannelsMap(cliConfig, visitState)
-    await pikkuWebSocket(cliConfig)
-    addImport(cliConfig.channelsMetaFile, 'meta', [PikkuEventTypes.channel])
-    addImport(cliConfig.channelsFile, 'events', [PikkuEventTypes.channel])
+    await pikkuChannelsMap(logger, cliConfig, visitState)
+    await pikkuWebSocketTyped(logger, cliConfig)
+    allImports.push(cliConfig.channelsMetaFile, cliConfig.channelsFile)
+
+    await generateBootstrapFile(
+      logger,
+      cliConfig,
+      cliConfig.bootstrapFiles.channel,
+      [cliConfig.channelsMetaFile, cliConfig.channelsFile],
+      schemas
+    )
+  }
+
+  const mcp = await pikkuMCP(logger, cliConfig, visitState)
+  if (mcp) {
+    await pikkuMCPJSON(logger, cliConfig, visitState)
+    allImports.push(cliConfig.mcpEndpointsMetaFile, cliConfig.mcpEndpointsFile)
+
+    await generateBootstrapFile(
+      logger,
+      cliConfig,
+      cliConfig.bootstrapFiles.mcp,
+      [cliConfig.mcpEndpointsMetaFile, cliConfig.mcpEndpointsFile],
+      schemas
+    )
   }
 
   if (cliConfig.nextBackendFile || cliConfig.nextHTTPFile) {
-    await pikkuNext(cliConfig, visitState, options)
+    await pikkuNext(logger, cliConfig, visitState, options)
   }
 
   if (cliConfig.openAPI) {
-    logInfo(`• OpenAPI requires a reinspection to pickup new generated types..`)
+    logger.info(
+      `• OpenAPI requires a reinspection to pickup new generated types..`
+    )
     visitState = await inspectorGlob(
+      logger,
       cliConfig.rootDir,
       cliConfig.srcDirectories,
       cliConfig.filters
     )
-    await pikkuOpenAPI(cliConfig, visitState)
+    await pikkuOpenAPI(logger, cliConfig, visitState)
   }
 
-  for (const [type, { meta, events }] of Object.entries(boostrapImports)) {
-    await writeFileInDir(
-      type === 'all' ? cliConfig.bootstrapFile : cliConfig.bootstrapFiles[type],
-      [...meta, ...events].join('\n')
-    )
-  }
+  // Generate main bootstrap file (pass all imports directly since this is the main file)
+  await writeFileInDir(
+    logger,
+    cliConfig.bootstrapFile,
+    allImports
+      .map(
+        (to) =>
+          `import '${getFileImportRelativePath(cliConfig.bootstrapFile, to, cliConfig.packageMappings)}'`
+      )
+      .sort((to) => (to.includes('meta') ? -1 : 1)) // Ensure meta files are at the top
+      .join('\n')
+  )
 }
 
-const watch = (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
+const watch = (
+  logger: CLILogger,
+  cliConfig: PikkuCLIConfig,
+  options: PikkuCLIOptions
+) => {
   const configWatcher = chokidar.watch(cliConfig.srcDirectories, {
     ignoreInitial: true,
     ignored: /.*\.gen\.tsx?/,
@@ -154,7 +242,7 @@ const watch = (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
   const generatorWatcher = () => {
     watcher.close()
 
-    logInfo(
+    logger.info(
       `• Watching directories: \n  - ${cliConfig.srcDirectories.join('\n  - ')}`
     )
     watcher = chokidar.watch(cliConfig.srcDirectories, {
@@ -165,7 +253,7 @@ const watch = (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
     watcher.on('ready', async () => {
       const handle = async () => {
         try {
-          await runAll(cliConfig, options)
+          await runAll(logger, cliConfig, options)
         } catch (err) {
           console.error(err)
           console.info()
@@ -194,19 +282,23 @@ const watch = (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
 }
 
 export const action = async (options: PikkuCLIOptions): Promise<void> => {
-  logPikkuLogo()
+  const logger = new CLILogger({ logLogo: true })
 
   const cliConfig = await getPikkuCLIConfig(
     options.config,
     [],
-    options.tags,
+    {
+      tags: options.tags,
+      types: options.types,
+      directories: options.directories,
+    },
     true
   )
 
   if (options.watch) {
-    watch(cliConfig, options)
+    watch(logger, cliConfig, options)
   } else {
-    await runAll(cliConfig, options)
+    await runAll(logger, cliConfig, options)
   }
 }
 
@@ -225,6 +317,11 @@ export const all = (program: Command): void => {
     )
     .option('-c | --config <string>', 'The path to pikku cli config file')
     .option('-t | --tags <tags...>', 'Which tags to filter by')
+    .option(
+      '--types <types...>',
+      'Which types to filter by (http, channel, queue, scheduler, rpc, mcp)'
+    )
+    .option('--directories <directories...>', 'Which directories to filter by')
     .option('-w | --watch', 'Whether to watch file changes')
     .action(action)
 }

package/bin/pikku-fetch.ts

@@ -1,49 +1,21 @@
 import { Command } from 'commander'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { serializeFetchWrapper } from '../src/serialize-fetch-wrapper.js'
-import {
-  getFileImportRelativePath,
-  logCommandInfoAndTime,
-  logPikkuLogo,
-  PikkuCLIOptions,
-  writeFileInDir,
-} from '../src/utils/utils.js'
-
-export const pikkuFetch = async ({
-  fetchFile,
-  httpRoutesMapDeclarationFile,
-  packageMappings,
-}: PikkuCLIConfig) => {
-  await logCommandInfoAndTime(
-    'Generating fetch wrapper',
-    'Generated fetch wrapper',
-    [fetchFile === undefined, "fetchFile isn't set in the pikku config"],
-    async () => {
-      if (!fetchFile) {
-        throw new Error("fetchFile is isn't set in the pikku config")
-      }
-
-      const routesMapDeclarationPath = getFileImportRelativePath(
-        fetchFile,
-        httpRoutesMapDeclarationFile,
-        packageMappings
-      )
-
-      const content = [serializeFetchWrapper(routesMapDeclarationPath)]
-      await writeFileInDir(fetchFile, content.join('\n'))
-    }
-  )
-}
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { pikkuFetch } from '../src/events/fetch/index.js'
+import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
 
 export const action = async (options: PikkuCLIOptions): Promise<void> => {
-  logPikkuLogo()
+  const logger = new CLILogger({ logLogo: true })
   const cliConfig = await getPikkuCLIConfig(
     options.config,
     ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'],
-    options.tags,
+    {
+      tags: options.tags,
+      types: options.types,
+      directories: options.directories,
+    },
     true
   )
-  await pikkuFetch(cliConfig)
+  await pikkuFetch(logger, cliConfig)
 }
 
 export const fetch = (program: Command): void => {

package/bin/pikku-nextjs.ts

@@ -1,130 +1,29 @@
 import { Command } from 'commander'
-import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from '../src/serialize-nextjs-backend-wrapper.js'
-import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from '../src/serialize-nextjs-http-wrapper.js'
-import {
-  getFileImportRelativePath,
-  getPikkuFilesAndMethods,
-  logCommandInfoAndTime,
-  logPikkuLogo,
-  PikkuCLIOptions,
-  writeFileInDir,
-} from '../src/utils/utils.js'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
+import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
-
-export const pikkuNext = async (
-  {
-    nextBackendFile,
-    nextHTTPFile,
-    httpRoutesMapDeclarationFile,
-    packageMappings,
-    fetchFile,
-    bootstrapFiles,
-  }: PikkuCLIConfig,
-  visitState: InspectorState,
-  options: PikkuCLIOptions
-) => {
-  return await logCommandInfoAndTime(
-    'Generating nextjs wrapper',
-    'Generated nextjs wrapper',
-    [
-      nextBackendFile === undefined && nextHTTPFile === undefined,
-      'nextjs outfile is not defined',
-    ],
-    async () => {
-      if (!nextBackendFile && !nextHTTPFile) {
-        throw new Error(
-          'nextBackendFile or nextHTTPFile is required in pikku config for nextJS'
-        )
-      }
-
-      if (nextHTTPFile && !fetchFile) {
-        throw new Error(
-          'fetchFile is required in pikku config in order for nextJS http wrapper to work'
-        )
-      }
-
-      if (nextBackendFile) {
-        const {
-          pikkuConfigFactory,
-          singletonServicesFactory,
-          sessionServicesFactory,
-        } = await getPikkuFilesAndMethods(
-          visitState,
-          packageMappings,
-          nextBackendFile,
-          options,
-          {
-            config: true,
-            singletonServicesFactory: true,
-            sessionServicesFactory: true,
-          }
-        )
-
-        const pikkuConfigImport = `import { ${pikkuConfigFactory.variable} as createConfig } from '${getFileImportRelativePath(nextBackendFile, pikkuConfigFactory.file, packageMappings)}'`
-        const singletonServicesImport = `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${getFileImportRelativePath(nextBackendFile, singletonServicesFactory.file, packageMappings)}'`
-        const sessionServicesImport = `import { ${sessionServicesFactory.variable} as createSessionServices } from '${getFileImportRelativePath(nextBackendFile, sessionServicesFactory.file, packageMappings)}'`
-
-        const httpBootstrapPath = getFileImportRelativePath(
-          nextBackendFile,
-          bootstrapFiles.http,
-          packageMappings
-        )
-
-        const routesMapDeclarationPath = getFileImportRelativePath(
-          nextBackendFile,
-          httpRoutesMapDeclarationFile,
-          packageMappings
-        )
-
-        const content = serializeNextBackendWrapper(
-          httpBootstrapPath,
-          routesMapDeclarationPath,
-          pikkuConfigImport,
-          singletonServicesImport,
-          sessionServicesImport
-        )
-        await writeFileInDir(nextBackendFile, content)
-      }
-
-      if (nextHTTPFile && fetchFile) {
-        const routesMapDeclarationPath = getFileImportRelativePath(
-          nextHTTPFile,
-          httpRoutesMapDeclarationFile,
-          packageMappings
-        )
-
-        const fetchPath = getFileImportRelativePath(
-          nextHTTPFile,
-          fetchFile,
-          packageMappings
-        )
-
-        const content = serializeNextHTTPWrapper(
-          routesMapDeclarationPath,
-          fetchPath
-        )
-        await writeFileInDir(nextHTTPFile, content)
-      }
-    }
-  )
-}
+import { pikkuNext } from '../src/runtimes/nextjs/pikku-command-nextjs.js'
 
 export const action = async (options: PikkuCLIOptions): Promise<void> => {
-  logPikkuLogo()
+  const logger = new CLILogger({ logLogo: true })
+
   const cliConfig = await getPikkuCLIConfig(
     options.config,
     ['rootDir', 'schemaDirectory', 'configDir'],
-    options.tags,
+    {
+      tags: options.tags,
+      types: options.types,
+      directories: options.directories,
+    },
     true
   )
   const visitState = await inspectorGlob(
+    logger,
     cliConfig.rootDir,
     cliConfig.srcDirectories,
     cliConfig.filters
   )
-  await pikkuNext(cliConfig, visitState, options)
+  await pikkuNext(logger, cliConfig, visitState, options)
 }
 
 export const nextjs = (program: Command): void => {