@cairnkeep/cli 2.8.0 → 2.11.0

package/mcp-memory-server/dist/mcp-tool-cli.js

@@ -0,0 +1,85 @@
+import { MCP_TOOL_CATALOG, MCP_TOOL_NAMES } from "./mcp-tool-catalog.js";
+import { resetMcpToolProfile, resolveMcpToolProfile, setMcpToolProfile } from "./mcp-tool-profile.js";
+function usage() {
+    process.stderr.write("Usage: cairn mcp-tools list [--json] | status [--project PATH] [--json] | set full|read-only [--project PATH] | set custom --tool NAME... [--project PATH] | reset [--project PATH]\n");
+    process.exit(2);
+}
+function option(args, name) {
+    const index = args.indexOf(name);
+    if (index < 0)
+        return undefined;
+    const value = args[index + 1];
+    if (!value || value.startsWith("--"))
+        usage();
+    args.splice(index, 2);
+    return value;
+}
+function flags(args, name) {
+    const values = [];
+    for (let index = 0; index < args.length;) {
+        if (args[index] !== name) {
+            index += 1;
+            continue;
+        }
+        args.splice(index, 1);
+        let consumed = 0;
+        while (index < args.length && !args[index].startsWith("--")) {
+            values.push(args[index]);
+            args.splice(index, 1);
+            consumed += 1;
+        }
+        if (consumed === 0)
+            usage();
+    }
+    return values;
+}
+function output(value, json, human) {
+    process.stdout.write(`${json ? JSON.stringify(value) : human}\n`);
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args.shift();
+    const jsonIndex = args.indexOf("--json");
+    const json = jsonIndex >= 0;
+    if (json)
+        args.splice(jsonIndex, 1);
+    const projectRoot = option(args, "--project") ?? process.cwd();
+    if (command === "list") {
+        if (args.length)
+            usage();
+        const tools = MCP_TOOL_NAMES.map((name) => ({ name, title: MCP_TOOL_CATALOG[name].title, annotations: MCP_TOOL_CATALOG[name].annotations }));
+        output({ schema_version: 1, tools }, json, tools.map(({ name, annotations }) => `${name}\t${annotations.readOnlyHint ? "read-only" : "mutation"}`).join("\n"));
+        return;
+    }
+    if (command === "status") {
+        if (args.length)
+            usage();
+        const status = resolveMcpToolProfile({ projectRoot });
+        output(status, json, `Profile: ${status.mode}\nSource: ${status.source}\nDigest: ${status.profile_digest}\nTools: ${status.allowed_tools.join(", ")}`);
+        return;
+    }
+    if (command === "set") {
+        const mode = args.shift();
+        if (!mode || !["full", "read-only", "custom"].includes(mode))
+            usage();
+        const allowedTools = flags(args, "--tool");
+        if (args.length || (mode === "custom" && allowedTools.length === 0) || (mode !== "custom" && allowedTools.length > 0))
+            usage();
+        const status = await setMcpToolProfile({ projectRoot, mode, allowedTools });
+        output(status, json, `MCP tool profile set to ${mode} (${status.profile_digest}).`);
+        return;
+    }
+    if (command === "reset") {
+        if (args.length)
+            usage();
+        await resetMcpToolProfile(projectRoot);
+        const status = resolveMcpToolProfile({ projectRoot });
+        output(status, json, `Project MCP tool profile reset; effective profile is ${status.mode} from ${status.source}.`);
+        return;
+    }
+    usage();
+}
+main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+});

package/mcp-memory-server/dist/mcp-tool-profile.js

@@ -0,0 +1,164 @@
+import { createHash, randomBytes } from "node:crypto";
+import { closeSync, constants, existsSync, lstatSync, openSync, readFileSync, realpathSync, rmSync } from "node:fs";
+import { chmod, mkdir, open, rm } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { MCP_TOOL_CATALOG, MCP_TOOL_NAMES, isCairnToolName } from "./mcp-tool-catalog.js";
+import { atomicReplace, hardenPrivatePath, privatePathIsSafe } from "./platform-security.js";
+const MAX_CONFIG_BYTES = 64 * 1024;
+function paths(projectRoot) {
+    const root = resolve(projectRoot);
+    const directory = join(root, ".ai");
+    const config = join(directory, "mcp-tools.json");
+    if (dirname(directory) !== root || dirname(config) !== directory)
+        throw new Error("MCP tool profile path is unsafe.");
+    return { root, directory, config };
+}
+function exactAllowed(mode, requested) {
+    if (mode === "full")
+        return [...MCP_TOOL_NAMES];
+    if (mode === "read-only") {
+        return MCP_TOOL_NAMES.filter((name) => MCP_TOOL_CATALOG[name].annotations.readOnlyHint);
+    }
+    const unknown = requested.filter((name) => !isCairnToolName(name));
+    if (unknown.length)
+        throw new Error(`Unknown MCP tool name${unknown.length === 1 ? "" : "s"}: ${unknown.join(", ")}`);
+    if (requested.length === 0)
+        throw new Error("A custom MCP tool profile requires at least one allowed tool.");
+    const selected = new Set(requested);
+    return MCP_TOOL_NAMES.filter((name) => selected.has(name));
+}
+function canonicalProfile(mode, allowed) {
+    return { schema_version: 1, mode, allowed_tools: exactAllowed(mode, allowed) };
+}
+function storedProfile(mode, allowed) {
+    const effective = exactAllowed(mode, allowed);
+    return { schema_version: 1, mode, allowed_tools: mode === "custom" ? effective : [] };
+}
+export function mcpToolProfileDigest(config) {
+    return createHash("sha256").update(JSON.stringify(config), "utf8").digest("hex");
+}
+function parseConfig(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Invalid MCP tool profile configuration.");
+    const row = value;
+    if (Object.keys(row).some((key) => !["schema_version", "mode", "allowed_tools"].includes(key))
+        || row.schema_version !== 1
+        || !["full", "read-only", "custom"].includes(String(row.mode))
+        || !Array.isArray(row.allowed_tools)
+        || row.allowed_tools.some((name) => typeof name !== "string")) {
+        throw new Error("Invalid MCP tool profile configuration.");
+    }
+    const mode = row.mode;
+    const requested = row.allowed_tools;
+    const canonical = storedProfile(mode, requested);
+    if (mode !== "custom" && requested.length > 0)
+        throw new Error("Only custom MCP tool profiles may contain allowed_tools.");
+    if (mode === "custom" && new Set(requested).size !== requested.length)
+        throw new Error("Duplicate MCP tool names are not allowed.");
+    return canonical;
+}
+function readProjectConfig(projectRoot) {
+    const { directory, config } = paths(projectRoot);
+    if (!existsSync(config))
+        return undefined;
+    const dirInfo = lstatSync(directory);
+    const info = lstatSync(config);
+    if (!dirInfo.isDirectory() || dirInfo.isSymbolicLink() || !info.isFile() || info.isSymbolicLink()
+        || info.size > MAX_CONFIG_BYTES || !privatePathIsSafe(config)) {
+        throw new Error("MCP tool profile configuration is unsafe.");
+    }
+    const fd = requireNoFollow(config);
+    try {
+        const bytes = readFileSync(fd);
+        if (bytes.byteLength > MAX_CONFIG_BYTES)
+            throw new Error("MCP tool profile configuration is too large.");
+        return parseConfig(JSON.parse(bytes.toString("utf8")));
+    }
+    finally {
+        // readFileSync does not own numeric descriptors.
+        closeSync(fd);
+    }
+}
+function requireNoFollow(path) {
+    return openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+}
+function environmentConfig(env) {
+    const rawMode = env.CAIRN_MCP_TOOL_PROFILE?.trim();
+    if (!rawMode)
+        return undefined;
+    if (!["full", "read-only", "custom"].includes(rawMode))
+        throw new Error("CAIRN_MCP_TOOL_PROFILE must be full, read-only, or custom.");
+    const allowed = (env.CAIRN_MCP_ALLOWED_TOOLS ?? "").split(",").map((name) => name.trim()).filter(Boolean);
+    if (rawMode !== "custom" && allowed.length)
+        throw new Error("CAIRN_MCP_ALLOWED_TOOLS is valid only with the custom profile.");
+    return storedProfile(rawMode, allowed);
+}
+export function resolveMcpToolProfile(options = {}) {
+    const projectRoot = options.projectRoot ?? process.cwd();
+    const env = options.env ?? process.env;
+    const { root, config } = paths(projectRoot);
+    const environment = environmentConfig(env);
+    const project = environment ? undefined : readProjectConfig(root);
+    const source = environment ? "environment" : project ? "project" : "default";
+    const selected = environment ?? project ?? storedProfile("full", []);
+    const effective = canonicalProfile(selected.mode, selected.allowed_tools);
+    return { ...effective, source, profile_digest: mcpToolProfileDigest(effective), project_root: root, config_path: config, issues: [] };
+}
+async function atomicWrite(path, value) {
+    if (existsSync(dirname(path))) {
+        const existingDirectory = lstatSync(dirname(path));
+        if (!existingDirectory.isDirectory() || existingDirectory.isSymbolicLink())
+            throw new Error("MCP tool profile directory is unsafe.");
+    }
+    else {
+        await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    }
+    const directoryInfo = lstatSync(dirname(path));
+    if (!directoryInfo.isDirectory() || directoryInfo.isSymbolicLink())
+        throw new Error("MCP tool profile directory is unsafe.");
+    if (existsSync(path)) {
+        const existing = lstatSync(path);
+        if (!existing.isFile() || existing.isSymbolicLink())
+            throw new Error("MCP tool profile configuration is unsafe.");
+    }
+    const temporary = join(dirname(path), `.${basename(path)}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`);
+    let handle;
+    try {
+        handle = await open(temporary, "wx", 0o600);
+        await handle.writeFile(`${JSON.stringify(value, null, 2)}\n`, "utf8");
+        await handle.sync();
+        await handle.close();
+        handle = undefined;
+        await chmod(temporary, 0o600);
+        hardenPrivatePath(temporary);
+        await atomicReplace(temporary, path);
+        hardenPrivatePath(path);
+    }
+    finally {
+        if (handle)
+            await handle.close().catch(() => undefined);
+        await rm(temporary, { force: true });
+    }
+}
+export async function setMcpToolProfile(options) {
+    const { root, config } = paths(options.projectRoot ?? process.cwd());
+    const value = storedProfile(options.mode, options.allowedTools ?? []);
+    await atomicWrite(config, value);
+    return resolveMcpToolProfile({ projectRoot: root, env: {} });
+}
+export async function resetMcpToolProfile(projectRoot = process.cwd()) {
+    const { config } = paths(projectRoot);
+    if (!existsSync(config))
+        return;
+    const info = lstatSync(config);
+    if (!info.isFile() || info.isSymbolicLink())
+        throw new Error("MCP tool profile configuration is unsafe.");
+    rmSync(config);
+}
+export function profileAllowsTool(status, name) {
+    return status.allowed_tools.includes(name);
+}
+export function canonicalProjectRoot(projectRoot) {
+    const resolved = resolve(projectRoot);
+    return existsSync(resolved) ? realpathSync(resolved) : resolved;
+}

package/mcp-memory-server/dist/note-store.js

@@ -5,6 +5,7 @@ import { basename, dirname, isAbsolute, join, relative, resolve } from "node:pat
 import { buildFailureSignature } from "./failure-signature.js";
 import { NOTE_SCHEMA_VERSION, noteNodeSchema, } from "./note-schema.js";
 import { memoryImportEnvelopeSchema, nodePathSchema, } from "./node-schema.js";
+import { atomicReplace } from "./platform-security.js";
 const MANAGED_START = "<!-- cairnkeep:managed:v1:start -->";
 const MANAGED_END = "<!-- cairnkeep:managed:v1:end -->";
 const MAX_PROCESSED_SESSIONS_PER_PROJECT = 4096;
@@ -685,7 +686,8 @@ export function planCreateAddressedNote(options) {
     return { schema_version: 1, operation: "create", notes_root: target.layout.notes_root, project_id: target.layout.project_id, changes: manifestChanges(target.layout.notes_root, manifest, [{ path: target.absolute_path, bytes: renderNote(record) }]), result: { ok: true, scope: "project", key: options.key, created: true, snapshot_key: null, node } };
 }
 function historyPath(notesRoot, addressSpace, key) {
-    return join(notesRoot, ".cairnkeep", "history", addressSpace, ...key.split("/"), `${new Date().toISOString()}-${randomBytes(6).toString("hex")}.json`);
+    const portableTimestamp = new Date().toISOString().replaceAll(":", "-");
+    return join(notesRoot, ".cairnkeep", "history", addressSpace, ...key.split("/"), `${portableTimestamp}-${randomBytes(6).toString("hex")}.json`);
 }
 export function planSupersedeAddressedNote(options) {
     const target = resolveNoteTarget(options);
@@ -725,7 +727,9 @@ function pendingTransactionDirectories(notesRoot) {
     return readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join(root, entry.name)).sort();
 }
 function syncFile(path) {
-    const descriptor = openSync(path, "r");
+    // FlushFileBuffers requires a write-capable Windows handle. POSIX accepts
+    // the narrower read handle used by the historical implementation.
+    const descriptor = openSync(path, process.platform === "win32" ? "r+" : "r");
     try {
         fsyncSync(descriptor);
     }
@@ -734,6 +738,11 @@ function syncFile(path) {
     }
 }
 function syncDirectory(path) {
+    // Windows does not permit opening a directory as a file descriptor, so
+    // Node cannot fsync it. File contents are still fsynced before the atomic
+    // rename; POSIX additionally persists the containing directory entry.
+    if (process.platform === "win32")
+        return;
     const descriptor = openSync(path, "r");
     try {
         fsyncSync(descriptor);
@@ -839,7 +848,7 @@ export async function commitJournaledNoteMutation(plan) {
         for (const change of journal.changes) {
             mkdirSync(dirname(change.path), { recursive: true });
             if (change.staged)
-                renameSync(change.staged, change.path);
+                await atomicReplace(change.staged, change.path);
             else
                 rmSync(change.path, { force: true });
             if (existsSync(change.path))

package/mcp-memory-server/dist/pi-mcp-bridge.js

@@ -0,0 +1,185 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+const DEFAULT_STARTUP_TIMEOUT_MS = 10_000;
+const DEFAULT_CALL_TIMEOUT_MS = 30_000;
+const DEFAULT_STDERR_LIMIT_BYTES = 16 * 1024;
+const DEFAULT_RESULT_LIMIT_BYTES = 4 * 1024 * 1024;
+const MAX_CATALOG_PAGES = 1_000;
+function positiveInteger(value, fallback, name) {
+    const selected = value ?? fallback;
+    if (!Number.isSafeInteger(selected) || selected <= 0)
+        throw new Error(`${name} must be a positive integer.`);
+    return selected;
+}
+function childEnvironment(source) {
+    const env = {};
+    for (const [name, value] of Object.entries(source)) {
+        if (value !== undefined && name !== "MCP_HTTP_PORT")
+            env[name] = value;
+    }
+    return env;
+}
+function byteLength(value) {
+    try {
+        return Buffer.byteLength(JSON.stringify(value), "utf8");
+    }
+    catch {
+        throw new Error("MCP result could not be measured safely.");
+    }
+}
+function boundedMessage(error, stderr) {
+    const base = error instanceof Error ? error.message : String(error);
+    const tail = stderr.trim();
+    return tail ? `${base} (server stderr: ${tail})` : base;
+}
+function transportBufferSize(resultLimitBytes) {
+    return Math.min(Math.max(resultLimitBytes + 64 * 1024, resultLimitBytes * 4), 64 * 1024 * 1024);
+}
+function failureText(result) {
+    const text = result.content
+        .filter((item) => item.type === "text")
+        .map((item) => item.text.trim())
+        .filter(Boolean)
+        .join("; ");
+    return text || "The MCP server reported a tool failure.";
+}
+function piContent(result) {
+    return result.content.map((item) => {
+        if (item.type === "text")
+            return { ...item };
+        if (item.type === "image")
+            return { ...item };
+        throw new Error(`Unsupported MCP result content type: ${item.type}.`);
+    });
+}
+export async function connectCairnPiBridge(options = {}) {
+    const startupTimeoutMs = positiveInteger(options.startupTimeoutMs, DEFAULT_STARTUP_TIMEOUT_MS, "startupTimeoutMs");
+    const callTimeoutMs = positiveInteger(options.callTimeoutMs, DEFAULT_CALL_TIMEOUT_MS, "callTimeoutMs");
+    const stderrLimitBytes = positiveInteger(options.stderrLimitBytes, DEFAULT_STDERR_LIMIT_BYTES, "stderrLimitBytes");
+    const resultLimitBytes = positiveInteger(options.resultLimitBytes, DEFAULT_RESULT_LIMIT_BYTES, "resultLimitBytes");
+    const transport = new StdioClientTransport({
+        command: options.command ?? "cairn",
+        args: options.args ? [...options.args] : ["memory-server"],
+        cwd: options.cwd ?? process.cwd(),
+        env: childEnvironment(options.env ?? process.env),
+        stderr: "pipe",
+        maxBufferSize: transportBufferSize(resultLimitBytes),
+    });
+    const client = new Client({ name: "cairnkeep-pi-bridge", version: "1" }, { capabilities: {} });
+    let state = "idle";
+    let stderr = Buffer.alloc(0);
+    let transportFailure;
+    let catalog = [];
+    let closePromise;
+    transport.stderr?.on("data", (chunk) => {
+        const next = Buffer.concat([stderr, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
+        stderr = next.byteLength <= stderrLimitBytes ? next : next.subarray(next.byteLength - stderrLimitBytes);
+    });
+    const stderrTail = () => stderr.toString("utf8");
+    const requireReady = () => {
+        if (state !== "ready")
+            throw new Error(`Pi MCP bridge is ${state}; calls require ready state.`);
+    };
+    const discover = async () => {
+        const tools = [];
+        const names = new Set();
+        const cursors = new Set();
+        let cursor;
+        for (let pageNumber = 0; pageNumber < MAX_CATALOG_PAGES; pageNumber += 1) {
+            const page = await client.listTools(cursor ? { cursor } : undefined, { timeout: startupTimeoutMs });
+            if (byteLength(page) > resultLimitBytes)
+                throw new Error("MCP tool catalog exceeds the configured result size limit.");
+            for (const tool of page.tools) {
+                if (names.has(tool.name))
+                    throw new Error(`MCP tool catalog contains duplicate name: ${tool.name}.`);
+                names.add(tool.name);
+                tools.push(tool);
+            }
+            if (!page.nextCursor)
+                return tools;
+            if (cursors.has(page.nextCursor))
+                throw new Error("MCP tool catalog pagination repeated a cursor.");
+            cursors.add(page.nextCursor);
+            cursor = page.nextCursor;
+        }
+        throw new Error("MCP tool catalog exceeded the pagination limit.");
+    };
+    const close = () => {
+        if (closePromise)
+            return closePromise;
+        state = "closing";
+        closePromise = (async () => {
+            try {
+                await client.close();
+            }
+            finally {
+                state = "closed";
+                catalog = [];
+            }
+        })();
+        return closePromise;
+    };
+    state = "starting";
+    try {
+        await client.connect(transport, { timeout: startupTimeoutMs, maxTotalTimeout: startupTimeoutMs });
+        const protocolErrorHandler = transport.onerror;
+        transport.onerror = (error) => {
+            transportFailure = error;
+            protocolErrorHandler?.(error);
+        };
+        const protocolCloseHandler = transport.onclose;
+        transport.onclose = () => {
+            protocolCloseHandler?.();
+            if (state === "starting" || state === "ready") {
+                state = "closed";
+                catalog = [];
+            }
+        };
+        const pid = transport.pid;
+        if (pid !== null)
+            options.onSpawn?.({ pid });
+        catalog = await discover();
+        state = "ready";
+    }
+    catch (error) {
+        await close().catch(() => undefined);
+        throw new Error(`Unable to start local Pi MCP bridge: ${boundedMessage(error, stderrTail())}`, { cause: error });
+    }
+    return {
+        get state() { return state; },
+        async listAllTools() {
+            requireReady();
+            return catalog.map((tool) => structuredClone(tool));
+        },
+        async call(tool, args, callOptions = {}) {
+            requireReady();
+            const discovered = catalog.find(({ name }) => name === tool.name);
+            if (!discovered)
+                throw new Error(`MCP tool was not discovered for this session: ${tool.name}.`);
+            try {
+                const result = await client.callTool({ name: discovered.name, arguments: args }, undefined, { signal: callOptions.signal, timeout: callTimeoutMs, maxTotalTimeout: callTimeoutMs });
+                if (byteLength(result) > resultLimitBytes)
+                    throw new Error("MCP tool result exceeds the configured size limit.");
+                if (result.isError)
+                    throw new Error(failureText(result));
+                const details = {
+                    tool: discovered,
+                    annotations: discovered.annotations,
+                    outputSchema: discovered.outputSchema,
+                    content: result.content,
+                    structuredContent: result.structuredContent,
+                    isError: false,
+                    ...(result._meta ? { _meta: result._meta } : {}),
+                };
+                return { content: piContent(result), details };
+            }
+            catch (error) {
+                const failure = transportFailure && /closed/i.test(error instanceof Error ? error.message : String(error))
+                    ? transportFailure
+                    : error;
+                throw new Error(`Pi MCP call ${discovered.name} failed: ${boundedMessage(failure, stderrTail())}`, { cause: error });
+            }
+        },
+        close,
+    };
+}

package/mcp-memory-server/dist/platform-security.js

@@ -0,0 +1,102 @@
+import { chmodSync, existsSync, lstatSync, rmSync } from "node:fs";
+import { rename } from "node:fs/promises";
+import { spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+function currentWindowsSid() {
+    const result = spawnSync("whoami.exe", ["/user", "/fo", "csv", "/nh"], { encoding: "utf8", windowsHide: true });
+    if (result.status !== 0)
+        throw new Error("Unable to resolve the current Windows security identity.");
+    const match = result.stdout.match(/"(S-1-[0-9-]+)"/i);
+    if (!match)
+        throw new Error("Unable to resolve the current Windows security identity.");
+    return match[1];
+}
+export function hardenPrivatePath(path) {
+    if (process.platform !== "win32") {
+        chmodSync(path, lstatSync(path).isDirectory() ? 0o700 : 0o600);
+        return;
+    }
+    const sid = currentWindowsSid();
+    const args = [
+        path,
+        "/inheritance:r",
+        "/grant:r", `*${sid}:(F)`,
+        "/grant:r", "*S-1-5-18:(F)",
+        "/grant:r", "*S-1-5-32-544:(F)",
+    ];
+    const result = spawnSync("icacls.exe", args, { encoding: "utf8", windowsHide: true });
+    if (result.status !== 0)
+        throw new Error("Unable to restrict Windows ACLs for private Cairnkeep state.");
+}
+export function privatePathIsSafe(path) {
+    if (!existsSync(path))
+        return false;
+    const info = lstatSync(path);
+    if (info.isSymbolicLink())
+        return false;
+    if (process.platform !== "win32")
+        return (info.mode & 0o077) === 0;
+    const script = [
+        "$p=$env:CK_INTERNAL_PRIVATE_PATH",
+        "$me=[Security.Principal.WindowsIdentity]::GetCurrent().User.Value",
+        "$ok=@($me,'S-1-5-18','S-1-5-32-544')",
+        "$acl=Get-Acl -LiteralPath $p",
+        "foreach($a in $acl.Access){",
+        "if($a.AccessControlType -eq 'Allow'){",
+        "try{$sid=$a.IdentityReference.Translate([Security.Principal.SecurityIdentifier]).Value}catch{exit 1}",
+        "if($ok -notcontains $sid){exit 1}",
+        "}",
+        "}",
+        "exit 0",
+    ].join(";");
+    const result = spawnSync("powershell.exe", ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", script], {
+        encoding: "utf8",
+        windowsHide: true,
+        env: { ...process.env, CK_INTERNAL_PRIVATE_PATH: path },
+    });
+    return result.status === 0;
+}
+function delay(milliseconds) {
+    return new Promise((resolveDelay) => setTimeout(resolveDelay, milliseconds));
+}
+export async function atomicReplace(source, destination) {
+    if (process.platform === "win32") {
+        let lastError = "Windows atomic replacement failed.";
+        for (let attempt = 0; attempt < 12; attempt += 1) {
+            if (!existsSync(destination)) {
+                try {
+                    await rename(source, destination);
+                    return;
+                }
+                catch (error) {
+                    lastError = error instanceof Error ? error.message : String(error);
+                }
+            }
+            else {
+                const backup = `${destination}.replace-backup-${randomUUID()}`;
+                const result = spawnSync("powershell.exe", [
+                    "-NoLogo", "-NoProfile", "-NonInteractive", "-Command",
+                    "[IO.File]::Replace($env:CK_INTERNAL_ATOMIC_SOURCE,$env:CK_INTERNAL_ATOMIC_DESTINATION,$env:CK_INTERNAL_ATOMIC_BACKUP,$true)",
+                ], {
+                    encoding: "utf8",
+                    windowsHide: true,
+                    env: {
+                        ...process.env,
+                        CK_INTERNAL_ATOMIC_SOURCE: source,
+                        CK_INTERNAL_ATOMIC_DESTINATION: destination,
+                        CK_INTERNAL_ATOMIC_BACKUP: backup,
+                    },
+                });
+                if (result.status === 0) {
+                    rmSync(backup, { force: true });
+                    return;
+                }
+                rmSync(backup, { force: true });
+                lastError = result.stderr.trim() || result.stdout.trim() || lastError;
+            }
+            await delay(25 * (attempt + 1));
+        }
+        throw new Error(lastError);
+    }
+    await rename(source, destination);
+}