@cremini/skillpack 1.1.7 → 1.1.8-beta.1

package/dist/cli.js

@@ -85,6 +85,91 @@ var init_attachment_utils = __esm({
   }
 });
 
+// src/runtime/config.ts
+import fs8 from "fs";
+import path8 from "path";
+var ConfigManager, configManager;
+var init_config = __esm({
+  "src/runtime/config.ts"() {
+    "use strict";
+    ConfigManager = class _ConfigManager {
+      static instance;
+      configData = {};
+      configPath = "";
+      constructor() {
+      }
+      static getInstance() {
+        if (!_ConfigManager.instance) {
+          _ConfigManager.instance = new _ConfigManager();
+        }
+        return _ConfigManager.instance;
+      }
+      load(rootDir) {
+        this.configPath = path8.join(rootDir, "data", "config.json");
+        if (fs8.existsSync(this.configPath)) {
+          try {
+            this.configData = JSON.parse(fs8.readFileSync(this.configPath, "utf-8"));
+            console.log("  Loaded config from data/config.json");
+          } catch (err) {
+            console.warn("  Warning: Failed to parse data/config.json:", err);
+          }
+        }
+        let { apiKey = "", provider = "openai" } = this.configData;
+        if (!apiKey) {
+          if (process.env.OPENAI_API_KEY) {
+            apiKey = process.env.OPENAI_API_KEY;
+            provider = "openai";
+          } else if (process.env.ANTHROPIC_API_KEY) {
+            apiKey = process.env.ANTHROPIC_API_KEY;
+            provider = "anthropic";
+          }
+        }
+        this.configData.apiKey = apiKey;
+        this.configData.provider = provider;
+        return this.configData;
+      }
+      getConfig() {
+        return this.configData;
+      }
+      save(rootDir, updates) {
+        const configDir = path8.join(rootDir, "data");
+        if (!this.configPath) {
+          this.configPath = path8.join(rootDir, "data", "config.json");
+        }
+        if (!fs8.existsSync(configDir)) {
+          fs8.mkdirSync(configDir, { recursive: true });
+        }
+        if (updates.apiKey !== void 0) this.configData.apiKey = updates.apiKey;
+        if (updates.provider !== void 0) this.configData.provider = updates.provider;
+        if (updates.adapters !== void 0) {
+          const merged = { ...this.configData.adapters || {} };
+          for (const [adapterKey, adapterVal] of Object.entries(updates.adapters)) {
+            if (adapterVal === null || adapterVal === void 0) {
+              delete merged[adapterKey];
+            } else {
+              merged[adapterKey] = adapterVal;
+            }
+          }
+          this.configData.adapters = merged;
+        }
+        if (updates.scheduledJobs !== void 0) {
+          this.configData.scheduledJobs = updates.scheduledJobs;
+        }
+        try {
+          fs8.writeFileSync(
+            this.configPath,
+            JSON.stringify(this.configData, null, 2),
+            "utf-8"
+          );
+        } catch (err) {
+          console.error("Failed to save config:", err);
+        }
+      }
+    };
+    configManager = ConfigManager.getInstance();
+  }
+});
+
 // src/runtime/adapters/markdown.ts
 function unwrapMarkdownSourceBlocks(text) {
   return text.replace(
@@ -204,7 +289,7 @@ var telegram_exports = {};
 __export(telegram_exports, {
   TelegramAdapter: () => TelegramAdapter
 });
-import fs10 from "fs";
+import fs11 from "fs";
 import TelegramBot from "node-telegram-bot-api";
 var COMMANDS2, MAX_MESSAGE_LENGTH, ACK_REACTION, TelegramAdapter;
 var init_telegram = __esm({
@@ -256,6 +341,21 @@ var init_telegram = __esm({
         console.log("[TelegramAdapter] Stopped");
       }
       // -------------------------------------------------------------------------
+      // MessageSender – proactive message sending
+      // -------------------------------------------------------------------------
+      /**
+       * Public method: send a message to a specific Telegram chat.
+       * channelId format: telegram-<chatId>
+       */
+      async sendMessage(channelId, text) {
+        if (!this.bot) throw new Error("[Telegram] Bot not initialized");
+        const chatId = Number(channelId.replace("telegram-", ""));
+        if (isNaN(chatId)) {
+          throw new Error(`[Telegram] Invalid channelId: ${channelId}`);
+        }
+        await this.sendLongMessage(chatId, text);
+      }
+      // -------------------------------------------------------------------------
       // Message handler
       // -------------------------------------------------------------------------
       async handleTelegramMessage(msg) {
@@ -499,7 +599,7 @@ var init_telegram = __esm({
       async sendFileSafe(chatId, filePath, caption) {
         if (!this.bot) return;
         try {
-          if (!fs10.existsSync(filePath)) {
+          if (!fs11.existsSync(filePath)) {
             console.error(`[Telegram] File not found for sending: ${filePath}`);
             return;
           }
@@ -519,8 +619,8 @@ var slack_exports = {};
 __export(slack_exports, {
   SlackAdapter: () => SlackAdapter
 });
-import fs11 from "fs";
-import path10 from "path";
+import fs12 from "fs";
+import path11 from "path";
 import { App, LogLevel } from "@slack/bolt";
 var INLINE_COMMANDS, SLASH_COMMANDS, MAX_MESSAGE_LENGTH2, ACK_REACTION2, SlackAdapter;
 var init_slack = __esm({
@@ -578,6 +678,20 @@ var init_slack = __esm({
         console.log("[SlackAdapter] Stopped");
       }
       // -------------------------------------------------------------------------
+      // MessageSender – proactive message sending
+      // -------------------------------------------------------------------------
+      /**
+       * Public method: send a message to a specific Slack channel/DM.
+       * channelId formats:
+       *   - slack-dm-<teamId>-<channelId>
+       *   - slack-thread-<teamId>-<channel>-<threadTs>
+       */
+      async sendMessage(channelId, text) {
+        if (!this.app) throw new Error("[Slack] App not initialized");
+        const route = this.parseChannelId(channelId);
+        await this.sendLongMessage(this.app.client, route, text);
+      }
+      // -------------------------------------------------------------------------
       // Listener registration
       // -------------------------------------------------------------------------
       registerListeners(app) {
@@ -916,6 +1030,30 @@ var init_slack = __esm({
       escapeRegExp(value) {
         return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
       }
+      /**
+       * Parse a skillpack channelId into a SlackRoute.
+       * Supports:
+       *   slack-dm-<teamId>-<channelId>       → { channel: <channelId> }
+       *   slack-thread-<teamId>-<ch>-<ts>     → { channel: <ch>, threadTs: <ts> }
+       */
+      parseChannelId(channelId) {
+        if (channelId.startsWith("slack-thread-")) {
+          const rest = channelId.replace("slack-thread-", "");
+          const parts = rest.split("-");
+          if (parts.length >= 3) {
+            const threadTs = parts.slice(2).join("-");
+            return { channel: parts[1], threadTs };
+          }
+        }
+        if (channelId.startsWith("slack-dm-")) {
+          const rest = channelId.replace("slack-dm-", "");
+          const parts = rest.split("-");
+          if (parts.length >= 2) {
+            return { channel: parts.slice(1).join("-") };
+          }
+        }
+        return { channel: channelId };
+      }
       // -------------------------------------------------------------------------
       // Attachment extraction & sending
       // -------------------------------------------------------------------------
@@ -959,12 +1097,12 @@ var init_slack = __esm({
        */
       async sendFileSafe(client, route, filePath, caption) {
         try {
-          if (!fs11.existsSync(filePath)) {
+          if (!fs12.existsSync(filePath)) {
             console.error(`[Slack] File not found for sending: ${filePath}`);
             return;
           }
-          const filename = path10.basename(filePath);
-          const fileContent = fs11.readFileSync(filePath);
+          const filename = path11.basename(filePath);
+          const fileContent = fs12.readFileSync(filePath);
           await client.files.uploadV2({
             channel_id: route.channel,
             thread_ts: route.threadTs,
@@ -981,6 +1119,357 @@ var init_slack = __esm({
   }
 });
 
+// src/runtime/adapters/types.ts
+var types_exports = {};
+__export(types_exports, {
+  isMessageSender: () => isMessageSender
+});
+function isMessageSender(adapter) {
+  return typeof adapter.sendMessage === "function";
+}
+var init_types = __esm({
+  "src/runtime/adapters/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/runtime/adapters/scheduler.ts
+var scheduler_exports = {};
+__export(scheduler_exports, {
+  SchedulerAdapter: () => SchedulerAdapter
+});
+import cron from "node-cron";
+function isValidTimezone(tz) {
+  try {
+    Intl.DateTimeFormat(void 0, { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isValidJobName(name) {
+  return VALID_JOB_NAME.test(name) && name.length <= 64;
+}
+var VALID_JOB_NAME, SchedulerAdapter;
+var init_scheduler = __esm({
+  "src/runtime/adapters/scheduler.ts"() {
+    "use strict";
+    init_config();
+    VALID_JOB_NAME = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
+    SchedulerAdapter = class {
+      name = "scheduler";
+      agent;
+      rootDir = "";
+      notifyFn = async () => {
+      };
+      jobs = /* @__PURE__ */ new Map();
+      async start(ctx) {
+        this.agent = ctx.agent;
+        this.rootDir = ctx.rootDir;
+        this.notifyFn = ctx.notify || (async () => {
+        });
+        const config = configManager.getConfig();
+        const jobConfigs = config.scheduledJobs || [];
+        let scheduledCount = 0;
+        let disabledCount = 0;
+        for (const jc of jobConfigs) {
+          const result = this.registerJob(jc);
+          if (result.registered) {
+            if (jc.enabled === false) {
+              disabledCount++;
+            } else {
+              scheduledCount++;
+            }
+          }
+        }
+        const parts = [];
+        if (scheduledCount > 0) parts.push(`${scheduledCount} active`);
+        if (disabledCount > 0) parts.push(`${disabledCount} disabled`);
+        if (parts.length > 0) {
+          console.log(`[SchedulerAdapter] Started with ${parts.join(", ")} job(s)`);
+        } else {
+          console.log("[SchedulerAdapter] Started (no jobs configured)");
+        }
+      }
+      // -------------------------------------------------------------------------
+      // Core: register a job into the managed map
+      // -------------------------------------------------------------------------
+      /**
+       * Register a job: validate, create cron task (if enabled), store in map.
+       * Does NOT persist – callers decide when to persist.
+       */
+      registerJob(jobConfig) {
+        if (!isValidJobName(jobConfig.name)) {
+          const msg = `[Scheduler] Invalid job name "${jobConfig.name}": must match ${VALID_JOB_NAME} and be \u226464 chars`;
+          console.error(msg);
+          return { registered: false, message: msg };
+        }
+        if (!cron.validate(jobConfig.cron)) {
+          const msg = `[Scheduler] Invalid cron expression for job "${jobConfig.name}": ${jobConfig.cron}`;
+          console.error(msg);
+          return { registered: false, message: msg };
+        }
+        if (jobConfig.timezone && !isValidTimezone(jobConfig.timezone)) {
+          const msg = `[Scheduler] Invalid timezone for job "${jobConfig.name}": ${jobConfig.timezone}`;
+          console.error(msg);
+          return { registered: false, message: msg };
+        }
+        this.removeFromMap(jobConfig.name);
+        let task = null;
+        if (jobConfig.enabled !== false) {
+          task = cron.schedule(
+            jobConfig.cron,
+            () => {
+              void this.runJob(jobConfig);
+            },
+            {
+              timezone: jobConfig.timezone
+            }
+          );
+          console.log(
+            `[Scheduler] Job "${jobConfig.name}" scheduled: ${jobConfig.cron}${jobConfig.timezone ? ` (${jobConfig.timezone})` : ""}`
+          );
+        } else {
+          console.log(
+            `[Scheduler] Job "${jobConfig.name}" registered (disabled)`
+          );
+        }
+        this.jobs.set(jobConfig.name, {
+          config: jobConfig,
+          task,
+          running: false,
+          notifyFailed: false
+        });
+        return { registered: true, message: "" };
+      }
+      // -------------------------------------------------------------------------
+      // Job execution
+      // -------------------------------------------------------------------------
+      /**
+       * Execute a scheduled job: call agent.handleMessage and push results.
+       * Returns { text, notifyFailed } so callers can produce accurate status.
+       */
+      async runJob(jobConfig) {
+        const channelId = `scheduler-${jobConfig.name}`;
+        const job = this.jobs.get(jobConfig.name);
+        if (job?.running) {
+          console.warn(
+            `[Scheduler] Job "${jobConfig.name}" is already running, skipping this trigger`
+          );
+          return { text: "", notifyFailed: false };
+        }
+        if (job) job.running = true;
+        console.log(`[Scheduler] Running job "${jobConfig.name}"`);
+        let fullText = "";
+        let agentFailed = false;
+        const pendingFiles = [];
+        const onEvent = (event) => {
+          if (event.type === "text_delta") fullText += event.delta;
+          if (event.type === "file_output") {
+            pendingFiles.push({
+              filePath: event.filePath,
+              caption: event.caption
+            });
+          }
+        };
+        try {
+          const result = await this.agent.handleMessage(
+            channelId,
+            jobConfig.prompt,
+            onEvent
+          );
+          if (result.errorMessage) {
+            fullText = `\u274C \u5B9A\u65F6\u4EFB\u52A1 "${jobConfig.name}" \u6267\u884C\u5931\u8D25\uFF1A${result.errorMessage}`;
+            agentFailed = true;
+            if (job) job.lastError = result.errorMessage;
+          } else {
+            if (job) job.lastError = void 0;
+          }
+        } catch (err) {
+          const errorMsg = err instanceof Error ? err.message : String(err);
+          fullText = `\u274C \u5B9A\u65F6\u4EFB\u52A1 "${jobConfig.name}" \u5F02\u5E38\uFF1A${errorMsg}`;
+          agentFailed = true;
+          if (job) job.lastError = errorMsg;
+        }
+        if (job) {
+          job.lastRunAt = (/* @__PURE__ */ new Date()).toISOString();
+          job.lastResult = fullText.slice(0, 200);
+        }
+        let notifyFailed = false;
+        if (fullText.trim()) {
+          try {
+            await this.notifyFn(
+              jobConfig.notify.adapter,
+              jobConfig.notify.channelId,
+              fullText
+            );
+          } catch (err) {
+            notifyFailed = true;
+            const notifyErr = err instanceof Error ? err.message : String(err);
+            console.error(
+              `[Scheduler] Failed to notify for job "${jobConfig.name}":`,
+              err
+            );
+            if (job) {
+              job.lastError = agentFailed ? `${job.lastError}; Notify also failed: ${notifyErr}` : `Notify failed: ${notifyErr}`;
+            }
+          }
+        }
+        if (job) {
+          job.running = false;
+          job.notifyFailed = notifyFailed;
+        }
+        return { text: fullText, notifyFailed };
+      }
+      // -------------------------------------------------------------------------
+      // Dynamic management API
+      // -------------------------------------------------------------------------
+      /**
+       * Add a new job, persist to config.json.
+       */
+      addJob(jobConfig) {
+        if (this.jobs.has(jobConfig.name)) {
+          return {
+            success: false,
+            message: `Job "${jobConfig.name}" already exists. Remove it first.`
+          };
+        }
+        const result = this.registerJob(jobConfig);
+        if (!result.registered) {
+          return { success: false, message: result.message };
+        }
+        this.persistJobs();
+        const enabled = jobConfig.enabled !== false;
+        return {
+          success: true,
+          message: enabled ? `Job "${jobConfig.name}" created and scheduled.` : `Job "${jobConfig.name}" created (disabled).`
+        };
+      }
+      /**
+       * Remove a job and persist to config.json.
+       */
+      removeJob(name) {
+        if (!this.jobs.has(name)) {
+          return { success: false, message: `Job "${name}" not found.` };
+        }
+        this.removeFromMap(name);
+        this.persistJobs();
+        return { success: true, message: `Job "${name}" removed.` };
+      }
+      /**
+       * Enable or disable a job and persist.
+       */
+      setEnabled(name, enabled) {
+        const job = this.jobs.get(name);
+        if (!job) {
+          return { success: false, message: `Job "${name}" not found.` };
+        }
+        job.config.enabled = enabled;
+        if (enabled && !job.task) {
+          job.task = cron.schedule(
+            job.config.cron,
+            () => {
+              void this.runJob(job.config);
+            },
+            {
+              timezone: job.config.timezone
+            }
+          );
+        } else if (enabled && job.task) {
+          job.task.start();
+        } else if (!enabled && job.task) {
+          job.task.stop();
+        }
+        this.persistJobs();
+        return {
+          success: true,
+          message: `Job "${name}" ${enabled ? "enabled" : "disabled"}.`
+        };
+      }
+      /**
+       * Manually trigger a job (runs immediately, ignoring cron schedule).
+       */
+      async triggerJob(name) {
+        const job = this.jobs.get(name);
+        if (!job) {
+          return { success: false, message: `Job "${name}" not found.` };
+        }
+        const { text, notifyFailed } = await this.runJob(job.config);
+        if (!text) {
+          return {
+            success: true,
+            message: `Job "${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.`
+          };
+        }
+        return {
+          success: true,
+          message: `Job "${name}" triggered. Result sent to ${job.config.notify.adapter}.`
+        };
+      }
+      /**
+       * List all jobs with their current status.
+       */
+      listJobs() {
+        const result = [];
+        for (const [, job] of this.jobs) {
+          result.push({
+            name: job.config.name,
+            cron: job.config.cron,
+            prompt: job.config.prompt,
+            notify: job.config.notify,
+            enabled: job.config.enabled !== false,
+            timezone: job.config.timezone,
+            lastRunAt: job.lastRunAt,
+            lastError: job.lastError,
+            running: job.running,
+            notifyFailed: job.notifyFailed
+          });
+        }
+        return result;
+      }
+      // -------------------------------------------------------------------------
+      // Internal helpers
+      // -------------------------------------------------------------------------
+      /**
+       * Stop the cron task and remove a job from the map (does NOT persist).
+       */
+      removeFromMap(name) {
+        const existing = this.jobs.get(name);
+        if (existing) {
+          existing.task?.stop();
+          this.jobs.delete(name);
+        }
+      }
+      /**
+       * Persist all current jobs to data/config.json.
+       */
+      persistJobs() {
+        const configs = [];
+        for (const [, job] of this.jobs) {
+          configs.push(job.config);
+        }
+        configManager.save(this.rootDir, { scheduledJobs: configs });
+      }
+      // -------------------------------------------------------------------------
+      // Lifecycle
+      // -------------------------------------------------------------------------
+      async stop() {
+        for (const [, job] of this.jobs) {
+          job.task?.stop();
+        }
+        this.jobs.clear();
+        console.log("[SchedulerAdapter] All jobs stopped.");
+      }
+    };
+  }
+});
+
 // src/cli.ts
 import { Command } from "commander";
 import chalk5 from "chalk";
@@ -1547,15 +2036,15 @@ async function interactiveCreate(workDir) {
 }
 
 // src/commands/run.ts
-import path12 from "path";
-import fs13 from "fs";
+import path13 from "path";
+import fs14 from "fs";
 import inquirer2 from "inquirer";
 import chalk4 from "chalk";
 
 // src/runtime/server.ts
 import express from "express";
-import path11 from "path";
-import fs12 from "fs";
+import path12 from "path";
+import fs13 from "fs";
 import { fileURLToPath } from "url";
 import { createServer } from "http";
 import { exec } from "child_process";
@@ -4268,6 +4757,169 @@ function createSendFileTool(fileOutputCallbackRef) {
   };
 }
 
+// src/runtime/tools/manage-schedule-tool.ts
+var ManageScheduleParams = Type.Object({
+  action: Type.Union(
+    [
+      Type.Literal("add"),
+      Type.Literal("list"),
+      Type.Literal("remove"),
+      Type.Literal("trigger"),
+      Type.Literal("enable"),
+      Type.Literal("disable")
+    ],
+    { description: "The action to perform." }
+  ),
+  name: Type.Optional(
+    Type.String({
+      description: "Unique name for the scheduled task. Required for add/remove/trigger/enable/disable."
+    })
+  ),
+  cron: Type.Optional(
+    Type.String({
+      description: "Cron expression (5 fields: minute hour day month weekday). Required for add."
+    })
+  ),
+  prompt: Type.Optional(
+    Type.String({
+      description: "The work prompt to execute when the task triggers. Required for add. Describe only what to do each run; do not repeat timing, cron, or 'every N minutes' instructions here."
+    })
+  ),
+  notifyAdapter: Type.Optional(
+    Type.String({
+      description: "Target adapter name for result notification: 'telegram' or 'slack'. Required for add."
+    })
+  ),
+  notifyChannelId: Type.Optional(
+    Type.String({
+      description: "Target channelId for result notification (e.g. 'telegram-123456'). Required for add."
+    })
+  ),
+  timezone: Type.Optional(
+    Type.String({
+      description: "Optional timezone for the cron schedule, e.g. 'Asia/Shanghai', 'America/New_York'."
+    })
+  )
+});
+function textResult(text) {
+  return { content: [{ type: "text", text }], details: void 0 };
+}
+function createManageScheduleTool(schedulerRef, _rootDirRef) {
+  return {
+    name: "manage_scheduled_task",
+    label: "Manage Scheduled Task",
+    description: [
+      "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, 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.",
+      "- disable: Disable a scheduled task without removing it.",
+      "",
+      "Cron expression format: '* * * * *' (minute hour day month weekday)",
+      "Examples:",
+      "  '0 9 * * 1-5'  = every weekday at 9:00 AM",
+      "  '0 18 * * 5'   = every Friday at 6:00 PM",
+      "  '*/30 * * * *'  = every 30 minutes",
+      "",
+      "notifyAdapter: 'telegram' or 'slack'",
+      "notifyChannelId: the channel ID where result will be sent (e.g. 'telegram-123456')"
+    ].join("\n"),
+    parameters: ManageScheduleParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      const scheduler = schedulerRef.current;
+      if (!scheduler) {
+        return textResult(
+          "Error: Scheduler is not available. The scheduled task system may not be initialized."
+        );
+      }
+      switch (params.action) {
+        case "list": {
+          const jobs = scheduler.listJobs();
+          if (jobs.length === 0) {
+            return textResult("No scheduled tasks configured.");
+          }
+          const lines = jobs.map(
+            (j) => `- **${j.name}**: \`${j.cron}\` \u2192 ${j.notify.adapter}:${j.notify.channelId} [${j.enabled ? "enabled" : "disabled"}]${j.running ? " (running)" : ""}${j.lastRunAt ? ` (last: ${j.lastRunAt})` : ""}`
+          );
+          return textResult(
+            `Scheduled tasks (${jobs.length}):
+${lines.join("\n")}`
+          );
+        }
+        case "add": {
+          if (!params.name || !params.cron || !params.prompt) {
+            return textResult(
+              "Error: 'name', 'cron', and 'prompt' are required for adding a task."
+            );
+          }
+          if (!params.notifyAdapter || !params.notifyChannelId) {
+            return textResult(
+              "Error: 'notifyAdapter' and 'notifyChannelId' are required for adding a task."
+            );
+          }
+          const jobConfig = {
+            name: params.name,
+            cron: params.cron,
+            prompt: params.prompt,
+            notify: {
+              adapter: params.notifyAdapter,
+              channelId: params.notifyChannelId
+            },
+            enabled: true,
+            timezone: params.timezone
+          };
+          const result = scheduler.addJob(jobConfig);
+          return textResult(result.message);
+        }
+        case "remove": {
+          if (!params.name) {
+            return textResult(
+              "Error: 'name' is required for removing a task."
+            );
+          }
+          const result = scheduler.removeJob(params.name);
+          return textResult(result.message);
+        }
+        case "trigger": {
+          if (!params.name) {
+            return textResult(
+              "Error: 'name' is required for triggering a task."
+            );
+          }
+          const result = await scheduler.triggerJob(params.name);
+          return textResult(result.message);
+        }
+        case "enable": {
+          if (!params.name) {
+            return textResult(
+              "Error: 'name' is required for enabling a task."
+            );
+          }
+          const result = scheduler.setEnabled(params.name, true);
+          return textResult(result.message);
+        }
+        case "disable": {
+          if (!params.name) {
+            return textResult(
+              "Error: 'name' is required for disabling a task."
+            );
+          }
+          const result = scheduler.setEnabled(params.name, false);
+          return textResult(result.message);
+        }
+        default:
+          return textResult(
+            `Error: Unknown action '${params.action}'. Use: add, list, remove, trigger, enable, disable.`
+          );
+      }
+    }
+  };
+}
+
 // src/runtime/agent.ts
 var DEBUG = true;
 var log = (...args) => DEBUG && console.log(...args);
@@ -4298,8 +4950,22 @@ var PackAgent = class {
     current: null
   };
   sendFileToolDef = createSendFileTool(this.fileOutputCallbackRef);
+  schedulerRef = { current: null };
+  rootDirRef;
+  scheduleToolDef;
   constructor(options) {
     this.options = options;
+    this.rootDirRef = { current: options.rootDir };
+    this.scheduleToolDef = createManageScheduleTool(
+      this.schedulerRef,
+      this.rootDirRef
+    );
+  }
+  /**
+   * Inject scheduler reference (called by server.ts after adapter init).
+   */
+  setScheduler(scheduler) {
+    this.schedulerRef.current = scheduler;
   }
   /**
    * Lazily create (or return existing) session for a channel.
@@ -4350,7 +5016,7 @@ var PackAgent = class {
         resourceLoader,
         model,
         tools,
-        customTools: [this.sendFileToolDef]
+        customTools: [this.sendFileToolDef, this.scheduleToolDef]
       });
       const channelSession = {
         session,
@@ -4555,87 +5221,10 @@ ${text}`;
 };
 
 // src/runtime/adapters/web.ts
+init_config();
 import fs9 from "fs";
 import path9 from "path";
 import { WebSocketServer } from "ws";
-
-// src/runtime/config.ts
-import fs8 from "fs";
-import path8 from "path";
-var ConfigManager = class _ConfigManager {
-  static instance;
-  configData = {};
-  configPath = "";
-  constructor() {
-  }
-  static getInstance() {
-    if (!_ConfigManager.instance) {
-      _ConfigManager.instance = new _ConfigManager();
-    }
-    return _ConfigManager.instance;
-  }
-  load(rootDir) {
-    this.configPath = path8.join(rootDir, "data", "config.json");
-    if (fs8.existsSync(this.configPath)) {
-      try {
-        this.configData = JSON.parse(fs8.readFileSync(this.configPath, "utf-8"));
-        console.log("  Loaded config from data/config.json");
-      } catch (err) {
-        console.warn("  Warning: Failed to parse data/config.json:", err);
-      }
-    }
-    let { apiKey = "", provider = "openai" } = this.configData;
-    if (!apiKey) {
-      if (process.env.OPENAI_API_KEY) {
-        apiKey = process.env.OPENAI_API_KEY;
-        provider = "openai";
-      } else if (process.env.ANTHROPIC_API_KEY) {
-        apiKey = process.env.ANTHROPIC_API_KEY;
-        provider = "anthropic";
-      }
-    }
-    this.configData.apiKey = apiKey;
-    this.configData.provider = provider;
-    return this.configData;
-  }
-  getConfig() {
-    return this.configData;
-  }
-  save(rootDir, updates) {
-    const configDir = path8.join(rootDir, "data");
-    if (!this.configPath) {
-      this.configPath = path8.join(rootDir, "data", "config.json");
-    }
-    if (!fs8.existsSync(configDir)) {
-      fs8.mkdirSync(configDir, { recursive: true });
-    }
-    if (updates.apiKey !== void 0) this.configData.apiKey = updates.apiKey;
-    if (updates.provider !== void 0) this.configData.provider = updates.provider;
-    if (updates.adapters !== void 0) {
-      const merged = { ...this.configData.adapters || {} };
-      for (const [adapterKey, adapterVal] of Object.entries(updates.adapters)) {
-        if (adapterVal === null || adapterVal === void 0) {
-          delete merged[adapterKey];
-        } else {
-          merged[adapterKey] = adapterVal;
-        }
-      }
-      this.configData.adapters = merged;
-    }
-    try {
-      fs8.writeFileSync(
-        this.configPath,
-        JSON.stringify(this.configData, null, 2),
-        "utf-8"
-      );
-    } catch (err) {
-      console.error("Failed to save config:", err);
-    }
-  }
-};
-var configManager = ConfigManager.getInstance();
-
-// src/runtime/adapters/web.ts
 function getPackConfig(rootDir) {
   const raw = fs9.readFileSync(path9.join(rootDir, "skillpack.json"), "utf-8");
   return JSON.parse(raw);
@@ -4680,8 +5269,7 @@ var WebAdapter = class {
         hasApiKey: !!conf.apiKey,
         apiKey: conf.apiKey || "",
         provider: conf.provider || "openai",
-        adapters: conf.adapters || {},
-        runtimeControl: lifecycle.getRuntimeControl()
+        adapters: conf.adapters || {}
       });
     });
     app.get("/api/skills", (_req, res) => {
@@ -4710,22 +5298,12 @@ var WebAdapter = class {
         success: true,
         provider: newConf.provider,
         adapters: newConf.adapters,
-        requiresRestart,
-        runtimeControl: lifecycle.getRuntimeControl()
+        requiresRestart
       });
     });
     app.post("/api/runtime/restart", async (_req, res) => {
-      const runtimeControl = lifecycle.getRuntimeControl();
-      if (!runtimeControl.canManagedRestart) {
-        res.status(409).json({
-          success: false,
-          message: "Managed restart is unavailable for this process.",
-          runtimeControl
-        });
-        return;
-      }
       const result = await lifecycle.requestRestart("web");
-      res.status(202).json({ ...result, runtimeControl });
+      res.status(202).json(result);
     });
     app.delete("/api/chat", (_req, res) => {
       res.json({ success: true });
@@ -4761,6 +5339,75 @@ var WebAdapter = class {
       );
       fs9.createReadStream(resolvedPath).pipe(res);
     });
+    const getScheduler = () => {
+      const schedulerAdapter = ctx.adapterMap?.get("scheduler");
+      if (!schedulerAdapter) return null;
+      return schedulerAdapter;
+    };
+    app.get("/api/scheduler/jobs", (_req, res) => {
+      const scheduler = getScheduler();
+      if (!scheduler) {
+        res.json([]);
+        return;
+      }
+      res.json(scheduler.listJobs());
+    });
+    app.post("/api/scheduler/jobs", (req, res) => {
+      const scheduler = getScheduler();
+      if (!scheduler) {
+        res.status(503).json({ success: false, message: "Scheduler not available" });
+        return;
+      }
+      const { name, cron: cronExpr, prompt, notify, enabled, timezone } = req.body;
+      if (!name || !cronExpr || !prompt || !notify?.adapter || !notify?.channelId) {
+        res.status(400).json({
+          success: false,
+          message: "Required fields: name, cron, prompt, notify.adapter, notify.channelId"
+        });
+        return;
+      }
+      const result = scheduler.addJob({
+        name,
+        cron: cronExpr,
+        prompt,
+        notify,
+        enabled: enabled !== false,
+        timezone
+      });
+      res.json(result);
+    });
+    app.delete("/api/scheduler/jobs/:name", (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);
+      res.json(result);
+    });
+    app.post("/api/scheduler/jobs/:name/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);
+      res.json(result);
+    });
+    app.patch("/api/scheduler/jobs/:name", (req, res) => {
+      const scheduler = getScheduler();
+      if (!scheduler) {
+        res.status(503).json({ success: false, message: "Scheduler not available" });
+        return;
+      }
+      const { enabled } = req.body;
+      if (typeof enabled !== "boolean") {
+        res.status(400).json({ success: false, message: "Field 'enabled' (boolean) is required" });
+        return;
+      }
+      const result = scheduler.setEnabled(req.params.name, enabled);
+      res.json(result);
+    });
     this.wss = new WebSocketServer({ noServer: true });
     server.on("upgrade", (request, socket, head) => {
       if (request.url?.startsWith("/api/chat")) {
@@ -4841,33 +5488,25 @@ var WebAdapter = class {
   }
 };
 
+// src/runtime/server.ts
+init_config();
+
 // src/runtime/lifecycle.ts
 var SHUTDOWN_EXIT_CODE = 64;
 var RESTART_EXIT_CODE = 75;
 var STOP_TIMEOUT_MS = 3e3;
-function detectProcessManager() {
-  return process.env.PACK_ROOT ? "wrapper" : "none";
-}
 var Lifecycle = class {
   server;
   exitFn;
-  processManager;
   adapters = [];
   stopReason = null;
   constructor(server, exitFn = (code) => process.exit(code)) {
     this.server = server;
     this.exitFn = exitFn;
-    this.processManager = detectProcessManager();
   }
   registerAdapters(adapters) {
     this.adapters = adapters;
   }
-  getRuntimeControl() {
-    return {
-      canManagedRestart: this.processManager === "wrapper",
-      processManager: this.processManager
-    };
-  }
   async requestRestart(trigger) {
     return this.requestStop("restart", trigger);
   }
@@ -4923,25 +5562,197 @@ var Lifecycle = class {
   }
 };
 
+// src/runtime/registry.ts
+import crypto from "crypto";
+import fs10 from "fs";
+import os from "os";
+import path10 from "path";
+var SKILLPACK_HOME = path10.join(os.homedir(), ".skillpack");
+var LEGACY_REGISTRY_FILE = path10.join(SKILLPACK_HOME, "registry.json");
+var REGISTRY_DIR = path10.join(SKILLPACK_HOME, "registry.d");
+var migrationChecked = false;
+function ensureHomeDir() {
+  if (!fs10.existsSync(SKILLPACK_HOME)) {
+    fs10.mkdirSync(SKILLPACK_HOME, { recursive: true });
+  }
+}
+function ensureRegistryDir() {
+  ensureHomeDir();
+  if (!fs10.existsSync(REGISTRY_DIR)) {
+    fs10.mkdirSync(REGISTRY_DIR, { recursive: true });
+  }
+}
+function canonicalizeDir(dir) {
+  const resolved = path10.resolve(dir);
+  try {
+    return fs10.realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function hashDir(dir) {
+  return crypto.createHash("md5").update(canonicalizeDir(dir)).digest("hex");
+}
+function getEntryPathForCanonicalDir(dir) {
+  return path10.join(REGISTRY_DIR, `${hashDir(dir)}.json`);
+}
+function getEntryPath(dir) {
+  ensureRegistryReady();
+  return getEntryPathForCanonicalDir(canonicalizeDir(dir));
+}
+function listEntryFiles() {
+  ensureRegistryReady();
+  return fs10.readdirSync(REGISTRY_DIR).filter((file) => file.endsWith(".json")).sort().map((file) => path10.join(REGISTRY_DIR, file));
+}
+function readEntryFile(filePath) {
+  try {
+    const raw = fs10.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(raw);
+    if (typeof data?.dir !== "string" || typeof data?.name !== "string" || typeof data?.version !== "string" || typeof data?.port !== "number" || typeof data?.pid !== "number" && data?.pid !== null || data?.status !== "running" && data?.status !== "stopped") {
+      return null;
+    }
+    return {
+      dir: canonicalizeDir(data.dir),
+      name: data.name,
+      version: data.version,
+      port: data.port,
+      pid: data.pid,
+      status: data.status,
+      startedAt: data.startedAt,
+      stoppedAt: data.stoppedAt,
+      updatedAt: data.updatedAt
+    };
+  } catch {
+    return null;
+  }
+}
+function createTmpPath(entryPath) {
+  const suffix = `${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}`;
+  return `${entryPath}.tmp.${suffix}`;
+}
+function writeEntryFile(entry) {
+  ensureRegistryReady();
+  const normalized = {
+    ...entry,
+    dir: canonicalizeDir(entry.dir),
+    updatedAt: entry.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const entryPath = getEntryPathForCanonicalDir(normalized.dir);
+  const tmpPath = createTmpPath(entryPath);
+  fs10.writeFileSync(tmpPath, JSON.stringify(normalized, null, 2), "utf-8");
+  fs10.renameSync(tmpPath, entryPath);
+}
+function migrateLegacyRegistryIfNeeded() {
+  if (migrationChecked) {
+    return;
+  }
+  migrationChecked = true;
+  ensureRegistryDir();
+  if (!fs10.existsSync(LEGACY_REGISTRY_FILE)) {
+    return;
+  }
+  if (listEntryFiles().length > 0) {
+    return;
+  }
+  try {
+    const raw = fs10.readFileSync(LEGACY_REGISTRY_FILE, "utf-8");
+    const data = JSON.parse(raw);
+    const packs = Array.isArray(data?.packs) ? data.packs : [];
+    for (const pack of packs) {
+      try {
+        writeEntryFile({
+          ...pack,
+          dir: canonicalizeDir(pack.dir),
+          updatedAt: pack.updatedAt ?? pack.stoppedAt ?? pack.startedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } catch {
+      }
+    }
+    fs10.renameSync(LEGACY_REGISTRY_FILE, `${LEGACY_REGISTRY_FILE}.legacy`);
+  } catch (err) {
+    console.warn("  [Registry] Failed to migrate legacy registry.json:", err);
+  }
+}
+function ensureRegistryReady() {
+  ensureRegistryDir();
+  migrateLegacyRegistryIfNeeded();
+}
+function readEntry(dir) {
+  ensureRegistryReady();
+  return readEntryFile(getEntryPath(dir));
+}
+function register(opts) {
+  try {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = {
+      dir: canonicalizeDir(opts.dir),
+      name: opts.name,
+      version: opts.version,
+      port: opts.port,
+      pid: process.pid,
+      status: "running",
+      startedAt: now,
+      updatedAt: now
+    };
+    writeEntryFile(entry);
+    console.log(`  [Registry] Registered "${opts.name}" (pid ${process.pid})`);
+  } catch (err) {
+    console.warn("  [Registry] Failed to register:", err);
+  }
+}
+function deregister(dir, pid) {
+  try {
+    const entry = readEntry(dir);
+    if (!entry || entry.pid !== pid) {
+      return;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    writeEntryFile({
+      ...entry,
+      pid: null,
+      status: "stopped",
+      stoppedAt: now,
+      updatedAt: now
+    });
+    console.log(`  [Registry] Deregistered "${entry.name}"`);
+  } catch (err) {
+    console.warn("  [Registry] Failed to deregister:", err);
+  }
+}
+
 // src/runtime/server.ts
-var __dirname = path11.dirname(fileURLToPath(import.meta.url));
+var __dirname = path12.dirname(fileURLToPath(import.meta.url));
 async function startServer(options) {
   const {
     rootDir,
     host = process.env.HOST || "127.0.0.1",
     port = Number(process.env.PORT) || 26313,
-    firstRun = true
+    daemonRun = false
   } = options;
   const dataConfig = configManager.load(rootDir);
   const apiKey = dataConfig.apiKey || "";
   const provider = dataConfig.provider || "openai";
+  const canonicalRootDir = canonicalizeDir(rootDir);
+  const packConfig = loadConfig(canonicalRootDir);
   const modelId = provider === "anthropic" ? "claude-opus-4-6" : "gpt-5.4";
-  const packageRoot = path11.resolve(__dirname, "..");
-  const webDir = fs12.existsSync(path11.join(rootDir, "web")) ? path11.join(rootDir, "web") : path11.join(packageRoot, "web");
+  const packageRoot = path12.resolve(__dirname, "..");
+  const webDir = fs13.existsSync(path12.join(rootDir, "web")) ? path12.join(rootDir, "web") : path12.join(packageRoot, "web");
   const app = express();
   app.use(express.json());
   app.use(express.static(webDir));
   const server = createServer(app);
+  app.get("/api/health", (_req, res) => {
+    const address = server.address();
+    const actualPort = typeof address === "string" ? port : address?.port ?? port;
+    res.json({
+      status: "ok",
+      dir: canonicalRootDir,
+      name: packConfig.name,
+      version: packConfig.version,
+      port: actualPort,
+      pid: process.pid
+    });
+  });
   const lifecycle = new Lifecycle(server);
   const agent = new PackAgent({
     apiKey,
@@ -4951,9 +5762,11 @@ async function startServer(options) {
     lifecycleHandler: lifecycle
   });
   const adapters = [];
+  const adapterMap = /* @__PURE__ */ new Map();
   const webAdapter = new WebAdapter();
-  await webAdapter.start({ agent, server, app, rootDir, lifecycle });
+  await webAdapter.start({ agent, server, app, rootDir, lifecycle, adapterMap });
   adapters.push(webAdapter);
+  adapterMap.set(webAdapter.name, webAdapter);
   if (dataConfig.adapters?.telegram?.token) {
     try {
       const { TelegramAdapter: TelegramAdapter2 } = await Promise.resolve().then(() => (init_telegram(), telegram_exports));
@@ -4962,6 +5775,7 @@ async function startServer(options) {
       });
       await telegramAdapter.start({ agent, server, app, rootDir, lifecycle });
       adapters.push(telegramAdapter);
+      adapterMap.set(telegramAdapter.name, telegramAdapter);
     } catch (err) {
       console.error("[Telegram] Failed to start:", err);
     }
@@ -4981,11 +5795,48 @@ async function startServer(options) {
         });
         await slackAdapter.start({ agent, server, app, rootDir, lifecycle });
         adapters.push(slackAdapter);
+        adapterMap.set(slackAdapter.name, slackAdapter);
       } catch (err) {
         console.error("[Slack] 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);
+    if (!adapter || !isMessageSender2(adapter)) {
+      console.warn(
+        `[Scheduler] Target adapter "${adapterName}" not found or doesn't support sendMessage`
+      );
+      return;
+    }
+    await adapter.sendMessage(channelId, text);
+  };
+  const scheduledJobs = dataConfig.scheduledJobs || [];
+  let schedulerAdapter = null;
+  try {
+    const { SchedulerAdapter: SchedulerAdapter2 } = await Promise.resolve().then(() => (init_scheduler(), scheduler_exports));
+    schedulerAdapter = new SchedulerAdapter2();
+    await schedulerAdapter.start({
+      agent,
+      server,
+      app,
+      rootDir,
+      lifecycle,
+      notify: notifyFn,
+      adapterMap
+    });
+    adapters.push(schedulerAdapter);
+    adapterMap.set(schedulerAdapter.name, schedulerAdapter);
+    if (scheduledJobs.length > 0) {
+      console.log(`[Server] Scheduler started with ${scheduledJobs.length} job(s)`);
+    }
+  } catch (err) {
+    console.error("[Scheduler] Failed to start:", err);
+  }
+  if (schedulerAdapter) {
+    agent.setScheduler(schedulerAdapter);
+  }
   lifecycle.registerAdapters(adapters);
   server.once("listening", () => {
     const address = server.address();
@@ -4995,7 +5846,17 @@ async function startServer(options) {
   Skills Pack Server`);
     console.log(`  Running at ${url}
 `);
-    if (firstRun) {
+    try {
+      register({
+        dir: canonicalRootDir,
+        name: packConfig.name,
+        version: packConfig.version,
+        port: typeof actualPort === "number" ? actualPort : port
+      });
+    } catch (err) {
+      console.warn("  [Registry] Could not register pack:", err);
+    }
+    if (!daemonRun) {
       const cmd = process.platform === "darwin" ? `open ${url}` : process.platform === "win32" ? `start ${url}` : `xdg-open ${url}`;
       exec(cmd, (err) => {
         if (err) console.warn(`  Could not open browser: ${err.message}`);
@@ -5003,9 +5864,11 @@ async function startServer(options) {
     }
   });
   process.on("SIGINT", () => {
+    deregister(canonicalRootDir, process.pid);
     void lifecycle.requestShutdown("signal");
   });
   process.on("SIGTERM", () => {
+    deregister(canonicalRootDir, process.pid);
     void lifecycle.requestShutdown("signal");
   });
   await new Promise((resolve, reject) => {
@@ -5040,23 +5903,23 @@ function findMissingSkills(workDir, config) {
   });
 }
 function copyStartTemplates2(workDir) {
-  const templateDir = path12.resolve(
+  const templateDir = path13.resolve(
     new URL("../templates", import.meta.url).pathname
   );
   for (const file of ["start.sh", "start.bat"]) {
-    const src = path12.join(templateDir, file);
-    const dest = path12.join(workDir, file);
-    if (fs13.existsSync(src)) {
-      fs13.copyFileSync(src, dest);
+    const src = path13.join(templateDir, file);
+    const dest = path13.join(workDir, file);
+    if (fs14.existsSync(src)) {
+      fs14.copyFileSync(src, dest);
       if (file === "start.sh") {
-        fs13.chmodSync(dest, 493);
+        fs14.chmodSync(dest, 493);
       }
     }
   }
 }
 async function runCommand(directory) {
-  const workDir = directory ? path12.resolve(directory) : process.cwd();
-  fs13.mkdirSync(workDir, { recursive: true });
+  const workDir = directory ? path13.resolve(directory) : process.cwd();
+  fs14.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([
@@ -5092,13 +5955,16 @@ async function runCommand(directory) {
       console.warn(chalk4.yellow(`  Warning: Some skills could not be installed: ${err}`));
     }
   }
-  await startServer({ rootDir: workDir, firstRun: true });
+  await startServer({
+    rootDir: workDir,
+    daemonRun: process.env.DAEMON_RUN === "1"
+  });
 }
 
 // src/cli.ts
-import fs14 from "fs";
+import fs15 from "fs";
 var packageJson = JSON.parse(
-  fs14.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
+  fs15.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
 );
 var program = new Command();
 program.name("skillpack").description("Assemble, package, and run Agent Skills packs").version(packageJson.version);