amalgm 0.1.134 → 0.1.135

package/lib/state-migration.js

@@ -10,6 +10,7 @@ const {
 } = require('./paths');
 
 const MARKER_FILE = path.join(AMALGM_DIR, '.user-state-migrated.json');
+const CLI_HOMES_BACKFILL_ID = 'cli-homes-merge-v1';
 
 const DATA_FILES = [
   'amalgm.db',
@@ -75,34 +76,100 @@ function copyDirIfMissing(source, target) {
   return true;
 }
 
+function copyEntryIfMissing(source, target) {
+  if (!fs.existsSync(source) || fs.existsSync(target)) return false;
+  fs.mkdirSync(path.dirname(target), { recursive: true, mode: 0o700 });
+  fs.cpSync(source, target, {
+    recursive: fs.statSync(source).isDirectory(),
+    force: false,
+    errorOnExist: true,
+    dereference: false,
+  });
+  return true;
+}
+
+function mergeDirContents(source, target) {
+  if (!fs.existsSync(source) || !fs.statSync(source).isDirectory()) return false;
+  fs.mkdirSync(target, { recursive: true, mode: 0o700 });
+
+  let changed = false;
+  for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
+    const sourcePath = path.join(source, entry.name);
+    const targetPath = path.join(target, entry.name);
+
+    if (copyEntryIfMissing(sourcePath, targetPath)) {
+      changed = true;
+      continue;
+    }
+
+    if (entry.isDirectory() && fs.existsSync(targetPath) && fs.statSync(targetPath).isDirectory()) {
+      if (mergeDirContents(sourcePath, targetPath)) changed = true;
+    }
+  }
+
+  return changed;
+}
+
+function markerCopiedEntries(marker) {
+  return Array.isArray(marker?.copied)
+    ? marker.copied.filter((entry) => typeof entry === 'string' && entry)
+    : [];
+}
+
+function markerCompletedMigrations(marker) {
+  return new Set(
+    Array.isArray(marker?.completed_migrations)
+      ? marker.completed_migrations.filter((entry) => typeof entry === 'string' && entry)
+      : [],
+  );
+}
+
 function migrateLegacyUserState() {
   if (path.resolve(AMALGM_DIR) === path.resolve(AMALGM_HOME)) return { migrated: false, reason: 'legacy-root' };
   if (path.resolve(AMALGM_DIR).startsWith(path.resolve(os.tmpdir()))) return { migrated: false, reason: 'temp-dir' };
-  if (readJson(MARKER_FILE, null)) return { migrated: false, reason: 'already-migrated' };
+
+  const marker = readJson(MARKER_FILE, null);
+  const hadMarker = Boolean(marker);
+  const completedMigrations = markerCompletedMigrations(marker);
+  const needsCliHomesBackfill = !completedMigrations.has(CLI_HOMES_BACKFILL_ID);
 
   fs.mkdirSync(AMALGM_DIR, { recursive: true, mode: 0o700 });
 
   const copied = [];
-  for (const fileName of DATA_FILES) {
-    const source = path.join(AMALGM_HOME, fileName);
-    const target = path.join(AMALGM_DIR, fileName);
-    if (copyFileIfUseful(source, target)) copied.push(fileName);
+  if (!hadMarker) {
+    for (const fileName of DATA_FILES) {
+      const source = path.join(AMALGM_HOME, fileName);
+      const target = path.join(AMALGM_DIR, fileName);
+      if (copyFileIfUseful(source, target)) copied.push(fileName);
+    }
+
+    for (const dirName of DATA_DIRS) {
+      const source = path.join(AMALGM_HOME, dirName);
+      const target = path.join(AMALGM_DIR, dirName);
+      if (copyDirIfMissing(source, target)) copied.push(`${dirName}/`);
+    }
   }
 
-  for (const dirName of DATA_DIRS) {
-    const source = path.join(AMALGM_HOME, dirName);
-    const target = path.join(AMALGM_DIR, dirName);
-    if (copyDirIfMissing(source, target)) copied.push(`${dirName}/`);
+  if (needsCliHomesBackfill) {
+    const cliHomesSource = path.join(AMALGM_HOME, 'cli-homes');
+    const cliHomesTarget = path.join(AMALGM_DIR, 'cli-homes');
+    if (mergeDirContents(cliHomesSource, cliHomesTarget)) copied.push('cli-homes/');
+    completedMigrations.add(CLI_HOMES_BACKFILL_ID);
   }
 
-  writeJson(MARKER_FILE, {
-    migrated_at: new Date().toISOString(),
-    source: AMALGM_HOME,
-    target: AMALGM_DIR,
-    copied,
-  });
+  if (!hadMarker || copied.length > 0 || needsCliHomesBackfill) {
+    writeJson(MARKER_FILE, {
+      migrated_at: marker?.migrated_at || new Date().toISOString(),
+      source: AMALGM_HOME,
+      target: AMALGM_DIR,
+      copied: [...new Set([...markerCopiedEntries(marker), ...copied])],
+      completed_migrations: Array.from(completedMigrations).sort(),
+    });
+  }
 
-  return { migrated: copied.length > 0, copied };
+  if (copied.length > 0) return { migrated: true, copied };
+  if (hadMarker) return { migrated: false, reason: 'already-migrated' };
+  return { migrated: false, copied: [] };
 }
 
 module.exports = {

package/package.json

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

package/runtime/scripts/amalgm-mcp/config.js

@@ -12,6 +12,7 @@ const os = require('os');
 
 const PORT = parseInt(process.env.AMALGM_MCP_PORT || '8083', 10);
 const MCP_PROTOCOL_VERSION = '2024-11-05';
+const CLI_HOMES_BACKFILL_ID = 'cli-homes-merge-v1';
 
 const AMALGM_DIR = process.env.AMALGM_DIR || path.join(os.homedir(), '.amalgm');
 const AMALGM_HOME = process.env.AMALGM_HOME || path.join(os.homedir(), '.amalgm');
@@ -112,25 +113,108 @@ function copyIfUseful(source, target) {
   fs.copyFileSync(source, target);
 }
 
+function copyEntryIfMissing(source, target) {
+  if (!fs.existsSync(source) || fs.existsSync(target)) return false;
+  fs.mkdirSync(path.dirname(target), { recursive: true, mode: 0o700 });
+  fs.cpSync(source, target, {
+    recursive: fs.statSync(source).isDirectory(),
+    force: false,
+    errorOnExist: true,
+    dereference: false,
+  });
+  return true;
+}
+
+function mergeDirContents(source, target) {
+  if (!fs.existsSync(source) || !fs.statSync(source).isDirectory()) return false;
+  fs.mkdirSync(target, { recursive: true, mode: 0o700 });
+
+  let changed = false;
+  for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
+    const sourcePath = path.join(source, entry.name);
+    const targetPath = path.join(target, entry.name);
+
+    if (copyEntryIfMissing(sourcePath, targetPath)) {
+      changed = true;
+      continue;
+    }
+
+    if (entry.isDirectory() && fs.existsSync(targetPath) && fs.statSync(targetPath).isDirectory()) {
+      if (mergeDirContents(sourcePath, targetPath)) changed = true;
+    }
+  }
+
+  return changed;
+}
+
+function readJson(file, fallback = null) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function markerCopiedEntries(marker) {
+  return Array.isArray(marker?.copied)
+    ? marker.copied.filter((entry) => typeof entry === 'string' && entry)
+    : [];
+}
+
+function markerCompletedMigrations(marker) {
+  return new Set(
+    Array.isArray(marker?.completed_migrations)
+      ? marker.completed_migrations.filter((entry) => typeof entry === 'string' && entry)
+      : [],
+  );
+}
+
 function migrateLegacyUserState() {
   if (path.resolve(AMALGM_DIR) === path.resolve(AMALGM_HOME)) return;
   if (path.resolve(AMALGM_DIR).startsWith(path.resolve(os.tmpdir()))) return;
   const marker = path.join(AMALGM_DIR, '.runtime-legacy-state-migrated.json');
-  if (fs.existsSync(marker)) return;
+  const markerData = readJson(marker, null);
+  const hadMarker = Boolean(markerData);
+  const completedMigrations = markerCompletedMigrations(markerData);
+  const needsCliHomesBackfill = !completedMigrations.has(CLI_HOMES_BACKFILL_ID);
   fs.mkdirSync(AMALGM_DIR, { recursive: true, mode: 0o700 });
-  for (const fileName of [
-    'amalgm.db',
-    'apps.json',
-    'artifacts.json',
-    'agents.json',
-    'tasks.json',
-    'event-triggers.json',
-    'workflows.json',
-    'mcp-connections.json',
-  ]) {
-    copyIfUseful(path.join(AMALGM_HOME, fileName), path.join(AMALGM_DIR, fileName));
+
+  const copied = [];
+  if (!hadMarker) {
+    for (const fileName of [
+      'amalgm.db',
+      'apps.json',
+      'artifacts.json',
+      'agents.json',
+      'tasks.json',
+      'event-triggers.json',
+      'workflows.json',
+      'mcp-connections.json',
+    ]) {
+      const source = path.join(AMALGM_HOME, fileName);
+      const target = path.join(AMALGM_DIR, fileName);
+      const targetExists = fs.existsSync(target);
+      copyIfUseful(source, target);
+      if (!targetExists && fs.existsSync(target)) copied.push(fileName);
+    }
+  }
+
+  if (needsCliHomesBackfill) {
+    const cliHomesSource = path.join(AMALGM_HOME, 'cli-homes');
+    const cliHomesTarget = path.join(AMALGM_DIR, 'cli-homes');
+    if (mergeDirContents(cliHomesSource, cliHomesTarget)) copied.push('cli-homes/');
+    completedMigrations.add(CLI_HOMES_BACKFILL_ID);
+  }
+
+  if (!hadMarker || copied.length > 0 || needsCliHomesBackfill) {
+    fs.writeFileSync(marker, `${JSON.stringify({
+      migrated_at: markerData?.migrated_at || new Date().toISOString(),
+      source: AMALGM_HOME,
+      target: AMALGM_DIR,
+      copied: [...new Set([...markerCopiedEntries(markerData), ...copied])],
+      completed_migrations: Array.from(completedMigrations).sort(),
+    }, null, 2)}\n`);
   }
-  fs.writeFileSync(marker, `${JSON.stringify({ migrated_at: new Date().toISOString(), source: AMALGM_HOME }, null, 2)}\n`);
 }
 
 migrateLegacyUserState();

package/runtime/scripts/amalgm-mcp/tests/config-migration.test.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const ORIGINAL_ENV = { ...process.env };
+const SCRIPT_DIR = path.resolve(__dirname, '..');
+const TEST_TMP_DIR = path.join(__dirname, '.tmp');
+
+function resetEnv() {
+  for (const key of Object.keys(process.env)) {
+    if (key.startsWith('AMALGM_') || key === 'HOME') delete process.env[key];
+  }
+  Object.assign(process.env, ORIGINAL_ENV);
+}
+
+function clearScriptModules() {
+  for (const key of Object.keys(require.cache)) {
+    if (key.startsWith(SCRIPT_DIR)) delete require.cache[key];
+  }
+}
+
+function loadConfig(root, scope = 'user-a') {
+  resetEnv();
+  const home = path.join(root, '.amalgm');
+  const userDir = path.join(home, 'users', scope);
+  process.env.HOME = root;
+  process.env.AMALGM_HOME = home;
+  process.env.AMALGM_DIR = userDir;
+  clearScriptModules();
+  return require('../config');
+}
+
+function readJson(file) {
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+test.after(() => {
+  resetEnv();
+  clearScriptModules();
+});
+
+test('runtime config backfills legacy cli homes after the runtime marker already exists', () => {
+  fs.mkdirSync(TEST_TMP_DIR, { recursive: true });
+  const root = fs.mkdtempSync(path.join(TEST_TMP_DIR, 'amalgm-runtime-config-'));
+  try {
+    const home = path.join(root, '.amalgm');
+    const userDir = path.join(home, 'users', 'user-a');
+    const legacyRoot = path.join(home, 'cli-homes', 'claude_code', 'home');
+    const targetRoot = path.join(userDir, 'cli-homes', 'claude_code', 'home');
+    const markerPath = path.join(userDir, '.runtime-legacy-state-migrated.json');
+
+    const legacySession = path.join(legacyRoot, 'sessions', '2026', '06', '15', 'rollout-old.jsonl');
+    const targetSession = path.join(targetRoot, 'sessions', '2026', '06', '15', 'rollout-new.jsonl');
+    const legacySettings = path.join(legacyRoot, 'settings.json');
+    const targetSettings = path.join(targetRoot, 'settings.json');
+
+    fs.mkdirSync(path.dirname(legacySession), { recursive: true });
+    fs.mkdirSync(path.dirname(targetSession), { recursive: true });
+    fs.mkdirSync(path.dirname(markerPath), { recursive: true });
+    fs.writeFileSync(legacySession, 'old session\n');
+    fs.writeFileSync(targetSession, 'new session\n');
+    fs.writeFileSync(legacySettings, '{"source":"legacy"}\n');
+    fs.writeFileSync(targetSettings, '{"source":"target"}\n');
+    fs.writeFileSync(markerPath, `${JSON.stringify({
+      migrated_at: '2026-05-26T02:00:41.477Z',
+      source: home,
+    }, null, 2)}\n`);
+
+    const config = loadConfig(root);
+
+    assert.equal(config.AMALGM_DIR, userDir);
+    assert.equal(
+      fs.readFileSync(path.join(targetRoot, 'sessions', '2026', '06', '15', 'rollout-old.jsonl'), 'utf8'),
+      'old session\n',
+    );
+    assert.equal(fs.readFileSync(targetSession, 'utf8'), 'new session\n');
+    assert.equal(fs.readFileSync(targetSettings, 'utf8'), '{"source":"target"}\n');
+
+    const marker = readJson(markerPath);
+    assert.ok(marker.copied.includes('cli-homes/'));
+    assert.ok(marker.completed_migrations.includes('cli-homes-merge-v1'));
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});

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

@@ -109,9 +109,8 @@ function providerAuthIdentity(harness) {
   return `${harness || 'provider'}:provider-default`;
 }
 
-function runtimeHome({ amalgmDir, harness, agentConfigId, runtimeHomeLayout }) {
+function runtimeHome({ amalgmDir, harness, agentConfigId }) {
   const harnessHome = path.join(amalgmDir, 'cli-homes', safePathSegment(harness));
-  if (runtimeHomeLayout === 'legacy') return path.join(harnessHome, 'home');
   return path.join(
     harnessHome,
     'agents',
@@ -172,7 +171,7 @@ function authEnvelope({ harness, authMethod, sessionId, localBaseUrl, proxyToken
   } else if (method === 'provider_auth') {
     tokenFingerprint = providerAuthFingerprint(harness);
   }
-  const runtimeHomePath = runtimeHome({ amalgmDir, harness, agentConfigId, runtimeHomeLayout });
+  const runtimeHomePath = runtimeHome({ amalgmDir, harness, agentConfigId });
   return {
     method,
     baseUrl,

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

@@ -141,6 +141,19 @@ 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('legacy runtime-home requests still resolve to the canonical per-agent home', () => {
+  const envelope = authEnvelope({
+    harness: 'codex',
+    authMethod: 'provider_auth',
+    sessionId: 'session-test',
+    amalgmDir: '/tmp/amalgm-test',
+    agentConfigId: 'legacy-agent',
+    runtimeHomeLayout: 'legacy',
+  });
+
+  assert.equal(envelope.runtimeHome, '/tmp/amalgm-test/cli-homes/codex/agents/legacy-agent/home');
+});
+
 test('per-agent auth envelope exposes legacy homes as match sources', () => {
   const amalgmDir = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-home-sources-'));
   try {

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

@@ -57,7 +57,7 @@ function agentConfig(instructions) {
   return {
     version: 1,
     agentId: 'codex',
-    runtimeHomeLayout: 'legacy',
+    runtimeHomeLayout: 'per-agent',
     instructions,
     skills: [],
     loadout: { toolIds: [] },