@adeildo/pi-ask-permission 4.0.0

package/src/core/tools.ts

@@ -0,0 +1,208 @@
+import { homedir } from "node:os";
+import { dirname } from "node:path";
+
+import { commandWords, isReadOnlyCommand } from "#core/readonly-bash.ts";
+
+export interface CallDescriptor {
+	summary: string;
+	levels: string[];
+}
+
+export type ToolInput = Record<string, unknown>;
+
+export interface ToolAdapter {
+	describe(input: ToolInput): CallDescriptor;
+	/** Undefined counts as outside the workspace. */
+	paths(input: ToolInput): string[] | undefined;
+	edits?: boolean;
+	readOnly?(input: ToolInput): boolean;
+}
+
+const ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/;
+const INPUT_SUMMARY_MAX = 400;
+
+const bash: ToolAdapter = {
+	describe: commandTarget,
+	paths: (input) => commandPaths(text(input.command) ?? ""),
+	readOnly: (input) => isReadOnlyCommand(text(input.command) ?? ""),
+};
+
+const powershell: ToolAdapter = {
+	describe: commandTarget,
+	paths: () => undefined,
+};
+
+const fileReader: ToolAdapter = {
+	describe: (input) => {
+		const path = text(input.path) ?? "";
+		return { summary: path.trim() || "(no path)", levels: pathLevels(path) };
+	},
+	paths: (input) => [text(input.path)?.trim() || "."],
+};
+
+const fileWriter: ToolAdapter = { ...fileReader, edits: true };
+
+const mcp: ToolAdapter = {
+	describe: mcpTarget,
+	paths: () => [],
+};
+
+const BUILT_IN: Record<string, ToolAdapter> = {
+	bash,
+	powershell,
+	read: fileReader,
+	grep: fileReader,
+	find: fileReader,
+	ls: fileReader,
+	write: fileWriter,
+	edit: fileWriter,
+	mcp,
+};
+
+export type CustomTools = ReadonlyMap<string, Partial<ToolAdapter>>;
+
+export function toolAdapter(toolName: string, custom: CustomTools = new Map()): ToolAdapter {
+	const builtIn = BUILT_IN[toolName];
+	if (builtIn) return builtIn;
+
+	return {
+		describe: (input) => ({ summary: summarizeInput(input), levels: [toolName] }),
+		paths: () => [],
+		...custom.get(toolName),
+	};
+}
+
+export function isBuiltInTool(toolName: string): boolean {
+	return toolName in BUILT_IN;
+}
+
+export function asToolInput(input: unknown): ToolInput {
+	return typeof input === "object" && input !== null ? (input as ToolInput) : {};
+}
+
+function commandTarget(input: ToolInput): CallDescriptor {
+	const command = text(input.command) ?? "";
+	return { summary: command.trim() || "(empty command)", levels: commandLevels(command) };
+}
+
+export function commandLevels(command: string): string[] {
+	const tokens = tokenize(command).filter((token) => !ASSIGNMENT.test(token));
+	const head = tokens[0];
+
+	const exact = command.trim();
+	if (head === undefined) return [exact || "(empty command)"];
+
+	const levels = [head];
+	if (tokens.length > 1) levels.push(tokens.slice(0, 2).join(" "));
+	if (!levels.includes(exact)) levels.push(exact);
+
+	return levels;
+}
+
+export function pathLevels(path: string): string[] {
+	const exact = path.trim();
+	if (!exact) return ["(no path)"];
+
+	const display = shortenHome(exact);
+	const directory = dirname(display);
+	if (directory === "." || directory === display) return [display];
+
+	return [directory, display];
+}
+
+export function commandPaths(command: string): string[] | undefined {
+	const words = commandWords(command);
+	if (words === undefined) return undefined;
+
+	const paths: string[] = [];
+	for (const word of words) {
+		const path = pathValue(word);
+		if (path !== undefined) paths.push(path);
+	}
+	return paths;
+}
+
+function pathValue(word: string): string | undefined {
+	const value = word.startsWith("-") ? word.slice(word.indexOf("=") + 1) : word;
+	if (value === "" || value.startsWith("-")) return undefined;
+	return /^(~|\/|\.\.?$|\.\.?\/)/.test(value) || value.includes("/") ? value : undefined;
+}
+
+export function shortenHome(path: string): string {
+	const home = homedir();
+	if (!home) return path;
+	if (path === home) return "~";
+	if (path.startsWith(`${home}/`) || path.startsWith(`${home}\\`))
+		return `~${path.slice(home.length)}`;
+	return path;
+}
+
+export function summarizeInput(input: ToolInput): string {
+	const keys = Object.keys(input);
+	if (keys.length === 0) return "(no input)";
+
+	try {
+		const json = JSON.stringify(input);
+		return json.length > INPUT_SUMMARY_MAX ? `${json.slice(0, INPUT_SUMMARY_MAX - 3)}...` : json;
+	} catch {
+		return `{ ${keys.join(", ")} }`;
+	}
+}
+
+export function tokenize(command: string): string[] {
+	const tokens: string[] = [];
+	let current = "";
+	let quote: '"' | "'" | null = null;
+
+	for (let index = 0; index < command.length; index++) {
+		const char = command[index];
+		if (char === undefined) break;
+
+		if (quote) {
+			if (char === quote) quote = null;
+			else current += char;
+			continue;
+		}
+
+		if (char === '"' || char === "'") {
+			quote = char;
+			continue;
+		}
+
+		if (char === "\\" && index + 1 < command.length) {
+			const escaped = command[index + 1];
+			if (escaped !== undefined) current += escaped;
+			index++;
+			continue;
+		}
+
+		if (/\s/.test(char)) {
+			if (current) {
+				tokens.push(current);
+				current = "";
+			}
+			continue;
+		}
+
+		current += char;
+	}
+
+	if (current) tokens.push(current);
+	return tokens;
+}
+
+function mcpTarget(input: ToolInput): CallDescriptor {
+	const server = text(input.server);
+	const tool = text(input.tool);
+
+	if (server && tool) {
+		return { summary: `${server}:${tool}`, levels: [server, `${server}:${tool}`] };
+	}
+	if (tool) return { summary: tool, levels: [tool] };
+	if (server) return { summary: server, levels: [server] };
+	return { summary: summarizeInput(input), levels: ["mcp"] };
+}
+
+function text(value: unknown): string | undefined {
+	return typeof value === "string" && value !== "" ? value : undefined;
+}

package/src/core/workspace.ts

@@ -0,0 +1,66 @@
+import { realpathSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { basename, dirname, join, normalize, resolve, sep } from "node:path";
+
+import type { WorkspaceConfig } from "#core/config/schema.ts";
+
+const PASTED_IMAGE_PREFIXES = ["pi-clipboard-", "pi-ask-permission-"];
+
+export interface WorkspaceCheck {
+	outside: boolean;
+	path?: string;
+}
+
+// realpath, so a symlink out of the project does not count as inside.
+export function checkWorkspace(
+	config: WorkspaceConfig,
+	cwd: string,
+	paths: string[] | undefined,
+): WorkspaceCheck {
+	if (paths === undefined) return { outside: true };
+
+	const roots = resolveRoots(config.roots, cwd);
+	const temp = canonical(tmpdir());
+	for (const path of paths) {
+		const absolute = canonical(resolvePath(path, cwd));
+		if (isPastedFile(absolute, temp)) continue;
+		if (!isInside(absolute, roots)) return { outside: true, path };
+	}
+	return { outside: false };
+}
+
+export function resolveRoots(roots: string[], cwd: string): string[] {
+	const list = roots.length > 0 ? roots : ["."];
+	return list.map((root) => canonical(resolvePath(root, cwd)));
+}
+
+function resolvePath(path: string, cwd: string): string {
+	if (path === "~") return homedir();
+	if (path.startsWith("~/")) return join(homedir(), path.slice(2));
+	return resolve(cwd, path);
+}
+
+function canonical(path: string): string {
+	const lexical = normalize(path);
+	try {
+		return realpathSync(lexical);
+	} catch {
+		try {
+			return join(realpathSync(dirname(lexical)), basename(lexical));
+		} catch {
+			return lexical;
+		}
+	}
+}
+
+function isInside(path: string, roots: string[]): boolean {
+	return roots.some((root) => {
+		const prefix = root.endsWith(sep) ? root : `${root}${sep}`;
+		return path === root || path.startsWith(prefix);
+	});
+}
+
+function isPastedFile(path: string, temp: string): boolean {
+	if (dirname(path) !== temp) return false;
+	return PASTED_IMAGE_PREFIXES.some((prefix) => basename(path).startsWith(prefix));
+}

package/src/identity.ts

@@ -0,0 +1,5 @@
+// The npm package is `@adeildo/pi-ask-permission`, but these names are written into session files
+// (the judge card's customType), events, the status key and the config folder, so they stay
+// `pi-ask-permission`. Another name would break every saved session on resume.
+export const NAME = "pi-ask-permission";
+export const CONFIG_DIR = "pi-ask-permission";

package/src/index.ts

@@ -0,0 +1,29 @@
+import { createApp, defineFeature } from "@adeildo/pi-kit";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { listenForTools } from "#pi/api.ts";
+import { registerBashTimer } from "#pi/bash-timer.ts";
+import { registerCommands } from "#pi/commands.ts";
+import { registerEvents } from "#pi/events.ts";
+import { registerTypesafeProvider } from "#pi/provider.ts";
+import { createSession } from "#pi/session.ts";
+import { registerJudgeEntry } from "#ui/judge-entry.ts";
+
+export const permission = defineFeature({
+	id: "permission",
+	description: "Ask before a tool call runs, with a judge model for the routine ones",
+	setup(scope) {
+		registerBashTimer(scope);
+		registerTypesafeProvider(scope);
+		registerJudgeEntry(scope);
+
+		const session = createSession();
+		registerEvents(scope, session);
+		listenForTools(scope, session.customTools);
+		registerCommands(scope, session);
+	},
+});
+
+export default function piAskPermission(pi: ExtensionAPI): void {
+	createApp(pi, { name: "pi-ask-permission" }).use(permission).build();
+}

package/src/pi/api.ts

@@ -0,0 +1,44 @@
+import type { FeatureScope } from "@adeildo/pi-kit";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { isBuiltInTool, type ToolAdapter } from "#core/tools.ts";
+import { NAME } from "#identity";
+import { isRecord } from "#util/primitives.ts";
+
+export const DECIDED_EVENT = `${NAME}:decided`;
+export const TOOL_EVENT = `${NAME}:tool`;
+export const ANSWER_ENTRY = `${NAME}:answer`;
+
+export interface Decided {
+	toolCallId: string;
+	toolName: string;
+	summary: string;
+	action: "allow" | "block";
+	/** The layer that decided, `you` for the dialog, or `no UI`. */
+	by: string;
+	reason?: string;
+	note?: string;
+}
+
+export function announce(pi: ExtensionAPI, decided: Decided): void {
+	pi.events.emit(DECIDED_EVENT, decided);
+	if (decided.by === "you") pi.appendEntry(ANSWER_ENTRY, decided);
+}
+
+// Emit from session_start: every extension has loaded by then, so this one is listening.
+export function listenForTools(
+	scope: FeatureScope,
+	tools: Map<string, Partial<ToolAdapter>>,
+): void {
+	scope.events.on(TOOL_EVENT, (data) => {
+		if (!isRecord(data) || typeof data.name !== "string" || isBuiltInTool(data.name)) return;
+
+		const adapter: Partial<ToolAdapter> = {};
+		if (typeof data.edits === "boolean") adapter.edits = data.edits;
+		if (typeof data.paths === "function") adapter.paths = data.paths as ToolAdapter["paths"];
+		if (typeof data.describe === "function") {
+			adapter.describe = data.describe as ToolAdapter["describe"];
+		}
+		tools.set(data.name, adapter);
+	});
+}

package/src/pi/bash-timer.ts

@@ -0,0 +1,49 @@
+import type { FeatureScope } from "@adeildo/pi-kit";
+import {
+	createBashToolDefinition,
+	type ExtensionContext,
+	getAgentDir,
+	SettingsManager,
+} from "@earendil-works/pi-coding-agent";
+
+// pi starts the "Took" clock before the dialog answers; this restarts it when bash runs.
+export function registerBashTimer(scope: FeatureScope): void {
+	const template = createBashToolDefinition(process.cwd());
+	const renderResult = template.renderResult;
+	if (!renderResult) return;
+
+	const startedAt = new Map<string, number>();
+
+	scope.on("session_shutdown", () => {
+		startedAt.clear();
+	});
+
+	const timed: typeof template = {
+		...template,
+		execute(toolCallId, params, signal, onUpdate, ctx) {
+			startedAt.set(toolCallId, Date.now());
+			return bashFor(ctx).execute(toolCallId, params, signal, onUpdate, ctx);
+		},
+		renderResult(result, options, theme, context) {
+			const start = startedAt.get(context.toolCallId);
+			if (start !== undefined) context.state.startedAt = start;
+
+			const component = renderResult(result, options, theme, context);
+			if (!options.isPartial) startedAt.delete(context.toolCallId);
+			return component;
+		},
+	};
+
+	scope.registerTool(timed);
+}
+
+// Per call, so an untrusted project's settings.json cannot prefix every command.
+function bashFor(ctx: ExtensionContext): ReturnType<typeof createBashToolDefinition> {
+	const settings = SettingsManager.create(ctx.cwd, getAgentDir(), {
+		projectTrusted: ctx.isProjectTrusted(),
+	});
+	return createBashToolDefinition(ctx.cwd, {
+		commandPrefix: settings.getShellCommandPrefix(),
+		shellPath: settings.getShellPath(),
+	});
+}

package/src/pi/commands.ts

@@ -0,0 +1,193 @@
+import type { FeatureScope } from "@adeildo/pi-kit";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type AutocompleteItem, Key } from "@earendil-works/pi-tui";
+
+import { type Scope, SCOPE_LABEL } from "#core/always-yes.ts";
+import { TYPESAFE_PROVIDER } from "#core/judge/backends/jev.ts";
+import { probeJudge } from "#core/judge/probe.ts";
+import { judgeLogText } from "#core/judge/report.ts";
+import { MODE_DESCRIPTION, nextMode, parseMode, PERMISSION_MODES } from "#core/mode.ts";
+import { NAME } from "#identity";
+import { setSessionMode } from "#pi/mode.ts";
+import { forgetAlwaysYes, resetJudgeHealth, saveConfig, type SessionState } from "#pi/session.ts";
+import { alwaysYesCount, openSettings } from "#ui/settings/screen.ts";
+import { notifyJudgePolicyWarning, statusText } from "#ui/settings/status.ts";
+
+const JUDGE_STATUS = `${NAME}:judge`;
+
+export function registerCommands(scope: FeatureScope, state: SessionState): void {
+	const openSettingsFor = (ctx: ExtensionContext): Promise<void> =>
+		openSettings(ctx, {
+			config: state.config,
+			alwaysYes: state.alwaysYes,
+			mode: () => state.mode,
+			setMode: (mode) => setSessionMode(scope, state, mode, ctx, false),
+			save: () => saveConfig(scope, state, ctx),
+			onJudgeChange: () => state.judgeCache.clear(),
+		});
+
+	function notifyStatus(ctx: ExtensionContext): void {
+		ctx.ui.notify(statusText(state.config, state.alwaysYes, ctx.cwd, state.mode), "info");
+	}
+
+	function cycleMode(ctx: ExtensionContext): void {
+		setSessionMode(scope, state, nextMode(state.mode), ctx);
+	}
+
+	async function runJudgeProbe(ctx: ExtensionContext): Promise<void> {
+		ctx.ui.setStatus(JUDGE_STATUS, "judge: testing\u2026");
+		const auth = ctx.modelRegistry.getProviderAuthStatus(TYPESAFE_PROVIDER);
+		const probe = await probeJudge(
+			state.config.judge,
+			{
+				resolveApiKey: () => ctx.modelRegistry.getApiKeyForProvider(TYPESAFE_PROVIDER),
+				modelRegistry: ctx.modelRegistry,
+			},
+			ctx.signal,
+		).finally(() => ctx.ui.setStatus(JUDGE_STATUS, undefined));
+
+		if (!probe.ok) {
+			const source = auth.configured
+				? `key from ${auth.label ?? auth.source}`
+				: "no key configured";
+			const suffix = state.config.judge.provider === "jev" ? ` (${source})` : "";
+			ctx.ui.notify(`${NAME}: judge test failed: ${probe.detail}${suffix}`, "error");
+			return;
+		}
+
+		resetJudgeHealth(state);
+
+		const summary = `judge test ok \u00b7 ${probe.model ?? state.config.judge.model} \u00b7 ${probe.elapsedMs}ms`;
+		if (probe.elapsedMs > state.config.judge.timeoutMs) {
+			ctx.ui.notify(
+				`${NAME}: ${summary}. Slower than the ${state.config.judge.timeoutMs}ms timeout, raise judge.timeoutMs`,
+				"warning",
+			);
+			return;
+		}
+
+		ctx.ui.notify(`${NAME}: ${summary}`, "info");
+	}
+
+	async function judgeCommand(ctx: ExtensionContext, argument: string | undefined): Promise<void> {
+		if (argument === "log") {
+			ctx.ui.notify(judgeLogText(state.judgeLog), "info");
+			return;
+		}
+
+		if (argument === "test") {
+			await runJudgeProbe(ctx);
+			return;
+		}
+
+		if (argument === "on" || argument === "off") {
+			state.config.judge.enabled = argument === "on";
+			saveConfig(scope, state, ctx);
+			state.judgeCache.clear();
+			if (argument === "on") {
+				resetJudgeHealth(state);
+				notifyJudgePolicyWarning(state.config, ctx);
+			}
+			ctx.ui.notify(`${NAME}: judge ${argument}`, "info");
+			return;
+		}
+
+		await settingsOrStatus(ctx);
+	}
+
+	function modeCommand(ctx: ExtensionContext, argument: string | undefined): void {
+		if (argument === undefined) {
+			cycleMode(ctx);
+			return;
+		}
+
+		const mode = parseMode(argument);
+		if (!mode) {
+			ctx.ui.notify(`${NAME}: mode takes ${PERMISSION_MODES.join(", ")}`, "warning");
+			return;
+		}
+
+		setSessionMode(scope, state, mode, ctx);
+	}
+
+	function forgetCommand(ctx: ExtensionContext, argument = "session"): void {
+		const level = FORGET_SCOPES[argument];
+		if (!level) {
+			ctx.ui.notify(`${NAME}: forget takes ${Object.keys(FORGET_SCOPES).join(", ")}`, "warning");
+			return;
+		}
+
+		const where = level === "all" ? "every scope" : SCOPE_LABEL[level];
+		const removed = alwaysYesCount(forgetAlwaysYes(scope, state, ctx, level));
+		ctx.ui.notify(`${NAME}: forgot ${removed} from ${where}`, "info");
+	}
+
+	async function settingsOrStatus(ctx: ExtensionContext): Promise<void> {
+		if (ctx.mode === "tui") await openSettingsFor(ctx);
+		else notifyStatus(ctx);
+	}
+
+	scope.registerCommand("perm", {
+		description: `${NAME}: settings, mode, status, forget, judge`,
+		getArgumentCompletions: (prefix) => {
+			const typed = prefix.trimStart().toLowerCase();
+			const matches = SUBCOMMANDS.filter((command) => command.value.startsWith(typed));
+			return matches.length > 0 ? matches : null;
+		},
+		handler: async (args, ctx) => {
+			const [verb, argument] = args.trim().toLowerCase().split(/\s+/);
+
+			switch (verb) {
+				case "":
+					await settingsOrStatus(ctx);
+					return;
+				case "mode":
+					modeCommand(ctx, argument);
+					return;
+				case "status":
+					notifyStatus(ctx);
+					return;
+				case "forget":
+					forgetCommand(ctx, argument);
+					return;
+				case "judge":
+					await judgeCommand(ctx, argument);
+					return;
+				default:
+					ctx.ui.notify(`${NAME}: /perm takes ${VERBS.join(", ")}`, "warning");
+			}
+		},
+	});
+
+	scope.registerShortcut(Key.alt("m"), {
+		description: `${NAME}: cycle mode (manual, accept edits, auto)`,
+		handler: cycleMode,
+	});
+}
+
+const FORGET_SCOPES: Record<string, Scope | "all"> = {
+	session: "session",
+	project: "project",
+	everywhere: "global",
+	all: "all",
+};
+
+const SUBCOMMANDS: AutocompleteItem[] = [
+	suggestion("mode", "Switch to the next mode (also Alt+M)"),
+	...PERMISSION_MODES.map((mode) => suggestion(`mode ${mode}`, MODE_DESCRIPTION[mode])),
+	suggestion("status", "Show the config, always yes, and file paths"),
+	suggestion("forget", "Forget this session's always yes"),
+	suggestion("forget project", "Forget this project's always yes"),
+	suggestion("forget everywhere", "Forget the always yes that applies everywhere"),
+	suggestion("forget all", "Forget every always yes"),
+	suggestion("judge on", "Turn the judge on"),
+	suggestion("judge off", "Turn the judge off"),
+	suggestion("judge log", "Show this session's judge decisions"),
+	suggestion("judge test", "Send one real request and report the result"),
+];
+
+function suggestion(value: string, description: string): AutocompleteItem {
+	return { value, label: value, description };
+}
+
+const VERBS = ["mode", "status", "forget", "judge"];