@tduyng/pi-shell 0.0.1 → 0.0.2

package/README.md

@@ -46,6 +46,10 @@ Only a task the model parked on (via `wait: "exit"` or `wait: "next_write"`) inj
 
 The wake fires from the `onExit` callback via `queueMicrotask`, not from polling. If the agent is mid-turn, the wake lands in the follow-up queue and is delivered at the next `agent_settled` boundary.
 
+## Stall check
+
+A task the model parked on with `wait: "exit"` also gets a silence check. Every 30 seconds it reads the log size. After 10 minutes with no new bytes, the agent is woken once with the elapsed time and the log path. The wake fires again only after output resumes and stops again. No model call runs for the check.
+
 ## Footer indicator
 
 The footer shows a dot and the live task count (e.g. "2 bg running") while any background task is active. It clears when the last task exits.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tduyng/pi-shell",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Background processes the agent parks on: one bg tool with start/output/kill/status, cursor reads that never re-read bytes, and a runtime wake-up when a task exits.",
   "keywords": [
     "pi",

package/src/index.ts

@@ -16,6 +16,7 @@ import {
     killTask,
     middleOut,
     benignExitNote,
+    isNoMatchCommand,
     pidForPort,
     readNewBytes,
     readUnreadTail,
@@ -23,6 +24,7 @@ import {
     spawnTask,
     watchForWrite
 } from './process.js'
+import { watchStall } from './stall.js'
 import type { TaskRecord } from './process.js'
 const isString = new Validator(t.string()).isValidObject
 
@@ -95,7 +97,7 @@ export async function buildWakeText(records: TaskRecord[], budget = WAKE_TAIL_MA
 }
 
 export async function sendBackgroundWake(pi: Pick<ExtensionAPI, 'sendMessage'>, text: string): Promise<void> {
-    pi.sendMessage(
+    await pi.sendMessage(
         { customType: WAKE_TYPE, content: text, display: true },
         { deliverAs: 'followUp', triggerTurn: true }
     )
@@ -116,8 +118,7 @@ async function flushWakes(pi: ExtensionAPI): Promise<boolean> {
 
 function isBenignNoMatch(rec: Pick<TaskRecord, 'command' | 'exitCode' | 'signal'>): boolean {
     if (rec.exitCode !== 1 || rec.signal !== null) return false
-    const cmd = rec.command.trim()
-    return /^(grep|rg|find)\b/.test(cmd) || /\b(grep|rg)\b/.test(cmd)
+    return isNoMatchCommand(rec.command)
 }
 
 interface PersistedTask {
@@ -226,6 +227,14 @@ async function bgAction(pi: ExtensionAPI, ctx: ExtensionContext, params: BgInput
             )
         }
 
+        if (!rec.wakeRequested) {
+            watchStall(rec, (silentMs) => {
+                void sendBackgroundWake(
+                    pi,
+                    `bg task ${params.task_id} has written no output for ${Math.round(silentMs / 60000)} min and is still running. Check its log, or kill it if it is stuck. ${LOG_PREFIX}${rec.logPath}`
+                ).catch(() => undefined)
+            })
+        }
         rec.wakeRequested = true
         return textResult(
             `Watching task ${params.task_id} (bytes ${read.start}-${read.end} of ${read.size}). ` +

package/src/process.ts

@@ -1,7 +1,7 @@
 import { spawn } from 'node:child_process'
 import type { ChildProcess } from 'node:child_process'
 import { randomUUID } from 'node:crypto'
-import { createWriteStream, mkdirSync, readdirSync, statSync, unlinkSync, watch } from 'node:fs'
+import { appendFileSync, createWriteStream, mkdirSync, readdirSync, statSync, unlinkSync, watch } from 'node:fs'
 import type { WriteStream } from 'node:fs'
 import { open, stat } from 'node:fs/promises'
 import { basename, join } from 'node:path'
@@ -131,6 +131,7 @@ export function spawnTask(options: SpawnOptions): TaskRecord {
     mkdirSync(logDirPath, { recursive: true })
     sweepTaskLogs(logDirPath, Date.now())
     const logPath = join(logDirPath, `${taskId}.log`)
+    appendFileSync(logPath, '')
     const stream: WriteStream = createWriteStream(logPath, { flags: 'a' })
 
     const shell = resolveShell()
@@ -381,6 +382,7 @@ export function watchForWrite(
     let pollTimer: ReturnType<typeof setInterval> | undefined
     let settled = false
     let checking: Promise<boolean> | undefined
+    let pending = false
 
     const stopPolling = () => {
         if (pollTimer) clearInterval(pollTimer)
@@ -394,7 +396,10 @@ export function watchForWrite(
     }
 
     const check = (): Promise<boolean> => {
-        if (checking) return checking
+        if (checking) {
+            pending = true
+            return checking
+        }
         checking = (async (): Promise<boolean> => {
             if (settled) return false
             try {
@@ -409,6 +414,10 @@ export function watchForWrite(
             }
         })().finally(() => {
             checking = undefined
+            if (pending && !settled) {
+                pending = false
+                void check()
+            }
         })
         return checking
     }
@@ -434,9 +443,7 @@ export function watchForWrite(
 
     const exitBridge = () => {
         if (settled) return
-        void (checking ?? Promise.resolve(false))
-            .then(() => check())
-            .then(finishWithoutOutput)
+        void (checking ?? Promise.resolve(false)).then(() => check()).then(finishWithoutOutput)
     }
     rec.exitWaiters.add(exitBridge)
 
@@ -472,7 +479,7 @@ export function benignExitNote(
     raisedText: string
 ): string | undefined {
     if (!isError) return undefined
-    if (exitCode === 1 && /\b(?:grep|rg)\b/.test(command)) {
+    if (exitCode === 1 && isNoMatchCommand(command)) {
         return '\n[Note: exit 1 here means no matches found, not an error.]'
     }
     if (exitCode === undefined && /^Command timed out after\b/.test(raisedText.trimEnd().split('\n').at(-1) ?? '')) {
@@ -481,6 +488,10 @@ export function benignExitNote(
     return undefined
 }
 
+export function isNoMatchCommand(command: string): boolean {
+    return /^(?:grep|rg)\b[^|&;\n]*$/.test(command.trim())
+}
+
 export function middleOut(text: string, maxBytes: number): MiddleOutView {
     const total = Buffer.byteLength(text, 'utf8')
     if (total <= maxBytes) {

package/src/stall.ts

@@ -0,0 +1,46 @@
+import { statSync } from 'node:fs'
+
+import { registry } from './process.js'
+import type { TaskRecord } from './process.js'
+
+export const STALL_MS = 10 * 60 * 1000
+const STALL_CHECK_MS = 30 * 1000
+
+export interface StallState {
+    size: number
+    since: number
+    reported: boolean
+}
+
+export interface StallStep {
+    next: StallState
+    report: boolean
+}
+
+export function advanceStall(prev: StallState, size: number, now: number): StallStep {
+    if (size !== prev.size) return { next: { size, since: now, reported: false }, report: false }
+    if (prev.reported || now - prev.since < STALL_MS) return { next: prev, report: false }
+    return { next: { ...prev, reported: true }, report: true }
+}
+
+export function watchStall(rec: TaskRecord, onStall: (silentMs: number) => void): void {
+    let state: StallState = { size: -1, since: Date.now(), reported: false }
+    const timer = setInterval(() => {
+        const live = registry.get(rec.taskId)
+        if (!live || live.exitCode !== null || live.signal !== null) {
+            clearInterval(timer)
+            return
+        }
+        let size: number
+        try {
+            size = statSync(rec.logPath).size
+        } catch {
+            return
+        }
+        const now = Date.now()
+        const step = advanceStall(state, size, now)
+        state = step.next
+        if (step.report) onStall(now - state.since)
+    }, STALL_CHECK_MS)
+    timer.unref()
+}