amalgm 0.1.154 → 0.1.155

package/runtime/scripts/amalgm-mcp/agent-bundles/install.js

@@ -14,15 +14,14 @@ const { rewriteAppBoundPaths } = require('./tool-bindings');
 const {
   BUNDLE_KIND,
   BUNDLE_SCHEMA_VERSION,
-  LEGACY_AGENT_BUNDLE_KIND,
   agentEntryId,
   appEntryId,
+  assertBundleGraphMatches,
   automationEntryId,
   isObject,
   nowIso,
   standaloneToolIds,
   uniqueStrings,
-  withBundleGraph,
 } = require('./graph');
 
 function assertUniqueRecords(label, records, idForRecord) {
@@ -121,7 +120,7 @@ function assertClosedAgentBundleGraph(bundle) {
 
 function validateBundle(bundle) {
   if (!isObject(bundle)) throw new Error('bundle must be an object');
-  if (bundle.kind !== BUNDLE_KIND && bundle.kind !== LEGACY_AGENT_BUNDLE_KIND) {
+  if (bundle.kind !== BUNDLE_KIND) {
     throw new Error(`Unsupported bundle kind: ${bundle.kind || 'unknown'}`);
   }
   if (bundle.schemaVersion !== BUNDLE_SCHEMA_VERSION) {
@@ -143,7 +142,7 @@ function validateBundle(bundle) {
   assertUniqueRecords('tool action', toolActions, (action) => String(action?.id || '').trim());
   apps.forEach(assertPortableAppEntry);
   if (agents.length > 0) assertClosedAgentBundleGraph(bundle);
-  return withBundleGraph(bundle);
+  return assertBundleGraphMatches(bundle);
 }
 
 function installTools(bundle, appDirBySourceId = new Map(), appIdBySourceId = new Map()) {
@@ -166,16 +165,12 @@ function installTools(bundle, appDirBySourceId = new Map(), appIdBySourceId = ne
   for (const tool of Array.isArray(bundle.tools) ? bundle.tools : []) {
     if (!tool?.id || tool.origin === 'system') continue;
     const record = rewrite(tool);
-    // The app link travels by source app id; point it at the recipient's
-    // installed copy, or drop it if that app was not part of the install.
+    // The app link travels by source app id; validation guarantees that the
+    // owning app is in the same bundle and was installed first.
     if (typeof record.appId === 'string' && record.appId) {
       const installedAppId = appIdBySourceId.get(record.appId);
-      if (installedAppId) {
-        record.appId = installedAppId;
-      } else {
-        delete record.appId;
-        warnings.push(`Tool ${tool.id} belongs to an app that was not installed with this bundle; the app link was removed.`);
-      }
+      if (!installedAppId) throw new Error(`Tool ${tool.id} references app that was not installed: ${record.appId}`);
+      record.appId = installedAppId;
     }
     const result = defaultToolboxService.registerTool({
       ...record,

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

@@ -229,6 +229,11 @@ function writeEncryptedStateBundle(input = {}) {
     cookies: normalizedCookies,
   };
   const storageKinds = stateStorageKinds(normalizedState);
+  const payloadExtensions = input.payloadExtensions
+    && typeof input.payloadExtensions === 'object'
+    && !Array.isArray(input.payloadExtensions)
+    ? input.payloadExtensions
+    : {};
   const encrypted = encryptJson({
     version: 2,
     profileId,
@@ -237,11 +242,17 @@ function writeEncryptedStateBundle(input = {}) {
     capturedAt: nowIso(),
     cookies: normalizedCookies,
     state: normalizedState,
+    ...payloadExtensions,
   });
   const id = bundleIdFor(input.id);
   const file = path.join(authBundleRoot(), `${id}.json.enc`);
   const payload = `${JSON.stringify(encrypted.envelope, null, 2)}\n`;
-  fs.writeFileSync(file, payload, { mode: 0o600 });
+  // Cookie jars are updated frequently. Write beside the destination and
+  // rename so a crash can leave either the previous complete envelope or the
+  // next complete envelope, never a truncated encrypted blob.
+  const temporary = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  fs.writeFileSync(temporary, payload, { mode: 0o600 });
+  fs.renameSync(temporary, file);
   try { fs.chmodSync(file, 0o600); } catch {}
 
   return upsertBrowserAuthBundle({

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

@@ -1,7 +1,7 @@
 'use strict';
 
 /**
- * Browser auth actions — durable profiles, encrypted auth bundles, and
+ * Browser auth actions — explicitly saved profiles, encrypted auth bundles, and
  * temporary login links. Split from the core surface: these manage login
  * state, they don't drive pages.
  *
@@ -31,9 +31,8 @@ function jsonText(value) {
   return textResult(JSON.stringify(value, null, 2));
 }
 
-/** Every browser session leaves a durable profile behind, so the full lists
- * grow without bound (a stress test found ~130 profiles / 86K chars from one
- * unpaged dump). Summaries are the default; `full` is the opt-in. */
+/** Saved auth/login history can still be long. Summaries are the default;
+ * ordinary chat working profiles are no longer registered here. */
 const SUMMARY_LIMIT = 15;
 
 function summarizeEntry(entry) {
@@ -59,7 +58,7 @@ function summarizeList(entries) {
 module.exports = [
   {
     name: 'auth_list',
-    description: 'List saved browser auth state on this computer: durable profiles, encrypted auth bundles, and pending login links. Returns a recent-first summary by default; pass full: true for complete records. Raw cookies and tokens are never returned.',
+    description: 'List explicitly saved browser auth state on this computer: profiles, encrypted auth bundles, and pending login links. Returns a recent-first summary by default; pass full: true for complete records. Raw cookies and tokens are never returned.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -157,8 +156,8 @@ module.exports = [
     inputSchema: {
       type: 'object',
       properties: {
-        browserProfileId: { type: 'string', description: 'Durable browser profile id to save from' },
-        id: { type: 'string', description: 'Optional bundle id. Defaults to the shared browser cookie source.' },
+        browserProfileId: { type: 'string', description: 'Browser session/profile id to save from' },
+        id: { type: 'string', description: 'Optional bundle id. A new id is generated when omitted.' },
         name: { type: 'string', description: 'Human-readable bundle name' },
         domains: { type: 'array', items: { type: 'string' }, description: 'Optional domains to include. Omit to save all current browser auth state.' },
       },
@@ -168,8 +167,8 @@ module.exports = [
         const profileId = safeId(args.browserProfileId || args.browserSessionId || ctx?.callerSessionId || DEFAULT_COOKIE_SOURCE_PROFILE_ID);
         const saved = await engine.saveState({ ...args, session: profileId }, ctx);
         const bundle = writeEncryptedStateBundle({
-          id: args.id || COOKIE_SOURCE_BUNDLE_ID,
-          name: args.name || 'Browser cookie source',
+          id: args.id,
+          name: args.name || `${profileId} login`,
           profileId,
           domains: Array.isArray(args.domains) ? args.domains : [],
           state: saved.state || {},

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

@@ -3,8 +3,9 @@
 /**
  * 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
+ * One agent-browser daemon and working profile exists per live session;
+ * durability belongs to the auth/profile layer, not this process wrapper.
+ * This module owns process spawning, environment
  * setup, and the JSON envelope — nothing else. Verb-level behavior lives in
  * engine.js.
  *

package/runtime/scripts/amalgm-mcp/browser/cookie-jar.js

@@ -0,0 +1,364 @@
+'use strict';
+
+/**
+ * Browser-neutral shared cookie jar.
+ *
+ * This is the source of truth. Electron, agent-browser, and future browser
+ * providers are adapters: they read snapshots, apply them locally, then send
+ * record-level mutations back. No adapter knows about another adapter.
+ *
+ * The jar intentionally rides the existing encrypted browser auth bundle so
+ * current installs migrate in place. Cookie values, record provenance, and
+ * deletion tombstones all remain inside the encrypted envelope; database
+ * rows and state events continue to contain metadata only.
+ */
+
+const {
+  getBrowserAuthBundle,
+  normalizeChromiumCookie,
+  readEncryptedStateBundle,
+  writeEncryptedStateBundle,
+} = require('./auth-bundles');
+const {
+  COOKIE_SOURCE_BUNDLE_ID,
+  DEFAULT_COOKIE_SOURCE_PROFILE_ID,
+} = require('./cookie-source');
+
+const COOKIE_JAR_SCHEMA_VERSION = 1;
+const MAX_MUTATIONS_PER_MERGE = 10_000;
+const MAX_TOMBSTONES = 4_096;
+const DEFAULT_EXCLUDED_HOST_SUFFIXES = [
+  'supabase.co',
+  'supabase.io',
+  'localhost',
+  '127.0.0.1',
+  'amalgm.ai',
+];
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function cleanSourceId(value) {
+  return String(value || 'unknown-adapter').trim().slice(0, 128) || 'unknown-adapter';
+}
+
+function normalizeHost(value) {
+  return String(value || '').trim().toLowerCase().replace(/^\.+/, '');
+}
+
+function normalizeExcludedHosts(values = []) {
+  const environment = String(process.env.AMALGM_BROWSER_COOKIE_EXCLUDE_HOSTS || '')
+    .split(',');
+  return Array.from(new Set([
+    ...DEFAULT_EXCLUDED_HOST_SUFFIXES,
+    ...environment,
+    ...(Array.isArray(values) ? values : []),
+  ].map(normalizeHost).filter(Boolean)));
+}
+
+function hostIsExcluded(rawHost, extraHosts = []) {
+  const host = normalizeHost(rawHost);
+  if (!host) return true;
+  return normalizeExcludedHosts(extraHosts)
+    .some((suffix) => host === suffix || host.endsWith(`.${suffix}`));
+}
+
+function stableValue(value) {
+  if (Array.isArray(value)) return value.map(stableValue);
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stableValue(value[key])]));
+}
+
+function partitionKeyFor(cookie = {}) {
+  if (cookie.partitionKey === undefined || cookie.partitionKey === null) return '';
+  return JSON.stringify(stableValue(cookie.partitionKey));
+}
+
+function normalizeJarCookie(cookie = {}) {
+  const normalized = normalizeChromiumCookie(cookie);
+  normalized.hostOnly = cookie.hostOnly === undefined
+    ? !String(normalized.domain || '').startsWith('.')
+    : Boolean(cookie.hostOnly);
+  return normalized;
+}
+
+function injectableCookie(cookie = {}) {
+  const { hostOnly, ...injectable } = normalizeJarCookie(cookie);
+  if (hostOnly) injectable.domain = normalizeHost(injectable.domain);
+  return injectable;
+}
+
+function cookieKey(cookie = {}) {
+  const normalized = normalizeJarCookie(cookie);
+  return [
+    normalizeHost(normalized.domain),
+    normalized.hostOnly ? 'host' : 'domain',
+    normalized.path || '/',
+    normalized.name,
+    partitionKeyFor(normalized),
+  ].join('\u0000');
+}
+
+function cookieFingerprint(cookie = {}) {
+  return JSON.stringify(stableValue(normalizeJarCookie(cookie)));
+}
+
+function validCookie(cookie = {}, extraHosts = []) {
+  return Boolean(
+    String(cookie.name || '')
+    && normalizeHost(cookie.domain)
+    && !hostIsExcluded(cookie.domain, extraHosts),
+  );
+}
+
+function isExpiredCookie(cookie = {}) {
+  return typeof cookie.expires === 'number'
+    && cookie.expires >= 0
+    && cookie.expires <= Date.now() / 1000;
+}
+
+function normalizeCookieList(cookies = [], extraHosts = []) {
+  const byKey = new Map();
+  for (const input of Array.isArray(cookies) ? cookies : []) {
+    const cookie = normalizeJarCookie(input);
+    if (!validCookie(cookie, extraHosts) || isExpiredCookie(cookie)) continue;
+    byKey.set(cookieKey(cookie), cookie);
+  }
+  return [...byKey.values()].sort((a, b) => cookieKey(a).localeCompare(cookieKey(b)));
+}
+
+function emptyInternalJar() {
+  return {
+    exists: false,
+    version: 0,
+    bundle: null,
+    records: new Map(),
+    tombstones: new Map(),
+    migratedFromLegacy: false,
+  };
+}
+
+function loadInternalCookieJar() {
+  const bundle = getBrowserAuthBundle(COOKIE_SOURCE_BUNDLE_ID);
+  if (!bundle?.blobPath) return emptyInternalJar();
+
+  const { payload } = readEncryptedStateBundle(COOKIE_SOURCE_BUNDLE_ID);
+  const stored = payload?.cookieJar;
+  const records = new Map();
+  const tombstones = new Map();
+
+  if (stored?.schemaVersion === COOKIE_JAR_SCHEMA_VERSION) {
+    for (const item of Array.isArray(stored.records) ? stored.records : []) {
+      const cookie = normalizeJarCookie(item?.cookie || {});
+      if (!validCookie(cookie)) continue;
+      const key = cookieKey(cookie);
+      records.set(key, {
+        key,
+        cookie,
+        revision: Number(item.revision) || 0,
+        sourceId: cleanSourceId(item.sourceId),
+        updatedAt: String(item.updatedAt || bundle.updatedAt || nowIso()),
+      });
+    }
+    for (const item of Array.isArray(stored.tombstones) ? stored.tombstones : []) {
+      const key = String(item?.key || '');
+      if (!key) continue;
+      tombstones.set(key, {
+        key,
+        revision: Number(item.revision) || 0,
+        sourceId: cleanSourceId(item.sourceId),
+        deletedAt: String(item.deletedAt || bundle.updatedAt || nowIso()),
+      });
+    }
+    return {
+      exists: true,
+      version: Math.max(1, Number(stored.version) || 1),
+      bundle,
+      records,
+      tombstones,
+      migratedFromLegacy: false,
+    };
+  }
+
+  // Migration: the previous implementation stored a whole Playwright state
+  // snapshot in this same encrypted bundle. Read it as revision 1; the first
+  // mutation rewrites it in the SDK format without exposing or dropping data.
+  const capturedAt = String(payload?.capturedAt || bundle.updatedAt || nowIso());
+  for (const cookie of normalizeCookieList(payload?.state?.cookies || payload?.cookies || [])) {
+    const key = cookieKey(cookie);
+    records.set(key, {
+      key,
+      cookie,
+      revision: 1,
+      sourceId: 'legacy-cookie-source',
+      updatedAt: capturedAt,
+    });
+  }
+  return {
+    exists: true,
+    version: 1,
+    bundle,
+    records,
+    tombstones,
+    migratedFromLegacy: true,
+  };
+}
+
+function publicSnapshot(jar) {
+  const records = [...jar.records.values()].sort((a, b) => a.key.localeCompare(b.key));
+  const tombstones = [...jar.tombstones.values()].sort((a, b) => a.key.localeCompare(b.key));
+  return {
+    schemaVersion: COOKIE_JAR_SCHEMA_VERSION,
+    exists: jar.exists,
+    version: jar.version,
+    versionToken: jar.exists
+      ? `${jar.version}:${jar.bundle?.blobSha256 || 'pending'}`
+      : '0:none',
+    cookies: records.map((record) => record.cookie),
+    tombstones: tombstones.map((item) => ({
+      key: item.key,
+      revision: item.revision,
+      deletedAt: item.deletedAt,
+    })),
+  };
+}
+
+function readCookieJar() {
+  return publicSnapshot(loadInternalCookieJar());
+}
+
+function pruneTombstones(tombstones) {
+  return new Map(
+    [...tombstones.values()]
+      .sort((a, b) => b.revision - a.revision || b.deletedAt.localeCompare(a.deletedAt))
+      .slice(0, MAX_TOMBSTONES)
+      .map((item) => [item.key, item]),
+  );
+}
+
+function persistCookieJar(jar) {
+  const records = [...jar.records.values()].sort((a, b) => a.key.localeCompare(b.key));
+  const tombstones = [...jar.tombstones.values()].sort((a, b) => a.key.localeCompare(b.key));
+  const bundle = writeEncryptedStateBundle({
+    id: COOKIE_SOURCE_BUNDLE_ID,
+    name: 'Browser cookie jar',
+    profileId: DEFAULT_COOKIE_SOURCE_PROFILE_ID,
+    state: { cookies: records.map((record) => injectableCookie(record.cookie)), origins: [] },
+    payloadExtensions: {
+      cookieJar: {
+        schemaVersion: COOKIE_JAR_SCHEMA_VERSION,
+        version: jar.version,
+        updatedAt: nowIso(),
+        records,
+        tombstones,
+      },
+    },
+  });
+  return { ...jar, exists: true, bundle, migratedFromLegacy: false };
+}
+
+function deleteKeyFor(input) {
+  if (typeof input === 'string') return input;
+  if (!input || typeof input !== 'object' || !validCookie(input)) return '';
+  return cookieKey(input);
+}
+
+function mergeCookieJar(input = {}) {
+  const sourceId = cleanSourceId(input.sourceId);
+  const extraHosts = Array.isArray(input.excludeHosts) ? input.excludeHosts : [];
+  const upserts = Array.isArray(input.upserts) ? input.upserts : [];
+  const deletes = Array.isArray(input.deletes) ? input.deletes : [];
+  if (upserts.length + deletes.length > MAX_MUTATIONS_PER_MERGE) {
+    throw new Error(`Cookie mutation batch exceeds ${MAX_MUTATIONS_PER_MERGE}`);
+  }
+
+  let jar = loadInternalCookieJar();
+  const nextRevision = jar.version + 1;
+  const changedAt = nowIso();
+  let changed = false;
+
+  for (const inputCookie of upserts) {
+    const cookie = normalizeJarCookie(inputCookie);
+    if (!validCookie(cookie, extraHosts)) continue;
+    const key = cookieKey(cookie);
+    if (isExpiredCookie(cookie)) {
+      if (jar.records.delete(key) || !jar.tombstones.has(key)) {
+        jar.tombstones.set(key, { key, revision: nextRevision, sourceId, deletedAt: changedAt });
+        changed = true;
+      }
+      continue;
+    }
+    const existing = jar.records.get(key);
+    if (!existing || cookieFingerprint(existing.cookie) !== cookieFingerprint(cookie)) {
+      jar.records.set(key, { key, cookie, revision: nextRevision, sourceId, updatedAt: changedAt });
+      changed = true;
+    }
+    if (jar.tombstones.delete(key)) changed = true;
+  }
+
+  for (const deletion of deletes) {
+    if (deletion && typeof deletion === 'object' && hostIsExcluded(deletion.domain, extraHosts)) continue;
+    const key = deleteKeyFor(deletion);
+    if (!key) continue;
+    const removed = jar.records.delete(key);
+    const existing = jar.tombstones.get(key);
+    if (removed || !existing) {
+      jar.tombstones.set(key, { key, revision: nextRevision, sourceId, deletedAt: changedAt });
+      changed = true;
+    }
+  }
+
+  if (!changed) return publicSnapshot(jar);
+  jar = {
+    ...jar,
+    exists: true,
+    version: nextRevision,
+    tombstones: pruneTombstones(jar.tombstones),
+  };
+  return publicSnapshot(persistCookieJar(jar));
+}
+
+function diffCookieSnapshots(before = [], after = [], options = {}) {
+  const beforeMap = new Map(normalizeCookieList(before, options.excludeHosts).map((cookie) => [cookieKey(cookie), cookie]));
+  const afterMap = new Map(normalizeCookieList(after, options.excludeHosts).map((cookie) => [cookieKey(cookie), cookie]));
+  const upserts = [];
+  const deletes = [];
+
+  for (const [key, cookie] of afterMap) {
+    const previous = beforeMap.get(key);
+    if (!previous || cookieFingerprint(previous) !== cookieFingerprint(cookie)) upserts.push(cookie);
+  }
+  for (const [key, cookie] of beforeMap) {
+    if (!afterMap.has(key)) deletes.push(cookie);
+  }
+  return { upserts, deletes };
+}
+
+function cookiesMissingFromJar(cookies = [], snapshot = readCookieJar(), options = {}) {
+  const live = new Set((snapshot.cookies || []).map(cookieKey));
+  const deleted = new Set((snapshot.tombstones || []).map((item) => item.key));
+  return normalizeCookieList(cookies, options.excludeHosts)
+    .filter((cookie) => {
+      const key = cookieKey(cookie);
+      return !live.has(key) && !deleted.has(key);
+    });
+}
+
+function cookieJarState(snapshot = readCookieJar()) {
+  return { cookies: (snapshot.cookies || []).map(injectableCookie), origins: [] };
+}
+
+module.exports = {
+  COOKIE_JAR_SCHEMA_VERSION,
+  DEFAULT_EXCLUDED_HOST_SUFFIXES,
+  cookieFingerprint,
+  cookieJarState,
+  cookieKey,
+  cookiesMissingFromJar,
+  diffCookieSnapshots,
+  hostIsExcluded,
+  mergeCookieJar,
+  normalizeCookieList,
+  readCookieJar,
+};