/** Tests CLI backend config resolution, normalization, and live-test defaults. */

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

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

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

context?: CliBackendNormalizeConfigContext,

) => CliBackendConfig;

}) {

// Runtime/setup backend entries share most shape; tests build both from one

// helper so registry behavior stays aligned.

return {

pluginId: params.pluginId,

source: "test",

args: string[] | undefined,

permission: { mode?: string; overrideExisting: boolean },

): string[] | undefined {

// Mirrors Claude backend normalization without loading the bundled runtime.

if (!args) {

return permission.mode ? ["--permission-mode", permission.mode] : args;

}

/** Tests CLI credential parsing, cache expiry, and safe keychain/file writes. */

import fs from "node:fs";

import os from "node:os";

import path from "node:path";

let readGeminiCliCredentialsCached: typeof import("./cli-credentials.js").readGeminiCliCredentialsCached;

function mockExistingClaudeKeychainItem() {

// The macOS security CLI returns the whole JSON payload as password data.

execFileSyncMock.mockImplementation((file: unknown, args: unknown) => {

const argv = Array.isArray(args) ? args.map(String) : [];

if (String(file) === "security" && argv.includes("find-generic-password")) {

}

function createJwtWithExp(expSeconds: number): string {

// Signature verification is out of scope; expiration extraction only needs a

// syntactically valid JWT-like payload.

const encode = (value: Record<string, unknown>) =>

Buffer.from(JSON.stringify(value)).toString("base64url");

return `${encode({ alg: "RS256", typ: "JWT" })}.${encode({ exp: expSeconds })}.signature`;

}

function expectFields(value: unknown, expected: Record<string, unknown>): void {

// Keeps large credential objects readable while still asserting exact fields

// relevant to the branch under test.

if (!value || typeof value !== "object") {

throw new Error("expected fields object");

}

/** Tests CLI JSON/JSONL output parsing, streamed deltas, and error extraction. */

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

import {

createCliJsonlStreamingParser,

/** Tests Code Mode tool registration, namespace filtering, and run lifecycle. */

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

import { isRecord } from "../../packages/normalization-core/src/record-coerce.js";

import { setPluginToolMeta } from "../plugins/tools.js";

import { jsonResult, type AnyAgentTool } from "./tools/common.js";

function fakeTool(name: string, description: string): AnyAgentTool {

// Minimal tool shape keeps Code Mode catalog tests runtime-free.

return {

name,

label: name,

operation?: "tool" | "resources_list" | "resources_read" | "prompts_list" | "prompts_get";

execute?: AnyAgentTool["execute"];

}): AnyAgentTool {

// MCP metadata drives Code Mode grouping and raw tool routing.

const tool: AnyAgentTool = {

name: params.name,

label: params.toolName,

code: string;

language?: "javascript" | "typescript";

}) {

// Code Mode may return a waiting state before completion; tests poll through

// the public wait tool instead of reaching into activeRuns.

let details = resultDetails(

await params.execTool.execute("code-call-1", {

code: params.code,