// Gateway agent list projection.

// Combines configured agents and existing on-disk agent state for lightweight UI use.

import fs from "node:fs";

import path from "node:path";

import { normalizeOptionalString } from "@openclaw/normalization-core/string-coerce";

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

import { normalizeAgentId, normalizeMainKey } from "../routing/session-key.js";

// Basic agent list data is used by lightweight gateway/control surfaces that do

// not need full session rows. Configured agents stay authoritative, while disk

// state contributes existing agent ids when config does not explicitly narrow.

type GatewayAgentListRow = {

id: string;

name?: string;

}

}

// Keep the default agent first for UI selection while preserving deterministic

// ordering for the remaining configured/on-disk ids.

function listConfiguredAgentIds(cfg: OpenClawConfig): string[] {

const ids = new Set<string>();

const defaultId = normalizeAgentId(resolveDefaultAgentId(cfg));

const sorted = Array.from(ids).filter(Boolean);

sorted.sort((a, b) => a.localeCompare(b));

// Keep the default agent first for UI selection while preserving deterministic

// ordering for the remaining configured/on-disk ids.

return sorted.includes(defaultId)

? [defaultId, ...sorted.filter((id) => id !== defaultId)]

: sorted;

// Gateway agent prompt builder.

// Converts conversation entries into the latest-message-plus-history prompt.

import { STREAM_ERROR_FALLBACK_TEXT } from "../agents/stream-message-shared.js";

import { buildHistoryContextFromEntries, type HistoryEntry } from "../auto-reply/reply/history.js";

import { extractTextFromChatContent } from "../shared/chat-content.js";

};

}

/** Build the prompt text sent to an agent from ordered conversation entries. */

export function buildAgentMessageFromConversationEntries(entries: ConversationEntry[]): string {

if (entries.length === 0) {

return "";

// Claude CLI session history importer.

// Converts Claude project JSONL into OpenClaw transcript-compatible messages.

import fs from "node:fs";

import os from "node:os";

import path from "node:path";

const block = cloneJsonValue(item as ToolContentBlock);

const type = typeof block.type === "string" ? block.type : "";

if (type === "tool_use") {

// Claude stores tool calls as `tool_use` with `input`; OpenClaw history

// expects `toolcall` plus `arguments` so replay remains provider-neutral.

const id = normalizeOptionalString(block.id) ?? "";

const name = normalizeOptionalString(block.name) ?? "";

if (id && name) {

return undefined;

}

/** Reads visible messages for a bound Claude CLI session. */

export function readClaudeCliSessionMessages(params: {

cliSessionId: string;

homeDir?: string;

}

if (isCompactBoundary(parsed)) {

// Compact boundaries split Claude history into context windows. Keep the

// latest summary plus only post-boundary turns for fallback seeding.

lastSummary = pendingSummary;

pendingSummary = undefined;

lastBoundaryFallback = extractCompactBoundaryFallbackText(parsed) ?? lastBoundaryFallback;

// Imported CLI history merge helpers.

// Deduplicates external history messages against local OpenClaw transcripts.

import { asFiniteNumber } from "@openclaw/normalization-core/number-coercion";

import {

normalizeOptionalString,

const DEDUPE_TIMESTAMP_WINDOW_MS = 5 * 60 * 1000;

// Imported CLI history can overlap local transcript writes. Dedupe prefers

// stable imported external ids, then falls back to role/text/timestamp matching.

function extractComparableText(message: unknown): string | undefined {

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

return undefined;

// Control UI shared URL helpers.

// Normalizes base paths and avatar URLs for browser/gateway surfaces.

import {

isAvatarHttpUrl,

isAvatarImageDataUrl,

const CONTROL_UI_AVATAR_PREFIX = "/avatar";

// Control UI URL helpers keep browser bootstrap paths stable across root and

// subpath deployments, including avatar paths proxied through the gateway.

/** Normalizes a Control UI base path to either "" or a leading-slash path without trailing slash. */

export function normalizeControlUiBasePath(basePath?: string): string {

if (!basePath) {

// Gateway setup prompt shared constants.

// Provides Tailscale copy and Control UI origin updates for CLI setup flows.

import { isIpv6Address, parseCanonicalIpAddress } from "@openclaw/net-policy/ip";

import { normalizeLowercaseStringOrEmpty } from "@openclaw/normalization-core/string-coerce";

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

const existing = params.config.gateway?.controlUi?.allowedOrigins ?? [];

const updatedOrigins = appendAllowedOrigin(existing, tsOrigin);

// Preserve all unrelated gateway/controlUi config while adding the derived

// tailnet origin, because setup writes partial gateway config objects.

return {

...params.config,

gateway: {

// Gateway HTTP session kill handler.

// Allows local admins or owning parent sessions to stop subagent runs.

import type { IncomingMessage, ServerResponse } from "node:http";

import { normalizeOptionalString } from "@openclaw/normalization-core/string-coerce";

import {

const allowLocalAdminKill = isLocalDirectRequest(req, trustedProxies, allowRealIpFallback);

const requestedScopes = resolveTrustedHttpOperatorScopes(req, requestAuth);

// Remote browser requests must prove parent-session ownership; local direct

// operator requests can perform the stronger admin kill path.

if (!requesterSessionKey && !allowLocalAdminKill) {

sendJson(res, 403, {

ok: false,

// Filesystem transcript indexer.

// Streams JSONL transcript files into byte-offset indexes for history paging.

import fs from "node:fs";

import { StringDecoder } from "node:string_decoder";

/**

* Streaming JSONL transcript index used by gateway history reads.

*

* The index keeps byte offsets for visible entries so callers can page large

* transcripts without decoding every message body into memory.

*/

const TRANSCRIPT_INDEX_READ_CHUNK_BYTES = 64 * 1024;

const MAX_TRANSCRIPT_INDEX_CACHE_ENTRIES = 256;

const MAX_TRANSCRIPT_INDEX_PARSE_LINE_BYTES = 256 * 1024;

// Shared-auth websocket test helpers.

// Opens authenticated gateway sockets and reads config snapshots in tests.

import { expect } from "vitest";

import { WebSocket } from "ws";

import { connectOk, rpcReq, trackConnectChallengeNonce } from "./test-helpers.js";

return ws;

}

/** Waits for a gateway websocket to close and returns the close details. */

export async function waitForGatewayWsClose(

ws: WebSocket,

timeoutMs = 10_000,

});

}

/** Loads the current config through the gateway RPC API for mutation tests. */

export async function loadGatewayConfig(ws: WebSocket): Promise<{

hash: string;

config: Record<string, unknown>;

// Temporary Gateway config test helper.

// Installs isolated config files and restores process-global config state.

import { mkdtemp, rm, writeFile } from "node:fs/promises";

import os from "node:os";

import path from "node:path";

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

import { clearSecretsRuntimeSnapshot } from "../secrets/runtime.js";

/**

* Temporary gateway config helper for tests that need isolated config files.

*/

function withStableOwnerDisplaySecretForTest(cfg: unknown): unknown {

if (!cfg || typeof cfg !== "object" || Array.isArray(cfg)) {

return cfg;

try {

await writeFile(configPath, JSON.stringify(testConfig, null, 2), "utf-8");

// Mirror both on-disk and runtime snapshots so code paths using either

// config IO layer see the same isolated fixture.

clearConfigCache();

resetConfigRuntimeState();

clearSecretsRuntimeSnapshot();