@platformatic/basic 2.0.0-alpha.7 → 2.0.0-alpha.8

package/eslint.config.js

@@ -1,5 +1,5 @@
 import neostandard from 'neostandard'
 
 export default neostandard({
-  ignores: ['test/tmp/version.js', '**/.next'],
+  ignores: ['**/.next'],
 })

package/index.js

@@ -7,18 +7,35 @@ import pino from 'pino'
 import { packageJson, schema } from './lib/schema.js'
 import { importFile } from './lib/utils.js'
 
+function isImportFailedError (error, pkg) {
+  if (error.code !== 'ERR_MODULE_NOT_FOUND') {
+    return false
+  }
+
+  const match = error.message.match(/Cannot find package '(.+)' imported from (.+)/)
+  return match?.[1] === pkg
+}
+
 async function importStackablePackage (opts, pkg, autodetectDescription) {
   try {
     try {
       // Try regular import
       return await import(pkg)
     } catch (e) {
+      if (!isImportFailedError(e, pkg)) {
+        throw e
+      }
+
       // Scope to the service
       const require = createRequire(resolve(opts.context.directory, 'index.js'))
       const imported = require.resolve(pkg)
       return await importFile(imported)
     }
   } catch (e) {
+    if (!isImportFailedError(e, pkg)) {
+      throw e
+    }
+
     const rootFolder = relative(process.cwd(), workerData.dirname)
 
     let errorMessage = `Unable to import package, "${pkg}". Please add it as a dependency `
@@ -120,4 +137,4 @@ export * as errors from './lib/errors.js'
 export { schema, schemaComponents } from './lib/schema.js'
 export * from './lib/utils.js'
 export * from './lib/worker/child-manager.js'
-export * from './lib/worker/server-listener.js'
+export * from './lib/worker/listeners.js'

package/lib/base.js

@@ -1,15 +1,32 @@
+import { parseCommandString } from 'execa'
+import { spawn } from 'node:child_process'
+import { once } from 'node:events'
+import { existsSync } from 'node:fs'
+import { platform } from 'node:os'
+import { pathToFileURL } from 'node:url'
 import pino from 'pino'
+import split2 from 'split2'
+import { NonZeroExitCode } from './errors.js'
+import { cleanBasePath } from './utils.js'
+import { ChildManager } from './worker/child-manager.js'
 
 export class BaseStackable {
+  #childManager
+  #subprocess
+  #subprocessStarted
+
   constructor (type, version, options, root, configManager) {
     this.type = type
     this.version = version
     this.id = options.context.serviceId
+    this.options = options
     this.root = root
     this.configManager = configManager
     this.serverConfig = options.context.serverConfig
     this.openapiSchema = null
     this.getGraphqlSchema = null
+    this.isEntrypoint = options.context.isEntrypoint
+    this.isProduction = options.context.isProduction
 
     // Setup the logger
     const pinoOptions = {
@@ -24,7 +41,8 @@ export class BaseStackable {
     // Setup globals
     this.registerGlobals({
       setOpenapiSchema: this.setOpenapiSchema.bind(this),
-      setGraphqlSchema: this.setGraphqlSchema.bind(this)
+      setGraphqlSchema: this.setGraphqlSchema.bind(this),
+      setServicePrefix: this.setServicePrefix.bind(this)
     })
   }
 
@@ -80,6 +98,10 @@ export class BaseStackable {
     this.graphqlSchema = schema
   }
 
+  setServicePrefix (prefix) {
+    this.servicePrefix = prefix
+  }
+
   async log ({ message, level }) {
     const logLevel = level ?? 'info'
     this.logger[logLevel](message)
@@ -88,4 +110,141 @@ export class BaseStackable {
   registerGlobals (globals) {
     globalThis.platformatic = Object.assign(globalThis.platformatic ?? {}, globals)
   }
+
+  verifyOutputDirectory (path) {
+    if (this.isProduction && !existsSync(path)) {
+      throw new Error(
+        `Cannot access directory '${path}'. Please run the 'build' command before running in production mode.`
+      )
+    }
+  }
+
+  async buildWithCommand (command, basePath, loader) {
+    if (Array.isArray(command)) {
+      command = command.join(' ')
+    }
+
+    this.logger.debug(`Executing "${command}" ...`)
+
+    this.#childManager = new ChildManager({
+      logger: this.logger,
+      loader,
+      context: {
+        id: this.id,
+        // Always use URL to avoid serialization problem in Windows
+        root: pathToFileURL(this.root).toString(),
+        basePath,
+        logLevel: this.logger.level,
+        port: (this.isEntrypoint ? this.serverConfig?.port || 0 : undefined) ?? true
+      }
+    })
+
+    try {
+      await this.#childManager.inject()
+
+      const subprocess = this.spawn(command)
+
+      // Wait for the process to be started
+      await new Promise((resolve, reject) => {
+        subprocess.on('spawn', resolve)
+        subprocess.on('error', reject)
+      })
+
+      // Route anything not catched by child process logger to the logger manually
+      subprocess.stdout.pipe(split2()).on('data', line => {
+        this.logger.info(line)
+      })
+
+      subprocess.stderr.pipe(split2()).on('data', line => {
+        this.logger.error(line)
+      })
+
+      const [exitCode] = await once(subprocess, 'exit')
+
+      if (exitCode !== 0) {
+        const error = new NonZeroExitCode(exitCode)
+        error.exitCode = exitCode
+        throw error
+      }
+    } finally {
+      await this.#childManager.eject()
+      await this.#childManager.close()
+    }
+  }
+
+  async startWithCommand (command, loader) {
+    const config = this.configManager.current
+    const basePath = config.application?.basePath ? cleanBasePath(config.application?.basePath) : ''
+
+    this.#childManager = new ChildManager({
+      logger: this.logger,
+      loader,
+      context: {
+        id: this.id,
+        // Always use URL to avoid serialization problem in Windows
+        root: pathToFileURL(this.root).toString(),
+        basePath,
+        logLevel: this.logger.level,
+        port: (this.isEntrypoint ? this.serverConfig?.port || 0 : undefined) ?? true
+      }
+    })
+
+    this.#childManager.on('config', config => {
+      this.subprocessConfig = config
+    })
+
+    try {
+      await this.#childManager.inject()
+
+      this.subprocess = this.spawn(command)
+
+      // Route anything not catched by child process logger to the logger manually
+      this.subprocess.stdout.pipe(split2()).on('data', line => {
+        this.logger.info(line)
+      })
+
+      this.subprocess.stderr.pipe(split2()).on('data', line => {
+        this.logger.error(line)
+      })
+
+      // Wait for the process to be started
+      await new Promise((resolve, reject) => {
+        this.subprocess.on('spawn', resolve)
+        this.subprocess.on('error', reject)
+      })
+
+      this.#subprocessStarted = true
+    } catch (e) {
+      throw new Error(`Cannot execute command "${command}": executable not found`)
+    } finally {
+      await this.#childManager.eject()
+    }
+
+    // // If the process exits prematurely, terminate the thread with the same code
+    this.subprocess.on('exit', code => {
+      if (this.#subprocessStarted && typeof code === 'number' && code !== 0) {
+        process.exit(code)
+      }
+    })
+
+    const [url] = await once(this.#childManager, 'url')
+    this.url = url
+  }
+
+  async stopCommand () {
+    this.#subprocessStarted = false
+    const exitPromise = once(this.subprocess, 'exit')
+
+    this.#childManager.close(this.subprocessTerminationSignal ?? 'SIGINT')
+    this.subprocess.kill(this.subprocessTerminationSignal ?? 'SIGINT')
+    await exitPromise
+  }
+
+  spawn (command) {
+    const [executable, ...args] = parseCommandString(command)
+
+    return platform() === 'win32'
+      ? spawn(command, { cwd: this.root, shell: true, windowsVerbatimArguments: true })
+      : spawn(executable, args, { cwd: this.root })
+  }
 }

package/lib/errors.js

@@ -2,7 +2,20 @@ import createError from '@fastify/error'
 
 const ERROR_PREFIX = 'PLT_BASIC'
 
+export const exitCodes = {
+  MANAGER_MESSAGE_HANDLING_FAILED: 11,
+  MANAGER_SOCKET_ERROR: 11,
+  PROCESS_UNHANDLED_ERROR: 20,
+  PROCESS_MESSAGE_HANDLING_FAILED: 21,
+  PROCESS_SOCKET_ERROR: 22
+}
+
 export const UnsupportedVersion = createError(
   `${ERROR_PREFIX}_UNSUPPORTED_VERSION`,
   '%s version %s is not supported. Please use version %s.'
 )
+
+export const NonZeroExitCode = createError(
+  `${ERROR_PREFIX}_NON_ZERO_EXIT_CODE`,
+  'Process exit with non zero exit code %d.'
+)

package/lib/schema.js

@@ -1,4 +1,4 @@
-import { schemas } from '@platformatic/utils'
+import { schemaComponents as utilsSchemaComponents } from '@platformatic/utils'
 import { readFileSync } from 'node:fs'
 
 export const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'))
@@ -8,14 +8,48 @@ const application = {
   properties: {
     basePath: {
       type: 'string'
+    },
+    outputDirectory: {
+      type: 'string',
+      default: 'dist'
+    },
+    include: {
+      type: 'array',
+      items: {
+        type: 'string'
+      },
+      default: ['dist']
+    },
+    commands: {
+      type: 'object',
+      properties: {
+        install: {
+          type: 'string',
+          default: 'npm ci --omit-dev'
+        },
+        // All the following options purposely don't have a default so
+        // that stackables can detect if the user explicitly set them.
+        build: {
+          type: 'string'
+        },
+        development: {
+          type: 'string'
+        },
+        production: {
+          type: 'string'
+        }
+      },
+      default: {},
+      additionalProperties: false
     }
   },
-  additionalProperties: false
+  additionalProperties: false,
+  default: {}
 }
 
 const watch = {
   anyOf: [
-    schemas.watch,
+    utilsSchemaComponents.watch,
     {
       type: 'boolean'
     },
@@ -25,33 +59,7 @@ const watch = {
   ]
 }
 
-const deploy = {
-  type: 'object',
-  properties: {
-    include: {
-      type: 'array',
-      items: {
-        type: 'string'
-      },
-      default: ['dist']
-    },
-    buildCommand: {
-      type: 'string',
-      default: 'npm run build'
-    },
-    installCommand: {
-      type: 'string',
-      default: 'npm ci --omit-dev'
-    },
-    startCommand: {
-      type: 'string',
-      default: 'npm run start'
-    }
-  },
-  default: {}
-}
-
-export const schemaComponents = { application, deploy, watch }
+export const schemaComponents = { application, watch }
 
 export const schema = {
   $id: `https://schemas.platformatic.dev/@platformatic/basic/${packageJson.version}.json`,

package/lib/utils.js

@@ -1,3 +1,4 @@
+import { createRequire } from 'node:module'
 import { pathToFileURL } from 'node:url'
 import { request } from 'undici'
 
@@ -38,7 +39,35 @@ export async function injectViaRequest (baseUrl, injectParams, onInject) {
   }
 }
 
+export function ensureFileUrl (pathOrUrl) {
+  if (!pathOrUrl) {
+    return pathOrUrl
+  }
+
+  pathOrUrl = pathOrUrl.toString()
+
+  if (pathOrUrl.startsWith('file://')) {
+    return pathOrUrl
+  }
+
+  return pathToFileURL(pathOrUrl)
+}
+
 // This is to avoid common path/URL problems on Windows
 export function importFile (path) {
-  return import(pathToFileURL(path))
+  return import(ensureFileUrl(path))
+}
+
+export function resolvePackage (root, pkg) {
+  const require = createRequire(root)
+
+  return require.resolve(pkg, { paths: [root, ...require.main.paths] })
+}
+
+export function cleanBasePath (basePath) {
+  return basePath ? `/${basePath}`.replaceAll(/\/+/g, '/').replace(/\/$/, '') : '/'
+}
+
+export function ensureTrailingSlash (basePath) {
+  return basePath ? `${basePath}${basePath.endsWith('/') ? '' : '/'}` : '/'
 }

package/lib/worker/child-manager.js

@@ -1,85 +1,206 @@
-import { ITC } from '@platformatic/itc'
-import { subscribe, unsubscribe } from 'node:diagnostics_channel'
+import { ITC, generateNotification } from '@platformatic/itc'
+import { createDirectory, errors } from '@platformatic/utils'
 import { once } from 'node:events'
+import { rm, writeFile } from 'node:fs/promises'
+import { createServer } from 'node:http'
+import { register } from 'node:module'
+import { platform, tmpdir } from 'node:os'
+import { dirname, resolve } from 'node:path'
 import { workerData } from 'node:worker_threads'
 import { request } from 'undici'
+import { WebSocketServer } from 'ws'
+import { exitCodes } from '../errors.js'
+import { ensureFileUrl } from '../utils.js'
 
-export const childProcessWorkerFile = new URL('./child-process.js', import.meta.url)
+export const isWindows = platform() === 'win32'
+
+// In theory we could use the context.id to namespace even more, but due to
+// UNIX socket length limitation on MacOS, we don't.
+function generateChildrenId (context) {
+  return [process.pid, Date.now()].join('-')
+}
+
+export function getSocketPath (id) {
+  let socketPath = null
+  if (platform() === 'win32') {
+    socketPath = `\\\\.\\pipe\\plt-${id}`
+  } else {
+    // As stated in https://nodejs.org/dist/latest-v20.x/docs/api/net.html#identifying-paths-for-ipc-connections,
+    // Node will take care of deleting the file for us
+    socketPath = resolve(tmpdir(), 'platformatic', 'runtimes', `${id}.socket`)
+  }
+
+  return socketPath
+}
 
 export class ChildManager extends ITC {
-  #child
+  #id
+  #loader
+  #context
+  #scripts
+  #logger
+  #server
+  #socketPath
+  #clients
+  #requests
+  #currentClient
   #listener
-  #injectedNodeOptions
   #originalNodeOptions
+  #dataPath
+
+  constructor (opts) {
+    let { loader, context, scripts, handlers, ...itcOpts } = opts
+
+    context ??= {}
+    scripts ??= []
 
-  constructor ({ loader, context }) {
     super({
+      name: 'child-manager',
+      ...itcOpts,
       handlers: {
-        log (message) {
-          workerData.loggingPort.postMessage(JSON.parse(message))
+        log: message => {
+          return this.#log(message)
         },
         fetch: request => {
           return this.#fetch(request)
-        }
+        },
+        ...itcOpts.handlers
       }
     })
 
-    const childHandler = ({ process: child }) => {
-      unsubscribe('child_process', childHandler)
+    this.#id = generateChildrenId(context)
+    this.#loader = loader
+    this.#context = context
+    this.#scripts = scripts
+    this.#originalNodeOptions = process.env.NODE_OPTIONS
+    this.#logger = globalThis.platformatic.logger
+    this.#server = createServer()
+    this.#socketPath ??= getSocketPath(this.#id)
+    this.#clients = new Set()
+    this.#requests = new Map()
+  }
 
-      this.#child = child
-      this.#child.once('exit', () => {
-        this.emit('exit')
-      })
+  async listen () {
+    super.listen()
 
-      this.listen()
+    if (!isWindows) {
+      await createDirectory(dirname(this.#socketPath))
     }
 
-    subscribe('child_process', childHandler)
+    const wssServer = new WebSocketServer({ server: this.#server })
+
+    wssServer.on('connection', ws => {
+      this.#clients.add(ws)
+
+      ws.on('message', raw => {
+        try {
+          const message = JSON.parse(raw)
+          this.#requests.set(message.reqId, ws)
+          this.#listener(message)
+        } catch (error) {
+          this.#handleUnexpectedError(error, 'Handling a message failed.', exitCodes.MANAGER_MESSAGE_HANDLING_FAILED)
+        }
+      })
 
-    this.#prepareChildEnvironment(loader, context)
+      ws.on('close', () => {
+        this.#clients.delete(ws)
+      })
+
+      ws.on('error', error => {
+        this.#handleUnexpectedError(
+          error,
+          'Error while communicating with the children process.',
+          exitCodes.MANAGER_SOCKET_ERROR
+        )
+      })
+    })
+
+    return new Promise((resolve, reject) => {
+      this.#server.listen({ path: this.#socketPath }, resolve).on('error', reject)
+    })
   }
 
-  inject () {
-    process.env.NODE_OPTIONS = this.#injectedNodeOptions
+  async close (signal) {
+    await rm(this.#dataPath)
+
+    for (const client of this.#clients) {
+      this.#currentClient = client
+      this._send(generateNotification('close', signal))
+    }
+
+    super.close()
+  }
+
+  async inject () {
+    await this.listen()
+
+    // Serialize data into a JSON file for the stackable to use
+    this.#dataPath = resolve(tmpdir(), 'platformatic', 'runtimes', `${this.#id}.json`)
+    await createDirectory(dirname(this.#dataPath))
+
+    // We write all the data to a JSON file
+    await writeFile(
+      this.#dataPath,
+      JSON.stringify(
+        {
+          data: this.#context,
+          loader: ensureFileUrl(this.#loader),
+          scripts: this.#scripts.map(s => ensureFileUrl(s))
+        },
+        null,
+        2
+      ),
+      'utf-8'
+    )
+
+    process.env.PLT_MANAGER_ID = this.#id
+    process.env.NODE_OPTIONS =
+      `--import="${new URL('./child-process.js', import.meta.url)}" ${process.env.NODE_OPTIONS ?? ''}`.trim()
   }
 
-  eject () {
+  async eject () {
     process.env.NODE_OPTIONS = this.#originalNodeOptions
+    process.env.PLT_MANAGER_ID = ''
   }
 
-  _setupListener (listener) {
-    this.#listener = listener
-    this.#child.on('message', this.#listener)
+  register () {
+    register(this.#loader, { data: this.#context })
+  }
+
+  send (client, name, message) {
+    this.#currentClient = client
+    super.send(name, message)
+  }
+
+  _send (message) {
+    if (!this.#currentClient) {
+      this.#currentClient = this.#requests.get(message.reqId)
+      this.#requests.delete(message.reqId)
+
+      if (!this.#currentClient) {
+        return
+      }
+    }
+
+    this.#currentClient.send(JSON.stringify(message))
+    this.#currentClient = null
   }
 
-  _send (request) {
-    this.#child.send(request)
+  _setupListener (listener) {
+    this.#listener = listener
   }
 
   _createClosePromise () {
-    return once(this.#child, 'exit')
+    return once(this.#server, 'exit')
   }
 
   _close () {
-    this.#child.removeListener('message', this.#listener)
-    this.#child.kill('SIGKILL')
+    this.#server.close()
   }
 
-  #prepareChildEnvironment (loader, context) {
-    this.#originalNodeOptions = process.env.NODE_OPTIONS
-
-    const loaderScript = `
-      import { register } from 'node:module';
-      globalThis.platformatic=${JSON.stringify(context).replaceAll('"', '\\"')};    
-      register('${loader}',{ data: globalThis.platformatic });
-    `
-
-    this.#injectedNodeOptions = [
-      `--import="data:text/javascript,${loaderScript.replaceAll(/\n/g, '')}"`,
-      `--import=${childProcessWorkerFile}`,
-      process.env.NODE_OPTIONS ?? ''
-    ].join(' ')
+  #log (message) {
+    const logs = Array.isArray(message.logs) ? message.logs : [message.logs]
+    workerData.loggingPort.postMessage({ logs: logs.map(m => JSON.stringify(m)) })
   }
 
   async #fetch (opts) {
@@ -90,4 +211,9 @@ export class ChildManager extends ITC {
 
     return { statusCode, headers, body: payload, payload, rawPayload }
   }
+
+  #handleUnexpectedError (error, message, exitCode) {
+    this.#logger.error({ err: errors.ensureLoggableError(error) }, message)
+    process.exit(exitCode)
+  }
 }

package/lib/worker/child-process.js

@@ -1,8 +1,18 @@
 import { ITC } from '@platformatic/itc'
-import { createPinoWritable, DestinationWritable, withResolvers } from '@platformatic/utils'
+import { createPinoWritable, errors } from '@platformatic/utils'
 import { tracingChannel } from 'node:diagnostics_channel'
+import { once } from 'node:events'
+import { readFile } from 'node:fs/promises'
+import { register } from 'node:module'
+import { platform, tmpdir } from 'node:os'
+import { basename, resolve } from 'node:path'
+import { isMainThread } from 'node:worker_threads'
 import pino from 'pino'
 import { getGlobalDispatcher, setGlobalDispatcher } from 'undici'
+import { WebSocket } from 'ws'
+import { exitCodes } from '../errors.js'
+import { importFile } from '../utils.js'
+import { getSocketPath, isWindows } from './child-manager.js'
 
 function createInterceptor (itc) {
   return function (dispatch) {
@@ -18,7 +28,7 @@ function createInterceptor (itc) {
       }
 
       const headers = {
-        ...opts?.headers,
+        ...opts?.headers
       }
 
       delete headers.connection
@@ -27,7 +37,7 @@ function createInterceptor (itc) {
 
       const requestOpts = {
         ...opts,
-        headers,
+        headers
       }
       delete requestOpts.dispatcher
 
@@ -64,66 +74,104 @@ function createInterceptor (itc) {
   }
 }
 
-class ChildProcessWritable extends DestinationWritable {
-  #itc
-
-  constructor (options) {
-    const { itc, ...opts } = options
-
-    super(opts)
-    this.#itc = itc
-  }
-
-  _send (message) {
-    this.#itc.send('log', JSON.stringify(message))
-  }
-}
-
-class ChildProcess extends ITC {
+export class ChildProcess extends ITC {
   #listener
+  #socket
   #child
   #logger
+  #pendingMessages
 
   constructor () {
-    super({})
+    super({ throwOnMissingHandler: false, name: `${process.env.PLT_MANAGER_ID}-child-process` })
+
+    const protocol = platform() === 'win32' ? 'ws+unix:' : 'ws+unix://'
+    this.#socket = new WebSocket(`${protocol}${getSocketPath(process.env.PLT_MANAGER_ID)}`)
+    this.#pendingMessages = []
 
     this.listen()
     this.#setupLogger()
+    this.#setupHandlers()
     this.#setupServer()
     this.#setupInterceptors()
+
+    this.on('close', signal => {
+      process.kill(process.pid, signal)
+    })
   }
 
   _setupListener (listener) {
     this.#listener = listener
-    process.on('message', this.#listener)
+
+    this.#socket.on('open', () => {
+      // Never hang the process on this socket.
+      this.#socket._socket.unref()
+
+      for (const message of this.#pendingMessages) {
+        this.#socket.send(message)
+      }
+    })
+
+    this.#socket.on('message', message => {
+      try {
+        this.#listener(JSON.parse(message))
+      } catch (error) {
+        this.#logger.error({ err: errors.ensureLoggableError(error) }, 'Handling a message failed.')
+        process.exit(exitCodes.PROCESS_MESSAGE_HANDLING_FAILED)
+      }
+    })
+
+    this.#socket.on('error', error => {
+      process._rawDebug(error)
+      // There is nothing to log here as the connection with the parent thread is lost. Exit with a special code
+      process.exit(exitCodes.PROCESS_SOCKET_ERROR)
+    })
   }
 
-  _send (request) {
-    process.send(request)
+  _send (message) {
+    if (this.#socket.readyState === WebSocket.CONNECTING) {
+      this.#pendingMessages.push(JSON.stringify(message))
+      return
+    }
+
+    this.#socket.send(JSON.stringify(message))
   }
 
   _createClosePromise () {
-    const { promise } = withResolvers()
-    return promise
+    return once(this.#socket, 'close')
   }
 
   _close () {
-    process.kill(process.pid, 'SIGKILL')
-    this.#child.removeListener('message', this.#listener)
+    this.#socket.close()
   }
 
   #setupLogger () {
-    const destination = new ChildProcessWritable({ itc: this })
-    this.#logger = pino({ level: 'info', ...globalThis.platformatic.logger }, destination)
-
-    Reflect.defineProperty(process, 'stdout', { value: createPinoWritable(this.#logger, 'info') })
-    Reflect.defineProperty(process, 'stderr', { value: createPinoWritable(this.#logger, 'error') })
+    // Since this is executed by user code, make sure we only override this in the main thread
+    // The rest will be intercepted by the BaseStackable.
+    if (isMainThread) {
+      this.#logger = pino({
+        level: 'info',
+        name: globalThis.platformatic.id,
+        transport: {
+          target: new URL('./child-transport.js', import.meta.url).toString(),
+          options: { id: globalThis.platformatic.id }
+        }
+      })
+
+      Reflect.defineProperty(process, 'stdout', { value: createPinoWritable(this.#logger, 'info') })
+      Reflect.defineProperty(process, 'stderr', { value: createPinoWritable(this.#logger, 'error') })
+    } else {
+      this.#logger = pino({ level: 'info', name: globalThis.platformatic.id })
+    }
   }
 
   #setupServer () {
     const subscribers = {
       asyncStart ({ options }) {
-        options.port = 0
+        const port = globalThis.platformatic.port
+
+        if (port !== false) {
+          options.port = typeof port === 'number' ? port : 0
+        }
       },
       asyncEnd: ({ server }) => {
         tracingChannel('net.server.listen').unsubscribe(subscribers)
@@ -136,7 +184,7 @@ class ChildProcess extends ITC {
       error: error => {
         tracingChannel('net.server.listen').unsubscribe(subscribers)
         this.notify('error', error)
-      },
+      }
     }
 
     tracingChannel('net.server.listen').subscribe(subscribers)
@@ -145,6 +193,40 @@ class ChildProcess extends ITC {
   #setupInterceptors () {
     setGlobalDispatcher(getGlobalDispatcher().compose(createInterceptor(this)))
   }
+
+  #setupHandlers () {
+    function handleUnhandled (type, err) {
+      process._rawDebug(globalThis.platformatic.id, err)
+      this.#logger.error(
+        { err: errors.ensureLoggableError(err) },
+        `Child process for service ${globalThis.platformatic.id} threw an ${type}.`
+      )
+
+      process.exit(exitCodes.PROCESS_UNHANDLED_ERROR)
+    }
+
+    process.on('uncaughtException', handleUnhandled.bind(this, 'uncaught exception'))
+    process.on('unhandledRejection', handleUnhandled.bind(this, 'unhandled rejection'))
+  }
 }
 
-globalThis[Symbol.for('plt.children.itc')] = new ChildProcess()
+async function main () {
+  const dataPath = resolve(tmpdir(), 'platformatic', 'runtimes', `${process.env.PLT_MANAGER_ID}.json`)
+  const { data, loader, scripts } = JSON.parse(await readFile(dataPath))
+
+  globalThis.platformatic = data
+
+  if (loader) {
+    register(loader, { data })
+  }
+
+  for (const script of scripts) {
+    await importFile(script)
+  }
+
+  globalThis[Symbol.for('plt.children.itc')] = new ChildProcess()
+}
+
+if (!isWindows || basename(process.argv.at(-1)) !== 'npm-prefix.js') {
+  await main()
+}

package/lib/worker/child-transport.js

@@ -0,0 +1,54 @@
+import { generateRequest } from '@platformatic/itc'
+import { errors } from '@platformatic/utils'
+import { once } from 'node:events'
+import { platform } from 'node:os'
+import { workerData } from 'node:worker_threads'
+import build from 'pino-abstract-transport'
+import { WebSocket } from 'ws'
+import { getSocketPath } from './child-manager.js'
+
+function logDirectError (message, error) {
+  process._rawDebug(`Logger thread for child process of service ${workerData.id} ${message}.`, {
+    error: errors.ensureLoggableError(error)
+  })
+}
+
+function handleUnhandled (type, error) {
+  logDirectError(`threw an ${type}`, error)
+  process.exit(6)
+}
+
+process.on('uncaughtException', handleUnhandled.bind(null, 'uncaught exception'))
+process.on('unhandledRejection', handleUnhandled.bind(null, 'unhandled rejection'))
+
+export default async function (opts) {
+  try {
+    const protocol = platform() === 'win32' ? 'ws+unix:' : 'ws+unix://'
+    const socket = new WebSocket(`${protocol}${getSocketPath(process.env.PLT_MANAGER_ID)}`)
+
+    await once(socket, 'open')
+
+    // Do not process responses but empty the socket inbound queue
+    socket.on('message', () => {})
+
+    socket.on('error', error => {
+      logDirectError('threw a socket error', error)
+    })
+
+    return build(
+      async function (source) {
+        for await (const obj of source) {
+          socket.send(JSON.stringify(generateRequest('log', { logs: [obj] })))
+        }
+      },
+      {
+        close (_, cb) {
+          socket.close()
+          cb()
+        }
+      }
+    )
+  } catch (error) {
+    logDirectError('threw a connection error', error)
+  }
+}

package/lib/worker/listeners.js

@@ -0,0 +1,51 @@
+import { withResolvers } from '@platformatic/utils'
+import { subscribe, tracingChannel, unsubscribe } from 'node:diagnostics_channel'
+
+export function createServerListener (overridePort = true) {
+  const { promise, resolve, reject } = withResolvers()
+
+  const subscribers = {
+    asyncStart ({ options }) {
+      if (overridePort !== false) {
+        options.port = typeof overridePort === 'number' ? overridePort : 0
+      }
+    },
+    asyncEnd ({ server }) {
+      resolve(server)
+    },
+    error (error) {
+      cancel()
+      reject(error)
+    }
+  }
+
+  function cancel () {
+    tracingChannel('net.server.listen').unsubscribe(subscribers)
+  }
+
+  tracingChannel('net.server.listen').subscribe(subscribers)
+  promise.finally(cancel)
+  promise.cancel = resolve.bind(null, null)
+
+  return promise
+}
+
+export function createChildProcessListener () {
+  const { promise, resolve } = withResolvers()
+
+  const handler = ({ process: child }) => {
+    unsubscribe('child_process', handler)
+    resolve(child)
+  }
+
+  function cancel () {
+    unsubscribe('child_process', handler)
+  }
+
+  subscribe('child_process', handler)
+
+  promise.finally(cancel)
+  promise.cancel = resolve.bind(null, null)
+
+  return promise
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/basic",
-  "version": "2.0.0-alpha.7",
+  "version": "2.0.0-alpha.8",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -16,12 +16,16 @@
   "homepage": "https://github.com/platformatic/platformatic#readme",
   "dependencies": {
     "@fastify/error": "^4.0.0",
+    "execa": "^9.3.1",
     "pino": "^9.3.2",
+    "pino-abstract-transport": "^2.0.0",
     "semver": "^7.6.3",
+    "split2": "^4.2.0",
     "undici": "^6.19.5",
-    "@platformatic/config": "2.0.0-alpha.7",
-    "@platformatic/itc": "2.0.0-alpha.7",
-    "@platformatic/utils": "2.0.0-alpha.7"
+    "ws": "^8.18.0",
+    "@platformatic/config": "2.0.0-alpha.8",
+    "@platformatic/itc": "2.0.0-alpha.8",
+    "@platformatic/utils": "2.0.0-alpha.8"
   },
   "devDependencies": {
     "borp": "^0.17.0",
@@ -35,9 +39,8 @@
     "react-dom": "^18.3.1",
     "typescript": "^5.5.4",
     "vite": "^5.4.0",
-    "ws": "^8.18.0",
-    "@platformatic/composer": "2.0.0-alpha.7",
-    "@platformatic/service": "2.0.0-alpha.7"
+    "@platformatic/composer": "2.0.0-alpha.8",
+    "@platformatic/service": "2.0.0-alpha.8"
   },
   "scripts": {
     "gen-schema": "node lib/schema.js > schema.json",

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/basic/2.0.0-alpha.7.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/basic/2.0.0-alpha.8.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Stackable",
   "type": "object",

package/lib/worker/server-listener.js

@@ -1,29 +0,0 @@
-import { withResolvers } from '@platformatic/utils'
-import { tracingChannel } from 'node:diagnostics_channel'
-
-export function createServerListener () {
-  const { promise, resolve, reject } = withResolvers()
-
-  const subscribers = {
-    asyncStart ({ options }) {
-      options.port = 0
-    },
-    asyncEnd ({ server }) {
-      resolve(server)
-    },
-    error (error) {
-      cancel()
-      reject(error)
-    },
-  }
-
-  function cancel () {
-    tracingChannel('net.server.listen').unsubscribe(subscribers)
-  }
-
-  tracingChannel('net.server.listen').subscribe(subscribers)
-  promise.finally(cancel)
-  promise.cancel = resolve.bind(null, null)
-
-  return promise
-}

package/test/helper.js

@@ -1,166 +0,0 @@
-import { createDirectory, withResolvers } from '@platformatic/utils'
-import { deepStrictEqual, ok, strictEqual } from 'node:assert'
-import { existsSync } from 'node:fs'
-import { readFile, symlink, writeFile } from 'node:fs/promises'
-import { dirname, resolve } from 'node:path'
-import { setTimeout as sleep } from 'node:timers/promises'
-import { Client, request } from 'undici'
-import WebSocket from 'ws'
-import { loadConfig } from '../../config/index.js'
-import { buildServer, platformaticRuntime } from '../../runtime/index.js'
-
-export { setTimeout as sleep } from 'node:timers/promises'
-
-const HMR_TIMEOUT = process.env.CI ? 20000 : 10000
-let hrmVersion = Date.now()
-export let fixturesDir
-
-export function setFixturesDir (directory) {
-  fixturesDir = directory
-}
-
-// This is used to debug tests
-export function pause (url, timeout = 300000) {
-  console.log(`Server is listening at ${url}`)
-  return sleep(timeout)
-}
-
-export async function ensureDependency (directory, pkg, source) {
-  const [namespace, name] = pkg.includes('/') ? pkg.split('/') : ['', pkg]
-  const basedir = resolve(fixturesDir, directory, `node_modules/${namespace}`)
-  const destination = resolve(basedir, name)
-
-  await createDirectory(basedir)
-  if (!existsSync(destination)) {
-    await symlink(source, destination, 'dir')
-  }
-}
-
-export async function createRuntime (t, path, packageRoot) {
-  const configFile = resolve(fixturesDir, path)
-
-  if (packageRoot) {
-    const packageName = JSON.parse(await readFile(resolve(packageRoot, 'package.json'), 'utf-8')).name
-    const root = dirname(configFile)
-    await ensureDependency(root, packageName, packageRoot)
-  }
-
-  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
-  const runtime = await buildServer(config.configManager.current)
-  const url = await runtime.start()
-
-  t.after(async () => {
-    await runtime.close()
-  })
-
-  return { runtime, url }
-}
-
-export async function getLogs (app) {
-  const client = new Client(
-    {
-      hostname: 'localhost',
-      protocol: 'http:'
-    },
-    {
-      socketPath: app.getManagementApiUrl(),
-      keepAliveTimeout: 10,
-      keepAliveMaxTimeout: 10
-    }
-  )
-
-  // Wait for logs to be written
-  await sleep(3000)
-
-  const { statusCode, body } = await client.request({
-    method: 'GET',
-    path: '/api/v1/logs/all'
-  })
-
-  strictEqual(statusCode, 200)
-
-  const rawLogs = await body.text()
-
-  return rawLogs
-    .trim()
-    .split('\n')
-    .filter(l => l)
-    .map(m => JSON.parse(m))
-}
-
-export async function updateHMRVersion (versionFile) {
-  versionFile ??= resolve(fixturesDir, '../tmp/version.js')
-  await createDirectory(dirname(versionFile))
-  await writeFile(versionFile, `export const version = ${hrmVersion++}\n`, 'utf-8')
-}
-
-export async function verifyJSONViaHTTP (baseUrl, path, expectedCode, expectedContent) {
-  const { statusCode, body } = await request(baseUrl + path)
-  strictEqual(statusCode, expectedCode)
-  deepStrictEqual(await body.json(), expectedContent)
-}
-
-export async function verifyJSONViaInject (app, serviceId, method, url, expectedCode, expectedContent) {
-  const { statusCode, body } = await app.inject(serviceId, { method, url })
-  strictEqual(statusCode, expectedCode)
-  deepStrictEqual(JSON.parse(body), expectedContent)
-}
-
-export async function verifyHTMLViaHTTP (baseUrl, path, contents) {
-  const { statusCode, headers, body } = await request(baseUrl + path, { maxRedirections: 1 })
-  const html = await body.text()
-
-  deepStrictEqual(statusCode, 200)
-  ok(headers['content-type']?.startsWith('text/html'))
-
-  for (const content of contents) {
-    ok(content instanceof RegExp ? content.test(html) : html.includes(content), content)
-  }
-}
-
-export async function verifyHTMLViaInject (app, serviceId, url, contents) {
-  const { statusCode, headers, body: html } = await app.inject(serviceId, { method: 'GET', url })
-
-  deepStrictEqual(statusCode, 200)
-  ok(headers['content-type'].startsWith('text/html'))
-
-  for (const content of contents) {
-    ok(content instanceof RegExp ? content.test(html) : html.includes(content), content)
-  }
-}
-
-export async function verifyHMR (baseUrl, path, protocol, handler) {
-  const connection = withResolvers()
-  const reload = withResolvers()
-  const ac = new AbortController()
-  const timeout = sleep(HMR_TIMEOUT, 'timeout', { signal: ac.signal })
-
-  const url = baseUrl.replace('http:', 'ws:') + path
-  const webSocket = new WebSocket(url, protocol)
-
-  webSocket.on('error', err => {
-    clearTimeout(timeout)
-    connection.reject(err)
-    reload.reject(err)
-  })
-
-  webSocket.on('message', data => {
-    handler(JSON.parse(data), connection.resolve, reload.resolve)
-  })
-
-  try {
-    if ((await Promise.race([connection.promise, timeout])) === 'timeout') {
-      throw new Error('Timeout while waiting for HMR connection')
-    }
-
-    await sleep(1000)
-    await updateHMRVersion()
-
-    if ((await Promise.race([reload.promise, timeout])) === 'timeout') {
-      throw new Error('Timeout while waiting for HMR reload')
-    }
-  } finally {
-    webSocket.terminate()
-    ac.abort()
-  }
-}