amalgm 0.1.41 → 0.1.44

package/lib/service.js

@@ -15,6 +15,9 @@ const {
   SERVICE_STATE_FILE,
   SERVICE_STOP_FILE,
 } = require('./paths');
+const {
+  cleanupStaleRuntimeProcesses,
+} = require('./process-cleanup');
 
 const PACKAGE_VERSION = require('../package.json').version;
 const SERVICE_LABEL = 'ai.amalgm.runtime';
@@ -250,6 +253,7 @@ function writePortableScript(localOnly) {
     `LOCK_DIR=${shellQuote(path.join(SERVICE_DIR, 'lock'))}`,
     `NODE_BIN=${shellQuote(process.execPath)}`,
     `AMALGM_BIN=${shellQuote(AMALGM_BIN)}`,
+    `NODE_WATCHDOG=${shellQuote(SERVICE_NODE_SCRIPT_FILE)}`,
     `DAEMON_LOG=${shellQuote(path.join(LOG_DIR, 'daemon.log'))}`,
     `SERVICE_LOG=${shellQuote(SERVICE_LOG_FILE)}`,
     `RESTART_DELAY=${shellQuote(String(process.env.AMALGM_SERVICE_RESTART_DELAY || '5'))}`,
@@ -261,42 +265,7 @@ function writePortableScript(localOnly) {
 
   lines.push(
     'mkdir -p "$AMALGM_DIR" "$LOG_DIR"',
-    'if ! mkdir "$LOCK_DIR" 2>/dev/null; then',
-    '  existing="$(cat "$PID_FILE" 2>/dev/null | sed -n \'s/.*"pid"[[:space:]]*:[[:space:]]*\\([0-9][0-9]*\\).*/\\1/p\')"',
-    '  [ -n "$existing" ] || existing="$(cat "$PID_FILE" 2>/dev/null || true)"',
-    '  if [ -n "$existing" ] && kill -0 "$existing" 2>/dev/null; then',
-    '    exit 0',
-    '  fi',
-    '  rm -rf "$LOCK_DIR"',
-    '  mkdir "$LOCK_DIR" || exit 1',
-    'fi',
-    'child_pid=""',
-    'cleanup() {',
-    '  touch "$STOP_FILE" 2>/dev/null || true',
-    '  if [ -n "$child_pid" ] && kill -0 "$child_pid" 2>/dev/null; then',
-    '    kill "$child_pid" 2>/dev/null || true',
-    '    wait "$child_pid" 2>/dev/null || true',
-    '  fi',
-    '  rm -f "$PID_FILE"',
-    '  rm -rf "$LOCK_DIR"',
-    '  exit 0',
-    '}',
-    'trap cleanup TERM INT HUP',
-    'printf \'{"pid":%s,"started_at":"%s","backend":"portable"}\\n\' "$$" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" > "$PID_FILE"',
-    'rm -f "$STOP_FILE"',
-    'while [ ! -f "$STOP_FILE" ]; do',
-    '  printf \'[%s] [service] starting amalgm run\\n\' "$(date -u +%Y-%m-%dT%H:%M:%SZ)" >> "$SERVICE_LOG"',
-    '  "$NODE_BIN" "$AMALGM_BIN" run >> "$DAEMON_LOG" 2>&1 &',
-    '  child_pid=$!',
-    '  wait "$child_pid"',
-    '  code=$?',
-    '  child_pid=""',
-    '  printf \'[%s] [service] amalgm run exited code=%s\\n\' "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$code" >> "$SERVICE_LOG"',
-    '  [ -f "$STOP_FILE" ] && break',
-    '  sleep "$RESTART_DELAY"',
-    'done',
-    'rm -f "$PID_FILE"',
-    'rm -rf "$LOCK_DIR"',
+    'exec "$NODE_BIN" "$NODE_WATCHDOG"',
   );
 
   fs.writeFileSync(SERVICE_SCRIPT_FILE, `${lines.join('\n')}\n`, { mode: 0o700 });
@@ -323,6 +292,8 @@ function writePortableNodeScript(localOnly) {
     daemonLog: path.join(LOG_DIR, 'daemon.log'),
     serviceLog: SERVICE_LOG_FILE,
     restartDelayMs: Math.max(1000, Number(process.env.AMALGM_SERVICE_RESTART_DELAY || 5) * 1000),
+    maxRestartDelayMs: Math.max(5000, Number(process.env.AMALGM_SERVICE_MAX_RESTART_DELAY || 60) * 1000),
+    stableAfterMs: Math.max(10000, Number(process.env.AMALGM_SERVICE_STABLE_AFTER || 60) * 1000),
     env: buildServiceEnv(localOnly),
   };
   const source = `'use strict';
@@ -330,11 +301,16 @@ function writePortableNodeScript(localOnly) {
 const fs = require('fs');
 const path = require('path');
 const { spawn } = require('child_process');
+const {
+  cleanupStaleRuntimeProcesses,
+} = require(path.join(path.dirname(${JSON.stringify(AMALGM_BIN)}), '..', 'lib', 'process-cleanup'));
 
 const config = ${JSON.stringify(config, null, 2)};
 let child = null;
 let stopping = false;
 let exiting = false;
+let restartDelayMs = config.restartDelayMs;
+let childStartedAt = 0;
 
 function ensureDir(dir) {
   fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
@@ -411,21 +387,42 @@ function cleanup(exitCode = 0) {
       if (child && !child.killed) {
         try { child.kill('SIGKILL'); } catch {}
       }
+      cleanupStaleRuntimeProcesses({
+        excludePids: [process.pid],
+        includeSupervisors: true,
+        logger: { log: (message) => append(config.serviceLog, message) },
+      });
       finish(exitCode);
     }, 5000);
     child.once('exit', () => {
       clearTimeout(timer);
+      cleanupStaleRuntimeProcesses({
+        excludePids: [process.pid],
+        includeSupervisors: true,
+        logger: { log: (message) => append(config.serviceLog, message) },
+      });
       finish(exitCode);
     });
     return;
   }
+  cleanupStaleRuntimeProcesses({
+    excludePids: [process.pid],
+    includeSupervisors: true,
+    logger: { log: (message) => append(config.serviceLog, message) },
+  });
   finish(exitCode);
 }
 
 function launch() {
   if (stopping || fs.existsSync(config.stopFile)) return cleanup(0);
+  cleanupStaleRuntimeProcesses({
+    excludePids: [process.pid],
+    includeSupervisors: true,
+    logger: { log: (message) => append(config.serviceLog, message) },
+  });
   append(config.serviceLog, 'starting amalgm run');
   const fd = fs.openSync(config.daemonLog, 'a');
+  childStartedAt = Date.now();
   child = spawn(config.nodeBin, [config.amalgmBin, 'run'], {
     cwd: process.env.HOME || process.cwd(),
     env: { ...process.env, ...config.env },
@@ -434,10 +431,15 @@ function launch() {
   });
   try { fs.closeSync(fd); } catch {}
   child.on('exit', (code, signal) => {
+    const runtimeMs = Date.now() - childStartedAt;
     append(config.serviceLog, \`amalgm run exited code=\${code ?? ''} signal=\${signal ?? ''}\`);
     child = null;
     if (stopping || fs.existsSync(config.stopFile)) return cleanup(0);
-    setTimeout(launch, config.restartDelayMs);
+    if (runtimeMs >= config.stableAfterMs) restartDelayMs = config.restartDelayMs;
+    const delay = restartDelayMs;
+    restartDelayMs = Math.min(restartDelayMs * 2, config.maxRestartDelayMs);
+    append(config.serviceLog, \`restarting amalgm run in \${delay}ms\`);
+    setTimeout(launch, delay);
   });
 }
 
@@ -655,10 +657,8 @@ function startPortable() {
   removeFile(SERVICE_STOP_FILE);
   ensureDir(LOG_DIR, 0o700);
   const logFd = fs.openSync(SERVICE_LOG_FILE, 'a');
-  const command = process.platform === 'win32' ? process.execPath : '/bin/sh';
-  const args = process.platform === 'win32'
-    ? [state?.files?.nodeScript || SERVICE_NODE_SCRIPT_FILE]
-    : [state?.files?.script || SERVICE_SCRIPT_FILE];
+  const command = process.execPath;
+  const args = [state?.files?.nodeScript || SERVICE_NODE_SCRIPT_FILE];
   const child = spawn(command, args, {
     detached: true,
     env: {
@@ -682,6 +682,7 @@ function stopDaemonProcess() {
   const pid = readPidFile(PID_FILE);
   if (!isPidRunning(pid)) {
     removeFile(PID_FILE);
+    cleanupStaleRuntimeProcesses({ includeSupervisors: true });
     return false;
   }
   try {
@@ -701,6 +702,7 @@ function stopDaemonProcess() {
     }
   }
   removeFile(PID_FILE);
+  cleanupStaleRuntimeProcesses({ includeSupervisors: true });
   return true;
 }
 
@@ -720,6 +722,7 @@ function stopPortable() {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
   }
   removeFile(SERVICE_PID_FILE);
+  cleanupStaleRuntimeProcesses({ includeSupervisors: true });
 }
 
 function startService(options = {}) {

package/lib/supervisor.js

@@ -2,6 +2,7 @@
 
 const crypto = require('crypto');
 const fs = require('fs');
+const http = require('http');
 const os = require('os');
 const path = require('path');
 const { spawn, spawnSync } = require('child_process');
@@ -26,8 +27,33 @@ const {
   ensureAgentCommandShims,
   ensureNativeBinaries,
 } = require('../runtime/scripts/chat-core/tooling/native-binaries');
+const {
+  cleanupStaleRuntimeProcesses,
+  isPidRunning,
+  supervisorProcesses,
+} = require('./process-cleanup');
+const {
+  runtimeLaunchServices,
+  runtimePortsState,
+  runtimeServiceScripts,
+} = require('./runtime-manifest');
 const PACKAGE_VERSION = require('../package.json').version;
 
+const CHILD_RESTART_POLICY = {
+  initialDelayMs: 1000,
+  maxDelayMs: 30000,
+  stableAfterMs: 30000,
+  maxRestarts: 8,
+  windowMs: 60000,
+};
+
+const CHILD_HEALTH_POLICY = {
+  graceMs: 8000,
+  intervalMs: 10000,
+  timeoutMs: 2500,
+  maxFailures: 3,
+};
+
 function ensureDir(dir, mode = 0o700) {
   fs.mkdirSync(dir, { recursive: true, mode });
   try {
@@ -98,13 +124,7 @@ function runtimeEntry(relativePath) {
 }
 
 function assertRuntimePresent() {
-  const required = [
-    runtimeEntry('scripts/amalgm-mcp/index.js'),
-    runtimeEntry('scripts/chat-server.js'),
-    runtimeEntry('scripts/fs-watcher.js'),
-    runtimeEntry('scripts/local-gateway.js'),
-    runtimeEntry('scripts/port-monitor.js'),
-  ];
+  const required = runtimeServiceScripts().map((script) => runtimeEntry(script));
   const missing = required.filter((file) => !fs.existsSync(file));
   if (missing.length > 0) {
     throw new Error(
@@ -172,7 +192,7 @@ function ensureRuntimeToken() {
   return token;
 }
 
-function baseRuntimeEnv(record, ports) {
+function baseRuntimeEnv(record, ports, options = {}) {
   const workspaceRoot =
     process.env.AMALGM_WORKSPACES_DIR ||
     process.env.AMALGM_PROJECTS_DIR ||
@@ -180,11 +200,13 @@ function baseRuntimeEnv(record, ports) {
   ensureDir(workspaceRoot);
   const defaultCwd = process.env.AMALGM_DEFAULT_CWD || workspaceRoot;
   const proxyToken = proxyTokenFromRecord(record);
+  const localOnly = !!options.localOnly || process.env.AMALGM_LOCAL_ONLY === 'true';
   const env = {
     ...safeBaseProcessEnv(),
     AMALGM_RUNTIME_SOURCE: 'npm',
     AMALGM_RUNTIME_TOKEN: record?.runtime_token || process.env.AMALGM_RUNTIME_TOKEN || '',
     AMALGM_LOCAL_MODE: 'true',
+    AMALGM_LOCAL_ONLY: localOnly ? 'true' : 'false',
     AMALGM_BIND_HOST: process.env.AMALGM_BIND_HOST || '127.0.0.1',
     AMALGM_AUTH_BACKUP_ENABLED: process.env.AMALGM_AUTH_BACKUP_ENABLED || 'false',
     AMALGM_CREATE_AUTH_WATCH_DIRS: process.env.AMALGM_CREATE_AUTH_WATCH_DIRS || 'false',
@@ -216,40 +238,16 @@ function baseRuntimeEnv(record, ports) {
   return env;
 }
 
-function serviceSpecs(record, ports) {
-  const env = baseRuntimeEnv(record, ports);
-  return [
-    {
-      name: 'port-monitor',
-      command: process.execPath,
-      args: [runtimeEntry('scripts/port-monitor.js')],
-      env: { ...env, PORT: process.env.PORT || '0' },
-    },
-    {
-      name: 'fs-watcher',
-      command: process.execPath,
-      args: [runtimeEntry('scripts/fs-watcher.js')],
-      env,
-    },
-    {
-      name: 'chat-server',
-      command: process.execPath,
-      args: [runtimeEntry('scripts/chat-server.js')],
-      env,
-    },
-    {
-      name: 'amalgm-mcp',
-      command: process.execPath,
-      args: [runtimeEntry('scripts/amalgm-mcp/index.js')],
-      env,
-    },
-    {
-      name: 'local-gateway',
-      command: process.execPath,
-      args: [runtimeEntry('scripts/local-gateway.js')],
-      env,
-    },
-  ];
+function serviceSpecs(record, ports, options = {}) {
+  const env = baseRuntimeEnv(record, ports, options);
+  return runtimeLaunchServices().map((service) => ({
+    name: service.name,
+    command: process.execPath,
+    args: [runtimeEntry(service.script)],
+    env: service.name === 'port-monitor' ? { ...env, PORT: process.env.PORT || '0' } : env,
+    port: ports[service.portKey],
+    healthPath: '/healthz',
+  }));
 }
 
 function isPortFree(port, host = '127.0.0.1') {
@@ -314,13 +312,11 @@ async function pickPort(name, envName, preferred, used) {
 
 async function resolveRuntimePorts() {
   const used = new Set();
-  return {
-    gateway: await pickPort('local-gateway', 'AMALGM_GATEWAY_PORT', 28781, used),
-    portMonitor: await pickPort('port-monitor', 'PORT_MONITOR_PORT', 8081, used),
-    fsWatcher: await pickPort('fs-watcher', 'FS_WATCHER_PORT', 8082, used),
-    amalgmMcp: await pickPort('amalgm-mcp', 'AMALGM_MCP_PORT', 8083, used),
-    chatServer: await pickPort('chat-server', 'CHAT_SERVER_PORT', 8084, used),
-  };
+  const ports = {};
+  for (const service of runtimeLaunchServices()) {
+    ports[service.portKey] = await pickPort(service.name, service.envName, service.defaultPort, used);
+  }
+  return ports;
 }
 
 function openServiceLog(name) {
@@ -343,14 +339,150 @@ function writePrefixed(stream, name, chunk, consoleStream) {
   }
 }
 
+function updateRuntimeState(update) {
+  const current = readJson(RUNTIME_STATE_FILE, {});
+  if (!current || (current.pid !== process.pid && current.supervisor_pid !== process.pid)) return;
+  writeJsonSecret(RUNTIME_STATE_FILE, {
+    ...current,
+    ...update,
+    updated_at: new Date().toISOString(),
+  });
+}
+
+function appendServiceState(name, update) {
+  const current = readJson(RUNTIME_STATE_FILE, {});
+  if (!current || (current.pid !== process.pid && current.supervisor_pid !== process.pid)) return;
+  const services = Array.isArray(current.services) ? current.services : [];
+  const next = services.map((service) => (
+    service.name === name ? { ...service, ...update } : service
+  ));
+  updateRuntimeState({ services: next });
+}
+
+function checkServiceHealth(spec, timeoutMs = CHILD_HEALTH_POLICY.timeoutMs) {
+  if (!spec.port) return Promise.resolve(true);
+  return new Promise((resolve) => {
+    const req = http.request(
+      {
+        host: '127.0.0.1',
+        port: spec.port,
+        path: spec.healthPath || '/healthz',
+        method: 'GET',
+        timeout: timeoutMs,
+      },
+      (res) => {
+        res.resume();
+        res.on('end', () => resolve(res.statusCode >= 200 && res.statusCode < 500));
+      },
+    );
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(false);
+    });
+    req.on('error', () => resolve(false));
+    req.end();
+  });
+}
+
 function createManagedProcess(spec, options) {
   const { stream } = openServiceLog(spec.name);
   let child = null;
   let stopped = false;
   let restartTimer = null;
+  let healthTimer = null;
+  let healthFailures = 0;
+  let startedAt = 0;
+  let restartDelayMs = CHILD_RESTART_POLICY.initialDelayMs;
+  let restartHistory = [];
+  let state = 'starting';
+
+  const setState = (nextState, extra = {}) => {
+    state = nextState;
+    appendServiceState(spec.name, {
+      status: state,
+      pid: child?.pid || null,
+      restart_count_window: restartHistory.length,
+      ...extra,
+    });
+  };
+
+  const clearHealthTimer = () => {
+    if (healthTimer) clearTimeout(healthTimer);
+    healthTimer = null;
+  };
+
+  const scheduleHealthCheck = () => {
+    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');
+      } else {
+        healthFailures += 1;
+        writePrefixed(
+          stream,
+          spec.name,
+          `health check failed (${healthFailures}/${CHILD_HEALTH_POLICY.maxFailures})\n`,
+          options.foreground ? process.stderr : null,
+        );
+        if (healthFailures >= CHILD_HEALTH_POLICY.maxFailures) {
+          setState('restarting', { reason: 'health_check_failed' });
+          try {
+            child.kill('SIGTERM');
+          } catch {
+            // noop
+          }
+          const pid = child.pid;
+          setTimeout(() => {
+            if (child && child.pid === pid) {
+              try {
+                child.kill('SIGKILL');
+              } catch {
+                // noop
+              }
+            }
+          }, 5000);
+          return;
+        }
+      }
+      scheduleHealthCheck();
+    }, CHILD_HEALTH_POLICY.intervalMs);
+  };
+
+  const canRestart = () => {
+    const now = Date.now();
+    restartHistory = restartHistory.filter((time) => now - time <= CHILD_RESTART_POLICY.windowMs);
+    if (restartHistory.length >= CHILD_RESTART_POLICY.maxRestarts) {
+      setState('degraded', {
+        reason: 'restart_limit_exceeded',
+        next_retry_at: null,
+      });
+      writePrefixed(
+        stream,
+        spec.name,
+        `entered degraded state after ${restartHistory.length} restarts in ${CHILD_RESTART_POLICY.windowMs}ms\n`,
+        options.foreground ? process.stderr : null,
+      );
+      return false;
+    }
+    restartHistory.push(now);
+    return true;
+  };
 
   const launch = () => {
     if (stopped) return;
+    clearHealthTimer();
+    healthFailures = 0;
+    startedAt = Date.now();
+    setState('starting');
     child = spawn(spec.command, spec.args, {
       cwd: RUNTIME_DIR,
       env: spec.env,
@@ -364,6 +496,8 @@ 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() });
+    scheduleHealthCheck();
 
     child.stdout.on('data', (chunk) => {
       writePrefixed(stream, spec.name, chunk, options.foreground ? process.stdout : null);
@@ -372,15 +506,35 @@ function createManagedProcess(spec, options) {
       writePrefixed(stream, spec.name, chunk, options.foreground ? process.stderr : null);
     });
     child.on('exit', (code, signal) => {
+      clearHealthTimer();
       writePrefixed(
         stream,
         spec.name,
         `exited code=${code ?? ''} signal=${signal ?? ''}\n`,
         options.foreground ? process.stderr : null,
       );
+      const runtimeMs = Date.now() - startedAt;
       child = null;
       if (!stopped) {
-        restartTimer = setTimeout(launch, 2000);
+        if (runtimeMs >= CHILD_RESTART_POLICY.stableAfterMs) {
+          restartDelayMs = CHILD_RESTART_POLICY.initialDelayMs;
+          restartHistory = [];
+        }
+        if (!canRestart()) return;
+        const delay = restartDelayMs;
+        restartDelayMs = Math.min(restartDelayMs * 2, CHILD_RESTART_POLICY.maxDelayMs);
+        setState('restarting', {
+          exit_code: code ?? null,
+          exit_signal: signal || null,
+          next_retry_at: new Date(Date.now() + delay).toISOString(),
+        });
+        writePrefixed(
+          stream,
+          spec.name,
+          `restart scheduled in ${delay}ms\n`,
+          options.foreground ? process.stderr : null,
+        );
+        restartTimer = setTimeout(launch, delay);
       }
     });
   };
@@ -391,6 +545,8 @@ function createManagedProcess(spec, options) {
     stop() {
       stopped = true;
       if (restartTimer) clearTimeout(restartTimer);
+      clearHealthTimer();
+      setState('stopping');
       if (child && !child.killed) {
         try {
           child.kill('SIGTERM');
@@ -408,6 +564,21 @@ async function startSupervisor(options = {}) {
   ensureDir(AMALGM_DIR, 0o700);
   ensureDir(LOG_DIR, 0o700);
 
+  const activeSupervisors = supervisorProcesses({ excludePids: [process.pid] });
+  if (activeSupervisors.length > 0) {
+    const pids = activeSupervisors
+      .filter((item) => isPidRunning(item.pid))
+      .map((item) => item.pid);
+    if (pids.length > 0) {
+      throw new Error(`Amalgm runtime is already running (pid ${pids.join(', ')}). Run \`amalgm stop\` first.`);
+    }
+  }
+
+  cleanupStaleRuntimeProcesses({
+    excludePids: [process.pid],
+    logger: options.foreground ? console : null,
+  });
+
   const nativeResult = ensureNativeBinaries({
     logger: console,
     quiet: !options.foreground,
@@ -445,6 +616,7 @@ async function startSupervisor(options = {}) {
     device_id: record?.device_id || null,
     event_ref: record?.event_ref || null,
     local_only: !!options.localOnly,
+    services: [],
     started_at: new Date().toISOString(),
   });
   if (!storedRecord?.computer_id && options.foreground) {
@@ -459,7 +631,8 @@ async function startSupervisor(options = {}) {
     FS_WATCHER_PORT: String(ports.fsWatcher),
     PORT_MONITOR_PORT: String(ports.portMonitor),
   });
-  const managed = serviceSpecs(record, ports).map((spec) => createManagedProcess(spec, options));
+  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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.41",
+  "version": "0.1.44",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,
@@ -17,7 +17,7 @@
     "sync-runtime": "node ../../scripts/sync-npm-package-runtime.mjs",
     "prepack": "node ../../scripts/sync-npm-package-runtime.mjs",
     "pack:dry": "npm pack --dry-run",
-    "check": "node --check bin/amalgm.js && node --check lib/auth-store.js && node --check lib/cli.js && node --check lib/paths.js && node --check lib/service.js && node --check lib/supervisor.js && node --check lib/tunnel-chat.js && node --check lib/tunnel-events.js && node --check runtime/scripts/runtime-auth.js && node --check runtime/scripts/proxy-token-store.js && node --check runtime/scripts/local-gateway.js && node --check runtime/scripts/port-monitor.js && node --check runtime/scripts/fs-watcher.js && node --check runtime/scripts/chat-server.js && node --check runtime/scripts/chat-server/index.js && node --check runtime/scripts/chat-server/config.js && node --check runtime/scripts/chat-core/tooling/native-binaries.js && node --check runtime/scripts/chat-core/tooling/package-import.js && node --check runtime/scripts/amalgm-mcp/index.js && node --check runtime/scripts/amalgm-mcp/config.js"
+    "check": "node --check bin/amalgm.js && node --check lib/auth-store.js && node --check lib/cli.js && node --check lib/paths.js && node --check lib/process-cleanup.js && node --check lib/runtime-manifest.js && node --check lib/service.js && node --check lib/supervisor.js && node --check lib/tunnel-chat.js && node --check lib/tunnel-events.js && node --check runtime/scripts/runtime-auth.js && node --check runtime/scripts/proxy-token-store.js && node --check runtime/scripts/local-gateway.js && node --check runtime/scripts/port-monitor.js && node --check runtime/scripts/fs-watcher.js && node --check runtime/scripts/chat-server.js && node --check runtime/scripts/chat-server/index.js && node --check runtime/scripts/chat-server/config.js && node --check runtime/scripts/chat-core/tooling/native-binaries.js && node --check runtime/scripts/chat-core/tooling/package-import.js && node --check runtime/scripts/amalgm-mcp/index.js && node --check runtime/scripts/amalgm-mcp/config.js"
   },
   "engines": {
     "node": ">=20"

package/runtime/scripts/amalgm-mcp/artifacts/supervisor.js

@@ -26,6 +26,13 @@ const stopping = new Set();
 const restartTimers = new Map();
 
 const ARTIFACT_ENV_ALLOWLIST = [
+  'AMALGM_BIND_HOST',
+  'AMALGM_DIR',
+  'AMALGM_GATEWAY_PORT',
+  'AMALGM_MCP_PORT',
+  'AMALGM_RUNTIME_TOKEN',
+  'AMALGM_WORKSPACES_DIR',
+  'CHAT_SERVER_PORT',
   'PATH',
   'HOME',
   'USER',
@@ -81,6 +88,8 @@ function buildEnv(artifact) {
     AMALGM_ARTIFACT_ID: artifact.id,
     AMALGM_ARTIFACT_REF: artifact.artifactRef,
     AMALGM_ARTIFACT_URL: artifact.publicUrl,
+    AMALGM_CHAT_SERVER_URL: `http://127.0.0.1:${process.env.CHAT_SERVER_PORT || 8084}`,
+    AMALGM_MCP_URL: `http://127.0.0.1:${process.env.AMALGM_MCP_PORT || 8083}`,
   };
 }
 

package/runtime/scripts/amalgm-mcp/events/executor.js

@@ -198,7 +198,7 @@ async function executeArtifactEvent(artifactOrTrigger, eventDef, payload, opts =
     if (hasSupabase()) {
       supabasePatch('sessions', 'id', codeSessionId, {
         last_message_at: new Date().toISOString(),
-        status: 'completed',
+        status: 'complete',
         new_messages: true,
       }).catch(() => {});
     }

package/runtime/scripts/amalgm-mcp/tasks/executor.js

@@ -233,6 +233,14 @@ async function executeTask(task) {
     console.log(
       `[AmalgmMCP:Exec] Task ${task.id} ${status} in ${durationMs}ms (session: ${codeSessionId})`,
     );
+
+    if (hasSupabase()) {
+      supabasePatch('sessions', 'id', codeSessionId, {
+        last_message_at: new Date().toISOString(),
+        status: 'complete',
+        new_messages: true,
+      }).catch(() => {});
+    }
   } catch (err) {
     if (err.name === 'AbortError') {
       appendRunLog(task.id, {