@linxin666/dsh-client-ui-task-board 0.1.20 → 0.2.1

package/src/core/schedule.ts

@@ -73,23 +73,91 @@ export function isValidCron(expr: string): boolean {
 /**
  * Compute the next matching instant after `fromMs` (ms epoch), in local time,
  * at minute granularity, strictly greater than `fromMs`. Returns the ms epoch
- * of the matching minute's start, or undefined when nothing matches within
- * 366 days (e.g. `0 0 30 2 *`).
+ * of the matching minute's start, or undefined when the calendar constraint
+ * can never match (for example `0 0 30 2 *`). The five-year horizon includes
+ * a full leap cycle, so a valid February 29 schedule remains reachable from
+ * every non-leap year.
+ *
+ * Walks candidate year/month/day/hour/minute values straight from the parsed
+ * field sets instead of scanning every minute: a sparse expression such as
+ * `0 0 29 2 *` used to iterate ~1.5M wall-clock minutes before reaching the
+ * next leap day. Wall-clock field construction + the final `matches` re-check
+ * preserve the old minute scan's DST semantics exactly (nonexistent spring
+ * minutes normalize forward and the repeated fall-back hour is never visited).
  */
 export function nextRunAtMs(expr: string, fromMs: number): number | undefined {
   const schedule = parseCron(expr)
   if (schedule === null) return undefined
+  if (!hasPossibleCalendarDay(schedule)) return undefined
   const from = new Date(fromMs)
-  // Scan from the next minute; Date rolls overflow (Feb 30 → Mar 2) for free.
-  const scan = new Date(from.getFullYear(), from.getMonth(), from.getDate(), from.getHours(), from.getMinutes() + 1, 0, 0)
-  const limitMs = fromMs + 366 * 24 * 60 * 60 * 1000
-  while (scan.getTime() <= limitMs) {
-    if (matches(schedule, scan)) return scan.getTime()
-    scan.setMinutes(scan.getMinutes() + 1)
+  const limitMs = fromMs + 5 * 366 * 24 * 60 * 60 * 1000
+
+  const sortedMinutes = [...schedule.minutes].sort((a, b) => a - b)
+  const sortedHours = [...schedule.hours].sort((a, b) => a - b)
+  const sortedMonths = [...schedule.months].sort((a, b) => a - b)
+
+  let year = from.getFullYear()
+  let month = from.getMonth() + 1
+  let day = from.getDate()
+  let hour = from.getHours()
+  // Strictly after fromMs: the old scan started from the next minute.
+  let minute = from.getMinutes() + 1
+
+  while (new Date(year, month - 1, 1, 0, 0, 0, 0).getTime() <= limitMs) {
+    for (const candidateMonth of sortedMonths) {
+      if (candidateMonth < month) continue
+      const daysInMonth = new Date(year, candidateMonth, 0).getDate()
+      const dayStart = candidateMonth === month ? day : 1
+      for (let candidateDay = dayStart; candidateDay <= daysInMonth; candidateDay += 1) {
+        const dayProbe = new Date(year, candidateMonth - 1, candidateDay, 0, 0, 0, 0)
+        if (!dayCandidate(schedule, dayProbe)) continue
+        const hourStart = candidateMonth === month && candidateDay === day ? hour : 0
+        for (const candidateHour of sortedHours) {
+          if (candidateHour < hourStart) continue
+          const minuteStart = candidateMonth === month && candidateDay === day && candidateHour === hour ? minute : 0
+          for (const candidateMinute of sortedMinutes) {
+            if (candidateMinute < minuteStart) continue
+            const candidate = new Date(year, candidateMonth - 1, candidateDay, candidateHour, candidateMinute, 0, 0)
+            const time = candidate.getTime()
+            if (time <= fromMs) continue
+            if (time > limitMs) return undefined
+            if (matches(schedule, candidate)) return time
+          }
+        }
+      }
+    }
+    year += 1
+    month = 1
+    day = 1
+    hour = 0
+    minute = 0
   }
   return undefined
 }
 
+/** Day/weekday OR gate shared by {@link matches} and the candidate scan. */
+function dayCandidate(schedule: CronSchedule, date: Date): boolean {
+  const dayMatches = schedule.days.has(date.getDate())
+  const weekdayMatches = schedule.weekdays.has(date.getDay())
+  if (schedule.dayWildcard) return weekdayMatches
+  if (schedule.weekdayWildcard) return dayMatches
+  return dayMatches || weekdayMatches
+}
+
+/** Reject impossible month/day pairs without spending the multi-year scan. */
+function hasPossibleCalendarDay(schedule: CronSchedule): boolean {
+  if (schedule.dayWildcard || !schedule.weekdayWildcard) return true
+  const maximumDay = new Map<number, number>([
+    [1, 31], [2, 29], [3, 31], [4, 30], [5, 31], [6, 30],
+    [7, 31], [8, 31], [9, 30], [10, 31], [11, 30], [12, 31],
+  ])
+  for (const month of schedule.months) {
+    const maximum = maximumDay.get(month) ?? 0
+    if ([...schedule.days].some(day => day <= maximum)) return true
+  }
+  return false
+}
+
 /** Parse one comma-list field into the match set. */
 function parseField(field: string, min: number, max: number, out: Set<number>): boolean {
   if (field === '*') {
@@ -128,11 +196,7 @@ function matches(schedule: CronSchedule, date: Date): boolean {
   if (!schedule.minutes.has(date.getMinutes())) return false
   if (!schedule.hours.has(date.getHours())) return false
   if (!schedule.months.has(date.getMonth() + 1)) return false
-  const dayMatches = schedule.days.has(date.getDate())
-  const weekdayMatches = schedule.weekdays.has(date.getDay())
-  if (schedule.dayWildcard) return weekdayMatches
-  if (schedule.weekdayWildcard) return dayMatches
-  return dayMatches || weekdayMatches
+  return dayCandidate(schedule, date)
 }
 
 function isDigits(value: string): boolean {

package/src/core/store.ts

@@ -1,13 +1,9 @@
 /**
- * Task persistence: a small storage seam with a localStorage backend.
+ * Legacy v1 browser persistence and the store seam used by pure client tests.
  *
- * The task-board client plugin runs in the browser, and dsh exposes no
- * browser-writable file channel (same conclusion the skin-center research
- * reached for cordis.patch.yml), so tasks persist in the browser's
- * localStorage under a versioned key — the same persistence mechanism dsh's
- * own client snapshot stores use (`createSnapshotStore` persist). Data
- * survives page refreshes and dsh restarts (same origin), and survives
- * plugin uninstall (the key is simply left in place).
+ * Production v2 state is Host-authoritative. This backend is retained only to
+ * read `dsh.taskBoard.v1` for one-time import; the old value is never removed,
+ * so it remains a read-only rollback copy after migration.
  *
  * The seam keeps the backend swappable (e.g. an IndexedDB or a host-file
  * channel later); tests run against the in-memory backend and a jsdom

package/src/core/tasks.ts

@@ -29,9 +29,8 @@ export interface ExecutionRecord {
 }
 
 /**
- * A scheduled-run rule attached to a task. The browser-side scheduler ticks
- * every minute and triggers the task when `nextRunAt` is due; the rule is
- * persisted with the task (localStorage), so scheduling survives refreshes.
+ * A scheduled-run rule attached to a task. The Host scheduler triggers the
+ * task when `nextRunAt` is due and persists the rule in the Host ledger.
  */
 export interface ScheduleRule {
   /** Whether the schedule is armed. */
@@ -81,7 +80,8 @@ export interface TaskRecord {
   permission?: TaskPermission
   /**
    * When the task was archived (ms epoch). Archived tasks keep their status
-   * and execution history but leave the main board; absent means on-board.
+   * and execution history, leave the main board, and cannot run until restored;
+   * absent means on-board.
    */
   archivedAt?: number
 }
@@ -146,8 +146,8 @@ export function isTaskStatus(value: unknown): value is TaskStatus {
 }
 
 /** Whether a manual move target is allowed from the given status. */
-export function canMoveManually(_from: TaskStatus, to: TaskStatus): boolean {
-  return (MANUAL_STATUSES as readonly TaskStatus[]).includes(to)
+export function canMoveManually(from: TaskStatus, to: TaskStatus): boolean {
+  return from !== 'running' && (MANUAL_STATUSES as readonly TaskStatus[]).includes(to)
 }
 
 /** Normalize one optional execution-target string: trim; blank collapses to undefined. */

package/src/core/use-cases/task-archive.ts

@@ -1,8 +1,8 @@
 /**
  * Archive/restore task use case: move a settled (done/failed) task off the
- * main board and back. Purely a marker transition — the task keeps its
- * status, execution history and transcript references, so archiving never
- * loses traceability and restoring lands it in the exact column it left.
+ * main board and back. The task keeps its status, execution history, and
+ * transcript references, while archiving disarms any schedule so it cannot
+ * create more execution records until the user restores and re-enables it.
  */
 import type { TaskRecord } from '../tasks.ts'
 import { ARCHIVABLE_STATUSES } from '../tasks.ts'
@@ -18,7 +18,8 @@ export interface ArchiveTaskResult {
 /**
  * Archive one task: only settled statuses (done/failed) can be archived;
  * a running or not-yet-settled task stays on the board (its runner still
- * owns its lifecycle). Already-archived tasks are a no-op.
+ * owns its lifecycle). Archiving disarms a schedule; already-archived tasks
+ * are a no-op.
  */
 export function applyArchiveTask(
   tasks: readonly TaskRecord[],
@@ -30,7 +31,15 @@ export function applyArchiveTask(
     if (task.id !== id || task.archivedAt !== undefined) return task
     if (!(ARCHIVABLE_STATUSES as readonly string[]).includes(task.status)) return task
     applied = true
-    return { ...task, archivedAt: now, updatedAt: now }
+    const schedule = task.schedule === undefined
+      ? undefined
+      : { ...task.schedule, enabled: false, nextRunAt: undefined }
+    return {
+      ...task,
+      ...(schedule === undefined ? {} : { schedule }),
+      archivedAt: now,
+      updatedAt: now,
+    }
   })
   return { tasks: next, archived: applied }
 }

package/src/core/use-cases/task-schedule.ts

@@ -22,9 +22,9 @@ export interface SetScheduleResult {
 }
 
 /**
- * Set a task's schedule rule. A blank or invalid cron is rejected (state
- * untouched); an enabled rule computes the next run instant immediately, a
- * disabled or invalid one carries no next-run instant.
+ * Set an on-board task's schedule rule. A blank or invalid cron, or an
+ * archived task, is rejected (state untouched); an enabled rule computes the
+ * next run instant immediately, a disabled one carries no next-run instant.
  * @param tasks - current ledger.
  * @param id - the task to schedule.
  * @param patch - rule fields to change (absent fields keep their current value).
@@ -37,12 +37,13 @@ export function applySetSchedule(
   now: number,
 ): SetScheduleResult {
   const task = tasks.find(candidate => candidate.id === id)
-  if (task === undefined) return { tasks, applied: false }
+  if (task === undefined || task.archivedAt !== undefined) return { tasks, applied: false }
   const current = task.schedule
   const cron = (patch.cron ?? current?.cron ?? '').trim()
   if (cron === '' || !isValidCron(cron)) return { tasks, applied: false }
   const enabled = patch.enabled ?? current?.enabled ?? false
   const nextRunAt = enabled ? nextRunAtMs(cron, now) : undefined
+  if (enabled && nextRunAt === undefined) return { tasks, applied: false }
   return {
     tasks: tasks.map(candidate =>
       candidate.id === id ? withSchedule(candidate, { enabled, cron, nextRunAt }, now) : candidate),
@@ -68,7 +69,7 @@ export function applyScheduleNextRun(
   now: number,
 ): readonly TaskRecord[] {
   return tasks.map(task =>
-    task.id === id && task.schedule !== undefined
+    task.id === id && task.archivedAt === undefined && task.schedule !== undefined
       ? withSchedule(task, { nextRunAt, lastTriggeredAt }, now)
       : task)
 }

package/src/dsh-home.ts

@@ -0,0 +1,36 @@
+// Generated by scripts/sync-shared.mjs from shared/host/dsh-home.ts. Do not edit this copy; edit the shared source and run "node scripts/sync-shared.mjs".
+/**
+ * DSH_HOME resolution shared by the plugin family's Host halves: the
+ * environment override wins, the platform home fallback follows. Mirrors
+ * what dsh-pet and dsh-liangshen each used to implement locally.
+ */
+
+import { homedir } from 'node:os'
+import { isAbsolute, join } from 'node:path'
+
+/** Expand a leading ~ (or ~user) in a path, platform-style. */
+export function expandHome(path: string, home: string = homedir()): string {
+  if (path === '~') return home
+  if (path.startsWith('~/') || path.startsWith('~\\')) return join(home, path.slice(2))
+  return path
+}
+
+/**
+ * Resolve the DSH home directory.
+ * @param env - process environment to read DSH_HOME from.
+ * @param home - platform home directory fallback (test seam).
+ * @returns the absolute DSH home path.
+ */
+export function resolveDshHome(env: NodeJS.ProcessEnv = process.env, home: string = homedir()): string {
+  const raw = env.DSH_HOME
+  if (raw !== undefined && raw.trim() !== '') {
+    const expanded = expandHome(raw.trim(), home)
+    return isAbsolute(expanded) ? expanded : join(process.cwd(), expanded)
+  }
+  return join(home, '.dsh')
+}
+
+/** Resolve the DSH home directory from the live environment. */
+export function dshHome(): string {
+  return resolveDshHome()
+}