@raidou/pi-notify 0.4.0 → 0.5.1

package/README.md

@@ -66,7 +66,21 @@ function endBackgroundJob(jobId: string): void {
 
 Events are automatically cleaned up on `session_shutdown`.
 
-## Testing
+## Commands
+
+### `/notify-dashboard`
+
+Open a full-screen TUI dashboard listing all pi sessions, with summary counts (total, running, idle) and an auto-refresh every second.
+
+Columns: `SESSION_ID` (last 6 chars), `PID`, `STATE` (running/idle, color-coded), `PROJECT`, `UPTIME`.
+
+Keybindings:
+
+- `↑` / `↓` or `j` / `k` — scroll
+- `r` — refresh
+- `q` or `esc` — close
+
+### `/notify-test`
 
 Run `/notify-test` inside pi to fire a test notification.
 Pass a string argument (e.g., `/notify-test hello`) to override the body.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raidou/pi-notify",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Desktop notification extension for the pi coding agent.",
   "keywords": [
     "pi",
@@ -36,6 +36,7 @@
   "dependencies": {
     "@earendil-works/pi-tui": "0.80.7",
     "emittery": "^2.0.0",
+    "lodash-es": "^4.18.1",
     "node-notifier": "^10.0.1",
     "proper-lockfile": "^4.1.2"
   },
@@ -44,6 +45,7 @@
   },
   "devDependencies": {
     "@raidou/eslint-config-base": "^4.4.3",
+    "@types/lodash-es": "^4.17.12",
     "@types/node": "^22.0.0",
     "@types/proper-lockfile": "^4.1.4",
     "eslint": "^10.7.0",

package/src/config.ts

@@ -13,7 +13,6 @@ interface NotifyConfig {
   readonly notifyTools?: readonly string[]
   readonly events?: NotifyEventsConfig
   readonly finished?: boolean
-  readonly finishedThrottleSecs?: number
   readonly onlyNotifyWhenUnfocused?: boolean
   readonly unfocusedActivityThresholdSecs?: number
   readonly tmuxSymbol?: string
@@ -24,7 +23,6 @@ export interface ResolvedNotifyConfig {
   readonly notifyTools: ReadonlySet<string>
   readonly events: NotifyEventsConfig
   readonly finished: boolean
-  readonly finishedThrottleMs: number
   readonly onlyNotifyWhenUnfocused: boolean
   readonly unfocusedActivityThresholdMs: number
   readonly tmuxSymbol: string
@@ -67,7 +65,6 @@ export function loadConfig(): ResolvedNotifyConfig {
     notifyTools: new Set(cfg.notifyTools ?? DEFAULT_NOTIFY_TOOLS),
     events,
     finished: cfg.finished ?? true,
-    finishedThrottleMs: Math.max(0, (cfg.finishedThrottleSecs ?? 0) * 1000),
     onlyNotifyWhenUnfocused: cfg.onlyNotifyWhenUnfocused ?? true,
     unfocusedActivityThresholdMs: Math.max(
       0,

package/src/dashboard/command.ts

@@ -1,6 +1,6 @@
 import { Registrar } from '../shared/registrar.js'
 import { readSessions } from './state-store.js'
-import { createDashboard } from './ui.js'
+import { Dashboard } from './ui/dashboard.js'
 
 export class DashboardCommand extends Registrar {
   protected override setup(): void {
@@ -11,7 +11,7 @@ export class DashboardCommand extends Registrar {
 
         await ctx.ui.custom<unknown>((tui, theme, _keybindings, done) => {
           let closed = false
-          const dashboard = createDashboard({
+          const dashboard = new Dashboard({
             tui,
             theme,
             initialSessions,
@@ -24,12 +24,7 @@ export class DashboardCommand extends Registrar {
             },
           })
 
-          return {
-            render: dashboard.render.bind(dashboard),
-            handleInput: dashboard.handleInput.bind(dashboard),
-            invalidate: dashboard.invalidate.bind(dashboard),
-            dispose: dashboard.dispose.bind(dashboard),
-          }
+          return dashboard
         })
 
         return undefined

package/src/dashboard/consts.ts

@@ -0,0 +1,6 @@
+import { join } from 'node:path'
+
+import { getAgentDir } from '@earendil-works/pi-coding-agent'
+
+export const STATE_FILE = join(getAgentDir(), 'pi-notify', 'state.json')
+export const STATE_TMP_FILE = `${STATE_FILE}.tmp`

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

@@ -1,11 +1,33 @@
-import { unlinkSync } from 'node:fs'
-import { join } from 'node:path'
+import { rmSync, unlinkSync } from 'node:fs'
+import { dirname } from 'node:path'
 
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
-import { getAgentDir } from '@earendil-works/pi-coding-agent'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  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-test-'))
+  return {
+    STATE_FILE: path.join(stateDir, 'state.json'),
+    STATE_TMP_FILE: path.join(stateDir, 'state.json.tmp'),
+  }
+})
 
-import type { StateTracker } from '../state-tracker.js'
+import type { ResolvedNotifyConfig } from '../config.js'
+import type { JobTracker } from '../jobs.js'
+import { StateTracker } from '../state-tracker.js'
+import { STATE_FILE } from './consts.js'
 import { SessionStore } from './session-store.js'
 import { readState, updateState } from './state-store.js'
 
@@ -113,8 +135,12 @@ const META = {
   projectName: 'test-project',
 }
 
+afterAll(() => {
+  rmSync(dirname(STATE_FILE), { recursive: true, force: true })
+})
+
 describe('SessionStore', () => {
-  const testLockFile = join(getAgentDir(), 'pi-notify-test', 'state.json.lock')
+  const testLockFile = `${STATE_FILE}.lock`
 
   beforeEach(async () => {
     try {
@@ -122,7 +148,7 @@ describe('SessionStore', () => {
     } catch {
       // ignore
     }
-    await updateState(() => ({ version: 1, sessions: {} }))
+    await updateState(() => ({ version: 2, sessions: {} }))
   })
 
   afterEach(() => {
@@ -145,9 +171,11 @@ describe('SessionStore', () => {
     )
     store.register(vi.fn())
 
-    expect(emitSpy).toHaveBeenCalledTimes(2)
+    expect(emitSpy).toHaveBeenCalledTimes(4)
     expect(emitSpy).toHaveBeenCalledWith('running', expect.any(Function))
     expect(emitSpy).toHaveBeenCalledWith('idle', expect.any(Function))
+    expect(emitSpy).toHaveBeenCalledWith('tool', expect.any(Function))
+    expect(emitSpy).toHaveBeenCalledWith('event', expect.any(Function))
     expect(piOnSpy).toHaveBeenCalledWith('session_start', expect.any(Function))
   })
 
@@ -287,4 +315,124 @@ describe('SessionStore', () => {
       store.stop()
     }).not.toThrow()
   })
+
+  it('clears runningSince on idle transition without accumulating duration', async () => {
+    await updateState(() => ({ version: 2, sessions: {} }))
+    const now = Date.now()
+    const nowSpy = vi.spyOn(Date, 'now').mockReturnValue(now)
+    const pi = makeFakePi()
+    const stateTracker = makeFakeStateTracker()
+    const store = new SessionStore(
+      pi as unknown as ExtensionAPI,
+      stateTracker as unknown as StateTracker,
+    )
+    store.register(() => {})
+
+    pi.emitSessionStart({
+      cwd: META.cwd,
+      sessionManager: { getSessionId: () => SESSION_ID },
+    })
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    stateTracker.events.emit('running')
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    nowSpy.mockReturnValue(now + 5000)
+    stateTracker.events.emit('idle')
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    const record = readState().sessions[String(process.pid)]
+    expect(record).not.toHaveProperty('runningTime')
+    expect(record?.startedRunningAt).toBeUndefined()
+    nowSpy.mockRestore()
+  })
+
+  it('does not update state on tool emission outside notifyTools', async () => {
+    await updateState(() => ({ version: 2, sessions: {} }))
+    const pi = makeFakePi()
+    const jobTracker = {
+      hasActiveJobs: false,
+      onEnd: () => () => {},
+    } as unknown as JobTracker
+    const tracker = new StateTracker(
+      pi as unknown as ExtensionAPI,
+      jobTracker,
+      {
+        notifyTools: new Set(['read']),
+        events: {},
+      } as unknown as ResolvedNotifyConfig,
+    )
+    tracker.register(() => {})
+
+    const store = new SessionStore(pi as unknown as ExtensionAPI, tracker)
+    store.register(() => {})
+
+    pi.emitSessionStart({
+      cwd: META.cwd,
+      sessionManager: { getSessionId: () => SESSION_ID },
+    })
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    expect(readState().sessions[String(process.pid)]?.state).toBe('idle')
+
+    pi.emit('tool_call', {
+      type: 'tool_call',
+      toolCallId: 't1',
+      toolName: 'grep',
+    })
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    const record = readState().sessions[String(process.pid)]
+    expect(record?.state).toBe('idle')
+  })
+
+  it('updates state immediately on event emission', async () => {
+    await updateState(() => ({ version: 2, sessions: {} }))
+    const pi = makeFakePi()
+    const jobTracker = {
+      hasActiveJobs: false,
+      onEnd: () => () => {},
+    } as unknown as JobTracker
+    const tracker = new StateTracker(
+      pi as unknown as ExtensionAPI,
+      jobTracker,
+      {
+        notifyTools: new Set(['bash']),
+        events: { 'permissions:ui_prompt': 'msg' },
+      } as unknown as ResolvedNotifyConfig,
+    )
+    tracker.register(() => {})
+
+    const store = new SessionStore(pi as unknown as ExtensionAPI, tracker)
+    store.register(() => {})
+
+    pi.emitSessionStart({
+      cwd: META.cwd,
+      sessionManager: { getSessionId: () => SESSION_ID },
+    })
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    pi.emitEvent('permissions:ui_prompt', {})
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    const record = readState().sessions[String(process.pid)]
+    expect(record?.state).toBe('event:permissions:ui_prompt')
+  })
+
+  it('ignores tool and event emissions before session_start', async () => {
+    await updateState(() => ({ version: 2, sessions: {} }))
+    const pi = makeFakePi()
+    const stateTracker = makeFakeStateTracker()
+    const store = new SessionStore(
+      pi as unknown as ExtensionAPI,
+      stateTracker as unknown as StateTracker,
+    )
+    store.register(() => {})
+
+    stateTracker.events.emit('tool', 'grep')
+    stateTracker.events.emit('event', 'permissions:ui_prompt')
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    expect(readState().sessions).toEqual({})
+  })
 })

package/src/dashboard/session-store.ts

@@ -5,13 +5,9 @@ import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 
 import { Registrar } from '../shared/registrar.js'
 import type { StateTracker } from '../state-tracker.js'
-import type { SessionRecord } from './state-store.js'
+import type { SessionRecord, SessionState } from './state-store.js'
 import { updateState } from './state-store.js'
 
-export interface SessionUpdate {
-  state: 'running' | 'idle'
-}
-
 export class SessionStore extends Registrar {
   private readonly stateTracker: StateTracker
   private sessionId: string | undefined = undefined
@@ -23,7 +19,7 @@ export class SessionStore extends Registrar {
     this.stateTracker = stateTracker
   }
 
-  private async saveSession(updates: SessionUpdate): Promise<void> {
+  private async saveSession(nextState: SessionState): Promise<void> {
     if (this.sessionId === undefined || this.meta === undefined) return
 
     const now = Date.now()
@@ -33,7 +29,9 @@ export class SessionStore extends Registrar {
 
     await updateState((state) => {
       const existing = state.sessions[id]
-      const stateChanged = updates.state !== existing?.state
+      const isRunning = nextState === 'running'
+
+      const startRunningAt = isRunning ? now : undefined
 
       const record: SessionRecord = {
         pid: meta.pid,
@@ -41,8 +39,8 @@ export class SessionStore extends Registrar {
         cwd: meta.cwd,
         projectName: meta.projectName,
         startedAt: existing?.startedAt ?? now,
-        state: updates.state,
-        stateChangedAt: stateChanged ? now : existing.stateChangedAt,
+        state: nextState,
+        startedRunningAt: startRunningAt,
       }
 
       return {
@@ -68,15 +66,21 @@ export class SessionStore extends Registrar {
       const sessionId = ctx.sessionManager.getSessionId()
       this.sessionId = sessionId
       this.meta = meta
-      void this.saveSession({ state: 'idle' })
+      void this.saveSession('idle')
     })
 
     this.unsubscribes.push(
       this.stateTracker.events.on('running', async () => {
-        await this.saveSession({ state: 'running' })
+        await this.saveSession('running')
       }),
       this.stateTracker.events.on('idle', async () => {
-        await this.saveSession({ state: 'idle' })
+        await this.saveSession('idle')
+      }),
+      this.stateTracker.events.on('tool', async ({ data }) => {
+        await this.saveSession(`tool_call:${data}`)
+      }),
+      this.stateTracker.events.on('event', async ({ data }) => {
+        await this.saveSession(`event:${data}`)
       }),
     )
   }

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

@@ -1,10 +1,89 @@
-import { unlinkSync } from 'node:fs'
-import { join } from 'node:path'
+import { rmSync, unlinkSync, writeFileSync } from 'node:fs'
+import { dirname } from 'node:path'
 
-import { getAgentDir } from '@earendil-works/pi-coding-agent'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  vi,
+} from 'vitest'
 
-import { isProcessAlive, readSessions, updateState } from './state-store.js'
+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-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 {
+  isProcessAlive,
+  readSessions,
+  readState,
+  updateState,
+} from './state-store.js'
+
+describe('readState', () => {
+  const testLockFile = `${STATE_FILE}.lock`
+
+  afterEach(() => {
+    try {
+      unlinkSync(testLockFile)
+      unlinkSync(STATE_FILE)
+    } catch {
+      // ignore
+    }
+  })
+
+  it('writes state with version 2', async () => {
+    await updateState((state) => ({ ...state, sessions: {} }))
+    expect(readState().version).toBe(2)
+  })
+
+  it('reads v1 records as-is with absent v2 fields', () => {
+    const record = {
+      pid: process.pid,
+      sessionId: 'v1-session',
+      cwd: process.cwd(),
+      projectName: 'v1-project',
+      startedAt: Date.now(),
+      state: 'idle',
+    }
+    writeFileSync(
+      STATE_FILE,
+      JSON.stringify({
+        version: 1,
+        sessions: { [String(process.pid)]: record },
+      }),
+      'utf8',
+    )
+
+    const state = readState()
+    expect(state.version).toBe(2)
+    expect(state.sessions[String(process.pid)]).toEqual(record)
+  })
+
+  it('drops malformed session records instead of crashing', () => {
+    writeFileSync(
+      STATE_FILE,
+      JSON.stringify({ version: 2, sessions: { x: null } }),
+      'utf8',
+    )
+    expect(readState().sessions).toEqual({ x: undefined })
+  })
+})
 
 describe('isProcessAlive', () => {
   it('returns true for current process pid', () => {
@@ -52,8 +131,7 @@ describe('isProcessAlive', () => {
 })
 
 describe('readSessions', () => {
-  const testDir = join(getAgentDir(), 'pi-notify-test')
-  const testLockFile = join(testDir, 'state.json.lock')
+  const testLockFile = `${STATE_FILE}.lock`
 
   beforeEach(async () => {
     try {
@@ -61,7 +139,7 @@ describe('readSessions', () => {
     } catch {
       // ignore
     }
-    await updateState(() => ({ version: 1, sessions: {} }))
+    await updateState(() => ({ version: 2, sessions: {} }))
   })
 
   afterEach(() => {
@@ -90,7 +168,6 @@ describe('readSessions', () => {
           projectName: 'alive-project',
           startedAt: Date.now(),
           state: 'running',
-          stateChangedAt: Date.now(),
         },
         [deadKey]: {
           pid: deadPid,
@@ -99,7 +176,6 @@ describe('readSessions', () => {
           projectName: 'dead-project',
           startedAt: Date.now(),
           state: 'running',
-          stateChangedAt: Date.now(),
         },
       },
     }))
@@ -128,7 +204,6 @@ describe('readSessions', () => {
           projectName: 'test-project',
           startedAt: Date.now(),
           state: 'running',
-          stateChangedAt: Date.now(),
         },
       },
     }))
@@ -140,8 +215,7 @@ describe('readSessions', () => {
 })
 
 describe('updateState', () => {
-  const testDir = join(getAgentDir(), 'pi-notify-test')
-  const testLockFile = join(testDir, 'state.json.lock')
+  const testLockFile = `${STATE_FILE}.lock`
 
   beforeEach(() => {
     try {
@@ -171,7 +245,6 @@ describe('updateState', () => {
           projectName: 'test-project',
           startedAt: Date.now(),
           state: 'running',
-          stateChangedAt: Date.now(),
         },
       },
     }))
@@ -191,7 +264,6 @@ describe('updateState', () => {
           projectName: 'concurrent-test',
           startedAt: Date.now(),
           state: 'running',
-          stateChangedAt: Date.now(),
         },
       },
     }))
@@ -204,7 +276,7 @@ describe('updateState', () => {
           [sessionId]: state.sessions[sessionId]
             ? {
                 ...state.sessions[sessionId],
-                stateChangedAt: Date.now(),
+                startedAt: Date.now(),
               }
             : undefined,
         },
@@ -216,7 +288,7 @@ describe('updateState', () => {
           [sessionId]: state.sessions[sessionId]
             ? {
                 ...state.sessions[sessionId],
-                stateChangedAt: Date.now() + 1,
+                startedAt: Date.now() + 1,
               }
             : undefined,
         },