amalgm 0.1.158 → 0.1.159

package/runtime/scripts/amalgm-mcp/workspace/git.js

@@ -0,0 +1,286 @@
+'use strict';
+
+/**
+ * Read-only git facts.
+ *
+ * The one place the workspace layer talks to git. Rules:
+ * - Queries only. A call here never mutates a repo — GIT_OPTIONAL_LOCKS=0
+ *   keeps even `status` from refreshing the index on disk.
+ * - Observation never executes repo-configured programs, and repo config
+ *   never reshapes what is observed. GIT_CONFIG_* below outranks any
+ *   repo/user/system setting for exactly those keys: core.fsmonitor is a
+ *   command git would otherwise run during `status`, and
+ *   status.showUntrackedFiles could hide untracked files from the count.
+ * - No shell, pinned cwd, no prompts, C locale.
+ * - Failure is an answer. "Not a repo" and "bare" are classification
+ *   results the caller matches on; anything unexpected throws GitError
+ *   carrying the full command and stderr.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+
+const execFileAsync = promisify(execFile);
+
+const GIT_ENV = {
+  GIT_OPTIONAL_LOCKS: '0',
+  GIT_TERMINAL_PROMPT: '0',
+  LC_ALL: 'C',
+  GIT_CONFIG_COUNT: '2',
+  GIT_CONFIG_KEY_0: 'core.fsmonitor',
+  GIT_CONFIG_VALUE_0: 'false',
+  GIT_CONFIG_KEY_1: 'status.showUntrackedFiles',
+  GIT_CONFIG_VALUE_1: 'normal',
+};
+
+class GitError extends Error {
+  constructor(args, cwd, exitCode, stderr) {
+    super(`git ${args.join(' ')} in ${cwd} exited ${exitCode}: ${stderr.trim()}`);
+    this.name = 'GitError';
+    this.args = args;
+    this.cwd = cwd;
+    this.exitCode = exitCode;
+    this.stderr = stderr;
+  }
+}
+
+async function git(args, cwd, { okCodes = [0] } = {}) {
+  try {
+    const { stdout } = await execFileAsync('git', args, {
+      cwd,
+      env: { ...process.env, ...GIT_ENV },
+      timeout: 15_000,
+      maxBuffer: 32 * 1024 * 1024,
+    });
+    return { stdout, exitCode: 0 };
+  } catch (error) {
+    const exitCode = typeof error.code === 'number' ? error.code : 1;
+    if (okCodes.includes(exitCode)) {
+      return { stdout: error.stdout ?? '', exitCode };
+    }
+    throw new GitError(args, cwd, exitCode, String(error.stderr ?? error.message));
+  }
+}
+
+const NOT_A_REPO_RE = /not a git repository/i;
+
+/**
+ * What is this directory, in git's own eyes?
+ *
+ * Returns one of:
+ *   { kind: 'not-a-repo', path }
+ *   { kind: 'bare',       path }
+ *   { kind: 'worktree',   path, toplevel, gitDir, commonDir,
+ *     linked: boolean, superproject: string | null }
+ *
+ * `path` is always the realpath of the input. `linked` means a linked
+ * worktree (`git worktree add`); a non-empty `superproject` means the
+ * toplevel is a submodule of that superproject.
+ */
+async function classifyDirectory(dirPath) {
+  const realPath = await fs.promises.realpath(dirPath);
+
+  let probe;
+  try {
+    probe = await git(['-C', realPath, 'rev-parse', '--is-inside-work-tree', '--is-bare-repository'], realPath);
+  } catch (error) {
+    if (error instanceof GitError && NOT_A_REPO_RE.test(error.stderr)) {
+      return { kind: 'not-a-repo', path: realPath };
+    }
+    throw error;
+  }
+  const [insideWorkTree, bare] = probe.stdout.trim().split('\n');
+  if (bare === 'true') return { kind: 'bare', path: realPath };
+  if (insideWorkTree !== 'true') {
+    // Inside a .git directory itself; the containing repo owns this path.
+    return { kind: 'not-a-repo', path: realPath };
+  }
+
+  const { stdout } = await git(
+    ['-C', realPath, 'rev-parse', '--show-toplevel', '--absolute-git-dir', '--git-common-dir'],
+    realPath,
+  );
+  const [toplevel, gitDir, commonDirRaw] = stdout.trim().split('\n');
+  const commonDir = path.resolve(realPath, commonDirRaw); // --git-common-dir prints relative to the cwd
+
+  const superprojectOut = await git(['-C', realPath, 'rev-parse', '--show-superproject-working-tree'], realPath);
+  const superproject = superprojectOut.stdout.trim() || null;
+
+  return {
+    kind: 'worktree',
+    path: realPath,
+    toplevel,
+    gitDir,
+    commonDir,
+    linked: gitDir !== commonDir && !superproject,
+    superproject,
+  };
+}
+
+/**
+ * All worktrees of the repo that owns `worktreeRoot`, from
+ * `git worktree list --porcelain`. Bare placeholder entries are dropped —
+ * they have no working files to card. Prunable entries (registered but
+ * gone from disk) are reported as git states them; callers decide.
+ */
+async function listWorktrees(worktreeRoot) {
+  const { stdout } = await git(['-C', worktreeRoot, 'worktree', 'list', '--porcelain'], worktreeRoot);
+  const worktrees = [];
+  let current = null;
+  for (const line of stdout.split('\n')) {
+    if (line.startsWith('worktree ')) {
+      current = {
+        path: line.slice('worktree '.length),
+        bare: false,
+        detached: false,
+        branch: null,
+        head: null,
+        prunable: false,
+        locked: false,
+      };
+      worktrees.push(current);
+    } else if (line === 'bare') {
+      current.bare = true;
+    } else if (line === 'detached') {
+      current.detached = true;
+    } else if (line === 'prunable' || line.startsWith('prunable ')) {
+      current.prunable = true;
+    } else if (line === 'locked' || line.startsWith('locked ')) {
+      current.locked = true;
+    } else if (line.startsWith('HEAD ')) {
+      current.head = line.slice('HEAD '.length);
+    } else if (line.startsWith('branch ')) {
+      current.branch = line.slice('branch '.length).replace(/^refs\/heads\//, '');
+    }
+  }
+  return worktrees.filter((worktree) => !worktree.bare);
+}
+
+/**
+ * HEAD position and working-tree cleanliness in one `git status
+ * --porcelain=v2 -z --branch` call.
+ *
+ * head.oid and head.branch are null for an unborn branch and a detached
+ * HEAD respectively. ahead/behind are 0 whenever there is no upstream.
+ *
+ * Dirty counts are git status entries, exactly as git reports them: an
+ * untracked directory of many files is one entry, and a file that is
+ * staged and then edited again counts once as staged and once as
+ * unstaged. Counts answer "is there uncommitted work, roughly how much" —
+ * they are not a file census.
+ */
+async function headAndDirty(worktreeRoot) {
+  const { stdout } = await git(['-C', worktreeRoot, 'status', '--porcelain=v2', '-z', '--branch'], worktreeRoot);
+
+  const head = { branch: null, oid: null, detached: false, upstream: null, ahead: 0, behind: 0 };
+  const dirty = { staged: 0, unstaged: 0, untracked: 0, conflicted: 0, submodulesChanged: 0 };
+
+  const tokens = stdout.split('\0');
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.startsWith('# branch.oid ')) {
+      const oid = token.slice('# branch.oid '.length);
+      head.oid = oid === '(initial)' ? null : oid;
+    } else if (token.startsWith('# branch.head ')) {
+      const branch = token.slice('# branch.head '.length);
+      head.detached = branch === '(detached)';
+      head.branch = head.detached ? null : branch;
+    } else if (token.startsWith('# branch.upstream ')) {
+      head.upstream = token.slice('# branch.upstream '.length);
+    } else if (token.startsWith('# branch.ab ')) {
+      const [ahead, behind] = token.slice('# branch.ab '.length).split(' ');
+      head.ahead = Number(ahead.slice(1));
+      head.behind = Number(behind.slice(1));
+    } else if (token.startsWith('1 ') || token.startsWith('2 ')) {
+      const [, xy, sub] = token.split(' ');
+      if (xy[0] !== '.') dirty.staged += 1;
+      if (xy[1] !== '.') dirty.unstaged += 1;
+      if (sub[0] === 'S') dirty.submodulesChanged += 1;
+      if (token.startsWith('2 ')) i += 1; // rename records carry origPath in the next token
+    } else if (token.startsWith('u ')) {
+      dirty.conflicted += 1;
+    } else if (token.startsWith('? ')) {
+      dirty.untracked += 1;
+    }
+  }
+  return { head, dirty };
+}
+
+/** HEAD's commit right now, or null on an unborn branch. The coherence probe. */
+async function headOid(worktreeRoot) {
+  const result = await git(['-C', worktreeRoot, 'rev-parse', '--verify', '--quiet', 'HEAD'], worktreeRoot, {
+    okCodes: [0, 1],
+  });
+  return result.exitCode === 0 ? result.stdout.trim() : null;
+}
+
+const OPERATION_MARKERS = [
+  ['rebase-merge', 'rebase'],
+  ['rebase-apply', 'rebase'],
+  ['MERGE_HEAD', 'merge'],
+  ['CHERRY_PICK_HEAD', 'cherry-pick'],
+  ['REVERT_HEAD', 'revert'],
+  ['BISECT_LOG', 'bisect'],
+];
+
+/** Which multi-step git operation is mid-flight, if any. */
+async function operationState(worktreeRoot) {
+  const markers = OPERATION_MARKERS.map(([marker]) => marker);
+  const { stdout } = await git(
+    ['-C', worktreeRoot, 'rev-parse', ...markers.flatMap((marker) => ['--git-path', marker])],
+    worktreeRoot,
+  );
+  const resolved = stdout.trim().split('\n');
+  for (let i = 0; i < OPERATION_MARKERS.length; i++) {
+    if (fs.existsSync(path.resolve(worktreeRoot, resolved[i]))) return OPERATION_MARKERS[i][1];
+  }
+  return 'none';
+}
+
+/** The configured origin URL, or null when the repo has no origin. */
+async function originUrl(worktreeRoot) {
+  const result = await git(['-C', worktreeRoot, 'config', '--get', 'remote.origin.url'], worktreeRoot, {
+    okCodes: [0, 1],
+  });
+  return result.exitCode === 0 ? result.stdout.trim() : null;
+}
+
+/**
+ * The repo's root commit — the lexically first parentless commit, a stable
+ * identity for "same history" across clones. Only call on a born HEAD.
+ */
+async function rootCommit(worktreeRoot) {
+  const { stdout } = await git(['-C', worktreeRoot, 'rev-list', '--max-parents=0', 'HEAD'], worktreeRoot);
+  return stdout.trim().split('\n').sort()[0];
+}
+
+/**
+ * Does git own this file? A file is git-owned when the worktree around it
+ * tracks it (`ls-files --error-unmatch`). Untracked files inside a repo
+ * and files outside any repo have no git owner.
+ * Returns { toplevel } for a git-owned file, null otherwise.
+ */
+async function gitOwnerOf(filePath) {
+  const classified = await classifyDirectory(path.dirname(filePath));
+  if (classified.kind !== 'worktree') return null;
+  const tracked = await git(
+    ['ls-files', '--error-unmatch', '--', path.basename(filePath)],
+    path.dirname(filePath),
+    { okCodes: [0, 1] },
+  );
+  return tracked.exitCode === 0 ? { toplevel: classified.toplevel } : null;
+}
+
+module.exports = {
+  GitError,
+  classifyDirectory,
+  gitOwnerOf,
+  headAndDirty,
+  headOid,
+  listWorktrees,
+  operationState,
+  originUrl,
+  rootCommit,
+};

package/runtime/scripts/amalgm-mcp/workspace/identity.js

@@ -0,0 +1,88 @@
+'use strict';
+
+/**
+ * Who observes, and which checkout is observed.
+ *
+ * machineId is the enrolled computer identity this runtime runs as — the
+ * same id the platform knows this machine by. replicaId is minted once
+ * per checkout and keyed by the checkout's own git directory, the one
+ * path git itself dedicates to exactly that checkout: two worktrees of a
+ * repo are two replicas, and a moved checkout is a new replica. Ids live
+ * only in our database; nothing is ever written into a repo.
+ */
+
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { AMALGM_COMPUTER_ID, AMALGM_DIR } = require('../config');
+const { cachedStatement, openLocalDb } = require('../state/db');
+
+let resolvedMachineId = null;
+let resolvedUserId;
+
+/**
+ * The identity other machines know this one by: the container/computer id
+ * from the environment, the enrolled computer record, or — on a machine
+ * that was never enrolled — a visibly local hostname identity.
+ */
+function machineId() {
+  if (resolvedMachineId) return resolvedMachineId;
+  if (AMALGM_COMPUTER_ID) {
+    resolvedMachineId = AMALGM_COMPUTER_ID;
+    return resolvedMachineId;
+  }
+  try {
+    const record = JSON.parse(fs.readFileSync(path.join(AMALGM_DIR, 'computer.json'), 'utf8'));
+    if (record?.computer_id) {
+      resolvedMachineId = String(record.computer_id);
+      return resolvedMachineId;
+    }
+  } catch {
+    // Not enrolled; fall through to the visibly-local identity.
+  }
+  resolvedMachineId = `unenrolled:${os.hostname()}`;
+  return resolvedMachineId;
+}
+
+/**
+ * The account this machine is enrolled to, or null on a machine that was
+ * never enrolled. Cloud-facing features key on this; without it they
+ * simply do not start.
+ */
+function userId() {
+  if (resolvedUserId !== undefined) return resolvedUserId;
+  try {
+    const record = JSON.parse(fs.readFileSync(path.join(AMALGM_DIR, 'computer.json'), 'utf8'));
+    resolvedUserId = record?.user_id ? String(record.user_id) : null;
+  } catch {
+    resolvedUserId = null;
+  }
+  return resolvedUserId;
+}
+
+/**
+ * The replica record for a checkout, minted on first sight.
+ *
+ * rootCommit is cached here the first time the repo's history has one —
+ * it is the repo's permanent identity anchor, so it is computed once per
+ * replica, never re-walked on refresh.
+ */
+function replicaForGitDir(gitDir) {
+  const db = openLocalDb();
+  const existing = cachedStatement(db, 'SELECT * FROM repo_replicas WHERE git_dir = ?').get(gitDir);
+  if (existing) return { replicaId: existing.replica_id, rootCommit: existing.root_commit };
+  const replicaId = `rpl_${crypto.randomBytes(9).toString('base64url')}`;
+  cachedStatement(db, `
+    INSERT INTO repo_replicas (git_dir, replica_id, root_commit, created_at)
+    VALUES (?, ?, NULL, ?)
+  `).run(gitDir, replicaId, new Date().toISOString());
+  return { replicaId, rootCommit: null };
+}
+
+function cacheRootCommit(gitDir, rootCommitOid) {
+  cachedStatement(openLocalDb(), 'UPDATE repo_replicas SET root_commit = ? WHERE git_dir = ?')
+    .run(rootCommitOid, gitDir);
+}
+
+module.exports = { cacheRootCommit, machineId, replicaForGitDir, userId };

package/runtime/scripts/amalgm-mcp/workspace/rest.js

@@ -14,6 +14,9 @@ const {
   renameWorkspace,
   upsertWorkspace,
 } = require('./store');
+const { listRepoCards, refreshRepoCards, repoCardServiceStats } = require('./cards');
+const { machineId } = require('./identity');
+const { readWall, wallStats } = require('./wall');
 
 const execFileAsync = promisify(execFile);
 const MAX_BUFFER = 10 * 1024 * 1024;
@@ -625,6 +628,63 @@ async function handleWorktreeDelete(body, sendJson) {
   sendJson(200, { success: true });
 }
 
+function handleRepoCards(sendJson) {
+  try {
+    sendJson(200, { cards: listRepoCards() });
+  } catch (error) {
+    sendJson(500, { error: error instanceof Error ? error.message : 'Failed to list repo cards' });
+  }
+}
+
+async function handleRepoCardsRefresh(sendJson) {
+  try {
+    sendJson(200, await refreshRepoCards());
+  } catch (error) {
+    sendJson(500, { error: error instanceof Error ? error.message : 'Failed to refresh repo cards' });
+  }
+}
+
+function handleWorkspaceSyncStats(sendJson) {
+  try {
+    const cards = listRepoCards();
+    const health = { healthy: 0, missing: 0, broken: 0, inaccessible: 0 };
+    for (const card of cards) health[card.health] = (health[card.health] || 0) + 1;
+    sendJson(200, {
+      machine: machineId(),
+      cards: { total: cards.length, ...health },
+      service: repoCardServiceStats(),
+      wall: wallStats(),
+    });
+  } catch (error) {
+    sendJson(500, { error: error instanceof Error ? error.message : 'Failed to read sync stats' });
+  }
+}
+
+/**
+ * The whole wall: this machine's cards straight from the live store, every
+ * peer's cards as last published. One call answers "what code does each of
+ * my machines have right now".
+ */
+function handleWorkspaceMachines(sendJson) {
+  try {
+    const self = machineId();
+    const machines = [
+      { machine: self, self: true, publishedAt: null, cards: listRepoCards() },
+      ...readWall()
+        .filter((entry) => entry.machine !== self)
+        .map((entry) => ({
+          machine: entry.machine,
+          self: false,
+          publishedAt: entry.publishedAt,
+          cards: entry.cards,
+        })),
+    ];
+    sendJson(200, { self, machines });
+  } catch (error) {
+    sendJson(500, { error: error instanceof Error ? error.message : 'Failed to read the machine wall' });
+  }
+}
+
 module.exports = {
   getWorkspaceRoot,
   handleProjects,
@@ -639,4 +699,8 @@ module.exports = {
   handleWorktreeList,
   handleWorktreeCreate,
   handleWorktreeDelete,
+  handleRepoCards,
+  handleRepoCardsRefresh,
+  handleWorkspaceMachines,
+  handleWorkspaceSyncStats,
 };