@fitlab-ai/agent-infra 0.9.3 → 0.9.5

package/dist/lib/sandbox/control/server.js

@@ -0,0 +1,144 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getProcessStartTime } from '../../server/process-state.js';
+import { createTask } from '../../task/create-service.js';
+import { assertGitWorktreeBinding } from '../../git/worktree-identity.js';
+import { bindSandboxControlTask, validateSandboxControlRequest } from './protocol.js';
+function readManifest(manifestPath) {
+    const stat = fs.lstatSync(manifestPath);
+    if (!stat.isFile() || stat.isSymbolicLink())
+        throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    if (manifest.version !== 2) {
+        throw new Error('SANDBOX_CONTROL_MANIFEST_VERSION_INVALID: expected version 2; recreate the sandbox');
+    }
+    if (typeof manifest.repoRoot !== 'string'
+        || typeof manifest.worktreeRoot !== 'string'
+        || typeof manifest.channelDir !== 'string'
+        || typeof manifest.token !== 'string')
+        throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
+    if (path.resolve(manifest.channelDir) !== path.join(path.dirname(path.resolve(manifestPath)), 'channel')) {
+        throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
+    }
+    return manifest;
+}
+function assertRealDirectory(directory, parent) {
+    const stat = fs.lstatSync(directory);
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+        throw new Error('SANDBOX_CONTROL_CHANNEL_INVALID');
+    if (parent && path.dirname(fs.realpathSync.native(directory)) !== fs.realpathSync.native(parent)) {
+        throw new Error('SANDBOX_CONTROL_CHANNEL_INVALID');
+    }
+}
+function writeResponse(directory, response) {
+    const temporary = path.join(directory, `.${response.id}.tmp`);
+    fs.writeFileSync(temporary, `${JSON.stringify(response)}\n`, { mode: 0o600, flag: 'wx' });
+    fs.renameSync(temporary, path.join(directory, `${response.id}.json`));
+}
+export function sandboxControlSafeEnv(env = process.env) {
+    return Object.fromEntries(Object.entries(env).filter(([key]) => !key.toUpperCase().startsWith('AGENT_INFRA_CONTROL_')));
+}
+function consumeRequest(directory, id) {
+    try {
+        fs.writeFileSync(path.join(directory, id), '', { flag: 'wx', mode: 0o600 });
+    }
+    catch (error) {
+        if (error.code === 'EEXIST') {
+            throw new Error('SANDBOX_CONTROL_REQUEST_REPLAYED');
+        }
+        throw error;
+    }
+}
+export function serveSandboxControl(manifestPath, signal = new AbortController().signal) {
+    const manifest = readManifest(manifestPath);
+    assertGitWorktreeBinding(manifest.repoRoot, manifest.worktreeRoot, manifest.branch);
+    const brokerPath = path.join(path.dirname(manifestPath), 'broker.json');
+    const startTime = getProcessStartTime(process.pid);
+    if (!startTime)
+        throw new Error('SANDBOX_CONTROL_BROKER_IDENTITY_UNAVAILABLE');
+    fs.writeFileSync(brokerPath, `${JSON.stringify({
+        version: 1,
+        pid: process.pid,
+        startTime,
+        token: manifest.token
+    })}\n`, { mode: 0o600, flag: 'wx' });
+    const requestsDir = path.join(manifest.channelDir, 'requests');
+    const responsesDir = path.join(manifest.channelDir, 'responses');
+    const consumedDir = path.join(path.dirname(manifestPath), 'consumed');
+    assertRealDirectory(manifest.channelDir);
+    fs.mkdirSync(requestsDir, { recursive: true, mode: 0o700 });
+    fs.mkdirSync(responsesDir, { recursive: true, mode: 0o700 });
+    fs.mkdirSync(consumedDir, { recursive: true, mode: 0o700 });
+    assertRealDirectory(requestsDir, manifest.channelDir);
+    assertRealDirectory(responsesDir, manifest.channelDir);
+    assertRealDirectory(consumedDir, path.dirname(manifestPath));
+    while (!signal.aborted) {
+        const current = readManifest(manifestPath);
+        if (current.token !== manifest.token)
+            return;
+        assertGitWorktreeBinding(current.repoRoot, current.worktreeRoot, current.branch);
+        assertRealDirectory(requestsDir, manifest.channelDir);
+        assertRealDirectory(responsesDir, manifest.channelDir);
+        for (const name of fs.readdirSync(requestsDir).sort()) {
+            if (!/^[a-f0-9-]{16,64}\.json$/.test(name))
+                continue;
+            const requestPath = path.join(requestsDir, name);
+            let id = name.slice(0, -5);
+            let response;
+            try {
+                const stat = fs.lstatSync(requestPath);
+                if (!stat.isFile() || stat.isSymbolicLink())
+                    throw new Error('SANDBOX_CONTROL_REQUEST_INVALID');
+                const request = validateSandboxControlRequest(JSON.parse(fs.readFileSync(requestPath, 'utf8')), manifest);
+                id = request.id;
+                consumeRequest(consumedDir, id);
+                if (request.family === 'task-create') {
+                    const result = createTask(request.candidate, { repoRoot: manifest.repoRoot });
+                    response = {
+                        version: 1, id,
+                        exitCode: result.status === 'blocked' ? 2 : result.status === 'failed' ? 1 : 0,
+                        stdout: `${JSON.stringify(result)}\n`, stderr: ''
+                    };
+                }
+                else {
+                    const boundArgs = bindSandboxControlTask(request, manifest.taskId);
+                    if (request.family === 'task-orchestration') {
+                        boundArgs.push('--git-worktree-root', manifest.worktreeRoot);
+                    }
+                    const result = spawnSync(process.execPath, ['--experimental-strip-types', '--no-warnings', process.argv[1], request.family, ...boundArgs], {
+                        cwd: manifest.repoRoot,
+                        encoding: 'utf8',
+                        env: sandboxControlSafeEnv()
+                    });
+                    response = {
+                        version: 1,
+                        id,
+                        exitCode: result.status ?? 1,
+                        stdout: result.stdout ?? '',
+                        stderr: result.stderr ?? ''
+                    };
+                }
+            }
+            catch (error) {
+                response = {
+                    version: 1,
+                    id,
+                    exitCode: 1,
+                    stdout: '',
+                    stderr: `${error instanceof Error ? error.message : String(error)}\n`
+                };
+            }
+            try {
+                fs.unlinkSync(requestPath);
+                writeResponse(responsesDir, response);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+    }
+}
+//# sourceMappingURL=server.js.map

package/dist/lib/sandbox/dockerfile.js

@@ -5,6 +5,11 @@ import { createHash } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { removeDirRecursive } from '../remove-dir.js';
 const RUNTIMES_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), 'runtimes');
+const AGENT_CLIENT_RUNTIMES_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'agent-clients', 'adapters', 'runtimes');
+const EMPTY_IMAGE_CONTRIBUTION = Object.freeze({
+    dockerfileFragments: Object.freeze([]),
+    dotfilesExclusions: Object.freeze([])
+});
 function listRuntimeFragments() {
     return fs.readdirSync(RUNTIMES_DIR)
         .filter((file) => file.endsWith('.dockerfile'))
@@ -15,7 +20,24 @@ export function availableRuntimes() {
         .filter((name) => name !== 'base' && name !== 'ai-tools')
         .sort();
 }
-function dockerfileContent(config) {
+function exclusionsFragment(exclusions) {
+    return [
+        "RUN mkdir -p /etc/agent-infra && cat > /etc/agent-infra/dotfiles-exclusions <<'EXCLUSIONS'",
+        ...exclusions,
+        'EXCLUSIONS'
+    ].join('\n');
+}
+function adapterFragmentPath(fragment) {
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(fragment)) {
+        throw new Error(`Invalid Agent Client Dockerfile fragment: ${fragment}`);
+    }
+    const fragmentPath = path.join(AGENT_CLIENT_RUNTIMES_DIR, `${fragment}.dockerfile`);
+    if (!fs.existsSync(fragmentPath)) {
+        throw new Error(`Unknown Agent Client Dockerfile fragment: ${fragment}`);
+    }
+    return fragmentPath;
+}
+function dockerfileContent(config, image = EMPTY_IMAGE_CONTRIBUTION) {
     if (config.dockerfile) {
         const customPath = path.resolve(config.repoRoot, config.dockerfile);
         if (!fs.existsSync(customPath)) {
@@ -30,22 +52,23 @@ function dockerfileContent(config) {
         }
     }
     const fragments = [
-        'base.dockerfile',
-        ...config.runtimes.map((runtime) => `${runtime}.dockerfile`),
-        'ai-tools.dockerfile'
+        fs.readFileSync(path.join(RUNTIMES_DIR, 'base.dockerfile'), 'utf8').trimEnd(),
+        exclusionsFragment(image.dotfilesExclusions),
+        ...image.dockerfileFragments.map((fragment) => fs.readFileSync(adapterFragmentPath(fragment), 'utf8').trimEnd()),
+        ...config.runtimes.map((runtime) => fs.readFileSync(path.join(RUNTIMES_DIR, `${runtime}.dockerfile`), 'utf8').trimEnd()),
+        fs.readFileSync(path.join(RUNTIMES_DIR, 'ai-tools.dockerfile'), 'utf8').trimEnd()
     ];
     const content = fragments
-        .map((fragment) => fs.readFileSync(path.join(RUNTIMES_DIR, fragment), 'utf8').trimEnd())
         .join('\n\n');
     return `${content}\n`;
 }
-export function dockerfileSignature(config) {
+export function dockerfileSignature(config, image = EMPTY_IMAGE_CONTRIBUTION) {
     return createHash('sha256')
-        .update(dockerfileContent(config))
+        .update(dockerfileContent(config, image))
         .digest('hex')
         .slice(0, 12);
 }
-export function prepareDockerfile(config) {
+export function prepareDockerfile(config, image = EMPTY_IMAGE_CONTRIBUTION) {
     if (config.dockerfile) {
         const customPath = path.resolve(config.repoRoot, config.dockerfile);
         if (!fs.existsSync(customPath)) {
@@ -53,23 +76,23 @@ export function prepareDockerfile(config) {
         }
         return {
             path: customPath,
-            signature: dockerfileSignature(config),
+            signature: dockerfileSignature(config, image),
             cleanup() { }
         };
     }
     const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), `${config.project}-sandbox-`));
     const tempPath = path.join(tempDir, 'Dockerfile');
-    fs.writeFileSync(tempPath, dockerfileContent(config), 'utf8');
+    fs.writeFileSync(tempPath, dockerfileContent(config, image), 'utf8');
     return {
         path: tempPath,
-        signature: dockerfileSignature(config),
+        signature: dockerfileSignature(config, image),
         cleanup() {
             removeDirRecursive(tempDir);
         }
     };
 }
-export function composeDockerfile(config) {
-    const content = dockerfileContent(config);
+export function composeDockerfile(config, image = EMPTY_IMAGE_CONTRIBUTION) {
+    const content = dockerfileContent(config, image);
     const tempPath = path.join(os.tmpdir(), `${config.project}-sandbox.Dockerfile`);
     fs.writeFileSync(tempPath, content, 'utf8');
     return tempPath;

package/dist/lib/sandbox/mounts.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { shareBranchDir, shareCommonDir, shellConfigDirCandidates, worktreeDirCandidates } from './constants.js';
-export function sandboxCoreBindMounts(config, branch, overrides = {}) {
-    return [
+export function sandboxCoreBindMounts(config, branch, overrides) {
+    const mounts = [
         {
             hostPaths: overrides.worktree
                 ? [overrides.worktree]
@@ -10,9 +10,9 @@ export function sandboxCoreBindMounts(config, branch, overrides = {}) {
             readOnly: false
         },
         {
-            hostPaths: [path.join(config.repoRoot, '.agents', 'workspace')],
+            hostPaths: [overrides.workspaceViewRoot],
             containerPath: '/workspace/.agents/workspace',
-            readOnly: false
+            readOnly: true
         },
         {
             hostPaths: [shareCommonDir(config)],
@@ -32,5 +32,18 @@ export function sandboxCoreBindMounts(config, branch, overrides = {}) {
             readOnly: true
         }
     ];
+    if (overrides.taskSource && overrides.taskId) {
+        mounts.splice(2, 0, {
+            hostPaths: [overrides.taskSource],
+            containerPath: path.posix.join('/workspace/.agents/workspace/active', overrides.taskId),
+            readOnly: false
+        });
+    }
+    mounts.push({
+        hostPaths: [overrides.controlDir],
+        containerPath: '/run/agent-infra/control',
+        readOnly: false
+    });
+    return mounts;
 }
 //# sourceMappingURL=mounts.js.map

package/dist/lib/sandbox/recovery.js

@@ -1,13 +1,53 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { containerNameCandidates, sandboxBranchLabel, sandboxLabel, sandboxRuntimeCapabilityLabel } from './constants.js';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { containerNameCandidates, sandboxBranchLabel, sandboxLabel, sandboxRuntimeCapabilityLabel, sandboxTaskIdLabel, sandboxWorkspaceModeLabel } from './constants.js';
 import { isAgentClientId } from '../agent-clients/types.js';
 import { createSandboxCapabilityPlan } from './agent-client-reconciler.js';
 import { toEnginePath } from './engines/wsl2-paths.js';
 import { sandboxCoreBindMounts } from './mounts.js';
+import { assertSandboxTaskSource, sandboxControlPaths, sandboxWorkspaceViewPaths } from './workspace-view.js';
+import { parseSandboxWorkspaceIdentity, sameSandboxWorkspaceIdentity } from './workspace-identity.js';
 import { runEngine, runOkEngine, runVerboseEngine } from './shell.js';
 import { declaredTmpfsSeedEntries, resolveTools, toolConfigDirCandidates } from './tools.js';
 import { fetchSandboxRows, selectSandboxContainer, startSandboxContainer } from './commands/list-running.js';
+import { processIdentityMatches } from '../server/process-state.js';
+function ensureSandboxControlBroker(params) {
+    const control = sandboxControlPaths({
+        base: params.config.controlBase ?? path.join(params.config.home, '.agent-infra', 'sandbox-control'),
+        project: params.config.project,
+        container: params.container,
+        identity: params.workspace
+    });
+    if (!fs.existsSync(control.manifestPath))
+        return;
+    const manifest = JSON.parse(fs.readFileSync(control.manifestPath, 'utf8'));
+    const brokerPath = path.join(control.root, 'broker.json');
+    try {
+        const broker = JSON.parse(fs.readFileSync(brokerPath, 'utf8'));
+        if (broker.version === 1
+            && typeof broker.pid === 'number'
+            && typeof broker.startTime === 'string'
+            && broker.token === manifest.token
+            && processIdentityMatches({ version: 1, pid: broker.pid, startTime: broker.startTime }))
+            return;
+    }
+    catch {
+        // A missing, stale, or malformed broker record is replaced below.
+    }
+    fs.rmSync(brokerPath, { force: true });
+    const directory = path.dirname(fileURLToPath(import.meta.url));
+    const extension = path.extname(fileURLToPath(import.meta.url));
+    const internalCli = path.resolve(directory, '..', '..', 'bin', `internal-cli${extension}`);
+    const child = spawn(process.execPath, [internalCli, 'sandbox-control', 'serve', '--manifest', control.manifestPath], { cwd: params.config.repoRoot, detached: true, stdio: 'ignore' });
+    child.once('error', () => {
+        // Readiness remains fail-closed; a later control request reports the
+        // unavailable broker without turning this detached spawn into an
+        // unhandled process error.
+    });
+    child.unref();
+}
 function findingKey(finding) {
     return `${finding.repairKind}:${finding.path ?? finding.seed?.targetPath ?? finding.message}`;
 }
@@ -156,7 +196,28 @@ function hostSourceAccessible(hostPath, writable) {
 }
 function expectedMounts(params) {
     const { config, branch, tools, actualMounts } = params;
-    const core = sandboxCoreBindMounts(config, branch).map((mount) => ({
+    const view = sandboxWorkspaceViewPaths({
+        base: config.workspaceViewBase ?? path.join(config.home, '.agent-infra', 'workspace-views'),
+        project: config.project,
+        container: params.container,
+        identity: params.workspace
+    });
+    const control = sandboxControlPaths({
+        base: config.controlBase ?? path.join(config.home, '.agent-infra', 'sandbox-control'),
+        project: config.project,
+        container: params.container,
+        identity: params.workspace
+    });
+    const core = sandboxCoreBindMounts(config, branch, {
+        workspaceViewRoot: view.root,
+        controlDir: control.channelDir,
+        ...(params.workspace.mode === 'task-bound'
+            ? {
+                taskSource: assertSandboxTaskSource(config.repoRoot, params.workspace.taskId),
+                taskId: params.workspace.taskId
+            }
+            : {})
+    }).map((mount) => ({
         path: mount.containerPath,
         expectedType: 'bind',
         hostPaths: mount.hostPaths,
@@ -248,6 +309,7 @@ export function collectSandboxRecoverySnapshot(params) {
         }
     }
     const capabilityPlan = createSandboxCapabilityPlan(params.config);
+    const workspace = params.workspace ?? { mode: 'branch-only' };
     const tools = [...capabilityPlan.tools];
     const seeds = declaredTmpfsSeedEntries(tools).map((seed) => {
         const mounted = mountsByDestination.get(seed.stagingPath)?.Type === 'bind';
@@ -269,6 +331,10 @@ export function collectSandboxRecoverySnapshot(params) {
     }));
     const labels = inspection.Config?.Labels ?? {};
     const branchLabel = labels[sandboxBranchLabel(params.config)];
+    const containerWorkspace = parseSandboxWorkspaceIdentity(labels, {
+        mode: sandboxWorkspaceModeLabel(params.config),
+        taskId: sandboxTaskIdLabel(params.config)
+    });
     const selectedToolIds = new Set(tools.map((tool) => tool.id));
     const enforceCanonicalPlan = params.config.agentClientSource === 'canonical';
     const unexpectedCapabilityMounts = enforceCanonicalPlan
@@ -280,6 +346,8 @@ export function collectSandboxRecoverySnapshot(params) {
     const mountSnapshots = expectedMounts({
         config: params.config,
         branch: params.branch,
+        container: params.container,
+        workspace,
         tools,
         actualMounts: mountsByDestination
     }).map((expected) => {
@@ -313,7 +381,8 @@ export function collectSandboxRecoverySnapshot(params) {
     return {
         identityOk: typeof inspection.Id === 'string'
             && inspection.Id.length > 0
-            && branchLabel === params.branch,
+            && branchLabel === params.branch
+            && sameSandboxWorkspaceIdentity(containerWorkspace, workspace),
         runtimeCapabilityOk: enforceCanonicalPlan
             ? labels[sandboxRuntimeCapabilityLabel(params.config)] === capabilityPlan.runtimeSignature
             : undefined,
@@ -424,14 +493,51 @@ function assess(params) {
     const snapshot = collectSandboxRecoverySnapshot(params);
     return { snapshot, findings: classifySandboxRecovery(snapshot) };
 }
-export function assertFreshSandboxReady(params) {
+function canRetryFreshReadiness(findings) {
+    return findings.length > 0 && findings.every((finding) => finding.repairKind === 'hard-failure'
+        && finding.path !== undefined
+        && (finding.path.startsWith('/workspace/.agents/workspace')
+            || finding.path === '/home/devuser/.host-shell-config'
+            || finding.path === '/home/devuser/.bash_aliases'));
+}
+export async function assertFreshSandboxReady(params) {
     validateTmpfsSeedEntries({
         engine: params.engine,
         container: params.container,
         entries: params.copiedEntries,
         deps: params.deps
     });
-    const { findings } = assess(params);
+    let { findings } = assess(params);
+    if (canRetryFreshReadiness(findings)) {
+        const runVerboseFn = params.deps?.runVerbose ?? runVerboseEngine;
+        runVerboseFn(params.engine, 'docker', ['restart', params.container]);
+        prepareTmpfsMounts({
+            engine: params.engine,
+            container: params.container,
+            mountPaths: resolveTools(params.config)
+                .filter((tool) => tool.tmpfs)
+                .map((tool) => tool.containerMount),
+            deps: params.deps
+        });
+        hydrateTmpfsSeedEntries({
+            engine: params.engine,
+            container: params.container,
+            entries: params.copiedEntries,
+            replace: true,
+            deps: params.deps
+        });
+        let retried = assess(params);
+        if (!retried.findings.some((finding) => finding.repairKind === 'hard-failure')) {
+            repairFindings({
+                engine: params.engine,
+                container: params.container,
+                findings: retried.findings,
+                deps: params.deps
+            });
+            retried = assess(params);
+        }
+        findings = retried.findings;
+    }
     if (findings.length > 0) {
         throw new Error(`Fresh sandbox readiness check failed: ${describeFindings(findings)}`);
     }
@@ -441,6 +547,11 @@ export async function ensureSandboxReady(params) {
     const startFn = deps?.start ?? startSandboxContainer;
     const warnings = [];
     let failure = null;
+    ensureSandboxControlBroker({
+        config: params.config,
+        container: params.row.name,
+        workspace: params.workspace ?? { mode: 'branch-only' }
+    });
     try {
         if (!params.row.running) {
             startFn(params.engine, params.row.name);
@@ -448,6 +559,7 @@ export async function ensureSandboxReady(params) {
                 config: params.config,
                 engine: params.engine,
                 branch: params.branch,
+                workspace: params.workspace,
                 container: params.row.name,
                 deps
             });
@@ -472,6 +584,7 @@ export async function ensureSandboxReady(params) {
                 config: params.config,
                 engine: params.engine,
                 branch: params.branch,
+                workspace: params.workspace,
                 container: params.row.name,
                 deps
             });
@@ -486,6 +599,7 @@ export async function ensureSandboxReady(params) {
                     config: params.config,
                     engine: params.engine,
                     branch: params.branch,
+                    workspace: params.workspace,
                     container: params.row.name,
                     deps
                 });
@@ -499,6 +613,7 @@ export async function ensureSandboxReady(params) {
             config: params.config,
             engine: params.engine,
             branch: params.branch,
+            workspace: params.workspace,
             container: params.row.name,
             deps
         });
@@ -521,6 +636,7 @@ export async function ensureSandboxReady(params) {
                 config: params.config,
                 engine: params.engine,
                 branch: params.branch,
+                workspace: params.workspace,
                 container: params.row.name,
                 deps
             });
@@ -539,6 +655,7 @@ export async function ensureSandboxReady(params) {
             config: params.config,
             engine: params.engine,
             branch: params.branch,
+            workspace: params.workspace,
             container: params.row.name,
             deps
         });
@@ -557,6 +674,11 @@ export async function ensureSandboxReady(params) {
     const warning = `Sandbox recovery failed in place. Replacing only the container. ${dataBoundary}`;
     warnings.push(warning);
     (params.writeWarning ?? ((message) => process.stderr.write(`${message}\n`)))(warning);
+    const runVerboseFn = deps?.runVerbose ?? runVerboseEngine;
+    if (params.row.running) {
+        runVerboseFn(params.engine, 'docker', ['stop', params.row.name]);
+    }
+    runVerboseFn(params.engine, 'docker', ['rm', params.row.name]);
     await params.recreate(params.branch);
     const rows = (deps?.fetchRows ?? fetchSandboxRows)(params.engine, sandboxLabel(params.config), sandboxBranchLabel(params.config));
     const replacement = selectSandboxContainer([...rows.running, ...rows.nonRunning], containerNameCandidates(params.config, params.branch));
@@ -567,6 +689,7 @@ export async function ensureSandboxReady(params) {
         config: params.config,
         engine: params.engine,
         branch: params.branch,
+        workspace: params.workspace,
         container: replacement.name,
         deps
     });

package/dist/lib/sandbox/redaction.js

@@ -0,0 +1,12 @@
+const SENSITIVE_OUTPUT_PATTERNS = [
+    { pattern: /\{[^{}]*"claudeAiOauth"[\s\S]*?\}\s*\}/g, replacement: '[REDACTED credentials blob]' },
+    { pattern: /sk-ant-[A-Za-z0-9_-]{20,}/g, replacement: '[REDACTED claude token]' },
+    { pattern: /gh[psoru]_[A-Za-z0-9]{30,}/g, replacement: '[REDACTED github token]' },
+    { pattern: /Bearer\s+[A-Za-z0-9._~+/=-]{20,}/gi, replacement: 'Bearer [REDACTED]' }
+];
+export function redactCommandError(text) {
+    if (!text || typeof text !== 'string')
+        return '';
+    return SENSITIVE_OUTPUT_PATTERNS.reduce((result, { pattern, replacement }) => result.replace(pattern, replacement), text);
+}
+//# sourceMappingURL=redaction.js.map

package/dist/lib/sandbox/runtimes/base.dockerfile

@@ -64,69 +64,9 @@ RUN printf '%s\n' \
       'set -g mouse on' \
       'set -g status-interval 1' \
       'set -g status-right-length 80' \
-      "set -g status-right '#(/usr/local/bin/cc-token-status) | %H:%M'" \
+      "set -g status-right '%H:%M'" \
     > /etc/tmux.conf
 
-RUN cat > /usr/local/bin/cc-token-status <<'SCRIPT' && chmod +x /usr/local/bin/cc-token-status
-#!/bin/sh
-set -eu
-
-SETTINGS_FILE="/home/devuser/.claude/settings.json"
-if [ -r "$SETTINGS_FILE" ] && jq -e '
-  def has_nonempty($v):
-    if ($v | type) == "string" then ($v | gsub("^\\s+|\\s+$"; "") | length) > 0 else false end;
-  (if type == "object" then . else {} end) as $settings
-  | (if ($settings.env | type) == "object" then $settings.env else {} end) as $env
-  | has_nonempty($env.ANTHROPIC_AUTH_TOKEN)
-    or has_nonempty($env.ANTHROPIC_API_KEY)
-    or has_nonempty($settings.apiKeyHelper)
-' "$SETTINGS_FILE" >/dev/null 2>&1; then
-  exit 0
-fi
-
-CRED_FILE="/home/devuser/.claude/.credentials.json"
-[ -r "$CRED_FILE" ] || exit 0
-
-EXPIRES_MS=$(jq -r '(.claudeAiOauth.expiresAt // .expiresAt) // empty' "$CRED_FILE" 2>/dev/null || true)
-case "$EXPIRES_MS" in
-  ''|*[!0-9]*) exit 0 ;;
-esac
-
-NOW_MS=$(($(date +%s) * 1000))
-DIFF_MS=$((EXPIRES_MS - NOW_MS))
-DIFF_S=$((DIFF_MS / 1000))
-
-DIM='#[fg=colour245]'
-YELLOW='#[fg=yellow]'
-YELLOW_BOLD='#[fg=yellow,bold]'
-RED_BOLD='#[fg=red,bold]'
-RED_REV='#[fg=red,reverse]'
-RESET='#[default]'
-
-if [ "$DIFF_S" -le 0 ]; then
-  ELAPSED=$(( -DIFF_S ))
-  M=$((ELAPSED / 60))
-  printf '%sClaude Code auth EXPIRED %dm ago%s' "$RED_REV" "$M" "$RESET"
-elif [ "$DIFF_S" -lt 60 ]; then
-  printf '%sClaude Code auth expires in %ds%s' "$RED_BOLD" "$DIFF_S" "$RESET"
-elif [ "$DIFF_S" -lt 300 ]; then
-  M=$((DIFF_S / 60))
-  S=$((DIFF_S % 60))
-  printf '%sClaude Code auth expires in %dm %ds%s' "$RED_BOLD" "$M" "$S" "$RESET"
-elif [ "$DIFF_S" -lt 1800 ]; then
-  M=$((DIFF_S / 60))
-  printf '%sClaude Code auth expires in %dm%s' "$YELLOW_BOLD" "$M" "$RESET"
-elif [ "$DIFF_S" -lt 3600 ]; then
-  M=$((DIFF_S / 60))
-  printf '%sClaude Code auth expires in %dm%s' "$YELLOW" "$M" "$RESET"
-else
-  TOTAL_M=$((DIFF_S / 60))
-  H=$((TOTAL_M / 60))
-  M=$((TOTAL_M % 60))
-  printf '%sClaude Code auth expires in %dh %dm%s' "$DIM" "$H" "$M" "$RESET"
-fi
-SCRIPT
-
 RUN cat > /usr/local/bin/sandbox-dotfiles-link <<'SCRIPT' && chmod +x /usr/local/bin/sandbox-dotfiles-link
 #!/bin/sh
 # Mirror /dotfiles/ tree as symlinks under $HOME/, overwriting any image-baked
@@ -136,23 +76,34 @@ set -eu
 DOTFILES_SRC=/dotfiles
 [ -d "$DOTFILES_SRC" ] || exit 0
 
-cd "$DOTFILES_SRC"
-find . -type f -print | while IFS= read -r rel; do
-  rel=${rel#./}
-  target="$HOME/$rel"
-  case "$rel" in
+is_dotfiles_excluded() {
+  candidate=$1
+  case "$candidate" in
     .ssh|.ssh/*|\
     .gnupg|.gnupg/*|\
-    .claude|.claude/*|\
-    .codex|.codex/*|\
-    .gemini|.gemini/*|\
-    .config/opencode|.config/opencode/*|\
-    .local/share/opencode|.local/share/opencode/*|\
     .host-shell-config|.host-shell-config/*|\
     .gitconfig|.gitignore_global|.stCommitMsg|.bash_aliases|README.md)
-      continue ;;
+      return 0 ;;
   esac
 
+  [ -r /etc/agent-infra/dotfiles-exclusions ] || return 1
+  while IFS= read -r prefix; do
+    [ -n "$prefix" ] || continue
+    case "$candidate" in
+      "$prefix"|"$prefix"/*) return 0 ;;
+    esac
+  done < /etc/agent-infra/dotfiles-exclusions
+  return 1
+}
+
+cd "$DOTFILES_SRC"
+find . -type f -print | while IFS= read -r rel; do
+  rel=${rel#./}
+  target="$HOME/$rel"
+  if is_dotfiles_excluded "$rel"; then
+    continue
+  fi
+
   mkdir -p "$(dirname "$target")"
   if [ -d "$target" ] && [ ! -L "$target" ]; then
     printf 'sandbox-dotfiles-link: skipping %s (existing directory; use nested path like %s/<file> instead)\n' "$target" "$rel" >&2
@@ -198,8 +149,7 @@ fi
 exec tmux new-session -s "$SESSION"
 SCRIPT
 
-RUN test -s /usr/local/bin/cc-token-status && test -x /usr/local/bin/cc-token-status && \
-    test -s /usr/local/bin/sandbox-dotfiles-link && test -x /usr/local/bin/sandbox-dotfiles-link && \
+RUN test -s /usr/local/bin/sandbox-dotfiles-link && test -x /usr/local/bin/sandbox-dotfiles-link && \
     test -s /usr/local/bin/sandbox-tmux-entry && test -x /usr/local/bin/sandbox-tmux-entry
 
 ENV LANG=en_US.UTF-8