@agentmeshhq/agent 0.1.10 → 0.1.12

package/src/cli/local.ts

@@ -0,0 +1,174 @@
+import { spawn, execSync, spawnSync } from "node:child_process";
+import path from "node:path";
+import pc from "picocolors";
+
+const COMPOSE_FILE = "docker/docker-compose.local.yml";
+
+interface LocalStackPorts {
+  postgres: number;
+  valkey: number;
+  hub: number;
+  admin: number;
+  nginx: number;
+}
+
+function findProjectRoot(): string {
+  // Try to find the project root by looking for docker-compose files
+  let dir = process.cwd();
+  for (let i = 0; i < 10; i++) {
+    const composePath = path.join(dir, COMPOSE_FILE);
+    try {
+      execSync(`test -f "${composePath}"`, { 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 getContainerStatus(containerName: string): { running: boolean; healthy: boolean; port?: string } {
+  try {
+    const result = execSync(
+      `docker inspect --format='{{.State.Running}}:{{.State.Health.Status}}' ${containerName} 2>/dev/null`,
+      { encoding: "utf-8" }
+    ).trim();
+    const [running, health] = result.split(":");
+    return {
+      running: running === "true",
+      healthy: health === "healthy",
+    };
+  } catch {
+    return { running: false, healthy: false };
+  }
+}
+
+function getContainerPort(containerName: string, internalPort: number): string | null {
+  try {
+    const result = execSync(
+      `docker port ${containerName} ${internalPort} 2>/dev/null | head -1`,
+      { encoding: "utf-8" }
+    ).trim();
+    // Format: 0.0.0.0:5432 -> 5432
+    const match = result.match(/:(\d+)$/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+
+export async function localUp(options: { detach?: boolean } = {}): Promise<void> {
+  const projectRoot = findProjectRoot();
+  const composePath = path.join(projectRoot, COMPOSE_FILE);
+
+  console.log(pc.cyan("Starting AgentMesh local development stack..."));
+  console.log();
+
+  const args = ["compose", "-f", composePath, "up"];
+  if (options.detach !== false) {
+    args.push("-d");
+  }
+  args.push("--build");
+
+  const result = spawnSync("docker", args, {
+    cwd: projectRoot,
+    stdio: "inherit",
+  });
+
+  if (result.status !== 0) {
+    console.error(pc.red("Failed to start local stack"));
+    process.exit(1);
+  }
+
+  if (options.detach !== false) {
+    console.log();
+    console.log(pc.green("Local stack started successfully!"));
+    console.log();
+    await localStatus();
+  }
+}
+
+export async function localDown(): Promise<void> {
+  const projectRoot = findProjectRoot();
+  const composePath = path.join(projectRoot, COMPOSE_FILE);
+
+  console.log(pc.cyan("Stopping AgentMesh local development stack..."));
+
+  const result = spawnSync("docker", ["compose", "-f", composePath, "down"], {
+    cwd: projectRoot,
+    stdio: "inherit",
+  });
+
+  if (result.status !== 0) {
+    console.error(pc.red("Failed to stop local stack"));
+    process.exit(1);
+  }
+
+  console.log(pc.green("Local stack stopped."));
+}
+
+export async function localStatus(): Promise<void> {
+  const services = [
+    { name: "postgres", container: "agentmesh_postgres", port: 5432 },
+    { name: "valkey", container: "agentmesh_valkey", port: 6379 },
+    { name: "hub-api", container: "agentmesh_hub_api", port: 3777 },
+    { name: "hub-worker", container: "agentmesh_hub_worker", port: null },
+    { name: "admin", container: "agentmesh_admin", port: 3778 },
+    { name: "nginx", container: "agentmesh_nginx", port: 80 },
+  ];
+
+  console.log(pc.bold("AgentMesh Local Stack Status"));
+  console.log();
+  console.log(pc.dim("Service".padEnd(15) + "Status".padEnd(12) + "Health".padEnd(10) + "Port"));
+  console.log(pc.dim("-".repeat(50)));
+
+  let anyRunning = false;
+
+  for (const service of services) {
+    const status = getContainerStatus(service.container);
+    const port = service.port ? getContainerPort(service.container, service.port) : null;
+
+    const statusText = status.running ? pc.green("running") : pc.dim("stopped");
+    const healthText = status.running
+      ? status.healthy
+        ? pc.green("healthy")
+        : pc.yellow("starting")
+      : pc.dim("-");
+    const portText = port ? pc.cyan(port) : pc.dim("-");
+
+    console.log(
+      `${service.name.padEnd(15)}${statusText.padEnd(20)}${healthText.padEnd(18)}${portText}`
+    );
+
+    if (status.running) anyRunning = true;
+  }
+
+  console.log();
+
+  if (anyRunning) {
+    const nginxPort = getContainerPort("agentmesh_nginx", 80) || "3000";
+    console.log(pc.bold("Access:"));
+    console.log(`  Admin UI:  ${pc.cyan(`http://localhost:${nginxPort}/admin`)}`);
+    console.log(`  API:       ${pc.cyan(`http://localhost:${nginxPort}/api`)}`);
+    console.log();
+    console.log(pc.bold("Commands:"));
+    console.log(`  Stop:      ${pc.cyan("agentmesh local down")}`);
+    console.log(`  Logs:      ${pc.cyan("docker compose -f docker/docker-compose.local.yml logs -f")}`);
+  } else {
+    console.log(pc.dim("No services running. Start with: agentmesh local up"));
+  }
+}
+
+export async function localLogs(options: { follow?: boolean; service?: string } = {}): Promise<void> {
+  const projectRoot = findProjectRoot();
+  const composePath = path.join(projectRoot, COMPOSE_FILE);
+
+  const args = ["compose", "-f", composePath, "logs"];
+  if (options.follow) args.push("-f");
+  if (options.service) args.push(options.service);
+
+  spawn("docker", args, {
+    cwd: projectRoot,
+    stdio: "inherit",
+  });
+}

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/config/schema.ts

@@ -39,6 +39,8 @@ export interface AgentState {
   tmuxSession: string;
   startedAt: string;
   token?: string;
+  workdir?: string;
+  assignedProject?: string;
   /** The effective runtime model (resolved from CLI > agent > defaults) */
   runtimeModel?: string;
   /** The runner type (opencode, claude, custom) */