@leeguoo/wrangler-accounts 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 leeguoo
+
+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,75 @@
+# wrangler-accounts
+
+Local CLI to manage multiple Cloudflare Wrangler login profiles by saving and swapping the Wrangler config file.
+
+## What it does
+
+- Save the current Wrangler config as a named profile
+- Switch between profiles by copying a saved config into place
+- List or inspect status (active profile and matching profile)
+- Optional automatic backups when switching
+
+## Install (npm)
+
+```bash
+npm i -g @leeguoo/wrangler-accounts
+```
+
+## Install (local)
+
+From this repo:
+
+```bash
+npm link
+```
+
+Or run directly:
+
+```bash
+node bin/wrangler-accounts.js <command>
+```
+
+## Usage
+
+```bash
+wrangler-accounts list
+wrangler-accounts status
+wrangler-accounts save work
+wrangler-accounts use personal
+wrangler-accounts remove old
+```
+
+## Options
+
+```text
+-c, --config <path>     Wrangler config path
+-p, --profiles <path>   Profiles directory
+--json                  JSON output for list/status
+-f, --force             Overwrite existing profile on save
+--backup                Backup current config on use (default)
+--no-backup             Disable backup on use
+```
+
+## Environment variables
+
+- WRANGLER_CONFIG_PATH
+- WRANGLER_ACCOUNTS_DIR
+- XDG_CONFIG_HOME
+
+## Defaults
+
+If you do not specify a config path, the CLI checks for these and uses the first existing path:
+
+- ~/.wrangler/config/default.toml
+- ~/.config/.wrangler/config/default.toml
+- ~/.config/wrangler/config/default.toml
+
+The profiles directory defaults to:
+
+- $XDG_CONFIG_HOME/wrangler-accounts (if set)
+- ~/.config/wrangler-accounts
+
+## Notes
+
+- Profile names accept only letters, numbers, dot, underscore, and dash.
+- On `use`, the current config is backed up into `__backup-YYYYMMDD-HHMMSS` unless you pass `--no-backup`.

package/bin/wrangler-accounts.js

@@ -0,0 +1,353 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const crypto = require("crypto");
+
+function die(message) {
+  console.error(`Error: ${message}`);
+  process.exit(1);
+}
+
+function printHelp(exitCode = 0) {
+  const text = `wrangler-accounts - manage multiple Wrangler login profiles
+
+Usage:
+  wrangler-accounts <command> [options]
+
+Commands:
+  list
+  status
+  save <name>
+  use <name>
+  remove <name>
+
+Options:
+  -c, --config <path>     Wrangler config path
+  -p, --profiles <path>   Profiles directory
+  --json                  JSON output for list/status
+  -f, --force             Overwrite existing profile on save
+  --backup                Backup current config on use (default)
+  --no-backup             Disable backup on use
+  -h, --help              Show help
+
+Env:
+  WRANGLER_CONFIG_PATH
+  WRANGLER_ACCOUNTS_DIR
+  XDG_CONFIG_HOME
+
+Examples:
+  wrangler-accounts save work
+  wrangler-accounts use personal
+`;
+  console.log(text);
+  process.exit(exitCode);
+}
+
+function expandHome(p) {
+  if (!p) return p;
+  if (p === "~") return os.homedir();
+  if (p.startsWith("~/")) return path.join(os.homedir(), p.slice(2));
+  return p;
+}
+
+function resolvePath(p) {
+  if (!p) return p;
+  return path.resolve(expandHome(p));
+}
+
+function parseArgs(argv) {
+  const opts = {
+    json: false,
+    force: false,
+    backup: true,
+  };
+  const rest = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--help" || arg === "-h") {
+      opts.help = true;
+    } else if (arg === "--json") {
+      opts.json = true;
+    } else if (arg === "--force" || arg === "-f") {
+      opts.force = true;
+    } else if (arg === "--backup") {
+      opts.backup = true;
+    } else if (arg === "--no-backup") {
+      opts.backup = false;
+    } else if (arg === "--config" || arg === "-c") {
+      opts.config = argv[i + 1];
+      if (!opts.config) die("Missing value for --config");
+      i += 1;
+    } else if (arg === "--profiles" || arg === "-p") {
+      opts.profiles = argv[i + 1];
+      if (!opts.profiles) die("Missing value for --profiles");
+      i += 1;
+    } else {
+      rest.push(arg);
+    }
+  }
+  return { opts, rest };
+}
+
+function detectConfigPath(cliPath) {
+  if (cliPath) return resolvePath(cliPath);
+  if (process.env.WRANGLER_CONFIG_PATH) {
+    return resolvePath(process.env.WRANGLER_CONFIG_PATH);
+  }
+
+  const home = os.homedir();
+  const candidates = [
+    path.join(home, ".wrangler", "config", "default.toml"),
+    path.join(home, ".config", ".wrangler", "config", "default.toml"),
+    path.join(home, ".config", "wrangler", "config", "default.toml"),
+  ];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+
+  return candidates[0];
+}
+
+function detectProfilesDir(cliPath) {
+  if (cliPath) return resolvePath(cliPath);
+  if (process.env.WRANGLER_ACCOUNTS_DIR) {
+    return resolvePath(process.env.WRANGLER_ACCOUNTS_DIR);
+  }
+
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg) return path.join(resolvePath(xdg), "wrangler-accounts");
+
+  return path.join(os.homedir(), ".config", "wrangler-accounts");
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function isValidName(name) {
+  return /^[A-Za-z0-9._-]+$/.test(name);
+}
+
+function listProfiles(profilesDir) {
+  if (!fs.existsSync(profilesDir)) return [];
+  const entries = fs.readdirSync(profilesDir, { withFileTypes: true });
+  return entries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .filter((name) => fs.existsSync(path.join(profilesDir, name, "config.toml")))
+    .sort();
+}
+
+function fileHash(filePath) {
+  const data = fs.readFileSync(filePath);
+  return crypto.createHash("sha256").update(data).digest("hex");
+}
+
+function filesEqual(pathA, pathB) {
+  if (!fs.existsSync(pathA) || !fs.existsSync(pathB)) return false;
+  const statA = fs.statSync(pathA);
+  const statB = fs.statSync(pathB);
+  if (statA.size !== statB.size) return false;
+  return fileHash(pathA) === fileHash(pathB);
+}
+
+function writeMeta(profileDir, name, sourcePath) {
+  const configPath = path.join(profileDir, "config.toml");
+  const stat = fs.statSync(configPath);
+  const meta = {
+    name,
+    savedAt: new Date().toISOString(),
+    sourcePath,
+    bytes: stat.size,
+    sha256: fileHash(configPath),
+  };
+  fs.writeFileSync(path.join(profileDir, "meta.json"), JSON.stringify(meta, null, 2));
+}
+
+function setActiveProfile(profilesDir, name) {
+  ensureDir(profilesDir);
+  fs.writeFileSync(path.join(profilesDir, "active"), `${name}\n`);
+}
+
+function getActiveProfile(profilesDir) {
+  const activePath = path.join(profilesDir, "active");
+  if (!fs.existsSync(activePath)) return null;
+  const value = fs.readFileSync(activePath, "utf8").trim();
+  return value.length ? value : null;
+}
+
+function timestampForFile() {
+  const now = new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return [
+    now.getFullYear(),
+    pad(now.getMonth() + 1),
+    pad(now.getDate()),
+    "-",
+    pad(now.getHours()),
+    pad(now.getMinutes()),
+    pad(now.getSeconds()),
+  ].join("");
+}
+
+function backupCurrentConfig(configPath, profilesDir) {
+  const backupName = `__backup-${timestampForFile()}`;
+  const backupDir = path.join(profilesDir, backupName);
+  ensureDir(backupDir);
+  fs.copyFileSync(configPath, path.join(backupDir, "config.toml"));
+  writeMeta(backupDir, backupName, configPath);
+  return backupName;
+}
+
+function findMatchingProfile(profilesDir, configPath) {
+  if (!fs.existsSync(configPath)) return null;
+  const configHash = fileHash(configPath);
+  const profiles = listProfiles(profilesDir);
+  for (const name of profiles) {
+    const profileConfig = path.join(profilesDir, name, "config.toml");
+    if (fileHash(profileConfig) === configHash) return name;
+  }
+  return null;
+}
+
+function saveProfile(name, configPath, profilesDir, force) {
+  if (!isValidName(name)) {
+    die(`Invalid profile name: ${name}`);
+  }
+  if (!fs.existsSync(configPath)) {
+    die(`Config file not found: ${configPath}`);
+  }
+
+  const profileDir = path.join(profilesDir, name);
+  if (fs.existsSync(profileDir) && !force) {
+    die(`Profile exists: ${name} (use --force to overwrite)`);
+  }
+
+  ensureDir(profileDir);
+  fs.copyFileSync(configPath, path.join(profileDir, "config.toml"));
+  writeMeta(profileDir, name, configPath);
+}
+
+function useProfile(name, configPath, profilesDir, backup) {
+  if (!isValidName(name)) {
+    die(`Invalid profile name: ${name}`);
+  }
+
+  const profileDir = path.join(profilesDir, name);
+  const profileConfig = path.join(profileDir, "config.toml");
+  if (!fs.existsSync(profileConfig)) {
+    die(`Profile not found: ${name}`);
+  }
+
+  let backupName = null;
+  if (backup && fs.existsSync(configPath) && !filesEqual(configPath, profileConfig)) {
+    backupName = backupCurrentConfig(configPath, profilesDir);
+  }
+
+  ensureDir(path.dirname(configPath));
+  fs.copyFileSync(profileConfig, configPath);
+  setActiveProfile(profilesDir, name);
+
+  return backupName;
+}
+
+function removeProfile(name, profilesDir) {
+  if (!isValidName(name)) {
+    die(`Invalid profile name: ${name}`);
+  }
+  const profileDir = path.join(profilesDir, name);
+  if (!fs.existsSync(profileDir)) {
+    die(`Profile not found: ${name}`);
+  }
+
+  fs.rmSync(profileDir, { recursive: true, force: true });
+
+  const active = getActiveProfile(profilesDir);
+  if (active === name) {
+    const activePath = path.join(profilesDir, "active");
+    if (fs.existsSync(activePath)) fs.unlinkSync(activePath);
+  }
+}
+
+function main() {
+  const { opts, rest } = parseArgs(process.argv.slice(2));
+  if (opts.help) printHelp(0);
+
+  const command = rest[0];
+  if (!command) printHelp(1);
+
+  const configPath = detectConfigPath(opts.config);
+  const profilesDir = detectProfilesDir(opts.profiles);
+
+  if (command === "list") {
+    const profiles = listProfiles(profilesDir);
+    if (opts.json) {
+      console.log(JSON.stringify(profiles, null, 2));
+    } else if (profiles.length === 0) {
+      console.log("No profiles found.");
+    } else {
+      console.log(profiles.join("\n"));
+    }
+    return;
+  }
+
+  if (command === "status") {
+    const profiles = listProfiles(profilesDir);
+    const active = getActiveProfile(profilesDir);
+    const match = findMatchingProfile(profilesDir, configPath);
+    const payload = {
+      configPath,
+      configExists: fs.existsSync(configPath),
+      profilesDir,
+      profileCount: profiles.length,
+      profiles,
+      activeProfile: active,
+      matchingProfile: match,
+    };
+
+    if (opts.json) {
+      console.log(JSON.stringify(payload, null, 2));
+    } else {
+      console.log(`Config: ${payload.configPath} (${payload.configExists ? "exists" : "missing"})`);
+      console.log(`Profiles: ${payload.profilesDir} (${payload.profileCount})`);
+      console.log(`Active: ${payload.activeProfile || "-"}`);
+      console.log(`Match: ${payload.matchingProfile || "-"}`);
+    }
+    return;
+  }
+
+  if (command === "save") {
+    const name = rest[1];
+    if (!name) die("Missing profile name for save");
+    ensureDir(profilesDir);
+    saveProfile(name, configPath, profilesDir, opts.force);
+    console.log(`Saved profile '${name}' from ${configPath}`);
+    return;
+  }
+
+  if (command === "use") {
+    const name = rest[1];
+    if (!name) die("Missing profile name for use");
+    ensureDir(profilesDir);
+    const backupName = useProfile(name, configPath, profilesDir, opts.backup);
+    const backupNote = backupName ? ` (backup: ${backupName})` : "";
+    console.log(`Switched to profile '${name}'${backupNote}`);
+    return;
+  }
+
+  if (command === "remove") {
+    const name = rest[1];
+    if (!name) die("Missing profile name for remove");
+    removeProfile(name, profilesDir);
+    console.log(`Removed profile '${name}'`);
+    return;
+  }
+
+  die(`Unknown command: ${command}`);
+}
+
+main();

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@leeguoo/wrangler-accounts",
+  "version": "0.1.0",
+  "description": "Local CLI to manage multiple Cloudflare Wrangler login profiles.",
+  "license": "MIT",
+  "bin": {
+    "wrangler-accounts": "bin/wrangler-accounts.js"
+  },
+  "files": [
+    "bin"
+  ],
+  "keywords": [
+    "cloudflare",
+    "wrangler",
+    "accounts",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/leeguooooo/wrangler-accounts.git"
+  },
+  "bugs": {
+    "url": "https://github.com/leeguooooo/wrangler-accounts/issues"
+  },
+  "homepage": "https://github.com/leeguooooo/wrangler-accounts#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=16"
+  }
+}