qlogicagent 2.13.4 → 2.13.5

package/dist/cli/handlers/config-handler.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Config + tunables handlers — extracted from StdioServer.
+ * Handles: config.get, config.update, config.tunables, config.updateTunable,
+ *          provider.list, tools.list, todos.list, tasks.list, tasks.cancel
+ *
+ * NOTE: Provider/model/key management is handled by settings-handler.ts (settings.* RPC).
+ * config.get/config.update only operate on tunables and non-model settings.
+ */
+import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
+import type { BackgroundTaskManager } from "../../runtime/infra/background-tasks.js";
+import type { TaskStore } from "../../runtime/infra/task-runtime.js";
+import type { ToolCatalog } from "../../runtime/ports/index.js";
+export interface ConfigHandlerHost {
+    taskStore: TaskStore;
+    backgroundTasks: BackgroundTaskManager;
+    toolCatalog?: ToolCatalog;
+    syncToolListMediaConfig?(): void;
+    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
+}
+export declare function handleToolsList(this: ConfigHandlerHost, msg: AgentRpcRequest): void;
+export declare function handleProviderList(this: ConfigHandlerHost, msg: AgentRpcRequest): void;
+export declare function handleConfigGet(this: ConfigHandlerHost, msg: AgentRpcRequest): void;
+export declare function handleConfigUpdate(this: ConfigHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleConfigTunables(this: ConfigHandlerHost, msg: AgentRpcRequest): void;
+export declare function handleConfigUpdateTunable(this: ConfigHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleTodosList(this: ConfigHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleTasksList(this: ConfigHandlerHost, msg: AgentRpcRequest): void;
+export declare function handleTasksCancel(this: ConfigHandlerHost, msg: AgentRpcRequest): void;

package/dist/cli/handlers/config-handler.js

@@ -0,0 +1,438 @@
+/**
+ * Config + tunables handlers — extracted from StdioServer.
+ * Handles: config.get, config.update, config.tunables, config.updateTunable,
+ *          provider.list, tools.list, todos.list, tasks.list, tasks.cancel
+ *
+ * NOTE: Provider/model/key management is handled by settings-handler.ts (settings.* RPC).
+ * config.get/config.update only operate on tunables and non-model settings.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getUserSettingsPath, getUserAgentHome } from "../../runtime/infra/agent-paths.js";
+import { getModelRegistry } from "../../runtime/infra/model-registry.js";
+import { getTunableDefaults } from "../../runtime/config/tunable-defaults.js";
+import { validateTunableUpdate, writeTunableOverride } from "../tunable-store.js";
+import { summarizeTaskList as summarizeTodoList } from "../../skills/tools/task-tool.js";
+import { SESSION_TOOL_MANIFEST } from "../core-tools/session-tool-manifest.js";
+const SESSION_TOOL_NAMES = new Set(SESSION_TOOL_MANIFEST.map((entry) => entry.name));
+const SESSION_TOOL_BY_NAME = new Map(SESSION_TOOL_MANIFEST.map((entry) => [entry.name, entry]));
+import { AGENT_RPC_ERROR_CODES } from "../../protocol/wire/index.js";
+import { buildPermissionModel } from "../../runtime/permission-model.js";
+import { createCliToolCatalog } from "../tool-catalog.js";
+const LEGACY_PERMISSION_CONFIG_KEYS = new Set([
+    "permissionMode",
+    "permissionRules",
+    "defaultBehavior",
+]);
+export function handleToolsList(msg) {
+    const params = msg.params;
+    this.syncToolListMediaConfig?.();
+    const toolCatalog = this.toolCatalog ?? createCliToolCatalog();
+    const localTools = params?.includeUnavailable
+        ? toolCatalog.getToolNames().flatMap((name) => {
+            const tool = toolCatalog.findTool(name);
+            if (!tool)
+                return [];
+            return [{
+                    type: "function",
+                    function: {
+                        name: tool.name,
+                        description: tool.description,
+                        parameters: tool.parameters,
+                    },
+                }];
+        })
+        : toolCatalog.getToolManifest(params?.includeDeferred ?? false);
+    const tools = localTools.map((t) => {
+        const tool = toolCatalog.findTool(t.function.name);
+        // The session-suite manifest is the single source of truth for the
+        // orchestration tools' categories (their live registrations don't carry one).
+        const category = SESSION_TOOL_BY_NAME.get(t.function.name)?.category ?? tool?.category ?? "other";
+        return {
+            id: t.function.name,
+            name: t.function.name,
+            category,
+            displayName: tool?.displayName ?? {
+                key: `capability.tool.${t.function.name}.name`,
+                fallback: tool?.label ?? t.function.name,
+            },
+            displayDescription: tool?.displayDescription ?? {
+                key: `capability.tool.${t.function.name}.description`,
+                fallback: "",
+            },
+            fallbackName: tool?.label ?? t.function.name,
+            fallbackDescription: "",
+            // Kept as an LLM/diagnostic contract. UI clients should use displayDescription.
+            description: t.function.description ?? "",
+            parameters: t.function.parameters,
+            deferred: !!tool?.shouldDefer,
+            enabled: tool?.isEnabled?.() !== false,
+            // Session-scoped: registered by the per-session bootstrap (orchestration
+            // suite) or injected dynamically (mcp__ server tools), not part of the
+            // static catalog a fresh process starts with.
+            sessionScoped: SESSION_TOOL_NAMES.has(t.function.name) || t.function.name.startsWith("mcp__"),
+            source: "builtin",
+        };
+    });
+    // Merge the declarative session-suite manifest for entries whose live
+    // registration isn't present (no session has run in this process yet) —
+    // the capability page must show the FULL tool surface either way.
+    const presentNames = new Set(tools.map((t) => t.name));
+    for (const entry of SESSION_TOOL_MANIFEST) {
+        if (presentNames.has(entry.name))
+            continue;
+        tools.push({
+            id: entry.name,
+            name: entry.name,
+            category: entry.category,
+            displayName: { key: `capability.tool.${entry.name}.name`, fallback: entry.label },
+            displayDescription: { key: `capability.tool.${entry.name}.description`, fallback: entry.description },
+            fallbackName: entry.label,
+            fallbackDescription: entry.description,
+            description: entry.description,
+            parameters: { type: "object", properties: {} },
+            deferred: entry.deferred ?? false,
+            enabled: true,
+            sessionScoped: true,
+            source: "builtin",
+        });
+    }
+    if (params?.category) {
+        const filtered = tools.filter((t) => t.category === params.category);
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, { tools: filtered, total: filtered.length });
+        }
+    }
+    else {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, { tools, total: tools.length });
+        }
+    }
+}
+export function handleProviderList(msg) {
+    const allProviders = getModelRegistry().listProviderDefs();
+    const groups = new Map();
+    for (const p of allProviders) {
+        const groupKey = p.group ?? p.id;
+        if (!groups.has(groupKey)) {
+            groups.set(groupKey, []);
+        }
+        const hasKey = !!getModelRegistry().resolveProviderApiKey(p.id);
+        groups.get(groupKey).push({
+            id: p.id,
+            name: p.name,
+            transport: p.transport,
+            baseUrl: p.baseUrl,
+            defaultModel: p.defaultModel,
+            modelCount: p.models?.length ?? 0,
+            available: hasKey,
+        });
+    }
+    const result = [...groups.entries()].map(([group, variants]) => ({
+        group,
+        variants,
+    }));
+    if (msg.id !== undefined) {
+        this.sendResponse(msg.id, { providers: result });
+    }
+}
+export function handleConfigGet(msg) {
+    try {
+        const registry = getModelRegistry();
+        const exported = registry.exportConfig();
+        const settingsPath = getUserSettingsPath();
+        let rawSettings = {};
+        try {
+            rawSettings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+        }
+        catch { /* settings file is optional */ }
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, {
+                config: {
+                    ...sanitizeSettingsForConfigGet(rawSettings),
+                    providers: redactProviderConfigs(exported.providers),
+                    models: exported.models,
+                    bindings: exported.bindings,
+                    permissions: sanitizePermissionConfig(rawSettings.permissions),
+                },
+                paths: {
+                    userSettings: getUserSettingsPath(),
+                    agentHome: getUserAgentHome(),
+                },
+                permissionModel: buildPermissionModel(),
+            });
+        }
+    }
+    catch (err) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.INTERNAL_ERROR,
+                message: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+}
+function sanitizeSettingsForConfigGet(settings) {
+    const safe = {};
+    for (const [key, value] of Object.entries(settings)) {
+        if (MODEL_MANAGEMENT_KEYS.has(key))
+            continue;
+        if (LEGACY_PERMISSION_CONFIG_KEYS.has(key))
+            continue;
+        const sanitized = sanitizeConfigValue(key, value);
+        if (sanitized !== undefined)
+            safe[key] = sanitized;
+    }
+    return safe;
+}
+function sanitizeConfigValue(key, value) {
+    if (isSecretLikeKey(key)) {
+        return typeof value === "string" ? maskApiKey(value) : "[REDACTED]";
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => sanitizeConfigValue(key, item));
+    }
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [childKey, childValue] of Object.entries(value)) {
+            if (MODEL_MANAGEMENT_KEYS.has(childKey))
+                continue;
+            const sanitized = sanitizeConfigValue(childKey, childValue);
+            if (sanitized !== undefined)
+                out[childKey] = sanitized;
+        }
+        return out;
+    }
+    return value;
+}
+function isSecretLikeKey(key) {
+    return /(?:apiKey|key|token|secret|credential|authorization|password)/i.test(key);
+}
+function redactProviderConfigs(providers) {
+    return providers.map((provider) => ({
+        providerId: provider.providerId,
+        baseUrl: provider.baseUrl,
+        strategy: provider.strategy,
+        keys: provider.keys.map((key) => {
+            const redacted = {
+                id: key.id,
+                maskedKey: maskApiKey(key.key),
+                weight: key.weight,
+                enabled: key.enabled,
+            };
+            if (key.label)
+                redacted.label = key.label;
+            return redacted;
+        }),
+        ...(provider.rateLimit ? { rateLimit: provider.rateLimit } : {}),
+    }));
+}
+function maskApiKey(key) {
+    if (key.length <= 8)
+        return "****";
+    return `${key.slice(0, 3)}***${key.slice(-4)}`;
+}
+/** Fields that must NOT be updated via config.update (use settings.* RPC instead). */
+const MODEL_MANAGEMENT_KEYS = new Set(["providers", "models", "bindings", "provider", "model", "apiKey", "baseUrl", "providerKeys"]);
+export async function handleConfigUpdate(msg) {
+    const params = msg.params;
+    if (!params?.updates || typeof params.updates !== "object") {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.INVALID_PARAMS,
+                message: "updates (object) is required.",
+            });
+        }
+        return;
+    }
+    // Reject any attempt to write model management fields through this endpoint
+    const rejected = [];
+    const allowed = {};
+    for (const [key, value] of Object.entries(params.updates)) {
+        if (MODEL_MANAGEMENT_KEYS.has(key)) {
+            rejected.push({ key, reason: "Use settings.* RPC methods for model/key management" });
+        }
+        else {
+            allowed[key] = key === "permissions" ? sanitizePermissionConfig(value) : value;
+        }
+    }
+    if (rejected.length > 0 && Object.keys(allowed).length === 0) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.INVALID_PARAMS,
+                message: `Rejected keys: ${rejected.map(r => r.key).join(", ")}. Use settings.* RPC for model management.`,
+            });
+        }
+        return;
+    }
+    // Write allowed fields (tunables etc.) directly to settings.json
+    try {
+        const settingsPath = getUserSettingsPath();
+        let config = {};
+        try {
+            const raw = await fs.promises.readFile(settingsPath, "utf-8");
+            config = JSON.parse(raw);
+        }
+        catch { /* start fresh */ }
+        Object.assign(config, allowed);
+        await fs.promises.mkdir(path.dirname(settingsPath), { recursive: true });
+        await fs.promises.writeFile(settingsPath, JSON.stringify(config, null, 2), "utf-8");
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, { ok: true, applied: Object.keys(allowed), rejected });
+        }
+    }
+    catch (err) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.INTERNAL_ERROR,
+                message: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+}
+function sanitizePermissionConfig(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const mode = value.mode;
+    if (mode === "default" || mode === "auto" || mode === "full_access")
+        return { mode };
+    return undefined;
+}
+export function handleConfigTunables(msg) {
+    try {
+        const defaults = getTunableDefaults();
+        const settingsPath = getUserSettingsPath();
+        let overrides = {};
+        try {
+            const raw = fs.readFileSync(settingsPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (parsed.tunables && typeof parsed.tunables === "object") {
+                overrides = parsed.tunables;
+            }
+        }
+        catch { /* no settings or parse error */ }
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, { defaults, overrides });
+        }
+    }
+    catch (err) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.INTERNAL_ERROR,
+                message: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+}
+export async function handleConfigUpdateTunable(msg) {
+    const params = msg.params;
+    const key = params?.key;
+    const value = params?.value;
+    if (!key || typeof key !== "string") {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.INVALID_PARAMS,
+                message: "Missing required param: key (string)",
+            });
+        }
+        return;
+    }
+    const validationError = validateTunableUpdate(key, value);
+    if (validationError) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.INVALID_PARAMS,
+                message: validationError,
+            });
+        }
+        return;
+    }
+    try {
+        await writeTunableOverride(getUserSettingsPath(), key, value);
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, { ok: true, key, value });
+        }
+    }
+    catch (err) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.INTERNAL_ERROR,
+                message: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+}
+export async function handleTodosList(msg) {
+    const taskTool = (this.toolCatalog ?? createCliToolCatalog()).findTool("task");
+    if (!taskTool || typeof taskTool.execute !== "function") {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, { items: [], summary: summarizeTodoList([]) });
+        }
+        return;
+    }
+    try {
+        const result = await taskTool.execute("rpc-todos-list", { action: "list" }, undefined);
+        const taskDetails = result.details;
+        const items = taskDetails?.taskList ?? [];
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, { items, summary: summarizeTodoList(items) });
+        }
+    }
+    catch {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, { items: [], summary: summarizeTodoList([]) });
+        }
+    }
+}
+export function handleTasksList(msg) {
+    const params = msg.params;
+    const filter = params?.lifecycle ?? "all";
+    const allTasks = this.taskStore.getAllTasks();
+    const tasks = filter === "all"
+        ? allTasks
+        : allTasks.filter((t) => t.lifecycle === filter);
+    if (msg.id !== undefined) {
+        this.sendResponse(msg.id, {
+            tasks: tasks.map((t) => ({
+                taskId: t.taskId,
+                type: t.type,
+                lifecycle: t.lifecycle,
+                label: t.label,
+            })),
+        });
+    }
+}
+export function handleTasksCancel(msg) {
+    const params = msg.params;
+    if (!params?.taskId) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, undefined, {
+                code: AGENT_RPC_ERROR_CODES.INVALID_PARAMS,
+                message: "taskId is required.",
+            });
+        }
+        return;
+    }
+    const allTasks = this.taskStore.getAllTasks();
+    const task = allTasks.find((t) => t.taskId === params.taskId);
+    if (!task) {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, { ok: false, message: `Task ${params.taskId} not found.` });
+        }
+        return;
+    }
+    if (task.lifecycle !== "running" && task.lifecycle !== "pending") {
+        if (msg.id !== undefined) {
+            this.sendResponse(msg.id, { ok: false, message: `Task ${params.taskId} is already ${task.lifecycle}.` });
+        }
+        return;
+    }
+    // Route through the manager: kills the process / aborts the agent,
+    // then flips lifecycle (an immutable update, so task.updated fires).
+    const cancelled = this.backgroundTasks.cancelTask(params.taskId);
+    if (msg.id !== undefined) {
+        this.sendResponse(msg.id, cancelled
+            ? { ok: true, message: `Task ${params.taskId} cancelled.` }
+            : { ok: false, message: `Task ${params.taskId} could not be cancelled.` });
+    }
+}

package/dist/cli/handlers/config-handler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/handlers/config-handler.test.js

@@ -0,0 +1,140 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { handleConfigGet, handleConfigUpdate } from "./config-handler.js";
+import { resetModelRegistry } from "../../runtime/infra/model-registry.js";
+import { getUserSettingsPath } from "../../runtime/infra/agent-paths.js";
+function rpcContext() {
+    const responses = [];
+    return {
+        responses,
+        taskStore: {},
+        backgroundTasks: {},
+        sendResponse(id, result, error) {
+            responses.push({ id, result, error });
+        },
+    };
+}
+describe("config handler", () => {
+    let home;
+    beforeEach(() => {
+        home = mkdtempSync(join(tmpdir(), "qlogicagent-config-handler-"));
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        resetModelRegistry();
+    });
+    afterEach(() => {
+        vi.unstubAllEnvs();
+        resetModelRegistry();
+        rmSync(home, { recursive: true, force: true });
+    });
+    it("redacts provider secrets from config.get while preserving key metadata", () => {
+        const settingsPath = getUserSettingsPath();
+        mkdirSync(dirname(settingsPath), { recursive: true });
+        writeFileSync(settingsPath, JSON.stringify({
+            providers: [
+                {
+                    providerId: "deepseek",
+                    baseUrl: "https://api.deepseek.com",
+                    strategy: "weighted-round-robin",
+                    keys: [
+                        { id: "deepseek-primary", key: "sk-real-secret-value", label: "primary", weight: 2, enabled: true },
+                    ],
+                },
+            ],
+            models: [],
+            bindings: { textGeneration: "deepseek:deepseek-chat" },
+            permissions: { mode: "default", rules: [] },
+        }, null, 2));
+        const ctx = rpcContext();
+        handleConfigGet.call(ctx, { jsonrpc: "2.0", id: 1, method: "config.get" });
+        const payload = ctx.responses[0].result;
+        const serialized = JSON.stringify(payload);
+        expect(serialized).not.toContain("sk-real-secret-value");
+        expect(payload.config.providers[0].keys[0]).toMatchObject({
+            id: "deepseek-primary",
+            maskedKey: "sk-***alue",
+            label: "primary",
+            weight: 2,
+            enabled: true,
+        });
+        expect(payload.config.providers[0].keys[0]).not.toHaveProperty("key");
+    });
+    it("preserves safe custom settings in config.get while redacting provider secrets", () => {
+        const settingsPath = getUserSettingsPath();
+        mkdirSync(dirname(settingsPath), { recursive: true });
+        writeFileSync(settingsPath, JSON.stringify({
+            testMarker_persistence: "test-value-12345",
+            providers: [
+                {
+                    providerId: "deepseek",
+                    strategy: "weighted-round-robin",
+                    keys: [
+                        { id: "deepseek-primary", key: "sk-real-secret-value", weight: 1, enabled: true },
+                    ],
+                },
+            ],
+            permissions: { mode: "auto", rules: [] },
+        }, null, 2));
+        const ctx = rpcContext();
+        handleConfigGet.call(ctx, { jsonrpc: "2.0", id: 1, method: "config.get" });
+        const payload = ctx.responses[0].result;
+        expect(payload.config.testMarker_persistence).toBe("test-value-12345");
+        expect(JSON.stringify(payload)).not.toContain("sk-real-secret-value");
+        expect(payload.config.providers[0].keys[0]).toMatchObject({
+            id: "deepseek-primary",
+            maskedKey: "sk-***alue",
+        });
+    });
+    it("exposes only the mode-only permission policy through config.get", () => {
+        const settingsPath = getUserSettingsPath();
+        mkdirSync(dirname(settingsPath), { recursive: true });
+        writeFileSync(settingsPath, JSON.stringify({
+            permissionMode: "acceptEdits",
+            permissionRules: [{ pattern: "write", behavior: "allow" }],
+            defaultBehavior: "allow",
+            permissions: {
+                mode: "default",
+                rules: [{ pattern: "write", behavior: "allow", source: "config" }],
+            },
+        }, null, 2));
+        const ctx = rpcContext();
+        handleConfigGet.call(ctx, { jsonrpc: "2.0", id: 1, method: "config.get" });
+        const payload = ctx.responses[0].result;
+        expect(payload.config.permissions).toEqual({ mode: "default" });
+        expect(payload.config).not.toHaveProperty("permissionMode");
+        expect(payload.config).not.toHaveProperty("permissionRules");
+        expect(payload.config).not.toHaveProperty("defaultBehavior");
+    });
+    it("config.get delivers permissionModel with modes and promptOptions", () => {
+        const ctx = rpcContext();
+        handleConfigGet.call(ctx, { jsonrpc: "2.0", id: 1, method: "config.get" });
+        const payload = ctx.responses[0].result;
+        expect(payload.permissionModel.modes.map((m) => m.id)).toContain("default");
+        expect(payload.permissionModel.promptOptions.cross_workspace.some((o) => o.optionId === "allow_dir")).toBe(true);
+    });
+    it("sanitizes config.update permission writes to mode only", async () => {
+        const settingsPath = getUserSettingsPath();
+        mkdirSync(dirname(settingsPath), { recursive: true });
+        writeFileSync(settingsPath, JSON.stringify({
+            permissions: { mode: "default", rules: [] },
+        }, null, 2));
+        const ctx = rpcContext();
+        await handleConfigUpdate.call(ctx, {
+            jsonrpc: "2.0",
+            id: 1,
+            method: "config.update",
+            params: {
+                updates: {
+                    permissions: {
+                        mode: "auto",
+                        rules: [{ pattern: "execute_command", behavior: "allow" }],
+                    },
+                },
+            },
+        });
+        const stored = JSON.parse(readFileSync(settingsPath, "utf-8"));
+        expect(stored.permissions).toEqual({ mode: "auto" });
+        expect(ctx.responses[0]).toMatchObject({ result: { ok: true, applied: ["permissions"] } });
+    });
+});

package/dist/cli/handlers/config-handler.tools-list.test.d.ts

@@ -0,0 +1 @@
+export {};