pi-teams 0.8.7 → 0.9.2

package/extensions/index.ts

@@ -5,6 +5,7 @@ import * as paths from "../src/utils/paths";
 import * as teams from "../src/utils/teams";
 import * as tasks from "../src/utils/tasks";
 import * as messaging from "../src/utils/messaging";
+import * as runtime from "../src/utils/runtime";
 import { Member } from "../src/utils/models";
 import { getTerminalAdapter } from "../src/adapters/terminal-registry";
 import { Iterm2Adapter } from "../src/adapters/iterm2-adapter";
@@ -154,6 +155,13 @@ export default function (pi: ExtensionAPI) {
       if (teamName) {
         const pidFile = path.join(paths.teamDir(teamName), `${agentName}.pid`);
         fs.writeFileSync(pidFile, process.pid.toString());
+        await runtime.writeRuntimeStatus(teamName, agentName, {
+          pid: process.pid,
+          startedAt: Date.now(),
+          lastHeartbeatAt: Date.now(),
+          ready: false,
+          lastError: undefined,
+        });
       }
       ctx.ui.notify(`Teammate: ${agentName} (Team: ${teamName})`, "info");
       ctx.ui.setStatus("00-pi-teams", `[${agentName.toUpperCase()}]`);
@@ -176,9 +184,19 @@ export default function (pi: ExtensionAPI) {
 
       setInterval(async () => {
         if (ctx.isIdle() && teamName) {
-          const unread = await messaging.readInbox(teamName, agentName, true, false);
-          if (unread.length > 0) {
-            pi.sendUserMessage(`I have ${unread.length} new message(s) in my inbox. Reading them now...`);
+          try {
+            const unread = await messaging.readInbox(teamName, agentName, true, false);
+            await runtime.writeRuntimeStatus(teamName, agentName, {
+              lastHeartbeatAt: Date.now(),
+            });
+            if (unread.length > 0) {
+              pi.sendUserMessage(`I have ${unread.length} new message(s) in my inbox. Reading them now...`);
+            }
+          } catch (e) {
+            await runtime.writeRuntimeStatus(teamName, agentName, {
+              lastHeartbeatAt: Date.now(),
+              lastError: runtime.createRuntimeError(e),
+            });
           }
         }
       }, 30000);
@@ -192,6 +210,11 @@ export default function (pi: ExtensionAPI) {
       const fullTitle = teamName ? `${teamName}: ${agentName}` : agentName;
       if ((ctx.ui as any).setTitle) (ctx.ui as any).setTitle(fullTitle);
       if (terminal) terminal.setTitle(fullTitle);
+      if (teamName) {
+        await runtime.writeRuntimeStatus(teamName, agentName, {
+          lastHeartbeatAt: Date.now(),
+        });
+      }
     }
   });
 
@@ -200,6 +223,12 @@ export default function (pi: ExtensionAPI) {
     if (isTeammate && firstTurn) {
       firstTurn = false;
 
+      if (teamName) {
+        await runtime.writeRuntimeStatus(teamName, agentName, {
+          lastHeartbeatAt: Date.now(),
+        });
+      }
+
       let modelInfo = "";
       if (teamName) {
         try {
@@ -244,6 +273,8 @@ export default function (pi: ExtensionAPI) {
     if (member.tmuxPaneId && terminal) {
       terminal.kill(member.tmuxPaneId);
     }
+
+    await runtime.deleteRuntimeStatus(teamName, member.name);
   }
 
   // Tools
@@ -378,11 +409,17 @@ export default function (pi: ExtensionAPI) {
             }
           }
 
+          const leadMember = teamConfig.members.find(m => m.name === "team-lead");
+          const anchorPaneId = terminal.name === "tmux"
+            ? leadMember?.tmuxPaneId || process.env.TMUX_PANE || undefined
+            : undefined;
+
           terminalId = terminal.spawn({
             name: safeName,
             cwd: params.cwd,
             command: piCmd,
             env: env,
+            anchorPaneId,
           });
           await teams.updateMember(safeTeamName, safeName, { tmuxPaneId: terminalId });
         }
@@ -480,6 +517,16 @@ export default function (pi: ExtensionAPI) {
     async execute(toolCallId, params: any, signal, onUpdate, ctx) {
       const targetAgent = params.agent_name || agentName;
       const msgs = await messaging.readInbox(params.team_name, targetAgent, params.unread_only);
+
+      if (isTeammate && teamName && params.team_name === teamName && targetAgent === agentName) {
+        await runtime.writeRuntimeStatus(teamName, agentName, {
+          lastHeartbeatAt: Date.now(),
+          lastInboxReadAt: Date.now(),
+          ready: true,
+          lastError: undefined,
+        });
+      }
+
       return {
         content: [{ type: "text", text: JSON.stringify(msgs, null, 2) }],
         details: { messages: msgs },
@@ -643,9 +690,40 @@ export default function (pi: ExtensionAPI) {
       }
 
       const unreadCount = (await messaging.readInbox(params.team_name, params.agent_name, true, false)).length;
+      const runtimeStatus = await runtime.readRuntimeStatus(params.team_name, params.agent_name);
+      const now = Date.now();
+      const hasRecentHeartbeat = !!runtimeStatus?.lastHeartbeatAt
+        && (now - runtimeStatus.lastHeartbeatAt) <= runtime.HEARTBEAT_STALE_MS;
+      const startupStalled = alive
+        && unreadCount > 0
+        && (now - member.joinedAt) > runtime.STARTUP_STALL_MS
+        && !(runtimeStatus?.ready);
+      const health = !alive
+        ? "dead"
+        : startupStalled
+          ? "stalled"
+          : runtimeStatus?.ready
+            ? (hasRecentHeartbeat ? "healthy" : "idle")
+            : "starting";
+
+      const details = {
+        alive,
+        unreadCount,
+        health,
+        agentLoopReady: !!runtimeStatus?.ready,
+        hasRecentHeartbeat,
+        startupStalled,
+        runtime: runtimeStatus,
+      };
+
+      // Clean up runtime status for dead teammates
+      if (!alive && runtimeStatus) {
+        await runtime.deleteRuntimeStatus(params.team_name, params.agent_name);
+      }
+
       return {
-        content: [{ type: "text", text: JSON.stringify({ alive, unreadCount }, null, 2) }],
-        details: { alive, unreadCount },
+        content: [{ type: "text", text: JSON.stringify(details, null, 2) }],
+        details,
       };
     },
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-teams",
-  "version": "0.8.7",
+  "version": "0.9.2",
   "description": "Agent teams for pi, ported from claude-code-teams-mcp",
   "repository": {
     "type": "git",

package/src/adapters/cmux-adapter.test.ts

@@ -0,0 +1,309 @@
+/**
+ * CmuxAdapter Tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { CmuxAdapter } from "./cmux-adapter";
+import * as terminalAdapter from "../utils/terminal-adapter";
+
+describe("CmuxAdapter", () => {
+  let adapter: CmuxAdapter;
+  let mockExecCommand: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    adapter = new CmuxAdapter();
+    mockExecCommand = vi.spyOn(terminalAdapter, "execCommand");
+    delete process.env.CMUX_SOCKET_PATH;
+    delete process.env.CMUX_WORKSPACE_ID;
+    delete process.env.TMUX;
+    delete process.env.ZELLIJ;
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("name", () => {
+    it("should have the correct name", () => {
+      expect(adapter.name).toBe("cmux");
+    });
+  });
+
+  describe("detect", () => {
+    it("should detect when CMUX_SOCKET_PATH is set", () => {
+      process.env.CMUX_SOCKET_PATH = "/tmp/cmux.sock";
+      expect(adapter.detect()).toBe(true);
+    });
+
+    it("should detect when CMUX_WORKSPACE_ID is set", () => {
+      process.env.CMUX_WORKSPACE_ID = "workspace-123";
+      expect(adapter.detect()).toBe(true);
+    });
+
+    it("should not detect when neither env var is set", () => {
+      expect(adapter.detect()).toBe(false);
+    });
+
+    it("should not detect when TMUX is set (defensive - nested)", () => {
+      process.env.CMUX_SOCKET_PATH = "/tmp/cmux.sock";
+      process.env.TMUX = "/tmp/tmux-1000/default,123,0";
+      expect(adapter.detect()).toBe(false);
+    });
+
+    it("should not detect when ZELLIJ is set (defensive - nested)", () => {
+      process.env.CMUX_WORKSPACE_ID = "workspace-123";
+      process.env.ZELLIJ = "1";
+      expect(adapter.detect()).toBe(false);
+    });
+  });
+
+  describe("spawn", () => {
+    beforeEach(() => {
+      process.env.CMUX_SOCKET_PATH = "/tmp/cmux.sock";
+    });
+
+    it("should spawn a new pane and return the surface ID", () => {
+      mockExecCommand.mockReturnValue({ 
+        stdout: "OK surface-42", 
+        stderr: "", 
+        status: 0 
+      });
+
+      const result = adapter.spawn({
+        name: "test-agent",
+        cwd: "/home/user/project",
+        command: "pi --agent test",
+        env: { PI_AGENT_ID: "test-123" },
+      });
+
+      expect(result).toBe("surface-42");
+      expect(mockExecCommand).toHaveBeenCalledWith(
+        "cmux",
+        ["new-split", "right", "--command", "env PI_AGENT_ID=test-123 pi --agent test"]
+      );
+    });
+
+    it("should spawn without env prefix when no PI_ vars", () => {
+      mockExecCommand.mockReturnValue({ 
+        stdout: "OK surface-99", 
+        stderr: "", 
+        status: 0 
+      });
+
+      const result = adapter.spawn({
+        name: "test-agent",
+        cwd: "/home/user/project",
+        command: "pi",
+        env: { OTHER: "ignored" },
+      });
+
+      expect(result).toBe("surface-99");
+      expect(mockExecCommand).toHaveBeenCalledWith(
+        "cmux",
+        ["new-split", "right", "--command", "pi"]
+      );
+    });
+
+    it("should throw on spawn failure", () => {
+      mockExecCommand.mockReturnValue({ 
+        stdout: "", 
+        stderr: "cmux not found", 
+        status: 1 
+      });
+
+      expect(() => adapter.spawn({
+        name: "test-agent",
+        cwd: "/home/user/project",
+        command: "pi",
+        env: {},
+      })).toThrow("cmux new-split failed with status 1");
+    });
+
+    it("should throw on unexpected output format", () => {
+      mockExecCommand.mockReturnValue({ 
+        stdout: "ERROR something went wrong", 
+        stderr: "", 
+        status: 0 
+      });
+
+      expect(() => adapter.spawn({
+        name: "test-agent",
+        cwd: "/home/user/project",
+        command: "pi",
+        env: {},
+      })).toThrow("cmux new-split returned unexpected output");
+    });
+  });
+
+  describe("kill", () => {
+    it("should kill a pane by surface ID", () => {
+      mockExecCommand.mockReturnValue({ stdout: "", stderr: "", status: 0 });
+
+      adapter.kill("surface-42");
+
+      expect(mockExecCommand).toHaveBeenCalledWith(
+        "cmux",
+        ["close-surface", "--surface", "surface-42"]
+      );
+    });
+
+    it("should be idempotent - no error on empty pane ID", () => {
+      adapter.kill("");
+      adapter.kill(undefined as unknown as string);
+      expect(mockExecCommand).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("isAlive", () => {
+    it("should return true if pane exists", () => {
+      mockExecCommand.mockReturnValue({ 
+        stdout: "surface-1\nsurface-42\nsurface-99", 
+        stderr: "", 
+        status: 0 
+      });
+
+      expect(adapter.isAlive("surface-42")).toBe(true);
+    });
+
+    it("should return false if pane does not exist", () => {
+      mockExecCommand.mockReturnValue({ 
+        stdout: "surface-1\nsurface-99", 
+        stderr: "", 
+        status: 0 
+      });
+
+      expect(adapter.isAlive("surface-42")).toBe(false);
+    });
+
+    it("should return false on error", () => {
+      mockExecCommand.mockImplementation(() => {
+        throw new Error("cmux error");
+      });
+
+      expect(adapter.isAlive("surface-42")).toBe(false);
+    });
+
+    it("should return false for empty pane ID", () => {
+      expect(adapter.isAlive("")).toBe(false);
+      expect(adapter.isAlive(undefined as unknown as string)).toBe(false);
+    });
+  });
+
+  describe("setTitle", () => {
+    it("should set the tab title", () => {
+      mockExecCommand.mockReturnValue({ stdout: "", stderr: "", status: 0 });
+
+      adapter.setTitle("My Team");
+
+      expect(mockExecCommand).toHaveBeenCalledWith(
+        "cmux",
+        ["rename-tab", "My Team"]
+      );
+    });
+
+    it("should silently ignore errors", () => {
+      mockExecCommand.mockImplementation(() => {
+        throw new Error("cmux error");
+      });
+
+      // Should not throw
+      expect(() => adapter.setTitle("My Team")).not.toThrow();
+    });
+  });
+
+  describe("supportsWindows", () => {
+    it("should return true", () => {
+      expect(adapter.supportsWindows()).toBe(true);
+    });
+  });
+
+  describe("spawnWindow", () => {
+    it("should spawn a new window with command", () => {
+      mockExecCommand
+        .mockReturnValueOnce({ stdout: "OK window-1", stderr: "", status: 0 })
+        .mockReturnValueOnce({ stdout: "", stderr: "", status: 0 })
+        .mockReturnValueOnce({ stdout: "", stderr: "", status: 0 });
+
+      const result = adapter.spawnWindow({
+        name: "test-agent",
+        cwd: "/home/user/project",
+        command: "pi",
+        env: { PI_TEAM: "myteam" },
+        teamName: "Team Alpha",
+      });
+
+      expect(result).toBe("window-1");
+      expect(mockExecCommand).toHaveBeenCalledWith(
+        "cmux",
+        ["new-window"]
+      );
+      expect(mockExecCommand).toHaveBeenCalledWith(
+        "cmux",
+        ["new-workspace", "--window", "window-1", "--command", "env PI_TEAM=myteam pi"]
+      );
+      expect(mockExecCommand).toHaveBeenCalledWith(
+        "cmux",
+        ["rename-window", "--window", "window-1", "Team Alpha"]
+      );
+    });
+
+    it("should throw on new-window failure", () => {
+      mockExecCommand.mockReturnValue({ 
+        stdout: "", 
+        stderr: "error", 
+        status: 1 
+      });
+
+      expect(() => adapter.spawnWindow({
+        name: "test",
+        cwd: "/home/user",
+        command: "pi",
+        env: {},
+      })).toThrow("cmux new-window failed with status 1");
+    });
+  });
+
+  describe("window operations", () => {
+    it("should set window title", () => {
+      mockExecCommand.mockReturnValue({ stdout: "", stderr: "", status: 0 });
+
+      adapter.setWindowTitle("window-1", "New Title");
+
+      expect(mockExecCommand).toHaveBeenCalledWith(
+        "cmux",
+        ["rename-window", "--window", "window-1", "New Title"]
+      );
+    });
+
+    it("should kill a window", () => {
+      mockExecCommand.mockReturnValue({ stdout: "", stderr: "", status: 0 });
+
+      adapter.killWindow("window-1");
+
+      expect(mockExecCommand).toHaveBeenCalledWith(
+        "cmux",
+        ["close-window", "--window", "window-1"]
+      );
+    });
+
+    it("should check if window is alive", () => {
+      mockExecCommand.mockReturnValue({ 
+        stdout: "window-1\nwindow-2", 
+        stderr: "", 
+        status: 0 
+      });
+
+      expect(adapter.isWindowAlive("window-1")).toBe(true);
+      expect(adapter.isWindowAlive("window-99")).toBe(false);
+    });
+
+    it("should handle empty window IDs gracefully", () => {
+      adapter.killWindow("");
+      adapter.killWindow(undefined as unknown as string);
+      expect(mockExecCommand).not.toHaveBeenCalled();
+
+      expect(adapter.isWindowAlive("")).toBe(false);
+      expect(adapter.isWindowAlive(undefined as unknown as string)).toBe(false);
+    });
+  });
+});

package/src/adapters/cmux-adapter.ts

@@ -10,7 +10,11 @@ export class CmuxAdapter implements TerminalAdapter {
   readonly name = "cmux";
 
   detect(): boolean {
-    // Check for CMUX specific environment variables
+    // Defensive: Don't detect cmux if we're inside tmux or Zellij
+    // This prevents false positives in nested terminal scenarios
+    if (process.env.TMUX || process.env.ZELLIJ) {
+      return false;
+    }
     return !!process.env.CMUX_SOCKET_PATH || !!process.env.CMUX_WORKSPACE_ID;
   }
 

package/src/adapters/terminal-registry.ts

@@ -7,8 +7,9 @@
 
 import { TerminalAdapter } from "../utils/terminal-adapter";
 import { TmuxAdapter } from "./tmux-adapter";
-import { Iterm2Adapter } from "./iterm2-adapter";
 import { ZellijAdapter } from "./zellij-adapter";
+import { CmuxAdapter } from "./cmux-adapter";
+import { Iterm2Adapter } from "./iterm2-adapter";
 import { WezTermAdapter } from "./wezterm-adapter";
 import { WindowsAdapter } from "./windows-adapter";
 
@@ -18,13 +19,15 @@ import { WindowsAdapter } from "./windows-adapter";
  * Detection order (first match wins):
  * 1. tmux - if TMUX env is set
  * 2. Zellij - if ZELLIJ env is set and not in tmux
- * 3. iTerm2 - if TERM_PROGRAM=iTerm.app and not in tmux/zellij
- * 4. WezTerm - if WEZTERM_PANE env is set and not in tmux/zellij
- * 5. Windows - if platform is win32 and not in tmux/zellij/iTerm2/WezTerm
+ * 3. cmux - if CMUX_SOCKET_PATH or CMUX_WORKSPACE_ID env is set
+ * 4. iTerm2 - if TERM_PROGRAM=iTerm.app and not in tmux/zellij/cmux
+ * 5. WezTerm - if WEZTERM_PANE env is set and not in tmux/zellij/cmux
+ * 6. Windows - if platform is win32 and not in tmux/zellij/cmux/iTerm2/WezTerm
  */
 const adapters: TerminalAdapter[] = [
   new TmuxAdapter(),
   new ZellijAdapter(),
+  new CmuxAdapter(),
   new Iterm2Adapter(),
   new WezTermAdapter(),
   new WindowsAdapter(),
@@ -41,9 +44,10 @@ let cachedAdapter: TerminalAdapter | null = null;
  * Detection order (first match wins):
  * 1. tmux - if TMUX env is set
  * 2. Zellij - if ZELLIJ env is set and not in tmux
- * 3. iTerm2 - if TERM_PROGRAM=iTerm.app and not in tmux/zellij
- * 4. WezTerm - if WEZTERM_PANE env is set and not in tmux/zellij
- * 5. Windows - if platform is win32 and not in tmux/zellij/iTerm2/WezTerm
+ * 3. cmux - if CMUX_SOCKET_PATH or CMUX_WORKSPACE_ID env is set
+ * 4. iTerm2 - if TERM_PROGRAM=iTerm.app and not in tmux/zellij/cmux
+ * 5. WezTerm - if WEZTERM_PANE env is set and not in tmux/zellij/cmux
+ * 6. Windows - if platform is win32 and not in tmux/zellij/cmux/iTerm2/WezTerm
  *
  * @returns The detected terminal adapter, or null if none detected
  */
@@ -65,7 +69,7 @@ export function getTerminalAdapter(): TerminalAdapter | null {
 /**
  * Get a specific terminal adapter by name.
  *
- * @param name - The adapter name (e.g., "tmux", "iTerm2", "zellij", "WezTerm", "Windows")
+ * @param name - The adapter name (e.g., "tmux", "zellij", "cmux", "iTerm2", "WezTerm", "Windows")
  * @returns The adapter instance, or undefined if not found
  */
 export function getAdapterByName(name: string): TerminalAdapter | undefined {
@@ -107,7 +111,7 @@ export function hasTerminalAdapter(): boolean {
 /**
  * Check if the current terminal supports spawning separate OS windows.
  *
- * @returns true if the detected terminal supports windows (iTerm2, WezTerm, Windows)
+ * @returns true if the detected terminal supports windows (iTerm2, WezTerm, Windows, cmux)
  */
 export function supportsWindows(): boolean {
   const adapter = getTerminalAdapter();