@agentmeshhq/agent 0.1.7 → 0.1.9

package/src/context/storage.ts

@@ -0,0 +1,197 @@
+/**
+ * Context Storage Module
+ * Handles saving and loading agent context to/from disk
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { type AgentContext, CONTEXT_DIR, CONTEXT_VERSION, createEmptyContext } from "./schema.js";
+
+/**
+ * Ensures the context directory exists
+ */
+export function ensureContextDir(): void {
+  if (!fs.existsSync(CONTEXT_DIR)) {
+    fs.mkdirSync(CONTEXT_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Gets the context file path for an agent
+ */
+export function getContextPath(agentId: string): string {
+  return path.join(CONTEXT_DIR, `${agentId}.json`);
+}
+
+/**
+ * Saves agent context to disk
+ */
+export function saveContext(context: AgentContext): void {
+  ensureContextDir();
+  const contextPath = getContextPath(context.agentId);
+
+  // Update savedAt timestamp
+  context.savedAt = new Date().toISOString();
+
+  fs.writeFileSync(contextPath, JSON.stringify(context, null, 2));
+}
+
+/**
+ * Loads agent context from disk
+ * Returns null if context doesn't exist or is invalid
+ */
+export function loadContext(agentId: string): AgentContext | null {
+  const contextPath = getContextPath(agentId);
+
+  try {
+    if (!fs.existsSync(contextPath)) {
+      return null;
+    }
+
+    const content = fs.readFileSync(contextPath, "utf-8");
+    const context = JSON.parse(content) as AgentContext;
+
+    // Validate version
+    if (context.version !== CONTEXT_VERSION) {
+      // In the future, we can migrate old versions here
+      console.warn(`Context version mismatch: expected ${CONTEXT_VERSION}, got ${context.version}`);
+      return null;
+    }
+
+    return context;
+  } catch (error) {
+    console.error(`Failed to load context for agent ${agentId}:`, error);
+    return null;
+  }
+}
+
+/**
+ * Loads context or creates a new empty one
+ */
+export function loadOrCreateContext(agentId: string, agentName: string): AgentContext {
+  const existing = loadContext(agentId);
+  if (existing) {
+    return existing;
+  }
+  return createEmptyContext(agentId, agentName);
+}
+
+/**
+ * Deletes agent context from disk
+ */
+export function deleteContext(agentId: string): boolean {
+  const contextPath = getContextPath(agentId);
+
+  try {
+    if (fs.existsSync(contextPath)) {
+      fs.unlinkSync(contextPath);
+      return true;
+    }
+    return false;
+  } catch (error) {
+    console.error(`Failed to delete context for agent ${agentId}:`, error);
+    return false;
+  }
+}
+
+/**
+ * Lists all saved context files
+ */
+export function listContexts(): Array<{ agentId: string; savedAt: string }> {
+  ensureContextDir();
+
+  try {
+    const files = fs.readdirSync(CONTEXT_DIR);
+    const contexts: Array<{ agentId: string; savedAt: string }> = [];
+
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+
+      const agentId = file.replace(".json", "");
+      const context = loadContext(agentId);
+      if (context) {
+        contexts.push({
+          agentId,
+          savedAt: context.savedAt,
+        });
+      }
+    }
+
+    return contexts.sort((a, b) => new Date(b.savedAt).getTime() - new Date(a.savedAt).getTime());
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Updates specific fields in the context
+ */
+export function updateContext(
+  agentId: string,
+  updates: Partial<Omit<AgentContext, "version" | "agentId" | "savedAt">>,
+): AgentContext | null {
+  const context = loadContext(agentId);
+  if (!context) {
+    return null;
+  }
+
+  const updated: AgentContext = {
+    ...context,
+    ...updates,
+    // Preserve these fields
+    version: CONTEXT_VERSION,
+    agentId: context.agentId,
+    savedAt: new Date().toISOString(),
+  };
+
+  saveContext(updated);
+  return updated;
+}
+
+/**
+ * Exports context to a specified file path
+ */
+export function exportContext(agentId: string, outputPath: string): boolean {
+  const context = loadContext(agentId);
+  if (!context) {
+    return false;
+  }
+
+  try {
+    fs.writeFileSync(outputPath, JSON.stringify(context, null, 2));
+    return true;
+  } catch (error) {
+    console.error(`Failed to export context:`, error);
+    return false;
+  }
+}
+
+/**
+ * Imports context from a file path
+ */
+export function importContext(inputPath: string): AgentContext | null {
+  try {
+    if (!fs.existsSync(inputPath)) {
+      console.error(`File not found: ${inputPath}`);
+      return null;
+    }
+
+    const content = fs.readFileSync(inputPath, "utf-8");
+    const context = JSON.parse(content) as AgentContext;
+
+    // Validate required fields
+    if (!context.agentId || !context.agentName) {
+      console.error("Invalid context file: missing agentId or agentName");
+      return null;
+    }
+
+    // Update version and save
+    context.version = CONTEXT_VERSION;
+    saveContext(context);
+
+    return context;
+  } catch (error) {
+    console.error(`Failed to import context:`, error);
+    return null;
+  }
+}

package/src/core/daemon.ts

@@ -2,14 +2,18 @@ import {
   addAgentToState,
   getAgentState,
   loadConfig,
+  loadState,
   removeAgentFromState,
   updateAgentInState,
 } from "../config/loader.js";
 import type { AgentConfig, Config } from "../config/schema.js";
+import { loadContext, loadOrCreateContext, saveContext } from "../context/index.js";
 import { Heartbeat } from "./heartbeat.js";
-import { handleWebSocketEvent, injectStartupMessage } from "./injector.js";
+import { handleWebSocketEvent, injectRestoredContext, injectStartupMessage } from "./injector.js";
 import { checkInbox, registerAgent } from "./registry.js";
+import { buildRunnerConfig, getRunnerDisplayName, type RunnerConfig } from "./runner.js";
 import {
+  captureSessionContext,
   createSession,
   destroySession,
   getSessionName,
@@ -24,17 +28,21 @@ export interface DaemonOptions {
   workdir?: string;
   model?: string;
   daemonize?: boolean;
+  /** Whether to restore context from previous session (default: true) */
+  restoreContext?: boolean;
 }
 
 export class AgentDaemon {
   private agentName: string;
   private config: Config;
   private agentConfig: AgentConfig;
+  private runnerConfig: RunnerConfig;
   private ws: AgentWebSocket | null = null;
   private heartbeat: Heartbeat | null = null;
   private token: string | null = null;
   private agentId: string | null = null;
   private isRunning = false;
+  private shouldRestoreContext: boolean;
 
   constructor(options: DaemonOptions) {
     const config = loadConfig();
@@ -44,6 +52,7 @@ export class AgentDaemon {
 
     this.config = config;
     this.agentName = options.name;
+    this.shouldRestoreContext = options.restoreContext !== false;
 
     // Find or create agent config
     let agentConfig = config.agents.find((a) => a.name === options.name);
@@ -63,6 +72,58 @@ export class AgentDaemon {
     if (options.model) agentConfig.model = options.model;
 
     this.agentConfig = agentConfig;
+
+    // Build runner configuration with model resolution
+    this.runnerConfig = buildRunnerConfig({
+      cliModel: options.model,
+      agentModel: agentConfig.model,
+      defaultModel: config.defaults.model,
+      command: agentConfig.command,
+    });
+
+    const runnerName = getRunnerDisplayName(this.runnerConfig.type);
+    console.log(`Runner: ${runnerName}`);
+    console.log(`Effective model: ${this.runnerConfig.model}`);
+
+    // Check workdir conflicts - prevent multiple agents from using same directory
+    this.checkWorkdirConflict(agentConfig.workdir);
+  }
+
+  /**
+   * Checks if another agent is already using the specified workdir
+   */
+  private checkWorkdirConflict(workdir?: string): void {
+    if (!workdir) return;
+
+    const state = loadState();
+    const conflictingAgent = state.agents.find((a) => {
+      // Skip self
+      if (a.name === this.agentName) return false;
+
+      // Check if agent is actually running
+      if (!a.pid) return false;
+      try {
+        process.kill(a.pid, 0); // Check if process exists
+      } catch {
+        return false; // Process not running
+      }
+
+      // Check if session exists and has same workdir
+      // We need to check the config for this agent's workdir
+      const otherAgentConfig = this.config.agents.find((c) => c.name === a.name);
+      if (otherAgentConfig?.workdir === workdir) {
+        return true;
+      }
+
+      return false;
+    });
+
+    if (conflictingAgent) {
+      throw new Error(
+        `Workdir conflict: Agent "${conflictingAgent.name}" is already using "${workdir}".\n` +
+          `Use a different --workdir or stop the other agent first.`,
+      );
+    }
   }
 
   async start(): Promise<void> {
@@ -84,6 +145,7 @@ export class AgentDaemon {
         this.agentName,
         this.agentConfig.command,
         this.agentConfig.workdir,
+        this.runnerConfig.env, // Pass runner env vars (e.g., OPENCODE_MODEL)
       );
 
       if (!created) {
@@ -91,6 +153,10 @@ export class AgentDaemon {
       }
     } else {
       console.log(`Reconnecting to existing session: ${sessionName}`);
+      // Update environment for existing session
+      if (Object.keys(this.runnerConfig.env).length > 0) {
+        updateSessionEnvironment(this.agentName, this.runnerConfig.env);
+      }
     }
 
     // Register with hub
@@ -126,6 +192,8 @@ export class AgentDaemon {
       tmuxSession: sessionName,
       startedAt: new Date().toISOString(),
       token: this.token,
+      runtimeModel: this.runnerConfig.model,
+      runnerType: this.runnerConfig.type,
     });
 
     // Start heartbeat with auto-refresh
@@ -141,6 +209,11 @@ export class AgentDaemon {
       onError: (error) => {
         console.error("Heartbeat error:", error.message);
       },
+      onContextSave: () => {
+        // Periodically save context (every 5 heartbeats = ~2.5 minutes)
+        this.saveAgentContext();
+      },
+      contextSaveFrequency: 5,
       onTokenRefresh: (newToken) => {
         this.token = newToken;
         // Update state file
@@ -210,6 +283,18 @@ export class AgentDaemon {
       injectStartupMessage(this.agentName, 0);
     }
 
+    // Restore context from previous session
+    if (this.shouldRestoreContext && this.agentId) {
+      console.log("Checking for previous context...");
+      const savedContext = loadContext(this.agentId);
+      if (savedContext) {
+        console.log(`Restoring context from ${savedContext.savedAt}`);
+        // Wait a moment for the session to be ready
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        injectRestoredContext(this.agentName, savedContext);
+      }
+    }
+
     this.isRunning = true;
 
     console.log(`
@@ -235,6 +320,12 @@ Nudge agent:
 
     this.isRunning = false;
 
+    // Save context before stopping
+    if (this.agentId) {
+      console.log("Saving agent context...");
+      this.saveAgentContext();
+    }
+
     // Stop heartbeat
     if (this.heartbeat) {
       this.heartbeat.stop();
@@ -256,4 +347,33 @@ Nudge agent:
     console.log("Agent stopped.");
     process.exit(0);
   }
+
+  /**
+   * Saves the current agent context to disk
+   */
+  private saveAgentContext(): void {
+    if (!this.agentId) return;
+
+    try {
+      // Load existing context or create new
+      const context = loadOrCreateContext(this.agentId, this.agentName);
+
+      // Capture current session state
+      const sessionContext = captureSessionContext(this.agentName);
+      if (sessionContext) {
+        context.workingState = {
+          ...context.workingState,
+          workdir: sessionContext.workdir,
+          gitBranch: sessionContext.gitBranch,
+          gitStatus: sessionContext.gitStatus,
+        };
+      }
+
+      // Save updated context
+      saveContext(context);
+      console.log(`Context saved for agent ${this.agentName}`);
+    } catch (error) {
+      console.error("Failed to save agent context:", error);
+    }
+  }
 }

package/src/core/heartbeat.ts

@@ -13,16 +13,23 @@ export interface HeartbeatConfig {
   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 {
@@ -78,6 +85,12 @@ export class Heartbeat {
         }
         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);
     }

package/src/core/injector.ts

@@ -1,11 +1,10 @@
-import { sendKeys } from "./tmux.js";
+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
-): void {
+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);
@@ -18,10 +17,7 @@ Use agentmesh_check_inbox to see them, or agentmesh_accept_handoff to start work
   sendKeys(agentName, message);
 }
 
-export function injectHandoffReceived(
-  agentName: string,
-  event: WebSocketEvent
-): void {
+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) ||
@@ -41,14 +37,9 @@ Accept this handoff and begin work.`;
   sendKeys(agentName, message);
 }
 
-export function injectNudge(
-  agentName: string,
-  event: WebSocketEvent
-): void {
+export function injectNudge(agentName: string, event: WebSocketEvent): void {
   const fromName =
-    (event.from as { name?: string })?.name ||
-    (event.from_name as string) ||
-    "Someone";
+    (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}:
@@ -57,12 +48,8 @@ ${message}`;
   sendKeys(agentName, formatted);
 }
 
-export function injectBlockerResolved(
-  agentName: string,
-  event: WebSocketEvent
-): void {
-  const description =
-    (event.description as string) || "A blocker has been resolved";
+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) ||
@@ -78,10 +65,7 @@ You can now proceed with your work.`;
   sendKeys(agentName, message);
 }
 
-export function injectInboxItems(
-  agentName: string,
-  items: InboxItem[]
-): void {
+export function injectInboxItems(agentName: string, items: InboxItem[]): void {
   if (items.length === 0) {
     sendKeys(agentName, "[AgentMesh] Your inbox is empty.");
     return;
@@ -101,10 +85,7 @@ export function injectInboxItems(
   sendKeys(agentName, message);
 }
 
-export function handleWebSocketEvent(
-  agentName: string,
-  event: WebSocketEvent
-): void {
+export function handleWebSocketEvent(agentName: string, event: WebSocketEvent): void {
   switch (event.type) {
     case "handoff_received":
     case "handoff.received":
@@ -126,3 +107,66 @@ export function handleWebSocketEvent(
       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);
+}