amalgm 0.1.54 → 0.1.56

package/bin/amalgm.js

@@ -1,6 +1,27 @@
 #!/usr/bin/env node
 'use strict';
 
+function takeFlag(argv, names) {
+  for (let i = 2; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (!arg || !arg.startsWith('--')) continue;
+    const eq = arg.indexOf('=');
+    const key = eq === -1 ? arg : arg.slice(0, eq);
+    if (!names.includes(key)) continue;
+    if (eq !== -1) return arg.slice(eq + 1);
+    const next = argv[i + 1];
+    if (next && !next.startsWith('--')) return next;
+    return '';
+  }
+  return '';
+}
+
+const label = takeFlag(process.argv, ['--label', '--runtime-label', '--branch']);
+if (label && !process.env.AMALGM_RUNTIME_LABEL) process.env.AMALGM_RUNTIME_LABEL = label;
+
+const userScope = takeFlag(process.argv, ['--user', '--user-id', '--runtime-user']);
+if (userScope && !process.env.AMALGM_RUNTIME_USER_ID) process.env.AMALGM_RUNTIME_USER_ID = userScope;
+
 require('../lib/cli').main(process.argv).catch((error) => {
   const message = error && error.message ? error.message : String(error);
   console.error(`Error: ${message}`);

package/lib/auth-store.js

@@ -4,9 +4,17 @@ const fs = require('fs');
 const path = require('path');
 
 const {
+  AMALGM_DIR,
+  AMALGM_HOME,
+  AMALGM_RUNTIME_LABEL,
+  AMALGM_RUNTIME_USER_SCOPE,
   AUTH_FILE,
   COMPUTER_FILE,
 } = require('./paths');
+const {
+  sanitizeScopeSegment,
+  scopedAmalgmDir,
+} = require('./runtime-identity');
 
 const PROXY_REFRESH_BUFFER_MS = 10 * 60 * 1000;
 
@@ -166,24 +174,50 @@ function mergeRecordAuth(record, auth) {
 
 function loadComputerRecord(options = {}) {
   const record = readJson(COMPUTER_FILE, null);
-  if (!record || typeof record !== 'object') return null;
-  const auth = readJson(AUTH_FILE, null);
-  const merged = mergeRecordAuth(record, auth);
-  if (options.migrate && hasComputerSecrets(record)) {
+  const scopedRecord = record && typeof record === 'object' ? record : null;
+  const legacyRecord = !scopedRecord ? loadLegacyComputerRecord() : null;
+  const activeRecord = scopedRecord || legacyRecord;
+  if (!activeRecord || typeof activeRecord !== 'object') return null;
+  const auth = scopedRecord ? readJson(AUTH_FILE, null) : readLegacyAuth();
+  const merged = mergeRecordAuth(activeRecord, auth);
+  if (options.migrate && (hasComputerSecrets(activeRecord) || legacyRecord)) {
     saveComputerRecord(merged);
   }
   return merged;
 }
 
+function loadLegacyComputerRecord() {
+  if (AMALGM_RUNTIME_LABEL !== 'main') return null;
+  if (path.resolve(AMALGM_DIR) === path.resolve(AMALGM_HOME)) return null;
+  const legacy = readJson(path.join(AMALGM_HOME, 'computer.json'), null);
+  return legacy && typeof legacy === 'object' ? legacy : null;
+}
+
+function readLegacyAuth() {
+  if (AMALGM_RUNTIME_LABEL !== 'main') return null;
+  if (path.resolve(AMALGM_DIR) === path.resolve(AMALGM_HOME)) return null;
+  return readJson(path.join(AMALGM_HOME, 'auth.json'), null);
+}
+
 function saveComputerRecord(record) {
   const existingAuth = readJson(AUTH_FILE, null);
   const nextAuth = authFromRecord(record, existingAuth);
   const nextRecord = publicComputerRecord(record);
   writeJsonSecret(COMPUTER_FILE, nextRecord);
   writeJsonSecret(AUTH_FILE, nextAuth);
+  mirrorLocalRecordToUserScope(nextRecord, nextAuth);
   return mergeRecordAuth(nextRecord, nextAuth);
 }
 
+function mirrorLocalRecordToUserScope(record, auth) {
+  const userId = cleanString(record?.user_id) || cleanString(auth?.user_id);
+  if (!userId || AMALGM_RUNTIME_USER_SCOPE !== 'local') return;
+  const targetDir = scopedAmalgmDir(AMALGM_HOME, sanitizeScopeSegment(userId), AMALGM_RUNTIME_LABEL);
+  if (path.resolve(targetDir) === path.resolve(AMALGM_DIR)) return;
+  writeJsonSecret(path.join(targetDir, 'computer.json'), record);
+  writeJsonSecret(path.join(targetDir, 'auth.json'), auth);
+}
+
 function deleteComputerAuth() {
   for (const file of [COMPUTER_FILE, AUTH_FILE]) {
     try {

package/lib/cli.js

@@ -11,15 +11,24 @@ const { spawn, spawnSync } = require('child_process');
 
 const {
   AMALGM_DIR,
+  AMALGM_BRANCH,
   DEFAULT_APP_URL,
   DEVICE_FILE,
   LOG_DIR,
   PID_FILE,
   RUNTIME_DIR,
+  AMALGM_RUNTIME_INSTANCE_ID,
+  AMALGM_RUNTIME_LABEL,
+  AMALGM_RUNTIME_USER_SCOPE,
   RUNTIME_STATE_FILE,
   RUNTIME_TOKEN_FILE,
   SHUTDOWN_REASON_FILE,
 } = require('./paths');
+const {
+  normalizeRuntimeLabel,
+  npmTagForRuntimeLabel,
+  sanitizeScopeSegment,
+} = require('./runtime-identity');
 const { startSupervisor } = require('./supervisor');
 const {
   getServiceStatus,
@@ -30,6 +39,7 @@ const {
 } = require('./service');
 const {
   cleanupStaleRuntimeProcesses,
+  RUNTIME_INSTANCE_ARG,
   runtimeServiceProcesses,
   supervisorProcesses,
 } = require('./process-cleanup');
@@ -94,7 +104,7 @@ function usage() {
     '',
     'Usage:',
     '  amalgm login [--app-url https://amalgm.ai] [--name "My Mac"] [--setup-code ABCD-EFGH-JKLM-NPQR] [--no-open] [--no-poll]',
-    '  amalgm start [--foreground] [--local-only]',
+    '  amalgm start [--foreground] [--local-only] [--branch main|preview] [--user <user-id>]',
     '  amalgm run [--local-only]',
     '  amalgm stop',
     '  amalgm status',
@@ -107,7 +117,10 @@ function usage() {
     'Environment:',
     '  AMALGM_APP_URL        Web app base URL for login/register',
     '  AMALGM_AUTO_UPDATE    Set to 1 to update to the latest stable release before start',
-    '  AMALGM_DIR            Runtime state dir (default ~/.amalgm)',
+    '  AMALGM_DIR            Explicit runtime state dir override',
+    '  AMALGM_HOME           Runtime state root (default ~/.amalgm)',
+    '  AMALGM_RUNTIME_LABEL  Runtime label: main, preview, or local',
+    '  AMALGM_RUNTIME_USER_ID Runtime user scope',
     '  AMALGM_PROXY_TOKEN    Optional short-lived proxy token override',
   ].join('\n');
 }
@@ -155,8 +168,17 @@ function runtimeMissingFiles() {
   return required.filter((file) => !fs.existsSync(file));
 }
 
+function runtimeStateMatchesCurrentScope(state) {
+  if (!state || typeof state !== 'object') return false;
+  const label = normalizeRuntimeLabel(state.runtime_label || state.label || state.branch);
+  if (label !== AMALGM_RUNTIME_LABEL) return false;
+  const userScope = sanitizeScopeSegment(state.user_scope || state.user_id || '');
+  return userScope === AMALGM_RUNTIME_USER_SCOPE;
+}
+
 function servicePorts() {
   const state = readJson(RUNTIME_STATE_FILE, null);
+  if (!runtimeStateMatchesCurrentScope(state)) return [];
   return runtimePortsForStatus(state, process.env);
 }
 
@@ -172,10 +194,15 @@ function hasRequiredComputerFields(record) {
 
 const SAFE_DAEMON_ENV_KEYS = [
   'AMALGM_BIND_HOST',
+  'AMALGM_BRANCH',
   'AMALGM_DEFAULT_CWD',
   'AMALGM_GATEWAY_PORT',
+  'AMALGM_HOME',
   'AMALGM_MCP_PORT',
   'AMALGM_NATIVE_NODE_MODULES',
+  'AMALGM_RUNTIME_INSTANCE_ID',
+  'AMALGM_RUNTIME_LABEL',
+  'AMALGM_RUNTIME_USER_ID',
   'AMALGM_SKIP_NATIVE_INSTALL',
   'CHAT_SERVER_PORT',
   'ELECTRON_RUN_AS_NODE',
@@ -204,6 +231,11 @@ function daemonEnv(localOnly) {
     if (process.env[key]) env[key] = process.env[key];
   }
   env.AMALGM_DIR = AMALGM_DIR;
+  env.AMALGM_RUNTIME_INSTANCE_ID = AMALGM_RUNTIME_INSTANCE_ID;
+  env.AMALGM_RUNTIME_LABEL = AMALGM_RUNTIME_LABEL;
+  env.AMALGM_BRANCH = AMALGM_BRANCH;
+  env.AMALGM_RUNTIME_USER_ID = AMALGM_RUNTIME_USER_SCOPE;
+  env.AMALGM_USER_SCOPE = AMALGM_RUNTIME_USER_SCOPE;
   if (localOnly) env.AMALGM_LOCAL_ONLY = 'true';
   return env;
 }
@@ -339,11 +371,11 @@ function isPortFree(port, host = '127.0.0.1') {
 
 async function unavailableServicePorts() {
   const results = [];
-  const explicitEnvByService = new Map(runtimeServices().map((service) => [service.name, service.envName]));
-  for (const [name, port] of servicePorts()) {
-    const envName = explicitEnvByService.get(name);
-    if (!envName || !process.env[envName]) continue;
-    if (!(await isPortFree(port))) results.push([name, port]);
+  for (const service of runtimeServices()) {
+    if (!process.env[service.envName]) continue;
+    const port = Number(process.env[service.envName]);
+    if (!Number.isInteger(port) || port <= 0 || port > 65535) continue;
+    if (!(await isPortFree(port))) results.push([service.name, port]);
   }
   return results;
 }
@@ -409,7 +441,7 @@ function npmCommand() {
 function npmInstallTag(options = {}) {
   const explicit = options.tag || options.channel;
   if (explicit && explicit !== true) return String(explicit).replace(/^@/, '');
-  return 'latest';
+  return npmTagForRuntimeLabel(AMALGM_RUNTIME_LABEL);
 }
 
 function npmPackageVersionForTag(tag) {
@@ -864,7 +896,7 @@ async function start(options) {
   ensureDir(LOG_DIR);
   const logPath = path.join(LOG_DIR, 'daemon.log');
   const logFd = fs.openSync(logPath, 'a');
-  const child = spawn(process.execPath, [path.join(__dirname, '..', 'bin', 'amalgm.js'), 'run'], {
+  const child = spawn(process.execPath, [path.join(__dirname, '..', 'bin', 'amalgm.js'), 'run', RUNTIME_INSTANCE_ARG], {
     detached: true,
     env: daemonEnv(localOnly),
     stdio: ['ignore', logFd, logFd],
@@ -978,7 +1010,13 @@ async function waitForServices(timeoutMs) {
   let latest = [];
   while (Date.now() < deadline) {
     latest = [];
-    for (const [name, port] of servicePorts()) {
+    const ports = servicePorts();
+    if (ports.length === 0) {
+      latest = [['runtime-state', false]];
+      await sleep(300);
+      continue;
+    }
+    for (const [name, port] of ports) {
       latest.push([name, await checkHttp(port)]);
     }
     if (latest.every(([, ok]) => ok)) return latest;
@@ -1002,6 +1040,8 @@ async function status() {
         : 'not installed'
     }`,
   );
+  console.log(`Label: ${AMALGM_RUNTIME_LABEL} (${AMALGM_BRANCH})`);
+  console.log(`User scope: ${AMALGM_RUNTIME_USER_SCOPE}`);
   console.log(`State: ${AMALGM_DIR}`);
   if (runtimeState?.gateway_url) console.log(`Gateway: ${runtimeState.gateway_url}`);
   if (lastShutdown?.signal || lastShutdown?.reason) {
@@ -1162,6 +1202,8 @@ async function doctor() {
   }
 
   console.log('Amalgm doctor');
+  console.log(`Label: ${AMALGM_RUNTIME_LABEL} (${AMALGM_BRANCH})`);
+  console.log(`User scope: ${AMALGM_RUNTIME_USER_SCOPE}`);
   console.log(`State: ${AMALGM_DIR}`);
   for (const check of checks) {
     console.log(`${check.level.padEnd(4)} ${check.name.padEnd(18)} ${check.detail}`);

package/lib/paths.js

@@ -1,11 +1,33 @@
 'use strict';
 
-const os = require('os');
 const path = require('path');
 
+const {
+  defaultAmalgmHome,
+  discoverLegacyUserScope,
+  resolveRuntimeLabel,
+  resolveRuntimeUserScope,
+  runtimeBranchForLabel,
+  runtimeInstanceIdForDir,
+  scopedAmalgmDir,
+} = require('./runtime-identity');
+
+const PACKAGE_VERSION = require('../package.json').version;
+
 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 AMALGM_HOME = defaultAmalgmHome(process.env);
+const AMALGM_RUNTIME_LABEL = resolveRuntimeLabel(process.env, { packageVersion: PACKAGE_VERSION });
+const AMALGM_BRANCH = runtimeBranchForLabel(AMALGM_RUNTIME_LABEL, process.env);
+const AMALGM_RUNTIME_USER_SCOPE = resolveRuntimeUserScope(
+  process.env,
+  discoverLegacyUserScope(AMALGM_HOME, AMALGM_RUNTIME_LABEL),
+);
+const AMALGM_DIR = process.env.AMALGM_DIR
+  ? path.resolve(process.env.AMALGM_DIR)
+  : scopedAmalgmDir(AMALGM_HOME, AMALGM_RUNTIME_USER_SCOPE, AMALGM_RUNTIME_LABEL);
+const AMALGM_RUNTIME_INSTANCE_ID = process.env.AMALGM_RUNTIME_INSTANCE_ID
+  || runtimeInstanceIdForDir(AMALGM_DIR);
 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');
@@ -21,7 +43,12 @@ const SHUTDOWN_REASON_FILE = path.join(AMALGM_DIR, 'shutdown-reason.json');
 const DEFAULT_APP_URL = process.env.AMALGM_APP_URL || 'https://amalgm.ai';
 
 module.exports = {
+  AMALGM_BRANCH,
   AMALGM_DIR,
+  AMALGM_HOME,
+  AMALGM_RUNTIME_INSTANCE_ID,
+  AMALGM_RUNTIME_LABEL,
+  AMALGM_RUNTIME_USER_SCOPE,
   AUTH_FILE,
   COMPUTER_FILE,
   DEFAULT_APP_URL,

package/lib/process-cleanup.js

@@ -6,6 +6,7 @@ const { spawnSync } = require('child_process');
 
 const {
   AMALGM_DIR,
+  AMALGM_RUNTIME_INSTANCE_ID,
   PACKAGE_ROOT,
   RUNTIME_DIR,
 } = require('./paths');
@@ -20,6 +21,7 @@ const RUNTIME_SERVICE_SUFFIXES = runtimeServiceScripts()
 
 const SUPERVISOR_MARKER = path.join(PACKAGE_ROOT, 'bin', 'amalgm.js').replace(/\\/g, '/');
 const SUPERVISOR_SUFFIX = '/bin/amalgm.js';
+const RUNTIME_INSTANCE_ARG = `--amalgm-runtime-id=${AMALGM_RUNTIME_INSTANCE_ID}`;
 
 function isPidRunning(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
@@ -144,15 +146,33 @@ function normalizedCommand(command) {
 }
 
 function envMatchesAmalgmDir(env) {
+  if (env?.AMALGM_RUNTIME_INSTANCE_ID) return env.AMALGM_RUNTIME_INSTANCE_ID === AMALGM_RUNTIME_INSTANCE_ID;
   if (!env || !env.AMALGM_DIR) return true;
   return path.resolve(env.AMALGM_DIR) === path.resolve(AMALGM_DIR);
 }
 
+function commandRuntimeInstanceId(command) {
+  const normalized = normalizedCommand(command);
+  const match = normalized.match(/(?:^|\s)--amalgm-runtime-id(?:=|\s+)([^\s]+)/);
+  return match ? match[1] : '';
+}
+
+function commandMatchesRuntimeInstance(command) {
+  const instanceId = commandRuntimeInstanceId(command);
+  if (instanceId) return instanceId === AMALGM_RUNTIME_INSTANCE_ID;
+  return null;
+}
+
 function commandLooksLikeRuntimeService(command, item = null, options = {}) {
   const normalized = normalizedCommand(command);
-  if (RUNTIME_SERVICE_MARKERS.some((marker) => normalized.includes(marker))) return true;
-  if (!RUNTIME_SERVICE_SUFFIXES.some((marker) => normalized.includes(marker))) return false;
+  const absoluteMatch = RUNTIME_SERVICE_MARKERS.some((marker) => normalized.includes(marker));
+  const suffixMatch = RUNTIME_SERVICE_SUFFIXES.some((marker) => normalized.includes(marker));
+  if (!absoluteMatch && !suffixMatch) return false;
+  const instanceMatch = commandMatchesRuntimeInstance(normalized);
+  if (instanceMatch !== null) return instanceMatch;
   if (item?.env && envMatchesAmalgmDir(item.env)) return true;
+  if (item?.env) return false;
+  if (!absoluteMatch) return false;
   if (!options.includeOrphanedForeign) return false;
   const parent = normalizedCommand(item?.parentCommand || '');
   return !commandLooksLikeAnySupervisor(parent);
@@ -160,7 +180,9 @@ function commandLooksLikeRuntimeService(command, item = null, options = {}) {
 
 function commandLooksLikeSupervisor(command) {
   const normalized = normalizedCommand(command);
-  return normalized.includes(SUPERVISOR_MARKER) && /\brun\b/.test(normalized);
+  if (!normalized.includes(SUPERVISOR_MARKER) || !/\brun\b/.test(normalized)) return false;
+  const instanceMatch = commandMatchesRuntimeInstance(normalized);
+  return instanceMatch === true;
 }
 
 function commandLooksLikeAnySupervisor(command) {
@@ -233,6 +255,7 @@ module.exports = {
   commandLooksLikeRuntimeService,
   commandLooksLikeSupervisor,
   isPidRunning,
+  RUNTIME_INSTANCE_ARG,
   runtimeServiceProcesses,
   supervisorProcesses,
   terminateProcesses,

package/lib/runtime-identity.js

@@ -0,0 +1,145 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const VALID_RUNTIME_LABELS = new Set(['main', 'preview', 'local']);
+
+function normalizeRuntimeLabel(value) {
+  const raw = String(value || '').trim().toLowerCase();
+  if (!raw) return '';
+  if (['main', 'latest', 'stable', 'prod', 'production', 'release', 'master'].includes(raw)) return 'main';
+  if (['preview', 'canary', 'native-chat', 'staging'].includes(raw)) return 'preview';
+  if (['local', 'dev', 'development'].includes(raw)) return 'local';
+  return '';
+}
+
+function runtimeLabelFromVersion(version) {
+  const raw = String(version || '').toLowerCase();
+  return /-(?:canary|preview|alpha|beta|rc)(?:[.\-+]|$)/.test(raw) ? 'preview' : 'main';
+}
+
+function resolveRuntimeLabel(env = process.env, options = {}) {
+  const explicit = normalizeRuntimeLabel(
+    env.AMALGM_RUNTIME_LABEL
+    || env.AMALGM_LABEL
+    || env.AMALGM_CHANNEL
+    || env.AMALGM_BRANCH,
+  );
+  if (explicit) return explicit;
+  if (options.local) return 'local';
+  return runtimeLabelFromVersion(options.packageVersion || env.npm_package_version || '');
+}
+
+function assertRuntimeLabel(label) {
+  if (!VALID_RUNTIME_LABELS.has(label)) {
+    throw new Error(`Unsupported Amalgm runtime label "${label}". Use main, preview, or local.`);
+  }
+  return label;
+}
+
+function runtimeBranchForLabel(label, env = process.env) {
+  const branch = normalizeRuntimeLabel(env.AMALGM_BRANCH);
+  if (branch === 'main' || branch === 'preview') return branch;
+  if (label === 'preview') return 'preview';
+  return 'main';
+}
+
+function npmTagForRuntimeLabel(label) {
+  return label === 'preview' ? 'canary' : 'latest';
+}
+
+function sanitizeScopeSegment(value, fallback = 'local') {
+  const clean = String(value || '')
+    .trim()
+    .replace(/[^A-Za-z0-9_.@-]/g, '_')
+    .replace(/^_+|_+$/g, '');
+  return clean || fallback;
+}
+
+function readJson(file, fallback = null) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function userIdFromRecord(record) {
+  return typeof record?.user_id === 'string' && record.user_id.trim()
+    ? record.user_id.trim()
+    : '';
+}
+
+function discoverLegacyUserScope(homeDir, label = '') {
+  const record = readJson(path.join(homeDir, 'computer.json'), null);
+  const fromRecord = userIdFromRecord(record);
+  if (fromRecord) return fromRecord;
+
+  const auth = readJson(path.join(homeDir, 'auth.json'), null);
+  const fromAuth = userIdFromRecord(auth);
+  if (fromAuth) return fromAuth;
+
+  const runtimeLabel = normalizeRuntimeLabel(label);
+  if (!runtimeLabel) return '';
+  try {
+    const usersDir = path.join(homeDir, 'users');
+    for (const entry of fs.readdirSync(usersDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const scopedDir = path.join(usersDir, entry.name, runtimeLabel);
+      const scopedRecord = readJson(path.join(scopedDir, 'computer.json'), null);
+      const fromScopedRecord = userIdFromRecord(scopedRecord);
+      if (fromScopedRecord) return fromScopedRecord;
+      const scopedAuth = readJson(path.join(scopedDir, 'auth.json'), null);
+      const fromScopedAuth = userIdFromRecord(scopedAuth);
+      if (fromScopedAuth) return fromScopedAuth;
+    }
+  } catch {
+    // No scoped users yet.
+  }
+  return '';
+}
+
+function resolveRuntimeUserScope(env = process.env, fallback = '') {
+  return sanitizeScopeSegment(
+    env.AMALGM_RUNTIME_USER_ID
+    || env.AMALGM_USER_SCOPE
+    || env.AMALGM_USER_ID
+    || fallback
+    || 'local',
+  );
+}
+
+function defaultAmalgmHome(env = process.env) {
+  return env.AMALGM_HOME || path.join(os.homedir(), '.amalgm');
+}
+
+function scopedAmalgmDir(homeDir, userScope, label) {
+  return path.join(homeDir, 'users', sanitizeScopeSegment(userScope), assertRuntimeLabel(label));
+}
+
+function runtimeInstanceIdForDir(dir) {
+  return crypto
+    .createHash('sha256')
+    .update(path.resolve(String(dir || '')), 'utf8')
+    .digest('hex')
+    .slice(0, 16);
+}
+
+module.exports = {
+  VALID_RUNTIME_LABELS,
+  assertRuntimeLabel,
+  defaultAmalgmHome,
+  discoverLegacyUserScope,
+  npmTagForRuntimeLabel,
+  normalizeRuntimeLabel,
+  resolveRuntimeLabel,
+  resolveRuntimeUserScope,
+  runtimeInstanceIdForDir,
+  runtimeBranchForLabel,
+  runtimeLabelFromVersion,
+  sanitizeScopeSegment,
+  scopedAmalgmDir,
+};

package/lib/service.js

@@ -7,9 +7,13 @@ const { spawn, spawnSync } = require('child_process');
 
 const {
   AMALGM_DIR,
+  AMALGM_BRANCH,
   LOG_DIR,
   PACKAGE_ROOT,
   PID_FILE,
+  AMALGM_RUNTIME_INSTANCE_ID,
+  AMALGM_RUNTIME_LABEL,
+  AMALGM_RUNTIME_USER_SCOPE,
   SERVICE_DIR,
   SERVICE_PID_FILE,
   SERVICE_STATE_FILE,
@@ -17,10 +21,13 @@ const {
 } = require('./paths');
 const {
   cleanupStaleRuntimeProcesses,
+  RUNTIME_INSTANCE_ARG,
 } = require('./process-cleanup');
 
 const PACKAGE_VERSION = require('../package.json').version;
-const SERVICE_LABEL = 'ai.amalgm.runtime';
+const SERVICE_LABEL_SCOPE = `${AMALGM_RUNTIME_USER_SCOPE}.${AMALGM_RUNTIME_LABEL}`
+  .replace(/[^A-Za-z0-9_.-]/g, '_');
+const SERVICE_LABEL = process.env.AMALGM_SERVICE_LABEL || `ai.amalgm.runtime.${SERVICE_LABEL_SCOPE}`;
 const SERVICE_SCRIPT_FILE = path.join(SERVICE_DIR, 'amalgm-watchdog.sh');
 const SERVICE_NODE_SCRIPT_FILE = path.join(SERVICE_DIR, 'amalgm-watchdog.cjs');
 const SERVICE_LOG_FILE = path.join(LOG_DIR, 'service.log');
@@ -33,6 +40,10 @@ const SERVICE_ENV_KEYS = [
   'AMALGM_CREATE_AUTH_WATCH_DIRS',
   'AMALGM_DEFAULT_CWD',
   'AMALGM_GATEWAY_PORT',
+  'AMALGM_HOME',
+  'AMALGM_RUNTIME_INSTANCE_ID',
+  'AMALGM_RUNTIME_LABEL',
+  'AMALGM_RUNTIME_USER_ID',
   'AMALGM_NATIVE_NODE_MODULES',
   'AMALGM_PROJECTS_DIR',
   'AMALGM_SKIP_NATIVE_INSTALL',
@@ -224,6 +235,11 @@ function detectServiceBackend(mode = 'auto') {
 function buildServiceEnv(localOnly) {
   const env = {
     AMALGM_DIR,
+    AMALGM_RUNTIME_INSTANCE_ID,
+    AMALGM_RUNTIME_LABEL,
+    AMALGM_BRANCH,
+    AMALGM_RUNTIME_USER_ID: AMALGM_RUNTIME_USER_SCOPE,
+    AMALGM_USER_SCOPE: AMALGM_RUNTIME_USER_SCOPE,
     AMALGM_LOCAL_ONLY: localOnly ? 'true' : 'false',
     AMALGM_SERVICE_MANAGED: 'true',
     AMALGM_SERVICE_LABEL: SERVICE_LABEL,
@@ -294,6 +310,7 @@ function writePortableNodeScript(localOnly) {
     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),
+    runtimeInstanceArg: RUNTIME_INSTANCE_ARG,
   };
   const source = `'use strict';
 
@@ -422,7 +439,7 @@ function launch() {
   append(config.serviceLog, 'starting amalgm run');
   const fd = fs.openSync(config.daemonLog, 'a');
   childStartedAt = Date.now();
-  child = spawn(config.nodeBin, [config.amalgmBin, 'run'], {
+  child = spawn(config.nodeBin, [config.amalgmBin, 'run', config.runtimeInstanceArg], {
     cwd: process.env.HOME || process.cwd(),
     env: { ...process.env, ...config.env },
     stdio: ['ignore', fd, fd],
@@ -484,6 +501,7 @@ function writeLaunchdPlist(localOnly) {
     <string>${plistEscape(process.execPath)}</string>
     <string>${plistEscape(AMALGM_BIN)}</string>
     <string>run</string>
+    <string>${plistEscape(RUNTIME_INSTANCE_ARG)}</string>
   </array>
   <key>EnvironmentVariables</key>
   <dict>
@@ -519,6 +537,7 @@ function writeSystemdUnit(localOnly) {
     AMALGM_NODE: process.execPath,
     AMALGM_BIN,
     AMALGM_DAEMON_LOG: path.join(LOG_DIR, 'daemon.log'),
+    AMALGM_RUNTIME_INSTANCE_ARG: RUNTIME_INSTANCE_ARG,
   };
   const envLines = Object.entries(env)
     .map(([key, value]) => `Environment=${systemdQuote(`${key}=${value}`)}`)
@@ -532,7 +551,7 @@ Wants=network-online.target
 Type=simple
 WorkingDirectory=${systemdQuote(os.homedir())}
 ${envLines}
-ExecStart=/bin/sh -lc ${systemdQuote('exec "$AMALGM_NODE" "$AMALGM_BIN" run >> "$AMALGM_DAEMON_LOG" 2>&1')}
+ExecStart=/bin/sh -lc ${systemdQuote('exec "$AMALGM_NODE" "$AMALGM_BIN" run "$AMALGM_RUNTIME_INSTANCE_ARG" >> "$AMALGM_DAEMON_LOG" 2>&1')}
 Restart=always
 RestartSec=5
 KillSignal=SIGTERM

package/lib/supervisor.js

@@ -10,8 +10,12 @@ const net = require('net');
 
 const {
   AMALGM_DIR,
+  AMALGM_BRANCH,
   LOG_DIR,
   PID_FILE,
+  AMALGM_RUNTIME_INSTANCE_ID,
+  AMALGM_RUNTIME_LABEL,
+  AMALGM_RUNTIME_USER_SCOPE,
   RUNTIME_DIR,
   RUNTIME_STATE_FILE,
   RUNTIME_TOKEN_FILE,
@@ -30,6 +34,7 @@ const {
 const {
   cleanupStaleRuntimeProcesses,
   isPidRunning,
+  RUNTIME_INSTANCE_ARG,
   supervisorProcesses,
 } = require('./process-cleanup');
 const {
@@ -204,6 +209,11 @@ function baseRuntimeEnv(record, ports, options = {}) {
   const env = {
     ...safeBaseProcessEnv(),
     AMALGM_RUNTIME_SOURCE: 'npm',
+    AMALGM_RUNTIME_INSTANCE_ID,
+    AMALGM_RUNTIME_LABEL,
+    AMALGM_BRANCH,
+    AMALGM_RUNTIME_USER_ID: AMALGM_RUNTIME_USER_SCOPE,
+    AMALGM_USER_SCOPE: AMALGM_RUNTIME_USER_SCOPE,
     AMALGM_RUNTIME_TOKEN: record?.runtime_token || process.env.AMALGM_RUNTIME_TOKEN || '',
     AMALGM_LOCAL_MODE: 'true',
     AMALGM_LOCAL_ONLY: localOnly ? 'true' : 'false',
@@ -241,7 +251,7 @@ function serviceSpecs(record, ports, options = {}) {
   return runtimeLaunchServices().map((service) => ({
     name: service.name,
     command: process.execPath,
-    args: [runtimeEntry(service.script)],
+    args: [runtimeEntry(service.script), RUNTIME_INSTANCE_ARG],
     env: service.name === 'port-monitor' ? { ...env, PORT: process.env.PORT || '0' } : env,
     port: ports[service.portKey],
     healthPath: '/healthz',
@@ -608,6 +618,10 @@ async function startSupervisor(options = {}) {
     pid: process.pid,
     supervisor_pid: process.pid,
     source: 'npm',
+    runtime_label: AMALGM_RUNTIME_LABEL,
+    label: AMALGM_RUNTIME_LABEL,
+    branch: AMALGM_BRANCH,
+    user_scope: AMALGM_RUNTIME_USER_SCOPE,
     package_version: PACKAGE_VERSION,
     runtime_dir: RUNTIME_DIR,
     computer_id: record?.computer_id || null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.54",
+  "version": "0.1.56",
   "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/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/lib/runtime-manifest.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/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-identity.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/lib/runtime-manifest.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/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/browser/agent-browser.js

@@ -60,57 +60,15 @@ function tabInfo(session, extra = {}) {
   return info;
 }
 
-function executableExists(file) {
-  try {
-    fs.accessSync(file, fs.constants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function linuxLibcSuffix() {
-  if (process.platform !== 'linux') return '';
-  const glibc = process.report?.getReport?.().header?.glibcVersionRuntime;
-  return glibc ? '' : '-musl';
-}
-
-function agentBrowserBinaryName() {
-  if (!['darwin', 'linux', 'win32'].includes(process.platform)) return null;
-  if (!['arm64', 'x64'].includes(process.arch)) return null;
-  const platform = process.platform === 'win32' ? 'win32' : `${process.platform}${linuxLibcSuffix()}`;
-  const ext = process.platform === 'win32' ? '.exe' : '';
-  return `agent-browser-${platform}-${process.arch}${ext}`;
-}
-
-function asarUnpackedPath(file) {
-  const marker = `${path.sep}app.asar${path.sep}`;
-  return file.includes(marker)
-    ? file.replace(marker, `${path.sep}app.asar.unpacked${path.sep}`)
-    : file;
-}
-
-function nativeAgentBrowserCommand(entrypoint) {
-  const binaryName = agentBrowserBinaryName();
-  if (!entrypoint || !binaryName) return null;
-  const candidate = path.join(path.dirname(entrypoint), binaryName);
-  const unpacked = asarUnpackedPath(candidate);
-  const candidates = unpacked === candidate ? [candidate] : [unpacked];
-  return candidates.find(executableExists) || null;
-}
-
 function agentBrowserCommand() {
   if (process.env.AMALGM_AGENT_BROWSER_BIN) {
     return { command: process.env.AMALGM_AGENT_BROWSER_BIN, prefix: [] };
   }
 
   try {
-    const entrypoint = require.resolve('agent-browser/bin/agent-browser.js');
-    const nativeCommand = nativeAgentBrowserCommand(entrypoint);
-    if (nativeCommand) return { command: nativeCommand, prefix: [] };
     return {
       command: process.execPath,
-      prefix: [entrypoint],
+      prefix: [require.resolve('agent-browser/bin/agent-browser.js')],
     };
   } catch {
     return { command: 'agent-browser', prefix: [] };

package/runtime/scripts/amalgm-mcp/browser/electron-bridge.js

@@ -1,12 +1,58 @@
 const http = require('http');
 const https = require('https');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
 
 const DEFAULT_SESSION = `mcp-${process.pid}-default`;
 
+function amalgmDir() {
+  return process.env.AMALGM_DIR || path.join(os.homedir(), '.amalgm');
+}
+
+function bridgeConfigFile() {
+  return path.join(amalgmDir(), 'electron-browser-bridge.json');
+}
+
+function isLoopbackUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === 'http:' && (url.hostname === '127.0.0.1' || url.hostname === 'localhost');
+  } catch {
+    return false;
+  }
+}
+
+function pidIsRunning(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err && err.code === 'EPERM';
+  }
+}
+
+function normalizeConfig(data) {
+  const baseUrl = typeof data?.baseUrl === 'string' ? data.baseUrl : '';
+  const token = typeof data?.token === 'string' ? data.token : '';
+  if (!baseUrl || !token || !isLoopbackUrl(baseUrl)) return null;
+  if (typeof data?.pid === 'number' && !pidIsRunning(data.pid)) return null;
+  return { baseUrl, token };
+}
+
+function fileConfig() {
+  try {
+    return normalizeConfig(JSON.parse(fs.readFileSync(bridgeConfigFile(), 'utf8')));
+  } catch {
+    return null;
+  }
+}
+
 function config() {
   const baseUrl = process.env.AMALGM_ELECTRON_BROWSER_URL;
   const token = process.env.AMALGM_ELECTRON_BROWSER_TOKEN;
-  return baseUrl && token ? { baseUrl, token } : null;
+  return normalizeConfig({ baseUrl, token }) || fileConfig();
 }
 
 function isConfigured() {

package/runtime/scripts/amalgm-mcp/browser/page.js

@@ -1,6 +1,11 @@
 const electron = require('./electron-bridge');
 const agentBrowser = require('./agent-browser');
 
+function isPackagedDesktopRuntime() {
+  const execPath = process.execPath || '';
+  return process.env.ELECTRON_RUN_AS_NODE === '1' && execPath.includes('.app/Contents/MacOS/');
+}
+
 function backend() {
   const requested = (process.env.AMALGM_BROWSER_BACKEND || '').toLowerCase();
   if (requested === 'agent-browser' || requested === 'external') return agentBrowser;
@@ -8,7 +13,8 @@ function backend() {
 
   // In the desktop app this bridge drives the visible in-tab Electron webview.
   // Outside Electron, keep the agent-browser CLI fallback for headless/remote use.
-  return electron.isConfigured() ? electron : agentBrowser;
+  if (electron.isConfigured() || isPackagedDesktopRuntime()) return electron;
+  return agentBrowser;
 }
 
 const exported = {};

package/runtime/scripts/chat-core/tooling/native-binaries.js

@@ -25,25 +25,6 @@ function executableExists(file) {
   }
 }
 
-function asarUnpackedPath(file) {
-  const marker = `${path.sep}app.asar${path.sep}`;
-  return file && file.includes(marker)
-    ? file.replace(marker, `${path.sep}app.asar.unpacked${path.sep}`)
-    : file;
-}
-
-function executablePath(file) {
-  const unpacked = asarUnpackedPath(file);
-  if (unpacked !== file) return executableExists(unpacked) ? unpacked : null;
-  return executableExists(file) ? file : null;
-}
-
-function existingPath(file) {
-  const unpacked = asarUnpackedPath(file);
-  if (unpacked !== file && fs.existsSync(unpacked)) return unpacked;
-  return fs.existsSync(file) ? file : null;
-}
-
 function findPackageJson(packageName) {
   const candidateDirs = [
     ...nativeNodeModulesDirs(),
@@ -179,7 +160,7 @@ function bundledClaudeBinary() {
   const root = packageRoot(packageName);
   if (!root) return null;
   const candidate = path.join(root, process.platform === 'win32' ? 'claude.exe' : 'claude');
-  return executablePath(candidate);
+  return executableExists(candidate) ? candidate : null;
 }
 
 function resolveClaudeBinary() {
@@ -232,10 +213,8 @@ function codexVendorRoot() {
   if (platformRoot) return path.join(platformRoot, 'vendor');
   const wrapperRoot = packageRoot('@openai/codex');
   if (wrapperRoot) {
-    const nestedVendorRoot = existingPath(path.join(wrapperRoot, 'node_modules', target.packageName, 'vendor'));
-    if (nestedVendorRoot) return nestedVendorRoot;
-    const localVendorRoot = existingPath(path.join(wrapperRoot, 'vendor'));
-    if (localVendorRoot) return localVendorRoot;
+    const localVendorRoot = path.join(wrapperRoot, 'vendor');
+    if (fs.existsSync(localVendorRoot)) return localVendorRoot;
   }
   return null;
 }
@@ -245,8 +224,7 @@ function bundledCodexBinary() {
   const vendorRoot = codexVendorRoot();
   if (target && vendorRoot) {
     const candidate = path.join(vendorRoot, target.triple, 'codex', target.binaryName);
-    const binary = executablePath(candidate);
-    if (binary) return binary;
+    if (executableExists(candidate)) return candidate;
   }
   return packageBin('@openai/codex', 'codex');
 }
@@ -256,8 +234,7 @@ function bundledCodexPathDirs() {
   const vendorRoot = codexVendorRoot();
   if (!target || !vendorRoot) return [];
   const candidate = path.join(vendorRoot, target.triple, 'path');
-  const rgPath = executablePath(path.join(candidate, process.platform === 'win32' ? 'rg.exe' : 'rg'));
-  return rgPath ? [path.dirname(rgPath)] : [];
+  return executableExists(path.join(candidate, process.platform === 'win32' ? 'rg.exe' : 'rg')) ? [candidate] : [];
 }
 
 function openCodePlatform() {
@@ -314,14 +291,12 @@ function bundledOpenCodeBinary() {
     const root = packageRoot(packageName);
     if (!root) continue;
     const candidate = path.join(root, 'bin', binaryName);
-    const binary = executablePath(candidate);
-    if (binary) return binary;
+    if (executableExists(candidate)) return candidate;
   }
   const wrapperRoot = packageRoot('opencode-ai');
   if (wrapperRoot) {
     const cached = path.join(wrapperRoot, 'bin', '.opencode');
-    const binary = executablePath(cached);
-    if (binary) return binary;
+    if (executableExists(cached)) return cached;
   }
   return packageBin('opencode-ai', 'opencode');
 }
@@ -365,12 +340,12 @@ function commandTargets() {
     {
       command: 'codex',
       name: 'Codex',
-      path: bundledCodexBinary() || packageBin('@openai/codex', 'codex'),
+      path: packageBin('@openai/codex', 'codex') || bundledCodexBinary(),
     },
     {
       command: 'opencode',
       name: 'OpenCode',
-      path: bundledOpenCodeBinary() || packageBin('opencode-ai', 'opencode'),
+      path: packageBin('opencode-ai', 'opencode') || bundledOpenCodeBinary(),
     },
   ];
 }

package/runtime/scripts/local-gateway.js

@@ -51,6 +51,12 @@ const LEGACY_ARTIFACTS_FILE = path.join(AMALGM_DIR, 'artifacts.json');
 const LOG_DIR = path.join(AMALGM_DIR, 'logs');
 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_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
+  || process.env.AMALGM_USER_ID
+  || 'local';
 const FORCE_RUNTIME_STATE_OWNER = process.env.AMALGM_RUNTIME_FORCE_STATE_OWNER === 'true';
 const VERSION = process.env.npm_package_version || process.env.AMALGM_RUNTIME_VERSION || '';
 const DEFAULT_CWD = process.env.AMALGM_DEFAULT_CWD || os.homedir();
@@ -330,6 +336,10 @@ function writeRuntimeState(actualPort) {
     schema_version: 1,
     owner: OWNER,
     source: OWNER,
+    runtime_label: RUNTIME_LABEL,
+    label: RUNTIME_LABEL,
+    branch: RUNTIME_BRANCH,
+    user_scope: RUNTIME_USER_SCOPE,
     pid: process.pid,
     gateway_pid: process.pid,
     supervisor_pid: process.ppid,
@@ -928,6 +938,9 @@ const server = http.createServer(async (req, res) => {
         status: 'ok',
         service: 'local-gateway',
         owner: OWNER,
+        runtime_label: RUNTIME_LABEL,
+        branch: RUNTIME_BRANCH,
+        user_scope: RUNTIME_USER_SCOPE,
         pid: process.pid,
         ports: SERVICE_PORTS,
       });