wattpm 2.72.0 → 3.0.0-alpha.1

package/bin/wattpm.js

@@ -4,6 +4,6 @@ import { checkNodeVersionForServices } from '@platformatic/utils'
 
 checkNodeVersionForServices()
 
-// Use await import here so that we can throw a proprer error on unsupported Node.js version
+// Use await import here so that we can throw a proper error on unsupported Node.js version
 const { main } = await import('../index.js')
 await main()

package/index.js

@@ -1,3 +1,4 @@
+import * as colorette from 'colorette'
 import { bold } from 'colorette'
 import { adminCommand } from './lib/commands/admin.js'
 import { buildCommand, installCommand, updateCommand } from './lib/commands/build.js'
@@ -10,8 +11,11 @@ import { logsCommand } from './lib/commands/logs.js'
 import { configCommand, envCommand, psCommand, servicesCommand } from './lib/commands/management.js'
 import { metricsCommand } from './lib/commands/metrics.js'
 import { patchConfigCommand } from './lib/commands/patch-config.js'
+import { getExecutableId } from './lib/embedding.js'
 import { version } from './lib/schema.js'
-import { createLogger, logFatalError, parseArgs, setVerbose } from './lib/utils.js'
+import { createLogger, loadServicesCommands, logFatalError, parseArgs, setVerbose } from './lib/utils.js'
+
+export * from './lib/embedding.js'
 
 export async function main () {
   globalThis.platformatic = { executable: 'watt' }
@@ -52,7 +56,9 @@ export async function main () {
   }
 
   let command
-  switch (unparsed[0] || 'help') {
+  const requestedCommand = unparsed[0] || 'help'
+  let serviceCommandContext
+  switch (requestedCommand) {
     case 'build':
       command = buildCommand
       break
@@ -119,15 +125,34 @@ export async function main () {
       command = adminCommand
       break
     default:
-      logFatalError(
-        logger,
-        `Unknown command ${bold(unparsed[0])}. Please run ${bold("'wattpm help'")} to see available commands.`
-      )
+      if (requestedCommand) {
+        const servicesCommands = await loadServicesCommands()
+        const serviceCommand = servicesCommands.commands[requestedCommand]
+
+        if (serviceCommand) {
+          serviceCommandContext = servicesCommands.services[requestedCommand]
+          command = serviceCommand
+        }
+      }
 
       break
   }
 
-  await command(logger, unparsed.slice(1))
+  if (!command) {
+    logFatalError(
+      logger,
+      `Unknown command ${bold(requestedCommand)}. Please run ${bold(`"${getExecutableId()} help"`)} to see available commands.`
+    )
+
+    return
+  }
+
+  if (serviceCommandContext) {
+    process.chdir(serviceCommandContext.path)
+    return command(logger, serviceCommandContext.config, unparsed.slice(1), { colorette, parseArgs, logFatalError })
+  } else {
+    await command(logger, unparsed.slice(1))
+  }
 }
 
 export * from './lib/schema.js'

package/lib/commands/admin.js

@@ -1,6 +1,5 @@
 import { spawn } from 'node:child_process'
-import { parseArgs } from '../utils.js'
-import { getPackageManager } from '@platformatic/utils'
+import { getPackageManager, parseArgs } from '../utils.js'
 
 export function adminCommand (logger, args) {
   let {

package/lib/commands/build.js

@@ -1,4 +1,5 @@
-import { ensureLoggableError, getPackageManager } from '@platformatic/utils'
+import { loadConfiguration } from '@platformatic/runtime'
+import { ensureLoggableError } from '@platformatic/utils'
 import { bold } from 'colorette'
 import { parse } from 'dotenv'
 import { execa } from 'execa'
@@ -11,8 +12,8 @@ import {
   buildRuntime,
   findRuntimeConfigurationFile,
   getPackageArgs,
+  getPackageManager,
   getRoot,
-  loadRuntimeConfigurationFile,
   logFatalError,
   parseArgs
 } from '../utils.js'
@@ -39,7 +40,7 @@ async function executeCommand (root, ...args) {
 
 export async function installDependencies (logger, root, services, production, packageManager) {
   if (typeof services === 'string') {
-    const config = await loadRuntimeConfigurationFile(logger, services)
+    const config = await loadConfiguration(services, null, { validate: false })
 
     if (!config) {
       return
@@ -180,7 +181,7 @@ export async function buildCommand (logger, args) {
     )
     const root = getRoot(positionals)
 
-    configurationFile = await findRuntimeConfigurationFile(logger, root, config, true)
+    configurationFile = await findRuntimeConfigurationFile(logger, root, config)
 
     /* c8 ignore next 3 - Hard to test */
     if (!configurationFile) {
@@ -251,7 +252,7 @@ export async function installCommand (logger, args) {
   )
 
   const root = getRoot(positionals)
-  const configurationFile = await findRuntimeConfigurationFile(logger, root, config, true)
+  const configurationFile = await findRuntimeConfigurationFile(logger, root, config)
 
   /* c8 ignore next 3 - Hard to test */
   if (!configurationFile) {
@@ -285,14 +286,14 @@ export async function updateCommand (logger, args) {
   )
 
   const root = getRoot(positionals)
-  const configurationFile = await findRuntimeConfigurationFile(logger, root, config, true)
+  const configurationFile = await findRuntimeConfigurationFile(logger, root, config)
 
   /* c8 ignore next 3 - Hard to test */
   if (!configurationFile) {
     return
   }
 
-  const configuration = await loadRuntimeConfigurationFile(logger, configurationFile)
+  const configuration = await loadConfiguration(configurationFile)
 
   if (!configuration) {
     return
@@ -373,7 +374,7 @@ export const help = {
   },
   update: {
     usage: 'update [root]',
-    description: 'Updates all the Platformatic packages to the latest available version.',
+    description: 'Updates all the Platformatic packages to the latest available version',
     args: [
       {
         name: 'root',

package/lib/commands/create.js

@@ -1,7 +1,7 @@
-import { getPackageManager } from '@platformatic/utils'
 import { createApplication, getUsername, getVersion, say } from 'create-platformatic'
 import { resolve } from 'node:path'
-import { parseArgs } from '../utils.js'
+import { getExecutableName } from '../embedding.js'
+import { getPackageManager, parseArgs } from '../utils.js'
 import { installDependencies } from './build.js'
 
 export async function createCommand (logger, args) {
@@ -46,15 +46,16 @@ export async function createCommand (logger, args) {
   )
 
   if (!packageManager) {
-    packageManager = getPackageManager(process.cwd(), null)
+    packageManager = getPackageManager(process.cwd())
   }
 
   const username = await getUsername()
   const version = await getVersion()
 
-  /* c8 ignore next 2 - Ignoring else branches */
+  /* c8 ignore next 3 - Ignoring else branches */
+  const executableName = getExecutableName()
   const greeting = username ? `Hello ${username},` : 'Hello,'
-  await say(`${greeting} welcome to ${version ? `Watt ${version}!` : 'Watt!'}`)
+  await say(`${greeting} welcome to ${version ? `${executableName} ${version}!` : `${executableName}!`}`)
 
   await createApplication(
     logger,
@@ -79,7 +80,9 @@ export async function createCommand (logger, args) {
 }
 
 const createHelp = {
-  description: 'Creates a new Watt project',
+  description () {
+    return `Creates a new ${getExecutableName()} project`
+  },
   options: [
     {
       usage: '-c, --config <config>',

package/lib/commands/execution.js

@@ -1,17 +1,10 @@
 import { RuntimeApiClient } from '@platformatic/control'
-import { startCommand as pltStartCommand } from '@platformatic/runtime'
+import { create } from '@platformatic/runtime'
 import { ensureLoggableError, FileWatcher } from '@platformatic/utils'
 import { bold } from 'colorette'
 import { spawn } from 'node:child_process'
 import { on } from 'node:events'
-import {
-  findRuntimeConfigurationFile,
-  getMatchingRuntime,
-  getRoot,
-  handleRuntimeError,
-  logFatalError,
-  parseArgs
-} from '../utils.js'
+import { findRuntimeConfigurationFile, getMatchingRuntime, getRoot, logFatalError, parseArgs } from '../utils.js'
 
 export async function devCommand (logger, args) {
   const {
@@ -29,33 +22,24 @@ export async function devCommand (logger, args) {
   )
   const root = getRoot(positionals)
 
-  const configurationFile = await findRuntimeConfigurationFile(logger, root, config, true)
+  const configurationFile = await findRuntimeConfigurationFile(logger, root, config)
 
   /* c8 ignore next 3 - Hard to test */
   if (!configurationFile) {
     return
   }
 
-  let runtime
-  try {
-    runtime = await pltStartCommand(['-c', configurationFile], true, true)
-  } catch (error) {
-    if (await handleRuntimeError(logger, configurationFile, error)) {
-      return
-      /* c8 ignore next 4 - Hard to test */
-    }
-
-    throw error
-  }
+  let runtime = await create(root, configurationFile, { start: true })
 
   // Add a watcher on the configurationFile so that we can eventually restart the runtime
   const watcher = new FileWatcher({ path: configurationFile })
   watcher.startWatching()
+
   // eslint-disable-next-line no-unused-vars
   for await (const _ of on(watcher, 'update')) {
     runtime.logger.info('The configuration file has changed, reloading the application ...')
     await runtime.close()
-    runtime = await pltStartCommand(['-c', configurationFile], true, true)
+    runtime = await create(root, configurationFile, { start: true })
   }
   /* c8 ignore next - Mistakenly reported as uncovered by C8 */
 }
@@ -80,28 +64,14 @@ export async function startCommand (logger, args) {
   )
 
   const root = getRoot(positionals)
-  const configurationFile = await findRuntimeConfigurationFile(logger, root, config, true)
+  const configurationFile = await findRuntimeConfigurationFile(logger, root, config)
 
   /* c8 ignore next 3 - Hard to test */
   if (!configurationFile) {
     return
   }
 
-  const cmd = ['--production', '-c', configurationFile]
-  if (inspect) {
-    cmd.push('--inspect')
-  }
-
-  try {
-    await pltStartCommand(cmd, true)
-  } catch (error) {
-    if (await handleRuntimeError(logger, configurationFile, error)) {
-      return
-      /* c8 ignore next 4 - Hard to test */
-    }
-
-    throw error
-  }
+  await create(root, configurationFile, { start: true, production: true, inspect })
 }
 
 export async function stopCommand (logger, args) {

package/lib/commands/external.js

@@ -1,24 +1,20 @@
+import { loadConfiguration } from '@platformatic/runtime'
 import {
-  ConfigManager,
+  detectApplicationType,
+  ensureLoggableError,
+  findConfigurationFile,
   loadConfigurationFile as loadRawConfigurationFile,
   saveConfigurationFile
-} from '@platformatic/config'
-import { detectApplicationType, ensureLoggableError } from '@platformatic/utils'
+} from '@platformatic/utils'
 import { bold } from 'colorette'
 import { parse } from 'dotenv'
 import { execa } from 'execa'
 import { existsSync } from 'node:fs'
 import { readFile, writeFile } from 'node:fs/promises'
 import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path'
+import { getExecutableId } from '../embedding.js'
 import { version } from '../schema.js'
-import {
-  findRuntimeConfigurationFile,
-  getRoot,
-  loadRuntimeConfigurationFile,
-  logFatalError,
-  parseArgs,
-  serviceToEnvVariable
-} from '../utils.js'
+import { findRuntimeConfigurationFile, getRoot, logFatalError, parseArgs, serviceToEnvVariable } from '../utils.js'
 import { installDependencies } from './build.js'
 
 const originCandidates = ['origin', 'upstream']
@@ -75,7 +71,7 @@ export async function appendEnvVariable (envFile, key, value) {
 }
 
 async function fixConfiguration (logger, root, configOption, skipDependencies, packageManager) {
-  const configurationFile = await findRuntimeConfigurationFile(logger, root, configOption, true)
+  const configurationFile = await findRuntimeConfigurationFile(logger, root, configOption, true, true, false)
 
   /* c8 ignore next 3 - Hard to test */
   if (!configurationFile) {
@@ -99,7 +95,7 @@ async function fixConfiguration (logger, root, configOption, skipDependencies, p
     const path = resolve(root)
     services = [{ path, id: basename(path) }]
   } else {
-    const config = await loadRuntimeConfigurationFile(logger, configurationFile)
+    const config = await loadConfiguration(configurationFile)
 
     /* c8 ignore next 3 - Hard to test */
     if (!config) {
@@ -111,7 +107,7 @@ async function fixConfiguration (logger, root, configOption, skipDependencies, p
 
   // For each service, if there is no watt.json, create one and fix package dependencies
   for (const { path } of services) {
-    const wattConfiguration = await ConfigManager.findConfigFile(path, 'application')
+    const wattConfiguration = await findConfigurationFile(path, 'application')
 
     const appType = await parseLocalFolder(resolve(root, path))
 
@@ -156,7 +152,7 @@ async function fixConfiguration (logger, root, configOption, skipDependencies, p
 }
 
 async function importService (logger, configurationFile, id, path, url, branch) {
-  const config = await loadRuntimeConfigurationFile(logger, configurationFile)
+  const config = await loadConfiguration(configurationFile)
 
   /* c8 ignore next 3 - Hard to test */
   if (!config) {
@@ -271,7 +267,7 @@ async function importLocal (logger, root, configurationFile, path, overridenId)
   }
 
   // Check if there is any configuration file we recognize. If so, don't do anything
-  const wattConfiguration = await ConfigManager.findConfigFile(path, 'application')
+  const wattConfiguration = await findConfigurationFile(path, 'application')
 
   if (wattConfiguration) {
     /* c8 ignore next */
@@ -305,7 +301,7 @@ export async function resolveServices (
   skipDependencies,
   packageManager
 ) {
-  const config = await loadRuntimeConfigurationFile(logger, configurationFile)
+  const config = await loadConfiguration(configurationFile)
 
   if (!config) {
     return
@@ -465,7 +461,7 @@ export async function importCommand (logger, args) {
     rawUrl = positionals[1]
   }
 
-  const configurationFile = await findRuntimeConfigurationFile(logger, root, config, true)
+  const configurationFile = await findRuntimeConfigurationFile(logger, root, config)
 
   /* c8 ignore next 3 - Hard to test */
   if (!configurationFile) {
@@ -520,7 +516,7 @@ export async function resolveCommand (logger, args) {
   )
 
   const root = getRoot(positionals)
-  const configurationFile = await findRuntimeConfigurationFile(logger, root, config, true)
+  const configurationFile = await findRuntimeConfigurationFile(logger, root, config)
 
   /* c8 ignore next 3 - Hard to test */
   if (!configurationFile) {
@@ -614,11 +610,12 @@ export const help = {
         description: 'Use an alternative package manager (the default is to autodetect it)'
       }
     ],
-    footer: `
-wattpm resolve command resolves runtime services that have the \`url\` in their configuration.
+    footer () {
+      return `
+${getExecutableId()} resolve command resolves runtime services that have the \`url\` in their configuration.
 To change the directory where a service is cloned, you can set the \`path\` property in the service configuration.
 
-After cloning the service, the resolve command will set the relative path to the service in the wattpm configuration file.
+After cloning the service, the resolve command will set the relative path to the service in the Platformatic configuration file.
 
 Example of the runtime \`watt.json\` configuration file:
 
@@ -669,5 +666,6 @@ You can find more details about the configuration format here:
 * [Platformatic DB Configuration](https://docs.platformatic.dev/docs/db/configuration)
 * [Platformatic Service Configuration](https://docs.platformatic.dev/docs/service/configuration)
     `
+    }
   }
 }

package/lib/commands/help.js

@@ -1,6 +1,11 @@
-import { bold, isColorSupported } from 'colorette'
+import { bold } from 'colorette'
+import { getExecutableId, getExecutableName } from '../embedding.js'
 import { logo } from '../logo.js'
-import { logFatalError } from '../utils.js'
+import { loadServicesCommands, logFatalError } from '../utils.js'
+
+function sanitizeHelp (raw) {
+  return (typeof raw === 'function' ? raw() : raw).trim()
+}
 
 async function loadCommands () {
   const commands = {}
@@ -26,36 +31,61 @@ async function loadCommands () {
   return commands
 }
 
-async function showGeneralHelp () {
+export async function showGeneralHelp (logger) {
+  if (typeof logger !== 'function') {
+    logger = console.log
+  }
+
+  const executableId = getExecutableId()
   const commands = Object.values(await loadCommands())
+  const servicesCommands = Object.values((await loadServicesCommands()).help)
+
   const options = [
-    { usage: '-V, --version', description: 'Show wattpm version' },
+    { usage: '-V, --version', description: `Show ${executableId} version` },
     { usage: '-v, --verbose', description: 'Show more information' },
     { usage: '--help', description: 'Show this help' }
   ]
 
-  console.log('\nUsage: wattpm [options] [command]\n')
+  logger(logo())
+  logger(`\nUsage: ${executableId} [options] [command]\n`)
 
   // Compute the maximum length of options or commands
-  const maximumLength = Math.max(...options.map(c => c.usage.length), ...commands.map(c => c.usage.length)) + 5
+  const maximumLength =
+    Math.max(
+      ...options.map(c => c.usage.length),
+      ...commands.map(c => c.usage.length),
+      ...servicesCommands.map(c => c.usage.length)
+    ) + 5
 
   // Print all options
-  console.log('Options:\n')
+  logger('Options:\n')
   for (const { usage, description } of options) {
-    console.log(`  ${usage.padEnd(maximumLength, ' ')} ${description}`)
+    logger(`  ${usage.padEnd(maximumLength, ' ')} ${sanitizeHelp(description)}`)
   }
-  console.log('')
+  logger('')
 
   // Print all commands
-  console.log('Commands:\n')
+  logger('Commands:\n')
   for (const { usage, description } of commands) {
-    console.log(`  ${usage.padEnd(maximumLength, ' ')} ${description}`)
+    logger(`  ${usage.padEnd(maximumLength, ' ')} ${sanitizeHelp(description)}`)
+  }
+  logger('')
+
+  if (servicesCommands.length) {
+    logger('Services Commands:\n')
+    for (const { usage, description } of servicesCommands) {
+      logger(`  ${usage.padEnd(maximumLength, ' ')} ${sanitizeHelp(description)})`)
+    }
+    logger('')
   }
-  console.log('')
 }
 
-function showHelp (command) {
-  console.log(`\nUsage: wattpm ${command.usage}\n\n${command.description}.\n`)
+export function showHelp (command, logger) {
+  if (typeof logger !== 'function') {
+    logger = console.log
+  }
+
+  logger(`\nUsage: ${getExecutableId()} ${sanitizeHelp(command.usage)}\n\n${sanitizeHelp(command.description)}.\n`)
 
   let { options, args } = command
   options ??= []
@@ -66,24 +96,24 @@ function showHelp (command) {
 
   // Print all options
   if (options.length) {
-    console.log('Options:\n')
+    logger('Options:\n')
     for (const { usage, description } of options) {
-      console.log(`  ${usage.padEnd(maximumLength, ' ')} ${description}`)
+      logger(`  ${usage.padEnd(maximumLength, ' ')} ${sanitizeHelp(description)}`)
     }
-    console.log('')
+    logger('')
   }
 
   // Print all arguments
   if (args.length) {
-    console.log('Arguments:\n')
+    logger('Arguments:\n')
     for (const { name, description } of args) {
-      console.log(`  ${name.padEnd(maximumLength, ' ')} ${description}`)
+      logger(`  ${name.padEnd(maximumLength, ' ')} ${sanitizeHelp(description)}`)
     }
-    console.log('')
+    logger('')
   }
 
   if (command.footer) {
-    console.log(command.footer.trim() + '\n')
+    logger(sanitizeHelp(command.footer) + '\n')
   }
 }
 
@@ -91,19 +121,21 @@ export async function helpCommand (logger, args) {
   const command = args?.[0]
 
   if (!command) {
-    /* c8 ignore next 3 - Hard to test */
-    if (isColorSupported && process.stdout.isTTY) {
-      console.log(logo)
-    }
-
     return showGeneralHelp()
   }
 
   const commands = await loadCommands()
   if (!commands[command]) {
+    const servicesCommands = (await loadServicesCommands()).help
+
+    if (servicesCommands[command]) {
+      // If the command is a service command, we show the help for that command
+      return showHelp(servicesCommands[command])
+    }
+
     return logFatalError(
       logger,
-      `Unknown command ${bold(command)}. Please run ${bold("'wattpm help'")} to see available commands.`
+      `Unknown command ${bold(command)}. Please run ${bold(`"${getExecutableId()} help"`)} to see available commands.`
     )
   }
 
@@ -111,6 +143,16 @@ export async function helpCommand (logger, args) {
 }
 
 export const help = {
-  help: { usage: 'help [command]', description: 'Show help about Watt or one of its commands' },
-  version: { usage: 'version', description: 'Show current Watt version' }
+  help: {
+    usage: 'help [command]',
+    description () {
+      return `Show help about ${getExecutableName()} or one of its commands`
+    }
+  },
+  version: {
+    usage: 'version',
+    description () {
+      return `Show current ${getExecutableName()} version`
+    }
+  }
 }

package/lib/commands/inject.js

@@ -114,6 +114,7 @@ export async function injectCommand (logger, args) {
     if (response.statusCode === 500) {
       const json = JSON.parse(responseBody)
 
+      /* c8 ignore next - else */
       if (json?.code === 'PLT_RUNTIME_SERVICE_NOT_FOUND' || json?.code === 'PLT_RUNTIME_SERVICE_WORKER_NOT_FOUND') {
         const error = new Error('Cannot find a service.')
         error.code = 'PLT_CTR_SERVICE_NOT_FOUND'

package/lib/commands/patch-config.js

@@ -1,25 +1,21 @@
 import {
-  ConfigManager,
+  ensureLoggableError,
+  extractModuleFromSchemaUrl,
   getParser,
   getStringifier,
+  listRecognizedConfigurationFiles,
   loadConfigurationFile,
+  loadModule,
+  safeRemove,
   saveConfigurationFile
-} from '@platformatic/config'
-import { ensureLoggableError, loadModule, safeRemove } from '@platformatic/utils'
+} from '@platformatic/utils'
 import jsonPatch from 'fast-json-patch'
 import { existsSync } from 'node:fs'
 import { mkdtemp, readFile, writeFile } from 'node:fs/promises'
 import { createRequire } from 'node:module'
 import { tmpdir } from 'node:os'
 import { resolve } from 'node:path'
-import {
-  buildRuntime,
-  findRuntimeConfigurationFile,
-  getRoot,
-  loadConfigurationFileAsConfig,
-  logFatalError,
-  parseArgs
-} from '../utils.js'
+import { buildRuntime, findRuntimeConfigurationFile, getRoot, logFatalError, parseArgs } from '../utils.js'
 
 async function patchFile (path, patch) {
   let config = getParser(path)(await readFile(path, 'utf-8'))
@@ -31,14 +27,15 @@ export async function patchConfig (logger, configurationFile, patchPath) {
   let runtime
   try {
     // Determine if the configuration file is for a service or a runtime
-    const config = await loadConfigurationFileAsConfig(logger, configurationFile)
+    const config = await loadConfigurationFile(configurationFile)
 
     /* c8 ignore next 3 - Hard to test */
     if (!config) {
       return false
     }
 
-    const isService = config.configType !== 'runtime'
+    const mod = extractModuleFromSchemaUrl(config)
+    const isService = mod.module !== '@platformatic/runtime'
 
     const patchFunction = await loadModule(createRequire(configurationFile), patchPath)
 
@@ -55,8 +52,9 @@ export async function patchConfig (logger, configurationFile, patchPath) {
     }
 
     // Prepare the structure for original and modified configurations files
+    const parser = getParser(configurationFile)
     const original = {
-      runtime: getParser(configurationFile)(await readFile(configurationFile, 'utf-8')),
+      runtime: parser(await readFile(configurationFile, 'utf-8')),
       services: {}
     }
 
@@ -70,7 +68,7 @@ export async function patchConfig (logger, configurationFile, patchPath) {
     // Load configuration for all services
     for (const service of loaded.runtime.services) {
       if (!service.config) {
-        const candidate = ConfigManager.listConfigFiles().find(f => existsSync(resolve(service.path, f)))
+        const candidate = listRecognizedConfigurationFiles().find(f => existsSync(resolve(service.path, f)))
 
         if (candidate) {
           service.config = resolve(service.path, candidate)
@@ -161,7 +159,7 @@ export async function patchConfigCommand (logger, args) {
     patch = positionals[1]
   }
 
-  const configurationFile = await findRuntimeConfigurationFile(logger, root, config, true)
+  const configurationFile = await findRuntimeConfigurationFile(logger, root, config)
 
   /* c8 ignore next 3 */
   if (!configurationFile) {
@@ -186,7 +184,7 @@ export async function patchConfigCommand (logger, args) {
 export const help = {
   'patch-config': {
     usage: 'patch-config [root] [patch]',
-    description: 'Applies a patch file to the runtime and services configurations.',
+    description: 'Applies a patch file to the runtime and services configurations',
     args: [
       {
         name: 'root',

package/lib/embedding.js

@@ -0,0 +1,15 @@
+let executableId = process.env.WATTPM_EXECUTABLE_ID ?? 'wattpm'
+let executableName = process.env.WATTPM_EXECUTABLE_NAME ?? 'Watt'
+
+export function getExecutableId () {
+  return executableId
+}
+
+export function getExecutableName () {
+  return executableName
+}
+
+export function setExecutableParameters (id, name) {
+  executableId = id
+  executableName = name
+}

package/lib/logo.js

@@ -1,6 +1,9 @@
-import { bold, green } from 'colorette'
+import { bold, green, isColorSupported } from 'colorette'
+import { getExecutableName } from './embedding.js'
 
-const str = `
+export function logo () {
+  const executableName = isColorSupported ? bold(getExecutableName()) : getExecutableName()
+  const str = `
 
                                   //////
                                /////////////
@@ -30,7 +33,9 @@ const str = `
                               &&&&&&&&&&&&&
                                   &&&&&&
 
-                            Welcome to ${bold('Watt')}!
+                            Welcome to ${executableName}!
 `
 
-export const logo = str.replace(/\//g, s => green(s))
+  /* c8 ignore next - else */
+  return isColorSupported ? str.replace(/\//g, s => green(s)) : str
+}

package/lib/packages.js

@@ -5,7 +5,6 @@ export const packages = [
   '@platformatic/client',
   '@platformatic/client-cli',
   '@platformatic/composer',
-  '@platformatic/config',
   '@platformatic/control',
   '@platformatic/db',
   '@platformatic/db-authorization',

package/lib/utils.js

@@ -1,28 +1,23 @@
-import {
-  findConfigurationFile,
-  loadConfig,
-  loadConfigurationFile,
-  saveConfigurationFile,
-  Store
-} from '@platformatic/config'
 import { errors } from '@platformatic/control'
-import { platformaticRuntime, buildRuntime as pltBuildRuntime, wrapConfigInRuntimeConfig } from '@platformatic/runtime'
+import { create, loadConfiguration } from '@platformatic/runtime'
 import {
+  abstractLogger,
   detectApplicationType,
-  ensureLoggableError,
-  escapeRegexp,
+  findConfigurationFileRecursive,
   hasJavascriptFiles,
-  kFailedImport
+  loadConfigurationModule,
+  saveConfigurationFile,
+  loadConfiguration as utilsLoadConfiguration
 } from '@platformatic/utils'
 import { bgGreen, black, bold } from 'colorette'
+import { existsSync } from 'node:fs'
 import { resolve } from 'node:path'
 import { parseArgs as nodeParseArgs } from 'node:util'
 import { pino } from 'pino'
 import pinoPretty from 'pino-pretty'
+import { getExecutableName } from './embedding.js'
 import { version } from './schema.js'
 
-const autoGeneratedSchemaMatcher = `^${escapeRegexp('https://schemas.platformatic.dev/')}@/(.+)\\?autogenerated=true$`
-
 export let verbose = false
 
 export function setVerbose (value) {
@@ -94,6 +89,18 @@ export function parseArgs (args, options, stopAtFirstPositional = true) {
   }
 }
 
+export function getPackageManager (root, defaultManager = 'npm') {
+  if (existsSync(resolve(root, 'pnpm-lock.yaml'))) {
+    return 'pnpm'
+  }
+
+  if (existsSync(resolve(root, 'yarn.lock'))) {
+    return 'yarn'
+  }
+
+  return defaultManager
+}
+
 export function getPackageArgs (packageManager, production) {
   const args = ['install']
   if (production) {
@@ -155,87 +162,48 @@ export function serviceToEnvVariable (service) {
   return `PLT_SERVICE_${service.toUpperCase().replaceAll(/[^A-Z0-9_]/g, '_')}_PATH`
 }
 
-export async function findRuntimeConfigurationFile (logger, root, configurationFile, fallback = false) {
-  let configFile = await findConfigurationFile(root, configurationFile, 'runtime')
+export async function findRuntimeConfigurationFile (
+  logger,
+  root,
+  configurationFile,
+  fallback = true,
+  throwOnError = true,
+  verifyPackages = true
+) {
+  let configFile = await findConfigurationFileRecursive(root, configurationFile, '@platformatic/runtime')
 
   // If a runtime was not found, search for service file that we wrap in a runtime
   if (!configFile && !configurationFile) {
-    configFile = await findConfigurationFile(root, configurationFile)
+    configFile = await findConfigurationFileRecursive(root, configurationFile)
   }
 
   if (!configFile) {
     if (fallback) {
-      configurationFile = await fallbackToTemporaryConfigFile(logger, root)
+      configurationFile = await fallbackToTemporaryConfigFile(logger, root, verifyPackages)
 
-      if (configurationFile) {
+      if (configurationFile || configurationFile === false) {
         return configurationFile
       }
     }
 
-    return logFatalError(
-      logger,
-      `Cannot find a supported Watt configuration file (like ${bold('watt.json')}, a ${bold('wattpm.json')} or a ${bold(
-        'platformatic.json'
-      )}) in ${bold(resolve(root))}.`
-    )
+    if (throwOnError) {
+      return logFatalError(
+        logger,
+        `Cannot find a supported ${getExecutableName()} configuration file (like ${bold('watt.json')}, a ${bold('wattpm.json')} or a ${bold(
+          'platformatic.json'
+        )}) in ${bold(resolve(root))}.`
+      )
+    }
   }
 
   return configFile
 }
 
 export async function loadConfigurationFileAsConfig (logger, configurationFile) {
-  const store = new Store()
-  store.add(platformaticRuntime)
-
-  const args = ['-c', configurationFile]
-  const options = { allowInvalid: true, transformOnValidationErrors: true }
-
-  try {
-    return await loadConfig(
-      {},
-      args,
-      store,
-      {
-        /* c8 ignore next 3 */
-        onMissingEnv () {
-          return ''
-        }
-      },
-      true,
-      logger,
-      options
-    )
-  } catch (error) {
-    if (await handleRuntimeError(logger, configurationFile, error)) {
-      return false
-      /* c8 ignore next 4 - Hard to test */
-    }
-
-    throw error
-  }
+  return loadConfiguration(configurationFile, null, { validate: false })
 }
 
-export async function loadRuntimeConfigurationFile (logger, configurationFile) {
-  const config = await loadConfigurationFileAsConfig(logger, configurationFile)
-
-  if (!config) {
-    return false
-  }
-
-  const args = ['-c', configurationFile]
-  const options = { allowInvalid: true, transformOnValidationErrors: true }
-
-  if (config.configType !== 'runtime') {
-    const configManager = await wrapConfigInRuntimeConfig(config, args, options)
-    config.configManager = configManager
-  }
-
-  config.configManager.args = config.args
-
-  return config.configManager.current
-}
-
-export async function fallbackToTemporaryConfigFile (logger, root) {
+export async function fallbackToTemporaryConfigFile (logger, root, verifyPackages) {
   if (await hasJavascriptFiles(root)) {
     const { name, label } = await detectApplicationType(root)
 
@@ -251,63 +219,79 @@ export async function fallbackToTemporaryConfigFile (logger, root) {
     const configurationFile = resolve(root, 'watt.json')
     await saveConfigurationFile(configurationFile, { $schema: schema })
 
+    // Try to load the module, if it is missing, we will throw an error
+    if (verifyPackages) {
+      try {
+        await loadConfigurationModule(root, { $schema: schema })
+      } catch (error) {
+        logFatalError(logger, `Cannot load module ${bold(name)}. Please add it to your package.json and try again.`)
+        return false
+      }
+    }
+
     return configurationFile
   }
 }
 
 export async function buildRuntime (logger, configurationFile) {
-  const store = new Store()
-  store.add(platformaticRuntime)
-
-  const args = ['-c', configurationFile]
-
-  let config
-
+  let runtime
   try {
-    config = await loadConfig({}, args, store, {}, true, logger)
+    runtime = await create(configurationFile)
+    await runtime.init()
+    /* c8 ignore next 3 - Hard to test */
   } catch (error) {
-    if (await handleRuntimeError(logger, configurationFile, error)) {
-      return false
-      /* c8 ignore next 4 - Hard to test */
-    }
+    await runtime.close()
 
-    throw error
+    return false
   }
 
-  if (config.configType !== 'runtime') {
-    const configManager = await wrapConfigInRuntimeConfig(config, args)
-    config.configManager = configManager
-  }
+  return runtime
+}
 
-  config.configManager.args = config.args
+export async function loadServicesCommands () {
+  const services = {}
+  const commands = {}
+  const help = {}
 
-  let runtime
+  let config
   try {
-    runtime = await pltBuildRuntime(config.configManager)
+    const file = await findRuntimeConfigurationFile(abstractLogger, process.cwd(), null, false, false)
+
     /* c8 ignore next 3 - Hard to test */
-  } catch (error) {
-    logFatalError(logger, { err: ensureLoggableError(error) }, 'Error creating the runtime')
-  }
+    if (!file) {
+      throw new Error('No runtime configuration file found.')
+    }
 
-  return runtime
-}
+    config = await loadConfiguration(file)
 
-export async function handleRuntimeError (logger, configurationFile, error) {
-  const failedModule = error[kFailedImport]
+    /* c8 ignore next 3 - Hard to test */
+    if (!config) {
+      throw new Error('No runtime configuration file found.')
+    }
+  } catch {
+    return { services, commands, help }
+  }
 
-  if (failedModule) {
-    const config = await loadConfigurationFile(configurationFile)
+  for (const service of config.services) {
+    try {
+      const serviceConfig = await utilsLoadConfiguration(service.config)
+      const pkg = await loadConfigurationModule(service.path, serviceConfig)
 
-    if (config.$schema.match(new RegExp(autoGeneratedSchemaMatcher.replace('@', escapeRegexp(failedModule))))) {
-      logFatalError(
-        logger,
-        `Cannot load module ${bold(failedModule)}. Please add it to your package.json and try again.`
-      )
+      if (pkg.createCommands) {
+        const definition = await pkg.createCommands(service.id)
+        process._rawDebug(definition)
+        for (const command of Object.keys(definition.commands)) {
+          services[command] = service
+        }
 
-      return true
-      /* c8 ignore next 4 - Hard to test */
+        Object.assign(commands, definition.commands)
+        Object.assign(help, definition.help)
+      }
+      /* c8 ignore next 3 - Hard to test */
+    } catch {
+      // No-op, ignore the service
     }
   }
 
-  return false
+  return { services, commands, help }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wattpm",
-  "version": "2.72.0",
+  "version": "3.0.0-alpha.1",
   "description": "The Node.js Application Server",
   "main": "index.js",
   "type": "module",
@@ -36,11 +36,10 @@
     "semver": "^7.7.0",
     "split2": "^4.2.0",
     "table": "^6.8.2",
-    "@platformatic/config": "2.72.0",
-    "@platformatic/control": "2.72.0",
-    "@platformatic/runtime": "2.72.0",
-    "@platformatic/utils": "2.72.0",
-    "create-platformatic": "2.72.0"
+    "@platformatic/control": "3.0.0-alpha.1",
+    "@platformatic/runtime": "3.0.0-alpha.1",
+    "@platformatic/utils": "3.0.0-alpha.1",
+    "create-platformatic": "3.0.0-alpha.1"
   },
   "devDependencies": {
     "borp": "^0.20.0",
@@ -50,7 +49,7 @@
     "neostandard": "^0.12.0",
     "typescript": "^5.5.4",
     "undici": "^7.0.0",
-    "@platformatic/node": "2.72.0"
+    "@platformatic/node": "3.0.0-alpha.1"
   },
   "scripts": {
     "test": "npm run lint && borp --concurrency=1 --timeout=1200000",

package/schema.json

@@ -1,6 +1,7 @@
 {
-  "$id": "https://schemas.platformatic.dev/wattpm/2.72.0.json",
+  "$id": "https://schemas.platformatic.dev/wattpm/3.0.0-alpha.1.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Platformatic Runtime Config",
   "type": "object",
   "properties": {
     "$schema": {