@agentmeshhq/agent 0.1.10 → 0.1.12

package/src/cli/build.ts

@@ -0,0 +1,137 @@
+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.");
+}
+
+export interface BuildOptions {
+  docker?: boolean;
+  package?: string;
+  clean?: boolean;
+}
+
+export async function build(options: BuildOptions = {}): Promise<void> {
+  const projectRoot = findProjectRoot();
+
+  if (options.docker) {
+    await buildDocker(projectRoot, options);
+  } else {
+    await buildPackages(projectRoot, options);
+  }
+}
+
+async function buildPackages(projectRoot: string, options: BuildOptions): Promise<void> {
+  console.log(pc.cyan("Building AgentMesh packages..."));
+  console.log();
+
+  const args = ["pnpm"];
+
+  if (options.package) {
+    args.push("--filter", options.package);
+  }
+
+  if (options.clean) {
+    console.log(pc.dim("Cleaning build artifacts..."));
+    const cleanResult = spawnSync("pnpm", ["-r", "exec", "rm", "-rf", "dist"], {
+      cwd: projectRoot,
+      stdio: "inherit",
+    });
+    if (cleanResult.status !== 0) {
+      console.warn(pc.yellow("Warning: Clean may have partially failed"));
+    }
+    console.log();
+  }
+
+  args.push("build");
+
+  const result = spawnSync(args[0], args.slice(1), {
+    cwd: projectRoot,
+    stdio: "inherit",
+  });
+
+  if (result.status !== 0) {
+    console.error(pc.red("Build failed"));
+    process.exit(1);
+  }
+
+  console.log();
+  console.log(pc.green("Build completed successfully!"));
+}
+
+async function buildDocker(projectRoot: string, options: BuildOptions): Promise<void> {
+  console.log(pc.cyan("Building Docker images..."));
+  console.log();
+
+  // Check if docker is available
+  try {
+    execSync("docker --version", { stdio: "ignore" });
+  } catch {
+    console.error(pc.red("Docker is not installed or not running"));
+    process.exit(1);
+  }
+
+  // Use docker buildx bake for multi-image builds
+  const dockerDir = path.join(projectRoot, "docker");
+  const dockerfilePath = path.join(dockerDir, "Dockerfile");
+
+  try {
+    execSync(`test -f "${dockerfilePath}"`, { stdio: "ignore" });
+  } catch {
+    console.error(pc.red("Dockerfile not found at docker/Dockerfile"));
+    process.exit(1);
+  }
+
+  // Build using docker compose to leverage the existing setup
+  const composePath = path.join(dockerDir, "docker-compose.local.yml");
+
+  const args = ["compose", "-f", composePath, "build"];
+  if (options.package) {
+    // Map package names to service names
+    const serviceMap: Record<string, string> = {
+      "@agentmesh/hub": "hub-api",
+      "@agentmesh/admin": "admin",
+      hub: "hub-api",
+      admin: "admin",
+    };
+    const service = serviceMap[options.package] || options.package;
+    args.push(service);
+  }
+
+  const result = spawnSync("docker", args, {
+    cwd: projectRoot,
+    stdio: "inherit",
+  });
+
+  if (result.status !== 0) {
+    console.error(pc.red("Docker build failed"));
+    process.exit(1);
+  }
+
+  console.log();
+  console.log(pc.green("Docker images built successfully!"));
+
+  // List built images
+  console.log();
+  console.log(pc.bold("Built images:"));
+  const listResult = spawnSync(
+    "docker",
+    ["images", "--filter", "reference=*agentmesh*", "--format", "{{.Repository}}:{{.Tag}}\t{{.Size}}"],
+    { encoding: "utf-8" }
+  );
+  if (listResult.stdout) {
+    console.log(pc.dim(listResult.stdout));
+  }
+}

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

@@ -1,6 +1,6 @@
 import { loadState, loadConfig } from "../config/loader.js";
 import { sessionExists, getSessionName, getSessionInfo } from "../core/tmux.js";
-import { checkInbox } from "../core/registry.js";
+import { checkInbox, fetchAssignments } from "../core/registry.js";
 import pc from "picocolors";
 
 export async function list(): Promise<void> {
@@ -15,9 +15,9 @@ export async function list(): Promise<void> {
 
   console.log(pc.bold("Running Agents:\n"));
   console.log(
-    `${"NAME".padEnd(20)} ${"STATUS".padEnd(10)} ${"SESSION".padEnd(25)} ${"PENDING"}`
+    `${"NAME".padEnd(20)} ${"STATUS".padEnd(10)} ${"SESSION".padEnd(25)} ${"PENDING ID".padEnd(18)} ${"WORKDIR".padEnd(38)} ${"PROJECT"}`
   );
-  console.log("-".repeat(70));
+  console.log("-".repeat(140));
 
   for (const agent of state.agents) {
     const sessionName = getSessionName(agent.name);
@@ -29,7 +29,8 @@ export async function list(): Promise<void> {
       status = pc.red("offline");
     }
 
-    let pending = pc.dim("-");
+    let pendingId = pc.dim("-");
+    let assignedProject = agent.assignedProject || "-";
 
     // Try to check inbox if we have a token
     if (config && agent.token) {
@@ -40,7 +41,17 @@ export async function list(): Promise<void> {
           agent.token
         );
         if (items.length > 0) {
-          pending = pc.yellow(`${items.length} handoff${items.length === 1 ? "" : "s"}`);
+          const firstId = items[0]?.id || "-";
+          pendingId = pc.yellow(items.length === 1 ? firstId : `${firstId} (+${items.length - 1})`);
+        }
+      } catch {
+        // Ignore errors
+      }
+
+      try {
+        const assignments = await fetchAssignments(config.hubUrl, agent.token);
+        if (assignments.length > 0) {
+          assignedProject = assignments.map((a) => a.project.name).join(", ");
         }
       } catch {
         // Ignore errors
@@ -48,9 +59,10 @@ export async function list(): Promise<void> {
     }
 
     const command = info.command ? pc.dim(`(${info.command})`) : "";
+    const workdir = agent.workdir || "-";
 
     console.log(
-      `${agent.name.padEnd(20)} ${status.padEnd(19)} ${sessionName.padEnd(25)} ${pending}`
+      `${agent.name.padEnd(20)} ${status.padEnd(19)} ${sessionName.padEnd(25)} ${pendingId.padEnd(18)} ${workdir.padEnd(38)} ${assignedProject}`
     );
 
     if (command) {