@adeildo/pi-ask-permission 4.0.0 → 5.0.0

package/src/pi/screen.ts

@@ -0,0 +1,293 @@
+import type { Control, FeatureScope, Json, ScreenEntry } from "@adeildo/pi-kit";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import { type Scope, SCOPE_LABEL } from "#core/always-yes.ts";
+import { isMcpPolicy, isOutsideScope } from "#core/config/schema.ts";
+import {
+	MCP_POLICY_CONTROL,
+	MODE_CONTROL,
+	OUTSIDE_CONTROL,
+	readDryRun,
+	readRigor,
+	setMcpPolicy,
+	writeDryRun,
+	writeRigor,
+} from "#core/config/settings.ts";
+import { globalAlwaysYesPath, projectAlwaysYesPath } from "#core/config/store.ts";
+import { TYPESAFE_PROVIDER } from "#core/judge/backends/jev.ts";
+import {
+	describeRigor,
+	JUDGE_RIGORS,
+	judgeBackendOf,
+	type JudgeRigor,
+} from "#core/judge/config.ts";
+import { probeJudge } from "#core/judge/probe.ts";
+import { judgeLogText } from "#core/judge/report.ts";
+import { MCP_POLICY_TEXT, type McpServer, mcpServers, policyFor, sameServer } from "#core/mcp.ts";
+import { parseMode } from "#core/mode.ts";
+import { shortenHome } from "#core/tools.ts";
+import { renderStatus, setSessionMode, setSessionOutside } from "#pi/mode.ts";
+import { closeFolders, forgetAlwaysYes, resetJudgeHealth, type SessionState } from "#pi/session.ts";
+
+export function registerScreen(scope: FeatureScope, state: SessionState): void {
+	scope.screen.rows(() => mcpRows(scope, state));
+
+	scope.screen.value({
+		id: "session.mode",
+		section: "This session",
+		label: "Mode",
+		description: "Which calls run without asking, until the session ends. Alt+M cycles it.",
+		control: MODE_CONTROL,
+		get: () => state.mode,
+		set: (value, ctx) => {
+			const mode = typeof value === "string" ? parseMode(value) : undefined;
+			if (mode === undefined) return "not a mode";
+			setSessionMode(scope, state, mode, ctx, false);
+			return undefined;
+		},
+	});
+
+	scope.screen.value({
+		id: "session.outside",
+		section: "This session",
+		label: "Outside the workspace",
+		description: "What a call outside the workspace does, until the session ends. Alt+W flips it.",
+		control: OUTSIDE_CONTROL,
+		get: () => state.outside,
+		set: (value, ctx) => {
+			if (!isOutsideScope(value)) return "not an outside policy";
+			setSessionOutside(scope, state, value, ctx, false);
+			return undefined;
+		},
+	});
+
+	scope.screen.value({
+		id: "judge.rigor",
+		section: "Judge",
+		label: "Rigor",
+		description:
+			"How sure the judge must be before a call runs without you. Below that, it asks you.",
+		meta: "saved for every project",
+		control: () => rigorControl(readRigor(scope)),
+		get: () => readRigor(scope),
+		set: (value) => {
+			if (value === "custom")
+				return "custom is what judge.thresholds and judge.riskCeiling set by hand";
+			if (!isRigor(value)) return "not a rigor";
+			return writeRigor(scope, value);
+		},
+	});
+
+	scope.screen.value({
+		id: "judge.dryRun",
+		section: "Judge",
+		label: "Dry run",
+		description:
+			"The judge shows its verdict, and you still decide. Try a policy or a rigor this way first.",
+		meta: "saved for every project",
+		control: { type: "toggle" },
+		get: () => readDryRun(scope),
+		set: (value) => (typeof value === "boolean" ? writeDryRun(scope, value) : "expected on or off"),
+	});
+
+	scope.screen.action({
+		id: "judge.test",
+		section: "Judge",
+		label: "Test the judge",
+		description:
+			"Sends one real request with the settings above, and reports the model and the time.",
+		run: (ctx) => testJudge(state, ctx),
+	});
+
+	scope.screen.action({
+		id: "judge.log",
+		section: "Judge",
+		label: "This session's verdicts",
+		description: "The last calls the judge decided in this session.",
+		text: () => (state.judgeLog.length === 0 ? "none yet" : `${state.judgeLog.length}`),
+		run: () => judgeLogText(state.judgeLog),
+	});
+
+	for (const where of ["session", "project", "global"] as const) {
+		scope.screen.action({
+			id: `always-yes.${where}`,
+			section: "Always yes",
+			label: capitalize(SCOPE_LABEL[where]),
+			description: alwaysYesDescription(where),
+			text: () => count(state.alwaysYes.size(where)),
+			confirm: `Forget every always yes for ${SCOPE_LABEL[where]}?`,
+			run: (ctx) => forget(scope, state, ctx, where),
+		});
+	}
+
+	for (const where of ["session", "project", "global"] as const) {
+		scope.screen.action({
+			id: `folders.${where}`,
+			section: "Folders",
+			label: capitalize(SCOPE_LABEL[where]),
+			description: `Folders outside the workspace you opened from the dialog, ${SCOPE_LABEL[where]}. A call that reaches only these counts as inside. Enter closes them.`,
+			text: () => foldersText(state, where),
+			confirm: `Close every folder open for ${SCOPE_LABEL[where]}?`,
+			run: (ctx) => close(scope, state, ctx, where),
+		});
+	}
+}
+
+// One row per server pi is connected to, plus any server the settings still name. The rows are
+// built when the screen opens, because a server connects after the session starts.
+function mcpRows(scope: FeatureScope, state: SessionState): ScreenEntry[] {
+	const connected = mcpServers(scope.getAllTools());
+	const gone = Object.keys(state.config.mcp.servers).filter(
+		(name) => !connected.some((entry) => sameServer(entry.server, name)),
+	);
+
+	if (connected.length === 0 && gone.length === 0) {
+		return [
+			{
+				kind: "info",
+				id: "mcp.none",
+				section: "MCP servers",
+				label: "Servers",
+				description:
+					"The MCP servers pi connects to. Each one follows the policy set here, whatever the mode.",
+				text: () => "none connected",
+			},
+		];
+	}
+
+	return [
+		...connected.map((entry) => mcpRow(scope, state, entry.server, entry)),
+		...gone.map((server) => mcpRow(scope, state, server)),
+	];
+}
+
+function mcpRow(
+	scope: FeatureScope,
+	state: SessionState,
+	server: string,
+	connected?: McpServer,
+): ScreenEntry {
+	const policy = policyFor(state.config.mcp.servers, server);
+
+	return {
+		kind: "value",
+		id: `mcp.${server}`,
+		section: "MCP servers",
+		label: server,
+		description: `${describeServer(connected)}. ${capitalize(MCP_POLICY_TEXT[policy].description)}.`,
+		meta: "saved for every project",
+		control: MCP_POLICY_CONTROL,
+		get: () => policy,
+		set: (value: Json) => {
+			if (!isMcpPolicy(value)) return "not an MCP policy";
+			return setMcpPolicy(scope, server, value);
+		},
+	};
+}
+
+function describeServer(server: McpServer | undefined): string {
+	if (server === undefined) return "not connected now, so the policy waits";
+	const tools = server.tools === 1 ? "1 tool" : `${server.tools} tools`;
+	return `${tools}, ${server.reads} that read, ${server.destructive} destructive`;
+}
+
+function isRigor(value: Json): value is JudgeRigor {
+	return JUDGE_RIGORS.some((rigor) => rigor === value);
+}
+
+// `custom` is listed only while it is the value, so the row can show it.
+function rigorControl(current: JudgeRigor | "custom"): Control {
+	const options: { value: string; description: string }[] = JUDGE_RIGORS.map((value) => ({
+		value,
+		description: describeRigor(value),
+	}));
+	if (current === "custom")
+		options.push({
+			value: "custom",
+			description:
+				"the settings file sets judge.thresholds or judge.riskCeiling. Pick a rigor to drop them",
+		});
+	return { type: "choice", options };
+}
+
+// With one folder open, the row names it.
+function foldersText(state: SessionState, where: Scope): string {
+	const [first, ...rest] = state.folders.list(where);
+	if (first === undefined) return "none";
+	if (rest.length > 0) return `${rest.length + 1} folders`;
+	return first.access === "read" ? `${shortenHome(first.path)}, reads` : shortenHome(first.path);
+}
+
+function close(
+	scope: FeatureScope,
+	state: SessionState,
+	ctx: ExtensionContext,
+	where: Scope,
+): string | undefined {
+	const removed = closeFolders(scope, state, ctx, where);
+	if (removed === 0) throw new Error(`no folder open for ${SCOPE_LABEL[where]}`);
+	renderStatus(ctx, state);
+	return undefined;
+}
+
+async function testJudge(state: SessionState, ctx: ExtensionContext): Promise<string> {
+	const judge = state.config.judge;
+	const probe = await probeJudge(
+		judge,
+		{
+			resolveApiKey: () => ctx.modelRegistry.getApiKeyForProvider(TYPESAFE_PROVIDER),
+			modelRegistry: ctx.modelRegistry,
+		},
+		ctx.signal,
+	);
+
+	if (!probe.ok) {
+		const auth = ctx.modelRegistry.getProviderAuthStatus(TYPESAFE_PROVIDER);
+		const key = auth.configured
+			? `key from ${auth.label ?? auth.source}`
+			: "no key, run /login typesafe";
+		throw new Error(
+			`the judge failed: ${probe.detail}${judgeBackendOf(judge.model) === "jev" ? ` (${key})` : ""}`,
+		);
+	}
+
+	resetJudgeHealth(state);
+	const lines = [`The judge answered in ${probe.elapsedMs}ms, with ${probe.model ?? judge.model}.`];
+	if (probe.elapsedMs > judge.timeoutMs) {
+		lines.push(
+			"",
+			`That is slower than the ${judge.timeoutMs}ms timeout, so real calls would come to you. Raise the timeout.`,
+		);
+	}
+	return lines.join("\n");
+}
+
+function forget(
+	scope: FeatureScope,
+	state: SessionState,
+	ctx: ExtensionContext,
+	where: Scope,
+): string | undefined {
+	const removed = forgetAlwaysYes(scope, state, ctx, where);
+	if (removed === 0) throw new Error(`nothing to forget for ${SCOPE_LABEL[where]}`);
+	return undefined;
+}
+
+function alwaysYesDescription(where: Scope): string {
+	switch (where) {
+		case "session":
+			return "Rules for this session. Enter forgets them.";
+		case "project":
+			return `Rules for this project, in ${projectAlwaysYesPath(".")}. Enter forgets them.`;
+		case "global":
+			return `Rules for every project, in ${shortenHome(globalAlwaysYesPath())}. Enter forgets them.`;
+	}
+}
+
+function count(size: number): string {
+	return size === 1 ? "1 rule" : `${size} rules`;
+}
+
+function capitalize(text: string): string {
+	return text.charAt(0).toUpperCase() + text.slice(1);
+}

package/src/pi/session-entries.ts

@@ -1,6 +1,9 @@
+// In the session file, so a resume or a fork comes back with its mode, outside and always yes.
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 
-import { isPermissionMode, type PermissionMode } from "#core/mode.ts";
+import { isOutsideScope, type OutsideScope } from "#core/config/schema.ts";
+import type { Access, OpenFolder } from "#core/folders.ts";
+import { parseMode, type PermissionMode } from "#core/mode.ts";
 import { NAME } from "#identity";
 import type { SessionState } from "#pi/session.ts";
 import { isRecord } from "#util/primitives.ts";
@@ -9,20 +12,28 @@ export const SESSION_ENTRY = `${NAME}:session`;
 
 export type SessionEntry =
 	| { kind: "mode"; mode: PermissionMode }
+	| { kind: "outside"; outside: OutsideScope }
 	| { kind: "always-yes"; toolName: string; level: string }
-	| { kind: "forget-always-yes" };
+	| { kind: "forget-always-yes" }
+	| { kind: "folder"; path: string; access: Access }
+	| { kind: "close-folders" };
 
-interface SessionSnapshot {
+export interface SessionSnapshot {
 	mode: PermissionMode;
+	outside: OutsideScope;
 	alwaysYes: { toolName: string; level: string }[];
+	folders: OpenFolder[];
 }
 
 export function record(pi: ExtensionAPI, entry: SessionEntry): void {
 	pi.appendEntry(SESSION_ENTRY, entry);
 }
 
-export function replay(branch: readonly unknown[], startMode: PermissionMode): SessionSnapshot {
-	const snapshot: SessionSnapshot = { mode: startMode, alwaysYes: [] };
+export function replay(
+	branch: readonly unknown[],
+	start: Pick<SessionSnapshot, "mode" | "outside">,
+): SessionSnapshot {
+	const snapshot: SessionSnapshot = { ...start, alwaysYes: [], folders: [] };
 
 	for (const item of branch) {
 		const entry = sessionEntry(item);
@@ -30,25 +41,40 @@ export function replay(branch: readonly unknown[], startMode: PermissionMode): S
 			case "mode":
 				snapshot.mode = entry.mode;
 				break;
+			case "outside":
+				snapshot.outside = entry.outside;
+				break;
 			case "always-yes":
 				snapshot.alwaysYes.push({ toolName: entry.toolName, level: entry.level });
 				break;
 			case "forget-always-yes":
 				snapshot.alwaysYes = [];
 				break;
+			case "folder":
+				snapshot.folders.push({ path: entry.path, access: entry.access });
+				break;
+			case "close-folders":
+				snapshot.folders = [];
+				break;
 		}
 	}
 	return snapshot;
 }
 
 export function restoreSession(state: SessionState, ctx: ExtensionContext): void {
-	const snapshot = replay(ctx.sessionManager.getBranch(), state.config.mode);
+	const snapshot = replay(ctx.sessionManager.getBranch(), {
+		mode: state.config.mode,
+		outside: state.config.workspace.outside,
+	});
 
 	state.mode = snapshot.mode;
+	state.outside = snapshot.outside;
 	state.alwaysYes.forget("session");
 	for (const { toolName, level } of snapshot.alwaysYes) {
 		state.alwaysYes.add("session", toolName, level);
 	}
+	state.folders.forget("session");
+	for (const { path, access } of snapshot.folders) state.folders.add("session", path, access);
 }
 
 function sessionEntry(item: unknown): SessionEntry | undefined {
@@ -59,13 +85,25 @@ function sessionEntry(item: unknown): SessionEntry | undefined {
 	const data = item.data;
 	if (!isRecord(data)) return undefined;
 
-	if (data.kind === "mode" && isPermissionMode(data.mode)) {
-		return { kind: "mode", mode: data.mode };
+	if (data.kind === "mode") {
+		const mode = typeof data.mode === "string" ? parseMode(data.mode) : undefined;
+		return mode === undefined ? undefined : { kind: "mode", mode };
+	}
+	if (data.kind === "outside" && isOutsideScope(data.outside)) {
+		return { kind: "outside", outside: data.outside };
 	}
 	if (data.kind === "always-yes" && isText(data.toolName) && isText(data.level)) {
 		return { kind: "always-yes", toolName: data.toolName, level: data.level };
 	}
 	if (data.kind === "forget-always-yes") return { kind: "forget-always-yes" };
+	if (
+		data.kind === "folder" &&
+		isText(data.path) &&
+		(data.access === "read" || data.access === "write")
+	) {
+		return { kind: "folder", path: data.path, access: data.access };
+	}
+	if (data.kind === "close-folders") return { kind: "close-folders" };
 	return undefined;
 }
 

package/src/pi/session.ts

@@ -2,9 +2,15 @@ import { type FeatureScope } from "@adeildo/pi-kit";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 import { AlwaysYes, savedFileExists, type Scope } from "#core/always-yes.ts";
-import { defaultConfig, type PermissionConfig } from "#core/config/schema.ts";
-import { migrateConfig, readConfig, writeConfig } from "#core/config/settings.ts";
-import { globalAlwaysYesPath, projectAlwaysYesPath } from "#core/config/store.ts";
+import { defaultConfig, type OutsideScope, type PermissionConfig } from "#core/config/schema.ts";
+import { dropRetiredKeys, migrateConfig, readConfig } from "#core/config/settings.ts";
+import {
+	globalAlwaysYesPath,
+	globalFoldersPath,
+	projectAlwaysYesPath,
+	projectFoldersPath,
+} from "#core/config/store.ts";
+import { type Access, OpenFolders } from "#core/folders.ts";
 import type { JudgeOutcome, JudgeRecord } from "#core/judge/types.ts";
 import type { PermissionMode } from "#core/mode.ts";
 import type { ToolAdapter } from "#core/tools.ts";
@@ -24,7 +30,9 @@ export interface JudgeHealth {
 export interface SessionState {
 	config: PermissionConfig;
 	mode: PermissionMode;
+	outside: OutsideScope;
 	alwaysYes: AlwaysYes;
+	folders: OpenFolders;
 	pendingNotes: Map<string, string>;
 	judgeCache: Map<string, JudgeOutcome>;
 	judgeLog: JudgeRecord[];
@@ -41,7 +49,9 @@ export function createSession(): SessionState {
 	return {
 		config,
 		mode: config.mode,
+		outside: config.workspace.outside,
 		alwaysYes: new AlwaysYes(),
+		folders: new OpenFolders(),
 		pendingNotes: new Map(),
 		judgeCache: new Map(),
 		judgeLog: [],
@@ -65,7 +75,7 @@ export function noteJudgeFailure(state: SessionState, ctx: ExtensionContext): vo
 	state.judgeHealth.failures = 0;
 	state.judgeHealth.retryAt = Date.now() + JUDGE_RETRY_MS;
 	ctx.ui.notify(
-		`${NAME}: judge paused for ${JUDGE_RETRY_MS / 1000}s after repeated failures; run /perm judge test`,
+		`${NAME}: judge paused for ${JUDGE_RETRY_MS / 1000}s after repeated failures; try Test the judge on Alt+S`,
 		"warning",
 	);
 }
@@ -77,17 +87,13 @@ export function loadSessionConfig(
 	ctx: ExtensionContext,
 ): void {
 	for (const warning of migrateConfig(scope)) ctx.ui.notify(`${NAME}: ${warning}`, "warning");
+	for (const line of dropRetiredKeys(scope)) ctx.ui.notify(`${NAME}: ${line}`, "info");
 
 	state.config = readConfig(scope);
 	state.typing.stop();
 	state.typing = new TypingMonitor(state.config.typing.pause, state.config.typing.maxWait);
 }
 
-export function saveConfig(scope: FeatureScope, state: SessionState, ctx: ExtensionContext): void {
-	const error = writeConfig(scope, state.config);
-	if (error) ctx.ui.notify(`${NAME}: could not save the settings: ${error}`, "error");
-}
-
 export function openAlwaysYes(state: SessionState, ctx: ExtensionContext): void {
 	const project = projectAlwaysYesPath(ctx.cwd);
 	const trusted = ctx.isProjectTrusted();
@@ -96,12 +102,47 @@ export function openAlwaysYes(state: SessionState, ctx: ExtensionContext): void
 		project: trusted ? project : undefined,
 	});
 
+	const folders = projectFoldersPath(ctx.cwd);
+	warnings.push(
+		...state.folders.open({
+			global: globalFoldersPath(),
+			project: trusted ? folders : undefined,
+		}),
+	);
+
 	for (const warning of warnings) ctx.ui.notify(`${NAME}: ${warning}`, "warning");
-	if (!trusted && savedFileExists(project)) {
-		ctx.ui.notify(`${NAME}: ${project} skipped, this project is not trusted`, "warning");
+	for (const file of [project, folders]) {
+		if (trusted || !savedFileExists(file)) continue;
+		ctx.ui.notify(`${NAME}: ${file} skipped, this project is not trusted`, "warning");
 	}
 }
 
+export function openFolder(
+	pi: ExtensionAPI,
+	state: SessionState,
+	ctx: ExtensionContext,
+	scope: Scope,
+	path: string,
+	access: Access,
+): void {
+	if (scope === "session") record(pi, { kind: "folder", path, access });
+	const problem = state.folders.add(scope, path, access);
+	if (problem) ctx.ui.notify(`${NAME}: could not save the folder: ${problem}`, "warning");
+}
+
+export function closeFolders(
+	pi: ExtensionAPI,
+	state: SessionState,
+	ctx: ExtensionContext,
+	scope: Scope,
+): number {
+	if (scope === "session") record(pi, { kind: "close-folders" });
+	const { removed, errors } = state.folders.forget(scope);
+	for (const error of errors)
+		ctx.ui.notify(`${NAME}: could not close the folders: ${error}`, "error");
+	return removed;
+}
+
 export function rememberAlwaysYes(
 	pi: ExtensionAPI,
 	state: SessionState,

package/src/ui/decision-options.ts

@@ -1,23 +1,69 @@
+import type { FolderOffer } from "#core/answer.ts";
+import { shortenHome } from "#core/tools.ts";
+
 export interface Choice {
 	key: string;
 	decision: "allow" | "deny";
 	always: boolean;
+	/** Opens the offered folder. */
+	open?: boolean;
 	label: string;
 	tone: "success" | "warning" | "error";
 }
 
+const YES: Omit<Choice, "key"> = {
+	decision: "allow",
+	always: false,
+	label: "yes",
+	tone: "success",
+};
+const ALWAYS: Omit<Choice, "key"> = {
+	decision: "allow",
+	always: true,
+	label: "always yes",
+	tone: "warning",
+};
+const DENY: Omit<Choice, "key"> = { decision: "deny", always: false, label: "deny", tone: "error" };
+
 export const CHOICES: Choice[] = [
-	{ key: "1", decision: "allow", always: false, label: "yes", tone: "success" },
-	{ key: "2", decision: "allow", always: true, label: "always yes", tone: "warning" },
-	{ key: "3", decision: "deny", always: false, label: "deny", tone: "error" },
+	{ ...YES, key: "1" },
+	{ ...ALWAYS, key: "2" },
+	{ ...DENY, key: "3" },
 ];
 
-export const FALLBACK_CHOICES: (Choice & { note: boolean })[] = CHOICES.flatMap((option, index) => [
-	{ ...option, key: String(index * 2 + 1), note: false },
-	{
-		...option,
-		key: String(index * 2 + 2),
-		note: true,
-		label: `${option.label}, ${option.decision === "allow" ? "with a note" : "with a reason"}`,
-	},
-]);
+// Second, right under the plain yes: the answer the call most likely wants.
+export function choicesFor(offer?: FolderOffer): Choice[] {
+	if (offer === undefined) return CHOICES;
+	const tone = offer.access === "read" ? "success" : "warning";
+	return [
+		{ ...YES, key: "1" },
+		{ key: "2", decision: "allow", always: false, open: true, label: "", tone },
+		{ ...ALWAYS, key: "3" },
+		{ ...DENY, key: "4" },
+	];
+}
+
+export function openLabel(offer: FolderOffer, folder: string): string {
+	const shown = shortenHome(folder);
+	return offer.access === "read"
+		? `yes, and allow reads in ${shown}`
+		: `yes, and add ${shown} to the workspace`;
+}
+
+export function fallbackChoices(offer?: FolderOffer): (Choice & { note: boolean })[] {
+	const folder = offer?.folders[offer.suggested];
+	return choicesFor(offer).flatMap((option, index) => {
+		const label = option.open && offer && folder ? openLabel(offer, folder) : option.label;
+		return [
+			{ ...option, label, key: String(index * 2 + 1), note: false },
+			{
+				...option,
+				key: String(index * 2 + 2),
+				note: true,
+				label: `${label}, ${option.decision === "allow" ? "with a note" : "with a reason"}`,
+			},
+		];
+	});
+}
+
+export const FALLBACK_CHOICES = fallbackChoices();