@agentmeshhq/agent 0.1.8 → 0.1.10

package/src/core/daemon.ts

@@ -1,3 +1,7 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import {
   addAgentToState,
   getAgentState,
@@ -9,7 +13,13 @@ import type { AgentConfig, Config } from "../config/schema.js";
 import { loadContext, loadOrCreateContext, saveContext } from "../context/index.js";
 import { Heartbeat } from "./heartbeat.js";
 import { handleWebSocketEvent, injectRestoredContext, injectStartupMessage } from "./injector.js";
-import { checkInbox, registerAgent } from "./registry.js";
+import { checkInbox, fetchAssignments, registerAgent } from "./registry.js";
+import {
+  buildRunnerConfig,
+  detectRunner,
+  getRunnerDisplayName,
+  type RunnerConfig,
+} from "./runner.js";
 import {
   captureSessionContext,
   createSession,
@@ -28,18 +38,22 @@ export interface DaemonOptions {
   daemonize?: boolean;
   /** Whether to restore context from previous session (default: true) */
   restoreContext?: boolean;
+  /** Auto-clone repository for project assignments */
+  autoSetup?: 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;
+  private autoSetup: boolean;
 
   constructor(options: DaemonOptions) {
     const config = loadConfig();
@@ -50,6 +64,7 @@ export class AgentDaemon {
     this.config = config;
     this.agentName = options.name;
     this.shouldRestoreContext = options.restoreContext !== false;
+    this.autoSetup = options.autoSetup === true;
 
     // Find or create agent config
     let agentConfig = config.agents.find((a) => a.name === options.name);
@@ -69,6 +84,18 @@ 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}`);
   }
 
   async start(): Promise<void> {
@@ -79,6 +106,27 @@ export class AgentDaemon {
 
     console.log(`Starting agent: ${this.agentName}`);
 
+    // Register with hub first (needed for assignment check)
+    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}`);
+
+    // Check assignments and auto-setup workdir if needed (before creating tmux session)
+    await this.checkAssignments();
+
     // Check if session already exists
     const sessionName = getSessionName(this.agentName);
     const sessionAlreadyExists = sessionExists(sessionName);
@@ -86,10 +134,13 @@ export class AgentDaemon {
     // Create tmux session if it doesn't exist
     if (!sessionAlreadyExists) {
       console.log(`Creating tmux session: ${sessionName}`);
+
+      // Include runner env vars (e.g., OPENCODE_MODEL) at session creation
       const created = createSession(
         this.agentName,
         this.agentConfig.command,
         this.agentConfig.workdir,
+        this.runnerConfig.env, // Apply model env at process start
       );
 
       if (!created) {
@@ -97,26 +148,10 @@ export class AgentDaemon {
       }
     } else {
       console.log(`Reconnecting to existing session: ${sessionName}`);
+      // Update environment for existing session
+      updateSessionEnvironment(this.agentName, this.runnerConfig.env);
     }
 
-    // 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}`);
-
     // Inject environment variables into tmux session
     console.log("Injecting environment variables...");
     updateSessionEnvironment(this.agentName, {
@@ -124,7 +159,7 @@ export class AgentDaemon {
       AGENTMESH_AGENT_ID: this.agentId,
     });
 
-    // Save state
+    // Save state including runtime model info
     addAgentToState({
       name: this.agentName,
       agentId: this.agentId,
@@ -132,6 +167,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
@@ -314,4 +351,170 @@ Nudge agent:
       console.error("Failed to save agent context:", error);
     }
   }
+
+  /**
+   * Fetches assignments from HQ and validates workdir setup
+   * Uses project.workdir from HQ as source of truth, falls back to helpful instructions
+   */
+  private async checkAssignments(): Promise<void> {
+    if (!this.token) return;
+
+    try {
+      console.log("Fetching project assignments from HQ...");
+      const assignments = await fetchAssignments(this.config.hubUrl, this.token);
+
+      if (assignments.length === 0) {
+        console.log("No project assignments found.");
+        return;
+      }
+
+      console.log(`Found ${assignments.length} assignment(s):`);
+      for (const assignment of assignments) {
+        const repoInfo = assignment.repo ? ` -> ${assignment.repo.full_name}` : "";
+        const workdirInfo = assignment.project.workdir ? ` [${assignment.project.workdir}]` : "";
+        console.log(`  - ${assignment.project.name} (${assignment.role})${repoInfo}${workdirInfo}`);
+      }
+
+      // If no CLI workdir specified, try to use project.workdir from HQ
+      if (!this.agentConfig.workdir) {
+        const assignmentWithWorkdir = assignments.find((a) => a.project.workdir);
+        if (assignmentWithWorkdir?.project.workdir) {
+          console.log(
+            `Using workdir from project settings: ${assignmentWithWorkdir.project.workdir}`,
+          );
+          this.agentConfig.workdir = assignmentWithWorkdir.project.workdir;
+          return;
+        }
+
+        // No project.workdir set, check if we have a repo assignment
+        const repoAssignment = assignments.find((a) => a.repo !== null);
+        if (repoAssignment) {
+          const repo = repoAssignment.repo!;
+          const expandedPath = path.join(
+            os.homedir(),
+            ".agentmesh",
+            "workspaces",
+            this.config.workspace,
+            repoAssignment.project.code.toLowerCase(),
+            this.agentName,
+          );
+          const suggestedPath = `~/.agentmesh/workspaces/${this.config.workspace}/${repoAssignment.project.code.toLowerCase()}/${this.agentName}`;
+
+          // If --auto-setup is enabled, automatically clone the repo
+          if (this.autoSetup) {
+            this.agentConfig.workdir = this.setupWorkspace(
+              expandedPath,
+              repo.url,
+              repo.default_branch,
+              repoAssignment.project.name,
+            );
+            return;
+          }
+
+          console.error(`
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+⚠️  WORKDIR REQUIRED
+
+You have a project assignment with a repository, but no workdir is configured.
+
+Project:  ${repoAssignment.project.name}
+Repo:     ${repo.full_name}
+Branch:   ${repo.default_branch}
+
+Option 1: Set workdir in project settings (recommended)
+  - Go to AgentMesh HQ → Projects → ${repoAssignment.project.name} → Settings
+  - Set the workdir field to the local path
+
+Option 2: Set up workspace manually and pass --workdir:
+
+  mkdir -p ${suggestedPath}
+  git clone ${repo.url} ${suggestedPath}
+  cd ${suggestedPath} && git checkout ${repo.default_branch}
+
+Then start the agent with:
+
+  agentmesh start -n ${this.agentName} --workdir ${suggestedPath}
+
+Option 3: Use --auto-setup to automatically clone the repository:
+
+  agentmesh start -n ${this.agentName} --auto-setup
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`);
+          // No session to clean up - we haven't created it yet
+          process.exit(1);
+        }
+      }
+    } catch (error) {
+      // Non-fatal: log and continue (HQ might not have assignments feature yet)
+      console.log("Could not fetch assignments:", (error as Error).message);
+    }
+  }
+
+  /**
+   * Sets up workspace by cloning repository or using existing clone
+   * Returns the absolute path to the workspace
+   */
+  private setupWorkspace(
+    workspacePath: string,
+    repoUrl: string,
+    defaultBranch: string,
+    projectName: string,
+  ): string {
+    console.log(
+      `\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`,
+    );
+    console.log(`🔧 AUTO-SETUP: Setting up workspace for ${projectName}`);
+    console.log(
+      `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`,
+    );
+
+    // Check if directory already exists and is a git repo
+    const gitDir = path.join(workspacePath, ".git");
+    if (fs.existsSync(gitDir)) {
+      console.log(`✓ Workspace already exists: ${workspacePath}`);
+      console.log(`  Updating from remote...`);
+
+      try {
+        // Fetch and checkout the branch
+        execSync(`git fetch origin`, { cwd: workspacePath, stdio: "inherit" });
+        execSync(`git checkout ${defaultBranch}`, { cwd: workspacePath, stdio: "inherit" });
+        execSync(`git pull origin ${defaultBranch}`, { cwd: workspacePath, stdio: "inherit" });
+        console.log(`✓ Workspace updated successfully\n`);
+      } catch (error) {
+        console.warn(`⚠ Could not update workspace: ${(error as Error).message}`);
+        console.log(`  Continuing with existing state...\n`);
+      }
+
+      return workspacePath;
+    }
+
+    // Create parent directories
+    const parentDir = path.dirname(workspacePath);
+    if (!fs.existsSync(parentDir)) {
+      console.log(`Creating directory: ${parentDir}`);
+      fs.mkdirSync(parentDir, { recursive: true });
+    }
+
+    // Clone the repository
+    console.log(`Cloning repository...`);
+    console.log(`  URL: ${repoUrl}`);
+    console.log(`  Path: ${workspacePath}`);
+    console.log(`  Branch: ${defaultBranch}\n`);
+
+    try {
+      execSync(`git clone --branch ${defaultBranch} "${repoUrl}" "${workspacePath}"`, {
+        stdio: "inherit",
+      });
+      console.log(`\n✓ Repository cloned successfully`);
+    } catch (error) {
+      console.error(`\n✗ Failed to clone repository: ${(error as Error).message}`);
+      console.error(`\nMake sure you have access to the repository and SSH keys are configured.`);
+      // No session to clean up - we haven't created it yet
+      process.exit(1);
+    }
+
+    console.log(`✓ Workspace ready: ${workspacePath}\n`);
+    return workspacePath;
+  }
 }

package/src/core/registry.ts

@@ -27,9 +27,7 @@ export interface InboxItem {
   created_at: string;
 }
 
-export async function registerAgent(
-  options: RegisterOptions
-): Promise<RegisterResult> {
+export async function registerAgent(options: RegisterOptions): Promise<RegisterResult> {
   const agentId = options.agentId || randomUUID();
 
   const response = await fetch(`${options.url}/api/v1/agents/register`, {
@@ -65,32 +63,27 @@ export async function registerAgent(
 export async function checkInbox(
   url: string,
   workspace: string,
-  token: string
+  token: string,
 ): Promise<InboxItem[]> {
-  const response = await fetch(
-    `${url}/api/v1/workspaces/${workspace}/inbox`,
-    {
-      headers: {
-        Authorization: `Bearer ${token}`,
-      },
-    }
-  );
+  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"
-  );
+  return (data.data || []).filter((item: InboxItem) => item.status === "pending");
 }
 
 export async function sendNudge(
   url: string,
   agentId: string,
   message: string,
-  token: string
+  token: string,
 ): Promise<boolean> {
   const response = await fetch(`${url}/api/v1/agents/${agentId}/nudge`, {
     method: "POST",
@@ -103,3 +96,51 @@ export async function sendNudge(
 
   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 || [];
+}

package/src/core/runner.ts

@@ -0,0 +1,200 @@
+/**
+ * Runner Module
+ * Handles model resolution, validation, and runner-specific configuration
+ */
+
+import { execSync } from "node:child_process";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type RunnerType = "opencode" | "claude" | "custom";
+
+export interface RunnerConfig {
+  type: RunnerType;
+  command: string;
+  model: string;
+  env: Record<string, string>;
+}
+
+export interface ModelResolutionInput {
+  cliModel?: string;
+  agentModel?: string;
+  defaultModel: string;
+  command: string;
+}
+
+// ============================================================================
+// Runner Detection
+// ============================================================================
+
+/**
+ * Detects the runner type from the command
+ */
+export function detectRunner(command: string): RunnerType {
+  const cmd = command.toLowerCase().trim();
+
+  if (cmd === "opencode" || cmd.startsWith("opencode ")) {
+    return "opencode";
+  }
+
+  if (cmd === "claude" || cmd.startsWith("claude ")) {
+    return "claude";
+  }
+
+  return "custom";
+}
+
+// ============================================================================
+// Model Resolution
+// ============================================================================
+
+/**
+ * Resolves the effective model from CLI > agent config > defaults
+ */
+export function resolveModel(input: ModelResolutionInput): string {
+  // Priority: CLI flag > agent config > default
+  return input.cliModel || input.agentModel || input.defaultModel;
+}
+
+// ============================================================================
+// OpenCode Integration
+// ============================================================================
+
+let cachedOpenCodeModels: string[] | null = null;
+
+/**
+ * Gets available OpenCode models (cached)
+ */
+export function getOpenCodeModels(): string[] {
+  if (cachedOpenCodeModels) {
+    return cachedOpenCodeModels;
+  }
+
+  try {
+    const output = execSync("opencode models 2>/dev/null", {
+      encoding: "utf-8",
+      timeout: 10000,
+    });
+
+    cachedOpenCodeModels = output
+      .split("\n")
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0 && !line.startsWith("#"));
+
+    return cachedOpenCodeModels;
+  } catch {
+    // OpenCode not available or failed
+    return [];
+  }
+}
+
+/**
+ * Validates that a model is available in OpenCode
+ */
+export function validateOpenCodeModel(model: string): { valid: boolean; error?: string } {
+  const models = getOpenCodeModels();
+
+  // If we couldn't get models list, allow any (graceful degradation)
+  if (models.length === 0) {
+    return { valid: true };
+  }
+
+  if (models.includes(model)) {
+    return { valid: true };
+  }
+
+  // Check for partial match (e.g., "claude-sonnet-4" matches "anthropic/claude-sonnet-4")
+  const partialMatch = models.find(
+    (m) => m.endsWith(`/${model}`) || m === model || m.split("/").pop() === model,
+  );
+
+  if (partialMatch) {
+    return { valid: true };
+  }
+
+  return {
+    valid: false,
+    error: `Model "${model}" not found in OpenCode. Run 'opencode models' to see available models.`,
+  };
+}
+
+/**
+ * Normalizes a model name for OpenCode
+ * e.g., "claude-sonnet-4" -> "anthropic/claude-sonnet-4" if that's what OpenCode expects
+ */
+export function normalizeOpenCodeModel(model: string): string {
+  const models = getOpenCodeModels();
+
+  // Direct match
+  if (models.includes(model)) {
+    return model;
+  }
+
+  // Try to find full path version
+  const fullPath = models.find((m) => m.endsWith(`/${model}`) || m.split("/").pop() === model);
+
+  return fullPath || model;
+}
+
+// ============================================================================
+// Runner Configuration
+// ============================================================================
+
+/**
+ * Builds the complete runner configuration including environment variables
+ */
+export function buildRunnerConfig(input: ModelResolutionInput): RunnerConfig {
+  const runnerType = detectRunner(input.command);
+  const model = resolveModel(input);
+  const env: Record<string, string> = {};
+
+  switch (runnerType) {
+    case "opencode": {
+      // Validate model for OpenCode
+      const validation = validateOpenCodeModel(model);
+      if (!validation.valid) {
+        console.warn(`Warning: ${validation.error}`);
+      }
+
+      // Normalize and set OPENCODE_MODEL
+      const normalizedModel = normalizeOpenCodeModel(model);
+      env.OPENCODE_MODEL = normalizedModel;
+      break;
+    }
+
+    case "claude": {
+      // Claude CLI uses ANTHROPIC_MODEL or similar
+      // For now, just pass the model - Claude CLI will handle it
+      env.CLAUDE_MODEL = model;
+      break;
+    }
+
+    case "custom":
+      // Custom runners don't get automatic model env
+      // User is responsible for configuring their tool
+      break;
+  }
+
+  return {
+    type: runnerType,
+    command: input.command,
+    model,
+    env,
+  };
+}
+
+/**
+ * Gets a human-readable runner name
+ */
+export function getRunnerDisplayName(runnerType: RunnerType): string {
+  switch (runnerType) {
+    case "opencode":
+      return "OpenCode";
+    case "claude":
+      return "Claude CLI";
+    case "custom":
+      return "Custom";
+  }
+}

package/src/core/tmux.ts

@@ -18,6 +18,9 @@ export function sessionExists(sessionName: string): boolean {
 export interface SessionEnv {
   AGENT_TOKEN?: string;
   AGENTMESH_AGENT_ID?: string;
+  OPENCODE_MODEL?: string;
+  CLAUDE_MODEL?: string;
+  [key: string]: string | undefined;
 }
 
 export function createSession(
@@ -34,17 +37,36 @@ export function createSession(
   }
 
   try {
+    // Build environment prefix for the command
+    // This ensures env vars are set BEFORE the process starts
+    let envPrefix = "";
+    if (env) {
+      const envParts: string[] = [];
+      for (const [key, value] of Object.entries(env)) {
+        if (value !== undefined && value !== "") {
+          // Escape special characters in value
+          const escapedValue = value.replace(/"/g, '\\"');
+          envParts.push(`${key}="${escapedValue}"`);
+        }
+      }
+      if (envParts.length > 0) {
+        envPrefix = envParts.join(" ") + " ";
+      }
+    }
+
+    const fullCommand = `${envPrefix}${command}`;
+
     const args = ["new-session", "-d", "-s", sessionName];
 
     if (workdir) {
       args.push("-c", workdir);
     }
 
-    args.push(command);
+    args.push(fullCommand);
 
     execSync(`tmux ${args.join(" ")}`);
 
-    // Inject environment variables after session creation
+    // Also set session environment for any subsequent processes/refreshes
     if (env) {
       setSessionEnvironment(sessionName, env);
     }
@@ -58,13 +80,10 @@ export function createSession(
 
 export function setSessionEnvironment(sessionName: string, env: SessionEnv): boolean {
   try {
-    if (env.AGENT_TOKEN) {
-      execSync(`tmux set-environment -t "${sessionName}" AGENT_TOKEN "${env.AGENT_TOKEN}"`);
-    }
-    if (env.AGENTMESH_AGENT_ID) {
-      execSync(
-        `tmux set-environment -t "${sessionName}" AGENTMESH_AGENT_ID "${env.AGENTMESH_AGENT_ID}"`,
-      );
+    for (const [key, value] of Object.entries(env)) {
+      if (value !== undefined && value !== "") {
+        execSync(`tmux set-environment -t "${sessionName}" ${key} "${value}"`);
+      }
     }
     return true;
   } catch (error) {