@victor-software-house/pi-openai-proxy 4.9.3 → 4.9.5

package/README.md

@@ -20,10 +20,10 @@ A local OpenAI-compatible HTTP proxy built on [pi](https://github.com/badlogic/p
 
 ```bash
 # Install globally
-npm install -g @victor-software-house/pi-openai-proxy
+pnpm add -g @victor-software-house/pi-openai-proxy
 
-# Or run directly with npx
-npx @victor-software-house/pi-openai-proxy
+# Or run directly
+pnpm dlx @victor-software-house/pi-openai-proxy
 ```
 
 ## Quickstart
@@ -339,17 +339,18 @@ The extension detects externally running instances and shows their status via `/
 ## Dev Workflow
 
 ```bash
-bun install           # Install dependencies
-bun run dev           # Run in development
-bun run build         # Build for npm (tsdown)
-bun run typecheck     # TypeScript strict check
-bun run lint          # Biome + oxlint (strict)
-bun test              # Run all tests
+pnpm install          # Install dependencies
+pnpm run dev          # Run in development
+pnpm run build        # Build for npm (tsdown)
+pnpm run typecheck    # TypeScript strict check
+pnpm run lint         # Biome + oxlint (strict)
+pnpm test             # Run all tests
 ```
 
 ### Tooling
 
-- **Bun** — runtime, test runner, package manager
+- **pnpm** — package manager and script runner
+- **Bun** — runtime and test runner
 - **tsdown** — npm build (ESM + .d.ts)
 - **Biome** — format + lint
 - **oxlint** — type-aware lint with strict rules (`.oxlintrc.json`)

package/dist/index.mjs

@@ -4,7 +4,6 @@ import { computeModelExposure, resolveExposedModel } from "./exposure.mjs";
 import * as z from "zod";
 import { AuthStorage, ModelRegistry, SettingsManager } from "@mariozechner/pi-coding-agent";
 import { randomBytes } from "node:crypto";
-import { Type } from "@sinclair/typebox";
 import { completeSimple, streamSimple } from "@mariozechner/pi-ai";
 import { Hono } from "hono";
 import { stream } from "hono/streaming";
@@ -53,8 +52,8 @@ let settingsManager;
 */
 function initRegistry() {
 	authStorage = AuthStorage.create();
-	registry = new ModelRegistry(authStorage);
-	settingsManager = SettingsManager.create();
+	registry = ModelRegistry.create(authStorage);
+	settingsManager = SettingsManager.create(process.cwd());
 	return registry.getError();
 }
 function getRegistry() {
@@ -89,9 +88,10 @@ async function getRequestAuth(model) {
 *
 * Returns undefined when no filter is configured (all models enabled).
 */
-function getEnabledModels() {
-	getSettingsManager().reload();
-	return getSettingsManager().getEnabledModels();
+async function getEnabledModels() {
+	const manager = getSettingsManager();
+	await manager.reload();
+	return manager.getEnabledModels();
 }
 //#endregion
 //#region src/server/errors.ts
@@ -761,6 +761,326 @@ async function* streamToSSE(events, requestId, model, includeUsage) {
 	yield encodeDone();
 }
 //#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/system/memory/metrics.mjs
+/** TypeBox instantiation metrics */
+const Metrics = {
+	assign: 0,
+	create: 0,
+	clone: 0,
+	discard: 0,
+	update: 0
+};
+//#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/guard/guard.mjs
+/** Returns true if this value is an array */
+function IsArray(value) {
+	return Array.isArray(value);
+}
+/** Returns true if this value is bigint */
+function IsBigInt(value) {
+	return IsEqual(typeof value, "bigint");
+}
+/** Returns true if this value is a boolean */
+function IsBoolean(value) {
+	return IsEqual(typeof value, "boolean");
+}
+/** Returns true if this value is null */
+function IsNull(value) {
+	return IsEqual(value, null);
+}
+/** Returns true if this value is number */
+function IsNumber(value) {
+	return Number.isFinite(value);
+}
+/** Returns true if this value is an object */
+function IsObject(value) {
+	return IsEqual(typeof value, "object") && !IsNull(value);
+}
+/** Returns true if this value is string */
+function IsString(value) {
+	return IsEqual(typeof value, "string");
+}
+function IsEqual(left, right) {
+	return left === right;
+}
+/** Returns true if the PropertyKey is Unsafe (ref: prototype-pollution). */
+function IsUnsafePropertyKey(key) {
+	return IsEqual(key, "__proto__") || IsEqual(key, "constructor") || IsEqual(key, "prototype");
+}
+/** Returns true if this value has this property key */
+function HasPropertyKey(value, key) {
+	return IsUnsafePropertyKey(key) ? Object.prototype.hasOwnProperty.call(value, key) : key in value;
+}
+/** Returns property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+function Keys(value) {
+	return Object.getOwnPropertyNames(value);
+}
+//#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/system/memory/clone.mjs
+function IsGuard(value) {
+	return IsObject(value) && HasPropertyKey(value, "~guard");
+}
+function FromGuard(value) {
+	return value;
+}
+function FromArray(value) {
+	return value.map((value) => FromValue(value));
+}
+function FromObject(value) {
+	const result = {};
+	const descriptors = Object.getOwnPropertyDescriptors(value);
+	for (const key of Object.keys(descriptors)) {
+		const descriptor = descriptors[key];
+		if (HasPropertyKey(descriptor, "value")) Object.defineProperty(result, key, {
+			...descriptor,
+			value: FromValue(descriptor.value)
+		});
+	}
+	return result;
+}
+function FromRegExp(value) {
+	return new RegExp(value.source, value.flags);
+}
+function FromUnknown(value) {
+	return value;
+}
+function FromValue(value) {
+	return value instanceof RegExp ? FromRegExp(value) : IsGuard(value) ? FromGuard(value) : IsArray(value) ? FromArray(value) : IsObject(value) ? FromObject(value) : FromUnknown(value);
+}
+/**
+* Clones a value using the TypeBox type cloning strategy. This function preserves non-enumerable
+* properties from the source value. This is to ensure cloned types retain discriminable
+* hidden properties.
+*/
+function Clone(value) {
+	Metrics.clone += 1;
+	return FromValue(value);
+}
+//#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/system/settings/settings.mjs
+const settings = {
+	immutableTypes: false,
+	maxErrors: 8,
+	useAcceleration: true,
+	exactOptionalPropertyTypes: false,
+	enumerableKind: false,
+	correctiveParse: false
+};
+/** Gets current system settings */
+function Get() {
+	return settings;
+}
+//#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/system/memory/create.mjs
+function MergeHidden(left, right) {
+	for (const key of Object.keys(right)) Object.defineProperty(left, key, {
+		configurable: true,
+		writable: true,
+		enumerable: false,
+		value: right[key]
+	});
+	return left;
+}
+function Merge(left, right) {
+	return {
+		...left,
+		...right
+	};
+}
+/**
+* Creates an object with hidden, enumerable, and optional property sets. This function
+* ensures types are instantiated according to configuration rules for enumerable and
+* non-enumerable properties.
+*/
+function Create(hidden, enumerable, options = {}) {
+	Metrics.create += 1;
+	const settings = Get();
+	const withOptions = Merge(enumerable, options);
+	const withHidden = settings.enumerableKind ? Merge(withOptions, hidden) : MergeHidden(withOptions, hidden);
+	return settings.immutableTypes ? Object.freeze(withHidden) : withHidden;
+}
+//#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/system/memory/update.mjs
+/**
+* Updates a value with new properties while preserving property enumerability. Use this function to modify
+* existing types without altering their configuration.
+*/
+function Update(current, hidden, enumerable) {
+	Metrics.update += 1;
+	const settings = Get();
+	const result = Clone(current);
+	for (const key of Object.keys(hidden)) Object.defineProperty(result, key, {
+		configurable: true,
+		writable: true,
+		enumerable: settings.enumerableKind,
+		value: hidden[key]
+	});
+	for (const key of Object.keys(enumerable)) Object.defineProperty(result, key, {
+		configurable: true,
+		enumerable: true,
+		writable: true,
+		value: enumerable[key]
+	});
+	return result;
+}
+//#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/schema.mjs
+function IsSchema(value) {
+	return IsObject(value);
+}
+//#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/_optional.mjs
+/** Adds Optional to the given type. */
+function OptionalAdd(type) {
+	return Update(type, { "~optional": true }, {});
+}
+/** Applies an Optional modifier to the given type. */
+function Optional(type) {
+	return OptionalAdd(type);
+}
+/** Returns true if the given value is TOptional */
+function IsOptional(value) {
+	return IsSchema(value) && HasPropertyKey(value, "~optional");
+}
+//#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/array.mjs
+/** Creates an Array type. */
+function _Array_(items, options) {
+	return Create({ "~kind": "Array" }, {
+		type: "array",
+		items
+	}, options);
+}
+//#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/properties.mjs
+/** Creates a RequiredArray derived from the given TProperties value. */
+function RequiredArray(properties) {
+	return Keys(properties).filter((key) => !IsOptional(properties[key]));
+}
+//#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/object.mjs
+/** Creates an Object type. */
+function _Object_(properties, options = {}) {
+	const requiredKeys = RequiredArray(properties);
+	return Create({ "~kind": "Object" }, {
+		type: "object",
+		...requiredKeys.length > 0 ? { required: requiredKeys } : {},
+		properties
+	}, options);
+}
+//#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/union.mjs
+/** Creates a Union type. */
+function Union(anyOf, options = {}) {
+	return Create({ "~kind": "Union" }, { anyOf }, options);
+}
+//#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/unknown.mjs
+/** Creates an Unknown type. */
+function Unknown(options) {
+	return Create({ ["~kind"]: "Unknown" }, {}, options);
+}
+//#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/system/hashing/hash.mjs
+var ByteMarker;
+(function(ByteMarker) {
+	ByteMarker[ByteMarker["Array"] = 0] = "Array";
+	ByteMarker[ByteMarker["BigInt"] = 1] = "BigInt";
+	ByteMarker[ByteMarker["Boolean"] = 2] = "Boolean";
+	ByteMarker[ByteMarker["Date"] = 3] = "Date";
+	ByteMarker[ByteMarker["Constructor"] = 4] = "Constructor";
+	ByteMarker[ByteMarker["Function"] = 5] = "Function";
+	ByteMarker[ByteMarker["Null"] = 6] = "Null";
+	ByteMarker[ByteMarker["Number"] = 7] = "Number";
+	ByteMarker[ByteMarker["Object"] = 8] = "Object";
+	ByteMarker[ByteMarker["RegExp"] = 9] = "RegExp";
+	ByteMarker[ByteMarker["String"] = 10] = "String";
+	ByteMarker[ByteMarker["Symbol"] = 11] = "Symbol";
+	ByteMarker[ByteMarker["TypeArray"] = 12] = "TypeArray";
+	ByteMarker[ByteMarker["Undefined"] = 13] = "Undefined";
+})(ByteMarker || (ByteMarker = {}));
+Array.from({ length: 256 }).map((_, i) => BigInt(i));
+const F64 = new Float64Array(1);
+new DataView(F64.buffer);
+new Uint8Array(F64.buffer);
+new TextEncoder();
+//#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/boolean.mjs
+/** Creates a Boolean type. */
+function Boolean(options) {
+	return Create({ "~kind": "Boolean" }, { type: "boolean" }, options);
+}
+//#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/integer.mjs
+const IntegerPattern = "-?(?:0|[1-9][0-9]*)";
+/** Creates a Integer type. */
+function Integer(options) {
+	return Create({ "~kind": "Integer" }, { type: "integer" }, options);
+}
+//#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/literal.mjs
+var InvalidLiteralValue = class extends Error {
+	constructor(value) {
+		super(`Invalid Literal value`);
+		Object.defineProperty(this, "cause", {
+			value: { value },
+			writable: false,
+			configurable: false,
+			enumerable: false
+		});
+	}
+};
+function LiteralTypeName(value) {
+	return IsBigInt(value) ? "bigint" : IsBoolean(value) ? "boolean" : IsNumber(value) ? "number" : IsString(value) ? "string" : (() => {
+		throw new InvalidLiteralValue(value);
+	})();
+}
+/** Creates a Literal type. */
+function Literal(value, options) {
+	return Create({ "~kind": "Literal" }, {
+		type: LiteralTypeName(value),
+		const: value
+	}, options);
+}
+//#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/null.mjs
+/** Creates a Null type. */
+function Null(options) {
+	return Create({ "~kind": "Null" }, { type: "null" }, options);
+}
+//#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/number.mjs
+const NumberPattern = "-?(?:0|[1-9][0-9]*)(?:.[0-9]+)?";
+/** Creates a Number type. */
+function Number$1(options) {
+	return Create({ "~kind": "Number" }, { type: "number" }, options);
+}
+//#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/string.mjs
+/** Creates a String type. */
+function String$1(options) {
+	return Create({ "~kind": "String" }, { type: "string" }, options);
+}
+//#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/types/record.mjs
+const IntegerKey = `^${IntegerPattern}$`;
+`${NumberPattern}`;
+//#endregion
+//#region node_modules/.pnpm/typebox@1.1.38/node_modules/typebox/build/type/script/token/internal/char.mjs
+function Range(start, end) {
+	return Array.from({ length: end - start + 1 }, (_, i) => String.fromCharCode(start + i));
+}
+const Alpha = [...Range(97, 122), ...Range(65, 90)];
+const Digit = ["0", ...Range(49, 57)];
+[...Digit];
+[...[
+	...Alpha,
+	"_",
+	"$"
+], ...Digit];
+[...Digit];
+new RegExp(IntegerKey);
+//#endregion
 //#region src/openai/json-schema-to-typebox.ts
 /**
 * JSON Schema -> TypeBox conversion for OpenAI function tool parameters.
@@ -829,7 +1149,7 @@ function jsonSchemaToTypebox(schema, path = "") {
 	if (typeof rawType !== "string") {
 		if (Object.keys(schema).length === 0 || Object.keys(schema).length === 1 && description !== void 0) return {
 			ok: true,
-			schema: Type.Unknown(opts)
+			schema: Unknown(opts)
 		};
 		return {
 			ok: false,
@@ -841,23 +1161,23 @@ function jsonSchemaToTypebox(schema, path = "") {
 		case "object": return convertObject(schema, path, opts);
 		case "string": return {
 			ok: true,
-			schema: Type.String(opts)
+			schema: String$1(opts)
 		};
 		case "number": return {
 			ok: true,
-			schema: Type.Number(opts)
+			schema: Number$1(opts)
 		};
 		case "integer": return {
 			ok: true,
-			schema: Type.Integer(opts)
+			schema: Integer(opts)
 		};
 		case "boolean": return {
 			ok: true,
-			schema: Type.Boolean(opts)
+			schema: Boolean(opts)
 		};
 		case "null": return {
 			ok: true,
-			schema: Type.Null(opts)
+			schema: Null(opts)
 		};
 		case "array": return convertArray(schema, path, opts);
 		default: return {
@@ -894,7 +1214,7 @@ function convertAnyOf(branches, path, opts) {
 	}
 	return {
 		ok: true,
-		schema: Type.Union(converted, opts)
+		schema: Union(converted, opts)
 	};
 }
 function convertEnum(values, path, opts) {
@@ -912,10 +1232,9 @@ function convertEnum(values, path, opts) {
 		message: `Empty enum at ${path || "root"}`,
 		path
 	};
-	const literals = stringValues.map((v) => Type.Literal(v));
 	return {
 		ok: true,
-		schema: Type.Union(literals, opts)
+		schema: Union(stringValues.map((v) => Literal(v)), opts)
 	};
 }
 function convertNullableType(typeArray, schema, path, opts) {
@@ -938,7 +1257,7 @@ function convertNullableType(typeArray, schema, path, opts) {
 	if (!innerResult.ok) return innerResult;
 	return {
 		ok: true,
-		schema: Type.Union([innerResult.schema, Type.Null()], opts)
+		schema: Union([innerResult.schema, Null()], opts)
 	};
 }
 function convertObject(schema, path, opts) {
@@ -952,7 +1271,7 @@ function convertObject(schema, path, opts) {
 	};
 	if (rawProperties === void 0) return {
 		ok: true,
-		schema: Type.Object({}, opts)
+		schema: _Object_({}, opts)
 	};
 	if (!isRecord(rawProperties)) return {
 		ok: false,
@@ -968,24 +1287,24 @@ function convertObject(schema, path, opts) {
 		const result = jsonSchemaToTypebox(propSchema, path.length > 0 ? `${path}.${key}` : key);
 		if (!result.ok) return result;
 		if (requiredSet.has(key)) typeboxProperties[key] = result.schema;
-		else typeboxProperties[key] = Type.Optional(result.schema);
+		else typeboxProperties[key] = Optional(result.schema);
 	}
 	return {
 		ok: true,
-		schema: Type.Object(typeboxProperties, opts)
+		schema: _Object_(typeboxProperties, opts)
 	};
 }
 function convertArray(schema, path, opts) {
 	const items = schema["items"];
 	if (items === void 0) return {
 		ok: true,
-		schema: Type.Array(Type.Unknown(), opts)
+		schema: _Array_(Unknown(), opts)
 	};
 	const itemResult = jsonSchemaToTypebox(items, path.length > 0 ? `${path}.items` : "items");
 	if (!itemResult.ok) return itemResult;
 	return {
 		ok: true,
-		schema: Type.Array(itemResult.schema, opts)
+		schema: _Array_(itemResult.schema, opts)
 	};
 }
 //#endregion
@@ -1008,7 +1327,7 @@ function convertTools(openaiTools) {
 				param: result.path
 			};
 			parameters = result.schema;
-		} else parameters = Type.Object({});
+		} else parameters = _Object_({});
 		piTools.push({
 			name: fn.name,
 			description: fn.description ?? "",
@@ -1631,19 +1950,19 @@ async function piStream(model, context, request, options) {
 }
 //#endregion
 //#region src/server/routes.ts
-function fileConfigReader() {
+async function fileConfigReader() {
 	const file = loadConfigFromFile();
 	return {
 		publicModelIdMode: file.publicModelIdMode,
 		modelExposureMode: file.modelExposureMode,
-		enabledModels: getEnabledModels(),
+		enabledModels: await getEnabledModels(),
 		customModels: file.customModels,
 		providerPrefixes: file.providerPrefixes
 	};
 }
 function createRoutes(config, configReader = fileConfigReader) {
-	function getExposure() {
-		const outcome = computeModelExposure(getAvailableModels(), configReader());
+	async function getExposure() {
+		const outcome = computeModelExposure(getAvailableModels(), await configReader());
 		if (!outcome.ok) throw new Error(`Model exposure configuration error: ${outcome.message}`);
 		return outcome;
 	}
@@ -1657,17 +1976,17 @@ function createRoutes(config, configReader = fileConfigReader) {
 		return mapped;
 	}
 	const routes = new Hono();
-	routes.get("/v1/models", (c) => {
-		const exposure = getExposure();
+	routes.get("/v1/models", async (c) => {
+		const exposure = await getExposure();
 		return c.json(buildModelList(exposure.models));
 	});
-	routes.get("/v1/models/*", (c) => {
+	routes.get("/v1/models/*", async (c) => {
 		const rawPath = c.req.path;
 		if (!rawPath.startsWith("/v1/models/")) return c.json(modelNotFound(""), 404);
 		const modelIdEncoded = rawPath.slice(11);
 		if (modelIdEncoded.length === 0) return c.json(modelNotFound(""), 404);
 		const modelId = decodeURIComponent(modelIdEncoded);
-		const resolved = resolveExposedModel(getExposure(), modelId);
+		const resolved = resolveExposedModel(await getExposure(), modelId);
 		if (resolved === void 0) return c.json(modelNotFound(modelId), 404);
 		return c.json(toOpenAIModel(resolved));
 	});
@@ -1687,7 +2006,7 @@ function createRoutes(config, configReader = fileConfigReader) {
 			return c.json(invalidRequest(validation.message, validation.param ?? void 0), 400);
 		}
 		const request = validation.data;
-		const resolved = resolveExposedModel(getExposure(), request.model);
+		const resolved = resolveExposedModel(await getExposure(), request.model);
 		if (resolved === void 0) return c.json(modelNotFound(request.model), 404);
 		const model = resolved.model;
 		const canonicalModelId = resolved.canonicalId;

package/extensions/proxy.ts

@@ -20,8 +20,10 @@
  */
 
 import { type ChildProcess, spawn } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
+import { constants, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { access } from "node:fs/promises";
+import { homedir } from "node:os";
+import { delimiter, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import type { Api, Model } from "@mariozechner/pi-ai";
 import {
@@ -94,24 +96,24 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 	// --- Model registry access (cached, refreshed per call) ---
 
 	const cachedAuth = AuthStorage.create();
-	const cachedRegistry = new ModelRegistry(cachedAuth);
-	const settingsManager = SettingsManager.create();
+	const cachedRegistry = ModelRegistry.create(cachedAuth);
+	const settingsManager = SettingsManager.create(process.cwd());
 
 	function getAvailableModels(): Model<Api>[] {
 		cachedRegistry.refresh();
 		return cachedRegistry.getAvailable();
 	}
 
-	function getEnabledModels(): readonly string[] | undefined {
-		settingsManager.reload();
+	async function getEnabledModels(): Promise<readonly string[] | undefined> {
+		await settingsManager.reload();
 		return settingsManager.getEnabledModels();
 	}
 
-	function buildExposureConfig(): ModelExposureConfig {
+	async function buildExposureConfig(): Promise<ModelExposureConfig> {
 		return {
 			publicModelIdMode: config.publicModelIdMode,
 			modelExposureMode: config.modelExposureMode,
-			enabledModels: getEnabledModels(),
+			enabledModels: await getEnabledModels(),
 			customModels: config.customModels,
 			providerPrefixes: config.providerPrefixes,
 		};
@@ -129,6 +131,41 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 		return "pi-proxy";
 	}
 
+	async function isExecutable(path: string): Promise<boolean> {
+		try {
+			await access(path, constants.X_OK);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+
+	async function resolveBunExecutable(): Promise<string> {
+		if ("bun" in process.versions) return process.execPath;
+
+		const bunInstall = process.env["BUN_INSTALL"];
+		const pathEntries = (process.env["PATH"] ?? "")
+			.split(delimiter)
+			.filter((entry) => entry.length > 0);
+		const candidates = [
+			process.env["PI_OPENAI_PROXY_BUN"],
+			bunInstall === undefined ? undefined : join(bunInstall, "bin", "bun"),
+			...pathEntries.map((entry) => join(entry, "bun")),
+			join(homedir(), ".bun", "bin", "bun"),
+			join(homedir(), ".local", "share", "mise", "installs", "bun", "latest", "bin", "bun"),
+			"/opt/homebrew/bin/bun",
+			"/usr/local/bin/bun",
+		];
+
+		for (const candidate of candidates) {
+			if (candidate !== undefined && (await isExecutable(candidate))) return candidate;
+		}
+
+		throw new Error(
+			"Bun runtime not found. Install Bun or set PI_OPENAI_PROXY_BUN to the Bun executable path.",
+		);
+	}
+
 	function proxyUrl(): string {
 		return `http://${config.host}:${String(config.port)}`;
 	}
@@ -137,7 +174,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 
 	pi.on("session_start", async (_event, ctx) => {
 		config = loadConfigFromFile();
-		maybeAutoSyncZed(ctx);
+		await maybeAutoSyncZed(ctx);
 		await refreshStatus(ctx);
 	});
 
@@ -193,16 +230,16 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 					await showStatus(ctx);
 					return;
 				case "verify":
-					verifyExposure(ctx);
+					await verifyExposure(ctx);
 					return;
 				case "models":
-					showModels(ctx);
+					await showModels(ctx);
 					return;
 				case "zed-sync":
-					handleZedSync(ctx, args);
+					await handleZedSync(ctx, args);
 					return;
 				case "show":
-					showConfig(ctx);
+					await showConfig(ctx);
 					return;
 				case "path":
 					ctx.ui.notify(getConfigPath(), "info");
@@ -343,9 +380,9 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 			const bin = findProxyBinary();
 
 			if (config.lifetime === "detached") {
-				startDetached(bin, proxyEnv);
+				await startDetached(bin, proxyEnv);
 			} else {
-				startSessionTied(ctx, bin, proxyEnv);
+				await startSessionTied(ctx, bin, proxyEnv);
 			}
 
 			const ready = await waitForReady(3000);
@@ -366,9 +403,9 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 		}
 	}
 
-	function startDetached(bin: string, env: Record<string, string>): void {
+	async function startDetached(bin: string, env: Record<string, string>): Promise<void> {
 		const usesBun = bin.endsWith(".mjs");
-		const cmd = usesBun ? "bun" : bin;
+		const cmd = usesBun ? await resolveBunExecutable() : bin;
 		const cmdArgs = usesBun ? ["run", bin] : [];
 
 		const child = spawn(cmd, cmdArgs, {
@@ -377,6 +414,10 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 			env: { ...process.env, ...env },
 		});
 
+		child.once("error", () => {
+			if (child.pid !== undefined) removePid();
+		});
+
 		if (child.pid === undefined) {
 			throw new Error("No PID returned from spawn");
 		}
@@ -385,14 +426,18 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 		writePid(child.pid);
 	}
 
-	function startSessionTied(ctx: ExtensionContext, bin: string, env: Record<string, string>): void {
+	async function startSessionTied(
+		ctx: ExtensionContext,
+		bin: string,
+		env: Record<string, string>,
+	): Promise<void> {
 		if (sessionProcess !== undefined) {
 			ctx.ui.notify("Session proxy already running", "info");
 			return;
 		}
 
 		const usesBun = bin.endsWith(".mjs");
-		const cmd = usesBun ? "bun" : bin;
+		const cmd = usesBun ? await resolveBunExecutable() : bin;
 		const cmdArgs = usesBun ? ["run", bin] : [];
 
 		sessionProcess = spawn(cmd, cmdArgs, {
@@ -460,7 +505,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 		await refreshStatus(ctx);
 	}
 
-	function showConfig(ctx: ExtensionContext): void {
+	async function showConfig(ctx: ExtensionContext): Promise<void> {
 		config = loadConfigFromFile();
 		const authDisplay =
 			config.authToken.length > 0 ? `enabled (token: ${config.authToken})` : "disabled";
@@ -483,7 +528,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 		];
 
 		if (config.modelExposureMode === "scoped") {
-			const enabledModels = getEnabledModels();
+			const enabledModels = await getEnabledModels();
 			if (enabledModels !== undefined && enabledModels.length > 0) {
 				exposureLines.push(`enabled: ${String(enabledModels.length)} pi model(s)`);
 			}
@@ -500,7 +545,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 
 		// Public ID preview (first 5 exposed models)
 		const models = getAvailableModels();
-		const outcome = computeModelExposure(models, buildExposureConfig());
+		const outcome = computeModelExposure(models, await buildExposureConfig());
 		if (outcome.ok && outcome.models.length > 0) {
 			const preview = outcome.models.slice(0, 5).map((m) => m.publicId);
 			const suffix =
@@ -517,10 +562,10 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 
 	// --- /proxy models ---
 
-	function showModels(ctx: ExtensionContext): void {
+	async function showModels(ctx: ExtensionContext): Promise<void> {
 		config = loadConfigFromFile();
 		const models = getAvailableModels();
-		const outcome = computeModelExposure(models, buildExposureConfig());
+		const outcome = computeModelExposure(models, await buildExposureConfig());
 
 		if (!outcome.ok) {
 			ctx.ui.notify(`Model exposure error: ${outcome.message}`, "warning");
@@ -562,7 +607,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 
 	// --- /proxy verify ---
 
-	function verifyExposure(ctx: ExtensionContext): void {
+	async function verifyExposure(ctx: ExtensionContext): Promise<void> {
 		config = loadConfigFromFile();
 		const models = getAvailableModels();
 		const issues: string[] = [];
@@ -586,7 +631,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 		}
 
 		// Run the full exposure computation to catch ID/prefix errors
-		const outcome = computeModelExposure(models, buildExposureConfig());
+		const outcome = computeModelExposure(models, await buildExposureConfig());
 		if (!outcome.ok) {
 			issues.push(outcome.message);
 		}
@@ -607,9 +652,9 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 	/**
 	 * Run Zed sync and return the result. Shared by the command and auto-sync.
 	 */
-	function runZedSync(dryRun: boolean): { ok: boolean; message: string } {
+	async function runZedSync(dryRun: boolean): Promise<{ ok: boolean; message: string }> {
 		const available = getAvailableModels();
-		const outcome = computeModelExposure(available, buildExposureConfig());
+		const outcome = computeModelExposure(available, await buildExposureConfig());
 		if (!outcome.ok) {
 			return { ok: false, message: `Model exposure error: ${outcome.message}` };
 		}
@@ -634,19 +679,19 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 		return { ok: true, message: `${prefix}${result.summary} (${result.configPath})` };
 	}
 
-	function handleZedSync(ctx: ExtensionContext, args: string): void {
+	async function handleZedSync(ctx: ExtensionContext, args: string): Promise<void> {
 		config = loadConfigFromFile();
 		const dryRun = args.includes("--dry-run");
-		const result = runZedSync(dryRun);
+		const result = await runZedSync(dryRun);
 		ctx.ui.notify(`Zed sync: ${result.message}`, result.ok ? "info" : "error");
 	}
 
 	/**
 	 * Trigger auto-sync to Zed if enabled. Called after config save.
 	 */
-	function maybeAutoSyncZed(ctx: ExtensionContext): void {
+	async function maybeAutoSyncZed(ctx: ExtensionContext): Promise<void> {
 		if (!config.zed.autoSync) return;
-		const result = runZedSync(false);
+		const result = await runZedSync(false);
 		if (result.ok) {
 			ctx.ui.notify(`Zed auto-sync: ${result.message}`, "info");
 		}
@@ -1106,7 +1151,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 							settingsList.updateValue("customModels", customModelsDisplay());
 						}
 
-						maybeAutoSyncZed(ctx);
+						void maybeAutoSyncZed(ctx);
 						tui.requestRender();
 					},
 					() => done(undefined),

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@victor-software-house/pi-openai-proxy",
-	"version": "4.9.3",
+	"version": "4.9.5",
 	"description": "OpenAI-compatible HTTP proxy for pi's multi-provider model registry",
 	"license": "MIT",
 	"author": "Victor Software House",
@@ -28,6 +28,7 @@
 	"engines": {
 		"node": ">=20"
 	},
+	"packageManager": "pnpm@11.0.0-dev.1005",
 	"type": "module",
 	"exports": {
 		".": {
@@ -60,7 +61,7 @@
 		"build": "tsdown",
 		"start": "bun dist/index.mjs",
 		"typecheck": "tsc --noEmit",
-		"lint": "bun run lint:biome && bun run lint:oxlint",
+		"lint": "pnpm run lint:biome && pnpm run lint:oxlint",
 		"lint:biome": "biome check .",
 		"lint:oxlint": "oxlint --import-plugin --type-aware --tsconfig=./tsconfig.json .",
 		"lint:fix": "biome check --write .",
@@ -68,36 +69,37 @@
 		"test": "bun test",
 		"test:ci": "bun test test/unit/ test/integration/",
 		"prepare": "tsdown",
-		"prepack": "bun run build",
-		"prepublishOnly": "bun test && bun run build"
+		"prepack": "pnpm run build",
+		"prepublishOnly": "pnpm test && pnpm run build"
 	},
 	"dependencies": {
-		"@mariozechner/pi-ai": "^0.63.1",
-		"@mariozechner/pi-coding-agent": "^0.63.1",
-		"@sinclair/typebox": "^0.34.0",
-		"citty": "^0.1.6",
-		"hono": "^4.12.8",
+		"@mariozechner/pi-ai": "^0.73.0",
+		"@mariozechner/pi-coding-agent": "^0.73.0",
+		"@mariozechner/pi-tui": "^0.73.0",
+		"citty": "^0.2.2",
+		"hono": "^4.12.18",
 		"jsonc-parser": "^3.3.1",
-		"zod": "^4.3.6"
+		"zod": "^4.4.3"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^2.4.8",
-		"@commitlint/cli": "^20.5.0",
-		"@commitlint/config-conventional": "^20.5.0",
+		"@biomejs/biome": "^2.4.14",
+		"@commitlint/cli": "^20.5.3",
+		"@commitlint/config-conventional": "^20.5.3",
 		"@limegrass/eslint-plugin-import-alias": "^1.6.1",
 		"@semantic-release/changelog": "^6.0.3",
 		"@semantic-release/git": "^10.0.1",
 		"@semantic-release/github": "^12.0.6",
 		"@semantic-release/npm": "^13.1.5",
-		"@types/bun": "^1.3.11",
-		"@types/node": "^25.5.0",
-		"eslint-plugin-zod": "^3.5.0",
-		"lefthook": "^2.1.4",
-		"openai": "^6.26.0",
-		"oxlint": "^1.56.0",
-		"oxlint-tsgolint": "^0.17.1",
+		"@types/bun": "^1.3.13",
+		"@types/node": "^25.6.0",
+		"eslint-plugin-zod": "^3.12.0",
+		"lefthook": "^2.1.6",
+		"openai": "^6.36.0",
+		"oxlint": "^1.63.0",
+		"oxlint-tsgolint": "^0.22.1",
 		"semantic-release": "^25.0.3",
-		"tsdown": "^0.21.4",
-		"typescript": "^5.9.3"
+		"tsdown": "^0.21.10",
+		"typebox": "^1.1.38",
+		"typescript": "^6.0.3"
 	}
 }