@agentmeshhq/agent 0.2.0 → 0.2.1

package/src/core/tmux.ts

@@ -1,405 +0,0 @@
-import { execFileSync, execSync, spawn } from "node:child_process";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-const SESSION_PREFIX = "agentmesh-";
-
-export function getSessionName(agentName: string): string {
-  return `${SESSION_PREFIX}${agentName}`;
-}
-
-export function sessionExists(sessionName: string): boolean {
-  try {
-    execSync(`tmux has-session -t "${sessionName}" 2>/dev/null`);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export interface SessionEnv {
-  AGENT_TOKEN?: string;
-  AGENTMESH_AGENT_ID?: string;
-  OPENCODE_MODEL?: string;
-  CLAUDE_MODEL?: string;
-  [key: string]: string | undefined;
-}
-
-export function createSession(
-  agentName: string,
-  command: string,
-  workdir?: string,
-  env?: SessionEnv,
-  opencodeSessionId?: string,
-): boolean {
-  const sessionName = getSessionName(agentName);
-
-  if (sessionExists(sessionName)) {
-    console.error(`Session ${sessionName} already exists`);
-    return false;
-  }
-
-  try {
-    // Isolate OpenCode's SQLite database per agent to prevent WAL corruption
-    // from multiple concurrent processes sharing one opencode.db file.
-    // See docs/RCA-OPENCODE-SQLITE-CORRUPTION.md for details.
-    const agentDataDir = path.join(os.homedir(), ".agentmesh", "opencode-data", agentName);
-    const agentOpencodeDir = path.join(agentDataDir, "opencode");
-    if (!fs.existsSync(agentOpencodeDir)) {
-      fs.mkdirSync(agentOpencodeDir, { recursive: true });
-    }
-
-    // Copy auth.json from default OpenCode data dir so agents inherit API keys.
-    // Strips xAI provider to prevent OpenCode from defaulting to non-Anthropic models.
-    const agentAuthPath = path.join(agentOpencodeDir, "auth.json");
-    const sourceAuthPath = path.join(os.homedir(), ".local", "share", "opencode", "auth.json");
-    if (!fs.existsSync(agentAuthPath) && fs.existsSync(sourceAuthPath)) {
-      try {
-        const auth = JSON.parse(fs.readFileSync(sourceAuthPath, "utf-8"));
-        delete auth.xai;
-        fs.writeFileSync(agentAuthPath, JSON.stringify(auth, null, 2));
-      } catch {
-        // Non-fatal — agent will just need manual auth
-      }
-    }
-
-    // Build environment prefix for the command
-    // This ensures env vars are set BEFORE the process starts
-    const mergedEnv: SessionEnv = {
-      XDG_DATA_HOME: agentDataDir,
-      ...env,
-    };
-
-    let envPrefix = "";
-    const envParts: string[] = [];
-    for (const [key, value] of Object.entries(mergedEnv)) {
-      if (value !== undefined && value !== "") {
-        // Escape special characters in value
-        const escapedValue = value.replace(/"/g, '\\"');
-        envParts.push(`${key}="${escapedValue}"`);
-      }
-    }
-    if (envParts.length > 0) {
-      envPrefix = `${envParts.join(" ")} `;
-    }
-
-    // Append --model flag for opencode if OPENCODE_MODEL is set
-    let finalCommand = command;
-    if (env?.OPENCODE_MODEL && (command === "opencode" || command.startsWith("opencode "))) {
-      // Check if --model is already in the command
-      if (!command.includes("--model") && !command.includes("-m ")) {
-        finalCommand = `${command} --model ${env.OPENCODE_MODEL}`;
-      }
-    }
-
-    // Append --session --continue flags for native session resume
-    if (
-      opencodeSessionId &&
-      (finalCommand === "opencode" || finalCommand.startsWith("opencode ")) &&
-      !finalCommand.includes("--session") &&
-      !finalCommand.includes("--continue")
-    ) {
-      finalCommand = `${finalCommand} --session ${opencodeSessionId} --continue`;
-      console.log(`[TMUX] Resuming OpenCode session: ${opencodeSessionId}`);
-    }
-
-    const fullCommand = `${envPrefix}${finalCommand}`;
-
-    // Set reasonable terminal size for TUI applications
-    const args = ["new-session", "-d", "-s", sessionName, "-x", "200", "-y", "50"];
-
-    if (workdir) {
-      args.push("-c", workdir);
-    }
-
-    args.push(fullCommand);
-
-    execFileSync("tmux", args);
-
-    // Also set session environment for any subsequent processes/refreshes
-    if (env) {
-      setSessionEnvironment(sessionName, env);
-    }
-
-    return true;
-  } catch (error) {
-    console.error(`Failed to create tmux session: ${error}`);
-    return false;
-  }
-}
-
-export function setSessionEnvironment(sessionName: string, env: SessionEnv): boolean {
-  try {
-    for (const [key, value] of Object.entries(env)) {
-      if (value !== undefined && value !== "") {
-        execFileSync("tmux", ["set-environment", "-t", sessionName, key, value]);
-      }
-    }
-    return true;
-  } catch (error) {
-    console.error(`Failed to set session environment: ${error}`);
-    return false;
-  }
-}
-
-export function updateSessionEnvironment(agentName: string, env: SessionEnv): boolean {
-  const sessionName = getSessionName(agentName);
-
-  if (!sessionExists(sessionName)) {
-    console.error(`Session ${sessionName} does not exist`);
-    return false;
-  }
-
-  return setSessionEnvironment(sessionName, env);
-}
-
-export function destroySession(agentName: string): boolean {
-  const sessionName = getSessionName(agentName);
-
-  if (!sessionExists(sessionName)) {
-    return true; // Already gone
-  }
-
-  try {
-    execSync(`tmux kill-session -t "${sessionName}"`);
-    return true;
-  } catch (error) {
-    console.error(`Failed to destroy tmux session: ${error}`);
-    return false;
-  }
-}
-
-export function sendKeys(agentName: string, message: string): boolean {
-  const sessionName = getSessionName(agentName);
-
-  if (!sessionExists(sessionName)) {
-    console.error(`Session ${sessionName} does not exist`);
-    return false;
-  }
-
-  try {
-    // Replace newlines with " | " to keep message on single line (newlines would act as Enter)
-    const cleanMessage = message.replace(/\n/g, " | ");
-
-    // Use execFileSync with array args to avoid shell escaping issues
-    // The -l flag sends keys literally
-    execFileSync("tmux", ["send-keys", "-t", sessionName, "-l", cleanMessage]);
-    execFileSync("tmux", ["send-keys", "-t", sessionName, "Enter"]);
-    return true;
-  } catch (error) {
-    console.error(`Failed to send keys: ${error}`);
-    return false;
-  }
-}
-
-export function attachSession(agentName: string): void {
-  const sessionName = getSessionName(agentName);
-
-  if (!sessionExists(sessionName)) {
-    console.error(`Session ${sessionName} does not exist`);
-    process.exit(1);
-  }
-
-  // Attach to the session (replaces current process)
-  const tmux = spawn("tmux", ["attach-session", "-t", sessionName], {
-    stdio: "inherit",
-  });
-
-  tmux.on("exit", (code) => {
-    process.exit(code ?? 0);
-  });
-}
-
-export function listSessions(): string[] {
-  try {
-    const output = execSync("tmux list-sessions -F '#{session_name}'", {
-      encoding: "utf-8",
-    });
-    return output
-      .trim()
-      .split("\n")
-      .filter((s) => s.startsWith(SESSION_PREFIX))
-      .map((s) => s.replace(SESSION_PREFIX, ""));
-  } catch {
-    return [];
-  }
-}
-
-export function getSessionInfo(agentName: string): { exists: boolean; command?: string } {
-  const sessionName = getSessionName(agentName);
-
-  if (!sessionExists(sessionName)) {
-    return { exists: false };
-  }
-
-  try {
-    const command = execSync(`tmux list-panes -t "${sessionName}" -F "#{pane_current_command}"`, {
-      encoding: "utf-8",
-    }).trim();
-
-    return { exists: true, command };
-  } catch {
-    return { exists: true };
-  }
-}
-
-/**
- * Checks if the session process is healthy (not crashed/exited)
- * Returns true if healthy, false if crashed or dead
- * @param containerName - If provided, checks inside the Docker container
- */
-export function isSessionHealthy(
-  agentName: string,
-  containerName?: string,
-): { healthy: boolean; reason?: string } {
-  const sessionName = getSessionName(agentName);
-
-  // For sandbox mode, check tmux inside the container
-  if (containerName) {
-    try {
-      // Check if container is running
-      const containerStatus = execSync(
-        `docker inspect -f '{{.State.Running}}' "${containerName}"`,
-        {
-          encoding: "utf-8",
-        },
-      ).trim();
-
-      if (containerStatus !== "true") {
-        return { healthy: false, reason: "container_not_running" };
-      }
-
-      // Check if tmux session exists inside container
-      const tmuxCheck = execSync(
-        `docker exec "${containerName}" tmux has-session -t "${sessionName}" 2>&1 || echo "no_session"`,
-        { encoding: "utf-8" },
-      ).trim();
-
-      if (tmuxCheck === "no_session" || tmuxCheck.includes("no server running")) {
-        return { healthy: false, reason: "session_not_found_in_container" };
-      }
-
-      // Check if pane is alive inside container
-      const paneInfo = execSync(
-        `docker exec "${containerName}" tmux list-panes -t "${sessionName}" -F "#{pane_pid}:#{pane_dead}"`,
-        { encoding: "utf-8" },
-      ).trim();
-
-      const [pid, dead] = paneInfo.split(":");
-
-      if (dead === "1") {
-        return { healthy: false, reason: "pane_dead_in_container" };
-      }
-
-      if (!pid || pid === "0") {
-        return { healthy: false, reason: "no_pid_in_container" };
-      }
-
-      return { healthy: true };
-    } catch (error) {
-      return { healthy: false, reason: `container_check_failed: ${error}` };
-    }
-  }
-
-  // Local mode - check tmux on host
-  if (!sessionExists(sessionName)) {
-    return { healthy: false, reason: "session_not_found" };
-  }
-
-  try {
-    // Check if pane is still alive and has a running process
-    const paneInfo = execSync(`tmux list-panes -t "${sessionName}" -F "#{pane_pid}:#{pane_dead}"`, {
-      encoding: "utf-8",
-    }).trim();
-
-    const [pid, dead] = paneInfo.split(":");
-
-    if (dead === "1") {
-      return { healthy: false, reason: "pane_dead" };
-    }
-
-    if (!pid || pid === "0") {
-      return { healthy: false, reason: "no_pid" };
-    }
-
-    return { healthy: true };
-  } catch (error) {
-    return { healthy: false, reason: `check_failed: ${error}` };
-  }
-}
-
-export interface SessionContext {
-  workdir: string;
-  gitBranch?: string;
-  gitStatus?: string;
-}
-
-/**
- * Captures current working state from the tmux session
- */
-export function captureSessionContext(agentName: string): SessionContext | null {
-  const sessionName = getSessionName(agentName);
-
-  if (!sessionExists(sessionName)) {
-    return null;
-  }
-
-  try {
-    // Get current working directory from the pane
-    const workdir = execSync(`tmux display-message -t "${sessionName}" -p "#{pane_current_path}"`, {
-      encoding: "utf-8",
-    }).trim();
-
-    const context: SessionContext = { workdir };
-
-    // Try to get git info if in a git repo
-    try {
-      const gitBranch = execSync("git rev-parse --abbrev-ref HEAD 2>/dev/null", {
-        encoding: "utf-8",
-        cwd: workdir,
-      }).trim();
-      if (gitBranch) {
-        context.gitBranch = gitBranch;
-      }
-
-      const gitStatus = execSync("git status --short 2>/dev/null", {
-        encoding: "utf-8",
-        cwd: workdir,
-      }).trim();
-      if (gitStatus) {
-        // Truncate if too long
-        context.gitStatus =
-          gitStatus.length > 500 ? `${gitStatus.substring(0, 500)}...` : gitStatus;
-      }
-    } catch {
-      // Not a git repo or git not available
-    }
-
-    return context;
-  } catch (error) {
-    console.error(`Failed to capture session context: ${error}`);
-    return null;
-  }
-}
-
-/**
- * Captures recent output from the tmux pane (last N lines)
- */
-export function captureSessionOutput(agentName: string, lines = 100): string | null {
-  const sessionName = getSessionName(agentName);
-
-  if (!sessionExists(sessionName)) {
-    return null;
-  }
-
-  try {
-    const output = execSync(`tmux capture-pane -t "${sessionName}" -p -S -${lines}`, {
-      encoding: "utf-8",
-    });
-    return output;
-  } catch (error) {
-    console.error(`Failed to capture session output: ${error}`);
-    return null;
-  }
-}

package/src/core/watchdog.ts

@@ -1,238 +0,0 @@
-/**
- * Agent Progress Watchdog
- *
- * Monitors agent activity and detects stuck agents.
- * Checks OpenCode logs for activity and tmux pane for permission prompts.
- */
-
-import { execSync, spawnSync } from "node:child_process";
-import { captureSessionOutput } from "./tmux.js";
-
-export type WatchdogStatus = "active" | "idle" | "stuck" | "permission_blocked";
-
-export interface WatchdogResult {
-  status: WatchdogStatus;
-  lastActivity?: Date;
-  blockedOn?: string;
-  details?: string;
-}
-
-// Patterns that indicate a permission prompt is blocking the agent
-const PERMISSION_PROMPT_PATTERNS = [
-  "Permission required",
-  "Allow once",
-  "Allow always",
-  "Reject",
-  "Access external directory",
-  "△ Permission required",
-];
-
-// Idle threshold: 2 minutes
-const IDLE_THRESHOLD_MS = 2 * 60 * 1000;
-// Stuck threshold: 5 minutes
-const STUCK_THRESHOLD_MS = 5 * 60 * 1000;
-
-/**
- * Check agent progress by analyzing OpenCode logs and tmux output
- */
-export function checkAgentProgress(agentName: string, containerName?: string): WatchdogResult {
-  // First check for permission prompts (highest priority)
-  const permissionPrompt = detectPermissionPrompt(agentName);
-  if (permissionPrompt) {
-    return {
-      status: "permission_blocked",
-      blockedOn: permissionPrompt,
-      details: "Agent is waiting for permission approval",
-    };
-  }
-
-  // Check last activity from OpenCode logs
-  const lastActivity = getLastActivityTime(agentName, containerName);
-
-  if (!lastActivity) {
-    // Can't determine activity, assume active
-    return {
-      status: "active",
-      details: "Unable to determine activity time",
-    };
-  }
-
-  const timeSinceActivity = Date.now() - lastActivity.getTime();
-
-  if (timeSinceActivity > STUCK_THRESHOLD_MS) {
-    return {
-      status: "stuck",
-      lastActivity,
-      details: `No activity for ${Math.round(timeSinceActivity / 60000)} minutes`,
-    };
-  }
-
-  if (timeSinceActivity > IDLE_THRESHOLD_MS) {
-    return {
-      status: "idle",
-      lastActivity,
-      details: `Idle for ${Math.round(timeSinceActivity / 60000)} minutes`,
-    };
-  }
-
-  return {
-    status: "active",
-    lastActivity,
-  };
-}
-
-/**
- * Detect if a permission prompt is blocking the agent
- */
-export function detectPermissionPrompt(agentName: string): string | null {
-  try {
-    const output = captureSessionOutput(agentName, 50);
-    if (!output) return null;
-
-    for (const pattern of PERMISSION_PROMPT_PATTERNS) {
-      if (output.includes(pattern)) {
-        // Try to extract what permission is being requested
-        const lines = output.split("\n");
-        for (const line of lines) {
-          if (line.includes("Access external directory")) {
-            const match = line.match(/Access external directory\s+(\S+)/);
-            if (match) return `External directory: ${match[1]}`;
-          }
-          if (line.includes("Permission required")) {
-            return "Permission prompt detected";
-          }
-        }
-        return "Permission prompt detected";
-      }
-    }
-
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Get the last activity time from OpenCode logs
- */
-export function getLastActivityTime(agentName: string, containerName?: string): Date | null {
-  try {
-    let logLine: string;
-
-    if (containerName) {
-      // Sandbox mode: read from container
-      const result = spawnSync(
-        "docker",
-        [
-          "exec",
-          containerName,
-          "sh",
-          "-c",
-          "ls -t /home/node/.local/share/opencode/log/*.log 2>/dev/null | head -1 | xargs tail -1 2>/dev/null",
-        ],
-        { encoding: "utf-8", timeout: 5000 },
-      );
-
-      if (result.status !== 0 || !result.stdout.trim()) {
-        return null;
-      }
-      logLine = result.stdout.trim();
-    } else {
-      // Non-sandbox mode: read from local logs
-      const logDir = `${process.env.HOME}/.local/share/opencode/log`;
-      const result = spawnSync(
-        "sh",
-        ["-c", `ls -t ${logDir}/*.log 2>/dev/null | head -1 | xargs tail -1 2>/dev/null`],
-        { encoding: "utf-8", timeout: 5000 },
-      );
-
-      if (result.status !== 0 || !result.stdout.trim()) {
-        return null;
-      }
-      logLine = result.stdout.trim();
-    }
-
-    // Parse timestamp from log line
-    // Format: INFO  2026-02-26T00:14:42 +0ms service=...
-    const match = logLine.match(/(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})/);
-    if (match) {
-      return new Date(match[1] + "Z");
-    }
-
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Send a nudge to the agent to continue working
- */
-export function sendNudge(agentName: string, message: string): boolean {
-  try {
-    const sessionName = `agentmesh-${agentName}`;
-
-    // Send keys to tmux session
-    execSync(`tmux send-keys -t "${sessionName}" "${message.replace(/"/g, '\\"')}" Enter`, {
-      encoding: "utf-8",
-      timeout: 5000,
-    });
-
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Check if a process is actually running
- */
-export function isProcessRunning(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Find orphan containers for an agent
- */
-export function findOrphanContainers(agentName: string): string[] {
-  try {
-    const result = spawnSync(
-      "docker",
-      ["ps", "-aq", "--filter", `name=agentmesh-sandbox-${agentName}-`],
-      { encoding: "utf-8", timeout: 5000 },
-    );
-
-    if (result.status !== 0 || !result.stdout.trim()) {
-      return [];
-    }
-
-    return result.stdout.trim().split("\n").filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Remove orphan containers for an agent
- */
-export function cleanupOrphanContainers(agentName: string): number {
-  const containers = findOrphanContainers(agentName);
-
-  for (const containerId of containers) {
-    try {
-      spawnSync("docker", ["rm", "-f", containerId], {
-        encoding: "utf-8",
-        timeout: 10000,
-      });
-    } catch {
-      // Ignore cleanup errors
-    }
-  }
-
-  return containers.length;
-}