@agentmeshhq/agent 0.1.17 → 0.2.1

package/src/__tests__/watchdog.test.ts

@@ -1,368 +0,0 @@
-import { execSync, spawnSync } from "node:child_process";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import * as tmux from "../core/tmux.js";
-import {
-  checkAgentProgress,
-  cleanupOrphanContainers,
-  detectPermissionPrompt,
-  findOrphanContainers,
-  getLastActivityTime,
-  isProcessRunning,
-  sendNudge,
-  type WatchdogResult,
-} from "../core/watchdog.js";
-
-// Mock child_process
-vi.mock("node:child_process", () => ({
-  execSync: vi.fn(),
-  spawnSync: vi.fn(),
-}));
-
-// Mock tmux module
-vi.mock("../core/tmux.js", () => ({
-  captureSessionOutput: vi.fn(),
-}));
-
-describe("Watchdog Module", () => {
-  beforeEach(() => {
-    vi.resetAllMocks();
-  });
-
-  describe("detectPermissionPrompt", () => {
-    it("should return null when no permission prompt detected", () => {
-      vi.mocked(tmux.captureSessionOutput).mockReturnValue(
-        "Normal output without any prompts\nJust some code being written",
-      );
-
-      const result = detectPermissionPrompt("test-agent");
-      expect(result).toBeNull();
-    });
-
-    it("should detect 'Permission required' prompt", () => {
-      vi.mocked(tmux.captureSessionOutput).mockReturnValue(
-        "Some output\nPermission required\nAllow once | Allow always | Reject",
-      );
-
-      const result = detectPermissionPrompt("test-agent");
-      expect(result).toBe("Permission prompt detected");
-    });
-
-    it("should detect external directory access prompt", () => {
-      vi.mocked(tmux.captureSessionOutput).mockReturnValue(
-        "Access external directory /tmp/some-path\nAllow once | Allow always | Reject",
-      );
-
-      const result = detectPermissionPrompt("test-agent");
-      expect(result).toBe("External directory: /tmp/some-path");
-    });
-
-    it("should detect triangle permission prompt", () => {
-      vi.mocked(tmux.captureSessionOutput).mockReturnValue(
-        "Some output\n△ Permission required\nWaiting for approval",
-      );
-
-      const result = detectPermissionPrompt("test-agent");
-      expect(result).toBe("Permission prompt detected");
-    });
-
-    it("should return null when capture fails", () => {
-      vi.mocked(tmux.captureSessionOutput).mockReturnValue(null);
-
-      const result = detectPermissionPrompt("test-agent");
-      expect(result).toBeNull();
-    });
-
-    it("should return null when capture throws", () => {
-      vi.mocked(tmux.captureSessionOutput).mockImplementation(() => {
-        throw new Error("Session not found");
-      });
-
-      const result = detectPermissionPrompt("test-agent");
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("getLastActivityTime", () => {
-    it("should parse timestamp from local log file", () => {
-      vi.mocked(spawnSync).mockReturnValue({
-        status: 0,
-        stdout: "INFO  2026-02-26T00:14:42 +0ms service=opencode message=test",
-        stderr: "",
-        pid: 123,
-        signal: null,
-        output: [],
-      });
-
-      const result = getLastActivityTime("test-agent");
-      expect(result).toBeInstanceOf(Date);
-      expect(result?.toISOString()).toContain("2026-02-26");
-    });
-
-    it("should parse timestamp from container log file", () => {
-      vi.mocked(spawnSync).mockReturnValue({
-        status: 0,
-        stdout: "INFO  2026-02-26T01:30:00 +0ms service=opencode",
-        stderr: "",
-        pid: 123,
-        signal: null,
-        output: [],
-      });
-
-      const result = getLastActivityTime("test-agent", "container-123");
-      expect(result).toBeInstanceOf(Date);
-    });
-
-    it("should return null when command fails", () => {
-      vi.mocked(spawnSync).mockReturnValue({
-        status: 1,
-        stdout: "",
-        stderr: "No such file",
-        pid: 123,
-        signal: null,
-        output: [],
-      });
-
-      const result = getLastActivityTime("test-agent");
-      expect(result).toBeNull();
-    });
-
-    it("should return null when no timestamp found", () => {
-      vi.mocked(spawnSync).mockReturnValue({
-        status: 0,
-        stdout: "Some output without timestamp",
-        stderr: "",
-        pid: 123,
-        signal: null,
-        output: [],
-      });
-
-      const result = getLastActivityTime("test-agent");
-      expect(result).toBeNull();
-    });
-
-    it("should return null on empty output", () => {
-      vi.mocked(spawnSync).mockReturnValue({
-        status: 0,
-        stdout: "",
-        stderr: "",
-        pid: 123,
-        signal: null,
-        output: [],
-      });
-
-      const result = getLastActivityTime("test-agent");
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("checkAgentProgress", () => {
-    it("should return permission_blocked when permission prompt detected", () => {
-      vi.mocked(tmux.captureSessionOutput).mockReturnValue("Permission required\nAllow once");
-
-      const result = checkAgentProgress("test-agent");
-      expect(result.status).toBe("permission_blocked");
-      expect(result.blockedOn).toBe("Permission prompt detected");
-    });
-
-    it("should return active when recent activity", () => {
-      vi.mocked(tmux.captureSessionOutput).mockReturnValue("Normal output");
-
-      // Mock recent timestamp (1 minute ago)
-      const recentTime = new Date(Date.now() - 60 * 1000);
-      vi.mocked(spawnSync).mockReturnValue({
-        status: 0,
-        stdout: `INFO  ${recentTime.toISOString().slice(0, 19)} +0ms service=opencode`,
-        stderr: "",
-        pid: 123,
-        signal: null,
-        output: [],
-      });
-
-      const result = checkAgentProgress("test-agent");
-      expect(result.status).toBe("active");
-    });
-
-    it("should return idle when no activity for 3 minutes", () => {
-      vi.mocked(tmux.captureSessionOutput).mockReturnValue("Normal output");
-
-      // Mock timestamp 3 minutes ago
-      const idleTime = new Date(Date.now() - 3 * 60 * 1000);
-      vi.mocked(spawnSync).mockReturnValue({
-        status: 0,
-        stdout: `INFO  ${idleTime.toISOString().slice(0, 19)} +0ms service=opencode`,
-        stderr: "",
-        pid: 123,
-        signal: null,
-        output: [],
-      });
-
-      const result = checkAgentProgress("test-agent");
-      expect(result.status).toBe("idle");
-    });
-
-    it("should return stuck when no activity for 6 minutes", () => {
-      vi.mocked(tmux.captureSessionOutput).mockReturnValue("Normal output");
-
-      // Mock timestamp 6 minutes ago
-      const stuckTime = new Date(Date.now() - 6 * 60 * 1000);
-      vi.mocked(spawnSync).mockReturnValue({
-        status: 0,
-        stdout: `INFO  ${stuckTime.toISOString().slice(0, 19)} +0ms service=opencode`,
-        stderr: "",
-        pid: 123,
-        signal: null,
-        output: [],
-      });
-
-      const result = checkAgentProgress("test-agent");
-      expect(result.status).toBe("stuck");
-    });
-
-    it("should return active when activity time cannot be determined", () => {
-      vi.mocked(tmux.captureSessionOutput).mockReturnValue("Normal output");
-      vi.mocked(spawnSync).mockReturnValue({
-        status: 1,
-        stdout: "",
-        stderr: "",
-        pid: 123,
-        signal: null,
-        output: [],
-      });
-
-      const result = checkAgentProgress("test-agent");
-      expect(result.status).toBe("active");
-      expect(result.details).toContain("Unable to determine");
-    });
-  });
-
-  describe("isProcessRunning", () => {
-    it("should return true for running process", () => {
-      // Current process is always running
-      const result = isProcessRunning(process.pid);
-      expect(result).toBe(true);
-    });
-
-    it("should return false for non-existent process", () => {
-      // Use a very high PID that's unlikely to exist
-      const result = isProcessRunning(999999999);
-      expect(result).toBe(false);
-    });
-  });
-
-  describe("findOrphanContainers", () => {
-    it("should return list of container IDs", () => {
-      vi.mocked(spawnSync).mockReturnValue({
-        status: 0,
-        stdout: "abc123\ndef456\nghi789",
-        stderr: "",
-        pid: 123,
-        signal: null,
-        output: [],
-      });
-
-      const result = findOrphanContainers("test-agent");
-      expect(result).toEqual(["abc123", "def456", "ghi789"]);
-    });
-
-    it("should return empty array when no containers found", () => {
-      vi.mocked(spawnSync).mockReturnValue({
-        status: 0,
-        stdout: "",
-        stderr: "",
-        pid: 123,
-        signal: null,
-        output: [],
-      });
-
-      const result = findOrphanContainers("test-agent");
-      expect(result).toEqual([]);
-    });
-
-    it("should return empty array on command failure", () => {
-      vi.mocked(spawnSync).mockReturnValue({
-        status: 1,
-        stdout: "",
-        stderr: "docker not found",
-        pid: 123,
-        signal: null,
-        output: [],
-      });
-
-      const result = findOrphanContainers("test-agent");
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe("cleanupOrphanContainers", () => {
-    it("should remove found containers and return count", () => {
-      vi.mocked(spawnSync)
-        .mockReturnValueOnce({
-          // findOrphanContainers call
-          status: 0,
-          stdout: "abc123\ndef456",
-          stderr: "",
-          pid: 123,
-          signal: null,
-          output: [],
-        })
-        .mockReturnValue({
-          // docker rm calls
-          status: 0,
-          stdout: "",
-          stderr: "",
-          pid: 123,
-          signal: null,
-          output: [],
-        });
-
-      const result = cleanupOrphanContainers("test-agent");
-      expect(result).toBe(2);
-    });
-
-    it("should return 0 when no orphan containers", () => {
-      vi.mocked(spawnSync).mockReturnValue({
-        status: 0,
-        stdout: "",
-        stderr: "",
-        pid: 123,
-        signal: null,
-        output: [],
-      });
-
-      const result = cleanupOrphanContainers("test-agent");
-      expect(result).toBe(0);
-    });
-  });
-
-  describe("sendNudge", () => {
-    it("should send nudge message to tmux session", () => {
-      vi.mocked(execSync).mockReturnValue(Buffer.from(""));
-
-      const result = sendNudge("test-agent", "Please continue working");
-      expect(result).toBe(true);
-      expect(execSync).toHaveBeenCalledWith(
-        expect.stringContaining("tmux send-keys"),
-        expect.any(Object),
-      );
-    });
-
-    it("should return false when tmux command fails", () => {
-      vi.mocked(execSync).mockImplementation(() => {
-        throw new Error("tmux session not found");
-      });
-
-      const result = sendNudge("test-agent", "Continue");
-      expect(result).toBe(false);
-    });
-
-    it("should escape quotes in message", () => {
-      vi.mocked(execSync).mockReturnValue(Buffer.from(""));
-
-      sendNudge("test-agent", 'Message with "quotes"');
-      expect(execSync).toHaveBeenCalledWith(
-        expect.stringContaining('\\"quotes\\"'),
-        expect.any(Object),
-      );
-    });
-  });
-});

package/src/cli/attach.ts

@@ -1,22 +0,0 @@
-import pc from "picocolors";
-import { attachSession, getSessionName, sessionExists } from "../core/tmux.js";
-
-export function attach(name: string): void {
-  if (!name) {
-    console.log(pc.red("Agent name is required."));
-    process.exit(1);
-  }
-
-  const sessionName = getSessionName(name);
-
-  if (!sessionExists(sessionName)) {
-    console.log(pc.red(`Agent "${name}" is not running.`));
-    console.log(`Start it with: ${pc.cyan(`agentmesh start --name ${name}`)}`);
-    process.exit(1);
-  }
-
-  console.log(`Attaching to ${sessionName}...`);
-  console.log(pc.dim("Detach with: Ctrl+B, D\n"));
-
-  attachSession(name);
-}

package/src/cli/build.ts

@@ -1,145 +0,0 @@
-import { execSync, spawnSync } 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/config.ts

@@ -1,148 +0,0 @@
-import pc from "picocolors";
-import { loadConfig, saveConfig } from "../config/loader.js";
-import { CONFIG_PATH, type Config } from "../config/schema.js";
-
-export async function configCmd(action: string, key?: string, value?: string): Promise<void> {
-  const config = loadConfig();
-
-  if (!config) {
-    console.log(pc.red("No config found. Run 'agentmesh init' first."));
-    process.exit(1);
-  }
-
-  switch (action) {
-    case "show":
-    case "view":
-      showConfig(config);
-      break;
-
-    case "get":
-      if (!key) {
-        console.log(pc.red("Key required. Usage: agentmesh config get <key>"));
-        process.exit(1);
-      }
-      getConfigValue(config, key);
-      break;
-
-    case "set":
-      if (!key || value === undefined) {
-        console.log(pc.red("Key and value required. Usage: agentmesh config set <key> <value>"));
-        process.exit(1);
-      }
-      setConfigValue(config, key, value);
-      break;
-
-    case "path":
-      console.log(CONFIG_PATH);
-      break;
-
-    case "edit":
-      await editConfig();
-      break;
-
-    default:
-      // Default to show
-      showConfig(config);
-  }
-}
-
-function showConfig(config: Config): void {
-  console.log(pc.bold("AgentMesh Configuration\n"));
-  console.log(pc.dim(`Path: ${CONFIG_PATH}\n`));
-
-  // Show main settings
-  console.log(`hubUrl:    ${pc.cyan(config.hubUrl)}`);
-  console.log(`workspace: ${pc.cyan(config.workspace)}`);
-  console.log(`apiKey:    ${pc.dim(maskApiKey(config.apiKey))}`);
-
-  // Show defaults
-  console.log();
-  console.log(pc.dim("Defaults:"));
-  console.log(`  command: ${config.defaults.command}`);
-  console.log(`  model:   ${config.defaults.model}`);
-
-  // Show agents
-  if (config.agents.length > 0) {
-    console.log();
-    console.log(pc.dim("Agent Configs:"));
-    for (const agent of config.agents) {
-      console.log(`  ${agent.name}:`);
-      if (agent.command) console.log(`    command: ${agent.command}`);
-      if (agent.model) console.log(`    model: ${agent.model}`);
-    }
-  }
-}
-
-function getConfigValue(config: Config, key: string): void {
-  const parts = key.split(".");
-  let value: unknown = config;
-
-  for (const part of parts) {
-    if (value && typeof value === "object" && part in value) {
-      value = (value as Record<string, unknown>)[part];
-    } else {
-      console.log(pc.red(`Key "${key}" not found.`));
-      process.exit(1);
-    }
-  }
-
-  if (typeof value === "object") {
-    console.log(JSON.stringify(value, null, 2));
-  } else {
-    console.log(String(value));
-  }
-}
-
-function setConfigValue(config: Config, key: string, value: string): void {
-  const parts = key.split(".");
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let target: any = config;
-
-  // Navigate to parent
-  for (let i = 0; i < parts.length - 1; i++) {
-    const part = parts[i];
-    if (!(part in target)) {
-      target[part] = {};
-    }
-    target = target[part];
-  }
-
-  const finalKey = parts[parts.length - 1];
-  const oldValue = target[finalKey];
-
-  // Try to parse as JSON, otherwise use string
-  try {
-    target[finalKey] = JSON.parse(value);
-  } catch {
-    target[finalKey] = value;
-  }
-
-  saveConfig(config);
-
-  console.log(pc.green(`Set ${key}:`));
-  console.log(`  Old: ${pc.dim(String(oldValue))}`);
-  console.log(`  New: ${pc.cyan(String(target[finalKey]))}`);
-}
-
-async function editConfig(): Promise<void> {
-  const { spawn } = await import("node:child_process");
-  const editor = process.env.EDITOR || process.env.VISUAL || "vi";
-
-  console.log(pc.dim(`Opening ${CONFIG_PATH} with ${editor}...`));
-
-  const child = spawn(editor, [CONFIG_PATH], {
-    stdio: "inherit",
-  });
-
-  child.on("exit", (code) => {
-    if (code === 0) {
-      console.log(pc.green("Config saved."));
-    }
-    process.exit(code ?? 0);
-  });
-}
-
-function maskApiKey(key: string): string {
-  if (!key || key.length < 12) return "***";
-  return `${key.slice(0, 8)}...${key.slice(-4)}`;
-}