@sideboard-ai/core 0.1.326 → 0.1.327

package/dist/{chunk-ZSHS46V5.js → chunk-Y6OHM672.js}

@@ -1,20 +1,28 @@
 import {
   sanitizeMcpServerName
-} from "./chunk-F2PVRF3B.js";
+} from "./chunk-N6ZF3XRP.js";
 import {
   cursorSdkStoreDir
 } from "./chunk-LG6RJBIY.js";
 import {
-  normalizeThinkingEffort
-} from "./chunk-77WWLBCI.js";
+  caffeinateWhileSchedulesEnabled,
+  coerceOrchestratorAgent,
+  isOrchestratorCapableAgent,
+  normalizeThinkingEffort,
+  updateAdvancedSettings
+} from "./chunk-D446IWPP.js";
 import {
+  writePrivateFile
+} from "./chunk-JT7R45JB.js";
+import {
+  appDataDir,
   threadFilePath,
   threadLockPath,
   threadsDir
 } from "./chunk-H4UEFJRI.js";
 
 // src/store/thread-store.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // src/review/review-write-gate.ts
 var REVIEW_TAB_TITLE = "Review";
@@ -1007,8 +1015,8 @@ function isWorktreeIdentityTitle(title, identities) {
 
 // src/store/thread-store.ts
 import {
-  existsSync,
-  readFileSync,
+  existsSync as existsSync2,
+  readFileSync as readFileSync2,
   renameSync,
   rmSync,
   statSync,
@@ -1018,7 +1026,435 @@ import {
 } from "fs";
 import { basename } from "path";
 import lockfile from "proper-lockfile";
-function nowIso() {
+
+// src/store/schedules.ts
+import { randomUUID } from "crypto";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+
+// src/store/schedule-when.ts
+import { Cron } from "croner";
+var WEEKDAY_LABELS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+var DURATION_RE = /^(\d+)(s|m|h|d)$/i;
+var UNIT_MS = {
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+var DAY_ALIASES = {
+  sun: 0,
+  sunday: 0,
+  mon: 1,
+  monday: 1,
+  tue: 2,
+  tues: 2,
+  tuesday: 2,
+  wed: 3,
+  wednesday: 3,
+  thu: 4,
+  thur: 4,
+  thurs: 4,
+  thursday: 4,
+  fri: 5,
+  friday: 5,
+  sat: 6,
+  saturday: 6
+};
+var TIME_RE = /^([01]\d|2[0-3]):([0-5]\d)(?::[0-5]\d)?$/;
+function parseDurationMs(every) {
+  const m = every.trim().match(DURATION_RE);
+  if (!m) return null;
+  const n = Number.parseInt(m[1], 10);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  const unit = m[2].toLowerCase();
+  return n * UNIT_MS[unit];
+}
+function dayIndex(token) {
+  const text = token.trim().toLowerCase();
+  if (/^[0-6]$/.test(text)) return Number(text);
+  return DAY_ALIASES[text];
+}
+function normalizeWeekdays(days) {
+  const set = /* @__PURE__ */ new Set();
+  for (const day of days) {
+    if (!Number.isInteger(day) || day < 0 || day > 6) {
+      throw new Error("Days must be 0 (Sunday) through 6 (Saturday)");
+    }
+    set.add(day);
+  }
+  if (set.size === 0) throw new Error("Pick at least one day");
+  return [...set].sort((a, b) => a - b);
+}
+function parseWeeklyDays(raw) {
+  const text = raw.trim().toLowerCase();
+  if (!text) throw new Error("Pick at least one day");
+  if (text === "daily" || text === "all" || text === "every day" || text === "everyday") {
+    return [0, 1, 2, 3, 4, 5, 6];
+  }
+  if (text === "weekdays" || text === "weekday") return [1, 2, 3, 4, 5];
+  if (text === "weekends" || text === "weekend") return [0, 6];
+  const days = [];
+  for (const part of text.split(/[\s,]+/).filter(Boolean)) {
+    const range = part.split("-");
+    if (range.length === 2 && range[0] && range[1]) {
+      const start = dayIndex(range[0]);
+      const end = dayIndex(range[1]);
+      if (start === void 0 || end === void 0) {
+        throw new Error(`Unknown day: ${part} (use mon,tue, weekdays, weekends, or daily)`);
+      }
+      if (start <= end) {
+        for (let d = start; d <= end; d++) days.push(d);
+      } else {
+        for (let d = start; d <= 6; d++) days.push(d);
+        for (let d = 0; d <= end; d++) days.push(d);
+      }
+      continue;
+    }
+    const n = dayIndex(part);
+    if (n === void 0) {
+      throw new Error(`Unknown day: ${part} (use mon,tue, weekdays, weekends, or daily)`);
+    }
+    days.push(n);
+  }
+  return normalizeWeekdays(days);
+}
+function normalizeWeeklyTime(raw) {
+  const m = raw.trim().match(TIME_RE);
+  if (!m) throw new Error(`Invalid time: ${raw} (use HH:mm, 24-hour)`);
+  return `${m[1]}:${m[2]}`;
+}
+function formatWeeklyDays(days) {
+  const key = normalizeWeekdays(days).join(",");
+  if (key === "0,1,2,3,4,5,6") return "daily";
+  if (key === "1,2,3,4,5") return "weekdays";
+  if (key === "0,6") return "weekends";
+  return normalizeWeekdays(days).map((day) => WEEKDAY_LABELS[day]).join(", ");
+}
+function weeklyCronExpr(when) {
+  const time = normalizeWeeklyTime(when.time);
+  const [hh, mm] = time.split(":");
+  const days = normalizeWeekdays(when.days);
+  return `${Number(mm)} ${Number(hh)} * * ${days.join(",")}`;
+}
+function computeNextRunAt(when, from = /* @__PURE__ */ new Date()) {
+  if (when.kind === "once") {
+    const at = new Date(when.at);
+    if (Number.isNaN(at.getTime())) {
+      throw new Error(`Invalid once-at datetime: ${when.at}`);
+    }
+    return at;
+  }
+  if (when.kind === "every") {
+    const ms = parseDurationMs(when.every);
+    if (!ms) {
+      throw new Error(`Invalid interval: ${when.every} (use 15m, 1h, 6h, 1d)`);
+    }
+    return new Date(from.getTime() + ms);
+  }
+  if (when.kind === "weekly") {
+    return computeNextRunAt(
+      { kind: "cron", expr: weeklyCronExpr(when), tz: when.tz },
+      from
+    );
+  }
+  try {
+    const job = new Cron(when.expr, {
+      timezone: when.tz?.trim() || void 0,
+      paused: true
+    });
+    const next = job.nextRun(from);
+    if (!next) {
+      throw new Error(`Cron expression has no next run: ${when.expr}`);
+    }
+    return next;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Invalid cron: ${message}`);
+  }
+}
+function formatScheduleWhen(when) {
+  if (when.kind === "once") return `once at ${when.at}`;
+  if (when.kind === "every") return `every ${when.every}`;
+  if (when.kind === "weekly") {
+    const label = `${formatWeeklyDays(when.days)} at ${normalizeWeeklyTime(when.time)}`;
+    const tz2 = when.tz?.trim();
+    return tz2 ? `${label} (${tz2})` : label;
+  }
+  const tz = when.tz?.trim();
+  return tz ? `cron ${when.expr} (${tz})` : `cron ${when.expr}`;
+}
+function normalizeWhen(raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new Error("Schedule is missing `when`");
+  }
+  const rec = raw;
+  const kind = rec.kind;
+  if (kind === "once" && typeof rec.at === "string") {
+    return { kind: "once", at: rec.at };
+  }
+  if (kind === "every" && typeof rec.every === "string") {
+    return { kind: "every", every: rec.every };
+  }
+  if (kind === "cron" && typeof rec.expr === "string") {
+    return {
+      kind: "cron",
+      expr: rec.expr,
+      tz: typeof rec.tz === "string" && rec.tz.trim() ? rec.tz.trim() : void 0
+    };
+  }
+  if (kind === "weekly" && Array.isArray(rec.days) && typeof rec.time === "string") {
+    return {
+      kind: "weekly",
+      days: normalizeWeekdays(rec.days.map((day) => Number(day))),
+      time: normalizeWeeklyTime(rec.time),
+      tz: typeof rec.tz === "string" && rec.tz.trim() ? rec.tz.trim() : void 0
+    };
+  }
+  throw new Error("Schedule `when` must be once, every, weekly, or cron");
+}
+
+// src/store/schedules.ts
+function schedulesPath() {
+  return join(appDataDir(), "schedules.json");
+}
+function defaultScheduleName(prompt) {
+  const line = prompt.trim().split(/\r?\n/, 1)[0]?.trim() ?? "";
+  if (!line) return "Untitled automation";
+  return line.length > 60 ? `${line.slice(0, 57).trimEnd()}\u2026` : line;
+}
+function resolveScheduleThreadId(raw, env = process.env) {
+  const value = raw?.trim() || "";
+  if (!value) return null;
+  if (value.toLowerCase() === "self") {
+    return env.SIDEBOARD_ORCHESTRATOR_THREAD_ID?.trim() || env.SIDEBOARD_THREAD_ID?.trim() || null;
+  }
+  return value;
+}
+function nowIso(d = /* @__PURE__ */ new Date()) {
+  return d.toISOString();
+}
+var ATTACHMENT_KINDS = /* @__PURE__ */ new Set([
+  "transcript",
+  "file",
+  "issue",
+  "workspace",
+  "diff-comment",
+  "code-ref"
+]);
+function normalizeOptionalBool(raw) {
+  if (raw === true || raw === false) return raw;
+  return null;
+}
+function normalizeAutonomy(raw) {
+  return raw === "default" || raw === "full" ? raw : null;
+}
+function normalizeAttachments(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object") continue;
+    const row = item;
+    if (typeof row.id !== "string" || !row.id.trim()) continue;
+    if (typeof row.name !== "string" || !row.name) continue;
+    if (typeof row.content !== "string") continue;
+    if (!ATTACHMENT_KINDS.has(row.kind)) continue;
+    const next = {
+      id: row.id,
+      name: row.name,
+      kind: row.kind,
+      content: row.content
+    };
+    if (typeof row.path === "string" && row.path) next.path = row.path;
+    if (typeof row.previewDataUrl === "string" && row.previewDataUrl) {
+      next.previewDataUrl = row.previewDataUrl;
+    }
+    out.push(next);
+  }
+  return out;
+}
+function normalizeTask(raw) {
+  const when = normalizeWhen(raw.when);
+  const agent = raw.agent && isOrchestratorCapableAgent(raw.agent) ? raw.agent : null;
+  return {
+    id: raw.id,
+    name: typeof raw.name === "string" && raw.name.trim() ? raw.name.trim() : defaultScheduleName(raw.prompt),
+    prompt: String(raw.prompt ?? ""),
+    enabled: Boolean(raw.enabled),
+    when,
+    threadId: raw.threadId?.trim() || null,
+    agent,
+    model: raw.model?.trim() || null,
+    effort: normalizeThinkingEffort(raw.effort),
+    fast: normalizeOptionalBool(raw.fast),
+    planMode: normalizeOptionalBool(raw.planMode),
+    autonomy: normalizeAutonomy(raw.autonomy),
+    attachments: normalizeAttachments(raw.attachments),
+    archiveChat: raw.archiveChat !== false,
+    nextRunAt: raw.nextRunAt,
+    lastRunAt: raw.lastRunAt ?? null,
+    lastThreadId: raw.lastThreadId ?? null,
+    lastError: raw.lastError ?? null,
+    createdBy: raw.createdBy === "mcp" || raw.createdBy === "cli" || raw.createdBy === "ui" ? raw.createdBy : "ui",
+    createdAt: raw.createdAt,
+    updatedAt: raw.updatedAt
+  };
+}
+function readAll() {
+  const path = schedulesPath();
+  if (!existsSync(path)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (!Array.isArray(parsed)) return [];
+    return parsed.map((row) => {
+      try {
+        return normalizeTask(row);
+      } catch {
+        return null;
+      }
+    }).filter((row) => Boolean(row?.id && row.prompt));
+  } catch {
+    return [];
+  }
+}
+function writeAll(rows) {
+  writePrivateFile(schedulesPath(), `${JSON.stringify(rows, null, 2)}
+`);
+}
+function buildTask(input, now) {
+  const prompt = input.prompt.trim();
+  if (!prompt) throw new Error("Schedule prompt is required");
+  const when = normalizeWhen(input.when);
+  const nextRunAt = computeNextRunAt(when, now).toISOString();
+  const ts = nowIso(now);
+  const agent = input.agent ? coerceOrchestratorAgent(input.agent) : null;
+  return {
+    id: randomUUID(),
+    name: input.name?.trim() || defaultScheduleName(prompt),
+    prompt,
+    enabled: input.enabled !== false,
+    when,
+    threadId: input.threadId?.trim() || null,
+    agent,
+    model: input.model?.trim() || null,
+    effort: input.effort != null ? normalizeThinkingEffort(input.effort) : null,
+    fast: normalizeOptionalBool(input.fast),
+    planMode: normalizeOptionalBool(input.planMode),
+    autonomy: normalizeAutonomy(input.autonomy),
+    attachments: normalizeAttachments(input.attachments),
+    archiveChat: input.archiveChat !== false,
+    nextRunAt,
+    lastRunAt: null,
+    lastThreadId: null,
+    lastError: null,
+    createdBy: input.createdBy,
+    createdAt: ts,
+    updatedAt: ts
+  };
+}
+function listSchedules() {
+  return readAll().sort((a, b) => a.nextRunAt.localeCompare(b.nextRunAt));
+}
+function hasEnabledSchedules() {
+  return listSchedules().some((row) => row.enabled);
+}
+function scheduleNeedsCaffeinate(task, now = /* @__PURE__ */ new Date()) {
+  if (!task.enabled) return false;
+  const at = new Date(task.nextRunAt);
+  if (Number.isNaN(at.getTime())) return false;
+  return at.getTime() > now.getTime();
+}
+function ensureCaffeinateForFutureSchedule(task) {
+  if (!scheduleNeedsCaffeinate(task)) return;
+  if (caffeinateWhileSchedulesEnabled()) return;
+  updateAdvancedSettings({ caffeinateWhileSchedules: true });
+}
+function getSchedule(id) {
+  const key = id.trim();
+  if (!key) return null;
+  return readAll().find(
+    (row) => row.id === key || row.id.startsWith(key) && key.length >= 8
+  ) ?? null;
+}
+function createSchedule(input) {
+  const task = buildTask(input, /* @__PURE__ */ new Date());
+  const rows = readAll();
+  rows.push(task);
+  writeAll(rows);
+  ensureCaffeinateForFutureSchedule(task);
+  return task;
+}
+function updateSchedule(id, patch) {
+  const rows = readAll();
+  const idx = rows.findIndex((row) => row.id === id || id.length >= 8 && row.id.startsWith(id));
+  if (idx < 0) throw new Error(`Automation not found: ${id}`);
+  const prev = rows[idx];
+  const when = patch.when ? normalizeWhen(patch.when) : prev.when;
+  const prompt = patch.prompt !== void 0 ? patch.prompt.trim() : prev.prompt;
+  if (!prompt) throw new Error("Schedule prompt is required");
+  const whenChanged = patch.when !== void 0;
+  const next = {
+    ...prev,
+    name: patch.name !== void 0 ? patch.name.trim() || defaultScheduleName(prompt) : prev.name,
+    prompt,
+    enabled: patch.enabled ?? prev.enabled,
+    when,
+    threadId: patch.threadId !== void 0 ? patch.threadId?.trim() || null : prev.threadId,
+    agent: patch.agent !== void 0 ? patch.agent ? coerceOrchestratorAgent(patch.agent) : null : prev.agent,
+    model: patch.model !== void 0 ? patch.model?.trim() || null : prev.model,
+    effort: patch.effort !== void 0 ? normalizeThinkingEffort(patch.effort) : prev.effort,
+    fast: patch.fast !== void 0 ? normalizeOptionalBool(patch.fast) : prev.fast,
+    planMode: patch.planMode !== void 0 ? normalizeOptionalBool(patch.planMode) : prev.planMode,
+    autonomy: patch.autonomy !== void 0 ? normalizeAutonomy(patch.autonomy) : prev.autonomy,
+    attachments: patch.attachments !== void 0 ? normalizeAttachments(patch.attachments) : prev.attachments,
+    archiveChat: patch.archiveChat !== void 0 ? patch.archiveChat !== false : prev.archiveChat,
+    nextRunAt: whenChanged ? computeNextRunAt(when).toISOString() : prev.nextRunAt,
+    lastError: whenChanged ? null : prev.lastError,
+    updatedAt: nowIso()
+  };
+  rows[idx] = next;
+  writeAll(rows);
+  ensureCaffeinateForFutureSchedule(next);
+  return next;
+}
+function deleteSchedulesForThread(threadId) {
+  const id = threadId.trim();
+  if (!id) return;
+  const rows = readAll();
+  const next = rows.filter((row) => row.threadId !== id);
+  if (next.length === rows.length) return;
+  writeAll(next);
+}
+function deleteSchedule(id) {
+  const rows = readAll();
+  const next = rows.filter(
+    (row) => row.id !== id && !(id.length >= 8 && row.id.startsWith(id))
+  );
+  if (next.length === rows.length) throw new Error(`Automation not found: ${id}`);
+  writeAll(next);
+}
+function recordScheduleRun(id, result) {
+  const rows = readAll();
+  const idx = rows.findIndex((row) => row.id === id);
+  if (idx < 0) throw new Error(`Automation not found: ${id}`);
+  const prev = rows[idx];
+  const firedAt = result.firedAt ?? /* @__PURE__ */ new Date();
+  const next = {
+    ...prev,
+    enabled: prev.when.kind === "once" ? false : prev.enabled,
+    nextRunAt: prev.when.kind === "once" ? prev.nextRunAt : computeNextRunAt(prev.when, firedAt).toISOString(),
+    lastRunAt: nowIso(firedAt),
+    lastThreadId: result.lastThreadId !== void 0 ? result.lastThreadId : prev.lastThreadId,
+    lastError: result.lastError ?? null,
+    updatedAt: nowIso(firedAt)
+  };
+  rows[idx] = next;
+  writeAll(rows);
+  return next;
+}
+
+// src/store/thread-store.ts
+function nowIso2() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 function resolveThreadEffort(raw) {
@@ -1107,9 +1543,9 @@ function normalizeThread(raw) {
   };
 }
 function createEmptyThread(partial) {
-  const ts = nowIso();
+  const ts = nowIso2();
   return {
-    id: randomUUID(),
+    id: randomUUID2(),
     sessionId: partial.sessionId ?? null,
     autonomy: partial.autonomy ?? "default",
     model: partial.model ?? null,
@@ -1217,7 +1653,7 @@ function readThread(id) {
   const cache = cacheForDir();
   const cached = cache.byId.get(id);
   if (cached && cache.mtimeMs.get(id) === mtimeMs) return cached;
-  const raw = readFileSync(path, "utf8");
+  const raw = readFileSync2(path, "utf8");
   const thread = normalizeThread(JSON.parse(raw));
   rememberThread(thread, mtimeMs);
   return thread;
@@ -1226,7 +1662,7 @@ var selfWriteMtimes = /* @__PURE__ */ new Map();
 function writeThread(thread, opts) {
   const path = threadFilePath(idPath(thread.id));
   const tmp = `${path}.${process.pid}.tmp`;
-  const next = opts?.touch === false ? { ...thread } : { ...thread, updatedAt: nowIso() };
+  const next = opts?.touch === false ? { ...thread } : { ...thread, updatedAt: nowIso2() };
   writeFileSync(tmp, JSON.stringify(next, null, 2), "utf8");
   renameSync(tmp, path);
   const mtimeMs = fileMtimeMs(path) ?? Date.now();
@@ -1270,30 +1706,29 @@ function listThreads(opts) {
 function deleteThreadRecord(id) {
   forgetThread(id);
   const path = threadFilePath(id);
-  if (existsSync(path)) unlinkSync(path);
-  const lock = threadLockPath(id);
-  if (existsSync(lock)) {
-    try {
-      unlinkSync(lock);
-    } catch {
-    }
+  if (existsSync2(path)) unlinkSync(path);
+  try {
+    if (existsSync2(threadLockPath(id))) unlinkSync(threadLockPath(id));
+  } catch {
   }
   try {
     rmSync(cursorSdkStoreDir(id), { recursive: true, force: true });
   } catch {
   }
+  deleteSchedulesForThread(id);
 }
 function updateThread(id, patch) {
   const current = readThread(id);
   if (!current) throw new Error(`Thread not found: ${id}`);
-  const next = { ...current, ...patch, id: current.id, updatedAt: nowIso() };
+  const next = { ...current, ...patch, id: current.id, updatedAt: nowIso2() };
   if (next.status === "archived") {
-    next.archivedAt = typeof next.archivedAt === "string" && next.archivedAt.trim() || current.archivedAt || nowIso();
+    next.archivedAt = typeof next.archivedAt === "string" && next.archivedAt.trim() || current.archivedAt || nowIso2();
   } else {
     delete next.archivedAt;
   }
   if (!next.ephemeralAutomationId?.trim()) delete next.ephemeralAutomationId;
   writeThread(next);
+  if (patch.status === "archived" && current.status !== "archived") deleteSchedulesForThread(current.id);
   return next;
 }
 function appendMessage(id, message) {
@@ -1339,6 +1774,27 @@ export {
   workspaceRowLabel,
   worktreeIdentityTitles,
   isWorktreeIdentityTitle,
+  WEEKDAY_LABELS,
+  parseDurationMs,
+  normalizeWeekdays,
+  parseWeeklyDays,
+  normalizeWeeklyTime,
+  formatWeeklyDays,
+  weeklyCronExpr,
+  computeNextRunAt,
+  formatScheduleWhen,
+  schedulesPath,
+  defaultScheduleName,
+  resolveScheduleThreadId,
+  listSchedules,
+  hasEnabledSchedules,
+  scheduleNeedsCaffeinate,
+  getSchedule,
+  createSchedule,
+  updateSchedule,
+  deleteSchedulesForThread,
+  deleteSchedule,
+  recordScheduleRun,
   resolveThreadEffort,
   normalizeThread,
   createEmptyThread,