@linxin666/dsh-client-ui-task-board 0.1.12 → 0.1.14

package/src/client/sidebar-entry.ts

@@ -87,6 +87,13 @@ function placeEntry(root: HTMLElement, entry: HTMLButtonElement): boolean {
  * @returns disposer removing the entry and its observers.
  */
 export function mountSidebarEntry(controller: BoardController): () => void {
+  // DOM-level idempotency: whatever path mounted an entry row before this
+  // call (a duplicated apply, an HMR re-injection, a stale module still
+  // alive), never mount a second one. The existing row keeps working; a full
+  // page reload is the ultimate reset.
+  if (typeof document !== 'undefined' && document.querySelector('[data-dsh-taskboard-entry]') !== null) {
+    return () => {}
+  }
   const entry = createEntry(controller)
   let root: HTMLElement | undefined
   let placed = false

package/src/core/controller.ts

@@ -94,6 +94,15 @@ export class BoardController {
   start(): void {
     this.tasks = this.deps.store.load()
     void this.reconcileRunningTasks()
+    // A sibling tab may have edited or deleted the ledger (same origin,
+    // storage events). Reload on external change so a task deleted in
+    // another tab stops firing here — and is never written back by this
+    // tab's stale copy (scheduler roll-forward, execution settlement).
+    const unsubscribeExternal = this.deps.store.subscribeExternal?.(() => {
+      this.tasks = this.deps.store.load()
+      this.notify()
+    })
+    if (unsubscribeExternal !== undefined) this.disposers.push(unsubscribeExternal)
     this.disposers.push(this.deps.sessions.list.subscribe(() => {
       this.onSessionsChanged()
     }))
@@ -329,7 +338,7 @@ export class BoardController {
     this.reconcileInFlight = true
     try {
       type Settled = Extract<ExecutionEvent, { kind: 'settled' }>
-      const events: Array<{ task: TaskRecord; event: Settled }> = []
+      const events: Array<{ taskId: string; event: Settled }> = []
       for (const task of this.tasks) {
         if (task.status !== 'running') continue
         const execution = task.executions[task.executions.length - 1]
@@ -337,14 +346,20 @@ export class BoardController {
         // boundary); reconciliation exists for background/leftover runs.
         if (execution !== undefined && this.activeExecutionIds.has(execution.id)) continue
         const event = await this.deps.exec.reconcile(task)
-        if (event !== undefined && event.kind === 'settled') events.push({ task, event })
+        if (event !== undefined && event.kind === 'settled') events.push({ taskId: task.id, event })
       }
       if (events.length === 0) return
       let changed = false
-      for (const { task, event } of events) {
+      for (const { taskId, event } of events) {
+        // The reconcile call above awaited: a sibling tab may have rewritten
+        // the ledger (storage event reload) meanwhile. Re-read the freshest
+        // record now so the stale task captured before the await can never
+        // overwrite fields the sibling wrote.
+        const task = this.tasks.find(candidate => candidate.id === taskId)
+        if (task === undefined) continue
         const next = settleExecution(task, event.executionId, event.outcome, this.now(), event.error)
         if (next === task) continue
-        this.tasks = this.tasks.map(candidate => candidate.id === task.id ? next : candidate)
+        this.tasks = this.tasks.map(candidate => candidate.id === taskId ? next : candidate)
         changed = true
       }
       if (changed) this.persistAndNotify()

package/src/core/store.ts

@@ -25,11 +25,30 @@ export interface TaskStore {
   save(tasks: readonly TaskRecord[]): void
   /** Drop the persisted ledger (leaves the in-memory state alone). */
   clear(): void
+  /**
+   * Subscribe to ledger changes written by ANOTHER tab of the same origin
+   * (browser storage events). The board controller reloads the ledger on
+   * such a change, so a task deleted in one tab cannot keep firing (or be
+   * written back) from the stale in-memory copy of another tab. No-op when
+   * the backend has no cross-instance channel (in-memory store).
+   */
+  subscribeExternal?(listener: () => void): () => void
 }
 
 /** Storage key for the task ledger document. */
 export const DEFAULT_STORAGE_KEY = 'dsh.taskBoard.v1'
 
+/** Structural shape of the storage event fired in sibling tabs (DOM-free). */
+export interface StorageChangeEvent {
+  key: string | null
+}
+
+/** The event-target face the store needs for cross-tab notifications. */
+export interface StorageEvents {
+  addEventListener(type: 'storage', listener: (event: StorageChangeEvent) => void): void
+  removeEventListener(type: 'storage', listener: (event: StorageChangeEvent) => void): void
+}
+
 /**
  * Structural row check with the status left unvalidated (see {@link parseLedger}).
  * The `schedule` field is deliberately NOT checked here: a malformed schedule
@@ -127,10 +146,16 @@ export class LocalStorageTaskStore implements TaskStore {
   /**
    * @param key - storage key for the ledger document.
    * @param storage - storage backend (defaults to the global localStorage; tests inject fakes).
+   * @param events - storage-event target for cross-tab notifications (defaults
+   *   to the browser global; undefined in non-browser runtimes, where the
+   *   subscription becomes a no-op).
    */
   constructor(
     private readonly key: string = DEFAULT_STORAGE_KEY,
     private readonly storage: Pick<Storage, 'getItem' | 'setItem' | 'removeItem'> | undefined = globalThis.localStorage,
+    private readonly events: StorageEvents | undefined = typeof (globalThis as { addEventListener?: unknown }).addEventListener === 'function'
+      ? (globalThis as unknown as StorageEvents)
+      : undefined,
   ) {}
 
   load(): TaskRecord[] {
@@ -163,6 +188,22 @@ export class LocalStorageTaskStore implements TaskStore {
       console.error('[dsh-task-board] task ledger clear failed', error)
     }
   }
+
+  /**
+   * Cross-tab change subscription (see {@link TaskStore.subscribeExternal}).
+   * The browser fires the storage event in every OTHER tab of the same origin
+   * when one tab writes; a null key means the whole storage was cleared. Both
+   * cases reload the ledger here; unrelated keys are ignored.
+   */
+  subscribeExternal(listener: () => void): () => void {
+    if (this.events === undefined) return () => {}
+    const onStorage = (event: StorageChangeEvent): void => {
+      if (event.key !== null && event.key !== this.key) return
+      listener()
+    }
+    this.events.addEventListener('storage', onStorage)
+    return () => { this.events?.removeEventListener('storage', onStorage) }
+  }
 }
 
 /** In-memory backend (tests, and a fallback when storage is unavailable). */