amalgm 0.1.88 → 0.1.89

package/lib/cli.js

@@ -65,6 +65,7 @@ const {
   ensureNativeBinaries,
 } = require('../runtime/scripts/chat-core/tooling/native-binaries');
 const {
+  compareVersions,
   shouldAutoUpdate,
   updatePackage,
 } = require('./updater');
@@ -713,18 +714,27 @@ function runningDaemonRestartReason(pid, record, localOnly) {
   const supervisorPid = Number(state?.supervisor_pid || state?.pid || 0);
   if (!state || supervisorPid !== pid) return 'runtime ownership state is missing';
   if (state.source && state.source !== 'npm') return `it is owned by ${state.source}`;
-  if (state.package_version && state.package_version !== PACKAGE_VERSION) {
-    return `it is running package ${state.package_version}, not ${PACKAGE_VERSION}`;
-  }
-  if (state.runtime_dir && state.runtime_dir !== RUNTIME_DIR) {
-    return 'it is running a different package install';
-  }
   if (!!state.local_only !== !!localOnly) {
     return localOnly ? 'it is running in registered mode' : 'it is running in local-only mode';
   }
   if (!localOnly && (state.computer_id || '') !== (record?.computer_id || '')) {
     return `it is connected as ${state.computer_id || 'another computer'}`;
   }
+  // An older CLI (e.g. the copy bundled inside the desktop app) must not
+  // restart a runtime from an equal-or-newer install: restarting it through
+  // startService() would re-home the service to the older tree and the
+  // auto-updater would restart-loop trying to escape it.
+  const runningNewerOrSame = state.package_version
+    ? compareVersions(state.package_version, PACKAGE_VERSION) >= 0
+    : false;
+  if (state.package_version && state.package_version !== PACKAGE_VERSION) {
+    if (runningNewerOrSame) return '';
+    return `it is running package ${state.package_version}, not ${PACKAGE_VERSION}`;
+  }
+  if (state.runtime_dir && state.runtime_dir !== RUNTIME_DIR) {
+    if (runningNewerOrSame) return '';
+    return 'it is running a different package install';
+  }
   return '';
 }
 

package/lib/service.js

@@ -25,6 +25,7 @@ const {
   cleanupStaleRuntimeProcesses,
   RUNTIME_INSTANCE_ARG,
 } = require('./process-cleanup');
+const { compareVersions } = require('./updater');
 
 const PACKAGE_VERSION = require('../package.json').version;
 const SERVICE_LABEL_SCOPE = `${AMALGM_RUNTIME_USER_SCOPE}.${AMALGM_RUNTIME_LABEL}`
@@ -634,9 +635,27 @@ function stateMatchesRequest(state, options = {}) {
   return true;
 }
 
+// A service registration owned by an equal-or-newer install of this package
+// must not be replaced by an older caller (e.g. the CLI bundled inside the
+// desktop app re-registering the service over the auto-updated npm install).
+// Re-pointing the service at an older tree makes the auto-updater restart-loop:
+// it installs the newer version, restarts, and boots the older tree again.
+// Explicit `amalgm service install` still takes over via installService().
+function deferToExistingInstall(state, options = {}) {
+  if (!state || !state.backend || !state.bin || !state.package_version) return false;
+  if (state.package_root === PACKAGE_ROOT) return false;
+  if (!!state.local_only !== !!options.localOnly) return false;
+  const requested = normalizeMode(options.mode || 'auto');
+  if (requested !== 'auto' && requested !== state.backend) return false;
+  if (compareVersions(state.package_version, PACKAGE_VERSION) < 0) return false;
+  if (!fs.existsSync(state.bin)) return false;
+  return true;
+}
+
 function ensureServiceInstalled(options = {}) {
   const state = readJson(SERVICE_STATE_FILE, null);
   if (stateMatchesRequest(state, options)) return state;
+  if (deferToExistingInstall(state, options)) return state;
   return installService(options);
 }
 

package/lib/supervisor.js

@@ -51,6 +51,20 @@ const {
   updatePackage,
 } = require('./updater');
 const PACKAGE_VERSION = require('../package.json').version;
+const PACKAGE_ROOT_DIR = path.join(__dirname, '..');
+
+// 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
+// another install (e.g. the CLI bundled inside the desktop app), the update can
+// never apply by restarting, so restarting would loop forever.
+function installedPackageVersionOnDisk() {
+  try {
+    const raw = fs.readFileSync(path.join(PACKAGE_ROOT_DIR, 'package.json'), 'utf8');
+    return JSON.parse(raw).version || null;
+  } catch {
+    return null;
+  }
+}
 
 const CHILD_RESTART_POLICY = {
   initialDelayMs: 1000,
@@ -532,6 +546,13 @@ function createAutoUpdateManager({ ports, runtimeToken, tunnels, foreground, req
   let timer = null;
   let inFlight = false;
   let installedUpdate = false;
+  // Survives restarts via the state file so a relaunched runtime does not
+  // re-install a target version that already failed to apply to this install.
+  let suppressedTarget = null;
+  const persistedAutoUpdateState = readJson(AUTO_UPDATE_STATE_FILE, null);
+  if (persistedAutoUpdateState?.status === 'restart_suppressed') {
+    suppressedTarget = persistedAutoUpdateState.target_version || null;
+  }
   const checkIntervalMs = numberFromEnv(
     'AMALGM_UPDATE_CHECK_INTERVAL_MS',
     AUTO_UPDATE_POLICY.checkIntervalMs,
@@ -663,6 +684,19 @@ function createAutoUpdateManager({ ports, runtimeToken, tunnels, foreground, req
         return;
       }
 
+      if (suppressedTarget && check.targetVersion === suppressedTarget) {
+        writeAutoUpdateState({
+          status: 'restart_suppressed',
+          current_version: PACKAGE_VERSION,
+          target_version: check.targetVersion,
+          tag: check.tag,
+          service_managed: serviceManaged,
+          last_checked_at: checkedAt,
+          last_error: `update ${check.targetVersion} does not apply to this install (running from ${PACKAGE_ROOT_DIR}); waiting for an install that includes it`,
+        });
+        return;
+      }
+
       log(`installing ${check.targetVersion} from ${check.tag}`);
       writeAutoUpdateState({
         status: 'installing',
@@ -681,6 +715,23 @@ function createAutoUpdateManager({ ports, runtimeToken, tunnels, foreground, req
           if (trimmed) log(trimmed, stream);
         },
       });
+      const diskVersion = installedPackageVersionOnDisk();
+      if (diskVersion !== check.targetVersion) {
+        suppressedTarget = check.targetVersion;
+        const reason = `installed ${check.targetVersion}, but this runtime still runs ${diskVersion || PACKAGE_VERSION} from ${PACKAGE_ROOT_DIR}; restart suppressed to avoid a restart loop`;
+        writeAutoUpdateState({
+          status: 'restart_suppressed',
+          current_version: PACKAGE_VERSION,
+          target_version: check.targetVersion,
+          tag: check.tag,
+          critical: isCriticalUpdate(check),
+          service_managed: serviceManaged,
+          last_checked_at: checkedAt,
+          last_error: reason,
+        });
+        log(reason, 'stderr');
+        return;
+      }
       installedUpdate = true;
       await waitForIdleAndRestart(check);
     } catch (error) {

package/package.json

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

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

@@ -9,7 +9,6 @@ const fs = require('fs');
 const path = require('path');
 const { spawn } = require('child_process');
 const { DEFAULT_CWD } = require('../config');
-const activeMemory = require('../../chat-core/tooling/active-memory');
 const { runtimePort } = require('../../../lib/runtime-manifest');
 const { syncAppRoutesToGateway } = require('./advertise');
 const {
@@ -330,22 +329,10 @@ async function registerApp(input) {
   const data = loadApps();
   data.apps.push(app);
   saveApps(data);
-  activeMemory.ensureConstructMemory({
-    type: 'app',
-    id: app.id,
-    name: app.name,
-    projectPath: app.cwd,
-  }, { source: 'app:register' });
 
   if (app.buildCommand) await runBuild(app);
   await startApp(app.id);
   const deployed = updateAppMeta(app.id, { lastDeployedAt: new Date().toISOString() });
-  activeMemory.ensureConstructMemory({
-    type: 'app',
-    id: deployed.id,
-    name: deployed.name,
-    projectPath: deployed.cwd,
-  }, { source: 'app:deploy' });
   return deployed;
 }
 
@@ -367,12 +354,6 @@ async function redeployApp(appId, updates = {}) {
   if (updates.keep_alive !== undefined) patch.keepAlive = updates.keep_alive !== false;
   if (updates.autostart !== undefined) patch.autostart = updates.autostart !== false;
   if (Object.keys(patch).length > 0) app = updateAppMeta(appId, patch);
-  activeMemory.ensureConstructMemory({
-    type: 'app',
-    id: app.id,
-    name: app.name,
-    projectPath: app.cwd,
-  }, { source: 'app:update' });
 
   if (!app.startCommand) throw new Error('startCommand is required');
   if (!fs.existsSync(app.cwd)) throw new Error(`cwd does not exist: ${app.cwd}`);
@@ -381,12 +362,6 @@ async function redeployApp(appId, updates = {}) {
   await stopApp(appId, { desiredState: 'running' });
   await startApp(appId);
   const deployed = updateAppMeta(appId, { lastDeployedAt: new Date().toISOString() });
-  activeMemory.ensureConstructMemory({
-    type: 'app',
-    id: deployed.id,
-    name: deployed.name,
-    projectPath: deployed.cwd,
-  }, { source: 'app:deploy' });
   return deployed;
 }
 

package/runtime/scripts/amalgm-mcp/browser/auth-tools.js

@@ -0,0 +1,179 @@
+'use strict';
+
+/**
+ * Browser auth tools — durable profiles, encrypted auth bundles, and
+ * temporary login links. Split from the core browser surface: these manage
+ * login state, they don't drive pages.
+ */
+
+const { textResult, errorResult } = require('../lib/tool-result');
+const engine = require('./engine');
+const {
+  createBrowserLoginSession,
+  listBrowserAuthBundles,
+  listBrowserLoginSessions,
+  listBrowserProfiles,
+  markBrowserAuthBundleImported,
+  readEncryptedStateBundle,
+  safeId,
+  touchBrowserProfile,
+  writeEncryptedStateBundle,
+} = require('./store');
+
+function jsonText(value) {
+  return textResult(JSON.stringify(value, null, 2));
+}
+
+function authDomainsFrom(inputDomains, fallbackUrl) {
+  if (Array.isArray(inputDomains) && inputDomains.length > 0) return inputDomains;
+  try {
+    const hostname = new URL(fallbackUrl).hostname;
+    return hostname ? [hostname] : [];
+  } catch {
+    return [];
+  }
+}
+
+module.exports = [
+  {
+    name: 'browser_profiles_list',
+    description: 'List durable Amalgm browser profiles on this computer.',
+    inputSchema: { type: 'object', properties: {} },
+    async handler() {
+      try {
+        return jsonText({ profiles: listBrowserProfiles() });
+      } catch (err) {
+        return errorResult(`List browser profiles failed: ${err.message}`);
+      }
+    },
+  },
+  {
+    name: 'browser_auth_bundles_list',
+    description: 'List encrypted browser auth bundles available on this computer. Raw cookies/storage are never returned.',
+    inputSchema: { type: 'object', properties: {} },
+    async handler() {
+      try {
+        return jsonText({ bundles: listBrowserAuthBundles() });
+      } catch (err) {
+        return errorResult(`List browser auth bundles failed: ${err.message}`);
+      }
+    },
+  },
+  {
+    name: 'browser_login_sessions_list',
+    description: 'List temporary browser login links on this computer. Raw tokens and cookies are never returned.',
+    inputSchema: { type: 'object', properties: {} },
+    async handler() {
+      try {
+        return jsonText({ sessions: listBrowserLoginSessions() });
+      } catch (err) {
+        return errorResult(`List browser login sessions failed: ${err.message}`);
+      }
+    },
+  },
+  {
+    name: 'browser_auth_link_create',
+    description: 'Create a short-lived browser login link for the user. Use this when an agent needs the user to log into a site before QA or browser work.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        targetUrl: { type: 'string', description: 'The site or app URL the user should log into.' },
+        browserProfileId: { type: 'string', description: 'Durable browser profile id that will receive the login.' },
+        name: { type: 'string', description: 'Human-readable login/bundle name.' },
+        domains: { type: 'array', items: { type: 'string' }, description: 'Domains to save after login, e.g. app.example.com.' },
+        transport: { type: 'string', description: 'Optional live-view transport: electron-splitview, novnc, or auto.' },
+        liveUrl: { type: 'string', description: 'Optional noVNC/live-view URL for web/mobile login.' },
+        appBaseUrl: { type: 'string', description: 'Optional Amalgm app base URL used to build an absolute link.' },
+        ttlMs: { type: 'number', description: 'Optional link lifetime in milliseconds. Defaults to 15 minutes, max 1 hour.' },
+      },
+      required: ['targetUrl'],
+    },
+    async handler(args, ctx) {
+      try {
+        const profileId = safeId(
+          args.browserProfileId
+            || args.browserSessionId
+            || ctx?.callerSessionId
+            || `login-${Date.now().toString(36)}`,
+        );
+        const result = createBrowserLoginSession({
+          ...args,
+          browserProfileId: profileId,
+          profileId,
+        }, { source: 'browser-auth-link-tool' });
+        return jsonText({
+          session: result.session,
+          authLink: result.authLink,
+          authLinkPath: result.authLinkPath,
+          message: `Open this temporary login link: ${result.authLink}`,
+        });
+      } catch (err) {
+        return errorResult(`Create browser auth link failed: ${err.message}`);
+      }
+    },
+  },
+  {
+    name: 'browser_auth_save',
+    description: 'Save the current browser profile cookies/storage into an encrypted auth bundle for later agent use.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        browserProfileId: { type: 'string', description: 'Durable browser profile id to save from' },
+        name: { type: 'string', description: 'Human-readable bundle name' },
+        domains: { type: 'array', items: { type: 'string' }, description: 'Optional domains to include, e.g. example.com' },
+      },
+    },
+    async handler(args, ctx) {
+      try {
+        const profileId = safeId(args.browserProfileId || args.browserSessionId || ctx?.callerSessionId || 'default');
+        const saved = await engine.saveState({ ...args, session: profileId }, ctx);
+        const bundle = writeEncryptedStateBundle({
+          name: args.name || saved.title || profileId,
+          profileId,
+          domains: authDomainsFrom(args.domains, saved.url),
+          state: saved.state || {},
+        });
+        touchBrowserProfile({
+          id: profileId,
+          name: args.name || profileId,
+          source: saved.backend || 'browser-auth-save',
+        }, { source: 'browser-auth-save' });
+        return jsonText({ bundle });
+      } catch (err) {
+        return errorResult(`Save browser auth bundle failed: ${err.message}`);
+      }
+    },
+  },
+  {
+    name: 'browser_auth_load',
+    description: 'Load an encrypted browser auth bundle into a durable browser profile so an agent can start past login.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Auth bundle id' },
+        browserProfileId: { type: 'string', description: 'Target durable browser profile id' },
+      },
+      required: ['id'],
+    },
+    async handler(args, ctx) {
+      try {
+        const { bundle, payload } = readEncryptedStateBundle(args.id);
+        const profileId = safeId(args.browserProfileId || args.browserSessionId || bundle.profileId);
+        const loaded = await engine.loadState({
+          ...args,
+          session: profileId,
+          state: payload.state,
+        }, ctx);
+        const updated = markBrowserAuthBundleImported(args.id, profileId);
+        touchBrowserProfile({
+          id: profileId,
+          name: profileId,
+          source: loaded.backend || 'browser-auth-load',
+        }, { source: 'browser-auth-load' });
+        return jsonText({ bundle: updated, loaded });
+      } catch (err) {
+        return errorResult(`Load browser auth bundle failed: ${err.message}`);
+      }
+    },
+  },
+];

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

@@ -0,0 +1,217 @@
+'use strict';
+
+/**
+ * Low-level runner for the agent-browser CLI (vercel-labs/agent-browser).
+ *
+ * One agent-browser daemon exists per session; sessions map 1:1 to durable
+ * Amalgm browser profiles. This module owns process spawning, environment
+ * setup, and the JSON envelope — nothing else. Verb-level behavior lives in
+ * engine.js.
+ *
+ * Environment fixes handled here (learned from live testing):
+ * - AGENT_BROWSER_SOCKET_DIR must be short or the daemon socket path can
+ *   exceed the 103-byte unix socket limit and every command fails.
+ * - The daemon resolves `ffmpeg` from PATH at daemon spawn time, so video
+ *   recording only works if ffmpeg is on PATH for the *first* command of a
+ *   session. We prepend ffmpeg-static's directory when available.
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const DEFAULT_TIMEOUT_MS = 120_000;
+const DEFAULT_SESSION = 'default';
+
+function amalgmDir() {
+  return process.env.AMALGM_DIR || path.join(os.homedir(), '.amalgm');
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  try { fs.chmodSync(dir, 0o700); } catch {}
+  return dir;
+}
+
+function safeId(value, fallback = DEFAULT_SESSION) {
+  const raw = String(value || fallback).replace(/^agent-browser:/, '');
+  return raw.replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 64) || fallback;
+}
+
+function browserRoot() {
+  return ensureDir(path.join(amalgmDir(), 'browser'));
+}
+
+function profileDir(session) {
+  return ensureDir(path.join(browserRoot(), 'profiles', session));
+}
+
+function screenshotDir() {
+  return ensureDir(path.join(browserRoot(), 'screenshots'));
+}
+
+/**
+ * Unix socket paths cap at ~103 bytes on macOS. The default socket dir is
+ * derived from TMPDIR which can be deep; keep ours short and stable.
+ */
+function socketDir() {
+  if (process.env.AGENT_BROWSER_SOCKET_DIR) return process.env.AGENT_BROWSER_SOCKET_DIR;
+  return ensureDir(path.join(os.tmpdir(), 'amalgm-ab'));
+}
+
+function ffmpegDir() {
+  try {
+    const resolved = require('ffmpeg-static');
+    if (resolved && fs.existsSync(resolved)) return path.dirname(resolved);
+  } catch {}
+  return null;
+}
+
+function agentBrowserCommand() {
+  if (process.env.AMALGM_AGENT_BROWSER_BIN) {
+    return { command: process.env.AMALGM_AGENT_BROWSER_BIN, prefix: [] };
+  }
+  try {
+    return {
+      command: process.execPath,
+      prefix: [require.resolve('agent-browser/bin/agent-browser.js')],
+    };
+  } catch {
+    return { command: 'agent-browser', prefix: [] };
+  }
+}
+
+function wantsHeaded() {
+  const explicit = process.env.AMALGM_BROWSER_HEADED || process.env.AGENT_BROWSER_HEADED;
+  if (explicit) return !/^(0|false|no)$/i.test(explicit);
+  if (/^(1|true|yes)$/i.test(process.env.AMALGM_BROWSER_HEADLESS || '')) return false;
+  if (process.platform === 'linux' && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) return false;
+  return true;
+}
+
+function baseArgs(session, json = true) {
+  const args = [
+    '--session', session,
+    '--profile', profileDir(session),
+    '--screenshot-dir', screenshotDir(),
+  ];
+  if (json) args.push('--json');
+  if (wantsHeaded()) args.push('--headed');
+  if (process.env.AMALGM_BROWSER_EXECUTABLE_PATH) {
+    args.push('--executable-path', process.env.AMALGM_BROWSER_EXECUTABLE_PATH);
+  }
+  if (process.env.AMALGM_BROWSER_PROVIDER) {
+    args.push('--provider', process.env.AMALGM_BROWSER_PROVIDER);
+  }
+  return args;
+}
+
+function parseJson(stdout) {
+  const text = String(stdout || '').trim();
+  if (!text) return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+      if (!/^[{[]/.test(lines[i])) continue;
+      try {
+        return JSON.parse(lines.slice(i).join('\n'));
+      } catch {
+        // Keep looking for a JSON suffix.
+      }
+    }
+  }
+  return { text };
+}
+
+function asText(value) {
+  if (value == null) return '';
+  if (typeof value === 'string') return value;
+  if (value.success === true && value.data !== undefined) return asText(value.data);
+  if (typeof value.snapshot === 'string') return value.snapshot;
+  if (typeof value.text === 'string') return value.text;
+  if (typeof value.value === 'string') return value.value;
+  if (typeof value.result === 'string') return value.result;
+  if (typeof value.output === 'string') return value.output;
+  if (typeof value.url === 'string') return value.url;
+  if (typeof value.title === 'string') return value.title;
+  return JSON.stringify(value, null, 2);
+}
+
+function runCli(commandArgs, options = {}) {
+  const session = safeId(options.session);
+  const json = options.json !== false;
+  const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS;
+  const bin = agentBrowserCommand();
+  const args = [...bin.prefix, ...baseArgs(session, json), ...commandArgs.map(String)];
+
+  const env = {
+    ...process.env,
+    AGENT_BROWSER_SESSION: session,
+    AGENT_BROWSER_PROFILE: profileDir(session),
+    AGENT_BROWSER_SOCKET_DIR: socketDir(),
+  };
+  // The daemon (spawned by the first command of a session) inherits this env,
+  // and resolves ffmpeg from PATH when recording starts.
+  const ffmpeg = ffmpegDir();
+  if (ffmpeg) env.PATH = `${ffmpeg}${path.delimiter}${env.PATH || ''}`;
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(bin.command, args, {
+      cwd: os.homedir(),
+      env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM');
+      reject(new Error(`agent-browser timed out running: ${commandArgs.join(' ')}`));
+    }, timeoutMs);
+
+    child.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+    child.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      reject(err.code === 'ENOENT'
+        ? new Error('agent-browser is not installed. Reinstall Amalgm or run `npm install agent-browser`.')
+        : err);
+    });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (code !== 0) {
+        reject(new Error((stderr || stdout || `agent-browser exited with code ${code}`).trim()));
+        return;
+      }
+      const result = json ? parseJson(stdout) : { text: stdout.trim() };
+      if (result && result.success === false) {
+        reject(new Error(result.error || result.message || 'agent-browser command failed'));
+        return;
+      }
+      resolve(result);
+    });
+  });
+}
+
+async function readText(commandArgs, session, timeoutMs = 30_000) {
+  return asText(await runCli(commandArgs, { session, timeoutMs }));
+}
+
+module.exports = {
+  DEFAULT_SESSION,
+  amalgmDir,
+  asText,
+  browserRoot,
+  ensureDir,
+  ffmpegDir,
+  profileDir,
+  readText,
+  runCli,
+  safeId,
+  screenshotDir,
+  socketDir,
+  wantsHeaded,
+};