// Verifies runtime plugin loading can reuse a compatible gateway startup registry.

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

import { createEmptyPluginRegistry } from "../plugins/registry-empty.js";

import type { PluginRegistry } from "../plugins/registry-types.js";

]);

function createRegistryWithPlugin(pluginId: string): PluginRegistry {

// Minimal active registry carrying just enough plugin identity for reuse checks.

const registry = createEmptyPluginRegistry();

registry.plugins.push({

id: pluginId,

describe("ensureRuntimePluginsLoaded registry reuse", () => {

it("reuses the compatible gateway startup registry on the dispatch caller path", () => {

// Matching cache key plus gateway-bindable mode means no second plugin load.

const config = { plugins: { allow: ["telegram"] } };

const activeRegistry = createRegistryWithPlugin("telegram");

activeRegistry.coreGatewayMethodNames = ["sessions.get", "sessions.list"];

// Verifies runtime plugin loading scope, disablement, and gateway-bindable mode.

import { beforeEach, describe, expect, it, vi } from "vitest";

const hoisted = vi.hoisted(() => ({

let ensureRuntimePluginsLoaded: typeof import("./runtime-plugins.js").ensureRuntimePluginsLoaded;

beforeEach(async () => {

// Reset modules so each case sees fresh mocked runtime-plugin dependencies.

hoisted.getCurrentPluginMetadataSnapshot.mockReset();

hoisted.getCurrentPluginMetadataSnapshot.mockReturnValue(undefined);

hoisted.ensureStandaloneRuntimePluginRegistryLoaded.mockReset();

});

it("scopes runtime plugin loading to the current gateway startup plan", () => {

// Startup metadata narrows runtime loading to plugins already planned for gateway startup.

const config = {} as never;

hoisted.getCurrentPluginMetadataSnapshot.mockReturnValue({

startup: {

// Verifies agent-specific sandbox config, workspace roots, and Docker setup commands.

import { EventEmitter } from "node:events";

import path from "node:path";

import { Readable } from "node:stream";

vi.mock("node:child_process", () => ({

execFile: (...args: unknown[]) => {

// Docker availability probes should succeed without invoking real Docker.

const callback = args.findLast(

(arg): arg is (error: null, stdout: string, stderr: string) => void =>

typeof arg === "function",

let resolveSandboxRuntimeStatus: typeof import("./sandbox/runtime-status.js").resolveSandboxRuntimeStatus;

async function resolveContext(config: OpenClawConfig, sessionKey: string, workspaceDir: string) {

// Convenience wrapper keeps session-key specific sandbox context assertions compact.

return resolveSandboxContext({

config,

sessionKey,

}

function expectDockerSetupCommand(command: string) {

// Setup commands are executed through docker exec in the resolved container.

expect(

spawnCalls.some(

(call) =>

// Verifies Docker create arguments for sandbox hardening and configured passthrough.

import { describe, expect, it } from "vitest";

import { OPENCLAW_CLI_ENV_VALUE } from "../infra/openclaw-exec-env.js";

import { buildSandboxCreateArgs } from "./sandbox/docker.js";

overrides: Partial<SandboxDockerConfig> = {},

binds?: string[],

): SandboxDockerConfig {

// Baseline config keeps each Docker argument case focused on one override.

return {

image: "openclaw-sandbox:bookworm-slim",

containerPrefix: "openclaw-sbx-",

}

function valuesForFlag(args: string[], flag: string): string[] {

// Docker flags are positional, so collect repeated flag values for assertions.

const values: string[] = [];

for (let i = 0; i < args.length; i += 1) {

if (args[i] === flag) {

// Verifies sandbox tool-policy resolution and blocked-tool explanation text.

import { beforeEach, describe, expect, it, vi } from "vitest";

import type { OpenClawConfig } from "../config/config.js";

import { resolveSandboxConfigForAgent } from "./sandbox/config.js";

vi.mock("../logging/subsystem.js", () => ({

createSubsystemLogger: () => ({

// Audit logging is asserted without touching the real subsystem logger.

info: toolPolicyAuditInfo,

}),

}));

// Verifies sandbox media paths resolve through bridge and workspace-only guards.

import { describe, expect, it, vi } from "vitest";

import {

createSandboxBridgeReadFile,

});

it("keeps workspace-only container paths under the sandbox workspace mount", async () => {

// Container paths must stay inside the remote workspace mount when workspaceOnly is set.

const resolvePath = vi.fn(({ filePath }: { filePath: string }) => {

if (filePath === "/tmp/sandbox-root") {

return {