pennyrouter 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PennyRouter
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+# PennyRouter CLI
+
+Local installer for PennyRouter coding-agent integrations.
+
+```bash
+npx pennyrouter install
+npx pennyrouter install --harness opencode,codex
+npx pennyrouter uninstall
+npx pennyrouter status
+```
+
+The CLI owns local config changes, backups, browser authorization, and uninstall metadata.
+The machine-readable pages at `https://pennyrouter.com/install` and
+`https://pennyrouter.com/uninstall` should tell coding agents to invoke this CLI instead of
+editing config files directly.

package/bin/pennyrouter.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { main } from "../src/cli.js";
+
+main().catch((error) => {
+  console.error(error?.message || String(error));
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "pennyrouter",
+  "version": "0.1.0",
+  "description": "Install and manage PennyRouter local coding-agent integrations.",
+  "type": "module",
+  "bin": {
+    "pennyrouter": "bin/pennyrouter.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node ./bin/pennyrouter.js",
+    "check": "node --check ./bin/pennyrouter.js && find src -name '*.js' -print0 | xargs -0 -n1 node --check"
+  },
+  "license": "MIT"
+}

package/src/cli.js

@@ -0,0 +1,304 @@
+import { spawnSync } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { codexHarness } from "./harnesses/codex.js";
+import { opencodeHarness } from "./harnesses/opencode.js";
+import {
+  APP_URL,
+  createCliSession,
+  maskKey,
+  pollForKey,
+  sleep,
+} from "./session.js";
+import {
+  expandHome,
+  loadManifest,
+  readJsonFile,
+  saveManifest,
+  statePath,
+} from "./state.js";
+
+const HARNESS_BY_ID = {
+  opencode: opencodeHarness,
+  codex: codexHarness,
+};
+
+const PLANNED_HARNESSES = [
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    reason: "Claude Code support is planned; this preview CLI does not mutate Claude settings yet.",
+  },
+  {
+    id: "cline",
+    name: "Cline",
+    reason: "Cline support is planned; this preview CLI does not mutate VS Code settings yet.",
+  },
+];
+
+export async function main(argv = process.argv.slice(2)) {
+  const { command, flags } = parseArgs(argv);
+
+  if (flags.help || command === "help") {
+    printHelp();
+    return;
+  }
+
+  if (command === "install") {
+    await install(flags);
+    return;
+  }
+
+  if (command === "uninstall") {
+    await uninstall(flags);
+    return;
+  }
+
+  if (command === "status") {
+    await status();
+    return;
+  }
+
+  throw new Error(`Unknown command "${command}". Run "pennyrouter help".`);
+}
+
+function parseArgs(argv) {
+  const command = argv[0] && !argv[0].startsWith("-") ? argv[0] : "install";
+  const rest = command === argv[0] ? argv.slice(1) : argv;
+  const flags = {};
+
+  for (let i = 0; i < rest.length; i += 1) {
+    const arg = rest[i];
+    if (arg === "--help" || arg === "-h") flags.help = true;
+    else if (arg === "--yes" || arg === "-y") flags.yes = true;
+    else if (arg === "--all") flags.all = true;
+    else if (arg === "--dry-run") flags.dryRun = true;
+    else if (arg === "--no-browser") flags.noBrowser = true;
+    else if (arg === "--harness") flags.harness = rest[++i] || "";
+    else if (arg.startsWith("--harness=")) flags.harness = arg.slice("--harness=".length);
+    else if (arg === "--app-url") flags.appUrl = rest[++i] || "";
+    else if (arg.startsWith("--app-url=")) flags.appUrl = arg.slice("--app-url=".length);
+    else throw new Error(`Unknown option "${arg}". Run "pennyrouter help".`);
+  }
+
+  return { command, flags };
+}
+
+async function install(flags) {
+  const selected = await selectHarnesses(flags);
+  if (selected.length === 0) {
+    console.log("No supported harnesses selected.");
+    return;
+  }
+
+  console.log("PennyRouter install");
+  console.log("");
+  console.log("Selected tools:");
+  for (const harness of selected) console.log(`  - ${harness.name}`);
+  console.log("");
+
+  if (flags.dryRun) {
+    for (const harness of selected) {
+      const plan = await harness.planInstall();
+      printPlan(harness, plan);
+    }
+    console.log("Dry run only. No files changed.");
+    return;
+  }
+
+  const session = await createCliSession({
+    appUrl: flags.appUrl || APP_URL,
+    harnesses: selected.map((harness) => harness.id),
+  });
+
+  console.log("Opening your browser to authorize this machine...");
+  console.log(`If your browser did not open, visit:\n${session.authorize_url}`);
+  if (!flags.noBrowser) openBrowser(session.authorize_url);
+  console.log("");
+  console.log("Waiting for approval...");
+
+  const claim = await pollForKey(session);
+  console.log(`Authorized. Received key ${maskKey(claim.api_key)}.`);
+  console.log("");
+
+  const manifest = await loadManifest();
+  const records = [];
+  for (const harness of selected) {
+    const plan = await harness.planInstall();
+    printPlan(harness, plan);
+    const record = await harness.install({
+      apiKey: claim.api_key,
+      gatewayBaseUrl: claim.gateway_base_url,
+      plan,
+    });
+    records.push(record);
+    upsertManifestRecord(manifest, record);
+  }
+
+  await saveManifest(manifest);
+  console.log("");
+  console.log("Installed PennyRouter.");
+  console.log(`Manifest: ${statePath("installations.json")}`);
+  for (const record of records) {
+    if (record.restart) console.log(`${record.harness}: ${record.restart}`);
+  }
+}
+
+async function uninstall(flags) {
+  const manifest = await loadManifest();
+  const records = manifest.installations || [];
+  const selectedIds = resolveRequestedHarnessIds(flags, records.map((record) => record.harness));
+  const selectedRecords = records.filter((record) => selectedIds.includes(record.harness));
+
+  if (selectedRecords.length === 0) {
+    console.log("No matching PennyRouter installations found.");
+    return;
+  }
+
+  console.log("PennyRouter uninstall");
+  console.log("");
+  for (const record of selectedRecords) {
+    console.log(`  - ${record.harness}: ${record.config_path}`);
+  }
+  console.log("");
+
+  if (!flags.yes) {
+    const ok = await confirm("Remove these PennyRouter local integrations?");
+    if (!ok) return;
+  }
+
+  const kept = [];
+  for (const record of records) {
+    if (!selectedIds.includes(record.harness)) {
+      kept.push(record);
+      continue;
+    }
+
+    const harness = HARNESS_BY_ID[record.harness];
+    if (!harness) {
+      console.log(`Skipping ${record.harness}: this CLI no longer knows how to uninstall it.`);
+      kept.push(record);
+      continue;
+    }
+
+    await harness.uninstall(record);
+    console.log(`Removed ${record.harness}.`);
+  }
+
+  manifest.installations = kept;
+  await saveManifest(manifest);
+}
+
+async function status() {
+  const manifest = await loadManifest();
+  const records = manifest.installations || [];
+  console.log("PennyRouter local setup");
+  console.log("");
+
+  if (records.length === 0) {
+    console.log("No local PennyRouter integrations recorded.");
+    return;
+  }
+
+  for (const record of records) {
+    console.log(`${record.harness}: installed`);
+    console.log(`  config: ${record.config_path}`);
+    if (record.backup_path) console.log(`  backup: ${record.backup_path}`);
+    if (record.installed_at) console.log(`  installed: ${record.installed_at}`);
+  }
+}
+
+async function selectHarnesses(flags) {
+  const requested = flags.all ? Object.keys(HARNESS_BY_ID) : parseHarnessList(flags.harness);
+  const detected = [];
+  for (const harness of Object.values(HARNESS_BY_ID)) {
+    if (await harness.detect()) detected.push(harness);
+  }
+
+  for (const planned of PLANNED_HARNESSES) {
+    if (requested.includes(planned.id)) console.log(`${planned.name}: ${planned.reason}`);
+  }
+
+  if (requested.length > 0) {
+    return requested.map((id) => HARNESS_BY_ID[id]).filter(Boolean);
+  }
+
+  if (detected.length === 0) {
+    console.log("No supported harness configs were detected.");
+    console.log("Use --harness opencode,codex to create config for specific tools.");
+    return [];
+  }
+
+  if (flags.yes || detected.length === 1) return detected;
+
+  console.log("Detected supported tools:");
+  detected.forEach((harness, index) => console.log(`  ${index + 1}. ${harness.name}`));
+  console.log("  a. All detected");
+  console.log("");
+
+  const rl = createInterface({ input, output });
+  const answer = await rl.question("Install for which tools? Enter numbers, comma-separated, or 'a': ");
+  rl.close();
+
+  if (answer.trim().toLowerCase() === "a") return detected;
+  const indexes = answer
+    .split(",")
+    .map((part) => Number(part.trim()) - 1)
+    .filter((index) => Number.isInteger(index) && detected[index]);
+  return [...new Set(indexes)].map((index) => detected[index]);
+}
+
+function parseHarnessList(value = "") {
+  return value
+    .split(",")
+    .map((part) => part.trim())
+    .filter(Boolean);
+}
+
+function resolveRequestedHarnessIds(flags, defaults) {
+  if (flags.all) return defaults;
+  const requested = parseHarnessList(flags.harness);
+  return requested.length > 0 ? requested : defaults;
+}
+
+function upsertManifestRecord(manifest, record) {
+  manifest.installations ||= [];
+  manifest.installations = manifest.installations.filter((existing) => existing.harness !== record.harness);
+  manifest.installations.push(record);
+}
+
+async function confirm(question) {
+  const rl = createInterface({ input, output });
+  const answer = await rl.question(`${question} [y/N] `);
+  rl.close();
+  return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+}
+
+function printPlan(harness, plan) {
+  console.log(`${harness.name}:`);
+  for (const line of plan.summary) console.log(`  - ${line}`);
+}
+
+function openBrowser(url) {
+  const platform = process.platform;
+  const command =
+    platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
+  const args = platform === "win32" ? ["/c", "start", "", url] : [url];
+  spawnSync(command, args, { stdio: "ignore", detached: true });
+}
+
+function printHelp() {
+  console.log(`PennyRouter CLI
+
+Usage:
+  pennyrouter install [--harness opencode,codex] [--all] [--yes] [--dry-run]
+  pennyrouter uninstall [--harness opencode,codex] [--all] [--yes]
+  pennyrouter status
+
+Examples:
+  npx pennyrouter install
+  npx pennyrouter install --all
+  npx pennyrouter install --harness opencode,codex --yes
+  npx pennyrouter uninstall
+`);
+}

package/src/harnesses/codex.js

@@ -0,0 +1,66 @@
+import { atomicWrite, backupFile, compactHome, exists, expandHome, readText } from "../state.js";
+
+const CONFIG_PATH = "~/.codex/config.toml";
+
+export const codexHarness = {
+  id: "codex",
+  name: "Codex",
+
+  async detect() {
+    return exists(CONFIG_PATH);
+  },
+
+  async planInstall() {
+    return {
+      configPath: expandHome(CONFIG_PATH),
+      summary: [
+        `write ${CONFIG_PATH}`,
+        "set OpenAI-compatible base URL to PennyRouter",
+        "store the PennyRouter API key without printing it",
+      ],
+    };
+  },
+
+  async install({ apiKey, gatewayBaseUrl, plan }) {
+    const current = await readText(CONFIG_PATH, "");
+    const backupPath = await backupFile(CONFIG_PATH, "codex");
+    const next = setTomlValue(
+      setTomlValue(current, "openai_base_url", `${gatewayBaseUrl}/v1`),
+      "openai_api_key",
+      apiKey,
+    );
+
+    await atomicWrite(CONFIG_PATH, next);
+
+    return {
+      harness: "codex",
+      config_path: compactHome(plan.configPath),
+      backup_path: backupPath ? compactHome(backupPath) : null,
+      installed_at: new Date().toISOString(),
+      restart: "restart Codex",
+      changes: {
+        keys: ["openai_base_url", "openai_api_key"],
+      },
+    };
+  },
+
+  async uninstall(record) {
+    const text = await readText(record.config_path, "");
+    const next = text
+      .split("\n")
+      .filter((line) => !/^\s*openai_base_url\s*=/.test(line))
+      .filter((line) => !/^\s*openai_api_key\s*=/.test(line))
+      .join("\n")
+      .replace(/\n{3,}/g, "\n\n");
+    await atomicWrite(record.config_path, next.endsWith("\n") ? next : `${next}\n`);
+  },
+};
+
+function setTomlValue(text, key, value) {
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  const line = `${key} = "${escaped}"`;
+  const pattern = new RegExp(`^\\s*${key}\\s*=.*$`, "m");
+  if (pattern.test(text)) return text.replace(pattern, line);
+  const normalized = text.trimEnd();
+  return `${normalized}${normalized ? "\n" : ""}${line}\n`;
+}

package/src/harnesses/opencode.js

@@ -0,0 +1,157 @@
+import {
+  atomicWrite,
+  backupFile,
+  compactHome,
+  exists,
+  expandHome,
+  readJsonFile,
+  readText,
+  writeJsonFile,
+} from "../state.js";
+
+const JSONC_PATH = "~/.config/opencode/opencode.jsonc";
+const JSON_PATH = "~/.config/opencode/opencode.json";
+const MODEL_STATE_PATH = "~/.local/state/opencode/model.json";
+
+export const opencodeHarness = {
+  id: "opencode",
+  name: "opencode",
+
+  async detect() {
+    return (await exists(JSONC_PATH)) || (await exists(JSON_PATH));
+  },
+
+  async planInstall() {
+    const configPath = (await exists(JSONC_PATH)) ? JSONC_PATH : JSON_PATH;
+    return {
+      configPath: expandHome(configPath),
+      summary: [
+        `write ${configPath}`,
+        "merge PennyRouter provider without replacing existing providers",
+        `reset ${MODEL_STATE_PATH} so opencode rediscovers configured models`,
+      ],
+    };
+  },
+
+  async install({ apiKey, gatewayBaseUrl, plan }) {
+    const configPath = compactHome(plan.configPath);
+    const backupPath = await backupFile(configPath, "opencode");
+    const current = await readConfig(configPath);
+    current.provider ||= {};
+    current.provider.pennyrouter = {
+      npm: "@ai-sdk/openai-compatible",
+      name: "PennyRouter",
+      options: {
+        baseURL: `${gatewayBaseUrl}/v1`,
+        apiKey,
+      },
+      models: {
+        "pennyrouter/auto": { name: "PennyRouter Auto" },
+        "pennyrouter/anthropic": { name: "PennyRouter Anthropic" },
+        "pennyrouter/openai": { name: "PennyRouter OpenAI" },
+        "pennyrouter/gemini": { name: "PennyRouter Gemini" },
+        "pennyrouter/grok": { name: "PennyRouter Grok" },
+        "pennyrouter/deepseek": { name: "PennyRouter DeepSeek" },
+        "pennyrouter/zai": { name: "PennyRouter Z.ai" },
+        "pennyrouter/qwen": { name: "PennyRouter Qwen" },
+        "pennyrouter/penny": { name: "PennyRouter Penny" },
+      },
+    };
+
+    await atomicWrite(configPath, `${JSON.stringify(current, null, 2)}\n`);
+
+    const modelBackupPath = await backupFile(MODEL_STATE_PATH, "opencode-model");
+    await writeJsonFile(MODEL_STATE_PATH, { recent: [], favorite: [], variant: {} });
+
+    return {
+      harness: "opencode",
+      config_path: compactHome(plan.configPath),
+      backup_path: backupPath ? compactHome(backupPath) : null,
+      installed_at: new Date().toISOString(),
+      restart: "type /exit, run opencode again, then pick PennyRouter Auto",
+      changes: {
+        provider_id: "pennyrouter",
+        model_state_path: MODEL_STATE_PATH,
+        model_state_backup_path: modelBackupPath ? compactHome(modelBackupPath) : null,
+      },
+    };
+  },
+
+  async uninstall(record) {
+    const current = await readConfig(record.config_path);
+    if (current.provider?.pennyrouter) delete current.provider.pennyrouter;
+    if (current.provider && Object.keys(current.provider).length === 0) delete current.provider;
+    await atomicWrite(record.config_path, `${JSON.stringify(current, null, 2)}\n`);
+
+    const model = (await readJsonFile(MODEL_STATE_PATH, null)) || {};
+    model.recent = removePennyRouterModels(model.recent);
+    model.favorite = removePennyRouterModels(model.favorite);
+    if (model.variant && typeof model.variant === "object") {
+      for (const [key, value] of Object.entries(model.variant)) {
+        if (isPennyRouterModel(key) || isPennyRouterModel(value)) delete model.variant[key];
+      }
+    }
+    await writeJsonFile(MODEL_STATE_PATH, model);
+  },
+};
+
+async function readConfig(path) {
+  const text = await readText(path, "");
+  if (!text.trim()) return {};
+  return JSON.parse(stripJsonComments(text));
+}
+
+function stripJsonComments(text) {
+  let result = "";
+  let inString = false;
+  let quote = "";
+  let escaped = false;
+
+  for (let i = 0; i < text.length; i += 1) {
+    const char = text[i];
+    const next = text[i + 1];
+
+    if (inString) {
+      result += char;
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === quote) inString = false;
+      continue;
+    }
+
+    if (char === '"' || char === "'") {
+      inString = true;
+      quote = char;
+      result += char;
+      continue;
+    }
+
+    if (char === "/" && next === "/") {
+      while (i < text.length && text[i] !== "\n") i += 1;
+      result += "\n";
+      continue;
+    }
+
+    if (char === "/" && next === "*") {
+      i += 2;
+      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i += 1;
+      i += 1;
+      continue;
+    }
+
+    result += char;
+  }
+
+  return result;
+}
+
+function removePennyRouterModels(value) {
+  if (!Array.isArray(value)) return Array.isArray(value) ? [] : value;
+  return value.filter((item) => !isPennyRouterModel(item));
+}
+
+function isPennyRouterModel(value) {
+  if (typeof value === "string") return value.includes("pennyrouter");
+  if (value && typeof value === "object") return JSON.stringify(value).includes("pennyrouter");
+  return false;
+}

package/src/session.js

@@ -0,0 +1,53 @@
+export const APP_URL = process.env.PENNYROUTER_APP_URL || "https://pennyrouter.com";
+
+export function maskKey(key) {
+  if (!key || key.length < 8) return "pr-...";
+  return `${key.slice(0, 3)}...${key.slice(-4)}`;
+}
+
+export async function createCliSession({ appUrl = APP_URL, harnesses }) {
+  const label = `${platformName()} / ${harnesses.join(",") || "PennyRouter"}`;
+  const response = await fetch(`${appUrl}/api/cli/session`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      harness: harnesses.join(","),
+      label,
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to create setup session: HTTP ${response.status}`);
+  }
+
+  return response.json();
+}
+
+export async function pollForKey(session) {
+  const interval = session.poll_interval_ms || 2000;
+  const deadline = Date.now() + (session.expires_in_s || 900) * 1000;
+
+  while (Date.now() < deadline) {
+    const response = await fetch(session.claim_url);
+    if (!response.ok) throw new Error(`Claim failed: HTTP ${response.status}`);
+    const body = await response.json();
+
+    if (body.status === "ready" && body.api_key) return body;
+    if (body.status === "expired") throw new Error("Setup session expired. Run install again.");
+    if (body.status === "claimed") throw new Error("Setup session was already claimed. Run install again.");
+    await sleep(interval);
+  }
+
+  throw new Error("Timed out waiting for authorization.");
+}
+
+export function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function platformName() {
+  if (process.platform === "darwin") return "Mac";
+  if (process.platform === "win32") return "Windows";
+  if (process.platform === "linux") return "Linux";
+  return "Machine";
+}

package/src/state.js

@@ -0,0 +1,91 @@
+import { constants } from "node:fs";
+import { access, copyFile, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+export function homeDir() {
+  return process.env.HOME || process.env.USERPROFILE || "";
+}
+
+export function expandHome(path) {
+  if (path === "~") return homeDir();
+  if (path.startsWith("~/")) return join(homeDir(), path.slice(2));
+  return path;
+}
+
+export function compactHome(path) {
+  const home = homeDir();
+  return home && path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+}
+
+export function statePath(...parts) {
+  const base =
+    process.env.XDG_STATE_HOME ||
+    (process.platform === "darwin"
+      ? join(homeDir(), ".local", "state")
+      : join(homeDir(), ".local", "state"));
+  return join(base, "pennyrouter", ...parts);
+}
+
+export async function exists(path) {
+  try {
+    await access(expandHome(path), constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function readText(path, fallback = "") {
+  try {
+    return await readFile(expandHome(path), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return fallback;
+    throw error;
+  }
+}
+
+export async function writeText(path, text) {
+  const expanded = expandHome(path);
+  await mkdir(dirname(expanded), { recursive: true });
+  await writeFile(expanded, text, "utf8");
+}
+
+export async function readJsonFile(path, fallback = null) {
+  const text = await readText(path, "");
+  if (!text.trim()) return fallback;
+  return JSON.parse(text);
+}
+
+export async function writeJsonFile(path, value) {
+  await writeText(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+export async function loadManifest() {
+  return (await readJsonFile(statePath("installations.json"), null)) || {
+    version: 1,
+    installations: [],
+  };
+}
+
+export async function saveManifest(manifest) {
+  await writeJsonFile(statePath("installations.json"), manifest);
+}
+
+export async function backupFile(path, harness) {
+  const expanded = expandHome(path);
+  if (!(await exists(expanded))) return null;
+  const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\..+/, "Z");
+  const ext = expanded.split(".").pop();
+  const backupPath = statePath("backups", `${harness}-${stamp}.${ext || "bak"}`);
+  await mkdir(dirname(backupPath), { recursive: true });
+  await copyFile(expanded, backupPath);
+  return backupPath;
+}
+
+export async function atomicWrite(path, text) {
+  const expanded = expandHome(path);
+  await mkdir(dirname(expanded), { recursive: true });
+  const temp = `${expanded}.pennyrouter-tmp`;
+  await writeFile(temp, text, "utf8");
+  await rename(temp, expanded);
+}