pi-background 0.3.2 → 0.4.0

package/README.md

@@ -14,11 +14,11 @@ pi install npm:pi-background
 ## Features
 
 - Long commands like downloads, builds, test suites and training runs go to the background, and Pi hears back with the exit code and the end of the output when they finish.
-- While a job runs, a line above the input shows it with its elapsed time and latest output, such as `⏵ bg1 python3 train.py · 4m12s · epoch 3/10 loss 0.41`.
-- `/bg` shows a job's last 20 lines of output, updating while it runs (`/bg bg2` for a specific job). Press esc to close it.
+- While a job runs, a line above the input shows it with its elapsed time and latest output, such as `⏵ bg1 python3 train.py · 4m12s · epoch 3/10 loss 0.41`. A job that has printed nothing for 10 minutes shows `no output for 12m30s` instead, so a stuck one stands out.
+- `/bg` shows a job's last 20 lines of output, updating while it runs (`/bg bg2` for a specific job). Press esc to close it. Its list shows running jobs first, then the 10 latest finished ones.
 - Pi can wait for a specific line, such as a dev server's `listening on` or a training run's `epoch 3`, without checking again and again.
 - Jobs started together are reported together: when Pi starts several jobs at once, such as benchmarks to compare, it's woken once when the last one finishes instead of after each. You can keep chatting meanwhile, and a job that runs much longer doesn't hold the others back for more than 2 minutes.
-- Regular commands time out after 2 minutes, unless Pi asks for longer (up to 10), so Pi never hangs on a stuck command. Commands that start their own background process with `&` are left alone.
+- A regular shell command still running after 2 minutes moves to the background on its own, so a slow command Pi didn't expect never holds up the turn. It shows in the jobs line, and Pi hears back when it ends. Press `ctrl+b` to move a running command to the background sooner. If another extension already replaces Pi's bash, such as a sandbox, pi-background leaves it alone.
 
 You don't need to do anything differently: Pi decides when a job belongs in the background. You can also ask for it, for example "run the tests in the background and tell me when they're done".
 

package/extensions/background.ts

@@ -1,17 +1,24 @@
 import { createWriteStream, mkdirSync, readFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
-import { createLocalBashOperations, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Key, matchesKey, stripTerminalSequences, Text, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { type BashOperations, createBashToolDefinition, createLocalBashOperations, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Key, matchesKey, stripTerminalSequences, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
+import { shortCommand } from "./command.ts";
 
 const TAIL_LINES = 20;
 const TAIL_BYTES = 64 * 1024;
-const BASH_DEFAULT_TIMEOUT = 120;
-const BASH_MAX_TIMEOUT = 600;
+// A bash command still running after this long moves to the background, so it no longer blocks the turn
+const AUTO_BACKGROUND_SECS = 120;
 const WAKE_DEBOUNCE_MS = 1000;
 const MAX_WAKES = 10;
 const MAX_SHOWN_JOBS = 3;
+// A running job silent this long shows how long it has been quiet, since it may be stuck
+const SILENT_AFTER_MS = 10 * 60_000;
+// Finished jobs listed by /bg; older ones stay reachable as /bg <id>
+const MAX_LISTED_FINISHED = 10;
+// How long a bash command runs before the jobs line offers ctrl+b, so quick commands don't flash it
+const HINT_AFTER_MS = 3000;
 // How long finished results wait for jobs started alongside them before Pi is woken anyway
 const GROUP_HOLD_MS = 2 * 60_000;
 
@@ -26,6 +33,8 @@ interface Job {
 	ended?: number;
 	// The latest output line, shown while the job runs
 	lastLine?: string;
+	// When the job last printed anything
+	lastOutput?: number;
 	// The turn that started the job; jobs from the same turn are reported together
 	group: number;
 	// Started with wake_on, so it may run indefinitely and doesn't hold back the others
@@ -41,9 +50,16 @@ function tail(path: string, lines: number): string {
 	}
 }
 
+/** 45s, 12m30s, or 1h20m once seconds no longer matter. */
+function duration(ms: number): string {
+	const s = Math.round(ms / 1000);
+	if (s < 60) return `${s}s`;
+	if (s < 3600) return `${Math.floor(s / 60)}m${s % 60}s`;
+	return `${Math.floor(s / 3600)}h${Math.floor(s / 60) % 60}m`;
+}
+
 function elapsed(job: Job): string {
-	const s = Math.round(((job.ended ?? Date.now()) - job.started) / 1000);
-	return s < 60 ? `${s}s` : `${Math.floor(s / 60)}m${s % 60}s`;
+	return duration((job.ended ?? Date.now()) - job.started);
 }
 
 function state(job: Job): string {
@@ -65,32 +81,26 @@ function shownCommand(command: string): string {
 	const shown = command
 		.split("\n")[0]
 		.replace(/^\s*(cd\s+("[^"]*"|'[^']*'|\S+)\s*(&&|;)\s*)+/, "")
+		// Leading settings such as PYTHONPATH=/some/src, which the path shortening below would cut at their last /
+		.replace(/^(\w+=("[^"]*"|'[^']*'|\S*)\s+)+/, "")
 		.replace(/^\S*\/(?=[^\s/]+(\s|$))/, "");
 	return shown.length > 50 ? `${shown.slice(0, 49)}…` : shown;
 }
 
-/** True when a command starts a job with a bare & (not &&, 2>&1, &> or |&). */
-function startsBackgroundJob(command: string): boolean {
-	return /&/.test(command.replace(/&&|[0-9]*>&[0-9-]*|&>>?|\|&/g, ""));
-}
-
 /** Compiles wake_on, accepting Python's (?i) prefix that models often write but JavaScript only takes as a flag. */
 function wakePattern(source: string): RegExp {
 	const insensitive = source.startsWith("(?i)");
 	return new RegExp(insensitive ? source.slice(4) : source, insensitive ? "i" : "");
 }
 
-export default function (pi: ExtensionAPI) {
-	// Pi's bash has no default timeout, so a stuck or polling command blocks until interrupted; cap it like Claude Code
-	// does. A timeout SIGKILLs the command's whole process group, which would include jobs it started with &, so a
-	// command that backgrounds something is never timed out, even if the model asked for a timeout.
-	pi.on("tool_call", async (event) => {
-		if (event.toolName !== "bash") return;
-		const input = event.input as { command?: string; timeout?: number };
-		if (startsBackgroundJob(String(input.command ?? ""))) delete input.timeout;
-		else input.timeout = Math.min(input.timeout ?? BASH_DEFAULT_TIMEOUT, BASH_MAX_TIMEOUT);
-	});
+/** Thrown by the bash operations below when a command moves to the background, carrying the job and its output so far. */
+class MovedToBackground extends Error {
+	constructor(readonly job: { id: string; log: string; started: number }, readonly output: string) {
+		super(`moved to background as ${job.id}`);
+	}
+}
 
+export default function (pi: ExtensionAPI) {
 	const jobs = new Map<string, Job>();
 	const ops = createLocalBashOperations();
 	let next = 1;
@@ -110,6 +120,14 @@ export default function (pi: ExtensionAPI) {
 		[...jobs.values()].filter((other) => other !== job && other.group === job.group && other.status === "running" && !other.watched);
 	const report = (job: Job, content: string, details: { headline: string; last: string; error: boolean }) => {
 		const others = job.watched ? [] : runningInGroup(job);
+		// Only Pi stops jobs, with bg_kill, so it already knows; the message is added without waking it again
+		if (job.status === "killed") {
+			if (others.length === 0) {
+				clearTimeout(holds.get(job.group));
+				holds.delete(job.group);
+			}
+			return wake(content, details, false);
+		}
 		// A failure wakes Pi straight away, so it can react before the rest of the group finishes
 		if (others.length === 0 || details.error) {
 			clearTimeout(holds.get(job.group));
@@ -179,19 +197,24 @@ export default function (pi: ExtensionAPI) {
 		}
 		redrawJobs();
 	};
+	// Running bash commands that ctrl+b can move to the background now, by tool call id, once they have run for
+	// HINT_AFTER_MS. Shared so pi-polish can show the hint under the command's row instead of in the jobs line.
+	const hinted = new Map<string, () => void>();
+	(globalThis as any)[Symbol.for("pi-background.movable")] = hinted;
+	let stopCtrlB = () => {};
 	const jobsWidget = (theme: any) => ({
 		invalidate() {},
 		render(width: number) {
 			if (jobsLine() === "off") return [];
 			const live = running().filter((job) => job !== viewing);
 			const lines = live.slice(0, MAX_SHOWN_JOBS).map((job) => {
-				const text =
-					theme.fg("accent", "⏵ ") +
-					theme.fg("toolTitle", `${job.id} ${shownCommand(job.command)}`) +
-					theme.fg("dim", ` · ${elapsed(job)}${jobsLine() === "full" && job.lastLine ? ` · ${job.lastLine}` : ""}`);
+				const silent = Date.now() - (job.lastOutput ?? job.started);
+				const detail = silent >= SILENT_AFTER_MS ? ` · no output for ${duration(silent)}` : jobsLine() === "full" && job.lastLine ? ` · ${job.lastLine}` : "";
+				const text = theme.fg("accent", "⏵ ") + theme.fg("toolTitle", `${job.id} ${shownCommand(job.command)}`) + theme.fg("dim", ` · ${elapsed(job)}${detail}`);
 				return truncateToWidth(text, width);
 			});
 			if (live.length > MAX_SHOWN_JOBS) lines.push(theme.fg("dim", `  and ${live.length - MAX_SHOWN_JOBS} more`));
+			if (hinted.size > 0 && !(globalThis as any)[Symbol.for("pi-polish.showsMoveHint")]) lines.push(theme.fg("dim", "  ctrl+b to run in background"));
 			return lines;
 		},
 	});
@@ -204,24 +227,179 @@ export default function (pi: ExtensionAPI) {
 
 	// Compact, Claude-Code-style rows instead of pi's default boxed tool and message rendering: quiet grey once done,
 	// with a dot only while running or when something failed
+	// "  └ text" in dim, with long and extra lines wrapped under the text instead of at the left edge
+	const branch = (theme: any, text: string, head?: string) => ({
+		invalidate() {},
+		render: (width: number) => [
+			...(head ? [truncateToWidth(head, width)] : []),
+			...wrapTextWithAnsi(text, Math.max(10, width - 4)).map((line, i) => theme.fg("dim", `${i === 0 ? "  └ " : "    "}${line}`)),
+		],
+	});
 	pi.registerMessageRenderer("background-job", (message, { expanded }, theme) => {
 		const d = (message.details ?? {}) as { headline?: string; last?: string; error?: boolean };
 		const title = `Background ${d.headline ?? ""}`;
 		const head = d.error ? theme.fg("error", "● ") + theme.fg("toolTitle", title) : `  ${theme.fg("dim", title)}`;
-		const body = expanded ? String(message.content) : (d.last ?? "");
-		return new Text(`${head}\n${theme.fg("dim", `  └ ${body.replace(/\n/g, "\n    ")}`)}`, 0, 0);
+		return branch(theme, expanded ? String(message.content) : (d.last ?? ""), head);
+	});
+	// One line, like pi-polish's shell rows; expanded (ctrl+o) shows the whole text, wrapped under the row
+	const row = (theme: any, text: string, context: any, full = text) => ({
+		invalidate() {},
+		render(width: number) {
+			const color = context.isError ? "error" : context.executionStarted && context.isPartial ? "accent" : undefined;
+			const mark = color ? theme.fg(color, "● ") : "  ";
+			const paint = (line: string) => theme.fg(color ? "toolTitle" : "dim", line);
+			if (!context.expanded) return [mark + paint(truncateToWidth(text, Math.max(10, width - 2)))];
+			return wrapTextWithAnsi(full, Math.max(10, width - 2)).map((line, i) => (i === 0 ? mark : "  ") + paint(line));
+		},
 	});
-	const row = (theme: any, text: string, context: any) => {
-		const color = context.isError ? "error" : context.executionStarted && context.isPartial ? "accent" : undefined;
-		return new Text(color ? theme.fg(color, "● ") + theme.fg("toolTitle", text) : `  ${theme.fg("dim", text)}`, 0, 0);
-	};
 	const note = (theme: any, result: any, expanded: boolean) => {
 		const text = result.content?.map((c: any) => c.text ?? "").join("\n") ?? "";
 		// Collapsed: first sentence only ("Started bg1"), without the log path
 		const short = text.split("\n")[0].split(";")[0];
-		return new Text(theme.fg("dim", `  └ ${(expanded ? text : short).replace(/\n/g, "\n    ")}`), 0, 0);
+		return branch(theme, expanded ? text : short);
+	};
+
+	// Starts tracking a job: its output goes to a log and the jobs line, and Pi is told when run's promise settles.
+	// A bash command that moves to the background brings its start time and the output it printed before.
+	const startJob = (
+		command: string,
+		pattern: RegExp | undefined,
+		controller: AbortController,
+		run: (onData: (d: Buffer) => void) => Promise<{ exitCode: number | null }>,
+		earlier?: { started: number; output: Buffer; lastOutput?: number },
+	) => {
+		const id = `bg${next++}`;
+		const dir = join(tmpdir(), "pi-bg");
+		mkdirSync(dir, { recursive: true });
+		const log = join(dir, `${process.pid}-${id}.log`);
+		const out = createWriteStream(log);
+		const job: Job = { id, command, log, started: earlier?.started ?? Date.now(), controller, status: "running", group: turn, watched: Boolean(pattern) };
+		jobs.set(id, job);
+
+		const watch = pattern ? watcher(job, pattern) : undefined;
+		const onData = (d: Buffer) => {
+			out.write(d);
+			watch?.(d);
+			job.lastOutput = Date.now();
+			const last = d.toString("utf8").split("\n").map(cleanLine).filter((line) => line.trim()).at(-1)?.trim();
+			if (last) job.lastLine = last;
+		};
+		if (earlier?.output.length) {
+			onData(earlier.output);
+			job.lastOutput = earlier.lastOutput;
+		}
+
+		run(onData)
+			.then(({ exitCode }) => {
+				job.status = "exited";
+				job.exitCode = exitCode;
+			})
+			.catch((err: Error) => {
+				job.status = controller.signal.aborted ? "killed" : "failed";
+				out.write(`\n[bg] ${err.message}\n`);
+			})
+			.finally(() => {
+				job.ended = Date.now();
+				showJobs();
+				out.end(() => {
+					// A kill from session shutdown has no session left to notify
+					if (job.status === "killed" && !jobs.has(id)) return;
+					report(job, `Background job finished: ${summary(job)}\nLast lines:\n${tail(log, TAIL_LINES)}`, {
+						headline: `${id} ${job.status === "exited" ? `exited ${job.exitCode}` : job.status} · ${elapsed(job)}`,
+						last: tail(log, 1),
+						error: job.status !== "exited" || job.exitCode !== 0,
+					});
+				});
+			});
+
+		showJobs();
+		return job;
 	};
 
+	// Pi's bash, except that a command still running after AUTO_BACKGROUND_SECS becomes a background job
+	// instead of blocking the turn until it ends or times out. The command keeps running in the same
+	// process; its output so far goes to the job's log, and Pi gets the usual message when it exits.
+	const handoff = (local: BashOperations, toolCallId: string): BashOperations => ({
+		exec(command, cwd, options) {
+			// Pi's own check, which its exec would otherwise have made
+			if (options.timeout !== undefined && !(Number.isFinite(options.timeout) && options.timeout > 0)) {
+				return Promise.reject(new Error("Invalid timeout: must be a finite number of seconds"));
+			}
+			const started = Date.now();
+			// Its own signal, so a job outlives the turn; until then the turn's abort is passed on
+			const controller = new AbortController();
+			const forward = () => controller.abort();
+			if (options.signal?.aborted) controller.abort();
+			options.signal?.addEventListener("abort", forward, { once: true });
+			// The output so far goes to the job's log; only its last TAIL_BYTES are kept, like the log tails
+			let earlier = Buffer.alloc(0);
+			let lastOutput: number | undefined;
+			let sink = (d: Buffer) => {
+				earlier = Buffer.concat([earlier, d]).subarray(-TAIL_BYTES);
+				lastOutput = Date.now();
+				options.onData(d);
+			};
+			const env = { ...(options.env ?? process.env), PYTHONUNBUFFERED: "1" };
+			// A timeout moves the command to the background sooner rather than stopping it, so its work isn't lost
+			const after = Math.min(options.timeout ?? AUTO_BACKGROUND_SECS, AUTO_BACKGROUND_SECS);
+			const running = local.exec(command, cwd, { onData: (d) => sink(d), signal: controller.signal, env });
+			return new Promise((resolve, reject) => {
+				let timer: NodeJS.Timeout | undefined;
+				let hint: NodeJS.Timeout | undefined;
+				const settle = () => {
+					clearTimeout(timer);
+					clearTimeout(hint);
+					options.signal?.removeEventListener("abort", forward);
+					if (hinted.delete(toolCallId)) redrawJobs();
+				};
+				const move = () => {
+					settle();
+					const output = earlier;
+					const job = startJob(command, undefined, controller, (onData) => {
+						sink = onData;
+						return running;
+					}, { started, output, lastOutput });
+					reject(new MovedToBackground(job, output.toString("utf8")));
+				};
+				timer = setTimeout(move, after * 1000);
+				hint = setTimeout(() => {
+					hinted.set(toolCallId, move);
+					redrawJobs();
+				}, HINT_AFTER_MS);
+				running.then(resolve, reject).finally(settle);
+			});
+		},
+	});
+	// Only Pi's own bash is wrapped; one that another extension replaced, such as a sandbox's, is left alone. By
+	// session_start every extension has registered its tools, whichever order they loaded in.
+	let wrapped = false;
+	pi.on("session_start", async () => {
+		if (wrapped || !pi.getAllTools().find((tool) => tool.name === "bash")?.sourceInfo.path.startsWith("builtin:")) return;
+		wrapped = true;
+		const pisBash = createBashToolDefinition(process.cwd());
+		pi.registerTool({
+			...pisBash,
+			promptGuidelines: [
+				...(pisBash.promptGuidelines ?? []),
+				`A bash command still running after ${AUTO_BACKGROUND_SECS} seconds, or after its timeout if that is shorter, moves to the background on its own, as if started with bg_run, and you get its job id instead of its output; it is not stopped. Still start a command you expect to take that long with bg_run, so you choose wake_on and the turn isn't held up first.`,
+			],
+			async execute(toolCallId, params, signal, onUpdate, ctx) {
+				// Built per call from the same settings Pi builds its own bash from
+				const { shellPath, shellCommandPrefix } = pi.getSettings();
+				const bash = createBashToolDefinition(ctx.cwd, { commandPrefix: shellCommandPrefix, operations: handoff(createLocalBashOperations({ shellPath }), toolCallId) });
+				try {
+					return await bash.execute(toolCallId, params, signal, onUpdate, ctx);
+				} catch (err) {
+					if (!(err instanceof MovedToBackground)) throw err;
+					const { id, log, started } = err.job;
+					const soFar = err.output.trimEnd().split("\n").slice(-TAIL_LINES).join("\n") || "(no output)";
+					const text = `Still running after ${duration(Date.now() - started)}, so it moved to the background as ${id}. You will be notified when it exits; check it with bg_status, or stop it with bg_kill if it shouldn't take this long.\nOutput so far:\n${soFar}\nlog: ${log}`;
+					return { content: [{ type: "text", text }], details: undefined };
+				}
+			},
+		});
+	});
+
 	pi.registerTool({
 		name: "bg_run",
 		label: "Background",
@@ -236,71 +414,39 @@ export default function (pi: ExtensionAPI) {
 			"When unsure whether a command is quick, prefer bg_run: a quick job just reports back sooner, while a long bash command blocks the user until it finishes.",
 			"After bg_run, continue with independent work or end your turn; a message with the exit code and log tail arrives automatically when the job exits, so never sleep, poll or tail the log to wait for it.",
 			"Keep using bash for quick commands whose output you need right away, such as git, ls, cat, grep, find, file inspection and short checks.",
-			"Pass wake_on only when you must act before a bg_run job ends, such as a server becoming ready to test against, or when the user asked to follow its progress. To report a job's result, leave wake_on out: the exit message already brings the exit code and last lines, so waking on every epoch or step only adds turns.",
+			"Pass wake_on only when you must act before a bg_run job ends, such as a server becoming ready to test against, or when the user asked to follow its progress. Make it a pattern for that one event, which matches once, not a line the job prints for every item, file, epoch or step. To report a job's result, leave wake_on out: the exit message already brings the exit code and last lines.",
 			"Don't redirect a bg_run command's output to a file (> file, 2>&1, nohup): bg_run already saves all of it to the job's log, and redirecting hides the job's progress from the user and from wake_on. If the output should be kept, tell the user where the job's log is.",
 			"bg_run starts only after the other tool calls in the same reply have finished, so editing a file and starting a job that uses it in one reply is safe.",
 			"Use bg_status to check progress of a bg_run job and bg_kill to stop one.",
-			`bash commands time out after ${BASH_DEFAULT_TIMEOUT / 60} minutes unless you pass timeout (at most ${BASH_MAX_TIMEOUT / 60} minutes); run anything that may take longer with bg_run instead.`,
 			"Unless the user explicitly asks for that bash command, never wait, poll or sleep in bash (while/until loops with sleep, watch, repeated status checks), not even as part of a larger command; start the wait with bg_run and pass wake_on to be woken when the awaited output appears.",
 			"Unless the user explicitly asks otherwise, start long-running processes (training or evaluation runs, servers, watchers) with bg_run, not with & or nohup in bash followed by sleep.",
 		],
 		// Runs after the edits in the same reply, so the job starts from the code pi just wrote
 		executionMode: "sequential",
 		renderShell: "self",
-		renderCall: (args: any, theme, context) => row(theme, `Background $ ${String(args?.command ?? "").split("\n")[0]}`, context),
+		renderCall: (args: any, theme, context) => {
+			const command = String(args?.command ?? "");
+			// Collapsed, without leading settings such as PYTHONPATH=/some/src, like the jobs line; ctrl+o shows them
+			const short = shortCommand(command, args?.cwd ?? process.cwd()).replace(/^(\w+=("[^"]*"|'[^']*'|\S*)\s+)+/, "");
+			return row(theme, `Background $ ${short}`, context, `Background $ ${command.trim()}`);
+		},
 		renderResult: (result, { expanded }, theme) => note(theme, result, expanded),
 		parameters: Type.Object({
 			command: Type.String({ description: "Shell command to run" }),
 			cwd: Type.Optional(Type.String({ description: "Working directory (defaults to the session cwd)" })),
 			wake_on: Type.Optional(
 				Type.String({
-					description: "Regex; also wake you while the job runs whenever an output line matches, e.g. 'listening on|ready'. Matches within a second are batched; at most 10 wake-ups per job.",
+					description: `Regex; also wake you while the job runs whenever an output line matches, e.g. 'listening on|ready'. Matches within a second are batched; at most ${MAX_WAKES} wake-ups per job.`,
 				}),
 			),
 		}),
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
 			const pattern = params.wake_on ? wakePattern(params.wake_on) : undefined;
-			const id = `bg${next++}`;
-			const dir = join(tmpdir(), "pi-bg");
-			mkdirSync(dir, { recursive: true });
-			const log = join(dir, `${process.pid}-${id}.log`);
-			const out = createWriteStream(log);
-			const job: Job = { id, command: params.command, log, started: Date.now(), controller: new AbortController(), status: "running", group: turn, watched: Boolean(pattern) };
-			jobs.set(id, job);
-
-			const watch = pattern ? watcher(job, pattern) : undefined;
-			const onData = (d: Buffer) => {
-				out.write(d);
-				watch?.(d);
-				const last = d.toString("utf8").split("\n").map(cleanLine).filter((line) => line.trim()).at(-1)?.trim();
-				if (last) job.lastLine = last;
-			};
-
+			const controller = new AbortController();
 			// Output goes to a pipe, where Python would buffer prints until it exits; unbuffered, the latest line and wake_on stay live
-			ops.exec(`export PYTHONUNBUFFERED=1; ${params.command}`, params.cwd ?? ctx.cwd, { onData, signal: job.controller.signal })
-				.then(({ exitCode }) => {
-					job.status = "exited";
-					job.exitCode = exitCode;
-				})
-				.catch((err: Error) => {
-					job.status = job.controller.signal.aborted ? "killed" : "failed";
-					out.write(`\n[bg] ${err.message}\n`);
-				})
-				.finally(() => {
-					job.ended = Date.now();
-					showJobs();
-					out.end(() => {
-						// A kill from session shutdown has no session left to notify
-						if (job.status === "killed" && !jobs.has(id)) return;
-						report(job, `Background job finished: ${summary(job)}\nLast lines:\n${tail(log, TAIL_LINES)}`, {
-							headline: `${id} ${job.status === "exited" ? `exited ${job.exitCode}` : job.status} · ${elapsed(job)}`,
-							last: tail(log, 1),
-							error: job.status !== "exited" || job.exitCode !== 0,
-						});
-					});
-				});
-
-			showJobs();
+			const { id, log } = startJob(params.command, pattern, controller, (onData) =>
+				ops.exec(`export PYTHONUNBUFFERED=1; ${params.command}`, params.cwd ?? ctx.cwd, { onData, signal: controller.signal }),
+			);
 			return { content: [{ type: "text", text: `Started ${id}; log: ${log}. You will be notified when it exits.` }], details: { id, log } };
 		},
 	});
@@ -343,60 +489,73 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	// Shows a job's latest output in place of the input until esc, refreshed every second while it runs
+	const showJob = async (args: string, ctx: ExtensionContext) => {
+		if (!ctx.hasUI) return;
+		const all = [...jobs.values()].reverse();
+		if (all.length === 0) return ctx.ui.notify("No background jobs yet", "info");
+		// "/bg 2" works as well as "/bg bg2"
+		const wanted = args.trim().toLowerCase().replace(/^(\d+)$/, "bg$1");
+		let job = wanted ? jobs.get(wanted) : all.length === 1 ? all[0] : undefined;
+		if (wanted && !job) return ctx.ui.notify(`No background job ${args.trim()}; there's ${[...jobs.keys()].join(", ")}`, "warning");
+		if (!job) {
+			// Running jobs first, then the latest finished ones
+			const listed = [...all.filter((other) => other.status === "running"), ...all.filter((other) => other.status !== "running").slice(0, MAX_LISTED_FINISHED)];
+			// Matched by position, since the elapsed time in a label changes while the list is open
+			// Ids and commands padded to one width, so the states and times line up
+			const idWidth = Math.max(...listed.map((other) => other.id.length));
+			const commandWidth = Math.max(...listed.map((other) => shownCommand(other.command).length));
+			const options = listed.map((other) => `${other.id.padEnd(idWidth)} ${shownCommand(other.command).padEnd(commandWidth)} · ${state(other)} · ${elapsed(other)}`);
+			job = listed[options.indexOf((await ctx.ui.select("Background jobs", options)) ?? "")];
+			if (!job) return;
+		}
+		const shown = job;
+		viewing = shown;
+		const log = shown.log.replace(homedir(), "~");
+		try {
+			await ctx.ui.custom<void>((tui, theme, _kb, done) => {
+				const timer = setInterval(() => tui.requestRender(), 1000);
+				return {
+					dispose: () => clearInterval(timer),
+					invalidate() {},
+					handleInput: (data: string) => {
+						if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c")) || data === "q") done();
+					},
+					render(width: number) {
+						const color = shown.status === "running" ? "accent" : shown.status === "exited" && shown.exitCode === 0 ? "success" : "error";
+						const title = theme.fg(color, " ● ") + theme.fg("toolTitle", `${shown.id} ${shownCommand(shown.command)}`);
+						const status = theme.fg("muted", `${state(shown)} · ${elapsed(shown)} `);
+						const gap = Math.max(1, width - visibleWidth(title) - visibleWidth(status));
+						// At most half the terminal, so the conversation above stays in view
+						const text = tail(shown.log, Math.max(3, Math.min(TAIL_LINES, Math.floor(tui.terminal.rows / 2))));
+						const output = text === "(no output)" ? [theme.fg("dim", theme.italic("   no output yet"))] : text.split("\n").map((line) => `   ${cleanLine(line)}`);
+						return [
+							theme.fg("borderMuted", "─".repeat(width)),
+							title + " ".repeat(gap) + status,
+							...output,
+							theme.fg("dim", ` esc to close · ${log}`),
+							theme.fg("borderMuted", "─".repeat(width)),
+						].map((line) => truncateToWidth(line, width));
+					},
+				};
+			});
+		} finally {
+			viewing = undefined;
+		}
+	};
 	pi.registerCommand("bg", {
 		description: "Show a background job's latest output",
 		getArgumentCompletions: (prefix) => {
 			const matching = [...jobs.values()].filter((job) => job.id.startsWith(prefix.trim().toLowerCase()));
 			return matching.length ? matching.map((job) => ({ value: job.id, label: job.id, description: `${shownCommand(job.command)} · ${state(job)}` })) : null;
 		},
-		handler: async (args, ctx) => {
-			if (!ctx.hasUI) return;
-			const all = [...jobs.values()].reverse();
-			if (all.length === 0) return ctx.ui.notify("No background jobs yet", "info");
-			// "/bg 2" works as well as "/bg bg2"
-			const wanted = args.trim().toLowerCase().replace(/^(\d+)$/, "bg$1");
-			let job = wanted ? jobs.get(wanted) : all.length === 1 ? all[0] : undefined;
-			if (wanted && !job) return ctx.ui.notify(`No background job ${args.trim()}; there's ${[...jobs.keys()].join(", ")}`, "warning");
-			if (!job) {
-				// Matched by position, since the elapsed time in a label changes while the list is open
-				const options = all.map((other) => `${other.id} ${shownCommand(other.command)} · ${state(other)} · ${elapsed(other)}`);
-				job = all[options.indexOf((await ctx.ui.select("Background jobs", options)) ?? "")];
-				if (!job) return;
-			}
-			const shown = job;
-			viewing = shown;
-			const log = shown.log.replace(homedir(), "~");
-			try {
-				await ctx.ui.custom<void>((tui, theme, _kb, done) => {
-					const timer = setInterval(() => tui.requestRender(), 1000);
-					return {
-						dispose: () => clearInterval(timer),
-						invalidate() {},
-						handleInput: (data: string) => {
-							if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c")) || data === "q") done();
-						},
-						render(width: number) {
-							const color = shown.status === "running" ? "accent" : shown.status === "exited" && shown.exitCode === 0 ? "success" : "error";
-							const title = theme.fg(color, " ● ") + theme.fg("toolTitle", `${shown.id} ${shownCommand(shown.command)}`);
-							const status = theme.fg("muted", `${state(shown)} · ${elapsed(shown)} `);
-							const gap = Math.max(1, width - visibleWidth(title) - visibleWidth(status));
-							// At most half the terminal, so the conversation above stays in view
-							const text = tail(shown.log, Math.max(3, Math.min(TAIL_LINES, Math.floor(tui.terminal.rows / 2))));
-							const output = text === "(no output)" ? [theme.fg("dim", theme.italic("   no output yet"))] : text.split("\n").map((line) => `   ${cleanLine(line)}`);
-							return [
-								theme.fg("borderMuted", "─".repeat(width)),
-								title + " ".repeat(gap) + status,
-								...output,
-								theme.fg("dim", ` esc to close · ${log}`),
-								theme.fg("borderMuted", "─".repeat(width)),
-							].map((line) => truncateToWidth(line, width));
-						},
-					};
-				});
-			} finally {
-				viewing = undefined;
-			}
-		},
+		handler: showJob,
+	});
+	// "/bg3" without the space isn't a command, so pi would send it to the model as a message; open the job instead
+	pi.on("input", async (event, ctx) => {
+		const id = event.text.trim().match(/^\/(bg\d+)$/i)?.[1];
+		if (!id || !jobs.has(id.toLowerCase())) return { action: "continue" };
+		await showJob(id, ctx);
+		return { action: "handled" };
 	});
 
 	// After /reload or a resume, carry on after the ids already in the conversation so "bg3" keeps meaning one job
@@ -406,6 +565,13 @@ export default function (pi: ExtensionAPI) {
 				redrawJobs = () => tui.requestRender();
 				return jobsWidget(theme);
 			});
+			// ctrl+b moves running bash commands to the background; otherwise it stays the editor's cursor-left
+			stopCtrlB();
+			stopCtrlB = ctx.ui.onTerminalInput((data) => {
+				if (hinted.size === 0 || !matchesKey(data, Key.ctrl("b"))) return undefined;
+				for (const move of [...hinted.values()]) move();
+				return { consume: true };
+			});
 		}
 		for (const entry of ctx.sessionManager.getBranch()) {
 			const msg = entry.type === "message" ? (entry.message as any) : undefined;

package/extensions/command.ts

@@ -0,0 +1,22 @@
+import { realpathSync } from "node:fs";
+import { basename, isAbsolute, resolve } from "node:path";
+
+// Real paths, so a cd through a symlink such as /tmp still counts as cwd
+const real = (path: string) => {
+	try {
+		return realpathSync(path);
+	} catch {
+		return path;
+	}
+};
+
+/** A shell command's first line, without leading cds into cwd; another folder shows as its last part when the path is absolute. */
+export function shortCommand(command: string, cwd: string): string {
+	const rest = command.trim().replace(/^(?:cd\s+(?:"[^"]*"|'[^']*'|\S+)[ \t]*(?:&&|;|\n)\s*)+/, (prefix) => {
+		const [, quoted, separator] = [...prefix.matchAll(/cd\s+("[^"]*"|'[^']*'|\S+)[ \t]*(&&|;|\n)/g)].at(-1)!;
+		const dir = quoted.replace(/^["']|["']$/g, "");
+		if (real(resolve(cwd, dir)) === real(resolve(cwd))) return "";
+		return `cd ${isAbsolute(dir) ? `…/${basename(dir)}` : quoted}${separator === ";" ? ";" : " &&"} `;
+	});
+	return rest.split("\n")[0];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-background",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "license": "MIT",
   "author": "Thomas van Dongen",
   "type": "module",