@voybio/ace-swarm 2.4.9 → 2.4.10

package/scripts/dev/test-preload.mjs

@@ -0,0 +1,153 @@
+// Test-only Node boundary. It is not an OS sandbox for arbitrary native code.
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import cp from 'node:child_process';
+import { syncBuiltinESMExports } from 'node:module';
+import { isAbsolute, join, relative, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+import { randomUUID } from 'node:crypto';
+
+const raw = Object.fromEntries(Object.entries(fs).filter(([, value]) => typeof value === 'function').map(([key, value]) => [key, value.bind(fs)]));
+const rawExecFileSync = cp.execFileSync.bind(cp);
+const rawRealpathNative = fs.realpathSync.native.bind(fs);
+const sessionFile = process.env.ACE_TEST_SESSION_FILE;
+if (!sessionFile) throw new Error('ACE test isolation required: missing session file');
+const session = JSON.parse(raw.readFileSync(sessionFile, 'utf8'));
+const lease = () => JSON.parse(raw.readFileSync(session.lease_file, 'utf8'));
+if (lease().status !== 'active' || lease().run_id !== session.run_id) throw new Error('ACE test isolation required: inactive session');
+if ((process.env.NODE_TEST_CONTEXT || process.env.ACE_TEST_PROBE === '1') && !process.env.ACE_TEST_WORKER_ROOT) {
+  const allocation = raw.mkdtempSync(join(session.fixtures_root, 'worker-'));
+  const workspace = join(allocation, 'workspace'); const temporary = join(allocation, 'tmp');
+  raw.mkdirSync(workspace); raw.mkdirSync(temporary);
+  process.env.ACE_TEST_WORKER_ROOT = workspace;
+  process.env.ACE_WORKSPACE_ROOT = workspace;
+  process.env.ACE_TEST_ALLOWED_ROOTS = JSON.stringify([allocation]);
+  process.env.TMPDIR = temporary; process.env.TMP = temporary; process.env.TEMP = temporary;
+}
+process.env.ACE_TEST_ISOLATION = '1';
+process.env.ACE_TEST_RUN_ID = session.run_id;
+process.env.ACE_TEST_LEASE_FILE = session.lease_file;
+process.env.ACE_TEST_SENTINEL_PATH = session.sentinel;
+
+function processFields(args) {
+  if (!Array.isArray(args) || args[0] !== '-p' || !/^\d+$/.test(args[1] ?? '')) return undefined;
+  const rest = args.slice(2).join(' ');
+  return rest === '-o lstart=' ? 'start' : rest === '-o stat=' ? 'stat' : rest === '-o lstart= -o stat=' ? 'both' : undefined;
+}
+function inspectProcess(args, opts = {}) {
+  const fields = processFields(args);
+  if (!session.process_info_broker || !fields) return rawExecFileSync('ps', args, opts);
+  const id = randomUUID(); const name = `${id}.json`; const request = join(session.process_info_requests, name); const response = join(session.process_info_responses, name);
+  raw.writeFileSync(`${request}.tmp`, JSON.stringify({ run_id: session.run_id, pid: Number(args[1]), fields })); raw.renameSync(`${request}.tmp`, request);
+  const end = Date.now() + (Number.isFinite(opts.timeout) && opts.timeout > 0 ? opts.timeout : 10000);
+  const wait = new Int32Array(new SharedArrayBuffer(4));
+  while (Date.now() < end) {
+    if (raw.existsSync(response)) {
+      const result = JSON.parse(raw.readFileSync(response, 'utf8')); raw.unlinkSync(response);
+      if (result.run_id !== session.run_id || result.pid !== Number(args[1])) throw new Error('Invalid owned process-info response');
+      if (!result.ok) throw Object.assign(new Error(result.stderr || 'OS process information unavailable'), { code: result.code, status: result.status, stdout: result.stdout, stderr: result.stderr });
+      return opts.encoding && opts.encoding !== 'buffer' ? result.stdout : Buffer.from(result.stdout);
+    }
+    Atomics.wait(wait, 0, 0, 5);
+  }
+  throw Object.assign(new Error('Owned process-info request timed out'), { code: 'ETIMEDOUT' });
+}
+
+// Every Node descendant inherits this import, including detached verification.
+const registration = join(session.registry_root, `${process.pid}.json`);
+let identity;
+try { identity = inspectProcess(['-p', String(process.pid), '-o', 'lstart='], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim().replace(/\s+/g, ' '); } catch { identity = null; }
+raw.writeFileSync(registration, JSON.stringify({ pid: process.pid, parent: process.ppid, identity, registered_at: Date.now() }));
+process.once('exit', () => { try { raw.unlinkSync(registration); } catch {} });
+
+if (process.env.ACE_TEST_WORKER_ROOT) {
+  const { captureTestWriteBoundary, currentTestWriteAnchors } = await import(new URL('../../dist/store/test-write-boundary.js', import.meta.url));
+  const check = path => {
+    if (typeof path === 'number') {
+      if (path === 1 || path === 2) return () => {};
+      const pinned = descriptors.get(path); if (!pinned) throw new Error('ace_test_write_boundary: untracked file descriptor'); pinned(); return pinned;
+    }
+    const pin = captureTestWriteBoundary(path instanceof URL ? fileURLToPath(path) : Buffer.isBuffer(path) ? path.toString() : path); pin(); return pin;
+  };
+  const descriptors = new Map();
+  const paths = { appendFile: [0], writeFile: [0], mkdir: [0], mkdtemp: [0], rm: [0], rmdir: [0], unlink: [0], rename: [0, 1], copyFile: [1], cp: [1], link: [0, 1], symlink: [1], chmod: [0], chown: [0], lchown: [0], lchmod: [0], truncate: [0], utimes: [0], lutimes: [0], createWriteStream: [0] };
+  for (const [name, indices] of Object.entries(paths)) {
+    for (const method of [name, `${name}Sync`]) if (typeof fs[method] === 'function') {
+      const original = fs[method].bind(fs);
+      fs[method] = (...args) => { indices.forEach(index => check(args[index])); return original(...args); };
+    }
+    if (typeof fsp[name] === 'function') {
+      const original = fsp[name].bind(fsp);
+      fsp[name] = async (...args) => { indices.forEach(index => check(args[index])); return original(...args); };
+    }
+  }
+  const writable = flags => typeof flags === 'number' ? Boolean(flags & (fs.constants.O_WRONLY | fs.constants.O_RDWR | fs.constants.O_CREAT | fs.constants.O_TRUNC | fs.constants.O_APPEND)) : /[wa+]/.test(flags ?? 'r');
+  const openSync = fs.openSync.bind(fs);
+  fs.openSync = (path, flags, ...rest) => { const pin = writable(flags) ? check(path) : undefined; const fd = openSync(path, flags, ...rest); if (pin) descriptors.set(fd, pin); return fd; };
+  const open = fs.open.bind(fs);
+  fs.open = (path, flags, ...rest) => {
+    const pin = writable(flags) ? check(path) : undefined; const callback = rest.pop();
+    return open(path, flags, ...rest, (error, fd) => { if (!error && pin) descriptors.set(fd, pin); callback(error, fd); });
+  };
+  const promiseOpen = fsp.open.bind(fsp);
+  fsp.open = async (path, flags, ...rest) => {
+    const pin = writable(flags) ? check(path) : undefined; const handle = await promiseOpen(path, flags, ...rest);
+    if (pin) {
+      descriptors.set(handle.fd, pin);
+      for (const key of ['write', 'writev', 'writeFile', 'appendFile', 'truncate', 'chmod', 'chown', 'utimes', 'createWriteStream']) if (typeof handle[key] === 'function') {
+        const operation = handle[key].bind(handle); handle[key] = (...args) => { pin(); return operation(...args); };
+      }
+    }
+    return handle;
+  };
+  for (const method of ['write', 'writeSync', 'writev', 'writevSync', 'ftruncate', 'ftruncateSync', 'fchmod', 'fchmodSync', 'fchown', 'fchownSync', 'futimes', 'futimesSync']) if (typeof fs[method] === 'function') {
+    const operation = fs[method].bind(fs); fs[method] = (fd, ...args) => { check(fd); return operation(fd, ...args); };
+  }
+  const inside = (path, base) => { const tail = relative(base, path); return tail !== '..' && !tail.startsWith(`..${sep}`) && !isAbsolute(tail); };
+  const inherited = Object.fromEntries(['ACE_TEST_ISOLATION', 'ACE_TEST_SESSION_FILE', 'ACE_TEST_RUN_ID', 'ACE_TEST_LEASE_FILE', 'ACE_TEST_ALLOWED_ROOTS', 'ACE_TEST_WORKER_ROOT', 'ACE_TEST_SENTINEL_PATH', 'NODE_OPTIONS'].map(key => [key, process.env[key]]));
+  function options(given = {}) {
+    // An explicit environment may intentionally omit credentials. Preserve that
+    // boundary and reattach only the isolation identity below.
+    const env = { ...(given.env ?? process.env) };
+    let requested;
+    try { requested = JSON.parse(env.ACE_TEST_ALLOWED_ROOTS); } catch {}
+    const parentRoots = JSON.parse(inherited.ACE_TEST_ALLOWED_ROOTS);
+    const narrow = Array.isArray(requested) && requested.length && requested.every(path => typeof path === 'string' && isAbsolute(path) && parentRoots.some(base => inside(rawRealpathNative(path), rawRealpathNative(base))));
+    const anchors = [...currentTestWriteAnchors()];
+    const workspace = env.ACE_WORKSPACE_ROOT;
+    if (workspace && raw.existsSync(workspace)) { const path = rawRealpathNative(workspace); const st = raw.statSync(path, { bigint: true }); anchors.push({ path, dev: String(st.dev), ino: String(st.ino) }); }
+    Object.assign(env, inherited);
+    if (narrow) env.ACE_TEST_ALLOWED_ROOTS = JSON.stringify(requested);
+    env.ACE_TEST_WRITE_ANCHORS = JSON.stringify(anchors);
+    return { ...given, env };
+  }
+  function registerOwned(child) {
+    if (!child?.pid) return child;
+    const file = join(session.registry_root, `${child.pid}.json`); let childIdentity;
+    try { childIdentity = inspectProcess(['-p', String(child.pid), '-o', 'lstart='], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim().replace(/\s+/g, ' '); } catch { childIdentity = null; }
+    raw.writeFileSync(file, JSON.stringify({ pid: child.pid, parent: process.pid, identity: childIdentity, registered_at: Date.now() }));
+    child.once('exit', () => { try { raw.unlinkSync(file); } catch {} }); return child;
+  }
+  for (const name of ['spawn', 'spawnSync', 'execFile', 'execFileSync', 'fork']) {
+    const original = cp[name].bind(cp);
+    cp[name] = (command, args, opts, callback) => {
+      if (!Array.isArray(args)) { callback = opts; opts = args; args = []; }
+      if (typeof opts === 'function') { callback = opts; opts = {}; }
+      if (name === 'execFileSync' && (command === 'ps' || command === '/bin/ps') && session.process_info_broker && processFields(args)) return inspectProcess(args, opts);
+      const child = callback ? original(command, args, options(opts), callback) : original(command, args, options(opts));
+      return name.endsWith('Sync') ? child : registerOwned(child);
+    };
+  }
+  for (const name of ['exec', 'execSync']) {
+    const original = cp[name].bind(cp);
+    cp[name] = (command, opts, callback) => { if (typeof opts === 'function') { callback = opts; opts = {}; } const child = callback ? original(command, options(opts), callback) : original(command, options(opts)); return name.endsWith('Sync') ? child : registerOwned(child); };
+  }
+  for (const name of ['exec', 'execFile']) cp[name][promisify.custom] = (...args) => {
+    let child;
+    const result = new Promise((resolvePromise, reject) => { child = cp[name](...args, (error, stdout, stderr) => error ? reject(Object.assign(error, { stdout, stderr })) : resolvePromise({ stdout, stderr })); });
+    result.child = child; return result;
+  };
+  syncBuiltinESMExports();
+  globalThis[Symbol.for('ace.test.preload')] = true;
+}

package/scripts/dev/test-source-inventory.mjs

@@ -0,0 +1,31 @@
+import { existsSync, lstatSync, readFileSync, readdirSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+
+const safe = name => typeof name === 'string' && name && !isAbsolute(name) && !name.split(/[\\/]/).includes('..') && !/^(?:agent-state|\.agents|\.git|node_modules)(?:[\\/]|$)/.test(name);
+
+/** An installed package has no Git checkout. Inventory only its declared files. */
+export function testSourceFiles(source) {
+  const manifest = join(source, '.ace-test-source-files.json');
+  if (existsSync(manifest)) return JSON.parse(readFileSync(manifest, 'utf8')).filter(safe);
+  if (existsSync(join(source, '.git'))) return execFileSync('git', ['ls-files', '-z', '--cached', '--others', '--exclude-standard'], { cwd: source, encoding: 'utf8' }).split('\0').filter(safe);
+  const pkg = JSON.parse(readFileSync(join(source, 'package.json'), 'utf8'));
+  const roots = ['package.json', 'package-lock.json', 'README.md', 'CHANGELOG.md', 'LICENSE', ...(pkg.files ?? [])].map(name => typeof name === 'string' ? name.split(/[*?[]/, 1)[0].replace(/[\\/]$/, '') : '').filter(safe);
+  const files = new Set();
+  function visit(name) {
+    if (!safe(name) || !existsSync(join(source, name))) return;
+    const stat = lstatSync(join(source, name));
+    if (stat.isSymbolicLink()) return;
+    if (stat.isDirectory()) for (const child of readdirSync(join(source, name))) visit(join(name, child));
+    else if (stat.isFile()) files.add(name);
+  }
+  roots.forEach(visit); return [...files].sort();
+}
+
+export function findTestDependencies(source) {
+  let cursor = resolve(source);
+  for (;;) {
+    const candidate = join(cursor, 'node_modules'); if (existsSync(candidate)) return candidate;
+    const parent = dirname(cursor); if (parent === cursor) throw new Error('Installed ACE dependencies are unavailable; use the package installation containing node_modules'); cursor = parent;
+  }
+}

package/docs/development.md

@@ -1,46 +0,0 @@
-# Development
-
-> Companion to the [README](../README.md).
-
-```bash
-cd ace-mcp-server
-npm install
-npm run build
-npm test
-npm run start
-```
-
-Run the Hermes live driver from a source checkout. The script is included in the npm package as of 2.4.6, but it imports the checkout/package `dist/` tree and is a diagnostic, not a supported production command. It exits nonzero if setup, protocol, or artifact checks fail.
-
-```bash
-npm run build
-# with a local llama.cpp or Ollama runtime running:
-ACE_WORKSPACE_ROOT=$PWD \
-  ACE_HERMES_ROOT=/path/to/hermes-agent \
-  HERMES_PYTHON=/path/to/hermes-python \
-  ACE_LIVE_PROVIDERS=llama.cpp \
-  ACE_LIVE_LLAMA_CPP_BASE_URL=http://127.0.0.1:8080/v1 \
-  ACE_LIVE_LLAMA_CPP_MODEL=gemma-3-4b-it \
-  ACE_LIVE_HERMES_MAX_TURNS=3 \
-  node scripts/dev/run_hermes_crispr_live.mjs
-```
-
-`ACE_LIVE_OUTPUT_ONLY=1` deliberately bypasses tool writing and is only for inspecting raw model output; it cannot satisfy the driver’s evidence-gated job check.
-
-## Key source files
-
-| File | Role |
-|---|---|
-| `src/index.ts` | Package entry point |
-| `src/cli.ts` | CLI command dispatch |
-| `src/server.ts` | MCP server setup and stdio transport |
-| `src/tools.ts` | Tool registration hub (delegates to domain modules) |
-| `src/hermes/session-manager.ts` | `HermesSubprocessExecutor` — Hermes subprocess lifecycle |
-| `src/hermes/bridge-protocol.ts` | Frame decoder for the Hermes bridge protocol |
-| `src/model-bridge.ts` | Model bridge interface and process orchestration |
-| `src/goal-engine.ts` | Goal engine — self-paced, evidence-gated objective loop |
-| `src/job-worker.ts` | In-process job worker for the scheduler execution loop |
-| `src/public-surface.ts` | Public surface audit and schema-bound entry map |
-| `src/store/ace-packed-store.ts` | ACEPACK binary store read/write |
-| `src/local-model-policy.ts` | Operator allow/block policy for local models |
-| `scripts/hermes_bridge_worker.py` | Packaged Python worker for the Hermes bridge |