@vibegrid/mcp 0.4.0-beta.1 → 0.4.0-beta.10

package/dist/index.js

@@ -177,6 +177,7 @@ function createSchema() {
       agent_type TEXT PRIMARY KEY,
       command TEXT NOT NULL,
       args TEXT NOT NULL DEFAULT '[]',
+      headless_args TEXT,
       fallback_command TEXT,
       fallback_args TEXT
     );
@@ -237,7 +238,9 @@ function createSchema() {
       remote_host_label TEXT,
       hook_session_id TEXT,
       status_source TEXT,
-      saved_at INTEGER
+      saved_at INTEGER,
+      sort_order INTEGER NOT NULL DEFAULT 0,
+      worktree_name TEXT
     );
 
     CREATE TABLE IF NOT EXISTS schedule_log (
@@ -317,8 +320,20 @@ function createSchema() {
 
     CREATE INDEX IF NOT EXISTS idx_session_logs_task ON session_logs(task_id);
     CREATE INDEX IF NOT EXISTS idx_session_logs_session ON session_logs(session_id);
+
+    CREATE TABLE IF NOT EXISTS session_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      event_type TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      metadata TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_session_events_session ON session_events(session_id, timestamp DESC);
+    CREATE INDEX IF NOT EXISTS idx_session_events_type ON session_events(event_type, timestamp DESC);
   `);
   migrateSchema(d);
+  verifySchema(d);
 }
 function migrateSchema(d) {
   const row = d.prepare("SELECT value FROM schema_meta WHERE key = 'schema_version'").get();
@@ -376,6 +391,106 @@ function migrateSchema(d) {
     })();
     logger_default.info("[database] migrated schema to version 2 (ssh credential vault)");
   }
+  if (version < 3) {
+    d.transaction(() => {
+      const sessionCols = d.prepare("PRAGMA table_info(sessions)").all();
+      if (!sessionCols.some((c) => c.name === "sort_order")) {
+        d.exec("ALTER TABLE sessions ADD COLUMN sort_order INTEGER NOT NULL DEFAULT 0");
+      }
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '3')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 3 (session sort order)");
+  }
+  if (version < 4) {
+    d.transaction(() => {
+      const sessionCols = d.prepare("PRAGMA table_info(sessions)").all();
+      if (!sessionCols.some((c) => c.name === "worktree_name")) {
+        d.exec("ALTER TABLE sessions ADD COLUMN worktree_name TEXT");
+      }
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '4')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 4 (worktree name)");
+  }
+  if (version < 5) {
+    d.transaction(() => {
+      const agentCols = d.prepare("PRAGMA table_info(agent_commands)").all();
+      if (!agentCols.some((c) => c.name === "headless_args")) {
+        d.exec("ALTER TABLE agent_commands ADD COLUMN headless_args TEXT");
+      }
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '5')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 5 (headless args)");
+  }
+  if (version < 6) {
+    d.transaction(() => {
+      const sessionCols = d.prepare("PRAGMA table_info(sessions)").all();
+      if (!sessionCols.some((c) => c.name === "claude_session_id")) {
+        d.exec("ALTER TABLE sessions ADD COLUMN claude_session_id TEXT");
+      }
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '6')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 6 (claude session id)");
+  }
+}
+function verifySchema(d) {
+  const expectedByTable = {
+    projects: [
+      {
+        column: "workspace_id",
+        ddl: "ALTER TABLE projects ADD COLUMN workspace_id TEXT NOT NULL DEFAULT 'personal'"
+      }
+    ],
+    workflows: [
+      {
+        column: "workspace_id",
+        ddl: "ALTER TABLE workflows ADD COLUMN workspace_id TEXT NOT NULL DEFAULT 'personal'"
+      }
+    ],
+    remote_hosts: [
+      { column: "auth_method", ddl: "ALTER TABLE remote_hosts ADD COLUMN auth_method TEXT" },
+      { column: "credential_id", ddl: "ALTER TABLE remote_hosts ADD COLUMN credential_id TEXT" },
+      {
+        column: "encrypted_password",
+        ddl: "ALTER TABLE remote_hosts ADD COLUMN encrypted_password TEXT"
+      }
+    ],
+    sessions: [
+      {
+        column: "sort_order",
+        ddl: "ALTER TABLE sessions ADD COLUMN sort_order INTEGER NOT NULL DEFAULT 0"
+      },
+      { column: "worktree_name", ddl: "ALTER TABLE sessions ADD COLUMN worktree_name TEXT" },
+      { column: "claude_session_id", ddl: "ALTER TABLE sessions ADD COLUMN claude_session_id TEXT" }
+    ],
+    agent_commands: [
+      {
+        column: "headless_args",
+        ddl: "ALTER TABLE agent_commands ADD COLUMN headless_args TEXT"
+      }
+    ]
+  };
+  for (const [table, columns] of Object.entries(expectedByTable)) {
+    const existing = new Set(
+      d.prepare(`PRAGMA table_info(${table})`).all().map((c) => c.name)
+    );
+    for (const { column, ddl } of columns) {
+      if (existing.has(column)) continue;
+      try {
+        d.exec(ddl);
+        logger_default.warn(`[database] self-heal: added missing column ${table}.${column}`);
+      } catch (err) {
+        logger_default.error(`[database] self-heal: failed to add ${table}.${column}:`, err);
+      }
+    }
+  }
 }
 function loadConfig() {
   const d = getDb();
@@ -440,6 +555,12 @@ function loadDefaults(d) {
     },
     ...map.networkAccessEnabled !== void 0 && {
       networkAccessEnabled: map.networkAccessEnabled
+    },
+    ...map.showHeadlessAgents !== void 0 && {
+      showHeadlessAgents: map.showHeadlessAgents
+    },
+    ...map.headlessRetentionMinutes !== void 0 && {
+      headlessRetentionMinutes: map.headlessRetentionMinutes
     }
   };
 }
@@ -458,6 +579,7 @@ function loadAgentCommands(d) {
     result[r.agent_type] = {
       command: r.command,
       args: JSON.parse(r.args),
+      ...r.headless_args != null && { headlessArgs: JSON.parse(r.headless_args) },
       ...r.fallback_command != null && { fallbackCommand: r.fallback_command },
       ...r.fallback_args != null && { fallbackArgs: JSON.parse(r.fallback_args) }
     };
@@ -534,7 +656,7 @@ function saveConfig(config) {
     }
     d.prepare("DELETE FROM agent_commands").run();
     const insertAgent = d.prepare(
-      "INSERT INTO agent_commands (agent_type, command, args, fallback_command, fallback_args) VALUES (?, ?, ?, ?, ?)"
+      "INSERT INTO agent_commands (agent_type, command, args, headless_args, fallback_command, fallback_args) VALUES (?, ?, ?, ?, ?, ?)"
     );
     if (config.agentCommands) {
       for (const [agentType, cmd] of Object.entries(config.agentCommands)) {
@@ -543,6 +665,7 @@ function saveConfig(config) {
             agentType,
             cmd.command,
             JSON.stringify(cmd.args),
+            cmd.headlessArgs ? JSON.stringify(cmd.headlessArgs) : null,
             cmd.fallbackCommand ?? null,
             cmd.fallbackArgs ? JSON.stringify(cmd.fallbackArgs) : null
           );
@@ -989,6 +1112,7 @@ var ConfigManager = class {
   changeCallbacks = [];
   dbWatcher = null;
   debounceTimer = null;
+  cachedConfig = null;
   init() {
     initDatabase();
   }
@@ -997,8 +1121,11 @@ var ConfigManager = class {
     closeDatabase();
   }
   loadConfig() {
+    if (this.cachedConfig) return this.cachedConfig;
     try {
-      return loadConfig();
+      const config = loadConfig();
+      this.cachedConfig = config;
+      return config;
     } catch (err) {
       logger_default.error("[config-manager] loadConfig failed, returning defaults:", err);
       return {
@@ -1018,6 +1145,7 @@ var ConfigManager = class {
   saveConfig(config) {
     try {
       saveConfig(config);
+      this.cachedConfig = null;
     } catch (err) {
       logger_default.error("[config-manager] saveConfig failed:", err);
       throw err;
@@ -1029,6 +1157,7 @@ var ConfigManager = class {
   }
   /** Notify all registered callbacks (call after main-process config mutations) */
   notifyChanged() {
+    this.cachedConfig = null;
     const config = this.loadConfig();
     for (const cb of this.changeCallbacks) {
       cb(config);
@@ -1465,26 +1594,128 @@ import { z as z4 } from "zod";
 import fs3 from "fs";
 import path4 from "path";
 import os3 from "os";
+import { execFileSync } from "child_process";
 import { WebSocket } from "ws";
 var PORT_FILE = path4.join(os3.homedir(), ".vibegrid", "ws-port");
 var TIMEOUT_MS = 1e4;
+var IS_WIN = process.platform === "win32";
+var PORT_FILE_MISSING_MSG = IS_WIN ? `VibeGrid port file not found (~/.vibegrid/ws-port).
+The app may be running but the port file was deleted (e.g. by another instance shutting down).
+To fix, find the VibeGrid process and its listening port:
+  powershell -c "Get-NetTCPConnection -State Listen -OwningProcess (Get-Process VibeGrid).Id | Select LocalPort"
+Then write the WS port to the file:
+  echo {"port":<PORT>,"pid":<PID>} > %USERPROFILE%\\.vibegrid\\ws-port
+Or restart VibeGrid to regenerate it.` : `VibeGrid port file not found (~/.vibegrid/ws-port).
+The app may be running but the port file was deleted (e.g. by another instance shutting down).
+To fix, run:  lsof -iTCP -sTCP:LISTEN -P | grep VibeGrid
+Then write the WS port (the one on *:<port>) to the file:
+  echo '{"port":<PORT>,"pid":<PID>}' > ~/.vibegrid/ws-port
+Or restart VibeGrid to regenerate it.`;
+var PORT_FILE_INVALID_MSG = `VibeGrid port file exists but contains invalid data (~/.vibegrid/ws-port).
+Delete it and restart VibeGrid, or overwrite it with the correct port:
+  ${IS_WIN ? "del %USERPROFILE%\\.vibegrid\\ws-port" : "rm ~/.vibegrid/ws-port"}`;
 var rpcId = 0;
+var cachedPort = null;
+var cacheTimestamp = 0;
+var CACHE_TTL_MS = 5e3;
+var EXEC_OPTS = {
+  encoding: "utf-8",
+  timeout: 5e3,
+  stdio: ["pipe", "pipe", "pipe"]
+};
+function discoverPort() {
+  try {
+    if (IS_WIN) {
+      const taskOut = execFileSync(
+        "tasklist",
+        ["/FI", "IMAGENAME eq VibeGrid.exe", "/FO", "CSV", "/NH"],
+        EXEC_OPTS
+      );
+      const pidMatch = taskOut.match(/"VibeGrid\.exe","(\d+)"/);
+      if (!pidMatch) return null;
+      const pid = pidMatch[1];
+      const lines = execFileSync("netstat", ["-ano"], EXEC_OPTS).split("\n");
+      let fallback = null;
+      for (const line of lines) {
+        if (!line.includes("LISTENING") || !line.trim().endsWith(pid)) continue;
+        const m = line.match(/(?:0\.0\.0\.0|127\.0\.0\.1):(\d+)/);
+        if (!m) continue;
+        if (line.includes("0.0.0.0")) return parseInt(m[1], 10);
+        fallback ??= parseInt(m[1], 10);
+      }
+      return fallback;
+    } else {
+      const lines = execFileSync("lsof", ["-iTCP", "-sTCP:LISTEN", "-P", "-n"], EXEC_OPTS).split(
+        "\n"
+      );
+      let fallback = null;
+      for (const line of lines) {
+        if (!line.includes("VibeGrid")) continue;
+        if (line.includes("*:")) {
+          const m = line.match(/\*:(\d+)/);
+          if (m) return parseInt(m[1], 10);
+        }
+        if (!fallback) {
+          const m = line.match(/:(\d+)\s/);
+          if (m) fallback = parseInt(m[1], 10);
+        }
+      }
+      return fallback;
+    }
+  } catch {
+  }
+  return null;
+}
+function discoverAndHeal() {
+  const now = Date.now();
+  if (cachedPort && now - cacheTimestamp < CACHE_TTL_MS) return { port: cachedPort };
+  const discovered = discoverPort();
+  cachedPort = discovered;
+  cacheTimestamp = now;
+  if (discovered) {
+    try {
+      fs3.mkdirSync(path4.dirname(PORT_FILE), { recursive: true });
+      fs3.writeFileSync(PORT_FILE, JSON.stringify({ port: discovered }), "utf-8");
+    } catch {
+    }
+    return { port: discovered };
+  }
+  return { port: null, reason: "missing" };
+}
 function readPort() {
   try {
     const raw = fs3.readFileSync(PORT_FILE, "utf-8").trim();
-    const port = parseInt(raw, 10);
-    return Number.isFinite(port) && port > 0 ? port : null;
+    if (!raw) return { port: null, reason: "invalid" };
+    if (raw.startsWith("{")) {
+      const parsed = JSON.parse(raw);
+      const p2 = parsed?.port;
+      const pid = parsed?.pid;
+      if (typeof p2 !== "number" || !Number.isFinite(p2) || p2 <= 0) {
+        return { port: null, reason: "invalid" };
+      }
+      if (typeof pid === "number" && Number.isInteger(pid) && pid > 0) {
+        try {
+          process.kill(pid, 0);
+        } catch (err) {
+          if (err.code === "EPERM") return { port: p2 };
+          return discoverAndHeal();
+        }
+      }
+      return { port: p2 };
+    }
+    const p = parseInt(raw, 10);
+    return Number.isFinite(p) && p > 0 ? { port: p } : { port: null, reason: "invalid" };
   } catch {
-    return null;
+    return discoverAndHeal();
   }
 }
 async function rpcCall(method, params) {
-  const port = readPort();
-  if (!port) {
-    throw new Error("VibeGrid app is not running. Start VibeGrid to use session management tools.");
+  const result = readPort();
+  if (!result.port) {
+    throw new Error(result.reason === "invalid" ? PORT_FILE_INVALID_MSG : PORT_FILE_MISSING_MSG);
   }
   return new Promise((resolve, reject) => {
-    const ws = new WebSocket(`ws://127.0.0.1:${port}/ws`);
+    const ws = new WebSocket(`ws://127.0.0.1:${result.port}/ws`);
     const id = ++rpcId;
     const timer = setTimeout(() => {
       ws.close();
@@ -1514,12 +1745,12 @@ async function rpcCall(method, params) {
   });
 }
 async function rpcNotify(method, params) {
-  const port = readPort();
-  if (!port) {
-    throw new Error("VibeGrid app is not running. Start VibeGrid to use session management tools.");
+  const result = readPort();
+  if (!result.port) {
+    throw new Error(result.reason === "invalid" ? PORT_FILE_INVALID_MSG : PORT_FILE_MISSING_MSG);
   }
   return new Promise((resolve, reject) => {
-    const ws = new WebSocket(`ws://127.0.0.1:${port}/ws`);
+    const ws = new WebSocket(`ws://127.0.0.1:${result.port}/ws`);
     ws.on("open", () => {
       ws.send(JSON.stringify({ jsonrpc: "2.0", method, params }));
       ws.close();
@@ -1755,12 +1986,12 @@ function registerSessionTools(server) {
     "Send input to a running terminal session. Requires the VibeGrid app to be running.",
     {
       id: V.id.describe("Session ID"),
-      data: z4.string().max(5e4, "Data must be 50000 characters or less").describe("Data to write (text input to send to the agent)")
+      data: z4.string().max(5e4, "Data must be 50000 characters or less").describe("Data to write (text input to send to the agent)"),
+      raw: z4.boolean().optional().describe("Send data as-is without appending carriage return (for raw terminal control)")
     },
     async (args) => {
       try {
-        const trimmed = args.data.replace(/[\r\n]+$/, "");
-        const data = trimmed + "\r";
+        const data = args.raw ? args.data : args.data.replace(/[\r\n]+$/, "") + "\r";
         await rpcNotify("terminal:write", { id: args.id, data });
         return { content: [{ type: "text", text: `Wrote to session: ${args.id}` }] };
       } catch (err) {
@@ -1776,6 +2007,109 @@ function registerSessionTools(server) {
       }
     }
   );
+  const KEY_MAP = {
+    enter: "\r",
+    escape: "\x1B",
+    esc: "\x1B",
+    tab: "	",
+    "shift+tab": "\x1B[Z",
+    up: "\x1B[A",
+    down: "\x1B[B",
+    left: "\x1B[D",
+    right: "\x1B[C",
+    backspace: "\x7F",
+    delete: "\x1B[3~",
+    home: "\x1B[H",
+    end: "\x1B[F",
+    "ctrl+c": "",
+    "ctrl+d": "",
+    "ctrl+x": "",
+    "ctrl+z": ""
+  };
+  server.tool(
+    "send_key",
+    "Send a single keystroke or key combo to a terminal session without appending Enter. Use for TUI interactions like selecting menu options (1, 2, y, n), pressing Escape, Ctrl+C, arrow keys, etc.",
+    {
+      id: V.id.describe("Session ID"),
+      key: z4.string().min(1).max(20).describe(
+        "Key to send: single char (1, y, n), named key (enter, escape, tab, up, down, left, right, backspace, delete, home, end), or combo (ctrl+c, ctrl+d, ctrl+x, ctrl+z, shift+tab)"
+      )
+    },
+    async (args) => {
+      const key = args.key.toLowerCase().trim();
+      let data = KEY_MAP[key];
+      if (!data) {
+        const ctrlMatch = key.match(/^ctrl\+([a-z])$/);
+        if (ctrlMatch) {
+          data = String.fromCharCode(ctrlMatch[1].toUpperCase().charCodeAt(0) - 64);
+        } else if (args.key.length === 1) {
+          data = args.key;
+        } else {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Unknown key: "${args.key}". Supported: single chars (1, y, n), named keys (${Object.keys(KEY_MAP).join(", ")}), or ctrl+<letter>.`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+      try {
+        await rpcNotify("terminal:write", { id: args.id, data });
+        return {
+          content: [{ type: "text", text: `Sent key "${args.key}" to session: ${args.id}` }]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error sending key to terminal: ${err instanceof Error ? err.message : err}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "list_session_events",
+    "List session lifecycle events (created, exited, task_linked, renamed, archived, unarchived). Use for post-mortem analysis and multi-agent coordination.",
+    {
+      session_id: V.id.optional().describe("Filter by session ID"),
+      event_type: z4.enum(["created", "exited", "task_linked", "renamed", "archived", "unarchived"]).optional().describe("Filter by event type"),
+      limit: z4.number().int().min(1).max(200).optional().describe("Max events to return (default: 50)")
+    },
+    async (args) => {
+      try {
+        let events;
+        if (args.session_id) {
+          events = await rpcCall("sessionEvent:listBySession", {
+            sessionId: args.session_id,
+            limit: args.limit ?? 50
+          });
+        } else {
+          events = await rpcCall("sessionEvent:list", {
+            eventType: args.event_type,
+            limit: args.limit ?? 50
+          });
+        }
+        return { content: [{ type: "text", text: JSON.stringify(events, null, 2) }] };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error listing session events: ${err instanceof Error ? err.message : err}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
 }
 
 // src/tools/workflows.ts
@@ -1900,7 +2234,7 @@ function registerWorkflowTools(server) {
       const workflow = {
         id: crypto2.randomUUID(),
         name: args.name,
-        icon: args.icon ?? "zap",
+        icon: args.icon ?? "Zap",
         iconColor: args.icon_color ?? "#6366f1",
         nodes,
         edges,
@@ -2155,7 +2489,7 @@ console.warn = (...args) => _origError("[mcp:warn]", ...args);
 console.error = (...args) => _origError("[mcp:error]", ...args);
 async function main() {
   configManager.init();
-  const version = true ? "0.4.0-beta.1" : createRequire(import.meta.url)("../package.json").version;
+  const version = true ? "0.4.0-beta.10" : createRequire(import.meta.url)("../package.json").version;
   const server = createMcpServer(version);
   const transport = new StdioServerTransport();
   await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibegrid/mcp",
-  "version": "0.4.0-beta.1",
+  "version": "0.4.0-beta.10",
   "description": "VibeGrid MCP server — task management, git, and workflow tools for AI coding agents",
   "type": "module",
   "license": "MIT",