@mclawnet/agent 0.5.8 → 0.6.1

package/dist/{chunk-KHPEQTWF.js → chunk-KITKMSBE.js}

@@ -95,7 +95,7 @@ import {
   MAX_RECONNECT_MS,
   WS_CLOSE_INVALID_TOKEN
 } from "@mclawnet/shared";
-import { listRecoverableSwarms, recoverSwarm, listRoles, loadRole, listRecoverableSwarmIds, deleteSwarmSnapshot } from "@mclawnet/swarm";
+import { listRecoverableSwarms, recoverSwarm, listRoles, loadRole, listRecoverableSwarmIds, deleteSwarmSnapshot, listTemplates, loadTemplate } from "@mclawnet/swarm";
 
 // src/fs-handler.ts
 import { readdir } from "fs/promises";
@@ -519,9 +519,11 @@ var HubConnection = class {
           const def = loadRole(name);
           return {
             name: def.name,
-            displayName: def.shortName || def.name,
+            displayName: def.displayName || def.description || def.name,
             description: def.description || "",
             capabilities: def.capabilities || [],
+            type: def.type,
+            color: def.color,
             promptBody: def.promptBody || ""
           };
         } catch {
@@ -535,6 +537,35 @@ var HubConnection = class {
       });
       return true;
     }
+    if (msg.type === "list_templates") {
+      log2.info("list_templates");
+      try {
+        const names = listTemplates();
+        const templates = names.map((name) => {
+          const tpl = loadTemplate(name);
+          return {
+            name: tpl.name,
+            displayName: tpl.displayName,
+            description: tpl.description,
+            icon: tpl.icon,
+            roles: tpl.roles
+          };
+        });
+        this.send({
+          type: "templates_list_result",
+          sessionId: msg.sessionId,
+          templates
+        });
+      } catch (err) {
+        log2.error({ err }, "list_templates failed");
+        this.send({
+          type: "templates_list_result",
+          sessionId: msg.sessionId,
+          templates: []
+        });
+      }
+      return true;
+    }
     if (msg.type === "generic.request") {
       const handler = this.namespaceHandlers.get(msg.namespace);
       if (handler) {
@@ -590,10 +621,11 @@ var HubConnection = class {
           sessionId,
           error: "\u8702\u7FA4\u4EFB\u52A1\u5DF2\u5B8C\u6210\uFF0C\u65E0\u6CD5\u7EE7\u7EED\u64CD\u4F5C\u3002\u8BF7\u521B\u5EFA\u65B0\u7684\u8702\u7FA4\u4EFB\u52A1\u3002"
         });
-      } else if (crewConfig?.roles) {
-        log2.info({ sessionId, rolesCount: crewConfig.roles.length }, "swarm.execute: creating new swarm");
+      } else if (crewConfig?.templateName || crewConfig?.roles) {
+        const templateName = crewConfig.templateName;
         const roles = crewConfig.roles;
-        this.swarmCoordinator.create(sessionId, { workDir, roles, task: content }).catch((err) => {
+        log2.info({ sessionId, templateName, rolesCount: roles?.length }, "swarm.execute: creating new swarm");
+        this.swarmCoordinator.create(sessionId, { workDir, templateName, roles, task: content }).catch((err) => {
           this.send({
             type: "session.error",
             sessionId,
@@ -746,17 +778,14 @@ var HubConnection = class {
 };
 
 // src/session-manager.ts
-import { writeFileSync as writeFileSync2, unlinkSync } from "fs";
-import { tmpdir } from "os";
-import { join as join3, dirname } from "path";
-import { createRequire } from "module";
 import { createLogger as createLogger3 } from "@mclawnet/logger";
 import { buildMemorySection } from "@mclawnet/memory";
 var log3 = createLogger3({ module: "agent/session-manager" });
+var DEFAULT_MAX_PROCESSES = 10;
+var MAX_PROCESSES = Number(process.env.CLAWNET_MAX_PROCESSES) || DEFAULT_MAX_PROCESSES;
 var SessionManager = class {
   sessions = /* @__PURE__ */ new Map();
   conversationBuffer = /* @__PURE__ */ new Map();
-  mcpConfigPaths = /* @__PURE__ */ new Map();
   adapter;
   onOutput;
   onTurnComplete;
@@ -773,24 +802,22 @@ var SessionManager = class {
     if (this.sessions.has(options.sessionId)) {
       throw new Error(`Session ${options.sessionId} already exists`);
     }
+    if (this.sessions.size >= MAX_PROCESSES) {
+      throw new Error(`Process limit reached (${MAX_PROCESSES}). Cannot create new session.`);
+    }
     if (options.roleId) {
       try {
         const memorySection = buildMemorySection(options.roleId);
-        options.systemPrompt = options.systemPrompt ? `${memorySection}
+        const roleHint = `
+
+[Memory Context] Your roleId is "${options.roleId}". Always use this roleId when calling memory_search, memory_store, memory_stats, or memory_reflect.`;
+        options.systemPrompt = options.systemPrompt ? `${memorySection}${roleHint}
 
-${options.systemPrompt}` : memorySection;
-        log3.debug({ roleId: options.roleId, sessionId: options.sessionId }, "memory prompt injected");
+${options.systemPrompt}` : `${memorySection}${roleHint}`;
+        log3.debug({ roleId: options.roleId, sessionId: options.sessionId }, "memory prompt + roleId hint injected");
       } catch (err) {
         log3.warn({ err, roleId: options.roleId }, "failed to build memory section, proceeding without");
       }
-      if (!options.mcpConfigPath) {
-        try {
-          options.mcpConfigPath = this.createMemoryMcpConfig(options.sessionId, options.roleId);
-          log3.debug({ roleId: options.roleId, sessionId: options.sessionId }, "memory MCP config created");
-        } catch (err) {
-          log3.warn({ err, roleId: options.roleId }, "failed to create memory MCP config, proceeding without");
-        }
-      }
     }
     try {
       const process2 = await this.adapter.spawn(options);
@@ -832,7 +859,6 @@ ${options.systemPrompt}` : memorySection;
     const process2 = this.sessions.get(sessionId);
     if (!process2) return;
     this.conversationBuffer.delete(sessionId);
-    this.cleanupMcpConfig(sessionId);
     this.sessions.delete(sessionId);
     await this.adapter.stop(process2);
   }
@@ -845,7 +871,6 @@ ${options.systemPrompt}` : memorySection;
       });
     }
     this.conversationBuffer.delete(sessionId);
-    this.cleanupMcpConfig(sessionId);
     this.sessions.delete(sessionId);
     await this.adapter.stop(process2);
   }
@@ -858,7 +883,6 @@ ${options.systemPrompt}` : memorySection;
           });
         }
         this.conversationBuffer.delete(sessionId);
-        this.cleanupMcpConfig(sessionId);
         this.sessions.delete(sessionId);
         await this.adapter.stop(process2).catch(() => {
         });
@@ -872,50 +896,101 @@ ${options.systemPrompt}` : memorySection;
   get activeSessionCount() {
     return this.sessions.size;
   }
-  // ── Private helpers ─────────────────────────────────────────────────
-  /** Generate a temporary MCP config file for the memory server. */
-  createMemoryMcpConfig(sessionId, roleId) {
+};
+
+// src/start.ts
+import { SwarmCoordinator, initRoles } from "@mclawnet/swarm";
+
+// src/skill-loader.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, copyFileSync, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3, dirname } from "path";
+import { homedir as homedir3 } from "os";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { createLogger as createLogger4 } from "@mclawnet/logger";
+var log4 = createLogger4({ module: "agent/skill-loader" });
+var CLAWNET_DIR = join3(homedir3(), ".clawnet");
+var SKILLS_DIR = join3(CLAWNET_DIR, ".claude", "skills");
+var MCP_CONFIG_PATH = join3(CLAWNET_DIR, "mcp.json");
+async function initSkills() {
+  ensureSkillsDir();
+  copyBuiltinSkills();
+  ensureMcpConfig();
+}
+function ensureSkillsDir() {
+  if (!existsSync3(SKILLS_DIR)) {
+    mkdirSync2(SKILLS_DIR, { recursive: true });
+    log4.info({ dir: SKILLS_DIR }, "created skills directory");
+  }
+}
+function copyBuiltinSkills() {
+  const thisFile = fileURLToPath(import.meta.url);
+  const srcDir = join3(dirname(thisFile), "..", "skills");
+  if (!existsSync3(srcDir)) {
+    log4.debug({ srcDir }, "no built-in skills directory found, skipping");
+    return;
+  }
+  let entries;
+  try {
+    entries = readdirSync2(srcDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    log4.warn({ srcDir }, "failed to read built-in skills directory");
+    return;
+  }
+  for (const skillName of entries) {
+    const srcSkillMd = join3(srcDir, skillName, "SKILL.md");
+    const destDir = join3(SKILLS_DIR, skillName);
+    const destSkillMd = join3(destDir, "SKILL.md");
+    if (!existsSync3(srcSkillMd)) continue;
+    if (existsSync3(destSkillMd)) {
+      log4.debug({ skill: skillName }, "skill already exists, skipping");
+      continue;
+    }
+    try {
+      mkdirSync2(destDir, { recursive: true });
+      copyFileSync(srcSkillMd, destSkillMd);
+      log4.info({ skill: skillName }, "copied built-in skill");
+    } catch (err) {
+      log4.warn({ skill: skillName, err }, "failed to copy built-in skill");
+    }
+  }
+}
+function ensureMcpConfig() {
+  if (existsSync3(MCP_CONFIG_PATH)) {
+    log4.debug("mcp.json already exists, skipping");
+    return;
+  }
+  let mcpServerPath;
+  try {
     const req = createRequire(import.meta.url);
     const memoryPkgDir = dirname(req.resolve("@mclawnet/memory/package.json"));
-    const mcpServerPath = join3(memoryPkgDir, "dist", "mcp", "server.js");
-    const configPath = join3(tmpdir(), `clawnet-mcp-${sessionId.replace(/::/g, "-")}.json`);
-    writeFileSync2(
-      configPath,
-      JSON.stringify({
-        mcpServers: {
-          "clawnet-memory": {
-            command: "node",
-            args: [mcpServerPath, "--role-id", roleId]
-          }
-        }
-      })
-    );
-    this.mcpConfigPaths.set(sessionId, configPath);
-    log3.debug({ sessionId, roleId, configPath, mcpServerPath }, "memory MCP config file written");
-    return configPath;
+    mcpServerPath = join3(memoryPkgDir, "dist", "mcp", "server.js");
+  } catch {
+    log4.warn("could not resolve @mclawnet/memory package path, skipping mcp.json generation");
+    return;
   }
-  /** Remove temporary MCP config file for a session. */
-  cleanupMcpConfig(sessionId) {
-    const configPath = this.mcpConfigPaths.get(sessionId);
-    if (configPath) {
-      try {
-        unlinkSync(configPath);
-      } catch {
+  const config = {
+    mcpServers: {
+      "clawnet-memory": {
+        command: "node",
+        args: [mcpServerPath]
       }
-      this.mcpConfigPaths.delete(sessionId);
-      log3.debug({ sessionId, configPath }, "memory MCP config file cleaned up");
     }
+  };
+  try {
+    mkdirSync2(CLAWNET_DIR, { recursive: true });
+    writeFileSync2(MCP_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+    log4.info({ path: MCP_CONFIG_PATH }, "generated default mcp.json");
+  } catch (err) {
+    log4.warn({ err }, "failed to generate mcp.json");
   }
-};
-
-// src/start.ts
-import { SwarmCoordinator, initRoles } from "@mclawnet/swarm";
+}
 
 // src/brain-bridge.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync2 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync as readdirSync3 } from "fs";
 import { join as join4 } from "path";
-import { createLogger as createLogger4 } from "@mclawnet/logger";
-var log4 = createLogger4({ module: "brain-bridge" });
+import { createLogger as createLogger5 } from "@mclawnet/logger";
+var log5 = createLogger5({ module: "brain-bridge" });
 var BrainBridge = class {
   constructor(hub, options) {
     this.hub = hub;
@@ -923,7 +998,7 @@ var BrainBridge = class {
     this.brainHome = options?.brainHomePath || process.env.BRAIN_HOME || join4(home, "BrainData");
     this.brainCorePath = options?.brainCorePath || join4(home, ".brain", "BrainCore");
     this.hub.registerNamespace("brain", (msg) => this.handleRequest(msg));
-    log4.info(
+    log5.info(
       { brainHome: this.brainHome, brainCorePath: this.brainCorePath },
       "BrainBridge initialized"
     );
@@ -931,11 +1006,11 @@ var BrainBridge = class {
   brainHome;
   brainCorePath;
   async handleRequest(msg) {
-    log4.info({ action: msg.action, requestId: msg.requestId }, "brain request");
+    log5.info({ action: msg.action, requestId: msg.requestId }, "brain request");
     switch (msg.action) {
       case "setup_status": {
         const status = this.checkSetup();
-        log4.info({ status }, "setup_status result");
+        log5.info({ status }, "setup_status result");
         return { status };
       }
       case "get_briefing":
@@ -943,20 +1018,20 @@ var BrainBridge = class {
       case "get_meeting_recap":
         return await this.getMeetingRecap(msg.params.recapPath);
       default:
-        log4.warn({ action: msg.action }, "unknown brain action");
+        log5.warn({ action: msg.action }, "unknown brain action");
         throw new Error(`Unknown brain action: ${msg.action}`);
     }
   }
   checkSetup() {
-    if (!existsSync3(this.brainCorePath)) {
+    if (!existsSync4(this.brainCorePath)) {
       return "not_installed";
     }
     const home = process.env.HOME || process.env.USERPROFILE || "";
     const installJson = join4(home, ".brain", "install.json");
-    if (!existsSync3(installJson)) {
+    if (!existsSync4(installJson)) {
       return "needs_config";
     }
-    if (!existsSync3(this.brainHome)) {
+    if (!existsSync4(this.brainHome)) {
       return "needs_config";
     }
     return "ready";
@@ -965,16 +1040,16 @@ var BrainBridge = class {
   async getBriefing(date) {
     const targetDate = date || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     const reportsDir = join4(this.brainHome, "reports", "daily");
-    if (!existsSync3(reportsDir)) {
-      log4.info({ reportsDir }, "get_briefing: reports dir not found");
+    if (!existsSync4(reportsDir)) {
+      log5.info({ reportsDir }, "get_briefing: reports dir not found");
       return { briefing: null, actions: [], projects: [], meetings: [], feed: [] };
     }
-    const files = readdirSync2(reportsDir).filter((f) => f.includes(targetDate) && f.endsWith(".md")).sort().reverse();
+    const files = readdirSync3(reportsDir).filter((f) => f.includes(targetDate) && f.endsWith(".md")).sort().reverse();
     if (files.length === 0) {
-      log4.info({ targetDate }, "get_briefing: no report for date");
+      log5.info({ targetDate }, "get_briefing: no report for date");
       return { briefing: null, actions: [], projects: [], meetings: [], feed: [] };
     }
-    log4.info({ targetDate, file: files[0] }, "get_briefing: reading report");
+    log5.info({ targetDate, file: files[0] }, "get_briefing: reading report");
     const content = readFileSync3(join4(reportsDir, files[0]), "utf-8");
     const tldrMatch = content.match(/## TL;DR\n([\s\S]*?)(?=\n---|\n## )/);
     const tldr = tldrMatch ? tldrMatch[1].trim() : content.slice(0, 200);
@@ -982,7 +1057,7 @@ var BrainBridge = class {
     const projects = this.parseProjects(content);
     const meetings = this.parseMeetings(content);
     const feed = this.parseFeed(content);
-    log4.info(
+    log5.info(
       { actions: actions.length, projects: projects.length, meetings: meetings.length, feed: feed.length },
       "get_briefing: parsed"
     );
@@ -1175,8 +1250,8 @@ var BrainBridge = class {
       return { error: "No recap path provided" };
     }
     const fullPath = join4(this.brainHome, recapPath);
-    if (!existsSync3(fullPath)) {
-      log4.warn({ fullPath }, "meeting recap file not found");
+    if (!existsSync4(fullPath)) {
+      log5.warn({ fullPath }, "meeting recap file not found");
       return { error: "Recap file not found" };
     }
     const content = readFileSync3(fullPath, "utf-8");
@@ -1212,10 +1287,10 @@ var BrainBridge = class {
 };
 
 // src/fs-bridge.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
 import { extname, isAbsolute } from "path";
-import { createLogger as createLogger5 } from "@mclawnet/logger";
-var log5 = createLogger5({ module: "fs-bridge" });
+import { createLogger as createLogger6 } from "@mclawnet/logger";
+var log6 = createLogger6({ module: "fs-bridge" });
 var MAX_TEXT_SIZE = 5 * 1024 * 1024;
 var MIME_MAP = {
   ".ts": "text/typescript",
@@ -1253,10 +1328,10 @@ var FsBridge = class {
   constructor(hub) {
     this.hub = hub;
     this.hub.registerNamespace("fs", (msg) => this.handleRequest(msg));
-    log5.info("FsBridge initialized");
+    log6.info("FsBridge initialized");
   }
   async handleRequest(msg) {
-    log5.info({ action: msg.action, requestId: msg.requestId }, "fs request");
+    log6.info({ action: msg.action, requestId: msg.requestId }, "fs request");
     switch (msg.action) {
       case "read":
         return this.readFile(msg.params);
@@ -1270,7 +1345,7 @@ var FsBridge = class {
     if (!isAbsolute(filePath)) {
       throw new Error(`Access denied: only absolute paths allowed`);
     }
-    if (!existsSync4(filePath)) {
+    if (!existsSync5(filePath)) {
       throw new Error(`File not found: ${filePath}`);
     }
     const stat2 = statSync2(filePath);
@@ -1293,29 +1368,30 @@ var FsBridge = class {
 };
 
 // src/start.ts
-import { createLogger as createLogger6 } from "@mclawnet/logger";
-var log6 = createLogger6({ module: "agent" });
+import { createLogger as createLogger7 } from "@mclawnet/logger";
+var log7 = createLogger7({ module: "agent" });
 async function startAgent(options) {
   const config = loadConfig(options.config);
   if (!config.token) {
-    log6.error("no token configured \u2014 set CLAWNET_TOKEN or use --token");
+    log7.error("no token configured \u2014 set CLAWNET_TOKEN or use --token");
     process.exit(1);
   }
-  log6.info({ backend: options.adapter.type }, "starting agent");
-  log6.info({ hubUrl: config.hubUrl }, "connecting to hub");
+  log7.info({ backend: options.adapter.type }, "starting agent");
+  log7.info({ hubUrl: config.hubUrl }, "connecting to hub");
   await initRoles();
+  await initSkills();
   const hub = new HubConnection({
     hubUrl: config.hubUrl,
     token: config.token,
     hostname: config.name,
     onConnect: (agentId) => {
-      log6.info({ agentId }, "connected to hub");
+      log7.info({ agentId }, "connected to hub");
     },
     onDisconnect: (code, reason) => {
-      log6.info({ code, reason }, "disconnected from hub");
+      log7.info({ code, reason }, "disconnected from hub");
     },
     onError: (err) => {
-      log6.error({ err }, "hub connection error");
+      log7.error({ err }, "hub connection error");
     }
   });
   let swarmCoordinator;
@@ -1353,7 +1429,7 @@ async function startAgent(options) {
   const brainBridge = new BrainBridge(hub);
   const fsBridge = new FsBridge(hub);
   const shutdown = async () => {
-    log6.info("shutting down");
+    log7.info("shutting down");
     await sessionManager.closeAll();
     hub.destroy();
     process.exit(0);
@@ -1373,4 +1449,4 @@ export {
   FsBridge,
   startAgent
 };
-//# sourceMappingURL=chunk-KHPEQTWF.js.map
+//# sourceMappingURL=chunk-KITKMSBE.js.map