pi-ui-extend 0.1.21 → 0.1.24

package/external/pi-tools-suite/src/web-search/index.ts

@@ -1,9 +1,13 @@
+import { spawn } from "node:child_process";
+
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
 import { WEB_SEARCH_TOOL_DESCRIPTIONS } from "../tool-descriptions";
 
+let spawnImpl: typeof spawn = spawn;
+
 interface SearchResult {
 	title: string;
 	url: string;
@@ -22,11 +26,21 @@ interface FetchResponse {
 
 type Operation = "Search" | "Fetch";
 
+class OllamaEndpointUnavailableError extends Error {
+	constructor(message: string, readonly status: number) {
+		super(message);
+		this.name = "OllamaEndpointUnavailableError";
+	}
+}
+
 const DEFAULT_OLLAMA_HOST = "http://localhost:11434";
 const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
 const MAX_REQUEST_TIMEOUT_MS = 120_000;
 const REQUEST_TIMEOUT_ENV = "PI_WEB_SEARCH_TIMEOUT_MS";
+const OLLAMA_STARTUP_TIMEOUT_ENV = "PI_WEB_SEARCH_OLLAMA_STARTUP_TIMEOUT_MS";
+const DEFAULT_OLLAMA_STARTUP_TIMEOUT_MS = 30_000;
 const MAX_ERROR_BODY_CHARS = 1_200;
+const STARTED_OLLAMA_PROCESSES = new Set<string>();
 
 function normalizeOllamaHost(host: string | undefined): string {
 	const trimmed = host?.trim();
@@ -55,6 +69,92 @@ function resolveRequestTimeoutMs(timeoutMs: number | undefined): number {
 	return DEFAULT_REQUEST_TIMEOUT_MS;
 }
 
+function resolveOllamaStartupTimeoutMs(timeoutMs: number): number {
+	const envTimeout = process.env[OLLAMA_STARTUP_TIMEOUT_ENV]?.trim();
+	if (envTimeout) return parseTimeoutMs(envTimeout, OLLAMA_STARTUP_TIMEOUT_ENV);
+
+	return Math.min(timeoutMs, DEFAULT_OLLAMA_STARTUP_TIMEOUT_MS);
+}
+
+function isLoopbackHost(host: string): boolean {
+	try {
+		const { hostname } = new URL(host);
+		return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
+	} catch {
+		return false;
+	}
+}
+
+function sleep(ms: number, signal: AbortSignal | undefined): Promise<void> {
+	return new Promise((resolve, reject) => {
+		const cleanup = () => signal?.removeEventListener("abort", abort);
+		const timeout = setTimeout(() => {
+			cleanup();
+			resolve();
+		}, ms);
+		const abort = () => {
+			clearTimeout(timeout);
+			cleanup();
+			reject(Object.assign(new Error("aborted"), { name: "AbortError" }));
+		};
+
+		if (signal?.aborted) abort();
+		else signal?.addEventListener("abort", abort, { once: true });
+	});
+}
+
+function startOllama(host: string): void {
+	if (!isLoopbackHost(host) || STARTED_OLLAMA_PROCESSES.has(host)) return;
+
+	const child = spawnImpl("ollama", ["serve"], {
+		detached: true,
+		stdio: "ignore",
+		env: { ...process.env, OLLAMA_HOST: host },
+	});
+
+	STARTED_OLLAMA_PROCESSES.add(host);
+	child.on("error", () => STARTED_OLLAMA_PROCESSES.delete(host));
+	child.unref();
+}
+
+export function __setSpawnForTests(nextSpawn: typeof spawn | undefined): void {
+	spawnImpl = nextSpawn ?? spawn;
+}
+
+async function waitForOllama(host: string, timeoutMs: number, signal: AbortSignal | undefined): Promise<void> {
+	const deadline = Date.now() + timeoutMs;
+	let lastError: unknown;
+
+	while (Date.now() < deadline) {
+		const remainingMs = deadline - Date.now();
+		const requestSignal = createRequestSignal(signal, Math.max(1, Math.min(1_000, remainingMs)));
+
+		try {
+			const response = await fetch(`${host}/api/tags`, { signal: requestSignal.signal });
+			if (response.ok) return;
+			lastError = new Error(`HTTP ${response.status}`);
+		} catch (error) {
+			if (requestSignal.timedOut()) lastError = error;
+			else if (isAbortError(error) && signal?.aborted) throw error;
+			else lastError = error;
+		} finally {
+			requestSignal.cleanup();
+		}
+
+		await sleep(Math.min(250, Math.max(1, deadline - Date.now())), signal);
+	}
+
+	const details = collectErrorText(lastError);
+	throw new Error(`Started Ollama for ${host}, but it did not become ready within ${timeoutMs}ms.${details ? ` ${details}` : ""}`);
+}
+
+async function ensureOllamaRunning(host: string, timeoutMs: number, signal: AbortSignal | undefined): Promise<void> {
+	if (!isLoopbackHost(host)) return;
+
+	startOllama(host);
+	await waitForOllama(host, resolveOllamaStartupTimeoutMs(timeoutMs), signal);
+}
+
 function createRequestSignal(parentSignal: AbortSignal | undefined, timeoutMs: number) {
 	const controller = new AbortController();
 	let timedOut = false;
@@ -145,9 +245,10 @@ function createHttpError(response: Response, operation: Operation, host: string,
 	}
 
 	if (response.status === 404 || response.status === 405) {
-		return new Error(
+		return new OllamaEndpointUnavailableError(
 			`Ollama ${apiName} endpoint is not available at ${host} (HTTP ${response.status}). ` +
 				`Update Ollama and make sure experimental web ${operationNoun(operation)} is enabled.${withBody}`,
+			response.status,
 		);
 	}
 
@@ -158,6 +259,31 @@ function createHttpError(response: Response, operation: Operation, host: string,
 	return new Error(`Ollama ${apiName} API at ${host} returned HTTP ${response.status}.${withBody || ` ${response.statusText}`}`);
 }
 
+function isEndpointUnavailable(error: unknown): boolean {
+	return error instanceof OllamaEndpointUnavailableError;
+}
+
+async function waitForEndpointReady<T>(request: () => Promise<T>, host: string, operation: Operation, timeoutMs: number, signal: AbortSignal | undefined): Promise<T> {
+	const startupTimeoutMs = resolveOllamaStartupTimeoutMs(timeoutMs);
+	const deadline = Date.now() + startupTimeoutMs;
+	let lastError: unknown;
+
+	while (Date.now() < deadline) {
+		try {
+			return await request();
+		} catch (error) {
+			if (!isEndpointUnavailable(error)) throw error;
+			lastError = error;
+		}
+
+		await sleep(Math.min(250, Math.max(1, deadline - Date.now())), signal);
+	}
+
+	throw lastError instanceof Error
+		? lastError
+		: new Error(`Ollama ${endpointName(operation)} endpoint at ${host} did not become ready within ${startupTimeoutMs}ms.`);
+}
+
 async function readJsonResponse<T>(response: Response, operation: Operation, host: string): Promise<T> {
 	const body = await response.text().catch(() => "");
 
@@ -207,7 +333,7 @@ function normalizeOllamaError(error: unknown, operation: Operation, host: string
 	return error instanceof Error ? error : new Error(String(error));
 }
 
-async function postOllamaJson<T>(host: string, endpoint: "web_search" | "web_fetch", body: Record<string, unknown>, operation: Operation, signal: AbortSignal | undefined, timeoutMs: number): Promise<T> {
+async function postOllamaJson<T>(host: string, endpoint: "web_search" | "web_fetch", body: Record<string, unknown>, operation: Operation, signal: AbortSignal | undefined, timeoutMs: number, retryEndpointUnavailable = true): Promise<T> {
 	const requestSignal = createRequestSignal(signal, timeoutMs);
 
 	try {
@@ -220,6 +346,17 @@ async function postOllamaJson<T>(host: string, endpoint: "web_search" | "web_fet
 
 		return await readJsonResponse<T>(response, operation, host);
 	} catch (error) {
+		if (isConnectionRefused(error) && isLoopbackHost(host)) {
+			requestSignal.cleanup();
+			await ensureOllamaRunning(host, timeoutMs, signal);
+			return waitForEndpointReady(() => postOllamaJson<T>(host, endpoint, body, operation, signal, timeoutMs, false), host, operation, timeoutMs, signal);
+		}
+
+		if (retryEndpointUnavailable && isEndpointUnavailable(error) && isLoopbackHost(host)) {
+			requestSignal.cleanup();
+			return waitForEndpointReady(() => postOllamaJson<T>(host, endpoint, body, operation, signal, timeoutMs, false), host, operation, timeoutMs, signal);
+		}
+
 		throw normalizeOllamaError(error, operation, host, timeoutMs, requestSignal.timedOut(), signal);
 	} finally {
 		requestSignal.cleanup();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "0.1.21",
+  "version": "0.1.24",
   "private": false,
   "type": "module",
   "bin": {
@@ -61,12 +61,12 @@
     "prepublishOnly": "npm run check && npm run build:pix && npm run generate-schemas"
   },
   "dependencies": {
-    "@earendil-works/pi-tui": "0.77.0",
-    "@earendil-works/pi-ai": "0.77.0",
-    "@earendil-works/pi-coding-agent": "0.77.0",
-    "@mariozechner/pi-ai": "npm:@earendil-works/pi-ai@0.77.0",
-    "@mariozechner/pi-coding-agent": "npm:@earendil-works/pi-coding-agent@0.77.0",
-    "@mariozechner/pi-tui": "npm:@earendil-works/pi-tui@0.77.0",
+    "@earendil-works/pi-tui": "0.79.1",
+    "@earendil-works/pi-ai": "0.79.1",
+    "@earendil-works/pi-coding-agent": "0.79.1",
+    "@mariozechner/pi-ai": "npm:@earendil-works/pi-ai@0.79.1",
+    "@mariozechner/pi-coding-agent": "npm:@earendil-works/pi-coding-agent@0.79.1",
+    "@mariozechner/pi-tui": "npm:@earendil-works/pi-tui@0.79.1",
     "@mariozechner/clipboard": "^0.3.9",
     "jsonc-parser": "3.3.1",
     "typebox": "1.1.38",