wattpm 3.38.1 → 3.40.0

package/bin/cli.js

@@ -14,11 +14,9 @@ try {
 }
 
 // Load wattpm via dynamic import so all modules benefit from compile cache
-const { checkNodeVersionForApplications, setExecutableId, setExecutableName } = await import('@platformatic/foundation')
+const { checkNodeVersionForApplications, createCLIContext } = await import('@platformatic/foundation')
 
 checkNodeVersionForApplications()
-setExecutableId('wattpm')
-setExecutableName('Watt')
 
 const { main } = await import('../index.js')
-await main()
+await main.call(createCLIContext('wattpm', 'Watt'))

package/index.js

@@ -1,4 +1,4 @@
-import { createCliLogger, getExecutableId, logFatalError, parseArgs, setVerbose } from '@platformatic/foundation'
+import { createCliLogger, logFatalError, parseArgs } from '@platformatic/foundation'
 import { loadApplicationsCommands } from '@platformatic/runtime'
 import * as colorette from 'colorette'
 import { bold } from 'colorette'
@@ -15,12 +15,11 @@ import { metricsCommand } from './lib/commands/metrics.js'
 import { pprofCommand } from './lib/commands/pprof.js'
 import { replCommand } from './lib/commands/repl.js'
 import { version } from './lib/schema.js'
-import { setSocket } from './lib/utils.js'
 
 export * from './lib/schema.js'
 
 export async function main () {
-  globalThis.platformatic = { executable: getExecutableId() }
+  globalThis.platformatic = { executable: this.executableId }
 
   const options = {
     'no-pretty': {
@@ -48,6 +47,7 @@ export async function main () {
   const { values, unparsed } = parseArgs(process.argv.slice(2), options)
 
   const logger = createCliLogger('info', values['no-pretty'])
+  this.logger = logger
 
   if (values.version || unparsed[0] === 'version') {
     console.log(version)
@@ -55,19 +55,19 @@ export async function main () {
   }
 
   if (values.help) {
-    helpCommand(logger, [])
+    helpCommand.call(this, logger, [])
     return
   } else if (unparsed.includes('-h') || unparsed.includes('--help')) {
-    helpCommand(logger, unparsed)
+    helpCommand.call(this, logger, unparsed)
     return
   }
 
   if (values.verbose) {
-    setVerbose(true)
+    this.verbose = true
   }
 
   if (values.socket) {
-    setSocket(values.socket)
+    this.socket = values.socket
   }
 
   let command
@@ -139,7 +139,8 @@ export async function main () {
       break
     default:
       if (requestedCommand) {
-        const applicationsCommands = await loadApplicationsCommands()
+        const applicationsCommands = await loadApplicationsCommands(this.executableName)
+        console.log(applicationsCommands)
         const applicationCommand = applicationsCommands.commands[requestedCommand]
 
         if (applicationCommand) {
@@ -154,7 +155,7 @@ export async function main () {
   if (!command) {
     logFatalError(
       logger,
-      `Unknown command ${bold(requestedCommand)}. Please run ${bold(`"${getExecutableId()} help"`)} to see available commands.`
+      `Unknown command ${bold(requestedCommand)}. Please run ${bold(`"${this.executableId} help"`)} to see available commands.`
     )
 
     return
@@ -162,8 +163,12 @@ export async function main () {
 
   if (applicationCommandContext) {
     process.chdir(applicationCommandContext.path)
-    return command(logger, applicationCommandContext.config, unparsed.slice(1), { colorette, parseArgs, logFatalError })
+    return command.call(this, logger, applicationCommandContext.config, unparsed.slice(1), {
+      colorette,
+      parseArgs,
+      logFatalError
+    })
   } else {
-    await command(logger, unparsed.slice(1))
+    await command.call(this, logger, unparsed.slice(1))
   }
 }

package/lib/commands/admin.js

@@ -19,7 +19,7 @@ export async function adminCommand (logger, args) {
     false
   )
 
-  return runDelegatedCommand(logger, packageManager, ['@platformatic/watt-admin' + (latest ? '@latest' : '')])
+  return runDelegatedCommand(this, logger, packageManager, ['@platformatic/watt-admin' + (latest ? '@latest' : '')])
 }
 
 export const help = {

package/lib/commands/applications.js

@@ -3,7 +3,6 @@ import { ensureLoggableError, logFatalError, parseArgs } from '@platformatic/fou
 import { bold } from 'colorette'
 import { readFile, stat, writeFile } from 'node:fs/promises'
 import { basename, isAbsolute, relative, resolve } from 'node:path'
-import { getSocket } from '../utils.js'
 
 async function updateConfigFile (path, update) {
   const contents = JSON.parse(await readFile(path, 'utf-8'))
@@ -26,7 +25,7 @@ export async function applicationsAddCommand (logger, args) {
     false
   )
 
-  const client = new RuntimeApiClient({ logger, socket: getSocket() })
+  const client = new RuntimeApiClient({ logger, socket: this.socket })
   try {
     const [runtime, applications] = await getMatchingRuntime(client, allPositionals)
     const config = await client.getRuntimeConfig(runtime.pid, true)
@@ -101,7 +100,7 @@ export async function applicationsRemoveCommand (logger, args) {
     false
   )
 
-  const client = new RuntimeApiClient({ logger, socket: getSocket() })
+  const client = new RuntimeApiClient({ logger, socket: this.socket })
   try {
     const [runtime, applications] = await getMatchingRuntime(client, positionals)
 

package/lib/commands/build.js

@@ -32,7 +32,7 @@ export async function buildCommand (logger, args) {
     )
     const root = getRoot(positionals)
 
-    configurationFile = await findRuntimeConfigurationFile(logger, root, config)
+    configurationFile = await findRuntimeConfigurationFile(logger, root, config, true, true, true, this.executableName)
 
     /* c8 ignore next 3 - Hard to test */
     if (!configurationFile) {

package/lib/commands/create.js

@@ -1,10 +1,9 @@
-import { getExecutableName, getPackageManager, parseArgs } from '@platformatic/foundation'
+import { getPackageManager, parseArgs } from '@platformatic/foundation'
 import { bold } from 'colorette'
 import { spawn } from 'node:child_process'
 import { platform } from 'node:os'
-import { getSocket } from '../utils.js'
 
-export async function runDelegatedCommand (logger, packageManager, args) {
+export async function runDelegatedCommand (context, logger, packageManager, args) {
   if (!packageManager) {
     packageManager = await getPackageManager(process.cwd())
   }
@@ -16,7 +15,7 @@ export async function runDelegatedCommand (logger, packageManager, args) {
     args.unshift('-y')
   }
 
-  const socket = getSocket()
+  const socket = context.socket
   if (socket) {
     if (packageManager === 'pnpm') {
       args.push('--', '--socket', socket)
@@ -102,12 +101,12 @@ export async function createCommand (logger, args) {
     }
   }
 
-  return runDelegatedCommand(logger, packageManager, runArgs)
+  return runDelegatedCommand(this, logger, packageManager, runArgs)
 }
 
 const createHelp = {
   description () {
-    return `Creates a new ${getExecutableName()} project`
+    return `Creates a new ${this.executableName} project`
   },
   options: [
     {

package/lib/commands/execution.js

@@ -11,7 +11,6 @@ import { create } from '@platformatic/runtime'
 import { bold } from 'colorette'
 import { spawn } from 'node:child_process'
 import { createInterface } from 'node:readline'
-import { getSocket } from '../utils.js'
 
 export async function devCommand (logger, args) {
   const {
@@ -33,7 +32,7 @@ export async function devCommand (logger, args) {
   )
   const root = getRoot(positionals)
 
-  const configurationFile = await findRuntimeConfigurationFile(logger, root, config)
+  const configurationFile = await findRuntimeConfigurationFile(logger, root, config, true, true, true, this.executableName)
 
   /* c8 ignore next 3 - Hard to test */
   if (!configurationFile) {
@@ -108,7 +107,7 @@ export async function startCommand (logger, args) {
   )
 
   const root = getRoot(positionals)
-  const configurationFile = await findRuntimeConfigurationFile(logger, root, config)
+  const configurationFile = await findRuntimeConfigurationFile(logger, root, config, true, true, true, this.executableName)
 
   /* c8 ignore next 3 - Hard to test */
   if (!configurationFile) {
@@ -132,7 +131,7 @@ export async function startCommand (logger, args) {
 export async function stopCommand (logger, args) {
   const { positionals } = parseArgs(args, {}, false)
 
-  const client = new RuntimeApiClient({ logger, socket: getSocket() })
+  const client = new RuntimeApiClient({ logger, socket: this.socket })
   try {
     const [runtime] = await getMatchingRuntime(client, positionals)
 
@@ -154,7 +153,7 @@ export async function stopCommand (logger, args) {
 export async function restartCommand (logger, args) {
   const { positionals } = parseArgs(args, {}, false)
 
-  const client = new RuntimeApiClient({ logger, socket: getSocket() })
+  const client = new RuntimeApiClient({ logger, socket: this.socket })
   try {
     const [runtime, applications] = await getMatchingRuntime(client, positionals)
 
@@ -180,7 +179,7 @@ export async function restartCommand (logger, args) {
 export async function reloadCommand (logger, args) {
   const { positionals } = parseArgs(args, {}, false)
 
-  const client = new RuntimeApiClient({ logger, socket: getSocket() })
+  const client = new RuntimeApiClient({ logger, socket: this.socket })
   try {
     const [runtime] = await getMatchingRuntime(client, positionals)
 

package/lib/commands/help.js

@@ -1,9 +1,9 @@
-import { getExecutableId, getExecutableName, logFatalError, logo } from '@platformatic/foundation'
+import { logFatalError, logo } from '@platformatic/foundation'
 import { loadApplicationsCommands } from '@platformatic/runtime'
 import { bold } from 'colorette'
 
-function sanitizeHelp (raw) {
-  return (typeof raw === 'function' ? raw() : raw).trim()
+function sanitizeHelp (context, raw) {
+  return (typeof raw === 'function' ? raw.call(context) : raw).trim()
 }
 
 async function loadCommands () {
@@ -31,14 +31,14 @@ async function loadCommands () {
   return commands
 }
 
-export async function showGeneralHelp (logger) {
+export async function showGeneralHelp (context, logger) {
   if (typeof logger !== 'function') {
     logger = console.log
   }
 
-  const executableId = getExecutableId()
+  const executableId = context.executableId
   const commands = Object.values(await loadCommands())
-  const applicationsCommands = Object.values((await loadApplicationsCommands()).help)
+  const applicationsCommands = Object.values((await loadApplicationsCommands(context.executableName)).help)
 
   const options = [
     { usage: '-V, --version', description: `Show ${executableId} version` },
@@ -50,7 +50,7 @@ export async function showGeneralHelp (logger) {
     { usage: '--help', description: 'Show this help' }
   ]
 
-  logger(logo())
+  logger(logo.call(context))
   logger(`\nUsage: ${executableId} [options] [command]\n`)
 
   // Compute the maximum length of options or commands
@@ -64,32 +64,34 @@ export async function showGeneralHelp (logger) {
   // Print all options
   logger('Options:\n')
   for (const { usage, description } of options) {
-    logger(`  ${usage.padEnd(maximumLength, ' ')} ${sanitizeHelp(description)}`)
+    logger(`  ${usage.padEnd(maximumLength, ' ')} ${sanitizeHelp(context, description)}`)
   }
   logger('')
 
   // Print all commands
   logger('Commands:\n')
   for (const { usage, description } of commands) {
-    logger(`  ${usage.padEnd(maximumLength, ' ')} ${sanitizeHelp(description)}`)
+    logger(`  ${usage.padEnd(maximumLength, ' ')} ${sanitizeHelp(context, description)}`)
   }
   logger('')
 
   if (applicationsCommands.length) {
     logger('Applications Commands:\n')
     for (const { usage, description } of applicationsCommands) {
-      logger(`  ${usage.padEnd(maximumLength, ' ')} ${sanitizeHelp(description)})`)
+      logger(`  ${usage.padEnd(maximumLength, ' ')} ${sanitizeHelp(context, description)})`)
     }
     logger('')
   }
 }
 
-export function showHelp (command, logger) {
+export function showHelp (context, command, logger) {
   if (typeof logger !== 'function') {
     logger = console.log
   }
 
-  logger(`\nUsage: ${getExecutableId()} ${sanitizeHelp(command.usage)}\n\n${sanitizeHelp(command.description)}.\n`)
+  logger(
+    `\nUsage: ${context.executableId} ${sanitizeHelp(context, command.usage)}\n\n${sanitizeHelp(context, command.description)}.\n`
+  )
 
   let { options, args } = command
   options ??= []
@@ -102,7 +104,7 @@ export function showHelp (command, logger) {
   if (options.length) {
     logger('Options:\n')
     for (const { usage, description } of options) {
-      logger(`  ${usage.padEnd(maximumLength, ' ')} ${sanitizeHelp(description)}`)
+      logger(`  ${usage.padEnd(maximumLength, ' ')} ${sanitizeHelp(context, description)}`)
     }
     logger('')
   }
@@ -111,13 +113,13 @@ export function showHelp (command, logger) {
   if (args.length) {
     logger('Arguments:\n')
     for (const { name, description } of args) {
-      logger(`  ${name.padEnd(maximumLength, ' ')} ${sanitizeHelp(description)}`)
+      logger(`  ${name.padEnd(maximumLength, ' ')} ${sanitizeHelp(context, description)}`)
     }
     logger('')
   }
 
   if (command.footer) {
-    logger(sanitizeHelp(command.footer) + '\n')
+    logger(sanitizeHelp(context, command.footer) + '\n')
   }
 }
 
@@ -125,38 +127,38 @@ export async function helpCommand (logger, args) {
   const command = args?.[0]
 
   if (!command) {
-    return showGeneralHelp()
+    return showGeneralHelp(this)
   }
 
   const commands = await loadCommands()
   if (!commands[command]) {
-    const applicationsCommands = (await loadApplicationsCommands()).help
+    const applicationsCommands = (await loadApplicationsCommands(this.executableName)).help
 
     if (applicationsCommands[command]) {
       // If the command is an application command, we show the help for that command
-      return showHelp(applicationsCommands[command])
+      return showHelp(this, applicationsCommands[command])
     }
 
     return logFatalError(
       logger,
-      `Unknown command ${bold(command)}. Please run ${bold(`"${getExecutableId()} help"`)} to see available commands.`
+      `Unknown command ${bold(command)}. Please run ${bold(`"${this.executableId} help"`)} to see available commands.`
     )
   }
 
-  showHelp(commands[command])
+  showHelp(this, commands[command])
 }
 
 export const help = {
   help: {
     usage: 'help [command]',
     description () {
-      return `Show help about ${getExecutableName()} or one of its commands`
+      return `Show help about ${this.executableName} or one of its commands`
     }
   },
   version: {
     usage: 'version',
     description () {
-      return `Show current ${getExecutableName()} version`
+      return `Show current ${this.executableName} version`
     }
   }
 }

package/lib/commands/inject.js

@@ -1,14 +1,13 @@
 import { getMatchingRuntime, RuntimeApiClient } from '@platformatic/control'
-import { ensureLoggableError, isVerbose, logFatalError, parseArgs } from '@platformatic/foundation'
+import { ensureLoggableError, logFatalError, parseArgs } from '@platformatic/foundation'
 import { createWriteStream } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 import { resolve } from 'node:path'
 import { finished } from 'node:stream/promises'
 import { setTimeout as sleep } from 'node:timers/promises'
-import { getSocket } from '../utils.js'
 
-function appendOutput (logger, stream, fullOutput, line) {
-  if (isVerbose()) {
+function appendOutput (verbose, logger, stream, fullOutput, line) {
+  if (verbose) {
     logger.info(line)
   }
 
@@ -18,7 +17,8 @@ function appendOutput (logger, stream, fullOutput, line) {
 }
 
 export async function injectCommand (logger, args) {
-  const verbose = isVerbose()
+  const verbose = this.verbose
+
   const {
     values: { method, path: url, header: rawHeaders, data, 'data-file': file, output, 'full-output': fullOutput },
     positionals: allPositionals
@@ -71,7 +71,7 @@ export async function injectCommand (logger, args) {
   )
 
   const outputStream = output ? createWriteStream(resolve(process.cwd(), output)) : process.stdout
-  const client = new RuntimeApiClient({ logger, socket: getSocket() })
+  const client = new RuntimeApiClient({ logger, socket: this.socket })
   try {
     const [runtime, positionals] = await getMatchingRuntime(client, allPositionals)
     let application = positionals[0]
@@ -89,25 +89,25 @@ export async function injectCommand (logger, args) {
     }
 
     // Track request
-    appendOutput(logger, outputStream, fullOutput, `> ${method} ${url} HTTP/1.1`)
+    appendOutput(verbose, logger, outputStream, fullOutput, `> ${method} ${url} HTTP/1.1`)
 
     for (const [name, value] of Object.entries(headers)) {
-      appendOutput(logger, outputStream, fullOutput, `> ${name}: ${value}`)
+      appendOutput(verbose, logger, outputStream, fullOutput, `> ${name}: ${value}`)
     }
 
-    appendOutput(logger, outputStream, fullOutput, '>')
+    appendOutput(verbose, logger, outputStream, fullOutput, '>')
 
     // Perform the request
     const response = await client.injectRuntime(runtime.pid, application, { url, method, headers, body })
 
     // Track response
-    appendOutput(logger, outputStream, fullOutput, `< HTTP/1.1 ${response.statusCode}`)
+    appendOutput(verbose, logger, outputStream, fullOutput, `< HTTP/1.1 ${response.statusCode}`)
 
     for (const [name, value] of Object.entries(response.headers)) {
-      appendOutput(logger, outputStream, fullOutput, `< ${name}: ${value}`)
+      appendOutput(verbose, logger, outputStream, fullOutput, `< ${name}: ${value}`)
     }
 
-    appendOutput(logger, outputStream, fullOutput, '<')
+    appendOutput(verbose, logger, outputStream, fullOutput, '<')
 
     // Show the response
     const responseBody = await response.body.text()

package/lib/commands/management.js

@@ -3,7 +3,6 @@ import { ensureLoggableError, logFatalError, parseArgs } from '@platformatic/fou
 import { bold, reset } from 'colorette'
 import { sep } from 'node:path'
 import { getBorderCharacters, table } from 'table'
-import { getSocket } from '../utils.js'
 
 const ONE_DAY = 3600 * 24
 const ONE_HOUR = 3600
@@ -62,7 +61,7 @@ function formatDuration (duration) {
 }
 
 export async function psCommand (logger) {
-  const client = new RuntimeApiClient({ logger, socket: getSocket() })
+  const client = new RuntimeApiClient({ logger, socket: this.socket })
   try {
     const runtimes = await client.getRuntimes()
 
@@ -93,7 +92,7 @@ export async function psCommand (logger) {
 
 export async function applicationsCommand (logger, args) {
   const { positionals } = parseArgs(args, {}, false)
-  const client = new RuntimeApiClient({ logger, socket: getSocket() })
+  const client = new RuntimeApiClient({ logger, socket: this.socket })
 
   try {
     const [runtime] = await getMatchingRuntime(client, positionals)
@@ -131,7 +130,7 @@ export async function envCommand (logger, args) {
   const { values, positionals: allPositionals } = parseArgs(args, { table: { type: 'boolean', short: 't' } }, false)
 
   let application
-  const client = new RuntimeApiClient({ logger, socket: getSocket() })
+  const client = new RuntimeApiClient({ logger, socket: this.socket })
   try {
     const [runtime, positionals] = await getMatchingRuntime(client, allPositionals)
     application = positionals[0]
@@ -177,7 +176,7 @@ export async function configCommand (logger, args) {
   const { positionals: allPositionals } = parseArgs(args, {}, false)
 
   let application
-  const client = new RuntimeApiClient({ logger, socket: getSocket() })
+  const client = new RuntimeApiClient({ logger, socket: this.socket })
   try {
     const [runtime, positionals] = await getMatchingRuntime(client, allPositionals)
     application = positionals[0]

package/lib/commands/metrics.js

@@ -1,10 +1,9 @@
 import { getMatchingRuntime, RuntimeApiClient } from '@platformatic/control'
 import { ensureLoggableError, logFatalError, parseArgs } from '@platformatic/foundation'
 import { bold } from 'colorette'
-import { getSocket } from '../utils.js'
 
 export async function metricsCommand (logger, args) {
-  const client = new RuntimeApiClient({ logger, socket: getSocket() })
+  const client = new RuntimeApiClient({ logger, socket: this.socket })
   try {
     const { values, positionals } = parseArgs(args, { format: { type: 'string', short: 'f', default: 'json' } }, false)
 

package/lib/commands/pprof.js

@@ -3,10 +3,9 @@ import { ensureLoggableError, logFatalError, parseArgs } from '@platformatic/fou
 import { bold } from 'colorette'
 import { writeFile } from 'node:fs/promises'
 import { resolve } from 'node:path'
-import { getSocket } from '../utils.js'
 
-export async function pprofStartCommand (logger, args) {
-  const client = new RuntimeApiClient({ logger, socket: getSocket() })
+export async function pprofStartCommand (context, logger, args) {
+  const client = new RuntimeApiClient({ logger, socket: context.socket })
 
   try {
     const { positionals, values } = parseArgs(
@@ -76,8 +75,8 @@ export async function pprofStartCommand (logger, args) {
   }
 }
 
-export async function pprofStopCommand (logger, args) {
-  const client = new RuntimeApiClient({ logger, socket: getSocket() })
+export async function pprofStopCommand (context, logger, args) {
+  const client = new RuntimeApiClient({ logger, socket: context.socket })
 
   try {
     const { positionals, values } = parseArgs(
@@ -155,9 +154,9 @@ export async function pprofCommand (logger, args) {
 
   switch (subcommand) {
     case 'start':
-      return pprofStartCommand(logger, restArgs)
+      return pprofStartCommand(this, logger, restArgs)
     case 'stop':
-      return pprofStopCommand(logger, restArgs)
+      return pprofStopCommand(this, logger, restArgs)
     default:
       return logFatalError(logger, `Please provide a pprof subcommand between ${bold('start')} and ${bold('stop')}.`)
   }

package/lib/commands/repl.js

@@ -3,7 +3,6 @@ import { ensureLoggableError, logFatalError, parseArgs } from '@platformatic/fou
 import { bold } from 'colorette'
 import { createInterface } from 'node:readline'
 import { getBorderCharacters, table } from 'table'
-import { getSocket } from '../utils.js'
 
 const tableConfig = {
   /* c8 ignore next */
@@ -16,7 +15,7 @@ const tableConfig = {
 export async function replCommand (logger, args) {
   const { positionals: allPositionals } = parseArgs(args, {}, false)
 
-  const client = new RuntimeApiClient({ logger, socket: getSocket() })
+  const client = new RuntimeApiClient({ logger, socket: this.socket })
   try {
     const [runtime, positionals] = await getMatchingRuntime(client, allPositionals)
     let application = positionals[0]

package/package.json

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

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/wattpm/3.38.1.json",
+  "$id": "https://schemas.platformatic.dev/wattpm/3.40.0.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Runtime Config",
   "type": "object",
@@ -354,6 +354,29 @@
                     "additionalProperties": false
                   }
                 ]
+              },
+              "management": {
+                "anyOf": [
+                  {
+                    "type": "boolean"
+                  },
+                  {
+                    "type": "object",
+                    "properties": {
+                      "enabled": {
+                        "type": "boolean",
+                        "default": true
+                      },
+                      "operations": {
+                        "type": "array",
+                        "items": {
+                          "type": "string"
+                        }
+                      }
+                    },
+                    "additionalProperties": false
+                  }
+                ]
               }
             }
           }
@@ -690,6 +713,29 @@
                 "additionalProperties": false
               }
             ]
+          },
+          "management": {
+            "anyOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "object",
+                "properties": {
+                  "enabled": {
+                    "type": "boolean",
+                    "default": true
+                  },
+                  "operations": {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  }
+                },
+                "additionalProperties": false
+              }
+            ]
           }
         }
       }
@@ -1024,6 +1070,29 @@
                 "additionalProperties": false
               }
             ]
+          },
+          "management": {
+            "anyOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "object",
+                "properties": {
+                  "enabled": {
+                    "type": "boolean",
+                    "default": true
+                  },
+                  "operations": {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  }
+                },
+                "additionalProperties": false
+              }
+            ]
           }
         }
       }
@@ -1358,6 +1427,29 @@
                 "additionalProperties": false
               }
             ]
+          },
+          "management": {
+            "anyOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "object",
+                "properties": {
+                  "enabled": {
+                    "type": "boolean",
+                    "default": true
+                  },
+                  "operations": {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  }
+                },
+                "additionalProperties": false
+              }
+            ]
           }
         }
       }
@@ -1578,6 +1670,26 @@
           "type": "object",
           "additionalProperties": true
         },
+        "openTelemetryExporter": {
+          "type": "object",
+          "properties": {
+            "protocol": {
+              "type": "string",
+              "enum": [
+                "grpc",
+                "http"
+              ]
+            },
+            "url": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "protocol",
+            "url"
+          ],
+          "additionalProperties": false
+        },
         "captureStdio": {
           "type": "boolean",
           "default": true
@@ -2081,6 +2193,29 @@
       ],
       "default": true
     },
+    "management": {
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "enabled": {
+              "type": "boolean",
+              "default": true
+            },
+            "operations": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            }
+          },
+          "additionalProperties": false
+        }
+      ]
+    },
     "metrics": {
       "anyOf": [
         {

package/lib/utils.js

@@ -1,9 +0,0 @@
-let socket
-
-export function setSocket (value) {
-  socket = value
-}
-
-export function getSocket () {
-  return socket
-}