@agentmeshhq/agent 0.2.0 → 0.2.1

package/src/__tests__/jwt.test.ts

@@ -1,112 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  decodeToken,
-  getAgentIdFromToken,
-  getTokenExpiry,
-  getTokenTimeRemaining,
-  isTokenExpired,
-  isTokenExpiringSoon,
-} from "../utils/jwt.js";
-
-// Sample JWT tokens for testing
-// These are test tokens with known payloads
-
-// Token payload: { sub: "test-agent-123", actorType: "agent", workspaceScopes: ["test"], iat: 1700000000, exp: 1700604800 }
-const VALID_TOKEN =
-  "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ0ZXN0LWFnZW50LTEyMyIsImFjdG9yVHlwZSI6ImFnZW50Iiwid29ya3NwYWNlU2NvcGVzIjpbInRlc3QiXSwiaWF0IjoxNzAwMDAwMDAwLCJleHAiOjE3MDA2MDQ4MDB9.fake_signature";
-
-// Expired token (exp: 1600000000 - Sep 2020)
-const EXPIRED_TOKEN =
-  "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJleHBpcmVkLWFnZW50IiwiYWN0b3JUeXBlIjoiYWdlbnQiLCJ3b3Jrc3BhY2VTY29wZXMiOlsidGVzdCJdLCJpYXQiOjE1MDAwMDAwMDAsImV4cCI6MTYwMDAwMDAwMH0.fake_signature";
-
-// Future token (exp: 2700000000 - ~2055)
-const FUTURE_TOKEN =
-  "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJmdXR1cmUtYWdlbnQiLCJhY3RvclR5cGUiOiJhZ2VudCIsIndvcmtzcGFjZVNjb3BlcyI6WyJ0ZXN0Il0sImlhdCI6MTcwMDAwMDAwMCwiZXhwIjoyNzAwMDAwMDAwfQ.fake_signature";
-
-describe("JWT Utils", () => {
-  describe("decodeToken", () => {
-    it("should decode a valid JWT token", () => {
-      const payload = decodeToken(VALID_TOKEN);
-      expect(payload).not.toBeNull();
-      expect(payload?.sub).toBe("test-agent-123");
-      expect(payload?.actorType).toBe("agent");
-      expect(payload?.workspaceScopes).toEqual(["test"]);
-    });
-
-    it("should return null for invalid token format", () => {
-      expect(decodeToken("invalid")).toBeNull();
-      expect(decodeToken("")).toBeNull();
-      expect(decodeToken("a.b")).toBeNull();
-    });
-
-    it("should return null for malformed base64", () => {
-      expect(decodeToken("a.!!!invalid!!!.c")).toBeNull();
-    });
-  });
-
-  describe("getTokenExpiry", () => {
-    it("should return expiry date for valid token", () => {
-      const expiry = getTokenExpiry(VALID_TOKEN);
-      expect(expiry).toBeInstanceOf(Date);
-      expect(expiry?.getTime()).toBe(1700604800 * 1000);
-    });
-
-    it("should return null for invalid token", () => {
-      expect(getTokenExpiry("invalid")).toBeNull();
-    });
-  });
-
-  describe("isTokenExpired", () => {
-    it("should return true for expired token", () => {
-      expect(isTokenExpired(EXPIRED_TOKEN)).toBe(true);
-    });
-
-    it("should return false for future token", () => {
-      expect(isTokenExpired(FUTURE_TOKEN)).toBe(false);
-    });
-
-    it("should return true for invalid token", () => {
-      expect(isTokenExpired("invalid")).toBe(true);
-    });
-  });
-
-  describe("isTokenExpiringSoon", () => {
-    it("should return true for expired token", () => {
-      expect(isTokenExpiringSoon(EXPIRED_TOKEN, 1000)).toBe(true);
-    });
-
-    it("should return false for future token with short threshold", () => {
-      // Future token expires in ~2055, so any reasonable threshold should return false
-      expect(isTokenExpiringSoon(FUTURE_TOKEN, 24 * 60 * 60 * 1000)).toBe(false);
-    });
-
-    it("should return true for invalid token", () => {
-      expect(isTokenExpiringSoon("invalid", 1000)).toBe(true);
-    });
-  });
-
-  describe("getAgentIdFromToken", () => {
-    it("should return agent ID from valid token", () => {
-      expect(getAgentIdFromToken(VALID_TOKEN)).toBe("test-agent-123");
-    });
-
-    it("should return null for invalid token", () => {
-      expect(getAgentIdFromToken("invalid")).toBeNull();
-    });
-  });
-
-  describe("getTokenTimeRemaining", () => {
-    it("should return 0 for expired token", () => {
-      expect(getTokenTimeRemaining(EXPIRED_TOKEN)).toBe(0);
-    });
-
-    it("should return positive value for future token", () => {
-      const remaining = getTokenTimeRemaining(FUTURE_TOKEN);
-      expect(remaining).toBeGreaterThan(0);
-    });
-
-    it("should return 0 for invalid token", () => {
-      expect(getTokenTimeRemaining("invalid")).toBe(0);
-    });
-  });
-});

package/src/__tests__/loader.test.ts

@@ -1,239 +0,0 @@
-import * as fs from "node:fs";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import {
-  addAgentToState,
-  getAgentState,
-  loadConfig,
-  loadState,
-  removeAgentFromState,
-  resetAgentRestartCount,
-  updateAgentInState,
-} from "../config/loader.js";
-import type { AgentState, Config, State } from "../config/schema.js";
-
-// Mock the file system
-vi.mock("node:fs");
-
-describe("Config Loader", () => {
-  const mockConfig: Config = {
-    hubUrl: "https://test.agentmesh.dev",
-    apiKey: "test-api-key",
-    workspace: "test-workspace",
-    defaults: {
-      command: "opencode",
-      model: "claude-sonnet-4",
-    },
-    agents: [],
-  };
-
-  const mockState: State = {
-    agents: [
-      {
-        name: "test-agent",
-        agentId: "agent-123",
-        pid: 12345,
-        tmuxSession: "agentmesh-test-agent",
-        startedAt: "2024-01-01T00:00:00Z",
-        token: "test-token",
-      },
-    ],
-  };
-
-  beforeEach(() => {
-    vi.resetAllMocks();
-  });
-
-  describe("loadConfig", () => {
-    it("should return null if config file does not exist", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(false);
-      expect(loadConfig()).toBeNull();
-    });
-
-    it("should load and parse config file", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockConfig));
-
-      const config = loadConfig();
-      expect(config).toEqual(mockConfig);
-    });
-
-    it("should return null on parse error", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue("invalid json");
-
-      expect(loadConfig()).toBeNull();
-    });
-  });
-
-  describe("loadState", () => {
-    it("should return empty state if file does not exist", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(false);
-      expect(loadState()).toEqual({ agents: [] });
-    });
-
-    it("should load and parse state file", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockState));
-
-      const state = loadState();
-      expect(state).toEqual(mockState);
-    });
-  });
-
-  describe("addAgentToState", () => {
-    it("should add new agent to state", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ agents: [] }));
-      vi.mocked(fs.writeFileSync).mockImplementation(() => {});
-
-      const newAgent: AgentState = {
-        name: "new-agent",
-        agentId: "agent-456",
-        pid: 67890,
-        tmuxSession: "agentmesh-new-agent",
-        startedAt: "2024-01-02T00:00:00Z",
-        token: "new-token",
-      };
-
-      addAgentToState(newAgent);
-
-      expect(fs.writeFileSync).toHaveBeenCalled();
-      const writtenContent = vi.mocked(fs.writeFileSync).mock.calls[0][1] as string;
-      const parsedState = JSON.parse(writtenContent);
-      expect(parsedState.agents).toHaveLength(1);
-      expect(parsedState.agents[0].name).toBe("new-agent");
-    });
-
-    it("should replace existing agent with same name", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockState));
-      vi.mocked(fs.writeFileSync).mockImplementation(() => {});
-
-      const updatedAgent: AgentState = {
-        name: "test-agent",
-        agentId: "agent-789",
-        pid: 11111,
-        tmuxSession: "agentmesh-test-agent",
-        startedAt: "2024-01-03T00:00:00Z",
-        token: "updated-token",
-      };
-
-      addAgentToState(updatedAgent);
-
-      const writtenContent = vi.mocked(fs.writeFileSync).mock.calls[0][1] as string;
-      const parsedState = JSON.parse(writtenContent);
-      expect(parsedState.agents).toHaveLength(1);
-      expect(parsedState.agents[0].agentId).toBe("agent-789");
-    });
-  });
-
-  describe("removeAgentFromState", () => {
-    it("should remove agent from state", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockState));
-      vi.mocked(fs.writeFileSync).mockImplementation(() => {});
-
-      removeAgentFromState("test-agent");
-
-      const writtenContent = vi.mocked(fs.writeFileSync).mock.calls[0][1] as string;
-      const parsedState = JSON.parse(writtenContent);
-      expect(parsedState.agents).toHaveLength(0);
-    });
-  });
-
-  describe("getAgentState", () => {
-    it("should return agent by name", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockState));
-
-      const agent = getAgentState("test-agent");
-      expect(agent).toBeDefined();
-      expect(agent?.agentId).toBe("agent-123");
-    });
-
-    it("should return undefined for non-existent agent", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockState));
-
-      const agent = getAgentState("non-existent");
-      expect(agent).toBeUndefined();
-    });
-  });
-
-  describe("updateAgentInState", () => {
-    it("should update agent fields", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockState));
-      vi.mocked(fs.writeFileSync).mockImplementation(() => {});
-
-      updateAgentInState("test-agent", { token: "new-token-123" });
-
-      const writtenContent = vi.mocked(fs.writeFileSync).mock.calls[0][1] as string;
-      const parsedState = JSON.parse(writtenContent);
-      expect(parsedState.agents[0].token).toBe("new-token-123");
-      // Other fields should remain unchanged
-      expect(parsedState.agents[0].agentId).toBe("agent-123");
-    });
-
-    it("should do nothing for non-existent agent", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockState));
-      vi.mocked(fs.writeFileSync).mockImplementation(() => {});
-
-      updateAgentInState("non-existent", { token: "new-token" });
-
-      // writeFileSync should not be called since agent doesn't exist
-      // Actually it will be called but the state will be unchanged
-    });
-
-    it("should update restart count and status fields", () => {
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockState));
-      vi.mocked(fs.writeFileSync).mockImplementation(() => {});
-
-      updateAgentInState("test-agent", {
-        restartCount: 2,
-        status: "stuck",
-        stuckSince: "2024-01-01T01:00:00Z",
-      });
-
-      const writtenContent = vi.mocked(fs.writeFileSync).mock.calls[0][1] as string;
-      const parsedState = JSON.parse(writtenContent);
-      expect(parsedState.agents[0].restartCount).toBe(2);
-      expect(parsedState.agents[0].status).toBe("stuck");
-      expect(parsedState.agents[0].stuckSince).toBe("2024-01-01T01:00:00Z");
-    });
-  });
-
-  describe("resetAgentRestartCount", () => {
-    it("should reset restart count and clear stuck status", () => {
-      const stuckState: State = {
-        agents: [
-          {
-            name: "test-agent",
-            agentId: "agent-123",
-            pid: 12345,
-            tmuxSession: "agentmesh-test-agent",
-            startedAt: "2024-01-01T00:00:00Z",
-            token: "test-token",
-            restartCount: 3,
-            status: "stuck",
-            stuckSince: "2024-01-01T01:00:00Z",
-          },
-        ],
-      };
-
-      vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(stuckState));
-      vi.mocked(fs.writeFileSync).mockImplementation(() => {});
-
-      resetAgentRestartCount("test-agent");
-
-      const writtenContent = vi.mocked(fs.writeFileSync).mock.calls[0][1] as string;
-      const parsedState = JSON.parse(writtenContent);
-      expect(parsedState.agents[0].restartCount).toBe(0);
-      expect(parsedState.agents[0].status).toBe("running");
-      expect(parsedState.agents[0].stuckSince).toBeUndefined();
-    });
-  });
-});

package/src/__tests__/runner.test.ts

@@ -1,104 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  buildRunnerConfig,
-  detectRunner,
-  getRunnerDisplayName,
-  resolveModel,
-} from "../core/runner.js";
-
-describe("Runner Module", () => {
-  describe("detectRunner", () => {
-    it("should detect opencode runner", () => {
-      expect(detectRunner("opencode")).toBe("opencode");
-      expect(detectRunner("opencode --some-flag")).toBe("opencode");
-      expect(detectRunner("OPENCODE")).toBe("opencode");
-    });
-
-    it("should detect claude runner", () => {
-      expect(detectRunner("claude")).toBe("claude");
-      expect(detectRunner("claude --some-flag")).toBe("claude");
-      expect(detectRunner("CLAUDE")).toBe("claude");
-    });
-
-    it("should detect custom runner for unknown commands", () => {
-      expect(detectRunner("aider")).toBe("custom");
-      expect(detectRunner("cursor")).toBe("custom");
-      expect(detectRunner("my-custom-tool")).toBe("custom");
-    });
-  });
-
-  describe("resolveModel", () => {
-    it("should prioritize CLI model over all others", () => {
-      const result = resolveModel({
-        cliModel: "cli-model",
-        agentModel: "agent-model",
-        defaultModel: "default-model",
-        command: "opencode",
-      });
-      expect(result).toBe("cli-model");
-    });
-
-    it("should use agent model when CLI not provided", () => {
-      const result = resolveModel({
-        agentModel: "agent-model",
-        defaultModel: "default-model",
-        command: "opencode",
-      });
-      expect(result).toBe("agent-model");
-    });
-
-    it("should fall back to default model", () => {
-      const result = resolveModel({
-        defaultModel: "default-model",
-        command: "opencode",
-      });
-      expect(result).toBe("default-model");
-    });
-  });
-
-  describe("buildRunnerConfig", () => {
-    it("should build config for opencode with OPENCODE_MODEL env", () => {
-      const config = buildRunnerConfig({
-        cliModel: "claude-sonnet-4",
-        defaultModel: "claude-sonnet-4",
-        command: "opencode",
-      });
-
-      expect(config.type).toBe("opencode");
-      expect(config.model).toBe("claude-sonnet-4");
-      expect(config.env.OPENCODE_MODEL).toBeDefined();
-    });
-
-    it("should build config for claude with CLAUDE_MODEL env", () => {
-      const config = buildRunnerConfig({
-        cliModel: "claude-sonnet-4",
-        defaultModel: "claude-sonnet-4",
-        command: "claude",
-      });
-
-      expect(config.type).toBe("claude");
-      expect(config.model).toBe("claude-sonnet-4");
-      expect(config.env.CLAUDE_MODEL).toBe("claude-sonnet-4");
-    });
-
-    it("should build config for custom runner without env vars", () => {
-      const config = buildRunnerConfig({
-        cliModel: "gpt-4",
-        defaultModel: "claude-sonnet-4",
-        command: "aider",
-      });
-
-      expect(config.type).toBe("custom");
-      expect(config.model).toBe("gpt-4");
-      expect(Object.keys(config.env)).toHaveLength(0);
-    });
-  });
-
-  describe("getRunnerDisplayName", () => {
-    it("should return correct display names", () => {
-      expect(getRunnerDisplayName("opencode")).toBe("OpenCode");
-      expect(getRunnerDisplayName("claude")).toBe("Claude CLI");
-      expect(getRunnerDisplayName("custom")).toBe("Custom");
-    });
-  });
-});