one-code-extension 0.3.1 → 0.4.1

package/extensions/footer/footer-line.ts

@@ -12,6 +12,7 @@
  */
 
 import { costOf, usageEntryCost } from "../lib/usage-bus.ts";
+import type { WorktreeLocation } from "../lib/worktree-channel.ts";
 
 export type Paint = (color: string, text: string) => string;
 
@@ -38,6 +39,18 @@ export interface FooterData {
 	effort?: string;
 }
 
+/**
+ * Where the footer says the session is: the active worktree's path and branch
+ * while `enter_worktree` is in effect (the process cwd never changes — the
+ * worktree extension rewrites tool inputs instead — so pi's own cwd and branch
+ * would keep naming the original checkout), else the process cwd and its
+ * branch.
+ */
+export function footerLocation(cwd: string, branch: string | undefined, worktree: WorktreeLocation | null | undefined): { cwd: string; branch?: string } {
+	if (worktree) return { cwd: worktree.path, branch: worktree.branch };
+	return { cwd, branch };
+}
+
 /** pi's token formatter, replicated so a "1.1M" here reads like pi's own. */
 export function formatTokens(count: number): string {
 	if (count < 1000) return count.toString();
@@ -197,6 +210,12 @@ export function computeMainUsage(entries: readonly unknown[]): { cost: number; c
 			cost += costOf(entry.message.usage);
 		} else if ((entry.type === "branch_summary" || entry.type === "compaction") && entry.usage) {
 			cost += costOf(entry.usage);
+		} else if (entry.type === "usage" && entry.usage) {
+			// pi 0.86's model-attributed usage outside the LLM context — today its
+			// cache-warming refreshes (`kind: "cache_warm"`), billed as a cache read
+			// of the full context plus one output token. pi's /session counts them;
+			// so does the footer.
+			cost += costOf(entry.usage);
 		} else {
 			// Out-of-band calls (subagents, classifier, readers, recap, setup)
 			// persisted by recordUsage — the all-in half of the total.

package/extensions/footer/index.ts

@@ -22,7 +22,8 @@ import { linesComponent, safeThemePaint } from "../lib/tui-render.ts";
 import { formatModel, isRealModel } from "../permissions/modes.ts";
 import { ULTRACODE_STATUS_KEY } from "../effort/slider.ts";
 import { USAGE_CHANNEL } from "../lib/usage-bus.ts";
-import { buildFooterLines, computeMainUsage, type FooterData } from "./footer-line.ts";
+import { buildFooterLines, computeMainUsage, footerLocation, type FooterData } from "./footer-line.ts";
+import { WORKTREE_CHANNEL, type WorktreeLocation } from "../lib/worktree-channel.ts";
 import { fetchPrNumber } from "./pr.ts";
 
 export default function footerExtension(pi: ExtensionAPI) {
@@ -40,6 +41,16 @@ export default function footerExtension(pi: ExtensionAPI) {
 
 	/** Invalidate the memoized line and repaint; set once the footer mounts. */
 	let repaint = () => {};
+	/** The active worktree session, if any; shown in place of the process cwd + branch. */
+	let worktree: WorktreeLocation | null = null;
+	/** Re-point the PR lookup at the location currently shown; set once the footer mounts. */
+	let refreshLocation = () => {};
+
+	pi.events.on(WORKTREE_CHANNEL, (data: unknown) => {
+		worktree = data as WorktreeLocation | null;
+		refreshLocation();
+		repaint();
+	});
 
 	const recomputeMain = (ctx: ExtensionContext) => {
 		lastCtx = ctx;
@@ -85,15 +96,19 @@ export default function footerExtension(pi: ExtensionAPI) {
 				onBranchChange(cb: () => void): () => void;
 			};
 
+			/** The path + branch shown, and the PR looked up: the worktree's while one is active. */
+			const currentLocation = () => footerLocation(ctx.cwd, fd.getGitBranch() ?? undefined, worktree);
+
 			const snapshot = (): FooterData => {
 				const usage = ctx.getContextUsage();
 				const ultracode = fd.getExtensionStatuses().get(ULTRACODE_STATUS_KEY);
 				const effort = ultracode ?? safeThinkingLevel(ctx);
 				const model = ctx.model;
+				const location = currentLocation();
 				return {
-					cwd: ctx.cwd,
+					cwd: location.cwd,
 					home: process.env.HOME || process.env.USERPROFILE || "",
-					branch: fd.getGitBranch() ?? undefined,
+					branch: location.branch,
 					contextTokens: usage?.tokens ?? undefined,
 					contextWindow: usage?.contextWindow,
 					contextPercent: usage?.percent,
@@ -116,9 +131,13 @@ export default function footerExtension(pi: ExtensionAPI) {
 			// only disposes the component, so the subscription must be released
 			// here — otherwise each replaced footer keeps firing its `gh pr list`
 			// against a stale cwd on every branch change.
-			refreshPr(ctx.cwd, fd.getGitBranch());
+			refreshLocation = () => {
+				const location = currentLocation();
+				refreshPr(location.cwd, location.branch ?? null);
+			};
+			refreshLocation();
 			const stopFollowingBranch = fd.onBranchChange(() => {
-				refreshPr(ctx.cwd, fd.getGitBranch());
+				refreshLocation();
 				repaint();
 			});
 
@@ -126,6 +145,7 @@ export default function footerExtension(pi: ExtensionAPI) {
 				dispose: () => {
 					stopFollowingBranch();
 					repaint = () => {};
+					refreshLocation = () => {};
 				},
 			});
 		});

package/extensions/hooks/executor.ts

@@ -9,11 +9,18 @@
  * a JSON payload from stdin. (Ported from pi-code's runHookCommand, MIT — see
  * docs/decisions.md.)
  *
+ * The interpreter is Claude Code's: bash (Git Bash on Windows, honouring
+ * `CLAUDE_CODE_GIT_BASH_PATH`) unless the hook says `shell: "powershell"`, or
+ * the machine is a Windows box without Git Bash — lib/shell-spawn.ts resolves
+ * both through pi's own shell lookup.
+ *
  * Hardening carried over:
- * - absolute /bin/sh, so a repo-local `sh` on PATH can't hijack the hook
+ * - an absolute interpreter path, so a repo-local `sh` on PATH can't hijack
+ *   the hook
  * - detached:true makes the shell a process-group leader; timeout SIGKILLs
  *   the negative pid so grandchildren holding the stdio pipes die too —
  *   otherwise `close` never fires and the promise hangs past the timeout
+ *   (Windows: `taskkill /T /F` on the leader's pid does the same)
  * - setEncoding("utf8") so multi-byte characters can't be split across chunks
  * - output capped at 1MB per stream
  * - stdin errors ignored (a hook that exits without reading stdin — `exit 2`
@@ -38,8 +45,36 @@
  *   mechanism for the LSP client). A ref'd child holds the loop until `close`.
  */
 
-import { spawn } from "node:child_process";
-import { killProcessTree } from "../lib/process-tree.ts";
+import type { ChildProcess } from "node:child_process";
+import { detachedSpawnOptions, killProcessTree, waitForChildExit } from "../lib/process-tree.ts";
+import { bashSpawn, POWERSHELL_UTF8_PREFIX, powerShellSpawn, type ShellSpawn, spawnShellCommand } from "../lib/shell-spawn.ts";
+import type { HookShell } from "./settings.ts";
+
+/**
+ * Claude Code's default: hooks run in bash (Git Bash on Windows) when one
+ * exists, otherwise in PowerShell — which only happens on Windows without Git
+ * for Windows, since every other platform resolves a bash.
+ */
+export function defaultHookShell(): HookShell {
+	return bashSpawn().spawn ? "bash" : "powershell";
+}
+
+/** The interpreter for one hook, or the reason none can run it. */
+export function hookShellSpawn(shell: HookShell | undefined): { spec?: ShellSpawn; shell?: HookShell; error?: string } {
+	const want = shell ?? defaultHookShell();
+	if (want === "powershell") {
+		const spec = powerShellSpawn();
+		return spec ? { spec, shell: want } : { error: "hook needs PowerShell but no pwsh/powershell executable was found on PATH" };
+	}
+	const resolved = bashSpawn();
+	if (!resolved.spawn) return { error: resolved.error ?? "hook needs bash but none was found" };
+	if (resolved.spawn.commandTransport === "stdin") {
+		// pi's legacy-WSL launcher takes its script on stdin, which the hook
+		// payload already occupies.
+		return { error: `hook cannot run under ${resolved.spawn.shell} (a WSL launcher); set CLAUDE_CODE_GIT_BASH_PATH to Git Bash's bash.exe` };
+	}
+	return { spec: resolved.spawn, shell: want };
+}
 
 export interface HookRunResult {
 	/**
@@ -80,6 +115,8 @@ export interface HookRunOptions {
 	 * stdout/stderr are therefore empty for a detached hook — nothing reads them.
 	 */
 	detached?: boolean;
+	/** The hook's `shell` field; unset → `defaultHookShell()`. */
+	shell?: HookShell;
 }
 
 const MAX_OUTPUT_BYTES = 1_000_000;
@@ -92,11 +129,28 @@ export function runHookCommand(command: string, stdinJson: string, opts: HookRun
 	const started = Date.now();
 
 	return new Promise((resolve) => {
-		let child: ReturnType<typeof spawn>;
+		let child: ChildProcess;
+		const failed = (spawnError: string) =>
+			resolve({ exitCode: null, timedOut: false, spawnError, stdout: "", stderr: "", durationMs: Date.now() - started });
+		const { spec, shell, error } = hookShellSpawn(opts.shell);
+		if (!spec) {
+			failed(error ?? "no shell available for the hook");
+			return;
+		}
+		// Windows PowerShell 5.1 (`powershell.exe`) defaults its console to
+		// UTF-16, which would corrupt this stream once decoded as UTF-8 below
+		// (setEncoding("utf8")) — the same fix every other PowerShell execution
+		// path applies (lib/shell-spawn.ts, extensions/powershell/index.ts).
+		const runCommand = shell === "powershell" ? `${POWERSHELL_UTF8_PREFIX}${command}` : command;
 		try {
-			child = spawn("/bin/sh", ["-c", command], {
+			// An absolute interpreter path (pi's resolver never yields a bare name
+			// where a real bash exists), so a repo-local `sh` on PATH cannot hijack
+			// the hook; the shell leads its own process group so a timeout kills
+			// grandchildren too (Windows: taskkill /T — lib/process-tree.ts).
+			child = spawnShellCommand(spec, runCommand, {
 				cwd: opts.cwd,
-				detached: true,
+				// A fire-and-forget hook must outlive a parent that is exiting.
+				...detachedSpawnOptions({ outlivesParent: opts.detached }),
 				stdio: opts.detached ? ["pipe", "ignore", "ignore"] : ["pipe", "pipe", "pipe"],
 				env: { ...process.env, CLAUDE_PROJECT_DIR: opts.projectDir ?? opts.cwd },
 			});
@@ -149,21 +203,33 @@ export function runHookCommand(command: string, stdinJson: string, opts: HookRun
 			resolve({ ...result, durationMs: Date.now() - started });
 		};
 
-		child.on("error", (error) => {
-			finish({ exitCode: null, timedOut, spawnError: error.message, stdout, stderr });
-		});
-		child.on("close", (code) => {
-			// A killed process reports null here, EXCEPT when the shell outlived the
-			// group kill just long enough to reap its child and exit 128+9 itself
-			// (see exitCode's contract). Normalizing keeps "we killed it" from ever
-			// looking like an ordinary non-zero exit, which fails OPEN downstream.
-			finish({ exitCode: timedOut ? null : code, timedOut, stdout, stderr });
-		});
+		// Settles on exit plus a short stdio grace, not on `close`: a grandchild
+		// the kill missed could otherwise hold the pipes — and this promise — open
+		// for its whole life (lib/process-tree.ts). A killed process reports null,
+		// EXCEPT when the shell outlived the group kill just long enough to reap
+		// its child and exit 128+9 itself (see exitCode's contract). Normalizing
+		// keeps "we killed it" from ever looking like an ordinary non-zero exit,
+		// which fails OPEN downstream.
+		waitForChildExit(child).then(
+			({ code }) => finish({ exitCode: timedOut ? null : code, timedOut, stdout, stderr }),
+			(error: Error) => finish({ exitCode: null, timedOut, spawnError: error.message, stdout, stderr }),
+		);
 
 		// A hook that never reads stdin (e.g. plain `exit 2`) closes the pipe
 		// early; the resulting EPIPE must not take the extension down.
 		child.stdin?.on("error", () => {});
-		child.stdin?.write(stdinJson.endsWith("\n") ? stdinJson : `${stdinJson}\n`);
-		child.stdin?.end();
+		const payload = stdinJson.endsWith("\n") ? stdinJson : `${stdinJson}\n`;
+		if (opts.detached) {
+			// Close the pipe the moment the payload is written, not with a graceful
+			// shutdown: on Windows libuv's pipe shutdown stays pending until the
+			// reader has drained the data, and a hook that never reads stdin would
+			// keep the process alive for its whole run (the probe test measured a
+			// `sleep 3` SessionEnd hook holding a one-shot open for 3 s). The data
+			// already written stays readable by the hook after the handle closes.
+			child.stdin?.write(payload, () => child.stdin?.destroy());
+		} else {
+			child.stdin?.write(payload);
+			child.stdin?.end();
+		}
 	});
 }

package/extensions/hooks/index.ts

@@ -196,6 +196,7 @@ export default function hooksExtension(pi: ExtensionAPI) {
 					const run = await runHookCommand(hook.command, stdin, {
 						cwd: ctx.cwd,
 						timeoutSeconds: hook.timeout,
+						shell: hook.shell,
 						projectDir: ctx.cwd,
 						// SessionEnd is fire-and-forget at shutdown: it must not hold a
 						// one-shot process open. Every other hook is awaited work that

package/extensions/hooks/matcher.ts

@@ -15,6 +15,7 @@ import { ccAliasesForTool } from "../permissions/matcher.ts";
  */
 const CC_CANONICAL: Record<string, string> = {
 	bash: "Bash",
+	powershell: "PowerShell",
 	read: "Read",
 	edit: "Edit",
 	write: "Write",
@@ -88,19 +89,32 @@ export function toolMatchCandidates(nativeName: string): string[] {
 	return [...new Set([nativeName, ccToolName(nativeName), ...ccAliasesForTool(nativeName)])];
 }
 
-/**
- * Whether a CC matcher applies to any candidate spelling. Anchored and
- * case-insensitive (`^(?:matcher)$`, the CC semantics); an invalid regex
- * falls back to case-insensitive exact comparison rather than throwing.
- */
-export function matcherApplies(matcher: string | undefined, candidates: string[]): boolean {
-	if (matcher === undefined || matcher === "" || matcher === "*") return true;
+/** One matcher spelling: a regex when it compiles, else a case-insensitive exact match. */
+function matchesAlternative(alternative: string, candidates: string[]): boolean {
 	let regex: RegExp | undefined;
 	try {
-		regex = new RegExp(`^(?:${matcher})$`, "i");
+		regex = new RegExp(`^(?:${alternative})$`, "i");
 	} catch {
 		regex = undefined;
 	}
-	const lowered = matcher.toLowerCase();
+	const lowered = alternative.toLowerCase();
 	return candidates.some((candidate) => (regex ? regex.test(candidate) : candidate.toLowerCase() === lowered));
 }
+
+/**
+ * Whether a CC matcher applies to any candidate spelling. Anchored and
+ * case-insensitive (`^(?:matcher)$`, the CC semantics); an invalid regex
+ * falls back to case-insensitive exact comparison rather than throwing. The
+ * whole matcher is tried first — so a regex that legitimately contains a
+ * comma (a `{m,n}` quantifier, a character class) still compiles and matches
+ * as written. Only once that fails is a comma-separated list
+ * (`Bash,PowerShell`) tried part by part — the spelling Claude Code's Windows
+ * docs use beside `Bash|PowerShell`.
+ */
+export function matcherApplies(matcher: string | undefined, candidates: string[]): boolean {
+	if (matcher === undefined || matcher === "" || matcher === "*") return true;
+	if (matchesAlternative(matcher, candidates)) return true;
+	if (!matcher.includes(",")) return false;
+	const alternatives = matcher.split(",").map((part) => part.trim()).filter(Boolean);
+	return alternatives.some((alternative) => matchesAlternative(alternative, candidates));
+}

package/extensions/hooks/settings.ts

@@ -17,11 +17,19 @@ import { readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { CC_HOOK_EVENTS, type CcHookEvent } from "./protocol.ts";
 
+/** Claude Code's per-hook `shell` field: which interpreter runs the command string. */
+export type HookShell = "bash" | "powershell";
+
 export interface HookCommand {
 	type: "command";
 	command: string;
 	/** Seconds, CC convention. */
 	timeout?: number;
+	/**
+	 * Unset means the platform default: bash where one exists, PowerShell on
+	 * Windows without Git Bash (Claude Code's rule — executor.ts `defaultHookShell`).
+	 */
+	shell?: HookShell;
 }
 
 export interface HookMatcherEntry {
@@ -97,10 +105,17 @@ export function parseHooksBlock(raw: unknown, origin: string, diagnostics: strin
 					diagnostics.push(`${origin}: ${event} hook of type "${String(candidate?.type)}" skipped (only "command" is supported)`);
 					continue;
 				}
+				const { shell } = hook as { shell?: unknown };
+				let hookShell: HookShell | undefined;
+				if (shell !== undefined) {
+					if (shell === "bash" || shell === "powershell") hookShell = shell;
+					else diagnostics.push(`${origin}: ${event} hook shell "${String(shell)}" ignored (use "bash" or "powershell")`);
+				}
 				hooks.push({
 					type: "command",
 					command: candidate.command,
 					timeout: typeof candidate.timeout === "number" && candidate.timeout > 0 ? candidate.timeout : undefined,
+					shell: hookShell,
 				});
 			}
 			if (hooks.length > 0) {

package/extensions/lib/branch-restore.ts

@@ -18,6 +18,18 @@
 
 import type { SessionEntry } from "@earendil-works/pi-coding-agent";
 
+/** A tool result as the session stores it (pi's `ToolResultMessage` reaches us only through `SessionEntry`). */
+export type BranchToolResult = Extract<Extract<SessionEntry, { type: "message" }>["message"], { role: "toolResult" }>;
+
+/** Every tool result on the branch from one of `toolNames`, oldest first. */
+export function* toolResultsOnBranch(branch: readonly SessionEntry[], toolNames: ReadonlySet<string>): Generator<BranchToolResult> {
+	for (const entry of branch) {
+		if (entry.type !== "message") continue;
+		const msg = entry.message;
+		if (msg.role === "toolResult" && toolNames.has(msg.toolName)) yield msg;
+	}
+}
+
 export function restoreLatestDetails<T>(
 	branch: SessionEntry[],
 	toolNames: ReadonlySet<string>,

package/extensions/lib/claude-context.ts

@@ -34,7 +34,7 @@
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { dirname, isAbsolute, join } from "node:path";
 import { tryReadFile } from "./plugins.ts";
-import { expandTilde } from "./paths.ts";
+import { absoluteFrom, expandTilde } from "./paths.ts";
 
 /** One CLAUDE.md-family file as it appears in the block. `content` is raw (untrimmed). */
 export interface ContextFile {
@@ -116,8 +116,7 @@ function firstOneCodeFile(dir: string): string | null {
 
 /** Resolve an `@import` reference: `~`/`~/` → home, absolute as-is, else relative to `baseDir`. */
 function resolveImportPath(ref: string, baseDir: string, home: string): string {
-	const p = expandTilde(ref, home);
-	return isAbsolute(p) ? p : join(baseDir, p);
+	return absoluteFrom(baseDir, expandTilde(ref, home));
 }
 
 /**

package/extensions/lib/claude-settings.ts

@@ -46,6 +46,25 @@ export function readSettingsFile(path: string): ClaudeSettingsFile | undefined {
 	}
 }
 
+/**
+ * Claude Code's `env` block from the USER settings file only: the string
+ * values it would export into every session. Read for `CLAUDE_CODE_GIT_BASH_PATH`
+ * (lib/shell-spawn.ts). Project and local files are deliberately not merged —
+ * a checked-in `env` that pointed the shell at a `tools/bash` inside the repo
+ * would run that binary for every hook and background command, and the file
+ * is the repository's, not the user's (Claude Code gates the same block behind
+ * its project-trust prompt).
+ */
+export function readSettingsEnv(home: string): Record<string, string> {
+	const env = readSettingsFile(claudeUserSettingsPath(home))?.env;
+	if (!env || typeof env !== "object" || Array.isArray(env)) return {};
+	const out: Record<string, string> = {};
+	for (const [key, value] of Object.entries(env as Record<string, unknown>)) {
+		if (typeof value === "string") out[key] = value;
+	}
+	return out;
+}
+
 /**
  * Claude Code's plugin enabled-state map (`{"name@marketplace": boolean}`),
  * merged across the three settings files — later files win per key.

package/extensions/lib/command-launch.ts

@@ -0,0 +1,71 @@
+/**
+ * How to spawn a user-named command on this platform (pure apart from the
+ * PATH lookup it is given). For every bare `spawn(command, args)` of a command
+ * the user or a config names — a language server, `$EDITOR` — never for the
+ * shell tools, which go through lib/shell-spawn.ts.
+ *
+ * On Windows an npm-installed tool is a `.cmd` shim
+ * (`typescript-language-server.cmd`, VS Code's `code.cmd`): `whichOnPath`
+ * finds it through PATHEXT, but a bare `spawn(command)` does not — libuv tries
+ * the name and `.com`/`.exe` only, so the spawn fails with ENOENT (findings
+ * §22) — and Node refuses to run a batch file without a shell anyway (20.12+,
+ * CVE-2024-27980). Such a shim is started through `cmd.exe /d /s /c` with the
+ * command line quoted the way Node's own `shell: true` does, and the arguments
+ * passed verbatim so Node does not quote them a second time. Anything that
+ * resolves to a real executable, or does not resolve at all (the caller's
+ * ENOENT handling then applies — lsp/install-hints.ts for servers), is spawned
+ * as given. Elsewhere the launch is the command and arguments unchanged.
+ */
+
+import { system32Path } from "./paths.ts";
+import { whichOnPath } from "./which.ts";
+
+export interface CommandLaunch {
+	command: string;
+	args: string[];
+	/** Set for a cmd.exe launch: the single command-line argument is already quoted. */
+	windowsVerbatimArguments?: boolean;
+}
+
+export interface CommandLaunchOptions {
+	platform?: string;
+	which?: (command: string, env: NodeJS.ProcessEnv, platform: string) => string | undefined;
+}
+
+/** A batch-file shim, by extension (the filesystem folds case; PATHEXT spells them upper-case). */
+export function isBatchFile(path: string): boolean {
+	return /\.(cmd|bat)$/i.test(path);
+}
+
+/**
+ * One argument for a cmd.exe command line: quoted when it holds whitespace or
+ * a cmd metacharacter, with the C runtime's rules for what the program the
+ * shim runs will read back — an inner quote is `\"`, and a run of backslashes
+ * directly before a quote (an inner one, or the closing one after a path that
+ * ends in `\`) is doubled, or it would escape that quote. A literal `%` cannot
+ * be protected: cmd.exe expands `%NAME%` before it reads the quotes, the same
+ * limit Node's `shell: true` has, and `.cmd` shims are only reached this way.
+ */
+export function quoteForCmd(arg: string): string {
+	if (arg === "") return '""';
+	if (!/[\s"&|<>^()]/.test(arg)) return arg;
+	const body = arg.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, "$1$1");
+	return `"${body}"`;
+}
+
+export function commandLaunch(command: string, args: string[], env: NodeJS.ProcessEnv, opts: CommandLaunchOptions = {}): CommandLaunch {
+	const platform = opts.platform ?? process.platform;
+	if (platform !== "win32") return { command, args };
+	const resolved = (opts.which ?? whichOnPath)(command, env, platform);
+	if (!resolved) return { command, args };
+	if (!isBatchFile(resolved)) return { command: resolved, args };
+	const line = [resolved, ...args].map(quoteForCmd).join(" ");
+	// cmd.exe is located from the PROCESS environment, never from `env`: a
+	// server's config may set its own variables (a plugin's `.lsp.json` env
+	// block), and `SystemRoot` among them must not redirect the interpreter.
+	return {
+		command: system32Path("cmd.exe"),
+		args: ["/d", "/s", "/c", `"${line}"`],
+		windowsVerbatimArguments: true,
+	};
+}