pi-multimodal-proxy 1.23.0 → 1.24.0

package/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [1.24.0] - 2026-10-11
+
+### Added
+
+- **Interactive YouTube 403 recovery** — a 403 on the media fetch with no cookies configured no longer dead-ends in a hint telling you to type a slash command. The proxy now opens a picker listing only the browsers actually installed on your machine (profile-dir detection per platform: Windows/macOS/Linux); picking one persists `ytdlpCookiesFromBrowser` (same write path as `/multimodal-proxy ytdlp cookies <browser>`, so future sessions just work) and retries the download immediately. Declining, headless sessions (`ctx.hasUI` false), or no detected browser fall back to a one-line notice. yt-dlp failure notifications also no longer echo the full command line: `summarizeYtDlpError` reduces the dump to the actionable `ERROR: …` line, and a 403 that persists *with* cookies now points at the extractor-args knob instead of the cookies knob. Ten new tests (559 total, all green): per-platform profile candidates, env-var fallback, XDG honoring, browser-set containment, and error summarization.
+
 ## [1.23.0] - 2026-10-10
 
 ### Fixed

package/README.md

@@ -47,9 +47,10 @@ winget install yt-dlp.yt-dlp        # Windows
 
 #### 403 Forbidden / download failures
 
-YouTube periodically rejects unauthenticated media fetches with `HTTP Error 403: Forbidden`, even on the latest `yt-dlp`. The proxy can't fix YouTube's backend, but you can satisfy the auth check:
+YouTube periodically rejects unauthenticated media fetches with `HTTP Error 403: Forbidden`, even on the latest `yt-dlp`. The proxy can't fix YouTube's backend, but it can satisfy the auth check:
 
-- **Reuse a logged-in browser session** — `/multimodal-proxy ytdlp cookies chrome` (also `firefox`, `edge`, `brave`, `opera`, `safari`, `vivaldi`, `chromium`, `whale`). yt-dlp reads that browser's YouTube cookies. This fixes most 403s.
+- **Interactive fix (default)** — when a download 403s and no cookies are configured, a picker offers the browsers actually installed on your machine. Pick one and the download retries immediately with that browser's YouTube cookies; the choice is persisted, so it only happens once.
+- **Manual setup** — `/multimodal-proxy ytdlp cookies chrome` (also `firefox`, `edge`, `brave`, `opera`, `safari`, `vivaldi`, `chromium`, `whale`). Same effect as the picker, for headless setups or pre-configuration.
 - **Try alternate player clients** — `/multimodal-proxy ytdlp extractor-args "youtube:player_client=web_safari,web"`.
 - Show current settings with `/multimodal-proxy ytdlp`; turn either off with `... off`.
 

package/extensions/__tests__/internal.test.ts

@@ -53,6 +53,8 @@ import {
 	sanitizeAllowedFolders,
 	sanitizeYtdlpCookiesFromBrowser,
 	sanitizeYtdlpExtractorArgs,
+	browserProfileCandidates,
+	summarizeYtDlpError,
 	sanitizeProviderHeaders,
 	YTDLP_COOKIES_BROWSERS,
 	pathAccessFromConfig,
@@ -348,6 +350,63 @@ describe("yt-dlp config sanitizers", () => {
 	});
 });
 
+describe("browserProfileCandidates", () => {
+	it("lists Windows profile dirs from LOCALAPPDATA/APPDATA, without safari", () => {
+		const env = { LOCALAPPDATA: join("C:", "Users", "u", "AppData", "Local"), APPDATA: join("C:", "Users", "u", "AppData", "Roaming") };
+		const map = new Map(browserProfileCandidates("win32", env, join("C:", "Users", "u")).map((c) => [c.browser, c.dirs]));
+		assert.ok(map.get("chrome")![0].endsWith(join("Google", "Chrome", "User Data")));
+		assert.ok(map.get("firefox")![0].endsWith(join("Mozilla", "Firefox", "Profiles")));
+		assert.ok(map.has("edge") && map.has("brave") && map.has("vivaldi") && map.has("chromium") && map.has("whale"));
+		assert.ok(!map.has("safari"));
+	});
+	it("falls back to homedir AppData when env vars are missing", () => {
+		const home = join("C:", "Users", "u");
+		const map = new Map(browserProfileCandidates("win32", {}, home).map((c) => [c.browser, c.dirs]));
+		assert.ok(map.get("chrome")![0].startsWith(join(home, "AppData", "Local")));
+		assert.ok(map.get("firefox")![0].startsWith(join(home, "AppData", "Roaming")));
+	});
+	it("lists macOS profile dirs including safari", () => {
+		const map = new Map(browserProfileCandidates("darwin", {}, "/Users/u").map((c) => [c.browser, c.dirs]));
+		assert.ok(map.get("firefox")![0].endsWith(join("Firefox", "Profiles")));
+		assert.ok(map.get("chrome")![0].endsWith(join("Google", "Chrome")));
+		assert.ok(map.get("safari")![0].endsWith("Safari.app"));
+		assert.ok(!map.has("whale"));
+	});
+	it("honors XDG_CONFIG_HOME on linux", () => {
+		const map = new Map(browserProfileCandidates("linux", { XDG_CONFIG_HOME: "/xdg" }, "/home/u").map((c) => [c.browser, c.dirs]));
+		assert.equal(map.get("chrome")![0], join("/xdg", "google-chrome"));
+		assert.equal(map.get("firefox")![0], join("/home/u", ".mozilla", "firefox"));
+		assert.ok(!map.has("safari"));
+	});
+	it("returns empty for unsupported platforms", () => {
+		assert.deepEqual(browserProfileCandidates("freebsd", {}, "/home/u"), []);
+	});
+	it("only yields browsers yt-dlp supports", () => {
+		for (const platform of ["win32", "darwin", "linux"] as const) {
+			for (const { browser } of browserProfileCandidates(platform, {}, "/home/u")) {
+				assert.ok(YTDLP_COOKIES_BROWSERS.has(browser), `${browser} on ${platform}`);
+			}
+		}
+	});
+});
+
+describe("summarizeYtDlpError", () => {
+	it("extracts the last ERROR line without the prefix", () => {
+		const msg = "Command failed: yt-dlp --no-playlist --no-warnings https://x\nWARNING: something\nERROR: unable to download video data: HTTP Error 403: Forbidden";
+		assert.equal(summarizeYtDlpError(msg), "unable to download video data: HTTP Error 403: Forbidden");
+	});
+	it("prefers the last ERROR line over earlier ones", () => {
+		const msg = "ERROR: first\nnoise\nERROR: second";
+		assert.equal(summarizeYtDlpError(msg), "second");
+	});
+	it("falls back to the last non-empty line", () => {
+		assert.equal(summarizeYtDlpError("Command failed: yt-dlp\n\nsome other failure\n"), "some other failure");
+	});
+	it("returns the message itself when it has no non-empty lines", () => {
+		assert.equal(summarizeYtDlpError(""), "");
+	});
+});
+
 describe("selectVisionModels", () => {
 	const img = (id: string) => ({ id, input: ["text", "image"] as readonly string[] });
 	const txt = (id: string) => ({ id, input: ["text"] as readonly string[] });

package/extensions/internal.ts

@@ -1163,6 +1163,68 @@ export function sanitizeYtdlpExtractorArgs(value: unknown): string {
 	return value.replace(/[\x00-\x1f\x7f]/g, "").trim().slice(0, YTDLP_EXTRACTOR_ARGS_MAX);
 }
 
+/**
+ * Well-known profile-dir candidates per browser, per platform (1.24.0). Pure:
+ * the caller does the fs checks and keeps only browsers whose dir exists.
+ * Drives the interactive 403 picker so it offers browsers that can actually
+ * work instead of listing all nine yt-dlp values blindly.
+ */
+export function browserProfileCandidates(
+	platform: NodeJS.Platform,
+	env: NodeJS.ProcessEnv,
+	homedir: string,
+): Array<{ browser: string; dirs: string[] }> {
+	const out: Array<{ browser: string; dirs: string[] }> = [];
+	const push = (browser: string, dirs: string[]) => out.push({ browser, dirs });
+	if (platform === "win32") {
+		const local = env.LOCALAPPDATA ?? join(homedir, "AppData", "Local");
+		const roaming = env.APPDATA ?? join(homedir, "AppData", "Roaming");
+		push("chrome", [join(local, "Google", "Chrome", "User Data")]);
+		push("firefox", [join(roaming, "Mozilla", "Firefox", "Profiles")]);
+		push("edge", [join(local, "Microsoft", "Edge", "User Data")]);
+		push("brave", [join(local, "BraveSoftware", "Brave-Browser", "User Data")]);
+		push("opera", [join(roaming, "Opera Software", "Opera Stable")]);
+		push("vivaldi", [join(local, "Vivaldi", "User Data")]);
+		push("chromium", [join(local, "Chromium", "User Data")]);
+		push("whale", [join(local, "Naver", "Naver Whale", "User Data")]);
+	} else if (platform === "darwin") {
+		const appSupport = join(homedir, "Library", "Application Support");
+		push("chrome", [join(appSupport, "Google", "Chrome")]);
+		push("firefox", [join(appSupport, "Firefox", "Profiles")]);
+		push("edge", [join(appSupport, "Microsoft Edge")]);
+		push("brave", [join(appSupport, "BraveSoftware", "Brave-Browser")]);
+		push("opera", [join(appSupport, "com.operasoftware.Opera")]);
+		push("vivaldi", [join(appSupport, "Vivaldi")]);
+		push("chromium", [join(appSupport, "Chromium")]);
+		push("safari", [join("/", "Applications", "Safari.app")]);
+	} else if (platform === "linux") {
+		const config = env.XDG_CONFIG_HOME ?? join(homedir, ".config");
+		push("chrome", [join(config, "google-chrome")]);
+		push("firefox", [join(homedir, ".mozilla", "firefox")]);
+		push("edge", [join(config, "microsoft-edge")]);
+		push("brave", [join(config, "BraveSoftware", "Brave-Browser")]);
+		push("opera", [join(config, "opera")]);
+		push("vivaldi", [join(config, "vivaldi")]);
+		push("chromium", [join(config, "chromium")]);
+		push("whale", [join(config, "naver-whale")]);
+	}
+	return out;
+}
+
+/**
+ * Reduce an execFile failure dump to the single actionable yt-dlp line: the
+ * last `ERROR: …` from stderr, else the last non-empty line. Keeps user-facing
+ * notifications to one line instead of echoing the full command (1.24.0).
+ */
+export function summarizeYtDlpError(message: string): string {
+	const lines = message.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
+	for (let i = lines.length - 1; i >= 0; i--) {
+		const m = /^ERROR:\s*(.+)$/i.exec(lines[i]);
+		if (m) return m[1].trim();
+	}
+	return lines[lines.length - 1] ?? message;
+}
+
 /**
  * Drop `null` header values from a `ProviderHeaders` map. Since pi 0.84.0,
  * `ModelRegistry.getApiKeyAndHeaders()` returns `Record<string, string | null>`

package/extensions/vision-proxy.ts

@@ -254,6 +254,7 @@ import {
 	buildVideoDescriptionFence,
 	buildVideoEmptyResponseError,
 	buildVideoProxySection,
+	browserProfileCandidates,
 	extractXaiResponsesText,
 	formatXaiSttTranscript,
 	analyzeDetailsForTranscript,
@@ -321,6 +322,7 @@ import {
 	isUncPath,
 	MAX_ALLOWED_FOLDERS,
 	sanitizeYtdlpExtractorArgs,
+	summarizeYtDlpError,
 	YTDLP_COOKIES_BROWSERS,
 
 	readMediaFileWithReason,
@@ -1448,6 +1450,65 @@ interface DownloadedMedia {
 	title: string;
 }
 
+/**
+ * Browsers from yt-dlp's --cookies-from-browser set whose profile dir exists
+ * on this machine (1.24.0). Drives the interactive 403 picker so it only
+ * offers browsers that can actually work.
+ */
+async function detectCookieBrowsers(): Promise<string[]> {
+	const found: string[] = [];
+	for (const { browser, dirs } of browserProfileCandidates(os.platform(), process.env, os.homedir())) {
+		for (const d of dirs) {
+			if (await pathExists(d)) {
+				found.push(browser);
+				break;
+			}
+		}
+	}
+	return found;
+}
+
+/**
+ * Persist a single config patch outside the slash-command handler (1.24.0).
+ * Mirrors commandHandler's writePersisted: sanitize → session entry → file,
+ * keeping allowedProviders file-scoped. Used by the interactive 403 flow.
+ */
+function persistConfigPatch(pi: ExtensionAPI, ctx: ExtensionContext, patch: Partial<VisionConfig>): void {
+	const validated = sanitize({ ...persistedBase(ctx.sessionManager.getEntries()), ...patch });
+	delete validated.allowedProviders;
+	pi.appendEntry(CUSTOM_TYPE_CONFIG, validated);
+	const fileNext: Partial<VisionConfig> = { ...validated };
+	if (_fileConfig.allowedProviders !== undefined) {
+		fileNext.allowedProviders = normalizeAllowedProviders(_fileConfig.allowedProviders) ?? [];
+	}
+	writePersistentFile(fileNext);
+	_fileConfig = fileNext;
+}
+
+/**
+ * Interactive half of the 403 flow (1.24.0): offer the installed browsers,
+ * persist the pick (same as `/multimodal-proxy ytdlp cookies <browser>`), and
+ * return it so the caller retries. Returns null when declined, when no UI is
+ * available, or when no supported browser is detected.
+ */
+async function promptForCookieBrowser(pi: ExtensionAPI, ctx: ExtensionContext): Promise<string | null> {
+	if (!ctx.hasUI) return null;
+	const browsers = await detectCookieBrowsers();
+	if (browsers.length === 0) return null;
+	const CANCEL = "Don't retry";
+	const choice = await ctx.ui.select(
+		"YouTube blocked the download (403 — it wants a logged-in session). Retry with cookies from:",
+		[...browsers, CANCEL],
+	);
+	if (!choice || choice === CANCEL || !YTDLP_COOKIES_BROWSERS.has(choice)) return null;
+	persistConfigPatch(pi, ctx, { ytdlpCookiesFromBrowser: choice });
+	ctx.ui.notify(
+		`[multimodal-proxy] Saved: yt-dlp will reuse ${choice} cookies from now on (change via /multimodal-proxy ytdlp cookies). Retrying…`,
+		"info",
+	);
+	return choice;
+}
+
 /**
  * Download a media URL via yt-dlp into a fresh temp dir.
  *
@@ -1464,6 +1525,7 @@ async function downloadMediaUrl(
 	signal: AbortSignal | undefined,
 	ctx: ExtensionContext,
 	ytdlp?: { cookiesFromBrowser?: string; extractorArgs?: string },
+	hooks?: { onForbidden?: () => Promise<string | null> },
 ): Promise<DownloadedMedia | null> {
 	if (!(await checkYtDlp())) {
 		ctx.ui.notify(
@@ -1524,12 +1586,32 @@ async function downloadMediaUrl(
 	} catch (err) {
 		if (signal?.aborted) return null;
 		const msg = err instanceof Error ? err.message : String(err);
-		// A 403 on the media fetch usually means YouTube wants a logged-in
-		// session; point the user at the cookies knob if it isn't already set.
-		const hint = /403|forbidden/i.test(msg) && !ytdlp?.cookiesFromBrowser
-			? " (a 403 often means YouTube wants a logged-in session — try /multimodal-proxy ytdlp cookies <browser>)"
+		const forbidden = /403|forbidden/i.test(msg);
+		// A 403 without cookies means YouTube wants a logged-in session. Offer to
+		// reuse a browser's cookies interactively (1.24.0) and retry once with
+		// them; the hook also persists the choice so later downloads just work.
+		if (forbidden && !ytdlp?.cookiesFromBrowser && hooks?.onForbidden) {
+			let browser: string | null = null;
+			try {
+				browser = await hooks.onForbidden();
+			} catch {
+				browser = null;
+			}
+			if (signal?.aborted) return null;
+			if (browser) {
+				return downloadMediaUrl(url, signal, ctx, { ...ytdlp, cookiesFromBrowser: browser });
+			}
+			// Declined (or nothing to offer): keep the notice to one line.
+			ctx.ui.notify(`[multimodal-proxy] YouTube download failed: ${summarizeYtDlpError(msg)}`, "warning");
+			return null;
+		}
+		// Point the user at the right knob depending on what is already set.
+		const hint = forbidden
+			? ytdlp?.cookiesFromBrowser
+				? " (still blocked with cookies — try /multimodal-proxy ytdlp extractor-args \"youtube:player_client=android\")"
+				: " (a 403 often means YouTube wants a logged-in session — try /multimodal-proxy ytdlp cookies <browser>)"
 			: "";
-		ctx.ui.notify(`[multimodal-proxy] YouTube download failed for ${url}: ${msg}${hint}`, "warning");
+		ctx.ui.notify(`[multimodal-proxy] YouTube download failed for ${url}: ${summarizeYtDlpError(msg)}${hint}`, "warning");
 		return null;
 	}
 }
@@ -3091,6 +3173,10 @@ export default function (pi: ExtensionAPI) {
 						() => downloadMediaUrl(watch, ctx.signal, ctx, {
 							cookiesFromBrowser: config.ytdlpCookiesFromBrowser,
 							extractorArgs: config.ytdlpExtractorArgs,
+						}, {
+							// 403 without cookies → offer to reuse an installed browser's
+							// session, persist the pick, and retry (1.24.0).
+							onForbidden: () => promptForCookieBrowser(pi, ctx),
 						}),
 					);
 					if (!dl) continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-multimodal-proxy",
-  "version": "1.23.0",
+  "version": "1.24.0",
   "description": "Media understanding for any model in Pi: video/audio/YouTube analysis, vision for text-only models, cost-routed vision, and session image recall.",
   "keywords": [
     "pi-package"