@vitos-pizza/vitos-pizza 0.1.0

package/node_modules/@vitos-pizza/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/node_modules/@vitos-pizza/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/node_modules/@vitos-pizza/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/node_modules/@vitos-pizza/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/node_modules/@vitos-pizza/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;
+}

package/node_modules/@vitos-pizza/permission-system/src/gates/pipeline.ts

@@ -0,0 +1,155 @@
+import { evaluateBashCommand } from "../bash/matcher.ts";
+import type { PermissionEvaluator } from "../permission-evaluator.ts";
+import { inferSkillNameFromPath } from "../sanitizers/skill-prompt.ts";
+import type {
+	FlatPermissionConfig,
+	GateContext,
+	PermissionCheckResult,
+	PermissionState,
+} from "../types.ts";
+import {
+	extractMcpTarget,
+	extractPathFromToolInput,
+	isExternalPath,
+	normalizePathValue,
+} from "./path-utils.ts";
+
+export interface GatePipelineOptions {
+	yoloMode?: boolean;
+	platform?: NodeJS.Platform;
+	skillDirs?: readonly string[];
+	registeredTools?: ReadonlySet<string>;
+}
+
+export function runGatePipeline(
+	permission: FlatPermissionConfig,
+	evaluator: PermissionEvaluator,
+	ctx: GateContext,
+	options: GatePipelineOptions = {},
+): PermissionCheckResult {
+	const { toolName, input, cwd } = ctx;
+	const evalOptions = {
+		yoloMode: options.yoloMode,
+		platform: options.platform,
+	};
+
+	if (options.registeredTools && !options.registeredTools.has(toolName)) {
+		return {
+			state: "deny",
+			reason: `Tool "${toolName}" is not registered`,
+			matchedPattern: "<unregistered-tool>",
+			surface: toolName,
+			value: toolName,
+			origin: "builtin",
+		};
+	}
+
+	const checks: PermissionCheckResult[] = [];
+	const pathValue = extractPathFromToolInput(toolName, input);
+	if (pathValue) {
+		const normalizedPath = normalizePathValue(pathValue, cwd);
+		checks.push(
+			evaluator.evaluateSurface(
+				permission,
+				"path",
+				normalizedPath,
+				"project",
+				evalOptions,
+			),
+		);
+		if (isExternalPath(pathValue, cwd)) {
+			const externalRules = permission.external_directory;
+			if (
+				typeof externalRules === "object" &&
+				externalRules !== null &&
+				!Array.isArray(externalRules)
+			) {
+				checks.push(
+					evaluator.evaluateSurface(
+						permission,
+						"external_directory",
+						normalizedPath,
+						"project",
+						evalOptions,
+					),
+				);
+			} else if (typeof externalRules === "string") {
+				checks.push({
+					state: externalRules as PermissionState,
+					matchedPattern: "external_directory",
+					surface: "external_directory",
+					value: normalizedPath,
+					origin: "project",
+				});
+			}
+		}
+	}
+
+	const toolPermission = permission[toolName];
+	if (typeof toolPermission === "string") {
+		checks.push({
+			state: toolPermission as PermissionState,
+			matchedPattern: toolName,
+			surface: toolName,
+			value: toolName,
+			origin: "project",
+		});
+	} else {
+		checks.push(
+			evaluator.evaluateSurface(
+				permission,
+				"*",
+				toolName,
+				"project",
+				evalOptions,
+			),
+		);
+	}
+
+	if (toolName === "bash" && typeof input.command === "string") {
+		checks.push(
+			evaluateBashCommand(input.command, permission, evaluator, evalOptions),
+		);
+	}
+
+	if (toolName === "mcp") {
+		const target = extractMcpTarget(input);
+		if (target) {
+			checks.push(
+				evaluator.evaluateSurface(
+					permission,
+					"mcp",
+					target,
+					"project",
+					evalOptions,
+				),
+			);
+		}
+	}
+
+	if (toolName === "read" && pathValue && options.skillDirs?.length) {
+		const skillName = inferSkillNameFromPath(pathValue, options.skillDirs);
+		if (skillName) {
+			checks.push(
+				evaluator.evaluateSurface(
+					permission,
+					"skill",
+					skillName,
+					"project",
+					evalOptions,
+				),
+			);
+		}
+	}
+
+	const mostRestrictive = evaluator.pickMostRestrictive(checks);
+	return (
+		mostRestrictive ?? {
+			state: "ask",
+			matchedPattern: "*",
+			surface: toolName,
+			value: toolName,
+			origin: "builtin",
+		}
+	);
+}

package/node_modules/@vitos-pizza/permission-system/src/handlers/before-agent-start.ts

@@ -0,0 +1,65 @@
+import type {
+	BeforeAgentStartEventResult,
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import type { PermissionSession } from "../permission-session.ts";
+import { sanitizeSkillPromptBlocks } from "../sanitizers/skill-prompt.ts";
+import { sanitizeAvailableToolsSection } from "../sanitizers/system-prompt.ts";
+
+export function registerBeforeAgentStart(
+	pi: ExtensionAPI,
+	session: PermissionSession,
+): void {
+	pi.on("before_agent_start", async (event, ctx) => {
+		session.refresh(ctx);
+		const agentName = session.resolveAgentName(ctx, event.systemPrompt);
+		session.setAgentName(agentName);
+
+		const config = session.getConfig();
+		const permission = config.permission ?? {};
+		const activeTools = pi.getActiveTools();
+		const allowedTools: string[] = [];
+
+		for (const toolName of activeTools) {
+			const state = session.evaluator.getToolPermission(permission, toolName, {
+				yoloMode: config.yoloMode,
+				sessionApprovals: session.sessionApprovals,
+			});
+			if (state !== "deny") allowedTools.push(toolName);
+		}
+
+		pi.setActiveTools(allowedTools);
+
+		const toolPromptResult = sanitizeAvailableToolsSection(
+			event.systemPrompt,
+			allowedTools,
+		);
+		const skillPromptResult = sanitizeSkillPromptBlocks(
+			toolPromptResult.prompt,
+			permission,
+			session.evaluator,
+			{ yoloMode: config.yoloMode, agentName },
+		);
+
+		if (
+			skillPromptResult.prompt !== event.systemPrompt ||
+			toolPromptResult.removed
+		) {
+			return { systemPrompt: skillPromptResult.prompt };
+		}
+		return {};
+	});
+}
+
+export function resolveAgentNameFromContext(
+	_ctx: ExtensionContext,
+	systemPrompt?: string,
+): string | undefined {
+	const match = systemPrompt
+		? /<active_agent>\s*([^\s<]+)/i.exec(systemPrompt)
+		: null;
+	return match?.[1];
+}
+
+export type { BeforeAgentStartEventResult };

package/node_modules/@vitos-pizza/permission-system/src/handlers/skill-input.ts

@@ -0,0 +1 @@
+export { registerSkillInputGate } from "./tool-call-gate.ts";