/** Tests cron before_agent_reply gating at the CLI runner entrypoint. */

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

import { SILENT_REPLY_TOKEN } from "../auto-reply/tokens.js";

import { cliBackendLog } from "./cli-runner/log.js";

let runCliAgent: typeof import("./cli-runner.js").runCliAgent;

function makeStubContext(params: typeof baseRunParams & { trigger?: string }) {

// Stub only the prepared context shape runCliAgent needs after the hook gate.

return {

params,

started: Date.now(),

const syntheticTurnLog = logInfoSpy.mock.calls

.map(([message]) => message)

.find((message) => message.startsWith("cli synthetic turn:"));

// Synthetic turn logs prove the branch without leaking hook reply text.

expect(syntheticTurnLog).toContain("provider=codex-cli");

expect(syntheticTurnLog).toContain("model=<synthetic>");

expect(syntheticTurnLog).toContain("requestedModel=gpt-5.5");

/** Tests bounded transcript-flush probing before reusing CLI bindings. */

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

import {

isCliBindingFlushed,

it("schedules at most 0 + 50 + 150ms of delay across the bounded retry", async () => {

vi.useFakeTimers();

try {

// Fake timers enforce the retry contract without introducing wall-clock

// sleeps into this import-heavy agent test.

const probe = vi.fn(async () => false);

setCliRunnerTestDeps({ claudeCliSessionTranscriptHasContent: probe });

/** E2E proof for CLI runner bundle-MCP subprocess execution. */

import fs from "node:fs/promises";

import os from "node:os";

import path from "node:path";

}

async function resetBundleMcpPluginState() {

// Bundle MCP setup caches plugin discovery; reset between temp plugin roots.

const { resetPluginLoaderTestStateForTest } = await import("../plugins/loader.test-fixtures.js");

const { clearPluginSetupRegistryCache } = await import("../plugins/setup-registry.js");

resetPluginLoaderTestStateForTest();

liveSession?: boolean;

tempPrefix: string;

}): Promise<BundleMcpFixture> {

// Fixture creates a real temp plugin + MCP server + fake CLI binary, but keeps

// it isolated from persisted plugin registry state.

await resetBundleMcpPluginState();

const envSnapshot = captureEnv([

"HOME",

sessionId: string;

workspaceDir: string;

}): Promise<PreparedCliRunContext> {

// Exercise bundle MCP config preparation while bypassing unrelated full

// runCliAgent context assembly.

const { prepareCliBundleMcpConfig } = await import("./cli-runner/bundle-mcp.js");

const preparedBackend = (await prepareCliBundleMcpConfig({

enabled: true,

/** Tests CLI runner integration with context-engine lifecycle hooks. */

import type { AgentMessage } from "openclaw/plugin-sdk/agent-core";

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

import type { ContextEngine } from "../context-engine/types.js";

}

function createContextEngine(overrides: Partial<ContextEngine> = {}): ContextEngine {

// Minimal context engine keeps tests focused on runner lifecycle calls.

return {

info: { id: "test-context-engine", name: "Test context engine" },

ingest: vi.fn(async () => ({ ingested: true })),

}

function buildPreparedContext(contextEngine: ContextEngine): PreparedCliRunContext {

// Prepared contexts mirror the shape produced by prepare.runtime without

// loading full backend setup in every lifecycle assertion.

const backend = {

command: "claude",

args: ["--print"],

}

function expectMessageText(message: AgentMessage | undefined, expected: string): void {

// Context engines may use legacy string content or structured text blocks.

expect(message).toBeDefined();

const content = (message as { content?: unknown } | undefined)?.content;

if (typeof content === "string") {

/** Tests CLI runner prompt/image/system-prompt helper utilities. */

import fs from "node:fs/promises";

import path from "node:path";

import { MAX_IMAGE_BYTES } from "@openclaw/media-core/constants";

describe("loadPromptRefImages", () => {

beforeEach(() => {

// Restore spies because these helpers use real modules with per-test mocks.

vi.restoreAllMocks();

});

}),

).resolves.toStrictEqual([]);

// Cached image paths are generated output, not fresh user references.

expect(loadImageFromRefSpy).not.toHaveBeenCalled();

expect(sanitizeImageBlocksSpy).not.toHaveBeenCalled();

});

});

it("strips the internal cache boundary from CLI system prompt args", () => {

// The boundary is internal prompt-cache metadata and must never reach the

// downstream CLI as literal text.

expect(

buildCliArgs({

backend: {

/** Tests CLI runner reliability paths for hooks, transcripts, failover, and reply ops. */

import fs from "node:fs";

import os from "node:os";

import path from "node:path";

};

function setHookRunnerForTest(hookRunner: unknown): void {

// Keep the module-level hook runner singleton aligned with the mocked getter.

mockGetGlobalHookRunner.mockReturnValue(hookRunner as never);

const globalStore = globalThis as Record<PropertyKey, unknown>;

const state = (globalStore[hookRunnerGlobalStateKey] as

}

function createSessionFile(params?: { history?: Array<{ role: "user"; content: string }> }) {

// Session files use the real JSONL shape so transcript/history readers stay

// covered without spinning up a full CLI process.

const dir = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-cli-hooks-"));

vi.stubEnv("OPENCLAW_STATE_DIR", dir);

const sessionFile = path.join(dir, "agents", "main", "sessions", "s1.jsonl");

model?: string;

allowEmptyAssistantReplyAsSilent?: boolean;

}): PreparedCliRunContext {

// Common prepared context fixture for runPreparedCliAgent reliability branches.

const provider = params?.provider ?? "codex-cli";

const model = params?.model ?? "gpt-5.4";

const backend = {

/** Tests CLI runner process spawning, logging, diagnostics, and live-session paths. */

import fs from "node:fs/promises";

import os from "node:os";

import path from "node:path";

workspaceDir?: string;

timeoutMs?: number;

}): PreparedCliRunContext {

// Produces a prepared context without invoking prepare.runtime, keeping spawn

// assertions focused on execute/runtime behavior.

const workspaceDir = params.workspaceDir ?? "/tmp";

const baseBackend =

params.provider === "claude-cli"

promise: Promise<unknown>,

expected: Record<string, unknown>,

): Promise<Record<string, unknown>> {

// Failover errors carry structured fields; this helper verifies them while

// preserving the original object for deeper assertions.

try {

await promise;

} catch (error) {

/** Shared CLI runner test doubles for supervisor, bootstrap, and heartbeat seams. */

import type { Mock } from "vitest";

import { beforeEach, vi } from "vitest";

import type { requestHeartbeat } from "../infra/heartbeat-wake.js";

wait: async () => {

const exit = await wait();

if (params.captureOutput === false) {

// Production streams stdout/stderr through callbacks; replay captured

// output once so tests cover streaming and captured-output paths.

if (!stdoutDelivered && exit.stdout) {

params.onStdout?.(exit.stdout);

}