@vibecodr/cli 0.1.8

package/dist/core/interactive-input.js

@@ -0,0 +1,114 @@
+import { CliError, EXIT_CODES } from "../cli/errors.js";
+function schemaType(schema) {
+    const type = schema?.["type"];
+    return typeof type === "string" ? type : undefined;
+}
+function describe(path, schema, required) {
+    const type = schemaType(schema);
+    const enumRaw = schema?.["enum"];
+    const enumValues = Array.isArray(enumRaw) ? ` [${enumRaw.map(String).join(", ")}]` : "";
+    return `${path}${type ? ` (${type})` : ""}${required ? " [required]" : " [optional]"}${enumValues}`;
+}
+async function promptScalar(prompt, path, schema, required) {
+    const type = schemaType(schema);
+    const raw = await prompt(`${describe(path, schema, required)}: `, { allowEmpty: !required });
+    if (!raw)
+        return undefined;
+    const enumRaw = schema?.["enum"];
+    if (Array.isArray(enumRaw) && !enumRaw.map(String).includes(raw)) {
+        throw new CliError("input.invalid_enum", `${path} must be one of: ${enumRaw.map(String).join(", ")}`, EXIT_CODES.usage);
+    }
+    if (type === "number" || type === "integer") {
+        const parsed = Number(raw);
+        if (!Number.isFinite(parsed)) {
+            throw new CliError("input.invalid_number", `${path} must be a number.`, EXIT_CODES.usage);
+        }
+        return type === "integer" ? Math.trunc(parsed) : parsed;
+    }
+    if (type === "boolean") {
+        const normalized = raw.toLowerCase();
+        if (["true", "t", "yes", "y", "1"].includes(normalized))
+            return true;
+        if (["false", "f", "no", "n", "0"].includes(normalized))
+            return false;
+        throw new CliError("input.invalid_boolean", `${path} must be true or false.`, EXIT_CODES.usage);
+    }
+    return raw;
+}
+async function promptArray(prompt, path, schema, required) {
+    const itemsRaw = schema?.["items"];
+    const items = itemsRaw && typeof itemsRaw === "object" && !Array.isArray(itemsRaw)
+        ? itemsRaw
+        : undefined;
+    const countRaw = await prompt(`${describe(path, schema, required)} count: `, { allowEmpty: !required });
+    if (!countRaw)
+        return undefined;
+    const count = Number(countRaw);
+    if (!Number.isInteger(count) || count < 0) {
+        throw new CliError("input.invalid_array_count", `${path} count must be a non-negative integer.`, EXIT_CODES.usage);
+    }
+    const values = [];
+    for (let index = 0; index < count; index += 1) {
+        values.push(await promptBySchema(prompt, `${path}[${index}]`, items, true));
+    }
+    return values;
+}
+async function promptObject(prompt, path, schema, required) {
+    const propertiesRaw = schema?.["properties"];
+    const properties = typeof propertiesRaw === "object" && propertiesRaw
+        ? propertiesRaw
+        : {};
+    const requiredRaw = schema?.["required"];
+    const requiredFields = Array.isArray(requiredRaw)
+        ? requiredRaw.filter((value) => typeof value === "string")
+        : [];
+    if (!required && !requiredFields.length && Object.keys(properties).length) {
+        const include = await prompt(`Include ${path} object? [y/N]: `, { allowEmpty: true });
+        if (!include || ["n", "no"].includes(include.toLowerCase()))
+            return undefined;
+    }
+    const result = {};
+    for (const [name, childSchema] of Object.entries(properties)) {
+        const childRequired = requiredFields.includes(name);
+        const value = await promptBySchema(prompt, `${path}.${name}`, childSchema, childRequired);
+        if (value !== undefined) {
+            result[name] = value;
+        }
+    }
+    if (!required && Object.keys(result).length === 0)
+        return undefined;
+    return result;
+}
+export async function promptBySchema(prompt, path, schema, required) {
+    const type = schemaType(schema);
+    if (type === "object" || (!type && schema?.["properties"])) {
+        return await promptObject(prompt, path, schema, required);
+    }
+    if (type === "array") {
+        return await promptArray(prompt, path, schema, required);
+    }
+    return await promptScalar(prompt, path, schema, required);
+}
+export async function promptObjectBySchema(prompt, toolName, schema) {
+    const propertiesRaw = schema?.["properties"];
+    const properties = typeof propertiesRaw === "object" && propertiesRaw
+        ? propertiesRaw
+        : {};
+    const requiredRaw = schema?.["required"];
+    const requiredFields = Array.isArray(requiredRaw)
+        ? requiredRaw.filter((value) => typeof value === "string")
+        : [];
+    if (requiredFields.length) {
+        // Stronger guidance before prompting starts.
+        // Users should know exactly which values cannot be skipped.
+        process.stderr.write(`Required fields for ${toolName}: ${requiredFields.join(", ")}\n`);
+    }
+    const result = {};
+    for (const [name, childSchema] of Object.entries(properties)) {
+        const value = await promptBySchema(prompt, name, childSchema, requiredFields.includes(name));
+        if (value !== undefined) {
+            result[name] = value;
+        }
+    }
+    return result;
+}

package/dist/core/mcp-client.js

@@ -0,0 +1,82 @@
+import { createRequire } from "node:module";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { extractWWWAuthenticateParams } from "@modelcontextprotocol/sdk/client/auth.js";
+import { StreamableHTTPClientTransport, StreamableHTTPError } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { CliError, EXIT_CODES } from "../cli/errors.js";
+const require = createRequire(import.meta.url);
+const packageJson = require("../../package.json");
+const packageVersion = typeof packageJson.version === "string" && packageJson.version.length > 0
+    ? packageJson.version
+    : "0.0.0";
+export const CLIENT_INFO = {
+    name: "vibecodr-mcp",
+    version: packageVersion
+};
+export class McpRuntimeClient {
+    async listTools(serverUrl, accessToken) {
+        return await this.withClient(serverUrl, accessToken, async (client) => {
+            const result = await client.listTools();
+            return result.tools;
+        });
+    }
+    async callTool(serverUrl, accessToken, name, args) {
+        return await this.withClient(serverUrl, accessToken, async (client) => {
+            return await client.callTool({
+                name,
+                arguments: args
+            });
+        });
+    }
+    async withClient(serverUrl, accessToken, fn) {
+        let authChallenge;
+        const transport = new StreamableHTTPClientTransport(new URL(serverUrl), {
+            ...(accessToken ? { requestInit: {
+                    headers: {
+                        authorization: `Bearer ${accessToken}`
+                    }
+                } } : {}),
+            fetch: async (input, init) => {
+                const response = await fetch(input, init);
+                if (response.status === 401 || response.status === 403) {
+                    const challenge = extractWWWAuthenticateParams(response);
+                    authChallenge = {
+                        status: response.status,
+                        scope: challenge.scope,
+                        error: challenge.error,
+                        resourceMetadataUrl: challenge.resourceMetadataUrl?.toString()
+                    };
+                }
+                return response;
+            }
+        });
+        const client = new Client(CLIENT_INFO, {
+            capabilities: {}
+        });
+        try {
+            await client.connect(transport);
+            return await fn(client);
+        }
+        catch (error) {
+            if (error instanceof StreamableHTTPError && (error.code === 401 || error.code === 403)) {
+                const requiredScope = authChallenge?.scope;
+                const isScopeStepUp = authChallenge?.error === "insufficient_scope" || error.code === 403;
+                throw new CliError(isScopeStepUp ? "auth.insufficient_scope" : "auth.required", isScopeStepUp
+                    ? "The MCP server requires a broader OAuth scope for this operation."
+                    : "The MCP server requires authentication for this operation.", EXIT_CODES.authRequired, {
+                    cause: error,
+                    debugDetails: authChallenge,
+                    nextStep: requiredScope
+                        ? `Run vibecodr login --scope "${requiredScope}", or retry interactively to complete CLI MCP OAuth. CLI auth is separate from Codex, editor, ChatGPT, and other MCP client auth.`
+                        : "Run vibecodr login, or retry interactively to complete CLI MCP OAuth. CLI auth is separate from Codex, editor, ChatGPT, and other MCP client auth."
+                });
+            }
+            throw new CliError("mcp.protocol", "Failed to complete the MCP request.", EXIT_CODES.protocol, {
+                cause: error,
+                nextStep: "Run vibecodr doctor to inspect auth, discovery, and connectivity."
+            });
+        }
+        finally {
+            await transport.close().catch(() => undefined);
+        }
+    }
+}

package/dist/core/renderers.js

@@ -0,0 +1,34 @@
+export function formatJson(value) {
+    return JSON.stringify(value, null, 2);
+}
+export function summarizeToolSchema(inputSchema) {
+    const requiredRaw = inputSchema?.["required"];
+    const required = Array.isArray(requiredRaw)
+        ? requiredRaw.filter((value) => typeof value === "string")
+        : [];
+    const propertiesRaw = inputSchema?.["properties"];
+    const properties = typeof propertiesRaw === "object" && propertiesRaw
+        ? propertiesRaw
+        : {};
+    const skeleton = Object.fromEntries(Object.entries(properties).map(([name, schema]) => [name, schema["type"] === "number" || schema["type"] === "integer" ? 0 : schema["type"] === "boolean" ? false : ""]));
+    const optional = Object.keys(properties).filter((name) => !required.includes(name));
+    return { required, optional, skeleton };
+}
+export function renderToolResult(result) {
+    const typed = typeof result === "object" && result ? result : {};
+    const lines = [];
+    if (Array.isArray(typed.content)) {
+        for (const item of typed.content) {
+            if (item && typeof item === "object" && "type" in item && item.type === "text") {
+                const text = item.text;
+                if (typeof text === "string" && text.trim())
+                    lines.push(text);
+            }
+        }
+    }
+    if (lines.length)
+        return lines.join("\n\n");
+    if (typed.structuredContent !== undefined)
+        return formatJson(typed.structuredContent);
+    return formatJson(result);
+}

package/dist/doctor/run.js

@@ -0,0 +1,132 @@
+import { access } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { SecretStore } from "../storage/secret-store.js";
+import { TokenManager } from "../auth/token-manager.js";
+import { codexConfigPath, cursorUserConfigPath, vscodeWorkspaceConfigPath, windsurfLegacyConfigPath, windsurfUserConfigPath } from "../platform/paths.js";
+import { browserLauncherAvailable } from "../platform/browser.js";
+import { commandExists } from "../platform/exec.js";
+function detectBrowserLauncher() {
+    return browserLauncherAvailable();
+}
+async function pathExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function writableAncestor(path) {
+    let current = resolve(path);
+    while (true) {
+        try {
+            await access(current, fsConstants.W_OK);
+            return current;
+        }
+        catch {
+            const parent = dirname(current);
+            if (parent === current)
+                return undefined;
+            current = parent;
+        }
+    }
+}
+async function configLocationCheck(path, label) {
+    const writableBase = await writableAncestor(path);
+    if (!writableBase) {
+        return {
+            id: label,
+            status: "warn",
+            summary: `${path} is not currently writable from this environment.`
+        };
+    }
+    return {
+        id: label,
+        status: "pass",
+        summary: `${path} is reachable via writable base ${writableBase}.`
+    };
+}
+export async function runDoctor(globalOptions, tokenManager, secretStore, targetClient) {
+    const checks = [];
+    const majorVersion = Number(process.versions.node.split(".")[0] || "0");
+    checks.push({
+        id: "node-version",
+        status: majorVersion >= 22 && majorVersion < 26 ? "pass" : "fail",
+        summary: `Node ${process.versions.node} detected.`
+    });
+    checks.push({
+        id: "browser-launcher",
+        status: detectBrowserLauncher() ? "pass" : "warn",
+        summary: detectBrowserLauncher() ? "A browser launcher is available." : "No browser launcher was detected."
+    });
+    const secretStoreCheck = await secretStore.checkAvailability();
+    checks.push({
+        id: "secret-store",
+        status: secretStoreCheck.ok ? "pass" : "fail",
+        summary: secretStoreCheck.summary
+    });
+    try {
+        const { serverUrl } = await tokenManager.resolveProfile(globalOptions);
+        const { profileName } = await tokenManager.resolveProfile(globalOptions);
+        const session = await tokenManager.getSession(profileName);
+        const discovery = await tokenManager.discover(serverUrl);
+        checks.push({
+            id: "server-reachability",
+            status: "pass",
+            summary: `Discovered authorization server ${discovery.authorizationServerUrl}.`
+        });
+        checks.push({
+            id: "pkce-supported",
+            status: Array.isArray(discovery.authorizationServerMetadata?.code_challenge_methods_supported)
+                && discovery.authorizationServerMetadata.code_challenge_methods_supported.includes("S256")
+                ? "pass"
+                : "fail",
+            summary: Array.isArray(discovery.authorizationServerMetadata?.code_challenge_methods_supported)
+                && discovery.authorizationServerMetadata.code_challenge_methods_supported.includes("S256")
+                ? "Authorization server advertises PKCE S256."
+                : "Authorization server metadata does not advertise PKCE S256."
+        });
+        checks.push({
+            id: "refresh-token",
+            status: session?.refreshToken ? "pass" : "warn",
+            summary: session?.refreshToken ? "A refresh token is available for the current profile." : "No refresh token is stored for the current profile."
+        });
+    }
+    catch (error) {
+        checks.push({
+            id: "server-reachability",
+            status: "fail",
+            summary: error instanceof Error ? error.message : String(error)
+        });
+    }
+    if (targetClient === "codex") {
+        checks.push({
+            id: "codex-cli",
+            status: commandExists("codex") ? "pass" : "warn",
+            summary: commandExists("codex") ? "Codex CLI is available." : "Codex CLI is not on PATH."
+        });
+        checks.push(await configLocationCheck(codexConfigPath(), "codex-config"));
+    }
+    if (targetClient === "cursor") {
+        checks.push(await configLocationCheck(cursorUserConfigPath(), "cursor-config"));
+    }
+    if (targetClient === "vscode") {
+        checks.push({
+            id: "vscode-cli",
+            status: commandExists("code") ? "pass" : "warn",
+            summary: commandExists("code") ? "VS Code CLI is available." : "VS Code CLI is not on PATH."
+        });
+        checks.push(await configLocationCheck(vscodeWorkspaceConfigPath(process.cwd()), "vscode-workspace-config"));
+    }
+    if (targetClient === "windsurf") {
+        checks.push(await configLocationCheck(windsurfUserConfigPath(), "windsurf-config"));
+        checks.push({
+            id: "windsurf-legacy-config",
+            status: await pathExists(windsurfLegacyConfigPath()) ? "warn" : "pass",
+            summary: `Legacy Windsurf plugin path: ${windsurfLegacyConfigPath()}`
+        });
+    }
+    return checks;
+}

package/dist/platform/browser.js

@@ -0,0 +1,79 @@
+import { spawn, spawnSync } from "node:child_process";
+import { accessSync, constants as fsConstants } from "node:fs";
+import { join } from "node:path";
+import { CliError, EXIT_CODES } from "../cli/errors.js";
+const ALLOWED_BROWSER_URL_PROTOCOLS = new Set(["http:", "https:", "cursor:", "vscode:"]);
+function windowsSystemCommand(name) {
+    const systemRoot = process.env["SystemRoot"]?.trim() || "C:\\Windows";
+    return join(systemRoot, "System32", name);
+}
+function commandBinaryAvailable(command) {
+    if (command.includes("\\") || command.includes("/")) {
+        try {
+            accessSync(command, fsConstants.F_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    const checker = process.platform === "win32" ? windowsSystemCommand("where.exe") : "which";
+    const result = spawnSync(checker, [command], { stdio: "ignore" });
+    return result.status === 0;
+}
+export function browserOpenCommandForCurrentPlatform() {
+    switch (process.platform) {
+        case "win32":
+            return { command: windowsSystemCommand("rundll32.exe"), args: ["url.dll,FileProtocolHandler"] };
+        case "darwin":
+            return { command: "open", args: [] };
+        default:
+            return { command: "xdg-open", args: [] };
+    }
+}
+export function browserLauncherAvailable() {
+    const launcher = browserOpenCommandForCurrentPlatform();
+    if (!launcher)
+        return false;
+    if (process.platform === "win32") {
+        return commandBinaryAvailable(launcher.command);
+    }
+    const check = spawnSync(launcher.command, ["--help"], { stdio: "ignore" });
+    return check.status === 0 || check.status === 1;
+}
+export async function openExternalUrl(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch (error) {
+        throw new CliError("auth.browser_url_invalid", "Refusing to open an invalid browser URL.", EXIT_CODES.protocol, {
+            cause: error,
+            nextStep: "Retry with a valid OAuth authorization URL."
+        });
+    }
+    if (!ALLOWED_BROWSER_URL_PROTOCOLS.has(parsed.protocol)) {
+        throw new CliError("auth.browser_url_blocked", `Refusing to open unsupported URL scheme ${parsed.protocol}.`, EXIT_CODES.protocol, {
+            nextStep: "Only http, https, Cursor, and VS Code install links can be opened automatically."
+        });
+    }
+    const launcher = browserOpenCommandForCurrentPlatform();
+    if (!launcher) {
+        throw new CliError("auth.browser_unavailable", "No browser launcher is available on this platform.", EXIT_CODES.authRequired);
+    }
+    await new Promise((resolve, reject) => {
+        const args = [...launcher.args, url];
+        const child = spawn(launcher.command, args, {
+            detached: process.platform !== "win32",
+            stdio: "ignore"
+        });
+        child.once("error", reject);
+        child.once("spawn", () => resolve());
+        child.unref();
+    }).catch((error) => {
+        throw new CliError("auth.browser_open_failed", `Failed to open a browser for ${url}.`, EXIT_CODES.authRequired, {
+            nextStep: "Retry without --browser open so the CLI prints the URL for manual browser auth.",
+            cause: error
+        });
+    });
+}

package/dist/platform/exec.js

@@ -0,0 +1,23 @@
+import { spawn, spawnSync } from "node:child_process";
+import { join } from "node:path";
+function windowsSystemCommand(name) {
+    const systemRoot = process.env["SystemRoot"]?.trim() || "C:\\Windows";
+    return join(systemRoot, "System32", name);
+}
+export function commandExists(command) {
+    const checker = process.platform === "win32" ? windowsSystemCommand("where.exe") : "which";
+    const result = spawnSync(checker, [command], { stdio: "ignore" });
+    return result.status === 0;
+}
+export function runCommand(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { stdio: "ignore" });
+        child.once("error", reject);
+        child.once("exit", (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`${command} exited with code ${code}`));
+        });
+    });
+}

package/dist/platform/paths.js

@@ -0,0 +1,36 @@
+import { join } from "node:path";
+import { homedir } from "node:os";
+function windowsAppDataPath() {
+    return process.env["APPDATA"] || join(homedir(), "AppData", "Roaming");
+}
+function vibecodrConfigRoot() {
+    switch (process.platform) {
+        case "win32":
+            return join(windowsAppDataPath(), "Vibecodr", "MCP");
+        case "darwin":
+            return join(homedir(), "Library", "Application Support", "Vibecodr MCP");
+        default:
+            return join(process.env["XDG_CONFIG_HOME"] || join(homedir(), ".config"), "vibecodr-mcp");
+    }
+}
+export function codexConfigPath() {
+    return join(homedir(), ".codex", "config.toml");
+}
+export function cursorUserConfigPath() {
+    return join(homedir(), ".cursor", "mcp.json");
+}
+export function vscodeWorkspaceConfigPath(rootPath) {
+    return join(rootPath, ".vscode", "mcp.json");
+}
+export function windsurfUserConfigPath() {
+    return join(homedir(), ".codeium", "windsurf", "mcp_config.json");
+}
+export function windsurfLegacyConfigPath() {
+    return join(homedir(), ".codeium", "mcp_config.json");
+}
+export function projectCursorConfigPath(rootPath) {
+    return join(rootPath, ".cursor", "mcp.json");
+}
+export function secretStoreDirectory() {
+    return join(vibecodrConfigRoot(), "secrets");
+}

package/dist/platform/prompt.js

@@ -0,0 +1,19 @@
+import { stdin as input, stdout as output } from "node:process";
+import { createInterface } from "node:readline/promises";
+import { CliError, EXIT_CODES } from "../cli/errors.js";
+export async function promptText(message, options) {
+    const rl = createInterface({ input, output });
+    try {
+        const value = (await rl.question(message)).trim();
+        if (!value && !options?.allowEmpty) {
+            throw new CliError("input.required", "A value is required.", EXIT_CODES.usage);
+        }
+        return value;
+    }
+    finally {
+        rl.close();
+    }
+}
+export function isInteractiveTerminal() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}

package/dist/storage/config-store.js

@@ -0,0 +1,72 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { CliError, EXIT_CODES } from "../cli/errors.js";
+import { defaultConfigFile, defaultProfileConfig } from "../types/config.js";
+import { writeFileWithBackup } from "./file-lock.js";
+function windowsAppDataPath() {
+    return process.env["APPDATA"] || join(homedir(), "AppData", "Roaming");
+}
+export function defaultConfigPath() {
+    if (process.env["VIBECDR_MCP_CONFIG_PATH"])
+        return process.env["VIBECDR_MCP_CONFIG_PATH"];
+    switch (process.platform) {
+        case "win32":
+            return join(windowsAppDataPath(), "Vibecodr", "MCP", "config.json");
+        case "darwin":
+            return join(homedir(), "Library", "Application Support", "Vibecodr MCP", "config.json");
+        default:
+            return join(process.env["XDG_CONFIG_HOME"] || join(homedir(), ".config"), "vibecodr-mcp", "config.json");
+    }
+}
+export class ConfigStore {
+    filePath;
+    constructor(filePath = defaultConfigPath()) {
+        this.filePath = filePath;
+    }
+    path() {
+        return this.filePath;
+    }
+    async load() {
+        try {
+            const raw = await readFile(this.filePath, "utf8");
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch (error) {
+                throw new CliError("config.parse_failed", `Config file at ${this.filePath} is not valid JSON.`, EXIT_CODES.config, {
+                    cause: error,
+                    nextStep: "Repair or remove the invalid config file, then retry."
+                });
+            }
+            if (parsed.version !== 1 || typeof parsed.currentProfile !== "string" || !parsed.profiles) {
+                throw new CliError("config.invalid_shape", `Config file at ${this.filePath} has an unsupported shape.`, EXIT_CODES.config, {
+                    nextStep: "Repair or remove the invalid config file, then retry."
+                });
+            }
+            return {
+                version: 1,
+                currentProfile: parsed.currentProfile,
+                profiles: Object.fromEntries(Object.entries(parsed.profiles).map(([name, value]) => [name, { ...defaultProfileConfig(), ...value }]))
+            };
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return defaultConfigFile();
+            throw error;
+        }
+    }
+    async save(config) {
+        await writeFileWithBackup(this.filePath, JSON.stringify(config, null, 2) + "\n");
+    }
+    async getProfile(profileName) {
+        const config = await this.load();
+        const name = profileName || config.currentProfile;
+        return {
+            name,
+            profile: config.profiles[name] || defaultProfileConfig(),
+            config
+        };
+    }
+}

package/dist/storage/file-lock.js

@@ -0,0 +1,41 @@
+import { copyFile, mkdir, open, rename, unlink, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { CliError, EXIT_CODES } from "../cli/errors.js";
+export class FileLock {
+    lockPath;
+    constructor(lockPath) {
+        this.lockPath = lockPath;
+    }
+    async withLock(fn) {
+        await mkdir(dirname(this.lockPath), { recursive: true });
+        let handle;
+        try {
+            handle = await open(this.lockPath, "wx");
+        }
+        catch (error) {
+            throw new CliError("install.locked", `Another process is already modifying ${this.lockPath}.`, EXIT_CODES.installConflict, {
+                cause: error
+            });
+        }
+        try {
+            return await fn();
+        }
+        finally {
+            await handle?.close().catch(() => undefined);
+            await unlink(this.lockPath).catch(() => undefined);
+        }
+    }
+}
+export async function writeFileWithBackup(path, content) {
+    const lock = new FileLock(`${path}.lock`);
+    await lock.withLock(async () => {
+        await mkdir(dirname(path), { recursive: true });
+        try {
+            await copyFile(path, `${path}.bak`);
+        }
+        catch { }
+        const tempPath = `${path}.tmp`;
+        await writeFile(tempPath, content, "utf8");
+        await rename(tempPath, path);
+    });
+}