493 lines
14 KiB
TypeScript
493 lines
14 KiB
TypeScript
import type { GatewayRequestHandlers, RespondFn } from "./types.js";
|
|
import { resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../../agents/agent-scope.js";
|
|
import { listChannelPlugins } from "../../channels/plugins/index.js";
|
|
import {
|
|
CONFIG_PATH,
|
|
loadConfig,
|
|
parseConfigJson5,
|
|
readConfigFileSnapshot,
|
|
readConfigFileSnapshotForWrite,
|
|
resolveConfigSnapshotHash,
|
|
validateConfigObjectWithPlugins,
|
|
writeConfigFile,
|
|
} from "../../config/config.js";
|
|
import { applyLegacyMigrations } from "../../config/legacy.js";
|
|
import { applyMergePatch } from "../../config/merge-patch.js";
|
|
import {
|
|
redactConfigObject,
|
|
redactConfigSnapshot,
|
|
restoreRedactedValues,
|
|
} from "../../config/redact-snapshot.js";
|
|
import { buildConfigSchema, type ConfigSchemaResponse } from "../../config/schema.js";
|
|
import { extractDeliveryInfo } from "../../config/sessions.js";
|
|
import {
|
|
formatDoctorNonInteractiveHint,
|
|
type RestartSentinelPayload,
|
|
writeRestartSentinel,
|
|
} from "../../infra/restart-sentinel.js";
|
|
import { scheduleGatewaySigusr1Restart } from "../../infra/restart.js";
|
|
import { loadOpenClawPlugins } from "../../plugins/loader.js";
|
|
import {
|
|
ErrorCodes,
|
|
errorShape,
|
|
formatValidationErrors,
|
|
validateConfigApplyParams,
|
|
validateConfigGetParams,
|
|
validateConfigPatchParams,
|
|
validateConfigSchemaParams,
|
|
validateConfigSetParams,
|
|
} from "../protocol/index.js";
|
|
|
|
function resolveBaseHash(params: unknown): string | null {
|
|
const raw = (params as { baseHash?: unknown })?.baseHash;
|
|
if (typeof raw !== "string") {
|
|
return null;
|
|
}
|
|
const trimmed = raw.trim();
|
|
return trimmed ? trimmed : null;
|
|
}
|
|
|
|
function requireConfigBaseHash(
|
|
params: unknown,
|
|
snapshot: Awaited<ReturnType<typeof readConfigFileSnapshot>>,
|
|
respond: RespondFn,
|
|
): boolean {
|
|
if (!snapshot.exists) {
|
|
return true;
|
|
}
|
|
const snapshotHash = resolveConfigSnapshotHash(snapshot);
|
|
if (!snapshotHash) {
|
|
respond(
|
|
false,
|
|
undefined,
|
|
errorShape(
|
|
ErrorCodes.INVALID_REQUEST,
|
|
"config base hash unavailable; re-run config.get and retry",
|
|
),
|
|
);
|
|
return false;
|
|
}
|
|
const baseHash = resolveBaseHash(params);
|
|
if (!baseHash) {
|
|
respond(
|
|
false,
|
|
undefined,
|
|
errorShape(
|
|
ErrorCodes.INVALID_REQUEST,
|
|
"config base hash required; re-run config.get and retry",
|
|
),
|
|
);
|
|
return false;
|
|
}
|
|
if (baseHash !== snapshotHash) {
|
|
respond(
|
|
false,
|
|
undefined,
|
|
errorShape(
|
|
ErrorCodes.INVALID_REQUEST,
|
|
"config changed since last load; re-run config.get and retry",
|
|
),
|
|
);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function resolveConfigRestartRequest(params: unknown): {
|
|
sessionKey: string | undefined;
|
|
note: string | undefined;
|
|
restartDelayMs: number | undefined;
|
|
deliveryContext: ReturnType<typeof extractDeliveryInfo>["deliveryContext"];
|
|
threadId: ReturnType<typeof extractDeliveryInfo>["threadId"];
|
|
} {
|
|
const sessionKey =
|
|
typeof (params as { sessionKey?: unknown }).sessionKey === "string"
|
|
? (params as { sessionKey?: string }).sessionKey?.trim() || undefined
|
|
: undefined;
|
|
const note =
|
|
typeof (params as { note?: unknown }).note === "string"
|
|
? (params as { note?: string }).note?.trim() || undefined
|
|
: undefined;
|
|
const restartDelayMsRaw = (params as { restartDelayMs?: unknown }).restartDelayMs;
|
|
const restartDelayMs =
|
|
typeof restartDelayMsRaw === "number" && Number.isFinite(restartDelayMsRaw)
|
|
? Math.max(0, Math.floor(restartDelayMsRaw))
|
|
: undefined;
|
|
|
|
// Extract deliveryContext + threadId for routing after restart
|
|
// Supports both :thread: (most channels) and :topic: (Telegram)
|
|
const { deliveryContext, threadId } = extractDeliveryInfo(sessionKey);
|
|
|
|
return {
|
|
sessionKey,
|
|
note,
|
|
restartDelayMs,
|
|
deliveryContext,
|
|
threadId,
|
|
};
|
|
}
|
|
|
|
function buildConfigRestartSentinelPayload(params: {
|
|
kind: RestartSentinelPayload["kind"];
|
|
mode: string;
|
|
sessionKey: string | undefined;
|
|
deliveryContext: ReturnType<typeof extractDeliveryInfo>["deliveryContext"];
|
|
threadId: ReturnType<typeof extractDeliveryInfo>["threadId"];
|
|
note: string | undefined;
|
|
}): RestartSentinelPayload {
|
|
return {
|
|
kind: params.kind,
|
|
status: "ok",
|
|
ts: Date.now(),
|
|
sessionKey: params.sessionKey,
|
|
deliveryContext: params.deliveryContext,
|
|
threadId: params.threadId,
|
|
message: params.note ?? null,
|
|
doctorHint: formatDoctorNonInteractiveHint(),
|
|
stats: {
|
|
mode: params.mode,
|
|
root: CONFIG_PATH,
|
|
},
|
|
};
|
|
}
|
|
|
|
async function tryWriteRestartSentinelPayload(
|
|
payload: RestartSentinelPayload,
|
|
): Promise<string | null> {
|
|
try {
|
|
return await writeRestartSentinel(payload);
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function loadSchemaWithPlugins(): ConfigSchemaResponse {
|
|
const cfg = loadConfig();
|
|
const workspaceDir = resolveAgentWorkspaceDir(cfg, resolveDefaultAgentId(cfg));
|
|
const pluginRegistry = loadOpenClawPlugins({
|
|
config: cfg,
|
|
cache: true,
|
|
workspaceDir,
|
|
logger: {
|
|
info: () => {},
|
|
warn: () => {},
|
|
error: () => {},
|
|
debug: () => {},
|
|
},
|
|
});
|
|
// Note: We can't easily cache this, as there are no callback that can invalidate
|
|
// our cache. However, both loadConfig() and loadOpenClawPlugins() already cache
|
|
// their results, and buildConfigSchema() is just a cheap transformation.
|
|
return buildConfigSchema({
|
|
plugins: pluginRegistry.plugins.map((plugin) => ({
|
|
id: plugin.id,
|
|
name: plugin.name,
|
|
description: plugin.description,
|
|
configUiHints: plugin.configUiHints,
|
|
configSchema: plugin.configJsonSchema,
|
|
})),
|
|
channels: listChannelPlugins().map((entry) => ({
|
|
id: entry.id,
|
|
label: entry.meta.label,
|
|
description: entry.meta.blurb,
|
|
configSchema: entry.configSchema?.schema,
|
|
configUiHints: entry.configSchema?.uiHints,
|
|
})),
|
|
});
|
|
}
|
|
|
|
export const configHandlers: GatewayRequestHandlers = {
|
|
"config.get": async ({ params, respond }) => {
|
|
if (!validateConfigGetParams(params)) {
|
|
respond(
|
|
false,
|
|
undefined,
|
|
errorShape(
|
|
ErrorCodes.INVALID_REQUEST,
|
|
`invalid config.get params: ${formatValidationErrors(validateConfigGetParams.errors)}`,
|
|
),
|
|
);
|
|
return;
|
|
}
|
|
const snapshot = await readConfigFileSnapshot();
|
|
const schema = loadSchemaWithPlugins();
|
|
respond(true, redactConfigSnapshot(snapshot, schema.uiHints), undefined);
|
|
},
|
|
"config.schema": ({ params, respond }) => {
|
|
if (!validateConfigSchemaParams(params)) {
|
|
respond(
|
|
false,
|
|
undefined,
|
|
errorShape(
|
|
ErrorCodes.INVALID_REQUEST,
|
|
`invalid config.schema params: ${formatValidationErrors(validateConfigSchemaParams.errors)}`,
|
|
),
|
|
);
|
|
return;
|
|
}
|
|
respond(true, loadSchemaWithPlugins(), undefined);
|
|
},
|
|
"config.set": async ({ params, respond }) => {
|
|
if (!validateConfigSetParams(params)) {
|
|
respond(
|
|
false,
|
|
undefined,
|
|
errorShape(
|
|
ErrorCodes.INVALID_REQUEST,
|
|
`invalid config.set params: ${formatValidationErrors(validateConfigSetParams.errors)}`,
|
|
),
|
|
);
|
|
return;
|
|
}
|
|
const { snapshot, writeOptions } = await readConfigFileSnapshotForWrite();
|
|
if (!requireConfigBaseHash(params, snapshot, respond)) {
|
|
return;
|
|
}
|
|
const rawValue = (params as { raw?: unknown }).raw;
|
|
if (typeof rawValue !== "string") {
|
|
respond(
|
|
false,
|
|
undefined,
|
|
errorShape(ErrorCodes.INVALID_REQUEST, "invalid config.set params: raw (string) required"),
|
|
);
|
|
return;
|
|
}
|
|
const parsedRes = parseConfigJson5(rawValue);
|
|
if (!parsedRes.ok) {
|
|
respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, parsedRes.error));
|
|
return;
|
|
}
|
|
const schemaSet = loadSchemaWithPlugins();
|
|
const restored = restoreRedactedValues(parsedRes.parsed, snapshot.config, schemaSet.uiHints);
|
|
if (!restored.ok) {
|
|
respond(
|
|
false,
|
|
undefined,
|
|
errorShape(ErrorCodes.INVALID_REQUEST, restored.humanReadableMessage ?? "invalid config"),
|
|
);
|
|
return;
|
|
}
|
|
const validated = validateConfigObjectWithPlugins(restored.result);
|
|
if (!validated.ok) {
|
|
respond(
|
|
false,
|
|
undefined,
|
|
errorShape(ErrorCodes.INVALID_REQUEST, "invalid config", {
|
|
details: { issues: validated.issues },
|
|
}),
|
|
);
|
|
return;
|
|
}
|
|
await writeConfigFile(validated.config, writeOptions);
|
|
respond(
|
|
true,
|
|
{
|
|
ok: true,
|
|
path: CONFIG_PATH,
|
|
config: redactConfigObject(validated.config, schemaSet.uiHints),
|
|
},
|
|
undefined,
|
|
);
|
|
},
|
|
"config.patch": async ({ params, respond }) => {
|
|
if (!validateConfigPatchParams(params)) {
|
|
respond(
|
|
false,
|
|
undefined,
|
|
errorShape(
|
|
ErrorCodes.INVALID_REQUEST,
|
|
`invalid config.patch params: ${formatValidationErrors(validateConfigPatchParams.errors)}`,
|
|
),
|
|
);
|
|
return;
|
|
}
|
|
const { snapshot, writeOptions } = await readConfigFileSnapshotForWrite();
|
|
if (!requireConfigBaseHash(params, snapshot, respond)) {
|
|
return;
|
|
}
|
|
if (!snapshot.valid) {
|
|
respond(
|
|
false,
|
|
undefined,
|
|
errorShape(ErrorCodes.INVALID_REQUEST, "invalid config; fix before patching"),
|
|
);
|
|
return;
|
|
}
|
|
const rawValue = (params as { raw?: unknown }).raw;
|
|
if (typeof rawValue !== "string") {
|
|
respond(
|
|
false,
|
|
undefined,
|
|
errorShape(
|
|
ErrorCodes.INVALID_REQUEST,
|
|
"invalid config.patch params: raw (string) required",
|
|
),
|
|
);
|
|
return;
|
|
}
|
|
const parsedRes = parseConfigJson5(rawValue);
|
|
if (!parsedRes.ok) {
|
|
respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, parsedRes.error));
|
|
return;
|
|
}
|
|
if (
|
|
!parsedRes.parsed ||
|
|
typeof parsedRes.parsed !== "object" ||
|
|
Array.isArray(parsedRes.parsed)
|
|
) {
|
|
respond(
|
|
false,
|
|
undefined,
|
|
errorShape(ErrorCodes.INVALID_REQUEST, "config.patch raw must be an object"),
|
|
);
|
|
return;
|
|
}
|
|
const merged = applyMergePatch(snapshot.config, parsedRes.parsed, {
|
|
mergeObjectArraysById: true,
|
|
});
|
|
const schemaPatch = loadSchemaWithPlugins();
|
|
const restoredMerge = restoreRedactedValues(merged, snapshot.config, schemaPatch.uiHints);
|
|
if (!restoredMerge.ok) {
|
|
respond(
|
|
false,
|
|
undefined,
|
|
errorShape(
|
|
ErrorCodes.INVALID_REQUEST,
|
|
restoredMerge.humanReadableMessage ?? "invalid config",
|
|
),
|
|
);
|
|
return;
|
|
}
|
|
const migrated = applyLegacyMigrations(restoredMerge.result);
|
|
const resolved = migrated.next ?? restoredMerge.result;
|
|
const validated = validateConfigObjectWithPlugins(resolved);
|
|
if (!validated.ok) {
|
|
respond(
|
|
false,
|
|
undefined,
|
|
errorShape(ErrorCodes.INVALID_REQUEST, "invalid config", {
|
|
details: { issues: validated.issues },
|
|
}),
|
|
);
|
|
return;
|
|
}
|
|
await writeConfigFile(validated.config, writeOptions);
|
|
|
|
const { sessionKey, note, restartDelayMs, deliveryContext, threadId } =
|
|
resolveConfigRestartRequest(params);
|
|
const payload = buildConfigRestartSentinelPayload({
|
|
kind: "config-patch",
|
|
mode: "config.patch",
|
|
sessionKey,
|
|
deliveryContext,
|
|
threadId,
|
|
note,
|
|
});
|
|
const sentinelPath = await tryWriteRestartSentinelPayload(payload);
|
|
const restart = scheduleGatewaySigusr1Restart({
|
|
delayMs: restartDelayMs,
|
|
reason: "config.patch",
|
|
});
|
|
respond(
|
|
true,
|
|
{
|
|
ok: true,
|
|
path: CONFIG_PATH,
|
|
config: redactConfigObject(validated.config, schemaPatch.uiHints),
|
|
restart,
|
|
sentinel: {
|
|
path: sentinelPath,
|
|
payload,
|
|
},
|
|
},
|
|
undefined,
|
|
);
|
|
},
|
|
"config.apply": async ({ params, respond }) => {
|
|
if (!validateConfigApplyParams(params)) {
|
|
respond(
|
|
false,
|
|
undefined,
|
|
errorShape(
|
|
ErrorCodes.INVALID_REQUEST,
|
|
`invalid config.apply params: ${formatValidationErrors(validateConfigApplyParams.errors)}`,
|
|
),
|
|
);
|
|
return;
|
|
}
|
|
const { snapshot, writeOptions } = await readConfigFileSnapshotForWrite();
|
|
if (!requireConfigBaseHash(params, snapshot, respond)) {
|
|
return;
|
|
}
|
|
const rawValue = (params as { raw?: unknown }).raw;
|
|
if (typeof rawValue !== "string") {
|
|
respond(
|
|
false,
|
|
undefined,
|
|
errorShape(
|
|
ErrorCodes.INVALID_REQUEST,
|
|
"invalid config.apply params: raw (string) required",
|
|
),
|
|
);
|
|
return;
|
|
}
|
|
const parsedRes = parseConfigJson5(rawValue);
|
|
if (!parsedRes.ok) {
|
|
respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, parsedRes.error));
|
|
return;
|
|
}
|
|
const schemaApply = loadSchemaWithPlugins();
|
|
const restored = restoreRedactedValues(parsedRes.parsed, snapshot.config, schemaApply.uiHints);
|
|
if (!restored.ok) {
|
|
respond(
|
|
false,
|
|
undefined,
|
|
errorShape(ErrorCodes.INVALID_REQUEST, restored.humanReadableMessage ?? "invalid config"),
|
|
);
|
|
return;
|
|
}
|
|
const validated = validateConfigObjectWithPlugins(restored.result);
|
|
if (!validated.ok) {
|
|
respond(
|
|
false,
|
|
undefined,
|
|
errorShape(ErrorCodes.INVALID_REQUEST, "invalid config", {
|
|
details: { issues: validated.issues },
|
|
}),
|
|
);
|
|
return;
|
|
}
|
|
await writeConfigFile(validated.config, writeOptions);
|
|
|
|
const { sessionKey, note, restartDelayMs, deliveryContext, threadId } =
|
|
resolveConfigRestartRequest(params);
|
|
const payload = buildConfigRestartSentinelPayload({
|
|
kind: "config-apply",
|
|
mode: "config.apply",
|
|
sessionKey,
|
|
deliveryContext,
|
|
threadId,
|
|
note,
|
|
});
|
|
const sentinelPath = await tryWriteRestartSentinelPayload(payload);
|
|
const restart = scheduleGatewaySigusr1Restart({
|
|
delayMs: restartDelayMs,
|
|
reason: "config.apply",
|
|
});
|
|
respond(
|
|
true,
|
|
{
|
|
ok: true,
|
|
path: CONFIG_PATH,
|
|
config: redactConfigObject(validated.config, schemaApply.uiHints),
|
|
restart,
|
|
sentinel: {
|
|
path: sentinelPath,
|
|
payload,
|
|
},
|
|
},
|
|
undefined,
|
|
);
|
|
},
|
|
};
|