@saadnvd1/agent-os 0.3.824 → 0.3.826

package/lib/mcp-config.ts

@@ -1,80 +0,0 @@
-/**
- * MCP Config Auto-Generation
- *
- * Writes a .mcp.json file to the session's working directory so Claude
- * automatically picks up the orchestration tools with the session ID baked in.
- */
-
-import { writeFileSync, existsSync, readFileSync } from "fs";
-import path from "path";
-import { selfUrl } from "./agents/self-env";
-
-interface McpConfig {
-  mcpServers: Record<
-    string,
-    {
-      command: string;
-      args: string[];
-      env?: Record<string, string>;
-    }
-  >;
-}
-
-/**
- * Write or update .mcp.json in the working directory with orchestration server config
- */
-export function ensureMcpConfig(
-  workingDirectory: string,
-  sessionId: string
-): void {
-  const configPath = path.join(workingDirectory, ".mcp.json");
-  const orchestrationServerPath = path.join(
-    process.cwd(),
-    "mcp",
-    "orchestration-server.ts"
-  );
-
-  let config: McpConfig = { mcpServers: {} };
-
-  // Read existing config if present
-  if (existsSync(configPath)) {
-    try {
-      const existing = readFileSync(configPath, "utf-8");
-      config = JSON.parse(existing);
-      if (!config.mcpServers) {
-        config.mcpServers = {};
-      }
-    } catch {
-      // Invalid JSON, start fresh
-      config = { mcpServers: {} };
-    }
-  }
-
-  // Add/update agent-os orchestration server
-  config.mcpServers["agent-os"] = {
-    command: "npx",
-    args: ["tsx", orchestrationServerPath],
-    env: {
-      AGENTOS_URL: selfUrl(),
-      CONDUCTOR_SESSION_ID: sessionId,
-    },
-  };
-
-  // Write config
-  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-}
-
-/**
- * Check if .mcp.json exists and has agent-os configured
- */
-export function hasMcpConfig(workingDirectory: string): boolean {
-  const configPath = path.join(workingDirectory, ".mcp.json");
-  if (!existsSync(configPath)) return false;
-
-  try {
-    const config = JSON.parse(readFileSync(configPath, "utf-8"));
-    return !!config.mcpServers?.["agent-os"];
-  } catch {
-    return false;
-  }
-}

package/lib/orchestration.ts

@@ -1,463 +0,0 @@
-/**
- * Orchestration System
- *
- * Allows a "conductor" session to spawn and manage worker sessions.
- * Each worker gets its own git worktree for isolation.
- */
-
-import { randomUUID } from "crypto";
-import { rm } from "fs/promises";
-import { homedir } from "os";
-import { db, queries, type Session } from "./db";
-import { createWorktree, deleteWorktree, mainCheckoutOf } from "./worktrees";
-import { setupWorktree } from "./env-setup";
-import { resolveModelForAgent } from "./model-catalog";
-import { type AgentType, getProvider } from "./providers";
-import { statusDetector } from "./status-detector";
-import { wrapWithBanner } from "./banner";
-import { UNSET_SERVER_ENV } from "./agents/server-env";
-import { runInBackground } from "./async-operations";
-import { tmux } from "./tmux/exec";
-import { endTmuxSession } from "./tmux/end";
-import { inheritGroup } from "@/lib/session-groups/assignSessions";
-
-export interface SpawnWorkerOptions {
-  conductorSessionId: string;
-  task: string;
-  workingDirectory: string;
-  branchName?: string;
-  useWorktree?: boolean;
-  model?: string;
-  agentType?: AgentType;
-}
-
-export interface WorkerInfo {
-  id: string;
-  name: string;
-  task: string;
-  status:
-    | "pending"
-    | "running"
-    | "waiting"
-    | "idle"
-    | "completed"
-    | "failed"
-    | "dead";
-  worktreePath: string | null;
-  branchName: string | null;
-  createdAt: string;
-}
-
-/**
- * Generate a unique branch name from a task description
- */
-function taskToBranchName(task: string): string {
-  const base =
-    task
-      .toLowerCase()
-      .replace(/[^a-z0-9\s]/g, "")
-      .split(/\s+/)
-      .slice(0, 4)
-      .join("-")
-      .slice(0, 30) || "worker";
-
-  // Add short unique suffix to avoid conflicts
-  const suffix = Date.now().toString(36).slice(-4);
-  return `${base}-${suffix}`;
-}
-
-/**
- * Generate a short session name from a task description
- */
-function taskToSessionName(task: string): string {
-  // Take first 50 chars, trim to last complete word
-  const truncated = task.slice(0, 50);
-  const lastSpace = truncated.lastIndexOf(" ");
-  return lastSpace > 20 ? truncated.slice(0, lastSpace) : truncated;
-}
-
-/**
- * Spawn a new worker session
- */
-export async function spawnWorker(
-  options: SpawnWorkerOptions
-): Promise<Session> {
-  const {
-    conductorSessionId,
-    task,
-    workingDirectory: rawWorkingDir,
-    branchName = taskToBranchName(task),
-    useWorktree = true,
-    agentType = "claude",
-  } = options;
-  const model = resolveModelForAgent(agentType, options.model);
-
-  // Expand ~ to home directory
-  const workingDirectory = rawWorkingDir.replace(/^~(?=\/|$)/, homedir());
-
-  const sessionId = randomUUID();
-  const sessionName = taskToSessionName(task);
-  const provider = getProvider(agentType);
-
-  let worktreePath: string | null = null;
-  let actualWorkingDir = workingDirectory;
-
-  // Create worktree if requested
-  if (useWorktree) {
-    try {
-      const worktreeResult = await createWorktree({
-        projectPath: workingDirectory,
-        featureName: branchName,
-      });
-      worktreePath = worktreeResult.worktreePath;
-      actualWorkingDir = worktreePath;
-
-      // Set up environment in background (copy .env files, install deps)
-      const capturedWorktreePath = worktreePath;
-      const capturedSourcePath = workingDirectory;
-      runInBackground(async () => {
-        const result = await setupWorktree({
-          worktreePath: capturedWorktreePath,
-          sourcePath: capturedSourcePath,
-        });
-        console.log("Worker worktree setup completed:", {
-          worktreePath: capturedWorktreePath,
-          envFilesCopied: result.envFilesCopied,
-          stepsRun: result.steps.length,
-          success: result.success,
-        });
-      }, `setup-worker-worktree-${sessionId}`);
-    } catch (error) {
-      console.error("Failed to create worktree:", error);
-      // Fall back to same directory (no isolation)
-    }
-  }
-
-  // Create session in database
-  const tmuxName = `${provider.id}-${sessionId}`;
-  queries.createWorkerSession(db).run(
-    sessionId,
-    sessionName,
-    tmuxName,
-    actualWorkingDir,
-    conductorSessionId,
-    task,
-    model,
-    "sessions", // group_path
-    agentType,
-    "uncategorized" // project_id
-  );
-  inheritGroup(conductorSessionId, sessionId);
-
-  // Update worktree info if created
-  if (worktreePath) {
-    queries.updateSessionWorktree(db).run(
-      worktreePath,
-      branchName,
-      "main", // base_branch
-      null, // dev_server_port
-      sessionId
-    );
-  }
-
-  // Create tmux session and start the agent
-  const tmuxSessionName = `${provider.id}-${sessionId}`;
-  const cwd = actualWorkingDir;
-  const target = `=${tmuxSessionName}:`;
-
-  // Build the initial prompt command (workers use auto-approve by default for automation)
-  const flags = provider.buildFlags({ model, autoApprove: true });
-  const flagsStr = flags.join(" ");
-
-  // Create tmux session with the agent and banner
-  const agentCmd = `${provider.command} ${flagsStr}`;
-  const newSessionCmd =
-    UNSET_SERVER_ENV + wrapWithBanner(agentCmd, provider.preamble);
-  try {
-    await tmux(["set", "-g", "mouse", "on"]).catch(() => {});
-    // The last argument is the agent's command line, which tmux runs.
-    await tmux([
-      "new-session",
-      "-d",
-      "-s",
-      tmuxSessionName,
-      "-c",
-      cwd,
-      "-e",
-      `AGENTOS_SESSION_ID=${sessionId}`,
-      newSessionCmd,
-    ]);
-
-    // Wait for Claude to be ready by checking for the input prompt
-    // Poll every 2 seconds for up to 30 seconds
-    const maxWaitMs = 30000;
-    const pollIntervalMs = 2000;
-    let waited = 0;
-    let ready = false;
-
-    console.log(
-      `[orchestration] Waiting for Claude to initialize in ${tmuxSessionName}...`
-    );
-
-    while (waited < maxWaitMs && !ready) {
-      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-      waited += pollIntervalMs;
-
-      try {
-        const stdout = await tmux([
-          "capture-pane",
-          "-t",
-          target,
-          "-p",
-          "-S",
-          "-10",
-        ]);
-        const content = stdout.toLowerCase();
-
-        // Check for trust/permissions prompt and auto-accept
-        // Claude shows "Ready to code here?" with "Yes, continue" option - just press Enter
-        if (
-          content.includes("ready to code here") ||
-          content.includes("yes, continue") ||
-          content.includes("need permission to work")
-        ) {
-          console.log(
-            `[orchestration] Trust prompt detected, pressing Enter to accept`
-          );
-          await tmux(["send-keys", "-t", target, "Enter"]);
-          continue; // Keep waiting for the real prompt
-        }
-
-        // Look for Claude's ready state - the "? for shortcuts" line indicates fully loaded
-        const lines = stdout.trim().split("\n");
-        const lastFewLines = lines.slice(-3).join("\n");
-        if (
-          lastFewLines.includes("? for shortcuts") ||
-          lastFewLines.includes("?>")
-        ) {
-          ready = true;
-          console.log(`[orchestration] Claude ready after ${waited}ms`);
-        }
-      } catch {
-        // Session might not be ready yet
-      }
-    }
-
-    if (!ready) {
-      console.log(
-        `[orchestration] Timed out waiting for Claude, sending task anyway after ${waited}ms`
-      );
-    }
-
-    // Send the task as input, then press Enter
-    console.log(
-      `[orchestration] Sending task to ${tmuxSessionName}: "${task}"`
-    );
-    try {
-      await tmux(["send-keys", "-t", target, "-l", "--", task]);
-      await tmux(["send-keys", "-t", target, "Enter"]);
-      console.log(
-        `[orchestration] Task sent successfully to ${tmuxSessionName}`
-      );
-    } catch (sendError) {
-      console.error(
-        `[orchestration] Failed to send task to ${tmuxSessionName}:`,
-        sendError
-      );
-    }
-
-    // Update worker status to running
-    queries.updateWorkerStatus(db).run("running", sessionId);
-  } catch (error) {
-    console.error("Failed to start worker session:", error);
-    queries.updateWorkerStatus(db).run("failed", sessionId);
-  }
-
-  return queries.getSession(db).get(sessionId) as Session;
-}
-
-/**
- * Get all workers for a conductor session
- */
-export async function getWorkers(
-  conductorSessionId: string
-): Promise<WorkerInfo[]> {
-  const workers = queries
-    .getWorkersByConductor(db)
-    .all(conductorSessionId) as Session[];
-
-  // Get live status for each worker
-  const workerInfos: WorkerInfo[] = [];
-
-  for (const worker of workers) {
-    const provider = getProvider(worker.agent_type || "claude");
-    const tmuxSessionName = worker.tmux_name || `${provider.id}-${worker.id}`;
-
-    // Get live status from tmux
-    let liveStatus: string;
-    try {
-      liveStatus = await statusDetector.getStatus(tmuxSessionName);
-    } catch {
-      liveStatus = "dead";
-    }
-
-    // Combine DB status with live status
-    let status: WorkerInfo["status"];
-    if (
-      worker.worker_status === "completed" ||
-      worker.worker_status === "failed"
-    ) {
-      status = worker.worker_status;
-    } else if (liveStatus === "dead") {
-      status = "dead";
-    } else {
-      status = liveStatus as WorkerInfo["status"];
-    }
-
-    workerInfos.push({
-      id: worker.id,
-      name: worker.name,
-      task: worker.worker_task || "",
-      status,
-      worktreePath: worker.worktree_path,
-      branchName: worker.branch_name,
-      createdAt: worker.created_at,
-    });
-  }
-
-  return workerInfos;
-}
-
-/**
- * Get recent output from a worker's terminal
- */
-export async function getWorkerOutput(
-  workerId: string,
-  lines: number = 50
-): Promise<string> {
-  const session = queries.getSession(db).get(workerId) as Session | undefined;
-  if (!session) {
-    throw new Error(`Worker ${workerId} not found`);
-  }
-
-  const provider = getProvider(session.agent_type || "claude");
-  const tmuxSessionName = session.tmux_name || `${provider.id}-${workerId}`;
-
-  try {
-    const stdout = await tmux([
-      "capture-pane",
-      "-t",
-      `=${tmuxSessionName}:`,
-      "-p",
-      "-S",
-      `-${Math.max(0, Math.floor(Number(lines)) || 0)}`,
-    ]);
-    return stdout.trim();
-  } catch {
-    return "";
-  }
-}
-
-/**
- * Send a message/command to a worker
- */
-export async function sendToWorker(
-  workerId: string,
-  message: string
-): Promise<boolean> {
-  const session = queries.getSession(db).get(workerId) as Session | undefined;
-  if (!session) {
-    throw new Error(`Worker ${workerId} not found`);
-  }
-
-  const provider = getProvider(session.agent_type || "claude");
-  const tmuxSessionName = session.tmux_name || `${provider.id}-${workerId}`;
-
-  try {
-    const target = `=${tmuxSessionName}:`;
-    await tmux(["send-keys", "-t", target, "-l", "--", message]);
-    await tmux(["send-keys", "-t", target, "Enter"]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Mark a worker as completed
- */
-export function completeWorker(workerId: string): void {
-  queries.updateWorkerStatus(db).run("completed", workerId);
-}
-
-/**
- * Mark a worker as failed
- */
-export function failWorker(workerId: string): void {
-  queries.updateWorkerStatus(db).run("failed", workerId);
-}
-
-/**
- * Kill a worker session and optionally clean up its worktree
- */
-export async function killWorker(
-  workerId: string,
-  cleanupWorktree: boolean = false
-): Promise<void> {
-  const session = queries.getSession(db).get(workerId) as Session | undefined;
-  if (!session) {
-    return;
-  }
-
-  const provider = getProvider(session.agent_type || "claude");
-  const tmuxSessionName = session.tmux_name || `${provider.id}-${workerId}`;
-
-  // Kill tmux session
-  await endTmuxSession(session.host_id, tmuxSessionName);
-
-  // Clean up worktree if requested
-  // Note: This requires knowing the original project path, which we derive from git
-  if (cleanupWorktree && session.worktree_path) {
-    try {
-      // Get the main worktree (original project) from git
-      const projectPath = await mainCheckoutOf(session.worktree_path);
-      if (projectPath && projectPath !== session.worktree_path) {
-        await deleteWorktree(session.worktree_path, projectPath, true);
-      }
-    } catch (error) {
-      console.error("Failed to delete worktree:", error);
-      // Fallback: just remove the directory
-      try {
-        await rm(session.worktree_path, { recursive: true, force: true });
-      } catch {
-        // Ignore cleanup errors
-      }
-    }
-  }
-
-  queries.updateWorkerStatus(db).run("failed", workerId);
-}
-
-/**
- * Get a summary of all workers' statuses
- */
-export async function getWorkersSummary(conductorSessionId: string): Promise<{
-  total: number;
-  pending: number;
-  running: number;
-  waiting: number;
-  completed: number;
-  failed: number;
-}> {
-  const workers = await getWorkers(conductorSessionId);
-
-  return {
-    total: workers.length,
-    pending: workers.filter((w) => w.status === "pending").length,
-    running: workers.filter((w) => w.status === "running").length,
-    waiting: workers.filter((w) => w.status === "waiting").length,
-    completed: workers.filter((w) => w.status === "completed").length,
-    failed: workers.filter((w) => w.status === "failed" || w.status === "dead")
-      .length,
-  };
-}