chainlesschain 0.45.81 → 0.47.0

package/src/lib/cowork-cron.js

@@ -0,0 +1,474 @@
+/**
+ * Cowork Cron — schedule and run daily Cowork tasks on a cron.
+ *
+ * Persists schedules to `.chainlesschain/cowork/schedules.jsonl` (one JSON
+ * object per line). Schedules have shape:
+ *
+ *   {
+ *     id: "sch-...",
+ *     cron: "0 9 * * 1-5",       // 5-field POSIX cron
+ *     templateId: "doc-convert",  // or null for free mode
+ *     userMessage: "...",         // task prompt
+ *     files: ["/abs/path/..."],   // optional
+ *     enabled: true,
+ *     createdAt: ISO,
+ *     lastRunAt: ISO|null,
+ *     lastStatus: "completed"|"failed"|null,
+ *   }
+ *
+ * The scheduler ticks every 60s by default. If any schedule uses a 6-field
+ * (seconds-aware) cron expression, the tick rate auto-adapts to 1s.
+ * Each tick reloads schedules and runs any whose cron matches the current
+ * minute (or second, if 6-field). A schedule only runs once per fire-window.
+ *
+ * Supported cron syntax:
+ *   - 5 fields: minute hour dom month dow              (POSIX)
+ *   - 6 fields: second minute hour dom month dow       (Quartz-like, seconds first)
+ *   - Aliases:  @yearly @annually @monthly @weekly @daily @midnight @hourly
+ *
+ * @module cowork-cron
+ */
+
+import crypto from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+export const _deps = {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  now: () => new Date(),
+  runTask: null, // injected at runtime to avoid circular import
+};
+
+// ─── Cron parser ─────────────────────────────────────────────────────────────
+
+const FIELD_RANGES = [
+  [0, 59], // minute
+  [0, 23], // hour
+  [1, 31], // day-of-month
+  [1, 12], // month
+  [0, 6], // day-of-week (0=Sun, 6=Sat). 7 also maps to 0.
+];
+
+const SECOND_RANGE = [0, 59];
+
+/**
+ * Non-standard alias → 5-field expression. Aliases never carry seconds.
+ */
+export const ALIASES = Object.freeze({
+  "@yearly": "0 0 1 1 *",
+  "@annually": "0 0 1 1 *",
+  "@monthly": "0 0 1 * *",
+  "@weekly": "0 0 * * 0",
+  "@daily": "0 0 * * *",
+  "@midnight": "0 0 * * *",
+  "@hourly": "0 * * * *",
+});
+
+/**
+ * Expand a cron alias (e.g. "@daily") into its 5-field equivalent.
+ * Returns the original string unchanged if not an alias.
+ */
+export function _expandExpr(expr) {
+  if (typeof expr !== "string") return expr;
+  const trimmed = expr.trim();
+  if (trimmed.startsWith("@")) {
+    const alias = ALIASES[trimmed.toLowerCase()];
+    if (!alias) throw new Error(`unknown cron alias: ${trimmed}`);
+    return alias;
+  }
+  return trimmed;
+}
+
+/**
+ * Parse a single cron field into a Set of matching integers.
+ * Supports:
+ *   *              — every value in range
+ *   N              — single number
+ *   A-B            — inclusive range
+ *   *\/N or A-B/N — step (every Nth value)
+ *   a,b,c          — comma-separated list (any combination of the above)
+ */
+export function parseCronField(field, [min, max]) {
+  if (typeof field !== "string" || field.length === 0) {
+    throw new Error("empty cron field");
+  }
+  const values = new Set();
+  for (const part of field.split(",")) {
+    const slashIdx = part.indexOf("/");
+    const stepStr = slashIdx >= 0 ? part.slice(slashIdx + 1) : null;
+    const base = slashIdx >= 0 ? part.slice(0, slashIdx) : part;
+    const step = stepStr === null ? 1 : parseInt(stepStr, 10);
+    if (!Number.isFinite(step) || step < 1) {
+      throw new Error(`invalid cron step: ${part}`);
+    }
+    let lo, hi;
+    if (base === "*") {
+      lo = min;
+      hi = max;
+    } else if (base.includes("-")) {
+      const [a, b] = base.split("-").map((x) => parseInt(x, 10));
+      if (!Number.isFinite(a) || !Number.isFinite(b)) {
+        throw new Error(`invalid cron range: ${part}`);
+      }
+      lo = a;
+      hi = b;
+    } else {
+      const n = parseInt(base, 10);
+      if (!Number.isFinite(n)) {
+        throw new Error(`invalid cron value: ${part}`);
+      }
+      lo = n;
+      hi = n;
+    }
+    // Normalize day-of-week 7 → 0
+    if (max === 6 && lo === 7) lo = 0;
+    if (max === 6 && hi === 7) hi = 0;
+    if (lo < min || hi > max || lo > hi) {
+      throw new Error(`cron value out of range ${min}-${max}: ${part}`);
+    }
+    for (let v = lo; v <= hi; v += step) {
+      values.add(v);
+    }
+  }
+  return values;
+}
+
+/**
+ * Parse a 5- or 6-field cron expression (or alias). Returns a match function
+ * with `.hasSeconds` boolean property indicating whether the expression
+ * carries seconds resolution.
+ *
+ * @param {string} expr
+ * @returns {((date: Date) => boolean) & { hasSeconds: boolean }}
+ */
+export function parseCron(expr) {
+  if (typeof expr !== "string") {
+    throw new Error("cron expression must be a string");
+  }
+  const expanded = _expandExpr(expr);
+  const parts = expanded.split(/\s+/);
+  if (parts.length !== 5 && parts.length !== 6) {
+    throw new Error(
+      `cron must have 5 or 6 fields (got ${parts.length}); use 6-field for seconds resolution or alias like @daily`,
+    );
+  }
+  const hasSeconds = parts.length === 6;
+  let second = null;
+  let minute, hour, dom, month, dow;
+  if (hasSeconds) {
+    second = parseCronField(parts[0], SECOND_RANGE);
+    [minute, hour, dom, month, dow] = parts
+      .slice(1)
+      .map((p, i) => parseCronField(p, FIELD_RANGES[i]));
+  } else {
+    [minute, hour, dom, month, dow] = parts.map((p, i) =>
+      parseCronField(p, FIELD_RANGES[i]),
+    );
+  }
+
+  // Pre-compute restriction flags for POSIX dom/dow OR-semantics
+  const domField = hasSeconds ? parts[3] : parts[2];
+  const dowField = hasSeconds ? parts[5] : parts[4];
+  const domRestricted = domField !== "*";
+  const dowRestricted = dowField !== "*";
+
+  function matches(date) {
+    const s = date.getSeconds();
+    const m = date.getMinutes();
+    const h = date.getHours();
+    const D = date.getDate();
+    const M = date.getMonth() + 1; // JS month is 0-based
+    const W = date.getDay();
+    if (hasSeconds && !second.has(s)) return false;
+    if (!minute.has(m)) return false;
+    if (!hour.has(h)) return false;
+    if (!month.has(M)) return false;
+    // POSIX: if both dom and dow are restricted (not *), match is OR.
+    if (domRestricted && dowRestricted) {
+      return dom.has(D) || dow.has(W);
+    }
+    if (domRestricted) return dom.has(D);
+    if (dowRestricted) return dow.has(W);
+    return true;
+  }
+  matches.hasSeconds = hasSeconds;
+  return matches;
+}
+
+/** Returns true if the cron expression carries seconds resolution. */
+export function hasSecondsResolution(expr) {
+  try {
+    return parseCron(expr).hasSeconds;
+  } catch (_e) {
+    return false;
+  }
+}
+
+/** Validate a cron expression — returns null if valid, error string otherwise. */
+export function validateCron(expr) {
+  try {
+    parseCron(expr);
+    return null;
+  } catch (err) {
+    return err.message;
+  }
+}
+
+// ─── Persistence ─────────────────────────────────────────────────────────────
+
+function _scheduleFile(cwd) {
+  return join(cwd, ".chainlesschain", "cowork", "schedules.jsonl");
+}
+
+/** Load all schedules from disk. Returns [] if the file doesn't exist. */
+export function loadSchedules(cwd) {
+  const file = _scheduleFile(cwd);
+  if (!_deps.existsSync(file)) return [];
+  const raw = _deps.readFileSync(file, "utf-8");
+  const out = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch (_e) {
+      // Skip malformed lines — don't let one bad record break the rest
+    }
+  }
+  return out;
+}
+
+/** Write the full schedule list back to disk, overwriting. */
+export function saveSchedules(cwd, schedules) {
+  const dir = join(cwd, ".chainlesschain", "cowork");
+  _deps.mkdirSync(dir, { recursive: true });
+  const file = _scheduleFile(cwd);
+  const body = schedules.map((s) => JSON.stringify(s)).join("\n");
+  _deps.writeFileSync(file, body ? body + "\n" : "", "utf-8");
+}
+
+// ─── CRUD ────────────────────────────────────────────────────────────────────
+
+export function addSchedule(cwd, input) {
+  const { cron, templateId = null, userMessage, files = [] } = input || {};
+  if (!userMessage || typeof userMessage !== "string") {
+    throw new Error("userMessage is required");
+  }
+  const err = validateCron(cron);
+  if (err) throw new Error(`invalid cron: ${err}`);
+
+  const schedules = loadSchedules(cwd);
+  const entry = {
+    id: `sch-${crypto.randomUUID().slice(0, 12)}`,
+    cron: cron.trim(),
+    templateId,
+    userMessage,
+    files: Array.isArray(files) ? files : [],
+    enabled: true,
+    createdAt: _deps.now().toISOString(),
+    lastRunAt: null,
+    lastStatus: null,
+  };
+  schedules.push(entry);
+  saveSchedules(cwd, schedules);
+  return entry;
+}
+
+export function removeSchedule(cwd, id) {
+  const schedules = loadSchedules(cwd);
+  const idx = schedules.findIndex((s) => s.id === id);
+  if (idx === -1) return false;
+  schedules.splice(idx, 1);
+  saveSchedules(cwd, schedules);
+  return true;
+}
+
+export function setScheduleEnabled(cwd, id, enabled) {
+  const schedules = loadSchedules(cwd);
+  const s = schedules.find((x) => x.id === id);
+  if (!s) return false;
+  s.enabled = !!enabled;
+  saveSchedules(cwd, schedules);
+  return true;
+}
+
+export function updateScheduleRunState(cwd, id, { lastRunAt, lastStatus }) {
+  const schedules = loadSchedules(cwd);
+  const s = schedules.find((x) => x.id === id);
+  if (!s) return false;
+  if (lastRunAt) s.lastRunAt = lastRunAt;
+  if (lastStatus) s.lastStatus = lastStatus;
+  saveSchedules(cwd, schedules);
+  return true;
+}
+
+// ─── Scheduler ───────────────────────────────────────────────────────────────
+
+/**
+ * Background scheduler that checks schedules every minute and runs due ones.
+ * Enforces once-per-minute-per-schedule via `_firedKeys` (schedule.id + minute).
+ */
+export class CoworkCronScheduler {
+  constructor(options = {}) {
+    this.cwd = options.cwd || process.cwd();
+    // If caller pins intervalMs we honor it; else auto-adapt based on schedules.
+    this._intervalPinned = typeof options.intervalMs === "number";
+    this.intervalMs = options.intervalMs || 60_000;
+    this.onEvent = options.onEvent || null; // (event) => void
+    this._timer = null;
+    this._firedKeys = new Set();
+    this._running = new Set();
+  }
+
+  start() {
+    if (this._timer) return;
+    this._adaptInterval(); // pick 1s vs 60s based on current schedules
+    this._tick(); // immediate first tick so tests don't wait
+    this._timer = setInterval(() => this._tick(), this.intervalMs);
+    this._emit({ type: "scheduler-started", intervalMs: this.intervalMs });
+  }
+
+  /**
+   * Re-evaluate desired tick rate. If any active schedule uses seconds, drop
+   * to 1s; else use 60s. No-op if caller pinned intervalMs.
+   */
+  _adaptInterval() {
+    if (this._intervalPinned) return;
+    let schedules = [];
+    try {
+      schedules = loadSchedules(this.cwd);
+    } catch (_e) {
+      // ignore — keep current interval
+    }
+    const wantSeconds = schedules.some(
+      (s) => s.enabled !== false && hasSecondsResolution(s.cron),
+    );
+    const desired = wantSeconds ? 1000 : 60_000;
+    if (desired !== this.intervalMs) {
+      this.intervalMs = desired;
+      if (this._timer) {
+        clearInterval(this._timer);
+        this._timer = setInterval(() => this._tick(), this.intervalMs);
+        this._emit({ type: "scheduler-retuned", intervalMs: this.intervalMs });
+      }
+    }
+  }
+
+  stop() {
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+    this._emit({ type: "scheduler-stopped" });
+  }
+
+  _emit(event) {
+    if (typeof this.onEvent === "function") {
+      try {
+        this.onEvent(event);
+      } catch (_e) {
+        // Never let observer errors break the scheduler
+      }
+    }
+  }
+
+  async _tick() {
+    const now = _deps.now();
+    let schedules;
+    try {
+      schedules = loadSchedules(this.cwd);
+    } catch (err) {
+      this._emit({ type: "load-error", error: err.message });
+      return;
+    }
+
+    // Re-adapt interval if schedule set changed (added/removed seconds-aware)
+    this._adaptInterval();
+
+    for (const s of schedules) {
+      if (!s.enabled) continue;
+      let matcher;
+      try {
+        matcher = parseCron(s.cron);
+      } catch (err) {
+        this._emit({ type: "invalid-cron", id: s.id, error: err.message });
+        continue;
+      }
+      const fireKey = `${s.id}:${
+        matcher.hasSeconds ? _secondKey(now) : _minuteKey(now)
+      }`;
+      if (this._firedKeys.has(fireKey)) continue;
+      if (this._running.has(s.id)) continue;
+      const isDue = matcher(now);
+      if (!isDue) continue;
+
+      this._firedKeys.add(fireKey);
+      this._running.add(s.id);
+      this._runSchedule(s).finally(() => {
+        this._running.delete(s.id);
+      });
+    }
+
+    // Prevent unbounded growth of _firedKeys — keep only recent minute keys
+    if (this._firedKeys.size > 10_000) {
+      this._firedKeys.clear();
+    }
+  }
+
+  async _runSchedule(schedule) {
+    const runTask = _deps.runTask;
+    if (typeof runTask !== "function") {
+      this._emit({
+        type: "run-error",
+        id: schedule.id,
+        error: "runTask not injected",
+      });
+      return;
+    }
+    this._emit({
+      type: "schedule-fired",
+      id: schedule.id,
+      cron: schedule.cron,
+      templateId: schedule.templateId,
+    });
+    try {
+      const result = await runTask({
+        templateId: schedule.templateId,
+        userMessage: schedule.userMessage,
+        files: schedule.files,
+        cwd: this.cwd,
+      });
+      updateScheduleRunState(this.cwd, schedule.id, {
+        lastRunAt: _deps.now().toISOString(),
+        lastStatus: result?.status || "completed",
+      });
+      this._emit({
+        type: "schedule-completed",
+        id: schedule.id,
+        taskId: result?.taskId,
+        status: result?.status,
+      });
+    } catch (err) {
+      updateScheduleRunState(this.cwd, schedule.id, {
+        lastRunAt: _deps.now().toISOString(),
+        lastStatus: "failed",
+      });
+      this._emit({
+        type: "schedule-failed",
+        id: schedule.id,
+        error: err.message,
+      });
+    }
+  }
+}
+
+function _minuteKey(date) {
+  return `${date.getFullYear()}-${date.getMonth()}-${date.getDate()}-${date.getHours()}-${date.getMinutes()}`;
+}
+
+function _secondKey(date) {
+  return `${_minuteKey(date)}-${date.getSeconds()}`;
+}

package/src/lib/cowork-evomap-adapter.js

@@ -0,0 +1,121 @@
+/**
+ * Cowork ↔ EvoMap adapter — publish Cowork templates as EvoMap "genes" and
+ * pull them back for local install. Thin wrapper over `evomap-client.js`
+ * that fixes `kind = "cowork-template"` and carries N4 signatures through.
+ *
+ * Pure glue: all I/O is delegated to EvoMapClient (network) and the
+ * marketplace/share modules (disk). Injectable via `_deps.createClient`.
+ *
+ * @module cowork-evomap-adapter
+ */
+
+import { EvoMapClient } from "./evomap-client.js";
+import {
+  toShareableTemplate,
+  saveUserTemplate,
+} from "./cowork-template-marketplace.js";
+import { buildPacket } from "./cowork-share.js";
+
+export const _deps = {
+  createClient: (opts) => new EvoMapClient(opts),
+};
+
+const KIND = "cowork-template";
+
+function _wrapGene(template, signer) {
+  const payload = toShareableTemplate(template);
+  // Reuse share-packet builder so signed genes land on the hub with the same
+  // canonical shape as file-based packets (checksum + optional signature).
+  const packet = buildPacket({
+    kind: "template",
+    payload,
+    author: signer?.did || "anonymous",
+    cliVersion: undefined,
+    signer: signer || undefined,
+  });
+  return {
+    id: payload.id,
+    name: payload.name || payload.id,
+    description: payload.description || "",
+    kind: KIND,
+    version: payload.version || "1.0.0",
+    packet,
+  };
+}
+
+/**
+ * Publish a template to a hub. Requires API key on the client.
+ * @returns {Promise<object>} hub response (typically { id, ... })
+ */
+export async function publishTemplateToHub(
+  template,
+  { hubUrl, apiKey, signer } = {},
+) {
+  if (!template || !template.id) {
+    throw new Error("template.id required");
+  }
+  const client = _deps.createClient({ hubUrl, apiKey });
+  const gene = _wrapGene(template, signer);
+  return client.publish(gene);
+}
+
+/**
+ * Search templates on a hub. Degrades to [] on network error unless
+ * `strict: true` is passed.
+ * @returns {Promise<Array>} annotated with `_hubMeta`
+ */
+export async function searchTemplatesInHub(
+  query,
+  { hubUrl, limit = 20, strict = false } = {},
+) {
+  const client = _deps.createClient({ hubUrl });
+  try {
+    const results = await client.search(query || "", {
+      category: KIND,
+      limit,
+    });
+    return (results || []).map((r) => ({
+      ...r,
+      _hubMeta: {
+        hubUrl: client.hubUrl,
+        downloads: r.downloads || 0,
+        rating: r.rating || null,
+      },
+    }));
+  } catch (err) {
+    if (strict) throw err;
+    return [];
+  }
+}
+
+/**
+ * Fetch a gene by id and install its template into the local marketplace.
+ * Returns the saved template object.
+ */
+export async function installTemplateFromHub(
+  cwd,
+  geneId,
+  { hubUrl, requireSigned = false, trustedDids = null } = {},
+) {
+  const client = _deps.createClient({ hubUrl });
+  const data = await client.download(geneId);
+  // Hub may return { gene: { packet } } or { packet } directly
+  const gene = data?.gene || data;
+  const packet = gene?.packet || data?.packet;
+  if (!packet || packet.kind !== "template" || !packet.payload) {
+    throw new Error("Hub response missing template packet");
+  }
+  if (requireSigned && !packet.signature) {
+    throw new Error("Gene is not signed and --require-signed was set");
+  }
+  if (
+    Array.isArray(trustedDids) &&
+    trustedDids.length > 0 &&
+    (!packet.signature || !trustedDids.includes(packet.signature.did))
+  ) {
+    throw new Error(
+      `Gene signer not in trusted list${packet.signature ? ` (${packet.signature.did})` : ""}`,
+    );
+  }
+  return saveUserTemplate(cwd, packet.payload);
+}