agent-bridge-mcp 1.2.0 → 1.4.0

package/README.md

@@ -88,6 +88,8 @@ Data directory:
     1740524430000-x7k2f9.json  # { from, to, content, timestamp }
   context/
     nova-main.json       # { agentName, agentId, project, updatedAt, content }
+  cursors/
+    nova-main.cursor     # timestamp of last delivered message
 ```
 
 ## Example Usage
@@ -198,6 +200,101 @@ Set `AGENT_BRIDGE_NAME` in your project's `.mcp.json` so the ingest knows which
 
 Context is stored as the last 20 exchanges per agent, accessible via `get_context`.
 
+## Automatic Message Delivery (UserPromptSubmit Hook)
+
+The `--check-messages` flag automatically delivers pending messages to an agent before every prompt — no manual `read_messages` calls needed.
+
+**How it works:** Every time you send a prompt to any tab, the hook checks for new messages addressed to that agent. If there are any, they get injected into the conversation as context so Claude sees them immediately. A cursor file tracks what's already been delivered so messages are never repeated.
+
+**Setup:**
+
+Add to the `UserPromptSubmit` hooks in `~/.claude/settings.json`:
+```json
+{
+  "type": "command",
+  "command": "npx agent-bridge-mcp --check-messages",
+  "timeout": 5
+}
+```
+
+The agent name is resolved automatically from the project's `.mcp.json` (reads `AGENT_BRIDGE_NAME` from the agent-bridge MCP config).
+
+## Session Bootstrap (SessionStart Hook)
+
+The `--bootstrap-context` flag loads shared context from all other agents when a new session starts — so new tabs immediately know what everyone else knows.
+
+**How it works:** When a Claude Code session starts or resumes, the hook reads all shared context files and lists active agents, then injects everything into the conversation. The agent starts with full awareness of what other agents have been working on.
+
+**Setup:**
+
+Add a `SessionStart` hook to `~/.claude/settings.json`:
+```json
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx agent-bridge-mcp --bootstrap-context",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+## Full Hook Setup
+
+Here's the complete `~/.claude/settings.json` hooks configuration with all agent-bridge features enabled:
+
+```json
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx agent-bridge-mcp --bootstrap-context",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx agent-bridge-mcp --capture-prompt",
+            "timeout": 5
+          },
+          {
+            "type": "command",
+            "command": "npx agent-bridge-mcp --check-messages",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx agent-bridge-mcp --ingest",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
 ## Requirements
 
 - Node.js >= 18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-bridge-mcp",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "MCP server enabling communication between multiple Claude Code sessions via shared filesystem message bus",
   "type": "module",
   "main": "server.mjs",

package/server.mjs

@@ -35,6 +35,7 @@ const BRIDGE_DIR = process.env.AGENT_BRIDGE_DATA_DIR || getDefaultDataDir();
 const AGENTS_DIR = resolve(BRIDGE_DIR, 'agents');
 const MESSAGES_DIR = resolve(BRIDGE_DIR, 'messages');
 const CONTEXT_DIR = resolve(BRIDGE_DIR, 'context');
+const CURSORS_DIR = resolve(BRIDGE_DIR, 'cursors');
 const HEARTBEAT_INTERVAL_MS = parseInt(process.env.AGENT_BRIDGE_HEARTBEAT_MS || '15000', 10);
 const STALE_THRESHOLD_MS = HEARTBEAT_INTERVAL_MS * 3;
 const DEAD_THRESHOLD_MS = parseInt(process.env.AGENT_BRIDGE_DEAD_MS || '300000', 10);
@@ -46,6 +47,7 @@ const MESSAGE_TTL_MS = parseInt(process.env.AGENT_BRIDGE_MESSAGE_TTL_MS || '3600
 
 const agentId = `agent-${randomBytes(3).toString('hex')}`;
 let agentName = process.env.AGENT_BRIDGE_NAME || null;
+let agentBaseName = process.env.AGENT_BRIDGE_NAME || null; // Original name before auto-suffix
 const startedAt = new Date().toISOString();
 let lastReadTimestamp = Date.now();  // only read messages after we start
 let heartbeatTimer = null;
@@ -58,6 +60,7 @@ function ensureDirs() {
   mkdirSync(AGENTS_DIR, { recursive: true });
   mkdirSync(MESSAGES_DIR, { recursive: true });
   mkdirSync(CONTEXT_DIR, { recursive: true });
+  mkdirSync(CURSORS_DIR, { recursive: true });
 }
 
 // ============================================================
@@ -81,6 +84,7 @@ function getAgentData() {
   return {
     id: agentId,
     name: agentName,
+    baseName: agentBaseName || agentName,
     project: process.cwd().split(/[\\/]/).pop(),
     cwd: process.cwd(),
     pid: process.pid,
@@ -281,17 +285,47 @@ function resolveAgent(nameOrId) {
   const byId = agents.find(a => a.id === nameOrId);
   if (byId) return byId;
 
-  // Exact name match (case-insensitive)
-  const byName = agents.find(a => a.name && a.name.toLowerCase() === nameOrId.toLowerCase());
-  if (byName) return byName;
+  // Exact name match (case-insensitive) — pick most recently active if multiple
+  const nameL = nameOrId.toLowerCase();
+  const byName = agents
+    .filter(a => a.name && a.name.toLowerCase() === nameL)
+    .sort((a, b) => new Date(b.lastHeartbeat) - new Date(a.lastHeartbeat));
+  if (byName.length > 0) return byName[0];
+
+  // Also match by baseName for auto-suffixed agents
+  const byBase = agents
+    .filter(a => a.baseName && a.baseName.toLowerCase() === nameL)
+    .sort((a, b) => new Date(b.lastHeartbeat) - new Date(a.lastHeartbeat));
+  if (byBase.length > 0) return byBase[0];
 
   // Partial name match
-  const partial = agents.filter(a => a.name && a.name.toLowerCase().includes(nameOrId.toLowerCase()));
+  const partial = agents.filter(a => a.name && a.name.toLowerCase().includes(nameL));
   if (partial.length === 1) return partial[0];
 
   return null;
 }
 
+// Resolve ALL agents matching a name (for multi-session messaging)
+function resolveAllAgents(nameOrId) {
+  const agents = getAllAgents().filter(a => !a.isMe && a.status === 'active');
+  const nameL = nameOrId.toLowerCase();
+
+  // Exact ID match — single result
+  const byId = agents.find(a => a.id === nameOrId);
+  if (byId) return [byId];
+
+  // Match by name or baseName
+  const matches = agents.filter(a =>
+    (a.name && a.name.toLowerCase() === nameL) ||
+    (a.baseName && a.baseName.toLowerCase() === nameL)
+  );
+  if (matches.length > 0) return matches;
+
+  // Partial name match
+  const partial = agents.filter(a => a.name && a.name.toLowerCase().includes(nameL));
+  return partial;
+}
+
 // ============================================================
 // Tool Handlers
 // ============================================================
@@ -300,26 +334,32 @@ async function handleRegister(args) {
   const name = args.name?.trim();
   if (!name) return { error: 'Name is required' };
 
-  // Check uniqueness
+  // Allow duplicate base names — auto-suffix if taken
   const agents = getAllAgents().filter(a => !a.isMe && a.status === 'active');
-  const conflict = agents.find(a => a.name && a.name.toLowerCase() === name.toLowerCase());
-  if (conflict) {
-    return {
-      error: `Name "${name}" is already taken by ${conflict.id} (project: ${conflict.project})`,
-      suggestion: `Try "${name}-2" or a different name`
-    };
+  let finalName = name;
+  const nameLower = name.toLowerCase();
+  const conflicts = agents.filter(a => a.name && a.name.toLowerCase() === nameLower);
+  if (conflicts.length > 0) {
+    // Find next available suffix
+    const allNames = agents.map(a => a.name?.toLowerCase()).filter(Boolean);
+    let suffix = 2;
+    while (allNames.includes(`${nameLower}-${suffix}`)) suffix++;
+    finalName = `${name}-${suffix}`;
   }
 
-  agentName = name;
+  agentName = finalName;
+  agentBaseName = name; // Track original base name for context grouping
   writeAgentFile();
 
   return {
     registered: true,
     id: agentId,
     name: agentName,
+    baseName: name,
     project: process.cwd().split(/[\\/]/).pop(),
     cwd: process.cwd(),
-    pid: process.pid
+    pid: process.pid,
+    ...(finalName !== name ? { note: `Name "${name}" was taken, registered as "${finalName}"` } : {})
   };
 }
 
@@ -386,16 +426,18 @@ async function handleBroadcast(args) {
 // Context Operations
 // ============================================================
 
-function writeContextFile(name, content) {
+function writeContextFile(name, content, uniqueId) {
   const safeName = name.replace(/[^a-zA-Z0-9_-]/g, '_').toLowerCase();
+  const suffix = uniqueId || agentId;
   const data = JSON.stringify({
     agentName: name,
-    agentId,
+    agentId: uniqueId || agentId,
+    baseName: name,
     project: process.cwd().split(/[\\/]/).pop(),
     updatedAt: new Date().toISOString(),
     content
   }, null, 2);
-  const targetPath = resolve(CONTEXT_DIR, `${safeName}.json`);
+  const targetPath = resolve(CONTEXT_DIR, `${safeName}--${suffix}.json`);
   const tmpPath = targetPath + '.tmp';
   try {
     writeFileSync(tmpPath, data);
@@ -444,15 +486,34 @@ async function handleGetContext(args) {
   const { from } = args;
 
   if (from) {
-    // Get context from a specific agent
+    // Get ALL contexts matching this base name (handles multiple sessions)
     const safeName = from.replace(/[^a-zA-Z0-9_-]/g, '_').toLowerCase();
-    const filePath = resolve(CONTEXT_DIR, `${safeName}.json`);
+    let files;
     try {
-      const ctx = JSON.parse(readFileSync(filePath, 'utf8'));
-      return { found: true, context: ctx };
+      files = readdirSync(CONTEXT_DIR).filter(f => f.endsWith('.json'));
     } catch {
       return { found: false, error: `No shared context found for "${from}"` };
     }
+
+    const matches = [];
+    for (const file of files) {
+      // Match: exact old-style "{name}.json" OR new-style "{name}--{id}.json"
+      const basePart = file.replace(/\.json$/, '').split('--')[0];
+      if (basePart === safeName) {
+        try {
+          const ctx = JSON.parse(readFileSync(resolve(CONTEXT_DIR, file), 'utf8'));
+          matches.push(ctx);
+        } catch { continue; }
+      }
+    }
+
+    if (matches.length === 0) {
+      return { found: false, error: `No shared context found for "${from}"` };
+    }
+    if (matches.length === 1) {
+      return { found: true, context: matches[0] };
+    }
+    return { found: true, contexts: matches, count: matches.length };
   }
 
   // Get all shared contexts
@@ -463,6 +524,108 @@ async function handleGetContext(args) {
   };
 }
 
+// ============================================================
+// Hook Helpers (used by --check-messages and --bootstrap-context)
+// ============================================================
+
+/**
+ * Figure out the agent name for this project.
+ * Checks: 1) AGENT_BRIDGE_NAME env var, 2) .mcp.json in the cwd, 3) agent files matching cwd
+ */
+function resolveAgentName(cwd) {
+  if (process.env.AGENT_BRIDGE_NAME) return process.env.AGENT_BRIDGE_NAME;
+
+  // Read .mcp.json from the project directory
+  if (cwd) {
+    const mcpPath = resolve(cwd, '.mcp.json');
+    try {
+      const mcp = JSON.parse(readFileSync(mcpPath, 'utf8'));
+      const bridge = mcp.mcpServers?.['agent-bridge'];
+      if (bridge?.env?.AGENT_BRIDGE_NAME) return bridge.env.AGENT_BRIDGE_NAME;
+    } catch {}
+  }
+
+  // Fallback: scan agent files for matching cwd
+  try {
+    const files = readdirSync(AGENTS_DIR).filter(f => f.endsWith('.json'));
+    for (const file of files) {
+      const agent = readAgentFile(resolve(AGENTS_DIR, file));
+      if (agent?.name && agent.cwd === cwd) return agent.name;
+    }
+  } catch {}
+
+  return null;
+}
+
+/**
+ * Read messages for a specific agent, starting from a cursor timestamp.
+ * Returns { messages: [...], newCursor: number }
+ */
+function readMessagesForAgent(name, cursorTimestamp) {
+  let files;
+  try {
+    files = readdirSync(MESSAGES_DIR).filter(f => f.endsWith('.json')).sort();
+  } catch {
+    return { messages: [], newCursor: cursorTimestamp };
+  }
+
+  const pending = [];
+  let newCursor = cursorTimestamp;
+  const nameLower = name.toLowerCase();
+
+  for (const file of files) {
+    const timestamp = parseInt(file.split('-')[0], 10);
+    if (isNaN(timestamp) || timestamp <= cursorTimestamp) continue;
+
+    const filePath = resolve(MESSAGES_DIR, file);
+    let msg;
+    try { msg = JSON.parse(readFileSync(filePath, 'utf8')); } catch { continue; }
+
+    // Skip messages FROM this agent
+    if (msg.fromName?.toLowerCase() === nameLower) continue;
+
+    // Check if addressed to this agent or is a broadcast
+    const isForMe = msg.toName?.toLowerCase() === nameLower || msg.to?.toLowerCase() === nameLower;
+    const isBroadcast = msg.broadcast && msg.to === '*';
+
+    if (isForMe || isBroadcast) {
+      pending.push(msg);
+    }
+
+    if (timestamp > newCursor) newCursor = timestamp;
+  }
+
+  return { messages: pending, newCursor };
+}
+
+/**
+ * Read the cursor file for an agent. Returns the timestamp of the last processed message.
+ */
+function readCursor(name) {
+  const safeName = name.replace(/[^a-zA-Z0-9_-]/g, '_').toLowerCase();
+  const cursorPath = resolve(CURSORS_DIR, `${safeName}.cursor`);
+  try {
+    return parseInt(readFileSync(cursorPath, 'utf8').trim(), 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Write the cursor file for an agent.
+ */
+function writeCursor(name, timestamp) {
+  const safeName = name.replace(/[^a-zA-Z0-9_-]/g, '_').toLowerCase();
+  const cursorPath = resolve(CURSORS_DIR, `${safeName}.cursor`);
+  const tmpPath = cursorPath + '.tmp';
+  try {
+    writeFileSync(tmpPath, String(timestamp));
+    renameSync(tmpPath, cursorPath);
+  } catch {
+    try { writeFileSync(cursorPath, String(timestamp)); } catch {}
+  }
+}
+
 // ============================================================
 // Tool Definitions
 // ============================================================
@@ -586,7 +749,7 @@ async function handleToolCall(name, args) {
 // ============================================================
 
 const server = new Server(
-  { name: 'agent-bridge', version: '1.2.0' },
+  { name: 'agent-bridge', version: '1.4.0' },
   { capabilities: { tools: {} } }
 );
 
@@ -708,14 +871,22 @@ async function runIngest() {
   if (!name) process.exit(0);
 
   // Read existing context and append new exchange
+  // Use session-specific filename so multiple sessions don't overwrite each other
   const safeName = name.replace(/[^a-zA-Z0-9_-]/g, '_').toLowerCase();
-  const ctxPath = resolve(CONTEXT_DIR, `${safeName}.json`);
+  const ctxPath = resolve(CONTEXT_DIR, `${safeName}--${sessionId}.json`);
+
+  // Also check for legacy file (no session suffix) and migrate it
+  const legacyPath = resolve(CONTEXT_DIR, `${safeName}.json`);
+
   let existing = { exchanges: [] };
   try {
     const prev = JSON.parse(readFileSync(ctxPath, 'utf8'));
     if (prev.exchanges) existing = prev;
     else if (prev.content) existing = { exchanges: [{ role: 'context', content: prev.content }] };
-  } catch {}
+  } catch {
+    // If no session-specific file exists, DON'T inherit from legacy file
+    // (it belongs to a different session)
+  }
 
   // Keep last 20 exchanges to avoid unbounded growth
   existing.exchanges.push({
@@ -729,6 +900,7 @@ async function runIngest() {
 
   const ctxData = JSON.stringify({
     agentName: name,
+    baseName: name,
     project: process.cwd().split(/[\\/]/).pop(),
     updatedAt: new Date().toISOString(),
     sessionId,
@@ -759,6 +931,167 @@ function findAgentNameForSession(sessionId) {
   return null;
 }
 
+// ============================================================
+// CLI: --check-messages (UserPromptSubmit hook mode)
+// ============================================================
+// Runs on every prompt. Checks for new messages addressed to this agent
+// and outputs them as additionalContext so Claude sees them automatically.
+// Usage: node server.mjs --check-messages
+
+async function runCheckMessages() {
+  ensureDirs();
+
+  // Read stdin for hook context
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  const raw = Buffer.concat(chunks).toString('utf8');
+
+  let data;
+  try { data = JSON.parse(raw); } catch { process.exit(0); }
+
+  const cwd = data.cwd || process.cwd();
+  const name = resolveAgentName(cwd);
+  if (!name) process.exit(0);
+
+  // Read cursor and scan for new messages
+  const cursor = readCursor(name);
+  const { messages, newCursor } = readMessagesForAgent(name, cursor);
+
+  // Update cursor even if no messages (advances past scanned files)
+  if (newCursor > cursor) {
+    writeCursor(name, newCursor);
+  }
+
+  if (messages.length === 0) {
+    process.exit(0); // No output = no context injection
+  }
+
+  // Format messages for Claude
+  const formatted = messages.map(m => {
+    const from = m.fromName || m.from;
+    const age = Math.round((Date.now() - new Date(m.timestamp).getTime()) / 1000);
+    const ageStr = age < 60 ? `${age}s ago` : `${Math.round(age / 60)}min ago`;
+    return `[MESSAGE FROM ${from}]: ${m.content} (${ageStr})`;
+  }).join('\n\n');
+
+  const output = {
+    hookSpecificOutput: {
+      hookEventName: data.hook_event_name || 'UserPromptSubmit',
+      additionalContext: `--- INCOMING AGENT MESSAGES (${messages.length}) ---\n${formatted}\n--- END AGENT MESSAGES ---\nYou received ${messages.length} message(s) from other agents. Read and respond to them. Use send_message to reply if needed.`
+    }
+  };
+
+  process.stdout.write(JSON.stringify(output));
+  process.exit(0);
+}
+
+// ============================================================
+// CLI: --bootstrap-context (SessionStart hook mode)
+// ============================================================
+// Runs once when a new session starts. Reads all shared contexts
+// from other agents and any pending messages, outputs them so
+// Claude starts the session knowing what everyone else knows.
+// Usage: node server.mjs --bootstrap-context
+
+async function runBootstrapContext() {
+  ensureDirs();
+
+  // Read stdin for hook context
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  const raw = Buffer.concat(chunks).toString('utf8');
+
+  let data;
+  try { data = JSON.parse(raw); } catch { process.exit(0); }
+
+  const cwd = data.cwd || process.cwd();
+  const myName = resolveAgentName(cwd);
+  if (!myName) process.exit(0);
+
+  const myNameLower = myName.toLowerCase();
+
+  // Get active agents (excluding self)
+  let activeAgents = [];
+  try {
+    const agentFiles = readdirSync(AGENTS_DIR).filter(f => f.endsWith('.json'));
+    for (const file of agentFiles) {
+      try {
+        const agent = JSON.parse(readFileSync(resolve(AGENTS_DIR, file), 'utf8'));
+        if (agent.name && agent.name.toLowerCase() !== myNameLower && isProcessAlive(agent.pid)) {
+          activeAgents.push(agent);
+        }
+      } catch {}
+    }
+  } catch {}
+
+  // Get all shared contexts (excluding own session only, NOT all same-name sessions)
+  // Use sessionId to filter — other sessions with the same name should still be visible
+  const mySessionId = data.session_id || '';
+  const contexts = readAllContextFiles().filter(c => {
+    // Exclude our own session's context, but keep other sessions even if same name
+    if (c.sessionId && mySessionId && c.sessionId === mySessionId) return false;
+    // Fallback: if no sessionId, exclude exact agentId match
+    if (c.agentId && c.agentId === myName) return false;
+    return true;
+  });
+
+  // Check for pending messages too
+  const cursor = readCursor(myName);
+  const { messages, newCursor } = readMessagesForAgent(myName, cursor);
+  if (newCursor > cursor) {
+    writeCursor(myName, newCursor);
+  }
+
+  // Nothing to bootstrap
+  if (activeAgents.length === 0 && contexts.length === 0 && messages.length === 0) {
+    process.exit(0);
+  }
+
+  // Build the bootstrap output
+  const parts = [];
+
+  if (activeAgents.length > 0) {
+    parts.push(`ACTIVE AGENTS: ${activeAgents.map(a => `${a.name} (${a.project})`).join(', ')}`);
+  }
+
+  for (const ctx of contexts) {
+    const ageMin = Math.round((Date.now() - new Date(ctx.updatedAt).getTime()) / 1000 / 60);
+    let summary = '';
+    if (ctx.content) {
+      summary = ctx.content.slice(0, 3000);
+    } else if (ctx.exchanges && ctx.exchanges.length > 0) {
+      // Show last 3 exchanges as summary
+      const recent = ctx.exchanges.slice(-3);
+      summary = recent.map(e =>
+        `User: ${(e.user || '').slice(0, 200)}\nAssistant: ${(e.assistant || '').slice(0, 500)}`
+      ).join('\n---\n');
+    }
+    if (summary) {
+      parts.push(`--- CONTEXT FROM ${ctx.agentName} (${ctx.project || 'unknown'}, updated ${ageMin}min ago) ---\n${summary}`);
+    }
+  }
+
+  if (messages.length > 0) {
+    const formatted = messages.map(m => {
+      const from = m.fromName || m.from;
+      const age = Math.round((Date.now() - new Date(m.timestamp).getTime()) / 1000);
+      const ageStr = age < 60 ? `${age}s ago` : `${Math.round(age / 60)}min ago`;
+      return `[MESSAGE FROM ${from}]: ${m.content} (${ageStr})`;
+    }).join('\n\n');
+    parts.push(`--- PENDING MESSAGES (${messages.length}) ---\n${formatted}`);
+  }
+
+  const output = {
+    hookSpecificOutput: {
+      hookEventName: data.hook_event_name || 'SessionStart',
+      additionalContext: `--- AGENT BRIDGE BOOTSTRAP ---\nYou are "${myName}". The agent-bridge connects you with other Claude Code sessions. Messages from other agents are delivered automatically before each prompt.\n\n${parts.join('\n\n')}\n--- END BOOTSTRAP ---`
+    }
+  };
+
+  process.stdout.write(JSON.stringify(output));
+  process.exit(0);
+}
+
 // ============================================================
 // Main
 // ============================================================
@@ -767,10 +1100,26 @@ if (process.argv.includes('--capture-prompt')) {
   runCapturePrompt().catch(() => process.exit(0));
 } else if (process.argv.includes('--ingest')) {
   runIngest().catch(() => process.exit(0));
+} else if (process.argv.includes('--check-messages')) {
+  runCheckMessages().catch(() => process.exit(0));
+} else if (process.argv.includes('--bootstrap-context')) {
+  runBootstrapContext().catch(() => process.exit(0));
 } else {
   async function main() {
     ensureDirs();
     cleanOldMessages();
+
+    // Auto-suffix name if env var conflicts with an existing active agent
+    if (agentName) {
+      const existing = getAllAgents().filter(a => a.status === 'active' && a.name?.toLowerCase() === agentName.toLowerCase());
+      if (existing.length > 0) {
+        const allNames = getAllAgents().map(a => a.name?.toLowerCase()).filter(Boolean);
+        let suffix = 2;
+        while (allNames.includes(`${agentName.toLowerCase()}-${suffix}`)) suffix++;
+        agentName = `${agentBaseName}-${suffix}`;
+      }
+    }
+
     writeAgentFile();
     startHeartbeat();