@vitos-pizza/vitos-pizza 0.1.0

package/packages/permission-system/node_modules/zod/v4-mini/index.cjs

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../v4/mini/index.cjs"), exports);

package/packages/permission-system/node_modules/zod/v4-mini/index.d.cts

@@ -0,0 +1 @@
+export * from "../v4/mini/index.cjs";

package/packages/permission-system/node_modules/zod/v4-mini/index.d.ts

@@ -0,0 +1 @@
+export * from "../v4/mini/index.js";

package/packages/permission-system/node_modules/zod/v4-mini/index.js

@@ -0,0 +1 @@
+export * from "../v4/mini/index.js";

package/packages/permission-system/package.json

@@ -0,0 +1,34 @@
+{
+	"name": "@vitos-pizza/permission-system",
+	"version": "0.1.0",
+	"description": "Permission enforcement for Vito's Pizzeria Pi distribution",
+	"type": "module",
+	"license": "MIT",
+	"private": true,
+	"exports": {
+		"./mode-api": "./src/mode-api.ts",
+		"./detect-preset-mode": "./src/detect-preset-mode.ts",
+		"./types": "./src/types.ts"
+	},
+	"scripts": {
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"typecheck": "tsc --noEmit",
+		"lint": "biome check .",
+		"lint:fix": "biome check --write ."
+	},
+	"dependencies": {
+		"@vitos-pizza/keybindings": "0.1.0",
+		"tree-sitter-bash": "^0.25.1",
+		"web-tree-sitter": "^0.25.10",
+		"zod": "^3.25.76"
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*"
+	},
+	"devDependencies": {
+		"@earendil-works/pi-coding-agent": "*",
+		"vitest": "^3.2.4"
+	}
+}

package/packages/permission-system/presets/default.json

@@ -0,0 +1,36 @@
+{
+	"permission": {
+		"*": "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"
+	}
+}

package/packages/permission-system/presets/plan.json

@@ -0,0 +1,25 @@
+{
+	"permission": {
+		"*": "deny",
+		"read": "allow",
+		"grep": "allow",
+		"find": "allow",
+		"ls": "allow",
+		"question": "allow",
+		"subagent": "allow",
+		"wait": "allow",
+		"web_search": "ask",
+		"web_read": "ask",
+		"bash": "deny",
+		"write": "deny",
+		"edit": "deny",
+		"skill": {
+			"*": "allow"
+		},
+		"path": {
+			"*": "allow",
+			"*.env": "deny",
+			"*.env.*": "deny"
+		}
+	}
+}

package/packages/permission-system/presets/yolo.json

@@ -0,0 +1,15 @@
+{
+	"permission": {
+		"*": "allow",
+		"path": {
+			"*": "allow",
+			"*.env": "deny",
+			"*.env.*": "deny",
+			"~/.ssh/*": "deny"
+		},
+		"bash": {
+			"*": "allow",
+			"rm -rf *": "deny"
+		}
+	}
+}

package/packages/permission-system/src/bash/matcher.ts

@@ -0,0 +1,51 @@
+import type { PermissionEvaluator } from "../permission-evaluator.ts";
+import type { FlatPermissionConfig, PermissionCheckResult } from "../types.ts";
+import { enumerateBashCommands, isTriviallyEmptyCommand } from "./parser.ts";
+
+export function evaluateBashCommand(
+	command: string,
+	permission: FlatPermissionConfig,
+	evaluator: PermissionEvaluator,
+	options: { yoloMode?: boolean; platform?: NodeJS.Platform },
+): PermissionCheckResult {
+	const units = enumerateBashCommands(command);
+
+	if (units.length === 0) {
+		if (isTriviallyEmptyCommand(command)) {
+			return evaluator.evaluateSurface(
+				permission,
+				"bash",
+				command.trim(),
+				"project",
+				options,
+			);
+		}
+		return {
+			state: "ask",
+			matchedPattern: "<unparseable-bash-command>",
+			surface: "bash",
+			value: command,
+			origin: "builtin",
+		};
+	}
+
+	const results = units.map((unit) => {
+		const base = evaluator.evaluateSurface(
+			permission,
+			"bash",
+			unit.text,
+			"project",
+			options,
+		);
+		if (unit.opaque && base.state === "allow") {
+			return {
+				...base,
+				state: "ask" as const,
+				matchedPattern: "<opaque-bash-wrapper>",
+			};
+		}
+		return base;
+	});
+
+	return evaluator.pickMostRestrictive(results) ?? results[0];
+}

package/packages/permission-system/src/bash/parser.ts

@@ -0,0 +1,40 @@
+export interface BashCommandUnit {
+	text: string;
+	opaque?: boolean;
+}
+
+const OPAQUE_WRAPPER_RE = /^(?:bash|sh|zsh|dash|eval)\s+(?:-c\b|eval\b)/;
+
+export function isTriviallyEmptyCommand(command: string): boolean {
+	const lines = command.split("\n").map((line) => line.trim());
+	return lines.every((line) => line.length === 0 || line.startsWith("#"));
+}
+
+export function splitBashProgram(command: string): BashCommandUnit[] {
+	const trimmed = command.trim();
+	if (!trimmed || isTriviallyEmptyCommand(trimmed)) return [];
+	if (isClearlyInvalidCommand(trimmed)) return [];
+
+	const segments = trimmed
+		.split(/(?:&&|\|\||;|\n)/)
+		.map((part) => part.trim())
+		.filter(Boolean);
+
+	if (segments.length === 0) return [];
+
+	return segments.map((text) => ({
+		text,
+		opaque: OPAQUE_WRAPPER_RE.test(text),
+	}));
+}
+
+export function enumerateBashCommands(command: string): BashCommandUnit[] {
+	const units = splitBashProgram(command);
+	if (units.length > 0) return units;
+	if (isTriviallyEmptyCommand(command)) return [];
+	return [];
+}
+
+function isClearlyInvalidCommand(command: string): boolean {
+	return /^[{}<>]+$/.test(command.trim());
+}

package/packages/permission-system/src/config-paths.ts

@@ -0,0 +1,23 @@
+import { join } from "node:path";
+
+export const EXTENSION_ID = "pi-permission-system";
+
+export function getGlobalConfigDir(agentDir: string): string {
+	return join(agentDir, "extensions", EXTENSION_ID);
+}
+
+export function getGlobalConfigPath(agentDir: string): string {
+	return join(getGlobalConfigDir(agentDir), "config.json");
+}
+
+export function getProjectConfigPath(cwd: string): string {
+	return join(cwd, ".pi", "extensions", EXTENSION_ID, "config.json");
+}
+
+export function getGlobalAgentsDir(agentDir: string): string {
+	return join(agentDir, "agents");
+}
+
+export function getProjectAgentsDir(cwd: string): string {
+	return join(cwd, ".pi", "agents");
+}

package/packages/permission-system/src/detect-preset-mode.ts

@@ -0,0 +1,61 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { FlatPermissionConfig } from "./types.ts";
+
+const PRESET_ORDER = ["yolo", "default", "plan"] as const;
+export type PresetModeName = (typeof PRESET_ORDER)[number];
+
+function canonicalize(value: unknown): unknown {
+	if (Array.isArray(value)) return value.map(canonicalize);
+	if (value && typeof value === "object") {
+		const record = value as Record<string, unknown>;
+		const sorted: Record<string, unknown> = {};
+		for (const key of Object.keys(record).sort()) {
+			sorted[key] = canonicalize(record[key]);
+		}
+		return sorted;
+	}
+	return value;
+}
+
+function normalizePermission(
+	permission: FlatPermissionConfig | undefined,
+): string {
+	return JSON.stringify(canonicalize(permission ?? {}));
+}
+
+export function detectPresetMode(
+	permission: FlatPermissionConfig | undefined,
+	presetsDir: string,
+): PresetModeName | "custom" {
+	if (!existsSync(presetsDir)) return "custom";
+
+	const target = normalizePermission(permission);
+	for (const mode of PRESET_ORDER) {
+		const presetPath = join(presetsDir, `${mode}.json`);
+		if (!existsSync(presetPath)) continue;
+		try {
+			const preset = JSON.parse(readFileSync(presetPath, "utf8")) as {
+				permission?: FlatPermissionConfig;
+			};
+			if (normalizePermission(preset.permission) === target) {
+				return mode;
+			}
+		} catch {
+			// skip invalid preset
+		}
+	}
+
+	return "custom";
+}
+
+export function listPresetModes(presetsDir: string): PresetModeName[] {
+	if (!existsSync(presetsDir)) return [...PRESET_ORDER];
+	return readdirSync(presetsDir)
+		.filter((name) => name.endsWith(".json"))
+		.map((name) => name.replace(/\.json$/, ""))
+		.filter((name): name is PresetModeName =>
+			(PRESET_ORDER as readonly string[]).includes(name),
+		)
+		.sort((a, b) => PRESET_ORDER.indexOf(a) - PRESET_ORDER.indexOf(b));
+}

package/packages/permission-system/src/expand-home.ts

@@ -0,0 +1,12 @@
+import { homedir } from "node:os";
+
+export function expandHomePath(value: string): string {
+	if (!value.startsWith("~/")) return value;
+	return joinPath(homedir(), value.slice(2));
+}
+
+function joinPath(base: string, rest: string): string {
+	if (!rest) return base;
+	const sep = base.includes("\\") ? "\\" : "/";
+	return `${base}${sep}${rest}`;
+}

package/packages/permission-system/src/forwarding/forwarder.ts

@@ -0,0 +1,224 @@
+import { randomUUID } from "node:crypto";
+import {
+	mkdirSync,
+	readdirSync,
+	readFileSync,
+	unlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import type { PermissionPromptDecision } from "../ui/permission-dialog.ts";
+
+export const PERMISSION_RPC_PROMPT = "permissions:rpc:prompt";
+export const PERMISSION_RPC_PROMPT_REPLY_PREFIX =
+	"permissions:rpc:prompt:reply:";
+
+export const SUBAGENT_PARENT_SESSION_ENV_CANDIDATES = [
+	"PI_AGENT_ROUTER_PARENT_SESSION_ID",
+	"PI_SUBAGENT_PARENT_SESSION",
+] as const;
+
+export interface ForwardedPermissionRequest {
+	id: string;
+	createdAt: number;
+	requesterSessionId: string;
+	targetSessionId: string;
+	message: string;
+	surface: string;
+	value: string;
+}
+
+export interface ForwardedPermissionResponse {
+	approved: boolean;
+	state: PermissionPromptDecision["state"];
+	denialReason?: string;
+	responderSessionId: string;
+	respondedAt: number;
+}
+
+interface EventBus {
+	emit(channel: string, payload: unknown): void;
+	on(channel: string, handler: (payload: unknown) => void): () => void;
+}
+
+export function resolveParentSessionId(): string | null {
+	for (const key of SUBAGENT_PARENT_SESSION_ENV_CANDIDATES) {
+		const value = process.env[key]?.trim();
+		if (value) return value;
+	}
+	return null;
+}
+
+function getForwardingDirs(sessionRootDir: string): {
+	requestsDir: string;
+	responsesDir: string;
+} {
+	const base = join(sessionRootDir, "permission-forwarding");
+	const requestsDir = join(base, "requests");
+	const responsesDir = join(base, "responses");
+	mkdirSync(requestsDir, { recursive: true });
+	mkdirSync(responsesDir, { recursive: true });
+	return { requestsDir, responsesDir };
+}
+
+export async function forwardPermissionPrompt(options: {
+	events?: EventBus;
+	sessionRootDir?: string;
+	requesterSessionId: string;
+	targetSessionId: string;
+	title: string;
+	message: string;
+	surface: string;
+	value: string;
+	timeoutMs?: number;
+}): Promise<PermissionPromptDecision | null> {
+	const requestId = randomUUID();
+	const payload = {
+		requestId,
+		targetSessionId: options.targetSessionId,
+		requesterSessionId: options.requesterSessionId,
+		title: options.title,
+		message: options.message,
+		surface: options.surface,
+		value: options.value,
+	};
+
+	if (options.events) {
+		return waitForRpcReply(
+			options.events,
+			payload,
+			options.timeoutMs ?? 600_000,
+		);
+	}
+
+	if (options.sessionRootDir) {
+		return waitForFileReply(
+			options.sessionRootDir,
+			payload,
+			options.timeoutMs ?? 600_000,
+		);
+	}
+
+	return null;
+}
+
+function waitForRpcReply(
+	events: EventBus,
+	payload: {
+		requestId: string;
+		targetSessionId: string;
+		requesterSessionId: string;
+		title: string;
+		message: string;
+		surface: string;
+		value: string;
+	},
+	timeoutMs: number,
+): Promise<PermissionPromptDecision | null> {
+	return new Promise((resolve) => {
+		const replyChannel = `${PERMISSION_RPC_PROMPT_REPLY_PREFIX}${payload.requestId}`;
+		let settled = false;
+		const timer = setTimeout(() => {
+			if (settled) return;
+			settled = true;
+			unsub();
+			resolve(null);
+		}, timeoutMs);
+
+		const unsub = events.on(replyChannel, (reply) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			unsub();
+			const decision = reply as PermissionPromptDecision;
+			resolve(decision);
+		});
+
+		events.emit(PERMISSION_RPC_PROMPT, payload);
+	});
+}
+
+function waitForFileReply(
+	sessionRootDir: string,
+	payload: {
+		requestId: string;
+		targetSessionId: string;
+		requesterSessionId: string;
+		title: string;
+		message: string;
+		surface: string;
+		value: string;
+	},
+	timeoutMs: number,
+): Promise<PermissionPromptDecision | null> {
+	const { requestsDir, responsesDir } = getForwardingDirs(sessionRootDir);
+	const request: ForwardedPermissionRequest = {
+		id: payload.requestId,
+		createdAt: Date.now(),
+		requesterSessionId: payload.requesterSessionId,
+		targetSessionId: payload.targetSessionId,
+		message: payload.message,
+		surface: payload.surface,
+		value: payload.value,
+	};
+	writeFileSync(
+		join(requestsDir, `${request.id}.json`),
+		JSON.stringify(request),
+		"utf8",
+	);
+
+	const started = Date.now();
+	return new Promise((resolve) => {
+		const timer = setInterval(() => {
+			if (Date.now() - started > timeoutMs) {
+				clearInterval(timer);
+				resolve(null);
+				return;
+			}
+			for (const file of readdirSync(responsesDir)) {
+				if (!file.startsWith(request.id)) continue;
+				try {
+					const response = JSON.parse(
+						readFileSync(join(responsesDir, file), "utf8"),
+					) as ForwardedPermissionResponse;
+					unlinkSync(join(responsesDir, file));
+					clearInterval(timer);
+					resolve({
+						approved: response.approved,
+						state: response.state,
+						denialReason: response.denialReason,
+					});
+					return;
+				} catch {
+					// keep polling
+				}
+			}
+		}, 250);
+	});
+}
+
+export function startPermissionRpcServer(
+	events: EventBus,
+	handler: (payload: {
+		requestId: string;
+		title: string;
+		message: string;
+		surface: string;
+		value: string;
+	}) => Promise<PermissionPromptDecision>,
+): () => void {
+	return events.on(PERMISSION_RPC_PROMPT, async (raw) => {
+		const payload = raw as {
+			requestId: string;
+			title: string;
+			message: string;
+			surface: string;
+			value: string;
+		};
+		const decision = await handler(payload);
+		events.emit(
+			`${PERMISSION_RPC_PROMPT_REPLY_PREFIX}${payload.requestId}`,
+			decision,
+		);
+	});
+}

package/packages/permission-system/src/forwarding/subagent-registry.ts

@@ -0,0 +1,61 @@
+const SUBAGENT_SESSION_REGISTRY_KEY = Symbol.for(
+	"@vitos-pizza/permission-system:subagent-registry",
+);
+
+export interface SubagentSessionInfo {
+	parentSessionId?: string;
+}
+
+export class SubagentSessionRegistry {
+	private readonly sessions = new Map<string, SubagentSessionInfo>();
+
+	register(sessionId: string, info: SubagentSessionInfo): void {
+		this.sessions.set(sessionId, info);
+	}
+
+	unregister(sessionId: string): void {
+		this.sessions.delete(sessionId);
+	}
+
+	get(sessionId: string): SubagentSessionInfo | undefined {
+		return this.sessions.get(sessionId);
+	}
+}
+
+export function getSubagentSessionRegistry(): SubagentSessionRegistry {
+	const store = globalThis as Record<symbol, unknown>;
+	const existing = store[SUBAGENT_SESSION_REGISTRY_KEY] as
+		| SubagentSessionRegistry
+		| undefined;
+	if (existing) return existing;
+	const registry = new SubagentSessionRegistry();
+	store[SUBAGENT_SESSION_REGISTRY_KEY] = registry;
+	return registry;
+}
+
+export const SUBAGENT_CHILD_SESSION_CREATED = "subagents:child:session-created";
+export const SUBAGENT_CHILD_DISPOSED = "subagents:child:disposed";
+
+interface LifecycleEventBus {
+	on(channel: string, handler: (data: unknown) => void): () => void;
+}
+
+export function subscribeSubagentLifecycle(
+	events: LifecycleEventBus,
+	registry: SubagentSessionRegistry,
+): () => void {
+	const unsubCreated = events.on(SUBAGENT_CHILD_SESSION_CREATED, (data) => {
+		const event = data as { sessionId: string; parentSessionId?: string };
+		registry.register(event.sessionId, {
+			parentSessionId: event.parentSessionId,
+		});
+	});
+	const unsubDisposed = events.on(SUBAGENT_CHILD_DISPOSED, (data) => {
+		const event = data as { sessionId: string };
+		registry.unregister(event.sessionId);
+	});
+	return () => {
+		unsubCreated();
+		unsubDisposed();
+	};
+}

package/packages/permission-system/src/gates/path-utils.ts

@@ -0,0 +1,66 @@
+import { existsSync } from "node:fs";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { expandHomePath } from "../expand-home.ts";
+
+export function normalizePathValue(pathValue: string, cwd: string): string {
+	const expanded = expandHomePath(pathValue.trim());
+	if (!expanded) return expanded;
+	return isAbsolute(expanded) ? resolve(expanded) : resolve(cwd, expanded);
+}
+
+export function findProjectRoot(cwd: string): string {
+	let dir = resolve(cwd);
+	while (true) {
+		if (existsSync(resolve(dir, ".git"))) {
+			return dir;
+		}
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return resolve(cwd);
+}
+
+export function isPathWithinRoot(normalizedPath: string, root: string): boolean {
+	const resolvedRoot = resolve(root);
+	const resolvedPath = resolve(normalizedPath);
+	if (resolvedPath === resolvedRoot) return true;
+	const rel = relative(resolvedRoot, resolvedPath);
+	return !rel.startsWith("..") && !isAbsolute(rel);
+}
+
+export function isExternalPath(pathValue: string, cwd: string): boolean {
+	const normalized = normalizePathValue(pathValue, cwd);
+	const projectRoot = findProjectRoot(cwd);
+	return !isPathWithinRoot(normalized, projectRoot);
+}
+export function extractPathFromToolInput(
+	toolName: string,
+	input: Record<string, unknown>,
+): string | null {
+	if (typeof input.path === "string") return input.path;
+	if (toolName === "bash" && typeof input.command === "string") {
+		return input.command;
+	}
+	if (toolName === "mcp") {
+		const args = input.arguments;
+		if (
+			typeof args === "object" &&
+			args !== null &&
+			typeof (args as { path?: string }).path === "string"
+		) {
+			return (args as { path: string }).path;
+		}
+	}
+	return null;
+}
+
+export function extractMcpTarget(
+	input: Record<string, unknown>,
+): string | null {
+	if (typeof input.server === "string" && typeof input.tool === "string") {
+		return `${input.server}/${input.tool}`;
+	}
+	if (typeof input.tool === "string") return input.tool;
+	return null;
+}