amalgm 0.1.123 → 0.1.124

package/lib/supervisor.js

@@ -42,6 +42,7 @@ const {
 } = require('./process-cleanup');
 const {
   runtimeLaunchServices,
+  runtimePortsFromState,
   runtimePortsState,
   runtimeServiceScripts,
 } = require('./runtime-manifest');
@@ -52,6 +53,10 @@ const {
 } = require('./updater');
 const PACKAGE_VERSION = require('../package.json').version;
 const PACKAGE_ROOT_DIR = path.join(__dirname, '..');
+const PORT_ALLOCATION_LOCK_DIR = path.join(AMALGM_HOME, 'runtime-port-allocation.lock');
+const PORT_ALLOCATION_LOCK_FILE = path.join(PORT_ALLOCATION_LOCK_DIR, 'owner.json');
+const PORT_ALLOCATION_LOCK_TIMEOUT_MS = 45_000;
+const PORT_ALLOCATION_LOCK_STALE_MS = 120_000;
 
 // npm installs land in the npm prefix, which is only the tree this process runs
 // from when the runtime was started from that prefix. When the service points at
@@ -289,6 +294,11 @@ function serviceSpecs(record, ports, options = {}) {
     env: service.name === 'port-monitor' ? { ...env, PORT: process.env.PORT || '0' } : env,
     port: ports[service.portKey],
     healthPath: '/healthz',
+    expectedRuntimeInstanceId: AMALGM_RUNTIME_INSTANCE_ID,
+    expectedService: service.name,
+    healthHeaders: env.AMALGM_RUNTIME_TOKEN
+      ? { 'x-amalgm-runtime-token': env.AMALGM_RUNTIME_TOKEN }
+      : {},
   }));
 }
 
@@ -352,8 +362,114 @@ async function pickPort(name, envName, preferred, used) {
   throw new Error(`Could not allocate a free port for ${name}`);
 }
 
-async function resolveRuntimePorts() {
+function runtimeStateFilesUnder(dir) {
+  const files = [];
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return files;
+  }
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...runtimeStateFilesUnder(fullPath));
+    } else if (entry.isFile() && entry.name === 'runtime-state.json') {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+function stateProcessRunning(state) {
+  const pids = [
+    state?.supervisor_pid,
+    state?.pid,
+    state?.gateway_pid,
+    ...(Array.isArray(state?.services) ? state.services.map((service) => service?.pid) : []),
+  ];
+  return pids.some((pid) => Number.isInteger(pid) && pid > 0 && isPidRunning(pid));
+}
+
+function liveDeclaredRuntimePorts() {
   const used = new Set();
+  const stateFiles = [
+    ...runtimeStateFilesUnder(path.join(AMALGM_HOME, 'users')),
+    ...runtimeStateFilesUnder(path.join(AMALGM_HOME, 'runtimes')),
+  ];
+  for (const stateFile of new Set(stateFiles)) {
+    if (path.resolve(stateFile) === path.resolve(RUNTIME_STATE_FILE)) continue;
+    const state = readJson(stateFile, null);
+    if (!state || !stateProcessRunning(state)) continue;
+    for (const port of Object.values(runtimePortsFromState(state))) {
+      if (Number.isInteger(port) && port > 0 && port <= 65535) used.add(port);
+    }
+  }
+  return used;
+}
+
+async function acquireRuntimePortAllocationLock(options = {}) {
+  const timeoutMs = options.timeoutMs || PORT_ALLOCATION_LOCK_TIMEOUT_MS;
+  const staleMs = options.staleMs || PORT_ALLOCATION_LOCK_STALE_MS;
+  const started = Date.now();
+  ensureDir(AMALGM_HOME);
+
+  while (true) {
+    try {
+      fs.mkdirSync(PORT_ALLOCATION_LOCK_DIR, { mode: 0o700 });
+      writeJsonSecret(PORT_ALLOCATION_LOCK_FILE, {
+        pid: process.pid,
+        runtime_instance_id: AMALGM_RUNTIME_INSTANCE_ID,
+        runtime_label: AMALGM_RUNTIME_LABEL,
+        user_scope: AMALGM_RUNTIME_USER_SCOPE,
+        acquired_at: new Date().toISOString(),
+      });
+      return () => {
+        const owner = readJson(PORT_ALLOCATION_LOCK_FILE, null);
+        if (owner?.pid === process.pid) {
+          fs.rmSync(PORT_ALLOCATION_LOCK_DIR, { recursive: true, force: true });
+        }
+      };
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error;
+      const owner = readJson(PORT_ALLOCATION_LOCK_FILE, null);
+      let mtimeMs = 0;
+      try {
+        mtimeMs = fs.statSync(PORT_ALLOCATION_LOCK_DIR).mtimeMs;
+      } catch {
+        mtimeMs = 0;
+      }
+      const stale = !owner?.pid
+        || !isPidRunning(owner.pid)
+        || (mtimeMs > 0 && Date.now() - mtimeMs > staleMs);
+      if (stale) {
+        try {
+          fs.rmSync(PORT_ALLOCATION_LOCK_DIR, { recursive: true, force: true });
+        } catch {
+          // Try again on the next loop.
+        }
+        continue;
+      }
+      if (Date.now() - started > timeoutMs) {
+        throw new Error(`Timed out waiting for Amalgm runtime port allocation lock held by pid ${owner.pid}`);
+      }
+      await sleep(100);
+    }
+  }
+}
+
+async function withRuntimePortAllocationLock(fn) {
+  const release = await acquireRuntimePortAllocationLock();
+  try {
+    return await fn();
+  } finally {
+    release();
+  }
+}
+
+async function resolveRuntimePorts() {
+  const used = liveDeclaredRuntimePorts();
   const ports = {};
   for (const service of runtimeLaunchServices()) {
     ports[service.portKey] = await pickPort(service.name, service.envName, service.defaultPort, used);
@@ -401,6 +517,26 @@ function appendServiceState(name, update) {
   updateRuntimeState({ services: next });
 }
 
+function removePidFileForThisSupervisor() {
+  try {
+    const pidRecord = readJson(PID_FILE, null);
+    if (pidRecord?.pid === process.pid) fs.unlinkSync(PID_FILE);
+  } catch {
+    // noop
+  }
+}
+
+function removeRuntimeStateForThisSupervisor() {
+  try {
+    const stateRecord = readJson(RUNTIME_STATE_FILE, null);
+    if (stateRecord?.pid === process.pid || stateRecord?.supervisor_pid === process.pid) {
+      fs.unlinkSync(RUNTIME_STATE_FILE);
+    }
+  } catch {
+    // noop
+  }
+}
+
 function numberFromEnv(name, fallback, minimum = 0) {
   const value = Number(process.env[name]);
   if (!Number.isFinite(value) || value <= 0) return fallback;
@@ -780,10 +916,34 @@ function checkServiceHealth(spec, timeoutMs = CHILD_HEALTH_POLICY.timeoutMs) {
         path: spec.healthPath || '/healthz',
         method: 'GET',
         timeout: timeoutMs,
+        headers: spec.healthHeaders || {},
       },
       (res) => {
-        res.resume();
-        res.on('end', () => resolve(res.statusCode >= 200 && res.statusCode < 500));
+        const chunks = [];
+        res.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+        res.on('end', () => {
+          if (res.statusCode < 200 || res.statusCode >= 500) {
+            resolve(false);
+            return;
+          }
+          let body = {};
+          try {
+            body = JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}');
+          } catch {
+            resolve(false);
+            return;
+          }
+          const runtimeInstanceId = body.runtime_instance_id || body.runtimeInstanceId || '';
+          if (spec.expectedRuntimeInstanceId && runtimeInstanceId !== spec.expectedRuntimeInstanceId) {
+            resolve(false);
+            return;
+          }
+          if (spec.expectedService && body.service && body.service !== spec.expectedService) {
+            resolve(false);
+            return;
+          }
+          resolve(true);
+        });
       },
     );
     req.on('timeout', () => {
@@ -806,6 +966,23 @@ function createManagedProcess(spec, options) {
   let restartDelayMs = CHILD_RESTART_POLICY.initialDelayMs;
   let restartHistory = [];
   let state = 'starting';
+  let readySettled = false;
+  let readyTimer = null;
+  let resolveReady;
+  let rejectReady;
+  const ready = new Promise((resolve, reject) => {
+    resolveReady = resolve;
+    rejectReady = reject;
+  });
+
+  const settleReady = (error = null) => {
+    if (readySettled) return;
+    readySettled = true;
+    if (readyTimer) clearTimeout(readyTimer);
+    readyTimer = null;
+    if (error) rejectReady(error);
+    else resolveReady();
+  };
 
   const setState = (nextState, extra = {}) => {
     state = nextState;
@@ -823,20 +1000,24 @@ function createManagedProcess(spec, options) {
   };
 
   const scheduleHealthCheck = () => {
+    const delayMs = state === 'running' ? CHILD_HEALTH_POLICY.intervalMs : 500;
     clearHealthTimer();
     if (stopped) return;
     healthTimer = setTimeout(async () => {
       if (stopped || !child) return;
-      if (Date.now() - startedAt < CHILD_HEALTH_POLICY.graceMs) {
-        scheduleHealthCheck();
-        return;
-      }
       const ok = await checkServiceHealth(spec);
       if (stopped || !child) return;
       if (ok) {
         healthFailures = 0;
-        if (state !== 'running') setState('running');
+        if (state !== 'running') {
+          setState('running');
+          settleReady();
+        }
       } else {
+        if (Date.now() - startedAt < CHILD_HEALTH_POLICY.graceMs) {
+          scheduleHealthCheck();
+          return;
+        }
         healthFailures += 1;
         writePrefixed(
           stream,
@@ -865,7 +1046,7 @@ function createManagedProcess(spec, options) {
         }
       }
       scheduleHealthCheck();
-    }, CHILD_HEALTH_POLICY.intervalMs);
+    }, delayMs);
   };
 
   const canRestart = () => {
@@ -894,6 +1075,12 @@ function createManagedProcess(spec, options) {
     healthFailures = 0;
     startedAt = Date.now();
     setState('starting');
+    if (!readySettled) {
+      if (readyTimer) clearTimeout(readyTimer);
+      readyTimer = setTimeout(() => {
+        settleReady(new Error(`${spec.name} did not become healthy on port ${spec.port}`));
+      }, CHILD_HEALTH_POLICY.graceMs + (CHILD_HEALTH_POLICY.intervalMs * CHILD_HEALTH_POLICY.maxFailures));
+    }
     child = spawn(spec.command, spec.args, {
       cwd: RUNTIME_DIR,
       env: spec.env,
@@ -907,7 +1094,7 @@ function createManagedProcess(spec, options) {
       `started pid=${child.pid} command=${[spec.command, ...spec.args].join(' ')}\n`,
       options.foreground ? process.stdout : null,
     );
-    setState('running', { started_at: new Date(startedAt).toISOString() });
+    setState('starting', { started_at: new Date(startedAt).toISOString() });
     scheduleHealthCheck();
 
     child.stdout.on('data', (chunk) => {
@@ -926,6 +1113,9 @@ function createManagedProcess(spec, options) {
       );
       const runtimeMs = Date.now() - startedAt;
       child = null;
+      if (!readySettled) {
+        settleReady(new Error(`${spec.name} exited before becoming healthy`));
+      }
       if (!stopped) {
         if (runtimeMs >= CHILD_RESTART_POLICY.stableAfterMs) {
           restartDelayMs = CHILD_RESTART_POLICY.initialDelayMs;
@@ -955,6 +1145,7 @@ function createManagedProcess(spec, options) {
   return {
     stop() {
       stopped = true;
+      settleReady(new Error(`${spec.name} stopped before becoming healthy`));
       if (restartTimer) clearTimeout(restartTimer);
       clearHealthTimer();
       setState('stopping');
@@ -967,6 +1158,7 @@ function createManagedProcess(spec, options) {
       }
       stream.end();
     },
+    ready,
   };
 }
 
@@ -1022,6 +1214,7 @@ async function startSupervisor(options = {}) {
     supervisor_pid: process.pid,
     source: 'npm',
     runtime_label: AMALGM_RUNTIME_LABEL,
+    runtime_instance_id: AMALGM_RUNTIME_INSTANCE_ID,
     label: AMALGM_RUNTIME_LABEL,
     branch: AMALGM_BRANCH,
     user_scope: AMALGM_RUNTIME_USER_SCOPE,
@@ -1038,15 +1231,27 @@ async function startSupervisor(options = {}) {
     console.warn('No registered computer found. Run `amalgm login` to enable event/chat tunnels.');
   }
 
-  const ports = await resolveRuntimePorts();
-  Object.assign(process.env, {
-    AMALGM_GATEWAY_PORT: String(ports.gateway),
-    AMALGM_MCP_PORT: String(ports.amalgmMcp),
-    CHAT_SERVER_PORT: String(ports.chatServer),
-    PORT_MONITOR_PORT: String(ports.portMonitor),
+  let ports = null;
+  let managed = [];
+  await withRuntimePortAllocationLock(async () => {
+    ports = await resolveRuntimePorts();
+    Object.assign(process.env, {
+      AMALGM_GATEWAY_PORT: String(ports.gateway),
+      AMALGM_MCP_PORT: String(ports.amalgmMcp),
+      CHAT_SERVER_PORT: String(ports.chatServer),
+      PORT_MONITOR_PORT: String(ports.portMonitor),
+    });
+    updateRuntimeState(runtimePortsState(ports));
+    managed = serviceSpecs(record, ports, options).map((spec) => createManagedProcess(spec, options));
+    try {
+      await Promise.all(managed.map((proc) => proc.ready));
+    } catch (error) {
+      for (const proc of managed) proc.stop();
+      removePidFileForThisSupervisor();
+      removeRuntimeStateForThisSupervisor();
+      throw error;
+    }
   });
-  updateRuntimeState(runtimePortsState(ports));
-  const managed = serviceSpecs(record, ports, options).map((spec) => createManagedProcess(spec, options));
   const tunnels = [];
 
   if (!options.localOnly && record?.tunnel_url && record?.tunnel_token) {
@@ -1079,18 +1284,8 @@ async function startSupervisor(options = {}) {
       writeShutdownReason(signal);
       for (const tunnel of tunnels) tunnel.stop();
       for (const proc of managed) proc.stop();
-      try {
-        const pidRecord = readJson(PID_FILE, null);
-        if (pidRecord?.pid === process.pid) fs.unlinkSync(PID_FILE);
-      } catch {
-        // noop
-      }
-      try {
-        const stateRecord = readJson(RUNTIME_STATE_FILE, null);
-        if (stateRecord?.pid === process.pid) fs.unlinkSync(RUNTIME_STATE_FILE);
-      } catch {
-        // noop
-      }
+      removePidFileForThisSupervisor();
+      removeRuntimeStateForThisSupervisor();
       resolve();
     };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.123",
+  "version": "0.1.124",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,

package/runtime/scripts/amalgm-mcp/server/routes/health.js

@@ -12,6 +12,10 @@ async function handleHealthRoutes(ctx) {
   const automations = listAutomations();
   ctx.sendJson(200, {
     status: 'ok',
+    service: 'amalgm-mcp',
+    runtime_label: process.env.AMALGM_RUNTIME_LABEL || 'main',
+    runtime_instance_id: process.env.AMALGM_RUNTIME_INSTANCE_ID || '',
+    pid: process.pid,
     automations: automations.length,
     enabledAutomations: automations.filter((automation) => automation.enabled !== false).length,
     apps: loadApps().apps.length,

package/runtime/scripts/chat-core/server.js

@@ -72,7 +72,17 @@ function createServer(core = createCore()) {
     const route = parseRoute(req.url);
     if (!route) return sendJson(res, 404, { error: 'Not found' });
     try {
-      if (route.handler === 'healthz') return sendJson(res, 200, { status: 'ok', runtime: 'chat-core', uptime: process.uptime() });
+      if (route.handler === 'healthz') {
+        return sendJson(res, 200, {
+          status: 'ok',
+          service: 'chat-server',
+          runtime: 'chat-core',
+          runtime_label: process.env.AMALGM_RUNTIME_LABEL || 'main',
+          runtime_instance_id: process.env.AMALGM_RUNTIME_INSTANCE_ID || '',
+          pid: process.pid,
+          uptime: process.uptime(),
+        });
+      }
       if (route.handler === 'active') return sendJson(res, 200, core.active(route.id));
       if (route.handler === 'runtime-idle') return sendJson(res, 200, core.idleStatus());
       if (route.handler === 'stop') {

package/runtime/scripts/local-gateway.js

@@ -58,6 +58,7 @@ const LOG_DIR = runtimeLogDir();
 const BIND_HOST = process.env.AMALGM_BIND_HOST || '127.0.0.1';
 const OWNER = process.env.AMALGM_RUNTIME_SOURCE || 'local';
 const RUNTIME_LABEL = process.env.AMALGM_RUNTIME_LABEL || 'main';
+const RUNTIME_INSTANCE_ID = process.env.AMALGM_RUNTIME_INSTANCE_ID || '';
 const RUNTIME_BRANCH = process.env.AMALGM_BRANCH || (RUNTIME_LABEL === 'preview' ? 'preview' : 'main');
 const RUNTIME_USER_SCOPE = process.env.AMALGM_RUNTIME_USER_ID
   || process.env.AMALGM_USER_SCOPE
@@ -377,6 +378,7 @@ function writeRuntimeState(actualPort) {
     owner: OWNER,
     source: OWNER,
     runtime_label: RUNTIME_LABEL,
+    runtime_instance_id: RUNTIME_INSTANCE_ID,
     label: RUNTIME_LABEL,
     branch: RUNTIME_BRANCH,
     user_scope: RUNTIME_USER_SCOPE,
@@ -982,6 +984,7 @@ const server = http.createServer(async (req, res) => {
         service: 'local-gateway',
         owner: OWNER,
         runtime_label: RUNTIME_LABEL,
+        runtime_instance_id: RUNTIME_INSTANCE_ID,
         branch: RUNTIME_BRANCH,
         user_scope: RUNTIME_USER_SCOPE,
         pid: process.pid,

package/runtime/scripts/port-monitor.js

@@ -15,6 +15,8 @@ const { runtimePort } = require('../lib/runtime-manifest');
 
 const PORT = runtimePort('port-monitor');
 const BIND_HOST = process.env.AMALGM_BIND_HOST || '0.0.0.0';
+const RUNTIME_INSTANCE_ID = process.env.AMALGM_RUNTIME_INSTANCE_ID || '';
+const RUNTIME_LABEL = process.env.AMALGM_RUNTIME_LABEL || 'main';
 const AGENT_PORT = parseInt(process.env.PORT || '8080');
 const AMALGM_MCP_PORT = runtimePort('amalgm-mcp');
 const CHAT_SERVER_PORT = runtimePort('chat-server');
@@ -186,6 +188,10 @@ const server = http.createServer((req, res) => {
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify({
       status: 'ok',
+      service: 'port-monitor',
+      runtime_label: RUNTIME_LABEL,
+      runtime_instance_id: RUNTIME_INSTANCE_ID,
+      pid: process.pid,
       activePorts: [...knownPorts.entries()].map(([port, processInfo]) => ({ port, processName: publicProcessName(processInfo) })),
     }));
     return;