pi-teams 0.9.10 → 0.9.13

package/extensions/index.ts

@@ -18,23 +18,36 @@ import { spawnSync } from "node:child_process";
 /**
  * Build the command used to relaunch pi for teammate processes.
  *
- * In Bun-compiled pi binaries, process.argv[1] points at a virtual $bunfs path
- * like /$bunfs/root/pi, which is not a real file and breaks when prefixed with
- * `node`. process.execPath points at the actual executable in both compiled and
- * regular environments, so prefer that when available.
+ * There are three common cases:
+ * - npm/node install: pi runs as `node .../dist/cli.js`
+ * - standalone compiled binary: process.execPath is the actual `pi` executable
+ * - shim-based installs (e.g. Volta): process.execPath is `node` and argv[1]
+ *   may be a shim path, so the safest relaunch command is plain `pi`
  */
 function getPiLaunchCommand(): string {
-  // If we have an execPath, use it directly (works for both compiled binaries and node scripts)
-  if (process.execPath) {
-    return JSON.stringify(process.execPath);
+  const argv1 = process.argv[1];
+  const execPath = process.execPath;
+
+  // Regular Node install: relaunch the actual CLI script with node.
+  if (argv1) {
+    const ext = path.extname(argv1).toLowerCase();
+    const looksLikeScript = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"].includes(ext)
+      || /(?:^|[/\\])dist[/\\]cli\.js$/i.test(argv1);
+
+    if (looksLikeScript) {
+      return `node ${JSON.stringify(argv1)}`;
+    }
   }
 
-  // Fallback: try argv[1] with node prefix for regular node environments
-  if (process.argv[1]) {
-    return `node ${JSON.stringify(process.argv[1])}`;
+  // Standalone binary install: execPath is the pi executable itself.
+  if (execPath) {
+    const base = path.basename(execPath).toLowerCase();
+    if (base !== "node" && base !== "node.exe" && base !== "bun" && base !== "bun.exe") {
+      return JSON.stringify(execPath);
+    }
   }
 
-  // Last resort: just use "pi" and hope it's on PATH
+  // Shim-based installs (like Volta) are safest to relaunch through PATH.
   return "pi";
 }
 
@@ -333,12 +346,42 @@ export default function (pi: ExtensionAPI) {
 
   // For leads without PI_TEAM_NAME, check if we're registered as lead for a team
   const detectedTeamName = envTeamName || findLeadTeamForSession();
-  const teamName = detectedTeamName;
+  let teamName = detectedTeamName;
 
   const terminal = getTerminalAdapter();
 
+  // Track whether lead inbox polling has been started (to avoid duplicates)
+  let leadPollingStarted = false;
+  let sessionCtx: any = null;
+
+  /**
+   * Start inbox polling for the team lead.
+   * Called when a team is created or when the lead reconnects to an existing team.
+   * Requires sessionCtx to be set (from session_start).
+   */
+  function startLeadInboxPolling() {
+    if (leadPollingStarted || isTeammate || !sessionCtx) return;
+    leadPollingStarted = true;
+
+    setInterval(async () => {
+      if (!teamName) return;
+      if (sessionCtx.isIdle()) {
+        try {
+          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...`);
+          }
+        } catch {
+          // Ignore errors for lead polling
+        }
+      }
+    }, 30000);
+  }
+
   pi.on("session_start", async (_event, ctx) => {
     paths.ensureDirs();
+    sessionCtx = ctx;
+
     if (isTeammate) {
       if (teamName) {
         const pidFile = path.join(paths.teamDir(teamName), `${agentName}.pid`);
@@ -369,34 +412,32 @@ export default function (pi: ExtensionAPI) {
       setTimeout(() => {
         pi.sendUserMessage(`I am starting my work as '${agentName}' on team '${teamName}'. Checking my inbox for instructions...`);
       }, 1000);
-    } else if (teamName) {
-      ctx.ui.setStatus("pi-teams", `Lead @ ${teamName}`);
-    }
 
-    // Inbox polling for BOTH teammates AND team-leads (anyone with teamName)
-    if (teamName) {
-      setInterval(async () => {
-        if (ctx.isIdle()) {
-          try {
-            const unread = await messaging.readInbox(teamName, agentName, true, false);
-            if (isTeammate) {
-              await runtime.writeRuntimeStatus(teamName, agentName, {
+      // Inbox polling for teammates
+      if (teamName) {
+        setInterval(async () => {
+          if (ctx.isIdle()) {
+            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) {
-            if (isTeammate) {
-              await runtime.writeRuntimeStatus(teamName, agentName, {
+              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);
+        }, 30000);
+      }
+    } else if (teamName) {
+      // Lead reconnecting to an existing team
+      ctx.ui.setStatus("pi-teams", `Lead @ ${teamName}`);
+      startLeadInboxPolling();
     }
   });
 
@@ -493,6 +534,9 @@ export default function (pi: ExtensionAPI) {
       const config = teams.createTeam(params.team_name, "local-session", "lead-agent", params.description, params.default_model, params.separate_windows);
       // Register this session as the lead so it can receive inbox messages
       registerLeadSession(params.team_name);
+      // Update teamName and start inbox polling for the lead
+      teamName = params.team_name;
+      startLeadInboxPolling();
       return {
         content: [{ type: "text", text: `Team ${params.team_name} created.` }],
         details: { config },
@@ -1077,6 +1121,9 @@ export default function (pi: ExtensionAPI) {
       // Create the team
       const config = teams.createTeam(params.team_name, "local-session", "lead-agent", `Predefined team: ${params.predefined_team}`, params.default_model, params.separate_windows);
       registerLeadSession(params.team_name);
+      // Update teamName and start inbox polling for the lead
+      teamName = params.team_name;
+      startLeadInboxPolling();
 
       const agentDefinitions = predefined.getAllAgentDefinitions(projectDir);
       const spawnResults: Array<{ name: string; status: string; error?: string }> = [];

package/package.json

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

package/src/adapters/iterm2-adapter.ts

@@ -7,6 +7,8 @@
 
 import { TerminalAdapter, SpawnOptions, execCommand } from "../utils/terminal-adapter";
 import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as paths from "../utils/paths";
 
 /**
  * Context needed for iTerm2 spawning (tracks last pane for layout)
@@ -19,6 +21,8 @@ export interface Iterm2SpawnContext {
 export class Iterm2Adapter implements TerminalAdapter {
   readonly name = "iTerm2";
   private spawnContext: Iterm2SpawnContext = {};
+  /** Cached iTerm2 session ID for this process (looked up from team config) */
+  private cachedOwnSessionId: string | null | undefined = undefined;
 
   detect(): boolean {
     return process.env.TERM_PROGRAM === "iTerm.app" && !process.env.TMUX && !process.env.ZELLIJ;
@@ -146,6 +150,38 @@ end tell`;
 
   setTitle(title: string): void {
     const escapedTitle = title.replace(/"/g, '\\"');
+
+    // For teammate processes, find the specific session to avoid renaming
+    // unrelated iTerm2 tabs. The session ID is stored in the team config.
+    const sessionId = this.findOwnSessionId();
+    if (sessionId) {
+      const script = `tell application "iTerm2"
+  repeat with aWindow in windows
+    repeat with aTab in tabs of aWindow
+      repeat with aSession in sessions of aTab
+        if id of aSession is "${sessionId}" then
+          set name of aSession to "${escapedTitle}"
+          return "Found"
+        end if
+      end repeat
+    end repeat
+  end repeat
+end tell`;
+      try {
+        this.runAppleScript(script);
+      } catch {
+        // Ignore errors
+      }
+      return;
+    }
+
+    // If we're a teammate but haven't found our session ID yet (race condition
+    // during startup), skip the rename to avoid overwriting an unrelated tab.
+    if (process.env.PI_AGENT_NAME) {
+      return;
+    }
+
+    // Fallback for non-teammate processes (e.g., standalone pi sessions).
     const script = `tell application "iTerm2" to tell current session of current window
       set name to "${escapedTitle}"
     end tell`;
@@ -156,6 +192,40 @@ end tell`;
     }
   }
 
+  /**
+   * Look up this process's iTerm2 session ID from the team config.
+   * Teammates have PI_AGENT_NAME and PI_TEAM_NAME env vars, and the
+   * team config stores the iTerm2 session ID in the tmuxPaneId field.
+   * Caches the result once found to avoid repeated file reads.
+   */
+  private findOwnSessionId(): string | null {
+    // Return cached value if we've already found it
+    if (this.cachedOwnSessionId != null) return this.cachedOwnSessionId;
+
+    const agentName = process.env.PI_AGENT_NAME;
+    const teamName = process.env.PI_TEAM_NAME;
+    if (!agentName || !teamName) return null;
+
+    try {
+      const configFile = paths.configPath(teamName);
+      const config = JSON.parse(fs.readFileSync(configFile, "utf-8"));
+      const member = config.members?.find((m: any) => m.name === agentName);
+      if (
+        member?.tmuxPaneId &&
+        member.tmuxPaneId.startsWith("iterm_") &&
+        !member.tmuxPaneId.startsWith("iterm_win_")
+      ) {
+        this.cachedOwnSessionId = member.tmuxPaneId.replace("iterm_", "");
+        return this.cachedOwnSessionId;
+      }
+    } catch {
+      // Config not yet available — will retry on next call
+    }
+
+    // Don't cache null — the config might not be written yet (timing)
+    return null;
+  }
+
   /**
    * iTerm2 supports spawning separate OS windows via AppleScript
    */