@ebowwa/coder 0.7.64 → 0.7.66

package/packages/src/teammates/index.ts

@@ -11,6 +11,18 @@ import type { Teammate, Team, TeammateMessage, TeammateStatus } from "../types/i
 import { spawn } from "child_process";
 import { mkdirSync, rmSync, existsSync, readFileSync, readdirSync, renameSync, writeFileSync, statSync } from "fs";
 import { join, basename } from "path";
+import {
+  parseTeam,
+  parseTeammate,
+  parseTeammateMessage,
+  parseStoredMessage,
+  safeParseTeam,
+  safeParseTeammate,
+  safeParseTeammateMessage,
+  safeParseStoredMessage,
+  ValidationError,
+  sanitizeForFilePath,
+} from "./schemas.js";
 
 // ============================================
 // FILE-BASED INBOX TYPES
@@ -48,8 +60,24 @@ export class TeammateManager {
   // INBOX PATH HELPERS
   // ============================================
 
+  /**
+   * Get safe directory name for a team (prevents ENAMETOOLONG)
+   */
+  private getSafeTeamDir(teamName: string): string {
+    return sanitizeForFilePath(teamName);
+  }
+
+  /**
+   * Get safe directory name for a teammate (prevents ENAMETOOLONG)
+   */
+  private getSafeTeammateDir(teammateId: string): string {
+    return sanitizeForFilePath(teammateId);
+  }
+
   private getInboxPath(teamName: string, teammateId: string): string {
-    return join(this.storagePath, teamName, "inboxes", teammateId);
+    const safeTeamName = this.getSafeTeamDir(teamName);
+    const safeTeammateId = this.getSafeTeammateDir(teammateId);
+    return join(this.storagePath, safeTeamName, "inboxes", safeTeammateId);
   }
 
   private getPendingPath(teamName: string, teammateId: string): string {
@@ -135,8 +163,8 @@ export class TeammateManager {
       }
       this.teams.delete(name);
 
-      // Delete team directory from disk
-      const teamDir = join(this.storagePath, name);
+      // Delete team directory from disk (use safe path)
+      const teamDir = join(this.storagePath, this.getSafeTeamDir(name));
       try {
         rmSync(teamDir, { recursive: true, force: true });
       } catch (err) {
@@ -363,6 +391,7 @@ export class TeammateManager {
 
   /**
    * Read all pending messages from a teammate's inbox
+   * Validates messages using Zod schema, skipping malformed ones
    */
   private readPendingMessages(teamName: string, teammateId: string): StoredMessage[] {
     const pendingPath = this.getPendingPath(teamName, teammateId);
@@ -381,14 +410,31 @@ export class TeammateManager {
         try {
           const msgPath = join(pendingPath, file);
           const content = readFileSync(msgPath, 'utf-8');
-          const msg = JSON.parse(content) as StoredMessage;
-          messages.push(msg);
-        } catch {
+
+          // Parse JSON first, then validate
+          let parsed: unknown;
+          try {
+            parsed = JSON.parse(content);
+          } catch {
+            continue; // Skip non-JSON files
+          }
+
+          const result = safeParseStoredMessage(parsed);
+
+          if (result.success && result.data) {
+            messages.push(result.data);
+          } else {
+            // Log validation error but skip this message
+            console.error(`Failed to parse message from ${msgPath}:`, result.error);
+          }
+        } catch (err) {
           // Skip malformed messages
+          console.error(`Error reading message file:`, err);
         }
       }
-    } catch {
+    } catch (err) {
       // Directory read error
+      console.error(`Error reading pending messages:`, err);
     }
 
     return messages;
@@ -784,7 +830,7 @@ export class TeammateManager {
    * Persist a team configuration to disk
    */
   private async persistTeam(team: Team): Promise<void> {
-    const teamDir = join(this.storagePath, team.name);
+    const teamDir = join(this.storagePath, this.getSafeTeamDir(team.name));
     const configPath = join(teamDir, "config.json");
 
     // Ensure directory exists
@@ -813,6 +859,7 @@ export class TeammateManager {
   /**
    * Load all teams from disk at startup
    * Uses synchronous operations for constructor compatibility
+   * Validates all data using Zod schemas
    */
   loadTeams(): void {
     // Use Bun's glob to find team configs
@@ -834,27 +881,26 @@ export class TeammateManager {
           // Read file synchronously using readFileSync
           // Bun.file().text() is async, so we use fs.readFileSync for sync operation
           const text = readFileSync(filePath, "utf-8");
-          const config = JSON.parse(text);
 
-          // Validate required fields - skip if missing teammates or name
-          if (!config.name || !config.teammates || !Array.isArray(config.teammates)) {
-            // Skip configs that don't match our expected structure
+          // Parse JSON first, then validate with Zod schema
+          let parsed: unknown;
+          try {
+            parsed = JSON.parse(text);
+          } catch (parseError) {
+            console.error(`Failed to parse JSON from ${filePath}:`, parseError);
             continue;
           }
 
-          const team: Team = {
-            name: config.name,
-            description: config.description || "",
-            teammates: config.teammates,
-            taskListId: config.taskListId || "",
-            status: config.status || "active",
-            coordination: config.coordination || {
-              dependencyOrder: [],
-              communicationProtocol: "broadcast",
-              taskAssignmentStrategy: "manual",
-            },
-          };
+          // Validate using Zod schema
+          const result = safeParseTeam(parsed);
 
+          if (!result.success || !result.data) {
+            // Log validation error but skip this config
+            console.error(`Failed to load team config from ${filePath}:`, result.error);
+            continue;
+          }
+
+          const team = result.data;
           this.teams.set(team.name, team);
 
           // Index teammates
@@ -863,12 +909,13 @@ export class TeammateManager {
           }
         } catch (error) {
           // Silently skip malformed configs
+          console.error(`Error reading team config:`, error);
         }
       }
     } catch (error) {
       // Storage path may not exist yet - that's okay
       if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
-        // Ignore permission errors too
+        console.error("Error loading teams:", error);
       }
     }
   }
@@ -980,3 +1027,26 @@ export function createTeammate(
 
 // Export types
 export type { StoredMessage };
+
+// Re-export runner module
+export {
+  TeammateModeRunner,
+  getTeammateRunner,
+  setTeammateRunner,
+  isTeammateModeActive,
+  type TeammateModeConfig,
+  type TeammateModeState,
+} from "./runner.js";
+
+// Re-export coordination module
+export {
+  CoordinationManager,
+  createCoordinationMessage,
+  parseCoordinationMessage,
+  type CoordinationEvent,
+  type CoordinationEventType,
+  type CoordinationCallback,
+  type CoordinationConfig,
+  type ProgressReport,
+  type FileClaim,
+} from "./coordination.js";

package/packages/src/teammates/integration.test.ts

@@ -0,0 +1,272 @@
+/**
+ * Integration test for teammate coordination
+ * Tests: long horizon, cohesion, assignment completion
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { TeammateManager } from "./index.js";
+import { TeammateModeRunner, setTeammateRunner } from "./runner.js";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+const TEAMS_DIR = path.join(os.homedir(), ".claude", "teams");
+const TEST_TEAM = `integration-test-${Date.now()}`;
+
+function cleanupTestTeam() {
+  const teamPath = path.join(TEAMS_DIR, TEST_TEAM);
+  if (fs.existsSync(teamPath)) {
+    fs.rmSync(teamPath, { recursive: true, force: true });
+  }
+}
+
+describe("Teammate Integration Tests", () => {
+  let manager: TeammateManager;
+
+  beforeEach(() => {
+    cleanupTestTeam();
+    manager = new TeammateManager();
+  });
+
+  afterEach(() => {
+    cleanupTestTeam();
+    setTeammateRunner(null);
+  });
+
+  describe("Long Horizon - Extended Operation", () => {
+    it("should maintain state over multiple operations", async () => {
+      // Create team
+      const team = manager.createTeam({
+        name: TEST_TEAM,
+        description: "Long horizon test team",
+        teammates: [],
+        taskListId: `${TEST_TEAM}-tasks`,
+        coordination: {
+          dependencyOrder: [],
+          communicationProtocol: "broadcast",
+          taskAssignmentStrategy: "manual",
+        },
+      });
+
+      // Create teammate
+      const runner = new TeammateModeRunner({
+        teamName: TEST_TEAM,
+        agentName: "long-horizon-agent",
+        agentColor: "green",
+        workingDirectory: process.cwd(),
+        pollInterval: 100,
+      });
+
+      await runner.start();
+      setTeammateRunner(runner);
+
+      // Simulate long horizon: multiple status updates
+      expect(runner.getStatus()).toBe("in_progress");
+
+      runner.reportActivity();
+      expect(runner.getStatus()).toBe("in_progress");
+
+      // Complete a task
+      runner.reportTaskComplete("task-1", "First task");
+      expect(runner.getStatus()).toBe("completed");
+
+      // Request new task (resets to idle)
+      runner.requestTask();
+      expect(runner.getStatus()).toBe("idle");
+
+      // Report activity again (should flip to in_progress)
+      runner.reportActivity();
+      expect(runner.getStatus()).toBe("in_progress");
+
+      // Fail a task
+      runner.reportTaskFailed("task-2", "Second task", "Test failure");
+      expect(runner.getStatus()).toBe("failed");
+
+      await runner.stop();
+      expect(runner.getStatus()).toBe("idle");
+    });
+
+    it("should persist team state across operations", async () => {
+      const runner = new TeammateModeRunner({
+        teamName: TEST_TEAM,
+        agentName: "persist-agent",
+        workingDirectory: process.cwd(),
+        pollInterval: 100,
+      });
+
+      await runner.start();
+
+      // Verify teammate was added to team
+      const teammate = runner.getTeammate();
+      expect(teammate).not.toBe(null);
+      expect(teammate?.name).toBe("persist-agent");
+
+      // Stop and restart
+      await runner.stop();
+
+      // Create new runner with same team
+      const runner2 = new TeammateModeRunner({
+        teamName: TEST_TEAM,
+        agentName: "persist-agent-2",
+        workingDirectory: process.cwd(),
+        pollInterval: 100,
+      });
+
+      await runner2.start();
+
+      // Team should have both teammates now
+      const members = runner2.getTeamMembers();
+      expect(members.length).toBe(2);
+
+      await runner2.stop();
+    });
+  });
+
+  describe("Cohesion - Multi-Agent Coordination", () => {
+    it("should support multiple teammates in same team", async () => {
+      // Create first teammate
+      const runner1 = new TeammateModeRunner({
+        teamName: TEST_TEAM,
+        agentName: "coordinator",
+        agentColor: "blue",
+        workingDirectory: process.cwd(),
+        pollInterval: 100,
+      });
+
+      await runner1.start();
+
+      // Wait for persistence to complete
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      // Create second teammate (will load team from disk)
+      const runner2 = new TeammateModeRunner({
+        teamName: TEST_TEAM,
+        agentName: "worker",
+        agentColor: "orange",
+        workingDirectory: process.cwd(),
+        pollInterval: 100,
+      });
+
+      await runner2.start();
+
+      // Wait for persistence
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      // Both should see each other
+      const members1 = runner1.getTeamMembers();
+      const members2 = runner2.getTeamMembers();
+
+      // runner1 sees itself (in memory) + runner2 (loaded from disk)
+      expect(members1.length).toBeGreaterThanOrEqual(1);
+      // runner2 sees itself (in memory) + runner1 (loaded from disk)
+      expect(members2.length).toBeGreaterThanOrEqual(1);
+
+      // Verify coordinator and worker are both in the team
+      const allNames = new Set([...members1, ...members2].map(m => m.name));
+      expect(allNames.has("coordinator")).toBe(true);
+      expect(allNames.has("worker")).toBe(true);
+
+      await runner1.stop();
+      await runner2.stop();
+    });
+
+    it("should support broadcast messages", async () => {
+      const runner1 = new TeammateModeRunner({
+        teamName: TEST_TEAM,
+        agentName: "broadcaster",
+        workingDirectory: process.cwd(),
+        pollInterval: 100,
+      });
+
+      await runner1.start();
+
+      // Broadcast should not throw
+      runner1.broadcast("Attention all teammates!");
+
+      await runner1.stop();
+    });
+  });
+
+  describe("Assignment Completion", () => {
+    it("should track task completion workflow", async () => {
+      const runner = new TeammateModeRunner({
+        teamName: TEST_TEAM,
+        agentName: "task-worker",
+        workingDirectory: process.cwd(),
+        pollInterval: 100,
+      });
+
+      await runner.start();
+
+      // Initial status
+      expect(runner.getStatus()).toBe("in_progress");
+
+      // Complete task
+      runner.reportTaskComplete("assignment-1", "Complete integration tests");
+      expect(runner.getStatus()).toBe("completed");
+
+      // Request new assignment
+      runner.requestTask();
+      expect(runner.getStatus()).toBe("idle");
+
+      await runner.stop();
+    });
+
+    it("should track task failure and recovery", async () => {
+      const runner = new TeammateModeRunner({
+        teamName: TEST_TEAM,
+        agentName: "failing-worker",
+        workingDirectory: process.cwd(),
+        pollInterval: 100,
+      });
+
+      await runner.start();
+
+      // Fail task
+      runner.reportTaskFailed("assignment-2", "Risky task", "Dependencies not met");
+      expect(runner.getStatus()).toBe("failed");
+
+      // Recover by requesting new task
+      runner.requestTask();
+      expect(runner.getStatus()).toBe("idle");
+
+      await runner.stop();
+    });
+  });
+
+  describe("Inbox Management", () => {
+    it("should track inbox stats", async () => {
+      const runner = new TeammateModeRunner({
+        teamName: TEST_TEAM,
+        agentName: "inbox-worker",
+        workingDirectory: process.cwd(),
+        pollInterval: 100,
+      });
+
+      await runner.start();
+
+      const stats = runner.getInboxStats();
+      expect(stats).toHaveProperty("pending");
+      expect(stats).toHaveProperty("processed");
+
+      await runner.stop();
+    });
+
+    it("should check for pending messages", async () => {
+      const runner = new TeammateModeRunner({
+        teamName: TEST_TEAM,
+        agentName: "message-checker",
+        workingDirectory: process.cwd(),
+        pollInterval: 100,
+      });
+
+      await runner.start();
+
+      expect(runner.hasPendingMessages()).toBe(false);
+      expect(runner.getPendingMessages()).toEqual([]);
+      expect(runner.peekPendingMessages()).toEqual([]);
+
+      await runner.stop();
+    });
+  });
+});

package/packages/src/teammates/runner.test.ts

@@ -0,0 +1,235 @@
+/**
+ * Tests for TeammateModeRunner
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "bun:test";
+import { TeammateModeRunner, getTeammateRunner, setTeammateRunner, isTeammateModeActive } from "./runner.js";
+import type { TeammateModeConfig } from "./runner.js";
+
+// Mock TeammateManager
+vi.mock("./index.js", () => ({
+  TeammateManager: vi.fn().mockImplementation(() => ({
+    getTeam: vi.fn(() => null),
+    createTeam: vi.fn((config) => ({ ...config, teammates: [] })),
+    getTeammate: vi.fn(() => null),
+    addTeammate: vi.fn(),
+    updateTeammateStatus: vi.fn(),
+    persistAllTeams: vi.fn(),
+    getMessages: vi.fn(() => []),
+    sendDirect: vi.fn(),
+    broadcast: vi.fn(),
+    injectUserMessageToTeammate: vi.fn(),
+    getInboxStats: vi.fn(() => ({ pending: 0, processed: 0 })),
+    waitForTeammatesToBecomeIdle: vi.fn(() => ({ success: true, timedOut: false, statuses: {} })),
+  })),
+  generateTeammateId: vi.fn(() => "test-teammate-id"),
+}));
+
+describe("TeammateModeRunner", () => {
+  let runner: TeammateModeRunner;
+  let config: TeammateModeConfig;
+
+  beforeEach(() => {
+    config = {
+      teamName: "test-team",
+      workingDirectory: "/tmp/test",
+      pollInterval: 100, // Fast polling for tests
+    };
+    runner = new TeammateModeRunner(config);
+    vi.useFakeTimers();
+  });
+
+  afterEach(async () => {
+    if (runner.isActive()) {
+      await runner.stop();
+    }
+    vi.useRealTimers();
+    vi.clearAllMocks();
+  });
+
+  describe("constructor", () => {
+    it("should initialize with correct default state", () => {
+      expect(runner.isActive()).toBe(false);
+      expect(runner.getStatus()).toBe("pending");
+      expect(runner.getTeammate()).toBe(null);
+      expect(runner.getTeam()).toBe(null);
+    });
+  });
+
+  describe("start", () => {
+    it("should start teammate mode successfully", async () => {
+      const teammate = await runner.start();
+
+      expect(runner.isActive()).toBe(true);
+      expect(runner.getStatus()).toBe("in_progress");
+      expect(teammate.teamName).toBe("test-team");
+      // Status comes from local state, not the returned teammate object
+      expect(runner.getStatus()).toBe("in_progress");
+    });
+
+    it("should throw if already active", async () => {
+      await runner.start();
+
+      await expect(runner.start()).rejects.toThrow("Teammate mode already active");
+    });
+
+    it("should use provided agent config", async () => {
+      const customConfig: TeammateModeConfig = {
+        ...config,
+        // Don't provide agentId - that requires an existing teammate
+        agentName: "Custom Agent",
+        agentColor: "red",
+        prompt: "Test prompt",
+      };
+      const customRunner = new TeammateModeRunner(customConfig);
+
+      const teammate = await customRunner.start();
+
+      expect(teammate.name).toBe("Custom Agent");
+      expect(teammate.color).toBe("red");
+      expect(teammate.prompt).toBe("Test prompt");
+
+      await customRunner.stop();
+    });
+  });
+
+  describe("stop", () => {
+    it("should stop teammate mode", async () => {
+      await runner.start();
+      await runner.stop();
+
+      expect(runner.isActive()).toBe(false);
+      expect(runner.getStatus()).toBe("idle");
+    });
+
+    it("should be idempotent", async () => {
+      await runner.start();
+      await runner.stop();
+      await runner.stop(); // Should not throw
+
+      expect(runner.isActive()).toBe(false);
+    });
+  });
+
+  describe("message polling", () => {
+    it("should have pending messages methods", async () => {
+      await runner.start();
+
+      expect(runner.hasPendingMessages()).toBe(false);
+      expect(runner.getPendingMessages()).toEqual([]);
+      expect(runner.peekPendingMessages()).toEqual([]);
+    });
+  });
+
+  describe("idle detection", () => {
+    it("should start with non-idle status", async () => {
+      await runner.start();
+
+      expect(runner.getStatus()).toBe("in_progress");
+    });
+
+    it("should report activity", async () => {
+      await runner.start();
+
+      runner.reportActivity();
+
+      expect(runner.getStatus()).toBe("in_progress");
+    });
+  });
+
+  describe("messaging", () => {
+    it("should throw when sending without active teammate", async () => {
+      expect(() => runner.sendDirectMessage("target", "hello")).toThrow("Teammate mode not active");
+      expect(() => runner.broadcast("hello")).toThrow("Teammate mode not active");
+      expect(() => runner.injectUserMessage("hello")).toThrow("Teammate mode not active");
+    });
+  });
+
+  describe("status & info", () => {
+    it("should return teammate after start", async () => {
+      await runner.start();
+
+      const teammate = runner.getTeammate();
+      expect(teammate).not.toBe(null);
+      expect(teammate?.teamName).toBe("test-team");
+    });
+
+    it("should return team after start", async () => {
+      await runner.start();
+
+      const team = runner.getTeam();
+      expect(team).not.toBe(null);
+      expect(team?.name).toBe("test-team");
+    });
+
+    it("should return inbox stats", async () => {
+      await runner.start();
+
+      const stats = runner.getInboxStats();
+      expect(stats).toEqual({ pending: 0, processed: 0 });
+    });
+
+    it("should return team members", async () => {
+      await runner.start();
+
+      const members = runner.getTeamMembers();
+      expect(Array.isArray(members)).toBe(true);
+    });
+  });
+
+  describe("task integration", () => {
+    it("should report task complete", async () => {
+      await runner.start();
+      expect(runner.getStatus()).toBe("in_progress");
+
+      // reportTaskComplete calls updateStatus("completed")
+      runner.reportTaskComplete("task-123", "Test Task");
+
+      // Verify status changed to completed
+      const status = runner.getStatus();
+      expect(status).toBe("completed");
+    });
+
+    it("should report task failed", async () => {
+      await runner.start();
+      expect(runner.getStatus()).toBe("in_progress");
+
+      runner.reportTaskFailed("task-123", "Test Task", "Something went wrong");
+
+      const status = runner.getStatus();
+      expect(status).toBe("failed");
+    });
+
+    it("should request task", async () => {
+      await runner.start();
+
+      runner.requestTask();
+
+      expect(runner.getStatus()).toBe("idle");
+    });
+  });
+});
+
+describe("Global runner functions", () => {
+  afterEach(() => {
+    setTeammateRunner(null);
+  });
+
+  it("should return null when no global runner set", () => {
+    expect(getTeammateRunner()).toBe(null);
+    expect(isTeammateModeActive()).toBe(false);
+  });
+
+  it("should set and get global runner", () => {
+    const config: TeammateModeConfig = {
+      teamName: "global-test",
+      workingDirectory: "/tmp/test",
+    };
+    const runner = new TeammateModeRunner(config);
+
+    setTeammateRunner(runner);
+
+    expect(getTeammateRunner()).toBe(runner);
+    expect(isTeammateModeActive()).toBe(false); // Not started yet
+  });
+});