@raidou/pi-notify 0.4.0 → 0.5.0

package/src/dashboard/state-store.ts

@@ -5,11 +5,13 @@ import {
   renameSync,
   writeFileSync,
 } from 'node:fs'
-import { dirname, join } from 'node:path'
+import { dirname } from 'node:path'
 
-import { getAgentDir } from '@earendil-works/pi-coding-agent'
+import { omit, partition } from 'lodash-es'
 import lockfile from 'proper-lockfile'
 
+import { STATE_FILE, STATE_TMP_FILE } from './consts.js'
+
 const ESRCH = 'ESRCH'
 const EPERM = 'EPERM'
 
@@ -32,49 +34,43 @@ export function isProcessAlive(pid: number): boolean {
 
 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))
-    }
-  }
+  const sessions = Object.values(state.sessions).filter(
+    (session): session is SessionRecord => session !== undefined,
+  )
+  const [alive, dead] = partition(sessions, (session) =>
+    isProcessAlive(session.pid),
+  )
+
+  const deadIds = dead.map((session) => 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]
-      }
-    }
+    const sessions: typeof s.sessions = omit(s.sessions, deadIds)
     return { ...s, sessions }
   })
 
   return alive
 }
 
+export type SessionState =
+  'running' | 'idle' | `tool_call:${string}` | `event:${string}`
+
 export interface SessionRecord {
   pid: number
   sessionId: string
   cwd: string
   projectName: string
   startedAt: number
-  state: 'running' | 'idle'
-  stateChangedAt: number
+  state: SessionState
+  startedRunningAt?: number
 }
 
 export interface DashboardState {
-  version: 1
+  version: 2
   sessions: Record<string, SessionRecord | undefined>
 }
 
-const STATE_FILE = join(getAgentDir(), 'pi-notify', 'state.json')
 const LOCK_RETRY_INTERVAL_MS = 50
 const LOCK_MAX_RETRIES = 20
 
@@ -85,24 +81,85 @@ function ensureStateDir(): void {
   }
 }
 
+ensureStateDir()
+
+function parseSessionRecord(value: unknown): SessionRecord | undefined {
+  if (typeof value !== 'object' || value === null) return undefined
+  const record = value as Record<string, unknown>
+  if (
+    typeof record.pid !== 'number' ||
+    typeof record.sessionId !== 'string' ||
+    typeof record.cwd !== 'string' ||
+    typeof record.projectName !== 'string' ||
+    typeof record.startedAt !== 'number' ||
+    !isSessionState(record.state)
+  ) {
+    return undefined
+  }
+  return {
+    pid: record.pid,
+    sessionId: record.sessionId,
+    cwd: record.cwd,
+    projectName: record.projectName,
+    startedAt: record.startedAt,
+    state: record.state,
+    startedRunningAt:
+      typeof record.startedRunningAt === 'number'
+        ? record.startedRunningAt
+        : undefined,
+  }
+}
+
+function isActivityState(
+  value: string,
+): value is `tool_call:${string}` | `event:${string}` {
+  return value.startsWith('tool_call:') || value.startsWith('event:')
+}
+
+function isSessionState(value: unknown): value is SessionState {
+  return (
+    value === 'running' ||
+    value === 'idle' ||
+    (typeof value === 'string' && isActivityState(value))
+  )
+}
+
+function parseState(data: string): DashboardState | undefined {
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(data)
+  } catch {
+    return undefined
+  }
+  if (typeof parsed !== 'object' || parsed === null) return undefined
+  const raw = parsed as Record<string, unknown>
+  if (typeof raw.sessions !== 'object' || raw.sessions === null)
+    return undefined
+
+  const sessions: Record<string, SessionRecord | undefined> = {}
+  for (const [key, value] of Object.entries(raw.sessions)) {
+    sessions[key] = parseSessionRecord(value)
+  }
+  // Records from earlier versions without optional fields parse as-is.
+  return { version: 2, sessions }
+}
+
 export function readState(): DashboardState {
   if (!existsSync(STATE_FILE)) {
-    return { version: 1, sessions: {} }
+    return { version: 2, sessions: {} }
   }
 
   try {
-    const data = readFileSync(STATE_FILE, 'utf8')
-    return JSON.parse(data) as DashboardState
+    const state = parseState(readFileSync(STATE_FILE, 'utf8'))
+    return state ?? { version: 2, sessions: {} }
   } catch {
-    return { version: 1, sessions: {} }
+    return { version: 2, sessions: {} }
   }
 }
 
 export async function updateState(
   mutator: (state: DashboardState) => DashboardState,
 ): Promise<void> {
-  ensureStateDir()
-
   const release = await lockfile.lock(STATE_FILE, {
     realpath: false,
     stale: 30000,
@@ -116,9 +173,8 @@ export async function updateState(
   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)
+    writeFileSync(STATE_TMP_FILE, JSON.stringify(newState, null, 2), 'utf8')
+    renameSync(STATE_TMP_FILE, STATE_FILE)
   } finally {
     await release()
   }

package/src/dashboard/ui/columns.ts

@@ -0,0 +1,102 @@
+import type { Theme } from '@earendil-works/pi-coding-agent'
+import { truncateToWidth } from '@earendil-works/pi-tui'
+import { sumBy } from 'lodash-es'
+
+import type { SessionRecord } from '../state-store.js'
+
+interface Column {
+  name: string
+  width?: number
+  hiddenByDefault?: boolean
+  render: (session: SessionRecord, theme: Theme, width: number) => string
+}
+
+const COLUMNS: Column[] = [
+  {
+    name: 'SESSION_ID',
+    width: 10,
+    hiddenByDefault: true,
+    render: (session, theme, width) =>
+      theme.fg('dim', session.sessionId.slice(-6).padEnd(width)),
+  },
+  {
+    name: 'PID',
+    width: 8,
+    hiddenByDefault: true,
+    render: (session, theme, width) =>
+      theme.fg('dim', String(session.pid).padEnd(width)),
+  },
+  {
+    name: 'STATE',
+    width: 20,
+    render: (session, theme, width) => {
+      const color = session.state === 'running' ? 'success' : 'muted'
+      return theme.fg(
+        color,
+        truncateToWidth(session.state, width, '…', true).padEnd(width),
+      )
+    },
+  },
+  {
+    name: 'PROJECT',
+    render: (session, theme, width) =>
+      theme.fg('text', truncateToWidth(session.projectName, width, '…', true)),
+  },
+  {
+    name: 'RUNNING',
+    width: 10,
+    render: (session, theme, width) => {
+      const startedRunningAt = session.startedRunningAt
+      if (!startedRunningAt) return ''
+      const duration = Date.now() - startedRunningAt
+      return theme.fg('dim', formatDuration(duration).padEnd(width))
+    },
+  },
+  {
+    name: 'UPTIME',
+    width: 10,
+    render: (session, theme, width) =>
+      theme.fg(
+        'dim',
+        formatDuration(Date.now() - session.startedAt).padEnd(width),
+      ),
+  },
+]
+
+export const COLUMN_SEPARATOR = ' '
+const MIN_PROJECT_WIDTH = 10
+
+export interface ResolvedColumn {
+  col: Column
+  width: number
+}
+
+export function resolveColumns(
+  totalWidth: number,
+  includeHidden = true,
+): ResolvedColumn[] {
+  const columns = COLUMNS.filter((col) => includeHidden || !col.hiddenByDefault)
+  const fixedWidth = sumBy(columns, (col) => col.width ?? 0)
+  const separatorWidth = COLUMN_SEPARATOR.length * (columns.length - 1)
+  const flexibleWidth = Math.max(
+    MIN_PROJECT_WIDTH,
+    totalWidth - fixedWidth - separatorWidth,
+  )
+  return columns.map((col) => ({ col, width: col.width ?? flexibleWidth }))
+}
+
+function formatDuration(milliseconds: number): string {
+  const seconds = Math.floor(milliseconds / 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`
+}

package/src/dashboard/ui/dashboard.test.ts

@@ -0,0 +1,118 @@
+import type { Theme, ThemeColor } from '@earendil-works/pi-coding-agent'
+import { visibleWidth } from '@earendil-works/pi-tui'
+import { describe, expect, it } from 'vitest'
+
+import type { SessionRecord } from '../state-store.js'
+import { Dashboard } from './dashboard.js'
+
+const theme = {
+  fg: (color: ThemeColor, text: string) => `\x1b[90m${text}\x1b[0m`,
+  bold: (text: string) => `\x1b[1m${text}\x1b[0m`,
+} as unknown as Theme
+
+const ANSI_RE =
+  // eslint-disable-next-line no-control-regex
+  /\[[0-9;?]*[ -/]*[@-~]/g
+const stripAnsi = (line: string): string => line.replace(ANSI_RE, '')
+
+function makeSession(overrides: Partial<SessionRecord>): SessionRecord {
+  return {
+    pid: 123,
+    sessionId: 'abc123',
+    cwd: '/tmp',
+    projectName: 'proj',
+    startedAt: Date.now(),
+    state: 'idle',
+    ...overrides,
+  }
+}
+
+function makeDashboard(sessions: SessionRecord[]) {
+  return new Dashboard({
+    tui: { requestRender: () => {} },
+    theme,
+    initialSessions: sessions,
+    onRefresh: async () => sessions,
+    onClose: () => {},
+  })
+}
+
+describe('Dashboard render clipping', () => {
+  const longNameSession = makeSession({
+    projectName: 'a-very-long-project-name-that-exceeds-any-narrow-width',
+  })
+
+  it('clips every line to the terminal width at narrow widths', () => {
+    const dashboard = makeDashboard([longNameSession])
+    for (const line of dashboard.render(40)) {
+      expect(visibleWidth(line)).toBeLessThanOrEqual(40)
+    }
+    dashboard.dispose()
+  })
+
+  it('does not add ellipsis or padding at wide widths', () => {
+    const dashboard = makeDashboard([longNameSession])
+    for (const line of dashboard.render(200)) {
+      expect(line).not.toContain('…')
+      expect(line.endsWith(' ')).toBe(false)
+    }
+    dashboard.dispose()
+  })
+
+  it('clips the header and footer hint lines at width 20', () => {
+    const dashboard = makeDashboard([makeSession({})])
+    const lines = dashboard.render(20)
+    const visible = lines.map(stripAnsi)
+    const header = visible.find((l) => l.includes('STATE'))
+    expect(header).toBeDefined()
+    const footer = visible.find((l) => l.startsWith('o ids'))
+    expect(footer).toBeDefined()
+    if (!header || !footer) throw new Error('unreachable')
+    expect(header.startsWith('STATE')).toBe(true)
+    expect(header.endsWith('…')).toBe(true)
+    expect(footer.startsWith('o ids • r refresh •…')).toBe(true)
+    for (const line of visible) {
+      expect(visibleWidth(line)).toBeLessThanOrEqual(20)
+    }
+    dashboard.dispose()
+  })
+
+  it('counts CJK project names by display width', () => {
+    const dashboard = makeDashboard([
+      makeSession({ projectName: '中文项目名' }),
+    ])
+    for (const line of dashboard.render(40)) {
+      expect(visibleWidth(line)).toBeLessThanOrEqual(40)
+    }
+    dashboard.dispose()
+  })
+})
+
+describe('hidden column toggle', () => {
+  it('hides hidden columns by default and toggles with o', () => {
+    const dashboard = makeDashboard([makeSession({})])
+    try {
+      const headerOf = () => {
+        const lines = dashboard.render(200).map(stripAnsi)
+        return lines.find((l) => l.includes('STATE') && l.includes('RUNNING'))
+      }
+
+      let header = headerOf()
+      expect(header).toContain('STATE')
+      expect(header).not.toContain('SESSION_ID')
+      expect(header).not.toContain('PID')
+
+      dashboard.handleInput('o')
+      header = headerOf()
+      expect(header).toContain('SESSION_ID')
+      expect(header).toContain('PID')
+
+      dashboard.handleInput('o')
+      header = headerOf()
+      expect(header).not.toContain('SESSION_ID')
+      expect(header).not.toContain('PID')
+    } finally {
+      dashboard.dispose()
+    }
+  })
+})

package/src/dashboard/ui/dashboard.ts

@@ -0,0 +1,122 @@
+import type { Theme } from '@earendil-works/pi-coding-agent'
+import type { Component } from '@earendil-works/pi-tui'
+import { Key, matchesKey, truncateToWidth } from '@earendil-works/pi-tui'
+
+import type { SessionRecord } from '../state-store.js'
+import {
+  COLUMN_SEPARATOR,
+  resolveColumns,
+  type ResolvedColumn,
+} from './columns.js'
+
+export interface DashboardProps {
+  tui: { requestRender: () => void }
+  theme: Theme
+  initialSessions: SessionRecord[]
+  onRefresh: () => Promise<SessionRecord[]>
+  onClose: () => void
+  onDispose?: () => void
+}
+
+export class Dashboard implements Component {
+  private readonly tui: DashboardProps['tui']
+  private readonly theme: Theme
+  private readonly onRefresh: DashboardProps['onRefresh']
+  private readonly onClose: DashboardProps['onClose']
+  private readonly onDispose: DashboardProps['onDispose']
+  private sessions: SessionRecord[]
+  private cachedWidth: number | null = null
+  private cachedLines: string[] = []
+  private disposed = false
+  private showHidden = false
+  private timer: NodeJS.Timeout
+
+  constructor({
+    tui,
+    theme,
+    initialSessions,
+    onRefresh,
+    onClose,
+    onDispose,
+  }: DashboardProps) {
+    this.tui = tui
+    this.theme = theme
+    this.onRefresh = onRefresh
+    this.onClose = onClose
+    this.onDispose = onDispose
+    this.sessions = [...initialSessions]
+
+    // FIXME: 改成用 fs.watch
+    this.timer = setInterval(() => {
+      if (!this.disposed) this.refresh()
+    }, 10000)
+  }
+
+  private forceRender(): void {
+    this.cachedWidth = null
+    this.tui.requestRender()
+  }
+
+  private refresh(): void {
+    this.onRefresh()
+      .then((newSessions) => {
+        this.sessions = [...newSessions]
+        this.forceRender()
+      })
+      .catch(() => {})
+  }
+
+  private headerLine(columns: ResolvedColumn[]): string {
+    return columns
+      .map(({ col, width }) => col.name.padEnd(width))
+      .join(COLUMN_SEPARATOR)
+  }
+
+  render(width: number): string[] {
+    if (this.cachedWidth === width) {
+      return this.cachedLines
+    }
+    this.cachedWidth = width
+    const columns = resolveColumns(width, this.showHidden)
+    const rows = [
+      this.theme.fg('borderAccent', this.headerLine(columns)),
+      this.theme.fg('borderAccent', '─'.repeat(Math.max(1, width))),
+      ...this.sessions.map((session) =>
+        columns
+          .map(({ col, width }) => col.render(session, this.theme, width))
+          .join(COLUMN_SEPARATOR),
+      ),
+      '',
+      this.theme.fg('dim', 'o ids • r refresh • q or esc close'),
+    ]
+    this.cachedLines = rows.map((line) => truncateToWidth(line, width, '…'))
+    return this.cachedLines
+  }
+
+  handleInput(data: string): void {
+    if (matchesKey(data, 'r')) {
+      this.refresh()
+      return
+    }
+
+    if (matchesKey(data, 'q') || matchesKey(data, Key.escape)) {
+      this.onClose()
+      return
+    }
+
+    if (matchesKey(data, 'o')) {
+      this.showHidden = !this.showHidden
+      this.forceRender()
+    }
+  }
+
+  invalidate(): void {
+    this.cachedWidth = null
+  }
+
+  dispose(): void {
+    this.disposed = true
+    clearInterval(this.timer)
+    this.onDispose?.()
+  }
+}

package/src/index.ts

@@ -5,9 +5,7 @@ import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 import { loadConfig } from './config.js'
 import { DashboardCommand } from './dashboard/command.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'
@@ -15,10 +13,9 @@ 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'
 
-export { PI_NOTIFY_EVENT } from './events.js'
 export { JOB_END_EVENT, JOB_START_EVENT } from './jobs.js'
+export { PI_NOTIFY_EVENT } from './state-tracker.js'
 
 export default function piNotifyExtension(pi: ExtensionAPI): void {
   const config = loadConfig()
@@ -27,11 +24,8 @@ export default function piNotifyExtension(pi: ExtensionAPI): void {
 
   const tmuxTitleTracker = new TmuxTitleTracker(pi, config)
   const focusTracker = new FocusTracker(pi, tmuxTitleTracker, config)
-  const eventsNotifier = new EventsNotifier(pi, config)
-  const toolNotifier = new ToolCallNotifier(pi, config)
   const jobTracker = new JobTracker(pi)
-  const stateTracker = new StateTracker(pi, jobTracker)
-  const idleNotifier = new IdleNotifier(pi, config, stateTracker)
+  const stateTracker = new StateTracker(pi, jobTracker, config)
   const notifyTest = new NotifyTest(pi, title, tmuxTitleTracker)
   const sessionState = new SessionState(pi)
   const sessionStore = new SessionStore(pi, stateTracker)
@@ -56,9 +50,6 @@ export default function piNotifyExtension(pi: ExtensionAPI): void {
     focusTracker,
     jobTracker,
     stateTracker,
-    eventsNotifier,
-    toolNotifier,
-    idleNotifier,
     sessionStore,
     notifyTest,
     dashboardCommand,