@raidou/pi-notify 0.3.1 → 0.4.0

package/src/events.ts

@@ -1,25 +1,22 @@
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 
 import type { ResolvedNotifyConfig } from './config.js'
-import type { NotifyAction, Unsubscribe } from './types.js'
+import { Registrar } from './shared/registrar.js'
+import type { NotifyAction } from './shared/types.js'
 
 export const PI_NOTIFY_EVENT = 'pi-notify:notify'
 
-export class EventsNotifier {
-  private unsubscribes: Unsubscribe[] = []
-  private registered = false
+export class EventsNotifier extends Registrar {
+  private readonly config: ResolvedNotifyConfig
 
-  constructor(
-    private readonly pi: ExtensionAPI,
-    private readonly config: ResolvedNotifyConfig,
-  ) {}
-
-  register(notify: NotifyAction): void {
-    if (this.registered) return
-    this.registered = true
+  constructor(pi: ExtensionAPI, config: ResolvedNotifyConfig) {
+    super(pi)
+    this.config = config
+  }
 
+  protected override setup(notify: NotifyAction): void {
     for (const [channel, message] of Object.entries(this.config.events)) {
-      if (!message) continue
+      if (typeof message !== 'string' || message === '') continue
       const unsubscribe = this.pi.events.on(channel, () => {
         notify(message)
       })
@@ -30,17 +27,5 @@ export class EventsNotifier {
       notify(String(payload))
     })
     this.unsubscribes.push(customEventUnsub)
-
-    this.pi.on('session_shutdown', () => {
-      this.stop()
-    })
-  }
-
-  stop(): void {
-    this.unsubscribes.forEach((unsub) => {
-      unsub()
-    })
-    this.unsubscribes = []
-    this.registered = false
   }
 }

package/src/focus.ts

@@ -1,36 +1,39 @@
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 
 import type { ResolvedNotifyConfig } from './config.js'
+import { Registrar } from './shared/registrar.js'
 import type { TmuxTitleTracker } from './tmux-title.js'
-import type { Unsubscribe } from './types.js'
 
-// xterm focus reporting (CSI ?1004): emitted by the terminal on focus gain/loss.
 const FOCUS_IN = '\x1b[I'
 const FOCUS_OUT = '\x1b[O'
 const ENABLE_FOCUS_REPORTING = '\x1b[?1004h'
 const DISABLE_FOCUS_REPORTING = '\x1b[?1004l'
 
-export class FocusTracker {
+export class FocusTracker extends Registrar {
+  private readonly titleTracker: TmuxTitleTracker
+  private readonly config: ResolvedNotifyConfig
   private _focused: boolean | undefined = undefined
   private _lastActivityAt = Date.now()
-  private unsubscribe: Unsubscribe | undefined
 
   constructor(
-    private readonly pi: ExtensionAPI,
-    private readonly titleTracker: TmuxTitleTracker,
-    private readonly config: ResolvedNotifyConfig,
-  ) {}
+    pi: ExtensionAPI,
+    titleTracker: TmuxTitleTracker,
+    config: ResolvedNotifyConfig,
+  ) {
+    super(pi)
+    this.titleTracker = titleTracker
+    this.config = config
+  }
 
   get isFocused(): boolean | undefined {
     return this._focused
   }
 
-  /** Timestamp of the last observed terminal input (fallback focus signal). */
   get lastActivityAt(): number {
     return this._lastActivityAt
   }
 
-  register(): void {
+  protected override setup(): void {
     this.pi.on('session_start', (_event, ctx) => {
       const activate =
         ctx.mode === 'tui' &&
@@ -38,24 +41,21 @@ export class FocusTracker {
       if (!activate) return
       this._lastActivityAt = Date.now()
       process.stdout.write(ENABLE_FOCUS_REPORTING)
-      this.unsubscribe = ctx.ui.onTerminalInput((data) => {
-        this._lastActivityAt = Date.now()
-        const result = this.consume(data)
-        if (result.gainedFocus) this.titleTracker.restore()
-        return result.data === data ? undefined : { data: result.data }
-      })
-    })
-    this.pi.on('session_shutdown', () => {
-      this.stop()
+      this.unsubscribes.push(
+        ctx.ui.onTerminalInput((data) => {
+          this._lastActivityAt = Date.now()
+          const result = this.consume(data)
+          if (result.gainedFocus) this.titleTracker.restore()
+          if (result.data !== data) return { consume: true }
+          return undefined
+        }),
+      )
     })
   }
 
-  stop(): void {
-    if (this.unsubscribe) {
-      process.stdout.write(DISABLE_FOCUS_REPORTING)
-      this.unsubscribe()
-      this.unsubscribe = undefined
-    }
+  override stop(): void {
+    process.stdout.write(DISABLE_FOCUS_REPORTING)
+    super.stop()
     this._focused = undefined
   }
 

package/src/idle.ts

@@ -1,52 +1,37 @@
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 
 import type { ResolvedNotifyConfig } from './config.js'
-import type { JobTracker } from './jobs.js'
-import type { NotifyAction } from './types.js'
+import { Registrar } from './shared/registrar.js'
+import type { NotifyAction } from './shared/types.js'
+import type { StateTracker } from './state-tracker.js'
 
-const IDLE_TIMEOUT_MS = 10000
-
-export class IdleNotifier {
-  private timer: NodeJS.Timeout | null = null
+export class IdleNotifier extends Registrar {
+  private readonly config: ResolvedNotifyConfig
+  private readonly stateTracker: StateTracker
+  private hasActivity = false
 
   constructor(
-    private readonly pi: ExtensionAPI,
-    private readonly config: ResolvedNotifyConfig,
-    private readonly jobTracker: JobTracker,
-  ) {}
-
-  clearIdleTimer(): void {
-    if (this.timer) {
-      clearTimeout(this.timer)
-      this.timer = null
-    }
-  }
-  startIdleTimer(notify: NotifyAction): void {
-    this.clearIdleTimer()
-    this.timer = setTimeout(() => {
-      this.clearIdleTimer()
-      notify('Idle')
-    }, IDLE_TIMEOUT_MS)
+    pi: ExtensionAPI,
+    config: ResolvedNotifyConfig,
+    stateTracker: StateTracker,
+  ) {
+    super(pi)
+    this.config = config
+    this.stateTracker = stateTracker
   }
 
-  register(notify: NotifyAction): void {
+  protected override setup(notify: NotifyAction): void {
     if (!this.config.finished) return
 
     this.pi.on('turn_start', () => {
-      this.clearIdleTimer()
-    })
-
-    this.pi.on('message_start', () => {
-      this.clearIdleTimer()
-    })
-
-    this.pi.on('agent_settled', () => {
-      if (this.jobTracker.hasActiveJobs) return
-      this.startIdleTimer(notify)
+      this.hasActivity = true
     })
 
-    this.jobTracker.onEnd(() => {
-      this.startIdleTimer(notify)
-    })
+    this.unsubscribes.push(
+      this.stateTracker.events.on('idle', () => {
+        if (!this.hasActivity) return
+        notify('Idle')
+      }),
+    )
   }
 }

package/src/index.ts

@@ -4,13 +4,15 @@ import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 
 import { loadConfig } from './config.js'
 import { DashboardCommand } from './dashboard/command.js'
-import { StateTracker } from './dashboard/state-tracker.js'
+import { SessionStore } from './dashboard/session-store.js'
 import { EventsNotifier } from './events.js'
 import { FocusTracker } from './focus.js'
 import { IdleNotifier } from './idle.js'
 import { JobTracker } from './jobs.js'
 import { notify } from './notifier.js'
 import { NotifyTest } from './notify-test.js'
+import type { Registerable } from './shared/types.js'
+import { StateTracker } from './state-tracker.js'
 import { SessionState } from './states.js'
 import { TmuxTitleTracker } from './tmux-title.js'
 import { ToolCallNotifier } from './tool.js'
@@ -28,10 +30,11 @@ export default function piNotifyExtension(pi: ExtensionAPI): void {
   const eventsNotifier = new EventsNotifier(pi, config)
   const toolNotifier = new ToolCallNotifier(pi, config)
   const jobTracker = new JobTracker(pi)
-  const idleNotifier = new IdleNotifier(pi, config, jobTracker)
+  const stateTracker = new StateTracker(pi, jobTracker)
+  const idleNotifier = new IdleNotifier(pi, config, stateTracker)
   const notifyTest = new NotifyTest(pi, title, tmuxTitleTracker)
   const sessionState = new SessionState(pi)
-  const stateTracker = new StateTracker(pi)
+  const sessionStore = new SessionStore(pi, stateTracker)
   const dashboardCommand = new DashboardCommand(pi)
 
   function notifyReal(body: string): void {
@@ -48,13 +51,17 @@ export default function piNotifyExtension(pi: ExtensionAPI): void {
     notify(title, body)
   }
 
-  tmuxTitleTracker.register()
-  focusTracker.register()
-  jobTracker.register()
-  eventsNotifier.register(notifyReal)
-  toolNotifier.register(notifyReal)
-  idleNotifier.register(notifyReal)
-  notifyTest.register()
-  stateTracker.register()
-  dashboardCommand.register()
+  const registrables: Registerable[] = [
+    tmuxTitleTracker,
+    focusTracker,
+    jobTracker,
+    stateTracker,
+    eventsNotifier,
+    toolNotifier,
+    idleNotifier,
+    sessionStore,
+    notifyTest,
+    dashboardCommand,
+  ]
+  for (const r of registrables) r.register(notifyReal)
 }

package/src/jobs.ts

@@ -1,18 +1,12 @@
-import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
-
-import type { Unsubscribe } from './types.js'
+import { Registrar } from './shared/registrar.js'
 
 export const JOB_START_EVENT = 'pi-notify:job:start'
 export const JOB_END_EVENT = 'pi-notify:job:end'
 
-export class JobTracker {
+export class JobTracker extends Registrar {
   private activeJobs = new Set<string>()
-  private unsubscribes: Unsubscribe[] = []
-  private registered = false
   private onEndListeners: Array<() => void> = []
 
-  constructor(private readonly pi: ExtensionAPI) {}
-
   get hasActiveJobs(): boolean {
     return this.activeJobs.size > 0
   }
@@ -25,10 +19,7 @@ export class JobTracker {
     }
   }
 
-  register(): void {
-    if (this.registered) return
-    this.registered = true
-
+  protected override setup(): void {
     const startUnsub = this.pi.events.on(JOB_START_EVENT, (params) => {
       if (
         typeof params === 'object' &&
@@ -53,18 +44,10 @@ export class JobTracker {
       }
     })
     this.unsubscribes.push(endUnsub)
-
-    this.pi.on('session_shutdown', () => {
-      this.stop()
-    })
   }
 
-  stop(): void {
-    this.unsubscribes.forEach((unsub) => {
-      unsub()
-    })
-    this.unsubscribes = []
+  override stop(): void {
+    super.stop()
     this.activeJobs.clear()
-    this.registered = false
   }
 }

package/src/notify-test.ts

@@ -1,17 +1,21 @@
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 
-import { notify } from './notifier.js'
+import { notify as sendNotification } from './notifier.js'
+import { sleep } from './shared/utils.js'
 import type { TmuxTitleTracker } from './tmux-title.js'
-import { sleep } from './utils.js'
 
 const DEFAULT_BODY = 'This is a test notification.'
 
 export class NotifyTest {
-  constructor(
-    private readonly pi: ExtensionAPI,
-    private readonly title: string,
-    private readonly titleTracker: TmuxTitleTracker,
-  ) {}
+  private readonly pi: ExtensionAPI
+  private readonly title: string
+  private readonly titleTracker: TmuxTitleTracker
+
+  constructor(pi: ExtensionAPI, title: string, titleTracker: TmuxTitleTracker) {
+    this.pi = pi
+    this.title = title
+    this.titleTracker = titleTracker
+  }
 
   register(): void {
     this.pi.registerCommand('notify-test', {
@@ -19,7 +23,7 @@ export class NotifyTest {
       handler: async (args) => {
         await sleep(3000)
         this.titleTracker.mark()
-        notify(this.title, args.trim() || DEFAULT_BODY)
+        sendNotification(this.title, args.trim() || DEFAULT_BODY)
       },
     })
   }

package/src/shared/registrar.test.ts

@@ -0,0 +1,137 @@
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+import { describe, expect, it, vi } from 'vitest'
+
+import { Registrar } from './registrar.js'
+import type { NotifyAction, Unsubscribe } from './types.js'
+
+type Listener = (...args: unknown[]) => void
+type EventsListener = (payload: unknown) => void
+
+interface FakePi {
+  listeners: Map<string, Set<Listener>>
+  eventListeners: Map<string, Set<EventsListener>>
+  on(event: string, listener: Listener): void
+  events: { on(event: string, listener: EventsListener): Unsubscribe }
+  emit(event: string, ...args: unknown[]): void
+  emitEvent(event: string, payload: unknown): void
+}
+
+function makeFakePi(): FakePi {
+  const listeners = new Map<string, Set<Listener>>()
+  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)
+    },
+  }
+  return pi
+}
+
+class TrackingRegistrar extends Registrar {
+  setupCalls = 0
+  notifyUsed: NotifyAction | undefined
+  stopCalls = 0
+
+  protected override setup(notify: NotifyAction): void {
+    this.setupCalls += 1
+    this.notifyUsed = notify
+    const unsub: Unsubscribe = () => {}
+    this.unsubscribes.push(unsub)
+    this.unsubscribes.push(unsub)
+  }
+
+  override stop(): void {
+    super.stop()
+    this.stopCalls += 1
+  }
+
+  get isRegistered() {
+    return this.registered
+  }
+  get unsubscribesCount() {
+    return this.unsubscribes.length
+  }
+}
+
+describe('Registrar', () => {
+  it('runs setup once and is idempotent', () => {
+    const pi = makeFakePi()
+    const reg = new TrackingRegistrar(pi as unknown as ExtensionAPI)
+    const notify = vi.fn() as unknown as NotifyAction
+    reg.register(notify)
+    reg.register(notify)
+    expect(reg.setupCalls).toBe(1)
+    expect(reg.notifyUsed).toBe(notify)
+  })
+
+  it('passes notify to setup', () => {
+    const pi = makeFakePi()
+    const reg = new TrackingRegistrar(pi as unknown as ExtensionAPI)
+    const notify = vi.fn() as unknown as NotifyAction
+    reg.register(notify)
+    expect(reg.notifyUsed).toBe(notify)
+  })
+
+  it('triggers stop on session_shutdown', () => {
+    const pi = makeFakePi()
+    const reg = new TrackingRegistrar(pi as unknown as ExtensionAPI)
+    const notify = vi.fn() as unknown as NotifyAction
+    reg.register(notify)
+    expect(reg.stopCalls).toBe(0)
+    pi.emit('session_shutdown')
+    expect(reg.stopCalls).toBe(1)
+    expect(reg.isRegistered).toBe(false)
+  })
+
+  it('clears unsubscribes on stop', () => {
+    const pi = makeFakePi()
+    const reg = new TrackingRegistrar(pi as unknown as ExtensionAPI)
+    const notify = vi.fn() as unknown as NotifyAction
+    reg.register(notify)
+    expect(reg.unsubscribesCount).toBe(2)
+    reg.stop()
+    expect(reg.unsubscribesCount).toBe(0)
+    expect(reg.isRegistered).toBe(false)
+  })
+
+  it('re-registers after stop', () => {
+    const pi = makeFakePi()
+    const reg = new TrackingRegistrar(pi as unknown as ExtensionAPI)
+    const notify = vi.fn() as unknown as NotifyAction
+    reg.register(notify)
+    pi.emit('session_shutdown')
+    expect(reg.setupCalls).toBe(1)
+    reg.register(notify)
+    expect(reg.setupCalls).toBe(2)
+  })
+})

package/src/shared/registrar.ts

@@ -0,0 +1,30 @@
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+
+import type { NotifyAction, Unsubscribe } from './types.js'
+
+export abstract class Registrar {
+  protected readonly pi: ExtensionAPI
+  protected registered = false
+  protected unsubscribes: Unsubscribe[] = []
+
+  constructor(pi: ExtensionAPI) {
+    this.pi = pi
+  }
+
+  register(notify: NotifyAction): void {
+    if (this.registered) return
+    this.registered = true
+    this.setup(notify)
+    this.pi.on('session_shutdown', () => {
+      this.stop()
+    })
+  }
+
+  protected abstract setup(notify: NotifyAction): void
+
+  stop(): void {
+    for (const unsubscribe of this.unsubscribes) unsubscribe()
+    this.unsubscribes = []
+    this.registered = false
+  }
+}

package/src/{types.ts → shared/types.ts}

@@ -1,3 +1,7 @@
 export type Unsubscribe = () => void
 
 export type NotifyAction = (body: string) => void
+
+export interface Registerable {
+  register(notify: NotifyAction): void
+}

package/src/state-tracker.test.ts

@@ -0,0 +1,145 @@
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { JobTracker } from './jobs.js'
+import { StateTracker } from './state-tracker.js'
+
+interface FakePi {
+  listeners: Map<string, Set<() => void>>
+  on(event: string, listener: () => void): void
+  emit(event: string): void
+}
+
+function makeFakePi(): FakePi {
+  const listeners = new Map<string, Set<() => void>>()
+  return {
+    listeners,
+    on(event, listener) {
+      let set = listeners.get(event)
+      if (!set) {
+        set = new Set()
+        listeners.set(event, set)
+      }
+      set.add(listener)
+    },
+    emit(event) {
+      const set = listeners.get(event)
+      if (!set) return
+      for (const listener of [...set]) listener()
+    },
+  }
+}
+
+function makeFakeJobTracker(): JobTracker {
+  return {
+    hasActiveJobs: false,
+    onEnd: () => () => {},
+  } as unknown as JobTracker
+}
+
+async function flush(): Promise<void> {
+  for (let i = 0; i < 5; i++) await Promise.resolve()
+}
+
+function makeTracker(pi: FakePi): {
+  tracker: StateTracker
+  states: string[]
+} {
+  const states: string[] = []
+  const tracker = new StateTracker(
+    pi as unknown as ExtensionAPI,
+    makeFakeJobTracker(),
+  )
+  tracker.register(() => {})
+  tracker.events.on('running', () => {
+    states.push('running')
+  })
+  tracker.events.on('idle', () => {
+    states.push('idle')
+  })
+  return { tracker, states }
+}
+
+describe('StateTracker', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('emits running on turn_start', async () => {
+    const pi = makeFakePi()
+    const { states } = makeTracker(pi)
+
+    pi.emit('turn_start')
+
+    await flush()
+
+    expect(states).toEqual(['running'])
+  })
+
+  it('emits idle after the idle timeout following agent_settled', async () => {
+    const pi = makeFakePi()
+    const { states } = makeTracker(pi)
+
+    pi.emit('turn_start')
+    pi.emit('agent_settled')
+    vi.advanceTimersByTime(10000)
+
+    await flush()
+
+    expect(states).toEqual(['running', 'idle'])
+  })
+
+  it('does not emit running repeatedly while already running', async () => {
+    const pi = makeFakePi()
+    const { states } = makeTracker(pi)
+
+    pi.emit('turn_start')
+    pi.emit('message_start')
+    pi.emit('tool_call')
+    pi.emit('turn_start')
+
+    await flush()
+
+    expect(states).toEqual(['running'])
+  })
+
+  it('emits running again after becoming idle', async () => {
+    const pi = makeFakePi()
+    const { states } = makeTracker(pi)
+
+    pi.emit('turn_start')
+    pi.emit('agent_settled')
+    vi.advanceTimersByTime(10000)
+    pi.emit('turn_start')
+
+    await flush()
+
+    expect(states).toEqual(['running', 'idle', 'running'])
+  })
+
+  it('resets the idle timer on activity', async () => {
+    const pi = makeFakePi()
+    const { states } = makeTracker(pi)
+
+    pi.emit('turn_start')
+    pi.emit('agent_settled')
+    vi.advanceTimersByTime(9000)
+    pi.emit('tool_call')
+    vi.advanceTimersByTime(9000)
+
+    await flush()
+
+    expect(states).toEqual(['running'])
+
+    pi.emit('agent_settled')
+    vi.advanceTimersByTime(10000)
+
+    await flush()
+
+    expect(states).toEqual(['running', 'idle'])
+  })
+})