pi-chassis 0.0.0-stage → 0.7.1

package/extensions/git/repo.ts

@@ -0,0 +1,200 @@
+/** Reading a repository: status, branches, remotes. Nothing here changes anything. */
+
+import { readFile, rename, rm, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { git, gitOut } from "./run.ts";
+import { plainText } from "./text.ts";
+
+export interface RepoStatus {
+	branch?: string;
+	/** The tracked branch ("origin/feat"); absent when there is none or it no longer exists. */
+	upstream?: string;
+	/** The tracked branch's name when it was deleted on the remote (git status says "[gone]"). */
+	gone?: string;
+	ahead: number;
+	behind: number;
+	staged: number;
+	unstaged: number;
+	untracked: number;
+	conflicted: number;
+}
+
+/** Parse `git status --porcelain=v1 --branch`. */
+export function parseStatus(out: string): RepoStatus {
+	const s: RepoStatus = { ahead: 0, behind: 0, staged: 0, unstaged: 0, untracked: 0, conflicted: 0 };
+	for (const line of out.split("\n")) {
+		if (line.startsWith("## ")) {
+			const b = line.slice(3);
+			if (b.startsWith("HEAD (no branch)")) continue;
+			const [names = "", rest = ""] = b.split(/ \[/, 2);
+			const [local = "", upstream] = names.replace(/^No commits yet on /, "").split("...");
+			s.branch = local || undefined;
+			if (upstream && /\bgone\b/.test(rest)) s.gone = upstream;
+			else s.upstream = upstream || undefined;
+			s.ahead = Number(rest.match(/ahead (\d+)/)?.[1] ?? 0);
+			s.behind = Number(rest.match(/behind (\d+)/)?.[1] ?? 0);
+			continue;
+		}
+		if (line.length < 3) continue;
+		const x = line[0]!;
+		const y = line[1]!;
+		if (x === "?" && y === "?") s.untracked++;
+		else if (x === "U" || y === "U" || (x === "A" && y === "A") || (x === "D" && y === "D")) s.conflicted++;
+		else {
+			if (x !== " " && x !== "!") s.staged++;
+			if (y !== " " && y !== "!") s.unstaged++;
+		}
+	}
+	return s;
+}
+
+/**
+ * The paths `git add -A` would stage, as git status lists them (one per file, also inside new
+ * directories), for showing before anything is staged. Undefined when git could not say.
+ */
+export async function changedPaths(cwd: string): Promise<string[] | undefined> {
+	const r = await git(cwd, ["--no-optional-locks", "-c", "core.quotepath=off", "status", "--porcelain=v1", "-z", "-uall"]);
+	if (r.code !== 0) return undefined;
+	const parts = r.stdout.split("\0");
+	const paths: string[] = [];
+	for (let i = 0; i < parts.length; i++) {
+		const p = parts[i]!;
+		if (p.length < 4) continue;
+		paths.push(plainText(p.slice(3)));
+		if (p[0] === "R" || p[0] === "C" || p[1] === "R" || p[1] === "C") i++; // skip the rename's origin
+	}
+	return paths;
+}
+
+/** A saved copy of the index: call `staged` after your own staging, and `restore` to undo it. */
+export interface IndexSnapshot {
+	/** Note what the index holds after the staging, so `restore` can tell if anything else changed it since. */
+	staged(): Promise<void>;
+	/** Put the index back as it was. Resolves false, leaving it alone, when something else changed it since `staged`. */
+	restore(): Promise<boolean>;
+}
+
+/**
+ * Save the index (the staging area) so a command that stages files can undo that if it is
+ * dropped. The index file itself is copied, because `git write-tree` and `read-tree` would lose
+ * entries added with `git add -N`. It is put back with git's own lock file (`index.lock`), so it
+ * cannot collide with a git command running at the same time. Undefined when it cannot be read.
+ */
+export async function saveIndex(cwd: string): Promise<IndexSnapshot | undefined> {
+	const where = await gitOut(cwd, ["rev-parse", "--git-path", "index"]);
+	if (!where) return undefined;
+	const path = resolve(cwd, where);
+	const before = await readFile(path).catch(() => undefined); // a new repository has no index file yet
+	/** What the index holds, ignoring the file-stat data git refreshes on its own. */
+	const entries = async (): Promise<string | undefined> => {
+		const r = await git(cwd, ["ls-files", "--stage", "-z"]);
+		return r.code === 0 ? r.stdout : undefined;
+	};
+	let after: string | undefined;
+	return {
+		staged: async () => void (after = await entries()),
+		restore: async () => {
+			// Take git's lock first, so nothing can stage between the check and the swap.
+			const lock = `${path}.lock`;
+			try {
+				await writeFile(lock, before ?? "", { flag: "wx" });
+			} catch {
+				return false; // another git command holds the lock
+			}
+			try {
+				const now = await entries();
+				if (now === undefined || now !== after) {
+					await rm(lock, { force: true });
+					return false;
+				}
+				if (before) await rename(lock, path);
+				else {
+					await rm(path, { force: true });
+					await rm(lock, { force: true });
+				}
+				return true;
+			} catch {
+				await rm(lock, { force: true }).catch(() => {});
+				return false;
+			}
+		},
+	};
+}
+
+export async function repoStatus(cwd: string): Promise<RepoStatus | undefined> {
+	const r = await git(cwd, ["--no-optional-locks", "status", "--porcelain=v1", "--branch"]);
+	return r.code === 0 ? parseStatus(r.stdout) : undefined;
+}
+
+/** The current branch, or undefined when HEAD is detached. */
+export async function currentBranch(cwd: string): Promise<string | undefined> {
+	return (await gitOut(cwd, ["branch", "--show-current"])) || undefined;
+}
+
+export async function refExists(cwd: string, ref: string): Promise<boolean> {
+	return (await git(cwd, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`])).code === 0;
+}
+
+/** The remote a branch publishes to: its upstream's remote, else origin, else the first remote. */
+export async function remoteName(cwd: string, upstream?: string): Promise<string | undefined> {
+	const names = (await gitOut(cwd, ["remote"]))?.split("\n").filter(Boolean) ?? [];
+	if (!names.length) return undefined;
+	const fromUpstream = upstream ? names.find((n) => upstream.startsWith(`${n}/`)) : undefined;
+	return fromUpstream ?? (names.includes("origin") ? "origin" : names[0]);
+}
+
+/** Branch names tried, in this order, when the remote does not say which one is its default. */
+const COMMON_BASES = ["main", "master"];
+
+/**
+ * The branch changes are normally merged into: the remote's HEAD (so a repository whose default is
+ * develop or trunk works), else main or master on the remote, else main or master locally.
+ */
+export async function defaultBranch(cwd: string, remote = "origin"): Promise<string | undefined> {
+	const head = await gitOut(cwd, ["symbolic-ref", "--short", `refs/remotes/${remote}/HEAD`]);
+	const prefix = `${remote}/`;
+	if (head) return head.startsWith(prefix) ? head.slice(prefix.length) : head;
+	for (const name of COMMON_BASES) if (await refExists(cwd, `refs/remotes/${remote}/${name}`)) return name;
+	for (const name of COMMON_BASES) if (await refExists(cwd, `refs/heads/${name}`)) return name;
+	return undefined;
+}
+
+/** The ref to compare with for a base branch: the remote's copy when there is one (a local copy can be stale), else the local branch. */
+export async function compareRef(cwd: string, remote: string, base: string): Promise<string | undefined> {
+	if (await refExists(cwd, `refs/remotes/${remote}/${base}`)) return `${remote}/${base}`;
+	return (await refExists(cwd, `refs/heads/${base}`)) ? base : undefined;
+}
+
+/** The remote and branch a local branch tracks, from its git config; undefined when it tracks nothing. */
+export async function trackedBranch(cwd: string, branch: string): Promise<{ remote: string; branch: string } | undefined> {
+	const [remote, merge] = await Promise.all([gitOut(cwd, ["config", "--get", `branch.${branch}.remote`]), gitOut(cwd, ["config", "--get", `branch.${branch}.merge`])]);
+	if (!remote || !merge) return undefined;
+	return { remote, branch: merge.replace(/^refs\/heads\//, "") };
+}
+
+/** Commits on each side of `HEAD` and `ref`: how many only HEAD has (ahead) and only `ref` has (behind). */
+export async function aheadBehind(cwd: string, ref: string): Promise<{ ahead: number; behind: number } | undefined> {
+	const out = await gitOut(cwd, ["rev-list", "--left-right", "--count", `HEAD...${ref}`]);
+	const [ahead, behind] = out?.split(/\s+/).map(Number) ?? [];
+	return Number.isFinite(ahead) && Number.isFinite(behind) ? { ahead: ahead!, behind: behind! } : undefined;
+}
+
+/** The host of a remote URL: https, ssh:// and scp-style (git@host:path) forms. */
+export function remoteHost(url: string): string | undefined {
+	const u = url.trim();
+	const scheme = u.match(/^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]+@)?([^/:]+)/i);
+	if (scheme) return scheme[1]!.toLowerCase();
+	const scp = u.match(/^(?:[^@/]+@)?([^:/]+):(?!\/\/)/);
+	return scp ? scp[1]!.toLowerCase() : undefined;
+}
+
+/** Local branch names other than `except`, most recently used first. */
+export async function localBranches(cwd: string, except?: string): Promise<string[]> {
+	const out = await gitOut(cwd, ["branch", "--sort=-committerdate", "--format=%(refname:short)"]);
+	return (out?.split("\n").filter(Boolean) ?? []).filter((b) => b !== except && !b.startsWith("("));
+}
+
+/** True when `cwd` is inside a git work tree. */
+export async function isRepo(cwd: string): Promise<boolean> {
+	return (await gitOut(cwd, ["rev-parse", "--is-inside-work-tree"])) === "true";
+}

package/extensions/git/run.ts

@@ -0,0 +1,143 @@
+/**
+ * Run a program without a shell: arguments are an array, so branch names, messages and paths never
+ * need quoting and cannot inject anything. Never throws: a failure is a non-zero `code`.
+ *
+ * Programs run with no way to ask you anything. A child that keeps pi's controlling terminal can
+ * open /dev/tty and draw an ssh passphrase, credential or gpg prompt over pi's screen, then wait
+ * for a key pi will never forward. So on POSIX the child gets its own session (no controlling
+ * terminal), git is told not to prompt, and a prompt fails at once with a message instead of
+ * hanging until the timeout. stdin stays a pipe, so `commit -F -` and `gh --body-file -` work.
+ */
+
+import { type ChildProcess, spawn } from "node:child_process";
+import { AUTH_HINT, looksLikeAuthFailure, plainText } from "./text.ts";
+
+export interface RunResult {
+	code: number;
+	stdout: string;
+	stderr: string;
+}
+
+export interface RunOptions {
+	timeoutMs?: number;
+	/** Written to the program's stdin. */
+	input?: string;
+	env?: Record<string, string>;
+}
+
+/** Exit code reported when the program had to be stopped for running too long (as timeout(1) does). */
+export const TIMED_OUT = 124;
+const KILL_GRACE_MS = 2000;
+const MAX_OUTPUT = 32 << 20;
+
+/** The environment for a child: prompts off, and no pointer to pi's terminal for gpg to draw on. */
+function childEnv(extra: Record<string, string> | undefined): NodeJS.ProcessEnv {
+	const env: NodeJS.ProcessEnv = { ...process.env, GIT_TERMINAL_PROMPT: "0", GCM_INTERACTIVE: "never", ...extra };
+	delete env.GPG_TTY;
+	return env;
+}
+
+/**
+ * Children run detached (their own process group, no controlling terminal), so they would not get
+ * the terminal's signals if pi is closed. Track them and stop their groups when pi exits.
+ */
+const live = new Set<ChildProcess>();
+let exitHookInstalled = false;
+function track(child: ChildProcess, group: boolean): void {
+	if (!group) return;
+	live.add(child);
+	child.once("close", () => live.delete(child));
+	if (exitHookInstalled) return;
+	exitHookInstalled = true;
+	process.once("exit", () => {
+		for (const c of live) stop(c, "SIGTERM", true);
+	});
+}
+
+/** Stop the child and anything it started: a hook or credential helper can have children of its own. */
+function stop(child: ChildProcess, signal: NodeJS.Signals, group: boolean): void {
+	try {
+		if (group && child.pid) process.kill(-child.pid, signal);
+		else child.kill(signal);
+	} catch {
+		// already gone
+	}
+}
+
+export function run(cmd: string, args: string[], cwd: string, opts: RunOptions = {}): Promise<RunResult> {
+	return new Promise((resolve) => {
+		const timeoutMs = opts.timeoutMs ?? 60_000;
+		const posix = process.platform !== "win32";
+		const out: Buffer[] = [];
+		const err: Buffer[] = [];
+		let size = 0;
+		let tooBig = false;
+		let timedOut = false;
+		let spawnError: NodeJS.ErrnoException | undefined;
+		let timer: NodeJS.Timeout | undefined;
+		let killTimer: NodeJS.Timeout | undefined;
+
+		const child = spawn(cmd, args, { cwd, env: childEnv(opts.env), detached: posix, stdio: ["pipe", "pipe", "pipe"] });
+		track(child, posix);
+		const collect = (into: Buffer[]) => (chunk: Buffer) => {
+			size += chunk.length;
+			if (size > MAX_OUTPUT) {
+				tooBig = true;
+				return stop(child, "SIGKILL", posix);
+			}
+			into.push(chunk);
+		};
+		child.stdout.on("data", collect(out));
+		child.stderr.on("data", collect(err));
+		child.on("error", (e) => void (spawnError = e));
+		child.on("close", (code, signal) => {
+			clearTimeout(timer);
+			clearTimeout(killTimer);
+			const stdout = Buffer.concat(out).toString("utf8");
+			const stderr = Buffer.concat(err).toString("utf8");
+			if (spawnError) {
+				const missing = spawnError.code === "ENOENT";
+				return resolve({ code: missing ? 127 : 1, stdout, stderr: missing ? `${cmd}: command not found` : spawnError.message });
+			}
+			if (timedOut) {
+				const note = `${cmd} did not finish in ${Math.round(timeoutMs / 1000)} seconds and was stopped.`;
+				return resolve({ code: TIMED_OUT, stdout, stderr: stderr ? `${stderr.trimEnd()}\n${note}` : note });
+			}
+			if (tooBig) return resolve({ code: 1, stdout, stderr: `${cmd} printed more than ${MAX_OUTPUT >> 20} MB and was stopped.` });
+			if (code === 0) return resolve({ code: 0, stdout, stderr });
+			resolve({ code: code ?? 1, stdout, stderr: stderr || (signal ? `${cmd} was stopped by ${signal}` : `${cmd} failed`) });
+		});
+		timer = setTimeout(() => {
+			timedOut = true;
+			stop(child, "SIGTERM", posix);
+			killTimer = setTimeout(() => stop(child, "SIGKILL", posix), KILL_GRACE_MS);
+		}, timeoutMs);
+		child.stdin.on("error", () => {});
+		child.stdin.end(opts.input ?? "");
+	});
+}
+
+/**
+ * Flags for a git diff whose output is parsed or sent to the model: no colour, no external diff
+ * program, and a/ b/ prefixes whatever diff.noprefix or diff.mnemonicPrefix says.
+ */
+export const PLAIN_DIFF = ["--no-color", "--no-ext-diff", "--src-prefix=a/", "--dst-prefix=b/"];
+
+export const git = (cwd: string, args: string[], opts?: RunOptions): Promise<RunResult> => run("git", args, cwd, opts);
+
+/** stdout of a git command, trimmed; undefined when it failed. */
+export async function gitOut(cwd: string, args: string[]): Promise<string | undefined> {
+	const r = await git(cwd, args);
+	return r.code === 0 ? r.stdout.trim() : undefined;
+}
+
+/**
+ * The useful part of a failed command, for a notification. Output from git, hooks and gh is
+ * cleaned of escape sequences first, so it cannot move the cursor or retitle the window, and a
+ * failure that reads like a missing sign-in gets a one-line hint.
+ */
+export function failure(r: RunResult, max = 1200): string {
+	const text = plainText(r.stderr.trim() || r.stdout.trim() || `exit ${r.code}`).trim() || `exit ${r.code}`;
+	const shown = text.length > max ? `${text.slice(0, max)}…` : text;
+	return looksLikeAuthFailure(text) ? `${shown}\n${AUTH_HINT}` : shown;
+}

package/extensions/git/settings.ts

@@ -0,0 +1,38 @@
+/**
+ * The on/off switch for the git commands, saved in chassis's state file under `git: { enabled }`
+ * next to the other chassis settings. It is read on each use, so `/git off` takes effect at once and
+ * in every running session. Anything missing or malformed means on.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { statePath } from "../chassis/api.ts";
+
+export function loadGitEnabled(path = statePath()): boolean {
+	try {
+		const enabled = JSON.parse(readFileSync(path, "utf8"))?.git?.enabled;
+		return typeof enabled === "boolean" ? enabled : true;
+	} catch {
+		return true;
+	}
+}
+
+/** Save into the state file, keeping its other keys. Returns false if it could not be written. */
+export function saveGitEnabled(enabled: boolean, path = statePath()): boolean {
+	try {
+		let data: Record<string, unknown> = {};
+		if (existsSync(path)) {
+			try {
+				data = JSON.parse(readFileSync(path, "utf8")) ?? {};
+			} catch {
+				data = {};
+			}
+		}
+		data.git = { enabled };
+		mkdirSync(dirname(path), { recursive: true });
+		writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`);
+		return true;
+	} catch {
+		return false;
+	}
+}

package/extensions/git/text.ts

@@ -0,0 +1,133 @@
+/**
+ * The pure text side of the git tools: the prompts sent to the model and cleaning what comes back.
+ * No I/O, so it is tested directly.
+ */
+
+import { stripEscapes } from "../chassis/sanitize.ts";
+
+export const MAX_DIFF_CHARS = 30_000;
+
+/** Cut a diff to `max` characters at a line boundary and say so, so the model knows it is partial. */
+export function truncateDiff(diff: string, max = MAX_DIFF_CHARS): string {
+	if (diff.length <= max) return diff;
+	const cut = diff.slice(0, max);
+	const lastNl = cut.lastIndexOf("\n");
+	return `${lastNl > 0 ? cut.slice(0, lastNl) : cut}\n\n[diff truncated: ${diff.length - max} more characters not shown]`;
+}
+
+const COMMIT_SYSTEM = [
+	"You write git commit messages.",
+	"Reply with the commit message only: no code fences, no preamble, no quotes around it.",
+	"First line: an imperative summary of 72 characters or fewer, no trailing period.",
+	"If the change needs explanation, add a blank line and a short body that says why, wrapped at about 72 columns.",
+	"Follow the style of the recent commits when one is evident (for example conventional commit prefixes), otherwise plain sentences.",
+	"Describe only what the diff shows. Do not invent reasons, ticket numbers or features.",
+].join("\n");
+
+export interface CommitPromptInput {
+	branch?: string;
+	stat: string;
+	diff: string;
+	recent: string[];
+}
+
+export function commitPrompt(i: CommitPromptInput): { system: string; user: string } {
+	const parts = [
+		i.branch ? `Branch: ${i.branch}` : "",
+		i.recent.length ? `Recent commit subjects (for style):\n${i.recent.map((s) => `- ${s}`).join("\n")}` : "",
+		`Staged changes (summary):\n${i.stat.trim()}`,
+		`Staged diff:\n${truncateDiff(i.diff)}`,
+	];
+	return { system: COMMIT_SYSTEM, user: parts.filter(Boolean).join("\n\n") };
+}
+
+const PR_SYSTEM = [
+	"You write pull request titles and descriptions.",
+	"Reply with the title on the first line, a blank line, then the description in Markdown. No code fences around the whole reply, no preamble.",
+	"Title: imperative, 72 characters or fewer, no trailing period.",
+	"Description: what changed and why, grouped sensibly, short. A brief bullet list is fine. Mention anything a reviewer should check or any risk visible in the diff.",
+	"Describe only what the commits and diff show. Do not invent testing that was not shown, ticket numbers or features.",
+].join("\n");
+
+export interface PrPromptInput {
+	base: string;
+	branch: string;
+	commits: string[];
+	stat: string;
+	diff: string;
+}
+
+export function prPrompt(i: PrPromptInput): { system: string; user: string } {
+	const parts = [
+		`Merging ${i.branch} into ${i.base}.`,
+		`Commits (${i.commits.length}):\n${i.commits.map((c) => `- ${c}`).join("\n")}`,
+		`Files changed:\n${i.stat.trim()}`,
+		`Diff:\n${truncateDiff(i.diff)}`,
+	];
+	return { system: PR_SYSTEM, user: parts.join("\n\n") };
+}
+
+/** Strip what models add around a message: fences, a "Commit message:" label, wrapping quotes. */
+export function cleanMessage(raw: string): string {
+	let t = raw.replace(/\r/g, "").trim();
+	const fenced = t.match(/^```[\w-]*\n([\s\S]*?)\n```$/);
+	if (fenced) t = fenced[1]!.trim();
+	t = t.replace(/^(?:here(?:'s| is)[^\n:]*:|(?:commit message|message|title)\s*:)\s*/i, "").trim();
+	if (/^(["'`]).*\1$/s.test(t) && !t.includes("\n")) t = t.slice(1, -1).trim();
+	return t;
+}
+
+/** A PR draft as one editable text: the title, a blank line, the body. */
+export function splitPr(text: string): { title: string; body: string } {
+	const lines = cleanMessage(text).split("\n");
+	const first = lines.findIndex((l) => l.trim());
+	if (first < 0) return { title: "", body: "" };
+	const title = lines[first]!.replace(/^#+\s*/, "").replace(/^title\s*:\s*/i, "").trim();
+	return { title, body: lines.slice(first + 1).join("\n").trim() };
+}
+
+/** The first line of a message. */
+export const subject = (message: string): string => message.split("\n", 1)[0]?.trim() ?? "";
+
+/** Arguments of /pr: an optional base branch and a --draft flag, in any order. */
+export function parsePrArgs(args: string): { base?: string; draft: boolean } {
+	let draft = false;
+	let base: string | undefined;
+	for (const word of args.split(/\s+/).filter(Boolean)) {
+		if (word === "--draft" || word === "-d") draft = true;
+		else if (!word.startsWith("-")) base ??= word;
+	}
+	return { base, draft };
+}
+
+/**
+ * Command output made safe to show in a notification: escape sequences (colours, cursor moves,
+ * window titles) and other control characters are dropped, a tab becomes spaces, and a line that
+ * was redrawn with carriage returns (a progress bar) keeps only its last version. Newlines stay.
+ */
+export function plainText(raw: string): string {
+	const withoutEscapes = stripEscapes(raw);
+	return withoutEscapes
+		.replace(/\r\n/g, "\n")
+		.split("\n")
+		.map((line) => line.split("\r").reverse().find((part) => part !== "") ?? "")
+		.join("\n")
+		.replace(/\t/g, "    ")
+		.replace(/[\u0000-\u0009\u000b-\u001f\u007f-\u009f\u2028\u2029]/g, "");
+}
+
+const AUTH_FAILURE = [
+	/could not read (?:username|password)/i,
+	/terminal prompts disabled/i,
+	/authentication (?:failed|required)|requires authentication|invalid username or password/i,
+	/permission denied \(publickey/i,
+	/enter passphrase|incorrect passphrase/i,
+	/(?:HTTP|error:?|status)\s*40[13]\b/i,
+	/gpg failed to sign|pinentry|no secret key/i,
+	/not logged in|(?:gh|glab) auth login/i,
+];
+
+/** True when command output reads like a missing sign-in, key passphrase or gpg unlock. */
+export const looksLikeAuthFailure = (text: string): boolean => AUTH_FAILURE.some((re) => re.test(text));
+
+export const AUTH_HINT = "Hint: sign in with your credential helper, or unlock your key in ssh-agent or gpg-agent, from another terminal first, then try again.";

package/extensions/widgets/container/detect.ts

@@ -0,0 +1,81 @@
+/**
+ * Container detection (no pi imports, so tests run standalone).
+ * Moved from ~/.pi/agent/extensions/container-status.ts.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { hostname } from "node:os";
+
+type Env = Record<string, string | undefined>;
+
+export interface ContainerInfo {
+	/** docker | podman | devcontainer | codespace | kubernetes | container */
+	kind: string;
+	/** Best available human name: devcontainer/codespace/pod name, else the hostname. */
+	name: string;
+	/** name came from an explicit label (DEVCONTAINER_NAME): show it without a kind prefix. */
+	named?: boolean;
+}
+
+export interface Probe {
+	env: Env;
+	exists: (path: string) => boolean;
+	read: (path: string) => string | undefined;
+	hostname: () => string;
+}
+
+const realProbe: Probe = {
+	env: process.env,
+	exists: (p) => existsSync(p),
+	read: (p) => {
+		try {
+			return readFileSync(p, "utf8");
+		} catch {
+			return undefined;
+		}
+	},
+	hostname: () => hostname(),
+};
+
+/** Podman writes `name="..."` into /run/.containerenv (rootful; often empty when rootless). */
+function podmanName(text: string | undefined): string | undefined {
+	const m = text?.match(/^name="([^"]*)"/m);
+	return m?.[1] || undefined;
+}
+
+/** Container runtime evidence in cgroup/mount tables (catches runtimes without marker files). */
+function cgroupRuntime(p: Probe): string | undefined {
+	const text = `${p.read("/proc/1/cgroup") ?? ""}\n${p.read("/proc/self/mountinfo") ?? ""}`;
+	if (/kubepods/.test(text)) return "kubernetes";
+	if (/\/docker\/containers\/|\/docker[-/][0-9a-f]{12,}/.test(text)) return "docker";
+	if (/\/containers\/storage\/|libpod/.test(text)) return "podman";
+	if (/containerd|\/lxc\//.test(text)) return "container";
+	return undefined;
+}
+
+export function detectContainer(p: Probe = realProbe): ContainerInfo | undefined {
+	const e = p.env;
+	const host = p.hostname().split(".")[0] || "container";
+
+	// Devcontainers / Codespaces first: they are containers too, and have better names.
+	if (e.CODESPACES === "true") return { kind: "codespace", name: e.CODESPACE_NAME || host };
+	if (e.REMOTE_CONTAINERS === "true" || e.DEVCONTAINER === "true" || e.REMOTE_CONTAINERS_IPC) {
+		// An explicit DEVCONTAINER_NAME (set by a devcontainer launcher) is shown as-is, without the kind prefix.
+		if (e.DEVCONTAINER_NAME) return { kind: "devcontainer", name: e.DEVCONTAINER_NAME, named: true };
+		return { kind: "devcontainer", name: e.DEVCONTAINER_ID || host };
+	}
+	if (e.KUBERNETES_SERVICE_HOST) return { kind: "kubernetes", name: host };
+	if (p.exists("/run/.containerenv") || e.container === "podman") {
+		return { kind: "podman", name: podmanName(p.read("/run/.containerenv")) || host };
+	}
+	if (p.exists("/.dockerenv") || e.container === "docker") return { kind: "docker", name: host };
+	if (e.container) return { kind: e.container, name: host };
+	const cg = cgroupRuntime(p);
+	if (cg) return { kind: cg, name: host };
+	return undefined;
+}
+
+/** Label for a container: the kind is prefixed unless the name already says it. */
+export function containerLabel(c: ContainerInfo): string {
+	return c.named || c.name.toLowerCase().includes(c.kind) ? c.name : `${c.kind}:${c.name}`;
+}

package/extensions/widgets/container/index.ts

@@ -0,0 +1,29 @@
+/**
+ * Container widget: shows when pi itself runs inside a container, devcontainer, Codespace or
+ * Kubernetes pod (first footer segment, sidebar "Host" row). On the workstation it shows nothing.
+ *
+ * Detection is pi's own process only: a container reached through `docker exec` from a pi running
+ * on the host is not detected, because pi is still on the host.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerWidget } from "../../chassis/api.ts";
+import { type IconLike, ICONS } from "../../chassis/icons.ts";
+import { containerLabel, detectContainer } from "./detect.ts";
+
+// Nerd Font glyphs: md-docker, md-kubernetes.
+const ICON_CONTAINER: IconLike = { nerd: ICONS.widgetContainer.nerd, plain: ICONS.widgetContainer.plain };
+const ICON_K8S: IconLike = { nerd: ICONS.widgetK8s.nerd, plain: ICONS.widgetK8s.plain };
+
+export default function (pi: ExtensionAPI) {
+	// Can't change during a process's life, so detect once.
+	const info = detectContainer();
+	if (!info) return;
+	registerWidget(pi, {
+		id: "container",
+		title: "Host",
+		order: 0,
+		render: () => ({ icon: info.kind === "kubernetes" ? ICON_K8S : ICON_CONTAINER, text: containerLabel(info), color: "accent" }),
+		detail: () => [info.kind],
+	});
+}

package/extensions/widgets/mcp/index.ts

@@ -0,0 +1,53 @@
+/**
+ * MCP widget: "<plug> MCP 6/6" = connected/enabled servers for pi's built-in MCP support.
+ * Green when all are connected, yellow when some are, red when none are; hidden when no server is
+ * enabled. See status.ts for how "connected" is inferred and its limits; /mcp is authoritative.
+ *
+ * There is no event for MCP connection changes, so it polls (an in-memory tool list and two small
+ * JSON reads). It deliberately does not handle `mcp_servers_change`: handling that event marks an
+ * extension as the one that connects registered servers, taking that job from the built-in support.
+ *
+ * Tests: node --experimental-strip-types test/mcp-status.test.ts
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { type ExtensionAPI, getAgentDir } from "@earendil-works/pi-coding-agent";
+import { registerWidget } from "../../chassis/api.ts";
+import { type IconLike, ICONS } from "../../chassis/icons.ts";
+import { connectedServers, enabledServers, formatStatus, type McpStatus, parseMcpServers, summarize } from "./status.ts";
+
+const POLL_MS = 2000;
+// Nerd Font "md-power-plug" (U+F06A5).
+const ICON: IconLike = { nerd: ICONS.widgetMcp.nerd, plain: ICONS.widgetMcp.plain };
+
+function readText(path: string): string | undefined {
+	try {
+		return readFileSync(path, "utf8");
+	} catch {
+		return undefined;
+	}
+}
+
+export default function (pi: ExtensionAPI) {
+	let status: McpStatus | undefined;
+
+	registerWidget(pi, {
+		id: "mcp",
+		title: "MCP",
+		order: 30,
+		refreshMs: POLL_MS,
+		update: (ctx) => {
+			const global = parseMcpServers(readText(join(getAgentDir(), "mcp.json")));
+			const project = ctx.isProjectTrusted() ? parseMcpServers(readText(join(ctx.cwd, ".pi", "mcp.json"))) : {};
+			const enabled = enabledServers(global, project, pi.getMcpServers());
+			status = summarize(enabled, connectedServers(enabled, pi.getAllTools()));
+		},
+		render: () => {
+			if (!status) return undefined;
+			const level = status.level === "ok" ? "ok" : status.level === "partial" ? "warn" : "error";
+			return { icon: ICON, label: "MCP", text: formatStatus(status), level };
+		},
+		detail: () => (status?.pending.length ? status.pending.map((s) => `○ ${s} not connected`) : undefined),
+	});
+}