import { scheduleGatewaySigusr1Restart } from "../../infra/restart.js";

import { createSubsystemLogger } from "../../logging/subsystem.js";

import { collectEnabledInsecureOrDangerousFlags } from "../../security/dangerous-config-flags.js";

import { parseConfigPathArrayIndex } from "../../shared/path-array-index.js";

import { optionalNonNegativeIntegerSchema, stringEnum } from "../schema/typebox.js";

import {

type AnyAgentTool,

jsonResult,

readNonNegativeIntegerParam,

readStringArrayParam,

readStringParam,

textResult,

ToolInputError,

} from "./common.js";

import { gatewayCallOptionSchemaProperties } from "./gateway-schema.js";

import { callGatewayTool, readGatewayCallOptions } from "./gateway.js";

const log = createSubsystemLogger("gateway-tool");

const DEFAULT_UPDATE_TIMEOUT_MS = 20 * 60_000;

// Keep complete JSON below the smallest default tool-result presentation budget.

const MAX_GATEWAY_CONFIG_GET_TEXT_CHARS = 12_000;

const CONFIG_SCHEMA_PATH_NOT_FOUND_MESSAGE = "config schema path not found";

// Per SECURITY.md the model/agent itself is not a trusted principal.

// `assertGatewayConfigMutationAllowed` is the explicit model -> operator

return config as Record<string, unknown>;

}

function splitGatewayConfigGetPath(path: string): string[] {

return path

.trim()

.replace(/\[(\d+)\]/g, ".$1")

.split(".")

.filter(Boolean);

}

function resolveGatewayConfigGetPath(config: Record<string, unknown>, path: string): unknown {

const parts = splitGatewayConfigGetPath(path);

if (parts.length === 0) {

return undefined;

}

let current: unknown = config;

for (const part of parts) {

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

return undefined;

}

if (Array.isArray(current)) {

const index = parseConfigPathArrayIndex(part);

if (index === undefined || index >= current.length) {

return undefined;

}

current = current[index];

continue;

}

if (!Object.hasOwn(current, part)) {

return undefined;

}

current = (current as Record<string, unknown>)[part];

}

return current;

}

function selectGatewayConfigGetResult(snapshot: unknown, path: string | undefined): unknown {

if (!path) {

return snapshot;

}

const value = resolveGatewayConfigGetPath(getSnapshotConfig(snapshot), path);

if (value === undefined) {

throw new ToolInputError(`config path not found: ${path}`);

}

const hash = readStringValue((snapshot as { hash?: unknown }).hash);

return {

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

path,

config: value,

};

}

function createGatewayConfigGetToolResult(result: unknown) {

const text = JSON.stringify({ ok: true, result }, null, 2);

if (text.length > MAX_GATEWAY_CONFIG_GET_TEXT_CHARS) {

throw new ToolInputError(

"config.get response is too large; use path to request a narrower config subtree",

);

}

return textResult(text, { ok: true });

}

// Direct RPC callers need the validated config echoed after writes; the

// agent-facing gateway tool does not, and replaying it bloats transcripts.

function stripConfigWriteResultPayload(result: unknown): unknown {

continuationMessage: Type.Optional(Type.String()),

// config.get, config.schema.lookup, config.apply, update.run

...gatewayCallOptionSchemaProperties(),

// config.schema.lookup

// config.get, config.schema.lookup

path: Type.Optional(Type.String()),

// config.apply, config.patch

raw: Type.Optional(Type.String()),

};

if (action === "config.get") {

const result = await callGatewayTool("config.get", gatewayOpts, {});

return jsonResult({ ok: true, result });

const path = readStringParam(params, "path");

const snapshot = await callGatewayTool("config.get", gatewayOpts, {});

const result = selectGatewayConfigGetResult(snapshot, path);

return createGatewayConfigGetToolResult(result);

}

if (action === "config.schema.lookup") {

const path = readStringParam(params, "path", {