@yusukeshib/pi-babysit 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yusuke Shibata
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,105 @@
+# pi-babysit
+
+A [pi](https://github.com/earendil-works/pi) extension that runs **anything
+long-lived** under [babysit](https://github.com/yusukeshib/babysit)-supervised
+PTY sessions — one substrate for background processes **and** pi subagents.
+It retires both `@mjakl/pi-processes` (the `process` tool) and the old
+`pi-subagent` extension.
+
+## Install
+
+```sh
+pi install npm:@yusukeshib/pi-babysit
+```
+
+Then install the [`babysit`](https://github.com/yusukeshib/babysit) binary
+(the extension does **not** auto-install it):
+
+```sh
+cargo install --git https://github.com/yusukeshib/babysit
+```
+
+or grab a prebuilt binary from the
+[releases](https://github.com/yusukeshib/babysit/releases) and put it on your
+`PATH`. If it's missing, every tool and the `/babysit` command fail with these
+instructions.
+
+## The model
+
+Every session is a babysit worker owning a PTY, recording all output to a log,
+reachable from anywhere (`~/.pi-babysit/<pi-session-id>/`). Two kinds:
+
+| kind | started by | completion | on completion |
+| ---- | ---------- | ---------- | ------------- |
+| **process** | `babysit_run { command }` | process **exit** | automatic notification message (`triggerTurn`) — the agent may end its turn after starting and is resumed on exit, same contract as the old `process` tool |
+| **subagent** | `babysit_run { profile: "subagent", task }` | `agent_end` in the RPC event stream (process stays alive) | none — the agent polls `babysit_check` or blocks on `babysit_wait`; the idle session accepts follow-up tasks |
+
+The **profile is a tool parameter, not a separate tool set**: domain knowledge
+(RPC bookkeeping, per-task byte offsets, parked-turn detection, PTY-safe
+message delivery, spawn validation) lives in code, while the LLM sees one small
+generic surface.
+
+Because sessions are real PTYs, the agent can also **drive interactive
+programs** (installers, wizards, REPLs): type with `babysit_send`
+(text or named keys) and read the rendered screen with
+`babysit_check { screen: true }` — a capability neither retired extension had.
+
+## Tools (LLM-callable)
+
+| Tool | What it does |
+| ---- | ------------ |
+| `babysit_run` | Start a process (`command`, optional `name`/`pty`/`timeout`/`idleTimeout`) or a subagent (`profile: "subagent"`, `task`, optional `agent`/`model`/`tools`). Non-blocking; returns a session id |
+| `babysit_check` | List all sessions, or inspect one: process → state + log tail (or `screen: true` for TUIs); subagent → live progress (turns, recent tool calls, partial answer) |
+| `babysit_send` | Process: type `text` / press `keys` into the PTY. Subagent: steer mid-run, or send a follow-up task when idle (`mode: auto/steer/task`) |
+| `babysit_wait` | Block until done: process exit (or `expect: "regex"` readiness marker), subagent task completion. Multi-wait: `ids` + `mode: "any"\|"all"` |
+| `babysit_kill` | Terminate a session (suppresses the exit notification) |
+
+A `tool_call` hook also blocks bash commands that background themselves
+(`… &`, `nohup`, `setsid`, `disown`) and points the agent at `babysit_run`
+(carried over from pi-processes' `blockBackgroundCommands`).
+
+## Commands (human)
+
+| Command | What it does |
+| ------- | ------------ |
+| `/babysit` | Arrow-key picker over all sessions. Renders an **inline snapshot** (no tmux): running **process** → current rendered screen + recent output + a copy-paste `babysit attach` take-over hint (detach `Ctrl-\ Ctrl-\`); running **subagent** → read-only progress (RPC stdin stays untouchable); finished → summary. Re-run `/babysit` to refresh |
+
+A minimal widget above the editor shows live counts
+(`N processes · M subagents working · K idle`).
+
+## How completion detection works
+
+- **Process**: a 2.5s poller watches for running→exited transitions and injects
+  one `pi.sendMessage(…, { triggerTurn: true, deliverAs: "steer" })` per ended
+  session (deduped via `meta/<id>.json`). `babysit_kill` and an exit already
+  reported by `babysit_wait` suppress the notification.
+- **Subagent**: `babysit_wait` blocks on `babysit expect '"type":"agent_end"'`.
+  An `agent_end` whose last message is a **parked** toolResult — a
+  `babysit_run { command }` result carrying the `[notify-on-exit]` marker (or
+  the legacy `process` tool) — only means "turn parked awaiting a process-exit
+  notification; pi resumes on its own", so the wait continues. Any other
+  `agent_end` is real completion. Per-task byte offsets scope check/wait to the
+  CURRENT task, which is what makes follow-up tasks work.
+
+Subagents load `self-reap.ts`, which exits an idle finished subagent after a
+grace window (`PI_BABYSIT_REAP_AFTER`, default 120s) using the same parked-turn
+rule, so a subagent waiting on a long build is never false-killed.
+
+## Environment overrides
+
+| Var | Default | Purpose |
+| --- | ------- | ------- |
+| `PI_BABYSIT_DIR` | `~/.pi-babysit` | babysit state root (namespaced per pi session) |
+| `PI_BABYSIT_BIN` | `pi` | agent binary for subagents |
+| `PI_BABYSIT_CLI` | `babysit` | babysit binary |
+| `PI_BABYSIT_VIEW_CMD` | bundled `format-stream.mjs` | live-attach pretty printer for subagent JSONL (`""` disables) |
+| `PI_BABYSIT_REAP_AFTER` | `120s` | idle grace before a finished subagent self-exits (`off`/`none`/`0` disables) |
+
+Requires `babysit` and `pi` on `PATH`. The extension does **not** auto-install
+`babysit`: if the binary is missing, every tool and the `/babysit` command fail
+with install instructions (`cargo install --git https://github.com/yusukeshib/babysit`
+or a prebuilt release), and a warning is shown at session start. Point
+`$PI_BABYSIT_CLI` at a custom binary path if needed.
+
+(No tmux dependency — `/babysit` renders inline; take over a live process
+manually with the `babysit attach` command it shows.)

package/agents.ts

@@ -0,0 +1,124 @@
+/**
+ * Agent discovery. Adapted from pi's official subagent example.
+ * Loads markdown agent definitions with YAML frontmatter from
+ *   ~/.pi/agent/agents/*.md        (user, always)
+ *   <project>/.pi/agents/*.md       (project, only with scope project|both)
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import {
+	CONFIG_DIR_NAME,
+	getAgentDir,
+	parseFrontmatter,
+} from "@earendil-works/pi-coding-agent";
+
+export type AgentScope = "user" | "project" | "both";
+
+export interface AgentConfig {
+	name: string;
+	description: string;
+	tools?: string[];
+	model?: string;
+	systemPrompt: string;
+	source: "user" | "project";
+	filePath: string;
+}
+
+export interface AgentDiscoveryResult {
+	agents: AgentConfig[];
+	projectAgentsDir: string | null;
+}
+
+function loadAgentsFromDir(
+	dir: string,
+	source: "user" | "project",
+): AgentConfig[] {
+	const agents: AgentConfig[] = [];
+	if (!fs.existsSync(dir)) return agents;
+
+	let entries: fs.Dirent[];
+	try {
+		entries = fs.readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return agents;
+	}
+
+	for (const entry of entries) {
+		if (!entry.name.endsWith(".md")) continue;
+		if (!entry.isFile() && !entry.isSymbolicLink()) continue;
+
+		const filePath = path.join(dir, entry.name);
+		let content: string;
+		try {
+			content = fs.readFileSync(filePath, "utf-8");
+		} catch {
+			continue;
+		}
+
+		const { frontmatter, body } =
+			parseFrontmatter<Record<string, string>>(content);
+		if (!frontmatter.name || !frontmatter.description) continue;
+
+		const tools = frontmatter.tools
+			?.split(",")
+			.map((t) => t.trim())
+			.filter(Boolean);
+
+		agents.push({
+			name: frontmatter.name,
+			description: frontmatter.description,
+			tools: tools && tools.length > 0 ? tools : undefined,
+			model: frontmatter.model,
+			systemPrompt: body,
+			source,
+			filePath,
+		});
+	}
+	return agents;
+}
+
+function isDirectory(p: string): boolean {
+	try {
+		return fs.statSync(p).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+function findNearestProjectAgentsDir(cwd: string): string | null {
+	let currentDir = cwd;
+	while (true) {
+		const candidate = path.join(currentDir, CONFIG_DIR_NAME, "agents");
+		if (isDirectory(candidate)) return candidate;
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) return null;
+		currentDir = parentDir;
+	}
+}
+
+export function discoverAgents(
+	cwd: string,
+	scope: AgentScope,
+): AgentDiscoveryResult {
+	const userDir = path.join(getAgentDir(), "agents");
+	const projectAgentsDir = findNearestProjectAgentsDir(cwd);
+
+	const userAgents = scope === "project" ? [] : loadAgentsFromDir(userDir, "user");
+	const projectAgents =
+		scope === "user" || !projectAgentsDir
+			? []
+			: loadAgentsFromDir(projectAgentsDir, "project");
+
+	const agentMap = new Map<string, AgentConfig>();
+	if (scope === "both") {
+		for (const a of userAgents) agentMap.set(a.name, a);
+		for (const a of projectAgents) agentMap.set(a.name, a);
+	} else if (scope === "user") {
+		for (const a of userAgents) agentMap.set(a.name, a);
+	} else {
+		for (const a of projectAgents) agentMap.set(a.name, a);
+	}
+
+	return { agents: Array.from(agentMap.values()), projectAgentsDir };
+}

package/format-stream.mjs

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+/**
+ * format-stream.mjs — human-readable view for a `pi --mode json` event stream.
+ *
+ * babysit records the raw JSONL to its log (machine scrapers + `babysit log`
+ * stay untouched); this filter only sits on the interactive attach path via
+ * `babysit run --view-cmd`. It reads the JSONL on stdin and prints a colored,
+ * incrementally-streamed transcript on stdout so a human attaching the tmux
+ * pane sees turns, thinking, tool calls and answers instead of a JSON firehose.
+ */
+import * as readline from "node:readline";
+
+const C = {
+	reset: "\x1b[0m",
+	dim: "\x1b[2m",
+	bold: "\x1b[1m",
+	gray: "\x1b[90m",
+	cyan: "\x1b[36m",
+	green: "\x1b[32m",
+	yellow: "\x1b[33m",
+	red: "\x1b[31m",
+	blue: "\x1b[34m",
+};
+// The attach client terminal is in raw mode (OPOST off), so a bare "\n"
+// moves down without returning to column 0 and the transcript stair-steps.
+// Normalize every newline (including ones inside model text) to "\r\n".
+const out = (s) => process.stdout.write(String(s).replace(/\r?\n/g, "\r\n"));
+const trunc = (s, n = 72) => {
+	s = String(s ?? "");
+	return s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
+};
+
+function summarizeTool(name, a = {}) {
+	switch (name) {
+		case "bash":
+			return `$ ${trunc(a.command)}`;
+		case "read":
+			return `read ${trunc(a.file_path ?? a.path)}`;
+		case "write":
+			return `write ${trunc(a.file_path ?? a.path)}`;
+		case "edit":
+			return `edit ${trunc(a.file_path ?? a.path)}`;
+		case "grep":
+			return `grep /${trunc(a.pattern, 40)}/`;
+		case "find":
+			return `find ${trunc(a.pattern ?? a.path, 40)}`;
+		case "ls":
+			return `ls ${trunc(a.path)}`;
+		default:
+			return trunc(JSON.stringify(a), 48);
+	}
+}
+
+// Join the text of a given block kind ("text" or "thinking") in a message's
+// content array. message_update re-emits the whole (growing) message, so we
+// compare lengths against what we've already printed to append only the delta.
+function blockText(content, kind) {
+	if (!Array.isArray(content)) return "";
+	let s = "";
+	for (const c of content) {
+		if (kind === "text" && c.type === "text" && c.text) s += c.text;
+		if (kind === "thinking" && c.type === "thinking") s += c.thinking ?? c.text ?? "";
+	}
+	return s;
+}
+
+const emitted = new Map(); // id -> {think, text, hThink, hText}
+let turn = 0;
+
+// Every visual unit (thinking, answer, tool call, error) is a "block": it
+// starts with a marker glyph on its own line. openBlock() is the single
+// place that emits the line break, so spacing stays consistent no matter
+// the event order — one block per line group, no blank lines in between.
+const openBlock = () => {
+	out("\n");
+};
+
+function streamMessage(msg, fresh = false) {
+	if (!msg || msg.role !== "assistant") return;
+	const id = msg.id ?? `t${turn}`;
+	if (fresh) emitted.delete(id);
+	let st = emitted.get(id);
+	if (!st) {
+		st = { think: 0, text: 0, hThink: false, hText: false };
+		emitted.set(id, st);
+	}
+	const think = blockText(msg.content, "thinking");
+	if (think.length > st.think) {
+		if (!st.hThink) {
+			openBlock();
+			out(`${C.gray}[think] `);
+			st.hThink = true;
+		}
+		out(C.gray + think.slice(st.think) + C.reset);
+		st.think = think.length;
+	}
+	const text = blockText(msg.content, "text");
+	if (text.length > st.text) {
+		if (!st.hText) {
+			openBlock();
+			out(`${C.green}[text]${C.reset} `);
+			st.hText = true;
+		}
+		out(text.slice(st.text));
+		st.text = text.length;
+	}
+}
+
+function usageLine(msg) {
+	const u = msg?.usage;
+	if (!u) return;
+	const tok = u.totalTokens ?? u.total_tokens;
+	const cost = u.cost?.total;
+	const bits = [];
+	if (tok != null) bits.push(`${tok} tok`);
+	if (cost != null) bits.push(`$${Number(cost).toFixed(4)}`);
+	if (msg.stopReason && msg.stopReason !== "stop") bits.push(msg.stopReason);
+	if (bits.length) out(`\n${C.gray}${C.dim}[usage] ${bits.join(" \u00b7 ")}${C.reset}`);
+}
+
+const rl = readline.createInterface({ input: process.stdin });
+rl.on("line", (line) => {
+	line = line.trim();
+	if (!line.startsWith("{")) return;
+	let ev;
+	try {
+		ev = JSON.parse(line);
+	} catch {
+		return;
+	}
+	switch (ev.type) {
+		case "turn_start":
+			// Turn separators are noise in the attach view; message/tool blocks
+			// already delimit the flow. `turn` still feeds streamMessage's id fallback.
+			turn++;
+			break;
+		case "message_start":
+			streamMessage(ev.message, true);
+			break;
+		case "message_update":
+			streamMessage(ev.message);
+			break;
+		case "message_end":
+			streamMessage(ev.message);
+			usageLine(ev.message);
+			break;
+		case "tool_execution_start":
+			openBlock();
+			out(
+				`${C.cyan}[tool]${C.reset} ${ev.toolName} ${C.dim}${summarizeTool(ev.toolName, ev.args ?? {})}${C.reset}`,
+			);
+			break;
+		case "tool_execution_end": {
+			const err = ev.isError || ev.error;
+			if (err)
+				out(`\n${C.red}[error] ${trunc(ev.error?.message ?? ev.error ?? "tool error", 80)}${C.reset}`);
+			break;
+		}
+		case "error":
+			openBlock();
+			out(`${C.red}[error] ${trunc(ev.message ?? ev.error ?? JSON.stringify(ev), 120)}${C.reset}`);
+			break;
+		default:
+			break; // session_start/info/shutdown/tree/user/compact: quietly ignored
+	}
+});
+rl.on("close", () => out("\n"));