@agentmeshhq/agent 0.1.11 → 0.1.12

package/src/cli/migrate.ts

@@ -0,0 +1,210 @@
+import { spawnSync, execSync } from "node:child_process";
+import path from "node:path";
+import pc from "picocolors";
+
+function findProjectRoot(): string {
+  let dir = process.cwd();
+  for (let i = 0; i < 10; i++) {
+    const packageJson = path.join(dir, "package.json");
+    const pnpmWorkspace = path.join(dir, "pnpm-workspace.yaml");
+    try {
+      execSync(`test -f "${packageJson}" && test -f "${pnpmWorkspace}"`, { stdio: "ignore" });
+      return dir;
+    } catch {
+      dir = path.dirname(dir);
+    }
+  }
+  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" }
+    ).trim();
+    return result === "true";
+  } catch {
+    return false;
+  }
+}
+
+function getLocalDbUrl(): string {
+  // Default local stack connection
+  return "postgresql://postgres:postgres@localhost:5432/agentmesh";
+}
+
+export interface MigrateOptions {
+  dev?: boolean;
+  staging?: boolean;
+  generate?: boolean;
+  status?: boolean;
+  rollback?: boolean;
+}
+
+export async function migrate(options: MigrateOptions = {}): Promise<void> {
+  const projectRoot = findProjectRoot();
+
+  if (options.generate) {
+    await generateMigration(projectRoot);
+    return;
+  }
+
+  if (options.status) {
+    await migrationStatus(projectRoot, options);
+    return;
+  }
+
+  if (options.rollback) {
+    console.error(pc.red("Rollback is not supported. Use a new migration to revert changes."));
+    process.exit(1);
+  }
+
+  await runMigrations(projectRoot, options);
+}
+
+async function generateMigration(projectRoot: string): Promise<void> {
+  console.log(pc.cyan("Generating migration from schema changes..."));
+  console.log();
+
+  const result = spawnSync("pnpm", ["--filter", "@agentmesh/hub", "db:generate"], {
+    cwd: projectRoot,
+    stdio: "inherit",
+  });
+
+  if (result.status !== 0) {
+    console.error(pc.red("Migration generation failed"));
+    process.exit(1);
+  }
+
+  console.log();
+  console.log(pc.green("Migration generated successfully!"));
+  console.log(pc.dim("Review the migration in packages/hub/drizzle/"));
+}
+
+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();
+
+  // Check if we can connect
+  if (!env.canConnect) {
+    console.error(pc.red(`Cannot connect to ${env.name}: ${env.reason}`));
+    process.exit(1);
+  }
+
+  const result = spawnSync("pnpm", ["--filter", "@agentmesh/hub", "db:status"], {
+    cwd: projectRoot,
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      DATABASE_URL: env.databaseUrl,
+    },
+  });
+
+  if (result.status !== 0) {
+    console.error(pc.red("Failed to check migration status"));
+    process.exit(1);
+  }
+}
+
+interface EnvironmentConfig {
+  name: string;
+  databaseUrl: string;
+  canConnect: boolean;
+  reason?: string;
+}
+
+function getEnvironmentConfig(options: MigrateOptions): EnvironmentConfig {
+  if (options.dev) {
+    // Dev environment uses cloud database via environment variable
+    const devUrl = process.env.AGENTMESH_DEV_DATABASE_URL;
+    if (!devUrl) {
+      return {
+        name: "dev (agentmeshhq.dev)",
+        databaseUrl: "",
+        canConnect: false,
+        reason: "AGENTMESH_DEV_DATABASE_URL environment variable not set",
+      };
+    }
+    return {
+      name: "dev (agentmeshhq.dev)",
+      databaseUrl: devUrl,
+      canConnect: true,
+    };
+  }
+
+  if (options.staging) {
+    const stagingUrl = process.env.AGENTMESH_STAGING_DATABASE_URL;
+    if (!stagingUrl) {
+      return {
+        name: "staging",
+        databaseUrl: "",
+        canConnect: false,
+        reason: "AGENTMESH_STAGING_DATABASE_URL environment variable not set",
+      };
+    }
+    return {
+      name: "staging",
+      databaseUrl: stagingUrl,
+      canConnect: true,
+    };
+  }
+
+  // Default: local stack
+  const localRunning = isLocalStackRunning();
+  if (!localRunning) {
+    return {
+      name: "local",
+      databaseUrl: getLocalDbUrl(),
+      canConnect: false,
+      reason: "Local stack is not running. Start it with: agentmesh local up",
+    };
+  }
+
+  return {
+    name: "local",
+    databaseUrl: getLocalDbUrl(),
+    canConnect: true,
+  };
+}
+
+async function runMigrations(projectRoot: string, options: MigrateOptions): Promise<void> {
+  const env = getEnvironmentConfig(options);
+
+  console.log(pc.cyan(`Running migrations against ${env.name}...`));
+  console.log();
+
+  if (!env.canConnect) {
+    console.error(pc.red(`Cannot connect to ${env.name}: ${env.reason}`));
+    process.exit(1);
+  }
+
+  // Safety confirmation for non-local environments
+  if (options.dev || options.staging) {
+    console.log(pc.yellow(`WARNING: You are about to run migrations against ${env.name}`));
+    console.log(pc.yellow("This will modify the database schema."));
+    console.log();
+    console.log(pc.dim("Press Ctrl+C to cancel, or wait 5 seconds to continue..."));
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+    console.log();
+  }
+
+  const result = spawnSync("pnpm", ["--filter", "@agentmesh/hub", "db:migrate"], {
+    cwd: projectRoot,
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      DATABASE_URL: env.databaseUrl,
+    },
+  });
+
+  if (result.status !== 0) {
+    console.error(pc.red("Migration failed"));
+    process.exit(1);
+  }
+
+  console.log();
+  console.log(pc.green(`Migrations applied successfully to ${env.name}!`));
+}

package/src/cli/slack.ts

@@ -0,0 +1,69 @@
+import { loadConfig, getAgentState } from "../config/loader.js";
+import pc from "picocolors";
+
+export async function slack(
+  action: string,
+  channel: string | undefined,
+  message: string | undefined,
+  options: { name?: string }
+): Promise<void> {
+  const config = loadConfig();
+
+  if (!config) {
+    console.log(pc.red("No config found. Run 'agentmesh init' first."));
+    process.exit(1);
+  }
+
+  if (action === "respond" || action === "reply") {
+    if (!channel) {
+      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>"));
+      process.exit(1);
+    }
+
+    // Get token from agent state or config
+    const agentName = options.name || "concierge";
+    const agentState = getAgentState(agentName);
+    const token = agentState?.token;
+
+    if (!token) {
+      console.log(pc.red(`No token found for agent "${agentName}". Is the agent running?`));
+      process.exit(1);
+    }
+
+    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 }),
+        }
+      );
+
+      if (response.ok) {
+        console.log(pc.green(`Message sent to Slack channel ${channel}`));
+      } else {
+        const error = await response.text();
+        console.log(pc.red(`Failed to send: ${error}`));
+        process.exit(1);
+      }
+    } catch (error) {
+      console.log(pc.red(`Failed to send: ${(error as Error).message}`));
+      process.exit(1);
+    }
+  } else {
+    console.log(pc.yellow("Usage:"));
+    console.log("  agentmesh slack respond <channel> <message>  - Send a message to Slack");
+    console.log("");
+    console.log(pc.dim("Examples:"));
+    console.log('  agentmesh slack respond C0123456 "Hello from AgentMesh!"');
+  }
+}

package/src/cli/start.ts

@@ -14,6 +14,10 @@ export interface StartOptions {
   foreground?: boolean;
   noContext?: boolean;
   autoSetup?: boolean;
+  /** Run opencode serve instead of tmux TUI (for Integration Service) */
+  serve?: boolean;
+  /** Port for opencode serve (default: 3001) */
+  servePort?: number;
 }
 
 export async function start(options: StartOptions): Promise<void> {
@@ -70,6 +74,10 @@ export async function start(options: StartOptions): Promise<void> {
   if (options.model) args.push("--model", options.model);
   if (options.noContext) args.push("--no-context");
   if (options.autoSetup) args.push("--auto-setup");
+  if (options.serve) {
+    args.push("--serve");
+    if (options.servePort) args.push("--serve-port", String(options.servePort));
+  }
 
   // Spawn detached background process
   const child = spawn("node", [cliPath, ...args], {

package/src/cli/test.ts

@@ -0,0 +1,141 @@
+import { spawnSync, execSync } from "node:child_process";
+import path from "node:path";
+import pc from "picocolors";
+
+function findProjectRoot(): string {
+  let dir = process.cwd();
+  for (let i = 0; i < 10; i++) {
+    const packageJson = path.join(dir, "package.json");
+    const pnpmWorkspace = path.join(dir, "pnpm-workspace.yaml");
+    try {
+      execSync(`test -f "${packageJson}" && test -f "${pnpmWorkspace}"`, { stdio: "ignore" });
+      return dir;
+    } catch {
+      dir = path.dirname(dir);
+    }
+  }
+  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" }
+    ).trim();
+    return result === "true";
+  } catch {
+    return false;
+  }
+}
+
+export interface TestOptions {
+  package?: string;
+  e2e?: boolean;
+  watch?: boolean;
+  coverage?: boolean;
+  updateSnapshots?: boolean;
+}
+
+export async function test(options: TestOptions = {}): Promise<void> {
+  const projectRoot = findProjectRoot();
+
+  if (options.e2e) {
+    await runE2ETests(projectRoot, options);
+  } else {
+    await runUnitTests(projectRoot, options);
+  }
+}
+
+async function runUnitTests(projectRoot: string, options: TestOptions): Promise<void> {
+  console.log(pc.cyan("Running unit tests..."));
+
+  // Check if local stack is running for integration tests
+  const localStackUp = isLocalStackRunning();
+  if (localStackUp) {
+    console.log(pc.dim("Local stack detected - integration tests will use local services"));
+  }
+
+  const args = ["pnpm"];
+
+  if (options.package) {
+    args.push("--filter", options.package);
+  }
+
+  args.push("test");
+
+  if (options.watch) {
+    args.push("--", "--watch");
+  }
+
+  if (options.coverage) {
+    args.push("--", "--coverage");
+  }
+
+  if (options.updateSnapshots) {
+    args.push("--", "-u");
+  }
+
+  console.log();
+
+  const result = spawnSync(args[0], args.slice(1), {
+    cwd: projectRoot,
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      // If local stack is running, use it for tests
+      ...(localStackUp && {
+        DATABASE_URL: "postgresql://postgres:postgres@localhost:5432/agentmesh",
+        REDIS_URL: "redis://localhost:6380/0",
+      }),
+    },
+  });
+
+  if (result.status !== 0) {
+    console.error(pc.red("Tests failed"));
+    process.exit(1);
+  }
+
+  console.log();
+  console.log(pc.green("All tests passed!"));
+}
+
+async function runE2ETests(projectRoot: string, options: TestOptions): Promise<void> {
+  console.log(pc.cyan("Running E2E tests..."));
+
+  // E2E tests require the local stack to be running
+  const localStackUp = isLocalStackRunning();
+  if (!localStackUp) {
+    console.log(pc.yellow("Warning: Local stack is not running."));
+    console.log(pc.dim("Start it with: agentmesh local up"));
+    console.log();
+  }
+
+  const args = ["pnpm", "--filter", "@agentmesh/admin", "test:e2e"];
+
+  if (options.updateSnapshots) {
+    args.push("--", "--update-snapshots");
+  }
+
+  console.log();
+
+  const result = spawnSync(args[0], args.slice(1), {
+    cwd: projectRoot,
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      // Point to local stack if running
+      ...(localStackUp && {
+        PLAYWRIGHT_BASE_URL: "http://localhost:3000",
+      }),
+    },
+  });
+
+  if (result.status !== 0) {
+    console.error(pc.red("E2E tests failed"));
+    process.exit(1);
+  }
+
+  console.log();
+  console.log(pc.green("E2E tests passed!"));
+}

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 {
@@ -55,6 +59,9 @@ export class AgentDaemon {
   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();
@@ -85,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({
@@ -110,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,
@@ -128,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,
@@ -211,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: () => {
@@ -237,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");
@@ -316,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
    */