@raidou/pi-notify 0.5.0 → 0.5.2

package/README.md

@@ -76,7 +76,7 @@ Columns: `SESSION_ID` (last 6 chars), `PID`, `STATE` (running/idle, color-coded)
 
 Keybindings:
 
-- `↑` / `↓` or `j` / `k` — scroll
+- `o` — show/hide the SESSION_ID and PID columns
 - `r` — refresh
 - `q` or `esc` — close
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raidou/pi-notify",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Desktop notification extension for the pi coding agent.",
   "keywords": [
     "pi",

package/src/dashboard/ui/columns.ts

@@ -47,7 +47,7 @@ const COLUMNS: Column[] = [
     width: 10,
     render: (session, theme, width) => {
       const startedRunningAt = session.startedRunningAt
-      if (!startedRunningAt) return ''
+      if (!startedRunningAt) return ''.padEnd(width)
       const duration = Date.now() - startedRunningAt
       return theme.fg('dim', formatDuration(duration).padEnd(width))
     },

package/src/dashboard/ui/dashboard.test.ts

@@ -1,6 +1,6 @@
 import type { Theme, ThemeColor } from '@earendil-works/pi-coding-agent'
 import { visibleWidth } from '@earendil-works/pi-tui'
-import { describe, expect, it } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 
 import type { SessionRecord } from '../state-store.js'
 import { Dashboard } from './dashboard.js'
@@ -27,16 +27,21 @@ function makeSession(overrides: Partial<SessionRecord>): SessionRecord {
   }
 }
 
-function makeDashboard(sessions: SessionRecord[]) {
+function makeDashboard(
+  sessions: SessionRecord[],
+  overrides: Partial<{
+    onRefresh: () => Promise<SessionRecord[]>
+  }> = {},
+) {
+  const onRefresh = overrides.onRefresh ?? (async () => sessions)
   return new Dashboard({
     tui: { requestRender: () => {} },
     theme,
     initialSessions: sessions,
-    onRefresh: async () => sessions,
+    onRefresh,
     onClose: () => {},
   })
 }
-
 describe('Dashboard render clipping', () => {
   const longNameSession = makeSession({
     projectName: 'a-very-long-project-name-that-exceeds-any-narrow-width',
@@ -65,12 +70,12 @@ describe('Dashboard render clipping', () => {
     const visible = lines.map(stripAnsi)
     const header = visible.find((l) => l.includes('STATE'))
     expect(header).toBeDefined()
-    const footer = visible.find((l) => l.startsWith('o ids'))
+    const footer = visible.find((l) => l.startsWith('[o] show/hide ids'))
     expect(footer).toBeDefined()
     if (!header || !footer) throw new Error('unreachable')
     expect(header.startsWith('STATE')).toBe(true)
     expect(header.endsWith('…')).toBe(true)
-    expect(footer.startsWith('o ids • r refresh •…')).toBe(true)
+    expect(footer.startsWith('[o] show/hide ids ·…')).toBe(true)
     for (const line of visible) {
       expect(visibleWidth(line)).toBeLessThanOrEqual(20)
     }
@@ -116,3 +121,21 @@ describe('hidden column toggle', () => {
     }
   })
 })
+
+describe('auto-refresh', () => {
+  it('manual r triggers refresh', () => {
+    const onRefresh = vi.fn(async () => [makeSession({})])
+    const dashboard = makeDashboard([makeSession({})], { onRefresh })
+    dashboard.handleInput('r')
+    expect(onRefresh).toHaveBeenCalledTimes(1)
+    dashboard.dispose()
+  })
+
+  it('dispose stops further refreshes', () => {
+    const onRefresh = vi.fn(async () => [makeSession({})])
+    const dashboard = makeDashboard([makeSession({})], { onRefresh })
+    dashboard.dispose()
+    dashboard.handleInput('r')
+    expect(onRefresh).not.toHaveBeenCalled()
+  })
+})

package/src/dashboard/ui/dashboard.ts

@@ -3,6 +3,7 @@ import type { Component } from '@earendil-works/pi-tui'
 import { Key, matchesKey, truncateToWidth } from '@earendil-works/pi-tui'
 
 import type { SessionRecord } from '../state-store.js'
+import { watchStore } from '../watch-store.js'
 import {
   COLUMN_SEPARATOR,
   resolveColumns,
@@ -29,7 +30,7 @@ export class Dashboard implements Component {
   private cachedLines: string[] = []
   private disposed = false
   private showHidden = false
-  private timer: NodeJS.Timeout
+  private readonly stopWatching: () => void
 
   constructor({
     tui,
@@ -46,10 +47,9 @@ export class Dashboard implements Component {
     this.onDispose = onDispose
     this.sessions = [...initialSessions]
 
-    // FIXME: 改成用 fs.watch
-    this.timer = setInterval(() => {
-      if (!this.disposed) this.refresh()
-    }, 10000)
+    this.stopWatching = watchStore(() => {
+      this.refresh()
+    })
   }
 
   private forceRender(): void {
@@ -58,6 +58,7 @@ export class Dashboard implements Component {
   }
 
   private refresh(): void {
+    if (this.disposed) return
     this.onRefresh()
       .then((newSessions) => {
         this.sessions = [...newSessions]
@@ -87,12 +88,30 @@ export class Dashboard implements Component {
           .join(COLUMN_SEPARATOR),
       ),
       '',
-      this.theme.fg('dim', 'o ids • r refresh • q or esc close'),
+      this.footerLine(width, [
+        ['o', 'show/hide ids'],
+        ['r', 'refresh'],
+        ['q/esc', 'close'],
+      ]),
     ]
     this.cachedLines = rows.map((line) => truncateToWidth(line, width, '…'))
     return this.cachedLines
   }
 
+  private footerLine(width: number, keys: [string, string][]): string {
+    const sep = this.theme.fg('dim', ' · ')
+    return truncateToWidth(
+      keys
+        .map(
+          ([key, desc]) =>
+            `${this.theme.fg('syntaxKeyword', `[${key}]`)} ${this.theme.fg('success', desc)}`,
+        )
+        .join(sep),
+      width,
+      '…',
+    )
+  }
+
   handleInput(data: string): void {
     if (matchesKey(data, 'r')) {
       this.refresh()
@@ -116,7 +135,7 @@ export class Dashboard implements Component {
 
   dispose(): void {
     this.disposed = true
-    clearInterval(this.timer)
+    this.stopWatching()
     this.onDispose?.()
   }
 }

package/src/dashboard/watch-store.test.ts

@@ -0,0 +1,112 @@
+import { renameSync, rmSync, writeFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+import { afterAll, describe, expect, it, vi } from 'vitest'
+
+vi.mock('./consts.js', async () => {
+  const { mkdtempSync } = await import('node:fs')
+  const path = await import('node:path')
+  const { tmpdir } = await import('node:os')
+
+  const stateDir = mkdtempSync(path.join(tmpdir(), 'pi-notify-watch-test-'))
+  return {
+    STATE_FILE: path.join(stateDir, 'state.json'),
+    STATE_TMP_FILE: path.join(stateDir, 'state.json.tmp'),
+  }
+})
+
+afterAll(() => {
+  rmSync(dirname(STATE_FILE), { recursive: true, force: true })
+})
+
+import { STATE_FILE } from './consts.js'
+import { watchStore } from './watch-store.js'
+
+const DEBOUNCE_MS = 25
+
+function waitFor(cb: () => boolean, timeoutMs = 2000): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const start = Date.now()
+    const check = (): void => {
+      if (cb()) {
+        resolve()
+        return
+      }
+      if (Date.now() - start > timeoutMs) {
+        reject(new Error('waitFor timed out'))
+        return
+      }
+      setTimeout(check, 10)
+    }
+    check()
+  })
+}
+
+function writeState(data: string): void {
+  const tmp = `${STATE_FILE}.tmp`
+  writeFileSync(tmp, data, 'utf8')
+  renameSync(tmp, STATE_FILE)
+}
+
+describe('watchStore', () => {
+  it('fires once for a tmp+rename write', async () => {
+    const onChange = vi.fn()
+    const stop = watchStore(onChange, { debounceMs: DEBOUNCE_MS })
+    try {
+      writeState('{"version":2,"sessions":{}}')
+      await waitFor(() => onChange.mock.calls.length > 0)
+      await new Promise((r) => setTimeout(r, DEBOUNCE_MS * 3))
+      expect(onChange).toHaveBeenCalledTimes(1)
+    } finally {
+      stop()
+    }
+  })
+
+  it('collapses a burst of writes into one call', async () => {
+    const onChange = vi.fn()
+    const stop = watchStore(onChange, { debounceMs: DEBOUNCE_MS })
+    try {
+      writeState('a')
+      writeState('b')
+      await new Promise((r) => setTimeout(r, DEBOUNCE_MS / 2))
+      writeState('c')
+      await waitFor(() => onChange.mock.calls.length > 0)
+      await new Promise((r) => setTimeout(r, DEBOUNCE_MS * 3))
+      expect(onChange).toHaveBeenCalledTimes(1)
+    } finally {
+      stop()
+    }
+  })
+
+  it('ignores tmp and lock file writes', async () => {
+    const onChange = vi.fn()
+    const stop = watchStore(onChange, { debounceMs: DEBOUNCE_MS })
+    try {
+      writeFileSync(`${STATE_FILE}.tmp`, 'tmp', 'utf8')
+      writeFileSync(`${STATE_FILE}.lock`, 'lock', 'utf8')
+      await new Promise((r) => setTimeout(r, DEBOUNCE_MS * 5))
+      expect(onChange).not.toHaveBeenCalled()
+    } finally {
+      stop()
+      rmSync(`${STATE_FILE}.tmp`, { force: true })
+      rmSync(`${STATE_FILE}.lock`, { force: true })
+    }
+  })
+
+  it('stops events after dispose', async () => {
+    const onChange = vi.fn()
+    const stop = watchStore(onChange, { debounceMs: DEBOUNCE_MS })
+    stop()
+    writeState('after-dispose')
+    await new Promise((r) => setTimeout(r, DEBOUNCE_MS * 5))
+    expect(onChange).not.toHaveBeenCalled()
+  })
+
+  it('is idempotent when disposed twice', () => {
+    const stop = watchStore(() => {}, { debounceMs: DEBOUNCE_MS })
+    stop()
+    expect(() => {
+      stop()
+    }).not.toThrow()
+  })
+})

package/src/dashboard/watch-store.ts

@@ -0,0 +1,48 @@
+import { type FSWatcher, watch } from 'node:fs'
+import { basename, dirname } from 'node:path'
+
+import { STATE_FILE } from './consts.js'
+
+const DEFAULT_DEBOUNCE_MS = 150
+
+export function watchStore(
+  onChange: () => void,
+  opts?: { debounceMs?: number },
+): () => void {
+  const debounceMs = opts?.debounceMs ?? DEFAULT_DEBOUNCE_MS
+  const stateFileName = basename(STATE_FILE)
+
+  let timer: NodeJS.Timeout | null = null
+  let closed = false
+
+  let watcher: FSWatcher
+  try {
+    watcher = watch(dirname(STATE_FILE), (_event, filename) => {
+      if (filename !== null && filename !== stateFileName) return
+      if (timer !== null) clearTimeout(timer)
+      timer = setTimeout(() => {
+        timer = null
+        onChange()
+      }, debounceMs)
+      timer.unref()
+    })
+  } catch {
+    return () => {}
+  }
+
+  watcher.on('error', () => {
+    if (closed) return
+    closed = true
+    watcher.close()
+  })
+
+  return () => {
+    if (timer !== null) {
+      clearTimeout(timer)
+      timer = null
+    }
+    if (closed) return
+    closed = true
+    watcher.close()
+  }
+}