@agentmeshhq/agent 0.1.11 → 0.1.13

package/src/core/daemon.ts

@@ -1,4 +1,4 @@
-import { execSync } from "node:child_process";
+import { type ChildProcess, execSync, spawn } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -13,13 +13,14 @@ import type { AgentConfig, Config } from "../config/schema.js";
 import { loadContext, loadOrCreateContext, saveContext } from "../context/index.js";
 import { Heartbeat } from "./heartbeat.js";
 import { handleWebSocketEvent, injectRestoredContext, injectStartupMessage } from "./injector.js";
-import { checkInbox, fetchAssignments, registerAgent } from "./registry.js";
+import { checkInbox, fetchAssignments, registerAgent, type ServerContext } from "./registry.js";
 import {
   buildRunnerConfig,
   detectRunner,
   getRunnerDisplayName,
   type RunnerConfig,
 } from "./runner.js";
+import { DockerSandbox } from "./sandbox.js";
 import {
   captureSessionContext,
   createSession,
@@ -40,6 +41,18 @@ export interface DaemonOptions {
   restoreContext?: boolean;
   /** Auto-clone repository for project assignments */
   autoSetup?: boolean;
+  /** Run opencode serve instead of tmux TUI (for Integration Service) */
+  serve?: boolean;
+  /** Port for opencode serve (default: 3001) */
+  servePort?: number;
+  /** Run agent in Docker sandbox container */
+  sandbox?: boolean;
+  /** Docker image for sandbox (default: agentmesh/agent-sandbox:latest) */
+  sandboxImage?: string;
+  /** CPU limit for sandbox (default: 1) */
+  sandboxCpu?: string;
+  /** Memory limit for sandbox (default: 2g) */
+  sandboxMemory?: string;
 }
 
 export class AgentDaemon {
@@ -55,6 +68,15 @@ export class AgentDaemon {
   private assignedProject: string | undefined;
   private shouldRestoreContext: boolean;
   private autoSetup: boolean;
+  private serveMode: boolean;
+  private servePort: number;
+  private serveProcess: ChildProcess | null = null;
+  private serverContext: ServerContext | undefined;
+  private sandboxMode: boolean;
+  private sandboxImage: string;
+  private sandboxCpu: string;
+  private sandboxMemory: string;
+  private sandbox: DockerSandbox | null = null;
 
   constructor(options: DaemonOptions) {
     const config = loadConfig();
@@ -85,6 +107,12 @@ export class AgentDaemon {
     if (options.model) agentConfig.model = options.model;
 
     this.agentConfig = agentConfig;
+    this.serveMode = options.serve === true;
+    this.servePort = options.servePort || 3001;
+    this.sandboxMode = options.sandbox === true;
+    this.sandboxImage = options.sandboxImage || "agentmesh/agent-sandbox:latest";
+    this.sandboxCpu = options.sandboxCpu || "1";
+    this.sandboxMemory = options.sandboxMemory || "2g";
 
     // Build runner configuration with model resolution
     this.runnerConfig = buildRunnerConfig({
@@ -110,6 +138,7 @@ export class AgentDaemon {
     // Register with hub first (needed for assignment check)
     console.log("Registering with AgentMesh hub...");
     const existingState = getAgentState(this.agentName);
+    console.log(`Existing state: ${existingState ? `agentId=${existingState.agentId}` : "none"}`);
 
     const registration = await registerAgent({
       url: this.config.hubUrl,
@@ -118,49 +147,66 @@ export class AgentDaemon {
       agentId: existingState?.agentId || this.agentConfig.agentId,
       agentName: this.agentName,
       model: this.agentConfig.model || this.config.defaults.model,
+      restoreContext: this.shouldRestoreContext,
     });
 
     this.agentId = registration.agentId;
     this.token = registration.token;
 
-    console.log(`Registered as: ${this.agentId}`);
+    if (registration.status === "re-registered") {
+      console.log(`Re-registered as: ${this.agentId}`);
+      if (registration.context && Object.keys(registration.context).length > 0) {
+        this.serverContext = registration.context;
+        console.log(`Server context restored: ${Object.keys(registration.context).join(", ")}`);
+      }
+    } else {
+      console.log(`Registered as: ${this.agentId}`);
+    }
 
     // Check assignments and auto-setup workdir if needed (before creating tmux session)
     await this.checkAssignments();
 
-    // Check if session already exists
-    const sessionName = getSessionName(this.agentName);
-    const sessionAlreadyExists = sessionExists(sessionName);
-
-    // Create tmux session if it doesn't exist
-    if (!sessionAlreadyExists) {
-      console.log(`Creating tmux session: ${sessionName}`);
-
-      // Include runner env vars (e.g., OPENCODE_MODEL) at session creation
-      const created = createSession(
-        this.agentName,
-        this.agentConfig.command,
-        this.agentConfig.workdir,
-        this.runnerConfig.env, // Apply model env at process start
-      );
-
-      if (!created) {
-        throw new Error("Failed to create tmux session");
-      }
+    // Choose runtime mode: sandbox > serve > tmux
+    if (this.sandboxMode) {
+      await this.startSandboxMode();
+    } else if (this.serveMode) {
+      await this.startServeMode();
     } else {
-      console.log(`Reconnecting to existing session: ${sessionName}`);
-      // Update environment for existing session
-      updateSessionEnvironment(this.agentName, this.runnerConfig.env);
-    }
+      // Check if session already exists
+      const sessionName = getSessionName(this.agentName);
+      const sessionAlreadyExists = sessionExists(sessionName);
+
+      // Create tmux session if it doesn't exist
+      if (!sessionAlreadyExists) {
+        console.log(`Creating tmux session: ${sessionName}`);
+
+        // Include runner env vars (e.g., OPENCODE_MODEL) at session creation
+        const created = createSession(
+          this.agentName,
+          this.agentConfig.command,
+          this.agentConfig.workdir,
+          this.runnerConfig.env, // Apply model env at process start
+        );
+
+        if (!created) {
+          throw new Error("Failed to create tmux session");
+        }
+      } else {
+        console.log(`Reconnecting to existing session: ${sessionName}`);
+        // Update environment for existing session
+        updateSessionEnvironment(this.agentName, this.runnerConfig.env);
+      }
 
-    // Inject environment variables into tmux session
-    console.log("Injecting environment variables...");
-    updateSessionEnvironment(this.agentName, {
-      AGENT_TOKEN: this.token,
-      AGENTMESH_AGENT_ID: this.agentId,
-    });
+      // Inject environment variables into tmux session
+      console.log("Injecting environment variables...");
+      updateSessionEnvironment(this.agentName, {
+        AGENT_TOKEN: this.token,
+        AGENTMESH_AGENT_ID: this.agentId,
+      });
+    }
 
     // Save state including runtime model info
+    const sessionName = this.serveMode ? `serve:${this.servePort}` : getSessionName(this.agentName);
     addAgentToState({
       name: this.agentName,
       agentId: this.agentId,
@@ -211,6 +257,7 @@ export class AgentDaemon {
             url: `${wsUrl}/ws/v1`,
             token: newToken,
             onMessage: (event) => {
+              console.log(`[WS] Received event: ${event.type}`);
               handleWebSocketEvent(this.agentName, event);
             },
             onConnect: () => {
@@ -237,7 +284,11 @@ export class AgentDaemon {
       url: `${wsUrl}/ws/v1`,
       token: this.token,
       onMessage: (event) => {
-        handleWebSocketEvent(this.agentName, event);
+        console.log(`[WS] Received event: ${event.type}`);
+        handleWebSocketEvent(this.agentName, event, {
+          hubUrl: this.config.hubUrl,
+          token: this.token ?? undefined,
+        });
       },
       onConnect: () => {
         console.log("WebSocket connected");
@@ -316,16 +367,156 @@ Nudge agent:
       this.ws = null;
     }
 
-    // Destroy tmux session
-    destroySession(this.agentName);
+    // Stop sandbox, serve process, or destroy tmux session
+    if (this.sandboxMode && this.sandbox) {
+      console.log("Stopping sandbox container...");
+      await this.sandbox.destroy();
+      this.sandbox = null;
+    } else if (this.serveMode && this.serveProcess) {
+      console.log("Stopping opencode serve...");
+      this.serveProcess.kill("SIGTERM");
+      this.serveProcess = null;
+    } else {
+      destroySession(this.agentName);
+    }
 
-    // Remove from state
-    removeAgentFromState(this.agentName);
+    // Update state to mark as stopped but preserve agentId for next restart
+    updateAgentInState(this.agentName, {
+      pid: 0,
+      tmuxSession: "",
+      startedAt: "",
+      token: undefined,
+    });
 
     console.log("Agent stopped.");
     process.exit(0);
   }
 
+  /**
+   * Starts opencode serve mode (for Integration Service)
+   * Replaces tmux with a direct HTTP server
+   */
+  private async startServeMode(): Promise<void> {
+    console.log(`Starting opencode serve mode on port ${this.servePort}...`);
+
+    const workdir = this.agentConfig.workdir || process.cwd();
+
+    // Build environment for opencode serve
+    const env: Record<string, string> = {
+      ...process.env,
+      ...this.runnerConfig.env,
+      AGENT_TOKEN: this.token!,
+      AGENTMESH_AGENT_ID: this.agentId!,
+    } as Record<string, string>;
+
+    // Spawn opencode serve as a child process
+    this.serveProcess = spawn(
+      "opencode",
+      ["serve", "--port", String(this.servePort), "--hostname", "0.0.0.0"],
+      {
+        cwd: workdir,
+        env,
+        stdio: ["ignore", "inherit", "inherit"],
+      },
+    );
+
+    // Handle process exit
+    this.serveProcess.on("exit", (code, signal) => {
+      console.error(`opencode serve exited with code ${code}, signal ${signal}`);
+      if (this.isRunning) {
+        console.log("Restarting opencode serve in 5 seconds...");
+        setTimeout(() => {
+          if (this.isRunning) {
+            this.startServeMode().catch(console.error);
+          }
+        }, 5000);
+      }
+    });
+
+    this.serveProcess.on("error", (error) => {
+      console.error("Failed to start opencode serve:", error);
+    });
+
+    // Wait a moment for the server to start
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+
+    console.log(`opencode serve started on http://0.0.0.0:${this.servePort}`);
+  }
+
+  /**
+   * Starts agent in Docker sandbox mode
+   * Provides filesystem isolation with only workspace mounted
+   */
+  private async startSandboxMode(): Promise<void> {
+    console.log("Starting in Docker sandbox mode...");
+
+    // Check Docker availability
+    if (!DockerSandbox.checkDockerAvailable()) {
+      throw new Error(
+        "Docker is not available. Install Docker or use --sandbox host to run on host.",
+      );
+    }
+
+    const workdir = this.agentConfig.workdir || process.cwd();
+
+    // Check for existing sandbox container
+    const existingContainer = DockerSandbox.findExisting(this.agentName);
+    if (existingContainer) {
+      console.log(`Found existing sandbox container: ${existingContainer}`);
+      console.log("Stop it with: agentmesh stop " + this.agentName);
+      throw new Error("Sandbox container already exists");
+    }
+
+    // Create sandbox configuration
+    this.sandbox = new DockerSandbox({
+      agentName: this.agentName,
+      image: this.sandboxImage,
+      workspacePath: workdir,
+      cpuLimit: this.sandboxCpu,
+      memoryLimit: this.sandboxMemory,
+      env: {
+        ...this.runnerConfig.env,
+        AGENT_TOKEN: this.token!,
+        AGENTMESH_AGENT_ID: this.agentId!,
+      },
+      serveMode: this.serveMode,
+      servePort: this.servePort,
+      networkMode: "bridge",
+    });
+
+    // Validate mount policy (will throw if denied)
+    this.sandbox.validateMountPolicy();
+
+    // Pull image if needed
+    await this.sandbox.pullImage();
+
+    // Start container
+    await this.sandbox.start();
+
+    console.log(`
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🐳 SANDBOX MODE ACTIVE
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Container: ${this.sandbox.getContainerName()}
+Image:     ${this.sandboxImage}
+Workspace: ${workdir} -> /workspace
+CPU:       ${this.sandboxCpu} core(s)
+Memory:    ${this.sandboxMemory}
+
+The agent is running in an isolated Docker container.
+Only the workspace directory is accessible.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`);
+
+    // Start opencode in the container
+    if (!this.serveMode) {
+      console.log("Starting opencode in sandbox container...");
+      await this.sandbox.spawnOpencode();
+    }
+  }
+
   /**
    * Saves the current agent context to disk
    */

package/src/core/injector.ts

@@ -1,3 +1,5 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { formatHandoffContextSummary, parseHandoffContext } from "../context/handoff.js";
 import type { AgentContext } from "../context/schema.js";
 import type { InboxItem } from "./registry.js";
@@ -65,6 +67,85 @@ You can now proceed with your work.`;
   sendKeys(agentName, message);
 }
 
+export interface EventContext {
+  hubUrl?: string;
+  token?: string;
+}
+
+interface SlackFile {
+  name: string;
+  type: string;
+  url: string;
+  permalink: string;
+  base64?: string;
+  mediaType?: string;
+}
+
+export function injectSlackMessage(
+  agentName: string,
+  event: WebSocketEvent,
+  context?: EventContext,
+): void {
+  const user = (event.user as string) || "unknown";
+  const channel = (event.channel as string) || "unknown";
+  const text = (event.text as string) || "";
+  const files = (event.files as SlackFile[] | undefined) || [];
+
+  // Build message with file info
+  let message = `[Slack from ${user} in ${channel}] ${text}`;
+
+  if (files.length > 0) {
+    const savedImages: string[] = [];
+    const otherFiles: string[] = [];
+
+    // Save images with base64 data to disk
+    const attachmentsDir = join(process.env.HOME || "/tmp", ".agentmesh", "attachments");
+    if (!existsSync(attachmentsDir)) {
+      mkdirSync(attachmentsDir, { recursive: true });
+    }
+
+    for (const f of files) {
+      console.log(
+        `[Injector] File: ${f.name}, type: ${f.type}, mediaType: ${f.mediaType}, has base64: ${!!f.base64}`,
+      );
+      if (f.base64 && (f.mediaType?.startsWith("image/") || f.type?.startsWith("image/"))) {
+        // Save image to disk
+        const timestamp = Date.now();
+        const safeName = f.name.replace(/[^a-zA-Z0-9._-]/g, "_");
+        const filePath = join(attachmentsDir, `${timestamp}-${safeName}`);
+
+        try {
+          writeFileSync(filePath, Buffer.from(f.base64, "base64"));
+          savedImages.push(filePath);
+          console.log(`[Injector] Saved image to: ${filePath}`);
+        } catch (err) {
+          console.error(`[Injector] Failed to save image:`, err);
+          otherFiles.push(`${f.name} (failed to save)`);
+        }
+      } else {
+        // Just reference the URL for non-image files
+        otherFiles.push(`${f.name}: ${f.permalink}`);
+      }
+    }
+
+    // Add instruction to view images - OpenCode needs explicit instruction
+    if (savedImages.length > 0) {
+      message += `\n\nUser attached ${savedImages.length} image(s). Use the Read tool to view them:`;
+      for (const img of savedImages) {
+        message += `\n- ${img}`;
+      }
+    }
+
+    if (otherFiles.length > 0) {
+      message += ` [Other files: ${otherFiles.join(" | ")}]`;
+    }
+  }
+
+  console.log(`[Injector] Sending to tmux: ${message}`);
+  const result = sendKeys(agentName, message);
+  console.log(`[Injector] sendKeys result: ${result}`);
+}
+
 export function injectInboxItems(agentName: string, items: InboxItem[]): void {
   if (items.length === 0) {
     sendKeys(agentName, "[AgentMesh] Your inbox is empty.");
@@ -85,7 +166,11 @@ export function injectInboxItems(agentName: string, items: InboxItem[]): void {
   sendKeys(agentName, message);
 }
 
-export function handleWebSocketEvent(agentName: string, event: WebSocketEvent): void {
+export function handleWebSocketEvent(
+  agentName: string,
+  event: WebSocketEvent,
+  context?: EventContext,
+): void {
   switch (event.type) {
     case "handoff_received":
     case "handoff.received":
@@ -102,6 +187,18 @@ export function handleWebSocketEvent(agentName: string, event: WebSocketEvent):
       injectBlockerResolved(agentName, event);
       break;
 
+    case "slack.message":
+      console.log(`[Injector] Handling slack.message for ${agentName}`);
+      console.log(`[Injector] Event keys: ${Object.keys(event).join(", ")}`);
+      if (event.files) {
+        const files = event.files as Array<{ name: string; base64?: string }>;
+        console.log(
+          `[Injector] Files count: ${files.length}, has base64: ${files.some((f) => !!f.base64)}`,
+        );
+      }
+      injectSlackMessage(agentName, event, context);
+      break;
+
     default:
       // Unknown event type, ignore
       break;

package/src/core/registry.ts

@@ -8,11 +8,17 @@ export interface RegisterOptions {
   agentName: string;
   model: string;
   capabilities?: string[];
+  restoreContext?: boolean;
 }
 
+export type ServerContext = Record<string, Record<string, unknown>>;
+
 export interface RegisterResult {
   agentId: string;
   token: string;
+  status?: "registered" | "re-registered";
+  context?: ServerContext;
+  assignments?: ProjectAssignment[];
 }
 
 export interface InboxItem {
@@ -42,6 +48,7 @@ export async function registerAgent(options: RegisterOptions): Promise<RegisterR
       model: options.model,
       capabilities: options.capabilities || ["coding", "review", "debugging"],
       workspace: options.workspace,
+      restore_context: options.restoreContext ?? true,
     }),
   });
 
@@ -57,7 +64,13 @@ export async function registerAgent(options: RegisterOptions): Promise<RegisterR
     throw new Error("No token in registration response");
   }
 
-  return { agentId, token };
+  return {
+    agentId,
+    token,
+    status: data.status,
+    context: data.context,
+    assignments: data.assignments,
+  };
 }
 
 export async function checkInbox(