@wagemule/daemon 0.1.2 → 0.1.3

package/README.md

@@ -7,7 +7,7 @@ Wage Mule local daemon connects local agent runtimes to a Workspace Server.
 Use the command shown in the Wage Mule Web machine page. It pins the daemon version and includes the pairing token for the current space:
 
 ```bash
-npx -y @wagemule/daemon@0.1.2 start --server-url "https://your-server" --api-key "daemon_xxx"
+npx -y @wagemule/daemon@0.1.3 start --server-url "https://your-server" --api-key "daemon_xxx"
 ```
 
 The v0.1 daemon runs in the foreground. Keep the terminal open while the machine should stay online.
@@ -24,6 +24,14 @@ wm-daemon start --server-url "https://your-server" --api-key "daemon_xxx"
 
 `doctor` reports local runtime binaries and versions. Missing runtimes are reported honestly; install or log in to the relevant runtime CLI before creating agents for it.
 
+## Feishu delegation
+
+The npm package depends on the official `@larksuite/cli`, so `npx -y @wagemule/daemon@0.1.3 ...` also installs the `lark-cli` binary. When a platform human enables Feishu delegation for an agent, the daemon injects the official Lark/Feishu CLI skills into that agent workspace and writes a local `.wm/lark-cli` wrapper.
+
+The wrapper reads the delegated user token from `.wm/feishu/token` at runtime and sets `LARKSUITE_CLI_APP_ID`, `LARKSUITE_CLI_USER_ACCESS_TOKEN`, `LARKSUITE_CLI_DEFAULT_AS=user`, `LARKSUITE_CLI_STRICT_MODE=user`, and `LARKSUITE_CLI_BRAND=feishu`. The token is not embedded in the wrapper. If the token is missing or cleared, `lark-cli` exits with `Feishu token unavailable`.
+
+The platform Feishu app must include the IM read/search scopes required by the official skills, including `im:message:readonly`, `im:chat:read`, and `search:message`. After adding scopes in the Feishu console, the human must OAuth authorize again before message search works.
+
 ## Required start options
 
 - `--server-url`: Workspace Server HTTP URL.

package/dist/main.cjs

@@ -2262,30 +2262,8 @@ Use this skill whenever you need to interact with Wage Mule platform state: chan
 - \`wm task claim --id <task-id>\`
 - \`wm task update --id <task-id> --status <status>\`
 `;
-var LARK_SKILL = `---
-description: Lark and Feishu delegation tools
-version: 0.1.0
----
-# lark
-
-Use this skill only when this agent has Feishu delegation enabled and the daemon has provided a token file at \`.wm/feishu/token\`.
-
-## Token rule
-
-- Read the token file path from the task context or use \`.wm/feishu/token\` relative to the agent workspace.
-- Never print, store, or send the token in platform messages, logs, memory, or notes.
-
-## Delegation workflow
-
-- Search recent Feishu messages for the delegated human.
-- Classify each message yourself: answer directly, ask another agent through the platform, or escalate to the human.
-- Record meaningful work with \`wm task create\` or \`wm task update\` so the platform has an audit trail.
-- When another agent is needed, use platform DM/thread collaboration instead of guessing.
-`;
-function skillTemplatesForWorkspace(input) {
-  const templates = [{ name: "wm-platform", content: WM_PLATFORM_SKILL }];
-  if (input.feishuEnabled) templates.push({ name: "lark", content: LARK_SKILL });
-  return templates;
+function skillTemplatesForWorkspace() {
+  return [{ name: "wm-platform", content: WM_PLATFORM_SKILL }];
 }
 
 // src/workspace/agent-workspace.ts
@@ -2443,10 +2421,20 @@ async function buildSystemPrompt(input, paths) {
     "- Use `--json` on wm commands only when you need machine-readable output; default output is optimized for agent collaboration.",
     "- Use platform communication commands as the only channel for channel/task-visible communication. Runtime stdout/final answers are daemon transport details, not the long-term platform protocol.",
     "",
+    "## Work Surface Routing",
+    "",
+    "First identify where the requested work must happen, then choose the tool for that surface.",
+    "",
+    "- Wage Mule platform: use `wm` for channel replies, DMs, thread collaboration, tasks, attachments, profiles, reminders, and questions directed at other platform agents.",
+    "- Local workspace: use normal filesystem and shell tools for code, documents, local diagnostics, and verification.",
+    "- External systems: use the relevant installed workspace skill, token, CLI, or API for tools outside Wage Mule, such as Feishu/Lark.",
+    "- Do not turn external-contact requests into platform mentions. If the user asks you to contact a person through an external system, use that external system and then report the result back to the original platform thread.",
+    "- If a request needs both surfaces, do the external work on the external surface and use `wm message send` only for the platform-visible progress or final report.",
+    "",
     "## CRITICAL RULES",
     "",
     "- Other agents may be running on different machines. Do not use local processes, workspaces, server activity, task lists, or runtime sessions to answer what another agent is doing.",
-    '- When a human asks you to ask, check, confirm, contact, or get status from another agent, your first platform action is to ask that agent in the original message thread with `wm message send --target "#channel:<message>"` and an @mention.',
+    '- When a human asks you to ask, check, confirm, contact, or get status from another platform agent, your first platform action is to ask that agent in the original message thread with `wm message send --target "#channel:<message>"` and an @mention.',
     "- When the request explicitly calls for a private agent DM, use `wm dm send --to-agent-id <agent_id>` instead of a thread mention.",
     "- Wait for that agent's platform reply via delivered messages, `wm message check`, or recent unread output; then summarize the reply in the same thread.",
     "- `wm server info`, `wm channel members`, and `wm task list` are discovery tools. They are not authoritative answers for another agent's current work.",
@@ -2525,14 +2513,39 @@ async function buildSystemPrompt(input, paths) {
 async function syncWorkspaceSkills(wmDir, feishuEnabled) {
   const skillsDir = import_node_path4.default.join(wmDir, "skills");
   await (0, import_promises4.mkdir)(skillsDir, { recursive: true });
-  for (const template of skillTemplatesForWorkspace({ feishuEnabled })) {
+  for (const template of skillTemplatesForWorkspace()) {
     const targetDir = import_node_path4.default.join(skillsDir, template.name);
     await (0, import_promises4.mkdir)(targetDir, { recursive: true });
-    await (0, import_promises4.writeFile)(import_node_path4.default.join(targetDir, "SKILL.md"), template.content, { flag: "wx" }).catch((error) => {
-      if (error?.code !== "EEXIST") throw error;
+    await (0, import_promises4.writeFile)(import_node_path4.default.join(targetDir, "SKILL.md"), template.content, "utf8");
+  }
+  await (0, import_promises4.rm)(import_node_path4.default.join(skillsDir, "lark"), { recursive: true, force: true });
+  if (feishuEnabled) await copyLarksuiteSkills(skillsDir);
+}
+async function copyLarksuiteSkills(skillsDir) {
+  const sourceDir = await resolveLarksuiteSkillsSourceDir();
+  const entries = await (0, import_promises4.readdir)(sourceDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !entry.name.startsWith("lark-")) continue;
+    await (0, import_promises4.cp)(import_node_path4.default.join(sourceDir, entry.name), import_node_path4.default.join(skillsDir, entry.name), {
+      recursive: true,
+      force: true
     });
   }
 }
+async function resolveLarksuiteSkillsSourceDir() {
+  const candidates = [
+    import_node_path4.default.join(__dirname, "..", "..", "vendor", "larksuite-cli-skills"),
+    import_node_path4.default.join(__dirname, "skills", "larksuite")
+  ];
+  for (const candidate of candidates) {
+    try {
+      const entries = await (0, import_promises4.readdir)(candidate, { withFileTypes: true });
+      if (entries.some((entry) => entry.isDirectory() && entry.name === "lark-im")) return candidate;
+    } catch {
+    }
+  }
+  throw new Error("official Lark/Feishu skills are missing from daemon package");
+}
 async function buildWorkspaceSkillsSection(input) {
   const result = await scanAgentSkills({
     rootDir: input.rootDir,
@@ -3788,7 +3801,7 @@ var import_ws = __toESM(require("ws"));
 // package.json
 var package_default = {
   name: "@wagemule/daemon",
-  version: "0.1.2",
+  version: "0.1.3",
   private: false,
   description: "Wage Mule local daemon for connecting local agent runtimes to Workspace Server.",
   main: "./dist/main.cjs",
@@ -3825,6 +3838,7 @@ var package_default = {
   dependencies: {
     "@anthropic-ai/claude-agent-sdk": "^0.2.138",
     "@inquirer/prompts": "^8.4.2",
+    "@larksuite/cli": "^1.0.32",
     commander: "^14.0.3",
     ws: "^8.0.0"
   }
@@ -4654,10 +4668,15 @@ var ReminderCache = class {
 
 // src/workspace/feishu-token-writer.ts
 var import_promises10 = require("node:fs/promises");
+var import_node_module = require("node:module");
 var import_node_path11 = __toESM(require("node:path"));
+var requireFromHere = (0, import_node_module.createRequire)(__filename);
 function feishuTokenPath(workspaceDir) {
   return import_node_path11.default.join(workspaceDir, ".wm", "feishu", "token");
 }
+function larkCliWrapperPath(workspaceDir) {
+  return import_node_path11.default.join(workspaceDir, ".wm", "lark-cli");
+}
 async function writeFeishuToken(input) {
   const tokenPath = feishuTokenPath(input.workspaceDir);
   const dir = import_node_path11.default.dirname(tokenPath);
@@ -4669,9 +4688,46 @@ async function writeFeishuToken(input) {
   await (0, import_promises10.chmod)(tokenPath, 384);
   return tokenPath;
 }
+async function writeLarkCliWrapper(input) {
+  const wrapperPath = larkCliWrapperPath(input.workspaceDir);
+  await (0, import_promises10.mkdir)(import_node_path11.default.dirname(wrapperPath), { recursive: true });
+  await (0, import_promises10.writeFile)(wrapperPath, buildLarkCliWrapper(input), { encoding: "utf8", mode: 493 });
+  await (0, import_promises10.chmod)(wrapperPath, 493);
+  return wrapperPath;
+}
 async function clearFeishuToken(input) {
   await (0, import_promises10.rm)(feishuTokenPath(input.workspaceDir), { force: true });
 }
+function buildLarkCliWrapper(input) {
+  const runner = resolveLarkCliRunner();
+  return [
+    "#!/usr/bin/env bash",
+    "set -euo pipefail",
+    'SELF_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"',
+    'TOKEN_FILE="${SELF_DIR}/feishu/token"',
+    'if [[ ! -s "$TOKEN_FILE" ]]; then',
+    '  echo "Feishu token unavailable" >&2',
+    "  exit 2",
+    "fi",
+    `export LARKSUITE_CLI_APP_ID=${shellQuote(input.appId)}`,
+    'export LARKSUITE_CLI_USER_ACCESS_TOKEN="$(cat "$TOKEN_FILE")"',
+    "export LARKSUITE_CLI_DEFAULT_AS=user",
+    "export LARKSUITE_CLI_STRICT_MODE=user",
+    `export LARKSUITE_CLI_BRAND=${shellQuote(input.brand ?? "feishu")}`,
+    runner ? `exec ${shellQuote(process.execPath)} ${shellQuote(runner)} "$@"` : 'exec lark-cli "$@"',
+    ""
+  ].join("\n");
+}
+function resolveLarkCliRunner() {
+  try {
+    return requireFromHere.resolve("@larksuite/cli/scripts/run.js");
+  } catch {
+    return void 0;
+  }
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
 
 // src/agent-manager/activity-tracker.ts
 var ActivityTracker = class {
@@ -4888,7 +4944,7 @@ var AgentProcessManager = class {
     } else if (message.type === "agent:workspace:init") {
       await this.replyWorkspaceInit(message.requestId, message.agentId, message.config);
     } else if (message.type === "feishu:token:write") {
-      await this.replyFeishuTokenWrite(message.requestId, message.agentId, message.token, message.config);
+      await this.replyFeishuTokenWrite(message.requestId, message.agentId, message.token, message.appId, message.brand, message.config);
     } 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") {
@@ -5170,11 +5226,12 @@ var AgentProcessManager = class {
       });
     }
   }
-  async replyFeishuTokenWrite(requestId, agentId, token, config) {
+  async replyFeishuTokenWrite(requestId, agentId, token, appId, brand, config) {
     try {
       const { workspace } = await this.ensureAgentWorkspace(agentId, config);
       if (!workspace) throw new Error(`workspace missing for ${agentId}`);
       const tokenPath = await writeFeishuToken({ workspaceDir: workspace.agentDir, token });
+      await writeLarkCliWrapper({ workspaceDir: workspace.agentDir, appId, brand });
       this.options.sendToServer({ type: "feishu:token:write_result", requestId, agentId, ok: true, tokenPath });
     } catch (error) {
       this.options.sendToServer({
@@ -6049,7 +6106,9 @@ function formatActionableMessagePrompt(messages, wrapperPath) {
     first?.message_id ? `Message ID: ${first.message_id}` : "Message ID: unknown",
     `Thread reply target: ${replyTarget}`,
     "",
-    "Collaboration rule: if this message asks you to ask, check, confirm, contact, or get status from another agent, do not inspect local process/workspace/server activity/task list to answer for them. Ask that agent in this exact thread target with an @mention, wait for their platform reply, then summarize in the same thread.",
+    "Before acting, identify the requested work surface: Wage Mule platform, local workspace, or an external system. Use the tool for that surface.",
+    "Platform-agent collaboration rule: if this message asks you to ask, check, confirm, contact, or get status from another platform agent, do not inspect local process/workspace/server activity/task list to answer for them. Ask that agent in this exact thread target with an @mention, wait for their platform reply, then summarize in the same thread.",
+    "External-system rule: if the user names an external system such as Feishu/Lark, do the action through that external skill, CLI, token, or API, then report the result in this thread. Do not replace an external contact request with a platform mention.",
     "",
     "Complete the requested work. When you have a channel-visible final reply, send it with this agent-local absolute command:",
     replyCommand,