@cremini/skillpack 1.2.8 → 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
+          }
+        );
+      }
     };
   }
 });
@@ -2694,7 +2744,7 @@ var ResultsQueryService = class {
   constructor(resultStore) {
     this.resultStore = resultStore;
   }
-  listRecentArtifacts(options = {}) {
+  async listRecentArtifacts(options = {}) {
     return this.resultStore.listRecentArtifacts({
       channelId: options.channelId,
       limit: clampLimit(options.limit, 100, 500),
@@ -2865,7 +2915,7 @@ var ArtifactPersistenceService = class {
     this.snapshotService = snapshotService;
     this.resultStore = resultStore;
   }
-  saveArtifacts(input) {
+  async saveArtifacts(input) {
     const declaredAt = (/* @__PURE__ */ new Date()).toISOString();
     const snapshots = this.snapshotService.createSnapshots(
       input.runId,
@@ -2873,7 +2923,7 @@ var ArtifactPersistenceService = class {
       declaredAt
     );
     try {
-      this.resultStore.insertArtifacts({
+      await this.resultStore.insertArtifacts({
         runId: input.runId,
         channelId: input.channelId,
         artifacts: snapshots
@@ -2892,7 +2942,7 @@ var ArtifactPersistenceService = class {
 import fs10 from "fs";
 import path10 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
-import Database from "better-sqlite3";
+import sqlite3 from "sqlite3";
 function mapArtifactRow(row) {
   return {
     artifactId: row.artifact_id,
@@ -2909,16 +2959,17 @@ function mapArtifactRow(row) {
   };
 }
 var ResultStore = class {
-  db;
+  db = null;
+  ready;
   constructor(rootDir) {
     const dataDir = path10.resolve(rootDir, "data");
     fs10.mkdirSync(dataDir, { recursive: true });
-    this.db = new Database(path10.join(dataDir, "result.db"));
-    this.db.pragma("journal_mode = WAL");
-    this.initialize();
+    this.ready = this.initialize(path10.join(dataDir, "result-v2.db"));
   }
-  initialize() {
-    this.db.exec(`
+  async initialize(databasePath) {
+    this.db = await openDatabase(databasePath);
+    await this.exec("PRAGMA journal_mode = WAL");
+    await this.exec(`
       CREATE TABLE IF NOT EXISTS artifacts (
         artifact_id TEXT PRIMARY KEY,
         run_id TEXT NOT NULL,
@@ -2937,11 +2988,12 @@ var ResultStore = class {
       ON artifacts(channel_id, declared_at DESC);
     `);
   }
-  insertArtifacts(input) {
+  async insertArtifacts(input) {
+    await this.ready;
     if (input.artifacts.length === 0) {
       return;
     }
-    const insertArtifact = this.db.prepare(`
+    const insertArtifact = `
       INSERT INTO artifacts (
         artifact_id,
         run_id,
@@ -2955,39 +3007,44 @@ var ResultStore = class {
         is_primary,
         declared_at
       ) VALUES (
-        @artifactId,
-        @runId,
-        @channelId,
-        @originalPath,
-        @snapshotPath,
-        @fileName,
-        @mimeType,
-        @sizeBytes,
-        @title,
-        @isPrimary,
-        @declaredAt
+        ?,
+        ?,
+        ?,
+        ?,
+        ?,
+        ?,
+        ?,
+        ?,
+        ?,
+        ?,
+        ?
       )
-    `);
-    const transaction = this.db.transaction((payload) => {
-      for (const artifact of payload.artifacts) {
-        insertArtifact.run({
-          artifactId: randomUUID2(),
-          runId: payload.runId,
-          channelId: payload.channelId,
-          originalPath: artifact.originalPath,
-          snapshotPath: artifact.snapshotPath,
-          fileName: artifact.fileName,
-          mimeType: artifact.mimeType ?? null,
-          sizeBytes: artifact.sizeBytes,
-          title: artifact.title ?? null,
-          isPrimary: artifact.isPrimary ? 1 : 0,
-          declaredAt: artifact.declaredAt
-        });
-      }
-    });
-    transaction(input);
+    `;
+    await this.exec("BEGIN");
+    try {
+      for (const artifact of input.artifacts) {
+        await this.run(insertArtifact, [
+          randomUUID2(),
+          input.runId,
+          input.channelId,
+          artifact.originalPath,
+          artifact.snapshotPath,
+          artifact.fileName,
+          artifact.mimeType ?? null,
+          artifact.sizeBytes,
+          artifact.title ?? null,
+          artifact.isPrimary ? 1 : 0,
+          artifact.declaredAt
+        ]);
+      }
+      await this.exec("COMMIT");
+    } catch (error) {
+      await this.rollback();
+      throw error;
+    }
   }
-  listRecentArtifacts(options = {}) {
+  async listRecentArtifacts(options = {}) {
+    await this.ready;
     const limit = options.limit ?? 100;
     const offset = options.offset ?? 0;
     const conditions = [];
@@ -2997,16 +3054,75 @@ var ResultStore = class {
       params.push(options.channelId);
     }
     const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    const rows = this.db.prepare(`
+    const rows = await this.all(`
       SELECT *
       FROM artifacts
       ${whereClause}
       ORDER BY declared_at DESC, rowid DESC
       LIMIT ? OFFSET ?
-    `).all(...params, limit, offset);
+    `, [...params, limit, offset]);
     return rows.map(mapArtifactRow);
   }
+  getDatabase() {
+    if (!this.db) {
+      throw new Error("Result store database is not ready");
+    }
+    return this.db;
+  }
+  exec(sql) {
+    const db = this.getDatabase();
+    return new Promise((resolve, reject) => {
+      db.exec(sql, (error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+  run(sql, params = []) {
+    const db = this.getDatabase();
+    return new Promise((resolve, reject) => {
+      db.run(sql, params, (error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+  all(sql, params = []) {
+    const db = this.getDatabase();
+    return new Promise((resolve, reject) => {
+      db.all(sql, params, (error, rows) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve(rows);
+      });
+    });
+  }
+  async rollback() {
+    try {
+      await this.exec("ROLLBACK");
+    } catch {
+    }
+  }
 };
+function openDatabase(databasePath) {
+  return new Promise((resolve, reject) => {
+    const db = new sqlite3.Database(databasePath, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve(db);
+    });
+  });
+}
 
 // src/runtime/artifacts/save-artifacts-tool.ts
 import { Type } from "@sinclair/typebox";
@@ -4495,12 +4611,12 @@ var WebAdapter = class {
         )
       );
     });
-    app.get("/api/results/artifacts", (req, res) => {
+    app.get("/api/results/artifacts", async (req, res) => {
       if (!resultsQueryService) {
         res.status(503).json({ error: "Results query service is not available" });
         return;
       }
-      res.json(resultsQueryService.listRecentArtifacts({
+      res.json(await resultsQueryService.listRecentArtifacts({
         channelId: typeof req.query.channelId === "string" ? req.query.channelId : void 0,
         limit: parsePositiveInt(req.query.limit, 100),
         offset: parsePositiveInt(req.query.offset, 0)
@@ -4549,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);
     });
@@ -4819,7 +4935,7 @@ var IpcAdapter = class {
             this.replyError(request.id, "Results query service is not available");
             return;
           }
-          this.reply(request.id, this.resultsQueryService.listRecentArtifacts({
+          this.reply(request.id, await this.resultsQueryService.listRecentArtifacts({
             channelId: request.channelId,
             limit: request.limit,
             offset: request.offset

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cremini/skillpack",
-  "version": "1.2.8",
+  "version": "1.2.10",
   "description": "Pack AI Skills into Local Agents",
   "type": "module",
   "repository": {
@@ -49,18 +49,17 @@
     "@slack/bolt": "^4.6.0",
     "ajv": "^8.17.1",
     "archiver": "^7.0.1",
-    "better-sqlite3": "^11.10.0",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "express": "^5.1.0",
     "inquirer": "^13.3.0",
     "node-cron": "^4.2.1",
     "node-telegram-bot-api": "^0.66.0",
+    "sqlite3": "^5.1.7",
     "ws": "^8.19.0"
   },
   "devDependencies": {
     "@types/archiver": "^7.0.0",
-    "@types/better-sqlite3": "^7.6.13",
     "@types/express": "^5.0.0",
     "@types/inquirer": "^9.0.9",
     "@types/node": "^25.5.0",