@vitos-pizza/vitos-pizza 0.1.0

package/node_modules/@vitos-pizza/permission-system/src/ui/approval-summary.ts

@@ -0,0 +1,43 @@
+import type { GateContext } from "../types.ts";
+
+export function buildApprovalSummary(ctx: GateContext): string {
+	const { toolName, input } = ctx;
+
+	if (toolName === "bash" && typeof input.command === "string") {
+		return `Run bash command:\n${input.command}`;
+	}
+
+	if (
+		(toolName === "read" ||
+			toolName === "write" ||
+			toolName === "edit" ||
+			toolName === "grep" ||
+			toolName === "find" ||
+			toolName === "ls") &&
+		typeof input.path === "string"
+	) {
+		return `${toolName} ${input.path}`;
+	}
+
+	if (toolName === "mcp") {
+		const server =
+			typeof input.server === "string" ? input.server : "unknown-server";
+		const tool = typeof input.tool === "string" ? input.tool : "unknown-tool";
+		return `MCP ${server}/${tool}`;
+	}
+
+	if (toolName === "edit" && typeof input.old_string === "string") {
+		const lines = input.old_string.split("\n").length;
+		return `edit (${lines} line${lines === 1 ? "" : "s"})`;
+	}
+
+	const preview = JSON.stringify(input, null, 2);
+	if (preview.length > 400) {
+		return `${toolName}: ${preview.slice(0, 400)}…`;
+	}
+	return `${toolName}: ${preview}`;
+}
+
+export function buildApprovalTitle(toolName: string): string {
+	return `Allow ${toolName}?`;
+}

package/node_modules/@vitos-pizza/permission-system/src/ui/config-modal.ts

@@ -0,0 +1,36 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionConfig } from "../types.ts";
+
+export async function showPermissionSystemModal(
+	ctx: ExtensionContext,
+	config: ExtensionConfig,
+	onSave: (next: ExtensionConfig) => void,
+): Promise<void> {
+	if (!ctx.hasUI) {
+		ctx.ui.notify(
+			"Permission system settings require an interactive UI.",
+			"info",
+		);
+		return;
+	}
+
+	const yoloLabel = config.yoloMode
+		? "YOLO mode: ON (auto-approve ask)"
+		: "YOLO mode: OFF";
+	const debugLabel = config.debug ? "Debug logging: ON" : "Debug logging: OFF";
+	const selected = await ctx.ui.select("Permission system", [
+		yoloLabel,
+		debugLabel,
+		"Close",
+	]);
+	if (!selected || selected === "Close") return;
+
+	const next = { ...config };
+	if (selected === yoloLabel) next.yoloMode = !config.yoloMode;
+	if (selected === debugLabel) next.debug = !config.debug;
+	onSave(next);
+	ctx.ui.notify(
+		"Permission settings updated. Run /reload to apply runtime changes.",
+		"info",
+	);
+}

package/node_modules/@vitos-pizza/permission-system/src/ui/permission-dialog.ts

@@ -0,0 +1,52 @@
+export type PermissionDecisionState =
+	| "approved"
+	| "approved_for_session"
+	| "denied"
+	| "denied_with_reason";
+
+export interface PermissionPromptDecision {
+	approved: boolean;
+	state: PermissionDecisionState;
+	denialReason?: string;
+	autoApproved?: true;
+	confirmationUnavailable?: true;
+}
+
+export interface PermissionDecisionUi {
+	select(title: string, options: string[]): Promise<string | undefined>;
+	input(title: string, placeholder?: string): Promise<string | undefined>;
+}
+
+const APPROVE_OPTION = "Yes";
+const APPROVE_FOR_SESSION_OPTION = "Yes, for this session";
+const DENY_OPTION = "No";
+const DENY_WITH_REASON_OPTION = "No, provide reason";
+
+export async function requestPermissionDecisionFromUi(
+	ui: PermissionDecisionUi,
+	title: string,
+	_message: string,
+	options?: { sessionLabel?: string },
+): Promise<PermissionPromptDecision> {
+	const sessionOption = options?.sessionLabel ?? APPROVE_FOR_SESSION_OPTION;
+	const decisionOptions = [
+		APPROVE_OPTION,
+		sessionOption,
+		DENY_OPTION,
+		DENY_WITH_REASON_OPTION,
+	];
+	const selected = await ui.select(title, decisionOptions);
+	if (!selected || selected === DENY_OPTION) {
+		return { approved: false, state: "denied" };
+	}
+	if (selected === DENY_WITH_REASON_OPTION) {
+		const reason = await ui.input("Reason for denial", "optional");
+		return reason
+			? { approved: false, state: "denied_with_reason", denialReason: reason }
+			: { approved: false, state: "denied" };
+	}
+	if (selected === sessionOption) {
+		return { approved: true, state: "approved_for_session" };
+	}
+	return { approved: true, state: "approved" };
+}

package/node_modules/@vitos-pizza/permission-system/src/wildcard-matcher.ts

@@ -0,0 +1,81 @@
+import { expandHomePath } from "./expand-home.ts";
+
+export type CompiledWildcardPattern<TState> = {
+	pattern: string;
+	state: TState;
+	regex: RegExp;
+};
+
+export type WildcardPatternMatch<TState> = {
+	state: TState;
+	matchedPattern: string;
+	matchedName: string;
+};
+
+export interface WildcardMatchOptions {
+	caseInsensitive?: boolean;
+	windowsSeparators?: boolean;
+}
+
+function escapeRegExp(value: string): string {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export function compileWildcardPattern<TState>(
+	pattern: string,
+	state: TState,
+	options?: WildcardMatchOptions,
+): CompiledWildcardPattern<TState> {
+	let expanded = expandHomePath(pattern);
+	if (options?.windowsSeparators) {
+		expanded = expanded.replaceAll("/", "\\");
+	}
+	let escaped = expanded
+		.split("*")
+		.map((part) => escapeRegExp(part).replaceAll("\\?", "."))
+		.join(".*");
+
+	if (escaped.endsWith(" .*")) {
+		escaped = `${escaped.slice(0, -3)}( .*)?`;
+	}
+
+	return {
+		pattern,
+		state,
+		regex: new RegExp(`^${escaped}$`, options?.caseInsensitive ? "si" : "s"),
+	};
+}
+
+export function compileWildcardPatternEntries<TState>(
+	entries: Iterable<readonly [string, TState]>,
+	options?: WildcardMatchOptions,
+): CompiledWildcardPattern<TState>[] {
+	return Array.from(entries, ([pattern, state]) =>
+		compileWildcardPattern(pattern, state, options),
+	);
+}
+
+export function findCompiledWildcardMatch<TState>(
+	patterns: readonly CompiledWildcardPattern<TState>[],
+	name: string,
+): WildcardPatternMatch<TState> | null {
+	for (let index = patterns.length - 1; index >= 0; index -= 1) {
+		const pattern = patterns[index];
+		if (pattern.regex.test(name)) {
+			return {
+				state: pattern.state,
+				matchedPattern: pattern.pattern,
+				matchedName: name,
+			};
+		}
+	}
+	return null;
+}
+
+export function wildcardMatch(
+	pattern: string,
+	value: string,
+	options?: WildcardMatchOptions,
+): boolean {
+	return compileWildcardPattern(pattern, null, options).regex.test(value);
+}

package/node_modules/@vitos-pizza/permission-system/src/yaml-frontmatter.ts

@@ -0,0 +1,84 @@
+export function extractFrontmatter(content: string): {
+	frontmatter: string;
+	body: string;
+} | null {
+	const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(content);
+	if (!match) return null;
+	return {
+		frontmatter: match[1],
+		body: content.slice(match[0].length),
+	};
+}
+
+export function parseSimpleYamlMap(yaml: string): Record<string, unknown> {
+	const result: Record<string, unknown> = {};
+	const lines = yaml.split(/\r?\n/);
+	let currentKey: string | null = null;
+	let currentIndent = 0;
+	const nested: Record<string, Record<string, unknown>> = {};
+
+	for (const rawLine of lines) {
+		if (!rawLine.trim() || rawLine.trim().startsWith("#")) continue;
+
+		const indent = rawLine.search(/\S/);
+		const trimmed = rawLine.trim();
+
+		if (indent === 0) {
+			const colon = trimmed.indexOf(":");
+			if (colon === -1) continue;
+			const key = trimmed.slice(0, colon).trim();
+			const value = trimmed.slice(colon + 1).trim();
+			currentKey = key;
+			currentIndent = 0;
+			if (value) {
+				result[key] = parseScalar(value);
+			} else {
+				nested[key] = {};
+				result[key] = nested[key];
+			}
+			continue;
+		}
+
+		if (currentKey && indent > currentIndent) {
+			const colon = trimmed.indexOf(":");
+			if (colon === -1) continue;
+			const key = trimmed.slice(0, colon).trim();
+			const value = trimmed.slice(colon + 1).trim();
+			const bucket = nested[currentKey] ?? {};
+			if (!nested[currentKey]) nested[currentKey] = bucket;
+			bucket[key] = parseScalar(value);
+		}
+	}
+
+	return result;
+}
+
+function parseScalar(value: string): unknown {
+	if (
+		(value.startsWith('"') && value.endsWith('"')) ||
+		(value.startsWith("'") && value.endsWith("'"))
+	) {
+		return value.slice(1, -1);
+	}
+	if (value === "true") return true;
+	if (value === "false") return false;
+	if (value === "null") return null;
+	return value;
+}
+
+export function parseAgentFrontmatterPermission(
+	content: string,
+): Record<string, unknown> | null {
+	const extracted = extractFrontmatter(content);
+	if (!extracted) return null;
+	const map = parseSimpleYamlMap(extracted.frontmatter);
+	const permission = map.permission;
+	if (
+		!permission ||
+		typeof permission !== "object" ||
+		Array.isArray(permission)
+	) {
+		return null;
+	}
+	return permission as Record<string, unknown>;
+}

package/node_modules/@vitos-pizza/permission-system/src/yolo/runtime-api.ts

@@ -0,0 +1,49 @@
+import type { ExtensionConfig } from "../types.ts";
+
+export interface YoloRuntimeApi {
+	getYoloMode(): boolean;
+	setYoloMode(
+		enabled: boolean,
+		options?: { persist?: boolean },
+	): { error?: string };
+	toggleYoloMode(options?: { persist?: boolean; source?: string }): {
+		error?: string;
+	};
+}
+
+type PermissionSystemGlobal = typeof globalThis & {
+	__piPermissionSystem?: YoloRuntimeApi;
+};
+
+export function installYoloRuntimeApi(
+	getConfig: () => ExtensionConfig,
+	setConfig: (config: ExtensionConfig) => void,
+	onConfigChange?: (config: ExtensionConfig) => void,
+): YoloRuntimeApi {
+	const applyConfig = (next: ExtensionConfig, persist: boolean) => {
+		if (persist) {
+			setConfig(next);
+		} else {
+			Object.assign(getConfig(), next);
+		}
+		onConfigChange?.(getConfig());
+	};
+
+	const api: YoloRuntimeApi = {
+		getYoloMode() {
+			return getConfig().yoloMode === true;
+		},
+		setYoloMode(enabled, options = {}) {
+			const next = { ...getConfig(), yoloMode: enabled };
+			applyConfig(next, options.persist !== false);
+			return {};
+		},
+		toggleYoloMode(options = {}) {
+			const enabled = !(getConfig().yoloMode === true);
+			return api.setYoloMode(enabled, options);
+		},
+	};
+
+	(globalThis as PermissionSystemGlobal).__piPermissionSystem = api;
+	return api;
+}

package/node_modules/@vitos-pizza/permission-system/tests/bash-parser.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { evaluateBashCommand } from "../src/bash/matcher.ts";
+import {
+	enumerateBashCommands,
+	isTriviallyEmptyCommand,
+} from "../src/bash/parser.ts";
+import { PermissionEvaluator } from "../src/permission-evaluator.ts";
+
+describe("bash parser", () => {
+	it("treats comments as trivially empty", () => {
+		expect(isTriviallyEmptyCommand("# just a comment")).toBe(true);
+	});
+
+	it("splits chained commands", () => {
+		expect(enumerateBashCommands("git status && npm test")).toEqual([
+			{ text: "git status", opaque: false },
+			{ text: "npm test", opaque: false },
+		]);
+	});
+
+	it("fails closed on unparseable non-empty commands", () => {
+		const evaluator = new PermissionEvaluator();
+		const result = evaluateBashCommand(
+			"{{{{",
+			{ "*": "allow", bash: { "*": "allow" } },
+			evaluator,
+			{},
+		);
+		expect(result.state).toBe("ask");
+		expect(result.matchedPattern).toBe("<unparseable-bash-command>");
+	});
+});

package/node_modules/@vitos-pizza/permission-system/tests/detect-preset-mode.test.ts

@@ -0,0 +1,68 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { detectPresetMode } from "../src/detect-preset-mode.ts";
+
+const presetsDir = join(
+	dirname(fileURLToPath(import.meta.url)),
+	"..",
+	"presets",
+);
+
+describe("detect-preset-mode", () => {
+	it("recognizes bundled default preset", () => {
+		const mode = detectPresetMode(
+			{
+				"*": "allow",
+				read: "allow",
+				grep: "allow",
+				find: "allow",
+				ls: "allow",
+				web_search: "ask",
+				web_read: "ask",
+				path: {
+					"*": "allow",
+					"*.env": "deny",
+					"*.env.*": "deny",
+					"*.env.example": "allow",
+					"~/.ssh/*": "deny",
+				},
+				bash: {
+					"*": "ask",
+					"git status": "allow",
+					"git status *": "allow",
+					"git diff": "allow",
+					"git diff *": "allow",
+					"git log": "allow",
+					"git log *": "allow",
+					ls: "allow",
+					"ls *": "allow",
+					"npm test": "allow",
+					"npm test *": "allow",
+					"npm run typecheck": "allow",
+					"npm run lint": "allow",
+					"rm -rf *": "deny",
+					"sudo *": "ask",
+				},
+				external_directory: "ask",
+			},
+			presetsDir,
+		);
+		expect(mode).toBe("default");
+	});
+
+	it("recognizes bundled plan preset", () => {
+		const planPreset = JSON.parse(
+			readFileSync(join(presetsDir, "plan.json"), "utf8"),
+		) as { permission: Record<string, unknown> };
+
+		expect(detectPresetMode(planPreset.permission, presetsDir)).toBe("plan");
+		expect(planPreset.permission.web_search).toBe("ask");
+		expect(planPreset.permission.web_read).toBe("ask");
+	});
+
+	it("returns custom for unknown policy shape", () => {
+		expect(detectPresetMode({ "*": "deny" }, presetsDir)).toBe("custom");
+	});
+});

package/node_modules/@vitos-pizza/permission-system/tests/forwarder.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import {
+	forwardPermissionPrompt,
+	PERMISSION_RPC_PROMPT,
+	PERMISSION_RPC_PROMPT_REPLY_PREFIX,
+	startPermissionRpcServer,
+} from "../src/forwarding/forwarder.ts";
+
+describe("permission forwarding", () => {
+	it("forwards prompts over the event bus", async () => {
+		const handlers = new Map<string, Array<(payload: unknown) => void>>();
+		const events = {
+			emit(channel: string, payload: unknown) {
+				for (const handler of handlers.get(channel) ?? []) {
+					handler(payload);
+				}
+			},
+			on(channel: string, handler: (payload: unknown) => void) {
+				const list = handlers.get(channel) ?? [];
+				list.push(handler);
+				handlers.set(channel, list);
+				return () => {
+					handlers.set(
+						channel,
+						(handlers.get(channel) ?? []).filter((item) => item !== handler),
+					);
+				};
+			},
+		};
+
+		startPermissionRpcServer(events, async () => ({
+			approved: true,
+			state: "approved",
+		}));
+
+		const decision = await forwardPermissionPrompt({
+			events,
+			requesterSessionId: "child",
+			targetSessionId: "parent",
+			title: "Allow bash?",
+			message: "git push",
+			surface: "bash",
+			value: "git push",
+			timeoutMs: 1000,
+		});
+
+		expect(decision?.approved).toBe(true);
+		expect(handlers.has(PERMISSION_RPC_PROMPT)).toBe(true);
+		expect(
+			[...handlers.keys()].some((key) =>
+				key.startsWith(PERMISSION_RPC_PROMPT_REPLY_PREFIX),
+			),
+		).toBe(true);
+	});
+});

package/node_modules/@vitos-pizza/permission-system/tests/gates.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { runGatePipeline } from "../src/gates/pipeline.ts";
+import { PermissionEvaluator } from "../src/permission-evaluator.ts";
+
+describe("gate pipeline", () => {
+	const evaluator = new PermissionEvaluator();
+	const permission = {
+		"*": "allow" as const,
+		path: {
+			"*": "allow" as const,
+			"*.env": "deny" as const,
+		},
+		bash: {
+			"*": "ask" as const,
+			"git status": "allow" as const,
+		},
+		external_directory: "ask" as const,
+	};
+
+	it("denies sensitive paths across tools", () => {
+		const result = runGatePipeline(
+			permission,
+			evaluator,
+			{
+				toolName: "read",
+				input: { path: ".env" },
+				cwd: "/workspace/project",
+			},
+			{ registeredTools: new Set(["read"]) },
+		);
+		expect(result.state).toBe("deny");
+	});
+
+	it("asks for external paths", () => {
+		const result = runGatePipeline(
+			permission,
+			evaluator,
+			{
+				toolName: "read",
+				input: { path: "/etc/hosts" },
+				cwd: "/workspace/project",
+			},
+			{ registeredTools: new Set(["read"]) },
+		);
+		expect(result.state).toBe("ask");
+	});
+
+	it("allows whitelisted bash commands", () => {
+		const result = runGatePipeline(
+			permission,
+			evaluator,
+			{
+				toolName: "bash",
+				input: { command: "git status" },
+				cwd: "/workspace/project",
+			},
+			{ registeredTools: new Set(["bash"]) },
+		);
+		expect(result.state).toBe("allow");
+	});
+});

package/node_modules/@vitos-pizza/permission-system/tests/path-utils.test.ts

@@ -0,0 +1,68 @@
+import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { runGatePipeline } from "../src/gates/pipeline.ts";
+import {
+	findProjectRoot,
+	isExternalPath,
+	isPathWithinRoot,
+} from "../src/gates/path-utils.ts";
+import { PermissionEvaluator } from "../src/permission-evaluator.ts";
+
+describe("path-utils project root", () => {
+	it("treats sibling packages inside the git repo as in-project", () => {
+		const repo = mkdtempSync(join(tmpdir(), "perm-repo-"));
+		mkdirSync(join(repo, ".git"));
+		const pkgA = join(repo, "packages", "a");
+		const pkgB = join(repo, "packages", "b", "file.ts");
+		mkdirSync(pkgA, { recursive: true });
+		mkdirSync(join(repo, "packages", "b"), { recursive: true });
+		writeFileSync(pkgB, "export {}\n", "utf8");
+
+		expect(findProjectRoot(pkgA)).toBe(repo);
+		expect(isExternalPath(pkgB, pkgA)).toBe(false);
+		expect(isPathWithinRoot(pkgB, repo)).toBe(true);
+	});
+
+	it("still treats paths outside the git repo as external", () => {
+		const repo = mkdtempSync(join(tmpdir(), "perm-repo-"));
+		mkdirSync(join(repo, ".git"));
+		expect(isExternalPath("/etc/hosts", repo)).toBe(true);
+	});
+});
+
+describe("gate pipeline in-project reads", () => {
+	const evaluator = new PermissionEvaluator();
+	const permission = {
+		"*": "allow" as const,
+		read: "allow" as const,
+		path: {
+			"*": "allow" as const,
+			"*.env": "deny" as const,
+		},
+		external_directory: "ask" as const,
+	};
+
+	it("allows reading another package in the same repo without asking", () => {
+		const repo = mkdtempSync(join(tmpdir(), "perm-gate-repo-"));
+		mkdirSync(join(repo, ".git"));
+		const cwd = join(repo, "packages", "a");
+		const target = join(repo, "packages", "b", "file.ts");
+		mkdirSync(cwd, { recursive: true });
+		mkdirSync(join(repo, "packages", "b"), { recursive: true });
+		writeFileSync(target, "export {}\n", "utf8");
+
+		const result = runGatePipeline(
+			permission,
+			evaluator,
+			{
+				toolName: "read",
+				input: { path: target },
+				cwd,
+			},
+			{ registeredTools: new Set(["read"]) },
+		);
+		expect(result.state).toBe("allow");
+	});
+});

package/node_modules/@vitos-pizza/permission-system/tests/permission-evaluator.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import { PermissionEvaluator } from "../src/permission-evaluator.ts";
+import { SessionApprovals } from "../src/session-approvals.ts";
+
+describe("permission-evaluator", () => {
+	const evaluator = new PermissionEvaluator();
+	const permission = {
+		"*": "allow" as const,
+		bash: {
+			"*": "ask" as const,
+			"git status": "allow" as const,
+			"rm -rf *": "deny" as const,
+		},
+	};
+
+	it("evaluates bash patterns with last-match-wins", () => {
+		const allowed = evaluator.evaluateSurface(permission, "bash", "git status");
+		const denied = evaluator.evaluateSurface(permission, "bash", "rm -rf /tmp");
+		const asked = evaluator.evaluateSurface(permission, "bash", "npm install");
+
+		expect(allowed.state).toBe("allow");
+		expect(denied.state).toBe("deny");
+		expect(asked.state).toBe("ask");
+	});
+
+	it("rewrites ask to allow in yolo mode", () => {
+		const result = evaluator.evaluateSurface(
+			permission,
+			"bash",
+			"npm install",
+			"project",
+			{
+				yoloMode: true,
+			},
+		);
+		expect(result.state).toBe("allow");
+		expect(result.origin).toBe("yolo");
+	});
+
+	it("honors session approvals", () => {
+		const approvals = new SessionApprovals();
+		approvals.add("bash", "npm install");
+		const result = evaluator.evaluateSurface(
+			permission,
+			"bash",
+			"npm install",
+			"project",
+			{
+				sessionApprovals: approvals,
+			},
+		);
+		expect(result.state).toBe("allow");
+		expect(result.origin).toBe("session");
+	});
+});