amalgm 0.1.114 → 0.1.115

package/package.json

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

package/runtime/scripts/chat-core/auth.js

@@ -120,6 +120,25 @@ function runtimeHome({ amalgmDir, harness, agentConfigId, runtimeHomeLayout }) {
   );
 }
 
+function legacyRuntimeHomeSources({ amalgmDir, harness, runtimeHome }) {
+  const harnessHome = path.join(amalgmDir, 'cli-homes', safePathSegment(harness));
+  const canonical = path.resolve(runtimeHome || '');
+  const sources = [path.join(harnessHome, 'home')];
+  try {
+    for (const entry of fs.readdirSync(harnessHome, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name === 'agents' || entry.name === 'home') continue;
+      if (!/^(amalgm|provider|byok)-/.test(entry.name)) continue;
+      sources.push(path.join(harnessHome, entry.name));
+    }
+  } catch {
+    // The harness home is created lazily.
+  }
+  return [...new Set(sources
+    .map((source) => path.resolve(source))
+    .filter((source) => source && source !== canonical && !canonical.startsWith(`${source}${path.sep}`)))];
+}
+
 function providerAuthFingerprint(harness) {
   return fingerprint(providerAuthIdentity(harness));
 }
@@ -153,6 +172,7 @@ function authEnvelope({ harness, authMethod, sessionId, localBaseUrl, proxyToken
   } else if (method === 'provider_auth') {
     tokenFingerprint = providerAuthFingerprint(harness);
   }
+  const runtimeHomePath = runtimeHome({ amalgmDir, harness, agentConfigId, runtimeHomeLayout });
   return {
     method,
     baseUrl,
@@ -162,7 +182,8 @@ function authEnvelope({ harness, authMethod, sessionId, localBaseUrl, proxyToken
     forwardBaseUrl,
     tokenRef,
     tokenFingerprint,
-    runtimeHome: runtimeHome({ amalgmDir, harness, agentConfigId, runtimeHomeLayout }),
+    runtimeHome: runtimeHomePath,
+    runtimeHomeSources: legacyRuntimeHomeSources({ amalgmDir, harness, runtimeHome: runtimeHomePath }),
   };
 }
 
@@ -222,5 +243,6 @@ module.exports = {
   authEnvelope,
   coerceAuth,
   fingerprint,
+  legacyRuntimeHomeSources,
   runtimeEnv,
 };

package/runtime/scripts/chat-core/tests/auth.test.js

@@ -5,7 +5,8 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const test = require('node:test');
-const { authEnvelope, runtimeEnv } = require('../auth');
+const { authEnvelope, legacyRuntimeHomeSources, runtimeEnv } = require('../auth');
+const { matchRuntimeHome } = require('../tooling/runtime-home');
 
 test('codex uses one stable per-agent CLI home across auth methods', () => {
   const amalgmDir = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-auth-test-'));
@@ -139,3 +140,69 @@ test('provided CLI home path cannot move an agent off its canonical home', () =>
 
   assert.equal(envelope.runtimeHome, '/tmp/amalgm-test/cli-homes/codex/agents/codex/home');
 });
+
+test('per-agent auth envelope exposes legacy homes as match sources', () => {
+  const amalgmDir = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-home-sources-'));
+  try {
+    const harnessHome = path.join(amalgmDir, 'cli-homes', 'codex');
+    fs.mkdirSync(path.join(harnessHome, 'home'), { recursive: true });
+    fs.mkdirSync(path.join(harnessHome, 'provider-abc123'), { recursive: true });
+    fs.mkdirSync(path.join(harnessHome, 'amalgm-def456'), { recursive: true });
+    fs.mkdirSync(path.join(harnessHome, 'agents', 'codex', 'home'), { recursive: true });
+
+    const envelope = authEnvelope({
+      harness: 'codex',
+      authMethod: 'provider_auth',
+      sessionId: 'session-test',
+      amalgmDir,
+      agentConfigId: 'codex',
+    });
+
+    assert.equal(envelope.runtimeHome, path.join(harnessHome, 'agents', 'codex', 'home'));
+    assert.deepEqual(envelope.runtimeHomeSources.sort(), [
+      path.join(harnessHome, 'amalgm-def456'),
+      path.join(harnessHome, 'home'),
+      path.join(harnessHome, 'provider-abc123'),
+    ].sort());
+    assert.deepEqual(legacyRuntimeHomeSources({
+      amalgmDir,
+      harness: 'codex',
+      runtimeHome: envelope.runtimeHome,
+    }).sort(), envelope.runtimeHomeSources.sort());
+  } finally {
+    fs.rmSync(amalgmDir, { recursive: true, force: true });
+  }
+});
+
+test('runtime home matcher preserves agent-id home and imports missing legacy sessions', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-home-match-'));
+  try {
+    const target = path.join(root, 'cli-homes', 'codex', 'agents', 'codex', 'home');
+    const legacy = path.join(root, 'cli-homes', 'codex', 'home');
+    const provider = path.join(root, 'cli-homes', 'codex', 'provider-abc123');
+    const legacySession = path.join(legacy, 'sessions', '2026', '06', '15', 'rollout-old.jsonl');
+    const targetSession = path.join(target, 'sessions', '2026', '06', '15', 'rollout-new.jsonl');
+    const providerSession = path.join(provider, 'sessions', '2026', '06', '16', 'rollout-provider.jsonl');
+    const overlapping = path.join(legacy, 'config.toml');
+    const targetOverlapping = path.join(target, 'config.toml');
+    fs.mkdirSync(path.dirname(legacySession), { recursive: true });
+    fs.mkdirSync(path.dirname(targetSession), { recursive: true });
+    fs.mkdirSync(path.dirname(providerSession), { recursive: true });
+    fs.writeFileSync(legacySession, 'old session\n');
+    fs.writeFileSync(targetSession, 'new session\n');
+    fs.writeFileSync(providerSession, 'provider session\n');
+    fs.writeFileSync(overlapping, 'legacy config\n');
+    fs.writeFileSync(targetOverlapping, 'target config\n');
+
+    const summary = matchRuntimeHome(target, [legacy, provider]);
+
+    assert.equal(fs.readFileSync(path.join(target, 'sessions', '2026', '06', '15', 'rollout-old.jsonl'), 'utf8'), 'old session\n');
+    assert.equal(fs.readFileSync(targetSession, 'utf8'), 'new session\n');
+    assert.equal(fs.readFileSync(path.join(target, 'sessions', '2026', '06', '16', 'rollout-provider.jsonl'), 'utf8'), 'provider session\n');
+    assert.equal(fs.readFileSync(targetOverlapping, 'utf8'), 'target config\n');
+    assert.ok(summary.length >= 1);
+    assert.equal(matchRuntimeHome(target, [legacy, provider]).length, 0);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});

package/runtime/scripts/chat-core/tooling/runtime-home.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const fs = require('fs');
+const path = require('path');
 const { runtimeEnv } = require('../auth');
 const { syncNativeProviderAuth } = require('./native-config');
 
@@ -12,20 +13,93 @@ function managedRuntimeHome(contract) {
   return runtimeHome;
 }
 
+function isSubpath(parent, child) {
+  const relative = path.relative(parent, child);
+  return relative && !relative.startsWith('..') && !path.isAbsolute(relative);
+}
+
+function mergeMissingEntries(source, target, stats) {
+  const sourceStat = fs.lstatSync(source);
+  if (fs.existsSync(target)) {
+    if (!sourceStat.isDirectory() || !fs.lstatSync(target).isDirectory()) {
+      stats.skipped += 1;
+      return;
+    }
+    for (const entry of fs.readdirSync(source)) {
+      mergeMissingEntries(path.join(source, entry), path.join(target, entry), stats);
+    }
+    return;
+  }
+
+  if (sourceStat.isSymbolicLink()) {
+    fs.symlinkSync(fs.readlinkSync(source), target);
+    stats.copied += 1;
+    return;
+  }
+
+  if (sourceStat.isDirectory()) {
+    fs.mkdirSync(target, { recursive: true, mode: sourceStat.mode });
+    stats.dirs += 1;
+    for (const entry of fs.readdirSync(source)) {
+      mergeMissingEntries(path.join(source, entry), path.join(target, entry), stats);
+    }
+    return;
+  }
+
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  fs.copyFileSync(source, target);
+  try {
+    fs.chmodSync(target, sourceStat.mode);
+  } catch {
+    // Best effort; content preservation matters more than exact mode metadata.
+  }
+  stats.copied += 1;
+}
+
+function matchRuntimeHome(runtimeHome, sources = []) {
+  const target = path.resolve(runtimeHome);
+  fs.mkdirSync(target, { recursive: true });
+  const marker = path.join(target, '.amalgm-home-match.json');
+  if (fs.existsSync(marker) && process.env.AMALGM_FORCE_HOME_MATCH !== '1') return [];
+  const summaries = [];
+  const checked = [];
+  for (const rawSource of Array.isArray(sources) ? sources : []) {
+    if (typeof rawSource !== 'string' || !rawSource.trim()) continue;
+    const source = path.resolve(rawSource);
+    if (source === target || isSubpath(target, source) || isSubpath(source, target)) continue;
+    if (!fs.existsSync(source)) continue;
+    checked.push(source);
+    const stats = { source, copied: 0, dirs: 0, skipped: 0 };
+    mergeMissingEntries(source, target, stats);
+    if (stats.copied || stats.dirs) summaries.push(stats);
+  }
+  if (checked.length) {
+    fs.writeFileSync(marker, `${JSON.stringify({
+      matched_at: new Date().toISOString(),
+      checked,
+      sources: summaries,
+    }, null, 2)}\n`);
+  }
+  return summaries;
+}
+
 function prepareHarnessRuntime(contract, baseEnv = process.env) {
   const runtimeHome = managedRuntimeHome(contract);
   fs.mkdirSync(runtimeHome, { recursive: true });
+  const homeMatch = matchRuntimeHome(runtimeHome, contract?.auth?.runtimeHomeSources);
   const syncInfo = contract?.authMethod === 'provider_auth'
     ? syncNativeProviderAuth(contract)
     : null;
   return {
     runtimeHome,
+    homeMatch,
     syncInfo,
     env: runtimeEnv(contract, baseEnv),
   };
 }
 
 module.exports = {
+  matchRuntimeHome,
   managedRuntimeHome,
   prepareHarnessRuntime,
 };