amalgm 0.0.0 → 0.0.32

package/lib/paths.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const os = require('os');
+const path = require('path');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const RUNTIME_DIR = path.join(PACKAGE_ROOT, 'runtime');
+const AMALGM_DIR = process.env.AMALGM_DIR || path.join(os.homedir(), '.amalgm');
+const DEVICE_FILE = path.join(AMALGM_DIR, 'device.json');
+const COMPUTER_FILE = path.join(AMALGM_DIR, 'computer.json');
+const AUTH_FILE = path.join(AMALGM_DIR, 'auth.json');
+const RUNTIME_TOKEN_FILE = path.join(AMALGM_DIR, 'runtime-token.json');
+const PID_FILE = path.join(AMALGM_DIR, 'amalgm.pid');
+const RUNTIME_STATE_FILE = path.join(AMALGM_DIR, 'runtime-state.json');
+const LOG_DIR = path.join(AMALGM_DIR, 'logs');
+const DEFAULT_APP_URL = process.env.AMALGM_APP_URL || 'https://amalgm.ai';
+
+module.exports = {
+  AMALGM_DIR,
+  AUTH_FILE,
+  COMPUTER_FILE,
+  DEFAULT_APP_URL,
+  DEVICE_FILE,
+  LOG_DIR,
+  PACKAGE_ROOT,
+  PID_FILE,
+  RUNTIME_DIR,
+  RUNTIME_STATE_FILE,
+  RUNTIME_TOKEN_FILE,
+};

package/lib/supervisor.js

@@ -0,0 +1,476 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn } = require('child_process');
+const net = require('net');
+
+const {
+  AMALGM_DIR,
+  LOG_DIR,
+  PID_FILE,
+  RUNTIME_DIR,
+  RUNTIME_STATE_FILE,
+  RUNTIME_TOKEN_FILE,
+} = require('./paths');
+const {
+  loadComputerRecord,
+  proxyTokenFromRecord,
+} = require('./auth-store');
+const { createChatTunnel } = require('./tunnel-chat');
+const { createEventTunnel } = require('./tunnel-events');
+const {
+  ensureAgentCommandShims,
+  ensureNativeBinaries,
+} = require('../runtime/scripts/chat-core/tooling/native-binaries');
+const PACKAGE_VERSION = require('../package.json').version;
+
+function ensureDir(dir, mode = 0o700) {
+  fs.mkdirSync(dir, { recursive: true, mode });
+  try {
+    fs.chmodSync(dir, mode);
+  } catch {
+    // Best effort.
+  }
+}
+
+function readJson(file, fallback = null) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJsonSecret(file, data) {
+  ensureDir(path.dirname(file));
+  const temp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(temp, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600 });
+  fs.renameSync(temp, file);
+  try {
+    fs.chmodSync(file, 0o600);
+  } catch {
+    // Best effort.
+  }
+}
+
+function runtimeEntry(relativePath) {
+  return path.join(RUNTIME_DIR, 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 missing = required.filter((file) => !fs.existsSync(file));
+  if (missing.length > 0) {
+    throw new Error(
+      [
+        'The Amalgm runtime has not been synced into this package.',
+        'Run `npm run npm:sync` from amalgm-engine, or reinstall the published package.',
+        `Missing: ${missing[0]}`,
+      ].join('\n'),
+    );
+  }
+}
+
+const SAFE_PROCESS_ENV_KEYS = [
+  'HOME',
+  'LANG',
+  'LC_ALL',
+  'LOGNAME',
+  'AMALGM_NATIVE_NODE_MODULES',
+  'AMALGM_SKIP_NATIVE_INSTALL',
+  'ELECTRON_RUN_AS_NODE',
+  'PATH',
+  'NODE_PATH',
+  'SHELL',
+  'SSH_AUTH_SOCK',
+  'TERM',
+  'TMP',
+  'TMPDIR',
+  'TEMP',
+  'USER',
+  'XDG_CACHE_HOME',
+  'XDG_CONFIG_HOME',
+  'XDG_DATA_HOME',
+];
+
+function safeBaseProcessEnv() {
+  const env = {};
+  for (const key of SAFE_PROCESS_ENV_KEYS) {
+    if (process.env[key]) env[key] = process.env[key];
+  }
+  return env;
+}
+
+function ensureRuntimeToken() {
+  const fromEnv = String(process.env.AMALGM_RUNTIME_TOKEN || '').trim();
+  if (fromEnv) {
+    writeJsonSecret(RUNTIME_TOKEN_FILE, {
+      token: fromEnv,
+      source: 'env',
+      updated_at: new Date().toISOString(),
+    });
+    return fromEnv;
+  }
+
+  const existing = readJson(RUNTIME_TOKEN_FILE, null);
+  if (typeof existing?.token === 'string' && existing.token.length >= 32) {
+    return existing.token;
+  }
+
+  const token = crypto.randomBytes(32).toString('base64url');
+  writeJsonSecret(RUNTIME_TOKEN_FILE, {
+    token,
+    source: 'generated',
+    created_at: new Date().toISOString(),
+  });
+  return token;
+}
+
+function baseRuntimeEnv(record, ports) {
+  const workspaceRoot =
+    process.env.AMALGM_WORKSPACES_DIR ||
+    process.env.AMALGM_PROJECTS_DIR ||
+    path.join(AMALGM_DIR, 'workspaces');
+  ensureDir(workspaceRoot);
+  const defaultCwd = process.env.AMALGM_DEFAULT_CWD || workspaceRoot;
+  const proxyToken = proxyTokenFromRecord(record);
+  const env = {
+    ...safeBaseProcessEnv(),
+    AMALGM_RUNTIME_SOURCE: 'npm',
+    AMALGM_RUNTIME_TOKEN: record?.runtime_token || process.env.AMALGM_RUNTIME_TOKEN || '',
+    AMALGM_LOCAL_MODE: 'true',
+    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',
+    AMALGM_DIR,
+    AMALGM_RUNTIME_DIR: RUNTIME_DIR,
+    AMALGM_WORKSPACES_DIR: workspaceRoot,
+    AMALGM_PROJECTS_DIR: workspaceRoot,
+    AMALGM_DEFAULT_CWD: defaultCwd,
+    AMALGM_COMPUTER_ID: record?.computer_id || process.env.AMALGM_COMPUTER_ID || '',
+    AMALGM_CONTAINER_ID: record?.computer_id || process.env.AMALGM_CONTAINER_ID || 'local-computer',
+    AMALGM_DEVICE_ID: record?.device_id || process.env.AMALGM_DEVICE_ID || '',
+    AMALGM_EVENTS_PUBLIC_URL: record?.webhook_url || process.env.AMALGM_EVENTS_PUBLIC_URL || '',
+    AMALGM_USER_ID: record?.user_id || process.env.AMALGM_USER_ID || '',
+    AMALGM_GATEWAY_PORT: String(ports.gateway),
+    CHAT_SERVER_PORT: String(ports.chatServer),
+    AMALGM_MCP_PORT: String(ports.amalgmMcp),
+    PORT_MONITOR_PORT: String(ports.portMonitor),
+    FS_WATCHER_PORT: String(ports.fsWatcher),
+    FS_WATCHER_ROOT: process.env.FS_WATCHER_ROOT || defaultCwd,
+    AMALGM_RUNTIME_VERSION: require('../package.json').version,
+  };
+
+  if (proxyToken) {
+    env.AMALGM_PROXY_TOKEN = proxyToken;
+  }
+  if (record?.app_url) {
+    env.AMALGM_APP_URL = record.app_url;
+  }
+  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 isPortFree(port, host = '127.0.0.1') {
+  return new Promise((resolve) => {
+    if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+      resolve(false);
+      return;
+    }
+
+    const server = net.createServer();
+    server.unref();
+    server.on('error', () => resolve(false));
+    server.listen({ host, port }, () => {
+      server.close(() => resolve(true));
+    });
+  });
+}
+
+function randomFreePort(host = '127.0.0.1') {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.unref();
+    server.on('error', reject);
+    server.listen({ host, port: 0 }, () => {
+      const address = server.address();
+      const port = typeof address === 'object' && address ? address.port : 0;
+      server.close(() => resolve(port));
+    });
+  });
+}
+
+async function pickPort(name, envName, preferred, used) {
+  const explicit = String(process.env[envName] || '').trim();
+  if (explicit) {
+    const port = Number(explicit);
+    if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+      throw new Error(`${envName} must be a valid TCP port`);
+    }
+    if (used.has(port)) throw new Error(`${envName} duplicates another Amalgm runtime port: ${port}`);
+    if (!(await isPortFree(port))) {
+      throw new Error(`${name} port ${port} is already in use`);
+    }
+    used.add(port);
+    return port;
+  }
+
+  if (!used.has(preferred) && (await isPortFree(preferred))) {
+    used.add(preferred);
+    return preferred;
+  }
+
+  for (let attempt = 0; attempt < 50; attempt += 1) {
+    const port = await randomFreePort();
+    if (!used.has(port)) {
+      used.add(port);
+      return port;
+    }
+  }
+
+  throw new Error(`Could not allocate a free port for ${name}`);
+}
+
+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),
+  };
+}
+
+function openServiceLog(name) {
+  ensureDir(LOG_DIR);
+  const logPath = path.join(LOG_DIR, `${name}.log`);
+  return {
+    logPath,
+    stream: fs.createWriteStream(logPath, { flags: 'a' }),
+  };
+}
+
+function writePrefixed(stream, name, chunk, consoleStream) {
+  const text = Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk);
+  const lines = text.split(/(?<=\n)/);
+  for (const line of lines) {
+    if (!line) continue;
+    const prefixed = `[${new Date().toISOString()}] [${name}] ${line}`;
+    stream.write(prefixed);
+    if (consoleStream) consoleStream.write(prefixed);
+  }
+}
+
+function createManagedProcess(spec, options) {
+  const { stream } = openServiceLog(spec.name);
+  let child = null;
+  let stopped = false;
+  let restartTimer = null;
+
+  const launch = () => {
+    if (stopped) return;
+    child = spawn(spec.command, spec.args, {
+      cwd: RUNTIME_DIR,
+      env: spec.env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true,
+    });
+
+    writePrefixed(
+      stream,
+      spec.name,
+      `started pid=${child.pid} command=${[spec.command, ...spec.args].join(' ')}\n`,
+      options.foreground ? process.stdout : null,
+    );
+
+    child.stdout.on('data', (chunk) => {
+      writePrefixed(stream, spec.name, chunk, options.foreground ? process.stdout : null);
+    });
+    child.stderr.on('data', (chunk) => {
+      writePrefixed(stream, spec.name, chunk, options.foreground ? process.stderr : null);
+    });
+    child.on('exit', (code, signal) => {
+      writePrefixed(
+        stream,
+        spec.name,
+        `exited code=${code ?? ''} signal=${signal ?? ''}\n`,
+        options.foreground ? process.stderr : null,
+      );
+      child = null;
+      if (!stopped) {
+        restartTimer = setTimeout(launch, 2000);
+      }
+    });
+  };
+
+  launch();
+
+  return {
+    stop() {
+      stopped = true;
+      if (restartTimer) clearTimeout(restartTimer);
+      if (child && !child.killed) {
+        try {
+          child.kill('SIGTERM');
+        } catch {
+          // noop
+        }
+      }
+      stream.end();
+    },
+  };
+}
+
+async function startSupervisor(options = {}) {
+  assertRuntimePresent();
+  ensureDir(AMALGM_DIR, 0o700);
+  ensureDir(LOG_DIR, 0o700);
+
+  const nativeResult = ensureNativeBinaries({
+    logger: console,
+    quiet: !options.foreground,
+  });
+  if (!nativeResult.ok) {
+    console.warn(`Could not install all agent binaries: ${nativeResult.error?.message || 'unknown error'}`);
+    const missing = nativeResult.after.filter((item) => !item.ok).map((item) => item.name);
+    if (missing.length > 0) console.warn(`Missing agents: ${missing.join(', ')}`);
+  } else if (nativeResult.installed && options.foreground) {
+    console.log('Agent binaries are ready.');
+  }
+  const shimResult = ensureAgentCommandShims({
+    logger: console,
+    quiet: !options.foreground,
+  });
+  if (!shimResult.ok) {
+    console.warn(`Could not expose all agent commands: ${shimResult.error?.message || 'unknown error'}`);
+  }
+
+  writeJsonSecret(PID_FILE, { pid: process.pid, started_at: new Date().toISOString() });
+
+  const runtimeToken = ensureRuntimeToken();
+  const storedRecord = loadComputerRecord({ migrate: true });
+  const record = {
+    ...(storedRecord || {}),
+    runtime_token: runtimeToken,
+  };
+  writeJsonSecret(RUNTIME_STATE_FILE, {
+    pid: process.pid,
+    supervisor_pid: process.pid,
+    source: 'npm',
+    package_version: PACKAGE_VERSION,
+    runtime_dir: RUNTIME_DIR,
+    computer_id: record?.computer_id || null,
+    device_id: record?.device_id || null,
+    event_ref: record?.event_ref || null,
+    local_only: !!options.localOnly,
+    started_at: new Date().toISOString(),
+  });
+  if (!storedRecord?.computer_id && options.foreground) {
+    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),
+    FS_WATCHER_PORT: String(ports.fsWatcher),
+    PORT_MONITOR_PORT: String(ports.portMonitor),
+  });
+  const managed = serviceSpecs(record, ports).map((spec) => createManagedProcess(spec, options));
+  const tunnels = [];
+
+  if (!options.localOnly && record?.tunnel_url && record?.tunnel_token) {
+    const eventTunnel = createEventTunnel({ record, foreground: options.foreground });
+    eventTunnel.start();
+    tunnels.push(eventTunnel);
+  }
+  if (!options.localOnly && record?.tunnel_token) {
+    const chatTunnel = createChatTunnel({ record, foreground: options.foreground });
+    chatTunnel.start();
+    tunnels.push(chatTunnel);
+  }
+
+  if (options.foreground) {
+    console.log('Amalgm local runtime is running.');
+    console.log(`Gateway: http://127.0.0.1:${ports.gateway}`);
+    if (record?.computer_id) {
+      console.log(`Computer: ${record.computer_id}`);
+      if (record.webhook_url) console.log(`Events: ${record.webhook_url}`);
+    }
+  }
+
+  await new Promise((resolve) => {
+    let cleaned = false;
+    const cleanup = () => {
+      if (cleaned) return;
+      cleaned = true;
+      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
+      }
+      resolve();
+    };
+
+    process.once('SIGINT', cleanup);
+    process.once('SIGTERM', cleanup);
+    process.once('SIGHUP', cleanup);
+  });
+}
+
+module.exports = { startSupervisor };