@agentmeshhq/agent 0.1.10 → 0.1.12

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";
@@ -40,6 +40,10 @@ 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;
 }
 
 export class AgentDaemon {
@@ -52,8 +56,12 @@ export class AgentDaemon {
   private token: string | null = null;
   private agentId: string | null = null;
   private isRunning = false;
+  private assignedProject: string | undefined;
   private shouldRestoreContext: boolean;
   private autoSetup: boolean;
+  private serveMode: boolean;
+  private servePort: number;
+  private serveProcess: ChildProcess | null = null;
 
   constructor(options: DaemonOptions) {
     const config = loadConfig();
@@ -84,6 +92,8 @@ export class AgentDaemon {
     if (options.model) agentConfig.model = options.model;
 
     this.agentConfig = agentConfig;
+    this.serveMode = options.serve === true;
+    this.servePort = options.servePort || 3001;
 
     // Build runner configuration with model resolution
     this.runnerConfig = buildRunnerConfig({
@@ -109,6 +119,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,
@@ -127,39 +138,45 @@ export class AgentDaemon {
     // 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");
-      }
+    // Serve mode: start opencode serve instead of tmux
+    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,
@@ -167,6 +184,8 @@ export class AgentDaemon {
       tmuxSession: sessionName,
       startedAt: new Date().toISOString(),
       token: this.token,
+      workdir: this.agentConfig.workdir,
+      assignedProject: this.assignedProject,
       runtimeModel: this.runnerConfig.model,
       runnerType: this.runnerConfig.type,
     });
@@ -208,6 +227,7 @@ export class AgentDaemon {
             url: `${wsUrl}/ws/v1`,
             token: newToken,
             onMessage: (event) => {
+              console.log(`[WS] Received event: ${event.type}`);
               handleWebSocketEvent(this.agentName, event);
             },
             onConnect: () => {
@@ -234,7 +254,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");
@@ -313,16 +337,78 @@ Nudge agent:
       this.ws = null;
     }
 
-    // Destroy tmux session
-    destroySession(this.agentName);
+    // Stop serve process or destroy tmux session
+    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}`);
+  }
+
   /**
    * Saves the current agent context to disk
    */
@@ -375,6 +461,8 @@ Nudge agent:
         console.log(`  - ${assignment.project.name} (${assignment.role})${repoInfo}${workdirInfo}`);
       }
 
+      this.assignedProject = assignments[0]?.project.name;
+
       // If no CLI workdir specified, try to use project.workdir from HQ
       if (!this.agentConfig.workdir) {
         const assignmentWithWorkdir = assignments.find((a) => a.project.workdir);

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/tmux.ts

@@ -1,4 +1,4 @@
-import { type ChildProcess, execSync, spawn } from "node:child_process";
+import { type ChildProcess, execFileSync, execSync, spawn } from "node:child_process";
 
 const SESSION_PREFIX = "agentmesh-";
 
@@ -56,7 +56,8 @@ export function createSession(
 
     const fullCommand = `${envPrefix}${command}`;
 
-    const args = ["new-session", "-d", "-s", sessionName];
+    // Set reasonable terminal size for TUI applications
+    const args = ["new-session", "-d", "-s", sessionName, "-x", "200", "-y", "50"];
 
     if (workdir) {
       args.push("-c", workdir);
@@ -64,7 +65,7 @@ export function createSession(
 
     args.push(fullCommand);
 
-    execSync(`tmux ${args.join(" ")}`);
+    execFileSync("tmux", args);
 
     // Also set session environment for any subsequent processes/refreshes
     if (env) {
@@ -82,7 +83,7 @@ export function setSessionEnvironment(sessionName: string, env: SessionEnv): boo
   try {
     for (const [key, value] of Object.entries(env)) {
       if (value !== undefined && value !== "") {
-        execSync(`tmux set-environment -t "${sessionName}" ${key} "${value}"`);
+        execFileSync("tmux", ["set-environment", "-t", sessionName, key, value]);
       }
     }
     return true;
@@ -128,16 +129,13 @@ export function sendKeys(agentName: string, message: string): boolean {
   }
 
   try {
-    // Escape special characters for tmux
-    const escapedMessage = message
-      .replace(/\\/g, "\\\\")
-      .replace(/"/g, '\\"')
-      .replace(/\$/g, "\\$")
-      .replace(/`/g, "\\`");
-
-    // Send the message, then press Enter separately to submit to the AI
-    execSync(`tmux send-keys -t "${sessionName}" "${escapedMessage}"`);
-    execSync(`tmux send-keys -t "${sessionName}" Enter`);
+    // 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}`);