@cremini/skillpack 1.2.11 → 1.2.12

package/dist/cli.js

@@ -42,6 +42,11 @@ function validateScheduledJobConfig(value, sourceLabel, index) {
     );
   }
   const job = value;
+  if (typeof job.id !== "string" || !job.id.trim()) {
+    throw new Error(
+      `Invalid job config from ${sourceLabel}: "jobs[${index}].id" is required`
+    );
+  }
   if (typeof job.name !== "string" || !job.name.trim()) {
     throw new Error(
       `Invalid job config from ${sourceLabel}: "jobs[${index}].name" is required`
@@ -92,16 +97,16 @@ function validateJobFileShape(value, sourceLabel) {
   if (!Array.isArray(jobFile.jobs)) {
     throw new Error(`Invalid job config from ${sourceLabel}: "jobs" must be an array`);
   }
-  const names = /* @__PURE__ */ new Set();
+  const ids = /* @__PURE__ */ new Set();
   jobFile.jobs.forEach((job, index) => {
     validateScheduledJobConfig(job, sourceLabel, index);
-    const normalizedName = job.name.trim().toLowerCase();
-    if (names.has(normalizedName)) {
+    const normalizedId = job.id.trim().toLowerCase();
+    if (ids.has(normalizedId)) {
       throw new Error(
-        `Invalid job config from ${sourceLabel}: duplicate job name "${job.name}" is not allowed`
+        `Invalid job config from ${sourceLabel}: duplicate job id "${job.id}" is not allowed`
       );
     }
-    names.add(normalizedName);
+    ids.add(normalizedId);
   });
 }
 function normalizeJobFile(jobFile) {
@@ -115,6 +120,7 @@ function normalizeScheduledJobConfig(job) {
   const normalizedCron = normalizeJobCron(job.cron);
   const normalizedTimezone = typeof job.timezone === "string" && job.timezone.trim() ? job.timezone.trim() : void 0;
   return {
+    id: job.id.trim(),
     name: job.name.trim(),
     ...normalizedCron ? { cron: normalizedCron } : {},
     prompt: job.prompt,
@@ -286,8 +292,16 @@ var init_commands = __esm({
 // src/runtime/adapters/types.ts
 var types_exports = {};
 __export(types_exports, {
+  detectPlatformFromChannelId: () => detectPlatformFromChannelId,
   isMessageSender: () => isMessageSender
 });
+function detectPlatformFromChannelId(channelId) {
+  if (channelId.startsWith("telegram-")) return "telegram";
+  if (channelId.startsWith("slack-")) return "slack";
+  if (channelId.startsWith("feishu-")) return "feishu";
+  if (channelId.startsWith("scheduler-")) return "scheduler";
+  return "web";
+}
 function isMessageSender(adapter) {
   return typeof adapter.sendMessage === "function";
 }
@@ -1413,6 +1427,297 @@ var init_slack = __esm({
   }
 });
 
+// src/runtime/adapters/feishu.ts
+var feishu_exports = {};
+__export(feishu_exports, {
+  FeishuAdapter: () => FeishuAdapter,
+  normalizeFeishuMessage: () => normalizeFeishuMessage,
+  parseFeishuChannelId: () => parseFeishuChannelId
+});
+import fs16 from "fs";
+import path16 from "path";
+import * as Lark from "@larksuiteoapi/node-sdk";
+function parseFeishuChannelId(channelId) {
+  if (!channelId.startsWith("feishu-")) {
+    throw new Error(`[Feishu] Invalid channelId: ${channelId}`);
+  }
+  const chatId = channelId.replace("feishu-", "").trim();
+  if (!chatId) {
+    throw new Error(`[Feishu] Invalid channelId: ${channelId}`);
+  }
+  return chatId;
+}
+function normalizeFeishuMessage(message) {
+  if (message.chatType === "group" && !message.mentionedBot) {
+    return { action: "ignore" };
+  }
+  if (message.rawContentType !== "text") {
+    return { action: "unsupported" };
+  }
+  const text = message.content.trim();
+  if (!text) {
+    return { action: "ignore" };
+  }
+  return {
+    action: "handle",
+    text
+  };
+}
+var MAX_MESSAGE_LENGTH3, ACK_REACTION3, UNSUPPORTED_MESSAGE_REPLY, FILE_DELIVERY_FAILED_REPLY, FeishuAdapter;
+var init_feishu = __esm({
+  "src/runtime/adapters/feishu.ts"() {
+    "use strict";
+    init_commands();
+    MAX_MESSAGE_LENGTH3 = 1800;
+    ACK_REACTION3 = "THUMBSUP";
+    UNSUPPORTED_MESSAGE_REPLY = "Only text messages are currently supported. Please send plain text.";
+    FILE_DELIVERY_FAILED_REPLY = "A file was generated, but Feishu could not deliver it.";
+    FeishuAdapter = class {
+      name = "feishu";
+      channel = null;
+      agent = null;
+      ipcBroadcaster = null;
+      options;
+      constructor(options) {
+        this.options = options;
+      }
+      async start(ctx) {
+        this.agent = ctx.agent;
+        this.ipcBroadcaster = ctx.ipcBroadcaster ?? null;
+        this.channel = Lark.createLarkChannel({
+          appId: this.options.appId,
+          appSecret: this.options.appSecret,
+          loggerLevel: Lark.LoggerLevel.info,
+          transport: "websocket",
+          source: "skillpack",
+          policy: {
+            dmMode: "open",
+            requireMention: false
+          }
+        });
+        this.channel.on("message", (message) => {
+          void this.handleIncomingMessage(message).catch((error) => {
+            console.error("[Feishu] Error handling message:", error);
+          });
+        });
+        this.channel.on("error", (error) => {
+          console.error("[Feishu] Channel error:", error);
+        });
+        await this.channel.connect();
+        const botName = this.channel.botIdentity?.name;
+        console.log(
+          botName ? `[FeishuAdapter] Started as ${botName}` : "[FeishuAdapter] Started"
+        );
+      }
+      async stop() {
+        if (this.channel) {
+          await this.channel.disconnect();
+          this.channel = null;
+        }
+        console.log("[FeishuAdapter] Stopped");
+      }
+      async sendMessage(channelId, text) {
+        if (!this.channel) {
+          throw new Error("[Feishu] Channel not initialized");
+        }
+        const chatId = parseFeishuChannelId(channelId);
+        await this.sendLongMessage(chatId, text);
+      }
+      async sendFile(channelId, filePath, caption) {
+        if (!this.channel) {
+          throw new Error("[Feishu] Channel not initialized");
+        }
+        const chatId = parseFeishuChannelId(channelId);
+        const sent = await this.sendFileSafe(chatId, filePath, caption);
+        if (!sent) {
+          throw new Error(`[Feishu] Failed to send file: ${filePath}`);
+        }
+      }
+      async handleIncomingMessage(message) {
+        if (!this.channel || !this.agent) {
+          return;
+        }
+        const decision = normalizeFeishuMessage(message);
+        if (decision.action === "ignore") {
+          return;
+        }
+        await this.tryAckReaction(message.messageId);
+        const channelId = `feishu-${message.chatId}`;
+        if (decision.action === "unsupported") {
+          await this.sendSafe(message.chatId, UNSUPPORTED_MESSAGE_REPLY, message.messageId);
+          return;
+        }
+        const userText = decision.text;
+        this.ipcBroadcaster?.broadcastInbound(
+          channelId,
+          "feishu",
+          {
+            id: message.senderId,
+            username: message.senderName || message.senderId
+          },
+          userText
+        );
+        const command = this.resolveCommand(userText);
+        if (command) {
+          const result = await this.agent.handleCommand(command, channelId);
+          await this.sendSafe(
+            message.chatId,
+            result.message || `/${command} executed.`,
+            message.messageId
+          );
+          return;
+        }
+        let finalText = "";
+        let hasError = false;
+        let errorMessage = "";
+        const pendingFiles = [];
+        const onEvent = (event) => {
+          switch (event.type) {
+            case "text_delta":
+              finalText += event.delta;
+              break;
+            case "file_output":
+              pendingFiles.push({
+                filePath: event.filePath,
+                caption: event.caption
+              });
+              break;
+          }
+          this.ipcBroadcaster?.broadcastAgentEvent(channelId, event);
+        };
+        try {
+          const result = await this.agent.handleMessage(
+            "feishu",
+            channelId,
+            userText,
+            onEvent
+          );
+          if (result.errorMessage) {
+            hasError = true;
+            errorMessage = result.errorMessage;
+          }
+        } catch (error) {
+          hasError = true;
+          errorMessage = error instanceof Error ? error.message : String(error);
+        }
+        if (hasError) {
+          await this.sendSafe(message.chatId, `Error: ${errorMessage}`, message.messageId);
+          return;
+        }
+        if (finalText.trim()) {
+          await this.sendLongMessage(message.chatId, finalText, message.messageId);
+        } else if (pendingFiles.length === 0) {
+          await this.sendSafe(message.chatId, "(No response generated)", message.messageId);
+        }
+        let sentFileCount = 0;
+        for (const file of pendingFiles) {
+          if (await this.sendFileSafe(
+            message.chatId,
+            file.filePath,
+            file.caption,
+            message.messageId
+          )) {
+            sentFileCount += 1;
+          }
+        }
+        if (pendingFiles.length > 0 && sentFileCount === 0) {
+          await this.sendSafe(
+            message.chatId,
+            FILE_DELIVERY_FAILED_REPLY,
+            message.messageId
+          );
+        }
+      }
+      resolveCommand(text) {
+        return resolveCommand(text);
+      }
+      async sendLongMessage(chatId, text, replyTo) {
+        for (const chunk of this.splitMessage(text)) {
+          await this.sendSafe(chatId, chunk, replyTo);
+        }
+      }
+      splitMessage(text) {
+        if (text.length <= MAX_MESSAGE_LENGTH3) {
+          return [text];
+        }
+        const chunks = [];
+        let remaining = text;
+        while (remaining.length > 0) {
+          if (remaining.length <= MAX_MESSAGE_LENGTH3) {
+            chunks.push(remaining);
+            break;
+          }
+          let splitAt = remaining.lastIndexOf("\n\n", MAX_MESSAGE_LENGTH3);
+          if (splitAt < MAX_MESSAGE_LENGTH3 * 0.5) {
+            splitAt = remaining.lastIndexOf("\n", MAX_MESSAGE_LENGTH3);
+          }
+          if (splitAt < MAX_MESSAGE_LENGTH3 * 0.3) {
+            splitAt = remaining.lastIndexOf(" ", MAX_MESSAGE_LENGTH3);
+          }
+          if (splitAt < 1) {
+            splitAt = MAX_MESSAGE_LENGTH3;
+          }
+          chunks.push(remaining.slice(0, splitAt));
+          remaining = remaining.slice(splitAt).trimStart();
+        }
+        return chunks;
+      }
+      async tryAckReaction(messageId) {
+        if (!this.channel) {
+          return;
+        }
+        try {
+          await this.channel.addReaction(messageId, ACK_REACTION3);
+        } catch (error) {
+          console.error("[Feishu] Failed to add ack reaction:", error);
+        }
+      }
+      async sendFileSafe(chatId, filePath, caption, replyTo) {
+        if (!this.channel) {
+          return false;
+        }
+        try {
+          if (!fs16.existsSync(filePath)) {
+            console.error(`[Feishu] File not found for sending: ${filePath}`);
+            return false;
+          }
+          if (caption?.trim()) {
+            await this.sendSafe(chatId, caption, replyTo);
+          }
+          await this.channel.send(
+            chatId,
+            {
+              file: {
+                source: filePath,
+                fileName: path16.basename(filePath)
+              }
+            },
+            replyTo ? { replyTo } : void 0
+          );
+          return true;
+        } catch (error) {
+          console.error("[Feishu] Failed to send file:", error);
+          return false;
+        }
+      }
+      async sendSafe(chatId, text, replyTo) {
+        if (!this.channel) {
+          return;
+        }
+        try {
+          await this.channel.send(
+            chatId,
+            { markdown: text },
+            replyTo ? { replyTo } : void 0
+          );
+        } catch (error) {
+          console.error("[Feishu] Failed to send message:", error);
+        }
+      }
+    };
+  }
+});
+
 // src/runtime/adapters/scheduler.ts
 var scheduler_exports = {};
 __export(scheduler_exports, {
@@ -1427,19 +1732,19 @@ function isValidTimezone(tz) {
     return false;
   }
 }
-function isValidJobName(name) {
-  return VALID_JOB_NAME.test(name) && name.length <= 64;
+function isValidJobId(id) {
+  return id.length > 0 && id.length <= 128 && !INVALID_JOB_ID_CHARS.test(id);
 }
 function isRecurringJob(jobConfig) {
   return hasJobSchedule(jobConfig);
 }
-var VALID_JOB_NAME, SchedulerAdapter;
+var INVALID_JOB_ID_CHARS, SchedulerAdapter;
 var init_scheduler = __esm({
   "src/runtime/adapters/scheduler.ts"() {
     "use strict";
     init_job_config();
     init_job_schedule();
-    VALID_JOB_NAME = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
+    INVALID_JOB_ID_CHARS = /[\\/\r\n]/;
     SchedulerAdapter = class {
       name = "scheduler";
       agent;
@@ -1493,8 +1798,8 @@ var init_scheduler = __esm({
       registerJob(jobConfig) {
         const normalizedConfig = normalizeScheduledJobConfig(jobConfig);
         const normalizedCron = normalizeJobCron(normalizedConfig.cron);
-        if (!isValidJobName(normalizedConfig.name)) {
-          const msg = `[Scheduler] Invalid job name "${normalizedConfig.name}": must match ${VALID_JOB_NAME} and be \u226464 chars`;
+        if (!isValidJobId(normalizedConfig.id)) {
+          const msg = `[Scheduler] Invalid job id "${normalizedConfig.id}": must be non-empty, must not contain "/", "\\\\", or line breaks, and must be \u2264128 chars`;
           console.error(msg);
           return { registered: false, message: msg };
         }
@@ -1510,7 +1815,7 @@ var init_scheduler = __esm({
             return { registered: false, message: msg };
           }
         }
-        this.removeFromMap(normalizedConfig.name);
+        this.removeFromMap(normalizedConfig.id);
         let task = null;
         if (normalizedCron && normalizedConfig.enabled !== false) {
           task = this.createCronTask(normalizedConfig);
@@ -1526,7 +1831,7 @@ var init_scheduler = __esm({
             `[Scheduler] Job "${normalizedConfig.name}" registered as one-time (manual trigger only)`
           );
         }
-        this.jobs.set(normalizedConfig.name, {
+        this.jobs.set(normalizedConfig.id, {
           config: normalizedConfig,
           task,
           running: false,
@@ -1542,8 +1847,8 @@ var init_scheduler = __esm({
        * Returns { text, notifyFailed } so callers can produce accurate status.
        */
       async runJob(jobConfig) {
-        const channelId = `scheduler-${jobConfig.name}`;
-        const job = this.jobs.get(jobConfig.name);
+        const channelId = `scheduler-${jobConfig.id}`;
+        const job = this.jobs.get(jobConfig.id);
         if (job?.running) {
           console.warn(
             `[Scheduler] Job "${jobConfig.name}" is already running, skipping this trigger`
@@ -1659,7 +1964,7 @@ var init_scheduler = __esm({
        * Add a new job, persist to job.json.
        */
       addJob(jobConfig) {
-        if (this.jobs.has(jobConfig.name)) {
+        if (this.jobs.has(jobConfig.id)) {
           return {
             success: false,
             message: `Job "${jobConfig.name}" already exists. Remove it first.`
@@ -1680,21 +1985,23 @@ var init_scheduler = __esm({
       /**
        * Remove a job and persist to job.json.
        */
-      removeJob(name) {
-        if (!this.jobs.has(name)) {
-          return { success: false, message: `Job "${name}" not found.` };
+      removeJob(id) {
+        const job = this.jobs.get(id);
+        if (!job) {
+          return { success: false, message: `Job "${id}" not found.` };
         }
-        this.removeFromMap(name);
+        this.removeFromMap(id);
         this.persistJobs();
-        return { success: true, message: `Job "${name}" removed.` };
+        return { success: true, message: `Job "${job.config.name}" removed.` };
       }
-      updateJob(name, updates) {
-        const job = this.jobs.get(name);
+      updateJob(id, updates) {
+        const job = this.jobs.get(id);
         if (!job) {
-          return { success: false, message: `Job "${name}" not found.` };
+          return { success: false, message: `Job "${id}" not found.` };
         }
         const nextConfig = {
-          name,
+          id: job.config.id,
+          name: job.config.name,
           cron: updates.cron,
           prompt: updates.prompt,
           notify: updates.notify,
@@ -1708,21 +2015,21 @@ var init_scheduler = __esm({
         this.persistJobs();
         return {
           success: true,
-          message: `Job "${name}" updated.`
+          message: `Job "${job.config.name}" updated.`
         };
       }
       /**
        * Enable or disable a job and persist.
        */
-      setEnabled(name, enabled) {
-        const job = this.jobs.get(name);
+      setEnabled(id, enabled) {
+        const job = this.jobs.get(id);
         if (!job) {
-          return { success: false, message: `Job "${name}" not found.` };
+          return { success: false, message: `Job "${id}" not found.` };
         }
         if (!isRecurringJob(job.config)) {
           return {
             success: false,
-            message: `Job "${name}" does not have a schedule and cannot be enabled or disabled.`
+            message: `Job "${job.config.name}" does not have a schedule and cannot be enabled or disabled.`
           };
         }
         job.config.enabled = enabled;
@@ -1736,33 +2043,33 @@ var init_scheduler = __esm({
         this.persistJobs();
         return {
           success: true,
-          message: `Job "${name}" ${enabled ? "enabled" : "disabled"}.`
+          message: `Job "${job.config.name}" ${enabled ? "enabled" : "disabled"}.`
         };
       }
       /**
        * Manually trigger a job (runs immediately, ignoring cron schedule).
        */
-      async triggerJob(name) {
-        const job = this.jobs.get(name);
+      async triggerJob(id) {
+        const job = this.jobs.get(id);
         if (!job) {
-          return { success: false, message: `Job "${name}" not found.` };
+          return { success: false, message: `Job "${id}" not found.` };
         }
         const { text, notifyFailed } = await this.runJob(job.config);
         if (!text) {
           return {
             success: true,
-            message: `Job "${name}" triggered but produced no output.`
+            message: `Job "${job.config.name}" triggered but produced no output.`
           };
         }
         if (notifyFailed) {
           return {
             success: true,
-            message: `Job "${name}" executed, but notification to ${job.config.notify.adapter} failed. Check logs.`
+            message: `Job "${job.config.name}" executed, but notification to ${job.config.notify.adapter} failed. Check logs.`
           };
         }
         return {
           success: true,
-          message: `Job "${name}" triggered. Result sent to ${job.config.notify.adapter}.`
+          message: `Job "${job.config.name}" triggered. Result sent to ${job.config.notify.adapter}.`
         };
       }
       /**
@@ -1772,6 +2079,7 @@ var init_scheduler = __esm({
         const result = [];
         for (const [, job] of this.jobs) {
           result.push({
+            id: job.config.id,
             name: job.config.name,
             ...job.config.cron ? { cron: job.config.cron } : {},
             prompt: job.config.prompt,
@@ -1792,11 +2100,11 @@ var init_scheduler = __esm({
       /**
        * Stop the cron task and remove a job from the map (does NOT persist).
        */
-      removeFromMap(name) {
-        const existing = this.jobs.get(name);
+      removeFromMap(id) {
+        const existing = this.jobs.get(id);
         if (existing) {
           existing.task?.stop();
-          this.jobs.delete(name);
+          this.jobs.delete(id);
         }
       }
       /**
@@ -2515,15 +2823,15 @@ async function interactiveCreate(workDir) {
 }
 
 // src/commands/run.ts
-import path17 from "path";
-import fs17 from "fs";
+import path18 from "path";
+import fs18 from "fs";
 import inquirer2 from "inquirer";
 import chalk4 from "chalk";
 
 // src/runtime/server.ts
 import express from "express";
-import path16 from "path";
-import fs16 from "fs";
+import path17 from "path";
+import fs17 from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createServer } from "http";
 import { exec } from "child_process";
@@ -2531,7 +2839,7 @@ import { exec } from "child_process";
 // src/runtime/agent.ts
 import path11 from "path";
 import fs10 from "fs";
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { fileURLToPath } from "url";
 import {
   AuthStorage,
@@ -3085,6 +3393,7 @@ function createSendFileTool(fileOutputCallbackRef) {
 }
 
 // src/runtime/tools/manage-schedule-tool.ts
+import { randomUUID as randomUUID3 } from "crypto";
 import { Type as Type2 } from "@sinclair/typebox";
 var ManageScheduleParams = Type2.Object({
   action: Type2.Union(
@@ -3100,7 +3409,7 @@ var ManageScheduleParams = Type2.Object({
   ),
   name: Type2.Optional(
     Type2.String({
-      description: "Unique name for the scheduled task. Required for add/remove/trigger/enable/disable."
+      description: "Display name for the scheduled task. Required for add/remove/trigger/enable/disable."
     })
   ),
   cron: Type2.Optional(
@@ -3120,7 +3429,7 @@ var ManageScheduleParams = Type2.Object({
   ),
   notifyAdapter: Type2.Optional(
     Type2.String({
-      description: "Optional target adapter for notifications. If omitted, the current chat is used when supported (Telegram, Slack, or Web)."
+      description: "Optional target adapter for notifications. If omitted, the current chat is used when supported (Telegram, Slack, Feishu, or Web)."
     })
   ),
   notifyChannelId: Type2.Optional(
@@ -3132,6 +3441,27 @@ var ManageScheduleParams = Type2.Object({
 function textResult(text) {
   return { content: [{ type: "text", text }], details: void 0 };
 }
+function resolveJobId(scheduler, nameOrId) {
+  const jobs = scheduler.listJobs();
+  const byId = jobs.find((job) => job.id === nameOrId);
+  if (byId) {
+    return { ok: true, jobId: byId.id };
+  }
+  const byName = jobs.filter((job) => job.name === nameOrId);
+  if (byName.length === 1) {
+    return { ok: true, jobId: byName[0].id };
+  }
+  if (byName.length > 1) {
+    return {
+      ok: false,
+      message: `Error: Multiple scheduled tasks share the name '${nameOrId}'. Rename one of them before using this action.`
+    };
+  }
+  return {
+    ok: false,
+    message: `Error: Scheduled task '${nameOrId}' was not found.`
+  };
+}
 function getDefaultNotifyTarget(adapter, channelId) {
   if (adapter === "telegram" && channelId.startsWith("telegram-")) {
     return { adapter: "telegram", channelId };
@@ -3139,12 +3469,15 @@ function getDefaultNotifyTarget(adapter, channelId) {
   if (adapter === "slack" && channelId.startsWith("slack-")) {
     return { adapter: "slack", channelId };
   }
+  if (adapter === "feishu" && channelId.startsWith("feishu-")) {
+    return { adapter: "feishu", channelId };
+  }
   if (adapter === "web") {
     return { adapter: "web", channelId };
   }
   return null;
 }
-function createManageScheduleTool(schedulerRef, adapter, channelId) {
+function createManageScheduleTool(schedulerRef, adapter, channelId, generateJobId = randomUUID3) {
   return {
     name: "manage_scheduled_task",
     label: "Manage Scheduled Task",
@@ -3152,11 +3485,11 @@ function createManageScheduleTool(schedulerRef, adapter, channelId) {
       "Manage scheduled tasks (cron jobs) that automatically execute prompts and push results to IM channels.",
       "",
       "Actions:",
-      "- add: Create a new scheduled task. Requires: name, cron, prompt. Notifications default to the current Telegram, Slack, or Web chat. You can override the destination with notifyAdapter + notifyChannelId. The prompt must describe only the work for each run, not the schedule itself.",
+      "- add: Create a new scheduled task. Requires: name, cron, prompt. Notifications default to the current Telegram, Slack, Feishu, or Web chat. You can override the destination with notifyAdapter + notifyChannelId. The prompt must describe only the work for each run, not the schedule itself.",
       "- list: List all scheduled tasks with their status.",
-      "- remove: Remove a scheduled task by name.",
-      "- trigger: Manually trigger a scheduled task by name (runs immediately).",
-      "- enable: Enable a disabled scheduled task.",
+      "- remove: Remove a scheduled task by display name.",
+      "- trigger: Manually trigger a scheduled task by display name (runs immediately).",
+      "- enable: Enable a disabled scheduled task by display name.",
       "- disable: Disable a scheduled task without removing it.",
       "",
       "Cron expression format: '* * * * *' (minute hour day month weekday)",
@@ -3208,6 +3541,7 @@ ${lines.join("\n")}`
             );
           }
           const jobConfig = {
+            id: generateJobId(),
             name: params.name,
             cron: params.cron,
             prompt: params.prompt,
@@ -3224,7 +3558,11 @@ ${lines.join("\n")}`
               "Error: 'name' is required for removing a task."
             );
           }
-          const result = scheduler.removeJob(params.name);
+          const resolved = resolveJobId(scheduler, params.name);
+          if (!resolved.ok) {
+            return textResult(resolved.message);
+          }
+          const result = scheduler.removeJob(resolved.jobId);
           return textResult(result.message);
         }
         case "trigger": {
@@ -3233,7 +3571,11 @@ ${lines.join("\n")}`
               "Error: 'name' is required for triggering a task."
             );
           }
-          const result = await scheduler.triggerJob(params.name);
+          const resolved = resolveJobId(scheduler, params.name);
+          if (!resolved.ok) {
+            return textResult(resolved.message);
+          }
+          const result = await scheduler.triggerJob(resolved.jobId);
           return textResult(result.message);
         }
         case "enable": {
@@ -3242,7 +3584,11 @@ ${lines.join("\n")}`
               "Error: 'name' is required for enabling a task."
             );
           }
-          const result = scheduler.setEnabled(params.name, true);
+          const resolved = resolveJobId(scheduler, params.name);
+          if (!resolved.ok) {
+            return textResult(resolved.message);
+          }
+          const result = scheduler.setEnabled(resolved.jobId, true);
           return textResult(result.message);
         }
         case "disable": {
@@ -3251,7 +3597,11 @@ ${lines.join("\n")}`
               "Error: 'name' is required for disabling a task."
             );
           }
-          const result = scheduler.setEnabled(params.name, false);
+          const resolved = resolveJobId(scheduler, params.name);
+          if (!resolved.ok) {
+            return textResult(resolved.message);
+          }
+          const result = scheduler.setEnabled(resolved.jobId, false);
           return textResult(result.message);
         }
         default:
@@ -3325,6 +3675,7 @@ function readInstalledSkills(configPath) {
 }
 
 // src/runtime/agent.ts
+init_types();
 var DEBUG = true;
 var log = (...args) => DEBUG && console.log(...args);
 var write = (data) => DEBUG && process.stdout.write(data);
@@ -3464,9 +3815,8 @@ function getAssistantDiagnostics(message) {
   return { stopReason, errorMessage, hasText: text.length > 0, toolCalls };
 }
 function getLifecycleTrigger(channelId) {
-  if (channelId.startsWith("telegram-")) return "telegram";
-  if (channelId.startsWith("slack-")) return "slack";
-  return "web";
+  const platform = detectPlatformFromChannelId(channelId);
+  return platform === "scheduler" ? "web" : platform;
 }
 var PackAgent = class {
   options;
@@ -3664,7 +4014,7 @@ var PackAgent = class {
     const run = async () => {
       cs.running = true;
       let turnHadVisibleOutput = false;
-      const runId = randomUUID3();
+      const runId = randomUUID4();
       let unsubscribe = () => void 0;
       try {
         cs.fileOutputCallbackRef.current = (event) => {
@@ -3878,12 +4228,14 @@ ${text}`;
 };
 
 // src/runtime/adapters/web.ts
+import { randomUUID as randomUUID5 } from "crypto";
 import fs12 from "fs";
 import path13 from "path";
 import { WebSocketServer } from "ws";
 init_commands();
 
 // src/runtime/services/conversation.ts
+init_types();
 import fs11 from "fs";
 import path12 from "path";
 import {
@@ -4267,10 +4619,7 @@ var ConversationService = class {
     return parts[parts.length - 1] || filePath;
   }
   detectPlatform(channelId) {
-    if (channelId.startsWith("telegram-")) return "telegram";
-    if (channelId.startsWith("slack-")) return "slack";
-    if (channelId.startsWith("scheduler-")) return "scheduler";
-    return "web";
+    return detectPlatformFromChannelId(channelId);
   }
   isLegacyWebConversation(channelId) {
     return channelId.startsWith("web-");
@@ -4298,7 +4647,9 @@ function getRuntimeConfigSignature(config) {
     apiProtocol: config.apiProtocol || "",
     telegramToken: config.adapters?.telegram?.token || "",
     slackBotToken: config.adapters?.slack?.botToken || "",
-    slackAppToken: config.adapters?.slack?.appToken || ""
+    slackAppToken: config.adapters?.slack?.appToken || "",
+    feishuAppId: config.adapters?.feishu?.appId || "",
+    feishuAppSecret: config.adapters?.feishu?.appSecret || ""
   });
 }
 function parsePositiveInt(value, fallback) {
@@ -4509,7 +4860,15 @@ var WebAdapter = class {
         res.status(503).json({ success: false, message: "Scheduler not available" });
         return;
       }
-      const { name, cron: cronExpr, prompt, notify, enabled, timezone } = req.body;
+      const {
+        id,
+        name,
+        cron: cronExpr,
+        prompt,
+        notify,
+        enabled,
+        timezone
+      } = req.body;
       if (!name || !prompt || !notify?.adapter || !notify?.channelId) {
         res.status(400).json({
           success: false,
@@ -4518,6 +4877,7 @@ var WebAdapter = class {
         return;
       }
       const result = scheduler.addJob({
+        id: typeof id === "string" && id.trim() ? id.trim() : randomUUID5(),
         name,
         ...typeof cronExpr === "string" ? { cron: cronExpr } : {},
         prompt,
@@ -4527,25 +4887,25 @@ var WebAdapter = class {
       });
       res.json(result);
     });
-    app.delete("/api/scheduler/jobs/:name", (req, res) => {
+    app.delete("/api/scheduler/jobs/:jobId", (req, res) => {
       const scheduler = getScheduler();
       if (!scheduler) {
         res.status(503).json({ success: false, message: "Scheduler not available" });
         return;
       }
-      const result = scheduler.removeJob(req.params.name);
+      const result = scheduler.removeJob(req.params.jobId);
       res.json(result);
     });
-    app.post("/api/scheduler/jobs/:name/trigger", async (req, res) => {
+    app.post("/api/scheduler/jobs/:jobId/trigger", async (req, res) => {
       const scheduler = getScheduler();
       if (!scheduler) {
         res.status(503).json({ success: false, message: "Scheduler not available" });
         return;
       }
-      const result = await scheduler.triggerJob(req.params.name);
+      const result = await scheduler.triggerJob(req.params.jobId);
       res.json(result);
     });
-    app.patch("/api/scheduler/jobs/:name", (req, res) => {
+    app.patch("/api/scheduler/jobs/:jobId", (req, res) => {
       const scheduler = getScheduler();
       if (!scheduler) {
         res.status(503).json({ success: false, message: "Scheduler not available" });
@@ -4556,7 +4916,7 @@ var WebAdapter = class {
         res.status(400).json({ success: false, message: "Field 'enabled' (boolean) is required" });
         return;
       }
-      const result = scheduler.setEnabled(req.params.name, enabled);
+      const result = scheduler.setEnabled(req.params.jobId, enabled);
       res.json(result);
     });
     this.wss = new WebSocketServer({ noServer: true });
@@ -4877,7 +5237,7 @@ var IpcAdapter = class {
             this.replyError(request.id, "Scheduler adapter is not available");
             return;
           }
-          const result = scheduler.updateJob(request.name, request.updates);
+          const result = scheduler.updateJob(request.jobId, request.updates);
           if (!result.success) {
             this.replyError(request.id, result.message);
             return;
@@ -4891,7 +5251,7 @@ var IpcAdapter = class {
             this.replyError(request.id, "Scheduler adapter is not available");
             return;
           }
-          const result = scheduler.setEnabled(request.name, request.enabled);
+          const result = scheduler.setEnabled(request.jobId, request.enabled);
           if (!result.success) {
             this.replyError(request.id, result.message);
             return;
@@ -4905,7 +5265,7 @@ var IpcAdapter = class {
             this.replyError(request.id, "Scheduler adapter is not available");
             return;
           }
-          const result = await scheduler.triggerJob(request.name);
+          const result = await scheduler.triggerJob(request.jobId);
           if (!result.success) {
             this.replyError(request.id, result.message);
             return;
@@ -4919,7 +5279,7 @@ var IpcAdapter = class {
             this.replyError(request.id, "Scheduler adapter is not available");
             return;
           }
-          const result = scheduler.removeJob(request.name);
+          const result = scheduler.removeJob(request.jobId);
           if (!result.success) {
             this.replyError(request.id, result.message);
             return;
@@ -4941,10 +5301,7 @@ var IpcAdapter = class {
     return adapter;
   }
   detectPlatform(channelId) {
-    if (channelId.startsWith("telegram-")) return "telegram";
-    if (channelId.startsWith("slack-")) return "slack";
-    if (channelId.startsWith("scheduler-")) return "scheduler";
-    return "web";
+    return detectPlatformFromChannelId(channelId);
   }
   sendIpc(payload) {
     if (typeof process.send === "function") {
@@ -5189,7 +5546,7 @@ function deregister(dir, pid) {
 }
 
 // src/runtime/server.ts
-var __dirname = path16.dirname(fileURLToPath2(import.meta.url));
+var __dirname = path17.dirname(fileURLToPath2(import.meta.url));
 async function startServer(options) {
   const {
     rootDir,
@@ -5205,8 +5562,8 @@ async function startServer(options) {
   const baseUrl = dataConfig.baseUrl?.trim() || void 0;
   const modelId = dataConfig.modelId?.trim() || (SUPPORTED_PROVIDERS[provider]?.defaultModelId ?? SUPPORTED_PROVIDERS.openai.defaultModelId);
   const apiProtocol = dataConfig.apiProtocol;
-  const packageRoot = path16.resolve(__dirname, "..");
-  const webDir = fs16.existsSync(path16.join(rootDir, "web")) ? path16.join(rootDir, "web") : path16.join(packageRoot, "web");
+  const packageRoot = path17.resolve(__dirname, "..");
+  const webDir = fs17.existsSync(path17.join(rootDir, "web")) ? path17.join(rootDir, "web") : path17.join(packageRoot, "web");
   const app = express();
   app.use(express.json());
   app.use(express.static(webDir));
@@ -5318,6 +5675,35 @@ async function startServer(options) {
       }
     }
   }
+  const feishuConfig = dataConfig.adapters?.feishu;
+  if (feishuConfig?.appId || feishuConfig?.appSecret) {
+    if (!feishuConfig.appId || !feishuConfig.appSecret) {
+      console.warn(
+        "[Feishu] Skipped: both adapters.feishu.appId and adapters.feishu.appSecret are required."
+      );
+    } else {
+      try {
+        const { FeishuAdapter: FeishuAdapter2 } = await Promise.resolve().then(() => (init_feishu(), feishu_exports));
+        const feishuAdapter = new FeishuAdapter2({
+          appId: feishuConfig.appId,
+          appSecret: feishuConfig.appSecret
+        });
+        await feishuAdapter.start({
+          agent,
+          server,
+          app,
+          rootDir,
+          lifecycle,
+          adapterMap,
+          ipcBroadcaster
+        });
+        adapters.push(feishuAdapter);
+        adapterMap.set(feishuAdapter.name, feishuAdapter);
+      } catch (err) {
+        console.error("[Feishu] Failed to start:", err);
+      }
+    }
+  }
   const { isMessageSender: isMessageSender2 } = await Promise.resolve().then(() => (init_types(), types_exports));
   const notifyFn = async (adapterName, channelId, text) => {
     const adapter = adapterMap.get(adapterName);
@@ -5429,23 +5815,23 @@ function findMissingSkills(workDir, config) {
   });
 }
 function copyStartTemplates2(workDir) {
-  const templateDir = path17.resolve(
+  const templateDir = path18.resolve(
     new URL("../templates", import.meta.url).pathname
   );
   for (const file of ["start.sh", "start.bat"]) {
-    const src = path17.join(templateDir, file);
-    const dest = path17.join(workDir, file);
-    if (fs17.existsSync(src)) {
-      fs17.copyFileSync(src, dest);
+    const src = path18.join(templateDir, file);
+    const dest = path18.join(workDir, file);
+    if (fs18.existsSync(src)) {
+      fs18.copyFileSync(src, dest);
       if (file === "start.sh") {
-        fs17.chmodSync(dest, 493);
+        fs18.chmodSync(dest, 493);
       }
     }
   }
 }
 async function runCommand(directory) {
-  const workDir = directory ? path17.resolve(directory) : process.cwd();
-  fs17.mkdirSync(workDir, { recursive: true });
+  const workDir = directory ? path18.resolve(directory) : process.cwd();
+  fs18.mkdirSync(workDir, { recursive: true });
   if (!configExists(workDir)) {
     console.log(chalk4.blue("\n  No skillpack.json found. Let's set one up.\n"));
     const { name, description } = await inquirer2.prompt([
@@ -5489,14 +5875,14 @@ async function runCommand(directory) {
 }
 
 // src/cli.ts
-import fs18 from "fs";
-import path18 from "path";
+import fs19 from "fs";
+import path19 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var packageJson = JSON.parse(
-  fs18.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
+  fs19.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
 );
 var program = new Command();
-var cliFilePath = path18.resolve(fileURLToPath3(import.meta.url));
+var cliFilePath = path19.resolve(fileURLToPath3(import.meta.url));
 program.name("skillpack").description("Assemble, package, and run Agent Skills packs").version(packageJson.version);
 program.command("create [directory]").description("Create a skills pack interactively").option("--config <path-or-url>", "Initialize from a local or remote skillpack.json").action(async (directory, options) => {
   await createCommand(directory, options);
@@ -5517,7 +5903,7 @@ program.command("zip").description("Package the current pack as a zip file (skil
 function normalizeUserArgs(argv) {
   if (argv.length === 0) return argv;
   const firstArg = argv[0];
-  if (firstArg && path18.resolve(firstArg) === cliFilePath) {
+  if (firstArg && path19.resolve(firstArg) === cliFilePath) {
     return argv.slice(1);
   }
   return argv;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cremini/skillpack",
-  "version": "1.2.11",
+  "version": "1.2.12",
   "description": "Pack AI Skills into Local Agents",
   "type": "module",
   "repository": {
@@ -44,6 +44,7 @@
   "author": "CreminiAI",
   "license": "MIT",
   "dependencies": {
+    "@larksuiteoapi/node-sdk": "^1.63.1",
     "@mariozechner/pi-coding-agent": "^0.57.1",
     "@sinclair/typebox": "^0.34.41",
     "@slack/bolt": "^4.6.0",
@@ -70,4 +71,4 @@
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   }
-}
+}

package/web/index.html

@@ -164,6 +164,17 @@
             <input type="password" id="chatapps-slack-app-token" placeholder="xapp-..." class="form-input" />
           </div>
         </div>
+        <div class="settings-section">
+          <h3 class="section-title">Feishu</h3>
+          <div class="form-group">
+            <label>App ID</label>
+            <input type="password" id="chatapps-feishu-app-id" placeholder="cli_a1b2c3d4..." class="form-input" />
+          </div>
+          <div class="form-group">
+            <label>App Secret</label>
+            <input type="password" id="chatapps-feishu-app-secret" placeholder="your-feishu-app-secret" class="form-input" />
+          </div>
+        </div>
       </div>
     </div>
     <div class="settings-modal-footer">

package/web/js/chat-apps-dialog.js

@@ -1,7 +1,7 @@
 /**
  * Chat Apps (IM Bots) Dialog Module
  * 
- * 负责 IM Bots（Telegram / Slack）Token 的配置管理。
+ * 负责 IM Bots（Telegram / Slack / Feishu）配置管理。
  * 独立的 Dialog，从原 SettingDialog 的 IM Bots 部分拆分出来。
  */
 import { state } from "./config.js";
@@ -16,8 +16,22 @@ let restartBtn;
 let telegramTokenInput;
 let slackBotTokenInput;
 let slackAppTokenInput;
+let feishuAppIdInput;
+let feishuAppSecretInput;
 let statusEl;
 
+function hasConfiguredChatApp(adapters = {}) {
+  const telegramConfigured = Boolean(adapters.telegram?.token);
+  const slackConfigured = Boolean(
+    adapters.slack?.botToken && adapters.slack?.appToken,
+  );
+  const feishuConfigured = Boolean(
+    adapters.feishu?.appId && adapters.feishu?.appSecret,
+  );
+
+  return telegramConfigured || slackConfigured || feishuConfigured;
+}
+
 // --- Public API ---
 
 export function initChatAppsDialog() {
@@ -29,6 +43,8 @@ export function initChatAppsDialog() {
   telegramTokenInput = document.getElementById("chatapps-telegram-token");
   slackBotTokenInput = document.getElementById("chatapps-slack-bot-token");
   slackAppTokenInput = document.getElementById("chatapps-slack-app-token");
+  feishuAppIdInput = document.getElementById("chatapps-feishu-app-id");
+  feishuAppSecretInput = document.getElementById("chatapps-feishu-app-secret");
   statusEl = document.getElementById("chatapps-status");
 
   if (!dialog) return;
@@ -54,9 +70,7 @@ export function updateChatAppsButton() {
   if (!openBtn) return;
   const config = state.config;
   const adapters = config?.adapters || {};
-  const hasAnyToken =
-    (adapters.telegram && adapters.telegram.token) ||
-    (adapters.slack && (adapters.slack.botToken || adapters.slack.appToken));
+  const hasAnyToken = hasConfiguredChatApp(adapters);
 
   if (hasAnyToken) {
     openBtn.classList.add("connected");
@@ -99,6 +113,14 @@ function populateForm() {
     slackAppTokenInput.value = "";
   }
 
+  if (adapters.feishu) {
+    feishuAppIdInput.value = adapters.feishu.appId || "";
+    feishuAppSecretInput.value = adapters.feishu.appSecret || "";
+  } else {
+    feishuAppIdInput.value = "";
+    feishuAppSecretInput.value = "";
+  }
+
   // Restart required status
   if (state.restartRequired) {
     setStatus(
@@ -116,6 +138,8 @@ async function handleSave() {
   const telegramToken = telegramTokenInput.value.trim();
   const slackBotToken = slackBotTokenInput.value.trim();
   const slackAppToken = slackAppTokenInput.value.trim();
+  const feishuAppId = feishuAppIdInput.value.trim();
+  const feishuAppSecret = feishuAppSecretInput.value.trim();
 
   // 始终写入所有 adapter 键，空值也要显式传递，让后端能感知「清空」操作
   const adapters = {
@@ -127,6 +151,13 @@ async function handleSave() {
             appToken: slackAppToken || undefined,
           }
         : null,
+    feishu:
+      feishuAppId || feishuAppSecret
+        ? {
+            appId: feishuAppId || undefined,
+            appSecret: feishuAppSecret || undefined,
+          }
+        : null,
   };
 
   const updates = { adapters };