@oh-my-pi/pi-coding-agent 13.6.0 → 13.6.2

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [13.6.2] - 2026-03-03
+### Fixed
+
+- Fixed LM Studio API key retrieval to use configured provider name instead of hardcoded 'lm-studio'
+- Fixed resource content handling to properly check for empty text values (null/undefined)
+- Fixed resource refresh tracking to prevent stale promise reuse when server connection changes
+- Fixed update target resolution to properly handle cases where binary path cannot be resolved
+
+## [13.6.1] - 2026-03-03
+
+### Fixed
+
+- Fixed `omp update` silently succeeding without actually updating the binary when the update channel (bun global vs compiled binary) doesn't match the installation method ([#247](https://github.com/can1357/oh-my-pi/issues/247))
+- Added post-update verification that checks the resolved `omp` binary reports the expected version, with actionable warnings on mismatch
+- `omp update` now detects when the `omp` in PATH is not managed by bun and falls back to binary replacement instead of updating the wrong location
 ## [13.6.0] - 2026-03-03
 ### Added
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "13.6.0",
+	"version": "13.6.2",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -41,12 +41,12 @@
 	},
 	"dependencies": {
 		"@mozilla/readability": "^0.6",
-		"@oh-my-pi/omp-stats": "13.6.0",
-		"@oh-my-pi/pi-agent-core": "13.6.0",
-		"@oh-my-pi/pi-ai": "13.6.0",
-		"@oh-my-pi/pi-natives": "13.6.0",
-		"@oh-my-pi/pi-tui": "13.6.0",
-		"@oh-my-pi/pi-utils": "13.6.0",
+		"@oh-my-pi/omp-stats": "13.6.2",
+		"@oh-my-pi/pi-agent-core": "13.6.2",
+		"@oh-my-pi/pi-ai": "13.6.2",
+		"@oh-my-pi/pi-natives": "13.6.2",
+		"@oh-my-pi/pi-tui": "13.6.2",
+		"@oh-my-pi/pi-utils": "13.6.2",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.18",

package/src/cli/update-cli.ts

@@ -4,29 +4,20 @@
  * Handles `omp update` to check for and install updates.
  * Uses bun if available, otherwise downloads binary from GitHub releases.
  */
-import { execSync, spawnSync } from "node:child_process";
 import * as fs from "node:fs";
+import * as path from "node:path";
 import { pipeline } from "node:stream/promises";
 import { APP_NAME, isEnoent, VERSION } from "@oh-my-pi/pi-utils";
+import { $ } from "bun";
 import chalk from "chalk";
 import { theme } from "../modes/theme/theme";
 
-/**
- * Detect if we're running as a Bun compiled binary.
- */
-const isBunBinary =
-	Bun.env.PI_COMPILED ||
-	import.meta.url.includes("$bunfs") ||
-	import.meta.url.includes("~BUN") ||
-	import.meta.url.includes("%7EBUN");
-
 const REPO = "can1357/oh-my-pi";
 const PACKAGE = "@oh-my-pi/pi-coding-agent";
 
 interface ReleaseInfo {
 	tag: string;
 	version: string;
-	assets: Array<{ name: string; url: string }>;
 }
 
 /**
@@ -44,16 +35,54 @@ export function parseUpdateArgs(args: string[]): { force: boolean; check: boolea
 	};
 }
 
-/**
- * Check if bun is available in PATH.
- */
-function hasBun(): boolean {
+async function getBunGlobalBinDir(): Promise<string | undefined> {
+	if (!Bun.which("bun")) return undefined;
 	try {
-		const result = spawnSync("bun", ["--version"], { encoding: "utf-8", stdio: "pipe" });
-		return result.status === 0;
+		const result = await $`bun pm bin -g`.quiet().nothrow();
+		if (result.exitCode !== 0) return undefined;
+		const output = result.text().trim();
+		return output.length > 0 ? output : undefined;
 	} catch {
-		return false;
+		return undefined;
+	}
+}
+
+function normalizePathForComparison(filePath: string): string {
+	const normalized = path.normalize(filePath);
+	if (process.platform === "win32") return normalized.toLowerCase();
+	return normalized;
+}
+
+function isPathInDirectory(filePath: string, directoryPath: string): boolean {
+	const normalizedPath = normalizePathForComparison(path.resolve(filePath));
+	const normalizedDirectory = normalizePathForComparison(path.resolve(directoryPath));
+	const relativePath = path.relative(normalizedDirectory, normalizedPath);
+	return relativePath === "" || (!relativePath.startsWith("..") && !path.isAbsolute(relativePath));
+}
+
+type UpdateTarget = { method: "bun" } | { method: "binary"; path: string };
+
+function resolveUpdateMethod(ompPath: string, bunBinDir: string | undefined): "bun" | "binary" {
+	if (!bunBinDir) return "binary";
+	return isPathInDirectory(ompPath, bunBinDir) ? "bun" : "binary";
+}
+
+export function _resolveUpdateMethodForTest(ompPath: string, bunBinDir: string | undefined): "bun" | "binary" {
+	return resolveUpdateMethod(ompPath, bunBinDir);
+}
+async function resolveUpdateTarget(): Promise<UpdateTarget> {
+	const bunBinDir = await getBunGlobalBinDir();
+	const ompPath = resolveOmpPath();
+
+	if (ompPath) {
+		const method = resolveUpdateMethod(ompPath, bunBinDir);
+		if (method === "bun") return { method };
+		return { method, path: ompPath };
 	}
+
+	if (bunBinDir) return { method: "bun" };
+
+	throw new Error(`Could not resolve ${APP_NAME} binary path in PATH`);
 }
 
 /**
@@ -70,15 +99,9 @@ async function getLatestRelease(): Promise<ReleaseInfo> {
 	const version = data.version;
 	const tag = `v${version}`;
 
-	// Construct deterministic GitHub release download URLs for the current platform
-	const makeAsset = (name: string) => ({
-		name,
-		url: `https://github.com/${REPO}/releases/download/${tag}/${name}`,
-	});
 	return {
 		tag,
 		version,
-		assets: [makeAsset(getBinaryName())],
 	};
 }
 
@@ -140,60 +163,93 @@ function getBinaryName(): string {
 	return `${APP_NAME}-${os}-${archName}`;
 }
 
+/**
+ * Resolve the path that `omp` maps to in the user's PATH.
+ */
+function resolveOmpPath(): string | undefined {
+	return Bun.which(APP_NAME) ?? undefined;
+}
+
+/**
+ * Run the resolved omp binary and check if it reports the expected version.
+ */
+async function verifyInstalledVersion(
+	expectedVersion: string,
+): Promise<{ ok: boolean; actual?: string; path?: string }> {
+	const ompPath = resolveOmpPath();
+	if (!ompPath) return { ok: false };
+	try {
+		const result = await $`${ompPath} --version`.quiet().nothrow();
+		if (result.exitCode !== 0) return { ok: false, path: ompPath };
+		const output = result.text().trim();
+		// Output format: "omp/X.Y.Z"
+		const match = output.match(/\/(\d+\.\d+\.\d+)/);
+		const actual = match?.[1];
+		return { ok: actual === expectedVersion, actual, path: ompPath };
+	} catch {
+		return { ok: false, path: ompPath };
+	}
+}
+
+/**
+ * Print post-update verification result.
+ */
+async function printVerification(expectedVersion: string): Promise<void> {
+	const result = await verifyInstalledVersion(expectedVersion);
+	if (result.ok) {
+		console.log(chalk.green(`\n${theme.status.success} Updated to ${expectedVersion}`));
+		return;
+	}
+	if (result.actual) {
+		console.log(
+			chalk.yellow(
+				`\nWarning: ${APP_NAME} at ${result.path} still reports ${result.actual} (expected ${expectedVersion})`,
+			),
+		);
+	} else {
+		console.log(
+			chalk.yellow(`\nWarning: could not verify updated version${result.path ? ` at ${result.path}` : ""}`),
+		);
+	}
+	console.log(
+		chalk.yellow(
+			`You may need to reinstall: curl -fsSL https://raw.githubusercontent.com/${REPO}/main/install.sh | bash`,
+		),
+	);
+}
+
 /**
  * Update via bun package manager.
  */
 async function updateViaBun(expectedVersion: string): Promise<void> {
 	console.log(chalk.dim("Updating via bun..."));
-	try {
-		execSync(`bun install -g ${PACKAGE}@${expectedVersion}`, { stdio: "inherit" });
-	} catch (error) {
-		throw new Error("bun install failed", { cause: error });
+	const result = await $`bun install -g ${PACKAGE}@${expectedVersion}`.nothrow();
+	if (result.exitCode !== 0) {
+		throw new Error(`bun install failed with exit code ${result.exitCode}`);
 	}
 
-	// Verify the update actually took effect
-	try {
-		const result = spawnSync("bun", ["pm", "ls", "-g"], { encoding: "utf-8", stdio: "pipe" });
-		const output = result.stdout || "";
-		const match = output.match(new RegExp(`${PACKAGE.replace("/", "\\/")}@(\\S+)`));
-		if (match) {
-			const installedVersion = match[1];
-			if (compareVersions(installedVersion, expectedVersion) < 0) {
-				console.log(
-					chalk.yellow(`\nWarning: bun reports ${installedVersion} installed, expected ${expectedVersion}`),
-				);
-				console.log(chalk.yellow(`Try: bun install -g ${PACKAGE}@latest`));
-				return;
-			}
-		}
-	} catch {
-		// Verification is best-effort, don't fail the update
-	}
-	console.log(chalk.green(`\n${theme.status.success} Update complete`));
+	await printVerification(expectedVersion);
 }
 
 /**
- * Update by downloading binary from GitHub releases.
+ * Download a release binary to a target path, replacing an existing file.
  */
-async function updateViaBinary(release: ReleaseInfo): Promise<void> {
+async function updateViaBinaryAt(targetPath: string, expectedVersion: string): Promise<void> {
 	const binaryName = getBinaryName();
-	const asset = release.assets.find(a => a.name === binaryName);
-	if (!asset) {
-		throw new Error(`No binary found for ${binaryName}`);
-	}
-	const execPath = process.execPath;
-	const tempPath = `${execPath}.new`;
-	const backupPath = `${execPath}.bak`;
+	const tag = `v${expectedVersion}`;
+	const url = `https://github.com/${REPO}/releases/download/${tag}/${binaryName}`;
+
+	const tempPath = `${targetPath}.new`;
+	const backupPath = `${targetPath}.bak`;
 	console.log(chalk.dim(`Downloading ${binaryName}…`));
 
-	// Download binary to temp file
-	const response = await fetch(asset.url, { redirect: "follow" });
+	const response = await fetch(url, { redirect: "follow" });
 	if (!response.ok || !response.body) {
 		throw new Error(`Download failed: ${response.statusText}`);
 	}
 	const fileStream = fs.createWriteStream(tempPath, { mode: 0o755 });
 	await pipeline(response.body, fileStream);
-	// Replace current binary
+
 	console.log(chalk.dim("Installing update..."));
 	try {
 		try {
@@ -201,15 +257,15 @@ async function updateViaBinary(release: ReleaseInfo): Promise<void> {
 		} catch (err) {
 			if (!isEnoent(err)) throw err;
 		}
-		await fs.promises.rename(execPath, backupPath);
-		await fs.promises.rename(tempPath, execPath);
+		await fs.promises.rename(targetPath, backupPath);
+		await fs.promises.rename(tempPath, targetPath);
 		await fs.promises.unlink(backupPath);
 
-		console.log(chalk.green(`\n${theme.status.success} Updated to ${release.version}`));
+		await printVerification(expectedVersion);
 		console.log(chalk.dim(`Restart ${APP_NAME} to use the new version`));
 	} catch (err) {
-		if (fs.existsSync(backupPath) && !fs.existsSync(execPath)) {
-			await fs.promises.rename(backupPath, execPath);
+		if (fs.existsSync(backupPath) && !fs.existsSync(targetPath)) {
+			await fs.promises.rename(backupPath, targetPath);
 		}
 		if (fs.existsSync(tempPath)) {
 			await fs.promises.unlink(tempPath);
@@ -251,12 +307,13 @@ export async function runUpdateCommand(opts: { force: boolean; check: boolean })
 		return;
 	}
 
-	// Choose update method
+	// Choose update method based on the prioritized omp binary in PATH
 	try {
-		if (!isBunBinary && hasBun()) {
+		const target = await resolveUpdateTarget();
+		if (target.method === "bun") {
 			await updateViaBun(release.version);
 		} else {
-			await updateViaBinary(release);
+			await updateViaBinaryAt(target.path, release.version);
 		}
 	} catch (err) {
 		console.error(chalk.red(`Update failed: ${err}`));

package/src/config/model-registry.ts

@@ -6,13 +6,11 @@ import {
 	DEFAULT_LOCAL_TOKEN,
 	getBundledModels,
 	getBundledProviders,
-	getGitHubCopilotBaseUrl,
 	googleAntigravityModelManagerOptions,
 	googleGeminiCliModelManagerOptions,
 	type Model,
 	type ModelManagerOptions,
 	type ModelRefreshStrategy,
-	normalizeDomain,
 	type OAuthCredentials,
 	type OAuthLoginCallbacks,
 	openaiCodexModelManagerOptions,
@@ -539,17 +537,7 @@ export class ModelRegistry {
 		const builtInModels = this.#loadBuiltInModels(overrides, modelOverrides);
 		const combined = this.#mergeCustomModels(builtInModels, customModels);
 
-		// Update github-copilot base URL based on OAuth credentials
-		const copilotCred = this.authStorage.getOAuthCredential("github-copilot");
-		if (copilotCred) {
-			const domain = copilotCred.enterpriseUrl
-				? (normalizeDomain(copilotCred.enterpriseUrl) ?? undefined)
-				: undefined;
-			const baseUrl = getGitHubCopilotBaseUrl(copilotCred.access, domain);
-			this.#models = combined.map(m => (m.provider === "github-copilot" ? { ...m, baseUrl } : m));
-		} else {
-			this.#models = combined;
-		}
+		this.#models = combined;
 	}
 
 	/** Load built-in models, applying provider and per-model overrides */
@@ -895,7 +883,7 @@ export class ModelRegistry {
 		const modelsUrl = `${baseUrl}/models`;
 
 		const headers: Record<string, string> = { ...(providerConfig.headers ?? {}) };
-		const apiKey = await this.authStorage.getApiKey("lm-studio");
+		const apiKey = await this.authStorage.getApiKey(providerConfig.provider);
 		if (apiKey && apiKey !== DEFAULT_LOCAL_TOKEN && apiKey !== kNoAuth) {
 			headers.Authorization = `Bearer ${apiKey}`;
 		}

package/src/internal-urls/mcp-protocol.ts

@@ -137,14 +137,14 @@ export class McpProtocolHandler implements ProtocolHandler {
 
 		const textParts: string[] = [];
 		for (const item of result.contents) {
-			if (item.text) {
+			if (item.text !== undefined && item.text !== null) {
 				textParts.push(item.text);
 			} else if (item.blob) {
 				textParts.push(`[Binary content: ${item.mimeType ?? "unknown"}, base64 length ${item.blob.length}]`);
 			}
 		}
 
-		const content = textParts.join("\n---\n") || "(empty resource)";
+		const content = textParts.length > 0 ? textParts.join("\n---\n") : "(empty resource)";
 		return {
 			url: url.href,
 			content,

package/src/mcp/manager.ts

@@ -126,7 +126,7 @@ export class MCPManager {
 	#notificationsEnabled = false;
 	#notificationsEpoch = 0;
 	#subscribedResources = new Map<string, Set<string>>();
-	#pendingResourceRefresh = new Map<string, Promise<void>>();
+	#pendingResourceRefresh = new Map<string, { connection: MCPServerConnection; promise: Promise<void> }>();
 
 	constructor(
 		private cwd: string,
@@ -590,6 +590,7 @@ export class MCPManager {
 		this.#pendingConnections.delete(name);
 		this.#pendingToolLoads.delete(name);
 		this.#sources.delete(name);
+		this.#pendingResourceRefresh.delete(name);
 
 		const connection = this.#connections.get(name);
 
@@ -622,6 +623,7 @@ export class MCPManager {
 
 		this.#pendingConnections.clear();
 		this.#pendingToolLoads.clear();
+		this.#pendingResourceRefresh.clear();
 		this.#sources.clear();
 		this.#connections.clear();
 		this.#tools = [];
@@ -660,13 +662,13 @@ export class MCPManager {
 	 * Refresh resources from a specific server.
 	 */
 	async refreshServerResources(name: string): Promise<void> {
+		const connection = this.#connections.get(name);
+		if (!connection || !serverSupportsResources(connection.capabilities)) return;
+
 		const existing = this.#pendingResourceRefresh.get(name);
-		if (existing) return existing;
+		if (existing && existing.connection === connection) return existing.promise;
 
 		const doRefresh = async (): Promise<void> => {
-			const connection = this.#connections.get(name);
-			if (!connection || !serverSupportsResources(connection.capabilities)) return;
-
 			// Clear cached resources
 			connection.resources = undefined;
 			connection.resourceTemplates = undefined;
@@ -716,11 +718,12 @@ export class MCPManager {
 		};
 
 		const promise = doRefresh().finally(() => {
-			if (this.#pendingResourceRefresh.get(name) === promise) {
+			const pending = this.#pendingResourceRefresh.get(name);
+			if (pending?.promise === promise) {
 				this.#pendingResourceRefresh.delete(name);
 			}
 		});
-		this.#pendingResourceRefresh.set(name, promise);
+		this.#pendingResourceRefresh.set(name, { connection, promise });
 		return promise;
 	}
 

package/src/mcp/smithery-registry.ts

@@ -1,3 +1,4 @@
+import { logger } from "@oh-my-pi/pi-utils";
 import type { MCPServerConfig } from "./types";
 
 const SMITHERY_REGISTRY_BASE_URL = "https://registry.smithery.ai";
@@ -324,8 +325,12 @@ async function fetchServerDetailsFromEntry(
 ): Promise<SmitheryServerDetails | null> {
 	const candidates = resolveDetailPathCandidates(entry);
 	for (const candidate of candidates) {
-		const details = await fetchServerDetails(candidate, options);
-		if (details) return details;
+		try {
+			const details = await fetchServerDetails(candidate, options);
+			if (details) return details;
+		} catch (error) {
+			logger.debug("Smithery detail fetch candidate failed", { candidate, error: String(error) });
+		}
 	}
 	return null;
 }
@@ -439,14 +444,31 @@ export async function searchSmitheryRegistry(
 		);
 	});
 
+	const detailFailures: Array<{ identity: string; error: string }> = [];
 	const results = await Promise.all(
 		uniqueEntries.map(async entry => {
-			const details = await fetchServerDetailsFromEntry(entry, { apiKey: options?.apiKey });
-			if (!details) return null;
-			return toSearchResult(entry, details);
+			try {
+				const details = await fetchServerDetailsFromEntry(entry, { apiKey: options?.apiKey });
+				if (!details) return null;
+				return toSearchResult(entry, details);
+			} catch (error) {
+				detailFailures.push({
+					identity: getEntryIdentityKey(entry) ?? entry.id ?? "unknown",
+					error: String(error),
+				});
+				return null;
+			}
 		}),
 	);
 
+	if (detailFailures.length > 0) {
+		logger.warn("Smithery detail fetch failed for some entries", {
+			query,
+			failedEntries: detailFailures.length,
+			totalEntries: uniqueEntries.length,
+			sample: detailFailures.slice(0, 3),
+		});
+	}
 	return results.filter((result): result is SmitherySearchResult => result !== null).slice(0, limit);
 }