@meowlynxsea/koi 0.1.2 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meowlynxsea/koi",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "A coding agent built on Pi SDK with TUI + Bun runtime",
   "module": "src/main.tsx",
   "type": "module",
@@ -44,6 +44,7 @@
     "@opentui/core": "latest",
     "@opentui/react": "latest",
     "@types/diff": "^8.0.0",
+    "@types/node": "^25.6.2",
     "axios": "^1.16.0",
     "bun": "^1.3.12",
     "commander": "^14.0.3",

package/src/agent/mode.ts

@@ -95,6 +95,7 @@ const ALL_TOOLS = [
   "agent",
   "CreateMonitor",
   "CancelMonitor",
+  "SendToMonitor"
 ];
 
 const READONLY_TOOLS = [

package/src/agent/monitor-registry.ts

@@ -1,19 +1,19 @@
 /**
- * Monitor Registry — 后台监控任务管理器
+ * Monitor Registry — 后台监控任务管理器 (PTY 版本)
  *
- * Manages background process monitors that watch command output and notify
- * the main agent when changes occur.
- *
- * Notification delivery:
- *   - Main agent busy → steer() to insert notification
- *   - Main agent idle → prompt() to trigger a new run
+ * Manages background process monitors using PTY for full I/O isolation.
+ * Supports:
+ * - PTY-based execution (full terminal isolation)
+ * - Process input via SendToMonitor
+ * - External PTY handoff from bash tool
+ * - Output notifications to parent agent
  */
 
-import { spawn, ChildProcess } from "child_process";
+import { spawnPty, PtySession, type PtyData } from "../tools/pty.js";
 import { EventEmitter } from "events";
 import { activeSessionRef } from "./hooks.js";
 
-export type MonitorStatus = "running" | "completed" | "killed" | "error";
+export type MonitorStatus = "running" | "completed" | "killed" | "error" | "detached";
 
 export interface MonitorEntry {
   id: string;
@@ -27,29 +27,49 @@ export interface MonitorEntry {
   outputLines: string[];
   lastOutput?: string;
   error?: string;
+  hasPendingInput?: boolean; // 如果有等待输入的命令
 }
 
 type MonitorListener = (entries: MonitorEntry[]) => void;
 
+// 检测是否需要交互式输入的关键词
+const INTERACTIVE_PATTERNS = [
+  /password\s*[:：]/i,
+  /passphrase\s*[:：]/i,
+  /enter\s*(your)?\s*password/i,
+  /\[sudo\]\s*password/i,
+  /press\s*(any)?\s*key\s*to/i,
+  /press\s*enter\s*to/i,
+  /continue\s*\?\s*\[y\/n\]/i,
+  /yes\/no\s*\[\w\]\s*:/i,
+  /confirm\s*\?\s*\[y\/n\]/i,
+];
+
+function detectInteractivePrompt(output: string): boolean {
+  for (const pattern of INTERACTIVE_PATTERNS) {
+    if (pattern.test(output)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 /**
  * Creates a monitor notification XML tag for internal LLM communication.
- * These tags are filtered out of the UI but visible to the agent.
  */
 function createMonitorNotification(
   monitorId: string,
-  type: "output" | "completed" | "error",
+  type: "output" | "completed" | "error" | "interactive",
   payload: string
 ): string {
-  return `<monitor-notification>\n  <monitor-id>${monitorId}</monitor-id>\n  <type>${type}</type>\n  <payload>${escapeXml(payload)}</payload>\n</monitor-notification>`;
-}
-
-function escapeXml(str: string): string {
-  return str
+  const escaped = payload
     .replace(/&/g, "&amp;")
     .replace(/</g, "&lt;")
     .replace(/>/g, "&gt;")
     .replace(/"/g, "&quot;")
     .replace(/'/g, "&apos;");
+  
+  return `<monitor-notification>\n  <monitor-id>${monitorId}</monitor-id>\n  <type>${type}</type>\n  <payload>${escaped}</payload>\n</monitor-notification>`;
 }
 
 /**
@@ -61,10 +81,10 @@ function generateMonitorId(): string {
 
 class MonitorRegistryImpl extends EventEmitter {
   private monitors = new Map<string, MonitorEntry>();
-  private processes = new Map<string, ChildProcess>();
+  private sessions = new Map<string, PtySession>();
 
   /**
-   * Launch a new background monitor.
+   * Launch a new background monitor with PTY.
    * Returns the monitor ID.
    */
   launch(sessionId: string, command: string, description: string = ""): string {
@@ -81,125 +101,169 @@ class MonitorRegistryImpl extends EventEmitter {
     };
 
     this.monitors.set(id, entry);
-    this.emit("change", this.getAll());
 
-    // Spawn the background process
-    const child = spawn("bash", ["-c", command], {
-      stdio: ["ignore", "pipe", "pipe"],
-      detached: false, // Keep in same process group so we can kill it
+    // Create PTY and session
+    const pty = spawnPty({
+      command: "bash",
+      args: ["-c", command],
     });
 
-    this.processes.set(id, child);
+    const session = new PtySession(id, pty, command);
+    
+    // Forward data to registry handlers
+    session.on("data", (data: string) => {
+      this.handlePtyData(id, { type: "data", data });
+    });
+    
+    session.on("exit", ({ exitCode }) => {
+      this.handlePtyExit(id, exitCode ?? 0);
+    });
 
-    let stderrBuffer = "";
+    this.sessions.set(id, session);
+    this.emit("change", this.getAll());
 
-    // Capture stdout line by line
-    child.stdout?.on("data", (chunk: Buffer) => {
-      const lines = chunk.toString().split("\n");
-      for (const line of lines) {
-        if (!line && lines.length === 1) continue; // Skip empty lines from partial chunks
-        const trimmed = line.trimEnd();
-        if (!trimmed) continue;
+    return id;
+  }
 
-        const monitor = this.monitors.get(id);
-        if (monitor) {
-          monitor.outputLines.push(trimmed);
-          monitor.lastOutput = trimmed;
-        }
+  /**
+   * Adopt an existing PtySession into the registry.
+   * Used by bash tool when timeout occurs.
+   */
+  adopt(
+    oldSession: PtySession,
+    sessionId: string,
+    command: string,
+    description?: string
+  ): string {
+    const id = oldSession.id;
+    
+    // Create a new PtySession with the same pty process
+    // This sets up new listeners while old session's listeners are cleaned up by caller
+    const pty = oldSession.pty;
+    const newSession = new PtySession(id, pty, command);
 
-        const notification = createMonitorNotification(id, "output", trimmed);
-        this.notifyParent(notification);
-        this.emit("change", this.getAll());
-      }
-    });
+    const entry: MonitorEntry = {
+      id,
+      sessionId,
+      description: description || `Monitor: ${command.slice(0, 40)}${command.length > 40 ? "…" : ""}`,
+      command,
+      status: "running",
+      startTime: oldSession.startTime,
+      outputLines: [],
+    };
+
+    this.monitors.set(id, entry);
+    this.sessions.set(id, newSession);
 
-    // Capture stderr
-    child.stderr?.on("data", (chunk: Buffer) => {
-      stderrBuffer += chunk.toString();
+    // Forward data to registry handlers
+    newSession.on("data", (data: string) => {
+      this.handlePtyData(id, { type: "data", data });
     });
 
-    // Handle process exit
-    child.on("close", (code: number | null) => {
-      this.processes.delete(id);
+    newSession.on("exit", ({ exitCode }) => {
+      this.handlePtyExit(id, exitCode ?? 0);
+    });
 
-      const monitor = this.monitors.get(id);
-      if (!monitor) return;
+    this.emit("change", this.getAll());
+    return id;
+  }
 
-      if (stderrBuffer.trim()) {
-        monitor.error = stderrBuffer.trim();
-        const notification = createMonitorNotification(id, "error", stderrBuffer.trim());
-        this.notifyParent(notification);
-      }
+  /**
+   * Handle PTY data.
+   */
+  private handlePtyData(id: string, data: PtyData): void {
+    const monitor = this.monitors.get(id);
+    if (!monitor) return;
 
-      if (monitor.status === "running") {
-        monitor.status = code === 0 ? "completed" : "error";
-        monitor.exitCode = code ?? undefined;
-        monitor.endTime = Date.now();
+    if (data.type === "data" && data.data) {
+      // 累积输出
+      monitor.outputLines.push(data.data);
+      monitor.lastOutput = data.data;
 
+      // 检测交互式提示
+      if (detectInteractivePrompt(data.data)) {
+        monitor.hasPendingInput = true;
         const notification = createMonitorNotification(
           id,
-          "completed",
-          `Exited with code ${code ?? "unknown"}`
+          "interactive",
+          data.data
         );
         this.notifyParent(notification);
+      } else {
+        const notification = createMonitorNotification(id, "output", data.data);
+        this.notifyParent(notification);
       }
+    }
 
-      this.emit("change", this.getAll());
-    });
+    this.emit("change", this.getAll());
+  }
 
-    child.on("error", (err: Error) => {
-      this.processes.delete(id);
+  /**
+   * Handle PTY exit.
+   */
+  private handlePtyExit(id: string, exitCode: number): void {
+    this.sessions.delete(id);
 
-      const monitor = this.monitors.get(id);
-      if (monitor) {
-        monitor.status = "error";
-        monitor.error = err.message;
-        monitor.endTime = Date.now();
+    const monitor = this.monitors.get(id);
+    if (!monitor) return;
 
-        const notification = createMonitorNotification(id, "error", err.message);
-        this.notifyParent(notification);
-      }
+    monitor.status = exitCode === 0 ? "completed" : "error";
+    monitor.exitCode = exitCode;
+    monitor.endTime = Date.now();
 
-      this.emit("change", this.getAll());
-    });
+    const notification = createMonitorNotification(
+      id,
+      "completed",
+      `Exited with code ${exitCode}`
+    );
+    this.notifyParent(notification);
 
-    return id;
+    this.emit("change", this.getAll());
   }
 
   /**
-   * Cancel a running monitor by killing its process.
-   * Returns true if the monitor was found and killed.
+   * Write input to a monitor's PTY.
    */
-  kill(id: string): boolean {
-    const child = this.processes.get(id);
-    if (!child) return false;
-
-    try {
-      // Kill the process group to ensure child processes are also terminated
-      process.kill(child.pid!, "SIGTERM");
-
-      // Give it a moment to clean up gracefully
-      setTimeout(() => {
-        const monitor = this.monitors.get(id);
-        if (monitor && monitor.status === "running") {
-          try {
-            process.kill(child.pid!, 0); // Check if still alive
-          } catch {
-            // Process already dead, already handled by 'close' event
-            return;
-          }
-          // Force kill if still alive
-          try {
-            process.kill(child.pid!, "SIGKILL");
-          } catch {
-            // ignore
-          }
-        }
-      }, 500);
-    } catch {
-      // Process might have already exited
+  write(id: string, input: string): boolean {
+    const session = this.sessions.get(id);
+    if (!session) return false;
+
+    const monitor = this.monitors.get(id);
+    if (monitor) {
+      monitor.hasPendingInput = false;
     }
 
+    session.write(input);
+    return true;
+  }
+
+  /**
+   * Send a line of input to a monitor's PTY.
+   */
+  sendLine(id: string, line: string): boolean {
+    return this.write(id, line + "\n");
+  }
+
+  /**
+   * Send Ctrl+C to interrupt a monitor.
+   */
+  interrupt(id: string): boolean {
+    const session = this.sessions.get(id);
+    if (!session) return false;
+    session.sendInterrupt();
+    return true;
+  }
+
+  /**
+   * Cancel a running monitor.
+   */
+  kill(id: string): boolean {
+    const session = this.sessions.get(id);
+    if (!session) return false;
+
+    session.kill("SIGTERM");
+    this.sessions.delete(id);
+
     const monitor = this.monitors.get(id);
     if (monitor) {
       monitor.status = "killed";
@@ -217,6 +281,13 @@ class MonitorRegistryImpl extends EventEmitter {
     return this.monitors.get(id);
   }
 
+  /**
+   * Get a PtySession by monitor ID.
+   */
+  getSession(id: string): PtySession | undefined {
+    return this.sessions.get(id);
+  }
+
   /**
    * Get all monitor entries.
    */
@@ -254,10 +325,14 @@ class MonitorRegistryImpl extends EventEmitter {
   }
 
   /**
-   * Remove a monitor from the registry.
-   * Does not kill the process if it's still running.
+   * Remove a monitor from the registry without killing the process.
    */
   remove(id: string): boolean {
+    const session = this.sessions.get(id);
+    if (session) {
+      session.detach();
+      this.sessions.delete(id);
+    }
     const existed = this.monitors.has(id);
     this.monitors.delete(id);
     if (existed) this.emit("change", this.getAll());
@@ -268,22 +343,16 @@ class MonitorRegistryImpl extends EventEmitter {
    * Clear all monitors.
    */
   clear(): void {
-    for (const [id, child] of this.processes) {
-      try {
-        process.kill(child.pid!, "SIGTERM");
-      } catch {
-        // ignore
-      }
-      this.monitors.delete(id);
+    for (const session of this.sessions.values()) {
+      session.kill("SIGTERM");
     }
-    this.processes.clear();
+    this.sessions.clear();
     this.monitors.clear();
     this.emit("change", this.getAll());
   }
 
   /**
    * Notify the parent agent session of a monitor event.
-   * Uses steer() if the agent is busy, prompt() if idle.
    */
   private notifyParent(notification: string): void {
     const parent = activeSessionRef.current;

package/src/agent/session-store.ts

@@ -376,7 +376,7 @@ class ToolAbortError extends Error {
 }
 
 /** Wraps a tool definition to support abort signal checking. */
-function wrapToolWithAbortSupport<TParams, TDetails>(
+function wrapToolWithAbortSupport<TParams extends Type.TSchema, TDetails>(
   tool: ToolDefinition<TParams, TDetails>
 ): ToolDefinition<TParams, TDetails> {
   return {

package/src/services/mcp/types.ts

@@ -18,6 +18,7 @@ export interface McpServerConfig {
   url?: string;
   headers?: Record<string, string>;
   authToken?: string;
+  enabled?: boolean;
 }
 
 // Config Scope

package/src/skills/bundled/batch.ts

@@ -16,7 +16,7 @@ const WORKER_INSTRUCTIONS = `After implementing the change:
 3. **Commit** — Commit changes with a clear message
 4. **Report** — End with a summary of what was done`;
 
-const NOT_A_GIT_REPO_MESSAGE = `This is not a git repository. The \`/batch\` command requires a git repo. Initialize a repo first, or run this from inside an existing one.`;
+
 
 const MISSING_INSTRUCTION_MESSAGE = `Provide an instruction describing the batch change you want to make.
 

package/src/skills/bundled/debug.ts

@@ -7,7 +7,7 @@
 
 import { registerBundledSkill } from "../bundled.js";
 
-const DEFAULT_DEBUG_LINES_READ = 30;
+
 
 export function registerDebugSkill(): void {
   registerBundledSkill({