pi-minimal 0.5.0 → 0.6.0

package/src/rex.ts

@@ -0,0 +1,304 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import { spawn as nodeSpawn, type ChildProcess } from "node:child_process"
+import { createInterface } from "node:readline"
+import { createListeners } from "./listeners.js"
+import type { Sibling, SiblingSource } from "./siblings.js"
+
+/**
+ * Rex siblings: other panes in the same Rex session whose program reports status with the
+ * Program Status Protocol (OSC 7501), e.g. another pi with the rex-agent-state extension, or
+ * claude-code / terraform. The pi in this pane is excluded by `REX_BLOCK`.
+ *
+ * Rex pushes status changes over `rex events -s SESSION --json`, so this source keeps one child
+ * process instead of polling every pane; it only shells out again to seed on start and to refresh
+ * tab labels / the block→tab map when the layout changes.
+ */
+
+export type RexStatusRecord = {
+  state: string
+  app?: string
+  msg?: string
+}
+
+export type RexLayout = {
+  /** window_id → tab label */
+  tabs: Map<string, string>
+  /** block_id → window_id, terminal blocks only */
+  blocks: Map<string, string>
+}
+
+export type RexState = {
+  layout: RexLayout
+  /** block_id → root status record */
+  status: Map<string, RexStatusRecord>
+}
+
+export function createRexState(): RexState {
+  return { layout: { tabs: new Map(), blocks: new Map() }, status: new Map() }
+}
+
+const TERMINAL_CREATOR = "com.superlogical.terminal"
+
+/** Parses `rex window ls -s SESSION --json`. */
+export function parseWindowList(stdout: string): RexLayout {
+  const data = JSON.parse(stdout) as {
+    windows?: Array<{
+      window_id?: unknown
+      label?: unknown
+      layers?: Array<{ blocks?: Array<{ block_id?: unknown; creator_name?: unknown }> }>
+    }>
+  }
+  if (!Array.isArray(data.windows)) throw new Error("invalid rex window list")
+  const layout: RexLayout = { tabs: new Map(), blocks: new Map() }
+  for (const window of data.windows) {
+    const windowId = typeof window.window_id === "string" ? window.window_id : undefined
+    if (!windowId) continue
+    layout.tabs.set(windowId, typeof window.label === "string" ? window.label : "")
+    for (const layer of window.layers ?? []) {
+      for (const block of layer.blocks ?? []) {
+        if (typeof block.block_id !== "string") continue
+        if (block.creator_name !== undefined && block.creator_name !== TERMINAL_CREATOR) continue
+        layout.blocks.set(block.block_id, windowId)
+      }
+    }
+  }
+  return layout
+}
+
+/** Parses `rex block call -b BLOCK program_status`; returns the root record, if any. */
+export function parseProgramStatus(stdout: string): RexStatusRecord | undefined {
+  const data = JSON.parse(stdout) as { records?: Array<Record<string, unknown>> }
+  if (!Array.isArray(data.records)) throw new Error("invalid rex program status")
+  const root = data.records.find((record) => record.id === undefined || record.id === "")
+  return root ? toRecord(root) : undefined
+}
+
+function toRecord(raw: Record<string, unknown>): RexStatusRecord | undefined {
+  if (typeof raw.state !== "string") return undefined
+  const record: RexStatusRecord = { state: raw.state }
+  const app = typeof raw.effective_app === "string" ? raw.effective_app : typeof raw.app === "string" ? raw.app : undefined
+  if (app) record.app = app
+  if (typeof raw.msg === "string") record.msg = raw.msg
+  return record
+}
+
+export type RexEventEffect = "status" | "layout" | undefined
+
+/**
+ * Applies one line of `rex events --json` to the state. Returns what changed: `status` (a pane's
+ * record) or `layout` (the caller should re-read the window list). Unknown events are ignored.
+ */
+export function applyRexEvent(state: RexState, line: string): RexEventEffect {
+  // Shape: {"type":"session_event","payload":{"session_id":…,"event":{"type":…,"payload":{…}}}}
+  let outer: { type?: unknown; payload?: { event?: { type?: unknown; payload?: Record<string, unknown> } } }
+  try {
+    outer = JSON.parse(line)
+  } catch {
+    return undefined
+  }
+  if (outer.type !== "session_event") return undefined
+  const event = outer.payload?.event
+  const payload = event?.payload ?? {}
+  switch (event?.type) {
+    case "block_event": {
+      const blockId = payload.block_id
+      if (typeof blockId !== "string") return undefined
+      const inner = (payload.payload ?? {}) as Record<string, unknown>
+      if (payload.name === "program_status_changed") {
+        if (inner.id !== "" && inner.id !== undefined) return undefined
+        const record = toRecord((inner.record ?? {}) as Record<string, unknown>)
+        if (!record) return undefined
+        state.status.set(blockId, record)
+        return "status"
+      }
+      if (payload.name === "program_status_removed") {
+        const ids = Array.isArray(inner.ids) ? inner.ids : []
+        if (!ids.includes("")) return undefined
+        return state.status.delete(blockId) ? "status" : undefined
+      }
+      return undefined
+    }
+    case "block_closed": {
+      const blockId = payload.block_id
+      if (typeof blockId !== "string") return undefined
+      state.status.delete(blockId)
+      state.layout.blocks.delete(blockId)
+      return "layout"
+    }
+    case "block_created":
+    case "window_label_changed":
+    case "window_created":
+    case "window_closed":
+    case "session_label_changed":
+      return "layout"
+    default:
+      return undefined
+  }
+}
+
+/** A Rex auto-label such as `Window 395a96cb` says nothing about the work; prefer the program. */
+const AUTO_LABEL = /^Window [0-9a-f]+$/i
+
+/**
+ * Siblings are named after their tab, like Herdr siblings. A pane in the same tab as this pi
+ * would share our tab's name, so it is named after its program instead.
+ */
+export function listRexSiblings(state: RexState, selfBlock?: string): Sibling[] | undefined {
+  if (!selfBlock) return undefined
+  const selfWindow = state.layout.blocks.get(selfBlock)
+  const parts: Sibling[] = []
+  for (const [blockId, record] of state.status) {
+    if (blockId === selfBlock) continue
+    const windowId = state.layout.blocks.get(blockId)
+    const label = windowId && windowId !== selfWindow ? state.layout.tabs.get(windowId) : undefined
+    const name = label && !AUTO_LABEL.test(label) ? label : record.app
+    if (!name) continue
+    parts.push({ name, status: record.state })
+  }
+  if (parts.length === 0) return undefined
+  return parts
+}
+
+export type RexSpawn = (command: string, args: string[]) => Pick<ChildProcess, "stdout" | "stderr" | "kill" | "on" | "once">
+
+export type RexSiblingsDeps = {
+  pi: ExtensionAPI
+  env?: NodeJS.ProcessEnv
+  spawn?: RexSpawn
+}
+
+const REX_EXEC_TIMEOUT_MS = 3000
+const REX_RESTART_MS = 10000
+const REX_LAYOUT_DEBOUNCE_MS = 150
+
+export function createRexSiblings(deps: RexSiblingsDeps): SiblingSource {
+  const env = deps.env ?? process.env
+  const spawn: RexSpawn = deps.spawn ?? ((command, args) => nodeSpawn(command, args, { stdio: ["ignore", "pipe", "pipe"] }))
+  const session = env.REX_SESSION ?? ""
+  const selfBlock = env.REX_BLOCK
+  let alive = true
+  let child: ReturnType<RexSpawn> | undefined
+  let restartTimer: ReturnType<typeof setTimeout> | undefined
+  let layoutTimer: ReturnType<typeof setTimeout> | undefined
+  let layoutInFlight = false
+  let layoutDirty = false
+  let siblings: Sibling[] | undefined
+  const state = createRexState()
+  const listeners = createListeners()
+
+  const recompute = () => {
+    if (!alive) return
+    const next = listRexSiblings(state, selfBlock)
+    const changed = JSON.stringify(next) !== JSON.stringify(siblings)
+    siblings = next
+    if (changed) listeners.notify()
+  }
+
+  const refreshLayout = async (seedStatus: boolean) => {
+    if (!alive) return
+    if (layoutInFlight) { layoutDirty = true; return }
+    layoutInFlight = true
+    try {
+      const run = await deps.pi.exec("rex", ["window", "ls", "-s", session, "--json"], { timeout: REX_EXEC_TIMEOUT_MS })
+      if (!alive) return
+      if (run.code !== 0 || run.killed) return
+      const layout = parseWindowList(run.stdout)
+      state.layout = layout
+      for (const blockId of [...state.status.keys()]) {
+        if (!layout.blocks.has(blockId)) state.status.delete(blockId)
+      }
+      if (seedStatus) {
+        await Promise.all(
+          [...layout.blocks.keys()]
+            .filter((blockId) => blockId !== selfBlock)
+            .map(async (blockId) => {
+              try {
+                const status = await deps.pi.exec("rex", ["block", "call", "-s", session, "-b", blockId, "program_status"], { timeout: REX_EXEC_TIMEOUT_MS })
+                if (!alive || status.code !== 0 || status.killed) return
+                const record = parseProgramStatus(status.stdout)
+                if (record) state.status.set(blockId, record)
+                else state.status.delete(blockId)
+              } catch {
+                // A pane that vanished mid-seed shows up via events later.
+              }
+            }),
+        )
+      }
+      recompute()
+    } catch {
+      // Keep the last known layout; the next layout event retries.
+    } finally {
+      layoutInFlight = false
+      if (layoutDirty && alive) {
+        layoutDirty = false
+        void refreshLayout(false)
+      }
+    }
+  }
+
+  const scheduleLayoutRefresh = () => {
+    if (!alive || layoutTimer) return
+    layoutTimer = setTimeout(() => {
+      layoutTimer = undefined
+      void refreshLayout(false)
+    }, REX_LAYOUT_DEBOUNCE_MS)
+  }
+
+  const start = () => {
+    if (!alive) return
+    restartTimer = undefined
+    let proc: ReturnType<RexSpawn>
+    try {
+      proc = spawn("rex", ["events", "-s", session, "--json"])
+    } catch {
+      scheduleRestart()
+      return
+    }
+    child = proc
+    if (proc.stdout) {
+      const lines = createInterface({ input: proc.stdout })
+      lines.on("line", (line) => {
+        if (!alive || child !== proc) return
+        const effect = applyRexEvent(state, line)
+        if (effect === "status") recompute()
+        else if (effect === "layout") { recompute(); scheduleLayoutRefresh() }
+      })
+    }
+    proc.on("error", () => { if (child === proc) onExit() })
+    proc.on("exit", () => { if (child === proc) onExit() })
+    void refreshLayout(true)
+  }
+
+  const onExit = () => {
+    child = undefined
+    if (!alive) return
+    state.status.clear()
+    recompute()
+    scheduleRestart()
+  }
+
+  const scheduleRestart = () => {
+    if (!alive || restartTimer) return
+    restartTimer = setTimeout(start, REX_RESTART_MS)
+  }
+
+  start()
+
+  return {
+    get: () => siblings,
+    onChange: listeners.add,
+    dispose() {
+      if (!alive) return
+      alive = false
+      if (restartTimer) clearTimeout(restartTimer)
+      if (layoutTimer) clearTimeout(layoutTimer)
+      restartTimer = undefined
+      layoutTimer = undefined
+      const proc = child
+      child = undefined
+      try { proc?.kill() } catch { /* already gone */ }
+      siblings = undefined
+      listeners.clear()
+    },
+  }
+}

package/src/session.ts

@@ -7,32 +7,58 @@ import { bindFooterContributionEvents } from "./footer-contribution-events.js"
 import { createFooterContributions } from "./footer-contributions.js"
 import { createGitState } from "./git-state.js"
 import { installHeader } from "./header.js"
-import { listSiblings, parseAgentList, parseTabList, type Sibling } from "./herdr.js"
+import { createBackgroundTracker, type BackgroundTracker } from "./background.js"
+import { backgroundSegment } from "./background-overlay.js"
+import { createPrSource, findPrUrls, prSegment, type PrSource } from "./prs.js"
 import { applyReclaim, reclaimPolicy, type ReclaimReason } from "./reclaim.js"
+import type { RexSpawn } from "./rex.js"
+import { createSiblingSource, type SiblingSource } from "./siblings.js"
 import { setSessionCwd } from "./tool-rows.js"
 import { setEditDiffMode } from "./tools.js"
 import { hideGauntletWidgets } from "./tracker.js"
 
+/** Custom session entry remembering a PR this session created, so a resumed session shows it. */
+export const PR_ENTRY_TYPE = "pi-minimal.pr"
+
+function readSessionPrs(ctx: ExtensionContext): string[] {
+  const urls: string[] = []
+  try {
+    for (const entry of ctx.sessionManager.getBranch()) {
+      if (entry.type !== "custom" || entry.customType !== PR_ENTRY_TYPE) continue
+      const url = (entry.data as { url?: unknown } | undefined)?.url
+      if (typeof url === "string") urls.push(url)
+    }
+  } catch {
+    // No branch available (tests, odd hosts): start empty.
+  }
+  return urls
+}
+
 export type SessionDeps = {
   /** Whether an agent run is in progress; owned by the extension because agent events are not session-scoped. */
   busy: () => boolean
+  /** Test seam for the Rex event stream; defaults to node:child_process.spawn. */
+  spawn?: RexSpawn
 }
 
 export type Session = {
   readonly id: string
+  /** Background processes left behind by bash tool calls; undefined outside TUI mode. */
+  readonly background?: BackgroundTracker
+  readonly backgroundShortcut?: string | null
+  /** Open PRs for the repo in cwd plus ones this session created; undefined outside TUI mode. */
+  readonly prs?: PrSource
+  /** Records PR URLs found in text (e.g. `gh pr create` output) as this session's PRs. */
+  notePrUrls(text: string): void
   /** Re-asserts chrome after an event that may have let another extension draw over it. */
   pin(reason: ReclaimReason): void
   refreshGit(force?: boolean): void
   dispose(): void
 }
 
-const HERDR_FAST_MS = 2000
-const HERDR_SLOW_MS = 10000
-const HERDR_EXEC_TIMEOUT_MS = 3000
-
 /**
- * Everything pi-minimal owns for one session: config, cwd, the contribution registry, the git and
- * Herdr pollers, and the header/footer/status-line chrome. Disposal stops every timer and makes
+ * Everything pi-minimal owns for one session: config, cwd, the contribution registry, the git
+ * poller, the sibling source (Herdr or Rex), and the header/footer/status-line chrome. Disposal stops every timer and makes
  * late async results inert, so two sessions in one process never share or overwrite each other's
  * state. Non-TUI sessions get a session too, but it only binds the contribution protocol (which
  * replies `not-tui`) and installs no chrome.
@@ -43,7 +69,7 @@ export function createSession(pi: ExtensionAPI, ctx: ExtensionContext, deps: Ses
   const contributions = createFooterContributions()
   const stopContributionEvents = bindFooterContributionEvents(pi.events, contributions, id, ctx.mode)
   if (ctx.mode !== "tui") {
-    return { id, pin() {}, refreshGit() {}, dispose() { if (!alive) return; alive = false; stopContributionEvents() } }
+    return { id, pin() {}, refreshGit() {}, notePrUrls() {}, dispose() { if (!alive) return; alive = false; stopContributionEvents() } }
   }
 
   const config = loadPiMinimalConfig({ agentDir: getAgentDir(), cwd: ctx.cwd, projectTrusted: ctx.isProjectTrusted() })
@@ -58,10 +84,9 @@ export function createSession(pi: ExtensionAPI, ctx: ExtensionContext, deps: Ses
 
   const gitState = createGitState(pi, () => ctx.cwd)
   let stopFooter = () => {}
-  let siblings: Sibling[] | undefined
-  let herdrTimer: ReturnType<typeof setInterval> | undefined
-  let herdrPeriod = 0
-  let herdrInFlight: AbortController | undefined
+  let siblings: SiblingSource | undefined
+  const background = createBackgroundTracker({ pi })
+  const prs = createPrSource({ pi, cwd: () => ctx.cwd, sessionPrs: readSessionPrs(ctx) })
   const settleTimers: ReturnType<typeof setTimeout>[] = []
 
   const contextPct = (): number | undefined => {
@@ -77,11 +102,26 @@ export function createSession(pi: ExtensionAPI, ctx: ExtensionContext, deps: Ses
       busy: deps.busy,
       editorText: () => (typeof ctx.ui.getEditorText === "function" ? ctx.ui.getEditorText() : ""),
       contextPct,
+      prs: (theme) => {
+        const snap = prs.get()
+        return prSegment(snap.prs, theme, 4, snap.repo ? `${snap.repo.host}/${snap.repo.nameWithOwner}` : undefined)
+      },
+      onPrsChange: prs.onChange,
+      background: () => backgroundSegment(background.get()),
+      onBackgroundChange: background.onChange,
     }, contributions)
   }
 
   const installStatusLine = () => {
-    installCwd(ctx, { gitState: gitState.get, siblings: () => siblings, onGitChange: gitState.onChange })
+    installCwd(ctx, {
+      gitState: gitState.get,
+      siblings: () => siblings?.get(),
+      onChange(listener) {
+        const offGit = gitState.onChange(listener)
+        const offSiblings = siblings?.onChange(listener) ?? (() => {})
+        return () => { offGit(); offSiblings() }
+      },
+    })
   }
 
   const pin = (reason: ReclaimReason) => {
@@ -95,37 +135,9 @@ export function createSession(pi: ExtensionAPI, ctx: ExtensionContext, deps: Ses
     installStatusLine()
   }
 
-  const scheduleHerdr = (periodMs: number) => {
-    if (!alive || herdrPeriod === periodMs) return
-    if (herdrTimer) clearInterval(herdrTimer)
-    herdrPeriod = periodMs
-    herdrTimer = setInterval(() => { void probeHerdr() }, periodMs)
-  }
-
-  const probeHerdr = async () => {
-    if (!alive || herdrInFlight) return
-    const ac = new AbortController()
-    herdrInFlight = ac
-    try {
-      const agentRun = await pi.exec("herdr", ["agent", "list"], { timeout: HERDR_EXEC_TIMEOUT_MS, signal: ac.signal })
-      if (!alive) return
-      const tabRun = await pi.exec("herdr", ["tab", "list"], { timeout: HERDR_EXEC_TIMEOUT_MS, signal: ac.signal })
-      if (!alive) return
-      if (agentRun.code !== 0 || tabRun.code !== 0 || agentRun.killed || tabRun.killed) {
-        siblings = undefined
-        scheduleHerdr(HERDR_SLOW_MS)
-        return
-      }
-      siblings = listSiblings(parseAgentList(agentRun.stdout), parseTabList(tabRun.stdout), process.env.HERDR_PANE_ID, process.env.HERDR_TAB_ID)
-      scheduleHerdr(siblings ? HERDR_FAST_MS : HERDR_SLOW_MS)
-    } catch {
-      if (!alive) return
-      siblings = undefined
-      scheduleHerdr(HERDR_SLOW_MS)
-    } finally {
-      if (herdrInFlight === ac) herdrInFlight = undefined
-    }
-  }
+  // The source is chosen from the environment (HERDR_ENV, else REX_SESSION/REX_BLOCK); start it
+  // before the status line so its onChange subscription is live.
+  siblings = createSiblingSource({ pi, spawn: deps.spawn })
 
   // Install once, then re-assert shortly after: other extensions' session_start handlers may draw after ours.
   installHeader(ctx)
@@ -136,20 +148,34 @@ export function createSession(pi: ExtensionAPI, ctx: ExtensionContext, deps: Ses
   ctx.ui.setHiddenThinkingLabel("◆ Thought")
   ctx.ui.setWorkingIndicator()
   for (const delay of [0, 50]) settleTimers.push(setTimeout(() => pin("session_settle"), delay))
-  if (process.env.HERDR_ENV === "1") void probeHerdr()
 
   return {
     id,
+    background,
+    backgroundShortcut: config.backgroundShortcut,
+    prs,
+    notePrUrls(text) {
+      if (!alive) return
+      const known = new Set(prs.sessionPrs())
+      for (const url of findPrUrls(text)) {
+        if (known.has(url)) continue
+        prs.addSessionPr(url)
+        try {
+          pi.appendEntry?.(PR_ENTRY_TYPE, { url })
+        } catch {
+          // A session that cannot accept entries just forgets the PR on restart.
+        }
+      }
+    },
     pin,
-    refreshGit(force) { if (alive) void gitState.refresh(force) },
+    refreshGit(force) { if (alive) { void gitState.refresh(force); void prs.refresh() } },
     dispose() {
       if (!alive) return
       alive = false
       for (const timer of settleTimers.splice(0)) clearTimeout(timer)
-      if (herdrTimer) clearInterval(herdrTimer)
-      herdrTimer = undefined
-      herdrInFlight?.abort()
-      herdrInFlight = undefined
+      background.dispose()
+      prs.dispose()
+      siblings?.dispose()
       siblings = undefined
       gitState.dispose()
       stopFooter()

package/src/siblings.ts

@@ -0,0 +1,38 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import { createHerdrSiblings } from "./herdr.js"
+import { createRexSiblings, type RexSpawn } from "./rex.js"
+
+/** One other agent in the same workspace, as shown on the status line. */
+export type Sibling = {
+  name: string
+  /** `idle | working | blocked | done | error`, or whatever the host reports; colour falls back to muted. */
+  status: string
+}
+
+/**
+ * Where sibling status comes from. `get()` is synchronous; `onChange` fires when the list may have
+ * changed so the status line can re-render; `dispose()` stops timers and child processes and makes
+ * late results inert.
+ */
+export type SiblingSource = {
+  get(): Sibling[] | undefined
+  onChange(listener: () => void): () => void
+  dispose(): void
+}
+
+export type SiblingSourceDeps = {
+  pi: ExtensionAPI
+  env?: NodeJS.ProcessEnv
+  spawn?: RexSpawn
+}
+
+/**
+ * Picks the host the session runs in. Herdr wins when both are present (Rex inside a Herdr pane):
+ * Herdr knows every agent it launched, Rex only the programs that report status.
+ */
+export function createSiblingSource(deps: SiblingSourceDeps): SiblingSource | undefined {
+  const env = deps.env ?? process.env
+  if (env.HERDR_ENV === "1") return createHerdrSiblings(deps.pi, env)
+  if (env.REX_SESSION && env.REX_BLOCK) return createRexSiblings({ pi: deps.pi, env, spawn: deps.spawn })
+  return undefined
+}