@agentmeshhq/agent 0.1.9 → 0.1.10

package/src/core/daemon.ts

@@ -1,8 +1,11 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import {
   addAgentToState,
   getAgentState,
   loadConfig,
-  loadState,
   removeAgentFromState,
   updateAgentInState,
 } from "../config/loader.js";
@@ -10,8 +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 { buildRunnerConfig, getRunnerDisplayName, type RunnerConfig } from "./runner.js";
+import { checkInbox, fetchAssignments, registerAgent } from "./registry.js";
+import {
+  buildRunnerConfig,
+  detectRunner,
+  getRunnerDisplayName,
+  type RunnerConfig,
+} from "./runner.js";
 import {
   captureSessionContext,
   createSession,
@@ -30,6 +38,8 @@ 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 {
@@ -43,6 +53,7 @@ export class AgentDaemon {
   private agentId: string | null = null;
   private isRunning = false;
   private shouldRestoreContext: boolean;
+  private autoSetup: boolean;
 
   constructor(options: DaemonOptions) {
     const config = loadConfig();
@@ -53,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);
@@ -84,46 +96,6 @@ export class AgentDaemon {
     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> {
@@ -134,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);
@@ -141,11 +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, // Pass runner env vars (e.g., OPENCODE_MODEL)
+        this.runnerConfig.env, // Apply model env at process start
       );
 
       if (!created) {
@@ -154,29 +149,9 @@ 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);
-      }
+      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, {
@@ -184,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,
@@ -376,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/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 therajushahi
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.