@agentmeshhq/agent 0.1.11 → 0.1.12

package/src/cli/deploy.ts

@@ -0,0 +1,153 @@
+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 scriptsDir = path.join(dir, "scripts");
+    const buildScript = path.join(scriptsDir, "build.sh");
+    try {
+      execSync(`test -f "${buildScript}"`, { 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.");
+}
+
+export type DeployEnvironment = "dev" | "staging" | "prod";
+
+export interface DeployOptions {
+  environment: DeployEnvironment;
+  skipBuild?: boolean;
+  skipPush?: boolean;
+  skipTests?: boolean;
+  dryRun?: boolean;
+}
+
+export async function deploy(options: DeployOptions): Promise<void> {
+  const projectRoot = findProjectRoot();
+
+  console.log(pc.cyan(`Deploying to ${options.environment}...`));
+  console.log();
+
+  // Safety checks
+  if (options.environment === "prod") {
+    console.log(pc.red("WARNING: You are about to deploy to PRODUCTION"));
+    console.log(pc.yellow("Make sure all tests pass and staging deployment is verified."));
+    console.log();
+    console.log(pc.dim("Press Ctrl+C to cancel, or wait 10 seconds to continue..."));
+    await new Promise((resolve) => setTimeout(resolve, 10000));
+    console.log();
+  }
+
+  if (options.dryRun) {
+    console.log(pc.yellow("[DRY RUN] No actual deployment will be performed"));
+    console.log();
+  }
+
+  // Step 1: Build
+  if (!options.skipBuild) {
+    console.log(pc.bold("Step 1: Building..."));
+    
+    const buildScript = path.join(projectRoot, "scripts", "build.sh");
+    const buildArgs = [buildScript, options.environment];
+    
+    if (options.dryRun) {
+      console.log(pc.dim(`Would run: ${buildArgs.join(" ")}`));
+    } else {
+      const result = spawnSync("bash", buildArgs, {
+        cwd: projectRoot,
+        stdio: "inherit",
+      });
+
+      if (result.status !== 0) {
+        console.error(pc.red("Build failed. Aborting deployment."));
+        process.exit(1);
+      }
+    }
+    console.log();
+  } else {
+    console.log(pc.dim("Skipping build (--skip-build)"));
+  }
+
+  // Step 2: Push to registry
+  if (!options.skipPush) {
+    console.log(pc.bold("Step 2: Pushing to registry..."));
+    
+    // Get the image tag from git commit
+    let tag: string;
+    try {
+      const commit = execSync("git rev-parse --short HEAD", { encoding: "utf-8" }).trim();
+      tag = `${options.environment}-${commit}`;
+    } catch {
+      console.error(pc.red("Failed to get git commit. Are you in a git repository?"));
+      process.exit(1);
+    }
+
+    const pushScript = path.join(projectRoot, "scripts", "push.sh");
+    const pushArgs = [pushScript, tag];
+
+    if (options.dryRun) {
+      console.log(pc.dim(`Would run: ${pushArgs.join(" ")}`));
+    } else {
+      const result = spawnSync("bash", pushArgs, {
+        cwd: projectRoot,
+        stdio: "inherit",
+      });
+
+      if (result.status !== 0) {
+        console.error(pc.red("Push failed. Aborting deployment."));
+        process.exit(1);
+      }
+    }
+    console.log();
+  } else {
+    console.log(pc.dim("Skipping push (--skip-push)"));
+  }
+
+  // Step 3: Deploy to server
+  console.log(pc.bold("Step 3: Deploying to server..."));
+
+  let tag: string;
+  try {
+    const commit = execSync("git rev-parse --short HEAD", { encoding: "utf-8" }).trim();
+    tag = `${options.environment}-${commit}`;
+  } catch {
+    console.error(pc.red("Failed to get git commit."));
+    process.exit(1);
+  }
+
+  const deployScript = path.join(projectRoot, "scripts", "deploy.sh");
+  const deployArgs = [deployScript, options.environment, tag];
+
+  if (options.dryRun) {
+    console.log(pc.dim(`Would run: ${deployArgs.join(" ")}`));
+  } else {
+    const result = spawnSync("bash", deployArgs, {
+      cwd: projectRoot,
+      stdio: "inherit",
+    });
+
+    if (result.status !== 0) {
+      console.error(pc.red("Deployment failed."));
+      process.exit(1);
+    }
+  }
+
+  console.log();
+  console.log(pc.green(`Successfully deployed to ${options.environment}!`));
+
+  // Show access info
+  const urls: Record<DeployEnvironment, string> = {
+    dev: "https://agentmeshhq.dev",
+    staging: "https://staging.agentmesh.ai",
+    prod: "https://agentmesh.ai",
+  };
+
+  console.log();
+  console.log(pc.bold("Access:"));
+  console.log(`  URL: ${pc.cyan(urls[options.environment])}`);
+}

package/src/cli/index.ts

@@ -4,16 +4,22 @@ import { createRequire } from "node:module";
 import { Command } from "commander";
 import pc from "picocolors";
 import { attach } from "./attach.js";
+import { build } from "./build.js";
 import { configCmd } from "./config.js";
 import { contextCmd } from "./context.js";
+import { deploy } from "./deploy.js";
 import { init } from "./init.js";
 import { list } from "./list.js";
+import { localUp, localDown, localStatus, localLogs } from "./local.js";
 import { logs } from "./logs.js";
+import { migrate } from "./migrate.js";
 import { nudge } from "./nudge.js";
 import { restart } from "./restart.js";
+import { slack } from "./slack.js";
 import { start } from "./start.js";
 import { status } from "./status.js";
 import { stop } from "./stop.js";
+import { test } from "./test.js";
 import { token } from "./token.js";
 import { whoami } from "./whoami.js";
 
@@ -49,8 +55,14 @@ program
   .option("-f, --foreground", "Run in foreground (blocking)")
   .option("--no-context", "Start fresh without restoring previous context")
   .option("--auto-setup", "Auto-clone repository for project assignments")
+  .option("--serve", "Run opencode serve instead of tmux TUI (for Integration Service)")
+  .option("--serve-port <port>", "Port for opencode serve (default: 3001)", "3001")
   .action(async (options) => {
     try {
+      // Parse serve port as number
+      if (options.servePort) {
+        options.servePort = parseInt(options.servePort, 10);
+      }
       await start(options);
     } catch (error) {
       console.error(pc.red((error as Error).message));
@@ -209,4 +221,148 @@ program
     }
   });
 
+program
+  .command("slack")
+  .description("Interact with Slack")
+  .argument("[action]", "Action: respond")
+  .argument("[channel]", "Slack channel ID")
+  .argument("[message]", "Message to send")
+  .option("-n, --name <name>", "Agent name (default: concierge)")
+  .action(async (action, channel, message, options) => {
+    try {
+      await slack(action || "help", channel, message, options);
+    } catch (error) {
+      console.error(pc.red((error as Error).message));
+      process.exit(1);
+    }
+  });
+
+// Local development stack commands
+const localCmd = program
+  .command("local")
+  .description("Manage local development stack (Postgres, Valkey, Hub)");
+
+localCmd
+  .command("up")
+  .description("Start local development stack")
+  .option("--no-detach", "Run in foreground")
+  .action(async (options) => {
+    try {
+      await localUp({ detach: options.detach });
+    } catch (error) {
+      console.error(pc.red((error as Error).message));
+      process.exit(1);
+    }
+  });
+
+localCmd
+  .command("down")
+  .description("Stop local development stack")
+  .action(async () => {
+    try {
+      await localDown();
+    } catch (error) {
+      console.error(pc.red((error as Error).message));
+      process.exit(1);
+    }
+  });
+
+localCmd
+  .command("status")
+  .description("Show local stack status and ports")
+  .action(async () => {
+    try {
+      await localStatus();
+    } catch (error) {
+      console.error(pc.red((error as Error).message));
+      process.exit(1);
+    }
+  });
+
+localCmd
+  .command("logs")
+  .description("View local stack logs")
+  .option("-f, --follow", "Follow log output")
+  .option("-s, --service <name>", "Specific service to show logs for")
+  .action(async (options) => {
+    try {
+      await localLogs({ follow: options.follow, service: options.service });
+    } catch (error) {
+      console.error(pc.red((error as Error).message));
+      process.exit(1);
+    }
+  });
+
+// Build commands
+program
+  .command("build")
+  .description("Build packages or Docker images")
+  .option("--docker", "Build Docker images instead of packages")
+  .option("-p, --package <name>", "Build specific package")
+  .option("--clean", "Clean build artifacts before building")
+  .action(async (options) => {
+    try {
+      await build(options);
+    } catch (error) {
+      console.error(pc.red((error as Error).message));
+      process.exit(1);
+    }
+  });
+
+// Test commands
+program
+  .command("test")
+  .description("Run tests")
+  .option("-p, --package <name>", "Test specific package")
+  .option("--e2e", "Run E2E tests")
+  .option("-w, --watch", "Watch mode")
+  .option("--coverage", "Generate coverage report")
+  .option("-u, --update-snapshots", "Update test snapshots")
+  .action(async (options) => {
+    try {
+      await test(options);
+    } catch (error) {
+      console.error(pc.red((error as Error).message));
+      process.exit(1);
+    }
+  });
+
+// Migration commands
+program
+  .command("migrate")
+  .description("Run database migrations")
+  .option("--dev", "Run against agentmeshhq.dev")
+  .option("--staging", "Run against staging")
+  .option("--generate", "Generate migration from schema changes")
+  .option("--status", "Show migration status")
+  .action(async (options) => {
+    try {
+      await migrate(options);
+    } catch (error) {
+      console.error(pc.red((error as Error).message));
+      process.exit(1);
+    }
+  });
+
+// Deploy commands
+program
+  .command("deploy")
+  .description("Deploy to environment")
+  .argument("<environment>", "Target environment: dev, staging, prod")
+  .option("--skip-build", "Skip build step")
+  .option("--skip-push", "Skip push to registry")
+  .option("--dry-run", "Show what would be done without executing")
+  .action(async (environment, options) => {
+    try {
+      if (!["dev", "staging", "prod"].includes(environment)) {
+        console.error(pc.red(`Invalid environment: ${environment}. Use: dev, staging, or prod`));
+        process.exit(1);
+      }
+      await deploy({ environment, ...options });
+    } catch (error) {
+      console.error(pc.red((error as Error).message));
+      process.exit(1);
+    }
+  });
+
 program.parse();

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",
+  });
+}