oh-my-opencode 5.0.0-beta.10 → 5.0.0-beta.12

package/packages/lsp-core/src/lsp/client-wrapper-outside-cwd.test.ts

@@ -0,0 +1,78 @@
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "bun:test";
+
+import { createStandaloneMcpRequestContext, runWithRequestContext } from "../request-context.js";
+import { findWorkspaceRoot, resolveReadablePathInsideContext, resolvePathInsideContext } from "./client-wrapper.js";
+import { LspInvalidPathError } from "./errors.js";
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+function tempRoot(prefix: string): string {
+	const root = mkdtempSync(join(tmpdir(), prefix));
+	tempDirectories.push(root);
+	return root;
+}
+
+describe("LSP read-only access outside request cwd", () => {
+	it("#given an absolute file outside cwd #when resolving a read path #then returns the canonical path", () => {
+		const root = tempRoot("lsp-outcwd-root-");
+		const outside = tempRoot("lsp-outcwd-outside-");
+		const outsideFile = join(outside, "probe.ts");
+		writeFileSync(outsideFile, "export const value = 1;\n");
+
+		const resolved = runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+			resolveReadablePathInsideContext(outsideFile),
+		);
+
+		expect(resolved).toBe(realpathSync(outsideFile));
+	});
+
+	it("#given an outside file inside its own marked project #when inferring workspace #then uses that project root", () => {
+		const root = tempRoot("lsp-outcwd-marker-root-");
+		const outside = tempRoot("lsp-outcwd-marker-outside-");
+		mkdirSync(join(outside, ".git"), { recursive: true });
+		mkdirSync(join(outside, "src"), { recursive: true });
+		const outsideFile = join(outside, "src", "probe.ts");
+		writeFileSync(outsideFile, "export const value = 1;\n");
+
+		const workspace = runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+			findWorkspaceRoot(outsideFile),
+		);
+
+		expect(workspace).toBe(realpathSync(outside));
+	});
+
+	it("#given an outside file without any marker #when inferring workspace #then falls back to its own directory", () => {
+		const root = tempRoot("lsp-outcwd-nomarker-root-");
+		const outside = tempRoot("lsp-outcwd-nomarker-outside-");
+		const outsideFile = join(outside, "probe.ts");
+		writeFileSync(outsideFile, "export const value = 1;\n");
+
+		const workspace = runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+			findWorkspaceRoot(outsideFile),
+		);
+
+		expect(workspace).toBe(realpathSync(outside));
+	});
+
+	it("#given an outside file #when resolving a mutating path #then still rejects to keep writes confined", () => {
+		const root = tempRoot("lsp-outcwd-write-root-");
+		const outside = tempRoot("lsp-outcwd-write-outside-");
+		const outsideFile = join(outside, "probe.ts");
+		writeFileSync(outsideFile, "export const value = 1;\n");
+
+		expect(() =>
+			runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+				resolvePathInsideContext(outsideFile),
+			),
+		).toThrow(LspInvalidPathError);
+	});
+});

package/packages/lsp-core/src/lsp/client-wrapper.test.ts

@@ -36,17 +36,17 @@ describe("LSP client path confinement", () => {
 		expect(workspace).toBe(realpathSync(root));
 	});
 
-	it("#given an absolute file outside context cwd #when resolving #then rejects before workspace inference", () => {
+	it("#given an absolute file outside context cwd #when resolving #then infers the file's own project root", () => {
 		const root = tempRoot("lsp-client-wrapper-cwd-");
 		const outside = tempRoot("lsp-client-wrapper-outside-");
 		mkdirSync(join(outside, ".git"), { recursive: true });
 		writeFileSync(join(outside, "file.ts"), "export const outside = true;\n");
 
-		expect(() =>
-			runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
-				findWorkspaceRoot(join(outside, "file.ts")),
-			),
-		).toThrow(LspInvalidPathError);
+		const workspace = runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+			findWorkspaceRoot(join(outside, "file.ts")),
+		);
+
+		expect(workspace).toBe(realpathSync(outside));
 	});
 
 	it("#given a symlink inside cwd that points outside #when resolving read path #then keeps lexical path and cwd root", () => {

package/packages/lsp-core/src/lsp/client-wrapper.ts

@@ -16,11 +16,11 @@ import {
 	LspServerLookupError,
 } from "./errors.js";
 import { getLspManager, type LspManager } from "./manager.js";
+import { findWorkspaceRootOutsideContext } from "./outside-context-workspace.js";
 import { loadInstallDecision } from "./server-install-state.js";
 import { findServerForExtension } from "./server-resolution.js";
 import type { ServerLookupResult } from "./types.js";
-
-const WORKSPACE_MARKERS = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
+import { WORKSPACE_MARKERS } from "./workspace-markers.js";
 
 export function isDirectoryPath(filePath: string): boolean {
 	try {
@@ -39,6 +39,8 @@ export function findWorkspaceRoot(filePath: string): string {
 		dir = dirname(dir);
 	}
 
+	if (!isPathInside(cwd, abs)) return findWorkspaceRootOutsideContext(dir);
+
 	const fallbackRoot = nearestExistingDirectoryInsideContext(dir, cwd) ?? cwd;
 	while (isPathInside(cwd, dir)) {
 		const canonicalDir = existingDirectoryInsideContext(dir, cwd);
@@ -64,10 +66,7 @@ export function resolveReadablePathInsideContext(filePath: string): string {
 	const rebased = rebaseThroughCanonicalAncestor(abs, cwd);
 	if (rebased !== undefined) return rebased;
 
-	const canonical = canonicalizeExistingOrNearestAncestor(abs);
-	if (isPathInside(cwd, canonical)) return canonical;
-
-	throw new LspInvalidPathError(`LSP file path must be inside request cwd: ${filePath}`);
+	return canonicalizeExistingOrNearestAncestor(abs);
 }
 
 export function resolvePathInsideContext(filePath: string): string {

package/packages/lsp-core/src/lsp/outside-context-workspace.ts

@@ -0,0 +1,33 @@
+import { existsSync, realpathSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import { WORKSPACE_MARKERS } from "./workspace-markers.js";
+
+/** Read-only tools accept out-of-cwd files, so cwd cannot bound this search; the fallback keeps the server scoped to the file's own directory. */
+export function findWorkspaceRootOutsideContext(directory: string): string {
+	const marked = nearestMarkedAncestor(directory);
+	if (marked !== undefined) return marked;
+	return realpathSync(nearestExistingAncestor(directory));
+}
+
+function nearestMarkedAncestor(directory: string): string | undefined {
+	let current = directory;
+	for (;;) {
+		if (existsSync(current) && WORKSPACE_MARKERS.some((marker) => existsSync(join(current, marker)))) {
+			return realpathSync(current);
+		}
+		const parent = dirname(current);
+		if (parent === current) return undefined;
+		current = parent;
+	}
+}
+
+function nearestExistingAncestor(directory: string): string {
+	let current = directory;
+	while (!existsSync(current)) {
+		const parent = dirname(current);
+		if (parent === current) return current;
+		current = parent;
+	}
+	return current;
+}

package/packages/lsp-core/src/lsp/workspace-markers.ts

@@ -0,0 +1 @@
+export const WORKSPACE_MARKERS = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"] as const;

package/packages/lsp-daemon/dist/cli.js

@@ -4,8 +4,8 @@
 import { argv, stderr } from "node:process";
 
 // src/proxy.ts
-import { existsSync as existsSync12, realpathSync as realpathSync5 } from "node:fs";
-import { basename as basename4, delimiter as delimiter4, dirname as dirname9, isAbsolute as isAbsolute5 } from "node:path";
+import { existsSync as existsSync13, realpathSync as realpathSync6 } from "node:fs";
+import { basename as basename4, delimiter as delimiter4, dirname as dirname10, isAbsolute as isAbsolute5 } from "node:path";
 
 // ../mcp-stdio-core/src/record.ts
 function isPlainRecord(value) {
@@ -315,8 +315,8 @@ function createIdleTimer(idleTimeoutMs, log, onTimeout) {
   };
 }
 // ../lsp-core/src/lsp/client-wrapper.ts
-import { existsSync as existsSync9, realpathSync as realpathSync4, statSync as statSync3 } from "node:fs";
-import { basename as basename3, dirname as dirname6, join as join4, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync10, realpathSync as realpathSync5, statSync as statSync3 } from "node:fs";
+import { basename as basename3, dirname as dirname7, join as join5, resolve as resolve7 } from "node:path";
 
 // ../lsp-core/src/request-context.ts
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -3500,15 +3500,52 @@ async function disposeDefaultLspManager() {
   }
 }
 
+// ../lsp-core/src/lsp/outside-context-workspace.ts
+import { existsSync as existsSync6, realpathSync as realpathSync4 } from "node:fs";
+import { dirname as dirname5, join as join3 } from "node:path";
+
+// ../lsp-core/src/lsp/workspace-markers.ts
+var WORKSPACE_MARKERS = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
+
+// ../lsp-core/src/lsp/outside-context-workspace.ts
+function findWorkspaceRootOutsideContext(directory) {
+  const marked = nearestMarkedAncestor(directory);
+  if (marked !== undefined)
+    return marked;
+  return realpathSync4(nearestExistingAncestor(directory));
+}
+function nearestMarkedAncestor(directory) {
+  let current = directory;
+  for (;; ) {
+    if (existsSync6(current) && WORKSPACE_MARKERS.some((marker) => existsSync6(join3(current, marker)))) {
+      return realpathSync4(current);
+    }
+    const parent = dirname5(current);
+    if (parent === current)
+      return;
+    current = parent;
+  }
+}
+function nearestExistingAncestor(directory) {
+  let current = directory;
+  while (!existsSync6(current)) {
+    const parent = dirname5(current);
+    if (parent === current)
+      return current;
+    current = parent;
+  }
+  return current;
+}
+
 // ../lsp-core/src/lsp/server-install-state.ts
-import { existsSync as existsSync6, mkdirSync, readFileSync as readFileSync3, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname5 } from "node:path";
+import { existsSync as existsSync7, mkdirSync, readFileSync as readFileSync3, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname6 } from "node:path";
 function getInstallDecisionsPath() {
   return lspRequestContext().installDecisionsPath;
 }
 function loadInstallDecisions() {
   const path = getInstallDecisionsPath();
-  if (!existsSync6(path))
+  if (!existsSync7(path))
     return {};
   try {
     const parsed = JSON.parse(readFileSync3(path, "utf8"));
@@ -3530,7 +3567,7 @@ function isInstallDecision(value) {
 }
 function writeInstallDecisions(decisions) {
   const path = getInstallDecisionsPath();
-  mkdirSync(dirname5(path), { recursive: true });
+  mkdirSync(dirname6(path), { recursive: true });
   const tmpPath = `${path}.tmp`;
   writeFileSync2(tmpPath, `${JSON.stringify(decisions, null, 2)}
 `, "utf8");
@@ -3549,7 +3586,7 @@ function isRecord5(value) {
 }
 
 // ../lsp-core/src/lsp/config-loader.ts
-import { existsSync as existsSync7, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync4 } from "node:fs";
 
 // ../lsp-core/src/lsp/server-definitions.ts
 var LSP_INSTALL_HINTS = {
@@ -3706,7 +3743,7 @@ function getUserConfigPath() {
   return lspRequestContext().userConfigPath;
 }
 function loadJsonFile(path) {
-  if (!existsSync7(path))
+  if (!existsSync8(path))
     return null;
   try {
     const parsed = JSON.parse(readFileSync4(path, "utf-8"));
@@ -3894,8 +3931,8 @@ function getDisabledServerIds() {
 }
 
 // ../lsp-core/src/lsp/server-installation.ts
-import { existsSync as existsSync8 } from "node:fs";
-import { delimiter as delimiter3, join as join3 } from "node:path";
+import { existsSync as existsSync9 } from "node:fs";
+import { delimiter as delimiter3, join as join4 } from "node:path";
 function isServerInstalled(command, _workingDirectory) {
   if (command.length === 0)
     return false;
@@ -3903,7 +3940,7 @@ function isServerInstalled(command, _workingDirectory) {
   if (!cmd)
     return false;
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync8(cmd))
+    if (existsSync9(cmd))
       return true;
   }
   const isWindows = process.platform === "win32";
@@ -3924,7 +3961,7 @@ function isServerInstalled(command, _workingDirectory) {
   const paths = pathEnv.split(delimiter3);
   for (const p of paths) {
     for (const suffix of exts) {
-      if (existsSync8(join3(p, cmd + suffix))) {
+      if (existsSync9(join4(p, cmd + suffix))) {
         return true;
       }
     }
@@ -4020,7 +4057,6 @@ function getAllServers() {
 }
 
 // ../lsp-core/src/lsp/client-wrapper.ts
-var WORKSPACE_MARKERS = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
 function isDirectoryPath(filePath) {
   try {
     return statSync3(filePath).isDirectory();
@@ -4033,21 +4069,23 @@ function findWorkspaceRoot(filePath) {
   const abs = resolveReadablePathInsideContext(filePath);
   let dir = abs;
   if (!isDirectoryPath(dir)) {
-    dir = dirname6(dir);
+    dir = dirname7(dir);
   }
+  if (!isPathInside(cwd, abs))
+    return findWorkspaceRootOutsideContext(dir);
   const fallbackRoot = nearestExistingDirectoryInsideContext(dir, cwd) ?? cwd;
   while (isPathInside(cwd, dir)) {
     const canonicalDir = existingDirectoryInsideContext(dir, cwd);
     if (canonicalDir !== undefined) {
       for (const marker of WORKSPACE_MARKERS) {
-        if (existsSync9(join4(dir, marker))) {
+        if (existsSync10(join5(dir, marker))) {
           return canonicalDir;
         }
       }
     }
     if (dir === cwd)
       break;
-    dir = dirname6(dir);
+    dir = dirname7(dir);
   }
   return fallbackRoot;
 }
@@ -4059,10 +4097,7 @@ function resolveReadablePathInsideContext(filePath) {
   const rebased = rebaseThroughCanonicalAncestor(abs, cwd);
   if (rebased !== undefined)
     return rebased;
-  const canonical = canonicalizeExistingOrNearestAncestor(abs);
-  if (isPathInside(cwd, canonical))
-    return canonical;
-  throw new LspInvalidPathError(`LSP file path must be inside request cwd: ${filePath}`);
+  return canonicalizeExistingOrNearestAncestor(abs);
 }
 function resolvePathInsideContext(filePath) {
   const cwd = contextCwd();
@@ -4077,12 +4112,12 @@ function rebaseThroughCanonicalAncestor(path, cwd) {
   let current = path;
   const suffix = [];
   while (true) {
-    if (existsSync9(current)) {
-      const canonical = realpathSync4(current);
+    if (existsSync10(current)) {
+      const canonical = realpathSync5(current);
       if (isPathInside(cwd, canonical))
-        return suffix.length === 0 ? canonical : join4(canonical, ...suffix);
+        return suffix.length === 0 ? canonical : join5(canonical, ...suffix);
     }
-    const parent = dirname6(current);
+    const parent = dirname7(current);
     if (parent === current)
       return;
     suffix.unshift(basename3(current));
@@ -4090,9 +4125,9 @@ function rebaseThroughCanonicalAncestor(path, cwd) {
   }
 }
 function existingDirectoryInsideContext(directory, cwd) {
-  if (!existsSync9(directory))
+  if (!existsSync10(directory))
     return;
-  const canonical = realpathSync4(directory);
+  const canonical = realpathSync5(directory);
   if (!statSync3(canonical).isDirectory())
     return;
   return isPathInside(cwd, canonical) ? canonical : undefined;
@@ -4105,7 +4140,7 @@ function nearestExistingDirectoryInsideContext(directory, cwd) {
       return canonical;
     if (current === cwd)
       return;
-    current = dirname6(current);
+    current = dirname7(current);
   }
   return;
 }
@@ -4223,8 +4258,8 @@ async function withLspClient(filePath, fn, toolName, options = {}) {
 }
 
 // ../lsp-core/src/lsp/directory-diagnostics.ts
-import { existsSync as existsSync10, lstatSync as lstatSync4, readdirSync as readdirSync3 } from "node:fs";
-import { join as join5, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync11, lstatSync as lstatSync4, readdirSync as readdirSync3 } from "node:fs";
+import { join as join6, resolve as resolve8 } from "node:path";
 
 // ../lsp-core/src/lsp/formatters.ts
 import { fileURLToPath as fileURLToPath2 } from "node:url";
@@ -4354,7 +4389,7 @@ function collectFilesWithExtension(dir, extension, maxFiles) {
     for (const entry of entries) {
       if (files.length >= maxFiles)
         return;
-      const fullPath = join5(currentDir, entry);
+      const fullPath = join6(currentDir, entry);
       let stat;
       try {
         stat = lstatSync4(fullPath);
@@ -4380,7 +4415,7 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
     throw new LspInvalidPathError(`Extension must start with a dot (e.g., ".ts", not "${extension}"). Use ".${extension}" instead.`);
   }
   const absDir = resolve8(options.workspaceRoot ?? contextCwd(), directory);
-  if (!existsSync10(absDir)) {
+  if (!existsSync11(absDir)) {
     throw new LspInvalidPathError(`Directory does not exist: ${absDir}`);
   }
   const serverResult = options.server === undefined ? findServerForExtension(extension) : { status: "found", server: options.server };
@@ -4467,7 +4502,7 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
 
 // ../lsp-core/src/lsp/infer-extension.ts
 import { lstatSync as lstatSync5, readdirSync as readdirSync4 } from "node:fs";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 var SKIP_DIRECTORIES2 = new Set(["node_modules", ".git", "dist", "build", ".next", "out"]);
 var MAX_SCAN_ENTRIES = 500;
 function inferExtensionFromDirectory(directory) {
@@ -4485,7 +4520,7 @@ function inferExtensionFromDirectory(directory) {
     for (const entry of entries) {
       if (scanned >= MAX_SCAN_ENTRIES)
         return;
-      const fullPath = join6(dir, entry);
+      const fullPath = join7(dir, entry);
       let stat;
       try {
         stat = lstatSync5(fullPath);
@@ -5167,7 +5202,7 @@ function requestedProtocolVersion(params) {
 // src/daemon-client.ts
 import { connect } from "node:net";
 import { homedir as homedir3 } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 
 // src/daemon-request-error.ts
 class DaemonRequestError extends Error {
@@ -5246,9 +5281,9 @@ function errorText(error) {
 
 // src/ensure-daemon.ts
 import { spawn as spawn2 } from "node:child_process";
-import { closeSync as closeSync2, existsSync as existsSync11, mkdirSync as mkdirSync3, openSync as openSync2, writeSync as writeSync2 } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync12, mkdirSync as mkdirSync3, openSync as openSync2, writeSync as writeSync2 } from "node:fs";
 import { Socket } from "node:net";
-import { dirname as dirname8, isAbsolute as isAbsolute4 } from "node:path";
+import { dirname as dirname9, isAbsolute as isAbsolute4 } from "node:path";
 import { argv0, execPath } from "node:process";
 
 // src/ipc-protocol.ts
@@ -5266,7 +5301,7 @@ import {
   unlinkSync,
   writeSync
 } from "node:fs";
-import { dirname as dirname7 } from "node:path";
+import { dirname as dirname8 } from "node:path";
 var OMO_DAEMON_PROTOCOL_VERSION = 1;
 var AUTH_ERROR_CODE = -32001;
 var PROTOCOL_ERROR_CODE = -32002;
@@ -5376,7 +5411,7 @@ function setPrivateFileMode(path) {
     chmodSync(path, 384);
 }
 function createAuthToken(paths) {
-  ensurePrivateDirectory(dirname7(paths.auth));
+  ensurePrivateDirectory(dirname8(paths.auth));
   const token = randomBytes(AUTH_TOKEN_BYTES).toString("base64url");
   let fd;
   try {
@@ -5716,7 +5751,7 @@ function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS, signal) {
   });
 }
 function spawnDaemonProcess(paths) {
-  mkdirSync3(dirname8(paths.log), { recursive: true });
+  mkdirSync3(dirname9(paths.log), { recursive: true });
   const logFd = openSync2(paths.log, "a");
   try {
     const child = spawn2(resolveDaemonNodeExecutable(), [paths.cliPath, "daemon"], {
@@ -5735,7 +5770,7 @@ function spawnDaemonProcess(paths) {
     throw error;
   }
 }
-function resolveDaemonNodeExecutable(cachedExecPath = execPath, originalArgv0 = argv0, pathExists = existsSync11) {
+function resolveDaemonNodeExecutable(cachedExecPath = execPath, originalArgv0 = argv0, pathExists = existsSync12) {
   if (pathExists(cachedExecPath))
     return cachedExecPath;
   if (isAbsolute4(originalArgv0) && pathExists(originalArgv0))
@@ -5955,9 +5990,9 @@ function currentRequestContext(env = process.env) {
   const home = env["HOME"] ?? homedir3();
   return parseLspRequestContext({
     cwd,
-    projectConfigPaths: [join7(cwd, ".codex", "lsp-client.json")],
-    userConfigPath: join7(home, ".codex", "lsp-client.json"),
-    installDecisionsPath: join7(home, ".codex", "lsp-install-decisions.json"),
+    projectConfigPaths: [join8(cwd, ".codex", "lsp-client.json")],
+    userConfigPath: join8(home, ".codex", "lsp-client.json"),
+    installDecisionsPath: join8(home, ".codex", "lsp-install-decisions.json"),
     capabilities: { installDecisionTool: true }
   });
 }
@@ -6212,18 +6247,18 @@ function canonicalizePathList(value) {
   return value.split(delimiter4).map((entry) => canonicalizePath(entry) ?? entry).join(delimiter4);
 }
 function canonicalizePath(value) {
-  if (value === undefined || !isAbsolute5(value) || !existsSync12(value))
+  if (value === undefined || !isAbsolute5(value) || !existsSync13(value))
     return value;
-  return realpathSync5(value);
+  return realpathSync6(value);
 }
 function projectRootFromOpenCodeConfigPath(path2) {
   if (basename4(path2) !== "lsp.json" && basename4(path2) !== "lsp-client.json")
     return;
-  const configDir = dirname9(path2);
+  const configDir = dirname10(path2);
   const configDirName = basename4(configDir);
   if (configDirName !== ".opencode" && configDirName !== ".omo")
     return;
-  return dirname9(configDir);
+  return dirname10(configDir);
 }
 
 // src/daemon-server.ts
@@ -6232,12 +6267,12 @@ import { createServer as createServer2 } from "node:net";
 
 // src/ownership.ts
 import { randomUUID } from "node:crypto";
-import { existsSync as existsSync13, lstatSync as lstatSync7, readFileSync as readFileSync7, statSync as statSync5, unlinkSync as unlinkSync3 } from "node:fs";
-import { dirname as dirname11 } from "node:path";
+import { existsSync as existsSync14, lstatSync as lstatSync7, readFileSync as readFileSync7, statSync as statSync5, unlinkSync as unlinkSync3 } from "node:fs";
+import { dirname as dirname12 } from "node:path";
 
 // src/lock.ts
 import { closeSync as closeSync3, mkdirSync as mkdirSync4, openSync as openSync3, readFileSync as readFileSync6, unlinkSync as unlinkSync2, writeSync as writeSync3 } from "node:fs";
-import { dirname as dirname10 } from "node:path";
+import { dirname as dirname11 } from "node:path";
 function isProcessAlive2(pid) {
   if (!Number.isInteger(pid) || pid <= 0)
     return false;
@@ -6259,7 +6294,7 @@ function readLockPid(lockPath) {
   }
 }
 function tryAcquireLock(lockPath, ownerPid = process.pid) {
-  mkdirSync4(dirname10(lockPath), { recursive: true });
+  mkdirSync4(dirname11(lockPath), { recursive: true });
   for (let attempt = 0;attempt < 2; attempt += 1) {
     const handle = writeLockFile(lockPath, ownerPid);
     if (handle)
@@ -6340,7 +6375,7 @@ async function acquireStartupLease(paths, pingOwner) {
 function ensureDaemonDirectories(paths) {
   ensurePrivateDirectory(paths.dir);
   if (process.platform !== "win32")
-    ensurePrivateDirectory(dirname11(paths.socket));
+    ensurePrivateDirectory(dirname12(paths.socket));
 }
 function readDaemonOwner(paths) {
   try {
@@ -6420,7 +6455,7 @@ async function validateExistingOwner(paths, pingOwner) {
   throw new DaemonStartupDeferredError("reachable_owner_mismatch");
 }
 function cleanupDeadOwner(paths, owner) {
-  if (process.platform !== "win32" && existsSync13(owner.endpoint.path)) {
+  if (process.platform !== "win32" && existsSync14(owner.endpoint.path)) {
     const stat = lstatSync7(owner.endpoint.path);
     if (stat.isSocket())
       unlinkSync3(owner.endpoint.path);
@@ -6471,7 +6506,7 @@ function parseEndpoint(value) {
 // src/version-reap.ts
 import { execFile } from "node:child_process";
 import { readdir, readFile, rm } from "node:fs/promises";
-import { basename as basename5, dirname as dirname12, join as join8 } from "node:path";
+import { basename as basename5, dirname as dirname13, join as join9 } from "node:path";
 var TERM_GRACE_MS = 5000;
 var KILL_GRACE_MS = 1000;
 var VERSION_ENTRY_PATTERN = /^v([A-Za-z0-9][A-Za-z0-9._+-]{0,127})$/;
@@ -6492,7 +6527,7 @@ async function attestDaemonCliProcess(pid, platform, deps = {}) {
   return isNodeCliDaemonCommand(command.trim());
 }
 async function reapStaleDaemonVersions(ownPaths, deps = {}) {
-  const baseDir = dirname12(ownPaths.dir);
+  const baseDir = dirname13(ownPaths.dir);
   const platform = deps.platform ?? process.platform;
   const isAlive = deps.isAlive ?? isProcessAlive2;
   const attest = deps.attest ?? ((pid) => attestDaemonCliProcess(pid, platform));
@@ -6511,7 +6546,7 @@ async function reapStaleDaemonVersions(ownPaths, deps = {}) {
     const version = parseVersionEntry(entry.name);
     if (version === null || !entry.isDirectory())
       continue;
-    const versionDir = join8(baseDir, entry.name);
+    const versionDir = join9(baseDir, entry.name);
     const siblingPaths = daemonPaths({ [OMO_LSP_DAEMON_DIR]: baseDir }, { cliPath: ownPaths.cliPath, version });
     results.push(await reapOneVersion({
       version,
@@ -6535,7 +6570,7 @@ async function reapOneVersion(context) {
   const { version, versionDir } = context;
   const owner = context.readOwner(context.siblingPaths);
   if (!owner) {
-    const lockPid = readLockPid(join8(versionDir, "daemon.lock"));
+    const lockPid = readLockPid(join9(versionDir, "daemon.lock"));
     if (lockPid !== null && context.isAlive(lockPid)) {
       context.log(`reap: sparing v${version}: owner metadata missing but daemon.lock is held by live pid ${lockPid}`);
       return { version, status: "spared", reason: `owner metadata missing but lock held by live pid ${lockPid}` };