@chatcode/chatcode-cli 3.0.4-rc.2 → 3.0.4-rc.4

package/runtime/node_modules/@deepseek-ai/dsh-atomic-write/lib/index.js

@@ -1,45 +1,252 @@
 import { createHash, randomBytes } from "node:crypto";
-import { lstat, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
+import { link, lstat, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, win32 } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { closeSync, constants, fstatSync, lstatSync, openSync, readFileSync } from "node:fs";
+import { constants as constants$1 } from "node:os";
+//#region lib/types/windows-lock.js
+/** Exclusive Windows inspection for an empty or zero-filled lock left by a failed creator. */
+const execute = promisify(execFile);
+/**
+* Read a small lock only when no other handle has the file open.
+* @param path - lock path, protected by the caller's takeover claim.
+* @returns its record, or undefined if exclusive access or inspection fails.
+*/
+async function readUnopenedWindowsLock(path) {
+	const powershell = win32.join(process.env.SystemRoot ?? "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+	const script = [
+		"$ErrorActionPreference = 'Stop'",
+		`$file = [IO.File]::Open('${path.replaceAll("'", "''")}', [IO.FileMode]::Open, [IO.FileAccess]::Read, [IO.FileShare]::None)`,
+		"try {",
+		"  if ($file.Length -gt 64) { exit 1 }",
+		"  $reader = [IO.StreamReader]::new($file, [Text.Encoding]::UTF8, $false)",
+		"  try { [Console]::Out.Write([Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($reader.ReadToEnd()))) }",
+		"  finally { $reader.Dispose() }",
+		"} finally { $file.Dispose() }"
+	].join("\n");
+	try {
+		const { stdout } = await execute(powershell, [
+			"-NoLogo",
+			"-NoProfile",
+			"-NonInteractive",
+			"-EncodedCommand",
+			Buffer.from(script, "utf16le").toString("base64")
+		], {
+			encoding: "utf8",
+			windowsHide: true,
+			timeout: 2e3,
+			maxBuffer: 4096,
+			env: Object.fromEntries(Object.entries(process.env).filter(([name]) => !/KEY|SECRET|TOKEN|PASSWORD/i.test(name)))
+		});
+		const value = stdout.trim();
+		const bytes = Buffer.from(value, "base64");
+		if (bytes.length > 64 || bytes.toString("base64") !== value) return void 0;
+		return bytes.toString("utf8");
+	} catch (error) {
+		return;
+	}
+}
+//#endregion
+//#region lib/types/linux-native.js
+/** Lazy Linux file-lease inspection for incomplete legacy writer records. */
+let bindings;
+const F_SETOWN = 8;
+const F_SETSIG = 10;
+const F_SETLEASE = 1024;
+const F_GETLEASE = 1025;
+const F_RDLCK = 0;
+const SC_CLK_TCK = 2;
+async function linux() {
+	return bindings ??= (async () => {
+		const libc = (await import("koffi")).default.load(null);
+		const fcntl = libc.func("fcntl", "int", [
+			"int",
+			"int",
+			"int"
+		]);
+		const sysconf = libc.func("sysconf", "long", ["int"]);
+		return {
+			fcntl,
+			clockTicks: () => sysconf(SC_CLK_TCK)
+		};
+	})();
+}
+/**
+* Read the Linux userspace clock-tick rate used by /proc process start times.
+* @returns ticks per second, or undefined when libc cannot supply the rate.
+*/
+async function linuxClockTicks() {
+	try {
+		const value = (await linux()).clockTicks();
+		return Number.isSafeInteger(value) && value > 0 ? value : void 0;
+	} catch (error) {
+		return;
+	}
+}
+/**
+* Read a small regular lock only after the kernel excludes open writers.
+* @param path - existing lock path protected by the caller's takeover claim.
+* @returns the unchanged inode's contents, or undefined when inspection is inconclusive.
+*/
+async function readClosedLinuxLock(path) {
+	let fd;
+	try {
+		const api = await linux();
+		fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+		const held = fstatSync(fd);
+		if (!held.isFile() || held.size > 128) return void 0;
+		if (api.fcntl(fd, F_SETSIG, constants$1.signals.SIGURG) !== 0) return void 0;
+		if (api.fcntl(fd, F_SETLEASE, F_RDLCK) !== 0) return void 0;
+		if (api.fcntl(fd, F_SETOWN, 0) !== 0) return void 0;
+		const record = readFileSync(fd, "utf8");
+		const current = lstatSync(path);
+		if (current.dev !== held.dev || current.ino !== held.ino || api.fcntl(fd, F_GETLEASE, 0) !== F_RDLCK) return void 0;
+		return record;
+	} catch (error) {
+		return;
+	} finally {
+		if (fd !== void 0) closeSync(fd);
+	}
+}
+//#endregion
+//#region lib/types/linux-lock.js
+/** Linux writer identity and complete-record publication; other platforms retain PID records. */
+const RECORD = /^(\d+)\r?\n(?:linux ([a-f0-9-]{36}) (\d+) ([a-f0-9]{24})\n)?$/u;
+let ownIdentity;
+/** Read kernel identity without treating inaccessible procfs as evidence of an exited writer. */
+async function identity(pid) {
+	try {
+		const [boot, stat] = await Promise.all([readFile("/proc/sys/kernel/random/boot_id", "utf8"), readFile(`/proc/${pid}/stat`, "utf8")]);
+		const end = stat.lastIndexOf(")");
+		const fields = end < 0 ? [] : stat.slice(end + 2).trim().split(/\s+/u);
+		const start = fields[19];
+		if (!/^[a-f0-9-]{36}$/u.test(boot.trim()) || start === void 0 || !/^\d+$/u.test(start)) return void 0;
+		return {
+			id: `${boot.trim()} ${start}`,
+			start: Number(start),
+			state: fields[0] ?? ""
+		};
+	} catch (error) {
+		return;
+	}
+}
+/**
+* Render a new acquisition's record; Linux adds boot identity, start ticks, and a unique claim token.
+* @returns the PID record, with Linux identity when the kernel exposes it.
+*/
+async function writerLockRecord() {
+	const pid = `${process.pid}\n`;
+	if (process.platform !== "linux") return pid;
+	const current = await (ownIdentity ??= identity(process.pid).then((value) => value?.id));
+	return current === void 0 ? pid : `${pid}linux ${current} ${randomBytes(12).toString("hex")}\n`;
+}
+/**
+* Exclusively publish a complete Linux identity record, or create a legacy PID lock.
+* @param path - lock sibling in an existing parent directory.
+* @param record - one acquisition's record from writerLockRecord.
+*/
+async function createWriterLock(path, record) {
+	const nonce = RECORD.exec(record)?.[4];
+	if (process.platform !== "linux" || nonce === void 0) {
+		await writeFile(path, record, {
+			mode: 384,
+			flag: "wx"
+		});
+		return;
+	}
+	const temp = `${path}.${randomBytes(12).toString("hex")}.tmp`;
+	try {
+		await writeFile(temp, record, {
+			mode: 384,
+			flag: "wx"
+		});
+		await link(temp, path);
+	} finally {
+		try {
+			await rm(temp, { force: true });
+		} catch (error) {}
+	}
+}
+/**
+* Determine whether a recorded writer exited, including Linux PID reuse and a previous boot.
+* @param record - untrusted contents of an existing lock file.
+* @param path - optional lock path for checking legacy PID records against process creation.
+* @returns true for an exited process, changed Linux identity, or a legacy record predating its current process.
+*/
+async function writerExited(record, path) {
+	const match = RECORD.exec(record);
+	if (match === null) return false;
+	const pid = Number(match[1]);
+	if (pid === 0 || pid > 2147483647) return false;
+	if (pid !== process.pid) try {
+		process.kill(pid, 0);
+	} catch (error) {
+		return error.code === "ESRCH";
+	}
+	if (process.platform !== "linux") return false;
+	const current = await identity(pid);
+	if (current === void 0) return false;
+	if (current.state === "Z" || current.state === "X") return true;
+	if (match[2] !== void 0) return current.id !== `${match[2]} ${match[3]}`;
+	if (path === void 0) return false;
+	try {
+		const [metadata, kernelStat, ticks] = await Promise.all([
+			stat(path),
+			readFile("/proc/stat", "utf8"),
+			linuxClockTicks()
+		]);
+		const bootSeconds = /^btime (\d+)$/mu.exec(kernelStat)?.[1];
+		if (bootSeconds === void 0 || ticks === void 0) return false;
+		return Number(bootSeconds) * 1e3 + current.start / ticks * 1e3 > Math.max(metadata.mtimeMs, metadata.ctimeMs, metadata.birthtimeMs) + 2e3;
+	} catch (error) {
+		return false;
+	}
+}
+//#endregion
 //#region lib/types/index.js
 /**
-* Zero-dependency atomic file replacement and writer coordination.
+* Atomic file replacement and writer coordination.
 * `writeFileAtomic` writes a random-suffix sibling with exclusive create and
 * the caller's permission bits, then renames it over the target, so readers
 * observe either the old or the new complete content and a replaced file ends
 * up with exactly the stated mode. `withFileLock` serializes cross-process
-* writers of one file through a `wx`-created `<file>.lock` sibling, so a
+* writers of one file through an exclusively published `<file>.lock` sibling, so a
 * read-modify-write cycle can never resurrect a state another writer just
 * replaced; readers stay lock-free because the rename commit is atomic. A lock
-* whose recorded holder process no longer exists is taken over.
+* whose recorded holder process no longer exists is taken over. Windows also
+* recovers empty or zero-filled records after an exclusive read proves no
+* creator still has the lock file open. Linux uses a read lease to exclude
+* unfinished writers, and kernel process identity to distinguish a previous
+* boot, reused PID, or zombie process.
 * @module @deepseek-ai/dsh-atomic-write
 */
-const WINDOWS_TRANSIENT_RENAME_ERRORS = new Set([
+const WINDOWS_TRANSIENT_FILE_ERRORS = new Set([
 	"EACCES",
 	"EBUSY",
 	"EPERM"
 ]);
-const WINDOWS_RENAME_RETRY_INITIAL_MS = 20;
-const WINDOWS_RENAME_RETRY_MAX_MS = 200;
-const WINDOWS_RENAME_RETRY_LIMIT = 8;
+const WINDOWS_FILE_RETRY_INITIAL_MS = 20;
+const WINDOWS_FILE_RETRY_MAX_MS = 200;
+const WINDOWS_FILE_RETRY_LIMIT = 8;
 /** Whether Windows reported temporary interference with an atomic replacement. */
-function isTransientWindowsRenameError(error) {
+function isTransientWindowsFileError(error) {
 	if (process.platform !== "win32") return false;
-	return WINDOWS_TRANSIENT_RENAME_ERRORS.has(error?.code ?? "");
+	return WINDOWS_TRANSIENT_FILE_ERRORS.has(error?.code ?? "");
 }
-/** Replace the target after bounded retries for transient Windows interference. */
-async function renameAtomicTemp(temp, filename) {
-	let delay = WINDOWS_RENAME_RETRY_INITIAL_MS;
+/** Retry a replacement or lock release while Windows briefly holds the path open. */
+async function retryWindowsFileOperation(operation) {
+	let delay = WINDOWS_FILE_RETRY_INITIAL_MS;
 	for (let retries = 0;; retries += 1) {
 		try {
-			await rename(temp, filename);
+			await operation();
 			return;
 		} catch (error) {
-			if (!isTransientWindowsRenameError(error)) throw error;
-			if (retries >= WINDOWS_RENAME_RETRY_LIMIT) throw error;
+			if (!isTransientWindowsFileError(error)) throw error;
+			if (retries >= WINDOWS_FILE_RETRY_LIMIT) throw error;
 		}
 		await new Promise((resolve) => setTimeout(resolve, delay));
-		delay = Math.min(delay * 2, WINDOWS_RENAME_RETRY_MAX_MS);
+		delay = Math.min(delay * 2, WINDOWS_FILE_RETRY_MAX_MS);
 	}
 }
 /**
@@ -69,7 +276,7 @@ async function writeFileAtomic(filename, content, options) {
 			mode: options.mode,
 			flag: "wx"
 		});
-		await renameAtomicTemp(temp, filename);
+		await retryWindowsFileOperation(() => rename(temp, filename));
 	} catch (error) {
 		await rm(temp, { force: true });
 		throw error;
@@ -87,18 +294,13 @@ async function isLockContention(error, lockPath) {
 		return false;
 	}
 }
-/** Whether the holder a `<pid>\n` record names is proven gone: a signal probe finds no such process. */
-function holderExited(record) {
-	if (!/^\d+\n$/.test(record)) return false;
-	const pid = Number(record.trim());
-	if (pid === 0 || pid > 2147483647) return false;
-	if (pid === process.pid) return false;
-	try {
-		process.kill(pid, 0);
-		return false;
-	} catch (error) {
-		return error.code === "ESRCH";
-	}
+/** Whether the recorded writer is absent or has a different observable Linux identity. */
+async function holderExited(record, path) {
+	return writerExited(record, path);
+}
+/** A crash can leave an empty or zero-filled record before the holder's PID reaches disk. */
+function damagedRecord(record, limit = 64) {
+	return record.length <= limit && /^\0*$/.test(record);
 }
 /** The lock file's content, or undefined when it cannot be read. */
 async function readLockRecord(lockPath) {
@@ -109,31 +311,38 @@ async function readLockRecord(lockPath) {
 	}
 }
 /**
-* Remove the lock when its recorded holder exited. Contenders that read the
+* Remove an exited holder's lock or a closed, damaged Windows or Linux lock. Contenders that read the
 * same record serialize on a claim file named after it. Under the claim, the
 * claimant re-reads the lock and probes its PID again, and removes it only
-* when it still holds that record and that PID is still gone: the record's
+* when it still holds that record and that PID is still gone. A damaged
+* record instead requires kernel-backed inspection after claiming it. The record's
 * holder can no longer release it, and no other contender can remove it
 * without the claim, so a removal never deletes a lock another contender
 * acquired after the dead holder's, including one whose holder reused the PID.
-* @returns Whether this call removed the dead holder's lock.
+* @returns Whether this call removed the abandoned lock.
 */
 async function takeOverExitedLock(lockPath) {
 	const record = await readLockRecord(lockPath);
-	if (record === void 0 || !holderExited(record)) return false;
+	if (record === void 0) return false;
+	const damaged = (process.platform === "win32" || process.platform === "linux") && damagedRecord(record, process.platform === "linux" ? 128 : 64);
+	const partialLinuxPid = process.platform === "linux" && /^\d{1,10}$/u.test(record);
+	if (!damaged && !partialLinuxPid && !await holderExited(record, lockPath)) return false;
 	const claim = `${lockPath}.takeover-${createHash("sha256").update(record).digest("hex").slice(0, 16)}`;
 	try {
-		await writeFile(claim, `${process.pid}\n`, {
-			mode: 384,
-			flag: "wx"
-		});
+		await createWriterLock(claim, await writerLockRecord());
 	} catch (error) {
 		const code = error.code;
-		if (code === "EEXIST" || code === "EPERM") return false;
+		if (code === "EEXIST" || code === "EPERM") {
+			if (await takeOverExitedLock(claim)) return takeOverExitedLock(lockPath);
+			return false;
+		}
 		throw error;
 	}
 	try {
-		if (await readLockRecord(lockPath) !== record || !holderExited(record)) return false;
+		if (await readLockRecord(lockPath) !== record) return false;
+		if (damaged || partialLinuxPid) {
+			if ((process.platform === "win32" ? await readUnopenedWindowsLock(lockPath) : await readClosedLinuxLock(lockPath)) !== record) return false;
+		} else if (!await holderExited(record, lockPath)) return false;
 		try {
 			await rm(lockPath, { force: true });
 		} catch (error) {
@@ -163,7 +372,7 @@ const LOCK_RETRY_MAX_MS = 200;
 const DEFAULT_LOCK_WAIT_MS = 2e3;
 /**
 * Hold the cross-process writer lock for `filename` around one operation. The
-* lock is a `wx`-created sibling (`<filename>.lock`); paired with the
+* lock is an exclusively published sibling (`<filename>.lock`); paired with the
 * rename-based commit of {@link writeFileAtomic}, readers stay lock-free and
 * only writers contend. `EEXIST` is contention directly; an `EPERM` is
 * contention only when a fresh `lstat` confirms the lock path exists, covering
@@ -172,9 +381,17 @@ const DEFAULT_LOCK_WAIT_MS = 2e3;
 * permission error is rethrown. The lock records its holder's PID. A contender
 * removes the lock and retries at once when no process with that PID exists
 * (`ESRCH`); any other lock, including one whose holder exists under another
-* user (`EPERM`) or whose record is incomplete, is waited for. Contention backs
-* off exponentially and times out after the deadline. A holder whose PID a
-* live process reused keeps its lock until an operator removes it. Takeover
+* user (`EPERM`) or whose record is incomplete, is waited for. On Windows,
+* empty or zero-filled records of at most 64 bytes can also be recovered after
+* exclusive inspection proves no creator still has the file open. A failed
+* inspection preserves the lock. Linux also recovers empty or zero-filled
+* records of at most 128 bytes and unfinished PID records after a read lease
+* excludes open writers. Dead takeover claimants are recovered automatically.
+* Windows lock release retries transient file interference for a bounded interval. Contention backs
+* off exponentially and times out after the deadline. Linux identity records
+* distinguish PID reuse, a previous boot, and zombies. Legacy PID-only records
+* are recovered when the current process began after the lock's file timestamps.
+* Missing or inaccessible identity metadata never authorizes takeover. Takeover
 * proves only that the recorded process exited: an operation that starts other
 * writers must stop them with it or leave its successor a way to find them.
 * PIDs are compared on the contender's host, so writers on other hosts or in
@@ -187,15 +404,13 @@ const DEFAULT_LOCK_WAIT_MS = 2e3;
 */
 async function withFileLock(filename, operation, options) {
 	const lockPath = `${filename}.lock`;
+	const record = await writerLockRecord();
 	const deadline = Date.now() + (options?.waitMs ?? DEFAULT_LOCK_WAIT_MS);
 	let delay = LOCK_RETRY_INITIAL_MS;
 	let retriedUnconfirmedPermissionError = false;
 	for (;;) {
 		try {
-			await writeFile(lockPath, `${process.pid}\n`, {
-				mode: 384,
-				flag: "wx"
-			});
+			await createWriterLock(lockPath, record);
 			break;
 		} catch (error) {
 			if (!await isLockContention(error, lockPath)) {
@@ -203,14 +418,19 @@ async function withFileLock(filename, operation, options) {
 				retriedUnconfirmedPermissionError = true;
 			} else if (await takeOverExitedLock(lockPath)) continue;
 		}
-		if (Date.now() >= deadline) throw new Error(`atomic-write: timed out waiting for the writer lock at ${lockPath}`);
+		if (Date.now() >= deadline) {
+			const held = await readLockRecord(lockPath);
+			const pid = held === void 0 ? void 0 : /^(\d+)\r?\n/u.exec(held)?.[1];
+			const state = held === void 0 ? "unreadable" : held === "" ? "empty" : /^\0+$/u.test(held) ? `zero-filled, ${String(held.length)} bytes` : pid === void 0 ? `incomplete or unrecognized, ${String(held.length)} bytes` : `PID ${pid}`;
+			throw new Error(`atomic-write: timed out waiting for the writer lock at ${lockPath} (record: ${state})`);
+		}
 		await new Promise((resolve) => setTimeout(resolve, delay));
 		delay = Math.min(delay * 2, LOCK_RETRY_MAX_MS);
 	}
 	try {
 		return await operation();
 	} finally {
-		await rm(lockPath, { force: true });
+		await retryWindowsFileOperation(() => rm(lockPath, { force: true }));
 	}
 }
 //#endregion

package/runtime/node_modules/@deepseek-ai/dsh-atomic-write/lib/types/index.d.ts

@@ -1,13 +1,17 @@
 /**
- * Zero-dependency atomic file replacement and writer coordination.
+ * Atomic file replacement and writer coordination.
  * `writeFileAtomic` writes a random-suffix sibling with exclusive create and
  * the caller's permission bits, then renames it over the target, so readers
  * observe either the old or the new complete content and a replaced file ends
  * up with exactly the stated mode. `withFileLock` serializes cross-process
- * writers of one file through a `wx`-created `<file>.lock` sibling, so a
+ * writers of one file through an exclusively published `<file>.lock` sibling, so a
  * read-modify-write cycle can never resurrect a state another writer just
  * replaced; readers stay lock-free because the rename commit is atomic. A lock
- * whose recorded holder process no longer exists is taken over.
+ * whose recorded holder process no longer exists is taken over. Windows also
+ * recovers empty or zero-filled records after an exclusive read proves no
+ * creator still has the lock file open. Linux uses a read lease to exclude
+ * unfinished writers, and kernel process identity to distinguish a previous
+ * boot, reused PID, or zombie process.
  * @module @deepseek-ai/dsh-atomic-write
  */
 /**
@@ -58,7 +62,7 @@ export interface FileLockOptions {
 }
 /**
  * Hold the cross-process writer lock for `filename` around one operation. The
- * lock is a `wx`-created sibling (`<filename>.lock`); paired with the
+ * lock is an exclusively published sibling (`<filename>.lock`); paired with the
  * rename-based commit of {@link writeFileAtomic}, readers stay lock-free and
  * only writers contend. `EEXIST` is contention directly; an `EPERM` is
  * contention only when a fresh `lstat` confirms the lock path exists, covering
@@ -67,9 +71,17 @@ export interface FileLockOptions {
  * permission error is rethrown. The lock records its holder's PID. A contender
  * removes the lock and retries at once when no process with that PID exists
  * (`ESRCH`); any other lock, including one whose holder exists under another
- * user (`EPERM`) or whose record is incomplete, is waited for. Contention backs
- * off exponentially and times out after the deadline. A holder whose PID a
- * live process reused keeps its lock until an operator removes it. Takeover
+ * user (`EPERM`) or whose record is incomplete, is waited for. On Windows,
+ * empty or zero-filled records of at most 64 bytes can also be recovered after
+ * exclusive inspection proves no creator still has the file open. A failed
+ * inspection preserves the lock. Linux also recovers empty or zero-filled
+ * records of at most 128 bytes and unfinished PID records after a read lease
+ * excludes open writers. Dead takeover claimants are recovered automatically.
+ * Windows lock release retries transient file interference for a bounded interval. Contention backs
+ * off exponentially and times out after the deadline. Linux identity records
+ * distinguish PID reuse, a previous boot, and zombies. Legacy PID-only records
+ * are recovered when the current process began after the lock's file timestamps.
+ * Missing or inaccessible identity metadata never authorizes takeover. Takeover
  * proves only that the recorded process exited: an operation that starts other
  * writers must stop them with it or leave its successor a way to find them.
  * PIDs are compared on the contender's host, so writers on other hosts or in

package/runtime/node_modules/@deepseek-ai/dsh-atomic-write/lib/types/linux-lock.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Render a new acquisition's record; Linux adds boot identity, start ticks, and a unique claim token.
+ * @returns the PID record, with Linux identity when the kernel exposes it.
+ */
+export declare function writerLockRecord(): Promise<string>;
+/**
+ * Exclusively publish a complete Linux identity record, or create a legacy PID lock.
+ * @param path - lock sibling in an existing parent directory.
+ * @param record - one acquisition's record from writerLockRecord.
+ */
+export declare function createWriterLock(path: string, record: string): Promise<void>;
+/**
+ * Determine whether a recorded writer exited, including Linux PID reuse and a previous boot.
+ * @param record - untrusted contents of an existing lock file.
+ * @param path - optional lock path for checking legacy PID records against process creation.
+ * @returns true for an exited process, changed Linux identity, or a legacy record predating its current process.
+ */
+export declare function writerExited(record: string, path?: string): Promise<boolean>;
+//# sourceMappingURL=linux-lock.d.ts.map

package/runtime/node_modules/@deepseek-ai/dsh-atomic-write/lib/types/linux-native.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Read the Linux userspace clock-tick rate used by /proc process start times.
+ * @returns ticks per second, or undefined when libc cannot supply the rate.
+ */
+export declare function linuxClockTicks(): Promise<number | undefined>;
+/**
+ * Read a small regular lock only after the kernel excludes open writers.
+ * @param path - existing lock path protected by the caller's takeover claim.
+ * @returns the unchanged inode's contents, or undefined when inspection is inconclusive.
+ */
+export declare function readClosedLinuxLock(path: string): Promise<string | undefined>;
+//# sourceMappingURL=linux-native.d.ts.map

package/runtime/node_modules/@deepseek-ai/dsh-atomic-write/lib/types/windows-lock.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Read a small lock only when no other handle has the file open.
+ * @param path - lock path, protected by the caller's takeover claim.
+ * @returns its record, or undefined if exclusive access or inspection fails.
+ */
+export declare function readUnopenedWindowsLock(path: string): Promise<string | undefined>;
+//# sourceMappingURL=windows-lock.d.ts.map

package/runtime/node_modules/@deepseek-ai/dsh-atomic-write/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepseek-ai/dsh-atomic-write",
-  "description": "Zero-dependency atomic file replacement: exclusive-create random-suffix temp + rename carrying the caller-stated permissions (writeFileAtomic)",
+  "description": "Atomic file replacement and cross-process writer coordination with automatic orphan recovery",
   "version": "0.1.7-rc.2",
   "publishConfig": {
     "access": "public"
@@ -26,6 +26,9 @@
     "lib/types/**/*.d.ts"
   ],
   "license": "MIT",
+  "dependencies": {
+    "koffi": "^3.1.0"
+  },
   "peerDependencies": {
     "@deepseek-ai/cordis": "workspace:~"
   },

package/runtime/node_modules/@deepseek-ai/dsh-client-ui-settings-account/lib/client.js

@@ -4125,7 +4125,7 @@ window.__ModuleLoader__.load({
 				for (const listener of listeners) listener();
 			};
 			/** @returns the client identity for one account call, read at call time so it carries the language and zone in effect then. */
-			const client = () => accountClientMetadata(ctx.locale.getSnapshot().active, "3.0.4-rc.2");
+			const client = () => accountClientMetadata(ctx.locale.getSnapshot().active, "3.0.4-rc.4");
 			const notices = createBonusNoticeController({
 				ackRetryDelayMs: config.bonusAckRetryDelayMs,
 				ackRetryMaxDelayMs: config.bonusAckRetryMaxDelayMs,
@@ -4256,7 +4256,7 @@ window.__ModuleLoader__.load({
 				refreshAccount,
 				contactUs() {
 					const url = contactUrl(config, {
-						version: "3.0.4-rc.2",
+						version: "3.0.4-rc.4",
 						locale: ctx.locale.getSnapshot().active === "zh" ? "zh-CN" : "en",
 						width: window.screen.width,
 						height: window.screen.height,

package/runtime/node_modules/@deepseek-ai/dsh-client-ui-settings-general/lib/client.js

@@ -657,7 +657,7 @@ window.__ModuleLoader__.load({
 		function CurrentVersionRow({ t }) {
 			return (0, react_jsx_runtime.jsx)("div", {
 				className: CurrentVersionRow_module_css_default.row,
-				children: t("general.currentVersion", { version: "3.0.4-rc.2" })
+				children: t("general.currentVersion", { version: "3.0.4-rc.4" })
 			});
 		}
 		//#endregion

package/runtime/node_modules/@deepseek-ai/dsh-client-ui-sidebar/lib/client.js

@@ -167,9 +167,7 @@ window.__ModuleLoader__.load({
 		const SCROLLBAR_LINGER_MS = 2e3;
 		/** Format complete-build metadata for the local brand badge. */
 		function localBuildVersion() {
-			const commit = "4d610ce";
-			const dirty = {}.CHATCODE_CLI_CLIENT_GIT_DIRTY ?? {}["DSH_CLIENT_GIT_DIRTY"];
-			return `3.0.4-rc.2-${commit}` + (dirty === "true" ? "-dirty" : "");
+			return `3.0.4-rc.4-b93a39c-dirty`;
 		}
 		/** Each panel row subscribes only to its own selection state. */
 		function PanelRow({ id, label, wide, usePanelInfo, selectPanel, renderSlot }) {

package/runtime/node_modules/@deepseek-ai/dsh-llm-deepseek/lib/types/adapter.d.ts

@@ -13,7 +13,7 @@ export declare class DeepSeekAdapter<C extends Connection = Connection> extends
         name: string;
     };
     providerRetryPolicy(_provider: string): import("@deepseek-ai/dsh-llm").ResolvedRetryPolicy;
-    listModels(provider: string): Promise<import("@deepseek-ai/dsh-llm").LlmModelInfo[] | never[]>;
+    listModels(provider: string): Promise<never[] | import("@deepseek-ai/dsh-llm").LlmModelInfo[]>;
     resolveModel(provider: string, model: string, _signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-llm").LlmResolvedModelInfo>;
     imageRequestPricing(_provider: string, model: string): import("@deepseek-ai/dsh-llm").LlmImageRequestPricing;
     prepareCall(provider: string, model: string, _signal?: AbortSignal): Promise<PreparedAdapterCall>;

package/runtime/node_modules/@deepseek-ai/dsh-llm-deepseek/lib/types/config.d.ts

@@ -56,7 +56,7 @@ export declare function plainOptions(config: Config): Options;
 export declare const deepSeekConfigFields: {
     baseURL: z<string, string, "volatile">;
     thinking: z<"enabled" | "disabled", "enabled" | "disabled", "volatile">;
-    reasoningEffort: z<"off" | "low" | "high" | "max", "off" | "low" | "high" | "max", "volatile">;
+    reasoningEffort: z<"low" | "off" | "high" | "max", "low" | "off" | "high" | "max", "volatile">;
     maxTokens: z<number, number, "volatile-defined">;
     defaultContextWindow: z<number, number, "volatile-defined">;
     models: z<NoInfer<DeepSeekCatalogModel[]>, NoInfer<DeepSeekCatalogModel[]>, "volatile-defined">;
@@ -76,7 +76,7 @@ export declare const deepSeekConfigFields: {
 export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     baseURL: z<string, string, "volatile">;
     thinking: z<"enabled" | "disabled", "enabled" | "disabled", "volatile">;
-    reasoningEffort: z<"off" | "low" | "high" | "max", "off" | "low" | "high" | "max", "volatile">;
+    reasoningEffort: z<"low" | "off" | "high" | "max", "low" | "off" | "high" | "max", "volatile">;
     maxTokens: z<number, number, "volatile-defined">;
     defaultContextWindow: z<number, number, "volatile-defined">;
     models: z<NoInfer<DeepSeekCatalogModel[]>, NoInfer<DeepSeekCatalogModel[]>, "volatile-defined">;
@@ -95,7 +95,7 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
 }>>, Schemastery.ObjectT<NoInfer<{
     baseURL: z<string, string, "volatile">;
     thinking: z<"enabled" | "disabled", "enabled" | "disabled", "volatile">;
-    reasoningEffort: z<"off" | "low" | "high" | "max", "off" | "low" | "high" | "max", "volatile">;
+    reasoningEffort: z<"low" | "off" | "high" | "max", "low" | "off" | "high" | "max", "volatile">;
     maxTokens: z<number, number, "volatile-defined">;
     defaultContextWindow: z<number, number, "volatile-defined">;
     models: z<NoInfer<DeepSeekCatalogModel[]>, NoInfer<DeepSeekCatalogModel[]>, "volatile-defined">;

package/runtime/node_modules/@deepseek-ai/dsh-llm-deepseek-account/lib/types/config.d.ts

@@ -5,7 +5,7 @@ export type Config = ProtocolConfig;
 export declare const Config: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<NoInfer<{
     baseURL: import("@deepseek-ai/schemastery").default<string, string, "volatile">;
     thinking: import("@deepseek-ai/schemastery").default<"enabled" | "disabled", "enabled" | "disabled", "volatile">;
-    reasoningEffort: import("@deepseek-ai/schemastery").default<"off" | "low" | "high" | "max", "off" | "low" | "high" | "max", "volatile">;
+    reasoningEffort: import("@deepseek-ai/schemastery").default<"low" | "off" | "high" | "max", "low" | "off" | "high" | "max", "volatile">;
     maxTokens: import("@deepseek-ai/schemastery").default<number, number, "volatile-defined">;
     defaultContextWindow: import("@deepseek-ai/schemastery").default<number, number, "volatile-defined">;
     models: import("@deepseek-ai/schemastery").default<NoInfer<import("@deepseek-ai/dsh-llm-deepseek").DeepSeekCatalogModel[]>, NoInfer<import("@deepseek-ai/dsh-llm-deepseek").DeepSeekCatalogModel[]>, "volatile-defined">;
@@ -24,7 +24,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
 }>>, Schemastery.ObjectT<NoInfer<{
     baseURL: import("@deepseek-ai/schemastery").default<string, string, "volatile">;
     thinking: import("@deepseek-ai/schemastery").default<"enabled" | "disabled", "enabled" | "disabled", "volatile">;
-    reasoningEffort: import("@deepseek-ai/schemastery").default<"off" | "low" | "high" | "max", "off" | "low" | "high" | "max", "volatile">;
+    reasoningEffort: import("@deepseek-ai/schemastery").default<"low" | "off" | "high" | "max", "low" | "off" | "high" | "max", "volatile">;
     maxTokens: import("@deepseek-ai/schemastery").default<number, number, "volatile-defined">;
     defaultContextWindow: import("@deepseek-ai/schemastery").default<number, number, "volatile-defined">;
     models: import("@deepseek-ai/schemastery").default<NoInfer<import("@deepseek-ai/dsh-llm-deepseek").DeepSeekCatalogModel[]>, NoInfer<import("@deepseek-ai/dsh-llm-deepseek").DeepSeekCatalogModel[]>, "volatile-defined">;