openclawdreams 2.3.0 → 2.4.0

package/dist/openclaw/src/agents/sandbox/browser.js

@@ -1,339 +0,0 @@
-import crypto from "node:crypto";
-import { startBrowserBridgeServer, stopBrowserBridgeServer } from "../../browser/bridge-server.js";
-import { resolveProfile } from "../../browser/config.js";
-import { DEFAULT_BROWSER_EVALUATE_ENABLED, DEFAULT_OPENCLAW_BROWSER_COLOR, DEFAULT_OPENCLAW_BROWSER_PROFILE_NAME, } from "../../browser/constants.js";
-import { deriveDefaultBrowserCdpPortRange } from "../../config/port-defaults.js";
-import { defaultRuntime } from "../../runtime.js";
-import { BROWSER_BRIDGES } from "./browser-bridges.js";
-import { computeSandboxBrowserConfigHash } from "./config-hash.js";
-import { resolveSandboxBrowserDockerCreateConfig } from "./config.js";
-import { DEFAULT_SANDBOX_BROWSER_IMAGE, SANDBOX_BROWSER_SECURITY_HASH_EPOCH } from "./constants.js";
-import { buildSandboxCreateArgs, dockerContainerState, execDocker, readDockerContainerEnvVar, readDockerContainerLabel, readDockerPort, } from "./docker.js";
-import { buildNoVncObserverTokenUrl, consumeNoVncObserverToken, generateNoVncPassword, isNoVncEnabled, NOVNC_PASSWORD_ENV_KEY, issueNoVncObserverToken, } from "./novnc-auth.js";
-import { readBrowserRegistry, updateBrowserRegistry } from "./registry.js";
-import { resolveSandboxAgentId, slugifySessionKey } from "./shared.js";
-import { isToolAllowed } from "./tool-policy.js";
-import { validateNetworkMode } from "./validate-sandbox-security.js";
-import { appendWorkspaceMountArgs } from "./workspace-mounts.js";
-const HOT_BROWSER_WINDOW_MS = 5 * 60 * 1000;
-const CDP_SOURCE_RANGE_ENV_KEY = "OPENCLAW_BROWSER_CDP_SOURCE_RANGE";
-async function waitForSandboxCdp(params) {
-    const deadline = Date.now() + Math.max(0, params.timeoutMs);
-    const url = `http://127.0.0.1:${params.cdpPort}/json/version`;
-    while (Date.now() < deadline) {
-        try {
-            const ctrl = new AbortController();
-            const t = setTimeout(ctrl.abort.bind(ctrl), 1000);
-            try {
-                const res = await fetch(url, { signal: ctrl.signal });
-                if (res.ok) {
-                    return true;
-                }
-            }
-            finally {
-                clearTimeout(t);
-            }
-        }
-        catch {
-            // ignore
-        }
-        await new Promise((r) => setTimeout(r, 150));
-    }
-    return false;
-}
-function buildSandboxBrowserResolvedConfig(params) {
-    const cdpHost = "127.0.0.1";
-    const cdpPortRange = deriveDefaultBrowserCdpPortRange(params.controlPort);
-    return {
-        enabled: true,
-        evaluateEnabled: params.evaluateEnabled,
-        controlPort: params.controlPort,
-        cdpProtocol: "http",
-        cdpHost,
-        cdpIsLoopback: true,
-        cdpPortRangeStart: cdpPortRange.start,
-        cdpPortRangeEnd: cdpPortRange.end,
-        remoteCdpTimeoutMs: 1500,
-        remoteCdpHandshakeTimeoutMs: 3000,
-        color: DEFAULT_OPENCLAW_BROWSER_COLOR,
-        executablePath: undefined,
-        headless: params.headless,
-        noSandbox: false,
-        attachOnly: true,
-        defaultProfile: DEFAULT_OPENCLAW_BROWSER_PROFILE_NAME,
-        extraArgs: [],
-        profiles: {
-            [DEFAULT_OPENCLAW_BROWSER_PROFILE_NAME]: {
-                cdpPort: params.cdpPort,
-                color: DEFAULT_OPENCLAW_BROWSER_COLOR,
-            },
-        },
-    };
-}
-async function ensureSandboxBrowserImage(image) {
-    const result = await execDocker(["image", "inspect", image], {
-        allowFailure: true,
-    });
-    if (result.code === 0) {
-        return;
-    }
-    throw new Error(`Sandbox browser image not found: ${image}. Build it with scripts/sandbox-browser-setup.sh.`);
-}
-async function ensureDockerNetwork(network, opts) {
-    validateNetworkMode(network, {
-        allowContainerNamespaceJoin: opts?.allowContainerNamespaceJoin === true,
-    });
-    const normalized = network.trim().toLowerCase();
-    if (!normalized || normalized === "bridge" || normalized === "none") {
-        return;
-    }
-    const inspect = await execDocker(["network", "inspect", network], { allowFailure: true });
-    if (inspect.code === 0) {
-        return;
-    }
-    await execDocker(["network", "create", "--driver", "bridge", network]);
-}
-export async function ensureSandboxBrowser(params) {
-    if (!params.cfg.browser.enabled) {
-        return null;
-    }
-    if (!isToolAllowed(params.cfg.tools, "browser")) {
-        return null;
-    }
-    const slug = params.cfg.scope === "shared" ? "shared" : slugifySessionKey(params.scopeKey);
-    const name = `${params.cfg.browser.containerPrefix}${slug}`;
-    const containerName = name.slice(0, 63);
-    const state = await dockerContainerState(containerName);
-    const browserImage = params.cfg.browser.image ?? DEFAULT_SANDBOX_BROWSER_IMAGE;
-    const cdpSourceRange = params.cfg.browser.cdpSourceRange?.trim() || undefined;
-    const browserDockerCfg = resolveSandboxBrowserDockerCreateConfig({
-        docker: params.cfg.docker,
-        browser: { ...params.cfg.browser, image: browserImage },
-    });
-    const expectedHash = computeSandboxBrowserConfigHash({
-        docker: browserDockerCfg,
-        browser: {
-            cdpPort: params.cfg.browser.cdpPort,
-            vncPort: params.cfg.browser.vncPort,
-            noVncPort: params.cfg.browser.noVncPort,
-            headless: params.cfg.browser.headless,
-            enableNoVnc: params.cfg.browser.enableNoVnc,
-            cdpSourceRange,
-        },
-        securityEpoch: SANDBOX_BROWSER_SECURITY_HASH_EPOCH,
-        workspaceAccess: params.cfg.workspaceAccess,
-        workspaceDir: params.workspaceDir,
-        agentWorkspaceDir: params.agentWorkspaceDir,
-    });
-    const now = Date.now();
-    let hasContainer = state.exists;
-    let running = state.running;
-    let currentHash = null;
-    let hashMismatch = false;
-    const noVncEnabled = isNoVncEnabled(params.cfg.browser);
-    let noVncPassword;
-    if (hasContainer) {
-        if (noVncEnabled) {
-            noVncPassword =
-                (await readDockerContainerEnvVar(containerName, NOVNC_PASSWORD_ENV_KEY)) ?? undefined;
-        }
-        const registry = await readBrowserRegistry();
-        const registryEntry = registry.entries.find((entry) => entry.containerName === containerName);
-        currentHash = await readDockerContainerLabel(containerName, "openclaw.configHash");
-        hashMismatch = !currentHash || currentHash !== expectedHash;
-        if (!currentHash) {
-            currentHash = registryEntry?.configHash ?? null;
-            hashMismatch = !currentHash || currentHash !== expectedHash;
-        }
-        if (hashMismatch) {
-            const lastUsedAtMs = registryEntry?.lastUsedAtMs;
-            const isHot = running && (typeof lastUsedAtMs !== "number" || now - lastUsedAtMs < HOT_BROWSER_WINDOW_MS);
-            if (isHot) {
-                const hint = (() => {
-                    if (params.cfg.scope === "session") {
-                        return `openclaw sandbox recreate --browser --session ${params.scopeKey}`;
-                    }
-                    if (params.cfg.scope === "agent") {
-                        const agentId = resolveSandboxAgentId(params.scopeKey) ?? "main";
-                        return `openclaw sandbox recreate --browser --agent ${agentId}`;
-                    }
-                    return "openclaw sandbox recreate --browser --all";
-                })();
-                defaultRuntime.log(`Sandbox browser config changed for ${containerName} (recently used). Recreate to apply: ${hint}`);
-            }
-            else {
-                await execDocker(["rm", "-f", containerName], { allowFailure: true });
-                hasContainer = false;
-                running = false;
-            }
-        }
-    }
-    if (!hasContainer) {
-        if (noVncEnabled) {
-            noVncPassword = generateNoVncPassword();
-        }
-        await ensureDockerNetwork(browserDockerCfg.network, {
-            allowContainerNamespaceJoin: browserDockerCfg.dangerouslyAllowContainerNamespaceJoin === true,
-        });
-        await ensureSandboxBrowserImage(browserImage);
-        const args = buildSandboxCreateArgs({
-            name: containerName,
-            cfg: browserDockerCfg,
-            scopeKey: params.scopeKey,
-            labels: {
-                "openclaw.sandboxBrowser": "1",
-                "openclaw.browserConfigEpoch": SANDBOX_BROWSER_SECURITY_HASH_EPOCH,
-            },
-            configHash: expectedHash,
-            includeBinds: false,
-            bindSourceRoots: [params.workspaceDir, params.agentWorkspaceDir],
-        });
-        appendWorkspaceMountArgs({
-            args,
-            workspaceDir: params.workspaceDir,
-            agentWorkspaceDir: params.agentWorkspaceDir,
-            workdir: params.cfg.docker.workdir,
-            workspaceAccess: params.cfg.workspaceAccess,
-        });
-        if (browserDockerCfg.binds?.length) {
-            for (const bind of browserDockerCfg.binds) {
-                args.push("-v", bind);
-            }
-        }
-        args.push("-p", `127.0.0.1::${params.cfg.browser.cdpPort}`);
-        if (noVncEnabled) {
-            args.push("-p", `127.0.0.1::${params.cfg.browser.noVncPort}`);
-        }
-        args.push("-e", `OPENCLAW_BROWSER_HEADLESS=${params.cfg.browser.headless ? "1" : "0"}`);
-        args.push("-e", `OPENCLAW_BROWSER_ENABLE_NOVNC=${params.cfg.browser.enableNoVnc ? "1" : "0"}`);
-        args.push("-e", `OPENCLAW_BROWSER_CDP_PORT=${params.cfg.browser.cdpPort}`);
-        if (cdpSourceRange) {
-            args.push("-e", `${CDP_SOURCE_RANGE_ENV_KEY}=${cdpSourceRange}`);
-        }
-        args.push("-e", `OPENCLAW_BROWSER_VNC_PORT=${params.cfg.browser.vncPort}`);
-        args.push("-e", `OPENCLAW_BROWSER_NOVNC_PORT=${params.cfg.browser.noVncPort}`);
-        // Chromium's setuid/namespace sandbox cannot work inside Docker containers
-        // (PID namespace creation requires privileges Docker does not grant by default).
-        // The container itself provides isolation, so --no-sandbox is safe here.
-        args.push("-e", "OPENCLAW_BROWSER_NO_SANDBOX=1");
-        if (noVncEnabled && noVncPassword) {
-            args.push("-e", `${NOVNC_PASSWORD_ENV_KEY}=${noVncPassword}`);
-        }
-        args.push(browserImage);
-        await execDocker(args);
-        await execDocker(["start", containerName]);
-    }
-    else if (!running) {
-        await execDocker(["start", containerName]);
-    }
-    const mappedCdp = await readDockerPort(containerName, params.cfg.browser.cdpPort);
-    if (!mappedCdp) {
-        throw new Error(`Failed to resolve CDP port mapping for ${containerName}.`);
-    }
-    const mappedNoVnc = noVncEnabled
-        ? await readDockerPort(containerName, params.cfg.browser.noVncPort)
-        : null;
-    if (noVncEnabled && !noVncPassword) {
-        noVncPassword =
-            (await readDockerContainerEnvVar(containerName, NOVNC_PASSWORD_ENV_KEY)) ?? undefined;
-    }
-    const existing = BROWSER_BRIDGES.get(params.scopeKey);
-    const existingProfile = existing
-        ? resolveProfile(existing.bridge.state.resolved, DEFAULT_OPENCLAW_BROWSER_PROFILE_NAME)
-        : null;
-    let desiredAuthToken = params.bridgeAuth?.token?.trim() || undefined;
-    let desiredAuthPassword = params.bridgeAuth?.password?.trim() || undefined;
-    if (!desiredAuthToken && !desiredAuthPassword) {
-        // Always require auth for the sandbox bridge server, even if gateway auth
-        // mode doesn't produce a shared secret (e.g. trusted-proxy).
-        // Keep it stable across calls by reusing the existing bridge auth.
-        desiredAuthToken = existing?.authToken;
-        desiredAuthPassword = existing?.authPassword;
-        if (!desiredAuthToken && !desiredAuthPassword) {
-            desiredAuthToken = crypto.randomBytes(24).toString("hex");
-        }
-    }
-    const shouldReuse = existing && existing.containerName === containerName && existingProfile?.cdpPort === mappedCdp;
-    const authMatches = !existing ||
-        (existing.authToken === desiredAuthToken && existing.authPassword === desiredAuthPassword);
-    if (existing && !shouldReuse) {
-        await stopBrowserBridgeServer(existing.bridge.server).catch(() => undefined);
-        BROWSER_BRIDGES.delete(params.scopeKey);
-    }
-    if (existing && shouldReuse && !authMatches) {
-        await stopBrowserBridgeServer(existing.bridge.server).catch(() => undefined);
-        BROWSER_BRIDGES.delete(params.scopeKey);
-    }
-    const bridge = (() => {
-        if (shouldReuse && authMatches && existing) {
-            return existing.bridge;
-        }
-        return null;
-    })();
-    const ensureBridge = async () => {
-        if (bridge) {
-            return bridge;
-        }
-        const onEnsureAttachTarget = params.cfg.browser.autoStart
-            ? async () => {
-                const state = await dockerContainerState(containerName);
-                if (state.exists && !state.running) {
-                    await execDocker(["start", containerName]);
-                }
-                const ok = await waitForSandboxCdp({
-                    cdpPort: mappedCdp,
-                    timeoutMs: params.cfg.browser.autoStartTimeoutMs,
-                });
-                if (!ok) {
-                    throw new Error(`Sandbox browser CDP did not become reachable on 127.0.0.1:${mappedCdp} within ${params.cfg.browser.autoStartTimeoutMs}ms.`);
-                }
-            }
-            : undefined;
-        return await startBrowserBridgeServer({
-            resolved: buildSandboxBrowserResolvedConfig({
-                controlPort: 0,
-                cdpPort: mappedCdp,
-                headless: params.cfg.browser.headless,
-                evaluateEnabled: params.evaluateEnabled ?? DEFAULT_BROWSER_EVALUATE_ENABLED,
-            }),
-            authToken: desiredAuthToken,
-            authPassword: desiredAuthPassword,
-            onEnsureAttachTarget,
-            resolveSandboxNoVncToken: consumeNoVncObserverToken,
-        });
-    };
-    const resolvedBridge = await ensureBridge();
-    if (!shouldReuse || !authMatches) {
-        BROWSER_BRIDGES.set(params.scopeKey, {
-            bridge: resolvedBridge,
-            containerName,
-            authToken: desiredAuthToken,
-            authPassword: desiredAuthPassword,
-        });
-    }
-    await updateBrowserRegistry({
-        containerName,
-        sessionKey: params.scopeKey,
-        createdAtMs: now,
-        lastUsedAtMs: now,
-        image: browserImage,
-        configHash: hashMismatch && running ? (currentHash ?? undefined) : expectedHash,
-        cdpPort: mappedCdp,
-        noVncPort: mappedNoVnc ?? undefined,
-    });
-    const noVncUrl = mappedNoVnc && noVncEnabled
-        ? (() => {
-            const token = issueNoVncObserverToken({
-                noVncPort: mappedNoVnc,
-                password: noVncPassword,
-            });
-            return buildNoVncObserverTokenUrl(resolvedBridge.baseUrl, token);
-        })()
-        : undefined;
-    return {
-        bridgeUrl: resolvedBridge.baseUrl,
-        noVncUrl,
-        containerName,
-    };
-}
-//# sourceMappingURL=browser.js.map

package/dist/openclaw/src/agents/sandbox/config-hash.d.ts

@@ -1,19 +0,0 @@
-import type { SandboxBrowserConfig, SandboxDockerConfig, SandboxWorkspaceAccess } from "./types.js";
-type SandboxHashInput = {
-    docker: SandboxDockerConfig;
-    workspaceAccess: SandboxWorkspaceAccess;
-    workspaceDir: string;
-    agentWorkspaceDir: string;
-};
-type SandboxBrowserHashInput = {
-    docker: SandboxDockerConfig;
-    browser: Pick<SandboxBrowserConfig, "cdpPort" | "cdpSourceRange" | "vncPort" | "noVncPort" | "headless" | "enableNoVnc">;
-    securityEpoch: string;
-    workspaceAccess: SandboxWorkspaceAccess;
-    workspaceDir: string;
-    agentWorkspaceDir: string;
-};
-export declare function computeSandboxConfigHash(input: SandboxHashInput): string;
-export declare function computeSandboxBrowserConfigHash(input: SandboxBrowserHashInput): string;
-export {};
-//# sourceMappingURL=config-hash.d.ts.map

package/dist/openclaw/src/agents/sandbox/config-hash.js

@@ -1,33 +0,0 @@
-import { hashTextSha256 } from "./hash.js";
-function normalizeForHash(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (Array.isArray(value)) {
-        return value.map(normalizeForHash).filter((item) => item !== undefined);
-    }
-    if (value && typeof value === "object") {
-        const entries = Object.entries(value).toSorted(([a], [b]) => a.localeCompare(b));
-        const normalized = {};
-        for (const [key, entryValue] of entries) {
-            const next = normalizeForHash(entryValue);
-            if (next !== undefined) {
-                normalized[key] = next;
-            }
-        }
-        return normalized;
-    }
-    return value;
-}
-export function computeSandboxConfigHash(input) {
-    return computeHash(input);
-}
-export function computeSandboxBrowserConfigHash(input) {
-    return computeHash(input);
-}
-function computeHash(input) {
-    const payload = normalizeForHash(input);
-    const raw = JSON.stringify(payload);
-    return hashTextSha256(raw);
-}
-//# sourceMappingURL=config-hash.js.map

package/dist/openclaw/src/agents/sandbox/config.d.ts

@@ -1,28 +0,0 @@
-import type { OpenClawConfig } from "../../config/config.js";
-import type { SandboxBrowserConfig, SandboxConfig, SandboxDockerConfig, SandboxPruneConfig, SandboxScope } from "./types.js";
-export declare const DANGEROUS_SANDBOX_DOCKER_BOOLEAN_KEYS: readonly ["dangerouslyAllowReservedContainerTargets", "dangerouslyAllowExternalBindSources", "dangerouslyAllowContainerNamespaceJoin"];
-export declare function resolveSandboxBrowserDockerCreateConfig(params: {
-    docker: SandboxDockerConfig;
-    browser: SandboxBrowserConfig;
-}): SandboxDockerConfig;
-export declare function resolveSandboxScope(params: {
-    scope?: SandboxScope;
-    perSession?: boolean;
-}): SandboxScope;
-export declare function resolveSandboxDockerConfig(params: {
-    scope: SandboxScope;
-    globalDocker?: Partial<SandboxDockerConfig>;
-    agentDocker?: Partial<SandboxDockerConfig>;
-}): SandboxDockerConfig;
-export declare function resolveSandboxBrowserConfig(params: {
-    scope: SandboxScope;
-    globalBrowser?: Partial<SandboxBrowserConfig>;
-    agentBrowser?: Partial<SandboxBrowserConfig>;
-}): SandboxBrowserConfig;
-export declare function resolveSandboxPruneConfig(params: {
-    scope: SandboxScope;
-    globalPrune?: Partial<SandboxPruneConfig>;
-    agentPrune?: Partial<SandboxPruneConfig>;
-}): SandboxPruneConfig;
-export declare function resolveSandboxConfigForAgent(cfg?: OpenClawConfig, agentId?: string): SandboxConfig;
-//# sourceMappingURL=config.d.ts.map

package/dist/openclaw/src/agents/sandbox/config.js

@@ -1,147 +0,0 @@
-import { resolveAgentConfig } from "../agent-scope.js";
-import { DEFAULT_SANDBOX_BROWSER_AUTOSTART_TIMEOUT_MS, DEFAULT_SANDBOX_BROWSER_CDP_PORT, DEFAULT_SANDBOX_BROWSER_IMAGE, DEFAULT_SANDBOX_BROWSER_NETWORK, DEFAULT_SANDBOX_BROWSER_NOVNC_PORT, DEFAULT_SANDBOX_BROWSER_PREFIX, DEFAULT_SANDBOX_BROWSER_VNC_PORT, DEFAULT_SANDBOX_CONTAINER_PREFIX, DEFAULT_SANDBOX_IDLE_HOURS, DEFAULT_SANDBOX_IMAGE, DEFAULT_SANDBOX_MAX_AGE_DAYS, DEFAULT_SANDBOX_WORKDIR, DEFAULT_SANDBOX_WORKSPACE_ROOT, } from "./constants.js";
-import { resolveSandboxToolPolicyForAgent } from "./tool-policy.js";
-export const DANGEROUS_SANDBOX_DOCKER_BOOLEAN_KEYS = [
-    "dangerouslyAllowReservedContainerTargets",
-    "dangerouslyAllowExternalBindSources",
-    "dangerouslyAllowContainerNamespaceJoin",
-];
-function resolveDangerousSandboxDockerBooleans(agentDocker, globalDocker) {
-    const resolved = {};
-    for (const key of DANGEROUS_SANDBOX_DOCKER_BOOLEAN_KEYS) {
-        resolved[key] = agentDocker?.[key] ?? globalDocker?.[key];
-    }
-    return resolved;
-}
-export function resolveSandboxBrowserDockerCreateConfig(params) {
-    const browserNetwork = params.browser.network.trim();
-    const base = {
-        ...params.docker,
-        // Browser container needs network access for Chrome, downloads, etc.
-        network: browserNetwork || DEFAULT_SANDBOX_BROWSER_NETWORK,
-        // For hashing and consistency, treat browser image as the docker image even though we
-        // pass it separately as the final `docker create` argument.
-        image: params.browser.image,
-    };
-    return params.browser.binds !== undefined ? { ...base, binds: params.browser.binds } : base;
-}
-export function resolveSandboxScope(params) {
-    if (params.scope) {
-        return params.scope;
-    }
-    if (typeof params.perSession === "boolean") {
-        return params.perSession ? "session" : "shared";
-    }
-    return "agent";
-}
-export function resolveSandboxDockerConfig(params) {
-    const agentDocker = params.scope === "shared" ? undefined : params.agentDocker;
-    const globalDocker = params.globalDocker;
-    const env = agentDocker?.env
-        ? { ...(globalDocker?.env ?? { LANG: "C.UTF-8" }), ...agentDocker.env }
-        : (globalDocker?.env ?? { LANG: "C.UTF-8" });
-    const ulimits = agentDocker?.ulimits
-        ? { ...globalDocker?.ulimits, ...agentDocker.ulimits }
-        : globalDocker?.ulimits;
-    const binds = [...(globalDocker?.binds ?? []), ...(agentDocker?.binds ?? [])];
-    return {
-        image: agentDocker?.image ?? globalDocker?.image ?? DEFAULT_SANDBOX_IMAGE,
-        containerPrefix: agentDocker?.containerPrefix ??
-            globalDocker?.containerPrefix ??
-            DEFAULT_SANDBOX_CONTAINER_PREFIX,
-        workdir: agentDocker?.workdir ?? globalDocker?.workdir ?? DEFAULT_SANDBOX_WORKDIR,
-        readOnlyRoot: agentDocker?.readOnlyRoot ?? globalDocker?.readOnlyRoot ?? true,
-        tmpfs: agentDocker?.tmpfs ?? globalDocker?.tmpfs ?? ["/tmp", "/var/tmp", "/run"],
-        network: agentDocker?.network ?? globalDocker?.network ?? "none",
-        user: agentDocker?.user ?? globalDocker?.user,
-        capDrop: agentDocker?.capDrop ?? globalDocker?.capDrop ?? ["ALL"],
-        env,
-        setupCommand: agentDocker?.setupCommand ?? globalDocker?.setupCommand,
-        pidsLimit: agentDocker?.pidsLimit ?? globalDocker?.pidsLimit,
-        memory: agentDocker?.memory ?? globalDocker?.memory,
-        memorySwap: agentDocker?.memorySwap ?? globalDocker?.memorySwap,
-        cpus: agentDocker?.cpus ?? globalDocker?.cpus,
-        ulimits,
-        seccompProfile: agentDocker?.seccompProfile ?? globalDocker?.seccompProfile,
-        apparmorProfile: agentDocker?.apparmorProfile ?? globalDocker?.apparmorProfile,
-        dns: agentDocker?.dns ?? globalDocker?.dns,
-        extraHosts: agentDocker?.extraHosts ?? globalDocker?.extraHosts,
-        binds: binds.length ? binds : undefined,
-        ...resolveDangerousSandboxDockerBooleans(agentDocker, globalDocker),
-    };
-}
-export function resolveSandboxBrowserConfig(params) {
-    const agentBrowser = params.scope === "shared" ? undefined : params.agentBrowser;
-    const globalBrowser = params.globalBrowser;
-    const binds = [...(globalBrowser?.binds ?? []), ...(agentBrowser?.binds ?? [])];
-    // Treat `binds: []` as an explicit override, so it can disable `docker.binds` for the browser container.
-    const bindsConfigured = globalBrowser?.binds !== undefined || agentBrowser?.binds !== undefined;
-    return {
-        enabled: agentBrowser?.enabled ?? globalBrowser?.enabled ?? false,
-        image: agentBrowser?.image ?? globalBrowser?.image ?? DEFAULT_SANDBOX_BROWSER_IMAGE,
-        containerPrefix: agentBrowser?.containerPrefix ??
-            globalBrowser?.containerPrefix ??
-            DEFAULT_SANDBOX_BROWSER_PREFIX,
-        network: agentBrowser?.network ?? globalBrowser?.network ?? DEFAULT_SANDBOX_BROWSER_NETWORK,
-        cdpPort: agentBrowser?.cdpPort ?? globalBrowser?.cdpPort ?? DEFAULT_SANDBOX_BROWSER_CDP_PORT,
-        cdpSourceRange: agentBrowser?.cdpSourceRange ?? globalBrowser?.cdpSourceRange,
-        vncPort: agentBrowser?.vncPort ?? globalBrowser?.vncPort ?? DEFAULT_SANDBOX_BROWSER_VNC_PORT,
-        noVncPort: agentBrowser?.noVncPort ?? globalBrowser?.noVncPort ?? DEFAULT_SANDBOX_BROWSER_NOVNC_PORT,
-        headless: agentBrowser?.headless ?? globalBrowser?.headless ?? false,
-        enableNoVnc: agentBrowser?.enableNoVnc ?? globalBrowser?.enableNoVnc ?? true,
-        allowHostControl: agentBrowser?.allowHostControl ?? globalBrowser?.allowHostControl ?? false,
-        autoStart: agentBrowser?.autoStart ?? globalBrowser?.autoStart ?? true,
-        autoStartTimeoutMs: agentBrowser?.autoStartTimeoutMs ??
-            globalBrowser?.autoStartTimeoutMs ??
-            DEFAULT_SANDBOX_BROWSER_AUTOSTART_TIMEOUT_MS,
-        binds: bindsConfigured ? binds : undefined,
-    };
-}
-export function resolveSandboxPruneConfig(params) {
-    const agentPrune = params.scope === "shared" ? undefined : params.agentPrune;
-    const globalPrune = params.globalPrune;
-    return {
-        idleHours: agentPrune?.idleHours ?? globalPrune?.idleHours ?? DEFAULT_SANDBOX_IDLE_HOURS,
-        maxAgeDays: agentPrune?.maxAgeDays ?? globalPrune?.maxAgeDays ?? DEFAULT_SANDBOX_MAX_AGE_DAYS,
-    };
-}
-export function resolveSandboxConfigForAgent(cfg, agentId) {
-    const agent = cfg?.agents?.defaults?.sandbox;
-    // Agent-specific sandbox config overrides global
-    let agentSandbox;
-    const agentConfig = cfg && agentId ? resolveAgentConfig(cfg, agentId) : undefined;
-    if (agentConfig?.sandbox) {
-        agentSandbox = agentConfig.sandbox;
-    }
-    const scope = resolveSandboxScope({
-        scope: agentSandbox?.scope ?? agent?.scope,
-        perSession: agentSandbox?.perSession ?? agent?.perSession,
-    });
-    const toolPolicy = resolveSandboxToolPolicyForAgent(cfg, agentId);
-    return {
-        mode: agentSandbox?.mode ?? agent?.mode ?? "off",
-        scope,
-        workspaceAccess: agentSandbox?.workspaceAccess ?? agent?.workspaceAccess ?? "none",
-        workspaceRoot: agentSandbox?.workspaceRoot ?? agent?.workspaceRoot ?? DEFAULT_SANDBOX_WORKSPACE_ROOT,
-        docker: resolveSandboxDockerConfig({
-            scope,
-            globalDocker: agent?.docker,
-            agentDocker: agentSandbox?.docker,
-        }),
-        browser: resolveSandboxBrowserConfig({
-            scope,
-            globalBrowser: agent?.browser,
-            agentBrowser: agentSandbox?.browser,
-        }),
-        tools: {
-            allow: toolPolicy.allow,
-            deny: toolPolicy.deny,
-        },
-        prune: resolveSandboxPruneConfig({
-            scope,
-            globalPrune: agent?.prune,
-            agentPrune: agentSandbox?.prune,
-        }),
-    };
-}
-//# sourceMappingURL=config.js.map

package/dist/openclaw/src/agents/sandbox/constants.d.ts

@@ -1,22 +0,0 @@
-export declare const DEFAULT_SANDBOX_WORKSPACE_ROOT: string;
-export declare const DEFAULT_SANDBOX_IMAGE = "openclaw-sandbox:bookworm-slim";
-export declare const DEFAULT_SANDBOX_CONTAINER_PREFIX = "openclaw-sbx-";
-export declare const DEFAULT_SANDBOX_WORKDIR = "/workspace";
-export declare const DEFAULT_SANDBOX_IDLE_HOURS = 24;
-export declare const DEFAULT_SANDBOX_MAX_AGE_DAYS = 7;
-export declare const DEFAULT_TOOL_ALLOW: readonly ["exec", "process", "read", "write", "edit", "apply_patch", "image", "sessions_list", "sessions_history", "sessions_send", "sessions_spawn", "subagents", "session_status"];
-export declare const DEFAULT_TOOL_DENY: readonly ["browser", "canvas", "nodes", "cron", "gateway", "telegram", "whatsapp", "discord", "irc", "googlechat", "slack", "signal", "imessage"];
-export declare const DEFAULT_SANDBOX_BROWSER_IMAGE = "openclaw-sandbox-browser:bookworm-slim";
-export declare const DEFAULT_SANDBOX_COMMON_IMAGE = "openclaw-sandbox-common:bookworm-slim";
-export declare const SANDBOX_BROWSER_SECURITY_HASH_EPOCH = "2026-02-28-no-sandbox-env";
-export declare const DEFAULT_SANDBOX_BROWSER_PREFIX = "openclaw-sbx-browser-";
-export declare const DEFAULT_SANDBOX_BROWSER_NETWORK = "openclaw-sandbox-browser";
-export declare const DEFAULT_SANDBOX_BROWSER_CDP_PORT = 9222;
-export declare const DEFAULT_SANDBOX_BROWSER_VNC_PORT = 5900;
-export declare const DEFAULT_SANDBOX_BROWSER_NOVNC_PORT = 6080;
-export declare const DEFAULT_SANDBOX_BROWSER_AUTOSTART_TIMEOUT_MS = 12000;
-export declare const SANDBOX_AGENT_WORKSPACE_MOUNT = "/agent";
-export declare const SANDBOX_STATE_DIR: string;
-export declare const SANDBOX_REGISTRY_PATH: string;
-export declare const SANDBOX_BROWSER_REGISTRY_PATH: string;
-//# sourceMappingURL=constants.d.ts.map

package/dist/openclaw/src/agents/sandbox/constants.js

@@ -1,47 +0,0 @@
-import path from "node:path";
-import { CHANNEL_IDS } from "../../channels/registry.js";
-import { STATE_DIR } from "../../config/config.js";
-export const DEFAULT_SANDBOX_WORKSPACE_ROOT = path.join(STATE_DIR, "sandboxes");
-export const DEFAULT_SANDBOX_IMAGE = "openclaw-sandbox:bookworm-slim";
-export const DEFAULT_SANDBOX_CONTAINER_PREFIX = "openclaw-sbx-";
-export const DEFAULT_SANDBOX_WORKDIR = "/workspace";
-export const DEFAULT_SANDBOX_IDLE_HOURS = 24;
-export const DEFAULT_SANDBOX_MAX_AGE_DAYS = 7;
-export const DEFAULT_TOOL_ALLOW = [
-    "exec",
-    "process",
-    "read",
-    "write",
-    "edit",
-    "apply_patch",
-    "image",
-    "sessions_list",
-    "sessions_history",
-    "sessions_send",
-    "sessions_spawn",
-    "subagents",
-    "session_status",
-];
-// Provider docking: keep sandbox policy aligned with provider tool names.
-export const DEFAULT_TOOL_DENY = [
-    "browser",
-    "canvas",
-    "nodes",
-    "cron",
-    "gateway",
-    ...CHANNEL_IDS,
-];
-export const DEFAULT_SANDBOX_BROWSER_IMAGE = "openclaw-sandbox-browser:bookworm-slim";
-export const DEFAULT_SANDBOX_COMMON_IMAGE = "openclaw-sandbox-common:bookworm-slim";
-export const SANDBOX_BROWSER_SECURITY_HASH_EPOCH = "2026-02-28-no-sandbox-env";
-export const DEFAULT_SANDBOX_BROWSER_PREFIX = "openclaw-sbx-browser-";
-export const DEFAULT_SANDBOX_BROWSER_NETWORK = "openclaw-sandbox-browser";
-export const DEFAULT_SANDBOX_BROWSER_CDP_PORT = 9222;
-export const DEFAULT_SANDBOX_BROWSER_VNC_PORT = 5900;
-export const DEFAULT_SANDBOX_BROWSER_NOVNC_PORT = 6080;
-export const DEFAULT_SANDBOX_BROWSER_AUTOSTART_TIMEOUT_MS = 12_000;
-export const SANDBOX_AGENT_WORKSPACE_MOUNT = "/agent";
-export const SANDBOX_STATE_DIR = path.join(STATE_DIR, "sandbox");
-export const SANDBOX_REGISTRY_PATH = path.join(SANDBOX_STATE_DIR, "containers.json");
-export const SANDBOX_BROWSER_REGISTRY_PATH = path.join(SANDBOX_STATE_DIR, "browsers.json");
-//# sourceMappingURL=constants.js.map

package/dist/openclaw/src/agents/sandbox/context.d.ts

@@ -1,21 +0,0 @@
-import type { OpenClawConfig } from "../../config/config.js";
-import type { SandboxContext, SandboxDockerConfig, SandboxWorkspaceInfo } from "./types.js";
-export declare function resolveSandboxDockerUser(params: {
-    docker: SandboxDockerConfig;
-    workspaceDir: string;
-    stat?: (workspaceDir: string) => Promise<{
-        uid: number;
-        gid: number;
-    }>;
-}): Promise<SandboxDockerConfig>;
-export declare function resolveSandboxContext(params: {
-    config?: OpenClawConfig;
-    sessionKey?: string;
-    workspaceDir?: string;
-}): Promise<SandboxContext | null>;
-export declare function ensureSandboxWorkspaceForSession(params: {
-    config?: OpenClawConfig;
-    sessionKey?: string;
-    workspaceDir?: string;
-}): Promise<SandboxWorkspaceInfo | null>;
-//# sourceMappingURL=context.d.ts.map