evolcore 0.0.19 → 0.0.21

package/dist/core/permission/sandbox-runtime.js

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import { resolveCommandPath } from '../../utils/cross-platform.js';
-import { getExistingHClassMaskTargets, getExistingLClassReadOnlyTargets, isSameOrDescendant, } from '../protected-paths.js';
+import { getExistingHClassMaskTargets, getExistingLClassReadOnlyTargets, isSameOrDescendant, } from './protected-paths.js';
 import { resolveRoot } from '../../paths.js';
 let cachedBubblewrapPath;
 let sandboxInitializationCircuit;
@@ -9,6 +9,7 @@ let sandboxCircuitNoticeAt = 0;
 export const SANDBOX_INITIALIZATION_FAILED = 'sandbox_initialization_failed';
 export const SANDBOX_INITIALIZATION_COOLDOWN_MS = 5 * 60 * 1000;
 export const SANDBOX_CIRCUIT_NOTICE_INTERVAL_MS = 60 * 1000;
+const SANDBOX_DIAGNOSTIC_TARGET_LIMIT = 256;
 /** Open a process-wide fail-closed circuit after a confirmed host bootstrap failure. */
 export function recordSandboxInitializationFailure(error, stderr = [], now = Date.now()) {
     const detail = createSandboxInitializationError(error, stderr).message.slice(0, 512);
@@ -218,6 +219,163 @@ function pushMaskedDirectory(args, candidate) {
         return;
     args.push('--tmpfs', candidate);
 }
+function decodeMountInfoPath(value) {
+    // mountinfo escapes whitespace, backslashes, and newlines as octal bytes.
+    return value.replace(/\\([0-7]{3})/g, (_match, octal) => {
+        const code = Number.parseInt(octal, 8);
+        return Number.isNaN(code) ? _match : String.fromCharCode(code);
+    });
+}
+function readMountInfoForPaths(paths, priorityPaths = []) {
+    if (process.platform !== 'linux' || paths.length === 0)
+        return [];
+    let contents;
+    try {
+        contents = fs.readFileSync('/proc/self/mountinfo', 'utf8');
+    }
+    catch (error) {
+        return [`mountinfo unavailable: ${error instanceof Error ? error.message : String(error)}`];
+    }
+    const wanted = paths.map(candidate => path.resolve(candidate));
+    const priority = priorityPaths.map(candidate => path.resolve(candidate));
+    const matches = [];
+    for (const [order, line] of contents.split(/\r?\n/).filter(Boolean).entries()) {
+        const mountPointField = line.split(' - ', 1)[0]?.split(' ')[4];
+        if (!mountPointField)
+            continue;
+        const mountPoint = path.resolve(decodeMountInfoPath(mountPointField));
+        if (!wanted.some(target => isSameOrDescendant(target, mountPoint)
+            || isSameOrDescendant(mountPoint, target)))
+            continue;
+        const isPriority = priority.some(target => target === mountPoint);
+        const isPriorityAncestor = !isPriority && priority.some(target => isSameOrDescendant(target, mountPoint));
+        matches.push({ line, score: isPriority ? 0 : isPriorityAncestor ? 1 : 2, order });
+    }
+    return matches
+        .sort((left, right) => left.score - right.score || left.order - right.order)
+        .slice(0, 32)
+        .map(match => match.line);
+}
+function snapshotSandboxPath(candidate) {
+    const resolved = path.resolve(candidate);
+    try {
+        const stat = fs.lstatSync(resolved);
+        let kind = 'other';
+        if (stat.isFile())
+            kind = 'file';
+        else if (stat.isDirectory())
+            kind = 'directory';
+        else if (stat.isSymbolicLink())
+            kind = 'symlink';
+        let realpath;
+        try {
+            realpath = fs.realpathSync(resolved);
+        }
+        catch { }
+        return {
+            path: resolved,
+            exists: true,
+            kind,
+            dev: stat.dev,
+            ino: stat.ino,
+            mode: stat.mode & 0o7777,
+            uid: stat.uid,
+            gid: stat.gid,
+            nlink: stat.nlink,
+            size: stat.size,
+            mtimeMs: stat.mtimeMs,
+            ctimeMs: stat.ctimeMs,
+            ...(realpath ? { realpath } : {}),
+        };
+    }
+    catch (error) {
+        const code = error.code;
+        return {
+            path: resolved,
+            exists: false,
+            ...(code ? { error: code } : { error: error instanceof Error ? error.message : String(error) }),
+        };
+    }
+}
+/** Capture the host-side state used to construct an H-class guard. */
+export function collectSandboxGuardDiagnostics(root = resolveRoot()) {
+    const absoluteRoot = path.resolve(root);
+    const candidates = [
+        path.join(absoluteRoot, 'data', 'causation-aun.json'),
+        path.join(absoluteRoot, 'data', 'causation-aun.json_'),
+        path.join(absoluteRoot, 'data', 'causation-aun.json__'),
+    ];
+    let targets = [];
+    try {
+        targets = getExistingHClassMaskTargets(absoluteRoot).map(target => target.path);
+    }
+    catch { }
+    // Keep the causation file and its atomic-write sidecars first. The full H
+    // target list can grow with the number of agents and must not turn every
+    // launch into an unbounded log payload.
+    const paths = [...new Set([...candidates, ...targets])];
+    const selectedPaths = paths.slice(0, SANDBOX_DIAGNOSTIC_TARGET_LIMIT);
+    return {
+        root: absoluteRoot,
+        targetCount: paths.length,
+        targetsTruncated: paths.length > selectedPaths.length,
+        targets: selectedPaths.map(snapshotSandboxPath),
+        mountInfo: readMountInfoForPaths(selectedPaths, candidates),
+    };
+}
+/** Reduce path and mount diagnostics to metadata suitable for INFO logs. */
+export function summarizeSandboxGuardDiagnostics(diagnostics) {
+    let existingTargetCount = 0;
+    let missingTargetCount = 0;
+    const targetKindCounts = {};
+    for (const target of diagnostics.targets) {
+        if (!target.exists) {
+            missingTargetCount += 1;
+            continue;
+        }
+        existingTargetCount += 1;
+        const kind = target.kind ?? 'unknown';
+        targetKindCounts[kind] = (targetKindCounts[kind] ?? 0) + 1;
+    }
+    return {
+        root: diagnostics.root,
+        targetCount: diagnostics.targetCount,
+        targetsTruncated: diagnostics.targetsTruncated,
+        existingTargetCount,
+        missingTargetCount,
+        targetKindCounts,
+        mountInfoCount: diagnostics.mountInfo.length,
+    };
+}
+/** Keep the exact mount portion of a bwrap argv while summarizing child argv. */
+export function summarizeBubblewrapArgs(args) {
+    const separator = args.indexOf('--');
+    const mountArgs = [...args.slice(0, separator >= 0 ? separator : args.length)];
+    const child = separator >= 0 ? args.slice(separator + 1) : [];
+    return {
+        mountArgs,
+        ...(child[0] ? { childCommand: child[0] } : {}),
+        childArgCount: Math.max(0, child.length - 1),
+    };
+}
+/** Keep only argument counts and option names for routine INFO logs. */
+export function summarizeBubblewrapArgsForLog(args) {
+    const separator = args.indexOf('--');
+    const mountArgs = args.slice(0, separator >= 0 ? separator : args.length);
+    const child = separator >= 0 ? args.slice(separator + 1) : [];
+    const mountOptionCounts = {};
+    for (const arg of mountArgs) {
+        if (!arg.startsWith('--'))
+            continue;
+        mountOptionCounts[arg] = (mountOptionCounts[arg] ?? 0) + 1;
+    }
+    return {
+        mountArgCount: mountArgs.length,
+        mountOptionCounts,
+        ...(child[0] ? { childCommand: child[0] } : {}),
+        childArgCount: Math.max(0, child.length - 1),
+    };
+}
 function appendRuntimeBackedEtcFiles(args) {
     if (process.platform !== 'linux' || !fs.existsSync('/run'))
         return;
@@ -285,6 +443,48 @@ function appendLClassReadOnlyBinds(args, root) {
         args.push('--ro-bind', target.path, target.path);
     }
 }
+export function ensureCodexManagedMountpoint(systemConfigDirectory = '/etc/codex', effectiveUid = typeof process.getuid === 'function' ? process.getuid() : undefined) {
+    let systemConfigStat;
+    try {
+        systemConfigStat = fs.lstatSync(systemConfigDirectory);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw new Error(`Codex managed requirements mountpoint is unavailable: ${systemConfigDirectory} `
+                + `could not be inspected (${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
+    if (!systemConfigStat && process.platform === 'linux' && effectiveUid === 0) {
+        let created = false;
+        try {
+            fs.mkdirSync(systemConfigDirectory, { mode: 0o755 });
+            created = true;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST') {
+                throw new Error(`Codex managed requirements mountpoint is unavailable: ${systemConfigDirectory} `
+                    + `could not be created by the root daemon (${error instanceof Error ? error.message : String(error)})`);
+            }
+        }
+        if (created)
+            fs.chmodSync(systemConfigDirectory, 0o755);
+        try {
+            systemConfigStat = fs.lstatSync(systemConfigDirectory);
+        }
+        catch (error) {
+            throw new Error(`Codex managed requirements mountpoint is unavailable: ${systemConfigDirectory} `
+                + `could not be verified after creation (${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
+    if (!systemConfigStat) {
+        throw new Error(`Codex managed requirements mountpoint is unavailable: ${systemConfigDirectory} `
+            + 'must be created as a real directory during installation; run: sudo install -d -m 0755 /etc/codex');
+    }
+    if (!systemConfigStat.isDirectory() || systemConfigStat.isSymbolicLink()) {
+        throw new Error(`Codex managed requirements mountpoint is unsafe: ${systemConfigDirectory} `
+            + 'must be a real directory');
+    }
+}
 export function buildHClassGuardCommand(executable, executableArgs, root = resolveRoot(), options = {}) {
     const bubblewrapPath = resolveBubblewrapPath();
     if (!bubblewrapPath)
@@ -306,18 +506,10 @@ export function buildHClassGuardCommand(executable, executableArgs, root = resol
         }
         const managedDirectory = path.dirname(requirements);
         const systemConfigDirectory = '/etc/codex';
-        let systemConfigStat;
-        try {
-            systemConfigStat = fs.lstatSync(systemConfigDirectory);
-        }
-        catch {
-            throw new Error(`Codex managed requirements mountpoint is unavailable: ${systemConfigDirectory} `
-                + 'must be created as a real directory during installation');
-        }
-        if (!systemConfigStat.isDirectory() || systemConfigStat.isSymbolicLink()) {
-            throw new Error(`Codex managed requirements mountpoint is unsafe: ${systemConfigDirectory} `
-                + 'must be a real directory');
-        }
+        // The npm lifecycle and public installer provision this path. Root-owned
+        // legacy daemons may repair only the missing-directory case; unsafe path
+        // types and unprivileged processes remain fail-closed.
+        ensureCodexManagedMountpoint(systemConfigDirectory);
         // Keep the copied hook immutable even when a session uses bypass mode.
         args.push('--ro-bind', managedDirectory, managedDirectory);
         // The guard starts from a writable root so owner-bypass workspaces keep