/** Tests diagnostic cache-trace event writing, redaction, and stream wrapping. */

import crypto from "node:crypto";

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

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

describe("createCacheTrace", () => {

function createMemoryTraceForTest() {

const lines: string[] = [];

// In-memory writer keeps cache trace assertions deterministic without

// touching real diagnostic log paths.

const trace = createCacheTrace({

cfg: {

diagnostics: {

const parent: Record<string, unknown> = { role: "user", content: "hello" };

const child: Record<string, unknown> = { ref: parent };

parent.child = child; // circular reference

// Cache tracing must fingerprint cyclic prompt payloads instead of recursing forever.

parent.child = child;

trace?.recordStage("prompt:images", {

messages: [parent] as unknown as [],

/** Tests SQLite-backed scoped agent cache entries and adapter ownership. */

import fs from "node:fs";

import os from "node:os";

import path from "node:path";

}

afterEach(() => {

// SQLite handles are shared by state dir/agent id; close them so temp dirs can

// be removed and tests cannot leak rows across cases.

closeOpenClawAgentDatabasesForTest();

closeOpenClawStateDatabaseForTest();

});

database.db

.prepare("update cache_entries set expires_at = ? where scope = ? and key = ?")

.run(Number.MAX_SAFE_INTEGER, "runtime", "invalid");

// Simulate a corrupted persisted timestamp that the public writer rejects.

expect(

readSqliteAgentCacheEntry({

/** Tests channel action discovery from plugin message-tool descriptors. */

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

import type { ChannelPlugin } from "../channels/plugins/types.js";

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

const errorSpy = vi.spyOn(defaultRuntime, "error").mockImplementation(() => undefined);

beforeEach(() => {

// A throwing plugin verifies discovery degrades and logs once instead of

// making all channel tooling unavailable.

const plugin: ChannelPlugin = {

id: "test",

meta: {

/** Tests Chutes OAuth token exchange and refresh HTTP flows. */

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

import { withFetchPreconnect } from "../test-utils/fetch-mock.js";

import {

refreshed: Awaited<ReturnType<typeof refreshChutesTokens>>,

now: number,

) {

// Refresh responses may omit refresh_token; the stored token remains valid and

// expiry keeps the safety skew applied.

expect(refreshed.access).toBe("at_new");

expect(refreshed.refresh).toBe("rt_old");

expect(refreshed.expires).toBe(now + 1800 * 1000 - 5 * 60 * 1000);

/** Tests Chutes OAuth callback parsing and PKCE generation. */

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

import { generateChutesPkce, parseOAuthCallbackInput } from "./chutes-oauth.js";

/** Tests CLI auth epoch stability across token refreshes and identity changes. */

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

import type { AuthProfileStore } from "./auth-profiles/types.js";

import {

epoch: Awaited<ReturnType<typeof resolveCliAuthEpoch>>,

label = "auth epoch",

): asserts epoch is string {

// Epochs are cache/session keys, so tests assert hash shape without caring

// about the exact digest value.

expect(typeof epoch, label).toBe("string");

expect(epoch, label).toMatch(/^[a-f0-9]{64}$/);

}