decorated-pi 0.5.4 → 0.6.0

package/{extensions/io.ts → tools/patch/index.ts}

@@ -1,53 +1,19 @@
 /**
- * IO — Replace Pi native edit/write with `patch` tool (single-file)
+ * patch — exact string replacement tool.
  *
- * Keeps:   read (for stale-read protection via mtime tracking)
- * Removes: edit, write
- * Adds:    patch (old_str/new_str exact replacement, single file per call)
- *
- * Schema: { path, edits?, overwrite?, new_str? }
- * Pi’s native parallel tool calls handle multi-file scenarios.
- *
- * Stale-read protection:
- *   - `read` tool records file mtime when LLM reads a file
- *   - `patch` tool checks: if file mtime > last-read mtime → reject
- *   - `patch` tool updates mtime after successful write
- *
- * TUI Rendering Pitfalls (learned the hard way):
- *   1. execute() MUST throw errors, NOT return { isError: true }
- *   2. TUI rendering MUST mirror the edit tool pattern exactly
- *   3. getPatchHeaderBg: settledError MUST be checked first
- *   4. renderResult must NOT return the Box
- *      renderCall returns the Box (callComponent). If renderResult
- *      also returns it, pi's ToolExecutionComponent adds it twice
- *      to the container, causing duplicate boxes. renderResult
- *      must return context.lastComponent (a separate Container).
- *   5. Error text must go INSIDE the Box, not in the result Container
- *   6. prepareArguments must handle literal newlines in JSON strings
+ * Replaces pi's native edit/write. Stale-read protection and mtime tracking
+ * are in hooks/track-mtime.ts (this tool does not register hooks itself).
  */
 
-import { defineTool, isEditToolResult, isReadToolResult, isWriteToolResult, keyHint, type ExtensionAPI, type ToolResultEvent, type ToolResultEventResult } from "@earendil-works/pi-coding-agent";
+import { defineTool, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { renderDiff } from "@earendil-works/pi-coding-agent";
 import { Box, Container, Spacer, Text, truncateToWidth } from "@earendil-works/pi-tui";
-import { writeOutputToTemp } from "./io-tool-output.js";
 import { Type } from "typebox";
 import {
   applyPatch,
-  formatPatchResult,
   generatePatchDiff,
   type PatchPreview,
-} from "./patch.js";
-import {
-  recordReadTime,
-  checkStaleFile,
-  clearReadMarkers,
-  resolveAbsolutePath,
-  FILE_TIMES_CUSTOM_TYPE,
-  createFileTimeMarkerData,
-  restoreReadMarkersFromBranch,
-} from "./file-times.js";
-
-// ─── Schema ─────────────────────────────────────────────────────────────────────────
+} from "./core.js";
 
 const EditSchema = Type.Object({
   anchor: Type.Optional(Type.String({
@@ -70,8 +36,6 @@ const PatchSchema = Type.Object({
   }),
 });
 
-// ─── Argument repair ───────────────────────────────────────────────────────────────
-
 function fixJsonNewlines(str: string): string {
   let result = '';
   let inString = false;
@@ -97,18 +61,13 @@ function jsonParseWithNewlineFix(str: string): any {
 
 export function preparePatchArguments(input: any): any {
   if (!input || typeof input !== "object") return input;
-
   const args = input as Record<string, any>;
-
-  // Edits serialized as JSON string
   if (typeof args.edits === "string") {
     try {
       const parsed = jsonParseWithNewlineFix(args.edits);
       if (Array.isArray(parsed)) args.edits = parsed;
     } catch { /* keep original */ }
   }
-
-  // Legacy: top-level old_str/new_str instead of edits array
   if (typeof args.old_str === "string" && typeof args.new_str === "string") {
     const edit: any = { old_str: args.old_str, new_str: args.new_str };
     if (typeof args.anchor === "string") edit.anchor = args.anchor;
@@ -117,12 +76,9 @@ export function preparePatchArguments(input: any): any {
     delete args.new_str;
     delete args.anchor;
   }
-
   return args;
 }
 
-// ─── TUI rendering ─────────────────────────────────────────────────────────────────
-
 interface PatchCallComponent extends Box {
   preview?: PatchPreview;
   previewArgsKey?: string;
@@ -156,13 +112,9 @@ function replaceTabs(text: string): string {
 }
 
 function getPatchHeaderBg(component: PatchCallComponent, theme: any) {
-  if (component.settledError) {
-    return (text: string) => theme.bg("toolErrorBg", text);
-  }
+  if (component.settledError) return (text: string) => theme.bg("toolErrorBg", text);
   if (component.preview) {
-    if ("error" in component.preview && component.preview.error) {
-      return (text: string) => theme.bg("toolErrorBg", text);
-    }
+    if ("error" in component.preview && component.preview.error) return (text: string) => theme.bg("toolErrorBg", text);
     return (text: string) => theme.bg("toolSuccessBg", text);
   }
   return (text: string) => theme.bg("toolPendingBg", text);
@@ -170,9 +122,7 @@ function getPatchHeaderBg(component: PatchCallComponent, theme: any) {
 
 function createSingleLineComponent(text: string) {
   return {
-    render(width: number) {
-      return [truncateToWidth(text, width)];
-    },
+    render(width: number) { return [truncateToWidth(text, width)]; },
     invalidate() {},
   };
 }
@@ -188,39 +138,23 @@ function formatPatchMetaLine(line: string, theme: any): string {
 function appendPatchDiffChildren(parent: Box, body: string, theme: any): void {
   const rawLines = body.split("\n");
   let buffer: string[] = [];
-
   const flush = () => {
     if (buffer.length === 0) return;
     parent.addChild(new Text(renderDiff(replaceTabs(buffer.join("\n"))), 0, 0));
     buffer = [];
   };
-
   for (const line of rawLines) {
-    if (line.startsWith("@@ lines ")) {
-      flush();
-      parent.addChild(createSingleLineComponent(formatPatchMetaLine(line, theme)) as any);
-      continue;
-    }
-    if (line === "anchors:") {
-      flush();
-      parent.addChild(createSingleLineComponent(formatPatchMetaLine(line, theme)) as any);
-      continue;
-    }
-    if (line.startsWith("  - ")) {
-      flush();
-      parent.addChild(createSingleLineComponent(formatPatchMetaLine(line, theme)) as any);
-      continue;
-    }
+    if (line.startsWith("@@ lines ")) { flush(); parent.addChild(createSingleLineComponent(formatPatchMetaLine(line, theme)) as any); continue; }
+    if (line === "anchors:") { flush(); parent.addChild(createSingleLineComponent(formatPatchMetaLine(line, theme)) as any); continue; }
+    if (line.startsWith("  - ")) { flush(); parent.addChild(createSingleLineComponent(formatPatchMetaLine(line, theme)) as any); continue; }
     buffer.push(line);
   }
-
   flush();
 }
 
-export function buildPatchCallComponent(component: PatchCallComponent, args: any, theme: any, expanded = false) {
+function buildPatchCallComponent(component: PatchCallComponent, args: any, theme: any, expanded = false) {
   component.setBgFn(getPatchHeaderBg(component, theme));
   component.clear();
-
   let label = "";
   if (args?.path) {
     label = theme.fg("accent", args.path);
@@ -230,115 +164,37 @@ export function buildPatchCallComponent(component: PatchCallComponent, args: any
   }
   const headerText = theme.fg("toolTitle", theme.bold("patch")) + (label ? " " + label : "");
   component.addChild(new Text(headerText, 0, 0));
-
   if (component.settledError || !component.preview) return component;
-
   const preview = component.preview;
   let body = "";
-  if ("diff" in preview && preview.diff) {
-    body = preview.diff;
-  } else if ("error" in preview && preview.error) {
+  if ("diff" in preview && preview.diff) body = preview.diff;
+  else if ("error" in preview && preview.error) {
     component.addChild(new Spacer(1));
     component.addChild(new Text(theme.fg("error", `  Error: ${preview.error}`), 0, 0));
     return component;
   }
-
-  if (!body) return component;
-
+  if (!body) {
+    component.addChild(new Spacer(1));
+    component.addChild(new Text(theme.fg("dim", `  (no changes)`), 0, 0));
+    return component;
+  }
   const lines = body.split("\n");
   const FOLD_THRESHOLD = 45;
-
   component.addChild(new Spacer(1));
-
   if (lines.length > FOLD_THRESHOLD && !expanded) {
-    // 折叠态: 显示前几行 + 摘要
     const shown = lines.slice(0, 10).join("\n");
     appendPatchDiffChildren(component, shown, theme);
     component.addChild(new Text(
-      theme.fg("dim", `  ... ${lines.length - 10} more lines (`) + keyHint("app.tools.expand", "expand") + theme.fg("dim", ")"),
+      theme.fg("dim", `  ... ${lines.length - 10} more lines (`) + "(expand)" + theme.fg("dim", ")"),
       0, 0,
     ));
   } else {
-    // 展开态: 完整显示
     appendPatchDiffChildren(component, body, theme);
   }
-
   return component;
 }
 
-// ─── Setup ──────────────────────────────────────────────────────────────────────────
-
-export const OUTPUT_EXTERNALIZE_THRESHOLD = 30_000; // 30KB — match Claude Code's bash truncation threshold
-
-/** If the tool result content is a single text string longer than the
- *  threshold, replace it with a one-line placeholder pointing at the
- *  full output on disk. Returns the modified result, or undefined to
- *  leave the original content untouched. */
-export function maybeExternalizeToolResult(event: ToolResultEvent): ToolResultEventResult | undefined {
-  const content = event.content;
-  if (!Array.isArray(content) || content.length === 0) return undefined;
-  const first = content[0];
-  if (first?.type !== "text" || typeof first.text !== "string") return undefined;
-  const text = first.text;
-  if (text.length <= OUTPUT_EXTERNALIZE_THRESHOLD) return undefined;
-
-  const filePath = writeOutputToTemp(event.toolName, event.toolCallId, text);
-  if (!filePath) return undefined; // write failed — keep original content
-
-  return {
-    content: [{
-      type: "text" as const,
-      text: `[Output truncated: ${text.length.toLocaleString()} chars. Full output: ${filePath}]`,
-    }],
-  };
-}
-
-export function setupIO(pi: ExtensionAPI) {
-  pi.on("session_start", (_event, ctx) => {
-    restoreReadMarkersFromBranch(ctx.sessionManager.getBranch() as any[], ctx.cwd);
-    const active = pi.getActiveTools();
-    // Remove: edit (replaced by patch), grep/find/ls (replaced by bash)
-    // Keep: write (full-file write)
-    pi.setActiveTools(active.filter(t => !["edit", "grep", "find", "ls"].includes(t)));
-  });
-
-  pi.on("session_compact", () => {
-    clearReadMarkers();
-  });
-
-  // Externalize large tool results (read / bash) to a temp file.
-  // Keeps the messages segment small so prompt cache stays warm across turns.
-  pi.on("tool_result", (event) => {
-    if (event.toolName !== "read" && event.toolName !== "bash") return;
-    return maybeExternalizeToolResult(event);
-  });
-
-  // Track file read times
-  pi.on("tool_result", (event, ctx) => {
-    if (!isReadToolResult(event)) return;
-    const filePath = event.input?.path;
-    if (typeof filePath !== "string" || !filePath.trim()) return;
-    const cwd: string = ctx.cwd ?? process.cwd();
-    const absPath = resolveAbsolutePath(cwd, filePath);
-    recordReadTime(absPath);
-    const marker = createFileTimeMarkerData(cwd, absPath);
-    if (marker) pi.appendEntry(FILE_TIMES_CUSTOM_TYPE, marker);
-  });
-
-  // Track file write times (for write and edit, in case patch module is disabled)
-  pi.on("tool_result", (event, ctx) => {
-    if (!isWriteToolResult(event) && !isEditToolResult(event)) return;
-    const filePath = event.input?.path;
-    if (typeof filePath !== "string" || !filePath.trim()) return;
-    const cwd: string = ctx.cwd ?? process.cwd();
-    const absPath = resolveAbsolutePath(cwd, filePath);
-    // Only record if the write succeeded (not an error result)
-    if (event.isError) return;
-    recordReadTime(absPath);
-    const marker = createFileTimeMarkerData(cwd, absPath);
-    if (marker) pi.appendEntry(FILE_TIMES_CUSTOM_TYPE, marker);
-  });
-
+export function registerPatchTool(pi: ExtensionAPI): void {
   pi.registerTool(defineTool({
     name: "patch",
     label: "Patch",
@@ -349,7 +205,7 @@ export function setupIO(pi: ExtensionAPI) {
       "Examples:",
       '  { path: "src/foo.ts", edits: [{ old_str: "return 1", new_str: "return 42" }] }',
       '  { path: "src/foo.ts", edits: [{ anchor: "function bar() {", old_str: "return x", new_str: "return x + 1" }] }',
-      '  { path: "src/foo.ts", edits: [{ anchor: "function init() {", old_str: "const DEBUG = true;", new_str: "const DEBUG = false;" }, { old_str: "log(\"debug\");", new_str: "// debug disabled" }] }',
+      '  { path: "src/foo.ts", edits: [{ anchor: "function init() {", old_str: "const DEBUG = true;", new_str: "const DEBUG = false;" }, { old_str: "log(\\"debug\\");", new_str: "// debug disabled" }] }',
       "",
       "Anchor (optional): narrows old_str search to lines after a unique marker.",
       "  Code: use the enclosing definition — function/class/struct/method signature.",
@@ -368,36 +224,19 @@ export function setupIO(pi: ExtensionAPI) {
     prepareArguments: preparePatchArguments,
     execute: async (_toolCallId: string, input: { path: string; edits: any[] }, _signal: any, _onUpdate: any, ctx: any) => {
       const cwd: string = ctx.cwd ?? process.cwd();
-
-      // Stale-read protection
-      if (input.path?.trim()) {
-        const absPath = resolveAbsolutePath(cwd, input.path);
-        const staleError = checkStaleFile(absPath, input.path);
-        if (staleError) throw new Error(staleError);
-      }
-
+      // Stale-read check is in hooks/track-mtime.ts (tool_call phase).
+      // Just apply the patch here.
       const result = await applyPatch(input as any, cwd);
-
-      // Update read markers after successful write
-      for (const filePath of [...result.modified, ...result.created]) {
-        const absPath = resolveAbsolutePath(cwd, filePath);
-        recordReadTime(absPath);
-        const marker = createFileTimeMarkerData(cwd, absPath);
-        if (marker) pi.appendEntry(FILE_TIMES_CUSTOM_TYPE, marker);
-      }
-
-      const summary = formatPatchResult(result);
       const diff = generatePatchDiff(result);
-      return {
-        content: [{ type: "text", text: summary }],
-        details: { diff },
-      };
+      // Return "Success" on the LLM-facing channel — the model already knows
+      // what it asked to change (it sent the edits). The full diff stays in
+      // `details` for the TUI renderer. This keeps the prompt-cache segment
+      // stable: success always costs 1 token regardless of N hunks edited.
+      return { content: [{ type: "text", text: "Success" }], details: { diff } };
     },
-
     renderCall(args: any, theme: any, context: any) {
       const state = context.state;
       const component = getPatchCallComponent(state, context.lastComponent);
-
       const argsKey = args ? JSON.stringify(args) : undefined;
       if (component.previewArgsKey !== argsKey) {
         component.preview = undefined;
@@ -405,20 +244,12 @@ export function setupIO(pi: ExtensionAPI) {
         component.previewPending = false;
         component.settledError = false;
       }
-
-      // Preview diff is computed during execute and delivered via result.details.diff.
-      // Skipping async preview here avoids a redundant file read — same design as
-      // Pi's native edit tool where renderResult overwrites the preview with execute's diff.
-
       return buildPatchCallComponent(component, args, theme, context.expanded);
     },
-
     renderResult(result: any, options: any, theme: any, context: any) {
       const callComponent: PatchCallComponent | undefined = context.state.callComponent;
       let changed = false;
-
       if (callComponent) {
-        // Use execute's returned diff (same design as Pi's native edit tool)
         const resultDiff = !context.isError && result.details?.diff;
         if (typeof resultDiff === "string") {
           const newPreview = { diff: resultDiff };
@@ -427,13 +258,10 @@ export function setupIO(pi: ExtensionAPI) {
             changed = true;
           }
         }
-
-        // Update error state
         if (callComponent.settledError !== context.isError) {
           callComponent.settledError = context.isError;
           changed = true;
         }
-
         if (changed) {
           buildPatchCallComponent(callComponent, context.args, theme, options.expanded);
           if (context.isError) {
@@ -448,10 +276,6 @@ export function setupIO(pi: ExtensionAPI) {
           }
         }
       }
-
-      // Return empty Container — the Box (callComponent) already holds all content.
-      // Per pitfall #4: returning the Box would cause ToolExecutionComponent to add
-      // it twice to the container, producing duplicate rendering.
       const component = context.lastComponent ?? new Container();
       component.clear();
       return component;

package/tsconfig.json

@@ -11,6 +11,15 @@
     "rootDir": ".",
     "noEmit": true
   },
-  "include": ["extensions/**/*.ts", "test/**/*.ts"],
+  "include": [
+    "index.ts",
+    "settings.ts",
+    "tools/**/*.ts",
+    "hooks/**/*.ts",
+    "commands/**/*.ts",
+    "providers/**/*.ts",
+    "ui/**/*.ts",
+    "test/**/*.ts"
+  ],
   "exclude": ["node_modules", "dist"]
 }

package/ui/mcp-status.ts

@@ -0,0 +1,202 @@
+/**
+ * MCP Status UI — used by /mcp command.
+ *
+ * Pure presentation: receives callbacks for read/toggle/refresh, knows
+ * nothing about the hook layer or config persistence. The caller (in
+ * commands/mcp-status.ts) wires up the concrete hook-layer functions.
+ */
+
+import type { Theme as PiTheme } from "@earendil-works/pi-coding-agent";
+import { Container, Spacer, Text, type TUI, type Component, getKeybindings } from "@earendil-works/pi-tui";
+
+// ─── Public types ──────────────────────────────────────────────────────────
+
+/** Status reported by the read() callback. UI doesn't care where it comes from. */
+export type McpServerState = "connecting" | "connected" | "failed" | "disabled" | "waiting reload";
+
+export interface McpServerView {
+  name: string;
+  url: string;
+  source: string;
+  state: McpServerState;
+  toolCount: number;
+  tools: Array<{ name: string; description?: string; inputSchema?: Record<string, unknown> }>;
+  description?: string;
+  error?: string;
+}
+
+/** Result of a refresh attempt. */
+export interface McpRefreshResult {
+  ok: boolean;
+  error?: string;
+}
+
+/**
+ * Callbacks the UI calls back into. The host (commands/<x>-status.ts)
+ * injects concrete implementations that bridge to the hook layer.
+ */
+export interface McpStatusCallbacks {
+  /** Snapshot the current server list. Called on every render tick. */
+  read: () => McpServerView[];
+  /**
+   * Toggle a server's enabled state. Returns true if the config was
+   * updated; UI then re-renders. Side effects (connection teardown)
+   * are the caller's responsibility.
+   */
+  toggle: (name: string, enabled: boolean) => Promise<boolean> | boolean;
+  /** Force-reconnect a single server. */
+  refresh: (name: string) => Promise<McpRefreshResult>;
+}
+
+// ─── Internal: border ──────────────────────────────────────────────────────
+
+class DynamicBorder implements Component {
+  private colorFn: (str: string) => string;
+  constructor(theme: PiTheme) { this.colorFn = (str: string) => theme.fg("border", str); }
+  invalidate() {}
+  render(width: number): string[] { return [this.colorFn("─".repeat(Math.max(1, width)))]; }
+}
+
+// ─── Component ─────────────────────────────────────────────────────────────
+
+export class McpStatusComponent extends Container {
+  private linesComponent: Text;
+  private hintComponent: Text;
+  private notifyComponent: Text;
+  private tui: TUI;
+  private theme: PiTheme;
+  private done: () => void;
+  private callbacks: McpStatusCallbacks;
+  private selected = 0;
+  private servers: McpServerView[] = [];
+  private notifyText = "";
+  private notifyTimer: ReturnType<typeof setTimeout> | null = null;
+  private refreshing = new Set<string>();
+  private autoRefreshTimer: ReturnType<typeof setInterval> | null = null;
+
+  constructor(tui: TUI, theme: PiTheme, callbacks: McpStatusCallbacks, onDone: () => void) {
+    super();
+    this.tui = tui; this.theme = theme; this.done = onDone; this.callbacks = callbacks;
+    this.addChild(new DynamicBorder(theme));
+    this.addChild(new Spacer(1));
+    this.linesComponent = new Text("", 1, 0);
+    this.addChild(this.linesComponent);
+    this.addChild(new Spacer(1));
+    this.notifyComponent = new Text("", 1, 0);
+    this.addChild(this.notifyComponent);
+    this.hintComponent = new Text("", 1, 0);
+    this.addChild(this.hintComponent);
+    this.addChild(new Spacer(1));
+    this.addChild(new DynamicBorder(theme));
+    this.updateServers();
+    this.renderView();
+    this.autoRefreshTimer = setInterval(() => {
+      this.updateServers(); this.renderView();
+      const allSettled = this.servers.every((s) => s.state !== "connecting");
+      if (allSettled && this.autoRefreshTimer) { clearInterval(this.autoRefreshTimer); this.autoRefreshTimer = null; }
+    }, 500);
+  }
+
+  private updateServers() {
+    this.servers = this.callbacks.read();
+    if (this.selected >= this.servers.length) this.selected = Math.max(0, this.servers.length - 1);
+  }
+
+  private renderView() {
+    if (this.servers.length === 0) {
+      this.linesComponent.setText("No MCP servers configured.");
+      this.hintComponent.setText(this.theme.fg("dim", "q close"));
+      this.tui.requestRender();
+      return;
+    }
+    const lines: string[] = [`MCP servers (${this.servers.length}):`, ""];
+    const namePad = Math.max(...this.servers.map((s) => s.name.length), 12);
+    for (let i = 0; i < this.servers.length; i++) {
+      const s = this.servers[i];
+      const isSelected = i === this.selected;
+      const isDisabled = s.state === "disabled";
+      const cursor = isSelected ? this.theme.fg("accent", "→ ") : "  ";
+      let statusIcon: string;
+      let statusColor: (s: string) => string;
+      if (s.state === "connected") { statusIcon = "🟢"; statusColor = (str: string) => this.theme.fg("accent", str); }
+      else if (s.state === "connecting") { statusIcon = "🟡"; statusColor = (str: string) => this.theme.fg("warning", str); }
+      else if (s.state === "waiting reload") { statusIcon = "⏳"; statusColor = (str: string) => this.theme.fg("accent", str); }
+      else if (s.state === "disabled") { statusIcon = "⚪"; statusColor = (str: string) => this.theme.fg("dim", str); }
+      else { statusIcon = "🔴"; statusColor = (str: string) => this.theme.fg("error", str); }
+      const name = isDisabled ? this.theme.fg("dim", s.name) : isSelected ? this.theme.fg("accent", s.name) : s.name;
+      const namePadding = " ".repeat(Math.max(0, namePad - s.name.length));
+      const desc = s.description ? ` — ${s.description.slice(0, 50)}` : "";
+      lines.push(`${cursor}${name}${namePadding}  ${statusIcon} ${statusColor(s.state)}${desc}`);
+      if (isSelected) {
+        lines.push(`    ${this.theme.fg("dim", s.url)}`);
+        if (s.error) lines.push(`    ${this.theme.fg("error", `Error: ${s.error}`)}`);
+        if (s.tools.length > 0) {
+          lines.push(`    ${s.toolCount} tool${s.toolCount === 1 ? "" : "s"}:`);
+          for (const tool of s.tools.slice(0, 6)) {
+            const flat = (tool.description ?? "").replace(/\s+/g, " ").trim();
+            const td = flat ? (flat.length > 55 ? ` — ${flat.slice(0, 55)}…` : ` — ${flat}`) : "";
+            lines.push(`      ${tool.name}${td}`);
+          }
+          if (s.tools.length > 6) lines.push(`      ... and ${s.tools.length - 6} more`);
+        }
+        lines.push("");
+      }
+    }
+    this.linesComponent.setText(lines.join("\n"));
+    const s = this.servers[this.selected];
+    const toggleHint = s?.state === "disabled" || s?.state === "waiting reload" ? "space enable" : "space disable";
+    const hintParts = ["↑↓ navigate", toggleHint, "r refresh", "q close"];
+    this.hintComponent.setText(this.theme.fg("dim", hintParts.join(" | ")));
+    this.notifyComponent.setText(this.notifyText ? this.theme.fg("warning", this.notifyText) : "");
+    this.tui.requestRender();
+  }
+
+  private showNotify(text: string) {
+    this.notifyText = text; this.renderView();
+    if (this.notifyTimer) clearTimeout(this.notifyTimer);
+    this.notifyTimer = setTimeout(() => { this.notifyText = ""; this.renderView(); }, 3000);
+  }
+
+  handleInput(data: string) {
+    const kb = getKeybindings();
+    if (kb.matches(data, "tui.select.up")) { this.selected = Math.max(0, this.selected - 1); this.renderView(); return; }
+    if (kb.matches(data, "tui.select.down")) { this.selected = Math.min(this.servers.length - 1, this.selected + 1); this.renderView(); return; }
+    if (data === "q" || data === "\r" || data === "\n" || kb.matches(data, "tui.select.cancel")) {
+      if (this.autoRefreshTimer) { clearInterval(this.autoRefreshTimer); this.autoRefreshTimer = null; }
+      if (this.notifyTimer) { clearTimeout(this.notifyTimer); this.notifyTimer = null; }
+      this.done();
+      return;
+    }
+    if (this.servers.length === 0) return;
+    const s = this.servers[this.selected];
+    if (data === " ") {
+      const newEnabled = s.state === "disabled";
+      void (async () => {
+        const ok = await this.callbacks.toggle(s.name, newEnabled);
+        this.showNotify(ok ? `${newEnabled ? "Enabled" : "Disabled"} "${s.name}". Use /reload to apply.` : `Failed to toggle "${s.name}".`);
+        this.updateServers(); this.renderView();
+      })();
+      return;
+    }
+    if (data === "r") {
+      if (this.refreshing.has(s.name)) return;
+      this.refreshing.add(s.name);
+      const targetName = s.name; const targetIndex = this.selected;
+      this.showNotify(`Refreshing "${targetName}"...`);
+      void (async () => {
+        const result = await this.callbacks.refresh(targetName);
+        this.refreshing.delete(targetName);
+        if (this.selected === targetIndex) {
+          this.updateServers(); this.renderView();
+          this.showNotify(result.ok ? `Refreshed "${targetName}".` : `Refresh failed: ${result.error}`);
+        }
+      })();
+      return;
+    }
+  }
+
+  dispose() {
+    if (this.autoRefreshTimer) { clearInterval(this.autoRefreshTimer); this.autoRefreshTimer = null; }
+    if (this.notifyTimer) { clearTimeout(this.notifyTimer); this.notifyTimer = null; }
+  }
+}