pi-ui-extend 0.1.72 → 0.1.77

package/external/pi-tools-suite/src/opencode-import/commands.ts

@@ -72,15 +72,18 @@ export function formatOpencodeImportResult(result: OpencodeImportResult): string
 	if (antigravity) providerLines.push(`- ${antigravity}`);
 
 	if (providerLines.length === 0) {
-		return `No opencode credentials were imported. Checked ${result.sourcePath}${result.antigravitySourcePath ? ` and ${result.antigravitySourcePath}` : ""}.`;
+		return `No OpenCode credentials were imported. Checked ${result.sourcePath}${result.antigravitySourcePath ? ` and ${result.antigravitySourcePath}` : ""}.`;
 	}
 
 	const suffix = missingCount > 0 ? `\nMissing ${missingCount} known opencode provider entr${missingCount === 1 ? "y" : "ies"}.` : "";
-	return `Opencode import wrote to ${result.authPath}:\n${providerLines.join("\n")}${suffix}`;
+	const heading = result.wroteAuth ? `Imported OpenCode credentials into ${result.authPath}:` : `OpenCode credential check for ${result.authPath}:`;
+	return `${heading}\n${providerLines.join("\n")}${suffix}`;
 }
 
-export function notificationLevel(result: OpencodeImportResult): "info" | "warn" | "error" {
+export function notificationLevel(result: OpencodeImportResult): "info" | "warning" | "error" {
 	if (result.wroteAuth) return "info";
-	if (result.providers.some((provider) => provider.status === "auth-exists-use-force") || result.antigravity?.reason === "auth-exists-use-force") return "warn";
-	return "error";
+	if (result.providers.some((provider) => provider.status === "auth-exists-use-force") || result.antigravity?.reason === "auth-exists-use-force") return "warning";
+	if (result.providers.some((provider) => provider.status === "invalid-source") || result.antigravity?.reason === "matching-account-not-found") return "error";
+	if (result.providers.some((provider) => provider.status === "already-imported") || result.antigravity?.reason === "already-imported") return "info";
+	return "warning";
 }

package/external/pi-tools-suite/src/opencode-import/importer.ts

@@ -55,16 +55,16 @@ export type OpencodeImportOptions = {
 type Mapping = {
 	label: string;
 	sourceProvider: string;
-	targetProvider: string;
+	targetProvider: string | ((credential: OpencodeAuthCredential | undefined) => string);
 	transform: (credential: OpencodeAuthCredential) => PiAuthCredential | undefined;
 };
 
 const AUTH_JSON_MAPPINGS: Mapping[] = [
 	{
-		label: "OpenAI Codex",
+		label: "OpenAI",
 		sourceProvider: "openai",
-		targetProvider: "openai-codex",
-		transform: transformOAuthCredential,
+		targetProvider: (credential) => (isOAuthCredential(credential) ? "openai-codex" : "openai"),
+		transform: transformOpenAiCredential,
 	},
 	{
 		label: "GitHub Copilot",
@@ -92,24 +92,45 @@ export function getDefaultOpencodeAuthPath(): string {
 }
 
 function transformOAuthCredential(credential: OpencodeAuthCredential): PiAuthCredential | undefined {
-	if (!credential.access && !credential.refresh) return undefined;
+	if (
+		typeof credential.access !== "string" ||
+		!credential.access ||
+		typeof credential.refresh !== "string" ||
+		!credential.refresh ||
+		typeof credential.expires !== "number" ||
+		!Number.isFinite(credential.expires)
+	) {
+		return undefined;
+	}
 	return { ...credential, type: "oauth" };
 }
 
 function transformApiKeyCredential(credential: OpencodeAuthCredential): PiAuthCredential | undefined {
-	if (!credential.key) return undefined;
+	if (typeof credential.key !== "string" || !credential.key) return undefined;
 	return { ...credential, type: "api_key", key: credential.key };
 }
 
+function isOAuthCredential(credential: OpencodeAuthCredential | undefined): boolean {
+	return credential?.type === "oauth" || typeof credential?.access === "string" || typeof credential?.refresh === "string";
+}
+
+function transformOpenAiCredential(credential: OpencodeAuthCredential): PiAuthCredential | undefined {
+	return isOAuthCredential(credential) ? transformOAuthCredential(credential) : transformApiKeyCredential(credential);
+}
+
 function sameCredential(a: PiAuthCredential | undefined, b: PiAuthCredential | undefined): boolean {
 	return JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
 }
 
-function providerResult(mapping: Mapping, status: OpencodeProviderImportStatus): OpencodeProviderImportResult {
+function targetProvider(mapping: Mapping, credential: OpencodeAuthCredential | undefined): string {
+	return typeof mapping.targetProvider === "function" ? mapping.targetProvider(credential) : mapping.targetProvider;
+}
+
+function providerResult(mapping: Mapping, status: OpencodeProviderImportStatus, credential?: OpencodeAuthCredential): OpencodeProviderImportResult {
 	return {
 		label: mapping.label,
 		sourceProvider: mapping.sourceProvider,
-		targetProvider: mapping.targetProvider,
+		targetProvider: targetProvider(mapping, credential),
 		status,
 	};
 }
@@ -123,8 +144,15 @@ async function pathExists(path: string): Promise<boolean> {
 	}
 }
 
+async function readOpencodeAuth(sourcePath: string, environmentSource: string | undefined): Promise<OpencodeAuthData> {
+	if (environmentSource !== undefined) return parseOpencodeAuthContent(environmentSource);
+	if (!(await pathExists(sourcePath))) return {};
+	return readJsonFile<OpencodeAuthData>(sourcePath, {});
+}
+
 export async function importOpencodeAccounts(options: OpencodeImportOptions = {}): Promise<OpencodeImportResult> {
-	const sourcePath = options.sourcePath ?? getDefaultOpencodeAuthPath();
+	const environmentSource = options.sourcePath === undefined ? process.env.OPENCODE_AUTH_CONTENT : undefined;
+	const sourcePath = options.sourcePath ?? (environmentSource !== undefined ? "OPENCODE_AUTH_CONTENT" : getDefaultOpencodeAuthPath());
 	const authPath = options.authPath ?? getPiAuthPath();
 	const result: OpencodeImportResult = {
 		sourcePath,
@@ -138,8 +166,7 @@ export async function importOpencodeAccounts(options: OpencodeImportOptions = {}
 	const changedTargets = new Set<string>();
 
 	if (!options.skipAuthJson) {
-		const sourceExists = await pathExists(sourcePath);
-		const opencodeAuth = sourceExists ? await readJsonFile<OpencodeAuthData>(sourcePath, {}) : {};
+		const opencodeAuth = await readOpencodeAuth(sourcePath, environmentSource);
 
 		for (const mapping of AUTH_JSON_MAPPINGS) {
 			const sourceCredential = opencodeAuth[mapping.sourceProvider];
@@ -147,34 +174,35 @@ export async function importOpencodeAccounts(options: OpencodeImportOptions = {}
 				result.providers.push(providerResult(mapping, "source-missing"));
 				continue;
 			}
+			const resolvedTargetProvider = targetProvider(mapping, sourceCredential);
 
-			if (changedTargets.has(mapping.targetProvider)) {
-				result.providers.push(providerResult(mapping, "target-set-from-other-source"));
+			if (changedTargets.has(resolvedTargetProvider)) {
+				result.providers.push(providerResult(mapping, "target-set-from-other-source", sourceCredential));
 				continue;
 			}
 
 			const nextCredential = mapping.transform(sourceCredential);
 			if (!nextCredential) {
-				result.providers.push(providerResult(mapping, "invalid-source"));
+				result.providers.push(providerResult(mapping, "invalid-source", sourceCredential));
 				continue;
 			}
 
-			const existingCredential = piAuth[mapping.targetProvider];
+			const existingCredential = piAuth[resolvedTargetProvider];
 			if (sameCredential(existingCredential, nextCredential)) {
-				result.providers.push(providerResult(mapping, "already-imported"));
-				changedTargets.add(mapping.targetProvider);
+				result.providers.push(providerResult(mapping, "already-imported", sourceCredential));
+				changedTargets.add(resolvedTargetProvider);
 				continue;
 			}
 
 			if (existingCredential && !options.overwrite) {
-				result.providers.push(providerResult(mapping, "auth-exists-use-force"));
-				changedTargets.add(mapping.targetProvider);
+				result.providers.push(providerResult(mapping, "auth-exists-use-force", sourceCredential));
+				changedTargets.add(resolvedTargetProvider);
 				continue;
 			}
 
-			piAuth = { ...piAuth, [mapping.targetProvider]: nextCredential };
-			changedTargets.add(mapping.targetProvider);
-			result.providers.push(providerResult(mapping, "imported"));
+			piAuth = { ...piAuth, [resolvedTargetProvider]: nextCredential };
+			changedTargets.add(resolvedTargetProvider);
+			result.providers.push(providerResult(mapping, "imported", sourceCredential));
 		}
 
 		if (result.providers.some((provider) => provider.status === "imported")) {
@@ -206,3 +234,16 @@ export async function importOpencodeAccounts(options: OpencodeImportOptions = {}
 
 	return result;
 }
+
+function parseOpencodeAuthContent(content: string): OpencodeAuthData {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(content);
+	} catch {
+		throw new Error("OPENCODE_AUTH_CONTENT must contain a valid JSON object.");
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+		throw new Error("OPENCODE_AUTH_CONTENT must contain a JSON object.");
+	}
+	return parsed as OpencodeAuthData;
+}

package/external/pi-tools-suite/src/opencode-import/index.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { formatOpencodeImportResult, notificationLevel, parseOpencodeImportCommandArgs } from "./commands";
 import { importOpencodeAccounts } from "./importer";
 
@@ -8,10 +8,12 @@ export type { OpencodeImportOptions, OpencodeImportResult } from "./importer";
 
 export default function opencodeImport(pi: ExtensionAPI): void {
 	pi.registerCommand("opencode-import", {
-		description: "Import opencode auth.json credentials and Antigravity accounts into Pi/Pix auth.json",
-		handler: async (args: string, ctx: any) => {
+		description: "Import supported OpenCode credentials and Antigravity accounts into Pi/Pix auth.json",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			let wroteAuth = false;
 			try {
 				const result = await importOpencodeAccounts(parseOpencodeImportCommandArgs(args));
+				wroteAuth = result.wroteAuth;
 				const message = formatOpencodeImportResult(result);
 				if (ctx.ui?.notify) ctx.ui.notify(message, notificationLevel(result));
 				else console.log(message);
@@ -19,6 +21,15 @@ export default function opencodeImport(pi: ExtensionAPI): void {
 				const message = error instanceof Error ? error.message : String(error);
 				if (ctx.ui?.notify) ctx.ui.notify(message, "error");
 				else console.error(message);
+				return;
+			}
+
+			if (!wroteAuth) return;
+			try {
+				await ctx.reload();
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				console.error(`OpenCode credentials were imported, but resource reload failed: ${message}`);
 			}
 		},
 	});

package/external/pi-tools-suite/src/tool-descriptions.ts

@@ -246,8 +246,8 @@ export const WEB_SEARCH_TOOL_DESCRIPTIONS = {
 		name: "web_search",
 		label: "web-search",
 		description:
-			"Search the web for real-time information using your local Ollama instance's web_search API. Requires Ollama running locally with web search enabled; supports per-call timeout_ms and PI_WEB_SEARCH_TIMEOUT_MS.",
-		promptSnippet: "Search the web for current or real-time information through the local Ollama web_search API.",
+			"Search the web for real-time information through Ollama, with automatic configured Tavily fallback. Credentials come from /web-credentials or environment variables. Supports per-call timeout_ms and PI_WEB_SEARCH_TIMEOUT_MS.",
+		promptSnippet: "Search the web for current or real-time information through Ollama, with Tavily fallback when configured.",
 		promptGuidelines: [
 			"Use web_search only for current public web information; keep queries focused and set max_results only when useful.",
 			"Never include secrets, tokens, or private repository data; do not use web_search for repo-local discovery—use repo_* or file/search tools.",
@@ -257,8 +257,8 @@ export const WEB_SEARCH_TOOL_DESCRIPTIONS = {
 		name: "web_fetch",
 		label: "web-fetch",
 		description:
-			"Fetch and extract text content from a web page URL using your local Ollama instance's web_fetch API. Requires Ollama running locally with web fetch enabled; supports per-call timeout_ms and PI_WEB_SEARCH_TIMEOUT_MS.",
-		promptSnippet: "Fetch and extract text from a specific URL through the local Ollama web_fetch API.",
+			"Fetch and extract text content from a web page URL through Ollama, with automatic configured Tavily Extract fallback. Credentials come from /web-credentials or environment variables. Supports per-call timeout_ms and PI_WEB_SEARCH_TIMEOUT_MS.",
+		promptSnippet: "Fetch and extract text from a specific URL through Ollama, with Tavily Extract fallback when configured.",
 		promptGuidelines: [
 			"Use web_fetch for user-provided URLs or web_search results needing deeper reading; never pass secret/private-credential URLs, and use read for local files.",
 		],