@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/gateway/server-methods/config.js

@@ -1,29 +1,30 @@
 import { resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../../agents/agent-scope.js";
-import { CONFIG_PATH, loadConfig, parseConfigJson5, readConfigFileSnapshot, resolveConfigSnapshotHash, validateConfigObjectWithPlugins, writeConfigFile, } from "../../config/config.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 } from "../../config/schema.js";
-import { scheduleGatewaySigusr1Restart } from "../../infra/restart.js";
+import { extractDeliveryInfo } from "../../config/sessions.js";
 import { formatDoctorNonInteractiveHint, writeRestartSentinel, } from "../../infra/restart-sentinel.js";
-import { listChannelPlugins } from "../../channels/plugins/index.js";
+import { scheduleGatewaySigusr1Restart } from "../../infra/restart.js";
 import { loadPoolBotPlugins } from "../../plugins/loader.js";
-import { ErrorCodes, errorShape, formatValidationErrors, validateConfigApplyParams, validateConfigGetParams, validateConfigPatchParams, validateConfigSchemaParams, validateConfigSetParams, } from "../protocol/index.js";
-function resolveBaseHash(params) {
-    const raw = params?.baseHash;
-    if (typeof raw !== "string")
-        return null;
-    const trimmed = raw.trim();
-    return trimmed ? trimmed : null;
-}
+import { diffConfigPaths } from "../config-reload.js";
+import { formatControlPlaneActor, resolveControlPlaneActor, summarizeChangedPaths, } from "../control-plane-audit.js";
+import { ErrorCodes, errorShape, validateConfigApplyParams, validateConfigGetParams, validateConfigPatchParams, validateConfigSchemaParams, validateConfigSetParams, } from "../protocol/index.js";
+import { resolveBaseHashParam } from "./base-hash.js";
+import { parseRestartRequestParams } from "./restart-request.js";
+import { assertValidParams } from "./validation.js";
 function requireConfigBaseHash(params, snapshot, respond) {
-    if (!snapshot.exists)
+    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);
+    const baseHash = resolveBaseHashParam(params);
     if (!baseHash) {
         respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "config base hash required; re-run config.get and retry"));
         return false;
@@ -34,89 +35,149 @@ function requireConfigBaseHash(params, snapshot, respond) {
     }
     return true;
 }
+function parseRawConfigOrRespond(params, requestName, respond) {
+    const rawValue = params.raw;
+    if (typeof rawValue !== "string") {
+        respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid ${requestName} params: raw (string) required`));
+        return null;
+    }
+    return rawValue;
+}
+function parseValidateConfigFromRawOrRespond(params, requestName, snapshot, respond) {
+    const rawValue = parseRawConfigOrRespond(params, requestName, respond);
+    if (!rawValue) {
+        return null;
+    }
+    const parsedRes = parseConfigJson5(rawValue);
+    if (!parsedRes.ok) {
+        respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, parsedRes.error));
+        return null;
+    }
+    const schema = loadSchemaWithPlugins();
+    const restored = restoreRedactedValues(parsedRes.parsed, snapshot.config, schema.uiHints);
+    if (!restored.ok) {
+        respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, restored.humanReadableMessage ?? "invalid config"));
+        return null;
+    }
+    const validated = validateConfigObjectWithPlugins(restored.result);
+    if (!validated.ok) {
+        respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "invalid config", {
+            details: { issues: validated.issues },
+        }));
+        return null;
+    }
+    return { config: validated.config, schema };
+}
+function resolveConfigRestartRequest(params) {
+    const { sessionKey, note, restartDelayMs } = parseRestartRequestParams(params);
+    // 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) {
+    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) {
+    try {
+        return await writeRestartSentinel(payload);
+    }
+    catch {
+        return null;
+    }
+}
+function loadSchemaWithPlugins() {
+    const cfg = loadConfig();
+    const workspaceDir = resolveAgentWorkspaceDir(cfg, resolveDefaultAgentId(cfg));
+    const pluginRegistry = loadPoolBotPlugins({
+        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 loadPoolBotPlugins() 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 = {
     "config.get": async ({ params, respond }) => {
-        if (!validateConfigGetParams(params)) {
-            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid config.get params: ${formatValidationErrors(validateConfigGetParams.errors)}`));
+        if (!assertValidParams(params, validateConfigGetParams, "config.get", respond)) {
             return;
         }
         const snapshot = await readConfigFileSnapshot();
-        respond(true, snapshot, undefined);
+        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)}`));
+        if (!assertValidParams(params, validateConfigSchemaParams, "config.schema", respond)) {
             return;
         }
-        const cfg = loadConfig();
-        const workspaceDir = resolveAgentWorkspaceDir(cfg, resolveDefaultAgentId(cfg));
-        const pluginRegistry = loadPoolBotPlugins({
-            config: cfg,
-            workspaceDir,
-            logger: {
-                info: () => { },
-                warn: () => { },
-                error: () => { },
-                debug: () => { },
-            },
-        });
-        const schema = 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,
-            })),
-        });
-        respond(true, schema, undefined);
+        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)}`));
+        if (!assertValidParams(params, validateConfigSetParams, "config.set", respond)) {
             return;
         }
-        const snapshot = await readConfigFileSnapshot();
+        const { snapshot, writeOptions } = await readConfigFileSnapshotForWrite();
         if (!requireConfigBaseHash(params, snapshot, respond)) {
             return;
         }
-        const rawValue = params.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 validated = validateConfigObjectWithPlugins(parsedRes.parsed);
-        if (!validated.ok) {
-            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "invalid config", {
-                details: { issues: validated.issues },
-            }));
+        const parsed = parseValidateConfigFromRawOrRespond(params, "config.set", snapshot, respond);
+        if (!parsed) {
             return;
         }
-        await writeConfigFile(validated.config);
+        await writeConfigFile(parsed.config, writeOptions);
         respond(true, {
             ok: true,
             path: CONFIG_PATH,
-            config: validated.config,
+            config: redactConfigObject(parsed.config, parsed.schema.uiHints),
         }, undefined);
     },
-    "config.patch": async ({ params, respond }) => {
-        if (!validateConfigPatchParams(params)) {
-            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid config.patch params: ${formatValidationErrors(validateConfigPatchParams.errors)}`));
+    "config.patch": async ({ params, respond, client, context }) => {
+        if (!assertValidParams(params, validateConfigPatchParams, "config.patch", respond)) {
             return;
         }
-        const snapshot = await readConfigFileSnapshot();
+        const { snapshot, writeOptions } = await readConfigFileSnapshotForWrite();
         if (!requireConfigBaseHash(params, snapshot, respond)) {
             return;
         }
@@ -140,9 +201,17 @@ export const configHandlers = {
             respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "config.patch raw must be an object"));
             return;
         }
-        const merged = applyMergePatch(snapshot.config, parsedRes.parsed);
-        const migrated = applyLegacyMigrations(merged);
-        const resolved = migrated.next ?? merged;
+        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", {
@@ -150,44 +219,37 @@ export const configHandlers = {
             }));
             return;
         }
-        await writeConfigFile(validated.config);
-        const sessionKey = typeof params.sessionKey === "string"
-            ? params.sessionKey?.trim() || undefined
-            : undefined;
-        const note = typeof params.note === "string"
-            ? params.note?.trim() || undefined
-            : undefined;
-        const restartDelayMsRaw = params.restartDelayMs;
-        const restartDelayMs = typeof restartDelayMsRaw === "number" && Number.isFinite(restartDelayMsRaw)
-            ? Math.max(0, Math.floor(restartDelayMsRaw))
-            : undefined;
-        const payload = {
-            kind: "config-apply",
-            status: "ok",
-            ts: Date.now(),
+        const changedPaths = diffConfigPaths(snapshot.config, validated.config);
+        const actor = resolveControlPlaneActor(client);
+        context?.logGateway?.info(`config.patch write ${formatControlPlaneActor(actor)} changedPaths=${summarizeChangedPaths(changedPaths)} restartReason=config.patch`);
+        await writeConfigFile(validated.config, writeOptions);
+        const { sessionKey, note, restartDelayMs, deliveryContext, threadId } = resolveConfigRestartRequest(params);
+        const payload = buildConfigRestartSentinelPayload({
+            kind: "config-patch",
+            mode: "config.patch",
             sessionKey,
-            message: note ?? null,
-            doctorHint: formatDoctorNonInteractiveHint(),
-            stats: {
-                mode: "config.patch",
-                root: CONFIG_PATH,
-            },
-        };
-        let sentinelPath = null;
-        try {
-            sentinelPath = await writeRestartSentinel(payload);
-        }
-        catch {
-            sentinelPath = null;
-        }
+            deliveryContext,
+            threadId,
+            note,
+        });
+        const sentinelPath = await tryWriteRestartSentinelPayload(payload);
         const restart = scheduleGatewaySigusr1Restart({
             delayMs: restartDelayMs,
             reason: "config.patch",
+            audit: {
+                actor: actor.actor,
+                deviceId: actor.deviceId,
+                clientIp: actor.clientIp,
+                changedPaths,
+            },
         });
+        if (restart.coalesced) {
+            context?.logGateway?.warn(`config.patch restart coalesced ${formatControlPlaneActor(actor)} delayMs=${restart.delayMs}`);
+        }
         respond(true, {
             ok: true,
             path: CONFIG_PATH,
-            config: validated.config,
+            config: redactConfigObject(validated.config, schemaPatch.uiHints),
             restart,
             sentinel: {
                 path: sentinelPath,
@@ -195,70 +257,49 @@ export const configHandlers = {
             },
         }, undefined);
     },
-    "config.apply": async ({ params, respond }) => {
-        if (!validateConfigApplyParams(params)) {
-            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid config.apply params: ${formatValidationErrors(validateConfigApplyParams.errors)}`));
+    "config.apply": async ({ params, respond, client, context }) => {
+        if (!assertValidParams(params, validateConfigApplyParams, "config.apply", respond)) {
             return;
         }
-        const snapshot = await readConfigFileSnapshot();
+        const { snapshot, writeOptions } = await readConfigFileSnapshotForWrite();
         if (!requireConfigBaseHash(params, snapshot, respond)) {
             return;
         }
-        const rawValue = params.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 validated = validateConfigObjectWithPlugins(parsedRes.parsed);
-        if (!validated.ok) {
-            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "invalid config", {
-                details: { issues: validated.issues },
-            }));
+        const parsed = parseValidateConfigFromRawOrRespond(params, "config.apply", snapshot, respond);
+        if (!parsed) {
             return;
         }
-        await writeConfigFile(validated.config);
-        const sessionKey = typeof params.sessionKey === "string"
-            ? params.sessionKey?.trim() || undefined
-            : undefined;
-        const note = typeof params.note === "string"
-            ? params.note?.trim() || undefined
-            : undefined;
-        const restartDelayMsRaw = params.restartDelayMs;
-        const restartDelayMs = typeof restartDelayMsRaw === "number" && Number.isFinite(restartDelayMsRaw)
-            ? Math.max(0, Math.floor(restartDelayMsRaw))
-            : undefined;
-        const payload = {
+        const changedPaths = diffConfigPaths(snapshot.config, parsed.config);
+        const actor = resolveControlPlaneActor(client);
+        context?.logGateway?.info(`config.apply write ${formatControlPlaneActor(actor)} changedPaths=${summarizeChangedPaths(changedPaths)} restartReason=config.apply`);
+        await writeConfigFile(parsed.config, writeOptions);
+        const { sessionKey, note, restartDelayMs, deliveryContext, threadId } = resolveConfigRestartRequest(params);
+        const payload = buildConfigRestartSentinelPayload({
             kind: "config-apply",
-            status: "ok",
-            ts: Date.now(),
+            mode: "config.apply",
             sessionKey,
-            message: note ?? null,
-            doctorHint: formatDoctorNonInteractiveHint(),
-            stats: {
-                mode: "config.apply",
-                root: CONFIG_PATH,
-            },
-        };
-        let sentinelPath = null;
-        try {
-            sentinelPath = await writeRestartSentinel(payload);
-        }
-        catch {
-            sentinelPath = null;
-        }
+            deliveryContext,
+            threadId,
+            note,
+        });
+        const sentinelPath = await tryWriteRestartSentinelPayload(payload);
         const restart = scheduleGatewaySigusr1Restart({
             delayMs: restartDelayMs,
             reason: "config.apply",
+            audit: {
+                actor: actor.actor,
+                deviceId: actor.deviceId,
+                clientIp: actor.clientIp,
+                changedPaths,
+            },
         });
+        if (restart.coalesced) {
+            context?.logGateway?.warn(`config.apply restart coalesced ${formatControlPlaneActor(actor)} delayMs=${restart.delayMs}`);
+        }
         respond(true, {
             ok: true,
             path: CONFIG_PATH,
-            config: validated.config,
+            config: redactConfigObject(parsed.config, parsed.schema.uiHints),
             restart,
             sentinel: {
                 path: sentinelPath,

package/dist/gateway/server-methods/devices.js

@@ -1,7 +1,7 @@
-import { approveDevicePairing, listDevicePairing, rejectDevicePairing, revokeDeviceToken, rotateDeviceToken, summarizeDeviceTokens, } from "../../infra/device-pairing.js";
-import { ErrorCodes, errorShape, formatValidationErrors, validateDevicePairApproveParams, validateDevicePairListParams, validateDevicePairRejectParams, validateDeviceTokenRevokeParams, validateDeviceTokenRotateParams, } from "../protocol/index.js";
+import { approveDevicePairing, listDevicePairing, removePairedDevice, rejectDevicePairing, revokeDeviceToken, rotateDeviceToken, summarizeDeviceTokens, } from "../../infra/device-pairing.js";
+import { ErrorCodes, errorShape, formatValidationErrors, validateDevicePairApproveParams, validateDevicePairListParams, validateDevicePairRemoveParams, validateDevicePairRejectParams, validateDeviceTokenRevokeParams, validateDeviceTokenRotateParams, } from "../protocol/index.js";
 function redactPairedDevice(device) {
-    const { tokens, ...rest } = device;
+    const { tokens, approvedScopes: _approvedScopes, ...rest } = device;
     return {
         ...rest,
         tokens: summarizeDeviceTokens(tokens),
@@ -58,6 +58,20 @@ export const deviceHandlers = {
         }, { dropIfSlow: true });
         respond(true, rejected, undefined);
     },
+    "device.pair.remove": async ({ params, respond, context }) => {
+        if (!validateDevicePairRemoveParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid device.pair.remove params: ${formatValidationErrors(validateDevicePairRemoveParams.errors)}`));
+            return;
+        }
+        const { deviceId } = params;
+        const removed = await removePairedDevice(deviceId);
+        if (!removed) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "unknown deviceId"));
+            return;
+        }
+        context.logGateway.info(`device pairing removed device=${removed.deviceId}`);
+        respond(true, removed, undefined);
+    },
     "device.token.rotate": async ({ params, respond, context }) => {
         if (!validateDeviceTokenRotateParams(params)) {
             respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid device.token.rotate params: ${formatValidationErrors(validateDeviceTokenRotateParams.errors)}`));

package/dist/gateway/server-methods/models.js

@@ -1,3 +1,6 @@
+import { DEFAULT_PROVIDER } from "../../agents/defaults.js";
+import { buildAllowedModelSet } from "../../agents/model-selection.js";
+import { loadConfig } from "../../config/config.js";
 import { ErrorCodes, errorShape, formatValidationErrors, validateModelsListParams, } from "../protocol/index.js";
 export const modelsHandlers = {
     "models.list": async ({ params, respond, context }) => {
@@ -6,7 +9,14 @@ export const modelsHandlers = {
             return;
         }
         try {
-            const models = await context.loadGatewayModelCatalog();
+            const catalog = await context.loadGatewayModelCatalog();
+            const cfg = loadConfig();
+            const { allowedCatalog } = buildAllowedModelSet({
+                cfg,
+                catalog,
+                defaultProvider: DEFAULT_PROVIDER,
+            });
+            const models = allowedCatalog.length > 0 ? allowedCatalog : catalog;
             respond(true, { models }, undefined);
         }
         catch (err) {

package/dist/gateway/server-methods/nodes.helpers.js

@@ -30,3 +30,15 @@ export function safeParseJson(value) {
         return { payloadJSON: value };
     }
 }
+export function respondUnavailableOnNodeInvokeError(respond, res) {
+    if (res.ok) {
+        return true;
+    }
+    const message = res.error && typeof res.error === "object" && "message" in res.error
+        ? res.error.message
+        : null;
+    respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, typeof message === "string" ? message : "node invoke failed", {
+        details: { nodeError: res.error ?? null },
+    }));
+    return false;
+}