} from "./cli-runner.test-support.js";

import { executePreparedCliRun } from "./cli-runner/execute.js";

import { resolveCliNoOutputTimeoutMs } from "./cli-runner/helpers.js";

import * as sessionHistoryModule from "./cli-runner/session-history.js";

import { MAX_CLI_SESSION_HISTORY_MESSAGES } from "./cli-runner/session-history.js";

import type { PreparedCliRunContext } from "./cli-runner/types.js";

}

});

it("does not emit llm_output when the CLI run returns no assistant text", async () => {

const hookRunner = {

hasHooks: vi.fn((hookName: string) => hookName === "llm_output"),

runLlmInput: vi.fn(async () => undefined),

runLlmOutput: vi.fn(async () => undefined),

runAgentEnd: vi.fn(async () => undefined),

};

mockGetGlobalHookRunner.mockReturnValue(hookRunner as never);

supervisorSpawnMock.mockResolvedValueOnce(

createManagedRun({

reason: "exit",

exitCode: 0,

exitSignal: null,

durationMs: 50,

stdout: " ",

stderr: "",

timedOut: false,

noOutputTimedOut: false,

}),

);

const result = await runPreparedCliAgent(buildPreparedContext());

expect(result.payloads).toBeUndefined();

expect(hookRunner.runLlmOutput).not.toHaveBeenCalled();

});

it("emits agent_end with failure details when the CLI run fails", async () => {

const hookRunner = {

hasHooks: vi.fn((hookName: string) => ["llm_input", "agent_end"].includes(hookName)),

fs.rmSync(dir, { recursive: true, force: true });

}

});

it("skips transcript loading when only llm_output hooks are active", async () => {

const hookRunner = {

hasHooks: vi.fn((hookName: string) => hookName === "llm_output"),

runLlmInput: vi.fn(async () => undefined),

runLlmOutput: vi.fn(async () => undefined),

runAgentEnd: vi.fn(async () => undefined),

};

mockGetGlobalHookRunner.mockReturnValue(hookRunner as never);

const historySpy = vi.spyOn(sessionHistoryModule, "loadCliSessionHistoryMessages");

supervisorSpawnMock.mockResolvedValueOnce(

createManagedRun({

reason: "exit",

exitCode: 0,

exitSignal: null,

durationMs: 50,

stdout: "hello from cli",

stderr: "",

timedOut: false,

noOutputTimedOut: false,

}),

);

try {

await runPreparedCliAgent(buildPreparedContext());

expect(historySpy).not.toHaveBeenCalled();

await vi.waitFor(() => {

expect(hookRunner.runLlmOutput).toHaveBeenCalledTimes(1);

});

} finally {

historySpy.mockRestore();

}

});

});

describe("resolveCliNoOutputTimeoutMs", () => {

import { formatErrorMessage } from "../infra/errors.js";

import { getGlobalHookRunner } from "../plugins/hook-runner-global.js";

import { loadCliSessionHistoryMessages } from "./cli-runner/session-history.js";

import type { PreparedCliRunContext, RunCliAgentParams } from "./cli-runner/types.js";

import { FailoverError, isFailoverError, resolveFailoverStatus } from "./failover-error.js";

import { buildAgentHookConversationMessages } from "./harness/hook-history.js";

import {

runAgentHarnessAgentEndHook,

runAgentHarnessLlmInputHook,

): Promise<EmbeddedPiRunResult> {

const { executePreparedCliRun } = await import("./cli-runner/execute.runtime.js");

const { params } = context;

const historyMessages = loadCliSessionHistoryMessages({

sessionId: params.sessionId,

sessionFile: params.sessionFile,

sessionKey: params.sessionKey,

agentId: params.agentId,

config: params.config,

});

const hookRunner = getGlobalHookRunner();

const hasLlmInputHooks = hookRunner?.hasHooks("llm_input") === true;

const hasLlmOutputHooks = hookRunner?.hasHooks("llm_output") === true;

const hasAgentEndHooks = hookRunner?.hasHooks("agent_end") === true;

const historyMessages =

hasLlmInputHooks || hasAgentEndHooks

? loadCliSessionHistoryMessages({

sessionId: params.sessionId,

sessionFile: params.sessionFile,

sessionKey: params.sessionKey,

agentId: params.agentId,

config: params.config,

})

: [];

const llmInputEvent = {

runId: params.runId,

sessionId: params.sessionId,

} as const;

const buildAgentEndMessages = (lastAssistant?: unknown): unknown[] => [

...historyMessages,

buildCliHookUserMessage(params.prompt),

...(lastAssistant ? [lastAssistant] : []),

...buildAgentHookConversationMessages({

historyMessages,

currentTurnMessages: [

buildCliHookUserMessage(params.prompt),

...(lastAssistant ? [lastAssistant] : []),

],

}),

];

const buildFailedAgentEndEvent = (error: string) => ({

usage: output.usage,

})

: undefined;

runAgentHarnessLlmOutputHook({

event: {

runId: params.runId,

sessionId: params.sessionId,

provider: params.provider,

model: context.modelId,

assistantTexts,

...(lastAssistant ? { lastAssistant } : {}),

...(output.usage ? { usage: output.usage } : {}),

},

ctx: hookContext,

});

if (assistantText.length > 0 && hasLlmOutputHooks) {

runAgentHarnessLlmOutputHook({

event: {

runId: params.runId,

sessionId: params.sessionId,

provider: params.provider,

model: context.modelId,

assistantTexts,

...(lastAssistant ? { lastAssistant } : {}),

...(output.usage ? { usage: output.usage } : {}),

},

ctx: hookContext,

});

}

return { output, assistantText, lastAssistant };

};

}

});

it("rejects symlinked transcripts instead of following them outside the sessions directory", () => {

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

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

vi.stubEnv("OPENCLAW_STATE_DIR", stateDir);

const canonicalSessionFile = path.join(

stateDir,

"agents",

"main",

"sessions",

"session-symlink.jsonl",

);

const outsideFile = createSessionTranscript({

rootDir: outsideDir,

sessionId: "session-symlink",

filePath: path.join(outsideDir, "outside.jsonl"),

messages: ["stolen history"],

});

fs.mkdirSync(path.dirname(canonicalSessionFile), { recursive: true });

fs.symlinkSync(outsideFile, canonicalSessionFile);

try {

expect(

loadCliSessionHistoryMessages({

sessionId: "session-symlink",

sessionFile: canonicalSessionFile,

sessionKey: "agent:main:main",

agentId: "main",

}),

).toEqual([]);

} finally {

fs.rmSync(stateDir, { recursive: true, force: true });

fs.rmSync(outsideDir, { recursive: true, force: true });

}

});

it("drops oversized transcript files instead of loading them into hook payloads", () => {

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

vi.stubEnv("OPENCLAW_STATE_DIR", stateDir);

fs.rmSync(stateDir, { recursive: true, force: true });

}

});

it("honors custom session store roots when resolving hook history transcripts", () => {

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

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

vi.stubEnv("OPENCLAW_STATE_DIR", stateDir);

const storePath = path.join(customStoreDir, "sessions.json");

fs.writeFileSync(storePath, "{}", "utf-8");

const sessionFile = createSessionTranscript({

rootDir: customStoreDir,

sessionId: "session-custom-store",

filePath: path.join(customStoreDir, "session-custom-store.jsonl"),

messages: ["custom store history"],

});

try {

expect(

loadCliSessionHistoryMessages({

sessionId: "session-custom-store",

sessionFile,

sessionKey: "agent:main:main",

agentId: "main",

config: {

session: {

store: storePath,

},

},

}),

).toMatchObject([{ role: "user", content: "custom store history" }]);

} finally {

fs.rmSync(stateDir, { recursive: true, force: true });

fs.rmSync(customStoreDir, { recursive: true, force: true });

}

});

});

import fs from "node:fs";

import path from "node:path";

import { SessionManager } from "@mariozechner/pi-coding-agent";

import {

resolveSessionFilePath,

resolveSessionFilePathOptions,

} from "../../config/sessions/paths.js";

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

import { resolveSessionAgentIds } from "../agent-scope.js";

import {

limitAgentHookHistoryMessages,

MAX_AGENT_HOOK_HISTORY_MESSAGES,

} from "../harness/hook-history.js";

export const MAX_CLI_SESSION_HISTORY_FILE_BYTES = 5 * 1024 * 1024;

export const MAX_CLI_SESSION_HISTORY_MESSAGES = 200;

export const MAX_CLI_SESSION_HISTORY_MESSAGES = MAX_AGENT_HOOK_HISTORY_MESSAGES;

function safeRealpathSync(filePath: string): string | undefined {

try {

return fs.realpathSync(filePath);

} catch {

return undefined;

}

}

function isPathWithinBase(basePath: string, targetPath: string): boolean {

const relative = path.relative(basePath, targetPath);

return Boolean(relative) && !relative.startsWith("..") && !path.isAbsolute(relative);

}

function resolveSafeCliSessionFile(params: {

sessionId: string;

sessionFile: string;

sessionKey?: string;

agentId?: string;

config?: OpenClawConfig;

}): string {

}): { sessionFile: string; sessionsDir: string } {

const { defaultAgentId, sessionAgentId } = resolveSessionAgentIds({

sessionKey: params.sessionKey,

config: params.config,

agentId: params.agentId,

});

return resolveSessionFilePath(

const pathOptions = resolveSessionFilePathOptions({

agentId: sessionAgentId ?? defaultAgentId,

storePath: params.config?.session?.store,

});

const sessionFile = resolveSessionFilePath(

params.sessionId,

{ sessionFile: params.sessionFile },

resolveSessionFilePathOptions({

agentId: sessionAgentId ?? defaultAgentId,

}),

pathOptions,

);

return {

sessionFile,

sessionsDir: pathOptions?.sessionsDir ?? path.dirname(sessionFile),

};

}

export function loadCliSessionHistoryMessages(params: {

config?: OpenClawConfig;

}): unknown[] {

try {

const sessionFile = resolveSafeCliSessionFile(params);

if (!fs.existsSync(sessionFile)) {

const { sessionFile, sessionsDir } = resolveSafeCliSessionFile(params);

const entryStat = fs.lstatSync(sessionFile);

if (!entryStat.isFile() || entryStat.isSymbolicLink()) {

return [];

}

const stat = fs.statSync(sessionFile);

if (!stat.isFile() || stat.size > MAX_CLI_SESSION_HISTORY_FILE_BYTES) {

const realSessionsDir = safeRealpathSync(sessionsDir) ?? path.resolve(sessionsDir);

const realSessionFile = safeRealpathSync(sessionFile);

if (!realSessionFile || !isPathWithinBase(realSessionsDir, realSessionFile)) {

return [];

}

const entries = SessionManager.open(sessionFile).getEntries();

const history: unknown[] = [];

for (let index = entries.length - 1; index >= 0; index -= 1) {

const entry = entries[index];

if (entry?.type !== "message") {

continue;

}

history.push(entry.message as unknown);

if (history.length >= MAX_CLI_SESSION_HISTORY_MESSAGES) {

break;

}

const stat = fs.statSync(realSessionFile);

if (!stat.isFile() || stat.size > MAX_CLI_SESSION_HISTORY_FILE_BYTES) {

return [];

}

history.reverse();

return history;

const entries = SessionManager.open(realSessionFile).getEntries();

const history = entries.flatMap((entry) =>

entry?.type === "message" ? [entry.message as unknown] : [],

);

return limitAgentHookHistoryMessages(history, MAX_CLI_SESSION_HISTORY_MESSAGES);

} catch {

return [];

}

hooks?: {

/** Controls prompt mutation via before_prompt_build and prompt fields from legacy before_agent_start. */

allowPromptInjection?: boolean;

/**

* Controls access to raw conversation content from llm_input/llm_output/agent_end hooks.

* Non-bundled plugins must opt in explicitly; bundled plugins stay allowed unless disabled.

*/

allowConversationAccess?: boolean;

};

subagent?: {

/** Explicitly allow this plugin to request per-run provider/model overrides for subagent runs. */