@datename/fastcode-termux 0.0.0-stage → 0.1.6

package/src/commands/plugin.ts

@@ -0,0 +1,74 @@
+import { getPlugin, importPlugin, listInstalledPlugins, removePlugin, } from "../plugins/manager.js";
+export const pluginCommand = {
+    name: "plugin",
+    description: "Manage always-active plugin packs. Usage: /plugin [list|import|enable|disable|remove|info]",
+    run({ args, state, actions }) {
+        const sub = (args[0] ?? "list").toLowerCase();
+        if (sub === "list") {
+            const plugins = listInstalledPlugins();
+            if (plugins.length === 0)
+                return { message: "No plugins installed. Import one with /plugin import <path> [name]." };
+            return {
+                message: [
+                    "Installed plugins:",
+                    "",
+                    ...plugins.map((p) => {
+                        const enabled = state.enabledPlugins.includes(p.name) ? "●" : " ";
+                        return `${enabled} ${p.name} — ${p.description}`;
+                    }),
+                ].join("\n"),
+            };
+        }
+        if (sub === "import") {
+            const source = args[1];
+            if (!source)
+                return { message: "Usage: /plugin import <folder-path> [name]" };
+            const plugin = importPlugin(source, args[2]);
+            actions.enablePlugin(plugin.name);
+            return { message: `Imported and enabled plugin ${plugin.name}.` };
+        }
+        if (sub === "enable") {
+            const name = args[1];
+            if (!name)
+                return { message: "Usage: /plugin enable <name>" };
+            const plugin = getPlugin(name);
+            if (!plugin)
+                return { message: `Plugin not found: ${name}` };
+            actions.enablePlugin(plugin.name);
+            return { message: `Enabled plugin ${plugin.name}.` };
+        }
+        if (sub === "disable") {
+            const name = args[1];
+            if (!name)
+                return { message: "Usage: /plugin disable <name>" };
+            actions.disablePlugin(name);
+            return { message: `Disabled plugin ${name}.` };
+        }
+        if (sub === "remove") {
+            const name = args[1];
+            if (!name)
+                return { message: "Usage: /plugin remove <name>" };
+            actions.disablePlugin(name);
+            return { message: removePlugin(name) ? `Removed plugin ${name}.` : `Plugin not found: ${name}` };
+        }
+        if (sub === "info") {
+            const name = args[1];
+            if (!name)
+                return { message: "Usage: /plugin info <name>" };
+            const plugin = getPlugin(name);
+            if (!plugin)
+                return { message: `Plugin not found: ${name}` };
+            return {
+                message: [
+                    `Plugin: ${plugin.name}`,
+                    `Path: ${plugin.path}`,
+                    `Description: ${plugin.description}`,
+                    `Skills: ${plugin.skills.map((s) => s.name).join(", ") || "none"}`,
+                    "",
+                    plugin.body.slice(0, 4000),
+                ].join("\n"),
+            };
+        }
+        return { message: "Usage: /plugin [list|import|enable|disable|remove|info]" };
+    },
+};

package/src/commands/provider.ts

@@ -0,0 +1,28 @@
+import { PROVIDERS, getProvider } from "../providers/index.js";
+export const providerCommand = {
+    name: "provider",
+    description: "List or switch the active LLM provider. Usage: /provider [id]",
+    run({ args, actions, state }) {
+        if (args.length === 0) {
+            const lines = ["Available providers:"];
+            for (const p of PROVIDERS) {
+                const marker = p.id === state.providerId ? "● " : "  ";
+                const auth = p.authEnv.length === 0 ? "(no key needed)" : `[${p.authEnv.join(", ")}]`;
+                lines.push(`${marker}${p.id.padEnd(12)} ${p.label}  ${auth}`);
+            }
+            lines.push("");
+            lines.push("Switch with `/provider <id>` (e.g. `/provider openrouter`).");
+            return { message: lines.join("\n") };
+        }
+        const target = args[0];
+        const next = getProvider(target);
+        if (!next) {
+            return { message: `Unknown provider "${target}". Try /provider with no args.` };
+        }
+        actions.setProvider(next.id);
+        actions.setModel(next.defaultModel);
+        return {
+            message: `Provider set to ${next.label}. Default model: ${next.defaultModel}. Use /model to change.`,
+        };
+    },
+};

package/src/commands/reset.ts

@@ -0,0 +1,13 @@
+import { DEFAULT_CONFIG, saveConfig } from "../config/store.js";
+export const resetCommand = {
+    name: "reset",
+    description: "Reset config to defaults (does not touch API keys).",
+    run({ actions }) {
+        saveConfig({ ...DEFAULT_CONFIG });
+        actions.setProvider(DEFAULT_CONFIG.providerId);
+        actions.setModel(DEFAULT_CONFIG.model);
+        actions.setTheme(DEFAULT_CONFIG.theme);
+        actions.setSystemPrompt(DEFAULT_CONFIG.systemPrompt);
+        return { message: "Config reset to defaults." };
+    },
+};

package/src/commands/skills.ts

@@ -0,0 +1,106 @@
+import { installSkill, uninstallSkill, listInstalledSkills, searchRegistry, getSkill, } from "../skills/manager.js";
+export const skillsCommand = {
+    name: "skills",
+    description: "Manage Agent Skills (download from skills.sh and toggle).",
+    async run({ args, state, actions }) {
+        const sub = (args[0] ?? "list").toLowerCase();
+        const rest = args.slice(1);
+        if (sub === "list" || sub === "ls") {
+            const installed = listInstalledSkills();
+            if (installed.length === 0) {
+                return {
+                    message: "No skills installed. Try `/skills search <query>` or `/skills install <name>`.",
+                };
+            }
+            const lines = ["Installed skills:"];
+            for (const s of installed) {
+                const enabled = state.enabledSkills.includes(s.name) ? "● " : "  ";
+                lines.push(`${enabled}${s.name}  — ${truncate(s.description, 80)}`);
+                lines.push(`    source: ${s.source}`);
+            }
+            lines.push("");
+            lines.push("Toggle with `/skills enable <name>` or `/skills disable <name>`.");
+            return { message: lines.join("\n") };
+        }
+        if (sub === "search") {
+            if (rest.length === 0)
+                return { message: "Usage: /skills search <query>" };
+            const hits = await searchRegistry(rest.join(" "), state.skillsRegistry);
+            if (hits.length === 0) {
+                return { message: `No skills found for "${rest.join(" ")}".` };
+            }
+            const lines = [`Skills matching "${rest.join(" ")}":`];
+            for (const h of hits.slice(0, 20)) {
+                lines.push(`  • ${h.slug}  — ${truncate(h.description ?? "", 80)}`);
+            }
+            lines.push("");
+            lines.push("Install with `/skills install <slug>`.");
+            return { message: lines.join("\n") };
+        }
+        if (sub === "install" || sub === "add") {
+            if (rest.length === 0)
+                return { message: "Usage: /skills install <name|owner/repo|url>" };
+            const force = rest.includes("--force");
+            const spec = rest.filter((r) => r !== "--force").join(" ");
+            try {
+                const skill = await installSkill(spec, { registry: state.skillsRegistry, force });
+                return {
+                    message: `Installed skill "${skill.name}" → ${skill.path}\n${truncate(skill.description, 200)}\n\nEnable with /skills enable ${skill.name}`,
+                };
+            }
+            catch (err) {
+                return { message: `Install failed: ${err.message}` };
+            }
+        }
+        if (sub === "uninstall" || sub === "remove" || sub === "rm") {
+            if (rest.length === 0)
+                return { message: "Usage: /skills uninstall <name>" };
+            const ok = uninstallSkill(rest[0]);
+            if (ok)
+                actions.disableSkill(rest[0]);
+            return { message: ok ? `Uninstalled "${rest[0]}".` : `No skill named "${rest[0]}".` };
+        }
+        if (sub === "enable" || sub === "use") {
+            if (rest.length === 0)
+                return { message: "Usage: /skills enable <name>" };
+            const skill = getSkill(rest[0]);
+            if (!skill)
+                return { message: `Skill "${rest[0]}" is not installed.` };
+            actions.enableSkill(skill.name);
+            return { message: `Enabled skill "${skill.name}".` };
+        }
+        if (sub === "disable" || sub === "off") {
+            if (rest.length === 0)
+                return { message: "Usage: /skills disable <name>" };
+            actions.disableSkill(rest[0]);
+            return { message: `Disabled skill "${rest[0]}".` };
+        }
+        if (sub === "info" || sub === "show") {
+            if (rest.length === 0)
+                return { message: "Usage: /skills info <name>" };
+            const skill = getSkill(rest[0]);
+            if (!skill)
+                return { message: `Skill "${rest[0]}" is not installed.` };
+            const head = `# ${skill.name}\n_${skill.description}_\n\nSource: ${skill.source}\n\n---\n\n`;
+            return { message: head + skill.body };
+        }
+        if (sub === "registry") {
+            if (rest.length === 0) {
+                return { message: `Skills registry: ${state.skillsRegistry}` };
+            }
+            // Mutate via AppActions so the in-memory React state stays in sync —
+            // direct saveConfig() would be silently overwritten by the next state
+            // change because app.tsx persists in-memory config on every update.
+            actions.setSkillsRegistry(rest[0]);
+            return { message: `Skills registry set to ${rest[0]}.` };
+        }
+        return {
+            message: "Unknown subcommand. Try: list, search, install, uninstall, enable, disable, info, registry.",
+        };
+    },
+};
+function truncate(s, n) {
+    if (s.length <= n)
+        return s;
+    return s.slice(0, n - 1) + "…";
+}

package/src/commands/system.ts

@@ -0,0 +1,20 @@
+export const systemCommand = {
+    name: "system",
+    description: "Show or set the system prompt. Usage: /system [new prompt]",
+    run({ raw, state, actions }) {
+        // Strip the leading "/system" verb keeping the rest verbatim, including
+        // whitespace, so multi-paragraph prompts survive.
+        const stripped = raw.replace(/^\/system\s*/i, "");
+        if (!stripped.trim()) {
+            return {
+                message: [
+                    "Current system prompt:",
+                    "",
+                    state.systemPrompt,
+                ].join("\n"),
+            };
+        }
+        actions.setSystemPrompt(stripped);
+        return { message: "System prompt updated." };
+    },
+};

package/src/commands/theme.ts

@@ -0,0 +1,22 @@
+import { THEMES } from "../config/themes.js";
+export const themeCommand = {
+    name: "theme",
+    description: "List or switch the color theme. Usage: /theme [id]",
+    run({ args, state, actions }) {
+        if (args.length === 0) {
+            const lines = ["Themes:"];
+            for (const id of Object.keys(THEMES)) {
+                const marker = id === state.theme ? "● " : "  ";
+                lines.push(`${marker}${id}  — ${THEMES[id].label}`);
+            }
+            lines.push("");
+            lines.push("Switch with `/theme <id>`.");
+            return { message: lines.join("\n") };
+        }
+        const id = args[0];
+        if (!THEMES[id])
+            return { message: `Unknown theme "${id}".` };
+        actions.setTheme(id);
+        return { message: `Theme set to ${id}.` };
+    },
+};

package/src/commands/tools.ts

@@ -0,0 +1,29 @@
+export const toolsCommand = {
+    name: "tools",
+    description: "Show local coding-agent tools.",
+    run() {
+        return {
+            message: [
+                "FastCode agent tools:",
+                "",
+                "  shell             Run terminal commands in the sandbox root",
+                "  pwd               Print sandbox root",
+                "  read_file         Read one file",
+                "  read_many         Read multiple files",
+                "  write_file        Replace/create a file",
+                "  append_file       Append to a file",
+                "  apply_patch       Apply focused patch hunks",
+                "  replace_in_file   Replace exact text in a file",
+                "  list_files        List files recursively",
+                "  grep              Search files",
+                "  stat_path         Inspect file metadata",
+                "  make_dir          Create directories",
+                "  copy_file         Copy a file",
+                "  move_path         Move/rename a path",
+                "  delete_file       Delete a path",
+                "",
+                "Sandbox: file tools are rooted at the current working directory.",
+            ].join("\n"),
+        };
+    },
+};

package/src/commands/whoami.ts

@@ -0,0 +1,51 @@
+import { PROVIDERS, getProvider } from "../providers/index.js";
+import { listCredentials, listLegacy, maskKey, resolveApiKey } from "../config/store.js";
+export const whoamiCommand = {
+    name: "whoami",
+    description: "Show which provider/model keys are configured.",
+    run({ state }) {
+        const lines = ["Authentication status:", `  current scope: ${state.providerId} · ${state.model}`];
+        const current = getProvider(state.providerId);
+        if (current)
+            lines.push("  " + describeLookup(current, resolveApiKey(current.id, state.model, current.authEnv)));
+        const credentials = listCredentials();
+        lines.push("");
+        lines.push(`Stored keys (${credentials.length}):`);
+        if (credentials.length === 0)
+            lines.push("  (none) — add one with /login");
+        for (const c of credentials) {
+            const marker = c.provider === state.providerId && c.model === state.model ? "● " : "  ";
+            lines.push(`${marker}${c.provider}::${c.model}   ${maskKey(c.key)}`);
+        }
+        const legacy = listLegacy();
+        if (legacy.length > 0) {
+            lines.push("");
+            lines.push("Unbound legacy keys (NOT used — re-bind them to a model):");
+            for (const l of legacy)
+                lines.push(`  ${l.provider}   ${maskKey(l.key)}   → /login ${l.provider} <model> <key>`);
+        }
+        const envLines = [];
+        for (const p of PROVIDERS) {
+            const envVar = p.authEnv.find((v) => process.env[v]);
+            if (envVar)
+                envLines.push(`  ${envVar}   (${p.id}, any model)`);
+        }
+        if (envLines.length > 0) {
+            lines.push("");
+            lines.push("Environment keys:");
+            lines.push(...envLines);
+        }
+        return { message: lines.join("\n") };
+    },
+};
+function describeLookup(provider, lookup) {
+    if (provider.authEnv.length === 0)
+        return `${provider.id}: no key needed`;
+    if (lookup.status === "ok")
+        return lookup.source === "env"
+            ? `${provider.id}: env ${lookup.envVar}`
+            : `${provider.id}: stored ${maskKey(lookup.key)}`;
+    if (lookup.status === "unbound")
+        return `${provider.id}: NO bound key (a stored legacy key needs re-binding)`;
+    return `${provider.id}: no key — /login ${provider.id} <model> <key>`;
+}

package/src/config/paths.ts

@@ -0,0 +1,59 @@
+/**
+ * Filesystem layout for FastCode user data.
+ *
+ *   ~/.fastcode/
+ *     config.json       global preferences (provider, model, theme, …)
+ *     auth.json         per-provider API keys (mode 0600)
+ *     skills/           installed SKILL.md folders
+ *     plugins/          installed plugin folders
+ *     cache/            transient downloads & registry caches
+ *     sessions/         conversation transcripts (future)
+ *     logs/             debug logs (future)
+ *
+ * On Windows we keep using `~/.fastcode` rather than %APPDATA% to match the
+ * dotfile convention most TUIs use; users can override via $FASTCODE_HOME.
+ */
+import { join } from "node:path";
+import { mkdirSync, existsSync, chmodSync } from "node:fs";
+import { safeHome, isWindows } from "../lib/platform.js";
+let cached;
+export function getPaths() {
+    if (cached)
+        return cached;
+    const root = process.env["FASTCODE_HOME"] ?? join(safeHome(), ".fastcode");
+    const paths = {
+        root,
+        config: join(root, "config.json"),
+        auth: join(root, "auth.json"),
+        trust: join(root, "trusted.json"),
+        skills: join(root, "skills"),
+        plugins: join(root, "plugins"),
+        cache: join(root, "cache"),
+        sessions: join(root, "sessions"),
+        logs: join(root, "logs"),
+    };
+    ensureDir(paths.root);
+    ensureDir(paths.skills);
+    ensureDir(paths.plugins);
+    ensureDir(paths.cache);
+    ensureDir(paths.sessions);
+    ensureDir(paths.logs);
+    cached = paths;
+    return paths;
+}
+export function ensureDir(dir) {
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+}
+/** Tighten permissions on a file storing secrets where the OS supports it. */
+export function lockdown(file) {
+    if (isWindows())
+        return;
+    try {
+        chmodSync(file, 0o600);
+    }
+    catch {
+        // best effort; some filesystems (FAT, Termux on internal storage) don't
+        // honor chmod and that's fine.
+    }
+}

package/src/config/store.ts

@@ -0,0 +1,240 @@
+/**
+ * Persistent config & auth store.
+ *
+ * We deliberately keep the format human-readable JSON so users on Termux can
+ * edit it from `nano ~/.fastcode/config.json` if needed. Atomic writes prevent
+ * partial files on Ctrl+C.
+ *
+ * API keys are NOT a single global string: each one is scoped to a concrete
+ * "provider + model" pair. auth.json stores one credential per
+ * `<provider>::<model>` scope, and a stored key is only used when the current
+ * provider AND model match that scope. The old provider-only format is read as
+ * "legacy": it is shown back to the user but never used silently, because a
+ * provider-only key does not tell us which model it was meant for.
+ */
+import { readFileSync, writeFileSync, existsSync, renameSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { getPaths, lockdown, ensureDir } from "./paths.js";
+import { DEFAULT_THEME } from "./themes.js";
+export const DEFAULT_CONFIG = {
+    providerId: "anthropic",
+    model: "claude-sonnet-5.5",
+    theme: DEFAULT_THEME,
+    agentMode: true,
+    systemPrompt: "You are FastCode, a fast, friendly coding assistant in a terminal UI. " +
+        "Prefer concise responses. Use markdown when helpful (especially fenced " +
+        "code blocks). When the user asks for code changes, output complete files " +
+        "or unified diffs the user can apply.",
+    enabledSkills: [],
+    enabledPlugins: [],
+    skillsRegistry: "https://skillshub.wtf",
+    lifetimeCostUsd: 0,
+};
+export interface StoredCredential {
+    provider: string;
+    model: string;
+    key: string;
+    addedAt: string;
+}
+export interface AuthStore {
+    version: number;
+    /** Scoped credentials, keyed by `provider::model`. */
+    keys: Record<string, StoredCredential>;
+    /** Old provider-only keys we refuse to use until the user re-binds them. */
+    legacy: Record<string, string>;
+}
+export type KeyLookup = {
+    status: "ok";
+    key: string;
+    source: "file" | "env";
+    envVar?: string;
+} | {
+    status: "unbound";
+    provider: string;
+    legacyKey: string;
+} | {
+    status: "missing";
+};
+export function loadConfig() {
+    const { config } = getPaths();
+    if (!existsSync(config))
+        return { ...DEFAULT_CONFIG };
+    try {
+        const raw = JSON.parse(readFileSync(config, "utf8"));
+        return { ...DEFAULT_CONFIG, ...raw };
+    }
+    catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}
+export function saveConfig(cfg) {
+    const { config } = getPaths();
+    atomicWrite(config, JSON.stringify(cfg, null, 2));
+}
+/** Composite scope id for a provider + model credential. */
+export function scopeId(providerId, model) {
+    return `${providerId}::${model}`;
+}
+export function loadAuth(): AuthStore {
+    const { auth } = getPaths();
+    const empty: AuthStore = { version: 2, keys: {}, legacy: {} };
+    if (!existsSync(auth))
+        return empty;
+    try {
+        const raw = JSON.parse(readFileSync(auth, "utf8"));
+        const keys: Record<string, StoredCredential> = {};
+        const legacy: Record<string, string> = {};
+        const source = raw && typeof raw === "object" ? (raw.keys ?? {}) : {};
+        for (const [id, value] of Object.entries<any>(source)) {
+            if (value && typeof value === "object" && typeof value.key === "string") {
+                const [idProvider, idModel] = id.split("::");
+                const provider = value.provider || idProvider || id;
+                const model = value.model || idModel || "";
+                keys[scopeId(provider, model)] = {
+                    provider,
+                    model,
+                    key: value.key,
+                    addedAt: value.addedAt ?? "",
+                };
+            }
+            else if (typeof value === "string" && value.trim()) {
+                legacy[id] = value;
+            }
+        }
+        if (raw && typeof raw === "object" && raw.legacy && typeof raw.legacy === "object") {
+            for (const [id, value] of Object.entries<any>(raw.legacy)) {
+                if (typeof value === "string" && value.trim())
+                    legacy[id] = value;
+            }
+        }
+        return { version: 2, keys, legacy };
+    }
+    catch {
+        return empty;
+    }
+}
+export function saveAuth(store: AuthStore) {
+    const { auth } = getPaths();
+    const payload: any = { version: 2, keys: store.keys };
+    if (Object.keys(store.legacy).length > 0)
+        payload.legacy = store.legacy;
+    atomicWrite(auth, JSON.stringify(payload, null, 2));
+    lockdown(auth);
+}
+export function getCredential(providerId, model): StoredCredential | undefined {
+    return loadAuth().keys[scopeId(providerId, model)];
+}
+export function listCredentials(): StoredCredential[] {
+    return Object.values(loadAuth().keys);
+}
+export function listLegacy(): Array<{
+    provider: string;
+    key: string;
+}> {
+    return Object.entries<any>(loadAuth().legacy).map(([provider, key]) => ({ provider, key }));
+}
+export function getLegacy(providerId): string | undefined {
+    return loadAuth().legacy[providerId];
+}
+/** Save/replace the credential for one provider+model scope (drops the legacy key). */
+export function setCredential(providerId, model, key): StoredCredential {
+    const store = loadAuth();
+    const credential = {
+        provider: providerId,
+        model,
+        key: key.trim(),
+        addedAt: new Date().toISOString(),
+    };
+    store.keys[scopeId(providerId, model)] = credential;
+    delete store.legacy[providerId];
+    saveAuth(store);
+    return credential;
+}
+export function removeCredential(providerId, model): boolean {
+    const store = loadAuth();
+    const id = scopeId(providerId, model);
+    if (!store.keys[id])
+        return false;
+    delete store.keys[id];
+    saveAuth(store);
+    return true;
+}
+/** Remove every credential for a provider (all models) plus its legacy key. */
+export function removeCredentialsForProvider(providerId): number {
+    const store = loadAuth();
+    let removed = 0;
+    for (const id of Object.keys(store.keys)) {
+        if (store.keys[id].provider === providerId) {
+            delete store.keys[id];
+            removed += 1;
+        }
+    }
+    if (store.legacy[providerId]) {
+        delete store.legacy[providerId];
+        removed += 1;
+    }
+    if (removed > 0)
+        saveAuth(store);
+    return removed;
+}
+/** Turn a key into a safe terminal echo: `sk-****abcd`. */
+export function maskKey(key) {
+    const value = (key ?? "").trim();
+    if (!value)
+        return "";
+    if (value.length <= 8)
+        return "*".repeat(value.length);
+    return value.slice(0, 3) + "****" + value.slice(-4);
+}
+/**
+ * Resolve the key to use for a specific provider+model:
+ *   1. the scoped credential in auth.json (exact provider+model match), then
+ *   2. the provider's environment variable (provider-scoped, any model), and
+ *   3. report an "unbound" legacy key instead of using it silently.
+ */
+export function resolveApiKey(providerId, model, envVars): KeyLookup {
+    const store = loadAuth();
+    const scoped = store.keys[scopeId(providerId, model)];
+    if (scoped && scoped.key)
+        return { status: "ok", key: scoped.key, source: "file" };
+    for (const envVar of envVars ?? []) {
+        const value = process.env[envVar];
+        if (value && value.trim())
+            return { status: "ok", key: value.trim(), source: "env", envVar };
+    }
+    if (store.legacy[providerId])
+        return { status: "unbound", provider: providerId, legacyKey: store.legacy[providerId] };
+    return { status: "missing" };
+}
+/** Best-effort key for a provider regardless of model (used to list models). */
+export function resolveProviderKey(providerId, envVars): {
+    key?: string;
+    source?: "file" | "env";
+    envVar?: string;
+} {
+    const store = loadAuth();
+    for (const credential of Object.values(store.keys)) {
+        if (credential.provider === providerId && credential.key)
+            return { key: credential.key, source: "file" };
+    }
+    for (const envVar of envVars ?? []) {
+        const value = process.env[envVar];
+        if (value && value.trim())
+            return { key: value.trim(), source: "env", envVar };
+    }
+    return {};
+}
+/**
+ * Write-then-rename so a Ctrl+C mid-write never leaves a corrupt file.
+ *
+ * The temp file MUST live in the same directory as the target so the rename
+ * is a same-filesystem operation. On many Linux distros `/tmp` is a tmpfs
+ * mount, which would make `renameSync` throw EXDEV across filesystems.
+ */
+function atomicWrite(target, contents) {
+    const dir = dirname(target);
+    ensureDir(dir);
+    const tmp = join(dir, `.fastcode-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
+    writeFileSync(tmp, contents, { encoding: "utf8" });
+    renameSync(tmp, target);
+}