impel-cli 0.7.0

package/src/commands/use.js

@@ -0,0 +1,208 @@
+// `impel use gateway|account [claude|codex|all]` and its aliases `impel on` /
+// `impel off`. This is the reversible switch between:
+//   - gateway mode: Claude Code / Codex route through the Impel custom gateway
+//   - account mode: the developer's own Anthropic / OpenAI login
+//
+// The switch is per-tool and idempotent. When we turn gateway mode ON we back
+// up whatever the tool had before (its own apiKeyHelper / base URL / Codex
+// model_provider) into the impel config, so turning it OFF restores exactly
+// that — never a guess.
+
+import { loadConfig, saveConfig, resolveDefaultGateway } from "../config.js";
+import {
+  applyClaudeGateway,
+  revertClaudeGateway,
+  isImpelApiKeyHelper,
+  isImpelClaudeBaseUrl,
+} from "../claudeSetup.js";
+import {
+  applyCodexGateway,
+  revertCodexGateway,
+  CODEX_HOME,
+  PROVIDER_ID,
+} from "../codexSetup.js";
+import { syncSkillsSafe } from "../skills.js";
+
+const VALID_TARGETS = ["claude", "codex", "all"];
+
+function wantsClaude(target) {
+  return target === "all" || target === "claude";
+}
+function wantsCodex(target) {
+  return target === "all" || target === "codex";
+}
+
+/** Store a fresh account-mode backup, but only when transitioning account -> gateway. */
+function ensureBackup(config, tool) {
+  config.backups = config.backups || {};
+  config.backups[tool] = config.backups[tool] || {};
+  return config.backups[tool];
+}
+
+export function cmdUse({ mode, target = "all", app = false }) {
+  if (!VALID_TARGETS.includes(target)) {
+    console.error(`impel: unknown target "${target}". Use \`claude\`, \`codex\`, or \`all\`.`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (mode === "gateway") return useGateway({ target, app });
+  if (mode === "account") return useAccount({ target, app });
+
+  console.error(`impel: unknown mode "${mode}". Use \`gateway\` or \`account\`.`);
+  process.exitCode = 1;
+}
+
+async function useGateway({ target, app }) {
+  const config = loadConfig();
+  if (!config?.pat) {
+    console.error("impel: not authenticated. Run `impel setup` (or `impel auth`) first.");
+    process.exitCode = 1;
+    return;
+  }
+  const gatewayUrl = config.gatewayUrl || resolveDefaultGateway();
+
+  if (wantsClaude(target)) {
+    const result = applyClaudeGateway(gatewayUrl);
+    const backup = ensureBackup(config, "claude");
+    // Only capture the account-mode value; if the prior value was already
+    // Impel's own (re-apply), keep whatever we backed up the first time.
+    if (!isImpelApiKeyHelper(result.priorApiKeyHelper)) {
+      backup.apiKeyHelper = result.priorApiKeyHelper ?? null;
+    }
+    if (!isImpelClaudeBaseUrl(result.priorBaseUrl, gatewayUrl)) {
+      backup.ANTHROPIC_BASE_URL = result.priorBaseUrl ?? null;
+    }
+    console.log(`Claude Code -> GATEWAY  (${result.path})`);
+    console.log(`  apiKeyHelper = "${result.apiKeyHelper}"`);
+    console.log(`  env.ANTHROPIC_BASE_URL = "${result.baseUrl}"`);
+    console.log(`  MCP server = "impel" (direct Impel CLI invocation)`);
+  }
+
+  if (wantsCodex(target)) {
+    let result;
+    try {
+      result = applyCodexGateway(gatewayUrl);
+    } catch (err) {
+      console.error(`impel: ${err.message}`);
+      process.exitCode = 1;
+      return;
+    }
+    const backup = ensureBackup(config, "codex");
+    if (result.priorProviderValue !== PROVIDER_ID) {
+      backup.model_provider = result.priorProviderValue ?? null;
+    }
+
+    console.log(`Codex ${app ? "app/IDE" : "CLI"} -> GATEWAY  (${result.path})`);
+    console.log(`  model_provider = "${PROVIDER_ID}"`);
+    console.log(`  [model_providers.${PROVIDER_ID}] base_url = "${result.baseUrl}"`);
+    console.log(`  [model_providers.${PROVIDER_ID}.auth] = direct Impel CLI invocation`);
+    console.log(`  [mcp_servers.${PROVIDER_ID}] = direct Impel CLI invocation`);
+  }
+
+  saveConfig(config);
+
+  // Best-effort: pull the latest Bifrost shared skills into whichever managed
+  // profile we just pointed at the gateway. Never fails the setup.
+  if (wantsClaude(target)) {
+    await syncSkillsSafe({ client: "claude", gatewayUrl, env: {}, label: "Claude Code (gateway)" });
+  }
+  if (wantsCodex(target)) {
+    await syncSkillsSafe({ client: "codex", gatewayUrl, env: { CODEX_HOME }, label: "Codex CLI (gateway)" });
+  }
+
+  console.log("");
+  printGatewayNextSteps({ target, app });
+}
+
+function useAccount({ target, app }) {
+  const config = loadConfig();
+  const gatewayUrl = config?.gatewayUrl || resolveDefaultGateway();
+  const backups = config?.backups || {};
+
+  if (wantsClaude(target)) {
+    const result = revertClaudeGateway(gatewayUrl, backups.claude || {});
+    if (!result.exists) {
+      console.log(`Claude Code -> ACCOUNT  (nothing to revert; ${result.path} doesn't exist)`);
+    } else if (!result.changed) {
+      console.log(`Claude Code -> ACCOUNT  (already in account mode; no Impel keys found)`);
+    } else {
+      console.log(`Claude Code -> ACCOUNT  (${result.path})`);
+      if (result.removedHelper) {
+        console.log(
+          result.restoredApiKeyHelper != null
+            ? `  restored apiKeyHelper = "${result.restoredApiKeyHelper}"`
+            : `  removed Impel apiKeyHelper`
+        );
+      }
+      if (result.removedBaseUrl) {
+        console.log(
+          result.restoredBaseUrl != null
+            ? `  restored env.ANTHROPIC_BASE_URL = "${result.restoredBaseUrl}"`
+            : `  removed Impel env.ANTHROPIC_BASE_URL`
+        );
+      }
+      if (result.removedMcpServer) {
+        console.log(`  removed Impel MCP server`);
+      }
+    }
+    if (config?.backups) delete config.backups.claude;
+  }
+
+  if (wantsCodex(target)) {
+    const result = revertCodexGateway(backups.codex || {});
+    if (!result.exists) {
+      console.log(`Codex ${app ? "app/IDE" : "CLI"} -> ACCOUNT  (nothing to revert; ${result.path} doesn't exist)`);
+    } else if (!result.changed) {
+      console.log(`Codex ${app ? "app/IDE" : "CLI"} -> ACCOUNT  (already in account mode; no Impel block found)`);
+    } else {
+      console.log(`Codex ${app ? "app/IDE" : "CLI"} -> ACCOUNT  (${result.path})`);
+      if (result.removedBlock) console.log(`  removed [model_providers.${PROVIDER_ID}] block`);
+      if (result.resetProvider) {
+        console.log(
+          result.restoredProvider != null
+            ? `  restored model_provider = "${result.restoredProvider}"`
+            : `  removed model_provider line (Codex falls back to its default)`
+        );
+      }
+    }
+    if (config?.backups) delete config.backups.codex;
+  }
+
+  if (config) saveConfig(config);
+
+  console.log("");
+  printAccountNextSteps({ target, app });
+}
+
+function printGatewayNextSteps({ target, app }) {
+  console.log("Next steps:");
+  if (wantsClaude(target)) {
+    console.log("  Claude Code: restart it (or open a new terminal) so it re-reads ~/.claude/settings.json.");
+  }
+  if (wantsCodex(target)) {
+    if (app) {
+      console.log(
+        `  Codex app/IDE: it shares ${CODEX_HOME} with the CLI — fully quit and reopen the app/IDE window so it re-reads config.toml.`
+      );
+    } else {
+      console.log("  Codex CLI: open a new terminal (config.toml is read at startup), then run `codex`.");
+    }
+  }
+  console.log("  Verify anytime with `impel status`. Flip back with `impel use account` (alias `impel off`).");
+}
+
+function printAccountNextSteps({ target, app }) {
+  console.log("Reverted to your own account login. Next steps:");
+  if (wantsClaude(target)) {
+    console.log("  Claude Code: restart it. If you aren't otherwise logged in, run `claude` and sign in / set ANTHROPIC_API_KEY.");
+  }
+  if (wantsCodex(target)) {
+    if (app) {
+      console.log("  Codex app/IDE: fully quit and reopen the window. Sign in with ChatGPT or your API key if needed.");
+    } else {
+      console.log("  Codex CLI: open a new terminal. Run `codex login` (or set OPENAI_API_KEY) if you aren't already signed in.");
+    }
+  }
+  console.log("  Flip back to the gateway anytime with `impel use gateway` (alias `impel on`).");
+}

package/src/config.js

@@ -0,0 +1,98 @@
+// Reads/writes the impel-cli config file: ~/.config/impel/config.json
+//
+// Shape:
+//   {
+//     "pat": "impel_pat_...",
+//     "gatewayUrl": "https://gateway.useimpel.com",
+//     "appUrl": "https://www.useimpel.com",
+//     "tenantId": "impel",
+//     "experimental": { "crossAppModels": true },
+//     "updatedAt": "2026-07-08T00:00:00.000Z"
+//   }
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export const DEFAULT_GATEWAY_URL = "https://gateway.useimpel.com";
+export const DEFAULT_APP_URL = "https://www.useimpel.com";
+const LEGACY_GATEWAY_URLS = new Set(["https://gateway.useimpel.ai"]);
+
+export const CONFIG_DIR = path.join(os.homedir(), ".config", "impel");
+export const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+
+/** Hidden, default-off experiment. Only the exact boolean true enables it. */
+export function crossAppModelsEnabled(config) {
+  return config?.experimental?.crossAppModels === true;
+}
+
+/** Resolve the gateway URL to use when nothing is stored yet: env var, else the canonical gateway. */
+export function resolveDefaultGateway() {
+  return normalizeGatewayUrl(process.env.IMPEL_GATEWAY_URL || DEFAULT_GATEWAY_URL);
+}
+
+/** Resolve the app/control-plane URL used by task APIs. */
+export function resolveDefaultAppUrl() {
+  return normalizeGatewayUrl(process.env.IMPEL_APP_URL || DEFAULT_APP_URL);
+}
+
+/** Strip trailing slashes so `${gatewayUrl}/anthropic` never ends up with a double slash. */
+export function normalizeGatewayUrl(url) {
+  const normalized = String(url).trim().replace(/\/+$/, "");
+  return LEGACY_GATEWAY_URLS.has(normalized) ? DEFAULT_GATEWAY_URL : normalized;
+}
+
+/** Returns the parsed config object, or null if it doesn't exist yet. Throws on malformed JSON. */
+export function loadConfig() {
+  let raw;
+  try {
+    raw = fs.readFileSync(CONFIG_PATH, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+  try {
+    const config = JSON.parse(raw);
+    if (config?.gatewayUrl) config.gatewayUrl = normalizeGatewayUrl(config.gatewayUrl);
+    return config;
+  } catch {
+    throw new Error(
+      `${CONFIG_PATH} exists but isn't valid JSON. Fix or delete it, then run \`impel auth\` again.`
+    );
+  }
+}
+
+/** Writes the config atomically-ish and locks it down to 0600 (owner read/write only). */
+export function saveConfig(config) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  const json = JSON.stringify(config, null, 2) + "\n";
+  const tmpPath = `${CONFIG_PATH}.tmp-${process.pid}`;
+  fs.writeFileSync(tmpPath, json, { mode: 0o600 });
+  fs.renameSync(tmpPath, CONFIG_PATH);
+  try {
+    fs.chmodSync(CONFIG_PATH, 0o600);
+  } catch {
+    // best-effort on platforms (e.g. Windows) where chmod is a no-op
+  }
+}
+
+/** Short, safe-to-print representation of a secret token, e.g. "impel_pat_ab12...wxyz". */
+export function maskSecret(secret) {
+  if (!secret) return "(none)";
+  if (secret.length <= 12) return "*".repeat(secret.length);
+  return `${secret.slice(0, 10)}...${secret.slice(-4)}`;
+}
+
+const TENANT_CREDENTIAL_RE = /impel_tenant_[A-Za-z0-9_-]+\.impel_pat_[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)?/gu;
+const PAT_RE = /impel_pat_[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)?/gu;
+const ANSI_ESCAPE_RE = /\u001B(?:\][^\u0007\u001B]*(?:\u0007|\u001B\\)|\[[0-?]*[ -/]*[@-~]|[@-_])/gu;
+const TERMINAL_CONTROL_RE = /[\u0000-\u001F\u007F-\u009F]/gu;
+
+/** Remove credentials and terminal control sequences from untrusted text. */
+export function redactSecretText(value) {
+  return String(value ?? "")
+    .replace(TENANT_CREDENTIAL_RE, "[REDACTED IMPEL CREDENTIAL]")
+    .replace(PAT_RE, "[REDACTED IMPEL CREDENTIAL]")
+    .replace(ANSI_ESCAPE_RE, "")
+    .replace(TERMINAL_CONTROL_RE, " ");
+}