@raidou/pi-notify 0.2.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raidou/pi-notify",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Desktop notification extension for the pi coding agent.",
   "keywords": [
     "pi-package",
@@ -33,6 +33,7 @@
     "test:lint": "eslint --fix ."
   },
   "dependencies": {
+    "@earendil-works/pi-tui": "0.80.7",
     "node-notifier": "^10.0.1"
   },
   "peerDependencies": {

package/src/dashboard/command.ts

@@ -0,0 +1,37 @@
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+
+import { readSessions } from './state-store.js'
+import { createDashboard } from './ui.js'
+
+export class DashboardCommand {
+  constructor(private readonly pi: ExtensionAPI) {}
+
+  register(): void {
+    this.pi.registerCommand('notify-dashboard', {
+      description: 'Show all pi sessions notify dashboard',
+      handler: async (_args, ctx) => {
+        const initialSessions = readSessions()
+
+        await ctx.ui.custom<unknown>((tui, theme, _keybindings, done) => {
+          const dashboard = createDashboard({
+            tui,
+            theme,
+            initialSessions,
+            onRefresh: async () => readSessions(),
+            onClose: () => {
+              done(undefined)
+            },
+          })
+
+          return {
+            render: dashboard.render.bind(dashboard),
+            handleInput: dashboard.handleInput.bind(dashboard),
+            invalidate: dashboard.invalidate.bind(dashboard),
+          }
+        })
+
+        return undefined
+      },
+    })
+  }
+}

package/src/dashboard/state-store.ts

@@ -0,0 +1,156 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmdirSync,
+  writeFileSync,
+} from 'node:fs'
+import { dirname, join } from 'node:path'
+
+import { getAgentDir } from '@earendil-works/pi-coding-agent'
+
+export interface SessionRecord {
+  pid: number
+  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 {
+  version: 1
+  sessions: Record<string, SessionRecord | undefined>
+}
+
+const STATE_FILE = join(getAgentDir(), 'pi-notify', 'state.json')
+const LOCK_FILE = `${STATE_FILE}.lock`
+const LOCK_RETRY_DELAY_MS = 50
+const LOCK_MAX_RETRIES = 20
+const STALE_THRESHOLD_MS = 30000
+
+function ensureStateDir(): void {
+  const dir = dirname(STATE_FILE)
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true })
+  }
+}
+
+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()
+  if (!existsSync(STATE_FILE)) {
+    return { version: 1, sessions: {} }
+  }
+
+  let state: DashboardState
+  try {
+    const data = readFileSync(STATE_FILE, 'utf8')
+    state = 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(
+  mutator: (state: DashboardState) => DashboardState,
+): Promise<void> {
+  ensureStateDir()
+
+  const locked = await acquireLock()
+  if (!locked) {
+    throw new Error('Failed to acquire lock for state update')
+  }
+
+  try {
+    const state = readState()
+    const newState = mutator(state)
+    const tmpFile = `${STATE_FILE}.tmp`
+    writeFileSync(tmpFile, JSON.stringify(newState, null, 2), 'utf8')
+    renameSync(tmpFile, STATE_FILE)
+  } finally {
+    releaseLock()
+  }
+}
+
+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/state-tracker.ts

@@ -0,0 +1,174 @@
+import { basename } from 'node:path'
+
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+
+import { type SessionRecord, updateState } from './state-store.js'
+
+const IDLE_TIMEOUT_MS = 10000
+const HEARTBEAT_INTERVAL_MS = 5000
+
+export class StateTracker {
+  private registered = false
+  private heartbeatTimer: NodeJS.Timeout | null = null
+  private idleTimer: NodeJS.Timeout | null = null
+  private sessionId: string | undefined = undefined
+  private cwd: string | undefined = undefined
+  private projectName: string | undefined = undefined
+  private model: string | undefined = undefined
+
+  private get cwdOrCwd(): string {
+    return this.cwd ?? process.cwd()
+  }
+
+  private get projectNameOrCwd(): string {
+    return this.projectName ?? basename(process.cwd())
+  }
+
+  constructor(private readonly pi: ExtensionAPI) {}
+
+  private updateSessionRecord(updates: Partial<SessionRecord>): void {
+    if (!this.sessionId) return
+    const now = Date.now()
+    const id = this.sessionId
+
+    void updateState((state) => {
+      const existing = state.sessions[id]
+      const stateChanged =
+        updates.state !== undefined && updates.state !== existing?.state
+
+      const record: SessionRecord = {
+        pid: process.pid,
+        cwd: this.cwdOrCwd,
+        projectName: this.projectNameOrCwd,
+        lastHeartbeatAt: now,
+        startedAt: existing?.startedAt ?? now,
+        state: updates.state ?? existing?.state ?? 'running',
+        stateChangedAt: stateChanged ? now : (existing?.stateChangedAt ?? now),
+        model: this.model ?? existing?.model,
+        lastEvent: updates.lastEvent ?? existing?.lastEvent,
+      }
+
+      return {
+        ...state,
+        sessions: { ...state.sessions, [id]: record },
+      }
+    })
+  }
+
+  private removeSession(): void {
+    if (!this.sessionId) return
+    const id = this.sessionId
+
+    void updateState((state) => {
+      const sessions: Record<string, SessionRecord | undefined> = {}
+      for (const [key, value] of Object.entries(state.sessions)) {
+        if (key !== id) sessions[key] = value
+      }
+      return { ...state, sessions }
+    })
+  }
+
+  private clearIdleTimer(): void {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer)
+      this.idleTimer = null
+    }
+  }
+
+  private startIdleTimer(): void {
+    this.clearIdleTimer()
+    this.idleTimer = setTimeout(() => {
+      this.clearIdleTimer()
+      this.updateSessionRecord({
+        state: 'idle',
+        lastEvent: { type: 'idle', summary: 'idle', at: Date.now() },
+      })
+    }, IDLE_TIMEOUT_MS)
+  }
+
+  register(): void {
+    if (this.registered) return
+    this.registered = true
+
+    this.pi.on('session_start', (_event, ctx) => {
+      this.sessionId = ctx.sessionManager.getSessionId()
+      this.cwd = ctx.cwd
+      this.projectName = basename(ctx.cwd)
+      this.model = ctx.model?.id
+
+      this.updateSessionRecord({
+        lastEvent: {
+          type: 'session_start',
+          summary: 'started',
+          at: Date.now(),
+        },
+      })
+
+      this.heartbeatTimer = setInterval(() => {
+        if (!this.sessionId) return
+        const id = this.sessionId
+
+        void updateState((state) => {
+          const existing = state.sessions[id]
+          if (!existing) return state
+
+          return {
+            ...state,
+            sessions: {
+              ...state.sessions,
+              [id]: {
+                ...existing,
+                lastHeartbeatAt: Date.now(),
+              },
+            },
+          }
+        })
+      }, HEARTBEAT_INTERVAL_MS)
+    })
+
+    this.pi.on('turn_start', () => {
+      this.clearIdleTimer()
+      this.updateSessionRecord({
+        state: 'running',
+        lastEvent: { type: 'turn_start', summary: 'running', at: Date.now() },
+      })
+    })
+
+    this.pi.on('agent_start', () => {
+      this.clearIdleTimer()
+      this.updateSessionRecord({
+        state: 'running',
+        lastEvent: { type: 'agent_start', summary: 'running', at: Date.now() },
+      })
+    })
+
+    this.pi.on('agent_settled', () => {
+      this.startIdleTimer()
+    })
+
+    this.pi.on('tool_call', (event) => {
+      this.updateSessionRecord({
+        state: 'running',
+        lastEvent: {
+          type: 'tool_call',
+          summary: `tool:${event.toolName}`,
+          at: Date.now(),
+        },
+      })
+    })
+
+    this.pi.on('session_shutdown', () => {
+      this.stop()
+      this.removeSession()
+    })
+  }
+
+  stop(): void {
+    this.clearIdleTimer()
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer)
+      this.heartbeatTimer = null
+    }
+    this.registered = false
+  }
+}

package/src/dashboard/ui.ts

@@ -0,0 +1,198 @@
+import type { Theme } from '@earendil-works/pi-coding-agent'
+import { DynamicBorder } from '@earendil-works/pi-coding-agent'
+import {
+  Container,
+  Key,
+  matchesKey,
+  Spacer,
+  Text,
+  truncateToWidth,
+} from '@earendil-works/pi-tui'
+
+import type { SessionRecord } from './state-store.js'
+
+const COLUMNS = [
+  { 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 MAX_ROWS = Math.max(1, (process.stdout.rows || 20) - 6)
+
+export interface DashboardProps {
+  tui: { requestRender: () => void }
+  theme: Theme
+  initialSessions: SessionRecord[]
+  onRefresh: () => Promise<SessionRecord[]>
+  onClose: () => void
+}
+
+function formatUptime(startedAt: number): string {
+  const elapsed = Date.now() - startedAt
+  const seconds = Math.floor(elapsed / 1000)
+  const minutes = Math.floor(seconds / 60)
+  const hours = Math.floor(minutes / 60)
+
+  if (hours > 0) {
+    const mins = minutes % 60
+    return `${hours}h ${mins}m`
+  }
+  if (minutes > 0) {
+    const secs = seconds % 60
+    return `${minutes}m ${secs}s`
+  }
+  return `${seconds}s`
+}
+
+export function createDashboard(props: DashboardProps) {
+  let sessions = [...props.initialSessions]
+  let scrollOffset = 0
+  let cachedWidth: number | null = null
+  let cachedLines: string[] = []
+
+  const dashboardContainer = new Container()
+
+  function updateChildren(width: number): void {
+    const remainingWidth = Math.max(1, width - FIXED_COLUMNS_WIDTH - GAPS_WIDTH)
+    const { theme } = props
+
+    const stats = sessions.reduce(
+      (acc, s) => {
+        acc[s.state]++
+        return acc
+      },
+      { running: 0, idle: 0 },
+    )
+
+    const headerLine = COLUMNS.map((col) =>
+      col.width === undefined ? col.name : col.name.padEnd(col.width),
+    ).join('  ')
+
+    dashboardContainer.clear()
+    dashboardContainer.addChild(
+      new Text(
+        `${theme.fg('accent', theme.bold('pi sessions dashboard'))} ${theme.fg(
+          'dim',
+          `total=${sessions.length} running=${stats.running} idle=${stats.idle}`,
+        )}`,
+        0,
+        0,
+      ),
+    )
+    dashboardContainer.addChild(new Spacer(1))
+    dashboardContainer.addChild(
+      new Text(theme.fg('borderAccent', headerLine), 0, 0),
+    )
+    dashboardContainer.addChild(
+      new DynamicBorder((str) => theme.fg('borderAccent', str)),
+    )
+
+    for (const session of sessions.slice(
+      scrollOffset,
+      scrollOffset + MAX_ROWS,
+    )) {
+      const stateColor = session.state === 'running' ? 'success' : 'muted'
+      const line = [
+        theme.fg('dim', String(session.pid).padEnd(PID_COL.width)),
+        theme.fg(stateColor, session.state.padEnd(STATE_COL.width)),
+        theme.fg(
+          'text',
+          truncateToWidth(session.projectName, PROJECT_COL.width, '…', true),
+        ),
+        theme.fg(
+          '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))
+    }
+
+    dashboardContainer.addChild(new Spacer(1))
+    dashboardContainer.addChild(
+      new Text(theme.fg('dim', '↑↓ scroll • r refresh • q or esc close'), 0, 0),
+    )
+  }
+
+  const component = {
+    render(width: number): string[] {
+      if (cachedWidth !== width) {
+        updateChildren(width)
+        cachedLines = dashboardContainer.render(width)
+        cachedWidth = width
+      }
+      return cachedLines
+    },
+
+    handleInput(data: string): void {
+      if (matchesKey(data, 'r')) {
+        props
+          .onRefresh()
+          .then((newSessions) => {
+            sessions = [...newSessions]
+            scrollOffset = 0
+            cachedWidth = null
+            props.tui.requestRender()
+          })
+          .catch(() => {})
+        return
+      }
+
+      if (matchesKey(data, 'q') || matchesKey(data, Key.escape)) {
+        props.onClose()
+        return
+      }
+
+      if (matchesKey(data, Key.up) || matchesKey(data, 'k')) {
+        if (scrollOffset > 0) {
+          scrollOffset--
+          cachedWidth = null
+          props.tui.requestRender()
+        }
+        return
+      }
+
+      if (matchesKey(data, Key.down) || matchesKey(data, 'j')) {
+        if (scrollOffset + MAX_ROWS < sessions.length) {
+          scrollOffset++
+          cachedWidth = null
+          props.tui.requestRender()
+        }
+      }
+    },
+
+    invalidate(): void {
+      cachedWidth = null
+      dashboardContainer.invalidate()
+    },
+  }
+
+  return component
+}

package/src/idle.ts

@@ -36,6 +36,10 @@ export class IdleNotifier {
       this.clearIdleTimer()
     })
 
+    this.pi.on('message_start', () => {
+      this.clearIdleTimer()
+    })
+
     this.pi.on('agent_settled', () => {
       if (this.jobTracker.hasActiveJobs) return
       this.startIdleTimer(notify)

package/src/index.ts

@@ -3,6 +3,8 @@ import { basename } from 'node:path'
 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 { EventsNotifier } from './events.js'
 import { FocusTracker } from './focus.js'
 import { IdleNotifier } from './idle.js'
@@ -29,6 +31,8 @@ export default function piNotifyExtension(pi: ExtensionAPI): void {
   const idleNotifier = new IdleNotifier(pi, config, jobTracker)
   const notifyTest = new NotifyTest(pi, title, tmuxTitleTracker)
   const sessionState = new SessionState(pi)
+  const stateTracker = new StateTracker(pi)
+  const dashboardCommand = new DashboardCommand(pi)
 
   function notifyReal(body: string): void {
     if (!config.enabled || !sessionState.hasUI) return
@@ -51,4 +55,6 @@ export default function piNotifyExtension(pi: ExtensionAPI): void {
   toolNotifier.register(notifyReal)
   idleNotifier.register(notifyReal)
   notifyTest.register()
+  stateTracker.register()
+  dashboardCommand.register()
 }

package/src/tmux-title.ts

@@ -29,8 +29,7 @@ export class TmuxTitleTracker {
   register(): void {
     this.pi.on('session_start', (_event, ctx) => {
       if (ctx.mode !== 'tui' || !this.enabled) return
-      // Resolve pi's own window up front via its controlling tty, so mark/restore
-      // keep targeting it even if the user switches windows during /new.
+      this.restore()
       const id = this.queryCurrentWindowId()
       if (id === undefined) return
       this.windowId = id
@@ -74,6 +73,7 @@ export class TmuxTitleTracker {
   }
 
   stop(): void {
+    this.restore()
     this.windowId = undefined
     this.originalTitle = undefined
     this.autoRename = undefined