@cremini/skillpack 1.2.9 → 1.2.10

package/dist/cli.js

@@ -9,6 +9,26 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/job-schedule.ts
+function normalizeJobCron(cron2) {
+  if (typeof cron2 !== "string") {
+    return void 0;
+  }
+  const normalized = cron2.trim();
+  return normalized ? normalized : void 0;
+}
+function hasJobSchedule(jobOrCron) {
+  if (typeof jobOrCron === "string" || jobOrCron == null) {
+    return !!normalizeJobCron(jobOrCron);
+  }
+  return !!normalizeJobCron(jobOrCron.cron);
+}
+var init_job_schedule = __esm({
+  "src/job-schedule.ts"() {
+    "use strict";
+  }
+});
+
 // src/job-config.ts
 import fs2 from "fs";
 import path2 from "path";
@@ -27,9 +47,9 @@ function validateScheduledJobConfig(value, sourceLabel, index) {
       `Invalid job config from ${sourceLabel}: "jobs[${index}].name" is required`
     );
   }
-  if (typeof job.cron !== "string" || !job.cron.trim()) {
+  if (job.cron !== void 0 && typeof job.cron !== "string") {
     throw new Error(
-      `Invalid job config from ${sourceLabel}: "jobs[${index}].cron" is required`
+      `Invalid job config from ${sourceLabel}: "jobs[${index}].cron" must be a string`
     );
   }
   if (typeof job.prompt !== "string" || !job.prompt.trim()) {
@@ -87,18 +107,25 @@ function validateJobFileShape(value, sourceLabel) {
 function normalizeJobFile(jobFile) {
   return {
     jobs: jobFile.jobs.map((job) => ({
-      name: job.name.trim(),
-      cron: job.cron.trim(),
-      prompt: job.prompt,
-      notify: {
-        adapter: job.notify.adapter.trim(),
-        channelId: job.notify.channelId.trim()
-      },
-      ...job.enabled !== void 0 ? { enabled: job.enabled } : {},
-      ...job.timezone !== void 0 ? { timezone: job.timezone.trim() } : {}
+      ...normalizeScheduledJobConfig(job)
     }))
   };
 }
+function normalizeScheduledJobConfig(job) {
+  const normalizedCron = normalizeJobCron(job.cron);
+  const normalizedTimezone = typeof job.timezone === "string" && job.timezone.trim() ? job.timezone.trim() : void 0;
+  return {
+    name: job.name.trim(),
+    ...normalizedCron ? { cron: normalizedCron } : {},
+    prompt: job.prompt,
+    notify: {
+      adapter: job.notify.adapter.trim(),
+      channelId: job.notify.channelId.trim()
+    },
+    ...normalizedCron && job.enabled !== void 0 ? { enabled: job.enabled } : {},
+    ...normalizedCron && normalizedTimezone ? { timezone: normalizedTimezone } : {}
+  };
+}
 function loadJobFile(workDir) {
   const filePath = getJobFilePath(workDir);
   if (!fs2.existsSync(filePath)) {
@@ -119,6 +146,7 @@ var JOB_FILE;
 var init_job_config = __esm({
   "src/job-config.ts"() {
     "use strict";
+    init_job_schedule();
     JOB_FILE = "job.json";
   }
 });
@@ -1402,11 +1430,15 @@ function isValidTimezone(tz) {
 function isValidJobName(name) {
   return VALID_JOB_NAME.test(name) && name.length <= 64;
 }
+function isRecurringJob(jobConfig) {
+  return hasJobSchedule(jobConfig);
+}
 var VALID_JOB_NAME, 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_-]*$/;
     SchedulerAdapter = class {
       name = "scheduler";
@@ -1423,10 +1455,13 @@ var init_scheduler = __esm({
         const jobConfigs = loadJobFile(this.rootDir).jobs;
         let scheduledCount = 0;
         let disabledCount = 0;
+        let oneTimeCount = 0;
         for (const jc of jobConfigs) {
           const result = this.registerJob(jc);
           if (result.registered) {
-            if (jc.enabled === false) {
+            if (!isRecurringJob(jc)) {
+              oneTimeCount++;
+            } else if (jc.enabled === false) {
               disabledCount++;
             } else {
               scheduledCount++;
@@ -1436,6 +1471,7 @@ var init_scheduler = __esm({
         const parts = [];
         if (scheduledCount > 0) parts.push(`${scheduledCount} active`);
         if (disabledCount > 0) parts.push(`${disabledCount} disabled`);
+        if (oneTimeCount > 0) parts.push(`${oneTimeCount} one-time`);
         if (parts.length > 0) {
           console.log(`[SchedulerAdapter] Started with ${parts.join(", ")} job(s)`);
         } else {
@@ -1450,43 +1486,43 @@ var init_scheduler = __esm({
        * 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`;
+        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`;
           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 };
+        if (normalizedCron) {
+          if (!cron.validate(normalizedCron)) {
+            const msg = `[Scheduler] Invalid cron expression for job "${normalizedConfig.name}": ${normalizedCron}`;
+            console.error(msg);
+            return { registered: false, message: msg };
+          }
+          if (normalizedConfig.timezone && !isValidTimezone(normalizedConfig.timezone)) {
+            const msg = `[Scheduler] Invalid timezone for job "${normalizedConfig.name}": ${normalizedConfig.timezone}`;
+            console.error(msg);
+            return { registered: false, message: msg };
+          }
         }
-        this.removeFromMap(jobConfig.name);
+        this.removeFromMap(normalizedConfig.name);
         let task = null;
-        if (jobConfig.enabled !== false) {
-          task = cron.schedule(
-            jobConfig.cron,
-            () => {
-              void this.runJob(jobConfig);
-            },
-            {
-              timezone: jobConfig.timezone
-            }
+        if (normalizedCron && normalizedConfig.enabled !== false) {
+          task = this.createCronTask(normalizedConfig);
+          console.log(
+            `[Scheduler] Job "${normalizedConfig.name}" scheduled: ${normalizedCron}${normalizedConfig.timezone ? ` (${normalizedConfig.timezone})` : ""}`
           );
+        } else if (normalizedCron) {
           console.log(
-            `[Scheduler] Job "${jobConfig.name}" scheduled: ${jobConfig.cron}${jobConfig.timezone ? ` (${jobConfig.timezone})` : ""}`
+            `[Scheduler] Job "${normalizedConfig.name}" registered (disabled)`
           );
         } else {
           console.log(
-            `[Scheduler] Job "${jobConfig.name}" registered (disabled)`
+            `[Scheduler] Job "${normalizedConfig.name}" registered as one-time (manual trigger only)`
           );
         }
-        this.jobs.set(jobConfig.name, {
-          config: jobConfig,
+        this.jobs.set(normalizedConfig.name, {
+          config: normalizedConfig,
           task,
           running: false,
           notifyFailed: false
@@ -1599,10 +1635,11 @@ var init_scheduler = __esm({
           return { success: false, message: result.message };
         }
         this.persistJobs();
-        const enabled = jobConfig.enabled !== false;
+        const recurring = isRecurringJob(jobConfig);
+        const enabled = recurring ? jobConfig.enabled !== false : true;
         return {
           success: true,
-          message: enabled ? `Job "${jobConfig.name}" created and scheduled.` : `Job "${jobConfig.name}" created (disabled).`
+          message: recurring ? enabled ? `Job "${jobConfig.name}" created and scheduled.` : `Job "${jobConfig.name}" created (disabled).` : `Job "${jobConfig.name}" created as a one-time task.`
         };
       }
       /**
@@ -1647,17 +1684,15 @@ var init_scheduler = __esm({
         if (!job) {
           return { success: false, message: `Job "${name}" not found.` };
         }
+        if (!isRecurringJob(job.config)) {
+          return {
+            success: false,
+            message: `Job "${name}" does not have a schedule and cannot be enabled or disabled.`
+          };
+        }
         job.config.enabled = enabled;
         if (enabled && !job.task) {
-          job.task = cron.schedule(
-            job.config.cron,
-            () => {
-              void this.runJob(job.config);
-            },
-            {
-              timezone: job.config.timezone
-            }
-          );
+          job.task = this.createCronTask(job.config);
         } else if (enabled && job.task) {
           job.task.start();
         } else if (!enabled && job.task) {
@@ -1703,13 +1738,13 @@ var init_scheduler = __esm({
         for (const [, job] of this.jobs) {
           result.push({
             name: job.config.name,
-            cron: job.config.cron,
+            ...job.config.cron ? { 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,
+            enabled: isRecurringJob(job.config) ? job.config.enabled !== false : true,
+            ...job.config.timezone ? { timezone: job.config.timezone } : {},
+            ...job.lastRunAt ? { lastRunAt: job.lastRunAt } : {},
+            ...job.lastError ? { lastError: job.lastError } : {},
             running: job.running,
             notifyFailed: job.notifyFailed
           });
@@ -1749,6 +1784,21 @@ var init_scheduler = __esm({
         this.jobs.clear();
         console.log("[SchedulerAdapter] All jobs stopped.");
       }
+      createCronTask(jobConfig) {
+        const cronExpr = normalizeJobCron(jobConfig.cron);
+        if (!cronExpr) {
+          throw new Error(`Job "${jobConfig.name}" does not have a valid cron expression`);
+        }
+        return cron.schedule(
+          cronExpr,
+          () => {
+            void this.runJob(jobConfig);
+          },
+          {
+            timezone: jobConfig.timezone
+          }
+        );
+      }
     };
   }
 });
@@ -4615,20 +4665,20 @@ var WebAdapter = class {
         return;
       }
       const { name, cron: cronExpr, prompt, notify, enabled, timezone } = req.body;
-      if (!name || !cronExpr || !prompt || !notify?.adapter || !notify?.channelId) {
+      if (!name || !prompt || !notify?.adapter || !notify?.channelId) {
         res.status(400).json({
           success: false,
-          message: "Required fields: name, cron, prompt, notify.adapter, notify.channelId"
+          message: "Required fields: name, prompt, notify.adapter, notify.channelId"
         });
         return;
       }
       const result = scheduler.addJob({
         name,
-        cron: cronExpr,
+        ...typeof cronExpr === "string" ? { cron: cronExpr } : {},
         prompt,
         notify,
-        enabled: enabled !== false,
-        timezone
+        ...typeof enabled === "boolean" ? { enabled } : {},
+        ...typeof timezone === "string" ? { timezone } : {}
       });
       res.json(result);
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cremini/skillpack",
-  "version": "1.2.9",
+  "version": "1.2.10",
   "description": "Pack AI Skills into Local Agents",
   "type": "module",
   "repository": {