@vitos-pizza/vitos-pizza 0.3.1 → 0.4.1

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

@@ -5,12 +5,18 @@
 		"grep": "allow",
 		"find": "allow",
 		"ls": "allow",
+		"hypa_read": "allow",
+		"hypa_grep": "allow",
+		"hypa_find": "allow",
+		"hypa_ls": "allow",
 		"question": "allow",
 		"subagent": "allow",
 		"wait": "allow",
 		"web_search": "ask",
 		"web_read": "ask",
 		"bash": "deny",
+		"hypa_shell": "deny",
+		"hypa_mcp_proxy": "deny",
 		"write": "deny",
 		"edit": "deny",
 		"skill": {

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

@@ -1,6 +1,7 @@
 {
 	"permission": {
 		"*": "allow",
+		"hypa_mcp_proxy": "deny",
 		"path": {
 			"*": "allow",
 			"*.env": "deny",

package/packages/question/extensions/index.ts

@@ -1,15 +1,18 @@
 /**
  * @vitos-pizza/question — structured ask-user question tool.
+ * Supports single-question (legacy) and multi-question tabbed modes.
  */
 
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { startQuestionFileWatcher } from "../src/forwarding/file-watcher.ts";
 import { startQuestionRpcServer } from "../src/forwarding/forwarder.ts";
+import type { ForwardQuestionPayload } from "../src/forwarding/forwarder.ts";
 import {
 	promptQuestionLocally,
 	registerQuestionTool,
 } from "../src/register-tool.ts";
+import type { MultiQuestionParams, QuestionParams } from "../src/types.ts";
 
 export default function (
 	pi: import("@earendil-works/pi-coding-agent").ExtensionAPI,
@@ -18,24 +21,42 @@ export default function (
 	let stopFileWatcher: (() => void) | null = null;
 	const agentDir = getAgentDir();
 
-	const unsubRpc = startQuestionRpcServer(pi.events, async (payload) => {
-		const ctx = activeCtx;
-		if (!ctx?.hasUI) {
-			return {
-				question: payload.question,
-				options: payload.options.map((o) => o.label),
-				answer: null,
-				cancelled: true,
-				responderSessionId: ctx?.sessionManager.getSessionId?.() ?? "unknown",
-				respondedAt: Date.now(),
-			};
-		}
-		return promptQuestionLocally(
-			ctx.ui,
-			{ question: payload.question, options: payload.options },
-			ctx.sessionManager.getSessionId?.() ?? "unknown",
-		);
-	});
+	const unsubRpc = startQuestionRpcServer(
+		pi.events,
+		async (payload: ForwardQuestionPayload) => {
+			const ctx = activeCtx;
+			// No UI or wrong session — stay silent so callers can fall through
+			// to file-based forwarding (do not fake cancelled).
+			if (!ctx?.hasUI) return null;
+
+			const sessionId =
+				ctx.sessionManager.getSessionId?.() ?? "unknown";
+			if (
+				payload.targetSessionId &&
+				payload.targetSessionId !== sessionId
+			) {
+				return null;
+			}
+
+			if (payload.questions) {
+				return promptQuestionLocally(
+					ctx.ui,
+					{ questions: payload.questions } as MultiQuestionParams,
+					sessionId,
+				);
+			}
+
+			return promptQuestionLocally(
+				ctx.ui,
+				{
+					question: payload.question ?? "",
+					options: payload.options ?? [],
+					selectType: payload.selectType,
+				} as QuestionParams,
+				sessionId,
+			);
+		},
+	);
 
 	registerQuestionTool(pi, {
 		getAgentDir: () => agentDir,
@@ -54,16 +75,28 @@ export default function (
 				responderSessionId: sessionId,
 				showQuestion: async (params) => {
 					if (!activeCtx?.hasUI) {
+						if ("questions" in params) {
+							return {
+								answers: {},
+								cancelled: true,
+								responderSessionId: sessionId,
+								respondedAt: Date.now(),
+							};
+						}
 						return {
-							question: params.question,
-							options: params.options.map((o) => o.label),
+							question: (params as QuestionParams).question,
+							options: (params as QuestionParams).options.map((o) => o.label),
 							answer: null,
 							cancelled: true,
 							responderSessionId: sessionId,
 							respondedAt: Date.now(),
 						};
 					}
-					return promptQuestionLocally(activeCtx.ui, params, sessionId);
+					return promptQuestionLocally(
+						activeCtx.ui,
+						params,
+						sessionId,
+					);
 				},
 			});
 		}

package/packages/question/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitos-pizza/question",
-	"version": "0.3.1",
+	"version": "0.4.1",
 	"description": "Structured ask-user question tool for Vito's Pizzeria Pi distribution",
 	"type": "module",
 	"license": "MIT",

package/packages/question/src/forwarding/file-watcher.ts

@@ -11,6 +11,7 @@ import { join } from "node:path";
 import type {
 	ForwardedQuestionRequest,
 	ForwardedQuestionResponse,
+	MultiQuestionParams,
 	QuestionParams,
 } from "../types.ts";
 import { getQuestionForwardingRoot } from "./forwarder.ts";
@@ -21,7 +22,9 @@ export function startQuestionFileWatcher(options: {
 	agentDir: string;
 	sessionId: string;
 	responderSessionId: string;
-	showQuestion: (params: QuestionParams) => Promise<ForwardedQuestionResponse>;
+	showQuestion: (
+		params: QuestionParams | MultiQuestionParams,
+	) => Promise<ForwardedQuestionResponse>;
 	pollIntervalMs?: number;
 }): () => void {
 	const forwardingRoot = getQuestionForwardingRoot(
@@ -62,16 +65,43 @@ export function startQuestionFileWatcher(options: {
 				readFileSync(processingPath, "utf8"),
 			) as ForwardedQuestionRequest;
 
-			const response = await options.showQuestion({
-				question: request.question,
-				options: request.options,
-			});
-
-			writeFileSync(
-				join(responsesDir, `${requestId}.json`),
-				JSON.stringify(response),
-				"utf8",
-			);
+			// Determine single vs multi
+			if (request.questions && request.questions.length > 0) {
+				const response = await options.showQuestion({
+					questions: request.questions,
+				});
+				writeFileSync(
+					join(responsesDir, `${requestId}.json`),
+					JSON.stringify(response),
+					"utf8",
+				);
+			} else if (request.question !== undefined && request.options) {
+				const response = await options.showQuestion({
+					question: request.question,
+					options: request.options,
+					selectType: request.selectType,
+				});
+				writeFileSync(
+					join(responsesDir, `${requestId}.json`),
+					JSON.stringify(response),
+					"utf8",
+				);
+			} else {
+				// Unknown format — write failure
+				const failure: ForwardedQuestionResponse = {
+					question: "",
+					options: [],
+					answer: null,
+					cancelled: true,
+					responderSessionId: options.responderSessionId,
+					respondedAt: Date.now(),
+				};
+				writeFileSync(
+					join(responsesDir, `${requestId}.json`),
+					JSON.stringify(failure),
+					"utf8",
+				);
+			}
 		} catch {
 			const failure: ForwardedQuestionResponse = {
 				question: "",

package/packages/question/src/forwarding/forwarder.ts

@@ -7,11 +7,15 @@ import {
 	writeFileSync,
 } from "node:fs";
 import { join } from "node:path";
+import { isSubagentChild } from "../parent-session.ts";
 import type {
 	ForwardedQuestionRequest,
 	ForwardedQuestionResponse,
+	MultiQuestionParams,
 	QuestionOption,
 	QuestionParams,
+	QuestionTab,
+	SelectType,
 } from "../types.ts";
 import { QUESTION_RPC_PROMPT, questionReplyChannel } from "./channels.ts";
 
@@ -20,6 +24,22 @@ interface EventBus {
 	on(channel: string, handler: (payload: unknown) => void): () => void;
 }
 
+/**
+ * Payload sent over RPC / file for a forwarded question prompt.
+ * Supports both single- and multi-question modes.
+ */
+export interface ForwardQuestionPayload {
+	requestId: string;
+	targetSessionId: string;
+	requesterSessionId: string;
+	/** Single‑question mode */
+	question?: string;
+	options?: QuestionOption[];
+	selectType?: SelectType;
+	/** Multi‑question mode */
+	questions?: QuestionTab[];
+}
+
 export function getQuestionForwardingRoot(
 	agentDir: string,
 	sessionId: string,
@@ -43,23 +63,37 @@ export async function forwardQuestionPrompt(options: {
 	agentDir?: string;
 	targetSessionId: string;
 	requesterSessionId: string;
-	params: QuestionParams;
+	params: QuestionParams | MultiQuestionParams;
 	timeoutMs?: number;
 }): Promise<ForwardedQuestionResponse | null> {
 	const requestId = randomUUID();
-	const payload = {
+
+	const isMulti = "questions" in options.params;
+	const payload: ForwardQuestionPayload = {
 		requestId,
 		targetSessionId: options.targetSessionId,
 		requesterSessionId: options.requesterSessionId,
-		question: options.params.question,
-		options: options.params.options,
 	};
 
-	if (options.events) {
+	if (isMulti) {
+		const mp = options.params as MultiQuestionParams;
+		payload.questions = mp.questions;
+	} else {
+		const sp = options.params as QuestionParams;
+		payload.question = sp.question;
+		payload.options = sp.options;
+		payload.selectType = sp.selectType;
+	}
+
+	// Subprocess children have an isolated event bus; their own no-UI RPC
+	// server would poison-reply with cancelled. Skip RPC and use files only.
+	if (options.events && !isSubagentChild()) {
+		// Same-process RPC. If no capable listener replies, fall through to
+		// file-based forwarding quickly instead of waiting the full timeout.
 		const rpcReply = await waitForRpcReply(
 			options.events,
 			payload,
-			options.timeoutMs ?? 600_000,
+			1500, // short RPC-specific timeout
 		);
 		if (rpcReply) return rpcReply;
 	}
@@ -74,7 +108,7 @@ export async function forwardQuestionPrompt(options: {
 				targetSessionId: options.targetSessionId,
 				params: options.params,
 			},
-			options.timeoutMs ?? 600_000,
+			options.timeoutMs ?? 300_000, // 5 min for user response
 		);
 	}
 
@@ -83,13 +117,7 @@ export async function forwardQuestionPrompt(options: {
 
 function waitForRpcReply(
 	events: EventBus,
-	payload: {
-		requestId: string;
-		targetSessionId: string;
-		requesterSessionId: string;
-		question: string;
-		options: QuestionOption[];
-	},
+	payload: ForwardQuestionPayload,
 	timeoutMs: number,
 ): Promise<ForwardedQuestionResponse | null> {
 	return new Promise((resolve) => {
@@ -121,20 +149,31 @@ function waitForFileReply(
 		requestId: string;
 		requesterSessionId: string;
 		targetSessionId: string;
-		params: QuestionParams;
+		params: QuestionParams | MultiQuestionParams;
 	},
 	timeoutMs: number,
 ): Promise<ForwardedQuestionResponse | null> {
 	const forwardingRoot = getQuestionForwardingRoot(agentDir, targetSessionId);
 	const { requestsDir, responsesDir } = getForwardingDirs(forwardingRoot);
+
+	const isMulti = "questions" in payload.params;
 	const request: ForwardedQuestionRequest = {
 		id: payload.requestId,
 		createdAt: Date.now(),
 		requesterSessionId: payload.requesterSessionId,
 		targetSessionId: payload.targetSessionId,
-		question: payload.params.question,
-		options: payload.params.options,
 	};
+
+	if (isMulti) {
+		const mp = payload.params as MultiQuestionParams;
+		request.questions = mp.questions;
+	} else {
+		const sp = payload.params as QuestionParams;
+		request.question = sp.question;
+		request.options = sp.options;
+		request.selectType = sp.selectType;
+	}
+
 	writeFileSync(
 		join(requestsDir, `${request.id}.json`),
 		JSON.stringify(request),
@@ -169,19 +208,14 @@ function waitForFileReply(
 
 export function startQuestionRpcServer(
 	events: EventBus,
-	handler: (payload: {
-		requestId: string;
-		question: string;
-		options: QuestionOption[];
-	}) => Promise<ForwardedQuestionResponse>,
+	handler: (
+		payload: ForwardQuestionPayload,
+	) => Promise<ForwardedQuestionResponse | null | undefined>,
 ): () => void {
 	return events.on(QUESTION_RPC_PROMPT, async (raw) => {
-		const payload = raw as {
-			requestId: string;
-			question: string;
-			options: QuestionOption[];
-		};
+		const payload = raw as ForwardQuestionPayload;
 		const response = await handler(payload);
+		if (response == null) return;
 		events.emit(questionReplyChannel(payload.requestId), response);
 	});
 }