@agentmeshhq/agent 0.1.0

package/src/config/schema.ts

@@ -0,0 +1,44 @@
+export interface AgentConfig {
+  name: string;
+  agentId?: string;
+  command: string;
+  workdir?: string;
+  model?: string;
+  teams?: string[];
+}
+
+export interface Config {
+  apiKey: string;
+  workspace: string;
+  hubUrl: string;
+  defaults: {
+    command: string;
+    model: string;
+  };
+  agents: AgentConfig[];
+}
+
+export const DEFAULT_CONFIG: Partial<Config> = {
+  hubUrl: "https://agentmeshhq.dev",
+  defaults: {
+    command: "opencode",
+    model: "claude-sonnet-4",
+  },
+  agents: [],
+};
+
+export const CONFIG_PATH = `${process.env.HOME}/.agentmesh/config.json`;
+export const STATE_PATH = `${process.env.HOME}/.agentmesh/state.json`;
+
+export interface AgentState {
+  name: string;
+  agentId: string;
+  pid: number;
+  tmuxSession: string;
+  startedAt: string;
+  token?: string;
+}
+
+export interface State {
+  agents: AgentState[];
+}

package/src/core/daemon.ts

@@ -0,0 +1,213 @@
+import { createSession, destroySession, sessionExists, getSessionName } from "./tmux.js";
+import { AgentWebSocket } from "./websocket.js";
+import { Heartbeat } from "./heartbeat.js";
+import { registerAgent, checkInbox } from "./registry.js";
+import { injectStartupMessage, handleWebSocketEvent } from "./injector.js";
+import {
+  addAgentToState,
+  removeAgentFromState,
+  loadConfig,
+  getAgentState,
+} from "../config/loader.js";
+import type { Config, AgentConfig } from "../config/schema.js";
+
+export interface DaemonOptions {
+  name: string;
+  command?: string;
+  workdir?: string;
+  model?: string;
+  daemonize?: boolean;
+}
+
+export class AgentDaemon {
+  private agentName: string;
+  private config: Config;
+  private agentConfig: AgentConfig;
+  private ws: AgentWebSocket | null = null;
+  private heartbeat: Heartbeat | null = null;
+  private token: string | null = null;
+  private agentId: string | null = null;
+  private isRunning = false;
+
+  constructor(options: DaemonOptions) {
+    const config = loadConfig();
+    if (!config) {
+      throw new Error(
+        "No config found. Run 'agentmesh init' first."
+      );
+    }
+
+    this.config = config;
+    this.agentName = options.name;
+
+    // Find or create agent config
+    let agentConfig = config.agents.find((a) => a.name === options.name);
+
+    if (!agentConfig) {
+      agentConfig = {
+        name: options.name,
+        command: options.command || config.defaults.command,
+        workdir: options.workdir,
+        model: options.model || config.defaults.model,
+      };
+    }
+
+    // Override with provided options
+    if (options.command) agentConfig.command = options.command;
+    if (options.workdir) agentConfig.workdir = options.workdir;
+    if (options.model) agentConfig.model = options.model;
+
+    this.agentConfig = agentConfig;
+  }
+
+  async start(): Promise<void> {
+    if (this.isRunning) {
+      console.error("Daemon already running");
+      return;
+    }
+
+    console.log(`Starting agent: ${this.agentName}`);
+
+    // Check if session already exists
+    const sessionName = getSessionName(this.agentName);
+    const sessionAlreadyExists = sessionExists(sessionName);
+
+    // Create tmux session if it doesn't exist
+    if (!sessionAlreadyExists) {
+      console.log(`Creating tmux session: ${sessionName}`);
+      const created = createSession(
+        this.agentName,
+        this.agentConfig.command,
+        this.agentConfig.workdir
+      );
+
+      if (!created) {
+        throw new Error("Failed to create tmux session");
+      }
+    } else {
+      console.log(`Reconnecting to existing session: ${sessionName}`);
+    }
+
+    // Register with hub
+    console.log("Registering with AgentMesh hub...");
+    const existingState = getAgentState(this.agentName);
+
+    const registration = await registerAgent({
+      url: this.config.hubUrl,
+      apiKey: this.config.apiKey,
+      workspace: this.config.workspace,
+      agentId: existingState?.agentId || this.agentConfig.agentId,
+      agentName: this.agentName,
+      model: this.agentConfig.model || this.config.defaults.model,
+    });
+
+    this.agentId = registration.agentId;
+    this.token = registration.token;
+
+    console.log(`Registered as: ${this.agentId}`);
+
+    // Save state
+    addAgentToState({
+      name: this.agentName,
+      agentId: this.agentId,
+      pid: process.pid,
+      tmuxSession: sessionName,
+      startedAt: new Date().toISOString(),
+      token: this.token,
+    });
+
+    // Start heartbeat
+    console.log("Starting heartbeat...");
+    this.heartbeat = new Heartbeat({
+      url: this.config.hubUrl,
+      token: this.token,
+      intervalMs: 30000,
+      onError: (error) => {
+        console.error("Heartbeat error:", error.message);
+      },
+    });
+    this.heartbeat.start();
+
+    // Connect WebSocket
+    console.log("Connecting WebSocket...");
+    const wsUrl = this.config.hubUrl.replace("https://", "wss://").replace("http://", "ws://");
+
+    this.ws = new AgentWebSocket({
+      url: `${wsUrl}/ws/v1`,
+      token: this.token,
+      onMessage: (event) => {
+        handleWebSocketEvent(this.agentName, event);
+      },
+      onConnect: () => {
+        console.log("WebSocket connected");
+      },
+      onDisconnect: () => {
+        console.log("WebSocket disconnected");
+      },
+      onError: (error) => {
+        console.error("WebSocket error:", error.message);
+      },
+    });
+    this.ws.connect();
+
+    // Check inbox and auto-nudge
+    console.log("Checking inbox...");
+    try {
+      const inboxItems = await checkInbox(
+        this.config.hubUrl,
+        this.config.workspace,
+        this.token
+      );
+      injectStartupMessage(this.agentName, inboxItems.length);
+    } catch (error) {
+      console.error("Failed to check inbox:", error);
+      injectStartupMessage(this.agentName, 0);
+    }
+
+    this.isRunning = true;
+
+    console.log(`
+Agent "${this.agentName}" is running.
+
+Attach to session:
+  agentmesh attach ${this.agentName}
+
+Stop agent:
+  agentmesh stop ${this.agentName}
+
+Nudge agent:
+  agentmesh nudge ${this.agentName} "Your message"
+`);
+
+    // Handle shutdown
+    process.on("SIGINT", () => this.stop());
+    process.on("SIGTERM", () => this.stop());
+  }
+
+  async stop(): Promise<void> {
+    console.log(`\nStopping agent: ${this.agentName}`);
+
+    this.isRunning = false;
+
+    // Stop heartbeat
+    if (this.heartbeat) {
+      this.heartbeat.stop();
+      this.heartbeat = null;
+    }
+
+    // Disconnect WebSocket
+    if (this.ws) {
+      this.ws.disconnect();
+      this.ws = null;
+    }
+
+    // Destroy tmux session
+    destroySession(this.agentName);
+
+    // Remove from state
+    removeAgentFromState(this.agentName);
+
+    console.log("Agent stopped.");
+    process.exit(0);
+  }
+}

package/src/core/heartbeat.ts

@@ -0,0 +1,54 @@
+export interface HeartbeatConfig {
+  url: string;
+  token: string;
+  intervalMs: number;
+  onError?: (error: Error) => void;
+}
+
+export class Heartbeat {
+  private config: HeartbeatConfig;
+  private intervalId: NodeJS.Timeout | null = null;
+
+  constructor(config: HeartbeatConfig) {
+    this.config = config;
+  }
+
+  start(): void {
+    if (this.intervalId) {
+      return;
+    }
+
+    // Send initial heartbeat
+    this.sendHeartbeat();
+
+    // Schedule recurring heartbeats
+    this.intervalId = setInterval(() => {
+      this.sendHeartbeat();
+    }, this.config.intervalMs);
+  }
+
+  stop(): void {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+  }
+
+  private async sendHeartbeat(): Promise<void> {
+    try {
+      const response = await fetch(`${this.config.url}/api/v1/agents/heartbeat`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.config.token}`,
+          "Content-Type": "application/json",
+        },
+      });
+
+      if (!response.ok) {
+        throw new Error(`Heartbeat failed: ${response.status}`);
+      }
+    } catch (error) {
+      this.config.onError?.(error as Error);
+    }
+  }
+}

package/src/core/injector.ts

@@ -0,0 +1,128 @@
+import { sendKeys } from "./tmux.js";
+import type { InboxItem } from "./registry.js";
+import type { WebSocketEvent } from "./websocket.js";
+
+export function injectStartupMessage(
+  agentName: string,
+  pendingCount: number
+): void {
+  if (pendingCount === 0) {
+    const message = `[AgentMesh] Connected and ready. No pending items in inbox.`;
+    sendKeys(agentName, message);
+    return;
+  }
+
+  const message = `[AgentMesh] Welcome back! You have ${pendingCount} pending handoff${pendingCount === 1 ? "" : "s"} in your inbox.
+Use agentmesh_check_inbox to see them, or agentmesh_accept_handoff to start working.`;
+
+  sendKeys(agentName, message);
+}
+
+export function injectHandoffReceived(
+  agentName: string,
+  event: WebSocketEvent
+): void {
+  const fromName =
+    (event.from_agent as { display_name?: string })?.display_name ||
+    (event.from_agent_id as string) ||
+    "Unknown";
+  const scope = (event.scope as string) || "No scope provided";
+  const reason = (event.reason as string) || "No reason provided";
+  const handoffId = (event.handoff_id as string) || (event.id as string) || "unknown";
+
+  const message = `[AgentMesh] New handoff from ${fromName}
+
+Scope: ${scope}
+Reason: ${reason}
+Handoff ID: ${handoffId}
+
+Accept this handoff and begin work.`;
+
+  sendKeys(agentName, message);
+}
+
+export function injectNudge(
+  agentName: string,
+  event: WebSocketEvent
+): void {
+  const fromName =
+    (event.from as { name?: string })?.name ||
+    (event.from_name as string) ||
+    "Someone";
+  const message = (event.message as string) || "Check your inbox";
+
+  const formatted = `[AgentMesh] Nudge from ${fromName}:
+${message}`;
+
+  sendKeys(agentName, formatted);
+}
+
+export function injectBlockerResolved(
+  agentName: string,
+  event: WebSocketEvent
+): void {
+  const description =
+    (event.description as string) || "A blocker has been resolved";
+  const resolvedBy =
+    (event.resolved_by as { display_name?: string })?.display_name ||
+    (event.resolved_by_name as string) ||
+    "Another agent";
+
+  const message = `[AgentMesh] Blocker resolved!
+
+Blocker: ${description}
+Resolved by: ${resolvedBy}
+
+You can now proceed with your work.`;
+
+  sendKeys(agentName, message);
+}
+
+export function injectInboxItems(
+  agentName: string,
+  items: InboxItem[]
+): void {
+  if (items.length === 0) {
+    sendKeys(agentName, "[AgentMesh] Your inbox is empty.");
+    return;
+  }
+
+  let message = `[AgentMesh] You have ${items.length} pending item${items.length === 1 ? "" : "s"}:\n\n`;
+
+  for (const item of items) {
+    const fromName = item.from_agent?.display_name || item.from_agent_id;
+    message += `- From: ${fromName}\n`;
+    message += `  Scope: ${item.scope}\n`;
+    message += `  ID: ${item.id}\n\n`;
+  }
+
+  message += "Use agentmesh_accept_handoff with the ID to start working.";
+
+  sendKeys(agentName, message);
+}
+
+export function handleWebSocketEvent(
+  agentName: string,
+  event: WebSocketEvent
+): void {
+  switch (event.type) {
+    case "handoff_received":
+    case "handoff.received":
+      injectHandoffReceived(agentName, event);
+      break;
+
+    case "nudge":
+    case "agent.nudge":
+      injectNudge(agentName, event);
+      break;
+
+    case "blocker_resolved":
+    case "blocker.resolved":
+      injectBlockerResolved(agentName, event);
+      break;
+
+    default:
+      // Unknown event type, ignore
+      break;
+  }
+}

package/src/core/registry.ts

@@ -0,0 +1,105 @@
+import { randomUUID } from "node:crypto";
+
+export interface RegisterOptions {
+  url: string;
+  apiKey: string;
+  workspace: string;
+  agentId?: string;
+  agentName: string;
+  model: string;
+  capabilities?: string[];
+}
+
+export interface RegisterResult {
+  agentId: string;
+  token: string;
+}
+
+export interface InboxItem {
+  id: string;
+  from_agent_id: string;
+  from_agent?: {
+    display_name?: string;
+  };
+  scope: string;
+  reason: string;
+  status: string;
+  created_at: string;
+}
+
+export async function registerAgent(
+  options: RegisterOptions
+): Promise<RegisterResult> {
+  const agentId = options.agentId || randomUUID();
+
+  const response = await fetch(`${options.url}/api/v1/agents/register`, {
+    method: "POST",
+    headers: {
+      "x-agentmesh-secret": options.apiKey,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      agent_id: agentId,
+      display_name: options.agentName,
+      model: options.model,
+      capabilities: options.capabilities || ["coding", "review", "debugging"],
+      workspace: options.workspace,
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Failed to register agent: ${error}`);
+  }
+
+  const data = await response.json();
+  const token = data.data?.token || data.token;
+
+  if (!token) {
+    throw new Error("No token in registration response");
+  }
+
+  return { agentId, token };
+}
+
+export async function checkInbox(
+  url: string,
+  workspace: string,
+  token: string
+): Promise<InboxItem[]> {
+  const response = await fetch(
+    `${url}/api/v1/workspaces/${workspace}/inbox`,
+    {
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+    }
+  );
+
+  if (!response.ok) {
+    throw new Error(`Failed to check inbox: ${response.status}`);
+  }
+
+  const data = await response.json();
+  return (data.data || []).filter(
+    (item: InboxItem) => item.status === "pending"
+  );
+}
+
+export async function sendNudge(
+  url: string,
+  agentId: string,
+  message: string,
+  token: string
+): Promise<boolean> {
+  const response = await fetch(`${url}/api/v1/agents/${agentId}/nudge`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ message }),
+  });
+
+  return response.ok;
+}

package/src/core/tmux.ts

@@ -0,0 +1,139 @@
+import { execSync, spawn, type ChildProcess } from "node:child_process";
+
+const SESSION_PREFIX = "agentmesh-";
+
+export function getSessionName(agentName: string): string {
+  return `${SESSION_PREFIX}${agentName}`;
+}
+
+export function sessionExists(sessionName: string): boolean {
+  try {
+    execSync(`tmux has-session -t "${sessionName}" 2>/dev/null`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function createSession(
+  agentName: string,
+  command: string,
+  workdir?: string
+): boolean {
+  const sessionName = getSessionName(agentName);
+
+  if (sessionExists(sessionName)) {
+    console.error(`Session ${sessionName} already exists`);
+    return false;
+  }
+
+  try {
+    const args = ["new-session", "-d", "-s", sessionName];
+
+    if (workdir) {
+      args.push("-c", workdir);
+    }
+
+    args.push(command);
+
+    execSync(`tmux ${args.join(" ")}`);
+    return true;
+  } catch (error) {
+    console.error(`Failed to create tmux session: ${error}`);
+    return false;
+  }
+}
+
+export function destroySession(agentName: string): boolean {
+  const sessionName = getSessionName(agentName);
+
+  if (!sessionExists(sessionName)) {
+    return true; // Already gone
+  }
+
+  try {
+    execSync(`tmux kill-session -t "${sessionName}"`);
+    return true;
+  } catch (error) {
+    console.error(`Failed to destroy tmux session: ${error}`);
+    return false;
+  }
+}
+
+export function sendKeys(agentName: string, message: string): boolean {
+  const sessionName = getSessionName(agentName);
+
+  if (!sessionExists(sessionName)) {
+    console.error(`Session ${sessionName} does not exist`);
+    return false;
+  }
+
+  try {
+    // Escape special characters for tmux
+    const escapedMessage = message
+      .replace(/\\/g, "\\\\")
+      .replace(/"/g, '\\"')
+      .replace(/\$/g, "\\$")
+      .replace(/`/g, "\\`");
+
+    execSync(`tmux send-keys -t "${sessionName}" "${escapedMessage}" Enter`);
+    return true;
+  } catch (error) {
+    console.error(`Failed to send keys: ${error}`);
+    return false;
+  }
+}
+
+export function attachSession(agentName: string): void {
+  const sessionName = getSessionName(agentName);
+
+  if (!sessionExists(sessionName)) {
+    console.error(`Session ${sessionName} does not exist`);
+    process.exit(1);
+  }
+
+  // Attach to the session (replaces current process)
+  const tmux = spawn("tmux", ["attach-session", "-t", sessionName], {
+    stdio: "inherit",
+  });
+
+  tmux.on("exit", (code) => {
+    process.exit(code ?? 0);
+  });
+}
+
+export function listSessions(): string[] {
+  try {
+    const output = execSync("tmux list-sessions -F '#{session_name}'", {
+      encoding: "utf-8",
+    });
+    return output
+      .trim()
+      .split("\n")
+      .filter((s) => s.startsWith(SESSION_PREFIX))
+      .map((s) => s.replace(SESSION_PREFIX, ""));
+  } catch {
+    return [];
+  }
+}
+
+export function getSessionInfo(
+  agentName: string
+): { exists: boolean; command?: string } {
+  const sessionName = getSessionName(agentName);
+
+  if (!sessionExists(sessionName)) {
+    return { exists: false };
+  }
+
+  try {
+    const command = execSync(
+      `tmux list-panes -t "${sessionName}" -F "#{pane_current_command}"`,
+      { encoding: "utf-8" }
+    ).trim();
+
+    return { exists: true, command };
+  } catch {
+    return { exists: true };
+  }
+}