Merge pull request #15 from PascalOrdano18/l-mendez/chat-ui-redesign

feat(agent): Claude SDK migration with chat UI and worktree isolation

Author: roccoppp

agent-orchestrator-main/packages/web/package.json

@@ -27,6 +27,7 @@
     "screenshot:install": "npx playwright install chromium"
   },
   "dependencies": {
+    "@anthropic-ai/claude-code": "^2.1.87",
     "@composio/ao-core": "workspace:*",
     "@composio/ao-plugin-agent-claude-code": "workspace:*",
     "@composio/ao-plugin-agent-opencode": "workspace:*",

agent-orchestrator-main/packages/web/server/__tests__/agent-process-manager.test.ts

@@ -0,0 +1,49 @@
+// Copyright (c) 2016-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// Mock the Claude Code SDK
+vi.mock("@anthropic-ai/claude-code", () => ({
+  claude: vi.fn(),
+}));
+
+import { AgentProcessManager } from "../agent-process-manager";
+import type { AgentEvent } from "../../src/lib/agent-events";
+
+describe("AgentProcessManager", () => {
+  let manager: AgentProcessManager;
+
+  beforeEach(() => {
+    manager = new AgentProcessManager();
+  });
+
+  afterEach(() => {
+    manager.destroyAll();
+  });
+
+  it("returns empty history for unknown session", () => {
+    expect(manager.getHistory("nonexistent")).toEqual([]);
+  });
+
+  it("getStatus returns idle for unknown session", () => {
+    expect(manager.getStatus("nonexistent")).toBe("idle");
+  });
+
+  it("tracks sessions after spawn", async () => {
+    const { claude } = await import("@anthropic-ai/claude-code");
+    (claude as ReturnType<typeof vi.fn>).mockImplementation(async function* () {
+      yield { type: "assistant", message: { content: [{ type: "text", text: "hello" }] } };
+    });
+
+    await manager.spawn("test-session", { workspacePath: "/tmp/test" });
+    expect(manager.getStatus("test-session")).not.toBe("idle");
+  });
+
+  it("addUserEvent appends to history", () => {
+    manager.addUserEvent("s1", "hello");
+    const history = manager.getHistory("s1");
+    expect(history).toHaveLength(1);
+    expect(history[0].type).toBe("user_message");
+  });
+});

agent-orchestrator-main/packages/web/server/agent-process-manager.ts

@@ -0,0 +1,247 @@
+// Copyright (c) 2016-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+import { spawn, type ChildProcess } from "child_process";
+import { createInterface } from "readline";
+import { resolve } from "path";
+import {
+  createAgentEvent,
+  type AgentEvent,
+  type AgentStatus,
+  type UserMessageData,
+  type AssistantMessageData,
+  type ThinkingData,
+  type ToolUseData,
+  type StatusData,
+} from "../src/lib/agent-events";
+
+const CLAUDE_CLI_PATH = resolve(
+  process.cwd(),
+  "node_modules/@anthropic-ai/claude-code/cli.js",
+);
+
+interface AgentProcess {
+  sessionId: string;
+  claudeSessionId: string | null;
+  status: AgentStatus;
+  history: AgentEvent[];
+  subscribers: Set<(event: AgentEvent) => void>;
+  childProcess: ChildProcess | null;
+  workspacePath: string;
+}
+
+export interface SpawnConfig {
+  workspacePath: string;
+  model?: string;
+  systemPrompt?: string;
+}
+
+export class AgentProcessManager {
+  private agents = new Map<string, AgentProcess>();
+
+  getHistory(sessionId: string): AgentEvent[] {
+    return this.agents.get(sessionId)?.history ?? [];
+  }
+
+  getStatus(sessionId: string): AgentStatus {
+    return this.agents.get(sessionId)?.status ?? "idle";
+  }
+
+  subscribe(sessionId: string, callback: (event: AgentEvent) => void): () => void {
+    const agent = this.agents.get(sessionId);
+    if (!agent) {
+      const placeholder: AgentProcess = {
+        sessionId,
+        claudeSessionId: null,
+        status: "idle",
+        history: [],
+        subscribers: new Set([callback]),
+        childProcess: null,
+        workspacePath: "",
+      };
+      this.agents.set(sessionId, placeholder);
+      return () => { placeholder.subscribers.delete(callback); };
+    }
+    agent.subscribers.add(callback);
+    return () => { agent.subscribers.delete(callback); };
+  }
+
+  addUserEvent(sessionId: string, text: string): void {
+    const event = createAgentEvent(sessionId, "user_message", { text } as UserMessageData);
+    this.appendAndBroadcast(sessionId, event);
+  }
+
+  async spawn(sessionId: string, config: SpawnConfig): Promise<void> {
+    const existing = this.agents.get(sessionId);
+    const agent: AgentProcess = {
+      sessionId,
+      claudeSessionId: existing?.claudeSessionId ?? null,
+      status: "spawning",
+      history: existing?.history ?? [],
+      subscribers: existing?.subscribers ?? new Set(),
+      childProcess: null,
+      workspacePath: config.workspacePath,
+    };
+    this.agents.set(sessionId, agent);
+    this.broadcastStatus(sessionId, "spawning");
+  }
+
+  async send(sessionId: string, message: string): Promise<void> {
+    const agent = this.agents.get(sessionId);
+    if (!agent) throw new Error(`No agent for session ${sessionId}`);
+
+    this.addUserEvent(sessionId, message);
+
+    agent.status = "active";
+    this.broadcastStatus(sessionId, "active");
+
+    const args = [
+      CLAUDE_CLI_PATH,
+      "--print",
+      "--output-format", "stream-json",
+      "--verbose",
+      "--dangerously-skip-permissions",
+    ];
+
+    if (agent.claudeSessionId) {
+      args.push("--resume", agent.claudeSessionId);
+    }
+
+    args.push(message);
+
+    const proc = spawn("node", args, {
+      cwd: agent.workspacePath,
+      env: { ...process.env },
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    agent.childProcess = proc;
+
+    const rl = createInterface({ input: proc.stdout! });
+    rl.on("line", (line: string) => {
+      if (!line.trim()) return;
+      try {
+        const sdkEvent = JSON.parse(line);
+        this.processSDKEvent(sessionId, sdkEvent);
+
+        if (sdkEvent.type === "system" && sdkEvent.subtype === "init" && sdkEvent.session_id) {
+          agent.claudeSessionId = sdkEvent.session_id;
+        }
+      } catch {
+        // Non-JSON output — ignore
+      }
+    });
+
+    proc.stderr?.on("data", (data: Buffer) => {
+      console.warn(`[AgentProcessManager] Claude CLI stderr: ${data.toString().slice(0, 200)}`);
+    });
+
+    return new Promise<void>((resolvePromise) => {
+      proc.on("close", () => {
+        agent.childProcess = null;
+        if (agent.status !== "error") {
+          agent.status = "idle";
+          this.broadcastStatus(sessionId, "idle");
+        }
+        resolvePromise();
+      });
+
+      proc.on("error", (err) => {
+        agent.childProcess = null;
+        agent.status = "error";
+        const errorEvent = createAgentEvent(sessionId, "error", { message: err.message });
+        this.appendAndBroadcast(sessionId, errorEvent);
+        this.broadcastStatus(sessionId, "error");
+        resolvePromise();
+      });
+    });
+  }
+
+  kill(sessionId: string): void {
+    const agent = this.agents.get(sessionId);
+    if (!agent) return;
+    if (agent.childProcess) {
+      agent.childProcess.kill("SIGTERM");
+      agent.childProcess = null;
+    }
+    agent.status = "idle";
+    this.broadcastStatus(sessionId, "idle");
+  }
+
+  destroyAll(): void {
+    for (const [id] of this.agents) {
+      this.kill(id);
+    }
+    this.agents.clear();
+  }
+
+  private processSDKEvent(sessionId: string, sdkEvent: any): void {
+    if (sdkEvent.type === "assistant" && sdkEvent.message?.content) {
+      for (const block of sdkEvent.message.content) {
+        if (block.type === "text") {
+          const event = createAgentEvent(sessionId, "assistant_message", {
+            text: block.text,
+          } as AssistantMessageData);
+          this.appendAndBroadcast(sessionId, event);
+        } else if (block.type === "thinking") {
+          const event = createAgentEvent(sessionId, "thinking", {
+            text: block.thinking,
+          } as ThinkingData);
+          this.appendAndBroadcast(sessionId, event);
+        } else if (block.type === "tool_use") {
+          const event = createAgentEvent(sessionId, "tool_use", {
+            toolName: block.name,
+            summary: this.summarizeToolInput(block.name, block.input),
+            callId: block.id,
+          } as ToolUseData);
+          this.appendAndBroadcast(sessionId, event);
+        }
+      }
+    }
+  }
+
+  private summarizeToolInput(toolName: string, input: any): string {
+    if (!input) return toolName;
+    if (typeof input.file_path === "string") {
+      const filename = input.file_path.split("/").pop() ?? input.file_path;
+      return `${filename}`;
+    }
+    if (typeof input.command === "string") {
+      const cmd = input.command.length > 60
+        ? input.command.slice(0, 57) + "..."
+        : input.command;
+      return cmd;
+    }
+    if (typeof input.pattern === "string") return input.pattern;
+    if (typeof input.query === "string") return input.query;
+    return toolName;
+  }
+
+  private appendAndBroadcast(sessionId: string, event: AgentEvent): void {
+    let agent = this.agents.get(sessionId);
+    if (!agent) {
+      agent = {
+        sessionId,
+        claudeSessionId: null,
+        status: "idle",
+        history: [],
+        subscribers: new Set(),
+        childProcess: null,
+        workspacePath: "",
+      };
+      this.agents.set(sessionId, agent);
+    }
+    agent.history.push(event);
+    for (const cb of agent.subscribers) {
+      try { cb(event); } catch { /* subscriber error */ }
+    }
+  }
+
+  private broadcastStatus(sessionId: string, status: AgentStatus): void {
+    const event = createAgentEvent(sessionId, "status", { status } as StatusData);
+    this.appendAndBroadcast(sessionId, event);
+  }
+}
+
+const agentProcessManager = new AgentProcessManager();
+export default agentProcessManager;

agent-orchestrator-main/packages/web/src/app/api/sessions/[id]/send/route.ts

@@ -8,6 +8,7 @@ import {
   recordApiObservation,
   resolveProjectIdForSessionId,
 } from "@/lib/observability";
+import agentProcessManager from "../../../../../../server/agent-process-manager";
 
 const MAX_MESSAGE_LENGTH = 10_000;
 
@@ -42,6 +43,30 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
   try {
     const { config, sessionManager } = await getServices();
     const projectId = resolveProjectIdForSessionId(config, id);
+
+    // Route to AgentProcessManager for chat-mode sessions
+    const session = await sessionManager.get(id);
+    if (session?.metadata?.["useChatUI"] === "true") {
+      await agentProcessManager.send(id, message);
+      recordApiObservation({
+        config,
+        method: "POST",
+        path: "/api/sessions/[id]/send",
+        correlationId,
+        startedAt,
+        outcome: "success",
+        statusCode: 200,
+        projectId,
+        sessionId: id,
+        data: { messageLength: message.length, chatMode: true },
+      });
+      return jsonWithCorrelation(
+        { ok: true, sessionId: id, message },
+        { status: 200 },
+        correlationId,
+      );
+    }
+
     await sessionManager.send(id, message);
     recordApiObservation({
       config,