@oh-my-pi/pi-utils 18.4.11 → 18.5.0

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [18.5.0] - 2026-10-03
+
+### Added
+
+- Added the public `getSessionOwnersDir()` utility, which returns the profile-independent `~/.omp/run/session-owners` directory that names session ownership leases ([#14095](https://github.com/can1357/oh-my-pi/pull/14095) by [@andrebrait](https://github.com/andrebrait))
+
+### Fixed
+
+- Fixed SQLite error messages doubling every backslash in Windows database paths
+- Fixed corrupt-database recovery failing with `EBUSY` on Windows when several in-process openers of the same store failed at once
+
+## [18.4.12] - 2026-10-02
+
+### Fixed
+
+- Fixed multi-second temp directory removal stalls on Windows by forcing a major GC before the first deletion retry ([#13044](https://github.com/can1357/oh-my-pi/pull/13044) by [@jchanghong023](https://github.com/jchanghong023)).
+
 ## [18.4.11] - 2026-10-02
 
 ### Added

package/dist/types/dirs.d.ts

@@ -322,6 +322,12 @@ export declare function getDaemonRuntimeDir(projectDir: string): string;
 export declare function getGlobalDaemonRuntimeRoot(): string;
 /** Get a profile-independent runtime directory for a machine-global daemon service. */
 export declare function getGlobalDaemonRuntimeDir(service: string): string;
+/**
+ * Directory naming session ownership leases (~/.omp/run/session-owners; XDG
+ * default: $XDG_STATE_HOME/omp/run/session-owners). Shared across profiles:
+ * every omp process that opens a session must meet the same lease.
+ */
+export declare function getSessionOwnersDir(): string;
 /** Get the provider in-flight root directory (~/.omp/run/provider-inflight; XDG default: $XDG_STATE_HOME/omp/run/provider-inflight). */
 export declare function getProviderInFlightRoot(): string;
 /** Get the marketplaces registry path (~/.omp/marketplaces.json; XDG default: $XDG_DATA_HOME/omp/marketplaces.json). Adopts a legacy registry on first XDG resolution. */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-utils",
-	"version": "18.4.11",
+	"version": "18.5.0",
 	"description": "Shared utilities for pi packages",
 	"keywords": [
 		"cli",
@@ -57,7 +57,7 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "18.4.11"
+		"@oh-my-pi/pi-natives": "18.5.0"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/dirs.ts

@@ -1095,6 +1095,15 @@ export function getGlobalDaemonRuntimeDir(service: string): string {
 	return path.join(getGlobalDaemonRuntimeRoot(), service);
 }
 
+/**
+ * Directory naming session ownership leases (~/.omp/run/session-owners; XDG
+ * default: $XDG_STATE_HOME/omp/run/session-owners). Shared across profiles:
+ * every omp process that opens a session must meet the same lease.
+ */
+export function getSessionOwnersDir(): string {
+	return dirs.baseRootSubdir(path.join("run", "session-owners"), "state");
+}
+
 /** Get the provider in-flight root directory (~/.omp/run/provider-inflight; XDG default: $XDG_STATE_HOME/omp/run/provider-inflight). */
 export function getProviderInFlightRoot(): string {
 	return dirs.rootSubdir(path.join("run", "provider-inflight"), "state");

package/src/sqlite.ts

@@ -1,6 +1,7 @@
 /** Shared SQLite opening, error attribution, and result-code classification for persistent stores. */
 import { Database } from "bun:sqlite";
 import * as fs from "node:fs";
+import * as path from "node:path";
 import { getDbBusyTimeoutMs } from "./env";
 import { withFileLockSync } from "./file-lock";
 import { isEnoent } from "./fs-error";
@@ -12,6 +13,55 @@ const SQLITE_STORE_SUFFIXES = ["-wal", "-shm", "-journal", ""];
 
 type SqliteFileIdentity = string | null | undefined;
 
+/**
+ * Corrupt handles held open by in-process openers awaiting recovery, keyed by
+ * resolved store path. Windows refuses to unlink a file any handle still holds,
+ * so the opener that quarantines the store closes its peers' dead handles too.
+ */
+const pendingCorruptHandles = new Map<string, Set<Database>>();
+
+function corruptHandleKey(dbPath: string): string {
+	const resolved = path.resolve(dbPath);
+	return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+
+function registerCorruptHandle(dbPath: string, db: Database | undefined): void {
+	if (!db) return;
+	const key = corruptHandleKey(dbPath);
+	let handles = pendingCorruptHandles.get(key);
+	if (!handles) {
+		handles = new Set();
+		pendingCorruptHandles.set(key, handles);
+	}
+	handles.add(db);
+}
+
+function unregisterCorruptHandle(dbPath: string, db: Database | undefined): void {
+	if (!db) return;
+	const key = corruptHandleKey(dbPath);
+	const handles = pendingCorruptHandles.get(key);
+	if (!handles) return;
+	handles.delete(db);
+	if (handles.size === 0) pendingCorruptHandles.delete(key);
+}
+
+/** Closes peers' failed handles on the store; each peer still closes (idempotently) and adopts on its own path. */
+function closePeerCorruptHandles(dbPath: string, own: Database | undefined): void {
+	const handles = pendingCorruptHandles.get(corruptHandleKey(dbPath));
+	if (!handles) return;
+	for (const peer of handles) {
+		if (peer === own) continue;
+		try {
+			peer.close();
+		} catch (error) {
+			logger.warn("Failed to close a peer's corrupt SQLite handle before quarantine", {
+				path: dbPath,
+				error: String(error),
+			});
+		}
+	}
+}
+
 class SqliteAttemptFailure extends Error {
 	readonly original: unknown;
 	readonly identity: SqliteFileIdentity;
@@ -99,6 +149,7 @@ async function openWithBusyRetries<T>(
 		} catch (caught) {
 			const error = options.recoverCorruption ? revealHiddenCorruption(db, caught) : caught;
 			if (options.recoverCorruption && isSqliteCorruptionError(error)) {
+				registerCorruptHandle(dbPath, db);
 				throw new SqliteAttemptFailure(error, identity, { db });
 			}
 			closeFailedDatabase(db, error, identity);
@@ -120,6 +171,7 @@ function openOnce<T>(dbPath: string, initialize: (db: Database) => T, options: S
 	} catch (caught) {
 		const error = options.recoverCorruption ? revealHiddenCorruption(db, caught) : caught;
 		if (options.recoverCorruption && isSqliteCorruptionError(error)) {
+			registerCorruptHandle(dbPath, db);
 			throw new SqliteAttemptFailure(error, identity, { db });
 		}
 		closeFailedDatabase(db, error, identity);
@@ -143,6 +195,10 @@ function quarantineCorruptSqliteStore(dbPath: string, db: Database | undefined):
 		}
 	}
 	db?.close();
+	// Only Windows refuses to unlink a file another handle still holds. Elsewhere
+	// each peer must keep its own handle until it closes it after adopting the
+	// replacement; closing it here races the peer's recovery on POSIX.
+	if (process.platform === "win32") closePeerCorruptHandles(dbPath, db);
 
 	const removed: string[] = [];
 	try {
@@ -199,6 +255,7 @@ function recoverCorruptDatabase(dbPath: string, error: unknown, options: SqliteO
 				return quarantineCorruptSqliteStore(dbPath, failure.db);
 			});
 		} finally {
+			unregisterCorruptHandle(dbPath, failure.db);
 			closeFailedDatabase(failure.db, failure.original, failure.identity);
 		}
 	} catch (preservationError) {
@@ -267,7 +324,7 @@ export function openSqliteDatabaseSync<T>(
 /** Adds the failing store's path to an error without losing SQLite result codes or its original stack. */
 export function annotateSqliteError(error: unknown, dbPath: string): Error {
 	const annotated = error instanceof Error ? error : new Error(String(error));
-	annotated.message = `Database ${JSON.stringify(dbPath)}: ${annotated.message}`;
+	annotated.message = `Database "${dbPath}": ${annotated.message}`;
 	return annotated;
 }
 

package/src/temp.ts

@@ -94,6 +94,11 @@ export async function removeWithRetries(target: string): Promise<void> {
 			return;
 		} catch (err) {
 			if (!shouldRetryRemove(err, attempt)) throw err;
+			// bun on Windows finalizes SQLite's db/-wal/-shm file and directory
+			// handles on GC, so a closed database can still block deletion for
+			// seconds. One forced major collection on the first retry releases
+			// them immediately instead of burning the retry window.
+			if (attempt === 0) Bun.gc(true);
 			await Bun.sleep(kRemoveRetryDelayMs);
 		}
 	}
@@ -106,6 +111,7 @@ export function removeSyncWithRetries(target: string): void {
 			return;
 		} catch (err) {
 			if (!shouldRetryRemove(err, attempt)) throw err;
+			if (attempt === 0) Bun.gc(true);
 			sleepSync(kRemoveRetryDelayMs);
 		}
 	}