qlogicagent 2.13.5 → 2.13.6

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

@@ -1,28 +0,0 @@
-/**
- * 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

@@ -1,438 +0,0 @@
-/**
- * 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

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

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

@@ -1,140 +0,0 @@
-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

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