@agentmeshhq/agent 0.1.13 → 0.1.15

package/src/core/injector.ts

@@ -6,15 +6,38 @@ import type { InboxItem } from "./registry.js";
 import { sendKeys } from "./tmux.js";
 import type { WebSocketEvent } from "./websocket.js";
 
-export function injectStartupMessage(agentName: string, pendingCount: number): void {
+export function injectStartupMessage(
+  agentName: string,
+  pendingCount: number,
+  inboxItems?: InboxItem[],
+): void {
   if (pendingCount === 0) {
     const message = `[AgentMesh] Connected and ready. No pending items in inbox.`;
     sendKeys(agentName, message);
     return;
   }
 
-  const message = `[AgentMesh] Welcome back! You have ${pendingCount} pending handoff${pendingCount === 1 ? "" : "s"} in your inbox.
-Use agentmesh_check_inbox to see them, or agentmesh_accept_handoff to start working.`;
+  // Build detailed message with handoff info
+  let message = `[AgentMesh] Welcome back! You have ${pendingCount} pending handoff${pendingCount === 1 ? "" : "s"}.`;
+
+  if (inboxItems && inboxItems.length > 0) {
+    message += "\n\n--- PENDING HANDOFFS ---";
+    for (const item of inboxItems.slice(0, 3)) {
+      // Show up to 3
+      const fromName = item.from_agent?.display_name || item.from_agent_id || "Unknown";
+      message += `\n\nHandoff ID: ${item.id}`;
+      message += `\nFrom: ${fromName}`;
+      message += `\nScope: ${item.scope || "Not specified"}`;
+      message += `\nReason: ${item.reason || "Not specified"}`;
+    }
+    if (inboxItems.length > 3) {
+      message += `\n\n... and ${inboxItems.length - 3} more.`;
+    }
+    message += "\n\n--- END HANDOFFS ---";
+    message += "\n\nReview the handoff(s) above and begin work on the assigned task.";
+  } else {
+    message += "\nUse agentmesh_check_inbox to see them.";
+  }
 
   sendKeys(agentName, message);
 }
@@ -84,7 +107,7 @@ interface SlackFile {
 export function injectSlackMessage(
   agentName: string,
   event: WebSocketEvent,
-  context?: EventContext,
+  _context?: EventContext,
 ): void {
   const user = (event.user as string) || "unknown";
   const channel = (event.channel as string) || "unknown";

package/src/core/runner.ts

@@ -120,11 +120,59 @@ export function validateOpenCodeModel(model: string): { valid: boolean; error?:
   };
 }
 
+// Common model aliases to their full OpenCode names
+const MODEL_ALIASES: Record<string, string> = {
+  // Anthropic — Claude
+  "claude-sonnet-4": "anthropic/claude-sonnet-4-5",
+  "claude-sonnet-4-0": "anthropic/claude-sonnet-4-0",
+  "claude-sonnet-4-5": "anthropic/claude-sonnet-4-5",
+  "claude-sonnet-4-6": "anthropic/claude-sonnet-4-6",
+  "claude-opus-4": "anthropic/claude-opus-4-5",
+  "claude-opus-4-0": "anthropic/claude-opus-4-0",
+  "claude-opus-4-1": "anthropic/claude-opus-4-1",
+  "claude-opus-4-5": "anthropic/claude-opus-4-5",
+  "claude-opus-4-6": "anthropic/claude-opus-4-6",
+  "claude-haiku-4": "anthropic/claude-haiku-4-5",
+  "claude-haiku-4-5": "anthropic/claude-haiku-4-5",
+  "claude-3-5-sonnet": "anthropic/claude-3-5-sonnet-20241022",
+  "claude-3-5-haiku": "anthropic/claude-3-5-haiku-latest",
+  "claude-3-7-sonnet": "anthropic/claude-3-7-sonnet-latest",
+
+  // OpenAI — GPT & Codex
+  "gpt-5.2": "openai/gpt-5.2",
+  "gpt-5.3-codex": "openai/gpt-5.3-codex",
+  "gpt-5.2-codex": "openai/gpt-5.2-codex",
+  "gpt-5.1-codex": "openai/gpt-5.1-codex",
+  "gpt-5.1-codex-max": "openai/gpt-5.1-codex-max",
+  "gpt-5.1-codex-mini": "openai/gpt-5.1-codex-mini",
+  "gpt-5-codex": "openai/gpt-5-codex",
+  "codex-mini": "openai/codex-mini-latest",
+  codex: "openai/gpt-5.3-codex",
+
+  // xAI — Grok
+  "grok-4": "xai/grok-4",
+  "grok-4-fast": "xai/grok-4-fast",
+  "grok-3": "xai/grok-3",
+  "grok-3-fast": "xai/grok-3-fast",
+  "grok-3-mini": "xai/grok-3-mini",
+  "grok-code": "xai/grok-code-fast-1",
+};
+
 /**
  * Normalizes a model name for OpenCode
- * e.g., "claude-sonnet-4" -> "anthropic/claude-sonnet-4" if that's what OpenCode expects
+ * e.g., "claude-sonnet-4" -> "anthropic/claude-sonnet-4-5" if that's what OpenCode expects
  */
 export function normalizeOpenCodeModel(model: string): string {
+  // Check hardcoded aliases first (works even if opencode not installed)
+  if (MODEL_ALIASES[model]) {
+    return MODEL_ALIASES[model];
+  }
+
+  // Already has provider prefix
+  if (model.includes("/")) {
+    return model;
+  }
+
   const models = getOpenCodeModels();
 
   // Direct match

package/src/core/sandbox.ts

@@ -34,6 +34,8 @@ export interface SandboxConfig {
   serveMode?: boolean;
   /** Port for serve mode */
   servePort?: number;
+  /** Custom command to run in container (overrides default) */
+  command?: string[];
 }
 
 export interface SandboxMountPolicy {
@@ -223,8 +225,11 @@ export class DockerSandbox {
     // Image and command
     args.push(this.config.image);
 
-    // Command: either serve mode or keep container alive for tmux-style attach
-    if (this.config.serveMode) {
+    // Command: custom command > serve mode > tail
+    if (this.config.command && this.config.command.length > 0) {
+      // Custom command (e.g., agentmesh start inside container)
+      args.push(...this.config.command);
+    } else if (this.config.serveMode) {
       args.push(
         "opencode",
         "serve",
@@ -433,6 +438,46 @@ export class DockerSandbox {
     this.containerId = null;
   }
 
+  /**
+   * Restarts the container (destroy + start)
+   * Returns the new container ID
+   */
+  async restart(): Promise<string> {
+    await this.destroy();
+
+    // Generate a new container name
+    const suffix = crypto.randomBytes(4).toString("hex");
+    this.containerName = `agentmesh-sandbox-${this.config.agentName}-${suffix}`;
+
+    return this.start();
+  }
+
+  /**
+   * Force removes any existing containers for this agent
+   */
+  static forceCleanup(agentName: string): number {
+    const result = spawnSync(
+      "docker",
+      ["ps", "-aq", "--filter", `name=agentmesh-sandbox-${agentName}-`],
+      { encoding: "utf-8" },
+    );
+
+    if (result.status !== 0 || !result.stdout.trim()) {
+      return 0;
+    }
+
+    const containers = result.stdout.trim().split("\n").filter(Boolean);
+
+    for (const containerId of containers) {
+      spawnSync("docker", ["rm", "-f", containerId], {
+        encoding: "utf-8",
+        timeout: 10000,
+      });
+    }
+
+    return containers.length;
+  }
+
   /**
    * Gets container name
    */

package/src/core/tmux.ts

@@ -1,4 +1,7 @@
-import { type ChildProcess, execFileSync, execSync, spawn } from "node:child_process";
+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-";
 
@@ -37,24 +40,59 @@ export function createSession(
   }
 
   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 = "";
-    if (env) {
-      const envParts: string[] = [];
-      for (const [key, value] of Object.entries(env)) {
-        if (value !== undefined && value !== "") {
-          // Escape special characters in value
-          const escapedValue = value.replace(/"/g, '\\"');
-          envParts.push(`${key}="${escapedValue}"`);
-        }
+    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(" ") + " ";
+    }
+    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}`;
       }
     }
 
-    const fullCommand = `${envPrefix}${command}`;
+    const fullCommand = `${envPrefix}${finalCommand}`;
 
     // Set reasonable terminal size for TUI applications
     const args = ["new-session", "-d", "-s", sessionName, "-x", "200", "-y", "50"];
@@ -194,6 +232,91 @@ export function getSessionInfo(agentName: string): { exists: boolean; command?:
   }
 }
 
+/**
+ * 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;

package/src/core/watchdog.ts

@@ -0,0 +1,238 @@
+/**
+ * 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;
+}

package/src/core/websocket.ts

@@ -70,11 +70,11 @@ export class AgentWebSocket {
     }
 
     this.reconnectAttempts++;
-    const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+    const delay = this.reconnectDelay * 2 ** (this.reconnectAttempts - 1);
 
     setTimeout(() => {
       console.log(
-        `Reconnecting... (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`
+        `Reconnecting... (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`,
       );
       this.connect();
     }, delay);

package/src/index.ts

@@ -1,9 +1,10 @@
 // Re-export core modules for programmatic usage
+
+export * from "./config/loader.js";
+export * from "./config/schema.js";
 export { AgentDaemon } from "./core/daemon.js";
-export { AgentWebSocket } from "./core/websocket.js";
 export { Heartbeat } from "./core/heartbeat.js";
-export * from "./core/tmux.js";
-export * from "./core/registry.js";
 export * from "./core/injector.js";
-export * from "./config/schema.js";
-export * from "./config/loader.js";
+export * from "./core/registry.js";
+export * from "./core/tmux.js";
+export { AgentWebSocket } from "./core/websocket.js";