@agentmeshhq/agent 0.1.4 → 0.1.6

package/src/__tests__/loader.test.ts

@@ -0,0 +1,191 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  addAgentToState,
+  getAgentState,
+  loadConfig,
+  loadState,
+  removeAgentFromState,
+  saveConfig,
+  saveState,
+  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
+    });
+  });
+});

package/src/cli/index.ts

@@ -1,20 +1,26 @@
 #!/usr/bin/env node
 
+import { createRequire } from "node:module";
 import { Command } from "commander";
+import pc from "picocolors";
+import { attach } from "./attach.js";
 import { init } from "./init.js";
-import { start } from "./start.js";
-import { stop } from "./stop.js";
 import { list } from "./list.js";
-import { attach } from "./attach.js";
 import { nudge } from "./nudge.js";
-import pc from "picocolors";
+import { start } from "./start.js";
+import { stop } from "./stop.js";
+import { token } from "./token.js";
+import { whoami } from "./whoami.js";
+
+const require = createRequire(import.meta.url);
+const pkg = require("../../package.json") as { version: string };
 
 const program = new Command();
 
 program
   .name("agentmesh")
   .description("AgentMesh Agent Wrapper - Turn any AI assistant into a dispatchable agent")
-  .version("0.1.4");
+  .version(pkg.version);
 
 program
   .command("init")
@@ -98,4 +104,31 @@ program
     }
   });
 
+program
+  .command("whoami")
+  .description("Show current agent identity and status")
+  .argument("[name]", "Agent name (optional)")
+  .action(async (name) => {
+    try {
+      await whoami(name);
+    } catch (error) {
+      console.error(pc.red((error as Error).message));
+      process.exit(1);
+    }
+  });
+
+program
+  .command("token")
+  .description("Manage agent tokens")
+  .argument("[action]", "Action: show (default), refresh, info")
+  .option("-n, --name <name>", "Agent name")
+  .action(async (action, options) => {
+    try {
+      await token(action || "show", options.name);
+    } catch (error) {
+      console.error(pc.red((error as Error).message));
+      process.exit(1);
+    }
+  });
+
 program.parse();

package/src/cli/token.ts

@@ -0,0 +1,188 @@
+import pc from "picocolors";
+import { loadConfig, loadState, updateAgentInState } from "../config/loader.js";
+import { registerAgent } from "../core/registry.js";
+import { getSessionName, sessionExists, updateSessionEnvironment } from "../core/tmux.js";
+import {
+  decodeToken,
+  getTokenExpiry,
+  getTokenTimeRemaining,
+  isTokenExpired,
+} from "../utils/jwt.js";
+
+export async function token(action: string, agentName?: string): Promise<void> {
+  const config = loadConfig();
+
+  if (!config) {
+    console.log(pc.red("No config found. Run 'agentmesh init' first."));
+    process.exit(1);
+  }
+
+  // Check if running inside an agent session
+  const envAgentId = process.env.AGENTMESH_AGENT_ID;
+  const envToken = process.env.AGENT_TOKEN;
+
+  switch (action) {
+    case "show":
+      await showToken(config, agentName, envAgentId, envToken);
+      break;
+    case "refresh":
+      await refreshToken(config, agentName, envAgentId);
+      break;
+    case "info":
+      await tokenInfo(config, agentName, envAgentId, envToken);
+      break;
+    default:
+      console.log(pc.red(`Unknown action: ${action}`));
+      console.log(pc.dim("Available actions: show, refresh, info"));
+      process.exit(1);
+  }
+}
+
+async function showToken(
+  config: ReturnType<typeof loadConfig>,
+  agentName?: string,
+  envAgentId?: string,
+  envToken?: string,
+): Promise<void> {
+  // If running as agent, show env token
+  if (envToken && !agentName) {
+    console.log(envToken);
+    return;
+  }
+
+  // Find agent in state
+  const state = loadState();
+  const agent = agentName ? state.agents.find((a) => a.name === agentName) : state.agents[0];
+
+  if (!agent) {
+    if (agentName) {
+      console.log(pc.red(`Agent "${agentName}" not found.`));
+    } else {
+      console.log(pc.red("No agents registered."));
+    }
+    process.exit(1);
+  }
+
+  if (!agent.token) {
+    console.log(pc.red(`No token found for agent "${agent.name}".`));
+    console.log(pc.dim("Run 'agentmesh token refresh' to get a new token."));
+    process.exit(1);
+  }
+
+  console.log(agent.token);
+}
+
+async function refreshToken(
+  config: ReturnType<typeof loadConfig>,
+  agentName?: string,
+  envAgentId?: string,
+): Promise<void> {
+  if (!config) {
+    process.exit(1);
+  }
+
+  const state = loadState();
+
+  // Find the agent to refresh
+  const agent = agentName
+    ? state.agents.find((a) => a.name === agentName)
+    : envAgentId
+      ? state.agents.find((a) => a.agentId === envAgentId)
+      : state.agents[0];
+
+  if (!agent) {
+    console.log(pc.red("No agent found to refresh token for."));
+    process.exit(1);
+  }
+
+  console.log(pc.dim(`Refreshing token for "${agent.name}"...`));
+
+  try {
+    const registration = await registerAgent({
+      url: config.hubUrl,
+      apiKey: config.apiKey,
+      workspace: config.workspace,
+      agentId: agent.agentId,
+      agentName: agent.name,
+      model: "claude-sonnet-4", // Default model
+    });
+
+    // Update state
+    updateAgentInState(agent.name, {
+      token: registration.token,
+    });
+
+    // Update tmux environment if session exists
+    if (sessionExists(getSessionName(agent.name))) {
+      updateSessionEnvironment(agent.name, {
+        AGENT_TOKEN: registration.token,
+        AGENTMESH_AGENT_ID: registration.agentId,
+      });
+      console.log(pc.dim("Updated tmux session environment."));
+    }
+
+    console.log(pc.green("Token refreshed successfully."));
+
+    const expiry = getTokenExpiry(registration.token);
+    if (expiry) {
+      console.log(pc.dim(`New expiry: ${expiry.toISOString()}`));
+    }
+  } catch (error) {
+    console.log(pc.red(`Failed to refresh token: ${(error as Error).message}`));
+    process.exit(1);
+  }
+}
+
+async function tokenInfo(
+  config: ReturnType<typeof loadConfig>,
+  agentName?: string,
+  envAgentId?: string,
+  envToken?: string,
+): Promise<void> {
+  // Get token to inspect
+  let tokenToInspect: string | null = null;
+  let source = "unknown";
+
+  if (envToken && !agentName) {
+    tokenToInspect = envToken;
+    source = "environment";
+  } else {
+    const state = loadState();
+    const agent = agentName ? state.agents.find((a) => a.name === agentName) : state.agents[0];
+
+    if (agent?.token) {
+      tokenToInspect = agent.token;
+      source = `agent: ${agent.name}`;
+    }
+  }
+
+  if (!tokenToInspect) {
+    console.log(pc.red("No token found."));
+    process.exit(1);
+  }
+
+  const payload = decodeToken(tokenToInspect);
+  if (!payload) {
+    console.log(pc.red("Invalid token format."));
+    process.exit(1);
+  }
+
+  const expiry = getTokenExpiry(tokenToInspect);
+  const expired = isTokenExpired(tokenToInspect);
+  const remaining = getTokenTimeRemaining(tokenToInspect);
+
+  console.log(pc.bold("Token Info"));
+  console.log(`  Source:     ${pc.dim(source)}`);
+  console.log(`  Agent ID:   ${pc.cyan(payload.sub)}`);
+  console.log(`  Type:       ${pc.dim(payload.actorType)}`);
+  console.log(`  Workspaces: ${pc.dim(payload.workspaceScopes.join(", "))}`);
+  console.log(`  Issued:     ${pc.dim(new Date(payload.iat * 1000).toISOString())}`);
+  console.log(`  Expires:    ${expiry ? pc.dim(expiry.toISOString()) : pc.red("unknown")}`);
+  console.log(`  Status:     ${expired ? pc.red("EXPIRED") : pc.green("VALID")}`);
+
+  if (!expired && remaining > 0) {
+    const days = Math.floor(remaining / (1000 * 60 * 60 * 24));
+    const hours = Math.floor((remaining % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
+    console.log(`  Remaining:  ${pc.dim(`${days}d ${hours}h`)}`);
+  }
+}

package/src/cli/whoami.ts

@@ -0,0 +1,113 @@
+import pc from "picocolors";
+import { loadConfig, loadState } from "../config/loader.js";
+import { decodeToken, getTokenExpiry } from "../utils/jwt.js";
+
+export async function whoami(agentName?: string): Promise<void> {
+  const config = loadConfig();
+
+  if (!config) {
+    console.log(pc.red("No config found. Run 'agentmesh init' first."));
+    process.exit(1);
+  }
+
+  const state = loadState();
+
+  // If no agent name provided, check environment or show all
+  if (!agentName) {
+    // Check if running as an agent (env vars set)
+    const envAgentId = process.env.AGENTMESH_AGENT_ID;
+    const envToken = process.env.AGENT_TOKEN;
+
+    if (envAgentId && envToken) {
+      // We're running inside an agent session
+      const expiry = getTokenExpiry(envToken);
+      const expiryStr = formatExpiry(expiry);
+
+      console.log(pc.bold("Current Agent"));
+      console.log(`  ID:        ${pc.cyan(envAgentId)}`);
+      console.log(`  Workspace: ${pc.dim(config.workspace)}`);
+      console.log(`  Token:     ${expiryStr}`);
+      console.log(`  Hub:       ${pc.dim(config.hubUrl)}`);
+      return;
+    }
+
+    // Show all registered agents
+    if (state.agents.length === 0) {
+      console.log(pc.dim("No agents registered."));
+      console.log(pc.dim("Start an agent with: agentmesh start <name>"));
+      return;
+    }
+
+    console.log(pc.bold("Registered Agents"));
+    console.log();
+
+    for (const agent of state.agents) {
+      const expiry = agent.token ? getTokenExpiry(agent.token) : null;
+      const expiryStr = formatExpiry(expiry);
+      const running = agent.pid ? isProcessRunning(agent.pid) : false;
+
+      console.log(`  ${pc.cyan(agent.name)}`);
+      console.log(`    ID:      ${pc.dim(agent.agentId)}`);
+      console.log(`    Status:  ${running ? pc.green("running") : pc.yellow("stopped")}`);
+      console.log(`    Token:   ${expiryStr}`);
+      console.log();
+    }
+    return;
+  }
+
+  // Show specific agent
+  const agent = state.agents.find((a) => a.name === agentName);
+
+  if (!agent) {
+    console.log(pc.red(`Agent "${agentName}" not found.`));
+    process.exit(1);
+  }
+
+  const expiry = agent.token ? getTokenExpiry(agent.token) : null;
+  const expiryStr = formatExpiry(expiry);
+  const running = agent.pid ? isProcessRunning(agent.pid) : false;
+
+  console.log(pc.bold(`Agent: ${agent.name}`));
+  console.log(`  ID:        ${pc.cyan(agent.agentId)}`);
+  console.log(`  Workspace: ${pc.dim(config.workspace)}`);
+  console.log(`  Status:    ${running ? pc.green("running") : pc.yellow("stopped")}`);
+  console.log(`  Token:     ${expiryStr}`);
+  console.log(`  Session:   ${pc.dim(agent.tmuxSession || "none")}`);
+  console.log(`  Started:   ${pc.dim(agent.startedAt || "unknown")}`);
+  console.log(`  Hub:       ${pc.dim(config.hubUrl)}`);
+}
+
+function formatExpiry(expiry: Date | null): string {
+  if (!expiry) {
+    return pc.red("No token");
+  }
+
+  const now = new Date();
+  const diffMs = expiry.getTime() - now.getTime();
+
+  if (diffMs <= 0) {
+    return pc.red("Expired");
+  }
+
+  const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+  const diffHours = Math.floor((diffMs % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
+
+  if (diffDays > 1) {
+    return pc.green(`Valid (expires in ${diffDays} days)`);
+  } else if (diffDays === 1) {
+    return pc.yellow(`Valid (expires in 1 day)`);
+  } else if (diffHours > 0) {
+    return pc.yellow(`Valid (expires in ${diffHours} hours)`);
+  } else {
+    return pc.red(`Expiring soon`);
+  }
+}
+
+function isProcessRunning(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/config/loader.ts

@@ -1,12 +1,12 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import {
-  type Config,
-  type State,
   type AgentState,
   CONFIG_PATH,
-  STATE_PATH,
+  type Config,
   DEFAULT_CONFIG,
+  STATE_PATH,
+  type State,
 } from "./schema.js";
 
 export function ensureConfigDir(): void {
@@ -69,10 +69,23 @@ export function getAgentState(name: string): AgentState | undefined {
   return state.agents.find((a) => a.name === name);
 }
 
-export function createDefaultConfig(
-  apiKey: string,
-  workspace: string
-): Config {
+export function updateAgentInState(name: string, updates: Partial<AgentState>): void {
+  const state = loadState();
+  const agentIndex = state.agents.findIndex((a) => a.name === name);
+
+  if (agentIndex === -1) {
+    return;
+  }
+
+  state.agents[agentIndex] = {
+    ...state.agents[agentIndex],
+    ...updates,
+  };
+
+  saveState(state);
+}
+
+export function createDefaultConfig(apiKey: string, workspace: string): Config {
   return {
     ...DEFAULT_CONFIG,
     apiKey,