@agentmeshhq/agent 0.1.13 → 0.1.14

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,4 @@
-import { type ChildProcess, execFileSync, execSync, spawn } from "node:child_process";
+import { execFileSync, execSync, spawn } from "node:child_process";
 
 const SESSION_PREFIX = "agentmesh-";
 
@@ -50,7 +50,7 @@ export function createSession(
         }
       }
       if (envParts.length > 0) {
-        envPrefix = envParts.join(" ") + " ";
+        envPrefix = `${envParts.join(" ")} `;
       }
     }
 
@@ -194,6 +194,39 @@ 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
+ */
+export function isSessionHealthy(agentName: string): { healthy: boolean; reason?: string } {
+  const sessionName = getSessionName(agentName);
+
+  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";