@wagemule/daemon 0.1.6 → 0.1.8

package/dist/main.cjs

@@ -1802,8 +1802,10 @@ var KimiAdapter = class {
     const wmDir = import_node_path.default.join(input.cwd, ".wm");
     await (0, import_promises.mkdir)(wmDir, { recursive: true });
     const agentFile = import_node_path.default.join(wmDir, "kimi-agent.yaml");
+    const systemPromptFile = import_node_path.default.join(wmDir, "kimi-system.md");
     const mcpConfigFile = import_node_path.default.join(wmDir, "kimi-mcp.json");
-    await (0, import_promises.writeFile)(agentFile, kimiAgentYaml(input.systemPrompt), "utf8");
+    await (0, import_promises.writeFile)(systemPromptFile, input.systemPrompt, "utf8");
+    await (0, import_promises.writeFile)(agentFile, kimiAgentYaml(), "utf8");
     await (0, import_promises.writeFile)(mcpConfigFile, JSON.stringify({ mcpServers: {} }, null, 2), "utf8");
     const args = [
       "--wire",
@@ -1927,12 +1929,13 @@ var KimiAdapter = class {
     }
   }
 };
-function kimiAgentYaml(systemPrompt) {
+function kimiAgentYaml() {
   return [
-    "name: wm",
-    "description: Wage Mule platform agent",
-    "instructions: |-",
-    ...systemPrompt.split(/\r?\n/).map((line) => `  ${line}`),
+    "version: 1",
+    "agent:",
+    "  extend: default",
+    "  name: wm",
+    "  system_prompt_path: ./kimi-system.md",
     ""
   ].join("\n");
 }
@@ -3888,7 +3891,7 @@ var import_ws = __toESM(require("ws"));
 // package.json
 var package_default = {
   name: "@wagemule/daemon",
-  version: "0.1.6",
+  version: "0.1.8",
   private: false,
   description: "Wage Mule local daemon for connecting local agent runtimes to Workspace Server.",
   main: "./dist/main.cjs",
@@ -3984,30 +3987,7 @@ var ServerConnection = class {
     ws.on("open", () => {
       this.reconnectAttempt = 0;
       this.log(`socket open url=${redactUrl(url)}`);
-      this.send({
-        type: "ready",
-        capabilities: [
-          "agent:start",
-          "agent:stop",
-          "agent:deliver",
-          "agent:reset-workspace",
-          "agent:diagnostic",
-          "workspace:list",
-          "workspace:read",
-          "agent:skills:list",
-          "machine:runtime_models:detect",
-          "machine:workspace:scan",
-          "machine:workspace:delete",
-          "reminder-cache"
-        ],
-        runtimes: supportedRuntimeIds,
-        runningAgents: this.options.runningAgentsProvider?.() ?? [],
-        wakeableAgents: this.options.wakeableAgentsProvider?.() ?? [],
-        hostname: import_node_os6.default.hostname() || "local",
-        name: this.options.name,
-        os: `${process.platform}/${process.arch}`,
-        daemonVersion: this.options.daemonVersion ?? package_default.version
-      });
+      void this.sendReady();
     });
     ws.on("message", (raw) => {
       const msg = JSON.parse(String(raw));
@@ -4033,6 +4013,42 @@ var ServerConnection = class {
       this.scheduleReconnect();
     });
   }
+  async sendReady() {
+    this.send({
+      type: "ready",
+      capabilities: [
+        "agent:start",
+        "agent:stop",
+        "agent:deliver",
+        "agent:reset-workspace",
+        "agent:diagnostic",
+        "workspace:list",
+        "workspace:read",
+        "agent:skills:list",
+        "machine:runtime_models:detect",
+        "machine:workspace:scan",
+        "machine:workspace:delete",
+        "reminder-cache"
+      ],
+      runtimes: await this.detectAvailableRuntimes(),
+      runningAgents: this.options.runningAgentsProvider?.() ?? [],
+      wakeableAgents: this.options.wakeableAgentsProvider?.() ?? [],
+      hostname: import_node_os6.default.hostname() || "local",
+      name: this.options.name,
+      os: `${process.platform}/${process.arch}`,
+      daemonVersion: this.options.daemonVersion ?? package_default.version
+    });
+  }
+  async detectAvailableRuntimes() {
+    if (this.options.runtimesProvider) return this.options.runtimesProvider();
+    try {
+      const results = await doctorRuntimes(supportedRuntimeIds);
+      return results.filter((result) => result.detected).map((result) => result.runtime);
+    } catch (error) {
+      this.log(`runtime detection failed ${error instanceof Error ? error.message : String(error)}`);
+      return [];
+    }
+  }
   scheduleReconnect() {
     if (this.stopped || this.reconnectTimer) return;
     const delay = this.nextReconnectDelayMs();
@@ -4296,15 +4312,35 @@ ${stderr}`);
 function parseKimiModelConfig(configText) {
   const ids = [];
   let defaultModel;
+  let section;
   for (const rawLine of configText.split(/\r?\n/)) {
     const line = stripYamlComment(rawLine).trim();
     if (!line) continue;
-    const model = line.match(/^(?:model|default_model)\s*=\s*["']?([^"']+)["']?\s*$/);
-    if (model) {
-      defaultModel = model[1]?.trim();
+    const table = line.match(/^\[models\.([^\]]+)]$/);
+    if (table) {
+      section = `models.${unquote(table[1].trim())}`;
+      pushUnique(ids, section.slice("models.".length));
+      continue;
+    }
+    const anyTable = line.match(/^\[([^\]]+)]$/);
+    if (anyTable) {
+      section = anyTable[1]?.trim();
+      continue;
+    }
+    const defaultModelLine = line.match(/^default_model\s*=\s*["']?([^"']+)["']?\s*$/);
+    if (defaultModelLine) {
+      defaultModel = defaultModelLine[1]?.trim();
       pushUnique(ids, defaultModel);
       continue;
     }
+    if (section?.startsWith("models.")) continue;
+    const model = line.match(/^model\s*=\s*["']?([^"']+)["']?\s*$/);
+    if (model) {
+      const value = model[1]?.trim();
+      defaultModel ??= value;
+      pushUnique(ids, value);
+      continue;
+    }
     const array = line.match(/^(?:models|available_models)\s*=\s*\[(.+)\]\s*$/);
     if (array) {
       for (const part of array[1].split(",")) pushUnique(ids, unquote(part.trim()));
@@ -5042,14 +5078,7 @@ var AgentProcessManager = class {
     } else if (message.type === "feishu:token:clear") {
       await this.replyFeishuTokenClear(message.requestId, message.agentId, message.config);
     } else if (message.type === "feishu:delegation:start" || message.type === "feishu:delegation:update") {
-      this.startFeishuDelegationSchedule(message.delegation, message.config);
-      this.options.sendToServer({
-        type: "feishu:delegation:result",
-        requestId: message.requestId,
-        delegationId: message.delegation.id,
-        agentId: message.delegation.delegate_agent_id,
-        ok: true
-      });
+      await this.replyFeishuDelegationStart(message.requestId, message.delegation, message.config);
     } else if (message.type === "feishu:delegation:stop") {
       this.stopFeishuDelegationSchedule(message.delegationId);
       this.options.sendToServer({
@@ -5130,8 +5159,32 @@ var AgentProcessManager = class {
         });
       });
     }, intervalMs);
+    timer.unref?.();
     this.feishuDelegationTimers.set(delegation.id, timer);
   }
+  async replyFeishuDelegationStart(requestId, delegation, config) {
+    try {
+      const feishuConfig = { ...config, feishuDelegationEnabled: true };
+      await this.ensureAgentWorkspace(delegation.delegate_agent_id, feishuConfig);
+      this.startFeishuDelegationSchedule(delegation, feishuConfig);
+      this.options.sendToServer({
+        type: "feishu:delegation:result",
+        requestId,
+        delegationId: delegation.id,
+        agentId: delegation.delegate_agent_id,
+        ok: true
+      });
+    } catch (error) {
+      this.options.sendToServer({
+        type: "feishu:delegation:result",
+        requestId,
+        delegationId: delegation.id,
+        agentId: delegation.delegate_agent_id,
+        ok: false,
+        error: error instanceof Error ? error.message : "feishu delegation start failed"
+      });
+    }
+  }
   shouldSkipScheduledFeishuWake(agentId) {
     if (this.starting.has(agentId)) return true;
     const running = this.running.get(agentId);
@@ -5331,7 +5384,7 @@ var AgentProcessManager = class {
     if (running && !config?.feishuDelegationEnabled) return { workspace: running.workspace };
     const idle = this.idleConfigs.get(agentId);
     if (idle?.workspace && !config?.feishuDelegationEnabled) return { workspace: idle.workspace };
-    const effectiveConfig = config ?? idle?.config;
+    const effectiveConfig = this.mergeWorkspaceConfig(config ?? idle?.config, running?.config, idle?.config);
     if (!effectiveConfig) return { missing: true };
     const workspace = await createAgentWorkspace({
       rootDir: this.options.rootDir,
@@ -5354,6 +5407,13 @@ var AgentProcessManager = class {
     this.idleConfigs.set(agentId, { config: effectiveConfig, sessionId: effectiveConfig.sessionId, workspace });
     return { workspace };
   }
+  mergeWorkspaceConfig(config, runningConfig, idleConfig) {
+    if (!config) return config;
+    if (config.feishuDelegationEnabled || runningConfig?.feishuDelegationEnabled || idleConfig?.feishuDelegationEnabled) {
+      return { ...config, feishuDelegationEnabled: true };
+    }
+    return config;
+  }
   async replyWorkspaceInit(requestId, agentId, config) {
     try {
       const { workspace } = await this.ensureAgentWorkspace(agentId, config);