mini-coder 0.5.12 → 0.5.13

package/src/ui/commands.test.ts

@@ -3,14 +3,15 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { ContainerNode } from "@cel-tui/types";
-import { registerFauxProvider } from "@mariozechner/pi-ai";
-import type { AppState } from "../index.ts";
+import { registerFauxProvider, Type } from "@mariozechner/pi-ai";
+import { type AppState, buildToolList } from "../index.ts";
 import {
   computeContextTokens,
   createSession,
+  loadMessages,
   openDatabase,
 } from "../session.ts";
-import { loadSettings } from "../settings.ts";
+import { loadSettings, saveSettings } from "../settings.ts";
 import { DEFAULT_THEME } from "../theme.ts";
 import { createCommandController } from "./commands.ts";
 import type { ActiveOverlay } from "./overlay.ts";
@@ -58,12 +59,12 @@ function createTestState(): AppState {
     contextTokens: 0,
     agentsMd: [],
     skills: [],
-    plugins: [],
     theme: DEFAULT_THEME,
     git: null,
     providers: new Map(),
     oauthCredentials: {},
     settings: {},
+    repoSettings: {},
     settingsPath,
     cwd,
     canonicalCwd: cwd,
@@ -74,6 +75,7 @@ function createTestState(): AppState {
     showReasoning: true,
     verbose: false,
     versionLabel: "dev",
+    mcpServers: [],
     customModels: [],
     startupWarnings: [],
   };
@@ -116,6 +118,9 @@ describe("ui/commands", () => {
       model: "test/beta",
       effort: "high",
     });
+    state.queuedUserMessages = [
+      { role: "user", content: "stale steering", timestamp: now - 1 },
+    ];
 
     state.db.run(
       "INSERT INTO messages (session_id, turn, data, created_at) VALUES (?, ?, ?, ?)",
@@ -173,6 +178,7 @@ describe("ui/commands", () => {
         totalCost: 0,
       });
       expect(state.contextTokens).toBe(computeContextTokens(state.messages));
+      expect(state.queuedUserMessages).toEqual([]);
     } finally {
       state.db.close();
     }
@@ -214,6 +220,9 @@ describe("ui/commands", () => {
     ];
     state.stats = { totalInput: 10, totalOutput: 20, totalCost: 0.5 };
     state.contextTokens = 123;
+    state.queuedUserMessages = [
+      { role: "user", content: "stale steering", timestamp: 2 },
+    ];
 
     try {
       expect(controller.handleCommand("new", state)).toBe(true);
@@ -231,6 +240,74 @@ describe("ui/commands", () => {
       expect(state.agentsMd).toEqual([
         { path: "/tmp/reloaded/AGENTS.md", content: "Reloaded context" },
       ]);
+      expect(state.queuedUserMessages).toEqual([]);
+    } finally {
+      state.db.close();
+    }
+  });
+
+  test("/undo clears queued steering before removing the latest turn", async () => {
+    const state = createTestState();
+    const controller = createCommandController({
+      openOverlay: () => {},
+      dismissOverlay: () => {},
+      setInputValue: () => {},
+      appendInfoMessage: () => {},
+      appendTodoMessage: () => {},
+      scrollConversationToBottom: () => {},
+      requestRender: () => {},
+      reloadPromptContext: async () => {},
+      openInBrowser: () => {},
+    });
+    const now = new Date("2026-04-07T12:00:00Z").getTime();
+    const session = createSession(state.db, {
+      cwd: state.canonicalCwd,
+      model: "test/beta",
+      effort: "high",
+    });
+
+    state.session = session;
+    state.queuedUserMessages = [
+      { role: "user", content: "stale steering", timestamp: now + 2 },
+    ];
+    state.db.run(
+      "INSERT INTO messages (session_id, turn, data, created_at) VALUES (?, ?, ?, ?)",
+      [
+        session.id,
+        1,
+        JSON.stringify({
+          role: "user",
+          content: "historical prompt",
+          timestamp: now,
+        }),
+        now,
+      ],
+    );
+    state.db.run(
+      "INSERT INTO messages (session_id, turn, data, created_at) VALUES (?, ?, ?, ?)",
+      [
+        session.id,
+        1,
+        JSON.stringify({
+          role: "assistant",
+          content: [{ type: "text", text: "historical reply" }],
+          api: "anthropic-messages",
+          provider: "anthropic",
+          model: "test/beta",
+          stopReason: "stop",
+          timestamp: now + 1,
+        }),
+        now + 1,
+      ],
+    );
+    state.messages = loadMessages(state.db, session.id);
+
+    try {
+      expect(controller.handleCommand("undo", state)).toBe(true);
+      await Promise.resolve();
+
+      expect(state.queuedUserMessages).toEqual([]);
+      expect(state.messages).toEqual([]);
     } finally {
       state.db.close();
     }
@@ -286,8 +363,396 @@ describe("ui/commands", () => {
     }
   });
 
+  test("/mcp toggles the selected server, persists it, and reconnects when re-enabled", async () => {
+    const state = createTestState();
+    state.model = {
+      id: "test-model",
+      name: "test-model",
+      api: "openai-completions",
+      provider: "test-provider",
+      baseUrl: "http://localhost:1234/v1",
+      reasoning: false,
+      input: ["text"],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: 8192,
+      maxTokens: 4096,
+    };
+
+    const docsTools = [
+      {
+        name: "docs__search",
+        description: "[MCP docs] Search the docs",
+        parameters: Type.Object({}),
+      },
+      {
+        name: "docs__fetch",
+        description: "[MCP docs] Fetch a page",
+        parameters: Type.Object({}),
+      },
+    ];
+    const docsHandlers = new Map();
+    let disconnectCalls = 0;
+    let connectCalls = 0;
+
+    state.mcpServers = [
+      {
+        name: "docs",
+        url: "http://docs.test/mcp",
+        enabled: true,
+        connected: true,
+        tools: docsTools,
+        toolHandlers: docsHandlers,
+        close: async () => {
+          disconnectCalls += 1;
+        },
+      },
+    ];
+    state.settings = saveSettings(state.settingsPath, {
+      mcp: {
+        servers: [
+          {
+            name: "docs",
+            url: "http://docs.test/mcp",
+            enabled: true,
+          },
+          {
+            name: "down",
+            url: "http://down.test/mcp",
+            enabled: false,
+          },
+        ],
+      },
+    });
+    const runtimeState = { overlay: null as ActiveOverlay | null };
+    const appended: Array<{
+      text: string;
+      sessionId: string | null;
+    }> = [];
+    const controller = createCommandController(
+      {
+        openOverlay: (nextOverlay) => {
+          runtimeState.overlay = nextOverlay;
+        },
+        dismissOverlay: () => {
+          runtimeState.overlay = null;
+        },
+        setInputValue: () => {},
+        appendInfoMessage: (text, nextState) => {
+          appended.push({ text, sessionId: nextState.session?.id ?? null });
+        },
+        appendTodoMessage: () => {},
+        scrollConversationToBottom: () => {},
+        requestRender: () => {},
+        reloadPromptContext: async () => {},
+        openInBrowser: () => {},
+      },
+      {
+        connectMcpServer: async (server) => {
+          connectCalls += 1;
+          server.connected = true;
+          server.tools = docsTools;
+          server.toolHandlers = docsHandlers;
+          server.close = async () => {
+            disconnectCalls += 1;
+          };
+          return [];
+        },
+        disconnectMcpServer: async (server) => {
+          await server.close();
+          server.connected = false;
+          server.tools = [];
+          server.toolHandlers = new Map();
+          server.close = async () => {};
+        },
+      },
+    );
+
+    try {
+      expect(controller.handleCommand("mcp", state)).toBe(true);
+      const firstOverlay = expectOverlay(runtimeState.overlay);
+      expect(firstOverlay.title).toBe("Toggle MCP servers");
+      expect(buildToolList(state).tools.map((tool) => tool.name)).toContain(
+        "docs__search",
+      );
+      renderSelect(firstOverlay).props.onKeyPress?.("enter");
+      await Promise.resolve();
+      await Promise.resolve();
+
+      expect(runtimeState.overlay).toBeNull();
+      expect(state.mcpServers[0]?.enabled).toBe(false);
+      expect(state.mcpServers[0]?.connected).toBe(false);
+      expect(state.settings.mcp).toEqual({
+        servers: [
+          {
+            name: "docs",
+            url: "http://docs.test/mcp",
+            enabled: false,
+          },
+          {
+            name: "down",
+            url: "http://down.test/mcp",
+            enabled: false,
+          },
+        ],
+      });
+      expect(loadSettings(state.settingsPath)).toEqual({
+        mcp: {
+          servers: [
+            {
+              name: "docs",
+              url: "http://docs.test/mcp",
+              enabled: false,
+            },
+            {
+              name: "down",
+              url: "http://down.test/mcp",
+              enabled: false,
+            },
+          ],
+        },
+      });
+      expect(disconnectCalls).toBe(1);
+      expect(appended).toEqual([
+        {
+          text: 'Disabled MCP server "docs" (-2 tools).',
+          sessionId: null,
+        },
+      ]);
+      expect(buildToolList(state).tools.map((tool) => tool.name)).not.toContain(
+        "docs__search",
+      );
+
+      expect(controller.handleCommand("mcp", state)).toBe(true);
+      const secondOverlay = expectOverlay(runtimeState.overlay);
+      renderSelect(secondOverlay).props.onKeyPress?.("enter");
+      await Promise.resolve();
+      await Promise.resolve();
+
+      expect(state.mcpServers[0]?.enabled).toBe(true);
+      expect(state.mcpServers[0]?.connected).toBe(true);
+      expect(connectCalls).toBe(1);
+      expect(loadSettings(state.settingsPath)).toEqual({
+        mcp: {
+          servers: [
+            {
+              name: "docs",
+              url: "http://docs.test/mcp",
+              enabled: true,
+            },
+            {
+              name: "down",
+              url: "http://down.test/mcp",
+              enabled: false,
+            },
+          ],
+        },
+      });
+      expect(appended[1]).toEqual({
+        text: 'Enabled MCP server "docs" (+2 tools).',
+        sessionId: null,
+      });
+      expect(buildToolList(state).tools.map((tool) => tool.name)).toContain(
+        "docs__search",
+      );
+    } finally {
+      state.db.close();
+    }
+  });
+
+  test("/mcp toggles repo-local servers for the current run without persisting a global shadow copy", async () => {
+    const state = createTestState();
+    state.model = {
+      id: "test-model",
+      name: "test-model",
+      api: "openai-completions",
+      provider: "test-provider",
+      baseUrl: "http://localhost:1234/v1",
+      reasoning: false,
+      input: ["text"],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: 8192,
+      maxTokens: 4096,
+    };
+
+    const docsTools = [
+      {
+        name: "docs__search",
+        description: "[MCP docs] Search the docs",
+        parameters: Type.Object({}),
+      },
+    ];
+    const docsHandlers = new Map();
+    let disconnectCalls = 0;
+    let connectCalls = 0;
+
+    state.mcpServers = [
+      {
+        name: "docs",
+        url: "http://repo-docs.test/mcp",
+        enabled: true,
+        connected: true,
+        tools: docsTools,
+        toolHandlers: docsHandlers,
+        close: async () => {
+          disconnectCalls += 1;
+        },
+      },
+    ];
+    state.settings = saveSettings(state.settingsPath, {
+      mcp: {
+        servers: [
+          {
+            name: "docs",
+            url: "http://global-docs.test/mcp",
+            enabled: false,
+          },
+          {
+            name: "down",
+            url: "http://down.test/mcp",
+            enabled: false,
+          },
+        ],
+      },
+    });
+    state.repoSettings = {
+      mcp: {
+        servers: [
+          {
+            name: "docs",
+            url: "http://repo-docs.test/mcp",
+            enabled: true,
+          },
+        ],
+      },
+    };
+    const runtimeState = { overlay: null as ActiveOverlay | null };
+    const appended: Array<{
+      text: string;
+      sessionId: string | null;
+    }> = [];
+    const controller = createCommandController(
+      {
+        openOverlay: (nextOverlay) => {
+          runtimeState.overlay = nextOverlay;
+        },
+        dismissOverlay: () => {
+          runtimeState.overlay = null;
+        },
+        setInputValue: () => {},
+        appendInfoMessage: (text, nextState) => {
+          appended.push({ text, sessionId: nextState.session?.id ?? null });
+        },
+        appendTodoMessage: () => {},
+        scrollConversationToBottom: () => {},
+        requestRender: () => {},
+        reloadPromptContext: async () => {},
+        openInBrowser: () => {},
+      },
+      {
+        connectMcpServer: async (server) => {
+          connectCalls += 1;
+          server.connected = true;
+          server.tools = docsTools;
+          server.toolHandlers = docsHandlers;
+          server.close = async () => {
+            disconnectCalls += 1;
+          };
+          return [];
+        },
+        disconnectMcpServer: async (server) => {
+          await server.close();
+          server.connected = false;
+          server.tools = [];
+          server.toolHandlers = new Map();
+          server.close = async () => {};
+        },
+      },
+    );
+
+    try {
+      expect(controller.handleCommand("mcp", state)).toBe(true);
+      renderSelect(expectOverlay(runtimeState.overlay)).props.onKeyPress?.(
+        "enter",
+      );
+      await Promise.resolve();
+      await Promise.resolve();
+
+      expect(state.mcpServers[0]?.enabled).toBe(false);
+      expect(state.mcpServers[0]?.connected).toBe(false);
+      expect(state.settings).toEqual({
+        mcp: {
+          servers: [
+            {
+              name: "docs",
+              url: "http://global-docs.test/mcp",
+              enabled: false,
+            },
+            {
+              name: "down",
+              url: "http://down.test/mcp",
+              enabled: false,
+            },
+          ],
+        },
+      });
+      expect(loadSettings(state.settingsPath)).toEqual(state.settings);
+      expect(disconnectCalls).toBe(1);
+
+      expect(controller.handleCommand("mcp", state)).toBe(true);
+      renderSelect(expectOverlay(runtimeState.overlay)).props.onKeyPress?.(
+        "enter",
+      );
+      await Promise.resolve();
+      await Promise.resolve();
+
+      expect(state.mcpServers[0]?.enabled).toBe(true);
+      expect(state.mcpServers[0]?.connected).toBe(true);
+      expect(connectCalls).toBe(1);
+      expect(state.settings).toEqual({
+        mcp: {
+          servers: [
+            {
+              name: "docs",
+              url: "http://global-docs.test/mcp",
+              enabled: false,
+            },
+            {
+              name: "down",
+              url: "http://down.test/mcp",
+              enabled: false,
+            },
+          ],
+        },
+      });
+      expect(loadSettings(state.settingsPath)).toEqual(state.settings);
+      expect(appended).toEqual([
+        {
+          text: 'Disabled MCP server "docs" (-1 tool).',
+          sessionId: null,
+        },
+        {
+          text: 'Enabled MCP server "docs" (+1 tool).',
+          sessionId: null,
+        },
+      ]);
+    } finally {
+      state.db.close();
+    }
+  });
+
   test("/help appends a markdown info message without creating a session", () => {
     const state = createTestState();
+    state.mcpServers = [
+      {
+        name: "docs",
+        url: "http://docs.test/mcp",
+        enabled: false,
+        connected: false,
+        tools: [],
+        toolHandlers: new Map(),
+        close: async () => {},
+      },
+    ];
     const appended: Array<{
       text: string;
       format: string | undefined;
@@ -315,6 +780,12 @@ describe("ui/commands", () => {
       expect(controller.handleCommand("help", state)).toBe(true);
       expect(appended).toHaveLength(1);
       expect(appended[0]?.text.length).toBeGreaterThan(0);
+      expect(appended[0]?.text).toContain("`/mcp`");
+      expect(appended[0]?.text).toContain("`/skill:name`");
+      expect(appended[0]?.text).toContain(
+        "submit `/skill` to open the skill picker",
+      );
+      expect(appended[0]?.text).toContain("`docs` (off)");
       expect(appended[0]?.format).toBe("markdown");
       expect(appended[0]?.sessionId).toBeNull();
       expect(state.session).toBeNull();