@agentmeshhq/agent 0.2.0 → 0.2.1

package/src/core/heartbeat.ts

@@ -1,129 +0,0 @@
-import { getTokenTimeRemaining, isTokenExpiringSoon } from "../utils/jwt.js";
-
-// Refresh token when less than 24 hours remain
-const TOKEN_REFRESH_THRESHOLD_MS = 24 * 60 * 60 * 1000;
-
-export interface HeartbeatConfig {
-  url: string;
-  token: string;
-  intervalMs: number;
-  agentName: string;
-  agentId: string;
-  apiKey: string;
-  workspace: string;
-  onError?: (error: Error) => void;
-  onTokenRefresh?: (newToken: string) => void;
-  /** Called periodically to save agent context (every N heartbeats) */
-  onContextSave?: () => void;
-  /** How many heartbeats between context saves (default: 5) */
-  contextSaveFrequency?: number;
-}
-
-export class Heartbeat {
-  private config: HeartbeatConfig;
-  private currentToken: string;
-  private intervalId: NodeJS.Timeout | null = null;
-  private heartbeatCount = 0;
-  private contextSaveFrequency: number;
-
-  constructor(config: HeartbeatConfig) {
-    this.config = config;
-    this.currentToken = config.token;
-    this.contextSaveFrequency = config.contextSaveFrequency ?? 5;
-  }
-
-  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;
-    }
-  }
-
-  getToken(): string {
-    return this.currentToken;
-  }
-
-  private async sendHeartbeat(): Promise<void> {
-    try {
-      // Check if token needs refresh before sending heartbeat
-      if (isTokenExpiringSoon(this.currentToken, TOKEN_REFRESH_THRESHOLD_MS)) {
-        const remaining = getTokenTimeRemaining(this.currentToken);
-        const hours = Math.floor(remaining / (1000 * 60 * 60));
-        console.log(`Token expiring in ${hours} hours, refreshing...`);
-        await this.refreshToken();
-      }
-
-      const response = await fetch(`${this.config.url}/api/v1/agents/heartbeat`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${this.currentToken}`,
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({}),
-      });
-
-      if (!response.ok) {
-        // If unauthorized, try to refresh token
-        if (response.status === 401) {
-          console.log("Token rejected, attempting refresh...");
-          await this.refreshToken();
-          return;
-        }
-        throw new Error(`Heartbeat failed: ${response.status}`);
-      }
-
-      // Periodically save context
-      this.heartbeatCount++;
-      if (this.config.onContextSave && this.heartbeatCount % this.contextSaveFrequency === 0) {
-        this.config.onContextSave();
-      }
-    } catch (error) {
-      this.config.onError?.(error as Error);
-    }
-  }
-
-  private async refreshToken(): Promise<void> {
-    try {
-      const response = await fetch(`${this.config.url}/api/v1/agents/register`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-agentmesh-secret": this.config.apiKey,
-        },
-        body: JSON.stringify({
-          agent_id: this.config.agentId,
-          workspace: this.config.workspace,
-          display_name: this.config.agentName,
-          model: "claude-sonnet-4",
-        }),
-      });
-
-      if (!response.ok) {
-        throw new Error(`Token refresh failed: ${response.status}`);
-      }
-
-      const data = (await response.json()) as { token: string };
-      this.currentToken = data.token;
-
-      console.log("Token refreshed successfully");
-      this.config.onTokenRefresh?.(data.token);
-    } catch (error) {
-      console.error("Failed to refresh token:", (error as Error).message);
-      this.config.onError?.(error as Error);
-    }
-  }
-}

package/src/core/injector.ts

@@ -1,292 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { formatHandoffContextSummary, parseHandoffContext } from "../context/handoff.js";
-import type { AgentContext } from "../context/schema.js";
-import type { InboxItem } from "./registry.js";
-import { sendKeys } from "./tmux.js";
-import type { WebSocketEvent } from "./websocket.js";
-
-export function injectStartupMessage(
-  agentName: string,
-  pendingCount: number,
-  inboxItems?: InboxItem[],
-): void {
-  if (pendingCount === 0) {
-    const message = `[AgentMesh] Connected and ready. No pending items in inbox.`;
-    sendKeys(agentName, message);
-    return;
-  }
-
-  // Build detailed message with handoff info
-  let message = `[AgentMesh] Welcome back! You have ${pendingCount} pending handoff${pendingCount === 1 ? "" : "s"}.`;
-
-  if (inboxItems && inboxItems.length > 0) {
-    message += "\n\n--- PENDING HANDOFFS ---";
-    for (const item of inboxItems.slice(0, 3)) {
-      // Show up to 3
-      const fromName = item.from_agent?.display_name || item.from_agent_id || "Unknown";
-      message += `\n\nHandoff ID: ${item.id}`;
-      message += `\nFrom: ${fromName}`;
-      message += `\nScope: ${item.scope || "Not specified"}`;
-      message += `\nReason: ${item.reason || "Not specified"}`;
-    }
-    if (inboxItems.length > 3) {
-      message += `\n\n... and ${inboxItems.length - 3} more.`;
-    }
-    message += "\n\n--- END HANDOFFS ---";
-    message += "\n\nReview the handoff(s) above and begin work on the assigned task.";
-  } else {
-    message += "\nUse agentmesh_check_inbox to see them.";
-  }
-
-  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 interface EventContext {
-  hubUrl?: string;
-  token?: string;
-}
-
-interface SlackFile {
-  name: string;
-  type: string;
-  url: string;
-  permalink: string;
-  base64?: string;
-  mediaType?: string;
-}
-
-export function injectSlackMessage(
-  agentName: string,
-  event: WebSocketEvent,
-  _context?: EventContext,
-): void {
-  const user = (event.user as string) || "unknown";
-  const channel = (event.channel as string) || "unknown";
-  const text = (event.text as string) || "";
-  const files = (event.files as SlackFile[] | undefined) || [];
-
-  // Build message with file info
-  let message = `[Slack from ${user} in ${channel}] ${text}`;
-
-  if (files.length > 0) {
-    const savedImages: string[] = [];
-    const otherFiles: string[] = [];
-
-    // Save images with base64 data to disk
-    const attachmentsDir = join(process.env.HOME || "/tmp", ".agentmesh", "attachments");
-    if (!existsSync(attachmentsDir)) {
-      mkdirSync(attachmentsDir, { recursive: true });
-    }
-
-    for (const f of files) {
-      console.log(
-        `[Injector] File: ${f.name}, type: ${f.type}, mediaType: ${f.mediaType}, has base64: ${!!f.base64}`,
-      );
-      if (f.base64 && (f.mediaType?.startsWith("image/") || f.type?.startsWith("image/"))) {
-        // Save image to disk
-        const timestamp = Date.now();
-        const safeName = f.name.replace(/[^a-zA-Z0-9._-]/g, "_");
-        const filePath = join(attachmentsDir, `${timestamp}-${safeName}`);
-
-        try {
-          writeFileSync(filePath, Buffer.from(f.base64, "base64"));
-          savedImages.push(filePath);
-          console.log(`[Injector] Saved image to: ${filePath}`);
-        } catch (err) {
-          console.error(`[Injector] Failed to save image:`, err);
-          otherFiles.push(`${f.name} (failed to save)`);
-        }
-      } else {
-        // Just reference the URL for non-image files
-        otherFiles.push(`${f.name}: ${f.permalink}`);
-      }
-    }
-
-    // Add instruction to view images - OpenCode needs explicit instruction
-    if (savedImages.length > 0) {
-      message += `\n\nUser attached ${savedImages.length} image(s). Use the Read tool to view them:`;
-      for (const img of savedImages) {
-        message += `\n- ${img}`;
-      }
-    }
-
-    if (otherFiles.length > 0) {
-      message += ` [Other files: ${otherFiles.join(" | ")}]`;
-    }
-  }
-
-  console.log(`[Injector] Sending to tmux: ${message}`);
-  const result = sendKeys(agentName, message);
-  console.log(`[Injector] sendKeys result: ${result}`);
-}
-
-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,
-  context?: EventContext,
-): 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;
-
-    case "slack.message":
-      console.log(`[Injector] Handling slack.message for ${agentName}`);
-      console.log(`[Injector] Event keys: ${Object.keys(event).join(", ")}`);
-      if (event.files) {
-        const files = event.files as Array<{ name: string; base64?: string }>;
-        console.log(
-          `[Injector] Files count: ${files.length}, has base64: ${files.some((f) => !!f.base64)}`,
-        );
-      }
-      injectSlackMessage(agentName, event, context);
-      break;
-
-    default:
-      // Unknown event type, ignore
-      break;
-  }
-}
-
-/**
- * Injects restored context from a previous session
- */
-export function injectRestoredContext(agentName: string, context: AgentContext): void {
-  const parts: string[] = ["[AgentMesh] Restored context from previous session:"];
-
-  // Working state
-  if (context.workingState.workdir) {
-    parts.push(`Working directory: ${context.workingState.workdir}`);
-  }
-  if (context.workingState.gitBranch) {
-    parts.push(`Git branch: ${context.workingState.gitBranch}`);
-  }
-
-  // Tasks
-  const activeTasks = context.tasks.tasks.filter(
-    (t) => t.status === "in_progress" || t.status === "pending",
-  );
-  if (activeTasks.length > 0) {
-    parts.push("");
-    parts.push("Active tasks:");
-    for (const task of activeTasks.slice(0, 5)) {
-      const statusIcon = task.status === "in_progress" ? ">" : "-";
-      parts.push(`  ${statusIcon} ${task.content}`);
-    }
-    if (activeTasks.length > 5) {
-      parts.push(`  ... and ${activeTasks.length - 5} more`);
-    }
-  }
-
-  // Current goal
-  if (context.tasks.currentGoal) {
-    parts.push("");
-    parts.push(`Goal: ${context.tasks.currentGoal}`);
-  }
-
-  // Accomplishments
-  if (context.conversation.accomplishments.length > 0) {
-    parts.push("");
-    parts.push("Recent accomplishments:");
-    for (const acc of context.conversation.accomplishments.slice(0, 3)) {
-      parts.push(`  - ${acc}`);
-    }
-  }
-
-  const message = parts.join("\n");
-  sendKeys(agentName, message);
-}
-
-/**
- * Injects context received from a handoff
- */
-export function injectHandoffContext(agentName: string, contextString: string): void {
-  const context = parseHandoffContext(contextString);
-  if (!context) {
-    return;
-  }
-
-  const summary = formatHandoffContextSummary(context);
-  const message = `[AgentMesh] Context from previous agent:\n\n${summary}`;
-  sendKeys(agentName, message);
-}

package/src/core/registry.ts

@@ -1,159 +0,0 @@
-import { randomUUID } from "node:crypto";
-
-export interface RegisterOptions {
-  url: string;
-  apiKey: string;
-  workspace: string;
-  agentId?: string;
-  agentName: string;
-  model: string;
-  capabilities?: string[];
-  restoreContext?: boolean;
-}
-
-export type ServerContext = Record<string, Record<string, unknown>>;
-
-export interface RegisterResult {
-  agentId: string;
-  token: string;
-  status?: "registered" | "re-registered";
-  context?: ServerContext;
-  assignments?: ProjectAssignment[];
-}
-
-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,
-      restore_context: options.restoreContext ?? false,
-    }),
-  });
-
-  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,
-    status: data.status,
-    context: data.context,
-    assignments: data.assignments,
-  };
-}
-
-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;
-}
-
-// ============================================================================
-// Agent Self-Discovery
-// ============================================================================
-
-export interface ProjectAssignment {
-  assignment_id: string;
-  role: string;
-  status: string;
-  notes: string | null;
-  priority: number;
-  created_at: string;
-  project: {
-    project_id: string;
-    name: string;
-    code: string;
-    description: string | null;
-    workdir: string | null;
-  };
-  repo: {
-    repo_id: string;
-    provider: string;
-    full_name: string;
-    url: string;
-    default_branch: string;
-  } | null;
-}
-
-/**
- * Fetch the agent's project assignments from HQ
- */
-export async function fetchAssignments(url: string, token: string): Promise<ProjectAssignment[]> {
-  const response = await fetch(`${url}/api/v1/agents/me/assignments`, {
-    headers: {
-      Authorization: `Bearer ${token}`,
-    },
-  });
-
-  if (!response.ok) {
-    if (response.status === 404) {
-      return []; // No assignments
-    }
-    throw new Error(`Failed to fetch assignments: ${response.status}`);
-  }
-
-  const data = (await response.json()) as { data: ProjectAssignment[] };
-  return data.data || [];
-}