setclaw 1.2.1 → 1.3.1

package/README.md

@@ -65,6 +65,23 @@ npm i -g setclaw
 setclaw <your-quatarly-api-key>
 ```
 
+### What it does
+
+- ✔ Backs up your current env vars and Factory config to `~/.setclaw/backup.json`
+- ✔ Adds all 11 models to Factory AI Droid
+- ✔ Sets env vars **system-wide** (all users) — falls back to current user if no admin rights
+- ✔ Works on Windows, macOS, and Linux
+
+### Restore Original Settings
+
+Made a mistake or want to undo everything?
+
+```bash
+setclaw --restore
+```
+
+This removes all env vars setclaw set and restores your original Factory config from the backup.
+
 ---
 
 ## Using Claude Code
@@ -157,7 +174,18 @@ Then create an account at [app.factory.ai](https://app.factory.ai), run `droid`
 <details>
 <summary><b>Can I run it again with a different API key?</b></summary>
 
-Yes. Just run `npx setclaw@latest <new-key>` again — it updates existing models and env vars without creating duplicates. A backup of your Factory settings is saved before any changes.
+Yes. Just run `npx setclaw@latest <new-key>` or `setclaw <new-key>` again — it updates existing models and env vars without creating duplicates. A fresh backup is saved before every run.
+
+</details>
+
+<details>
+<summary><b>How do I restore my original settings?</b></summary>
+
+```bash
+setclaw --restore
+```
+
+This reverts all env vars to their pre-setclaw values and restores your original Factory config from `~/.setclaw/backup.json`.
 
 </details>
 

package/bin/setclaw.js

@@ -4,9 +4,9 @@
  * setclaw — BOA & Quatarly setup for Claude Code & Factory
  *
  * Usage:
- *   setclaw <API_KEY>
- *   QUATARLY_API_KEY=<key> setclaw
- *   setclaw              (prompts interactively)
+ *   setclaw <API_KEY>        — setup with key
+ *   setclaw                  — interactive prompt
+ *   setclaw --restore        — restore original env vars & Factory config
  */
 
 import { readFileSync, writeFileSync, copyFileSync, appendFileSync, existsSync, rmSync, mkdirSync } from "fs";
@@ -20,29 +20,30 @@ import { createInterface } from "readline";
 function ask(question) {
   const rl = createInterface({ input: process.stdin, output: process.stderr, terminal: true });
   return new Promise((resolve) =>
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer.trim());
-    })
+    rl.question(question, (answer) => { rl.close(); resolve(answer.trim()); })
   );
 }
 
-const out = (msg) => process.stdout.write(msg + "\n");
-const err = (msg) => process.stderr.write(msg + "\n");
-
-function log(msg)     { err(`\x1b[36m>\x1b[0m ${msg}`); }
-function success(msg) { err(`\x1b[32m✔\x1b[0m ${msg}`); }
-function warn(msg)    { err(`\x1b[33m!\x1b[0m ${msg}`); }
-function fail(msg)    { err(`\x1b[31m✖\x1b[0m ${msg}`); }
-
-// ─── First-run detection ──────────────────────────────────────────────
-// If run via npx (npm_execpath contains 'npx' or no global install marker),
-// skip the first-run gate and always go interactive.
-
-const markerFile = join(homedir(), ".setclaw", "pending");
-const isNpx = (process.env.npm_execpath || "").includes("npx") ||
-              process.argv[1].includes("_npx");
-const isFirstRun = !isNpx && existsSync(markerFile);
+const out  = (msg = "") => process.stdout.write(msg + "\n");
+const err  = (msg = "") => process.stderr.write(msg + "\n");
+const log  = (msg) => err(`\x1b[36m>\x1b[0m ${msg}`);
+const ok   = (msg) => err(`\x1b[32m✔\x1b[0m ${msg}`);
+const warn = (msg) => err(`\x1b[33m!\x1b[0m ${msg}`);
+const fail = (msg) => err(`\x1b[31m✖\x1b[0m ${msg}`);
+
+const OS          = platform();
+const HOME        = homedir();
+const BACKUP_DIR  = join(HOME, ".setclaw");
+const MARKER_FILE = join(BACKUP_DIR, "pending");
+const BACKUP_FILE = join(BACKUP_DIR, "backup.json");
+
+const VAR_KEYS = [
+  "ANTHROPIC_BASE_URL",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL",
+];
 
 // ─── Banner ──────────────────────────────────────────────────────────
 
@@ -51,11 +52,93 @@ out("\x1b[1m  setclaw\x1b[0m — BOA & Quatarly setup for Claude Code & Factory"
 out("  \x1b[2m─────────────────────────────────────────────────\x1b[0m");
 out("");
 
-// ─── Get API key ─────────────────────────────────────────────────────
+// ─── Arg parsing ─────────────────────────────────────────────────────
+
+const args    = process.argv.slice(2);
+const restore = args.includes("--restore");
+
+// Only treat an arg as API key if it doesn't start with - and looks like a key
+const keyArg  = args.find(a => !a.startsWith("-") && a.length > 8);
+const apiKey  = !restore ? (process.env.QUATARLY_API_KEY || keyArg) : null;
+
+// ─── First-run detection ──────────────────────────────────────────────
+
+const isNpx      = (process.env.npm_execpath || "").includes("npx") || process.argv[1].includes("_npx");
+const isFirstRun = !isNpx && existsSync(MARKER_FILE);
+
+// ════════════════════════════════════════════════════════════════════
+// RESTORE MODE
+// ════════════════════════════════════════════════════════════════════
+
+if (restore) {
+  if (!existsSync(BACKUP_FILE)) {
+    fail("No backup found. Nothing to restore.");
+    process.exit(1);
+  }
+
+  const backup = JSON.parse(readFileSync(BACKUP_FILE, "utf-8"));
+  log("Restoring original environment variables...");
+
+  if (OS === "win32") {
+    for (const key of VAR_KEYS) {
+      if (backup.env[key] !== undefined) {
+        // Restore to both user and system
+        try {
+          execSync(`reg add "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment" /v "${key}" /t REG_SZ /d "${backup.env[key]}" /f`, { stdio: "ignore" });
+        } catch {}
+        execSync(`reg add "HKCU\\Environment" /v "${key}" /t REG_SZ /d "${backup.env[key]}" /f`, { stdio: "ignore" });
+        ok(`Restored ${key} = ${backup.env[key] || "(empty)"}`);
+      } else {
+        // Was not set before — delete it
+        try {
+          execSync(`reg delete "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment" /v "${key}" /f`, { stdio: "ignore" });
+        } catch {}
+        try {
+          execSync(`reg delete "HKCU\\Environment" /v "${key}" /f`, { stdio: "ignore" });
+        } catch {}
+        ok(`Removed ${key} (was not set before)`);
+      }
+    }
+  } else {
+    // Remove setclaw block from all rc files
+    const marker    = "# --- Quatarly / Claude Code env ---";
+    const endMarker = "# --- end Quatarly ---";
+    const rcFiles   = ["/etc/environment", "/etc/zshenv", "/etc/bash.bashrc",
+                       join(HOME, ".bashrc"), join(HOME, ".zshrc")];
+    for (const rc of rcFiles) {
+      if (!existsSync(rc)) continue;
+      const content = readFileSync(rc, "utf-8");
+      if (!content.includes(marker)) continue;
+      const regex = new RegExp(
+        `\\n?${marker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${endMarker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`, "g"
+      );
+      writeFileSync(rc, content.replace(regex, ""), "utf-8");
+      ok(`Cleaned ${rc}`);
+    }
+  }
+
+  // Restore Factory settings
+  const factoryPath = join(HOME, ".factory", "settings.json");
+  if (backup.factory && existsSync(factoryPath)) {
+    log("Restoring Factory settings...");
+    writeFileSync(factoryPath, JSON.stringify(backup.factory, null, 2), "utf-8");
+    ok("Factory settings restored.");
+  }
+
+  // Clean up backup
+  try { rmSync(BACKUP_FILE); } catch {}
+
+  out("");
+  ok("Restore complete! Open a new terminal to apply changes.");
+  out("");
+  process.exit(0);
+}
 
-let apiKey = process.env.QUATARLY_API_KEY || process.argv[2];
+// ════════════════════════════════════════════════════════════════════
+// SETUP MODE
+// ════════════════════════════════════════════════════════════════════
 
-// If no key and this is first run (just installed), show clear instructions
+// First-run gate
 if (!apiKey && isFirstRun) {
   out("  \x1b[33m⚡ Setup required!\x1b[0m Run with your Quatarly API key:");
   out("");
@@ -66,32 +149,59 @@ if (!apiKey && isFirstRun) {
   process.exit(0);
 }
 
-if (!apiKey) {
-  try {
-    apiKey = await ask("  Enter your Quatarly API key: ");
-  } catch (err) {
-    fail(err.message);
-    process.exit(1);
+let key = apiKey;
+if (!key) {
+  try { key = await ask("  Enter your Quatarly API key: "); }
+  catch (e) { fail(e.message); process.exit(1); }
+}
+if (!key) { fail("API key cannot be empty."); process.exit(1); }
+
+err("");
+
+// ─── Backup current state ─────────────────────────────────────────────
+
+mkdirSync(BACKUP_DIR, { recursive: true });
+
+const backup = { env: {}, factory: null };
+
+if (OS === "win32") {
+  for (const k of VAR_KEYS) {
+    try {
+      const val = execSync(`reg query "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment" /v "${k}" 2>nul`, { encoding: "utf-8" });
+      const match = val.match(/REG_SZ\s+(.+)/);
+      backup.env[k] = match ? match[1].trim() : "";
+    } catch {
+      // Also try HKCU
+      try {
+        const val = execSync(`reg query "HKCU\\Environment" /v "${k}" 2>nul`, { encoding: "utf-8" });
+        const match = val.match(/REG_SZ\s+(.+)/);
+        backup.env[k] = match ? match[1].trim() : "";
+      } catch {
+        backup.env[k] = undefined; // Was not set
+      }
+    }
   }
 }
 
-if (!apiKey) {
-  fail("API key cannot be empty.");
-  process.exit(1);
+// Backup Factory settings
+const factoryPath = join(HOME, ".factory", "settings.json");
+if (existsSync(factoryPath)) {
+  let raw = readFileSync(factoryPath, "utf-8");
+  if (raw.charCodeAt(0) === 0xfeff) raw = raw.slice(1);
+  backup.factory = JSON.parse(raw.trim() || "{}");
 }
 
-process.stderr.write("\n");
+writeFileSync(BACKUP_FILE, JSON.stringify(backup, null, 2), "utf-8");
+ok(`Backup saved to ${BACKUP_FILE}`);
 
 // ─── Step 1: Add models to Factory ──────────────────────────────────
 
-const settingsPath = join(homedir(), ".factory", "settings.json");
-
-if (existsSync(settingsPath)) {
+if (existsSync(factoryPath)) {
   log("Adding models to Factory...");
 
-  copyFileSync(settingsPath, `${settingsPath}.backup`);
+  copyFileSync(factoryPath, `${factoryPath}.backup`);
 
-  let raw = readFileSync(settingsPath, "utf-8");
+  let raw = readFileSync(factoryPath, "utf-8");
   if (raw.charCodeAt(0) === 0xfeff) raw = raw.slice(1);
   const settings = JSON.parse(raw.trim() || "{}");
 
@@ -109,120 +219,136 @@ if (existsSync(settingsPath)) {
     { model: "gpt-5.3-codex",              baseUrl: "https://api.quatarly.cloud/v1", provider: "openai"    },
   ];
 
-  const existing = settings.customModels || [];
+  const existing      = settings.customModels || [];
   const existingNames = new Set(existing.map((m) => m.model));
-  let maxIndex = existing.reduce((max, m) => Math.max(max, m.index ?? -1), -1);
-  let nextIndex = maxIndex + 1;
-
-  let added = 0;
-  let updated = 0;
+  let maxIndex        = existing.reduce((max, m) => Math.max(max, m.index ?? -1), -1);
+  let nextIndex       = maxIndex + 1;
+  let added = 0, updated = 0;
 
   for (const m of newModels) {
     if (existingNames.has(m.model)) {
       for (const e of existing) {
-        if (e.model === m.model) {
-          e.apiKey = apiKey;
-          e.baseUrl = m.baseUrl;
-          e.provider = m.provider;
-        }
+        if (e.model === m.model) { e.apiKey = key; e.baseUrl = m.baseUrl; e.provider = m.provider; }
       }
       updated++;
     } else {
-      existing.push({
-        model: m.model,
-        id: `custom:${m.model}-${nextIndex}`,
-        index: nextIndex,
-        baseUrl: m.baseUrl,
-        apiKey,
-        displayName: m.model,
-        noImageSupport: false,
-        provider: m.provider,
-      });
-      nextIndex++;
-      added++;
+      existing.push({ model: m.model, id: `custom:${m.model}-${nextIndex}`, index: nextIndex,
+        baseUrl: m.baseUrl, apiKey: key, displayName: m.model, noImageSupport: false, provider: m.provider });
+      nextIndex++; added++;
     }
   }
 
   settings.customModels = existing;
-  writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
-
-  success(`Factory: ${added} models added, ${updated} updated (${existing.length} total)`);
-  success(`Backup saved to ${settingsPath}.backup`);
+  writeFileSync(factoryPath, JSON.stringify(settings, null, 2), "utf-8");
+  ok(`Factory: ${added} added, ${updated} updated (${existing.length} total)`);
 } else {
-  warn(`Factory settings not found at ${settingsPath} — skipped.`);
+  warn("Factory settings not found — skipped.");
 }
 
-// ─── Step 2: Set Claude Code env vars ────────────────────────────────
+// ─── Step 2: Set env vars (system-wide, fallback to user) ─────────────
 
-log("Setting Claude Code environment variables...");
+log("Setting environment variables system-wide...");
 
 const vars = {
   ANTHROPIC_BASE_URL:             "https://api.quatarly.cloud/",
-  ANTHROPIC_AUTH_TOKEN:           apiKey,
+  ANTHROPIC_AUTH_TOKEN:           key,
   ANTHROPIC_DEFAULT_HAIKU_MODEL:  "claude-haiku-4-5-20251001",
   ANTHROPIC_DEFAULT_SONNET_MODEL: "claude-sonnet-4-6-20250929",
   ANTHROPIC_DEFAULT_OPUS_MODEL:   "claude-opus-4-6-thinking",
 };
 
-const os = platform();
+if (OS === "win32") {
+  let usedSystem = false;
 
-if (os === "win32") {
-  for (const [key, value] of Object.entries(vars)) {
-    execSync(`reg add "HKCU\\Environment" /v "${key}" /t REG_SZ /d "${value}" /f`, {
-      stdio: "ignore",
-    });
+  // Try HKLM (system-wide, requires admin)
+  try {
+    for (const [k, v] of Object.entries(vars)) {
+      execSync(
+        `reg add "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment" /v "${k}" /t REG_SZ /d "${v}" /f`,
+        { stdio: "ignore" }
+      );
+    }
+    usedSystem = true;
+    ok("Env vars written system-wide (HKLM — all users).");
+  } catch {
+    // No admin — fall back to HKCU
+    warn("No admin rights — setting for current user only (HKCU).");
+    for (const [k, v] of Object.entries(vars)) {
+      execSync(`reg add "HKCU\\Environment" /v "${k}" /t REG_SZ /d "${v}" /f`, { stdio: "ignore" });
+    }
+    ok("Env vars written to HKCU\\Environment.");
   }
-  success("Env vars written to Windows registry (HKCU\\Environment).");
+
+  // Broadcast WM_SETTINGCHANGE so open apps pick up the change without reboot
+  try {
+    execSync(
+      `powershell -NoProfile -Command "[System.Environment]::SetEnvironmentVariable('_setclaw_refresh', $null, 'Machine')" 2>nul`,
+      { stdio: "ignore" }
+    );
+  } catch {}
+
 } else {
-  const marker = "# --- Quatarly / Claude Code env ---";
+  const marker    = "# --- Quatarly / Claude Code env ---";
   const endMarker = "# --- end Quatarly ---";
-  const block = [
-    "",
-    marker,
-    ...Object.entries(vars).map(([k, v]) => `export ${k}="${v}"`),
-    endMarker,
-    "",
-  ].join("\n");
+  const block     = ["", marker, ...Object.entries(vars).map(([k, v]) => `export ${k}="${v}"`), endMarker, ""].join("\n");
 
-  const rcFiles = [join(homedir(), ".bashrc"), join(homedir(), ".zshrc")];
-  const written = [];
+  // Try system-wide files first
+  const systemFiles = OS === "darwin"
+    ? ["/etc/zshenv", "/etc/bashrc"]
+    : ["/etc/environment", "/etc/bash.bashrc", "/etc/zshenv"];
 
-  for (const rc of rcFiles) {
-    if (!existsSync(rc)) continue;
+  const userFiles = [join(HOME, ".bashrc"), join(HOME, ".zshrc")];
+  let written = [];
 
+  const writeToRc = (rc) => {
+    if (!existsSync(rc)) return false;
     const content = readFileSync(rc, "utf-8");
     if (content.includes(marker)) {
       const regex = new RegExp(
-        `\\n?${marker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${endMarker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`,
-        "g"
+        `\\n?${marker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${endMarker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`, "g"
       );
       writeFileSync(rc, content.replace(regex, block), "utf-8");
     } else {
       appendFileSync(rc, block, "utf-8");
     }
-    written.push(rc);
+    return true;
+  };
+
+  // Try system-wide
+  let systemOk = false;
+  for (const rc of systemFiles) {
+    try {
+      if (writeToRc(rc)) { written.push(rc); systemOk = true; }
+    } catch {}
   }
 
-  if (written.length === 0) {
-    const fallback = join(homedir(), ".bashrc");
-    appendFileSync(fallback, block, "utf-8");
-    written.push(fallback);
+  if (systemOk) {
+    ok(`Env vars written system-wide: ${written.join(", ")}`);
+  } else {
+    warn("No write access to system files — writing to user profile.");
+    for (const rc of userFiles) {
+      if (writeToRc(rc)) written.push(rc);
+    }
+    if (written.length === 0) {
+      appendFileSync(join(HOME, ".bashrc"), block, "utf-8");
+      written.push(join(HOME, ".bashrc"));
+    }
+    ok(`Env vars written to: ${written.join(", ")}`);
   }
-
-  success(`Env vars written to: ${written.join(", ")}`);
 }
 
 // ─── Done ────────────────────────────────────────────────────────────
 
-// Clear the first-run marker
-try { rmSync(markerFile); } catch {}
+try { rmSync(MARKER_FILE); } catch {}
 
 out("");
 out("  \x1b[1mEnvironment variables set:\x1b[0m");
-for (const [key, value] of Object.entries(vars)) {
-  const display = key === "ANTHROPIC_AUTH_TOKEN" ? value.slice(0, 8) + "..." : value;
-  out(`    ${key} = ${display}`);
+for (const [k, v] of Object.entries(vars)) {
+  const display = k === "ANTHROPIC_AUTH_TOKEN" ? v.slice(0, 8) + "..." : v;
+  out(`    ${k} = ${display}`);
 }
 out("");
-success("All done! Restart your terminal, then launch Claude Code.");
+ok("All done! Open a new terminal, then launch Claude Code.");
+out("");
+out("  \x1b[2mTo restore original settings: setclaw --restore\x1b[0m");
 out("");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "setclaw",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "description": "BOA & Quatarly setup for Claude Code and Factory",
   "type": "module",
   "bin": {