@happier-dev/stack 0.2.0 → 0.2.11

package/scripts/runtime/launch/resolveCliRuntimeLaunchSpec.mjs

@@ -4,7 +4,56 @@ import { getFirstPartyComponentCatalogEntry } from '@happier-dev/cli-common/firs
 
 import { resolveRuntimeManifestEntrypoint } from '../shared/runtime_manifest.mjs';
 
+const RUNTIME_PROVENANCE_ENV_KEYS = [
+  'HAPPIER_CLI_SUBPROCESS_RUNTIME_BACKED',
+  'HAPPIER_CLI_SUBPROCESS_DIST_ENTRYPOINT',
+  'HAPPIER_CLI_SUBPROCESS_DAEMON_DIST_CLOSURE_FINGERPRINT',
+];
+
+export function resolveCliRuntimeLaunchProvenance(cliLaunchSpec) {
+  if (!cliLaunchSpec) {
+    return {
+      runtimeBacked: false,
+      admittedDistClosureFingerprint: null,
+      distEntrypoint: '',
+    };
+  }
+  const admittedDistClosureFingerprint = String(
+    cliLaunchSpec.daemonDistClosureFingerprint ?? '',
+  ).trim().toLowerCase();
+  const distEntrypoint = String(
+    cliLaunchSpec.nodeEntrypoint || cliLaunchSpec.entrypoint || '',
+  ).trim();
+  if (
+    cliLaunchSpec.runtimeBacked !== true
+    || !/^[a-f0-9]{16}$/.test(admittedDistClosureFingerprint)
+    || !distEntrypoint
+  ) {
+    throw new Error('[runtime] invalid canonical CLI runtime launch provenance.');
+  }
+  return {
+    runtimeBacked: true,
+    admittedDistClosureFingerprint,
+    distEntrypoint,
+  };
+}
+
+export function applyCliRuntimeLaunchProvenanceEnv({ env = {}, cliLaunchSpec = null } = {}) {
+  const projected = { ...env };
+  for (const key of RUNTIME_PROVENANCE_ENV_KEYS) delete projected[key];
+  const provenance = resolveCliRuntimeLaunchProvenance(cliLaunchSpec);
+  if (!provenance.runtimeBacked) return projected;
+  projected.HAPPIER_CLI_SUBPROCESS_RUNTIME_BACKED = '1';
+  projected.HAPPIER_CLI_SUBPROCESS_DIST_ENTRYPOINT = provenance.distEntrypoint;
+  projected.HAPPIER_CLI_SUBPROCESS_DAEMON_DIST_CLOSURE_FINGERPRINT = provenance.admittedDistClosureFingerprint;
+  return projected;
+}
+
 export function resolveCliRuntimeLaunchSpec({ snapshot }) {
+  const daemonDistClosureFingerprint = String(snapshot?.daemonDistClosureFingerprint ?? '').trim().toLowerCase();
+  if (!/^[a-f0-9]{16}$/.test(daemonDistClosureFingerprint)) {
+    throw new Error('[runtime] admitted daemon snapshot is missing a valid dist closure fingerprint.');
+  }
   const daemonComponent = getFirstPartyComponentCatalogEntry('happier-daemon');
   const runtimeRoot = snapshot.launchPath ?? snapshot.snapshotPath;
   const entrypoint =
@@ -19,5 +68,7 @@ export function resolveCliRuntimeLaunchSpec({ snapshot }) {
       : '',
     command: entrypoint,
     args: [],
+    runtimeBacked: true,
+    daemonDistClosureFingerprint,
   };
 }

package/scripts/runtime/launch/resolveLaunchSpecs.test.mjs

@@ -1,13 +1,18 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 
-import { resolveCliRuntimeLaunchSpec } from './resolveCliRuntimeLaunchSpec.mjs';
+import {
+  applyCliRuntimeLaunchProvenanceEnv,
+  resolveCliRuntimeLaunchProvenance,
+  resolveCliRuntimeLaunchSpec,
+} from './resolveCliRuntimeLaunchSpec.mjs';
 import { resolveServerRuntimeLaunchSpec } from './resolveServerRuntimeLaunchSpec.mjs';
 
 test('resolveCliRuntimeLaunchSpec returns a runtime binary command from the snapshot', () => {
   const resolved = resolveCliRuntimeLaunchSpec({
     snapshot: {
       snapshotPath: '/tmp/stack/runtime/builds/snap-1',
+      daemonDistClosureFingerprint: '1111111111111111',
       manifest: {
         components: {
           daemon: { entrypoint: 'cli/happier' },
@@ -23,15 +28,65 @@ test('resolveCliRuntimeLaunchSpec returns a runtime binary command from the snap
     nodeEntrypoint: '/tmp/stack/runtime/builds/snap-1/cli/package-dist/index.mjs',
     command: '/tmp/stack/runtime/builds/snap-1/cli/happier',
     args: [],
+    runtimeBacked: true,
+    daemonDistClosureFingerprint: '1111111111111111',
   });
 });
 
+test('runtime CLI provenance is one canonical shape for daemon options and nested CLI environment', () => {
+  const launchSpec = resolveCliRuntimeLaunchSpec({
+    snapshot: {
+      snapshotPath: '/tmp/runtime/builds/snap-a',
+      launchPath: '/tmp/runtime/builds/snap-a',
+      daemonDistClosureFingerprint: 'abcdef1234567890',
+      manifest: {
+        entrypoints: { daemon: 'cli/happier' },
+      },
+    },
+  });
+
+  assert.deepEqual(resolveCliRuntimeLaunchProvenance(launchSpec), {
+    runtimeBacked: true,
+    admittedDistClosureFingerprint: 'abcdef1234567890',
+    distEntrypoint: '/tmp/runtime/builds/snap-a/cli/package-dist/index.mjs',
+  });
+  const projected = applyCliRuntimeLaunchProvenanceEnv({
+    env: {},
+    cliLaunchSpec: launchSpec,
+  });
+  assert.equal(projected.HAPPIER_CLI_SUBPROCESS_RUNTIME_BACKED, '1');
+  assert.equal(projected.HAPPIER_CLI_SUBPROCESS_DIST_ENTRYPOINT, '/tmp/runtime/builds/snap-a/cli/package-dist/index.mjs');
+  assert.equal(projected.HAPPIER_CLI_SUBPROCESS_DAEMON_DIST_CLOSURE_FINGERPRINT, 'abcdef1234567890');
+});
+
+test('source CLI provenance clears inherited runtime-backed subprocess policy', () => {
+  const projected = applyCliRuntimeLaunchProvenanceEnv({
+    env: {
+      HAPPIER_CLI_SUBPROCESS_RUNTIME_BACKED: '1',
+      HAPPIER_CLI_SUBPROCESS_DIST_ENTRYPOINT: '/stale/runtime/index.mjs',
+      HAPPIER_CLI_SUBPROCESS_DAEMON_DIST_CLOSURE_FINGERPRINT: 'abcdef1234567890',
+      KEEP_ME: 'yes',
+    },
+    cliLaunchSpec: null,
+  });
+  assert.deepEqual(resolveCliRuntimeLaunchProvenance(null), {
+    runtimeBacked: false,
+    admittedDistClosureFingerprint: null,
+    distEntrypoint: '',
+  });
+  assert.equal(projected.HAPPIER_CLI_SUBPROCESS_RUNTIME_BACKED, undefined);
+  assert.equal(projected.HAPPIER_CLI_SUBPROCESS_DIST_ENTRYPOINT, undefined);
+  assert.equal(projected.HAPPIER_CLI_SUBPROCESS_DAEMON_DIST_CLOSURE_FINGERPRINT, undefined);
+  assert.equal(projected.KEEP_ME, 'yes');
+});
+
 test('resolveServerRuntimeLaunchSpec returns the runtime server binary command from the snapshot', () => {
   const resolved = resolveServerRuntimeLaunchSpec({
     serverComponent: 'happier-server-light',
     snapshot: {
       snapshotPath: '/tmp/stack/runtime/builds/snap-1',
       manifest: {
+        source: { serverComponent: 'happier-server-light' },
         components: {
           server: { entrypoint: 'server/happier-server' },
         },
@@ -45,30 +100,109 @@ test('resolveServerRuntimeLaunchSpec returns the runtime server binary command f
     entrypoint: '/tmp/stack/runtime/builds/snap-1/server/happier-server',
     command: '/tmp/stack/runtime/builds/snap-1/server/happier-server',
     args: [],
+    migration: { mode: 'in-process' },
   });
 });
 
-test('resolveServerRuntimeLaunchSpec falls back to the canonical server binary path when the manifest is absent', () => {
+test('resolveServerRuntimeLaunchSpec rejects a snapshot without admitted server component metadata', () => {
+  assert.throws(
+    () => resolveServerRuntimeLaunchSpec({
+      serverComponent: 'happier-server',
+      snapshot: { snapshotPath: '/tmp/stack/runtime/builds/snap-1' },
+    }),
+    (error) => error.code === 'ERUNTIMESERVERCOMPONENTUNAVAILABLE'
+      && error.reason === 'missing_admitted_server_component',
+  );
+});
+
+test('resolveServerRuntimeLaunchSpec rejects both requested/admitted server component mismatch directions', () => {
+  for (const [requested, admitted] of [
+    ['happier-server-light', 'happier-server'],
+    ['happier-server', 'happier-server-light'],
+  ]) {
+    assert.throws(
+      () => resolveServerRuntimeLaunchSpec({
+        serverComponent: requested,
+        snapshot: {
+          snapshotPath: '/tmp/stack/runtime/builds/snap-1',
+          manifest: {
+            source: { serverComponent: admitted },
+            components: { server: { entrypoint: 'server/happier-server' } },
+          },
+        },
+      }),
+      (error) => error.code === 'ERUNTIMESERVERCOMPONENTMISMATCH'
+        && error.requestedServerComponent === requested
+        && error.admittedServerComponent === admitted,
+      `${requested} must reject admitted ${admitted}`,
+    );
+  }
+});
+
+test('resolveServerRuntimeLaunchSpec derives the Windows full-server migration executable beside the admitted entrypoint', () => {
   const resolved = resolveServerRuntimeLaunchSpec({
     serverComponent: 'happier-server',
+    dbProvider: 'postgres',
     snapshot: {
-      snapshotPath: '/tmp/stack/runtime/builds/snap-1',
+      snapshotPath: 'C:\\runtime\\builds\\snap-1',
+      manifest: {
+        source: { serverComponent: 'happier-server' },
+        components: {
+          server: { entrypoint: 'server/happier-server.exe' },
+        },
+      },
     },
   });
 
-  assert.deepEqual(resolved, {
-    source: 'runtime',
-    serverDir: '/tmp/stack/runtime/builds/snap-1/server',
-    entrypoint: '/tmp/stack/runtime/builds/snap-1/server/happier-server',
-    command: '/tmp/stack/runtime/builds/snap-1/server/happier-server',
-    args: [],
+  assert.equal(resolved.migration.command, 'C:\\runtime\\builds\\snap-1/server/happier-server-migrate.exe');
+  assert.deepEqual(resolved.migration.args, []);
+  assert.equal(resolved.migration.cwd, 'C:\\runtime\\builds\\snap-1/server');
+});
+
+test('resolveServerRuntimeLaunchSpec derives packaged migrations from the provider, not the preset', () => {
+  const snapshot = {
+    snapshotPath: '/tmp/stack/runtime/builds/snap-1',
+    manifest: {
+      source: { serverComponent: 'happier-server-light' },
+      components: { server: { entrypoint: 'server/happier-server' } },
+    },
+  };
+
+  const postgres = resolveServerRuntimeLaunchSpec({
+    serverComponent: 'happier-server-light',
+    dbProvider: 'postgres',
+    snapshot,
+  });
+  assert.equal(postgres.migration.command, '/tmp/stack/runtime/builds/snap-1/server/happier-server-migrate');
+
+  const pglite = resolveServerRuntimeLaunchSpec({
+    serverComponent: 'happier-server-light',
+    dbProvider: 'pglite',
+    snapshot,
   });
+  assert.equal(pglite.migration.command, '/tmp/stack/runtime/builds/snap-1/server/happier-server-migrate');
+
+  const sqlite = resolveServerRuntimeLaunchSpec({
+    serverComponent: 'happier-server-light',
+    dbProvider: 'sqlite',
+    snapshot,
+  });
+  assert.deepEqual(sqlite.migration, { mode: 'in-process' });
+
+  const disabled = resolveServerRuntimeLaunchSpec({
+    serverComponent: 'happier-server-light',
+    dbProvider: 'postgres',
+    migrationsEnabled: false,
+    snapshot,
+  });
+  assert.deepEqual(disabled.migration, { mode: 'disabled' });
 });
 
 test('resolveCliRuntimeLaunchSpec falls back to the canonical cli path when the manifest entrypoint escapes the snapshot root', () => {
   const resolved = resolveCliRuntimeLaunchSpec({
     snapshot: {
       snapshotPath: '/tmp/stack/runtime/builds/snap-1',
+      daemonDistClosureFingerprint: '1111111111111111',
       manifest: {
         components: {
           daemon: { entrypoint: '../outside-cli' },
@@ -84,15 +218,19 @@ test('resolveCliRuntimeLaunchSpec falls back to the canonical cli path when the
     nodeEntrypoint: '/tmp/stack/runtime/builds/snap-1/cli/package-dist/index.mjs',
     command: '/tmp/stack/runtime/builds/snap-1/cli/happier',
     args: [],
+    runtimeBacked: true,
+    daemonDistClosureFingerprint: '1111111111111111',
   });
 });
 
 test('resolveServerRuntimeLaunchSpec falls back to the canonical server path when the manifest entrypoint escapes the snapshot root', () => {
   const resolved = resolveServerRuntimeLaunchSpec({
     serverComponent: 'happier-server',
+    dbProvider: 'postgres',
     snapshot: {
       snapshotPath: '/tmp/stack/runtime/builds/snap-1',
       manifest: {
+        source: { serverComponent: 'happier-server' },
         components: {
           server: { entrypoint: '../outside-server' },
         },
@@ -106,5 +244,11 @@ test('resolveServerRuntimeLaunchSpec falls back to the canonical server path whe
     entrypoint: '/tmp/stack/runtime/builds/snap-1/server/happier-server',
     command: '/tmp/stack/runtime/builds/snap-1/server/happier-server',
     args: [],
+    migration: {
+      mode: 'packaged',
+      command: '/tmp/stack/runtime/builds/snap-1/server/happier-server-migrate',
+      args: [],
+      cwd: '/tmp/stack/runtime/builds/snap-1/server',
+    },
   });
 });

package/scripts/runtime/launch/resolveServerRuntimeLaunchSpec.mjs

@@ -2,18 +2,75 @@ import { join } from 'node:path';
 
 import { resolveRuntimeManifestEntrypoint } from '../shared/runtime_manifest.mjs';
 
-export function resolveServerRuntimeLaunchSpec({ serverComponent, snapshot }) {
-  void serverComponent;
+const SERVER_COMPONENTS = new Set(['happier-server', 'happier-server-light']);
+
+export class RuntimeServerComponentError extends Error {
+  constructor(message, { code, reason, requestedServerComponent = null, admittedServerComponent = null } = {}) {
+    super(message);
+    this.name = 'RuntimeServerComponentError';
+    this.code = code;
+    this.reason = reason;
+    this.requestedServerComponent = requestedServerComponent;
+    this.admittedServerComponent = admittedServerComponent;
+  }
+}
+
+function resolveAdmittedServerComponent({ serverComponent, snapshot }) {
+  const requestedServerComponent = String(serverComponent ?? '').trim();
+  const admittedServerComponent = String(snapshot?.manifest?.source?.serverComponent ?? '').trim();
+  if (!admittedServerComponent) {
+    throw new RuntimeServerComponentError('[runtime] admitted snapshot server component is missing', {
+      code: 'ERUNTIMESERVERCOMPONENTUNAVAILABLE',
+      reason: 'missing_admitted_server_component',
+      requestedServerComponent,
+    });
+  }
+  if (!SERVER_COMPONENTS.has(admittedServerComponent)) {
+    throw new RuntimeServerComponentError(`[runtime] admitted snapshot server component is unsupported: ${admittedServerComponent}`, {
+      code: 'ERUNTIMESERVERCOMPONENTUNAVAILABLE',
+      reason: 'unsupported_admitted_server_component',
+      requestedServerComponent,
+      admittedServerComponent,
+    });
+  }
+  if (!SERVER_COMPONENTS.has(requestedServerComponent) || requestedServerComponent !== admittedServerComponent) {
+    throw new RuntimeServerComponentError(
+      `[runtime] requested server component ${requestedServerComponent || '<empty>'} does not match admitted snapshot component ${admittedServerComponent}`,
+      {
+        code: 'ERUNTIMESERVERCOMPONENTMISMATCH',
+        reason: 'requested_admitted_server_component_mismatch',
+        requestedServerComponent,
+        admittedServerComponent,
+      },
+    );
+  }
+  return admittedServerComponent;
+}
+
+export function resolveServerRuntimeLaunchSpec({ serverComponent, dbProvider, snapshot, migrationsEnabled = true }) {
+  resolveAdmittedServerComponent({ serverComponent, snapshot });
   const runtimeRoot = snapshot.launchPath ?? snapshot.snapshotPath;
+  const serverDir = join(runtimeRoot, 'server');
   const entrypoint =
     resolveRuntimeManifestEntrypoint({ snapshotPath: runtimeRoot, manifest: snapshot?.manifest, component: 'server' }) ||
-    join(runtimeRoot, 'server', 'happier-server');
+    join(serverDir, 'happier-server');
+  const migration = !migrationsEnabled
+    ? { mode: 'disabled' }
+    : dbProvider === 'postgres' || dbProvider === 'mysql' || dbProvider === 'pglite'
+      ? {
+        mode: 'packaged',
+        command: join(serverDir, `happier-server-migrate${entrypoint.toLowerCase().endsWith('.exe') ? '.exe' : ''}`),
+        args: [],
+        cwd: serverDir,
+      }
+      : { mode: 'in-process' };
 
   return {
     source: 'runtime',
-    serverDir: join(runtimeRoot, 'server'),
+    serverDir,
     entrypoint,
     command: entrypoint,
     args: [],
+    migration,
   };
 }

package/scripts/runtime/launch/resolveStackRuntimeLaunchContext.mjs

@@ -2,10 +2,10 @@ import { getStackName, resolveStackBaseDir } from '../../utils/paths/paths.mjs';
 import { resolveStackRuntimeMode } from '../shared/runtime_mode.mjs';
 import { resolveActiveRuntimeSnapshot } from './resolveActiveRuntimeSnapshot.mjs';
 
-export async function resolveStackRuntimeLaunchContext({ argv = [], env = process.env } = {}) {
+export async function resolveStackRuntimeLaunchContext({ argv = [], env = process.env, activeRuntimeState = null } = {}) {
   const stackName = (env.HAPPIER_STACK_STACK ?? '').toString().trim() || getStackName(env);
   const { baseDir: stackBaseDir } = resolveStackBaseDir(stackName, env);
-  const runtimeMode = resolveStackRuntimeMode({ argv, env });
+  const runtimeMode = resolveStackRuntimeMode({ argv, env, activeRuntimeState });
   const snapshot = await resolveActiveRuntimeSnapshot({ mode: runtimeMode.mode, stackBaseDir });
 
   return {

package/scripts/runtime/launch/runServerRuntimeMigration.mjs

@@ -0,0 +1,116 @@
+import { lstat, realpath } from 'node:fs/promises';
+import { basename, dirname, resolve } from 'node:path';
+
+import { spawnProc } from '../../utils/proc/proc.mjs';
+
+export class RuntimeServerMigrationError extends Error {
+  constructor(message, { code, reason, command = null, cwd = null, exitCode = null, signal = null, cause } = {}) {
+    super(message, cause ? { cause } : undefined);
+    this.name = 'RuntimeServerMigrationError';
+    this.code = code;
+    this.reason = reason;
+    this.command = command;
+    this.cwd = cwd;
+    this.exitCode = exitCode;
+    this.signal = signal;
+  }
+}
+
+function migrationError(code, reason, migration, details = {}) {
+  return new RuntimeServerMigrationError(
+    `[local] runtime server migration ${reason.replaceAll('_', ' ')}`,
+    { code, reason, command: migration?.command ?? null, cwd: migration?.cwd ?? null, ...details },
+  );
+}
+
+function throwIfStartupCancelled(isCancellationRequested, migration) {
+  if (isCancellationRequested?.() === true) {
+    throw migrationError('ERUNTIMESERVERMIGRATIONCANCELLED', 'startup_shutdown_requested', migration);
+  }
+}
+
+async function validateRuntimeServerMigration(serverLaunchSpec) {
+  const migration = serverLaunchSpec?.migration;
+  if (!migration || typeof migration.command !== 'string' || !migration.command.trim()) {
+    throw migrationError('ERUNTIMESERVERMIGRATIONUNAVAILABLE', 'missing_artifact_migration_command', migration);
+  }
+  const serverDir = resolve(String(serverLaunchSpec?.serverDir ?? ''));
+  const command = resolve(migration.command);
+  const cwd = resolve(String(migration.cwd ?? ''));
+  const expectedName = `happier-server-migrate${String(serverLaunchSpec?.entrypoint ?? '').toLowerCase().endsWith('.exe') ? '.exe' : ''}`;
+  if (cwd !== serverDir || dirname(command) !== serverDir || basename(command) !== expectedName) {
+    throw migrationError('ERUNTIMESERVERMIGRATIONUNAVAILABLE', 'artifact_migration_command_escape', migration);
+  }
+
+  let commandStat;
+  try {
+    commandStat = await lstat(command);
+    const [realServerDir, realCommand] = await Promise.all([realpath(serverDir), realpath(command)]);
+    if (dirname(realCommand) !== realServerDir) {
+      throw migrationError('ERUNTIMESERVERMIGRATIONUNAVAILABLE', 'artifact_migration_command_escape', migration);
+    }
+  } catch (error) {
+    if (error instanceof RuntimeServerMigrationError) throw error;
+    throw migrationError('ERUNTIMESERVERMIGRATIONUNAVAILABLE', 'unusable_artifact_migration_command', migration, { cause: error });
+  }
+  const executable = process.platform === 'win32' || (commandStat.mode & 0o111) !== 0;
+  if (!commandStat.isFile() || !executable) {
+    throw migrationError('ERUNTIMESERVERMIGRATIONUNAVAILABLE', 'unusable_artifact_migration_command', migration);
+  }
+  return { command, cwd, args: Array.isArray(migration.args) ? migration.args : [] };
+}
+
+export async function runServerRuntimeMigration({
+  serverLaunchSpec,
+  env,
+  children,
+  isCancellationRequested,
+  spawnProcImpl = spawnProc,
+}) {
+  throwIfStartupCancelled(isCancellationRequested, serverLaunchSpec?.migration);
+  if (serverLaunchSpec?.migration?.mode === 'in-process' || serverLaunchSpec?.migration?.mode === 'disabled') return;
+  const migration = await validateRuntimeServerMigration(serverLaunchSpec);
+  throwIfStartupCancelled(isCancellationRequested, migration);
+  let child;
+  try {
+    child = spawnProcImpl('server-migrate', migration.command, migration.args, env, { cwd: migration.cwd });
+  } catch (error) {
+    throw migrationError('ERUNTIMESERVERMIGRATIONUNAVAILABLE', 'spawn_error', migration, { cause: error });
+  }
+  children?.push(child);
+  try {
+    let completion;
+    try {
+      completion = await child?.completion;
+    } catch (error) {
+      throw migrationError('ERUNTIMESERVERMIGRATIONFAILED', 'abnormal_completion', migration, { cause: error });
+    }
+    if (completion?.error) {
+      throw migrationError('ERUNTIMESERVERMIGRATIONUNAVAILABLE', 'spawn_error', migration, { cause: completion.error });
+    }
+    if (completion?.signal) {
+      throw migrationError('ERUNTIMESERVERMIGRATIONFAILED', 'signaled', migration, { signal: completion.signal });
+    }
+    if (completion?.code !== 0) {
+      const reason = Number.isInteger(completion?.code) ? 'nonzero_exit' : 'abnormal_completion';
+      throw migrationError('ERUNTIMESERVERMIGRATIONFAILED', reason, migration, { exitCode: completion?.code ?? null });
+    }
+  } finally {
+    const index = children?.indexOf(child) ?? -1;
+    if (index >= 0) children.splice(index, 1);
+  }
+}
+
+export async function spawnRuntimeServerAfterMigration({
+  serverLaunchSpec,
+  env,
+  children,
+  isCancellationRequested,
+  spawnProcImpl = spawnProc,
+}) {
+  await runServerRuntimeMigration({ serverLaunchSpec, env, children, isCancellationRequested, spawnProcImpl });
+  throwIfStartupCancelled(isCancellationRequested, serverLaunchSpec.migration);
+  const server = spawnProcImpl('server', serverLaunchSpec.command, serverLaunchSpec.args, env, { cwd: serverLaunchSpec.serverDir });
+  children?.push(server);
+  return server;
+}