@agentmeshhq/agent 0.1.12 → 0.1.14

package/src/cli/migrate.ts

@@ -1,4 +1,4 @@
-import { spawnSync, execSync } from "node:child_process";
+import { execSync, spawnSync } from "node:child_process";
 import path from "node:path";
 import pc from "picocolors";
 
@@ -14,14 +14,16 @@ function findProjectRoot(): string {
       dir = path.dirname(dir);
     }
   }
-  throw new Error("Could not find AgentMesh project root. Make sure you're in the agentmesh repository.");
+  throw new Error(
+    "Could not find AgentMesh project root. Make sure you're in the agentmesh repository.",
+  );
 }
 
 function isLocalStackRunning(): boolean {
   try {
     const result = execSync(
       'docker inspect --format="{{.State.Running}}" agentmesh_postgres 2>/dev/null',
-      { encoding: "utf-8" }
+      { encoding: "utf-8" },
     ).trim();
     return result === "true";
   } catch {
@@ -84,7 +86,7 @@ async function generateMigration(projectRoot: string): Promise<void> {
 
 async function migrationStatus(projectRoot: string, options: MigrateOptions): Promise<void> {
   const env = getEnvironmentConfig(options);
-  
+
   console.log(pc.cyan(`Checking migration status for ${env.name}...`));
   console.log();
 

package/src/cli/nudge.ts

@@ -1,7 +1,8 @@
-import { loadConfig, getAgentState, loadState } from "../config/loader.js";
-import { sendKeys, sessionExists, getSessionName } from "../core/tmux.js";
-import { registerAgent } from "../core/registry.js";
+import { spawnSync } from "node:child_process";
 import pc from "picocolors";
+import { getAgentState, loadConfig, loadState } from "../config/loader.js";
+import { registerAgent } from "../core/registry.js";
+import { getSessionName, sendKeys, sessionExists } from "../core/tmux.js";
 
 export async function nudge(name: string, message: string): Promise<void> {
   const config = loadConfig();
@@ -24,6 +25,23 @@ export async function nudge(name: string, message: string): Promise<void> {
   // Check if this is a local agent
   const localAgent = getAgentState(name);
 
+  // Sandbox agent - route nudge through docker exec
+  if (localAgent?.sandboxContainer) {
+    const result = spawnSync(
+      "docker",
+      ["exec", localAgent.sandboxContainer, "agentmesh", "nudge", name, message],
+      { encoding: "utf-8", stdio: "pipe" },
+    );
+
+    if (result.status === 0) {
+      console.log(pc.green(`Nudged "${name}" in sandbox.`));
+    } else {
+      console.log(pc.red(`Failed to nudge "${name}" in sandbox: ${result.stderr}`));
+    }
+    return;
+  }
+
+  // Local agent with tmux session on host
   if (localAgent && sessionExists(getSessionName(name))) {
     // Local nudge via tmux send-keys
     const formatted = `[AgentMesh] Nudge from CLI:
@@ -60,17 +78,14 @@ ${message}`;
       model: "cli",
     });
 
-    const response = await fetch(
-      `${config.hubUrl}/api/v1/agents/${agentState.agentId}/nudge`,
-      {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${registration.token}`,
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({ message }),
-      }
-    );
+    const response = await fetch(`${config.hubUrl}/api/v1/agents/${agentState.agentId}/nudge`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${registration.token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ message }),
+    });
 
     if (response.ok) {
       console.log(pc.green(`Nudged "${name}" via API.`));

package/src/cli/restart.ts

@@ -1,6 +1,6 @@
 import pc from "picocolors";
 import { getAgentState, loadConfig } from "../config/loader.js";
-import { destroySession, getSessionName, sessionExists } from "../core/tmux.js";
+import { getSessionName, sessionExists } from "../core/tmux.js";
 import { start } from "./start.js";
 import { stop } from "./stop.js";
 

package/src/cli/slack.ts

@@ -1,11 +1,11 @@
-import { loadConfig, getAgentState } from "../config/loader.js";
 import pc from "picocolors";
+import { getAgentState, loadConfig } from "../config/loader.js";
 
 export async function slack(
   action: string,
   channel: string | undefined,
   message: string | undefined,
-  options: { name?: string }
+  options: { name?: string },
 ): Promise<void> {
   const config = loadConfig();
 
@@ -16,12 +16,16 @@ export async function slack(
 
   if (action === "respond" || action === "reply") {
     if (!channel) {
-      console.log(pc.red("Channel is required. Usage: agentmesh slack respond <channel> <message>"));
+      console.log(
+        pc.red("Channel is required. Usage: agentmesh slack respond <channel> <message>"),
+      );
       process.exit(1);
     }
 
     if (!message) {
-      console.log(pc.red("Message is required. Usage: agentmesh slack respond <channel> <message>"));
+      console.log(
+        pc.red("Message is required. Usage: agentmesh slack respond <channel> <message>"),
+      );
       process.exit(1);
     }
 
@@ -36,17 +40,14 @@ export async function slack(
     }
 
     try {
-      const response = await fetch(
-        `${config.hubUrl}/api/v1/integrations/slack/respond`,
-        {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${token}`,
-            "Content-Type": "application/json",
-          },
-          body: JSON.stringify({ channel, text: message }),
-        }
-      );
+      const response = await fetch(`${config.hubUrl}/api/v1/integrations/slack/respond`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ channel, text: message }),
+      });
 
       if (response.ok) {
         console.log(pc.green(`Message sent to Slack channel ${channel}`));

package/src/cli/start.ts

@@ -18,6 +18,14 @@ export interface StartOptions {
   serve?: boolean;
   /** Port for opencode serve (default: 3001) */
   servePort?: number;
+  /** Run agent in Docker sandbox container */
+  sandbox?: boolean;
+  /** Docker image for sandbox */
+  sandboxImage?: string;
+  /** CPU limit for sandbox */
+  sandboxCpu?: string;
+  /** Memory limit for sandbox */
+  sandboxMemory?: string;
 }
 
 export async function start(options: StartOptions): Promise<void> {
@@ -78,6 +86,12 @@ export async function start(options: StartOptions): Promise<void> {
     args.push("--serve");
     if (options.servePort) args.push("--serve-port", String(options.servePort));
   }
+  if (options.sandbox) {
+    args.push("--sandbox");
+    if (options.sandboxImage) args.push("--sandbox-image", options.sandboxImage);
+    if (options.sandboxCpu) args.push("--sandbox-cpu", options.sandboxCpu);
+    if (options.sandboxMemory) args.push("--sandbox-memory", options.sandboxMemory);
+  }
 
   // Spawn detached background process
   const child = spawn("node", [cliPath, ...args], {

package/src/cli/stop.ts

@@ -1,6 +1,7 @@
-import { destroySession } from "../core/tmux.js";
-import { removeAgentFromState, getAgentState } from "../config/loader.js";
+import { spawnSync } from "node:child_process";
 import pc from "picocolors";
+import { getAgentState, removeAgentFromState } from "../config/loader.js";
+import { destroySession } from "../core/tmux.js";
 
 export async function stop(name: string): Promise<void> {
   if (!name) {
@@ -32,8 +33,16 @@ export async function stop(name: string): Promise<void> {
     console.log(pc.green(`Destroyed tmux session for "${name}"`));
   }
 
-  // Remove from state
-  removeAgentFromState(name);
+  // Clean up Docker sandbox container if it exists
+  if (state.sandboxContainer) {
+    console.log(`Stopping sandbox container: ${state.sandboxContainer}`);
+    spawnSync("docker", ["stop", "-t", "5", state.sandboxContainer], { encoding: "utf-8" });
+    spawnSync("docker", ["rm", "-f", state.sandboxContainer], { encoding: "utf-8" });
+    console.log(pc.green(`Removed sandbox container`));
+  }
+
+  // Remove from state but preserve agentId for re-registration
+  removeAgentFromState(name, true);
 
-  console.log(pc.green(`Agent "${name}" stopped.`));
+  console.log(pc.green(`Agent "${name}" stopped (agentId preserved for restart).`));
 }

package/src/cli/test.ts

@@ -1,4 +1,4 @@
-import { spawnSync, execSync } from "node:child_process";
+import { execSync, spawnSync } from "node:child_process";
 import path from "node:path";
 import pc from "picocolors";
 
@@ -14,14 +14,16 @@ function findProjectRoot(): string {
       dir = path.dirname(dir);
     }
   }
-  throw new Error("Could not find AgentMesh project root. Make sure you're in the agentmesh repository.");
+  throw new Error(
+    "Could not find AgentMesh project root. Make sure you're in the agentmesh repository.",
+  );
 }
 
 function isLocalStackRunning(): boolean {
   try {
     const result = execSync(
       'docker inspect --format="{{.State.Running}}" agentmesh_postgres 2>/dev/null',
-      { encoding: "utf-8" }
+      { encoding: "utf-8" },
     ).trim();
     return result === "true";
   } catch {

package/src/cli/token.ts

@@ -39,9 +39,9 @@ export async function token(action: string, agentName?: string): Promise<void> {
 }
 
 async function showToken(
-  config: ReturnType<typeof loadConfig>,
+  _config: ReturnType<typeof loadConfig>,
   agentName?: string,
-  envAgentId?: string,
+  _envAgentId?: string,
   envToken?: string,
 ): Promise<void> {
   // If running as agent, show env token
@@ -134,9 +134,9 @@ async function refreshToken(
 }
 
 async function tokenInfo(
-  config: ReturnType<typeof loadConfig>,
+  _config: ReturnType<typeof loadConfig>,
   agentName?: string,
-  envAgentId?: string,
+  _envAgentId?: string,
   envToken?: string,
 ): Promise<void> {
   // Get token to inspect

package/src/config/loader.ts

@@ -58,12 +58,39 @@ export function addAgentToState(agent: AgentState): void {
   saveState(state);
 }
 
-export function removeAgentFromState(name: string): void {
+export function removeAgentFromState(name: string, preserveAgentId = false): void {
   const state = loadState();
-  state.agents = state.agents.filter((a) => a.name !== name);
+
+  if (preserveAgentId) {
+    // Keep minimal state with agentId for re-registration
+    const existing = state.agents.find((a) => a.name === name);
+    if (existing) {
+      state.agents = state.agents.filter((a) => a.name !== name);
+      // Save only the agentId and restartCount for next startup
+      state.agents.push({
+        name: existing.name,
+        agentId: existing.agentId,
+        pid: 0,
+        tmuxSession: "",
+        startedAt: existing.startedAt,
+        restartCount: existing.restartCount,
+        status: "stopped",
+      });
+    }
+  } else {
+    state.agents = state.agents.filter((a) => a.name !== name);
+  }
+
   saveState(state);
 }
 
+/**
+ * Reset restart count for an agent (called on manual start or after stable period)
+ */
+export function resetAgentRestartCount(name: string): void {
+  updateAgentInState(name, { restartCount: 0, stuckSince: undefined, status: "running" });
+}
+
 export function getAgentState(name: string): AgentState | undefined {
   const state = loadState();
   return state.agents.find((a) => a.name === name);

package/src/config/schema.ts

@@ -32,6 +32,8 @@ export const STATE_PATH = `${process.env.HOME}/.agentmesh/state.json`;
 
 export type RunnerType = "opencode" | "claude" | "custom";
 
+export type AgentStatus = "running" | "stopped" | "failed" | "stuck";
+
 export interface AgentState {
   name: string;
   agentId: string;
@@ -45,6 +47,18 @@ export interface AgentState {
   runtimeModel?: string;
   /** The runner type (opencode, claude, custom) */
   runnerType?: RunnerType;
+  /** Docker container name if running in sandbox mode */
+  sandboxContainer?: string;
+  /** Number of auto-restart attempts since last manual start */
+  restartCount?: number;
+  /** ISO timestamp of last auto-restart */
+  lastRestartAt?: string;
+  /** ISO timestamp of last detected activity */
+  lastActivityAt?: string;
+  /** ISO timestamp when agent was detected as stuck */
+  stuckSince?: string;
+  /** Current agent status */
+  status?: AgentStatus;
 }
 
 export interface State {