wattpm 3.14.0 → 3.16.0

package/index.js

@@ -3,6 +3,7 @@ import { loadApplicationsCommands } from '@platformatic/runtime'
 import * as colorette from 'colorette'
 import { bold } from 'colorette'
 import { adminCommand } from './lib/commands/admin.js'
+import { applicationsAddCommand, applicationsRemoveCommand } from './lib/commands/applications.js'
 import { buildCommand } from './lib/commands/build.js'
 import { createCommand } from './lib/commands/create.js'
 import { devCommand, reloadCommand, restartCommand, startCommand, stopCommand } from './lib/commands/execution.js'
@@ -105,6 +106,12 @@ export async function main () {
     case 'pprof':
       command = pprofCommand
       break
+    case 'applications:add':
+      command = applicationsAddCommand
+      break
+    case 'applications:remove':
+      command = applicationsRemoveCommand
+      break
     case 'admin':
       command = adminCommand
       break

package/lib/commands/applications.js

@@ -0,0 +1,194 @@
+import { getMatchingRuntime, RuntimeApiClient } from '@platformatic/control'
+import { ensureLoggableError, logFatalError, parseArgs } from '@platformatic/foundation'
+import { bold } from 'colorette'
+import { readFile, stat, writeFile } from 'node:fs/promises'
+import { basename, isAbsolute, relative, resolve } from 'node:path'
+
+async function updateConfigFile (path, update) {
+  const contents = JSON.parse(await readFile(path, 'utf-8'))
+  await update(contents)
+  await writeFile(path, JSON.stringify(contents, null, 2), 'utf-8')
+}
+
+export async function applicationsAddCommand (logger, args) {
+  const {
+    values: { save },
+    positionals: allPositionals
+  } = parseArgs(
+    args,
+    {
+      save: {
+        type: 'boolean',
+        short: 's'
+      }
+    },
+    false
+  )
+
+  const client = new RuntimeApiClient()
+  try {
+    const [runtime, applications] = await getMatchingRuntime(client, allPositionals)
+    const config = await client.getRuntimeConfig(runtime.pid, true)
+    const root = config.__metadata.root
+
+    let toAdd = []
+    let added = 0
+
+    for (let app of applications) {
+      let spec
+
+      // Determine if app is a path to a directory or file, and load accordingly
+      try {
+        if (!isAbsolute(app)) {
+          app = resolve(root, app)
+        }
+
+        const pathStat = await stat(app)
+        if (pathStat.isDirectory()) {
+          spec = {
+            id: basename(app),
+            path: relative(root, app)
+          }
+        } else {
+          spec = JSON.parse(await readFile(app, 'utf-8'))
+        }
+      } catch (err) {
+        logFatalError(logger, `The path "${bold(app)}" does not exist or is not valid JSON.`)
+        return
+      }
+
+      const response = await client.addApplications(runtime.pid, spec, true)
+      added += response.length
+      toAdd = toAdd.concat(spec)
+    }
+
+    if (save) {
+      await updateConfigFile(config.__metadata.path, async config => {
+        config.applications = (config.applications ?? []).concat(toAdd)
+      })
+    }
+
+    logger.done(`Successfully added ${added} application${added > 1 ? 's' : ''} to the application.`)
+  } catch (error) {
+    if (error.code === 'PLT_CTR_RUNTIME_NOT_FOUND') {
+      return logFatalError(logger, 'Cannot find a matching runtime.')
+      /* c8 ignore next 7 - Hard to test */
+    } else {
+      return logFatalError(
+        logger,
+        { error: ensureLoggableError(error) },
+        `Cannot add applications to the application: ${error.message}`
+      )
+    }
+  } finally {
+    await client.close()
+  }
+}
+
+export async function applicationsRemoveCommand (logger, args) {
+  const {
+    values: { save },
+    positionals
+  } = parseArgs(
+    args,
+    {
+      save: {
+        type: 'boolean',
+        short: 's'
+      }
+    },
+    false
+  )
+
+  const client = new RuntimeApiClient()
+  try {
+    const [runtime, applications] = await getMatchingRuntime(client, positionals)
+
+    const removed = await client.removeApplications(runtime.pid, applications)
+
+    if (save) {
+      const config = await client.getRuntimeConfig(runtime.pid, true)
+      const absoluteAutoloadPath = resolve(config.__metadata.path, config.autoload.path)
+
+      await updateConfigFile(config.__metadata.path, async config => {
+        // Remove applications from all relevant sections
+        for (const app of removed) {
+          for (const section of ['applications', 'services', 'web']) {
+            if (Array.isArray(config[section])) {
+              config[section] = config[section].filter(a => a.id !== app.id)
+            }
+          }
+
+          if (config.autoload) {
+            if (app.path.startsWith(absoluteAutoloadPath)) {
+              config.autoload.exclude ??= []
+              config.autoload.exclude.push(relative(absoluteAutoloadPath, app.path))
+            }
+          }
+        }
+      })
+    }
+
+    logger.done(
+      `Successfully removed ${applications.length} application${applications.length > 1 ? 's' : ''} from the application.`
+    )
+  } catch (error) {
+    if (error.code === 'PLT_CTR_RUNTIME_NOT_FOUND') {
+      return logFatalError(logger, 'Cannot find a matching runtime.')
+      /* c8 ignore next 7 - Hard to test */
+    } else {
+      return logFatalError(
+        logger,
+        { error: ensureLoggableError(error) },
+        `Cannot remove applications from the application: ${error.message}`
+      )
+    }
+  } finally {
+    await client.close()
+  }
+}
+
+export const help = {
+  'applications:add': {
+    usage: 'applications:add [id] <path>',
+    description: 'Add new applications to a running application',
+    args: [
+      {
+        name: 'id',
+        description:
+          'The process ID or the name of the application (it can be omitted only if there is a single application running)'
+      },
+      {
+        name: 'path',
+        description: 'A folder containing an application or a JSON file containing the applications to add'
+      }
+    ],
+    options: [
+      {
+        usage: '-s, --save',
+        description: 'Save the added applications to the application configuration file'
+      }
+    ]
+  },
+  'applications:remove': {
+    usage: 'applications:remove [id] [applications...]',
+    description: 'Remove applications from a running application',
+    args: [
+      {
+        name: 'id',
+        description:
+          'The process ID or the name of the application (it can be omitted only if there is a single application running)'
+      },
+      {
+        name: 'applications',
+        description: 'The list of applications to remove'
+      }
+    ],
+    options: [
+      {
+        usage: '-s, --save',
+        description: 'Remove the removed applications from the application configuration file'
+      }
+    ]
+  }
+}

package/lib/commands/create.js

@@ -19,6 +19,7 @@ export async function runDelegatedCommand (logger, packageManager, args) {
 
   const options = { stdio: 'inherit' }
 
+  /* c8 ignore next 4 - Covered by CI */
   if (platform() === 'win32') {
     options.shell = true
     options.windowsVerbatimArguments = true

package/lib/commands/execution.js

@@ -10,7 +10,7 @@ import {
 import { create } from '@platformatic/runtime'
 import { bold } from 'colorette'
 import { spawn } from 'node:child_process'
-import { on } from 'node:events'
+import { createInterface } from 'node:readline'
 
 export async function devCommand (logger, args) {
   const {
@@ -38,16 +38,32 @@ export async function devCommand (logger, args) {
 
   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()
+  // Handle reloading via either file changes or stdin "rs" command
+  const { promise, reject } = Promise.withResolvers()
 
-  // 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 ...')
+  async function reloadApplication () {
     await runtime.close()
-    runtime = await create(root, configurationFile, { start: true })
+    runtime = await create(root, configurationFile, { start: true, reloaded: true })
   }
+
+  const watcher = new FileWatcher({ path: configurationFile })
+  watcher.startWatching()
+  watcher.on('update', () => {
+    runtime.logger.info('The configuration file has changed, reloading the application ...')
+    reloadApplication().catch(reject)
+  })
+
+  const rl = createInterface({ input: process.stdin })
+  rl.on('line', line => {
+    if (line.trim() !== 'rs') {
+      return
+    }
+
+    runtime.logger.info('Received "rs" from the stdin, Reloading the application ...')
+    reloadApplication().catch(reject)
+  })
+
+  return promise
 }
 
 export async function startCommand (logger, args) {
@@ -83,12 +99,11 @@ export async function startCommand (logger, args) {
 export async function stopCommand (logger, args) {
   const { positionals } = parseArgs(args, {}, false)
 
+  const client = new RuntimeApiClient()
   try {
-    const client = new RuntimeApiClient()
     const [runtime] = await getMatchingRuntime(client, positionals)
 
     await client.stopRuntime(runtime.pid)
-    await client.close()
 
     logger.done(`Runtime ${bold(runtime.packageName)} have been stopped.`)
   } catch (error) {
@@ -98,18 +113,19 @@ export async function stopCommand (logger, args) {
     } else {
       return logFatalError(logger, { error: ensureLoggableError(error) }, `Cannot stop the runtime: ${error.message}`)
     }
+  } finally {
+    await client.close()
   }
 }
 
 export async function restartCommand (logger, args) {
   const { positionals } = parseArgs(args, {}, false)
 
+  const client = new RuntimeApiClient()
   try {
-    const client = new RuntimeApiClient()
     const [runtime, applications] = await getMatchingRuntime(client, positionals)
 
     await client.restartRuntime(runtime.pid, ...applications)
-    await client.close()
 
     logger.done(`Runtime ${bold(runtime.packageName)} has been restarted.`)
   } catch (error) {
@@ -123,14 +139,16 @@ export async function restartCommand (logger, args) {
         `Cannot restart the runtime: ${error.message}`
       )
     }
+  } finally {
+    await client.close()
   }
 }
 
 export async function reloadCommand (logger, args) {
   const { positionals } = parseArgs(args, {}, false)
 
+  const client = new RuntimeApiClient()
   try {
-    const client = new RuntimeApiClient()
     const [runtime] = await getMatchingRuntime(client, positionals)
 
     // Stop the previous runtime
@@ -147,7 +165,6 @@ export async function reloadCommand (logger, args) {
     })
 
     child.unref()
-    await client.close()
 
     logger.done(`Runtime ${bold(runtime.packageName)} have been reloaded and it is now running as PID ${child.pid}.`)
   } catch (error) {
@@ -157,6 +174,8 @@ export async function reloadCommand (logger, args) {
     } else {
       return logFatalError(logger, { error: ensureLoggableError(error) }, `Cannot reload the runtime: ${error.message}`)
     }
+  } finally {
+    await client.close()
   }
 }
 
@@ -221,8 +240,7 @@ export const help = {
       },
       {
         name: 'application',
-        description:
-          'The name of the application to restart (if omitted, all applications are restarted)'
+        description: 'The name of the application to restart (if omitted, all applications are restarted)'
       }
     ]
   },

package/lib/commands/help.js

@@ -9,7 +9,18 @@ function sanitizeHelp (raw) {
 async function loadCommands () {
   const commands = {}
 
-  for (const file of ['build', 'create', 'execution', 'management', 'admin', 'logs', 'inject', 'metrics', 'pprof']) {
+  for (const file of [
+    'build',
+    'create',
+    'execution',
+    'applications',
+    'management',
+    'admin',
+    'logs',
+    'inject',
+    'metrics',
+    'pprof'
+  ]) {
     const category = await import(`./${file}.js`)
     Object.assign(commands, category.help)
   }

package/lib/commands/inject.js

@@ -70,8 +70,8 @@ export async function injectCommand (logger, args) {
   )
 
   const outputStream = output ? createWriteStream(resolve(process.cwd(), output)) : process.stdout
+  const client = new RuntimeApiClient()
   try {
-    const client = new RuntimeApiClient()
     const [runtime, positionals] = await getMatchingRuntime(client, allPositionals)
     let application = positionals[0]
 
@@ -137,8 +137,6 @@ export async function injectCommand (logger, args) {
       outputStream.end()
       await finished(outputStream)
     }
-
-    await client.close()
   } catch (error) {
     if (error.code === 'PLT_CTR_RUNTIME_NOT_FOUND') {
       return logFatalError(logger, 'Cannot find a matching runtime.')
@@ -148,6 +146,8 @@ export async function injectCommand (logger, args) {
     } else {
       return logFatalError(logger, { error: ensureLoggableError(error) }, `Cannot perform a request: ${error.message}`)
     }
+  } finally {
+    await client.close()
   }
 }
 

package/lib/commands/logs.js

@@ -18,8 +18,8 @@ export async function logsCommand (logger, args) {
   const output = values.pretty ? pinoPretty({ colorize: true }) : process.stdout
 
   let application
+  const client = new RuntimeApiClient()
   try {
-    const client = new RuntimeApiClient()
     const [runtime, positionals] = await getMatchingRuntime(client, allPositionals)
     application = positionals[0]
 
@@ -54,6 +54,8 @@ export async function logsCommand (logger, args) {
         `Cannot stream ${application ? 'application' : 'runtime'} logs: ${error.message}`
       )
     }
+  } finally {
+    await client.close()
   }
 }
 

package/lib/commands/management.js

@@ -61,10 +61,9 @@ function formatDuration (duration) {
 }
 
 export async function psCommand (logger) {
+  const client = new RuntimeApiClient()
   try {
-    const client = new RuntimeApiClient()
     const runtimes = await client.getRuntimes()
-    await client.close()
 
     if (runtimes.length === 0) {
       logger.warn('No runtimes found.')
@@ -86,17 +85,18 @@ export async function psCommand (logger) {
     /* c8 ignore next 3 - Hard to test */
   } catch (error) {
     return logFatalError(logger, { error: ensureLoggableError(error) }, `Cannot list runtime: ${error.message}`)
+  } finally {
+    await client.close()
   }
 }
 
 export async function applicationsCommand (logger, args) {
   const { positionals } = parseArgs(args, {}, false)
+  const client = new RuntimeApiClient()
 
   try {
-    const client = new RuntimeApiClient()
     const [runtime] = await getMatchingRuntime(client, positionals)
     const { production, applications } = await client.getRuntimeApplications(runtime.pid)
-    await client.close()
 
     const headers = production
       ? [bold('Name'), bold('Workers'), bold('Type'), bold('Entrypoint')]
@@ -121,6 +121,8 @@ export async function applicationsCommand (logger, args) {
         `Cannot list runtime applications: ${error.message}`
       )
     }
+  } finally {
+    await client.close()
   }
 }
 
@@ -128,15 +130,14 @@ export async function envCommand (logger, args) {
   const { values, positionals: allPositionals } = parseArgs(args, { table: { type: 'boolean', short: 't' } }, false)
 
   let application
+  const client = new RuntimeApiClient()
   try {
-    const client = new RuntimeApiClient()
     const [runtime, positionals] = await getMatchingRuntime(client, allPositionals)
     application = positionals[0]
 
     const env = application
       ? await client.getRuntimeApplicationEnv(runtime.pid, application)
       : await client.getRuntimeEnv(runtime.pid)
-    await client.close()
 
     if (values.table) {
       console.log(
@@ -166,6 +167,8 @@ export async function envCommand (logger, args) {
         `Cannot get ${application ? 'application' : 'runtime'} environment variables: ${error.message}`
       )
     }
+  } finally {
+    await client.close()
   }
 }
 
@@ -173,15 +176,14 @@ export async function configCommand (logger, args) {
   const { positionals: allPositionals } = parseArgs(args, {}, false)
 
   let application
+  const client = new RuntimeApiClient()
   try {
-    const client = new RuntimeApiClient()
     const [runtime, positionals] = await getMatchingRuntime(client, allPositionals)
     application = positionals[0]
 
     const config = application
       ? await client.getRuntimeApplicationConfig(runtime.pid, application)
       : await client.getRuntimeConfig(runtime.pid)
-    await client.close()
 
     console.log(JSON.stringify(config, null, 2))
   } catch (error) {
@@ -197,6 +199,8 @@ export async function configCommand (logger, args) {
         `Cannot get ${application ? 'application' : 'runtime'} configuration: ${error.message}`
       )
     }
+  } finally {
+    await client.close()
   }
 }
 

package/lib/commands/metrics.js

@@ -3,15 +3,14 @@ import { ensureLoggableError, logFatalError, parseArgs } from '@platformatic/fou
 import { bold } from 'colorette'
 
 export async function metricsCommand (logger, args) {
+  const client = new RuntimeApiClient()
   try {
     const { values, positionals } = parseArgs(args, { format: { type: 'string', short: 'f', default: 'json' } }, false)
 
-    const client = new RuntimeApiClient()
     const [runtime] = await getMatchingRuntime(client, positionals)
     const metrics = await client.getRuntimeMetrics(runtime.pid, { format: values.format })
     const result = values.format === 'text' ? metrics : JSON.stringify(metrics, null, 2)
     console.log(result)
-    await client.close()
 
     logger.done(`Runtime ${bold(runtime.packageName)} have been stopped.`)
   } catch (error) {
@@ -21,6 +20,8 @@ export async function metricsCommand (logger, args) {
     } else {
       return logFatalError(logger, { error: ensureLoggableError(error) }, `Cannot reload the runtime: ${error.message}`)
     }
+  } finally {
+    client.close()
   }
 }
 

package/lib/commands/pprof.js

@@ -4,10 +4,16 @@ import { bold } from 'colorette'
 import { writeFile } from 'node:fs/promises'
 
 export async function pprofStartCommand (logger, args) {
+  const client = new RuntimeApiClient()
+
   try {
-    const { positionals, values } = parseArgs(args, {
-      type: { type: 'string', short: 't', default: 'cpu' }
-    }, false)
+    const { positionals, values } = parseArgs(
+      args,
+      {
+        type: { type: 'string', short: 't', default: 'cpu' }
+      },
+      false
+    )
 
     // Validate profile type
     const type = values.type
@@ -15,7 +21,6 @@ export async function pprofStartCommand (logger, args) {
       return logFatalError(logger, `Invalid profile type: ${type}. Must be 'cpu' or 'heap'.`)
     }
 
-    const client = new RuntimeApiClient()
     const [runtime, remainingPositionals] = await getMatchingRuntime(client, positionals)
     const { applications: runtimeApplications } = await client.getRuntimeApplications(runtime.pid)
 
@@ -28,7 +33,6 @@ export async function pprofStartCommand (logger, args) {
       // Start profiling for specific application
       const application = runtimeApplications.find(s => s.id === applicationId)
       if (!application) {
-        await client.close()
         return logFatalError(logger, `Application not found: ${applicationId}`)
       }
 
@@ -45,8 +49,6 @@ export async function pprofStartCommand (logger, args) {
         }
       }
     }
-
-    await client.close()
   } catch (error) {
     if (error.code === 'PLT_CTR_RUNTIME_NOT_FOUND') {
       return logFatalError(logger, 'Cannot find a matching runtime.')
@@ -55,14 +57,22 @@ export async function pprofStartCommand (logger, args) {
     } else {
       return logFatalError(logger, { error: ensureLoggableError(error) }, `Cannot start profiling: ${error.message}`)
     }
+  } finally {
+    await client.close()
   }
 }
 
 export async function pprofStopCommand (logger, args) {
+  const client = new RuntimeApiClient()
+
   try {
-    const { positionals, values } = parseArgs(args, {
-      type: { type: 'string', short: 't', default: 'cpu' }
-    }, false)
+    const { positionals, values } = parseArgs(
+      args,
+      {
+        type: { type: 'string', short: 't', default: 'cpu' }
+      },
+      false
+    )
 
     // Validate profile type
     const type = values.type
@@ -70,7 +80,6 @@ export async function pprofStopCommand (logger, args) {
       return logFatalError(logger, `Invalid profile type: ${type}. Must be 'cpu' or 'heap'.`)
     }
 
-    const client = new RuntimeApiClient()
     const [runtime, remainingPositionals] = await getMatchingRuntime(client, positionals)
     const { applications: runtimeApplications } = await client.getRuntimeApplications(runtime.pid)
 
@@ -84,14 +93,15 @@ export async function pprofStopCommand (logger, args) {
       // Stop profiling for specific application
       const application = runtimeApplications.find(s => s.id === applicationId)
       if (!application) {
-        await client.close()
         return logFatalError(logger, `Application not found: ${applicationId}`)
       }
 
       const profileData = await client.stopApplicationProfiling(runtime.pid, applicationId, options)
       const filename = `pprof-${type}-${applicationId}-${timestamp}.pb`
       await writeFile(filename, Buffer.from(profileData))
-      logger.info(`${type.toUpperCase()} profiling stopped for application ${bold(applicationId)}, profile saved to ${bold(filename)}`)
+      logger.info(
+        `${type.toUpperCase()} profiling stopped for application ${bold(applicationId)}, profile saved to ${bold(filename)}`
+      )
     } else {
       // Stop profiling for all applications
       for (const application of runtimeApplications) {
@@ -99,14 +109,14 @@ export async function pprofStopCommand (logger, args) {
           const profileData = await client.stopApplicationProfiling(runtime.pid, application.id, options)
           const filename = `pprof-${type}-${application.id}-${timestamp}.pb`
           await writeFile(filename, Buffer.from(profileData))
-          logger.info(`${type.toUpperCase()} profiling stopped for application ${bold(application.id)}, profile saved to ${bold(filename)}`)
+          logger.info(
+            `${type.toUpperCase()} profiling stopped for application ${bold(application.id)}, profile saved to ${bold(filename)}`
+          )
         } catch (error) {
           logger.warn(`Failed to stop profiling for application ${application.id}: ${error.message}`)
         }
       }
     }
-
-    await client.close()
   } catch (error) {
     if (error.code === 'PLT_CTR_RUNTIME_NOT_FOUND') {
       return logFatalError(logger, 'Cannot find a matching runtime.')
@@ -115,6 +125,8 @@ export async function pprofStopCommand (logger, args) {
     } else {
       return logFatalError(logger, { error: ensureLoggableError(error) }, `Cannot stop profiling: ${error.message}`)
     }
+  } finally {
+    await client.close()
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wattpm",
-  "version": "3.14.0",
+  "version": "3.16.0",
   "description": "The Node.js Application Server",
   "main": "index.js",
   "type": "module",
@@ -29,9 +29,9 @@
     "pino-pretty": "^13.0.0",
     "split2": "^4.2.0",
     "table": "^6.8.2",
-    "@platformatic/foundation": "3.14.0",
-    "@platformatic/control": "3.14.0",
-    "@platformatic/runtime": "3.14.0"
+    "@platformatic/control": "3.16.0",
+    "@platformatic/runtime": "3.16.0",
+    "@platformatic/foundation": "3.16.0"
   },
   "devDependencies": {
     "cleaner-spec-reporter": "^0.5.0",
@@ -42,7 +42,7 @@
     "neostandard": "^0.12.0",
     "typescript": "^5.5.4",
     "undici": "^7.0.0",
-    "@platformatic/node": "3.14.0"
+    "@platformatic/node": "3.16.0"
   },
   "engines": {
     "node": ">=22.19.0"

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/wattpm/3.14.0.json",
+  "$id": "https://schemas.platformatic.dev/wattpm/3.16.0.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Runtime Config",
   "type": "object",
@@ -64,6 +64,10 @@
               "useHttp": {
                 "type": "boolean"
               },
+              "reuseTcpPorts": {
+                "type": "boolean",
+                "default": true
+              },
               "workers": {
                 "anyOf": [
                   {
@@ -342,6 +346,10 @@
           "useHttp": {
             "type": "boolean"
           },
+          "reuseTcpPorts": {
+            "type": "boolean",
+            "default": true
+          },
           "workers": {
             "anyOf": [
               {
@@ -618,6 +626,10 @@
           "useHttp": {
             "type": "boolean"
           },
+          "reuseTcpPorts": {
+            "type": "boolean",
+            "default": true
+          },
           "workers": {
             "anyOf": [
               {
@@ -894,6 +906,10 @@
           "useHttp": {
             "type": "boolean"
           },
+          "reuseTcpPorts": {
+            "type": "boolean",
+            "default": true
+          },
           "workers": {
             "anyOf": [
               {
@@ -1464,6 +1480,10 @@
       },
       "additionalProperties": false
     },
+    "reuseTcpPorts": {
+      "type": "boolean",
+      "default": true
+    },
     "startTimeout": {
       "default": 30000,
       "type": "number",