@fitlab-ai/agent-infra 0.9.0 → 0.9.2

package/lib/sandbox/commands/prune.ts

@@ -11,7 +11,7 @@ import { hostJoin } from '../engines/wsl2-paths.ts';
 import { removeManagedDir, removeWorktreeDir } from '../managed-fs.ts';
 import { parseLabels } from './ls.ts';
 import { runEngine, runSafe } from '../shell.ts';
-import { resolveTools } from '../tools.ts';
+import { createSandboxCapabilityPlan } from '../agent-client-reconciler.ts';
 import type { SandboxTool } from '../tools.ts';
 
 const USAGE = `Usage: ai sandbox prune [--dry-run]`;
@@ -158,7 +158,7 @@ export async function prune(args: string[]): Promise<void> {
   }
 
   const config = loadConfig();
-  const tools = resolveTools(config);
+  const tools = [...createSandboxCapabilityPlan(config).cleanupInventory];
   const engine = detectEngine(config);
   const psArgs = [
     'ps',

package/lib/sandbox/commands/rebuild.ts

@@ -16,8 +16,14 @@ import {
   parseImageLabels,
   parseRefreshTimestamp
 } from '../image-build.ts';
+import {
+  assertBuildProxyCompatibility,
+  buildProxyFailureHint,
+  prepareBuildProxy,
+  redactBuildProxyValues
+} from '../build-proxy.ts';
 
-const USAGE = `Usage: ai sandbox rebuild [--quiet] [--refresh]`;
+const USAGE = `Usage: ai sandbox rebuild [--quiet] [--refresh] [--inherit-build-proxy|-B]`;
 
 type EngineRunFn = (engine: string, cmd: string, args: string[], opts?: { cwd?: string }) => string;
 type EngineRunSafeFn = EngineRunFn;
@@ -33,7 +39,8 @@ export function buildArgs(
     runSafeFn = runSafeEngine,
     env = process.env,
     refresh = false,
-    lastRefresh
+    lastRefresh,
+    buildProxyArgs = []
   }: {
     engine?: string;
     runFn?: EngineRunFn;
@@ -41,6 +48,7 @@ export function buildArgs(
     env?: NodeJS.ProcessEnv;
     refresh?: boolean;
     lastRefresh?: number;
+    buildProxyArgs?: string[];
   } = {}
 ): string[] {
   return buildSandboxImageArgs(config, tools, dockerfilePath, imageSignature, {
@@ -49,7 +57,8 @@ export function buildArgs(
     runSafeFn,
     env,
     refresh,
-    lastRefresh
+    lastRefresh,
+    buildProxyArgs
   });
 }
 
@@ -77,6 +86,7 @@ export async function rebuild(args: string[]): Promise<void> {
     options: {
       refresh: { type: 'boolean' },
       quiet: { type: 'boolean', short: 'q' },
+      'inherit-build-proxy': { type: 'boolean', short: 'B' },
       help: { type: 'boolean', short: 'h' }
     }
   });
@@ -95,6 +105,11 @@ export async function rebuild(args: string[]): Promise<void> {
   const engine = detectEngine(config);
 
   await ensureDocker(config, undefined);
+  if (values['inherit-build-proxy'] && config.dockerfile) {
+    throw new Error('Build proxy inheritance is unavailable with a custom sandbox Dockerfile.');
+  }
+  const buildProxy = prepareBuildProxy(values['inherit-build-proxy'] ?? false, process.env, engine);
+  if (values['inherit-build-proxy']) assertBuildProxyCompatibility(engine);
   const lastRefresh = refresh ? Date.now() : readExistingLastRefresh(config, engine);
   p.intro(pc.cyan('Rebuilding sandbox image'));
 
@@ -105,9 +120,11 @@ export async function rebuild(args: string[]): Promise<void> {
       runEngine(engine, 'docker', buildArgs(config, tools, preparedDockerfile.path, imageSignature, {
         engine,
         refresh,
-        lastRefresh
+        lastRefresh,
+        buildProxyArgs: buildProxy.args
       }), {
-        cwd: config.repoRoot
+        cwd: config.repoRoot,
+        env: buildProxy.env
       });
       spinner.stop(pc.green('Sandbox image rebuilt'));
     } else {
@@ -118,13 +135,18 @@ export async function rebuild(args: string[]): Promise<void> {
         buildArgs(config, tools, preparedDockerfile.path, imageSignature, {
           engine,
           refresh,
-          lastRefresh
+          lastRefresh,
+          buildProxyArgs: buildProxy.args
         }),
-        { cwd: config.repoRoot }
+        { cwd: config.repoRoot, env: buildProxy.env }
       );
       p.log.success(pc.green('Sandbox image rebuilt'));
     }
     pruneSandboxDanglingImages(config, engine);
+  } catch (error) {
+    const message = redactBuildProxyValues(error instanceof Error ? error.message : String(error), buildProxy.redactionValues);
+    const hint = values['inherit-build-proxy'] ? `\n${buildProxyFailureHint(engine)}` : '';
+    throw new Error(`${message}${hint}`);
   } finally {
     preparedDockerfile.cleanup();
   }

package/lib/sandbox/commands/rm.ts

@@ -19,7 +19,8 @@ import { pruneSandboxDanglingImages } from '../image-prune.ts';
 import { removeManagedDir, removeWorktreeDir } from '../managed-fs.ts';
 import { runOk, runSafe, runSafeEngine } from '../shell.ts';
 import { resolveTaskBranch } from '../task-resolver.ts';
-import { resolveTools, toolConfigDirCandidates, toolProjectDirCandidates } from '../tools.ts';
+import { toolConfigDirCandidates, toolProjectDirCandidates } from '../tools.ts';
+import { createSandboxCapabilityPlan } from '../agent-client-reconciler.ts';
 import type { SandboxTool } from '../tools.ts';
 import { fetchSandboxRows } from './list-running.ts';
 import { lookupShortIdByBranch } from '../../task/short-id.ts';
@@ -353,7 +354,7 @@ export async function rm(args: string[]): Promise<void> {
   }
 
   const config = loadConfig();
-  const tools = resolveTools(config);
+  const tools = [...createSandboxCapabilityPlan(config).cleanupInventory];
 
   if (values.purge) {
     await rmPurge(config, tools);

package/lib/sandbox/config.ts

@@ -3,6 +3,9 @@ import path from 'node:path';
 import { homedir, platform } from 'node:os';
 import { execFileSync } from 'node:child_process';
 import pc from 'picocolors';
+import { normalizeAgentClients } from '../agent-clients/config.ts';
+import { isAgentClientId } from '../agent-clients/types.ts';
+import type { AgentClientState } from '../agent-clients/types.ts';
 import { validateSandboxEngine } from './engine.ts';
 import { hostJoin } from './engines/wsl2-paths.ts';
 import { findRuntimeEngineMismatches } from './runtime-engines.ts';
@@ -12,7 +15,7 @@ import type { SandboxTool } from './tools.ts';
 const DEFAULTS = Object.freeze({
   engine: null,
   runtimes: ['node22'],
-  tools: ['agent-infra', 'claude-code', 'codex', 'gemini-cli', 'opencode'],
+  tools: ['agent-infra'],
   refreshIntervalDays: 7,
   dockerfile: null,
   vm: {
@@ -57,6 +60,8 @@ export type SandboxConfig = {
   runtimes: string[];
   tools: string[];
   customTools: SandboxTool[];
+  agentClientState: AgentClientState;
+  agentClientSource: 'canonical' | 'legacy';
   refreshIntervalDays: number;
   dockerfile: string | null;
   vm: SandboxVmConfig;
@@ -65,6 +70,8 @@ export type SandboxConfig = {
 type AircConfig = {
   project?: unknown;
   org?: unknown;
+  agentClients?: unknown;
+  tuis?: unknown;
   sandbox?: SandboxConfigInput;
 };
 
@@ -98,6 +105,23 @@ function cloneDefaults(): SandboxConfigInput & { vm: SandboxVmConfig; runtimes:
   };
 }
 
+function resolveSandboxToolIds(
+  sandbox: SandboxConfigInput,
+  agentClients: ReturnType<typeof normalizeAgentClients>,
+  defaults: readonly string[]
+): string[] {
+  if (Array.isArray(sandbox.tools)) {
+    const tools = sandbox.tools.filter((tool): tool is string => typeof tool === 'string');
+    return agentClients.source === 'canonical'
+      ? tools.filter((tool) => !isAgentClientId(tool))
+      : tools;
+  }
+  if (agentClients.remainingSandboxTools !== undefined) {
+    return [...agentClients.remainingSandboxTools];
+  }
+  return [...defaults];
+}
+
 export function loadConfig({
   platformFn = platform,
   writeStderr = (chunk) => process.stderr.write(chunk)
@@ -115,6 +139,8 @@ export function loadConfig({
   }
 
   const airc = JSON.parse(fs.readFileSync(configPath, 'utf8')) as AircConfig;
+  const sandboxInput = airc.sandbox;
+  const agentClients = normalizeAgentClients(airc);
   const defaults = cloneDefaults();
   const sandbox = airc.sandbox ?? {};
   const engine = validateSandboxEngine(sandbox.engine ?? defaults.engine, { platformFn });
@@ -149,6 +175,7 @@ export function loadConfig({
   }
 
   const customTools = parseCustomTools(sandbox.customTools, { home });
+  const tools = resolveSandboxToolIds(sandbox, agentClients, defaults.tools);
 
   return {
     repoRoot,
@@ -164,10 +191,10 @@ export function loadConfig({
     dotfilesDir: hostJoin(home, '.agent-infra', 'dotfiles'),
     engine,
     runtimes,
-    tools: Array.isArray(sandbox.tools) && sandbox.tools.length > 0
-      ? [...sandbox.tools]
-      : defaults.tools,
+    tools,
     customTools,
+    agentClientState: agentClients.state,
+    agentClientSource: agentClients.source,
     refreshIntervalDays: asNonNegativeIntegerOrDefault(
       sandbox.refreshIntervalDays,
       defaults.refreshIntervalDays

package/lib/sandbox/constants.ts

@@ -111,6 +111,12 @@ export function sandboxImageRefreshLabel(config: Pick<SandboxPathConfig, 'projec
   return `${sandboxLabel(config)}.last-refresh`;
 }
 
+export function sandboxRuntimeCapabilityLabel(
+  config: Pick<SandboxPathConfig, 'project'>
+): string {
+  return `agent-infra.sandbox.runtime-capability.${config.project}`;
+}
+
 export function parsePositiveIntegerOption(value: unknown, optionName: string): number | undefined {
   if (value === undefined || value === null) {
     return undefined;

package/lib/sandbox/dockerfile.ts

@@ -3,6 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
+import { removeDirRecursive } from '../remove-dir.ts';
 
 const RUNTIMES_DIR = path.join(
   path.dirname(fileURLToPath(import.meta.url)),
@@ -88,7 +89,7 @@ export function prepareDockerfile(config: DockerfileConfig): { path: string; sig
     path: tempPath,
     signature: dockerfileSignature(config),
     cleanup() {
-      fs.rmSync(tempDir, { recursive: true, force: true });
+      removeDirRecursive(tempDir);
     }
   };
 }

package/lib/sandbox/image-build.ts

@@ -44,7 +44,8 @@ export function buildSandboxImageArgs(
     runSafeFn = runSafeEngine,
     env = process.env,
     refresh = false,
-    lastRefresh
+    lastRefresh,
+    buildProxyArgs = []
   }: {
     engine?: string;
     runFn?: EngineRunFn;
@@ -52,6 +53,7 @@ export function buildSandboxImageArgs(
     env?: NodeJS.ProcessEnv;
     refresh?: boolean;
     lastRefresh?: number;
+    buildProxyArgs?: string[];
   } = {}
 ): string[] {
   const selectedEngine = engine ?? detectEngine({ engine: config.engine });
@@ -79,6 +81,7 @@ export function buildSandboxImageArgs(
     '--label',
     `${sandboxImageConfigLabel(config)}=${imageSignature}`
   ];
+  args.push(...buildProxyArgs);
 
   if (lastRefresh !== undefined) {
     args.push('--label', `${sandboxImageRefreshLabel(config)}=${lastRefresh}`);

package/lib/sandbox/managed-fs.ts

@@ -1,6 +1,6 @@
-import fs from 'node:fs';
 import path from 'node:path';
-import { run } from './shell.ts';
+import { run, runSafe } from './shell.ts';
+import { removeDirRecursive } from '../remove-dir.ts';
 
 export function assertManagedPath(root: string, target: string): void {
   const resolvedRoot = path.resolve(root);
@@ -15,13 +15,26 @@ export function assertManagedPath(root: string, target: string): void {
 
 export function removeManagedDir(root: string, dir: string): void {
   assertManagedPath(root, dir);
-  fs.rmSync(dir, { recursive: true, force: true });
+  removeDirRecursive(dir);
 }
 
-export function removeWorktreeDir(repoRoot: string, worktreeBase: string, dir: string): void {
+export function removeWorktreeDir(
+  repoRoot: string,
+  worktreeBase: string,
+  dir: string,
+  { runFn = run, runSafeFn = runSafe }: {
+    runFn?: typeof run;
+    runSafeFn?: typeof runSafe;
+  } = {}
+): void {
   try {
-    run('git', ['-C', repoRoot, 'worktree', 'remove', dir, '--force']);
+    runFn('git', ['-C', repoRoot, 'worktree', 'remove', dir, '--force']);
   } catch {
+    // On WSL2 the worktree is registered under its `/mnt/<drive>/...` path, so
+    // `git worktree remove <windows-path>` cannot match it. Delete the managed
+    // directory directly, then prune the now-dangling worktree metadata so the
+    // branch is no longer reported as checked out.
     removeManagedDir(worktreeBase, dir);
+    runSafeFn('git', ['-C', repoRoot, 'worktree', 'prune']);
   }
 }

package/lib/sandbox/recovery.ts

@@ -1,6 +1,19 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { containerNameCandidates, sandboxBranchLabel, sandboxLabel } from './constants.ts';
+import {
+  containerNameCandidates,
+  sandboxBranchLabel,
+  sandboxLabel,
+  sandboxRuntimeCapabilityLabel
+} from './constants.ts';
+import { isAgentClientId } from '../agent-clients/types.ts';
+import {
+  createSandboxCapabilityPlan
+} from './agent-client-reconciler.ts';
+import type {
+  SandboxRecoveryFindingDescriptor,
+  SandboxRecoveryRepair
+} from './tool-types.ts';
 import type { SandboxConfig } from './config.ts';
 import { toEnginePath } from './engines/wsl2-paths.ts';
 import { sandboxCoreBindMounts } from './mounts.ts';
@@ -9,6 +22,7 @@ import {
   declaredTmpfsSeedEntries,
   resolveTools,
   toolConfigDirCandidates,
+  type SandboxTool,
   type TmpfsSeedEntry
 } from './tools.ts';
 import {
@@ -23,10 +37,22 @@ export type SandboxRecoveryFinding = {
   message: string;
   path?: string;
   seed?: TmpfsSeedEntry;
+  repair?: SandboxRecoveryRepair;
+};
+
+type SandboxAgentClientCheckSnapshot = {
+  adapterId: string;
+  checkId: string;
+  applicable: boolean;
+  healthy: boolean;
+  finding: SandboxRecoveryFindingDescriptor;
+  repair?: SandboxRecoveryRepair;
 };
 
 export type SandboxRecoverySnapshot = {
   identityOk: boolean;
+  runtimeCapabilityOk?: boolean;
+  unexpectedCapabilityMounts?: string[];
   mounts: Array<{
     path: string;
     expectedType: string;
@@ -48,12 +74,7 @@ export type SandboxRecoverySnapshot = {
     targetState: 'ok' | 'missing' | 'wrong-type' | 'inaccessible';
   }>;
   aliasesReadable: boolean;
-  codex?: {
-    commandAvailable: boolean;
-    stateWritable: boolean;
-    promptsSourceExists: boolean;
-    promptsValid: boolean;
-  };
+  agentClientChecks: SandboxAgentClientCheckSnapshot[];
 };
 
 export type SandboxReadyResult = {
@@ -114,6 +135,19 @@ export function classifySandboxRecovery(snapshot: SandboxRecoverySnapshot): Sand
       message: 'Container identity does not match the requested sandbox branch.'
     });
   }
+  if (snapshot.runtimeCapabilityOk === false) {
+    findings.push({
+      repairKind: 'hard-failure',
+      message: 'Container runtime capability signature does not match the current sandbox plan.'
+    });
+  }
+  for (const mountPath of snapshot.unexpectedCapabilityMounts ?? []) {
+    findings.push({
+      repairKind: 'hard-failure',
+      message: `Disabled Agent Client capability remains mounted at ${mountPath}.`,
+      path: mountPath
+    });
+  }
 
   for (const mount of snapshot.mounts) {
     if (
@@ -177,25 +211,11 @@ export function classifySandboxRecovery(snapshot: SandboxRecoverySnapshot): Sand
     });
   }
 
-  if (snapshot.codex) {
-    if (!snapshot.codex.commandAvailable) {
+  for (const check of snapshot.agentClientChecks) {
+    if (check.applicable && !check.healthy) {
       findings.push({
-        repairKind: 'hard-failure',
-        message: 'Codex is not available on PATH inside the sandbox.'
-      });
-    }
-    if (!snapshot.codex.stateWritable) {
-      findings.push({
-        repairKind: 'permissions',
-        message: 'Codex state directory is not writable by devuser.',
-        path: '/home/devuser/.codex'
-      });
-    }
-    if (snapshot.codex.promptsSourceExists && !snapshot.codex.promptsValid) {
-      findings.push({
-        repairKind: 'builtin-link',
-        message: 'Codex prompts link does not point to the workspace commands directory.',
-        path: '/home/devuser/.codex/prompts'
+        ...check.finding,
+        ...(check.repair === undefined ? {} : { repair: check.repair })
       });
     }
   }
@@ -277,11 +297,10 @@ function hostSourceAccessible(hostPath: string, writable: boolean): boolean {
 function expectedMounts(params: {
   config: SandboxConfig;
   branch: string;
-  engine: string;
+  tools: readonly SandboxTool[];
   actualMounts: Map<string, DockerMount>;
 }): ExpectedMount[] {
-  const { config, branch, actualMounts } = params;
-  const tools = resolveTools(config);
+  const { config, branch, tools, actualMounts } = params;
   const core = sandboxCoreBindMounts(config, branch).map((mount) => ({
     path: mount.containerPath,
     expectedType: 'bind' as const,
@@ -301,7 +320,13 @@ function expectedMounts(params: {
     })
   );
   const persistentTools = tools
-    .filter((tool) => !tool.tmpfs && actualMounts.has(tool.containerMount))
+    .filter((tool) =>
+      !tool.tmpfs
+      && (
+        config.agentClientSource === 'canonical'
+        || actualMounts.has(tool.containerMount)
+      )
+    )
     .map((tool) => ({
       path: tool.containerMount,
       expectedType: 'bind' as const,
@@ -401,7 +426,8 @@ export function collectSandboxRecoverySnapshot(params: {
       });
     }
   }
-  const tools = resolveTools(params.config);
+  const capabilityPlan = createSandboxCapabilityPlan(params.config);
+  const tools = [...capabilityPlan.tools];
   const seeds = declaredTmpfsSeedEntries(tools).map((seed) => {
     const mounted = mountsByDestination.get(seed.stagingPath)?.Type === 'bind';
     return {
@@ -434,11 +460,18 @@ export function collectSandboxRecoverySnapshot(params: {
   }));
   const labels = inspection.Config?.Labels ?? {};
   const branchLabel = labels[sandboxBranchLabel(params.config)];
-  const hasCodex = tools.some((tool) => tool.id === 'codex');
+  const selectedToolIds = new Set(tools.map((tool) => tool.id));
+  const enforceCanonicalPlan = params.config.agentClientSource === 'canonical';
+  const unexpectedCapabilityMounts = enforceCanonicalPlan
+    ? capabilityPlan.cleanupInventory
+      .filter((tool) => isAgentClientId(tool.id) && !selectedToolIds.has(tool.id))
+      .map((tool) => tool.containerMount)
+      .filter((mountPath) => mountsByDestination.has(mountPath))
+    : [];
   const mountSnapshots = expectedMounts({
     config: params.config,
     branch: params.branch,
-    engine: params.engine,
+    tools,
     actualMounts: mountsByDestination
   }).map((expected) => {
     const actual = mountsByDestination.get(expected.path);
@@ -478,6 +511,10 @@ export function collectSandboxRecoverySnapshot(params: {
     identityOk: typeof inspection.Id === 'string'
       && inspection.Id.length > 0
       && branchLabel === params.branch,
+    runtimeCapabilityOk: enforceCanonicalPlan
+      ? labels[sandboxRuntimeCapabilityLabel(params.config)] === capabilityPlan.runtimeSignature
+      : undefined,
+    unexpectedCapabilityMounts,
     mounts: mountSnapshots,
     tmpfs,
     seeds,
@@ -488,38 +525,31 @@ export function collectSandboxRecoverySnapshot(params: {
       ['/home/devuser/.bash_aliases'],
       runOkFn
     ),
-    codex: hasCodex
-      ? {
-          commandAvailable: probe(
-            params.engine,
-            params.container,
-            'command -v codex',
-            [],
-            runOkFn
-          ),
-          stateWritable: probe(
-            params.engine,
-            params.container,
-            'probe="$1/.agent-infra-codex-state-$$"; trap \'rm -f -- "$probe"\' EXIT; : > "$probe"',
-            ['/home/devuser/.codex'],
-            runOkFn
-          ),
-          promptsSourceExists: probe(
-            params.engine,
-            params.container,
-            'test -d "$1"',
-            ['/workspace/.codex/commands'],
-            runOkFn
-          ),
-          promptsValid: probe(
-            params.engine,
-            params.container,
-            'test "$(readlink -- "$1")" = "$2"',
-            ['/home/devuser/.codex/prompts', '/workspace/.codex/commands'],
-            runOkFn
-          )
-        }
-      : undefined
+    agentClientChecks: capabilityPlan.recoveryChecks.map(({ adapterId, check }) => {
+      const applicable = check.when === undefined || probe(
+        params.engine,
+        params.container,
+        check.when.script,
+        [...check.when.args],
+        runOkFn,
+        check.when.user
+      );
+      return {
+        adapterId,
+        checkId: check.id,
+        applicable,
+        healthy: !applicable || probe(
+          params.engine,
+          params.container,
+          check.probe.script,
+          [...check.probe.args],
+          runOkFn,
+          check.probe.user
+        ),
+        finding: check.finding,
+        ...(check.repair === undefined ? {} : { repair: check.repair })
+      };
+    })
   };
 }
 
@@ -626,10 +656,11 @@ function repairFindings(params: {
     deps: params.deps
   });
   const runVerboseFn = params.deps?.runVerbose ?? runVerboseEngine;
-  if (params.findings.some((finding) => finding.repairKind === 'builtin-link')) {
+  for (const repair of params.findings.flatMap((finding) =>
+    finding.repair === undefined ? [] : [finding.repair]
+  )) {
     runVerboseFn(params.engine, 'docker', [
-      'exec', '--user', 'devuser', params.container, 'ln', '-sfn',
-      '/workspace/.codex/commands', '/home/devuser/.codex/prompts'
+      'exec', '--user', repair.user, params.container, repair.command, ...repair.args
     ]);
   }
 }

package/lib/sandbox/runtimes/ai-tools.dockerfile

@@ -5,20 +5,41 @@ ENV NPM_CONFIG_PREFIX=/home/devuser/.npm-global
 ENV PATH="/home/devuser/.npm-global/bin:${PATH}"
 
 ARG AI_TOOL_PACKAGES=
-RUN set -e && \
+RUN --mount=type=secret,id=HTTP_PROXY \
+    --mount=type=secret,id=HTTPS_PROXY \
+    --mount=type=secret,id=NO_PROXY \
+    export HTTP_PROXY="$(cat /run/secrets/HTTP_PROXY 2>/dev/null || true)" && \
+    export HTTPS_PROXY="$(cat /run/secrets/HTTPS_PROXY 2>/dev/null || true)" && \
+    export NO_PROXY="$(cat /run/secrets/NO_PROXY 2>/dev/null || true)" && \
+    export http_proxy="${HTTP_PROXY}" https_proxy="${HTTPS_PROXY}" no_proxy="${NO_PROXY}" && \
+    set -e && \
     for pkg in ${AI_TOOL_PACKAGES}; do \
       npm install -g "$pkg"; \
     done
 
 ARG AI_TOOLS_SHELL_INSTALL_B64=
-RUN if [ -n "${AI_TOOLS_SHELL_INSTALL_B64}" ]; then \
+RUN --mount=type=secret,id=HTTP_PROXY \
+    --mount=type=secret,id=HTTPS_PROXY \
+    --mount=type=secret,id=NO_PROXY \
+    export HTTP_PROXY="$(cat /run/secrets/HTTP_PROXY 2>/dev/null || true)" && \
+    export HTTPS_PROXY="$(cat /run/secrets/HTTPS_PROXY 2>/dev/null || true)" && \
+    export NO_PROXY="$(cat /run/secrets/NO_PROXY 2>/dev/null || true)" && \
+    export http_proxy="${HTTP_PROXY}" https_proxy="${HTTPS_PROXY}" no_proxy="${NO_PROXY}" && \
+    if [ -n "${AI_TOOLS_SHELL_INSTALL_B64}" ]; then \
       set -e && \
       echo "${AI_TOOLS_SHELL_INSTALL_B64}" | base64 -d > /tmp/ai-tools-install.sh && \
       bash /tmp/ai-tools-install.sh && \
       rm /tmp/ai-tools-install.sh; \
     fi
 
-RUN npm install -g pyright
+RUN --mount=type=secret,id=HTTP_PROXY \
+    --mount=type=secret,id=HTTPS_PROXY \
+    --mount=type=secret,id=NO_PROXY \
+    export HTTP_PROXY="$(cat /run/secrets/HTTP_PROXY 2>/dev/null || true)" && \
+    export HTTPS_PROXY="$(cat /run/secrets/HTTPS_PROXY 2>/dev/null || true)" && \
+    export NO_PROXY="$(cat /run/secrets/NO_PROXY 2>/dev/null || true)" && \
+    export http_proxy="${HTTP_PROXY}" https_proxy="${HTTPS_PROXY}" no_proxy="${NO_PROXY}" && \
+    npm install -g pyright
 
 RUN mkdir -p /home/devuser/.local/share /home/devuser/.local/state
 

package/lib/sandbox/runtimes/base.dockerfile

@@ -19,7 +19,14 @@ RUN if [ "${HOST_UID}" = "0" ]; then \
         useradd -u ${HOST_UID} -g ${HOST_GID} -m -s /bin/bash devuser; \
     fi
 
-RUN apt-get update && apt-get install -y \
+RUN --mount=type=secret,id=HTTP_PROXY \
+    --mount=type=secret,id=HTTPS_PROXY \
+    --mount=type=secret,id=NO_PROXY \
+    export HTTP_PROXY="$(cat /run/secrets/HTTP_PROXY 2>/dev/null || true)" && \
+    export HTTPS_PROXY="$(cat /run/secrets/HTTPS_PROXY 2>/dev/null || true)" && \
+    export NO_PROXY="$(cat /run/secrets/NO_PROXY 2>/dev/null || true)" && \
+    export http_proxy="${HTTP_PROXY}" https_proxy="${HTTPS_PROXY}" no_proxy="${NO_PROXY}" && \
+    apt-get update && apt-get install -y \
     curl wget git vim file jq \
     build-essential ca-certificates gnupg lsb-release \
     libevent-core-2.1-7 libncursesw6 libtinfo6 \

package/lib/sandbox/runtimes/java17.dockerfile

@@ -1,3 +1,10 @@
-RUN apt-get update && apt-get install -y \
+RUN --mount=type=secret,id=HTTP_PROXY \
+    --mount=type=secret,id=HTTPS_PROXY \
+    --mount=type=secret,id=NO_PROXY \
+    export HTTP_PROXY="$(cat /run/secrets/HTTP_PROXY 2>/dev/null || true)" && \
+    export HTTPS_PROXY="$(cat /run/secrets/HTTPS_PROXY 2>/dev/null || true)" && \
+    export NO_PROXY="$(cat /run/secrets/NO_PROXY 2>/dev/null || true)" && \
+    export http_proxy="${HTTP_PROXY}" https_proxy="${HTTPS_PROXY}" no_proxy="${NO_PROXY}" && \
+    apt-get update && apt-get install -y \
     openjdk-17-jdk maven \
     && rm -rf /var/lib/apt/lists/*

package/lib/sandbox/runtimes/java21.dockerfile

@@ -1,3 +1,10 @@
-RUN apt-get update && apt-get install -y \
+RUN --mount=type=secret,id=HTTP_PROXY \
+    --mount=type=secret,id=HTTPS_PROXY \
+    --mount=type=secret,id=NO_PROXY \
+    export HTTP_PROXY="$(cat /run/secrets/HTTP_PROXY 2>/dev/null || true)" && \
+    export HTTPS_PROXY="$(cat /run/secrets/HTTPS_PROXY 2>/dev/null || true)" && \
+    export NO_PROXY="$(cat /run/secrets/NO_PROXY 2>/dev/null || true)" && \
+    export http_proxy="${HTTP_PROXY}" https_proxy="${HTTPS_PROXY}" no_proxy="${NO_PROXY}" && \
+    apt-get update && apt-get install -y \
     openjdk-21-jdk maven \
     && rm -rf /var/lib/apt/lists/*