amalgm 0.1.238 → 0.1.240

package/runtime/scripts/amalgm-mcp/workspace/native-file-transaction/BUILD.md

@@ -0,0 +1,31 @@
+# Native workspace file transaction
+
+This helper is the only code allowed to observe or cross an ordered file or
+Git-metadata mutation. JavaScript cannot express
+`openat`/`renameat`/`linkat`, so path confinement at that layer has an
+unavoidable check/use race. The helper opens each parent directory with
+`O_NOFOLLOW` and performs every observation and mutation relative to those
+held descriptors.
+
+`main.go` owns the transaction and crash ordering. `move_*.go` consumes a
+prepared target without replacing a concurrent destination; its disappearance
+is the crossing receipt. `writers_*.go` proves that an extracted source inode
+has no pre-existing writer before it can be retired. The checked-in binaries
+are required because managed runtimes do not include a Go compiler.
+`manifest.json` binds them to the exact source bytes.
+
+The `git-lock` backend prepares index or HEAD bytes inside the linked
+worktree's private Git directory, hard-links them to Git's canonical lock, and
+renames that lock over the destination. The retained hard link identifies the
+crossing even after later Git activity changes the destination or creates a
+new lock.
+
+Rebuild and verify both release platforms:
+
+```sh
+node build.mjs
+node verify.mjs
+```
+
+The ordinary JavaScript transition tests execute the host binary against real
+Git repositories, crashes, open descriptors, and directory-swap races.

package/runtime/scripts/amalgm-mcp/workspace/native-file-transaction/build.mjs

@@ -0,0 +1,72 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const root = path.dirname(fileURLToPath(import.meta.url));
+const sources = fs.readdirSync(root)
+  .filter((name) => name.endsWith('.go') || name === 'go.mod' || name === 'go.sum')
+  .sort();
+const platforms = [
+  { directory: 'darwin-arm64', goos: 'darwin', goarch: 'arm64', cgo: '1' },
+  { directory: 'linux-x64', goos: 'linux', goarch: 'amd64', cgo: '0' },
+];
+
+function digestFiles(names) {
+  const hash = crypto.createHash('sha256');
+  for (const name of names) {
+    hash.update(name);
+    hash.update('\0');
+    hash.update(fs.readFileSync(path.join(root, name)));
+    hash.update('\0');
+  }
+  return hash.digest('hex');
+}
+
+function run(command, args, env = {}) {
+  const result = spawnSync(command, args, {
+    cwd: root,
+    env: { ...process.env, ...env },
+    stdio: 'inherit',
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    throw new Error(`${command} exited ${result.status}`);
+  }
+}
+
+run('go', ['test', './...']);
+const binaries = {};
+for (const platform of platforms) {
+  const directory = path.join(root, 'bin', platform.directory);
+  fs.mkdirSync(directory, { recursive: true });
+  const output = path.join(directory, 'amalgm-file-transaction');
+  run('go', [
+    'build',
+    '-trimpath',
+    '-ldflags=-s -w',
+    '-o',
+    output,
+    '.',
+  ], {
+    GOOS: platform.goos,
+    GOARCH: platform.goarch,
+    CGO_ENABLED: platform.cgo,
+  });
+  fs.chmodSync(output, 0o755);
+  binaries[platform.directory] = crypto
+    .createHash('sha256')
+    .update(fs.readFileSync(output))
+    .digest('hex');
+}
+
+fs.writeFileSync(
+  path.join(root, 'manifest.json'),
+  `${JSON.stringify({
+    contract: 'amalgm-native-file-transaction-build@1',
+    sourceSha256: digestFiles(sources),
+    sources,
+    binaries,
+  }, null, 2)}\n`,
+);

package/runtime/scripts/amalgm-mcp/workspace/native-file-transaction/client.js

@@ -0,0 +1,165 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+function executable() {
+  const platform = `${process.platform}-${process.arch}`;
+  if (!['darwin-arm64', 'linux-x64'].includes(platform)) {
+    throw new Error(`native file transactions do not support ${platform}`);
+  }
+  const file = path.join(
+    __dirname,
+    'bin',
+    platform,
+    'amalgm-file-transaction',
+  );
+  if (!fs.existsSync(file)) {
+    throw new Error(`native file transaction helper is missing for ${platform}`);
+  }
+  return file;
+}
+
+function run(transaction, action, content = null, testHooks = {}) {
+  const target = transaction.target == null
+    ? null
+    : {
+      ...transaction.target,
+      ...(content === null ? {} : { content: content.toString('base64') }),
+    };
+  let stdout;
+  try {
+    stdout = execFileSync(executable(), [], {
+      input: JSON.stringify({
+        action,
+        ...(transaction.backend ? { backend: transaction.backend } : {}),
+        ...(transaction.pid ? { pid: transaction.pid } : {}),
+        ...(transaction.root ? {
+          root: transaction.root,
+          rootDev: transaction.rootDev,
+          rootIno: transaction.rootIno,
+          ...(transaction.source ? { source: transaction.source } : {}),
+          ...(transaction.sourceIdentity
+            ? { sourceIdentity: transaction.sourceIdentity }
+            : {}),
+          ...(transaction.sourceParentIdentity
+            ? { sourceParentIdentity: transaction.sourceParentIdentity }
+            : {}),
+          ...(transaction.targetParentIdentity
+            ? { targetParentIdentity: transaction.targetParentIdentity }
+            : {}),
+          path: transaction.path,
+          id: transaction.id,
+          operation: transaction.operation,
+          expected: transaction.expected,
+          target,
+        } : {}),
+        ...(testHooks.pauseAfterParentOpen > 0
+          ? { testPauseAfterParentOpenMillis: testHooks.pauseAfterParentOpen }
+          : {}),
+        ...(testHooks.pauseAfterExtraction > 0
+          ? { testPauseAfterExtractionMillis: testHooks.pauseAfterExtraction }
+          : {}),
+        ...(testHooks.pauseBeforeInstall > 0
+          ? { testPauseBeforeInstallMillis: testHooks.pauseBeforeInstall }
+          : {}),
+        ...(testHooks.pauseAfterTreeMove > 0
+          ? { testPauseAfterTreeMoveMillis: testHooks.pauseAfterTreeMove }
+          : {}),
+        ...(testHooks.crashAfterExtraction === true
+          ? { testCrashAfterExtraction: true }
+          : {}),
+        ...(testHooks.crashBeforeInstall === true
+          ? { testCrashBeforeInstall: true }
+          : {}),
+        ...(testHooks.crashAfterInstall === true
+          ? { testCrashAfterInstall: true }
+          : {}),
+        ...(testHooks.crashAfterTreeMove === true
+          ? { testCrashAfterTreeMove: true }
+          : {}),
+      }),
+      encoding: 'utf8',
+      maxBuffer: action === 'observe' ? 32 * 1024 * 1024 : 1024 * 1024,
+      timeout: transaction.backend === 'process-identity' ? 5_000 : 30_000,
+    });
+  } catch (error) {
+    const detail = String(error.stdout || error.stderr || error.message).trim();
+    throw new Error(`native file transaction failed: ${detail}`);
+  }
+  let result;
+  try {
+    result = JSON.parse(stdout);
+  } catch (error) {
+    throw new Error(`native file transaction returned invalid output: ${error.message}`);
+  }
+  if (![
+    'applied',
+    'changed',
+    'pending',
+    'crossed',
+    'not-crossed',
+    'released',
+    'guarded',
+    'identified',
+    'exited',
+    'observed',
+  ].includes(result?.status)) {
+    throw new Error(`native file transaction returned ${result?.status || 'no status'}`);
+  }
+  return result;
+}
+
+function observe(transaction, testHooks = {}) {
+  return run({
+    root: transaction.root,
+    rootDev: transaction.rootDev,
+    rootIno: transaction.rootIno,
+    path: transaction.path,
+    target: null,
+  }, 'observe', null, testHooks);
+}
+
+function processLifetime(pid) {
+  try {
+    const result = run({
+      backend: 'process-identity',
+      pid,
+      target: null,
+    }, 'identity');
+    if (result.status === 'exited') return { live: false, identity: null };
+    if (result.status === 'identified' && typeof result.identity === 'string') {
+      return { live: true, identity: result.identity };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function moveNoReplace(transaction, testHooks = {}) {
+  return run({
+    backend: 'tree-rename',
+    root: transaction.root,
+    rootDev: transaction.rootDev,
+    rootIno: transaction.rootIno,
+    source: transaction.source,
+    sourceIdentity: transaction.sourceIdentity,
+    sourceParentIdentity: transaction.sourceParentIdentity,
+    targetParentIdentity: transaction.targetParentIdentity,
+    path: transaction.path,
+    id: transaction.id,
+    operation: transaction.operation,
+    expected: null,
+    target: null,
+  }, 'move', null, testHooks);
+}
+
+module.exports = {
+  executable,
+  moveNoReplace,
+  observe,
+  processLifetime,
+  run,
+};

package/runtime/scripts/amalgm-mcp/workspace/native-file-transaction/go.mod

@@ -0,0 +1,5 @@
+module amalgm.ai/native-file-transaction
+
+go 1.25.0
+
+require golang.org/x/sys v0.42.0

package/runtime/scripts/amalgm-mcp/workspace/native-file-transaction/go.sum

@@ -0,0 +1,2 @@
+golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
+golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=