@raidou/pi-notify 0.3.0 → 0.4.0

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

@@ -0,0 +1,231 @@
+import { unlinkSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { getAgentDir } from '@earendil-works/pi-coding-agent'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { isProcessAlive, readSessions, updateState } from './state-store.js'
+
+describe('isProcessAlive', () => {
+  it('returns true for current process pid', () => {
+    expect(isProcessAlive(process.pid)).toBe(true)
+  })
+
+  it('returns false for non-existent pid', () => {
+    expect(isProcessAlive(999999)).toBe(false)
+  })
+
+  it('returns false for pid out of range', () => {
+    expect(isProcessAlive(2147483647)).toBe(false)
+  })
+
+  it('returns false for invalid pid', () => {
+    expect(isProcessAlive(0)).toBe(false)
+    expect(isProcessAlive(-1)).toBe(false)
+  })
+
+  it('handles ESRCH gracefully', () => {
+    const error = new Error('process not found') as Error & { code: string }
+    error.code = 'ESRCH'
+    vi.spyOn(process, 'kill').mockImplementation(() => {
+      throw error
+    })
+    try {
+      expect(isProcessAlive(12345)).toBe(false)
+    } finally {
+      vi.restoreAllMocks()
+    }
+  })
+
+  it('returns true for EPERM (process exists but no permission)', () => {
+    const error = new Error('permission denied') as Error & { code: string }
+    error.code = 'EPERM'
+    vi.spyOn(process, 'kill').mockImplementation(() => {
+      throw error
+    })
+    try {
+      expect(isProcessAlive(1)).toBe(true)
+    } finally {
+      vi.restoreAllMocks()
+    }
+  })
+})
+
+describe('readSessions', () => {
+  const testDir = join(getAgentDir(), 'pi-notify-test')
+  const testLockFile = join(testDir, 'state.json.lock')
+
+  beforeEach(async () => {
+    try {
+      unlinkSync(testLockFile)
+    } catch {
+      // ignore
+    }
+    await updateState(() => ({ version: 1, sessions: {} }))
+  })
+
+  afterEach(() => {
+    try {
+      unlinkSync(testLockFile)
+    } catch {
+      // ignore
+    }
+  })
+
+  it('keeps alive sessions and removes dead ones', async () => {
+    const aliveSessionId = `alive-${Date.now()}`
+    const deadSessionId = `dead-${Date.now()}`
+    const deadPid = 999999
+    const aliveKey = String(process.pid)
+    const deadKey = String(deadPid)
+
+    await updateState((state) => ({
+      ...state,
+      sessions: {
+        ...state.sessions,
+        [aliveKey]: {
+          pid: process.pid,
+          sessionId: aliveSessionId,
+          cwd: process.cwd(),
+          projectName: 'alive-project',
+          startedAt: Date.now(),
+          state: 'running',
+          stateChangedAt: Date.now(),
+        },
+        [deadKey]: {
+          pid: deadPid,
+          sessionId: deadSessionId,
+          cwd: process.cwd(),
+          projectName: 'dead-project',
+          startedAt: Date.now(),
+          state: 'running',
+          stateChangedAt: Date.now(),
+        },
+      },
+    }))
+
+    const alive = await readSessions()
+
+    expect(alive.some((s) => s.sessionId === aliveSessionId)).toBe(true)
+    expect(alive.every((s) => s.sessionId !== deadSessionId)).toBe(true)
+
+    const state = await import('./state-store.js').then((m) => m.readState())
+    expect(aliveKey in state.sessions).toBe(true)
+    expect(deadKey in state.sessions).toBe(false)
+  })
+
+  it('returns all sessions when none are dead', async () => {
+    const sessionId = `all-alive-${Date.now()}`
+
+    await updateState((state) => ({
+      ...state,
+      sessions: {
+        ...state.sessions,
+        [sessionId]: {
+          pid: process.pid,
+          sessionId,
+          cwd: process.cwd(),
+          projectName: 'test-project',
+          startedAt: Date.now(),
+          state: 'running',
+          stateChangedAt: Date.now(),
+        },
+      },
+    }))
+
+    const alive = await readSessions()
+
+    expect(alive.some((s) => s.sessionId === sessionId)).toBe(true)
+  })
+})
+
+describe('updateState', () => {
+  const testDir = join(getAgentDir(), 'pi-notify-test')
+  const testLockFile = join(testDir, 'state.json.lock')
+
+  beforeEach(() => {
+    try {
+      unlinkSync(testLockFile)
+    } catch {
+      // ignore
+    }
+  })
+
+  afterEach(() => {
+    try {
+      unlinkSync(testLockFile)
+    } catch {
+      // ignore
+    }
+  })
+
+  it('writes state and preserves other fields', async () => {
+    await updateState((state) => ({
+      ...state,
+      sessions: {
+        ...state.sessions,
+        'test-session-1': {
+          pid: process.pid,
+          sessionId: 'test-session-1',
+          cwd: process.cwd(),
+          projectName: 'test-project',
+          startedAt: Date.now(),
+          state: 'running',
+          stateChangedAt: Date.now(),
+        },
+      },
+    }))
+  })
+
+  it('handles concurrent updates correctly', async () => {
+    const sessionId = `test-concurrent-${Date.now()}`
+
+    await updateState((state) => ({
+      ...state,
+      sessions: {
+        ...state.sessions,
+        [sessionId]: {
+          pid: process.pid,
+          sessionId,
+          cwd: process.cwd(),
+          projectName: 'concurrent-test',
+          startedAt: Date.now(),
+          state: 'running',
+          stateChangedAt: Date.now(),
+        },
+      },
+    }))
+
+    await Promise.all([
+      updateState((state) => ({
+        ...state,
+        sessions: {
+          ...state.sessions,
+          [sessionId]: state.sessions[sessionId]
+            ? {
+                ...state.sessions[sessionId],
+                stateChangedAt: Date.now(),
+              }
+            : undefined,
+        },
+      })),
+      updateState((state) => ({
+        ...state,
+        sessions: {
+          ...state.sessions,
+          [sessionId]: state.sessions[sessionId]
+            ? {
+                ...state.sessions[sessionId],
+                stateChangedAt: Date.now() + 1,
+              }
+            : undefined,
+        },
+      })),
+    ])
+
+    await updateState((state) => {
+      expect(state.sessions[sessionId]).toBeDefined()
+      return state
+    })
+  })
+})

package/src/dashboard/state-store.ts

@@ -3,23 +3,70 @@ import {
   mkdirSync,
   readFileSync,
   renameSync,
-  rmdirSync,
   writeFileSync,
 } from 'node:fs'
 import { dirname, join } from 'node:path'
 
 import { getAgentDir } from '@earendil-works/pi-coding-agent'
+import lockfile from 'proper-lockfile'
+
+const ESRCH = 'ESRCH'
+const EPERM = 'EPERM'
+
+export function isProcessAlive(pid: number): boolean {
+  if (pid <= 0) return false
+  if (pid === process.pid) return true
+
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (err: unknown) {
+    if (err instanceof Error && 'code' in err) {
+      const code = (err as { code: string }).code
+      if (code === EPERM) return true
+      if (code === ESRCH) return false
+    }
+    return false
+  }
+}
+
+export async function readSessions(): Promise<SessionRecord[]> {
+  const state = readState()
+  const deadIds: string[] = []
+  const alive: SessionRecord[] = []
+
+  for (const session of Object.values(state.sessions)) {
+    if (!session) continue
+    if (isProcessAlive(session.pid)) {
+      alive.push(session)
+    } else {
+      deadIds.push(String(session.pid))
+    }
+  }
+
+  if (deadIds.length === 0) return alive
+
+  await updateState((s) => {
+    const sessions: typeof s.sessions = {}
+    for (const key of Object.keys(s.sessions)) {
+      if (!deadIds.includes(key)) {
+        sessions[key] = s.sessions[key]
+      }
+    }
+    return { ...s, sessions }
+  })
+
+  return alive
+}
 
 export interface SessionRecord {
   pid: number
+  sessionId: string
   cwd: string
   projectName: string
   startedAt: number
-  lastHeartbeatAt: number
   state: 'running' | 'idle'
   stateChangedAt: number
-  model: string | undefined
-  lastEvent: { type: string; summary: string; at: number } | undefined
 }
 
 export interface DashboardState {
@@ -28,10 +75,8 @@ export interface DashboardState {
 }
 
 const STATE_FILE = join(getAgentDir(), 'pi-notify', 'state.json')
-const LOCK_FILE = `${STATE_FILE}.lock`
-const LOCK_RETRY_DELAY_MS = 50
+const LOCK_RETRY_INTERVAL_MS = 50
 const LOCK_MAX_RETRIES = 20
-const STALE_THRESHOLD_MS = 30000
 
 function ensureStateDir(): void {
   const dir = dirname(STATE_FILE)
@@ -40,74 +85,17 @@ function ensureStateDir(): void {
   }
 }
 
-async function acquireLock(retries = LOCK_MAX_RETRIES): Promise<boolean> {
-  for (let i = 0; i < retries; i++) {
-    try {
-      mkdirSync(LOCK_FILE, { recursive: false })
-      return true
-    } catch (e) {
-      const code =
-        e instanceof Error && 'code' in e
-          ? (e as NodeJS.ErrnoException).code
-          : undefined
-      if (code === 'EEXIST') {
-        await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_DELAY_MS))
-        continue
-      }
-      if (code === 'ENOENT') {
-        ensureStateDir()
-        await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_DELAY_MS))
-        continue
-      }
-      throw e
-    }
-  }
-  return false
-}
-
-function releaseLock(): void {
-  try {
-    rmdirSync(LOCK_FILE)
-  } catch {
-    // Lock file may not exist
-  }
-}
-
-function isPidAlive(pid: number): boolean {
-  try {
-    process.kill(pid, 0)
-    return true
-  } catch {
-    return false
-  }
-}
-
-export function readState(options?: { filterStale?: boolean }): DashboardState {
-  ensureStateDir()
+export function readState(): DashboardState {
   if (!existsSync(STATE_FILE)) {
     return { version: 1, sessions: {} }
   }
 
-  let state: DashboardState
   try {
     const data = readFileSync(STATE_FILE, 'utf8')
-    state = JSON.parse(data) as DashboardState
+    return JSON.parse(data) as DashboardState
   } catch {
     return { version: 1, sessions: {} }
   }
-
-  if (options?.filterStale === false) {
-    return state
-  }
-
-  return cleanupStale(state).cleaned
-}
-
-export function readSessions(): SessionRecord[] {
-  const state = readState()
-  return Object.values(state.sessions).filter(
-    (s): s is SessionRecord => s !== undefined,
-  )
 }
 
 export async function updateState(
@@ -115,10 +103,15 @@ export async function updateState(
 ): Promise<void> {
   ensureStateDir()
 
-  const locked = await acquireLock()
-  if (!locked) {
-    throw new Error('Failed to acquire lock for state update')
-  }
+  const release = await lockfile.lock(STATE_FILE, {
+    realpath: false,
+    stale: 30000,
+    retries: {
+      minTimeout: LOCK_RETRY_INTERVAL_MS,
+      maxTimeout: LOCK_RETRY_INTERVAL_MS,
+      retries: LOCK_MAX_RETRIES,
+    },
+  })
 
   try {
     const state = readState()
@@ -127,30 +120,6 @@ export async function updateState(
     writeFileSync(tmpFile, JSON.stringify(newState, null, 2), 'utf8')
     renameSync(tmpFile, STATE_FILE)
   } finally {
-    releaseLock()
+    await release()
   }
 }
-
-function cleanupStale(
-  state: DashboardState,
-  staleThresholdMs = STALE_THRESHOLD_MS,
-): { cleaned: DashboardState; removedIds: string[] } {
-  const now = Date.now()
-  const removedIds: string[] = []
-  const sessions: Record<string, SessionRecord | undefined> = {}
-
-  for (const [id, record] of Object.entries(state.sessions)) {
-    if (!record) continue
-    const heartbeatAge = now - record.lastHeartbeatAt
-    const isStale = heartbeatAge > staleThresholdMs
-    const isPidAliveValue = isPidAlive(record.pid)
-
-    if (!isStale && isPidAliveValue) {
-      sessions[id] = record
-    } else {
-      removedIds.push(id)
-    }
-  }
-
-  return { cleaned: { version: 1, sessions }, removedIds }
-}

package/src/dashboard/ui.ts

@@ -12,23 +12,14 @@ import {
 import type { SessionRecord } from './state-store.js'
 
 const COLUMNS = [
+  { name: 'SESSION_ID', width: 8 },
   { name: 'PID', width: 8 },
   { name: 'STATE', width: 8 },
   { name: 'PROJECT', width: 15 },
   { name: 'UPTIME', width: 10 },
-  { name: 'MODEL', width: 20 },
-  { name: 'LAST EVENT', width: undefined },
 ] as const
 
-const [PID_COL, STATE_COL, PROJECT_COL, UPTIME_COL, MODEL_COL] = COLUMNS
-
-const FIXED_COLUMNS_WIDTH =
-  PID_COL.width +
-  STATE_COL.width +
-  PROJECT_COL.width +
-  UPTIME_COL.width +
-  MODEL_COL.width
-const GAPS_WIDTH = (COLUMNS.length - 1) * 2
+const [SESSION_ID_COL, PID_COL, STATE_COL, PROJECT_COL, UPTIME_COL] = COLUMNS
 
 const MAX_ROWS = Math.max(1, (process.stdout.rows || 20) - 6)
 
@@ -38,6 +29,7 @@ export interface DashboardProps {
   initialSessions: SessionRecord[]
   onRefresh: () => Promise<SessionRecord[]>
   onClose: () => void
+  onDispose?: () => void
 }
 
 function formatUptime(startedAt: number): string {
@@ -62,11 +54,27 @@ export function createDashboard(props: DashboardProps) {
   let scrollOffset = 0
   let cachedWidth: number | null = null
   let cachedLines: string[] = []
+  let disposed = false
 
   const dashboardContainer = new Container()
 
-  function updateChildren(width: number): void {
-    const remainingWidth = Math.max(1, width - FIXED_COLUMNS_WIDTH - GAPS_WIDTH)
+  function refresh(): void {
+    props
+      .onRefresh()
+      .then((newSessions) => {
+        sessions = [...newSessions]
+        scrollOffset = 0
+        cachedWidth = null
+        props.tui.requestRender()
+      })
+      .catch(() => {})
+  }
+
+  const timer = setInterval(() => {
+    if (!disposed) refresh()
+  }, 1000)
+
+  function updateChildren(): void {
     const { theme } = props
 
     const stats = sessions.reduce(
@@ -77,9 +85,9 @@ export function createDashboard(props: DashboardProps) {
       { running: 0, idle: 0 },
     )
 
-    const headerLine = COLUMNS.map((col) =>
-      col.width === undefined ? col.name : col.name.padEnd(col.width),
-    ).join('  ')
+    const headerLine = COLUMNS.map((col) => col.name.padEnd(col.width)).join(
+      '  ',
+    )
 
     dashboardContainer.clear()
     dashboardContainer.addChild(
@@ -106,6 +114,10 @@ export function createDashboard(props: DashboardProps) {
     )) {
       const stateColor = session.state === 'running' ? 'success' : 'muted'
       const line = [
+        theme.fg(
+          'dim',
+          session.sessionId.slice(-6).padEnd(SESSION_ID_COL.width),
+        ),
         theme.fg('dim', String(session.pid).padEnd(PID_COL.width)),
         theme.fg(stateColor, session.state.padEnd(STATE_COL.width)),
         theme.fg(
@@ -116,21 +128,6 @@ export function createDashboard(props: DashboardProps) {
           'dim',
           formatUptime(session.startedAt).padEnd(UPTIME_COL.width),
         ),
-        theme.fg(
-          'muted',
-          session.model
-            ? truncateToWidth(session.model, MODEL_COL.width, '…', true)
-            : '',
-        ),
-        theme.fg(
-          'dim',
-          session.lastEvent
-            ? truncateToWidth(
-                `${session.lastEvent.type}:${session.lastEvent.summary}`,
-                remainingWidth,
-              )
-            : '',
-        ),
       ].join('  ')
       dashboardContainer.addChild(new Text(line, 0, 0))
     }
@@ -144,7 +141,7 @@ export function createDashboard(props: DashboardProps) {
   const component = {
     render(width: number): string[] {
       if (cachedWidth !== width) {
-        updateChildren(width)
+        updateChildren()
         cachedLines = dashboardContainer.render(width)
         cachedWidth = width
       }
@@ -153,15 +150,7 @@ export function createDashboard(props: DashboardProps) {
 
     handleInput(data: string): void {
       if (matchesKey(data, 'r')) {
-        props
-          .onRefresh()
-          .then((newSessions) => {
-            sessions = [...newSessions]
-            scrollOffset = 0
-            cachedWidth = null
-            props.tui.requestRender()
-          })
-          .catch(() => {})
+        refresh()
         return
       }
 
@@ -192,6 +181,12 @@ export function createDashboard(props: DashboardProps) {
       cachedWidth = null
       dashboardContainer.invalidate()
     },
+
+    dispose(): void {
+      disposed = true
+      clearInterval(timer)
+      props.onDispose?.()
+    },
   }
 
   return component

package/src/events.test.ts

@@ -0,0 +1,115 @@
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+import { describe, expect, it } from 'vitest'
+
+import type { ResolvedNotifyConfig } from './config.js'
+import { EventsNotifier } from './events.js'
+
+type EventsListener = (payload: unknown) => void
+
+interface FakePi {
+  eventListeners: Map<string, Set<EventsListener>>
+  listeners: Map<string, Set<(...args: unknown[]) => void>>
+  events: { on(event: string, listener: EventsListener): () => void }
+  on(event: string, listener: (...args: unknown[]) => void): void
+}
+
+function makeFakePi(): FakePi {
+  const eventListeners = new Map<string, Set<EventsListener>>()
+  const listeners = new Map<string, Set<(...args: unknown[]) => void>>()
+  return {
+    eventListeners,
+    listeners,
+    events: {
+      on(event, listener) {
+        let set = eventListeners.get(event)
+        if (!set) {
+          set = new Set()
+          eventListeners.set(event, set)
+        }
+        set.add(listener)
+        return () => {
+          set.delete(listener)
+        }
+      },
+    },
+    on(event, listener) {
+      let set = listeners.get(event)
+      if (!set) {
+        set = new Set()
+        listeners.set(event, set)
+      }
+      set.add(listener)
+    },
+  }
+}
+
+function makeConfig(
+  events: ResolvedNotifyConfig['events'],
+): ResolvedNotifyConfig {
+  return {
+    enabled: true,
+    notifyTools: new Set<string>(),
+    events,
+    finished: true,
+    finishedThrottleMs: 0,
+    onlyNotifyWhenUnfocused: true,
+    unfocusedActivityThresholdMs: 0,
+    tmuxSymbol: '',
+  }
+}
+
+function emitEvent(pi: FakePi, event: string, payload?: unknown): void {
+  const set = pi.eventListeners.get(event)
+  if (!set) return
+  for (const listener of [...set]) listener(payload)
+}
+
+describe('EventsNotifier', () => {
+  it('notifies with the configured message when a custom event fires', () => {
+    const pi = makeFakePi()
+    const notifier = new EventsNotifier(
+      pi as unknown as ExtensionAPI,
+      makeConfig({
+        'my:custom:event': 'Custom event triggered',
+      }),
+    )
+    const bodies: string[] = []
+    notifier.register((body) => bodies.push(body))
+
+    emitEvent(pi, 'my:custom:event')
+
+    expect(bodies).toEqual(['Custom event triggered'])
+  })
+
+  it('does not notify for events disabled with false', () => {
+    const pi = makeFakePi()
+    const notifier = new EventsNotifier(
+      pi as unknown as ExtensionAPI,
+      makeConfig({
+        'my:custom:event': false,
+      }),
+    )
+    const bodies: string[] = []
+    notifier.register((body) => bodies.push(body))
+
+    emitEvent(pi, 'my:custom:event')
+
+    expect(bodies).toEqual([])
+  })
+
+  it('does not notify for events disabled with an empty string (backward compatibility)', () => {
+    const pi = makeFakePi()
+    const notifier = new EventsNotifier(
+      pi as unknown as ExtensionAPI,
+      makeConfig({
+        'my:custom:event': '',
+      }),
+    )
+    const bodies: string[] = []
+    notifier.register((body) => bodies.push(body))
+
+    emitEvent(pi, 'my:custom:event')
+
+    expect(bodies).toEqual([])
+  })
+})