@yaawn/workflow 0.4.0 → 0.5.0

package/dist/cli/exit-codes.js

@@ -0,0 +1,3 @@
+export const EXIT_OK = 0;
+export const EXIT_ERROR = 1;
+export const EXIT_INTERRUPTED = 130;

package/dist/cli/index.js

@@ -0,0 +1,11 @@
+export { agentFlag, packageRootFlag, parseArgs } from "./args.js";
+export { describeError, detailTemplates, fallbackMissingPackageRoot, fallbackTemplates, installProcessSafetyNet, isPromptCancellation, printError, runWithSafetyNet, templatesFrom, } from "./errors.js";
+export { InstallReport } from "./install-report.js";
+export { Installer } from "./install.js";
+export { run } from "./run.js";
+export { Uninstaller } from "./uninstall.js";
+export { EXIT_ERROR, EXIT_INTERRUPTED, EXIT_OK } from "./exit-codes.js";
+export { resolvePackageRoot } from "./package-root.js";
+export { resolveProjectRoot } from "./project-root.js";
+export { isInteractive } from "./terminal.js";
+export { helpText, versionText } from "./version.js";

package/dist/cli/install-report.js

@@ -0,0 +1,92 @@
+import path from "node:path";
+import { fill } from "../config/index.js";
+import { failureReason, KIND_IMPORTS, LINK_CREATED, LINK_EXISTED, LINK_SKIPPED } from "../link/index.js";
+/** Turns the install results into progress lines on reporter; every text comes from the config messages. */
+export class InstallReport {
+    messages;
+    reporter;
+    constructor(messages, reporter) {
+        this.messages = messages;
+        this.reporter = reporter;
+    }
+    /** Reports every synced target; with failure, the last target is reported as the one that failed. */
+    sync(result, failure) {
+        result.targets.forEach((target, index) => {
+            const values = {
+                source: target.source,
+                target: target.target,
+                path: target.source,
+                count: String(target.removed),
+            };
+            if (failure !== undefined && index === result.targets.length - 1) {
+                this.reporter.warn(fill(this.messages.syncFailed, { ...values, error: failure }));
+            }
+            else if (target.sourceMissing) {
+                this.reporter.warn(fill(this.messages.syncSourceMissing, values));
+            }
+            else {
+                this.reporter.info(fill(target.removed > 0 ? this.messages.syncedReplaced : this.messages.synced, values));
+            }
+            target.seedKept.forEach((kept) => this.reporter.info(fill(this.messages.fileKept, { file: path.posix.basename(kept) })));
+        });
+    }
+    languages(result) {
+        if (!result.hasLanguageFiles) {
+            return;
+        }
+        if (result.languages.length === 0) {
+            this.reporter.info(this.messages.languagesNone);
+            return;
+        }
+        const labels = result.languages.map((language) => language.label).join(", ");
+        this.reporter.info(fill(this.messages.languagesInstalled, { languages: labels }));
+    }
+    projects(result) {
+        result.updated.forEach((updated) => this.reporter.info(fill(this.messages.projectsUpdated, { path: updated })));
+        result.skipped.forEach((skipped) => this.reporter.warn(fill(this.messages.projectsSkipped, { path: skipped })));
+    }
+    changes(results) {
+        for (const change of results) {
+            const values = { file: change.fileName, count: String(change.added) };
+            this.reporter.info(fill(change.added > 0 ? this.messages.itemsAdded : this.messages.itemsUnchanged, values));
+        }
+    }
+    /** Reports every link; a failed symlink line carries the ln -s command to run by hand. */
+    links(results) {
+        results.forEach((result) => this.link(result));
+    }
+    link(result) {
+        const templates = this.linkTemplates(result);
+        const values = { path: result.path, target: result.target };
+        switch (result.status) {
+            case LINK_CREATED:
+                this.reporter.info(fill(templates.created, values));
+                return;
+            case LINK_EXISTED:
+                this.reporter.info(fill(templates.existed, values));
+                return;
+            case LINK_SKIPPED:
+                this.reporter.warn(fill(templates.skipped, values));
+                return;
+            default:
+                this.reporter.warn(fill(templates.failed, { ...values, error: failureReason(result.error), command: result.manualCommand ?? "" }));
+        }
+    }
+    linkTemplates(result) {
+        const messages = this.messages;
+        if (result.kind === KIND_IMPORTS) {
+            return {
+                created: messages.importsCreated,
+                existed: messages.importsExisted,
+                skipped: messages.importsSkipped,
+                failed: messages.importsFailed,
+            };
+        }
+        return {
+            created: messages.linkCreated,
+            existed: messages.linkExisted,
+            skipped: messages.linkSkipped,
+            failed: messages.linkFailed,
+        };
+    }
+}

package/dist/cli/install.js

@@ -0,0 +1,124 @@
+import { fill } from "../config/index.js";
+import { ReportCollector } from "../display/index.js";
+import { countLinkFailures, failureReason, linkAgent } from "../link/index.js";
+import { applyInstall, detectLanguages, InstallError, installedLanguageTags, planInstall, } from "../sync/index.js";
+import { buildWizard, readSeededFiles, runWizard } from "../wizard/index.js";
+import { describeError } from "./errors.js";
+import { EXIT_ERROR, EXIT_OK } from "./exit-codes.js";
+import { InstallReport } from "./install-report.js";
+/** Raised once everything else is done when at least one agent link failed. */
+class LinksFailedError extends Error {
+    name = "LinksFailedError";
+}
+/**
+ * Runs one install: intro, wizard, then — only once the wizard has
+ * completed — the sync, the agent links and the saved agent choice behind
+ * a spinner, and finally the summary. A cancelled wizard leaves the
+ * project untouched.
+ */
+export class Installer {
+    session;
+    wizardPrompts;
+    requestedAgent;
+    constructor(session, wizardPrompts, requestedAgent) {
+        this.session = session;
+        this.wizardPrompts = wizardPrompts;
+        this.requestedAgent = requestedAgent;
+    }
+    async run() {
+        const { config, packageRoot, projectRoot, ui } = this.session;
+        ui.intro(this.session.version);
+        const preparation = await this.prepare();
+        const choice = await runWizard(preparation.wizard, {
+            messages: config.wizard.messages,
+            fallback: preparation.fallback,
+            ...this.wizardPrompts,
+        });
+        const plan = await planInstall(config, packageRoot, projectRoot, choice);
+        const collector = new ReportCollector();
+        const failure = await ui.installing(() => this.apply(plan, choice, new InstallReport(config.wizard.messages, collector)));
+        ui.installSummary({
+            warnings: preparation.warnings,
+            lines: collector.lines,
+            outroValues: config.settings.outputFileNames,
+            ...(failure === undefined ? {} : { failure }),
+        });
+        return failure === undefined ? EXIT_OK : EXIT_ERROR;
+    }
+    async prepare() {
+        const { config, packageRoot, projectRoot } = this.session;
+        const languages = await detectLanguages(config, packageRoot, projectRoot);
+        const { wizard, skipped } = buildWizard(config, {
+            seededFiles: readSeededFiles(config, packageRoot, projectRoot),
+            languages: languages.options.map((language) => ({
+                value: language.tag,
+                label: language.label,
+                selected: language.installed,
+            })),
+            previousAgent: config.previousAgent(projectRoot),
+            requestedAgent: this.requestedAgent,
+        });
+        return {
+            wizard,
+            warnings: skipped.map((section) => this.skippedWarning(section)),
+            fallback: {
+                agent: config.resolveAgent(projectRoot, this.requestedAgent),
+                languages: installedLanguageTags(languages),
+            },
+        };
+    }
+    /** Writes everything and returns the described failure, or undefined on success. */
+    async apply(plan, choice, report) {
+        try {
+            await this.applyFiles(plan, report);
+            await this.linkAndSave(choice.agent, report);
+            return undefined;
+        }
+        catch (error) {
+            return describeError(this.session.templates, error);
+        }
+    }
+    async applyFiles(plan, report) {
+        try {
+            const result = await applyInstall(this.session.config, plan);
+            report.sync(result.sync);
+            report.languages(result.sync);
+            report.projects(result.projects);
+            report.changes(result.changes);
+        }
+        catch (error) {
+            if (error instanceof InstallError) {
+                this.reportPartial(error, report);
+            }
+            throw error;
+        }
+    }
+    reportPartial(error, report) {
+        if (error.stage === "sync") {
+            report.sync(error.result.sync, syncFailureReason(error));
+            return;
+        }
+        report.sync(error.result.sync);
+        report.languages(error.result.sync);
+        report.projects(error.result.projects);
+    }
+    /** A failed link does not stop the other links or the saved choice; it fails the install only at the end. */
+    async linkAndSave(agent, report) {
+        const { config, projectRoot } = this.session;
+        const results = await linkAgent(projectRoot, config.settings.filePrefix, agent);
+        report.links(results);
+        config.saveAgent(projectRoot, agent);
+        const failed = countLinkFailures(results);
+        if (failed > 0) {
+            throw new LinksFailedError(fill(config.wizard.messages.linksFailed, { count: String(failed) }));
+        }
+    }
+    skippedWarning(section) {
+        return fill(this.session.config.wizard.messages.sectionFileMissing, { file: section.fileName, path: section.path });
+    }
+}
+/** The file system cause of a failed sync, without the absolute paths Node puts into its message. */
+function syncFailureReason(error) {
+    const syncError = error.cause;
+    return syncError instanceof Error && syncError.cause !== undefined ? failureReason(syncError.cause) : error.message;
+}

package/dist/cli/main.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { installProcessSafetyNet } from "./errors.js";
+import { run } from "./run.js";
+import { isInteractive } from "./terminal.js";
+installProcessSafetyNet(process.stderr);
+void run(process.argv.slice(2), {
+    stdin: process.stdin,
+    stdout: process.stdout,
+    stderr: process.stderr,
+    env: process.env,
+    cwd: () => process.cwd(),
+    isTTY: () => isInteractive(process),
+    entryUrl: import.meta.url,
+}).then((code) => {
+    process.exitCode = code;
+});

package/dist/cli/package-root.js

@@ -0,0 +1,17 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+/** This file compiles to dist/cli/, two levels below the package root. */
+const compiledDirToPackageRoot = "../../";
+/**
+ * Returns the package root, which holds config/, agents/, yaawn/, github/
+ * and package.json: the --package-root value when given, kept for
+ * compatibility with the old launcher, else the directory two levels above
+ * the compiled entry. Returns undefined when --package-root was given
+ * without a value.
+ */
+export function resolvePackageRoot(flagValue, entryUrl = import.meta.url) {
+    if (flagValue !== undefined) {
+        return flagValue === "" ? undefined : path.resolve(flagValue);
+    }
+    return fileURLToPath(new URL(compiledDirToPackageRoot, entryUrl));
+}

package/dist/cli/project-root.js

@@ -0,0 +1,11 @@
+import path from "node:path";
+import process from "node:process";
+const PROJECT_ROOT_ENV = "INIT_CWD";
+/**
+ * Prefers INIT_CWD, which npm sets to the directory npx was started in,
+ * over the working directory.
+ */
+export function resolveProjectRoot(env = process.env, workingDirectory = process.cwd()) {
+    const initCwd = env[PROJECT_ROOT_ENV];
+    return path.resolve(initCwd !== undefined && initCwd !== "" ? initCwd : workingDirectory);
+}

package/dist/cli/run.js

@@ -0,0 +1,141 @@
+import { agents, fill, loadConfig, readPackageVersion } from "../config/index.js";
+import { MODE_UNINSTALL, Renderer } from "../display/index.js";
+import { clackPrompts } from "../wizard/index.js";
+import { parseArgs } from "./args.js";
+import { describeError, detailTemplates, fallbackMissingPackageRoot, isPromptCancellation, printError, runWithSafetyNet, templatesFrom, } from "./errors.js";
+import { EXIT_ERROR, EXIT_INTERRUPTED, EXIT_OK } from "./exit-codes.js";
+import { Installer } from "./install.js";
+import { resolvePackageRoot } from "./package-root.js";
+import { resolveProjectRoot } from "./project-root.js";
+import { Uninstaller } from "./uninstall.js";
+import { helpText, versionText } from "./version.js";
+/**
+ * Runs the installer with args (without the program name) and returns the
+ * exit code: 0 on success, 1 on any failure, 130 when cancelled. The
+ * config is loaded and validated, and a terminal required, before
+ * anything is written; an escaped error becomes one sanitized stderr line.
+ */
+export function run(args, deps) {
+    return runWithSafetyNet(deps.stderr, () => runChecked(parseArgs(args), deps));
+}
+async function runChecked(options, deps) {
+    const packageRoot = resolvePackageRoot(options.packageRoot, deps.entryUrl);
+    if (packageRoot === undefined) {
+        printError(deps.stderr, fallbackMissingPackageRoot);
+        return EXIT_ERROR;
+    }
+    const config = loadConfig(packageRoot);
+    const messages = config.wizard.messages;
+    const templates = templatesFrom(messages);
+    const version = readVersion(packageRoot, templates, deps.stderr);
+    if (version === undefined) {
+        return EXIT_ERROR;
+    }
+    const early = earlyExit(options, messages, version, deps);
+    if (early !== undefined) {
+        return early;
+    }
+    const createUi = deps.createUi ?? createRenderer;
+    const session = {
+        config,
+        packageRoot,
+        projectRoot: resolveProjectRoot(deps.env, deps.cwd()),
+        version,
+        ui: createUi(messages, config.settings.brandColor, deps.stdout),
+        templates,
+    };
+    const wizardPrompts = {
+        prompts: deps.prompts ?? clackPrompts,
+        context: { input: deps.stdin, output: deps.stdout },
+    };
+    return new Dispatcher(session, wizardPrompts, deps.stderr).dispatch(options);
+}
+function createRenderer(messages, brandColor, output) {
+    return new Renderer(messages, brandColor, output);
+}
+function readVersion(packageRoot, templates, stderr) {
+    try {
+        return readPackageVersion(packageRoot);
+    }
+    catch (error) {
+        printError(stderr, describeError(templates, error));
+        return undefined;
+    }
+}
+/** Handles the runs that end before any flow starts: a removed flag, invalid --agent, help, version and the missing terminal. */
+function earlyExit(options, messages, version, deps) {
+    if (options.removedFlag !== undefined) {
+        printError(deps.stderr, removedFlagMessage(options.removedFlag));
+        return EXIT_ERROR;
+    }
+    if (options.invalidAgent) {
+        printError(deps.stderr, fill(messages.invalidAgent, { agents: agents().join(", ") }));
+        return EXIT_ERROR;
+    }
+    if (options.help) {
+        deps.stdout.write(`${helpText(messages, version)}\n`);
+        return EXIT_OK;
+    }
+    if (options.version) {
+        deps.stdout.write(`${versionText(messages, version)}\n`);
+        return EXIT_OK;
+    }
+    if (!deps.isTTY()) {
+        printError(deps.stderr, options.uninstall ? messages.uninstallNoTerminal : messages.noTerminal);
+        return EXIT_ERROR;
+    }
+    return undefined;
+}
+function removedFlagMessage(flag) {
+    return `workflow: unknown option ${flag} — the installer is interactive only and needs a terminal`;
+}
+/**
+ * Runs the uninstall when asked for by --uninstall or, for a project that
+ * has yaawn installed, by the mode menu; every other run installs.
+ */
+class Dispatcher {
+    session;
+    wizardPrompts;
+    stderr;
+    constructor(session, wizardPrompts, stderr) {
+        this.session = session;
+        this.wizardPrompts = wizardPrompts;
+        this.stderr = stderr;
+    }
+    async dispatch(options) {
+        const uninstaller = new Uninstaller(this.session);
+        if (options.uninstall) {
+            return this.guardUninstall(async () => uninstaller.run(await uninstaller.plan()));
+        }
+        const installed = await uninstaller.findInstalled();
+        if (installed !== undefined) {
+            const uninstalled = await this.guardUninstall(async () => (await this.session.ui.chooseMode()) === MODE_UNINSTALL ? uninstaller.run(installed) : undefined);
+            if (uninstalled !== undefined) {
+                return uninstalled;
+            }
+        }
+        return this.guardInstall(() => new Installer(this.session, this.wizardPrompts, options.agent).run());
+    }
+    guardInstall(action) {
+        const messages = this.session.config.wizard.messages;
+        return this.guard(action, messages.installCancelled, (error) => describeError(this.session.templates, error));
+    }
+    guardUninstall(action) {
+        const messages = this.session.config.wizard.messages;
+        return this.guard(action, messages.uninstallCancelled, (error) => fill(messages.uninstallFailed, { error: describeError(detailTemplates(this.session.templates), error) }));
+    }
+    /** Ctrl+C at a prompt prints cancelledText and exits 130; any other error prints one described line and exits 1. */
+    async guard(action, cancelledText, describe) {
+        try {
+            return await action();
+        }
+        catch (error) {
+            if (isPromptCancellation(error)) {
+                printError(this.stderr, cancelledText);
+                return EXIT_INTERRUPTED;
+            }
+            printError(this.stderr, describe(error));
+            return EXIT_ERROR;
+        }
+    }
+}

package/dist/cli/session.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/terminal.js

@@ -0,0 +1,5 @@
+import process from "node:process";
+/** The installer is interactive only, so both ends must be a terminal. */
+export function isInteractive(streams = process) {
+    return streams.stdin.isTTY === true && streams.stdout.isTTY === true;
+}

package/dist/cli/uninstall.js

@@ -0,0 +1,89 @@
+import { fill, readPackageName } from "../config/index.js";
+import { failureReason, findInstalledLinks, KIND_IMPORTS, removeLinks } from "../link/index.js";
+import { applyUninstall, planUninstall, uninstallEntries, UninstallError } from "../sync/index.js";
+import { describeError, detailTemplates } from "./errors.js";
+import { EXIT_ERROR, EXIT_INTERRUPTED, EXIT_OK } from "./exit-codes.js";
+const FAILURE_SEPARATOR = "; ";
+/**
+ * Runs one uninstall: list everything yaawn installed, ask with "No"
+ * preselected, then remove the agent links first — trying every one —
+ * and the files after them. Nothing is removed without confirmation.
+ */
+export class Uninstaller {
+    session;
+    constructor(session) {
+        this.session = session;
+    }
+    /** Lists the links and files to remove; it only reads the file system. */
+    async plan() {
+        const { config, packageRoot, projectRoot } = this.session;
+        return {
+            links: await findInstalledLinks(projectRoot),
+            files: await planUninstall(config, packageRoot, projectRoot),
+        };
+    }
+    /**
+     * Returns the targets when yaawn is installed. A planning error counts
+     * as not installed, so the install runs unchanged and reports the
+     * problem itself.
+     */
+    async findInstalled() {
+        try {
+            const targets = await this.plan();
+            return this.entries(targets).length > 0 ? targets : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async run(targets) {
+        const { packageRoot, ui } = this.session;
+        const packageName = readPackageName(packageRoot);
+        const entries = this.entries(targets);
+        if (entries.length === 0) {
+            ui.nothingToRemove(packageName);
+            return EXIT_OK;
+        }
+        if (!(await ui.confirmUninstall(entries))) {
+            ui.uninstallCancelled();
+            return EXIT_INTERRUPTED;
+        }
+        const outcome = await ui.uninstalling(() => this.remove(targets));
+        ui.uninstallSummary({ ...outcome, packageName });
+        return outcome.failure === undefined ? EXIT_OK : EXIT_ERROR;
+    }
+    /** The entries shown before asking, in removal order. */
+    entries(targets) {
+        return [
+            ...targets.links.map((entry) => this.linkDisplay(entry)),
+            ...uninstallEntries(targets.files).map((entry) => entry.display),
+        ];
+    }
+    async remove(targets) {
+        const links = await removeLinks(this.session.projectRoot, targets.links);
+        const linkFailures = links.failures.map(({ entry, error }) => `remove ${this.linkDisplay(entry)}: ${failureReason(error)}`);
+        const files = await this.removeFiles(targets.files);
+        const failures = files.failure === undefined ? linkFailures : [...linkFailures, files.failure];
+        const summary = {
+            removed: [...links.removed.map((entry) => this.linkDisplay(entry)), ...files.summary.removed],
+            pruned: files.summary.pruned,
+            keptPlans: files.summary.keptPlans,
+        };
+        return failures.length === 0 ? { summary } : { summary, failure: failures.join(FAILURE_SEPARATOR) };
+    }
+    /** Stops at the first failure; the outcome lists what was removed before it. There is no rollback. */
+    async removeFiles(plan) {
+        try {
+            return { summary: await applyUninstall(plan) };
+        }
+        catch (error) {
+            const summary = error instanceof UninstallError ? error.result : { removed: [], pruned: [], keptPlans: plan.keptPlans };
+            return { summary, failure: describeError(detailTemplates(this.session.templates), error) };
+        }
+    }
+    linkDisplay(entry) {
+        return entry.kind === KIND_IMPORTS
+            ? fill(this.session.config.wizard.messages.uninstallImportsEntry, { path: entry.path })
+            : entry.path;
+    }
+}

package/dist/cli/version.js

@@ -0,0 +1,7 @@
+import { fill } from "../config/index.js";
+export function helpText(messages, version) {
+    return fill(messages.help, { version });
+}
+export function versionText(messages, version) {
+    return fill(messages.version, { version });
+}

package/dist/config/agents.js

@@ -0,0 +1,108 @@
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { UnknownAgentError } from "./errors.js";
+/**
+ * Coding agents the installer can set up. They are the only values
+ * accepted for --agent, the wizard's single-select section and the
+ * project's settings file.
+ */
+export const AGENT_COPILOT = "copilot";
+export const AGENT_CLAUDE = "claude";
+export const AGENT_VIBE = "vibe";
+const AGENTS = [AGENT_COPILOT, AGENT_CLAUDE, AGENT_VIBE];
+export const DEFAULT_AGENT = AGENT_COPILOT;
+/** yaawn's runtime directory inside the project; the settings file lives there. */
+export const PROJECT_DIR = ".yaawn";
+/** Caps how much of the settings file is read, so a huge file cannot exhaust memory. */
+export const MAX_SETTINGS_SIZE = 64 * 1024;
+const SETTINGS_DIR_MODE = 0o755;
+const SETTINGS_FILE_MODE = 0o644;
+/** Returns the allowed coding agents in display order. */
+export function agents() {
+    return [...AGENTS];
+}
+export function isAgent(value) {
+    return typeof value === "string" && AGENTS.includes(value);
+}
+/**
+ * Returns the agent saved in the settings file at filePath, or undefined
+ * when the file is missing, not a regular file, oversized, unparsable or
+ * names an agent outside the allow-list, so callers fall back safely.
+ */
+export function readAgentSetting(filePath) {
+    const text = readBoundedText(filePath);
+    if (text === undefined) {
+        return undefined;
+    }
+    const agent = parseAgent(text);
+    return isAgent(agent) ? agent : undefined;
+}
+function readBoundedText(filePath) {
+    try {
+        if (!fs.statSync(filePath).isFile()) {
+            return undefined;
+        }
+        const buffer = readAtMost(filePath, MAX_SETTINGS_SIZE + 1);
+        return buffer.length > MAX_SETTINGS_SIZE ? undefined : buffer.toString("utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+function readAtMost(filePath, limit) {
+    const buffer = Buffer.alloc(limit);
+    const descriptor = fs.openSync(filePath, "r");
+    try {
+        let total = 0;
+        let bytesRead = -1;
+        while (total < limit && bytesRead !== 0) {
+            bytesRead = fs.readSync(descriptor, buffer, total, limit - total, null);
+            total += bytesRead;
+        }
+        return buffer.subarray(0, total);
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+}
+function parseAgent(text) {
+    try {
+        const settings = JSON.parse(text);
+        if (typeof settings !== "object" || settings === null || Array.isArray(settings)) {
+            return undefined;
+        }
+        return Object.hasOwn(settings, "agent") ? settings.agent : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Writes {"agent":"<agent>"} to filePath, creating its directory. The
+ * content goes to a sibling temp file first and is renamed into place,
+ * so a crash never leaves a half-written settings file. The caller must
+ * have contained filePath inside the project.
+ */
+export function writeAgentSetting(filePath, agent) {
+    if (!isAgent(agent)) {
+        throw new UnknownAgentError(agent);
+    }
+    createSettingsDir(filePath);
+    writeFileAtomically(filePath, `${JSON.stringify({ agent })}\n`);
+}
+/** Creates the directory that holds the settings file at filePath. */
+export function createSettingsDir(filePath) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: SETTINGS_DIR_MODE });
+}
+function writeFileAtomically(filePath, content) {
+    const tempPath = `${filePath}.${process.pid}.tmp`;
+    try {
+        fs.writeFileSync(tempPath, content, { flag: "wx", mode: SETTINGS_FILE_MODE });
+        fs.renameSync(tempPath, filePath);
+    }
+    catch (error) {
+        fs.rmSync(tempPath, { force: true });
+        throw error;
+    }
+}