@raidou/pi-notify 0.3.1 → 0.4.0

package/README.md

@@ -10,11 +10,33 @@ A notification extension for the [pi](https://github.com/earendil-works/pi-codin
 pi install npm:@raidou/pi-notify
 ```
 
-Or, for local development, add the repo path to your `~/.pi/agent/settings.json`:
+Or, for local development
+
+```bash
+cd path/to/pi-notify
+pi install .
+```
+
+## Configuration
+
+All options live under the `piNotify` key in `~/.pi/agent/settings.json`. Everything is optional.
 
 ```jsonc
 {
-  "extensions": ["/absolute/path/to/pi-notify"],
+  "piNotify": {
+    "enabled": true, // master on/off switch (default: true)
+    "notifyTools": ["ask_user", "ask_user_question"], // tools that trigger "Tool call" notifications
+    "tmuxSymbol": "🔔", // symbol appended to tmux window title (empty string to disable)
+    "finished": true, // enable/disable "Idle" notification
+    "events": {
+      "permissions:ui_prompt": "Permission prompt", // custom event channel -> notification message
+      "my:custom:event": "Custom event triggered", // add your own custom events
+      "other:event": false, // set to false to disable a specific event
+    },
+    "finishedThrottleSecs": 0, // 0 = always notify; >0 = skip finished toasts for runs shorter than N seconds
+    "onlyNotifyWhenUnfocused": true, // only notify when user has been inactive
+    "unfocusedActivityThresholdSecs": 30, // seconds of inactivity before considering user "unfocused"
+  },
 }
 ```
 
@@ -44,42 +66,6 @@ function endBackgroundJob(jobId: string): void {
 
 Events are automatically cleaned up on `session_shutdown`.
 
-## Configuration
-
-All options live under the `piNotify` key in `~/.pi/agent/settings.json`. Everything is optional.
-
-```jsonc
-{
-  "piNotify": {
-    "enabled": true, // master on/off switch (default: true)
-    "notifyTools": ["ask_user", "ask_user_question"], // tools that trigger "Tool call" notifications
-    "tmuxSymbol": "🔔", // symbol appended to tmux window title (empty string to disable)
-    "finished": true, // enable/disable "Idle" notification
-    "events": {
-      "permissions:ui_prompt": "Permission prompt", // custom event channel -> notification message
-      "my:custom:event": "Custom event triggered", // add your own custom events
-    },
-    "finishedThrottleSecs": 0, // 0 = always notify; >0 = skip finished toasts for runs shorter than N seconds
-    "onlyNotifyWhenUnfocused": true, // only notify when user has been inactive
-    "unfocusedActivityThresholdSecs": 30, // seconds of inactivity before considering user "unfocused"
-  },
-}
-```
-
-### Disabling specific events
-
-To disable a specific event, set its message to an empty string:
-
-```jsonc
-{
-  "piNotify": {
-    "events": {
-      "permissions:ui_prompt": "", // disable permission notifications
-    },
-  },
-}
-```
-
 ## Testing
 
 Run `/notify-test` inside pi to fire a test notification.

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@raidou/pi-notify",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Desktop notification extension for the pi coding agent.",
   "keywords": [
-    "pi-package",
     "pi",
+    "pi-package",
     "pi-extension",
     "pi-coding-agent",
     "notifications",
@@ -28,13 +28,16 @@
   },
   "main": "./src/index.ts",
   "scripts": {
-    "test": "pnpm run test:types && pnpm run test:lint",
+    "test": "pnpm run test:types && pnpm run test:lint && pnpm run test:unit",
     "test:types": "tsc --noEmit",
-    "test:lint": "eslint --fix ."
+    "test:lint": "eslint --fix .",
+    "test:unit": "vitest run"
   },
   "dependencies": {
     "@earendil-works/pi-tui": "0.80.7",
-    "node-notifier": "^10.0.1"
+    "emittery": "^2.0.0",
+    "node-notifier": "^10.0.1",
+    "proper-lockfile": "^4.1.2"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.79.0"
@@ -42,8 +45,10 @@
   "devDependencies": {
     "@raidou/eslint-config-base": "^4.4.3",
     "@types/node": "^22.0.0",
+    "@types/proper-lockfile": "^4.1.4",
     "eslint": "^10.7.0",
     "prettier": "^3.9.5",
-    "typescript": "^5.6.0"
+    "typescript": "^5.6.0",
+    "vitest": "^4.1.11"
   }
 }

package/src/config.ts

@@ -3,8 +3,9 @@ import { join } from 'node:path'
 
 import { getAgentDir } from '@earendil-works/pi-coding-agent'
 
+// `false` disables the event
 interface NotifyEventsConfig {
-  readonly [channel: string]: string
+  readonly [channel: string]: string | false
 }
 
 interface NotifyConfig {

package/src/dashboard/command.ts

@@ -1,24 +1,25 @@
-import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
-
+import { Registrar } from '../shared/registrar.js'
 import { readSessions } from './state-store.js'
 import { createDashboard } from './ui.js'
 
-export class DashboardCommand {
-  constructor(private readonly pi: ExtensionAPI) {}
-
-  register(): void {
+export class DashboardCommand extends Registrar {
+  protected override setup(): void {
     this.pi.registerCommand('notify-dashboard', {
       description: 'Show all pi sessions notify dashboard',
       handler: async (_args, ctx) => {
-        const initialSessions = readSessions()
+        const initialSessions = await readSessions()
 
         await ctx.ui.custom<unknown>((tui, theme, _keybindings, done) => {
+          let closed = false
           const dashboard = createDashboard({
             tui,
             theme,
             initialSessions,
             onRefresh: async () => readSessions(),
             onClose: () => {
+              if (closed) return
+              closed = true
+              dashboard.dispose()
               done(undefined)
             },
           })
@@ -27,6 +28,7 @@ export class DashboardCommand {
             render: dashboard.render.bind(dashboard),
             handleInput: dashboard.handleInput.bind(dashboard),
             invalidate: dashboard.invalidate.bind(dashboard),
+            dispose: dashboard.dispose.bind(dashboard),
           }
         })
 

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

@@ -0,0 +1,290 @@
+import { unlinkSync } from 'node:fs'
+import { join } 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 type { StateTracker } from '../state-tracker.js'
+import { SessionStore } from './session-store.js'
+import { readState, updateState } from './state-store.js'
+
+type EventsListener = (payload: unknown) => void
+
+interface FakeStateTracker {
+  events: {
+    on(event: string, listener: EventsListener): () => void
+    emit(event: string, data?: unknown): void
+  }
+}
+
+interface FakeSessionManager {
+  getSessionId(): string
+}
+
+interface FakePiContext {
+  cwd: string
+  sessionManager: FakeSessionManager
+}
+
+interface FakePi {
+  listeners: Map<string, Set<(...args: unknown[]) => void>>
+  eventListeners: Map<string, Set<EventsListener>>
+  on(event: string, listener: (...args: unknown[]) => void): void
+  events: { on(event: string, listener: EventsListener): () => void }
+  emit(event: string, ...args: unknown[]): void
+  emitEvent(event: string, payload: unknown): void
+  emitSessionStart(ctx: FakePiContext): void
+}
+
+function makeFakePi(): FakePi {
+  const listeners = new Map<string, Set<(...args: unknown[]) => void>>()
+  const eventListeners = new Map<string, Set<EventsListener>>()
+  const pi: FakePi = {
+    listeners,
+    eventListeners,
+    on(event, listener) {
+      let set = listeners.get(event)
+      if (!set) {
+        set = new Set()
+        listeners.set(event, set)
+      }
+      set.add(listener)
+    },
+    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)
+        }
+      },
+    },
+    emit(event, ...args) {
+      const set = listeners.get(event)
+      if (!set) return
+      for (const listener of [...set]) listener(...args)
+    },
+    emitEvent(event, payload) {
+      const set = eventListeners.get(event)
+      if (!set) return
+      for (const listener of [...set]) listener(payload)
+    },
+    emitSessionStart(ctx) {
+      const set = listeners.get('session_start')
+      if (!set) return
+      for (const listener of [...set]) listener(undefined, ctx)
+    },
+  }
+  return pi
+}
+
+function makeFakeStateTracker(): FakeStateTracker {
+  const listeners = new Map<string, Set<EventsListener>>()
+  return {
+    events: {
+      on(event, listener) {
+        let set = listeners.get(event)
+        if (!set) {
+          set = new Set()
+          listeners.set(event, set)
+        }
+        set.add(listener)
+        return () => {
+          set.delete(listener)
+        }
+      },
+      emit(event, data?: unknown) {
+        const set = listeners.get(event)
+        if (!set) return
+        for (const listener of [...set]) listener({ data })
+      },
+    },
+  }
+}
+
+const SESSION_ID = 'test-session-123'
+const META = {
+  cwd: '/test/project',
+  projectName: 'test-project',
+}
+
+describe('SessionStore', () => {
+  const testLockFile = join(getAgentDir(), 'pi-notify-test', 'state.json.lock')
+
+  beforeEach(async () => {
+    try {
+      unlinkSync(testLockFile)
+    } catch {
+      // ignore
+    }
+    await updateState(() => ({ version: 1, sessions: {} }))
+  })
+
+  afterEach(() => {
+    try {
+      unlinkSync(testLockFile)
+    } catch {
+      // ignore
+    }
+  })
+
+  it('creates instance and registers event listeners', () => {
+    const pi = makeFakePi()
+    const stateTracker = makeFakeStateTracker()
+    const emitSpy = vi.spyOn(stateTracker.events, 'on')
+    const piOnSpy = vi.spyOn(pi, 'on')
+
+    const store = new SessionStore(
+      pi as unknown as ExtensionAPI,
+      stateTracker as unknown as StateTracker,
+    )
+    store.register(vi.fn())
+
+    expect(emitSpy).toHaveBeenCalledTimes(2)
+    expect(emitSpy).toHaveBeenCalledWith('running', expect.any(Function))
+    expect(emitSpy).toHaveBeenCalledWith('idle', expect.any(Function))
+    expect(piOnSpy).toHaveBeenCalledWith('session_start', expect.any(Function))
+  })
+
+  it('handles session_start event without errors', () => {
+    const pi = makeFakePi()
+    const stateTracker = makeFakeStateTracker()
+
+    const store = new SessionStore(
+      pi as unknown as ExtensionAPI,
+      stateTracker as unknown as StateTracker,
+    )
+    store.register(vi.fn())
+
+    expect(() => {
+      pi.emitSessionStart({
+        cwd: META.cwd,
+        sessionManager: { getSessionId: () => SESSION_ID },
+      })
+    }).not.toThrow()
+  })
+
+  it('handles running event without errors', () => {
+    const pi = makeFakePi()
+    const stateTracker = makeFakeStateTracker()
+
+    const store = new SessionStore(
+      pi as unknown as ExtensionAPI,
+      stateTracker as unknown as StateTracker,
+    )
+    store.register(vi.fn())
+
+    pi.emitSessionStart({
+      cwd: META.cwd,
+      sessionManager: { getSessionId: () => SESSION_ID },
+    })
+
+    expect(() => {
+      stateTracker.events.emit('running')
+    }).not.toThrow()
+  })
+
+  it('handles idle event without errors', () => {
+    const pi = makeFakePi()
+    const stateTracker = makeFakeStateTracker()
+
+    const store = new SessionStore(
+      pi as unknown as ExtensionAPI,
+      stateTracker as unknown as StateTracker,
+    )
+    store.register(vi.fn())
+
+    pi.emitSessionStart({
+      cwd: META.cwd,
+      sessionManager: { getSessionId: () => SESSION_ID },
+    })
+
+    expect(() => {
+      stateTracker.events.emit('idle')
+    }).not.toThrow()
+  })
+
+  it('ignores running event when session not started', () => {
+    const pi = makeFakePi()
+    const stateTracker = makeFakeStateTracker()
+
+    const store = new SessionStore(
+      pi as unknown as ExtensionAPI,
+      stateTracker as unknown as StateTracker,
+    )
+    store.register(vi.fn())
+
+    expect(() => {
+      stateTracker.events.emit('running')
+    }).not.toThrow()
+  })
+
+  it('ignores idle event when session not started', () => {
+    const pi = makeFakePi()
+    const stateTracker = makeFakeStateTracker()
+
+    const store = new SessionStore(
+      pi as unknown as ExtensionAPI,
+      stateTracker as unknown as StateTracker,
+    )
+    store.register(vi.fn())
+
+    expect(() => {
+      stateTracker.events.emit('idle')
+    }).not.toThrow()
+  })
+
+  it('writes running and idle states to state.json', async () => {
+    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, 10))
+
+    stateTracker.events.emit('running')
+    await new Promise((resolve) => setTimeout(resolve, 10))
+
+    let record = readState().sessions[String(process.pid)]
+    expect(record?.state).toBe('running')
+
+    stateTracker.events.emit('idle')
+    await new Promise((resolve) => setTimeout(resolve, 10))
+
+    record = readState().sessions[String(process.pid)]
+    expect(record?.state).toBe('idle')
+  })
+
+  it('stops without errors after session started', () => {
+    const pi = makeFakePi()
+    const stateTracker = makeFakeStateTracker()
+
+    const store = new SessionStore(
+      pi as unknown as ExtensionAPI,
+      stateTracker as unknown as StateTracker,
+    )
+    store.register(vi.fn())
+
+    pi.emitSessionStart({
+      cwd: META.cwd,
+      sessionManager: { getSessionId: () => SESSION_ID },
+    })
+
+    expect(() => {
+      store.stop()
+    }).not.toThrow()
+  })
+})

package/src/dashboard/session-store.ts

@@ -0,0 +1,83 @@
+import { realpathSync } from 'node:fs'
+import { basename } from 'node:path'
+
+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 { 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
+  private meta: { pid: number; cwd: string; projectName: string } | undefined =
+    undefined
+
+  constructor(pi: ExtensionAPI, stateTracker: StateTracker) {
+    super(pi)
+    this.stateTracker = stateTracker
+  }
+
+  private async saveSession(updates: SessionUpdate): Promise<void> {
+    if (this.sessionId === undefined || this.meta === undefined) return
+
+    const now = Date.now()
+    const meta = this.meta
+    const sessionId = this.sessionId
+    const id = String(meta.pid)
+
+    await updateState((state) => {
+      const existing = state.sessions[id]
+      const stateChanged = updates.state !== existing?.state
+
+      const record: SessionRecord = {
+        pid: meta.pid,
+        sessionId,
+        cwd: meta.cwd,
+        projectName: meta.projectName,
+        startedAt: existing?.startedAt ?? now,
+        state: updates.state,
+        stateChangedAt: stateChanged ? now : existing.stateChangedAt,
+      }
+
+      return {
+        ...state,
+        sessions: { ...state.sessions, [id]: record },
+      }
+    })
+  }
+
+  protected override setup(): void {
+    this.pi.on('session_start', (_event, ctx) => {
+      let normalizedCwd = ctx.cwd
+      try {
+        normalizedCwd = realpathSync(ctx.cwd)
+      } catch {
+        // Use original path if realpathSync fails
+      }
+      const meta = {
+        pid: process.pid,
+        cwd: normalizedCwd,
+        projectName: basename(normalizedCwd),
+      }
+      const sessionId = ctx.sessionManager.getSessionId()
+      this.sessionId = sessionId
+      this.meta = meta
+      void this.saveSession({ state: 'idle' })
+    })
+
+    this.unsubscribes.push(
+      this.stateTracker.events.on('running', async () => {
+        await this.saveSession({ state: 'running' })
+      }),
+      this.stateTracker.events.on('idle', async () => {
+        await this.saveSession({ state: 'idle' })
+      }),
+    )
+  }
+}