@agentmeshhq/agent 0.1.6 → 0.1.8

package/src/cli/context.ts

@@ -0,0 +1,232 @@
+import pc from "picocolors";
+import { getAgentState, loadState } from "../config/loader.js";
+import { extractHandoffContext, formatHandoffContextSummary } from "../context/handoff.js";
+import {
+  CONTEXT_DIR,
+  deleteContext,
+  exportContext,
+  importContext,
+  listContexts,
+  loadContext,
+} from "../context/index.js";
+
+export interface ContextOptions {
+  output?: string;
+}
+
+export async function contextCmd(
+  action: string,
+  nameOrPath?: string,
+  options?: ContextOptions,
+): Promise<void> {
+  switch (action) {
+    case "show":
+      await showContext(nameOrPath);
+      break;
+    case "clear":
+      await clearContext(nameOrPath);
+      break;
+    case "export":
+      await exportContextCmd(nameOrPath, options?.output);
+      break;
+    case "import":
+      await importContextCmd(nameOrPath);
+      break;
+    case "list":
+    case "ls":
+      await listContextsCmd();
+      break;
+    case "path":
+      console.log(CONTEXT_DIR);
+      break;
+    default:
+      console.log(pc.red(`Unknown action: ${action}`));
+      console.log("Available actions: show, clear, export, import, list, path");
+      process.exit(1);
+  }
+}
+
+async function showContext(name?: string): Promise<void> {
+  const agentId = await resolveAgentId(name);
+  if (!agentId) {
+    return;
+  }
+
+  const context = loadContext(agentId);
+  if (!context) {
+    console.log(pc.yellow(`No saved context found for agent.`));
+    return;
+  }
+
+  console.log(pc.bold(`Context for ${context.agentName} (${context.agentId}):`));
+  console.log(pc.dim(`Saved at: ${new Date(context.savedAt).toLocaleString()}`));
+  console.log();
+
+  // Working state
+  console.log(pc.bold("Working State:"));
+  console.log(`  Directory: ${context.workingState.workdir}`);
+  if (context.workingState.gitBranch) {
+    console.log(`  Git branch: ${context.workingState.gitBranch}`);
+  }
+  if (context.workingState.recentFiles.length > 0) {
+    console.log(`  Recent files: ${context.workingState.recentFiles.slice(0, 5).join(", ")}`);
+  }
+  console.log();
+
+  // Tasks
+  const activeTasks = context.tasks.tasks.filter(
+    (t) => t.status === "in_progress" || t.status === "pending",
+  );
+  if (activeTasks.length > 0 || context.tasks.currentGoal) {
+    console.log(pc.bold("Tasks:"));
+    if (context.tasks.currentGoal) {
+      console.log(`  Goal: ${context.tasks.currentGoal}`);
+    }
+    for (const task of activeTasks) {
+      const icon = task.status === "in_progress" ? pc.yellow(">") : pc.dim("-");
+      const priority =
+        task.priority === "high" ? pc.red(`[${task.priority}]`) : pc.dim(`[${task.priority}]`);
+      console.log(`  ${icon} ${task.content} ${priority}`);
+    }
+    console.log();
+  }
+
+  // Conversation
+  if (context.conversation.topics.length > 0 || context.conversation.accomplishments.length > 0) {
+    console.log(pc.bold("Conversation:"));
+    if (context.conversation.topics.length > 0) {
+      console.log(`  Topics: ${context.conversation.topics.join(", ")}`);
+    }
+    if (context.conversation.accomplishments.length > 0) {
+      console.log("  Accomplishments:");
+      for (const acc of context.conversation.accomplishments.slice(0, 5)) {
+        console.log(`    - ${acc}`);
+      }
+    }
+    console.log();
+  }
+
+  // Custom context
+  if (Object.keys(context.custom).length > 0) {
+    console.log(pc.bold("Custom Context:"));
+    console.log(JSON.stringify(context.custom, null, 2));
+  }
+}
+
+async function clearContext(name?: string): Promise<void> {
+  const agentId = await resolveAgentId(name);
+  if (!agentId) {
+    return;
+  }
+
+  const deleted = deleteContext(agentId);
+  if (deleted) {
+    console.log(pc.green(`Context cleared for agent.`));
+  } else {
+    console.log(pc.yellow(`No context found to clear.`));
+  }
+}
+
+async function exportContextCmd(name?: string, outputPath?: string): Promise<void> {
+  const agentId = await resolveAgentId(name);
+  if (!agentId) {
+    return;
+  }
+
+  const context = loadContext(agentId);
+  if (!context) {
+    console.log(pc.yellow(`No saved context found for agent.`));
+    return;
+  }
+
+  const output = outputPath || `${context.agentName}-context.json`;
+  const success = exportContext(agentId, output);
+
+  if (success) {
+    console.log(pc.green(`Context exported to: ${output}`));
+  } else {
+    console.log(pc.red(`Failed to export context.`));
+    process.exit(1);
+  }
+}
+
+async function importContextCmd(inputPath?: string): Promise<void> {
+  if (!inputPath) {
+    console.log(pc.red("Please specify a file path to import."));
+    console.log("Usage: agentmesh context import <file>");
+    process.exit(1);
+  }
+
+  const context = importContext(inputPath);
+  if (context) {
+    console.log(pc.green(`Context imported for agent: ${context.agentName} (${context.agentId})`));
+  } else {
+    console.log(pc.red(`Failed to import context from: ${inputPath}`));
+    process.exit(1);
+  }
+}
+
+async function listContextsCmd(): Promise<void> {
+  const contexts = listContexts();
+
+  if (contexts.length === 0) {
+    console.log(pc.yellow("No saved contexts found."));
+    return;
+  }
+
+  console.log(pc.bold("Saved Contexts:"));
+  console.log();
+
+  for (const ctx of contexts) {
+    const context = loadContext(ctx.agentId);
+    if (!context) continue;
+
+    console.log(`  ${pc.cyan(context.agentName)} (${pc.dim(ctx.agentId.slice(0, 8))}...)`);
+    console.log(`    Saved: ${new Date(ctx.savedAt).toLocaleString()}`);
+    if (context.tasks.currentGoal) {
+      console.log(`    Goal: ${context.tasks.currentGoal}`);
+    }
+    console.log();
+  }
+}
+
+async function resolveAgentId(name?: string): Promise<string | null> {
+  // If no name provided, try to get from environment
+  if (!name) {
+    const envAgentId = process.env.AGENTMESH_AGENT_ID;
+    if (envAgentId) {
+      return envAgentId;
+    }
+
+    // Try to find single running agent
+    const state = loadState();
+    if (state.agents.length === 1) {
+      return state.agents[0].agentId;
+    }
+
+    if (state.agents.length === 0) {
+      console.log(pc.yellow("No running agents found."));
+      console.log("Usage: agentmesh context show <name>");
+      return null;
+    }
+
+    console.log(pc.yellow("Multiple agents running. Please specify a name."));
+    console.log("Usage: agentmesh context show <name>");
+    return null;
+  }
+
+  // Try to find by name
+  const agentState = getAgentState(name);
+  if (agentState) {
+    return agentState.agentId;
+  }
+
+  // Maybe it's already an agent ID
+  const context = loadContext(name);
+  if (context) {
+    return name;
+  }
+
+  console.log(pc.red(`Agent not found: ${name}`));
+  return null;
+}

package/src/cli/index.ts

@@ -4,10 +4,15 @@ import { createRequire } from "node:module";
 import { Command } from "commander";
 import pc from "picocolors";
 import { attach } from "./attach.js";
+import { configCmd } from "./config.js";
+import { contextCmd } from "./context.js";
 import { init } from "./init.js";
 import { list } from "./list.js";
+import { logs } from "./logs.js";
 import { nudge } from "./nudge.js";
+import { restart } from "./restart.js";
 import { start } from "./start.js";
+import { status } from "./status.js";
 import { stop } from "./stop.js";
 import { token } from "./token.js";
 import { whoami } from "./whoami.js";
@@ -42,6 +47,7 @@ program
   .option("-w, --workdir <path>", "Working directory")
   .option("-m, --model <model>", "Model identifier")
   .option("-f, --foreground", "Run in foreground (blocking)")
+  .option("--no-context", "Start fresh without restoring previous context")
   .action(async (options) => {
     try {
       await start(options);
@@ -131,4 +137,74 @@ program
     }
   });
 
+program
+  .command("status")
+  .description("Show AgentMesh status and health")
+  .action(async () => {
+    try {
+      await status();
+    } catch (error) {
+      console.error(pc.red((error as Error).message));
+      process.exit(1);
+    }
+  });
+
+program
+  .command("logs")
+  .description("View agent session logs")
+  .argument("<name>", "Agent name")
+  .option("-f, --follow", "Follow log output (attach read-only)")
+  .option("-n, --lines <number>", "Number of lines to show", "50")
+  .action(async (name, options) => {
+    try {
+      await logs(name, { follow: options.follow, lines: parseInt(options.lines, 10) });
+    } catch (error) {
+      console.error(pc.red((error as Error).message));
+      process.exit(1);
+    }
+  });
+
+program
+  .command("restart")
+  .description("Restart an agent (preserves agent ID)")
+  .argument("<name>", "Agent name")
+  .action(async (name) => {
+    try {
+      await restart(name);
+    } catch (error) {
+      console.error(pc.red((error as Error).message));
+      process.exit(1);
+    }
+  });
+
+program
+  .command("config")
+  .description("View or edit configuration")
+  .argument("[action]", "Action: show (default), get, set, edit, path")
+  .argument("[key]", "Config key (for get/set)")
+  .argument("[value]", "Config value (for set)")
+  .action(async (action, key, value) => {
+    try {
+      await configCmd(action || "show", key, value);
+    } catch (error) {
+      console.error(pc.red((error as Error).message));
+      process.exit(1);
+    }
+  });
+
+program
+  .command("context")
+  .description("Manage agent context persistence")
+  .argument("[action]", "Action: show (default), clear, export, import, list, path")
+  .argument("[name]", "Agent name or file path (for import)")
+  .option("-o, --output <path>", "Output file path (for export)")
+  .action(async (action, name, options) => {
+    try {
+      await contextCmd(action || "show", name, options);
+    } catch (error) {
+      console.error(pc.red((error as Error).message));
+      process.exit(1);
+    }
+  });
+
 program.parse();

package/src/cli/logs.ts

@@ -0,0 +1,64 @@
+import { spawn } from "node:child_process";
+import pc from "picocolors";
+import { getAgentState, loadConfig } from "../config/loader.js";
+import { getSessionName, sessionExists } from "../core/tmux.js";
+
+export async function logs(
+  name: string,
+  options: { follow?: boolean; lines?: number },
+): Promise<void> {
+  const config = loadConfig();
+
+  if (!config) {
+    console.log(pc.red("No config found. Run 'agentmesh init' first."));
+    process.exit(1);
+  }
+
+  const agent = getAgentState(name);
+  if (!agent) {
+    console.log(pc.red(`Agent "${name}" not found.`));
+    process.exit(1);
+  }
+
+  const sessionName = getSessionName(name);
+  if (!sessionExists(sessionName)) {
+    console.log(pc.red(`Session "${sessionName}" not running.`));
+    process.exit(1);
+  }
+
+  const lines = options.lines || 50;
+
+  // Capture pane content using tmux capture-pane
+  if (options.follow) {
+    // Follow mode - attach in view-only mode
+    console.log(pc.dim(`Following logs for "${name}"... (Ctrl+C to exit)`));
+    console.log(pc.dim("─".repeat(60)));
+
+    // Use tmux pipe-pane to stream output
+    const tmux = spawn("tmux", ["attach-session", "-t", sessionName, "-r"], {
+      stdio: "inherit",
+    });
+
+    tmux.on("exit", (code) => {
+      process.exit(code ?? 0);
+    });
+  } else {
+    // Static mode - capture and print
+    try {
+      const { execSync } = await import("node:child_process");
+
+      // Capture the pane history
+      const output = execSync(`tmux capture-pane -t "${sessionName}" -p -S -${lines}`, {
+        encoding: "utf-8",
+        maxBuffer: 10 * 1024 * 1024,
+      });
+
+      console.log(pc.dim(`Last ${lines} lines from "${name}":`));
+      console.log(pc.dim("─".repeat(60)));
+      console.log(output);
+    } catch (error) {
+      console.log(pc.red(`Failed to capture logs: ${(error as Error).message}`));
+      process.exit(1);
+    }
+  }
+}

package/src/cli/restart.ts

@@ -0,0 +1,50 @@
+import pc from "picocolors";
+import { getAgentState, loadConfig } from "../config/loader.js";
+import { destroySession, getSessionName, sessionExists } from "../core/tmux.js";
+import { start } from "./start.js";
+import { stop } from "./stop.js";
+
+export async function restart(name: string): Promise<void> {
+  const config = loadConfig();
+
+  if (!config) {
+    console.log(pc.red("No config found. Run 'agentmesh init' first."));
+    process.exit(1);
+  }
+
+  const agent = getAgentState(name);
+  if (!agent) {
+    console.log(pc.red(`Agent "${name}" not found in state.`));
+    console.log(pc.dim("Use 'agentmesh start' to create a new agent."));
+    process.exit(1);
+  }
+
+  console.log(pc.dim(`Restarting agent "${name}"...`));
+
+  // Stop the agent (but preserve the agent ID for re-registration)
+  const sessionName = getSessionName(name);
+  if (sessionExists(sessionName)) {
+    console.log(pc.dim("Stopping current session..."));
+    await stop(name);
+
+    // Small delay to ensure clean shutdown
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  }
+
+  // Find agent config to get workdir and other settings
+  const agentConfig = config.agents.find((a) => a.name === name);
+
+  console.log(pc.dim("Starting new session..."));
+
+  // Start with the same settings, agent ID will be reused from state
+  await start({
+    name,
+    command: agentConfig?.command,
+    workdir: agentConfig?.workdir,
+    model: agentConfig?.model,
+    foreground: false,
+  });
+
+  console.log(pc.green(`Agent "${name}" restarted.`));
+  console.log(pc.dim(`Agent ID preserved: ${agent.agentId}`));
+}

package/src/cli/start.ts

@@ -1,10 +1,10 @@
 import { spawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
 import path from "node:path";
-import { AgentDaemon } from "../core/daemon.js";
-import { loadConfig, getAgentState } from "../config/loader.js";
-import { sessionExists, getSessionName } from "../core/tmux.js";
+import { fileURLToPath } from "node:url";
 import pc from "picocolors";
+import { getAgentState, loadConfig } from "../config/loader.js";
+import { AgentDaemon } from "../core/daemon.js";
+import { getSessionName, sessionExists } from "../core/tmux.js";
 
 export interface StartOptions {
   name: string;
@@ -12,6 +12,7 @@ export interface StartOptions {
   workdir?: string;
   model?: string;
   foreground?: boolean;
+  noContext?: boolean;
 }
 
 export async function start(options: StartOptions): Promise<void> {
@@ -40,7 +41,10 @@ export async function start(options: StartOptions): Promise<void> {
   // If --foreground flag is set, run in foreground (blocking)
   if (options.foreground) {
     try {
-      const daemon = new AgentDaemon(options);
+      const daemon = new AgentDaemon({
+        ...options,
+        restoreContext: !options.noContext,
+      });
       await daemon.start();
       // Keep process alive
       await new Promise(() => {});
@@ -55,16 +59,14 @@ export async function start(options: StartOptions): Promise<void> {
   console.log(`Starting agent "${options.name}" in background...`);
 
   // Get the path to this CLI
-  const cliPath = path.resolve(
-    path.dirname(fileURLToPath(import.meta.url)),
-    "../cli/index.js"
-  );
+  const cliPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../cli/index.js");
 
   // Build args for the background process
   const args = ["start", "--name", options.name, "--foreground"];
   if (options.command) args.push("--command", options.command);
   if (options.workdir) args.push("--workdir", options.workdir);
   if (options.model) args.push("--model", options.model);
+  if (options.noContext) args.push("--no-context");
 
   // Spawn detached background process
   const child = spawn("node", [cliPath, ...args], {

package/src/cli/status.ts

@@ -0,0 +1,83 @@
+import pc from "picocolors";
+import { loadConfig, loadState } from "../config/loader.js";
+import { getSessionName, sessionExists } from "../core/tmux.js";
+
+interface HealthResponse {
+  status: string;
+  service?: string;
+  version?: string;
+}
+
+export async function status(): Promise<void> {
+  const config = loadConfig();
+
+  if (!config) {
+    console.log(pc.red("No config found. Run 'agentmesh init' first."));
+    process.exit(1);
+  }
+
+  console.log(pc.bold("AgentMesh Status\n"));
+
+  // Check hub connectivity
+  console.log(pc.dim("Hub:"));
+  try {
+    const response = await fetch(`${config.hubUrl}/health`, {
+      signal: AbortSignal.timeout(5000),
+    });
+
+    if (response.ok) {
+      const data = (await response.json()) as HealthResponse;
+      console.log(`  URL:      ${pc.cyan(config.hubUrl)}`);
+      console.log(`  Status:   ${pc.green("connected")}`);
+      if (data.version) {
+        console.log(`  Version:  ${pc.dim(data.version)}`);
+      }
+    } else {
+      console.log(`  URL:      ${pc.cyan(config.hubUrl)}`);
+      console.log(`  Status:   ${pc.yellow(`HTTP ${response.status}`)}`);
+    }
+  } catch (error) {
+    console.log(`  URL:      ${pc.cyan(config.hubUrl)}`);
+    console.log(`  Status:   ${pc.red("unreachable")}`);
+    console.log(`  Error:    ${pc.dim((error as Error).message)}`);
+  }
+
+  // Check local agents
+  const state = loadState();
+  const runningAgents = state.agents.filter((a) => {
+    if (!a.pid) return false;
+    try {
+      process.kill(a.pid, 0);
+      return sessionExists(getSessionName(a.name));
+    } catch {
+      return false;
+    }
+  });
+
+  console.log();
+  console.log(pc.dim("Local Agents:"));
+  console.log(`  Running:  ${pc.cyan(String(runningAgents.length))}`);
+  console.log(`  Total:    ${pc.dim(String(state.agents.length))}`);
+
+  if (runningAgents.length > 0) {
+    console.log(`  Names:    ${pc.dim(runningAgents.map((a) => a.name).join(", "))}`);
+  }
+
+  // Check tmux
+  console.log();
+  console.log(pc.dim("Dependencies:"));
+  try {
+    const { execSync } = await import("node:child_process");
+    const tmuxVersion = execSync("tmux -V", { encoding: "utf-8" }).trim();
+    console.log(`  tmux:     ${pc.green(tmuxVersion)}`);
+  } catch {
+    console.log(`  tmux:     ${pc.red("not found")}`);
+  }
+
+  // Config info
+  console.log();
+  console.log(pc.dim("Config:"));
+  console.log(`  Workspace: ${pc.cyan(config.workspace)}`);
+  console.log(`  Command:   ${pc.dim(config.defaults.command)}`);
+  console.log(`  Model:     ${pc.dim(config.defaults.model)}`);
+}

package/src/context/handoff.ts

@@ -0,0 +1,122 @@
+/**
+ * Context Handoff Module
+ * Functions for sharing context between agents via handoffs
+ */
+
+import type { AgentContext } from "./schema.js";
+import { loadContext } from "./storage.js";
+
+/**
+ * Minimal context for handoff (excludes sensitive/large data)
+ */
+export interface HandoffContext {
+  /** Working directory */
+  workdir: string;
+  /** Git branch if in a repo */
+  gitBranch?: string;
+  /** Current goal being worked on */
+  currentGoal?: string;
+  /** Active tasks (in_progress and pending) */
+  activeTasks: Array<{
+    content: string;
+    status: "in_progress" | "pending";
+    priority: string;
+  }>;
+  /** Recent accomplishments */
+  recentAccomplishments: string[];
+  /** Key topics from conversation */
+  topics: string[];
+  /** Any custom context data */
+  custom?: Record<string, unknown>;
+}
+
+/**
+ * Extracts handoff-relevant context from full agent context
+ */
+export function extractHandoffContext(context: AgentContext): HandoffContext {
+  return {
+    workdir: context.workingState.workdir,
+    gitBranch: context.workingState.gitBranch,
+    currentGoal: context.tasks.currentGoal,
+    activeTasks: context.tasks.tasks
+      .filter((t) => t.status === "in_progress" || t.status === "pending")
+      .map((t) => ({
+        content: t.content,
+        status: t.status as "in_progress" | "pending",
+        priority: t.priority,
+      })),
+    recentAccomplishments: context.conversation.accomplishments.slice(0, 5),
+    topics: context.conversation.topics.slice(0, 10),
+    custom: Object.keys(context.custom).length > 0 ? context.custom : undefined,
+  };
+}
+
+/**
+ * Gets handoff context for an agent by ID
+ */
+export function getHandoffContextForAgent(agentId: string): HandoffContext | null {
+  const context = loadContext(agentId);
+  if (!context) {
+    return null;
+  }
+  return extractHandoffContext(context);
+}
+
+/**
+ * Serializes handoff context to a string for inclusion in API calls
+ */
+export function serializeHandoffContext(context: HandoffContext): string {
+  return JSON.stringify(context);
+}
+
+/**
+ * Parses handoff context from a string (received from API)
+ */
+export function parseHandoffContext(contextString: string): HandoffContext | null {
+  try {
+    return JSON.parse(contextString) as HandoffContext;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Generates a human-readable summary of handoff context
+ */
+export function formatHandoffContextSummary(context: HandoffContext): string {
+  const lines: string[] = [];
+
+  if (context.workdir) {
+    lines.push(`Working directory: ${context.workdir}`);
+  }
+  if (context.gitBranch) {
+    lines.push(`Git branch: ${context.gitBranch}`);
+  }
+  if (context.currentGoal) {
+    lines.push(`Current goal: ${context.currentGoal}`);
+  }
+
+  if (context.activeTasks.length > 0) {
+    lines.push("");
+    lines.push("Active tasks:");
+    for (const task of context.activeTasks) {
+      const icon = task.status === "in_progress" ? ">" : "-";
+      lines.push(`  ${icon} ${task.content}`);
+    }
+  }
+
+  if (context.recentAccomplishments.length > 0) {
+    lines.push("");
+    lines.push("Recent accomplishments:");
+    for (const acc of context.recentAccomplishments) {
+      lines.push(`  - ${acc}`);
+    }
+  }
+
+  if (context.topics.length > 0) {
+    lines.push("");
+    lines.push(`Topics: ${context.topics.join(", ")}`);
+  }
+
+  return lines.join("\n");
+}