@tokenbuddy/tokenbuddy 1.0.4

package/src/index.ts

@@ -0,0 +1,12 @@
+import { buildCli } from "./cli.js";
+
+export function run() {
+  const program = buildCli();
+  program.parseAsync(process.argv).catch((error: unknown) => {
+    const commandError = error as { code?: string; exitCode?: number; message?: string };
+    if (commandError.code !== "tokenbuddy.daemon_not_running") {
+      console.error(commandError.message || String(error));
+    }
+    process.exitCode = commandError.exitCode || 1;
+  });
+}

package/src/provider-install.ts

@@ -0,0 +1,363 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { BuyerStore, ProviderInstallSnapshot } from "./buyer-store.js";
+
+const PLACEHOLDER_API_KEY = "TOKENBUDDY_PROXY";
+const DESKTOP_PROFILE_ID = "00000000-0000-4000-8000-000000178210";
+
+export const SUPPORTED_PROVIDER_IDS = [
+  "codex",
+  "claude-code",
+  "claude-desktop",
+  "openclaw",
+  "hermes"
+] as const;
+
+export type ProviderId = typeof SUPPORTED_PROVIDER_IDS[number];
+
+export interface ProviderDetectOptions {
+  home?: string;
+}
+
+export interface ProviderInstallOptions extends ProviderDetectOptions {
+  providers: string[];
+  proxyUrl: string;
+  model: string;
+}
+
+export interface ProviderRollbackOptions extends ProviderDetectOptions {
+  providers: string[];
+}
+
+export interface ProviderCandidate {
+  id: ProviderId;
+  name: string;
+  detected: boolean;
+  configPath: string;
+  reason: string;
+}
+
+export interface ProviderFileChange {
+  providerId: ProviderId;
+  path: string;
+  action: "create" | "update";
+  existed: boolean;
+  summary: string;
+  content: string;
+}
+
+export interface ProviderApplyResult {
+  providerId: ProviderId;
+  path: string;
+  action: "created" | "updated";
+}
+
+export interface ProviderRollbackResult {
+  providerId: ProviderId;
+  path: string;
+  action: "restored" | "removed" | "missing_snapshot";
+}
+
+interface ProviderDefinition {
+  id: ProviderId;
+  name: string;
+  configPath(home: string): string;
+  changes(home: string, proxyUrl: string, model: string): ProviderFileChange[];
+}
+
+function resolveHome(home?: string): string {
+  return home && home.trim() ? home : os.homedir();
+}
+
+function isProviderId(value: string): value is ProviderId {
+  return (SUPPORTED_PROVIDER_IDS as readonly string[]).includes(value);
+}
+
+function assertProviderIds(providers: string[]): ProviderId[] {
+  if (!Array.isArray(providers) || providers.length === 0) {
+    throw new Error("providers must include at least one provider id");
+  }
+  const out: ProviderId[] = [];
+  for (const provider of providers) {
+    if (!isProviderId(provider)) {
+      throw new Error(`unsupported provider: ${provider}`);
+    }
+    if (!out.includes(provider)) {
+      out.push(provider);
+    }
+  }
+  return out;
+}
+
+function readText(filePath: string): string | undefined {
+  if (!fs.existsSync(filePath)) {
+    return undefined;
+  }
+  return fs.readFileSync(filePath, "utf8");
+}
+
+function readJsonObject(filePath: string): Record<string, unknown> {
+  const text = readText(filePath);
+  if (!text) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(text) as unknown;
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? parsed as Record<string, unknown>
+      : {};
+  } catch {
+    return {};
+  }
+}
+
+function jsonContent(value: unknown): string {
+  return `${JSON.stringify(value, null, 2)}\n`;
+}
+
+function escapeTomlString(value: string): string {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
+function replaceTomlSection(existing: string, sectionName: string, sectionBody: string): string {
+  const sectionPattern = new RegExp(`^\\[${sectionName}\\]\\n[\\s\\S]*?(?=^\\[|\\s*$)`, "m");
+  const normalized = existing.trimEnd();
+  const nextSection = `[${sectionName}]\n${sectionBody.trimEnd()}\n`;
+  if (sectionPattern.test(normalized)) {
+    return `${normalized.replace(sectionPattern, nextSection).trimEnd()}\n`;
+  }
+  return `${normalized}${normalized ? "\n\n" : ""}${nextSection}`;
+}
+
+function codexConfig(home: string, proxyUrl: string, model: string): ProviderFileChange[] {
+  const configPath = path.join(home, ".codex", "config.toml");
+  const existing = readText(configPath) || "";
+  const content = replaceTomlSection(existing, "tokenbuddy", [
+    `proxy_url = "${escapeTomlString(proxyUrl)}"`,
+    `api_key = "${PLACEHOLDER_API_KEY}"`,
+    `model = "${escapeTomlString(model)}"`
+  ].join("\n"));
+  return [makeChange("codex", configPath, "configure TokenBuddy proxy for Codex", content)];
+}
+
+function claudeCodeConfig(home: string, proxyUrl: string, model: string): ProviderFileChange[] {
+  const configPath = path.join(home, ".claude", "settings.json");
+  const config = readJsonObject(configPath);
+  const env = config.env && typeof config.env === "object" && !Array.isArray(config.env)
+    ? config.env as Record<string, unknown>
+    : {};
+  config.env = {
+    ...env,
+    ANTHROPIC_BASE_URL: proxyUrl,
+    ANTHROPIC_AUTH_TOKEN: PLACEHOLDER_API_KEY,
+    ANTHROPIC_MODEL: model,
+    ANTHROPIC_DEFAULT_SONNET_MODEL: model
+  };
+  return [makeChange("claude-code", configPath, "configure Anthropic proxy env for Claude Code", jsonContent(config))];
+}
+
+function claudeDesktopConfig(home: string, proxyUrl: string, model: string): ProviderFileChange[] {
+  const configDir = path.join(home, "Library", "Application Support", "Claude");
+  const configPath = path.join(configDir, "claude_desktop_config.json");
+  const threepDir = path.join(home, "Library", "Application Support", "Claude-3p");
+  const threepConfigPath = path.join(threepDir, "claude_desktop_config.json");
+  const libraryPath = path.join(threepDir, "configLibrary");
+  const profilePath = path.join(libraryPath, `${DESKTOP_PROFILE_ID}.json`);
+  const metaPath = path.join(libraryPath, "_meta.json");
+
+  const primary = readJsonObject(configPath);
+  primary.deploymentMode = "3p";
+  const threep = readJsonObject(threepConfigPath);
+  threep.deploymentMode = "3p";
+
+  const profile = {
+    disableDeploymentModeChooser: true,
+    inferenceGatewayApiKey: PLACEHOLDER_API_KEY,
+    inferenceGatewayAuthScheme: "bearer",
+    inferenceGatewayBaseUrl: proxyUrl,
+    inferenceProvider: "gateway",
+    inferenceModels: [{ name: model }]
+  };
+
+  const meta = readJsonObject(metaPath);
+  const existingEntries = Array.isArray(meta.entries) ? meta.entries : [];
+  meta.appliedId = DESKTOP_PROFILE_ID;
+  meta.entries = [
+    ...existingEntries.filter((entry) => {
+      return !(entry && typeof entry === "object" && "id" in entry && entry.id === DESKTOP_PROFILE_ID);
+    }),
+    { id: DESKTOP_PROFILE_ID, name: "TokenBuddy" }
+  ];
+
+  return [
+    makeChange("claude-desktop", configPath, "enable Claude Desktop 3p deployment mode", jsonContent(primary)),
+    makeChange("claude-desktop", threepConfigPath, "enable Claude Desktop 3p config", jsonContent(threep)),
+    makeChange("claude-desktop", profilePath, "write TokenBuddy Claude Desktop profile", jsonContent(profile)),
+    makeChange("claude-desktop", metaPath, "select TokenBuddy Claude Desktop profile", jsonContent(meta))
+  ];
+}
+
+function openclawConfig(home: string, proxyUrl: string, model: string): ProviderFileChange[] {
+  const configPath = path.join(home, ".openclaw", "config.json");
+  const config = readJsonObject(configPath);
+  config.api_url = proxyUrl;
+  config.api_key = PLACEHOLDER_API_KEY;
+  config.model = model;
+  return [makeChange("openclaw", configPath, "configure OpenClaw proxy settings", jsonContent(config))];
+}
+
+function hermesConfig(home: string, proxyUrl: string, model: string): ProviderFileChange[] {
+  const configPath = path.join(home, ".hermes", "settings.json");
+  const config = readJsonObject(configPath);
+  const openai = config.openai && typeof config.openai === "object" && !Array.isArray(config.openai)
+    ? config.openai as Record<string, unknown>
+    : {};
+  config.openai = {
+    ...openai,
+    base_url: proxyUrl,
+    api_key: PLACEHOLDER_API_KEY,
+    model
+  };
+  return [makeChange("hermes", configPath, "configure Hermes OpenAI proxy settings", jsonContent(config))];
+}
+
+function makeChange(providerId: ProviderId, filePath: string, summary: string, content: string): ProviderFileChange {
+  const existed = fs.existsSync(filePath);
+  return {
+    providerId,
+    path: filePath,
+    action: existed ? "update" : "create",
+    existed,
+    summary,
+    content
+  };
+}
+
+const PROVIDERS: ProviderDefinition[] = [
+  {
+    id: "codex",
+    name: "Codex CLI",
+    configPath: (home) => path.join(home, ".codex", "config.toml"),
+    changes: codexConfig
+  },
+  {
+    id: "claude-code",
+    name: "Claude Code CLI",
+    configPath: (home) => path.join(home, ".claude", "settings.json"),
+    changes: claudeCodeConfig
+  },
+  {
+    id: "claude-desktop",
+    name: "Claude Desktop App",
+    configPath: (home) => path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json"),
+    changes: claudeDesktopConfig
+  },
+  {
+    id: "openclaw",
+    name: "OpenClaw Agent",
+    configPath: (home) => path.join(home, ".openclaw", "config.json"),
+    changes: openclawConfig
+  },
+  {
+    id: "hermes",
+    name: "Hermes Terminal",
+    configPath: (home) => path.join(home, ".hermes", "settings.json"),
+    changes: hermesConfig
+  }
+];
+
+export function detectProviders(options: ProviderDetectOptions = {}): ProviderCandidate[] {
+  const home = resolveHome(options.home);
+  return PROVIDERS.map((provider) => {
+    const configPath = provider.configPath(home);
+    const detected = fs.existsSync(configPath);
+    return {
+      id: provider.id,
+      name: provider.name,
+      detected,
+      configPath,
+      reason: detected ? `Found ${configPath}` : `Missing ${configPath}`
+    };
+  });
+}
+
+export function previewProviderInstall(options: ProviderInstallOptions): ProviderFileChange[] {
+  const home = resolveHome(options.home);
+  const providerIds = assertProviderIds(options.providers);
+  if (!options.proxyUrl || !options.proxyUrl.trim()) {
+    throw new Error("proxyUrl is required");
+  }
+  if (!options.model || !options.model.trim()) {
+    throw new Error("model is required");
+  }
+  return providerIds.flatMap((providerId) => {
+    const provider = PROVIDERS.find((entry) => entry.id === providerId);
+    if (!provider) {
+      throw new Error(`unsupported provider: ${providerId}`);
+    }
+    return provider.changes(home, options.proxyUrl, options.model);
+  });
+}
+
+export function applyProviderInstall(options: ProviderInstallOptions, store: BuyerStore): ProviderApplyResult[] {
+  const changes = previewProviderInstall(options);
+  const byProvider = new Map<ProviderId, ProviderFileChange[]>();
+  for (const change of changes) {
+    byProvider.set(change.providerId, [...(byProvider.get(change.providerId) || []), change]);
+  }
+
+  for (const [providerId, providerChanges] of byProvider) {
+    const snapshot: ProviderInstallSnapshot = {
+      providerId,
+      files: providerChanges.map((change) => ({
+        path: change.path,
+        existed: fs.existsSync(change.path),
+        content: readText(change.path)
+      }))
+    };
+    store.saveProviderInstallSnapshot(snapshot);
+  }
+
+  const applied: ProviderApplyResult[] = [];
+  for (const change of changes) {
+    const dir = path.dirname(change.path);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(change.path, change.content, "utf8");
+    applied.push({
+      providerId: change.providerId,
+      path: change.path,
+      action: change.existed ? "updated" : "created"
+    });
+  }
+  return applied;
+}
+
+export function rollbackProviderInstall(options: ProviderRollbackOptions, store: BuyerStore): ProviderRollbackResult[] {
+  const providerIds = assertProviderIds(options.providers);
+  const results: ProviderRollbackResult[] = [];
+  for (const providerId of providerIds) {
+    const snapshot = store.getProviderInstallSnapshot(providerId);
+    if (!snapshot) {
+      results.push({ providerId, path: "", action: "missing_snapshot" });
+      continue;
+    }
+    for (const file of snapshot.files) {
+      if (file.existed) {
+        const dir = path.dirname(file.path);
+        if (!fs.existsSync(dir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(file.path, file.content || "", "utf8");
+        results.push({ providerId, path: file.path, action: "restored" });
+      } else {
+        fs.rmSync(file.path, { force: true });
+        results.push({ providerId, path: file.path, action: "removed" });
+      }
+    }
+    store.removeProviderInstallSnapshot(providerId);
+  }
+  return results;
+}

package/src/tb-proxyd.ts

@@ -0,0 +1,60 @@
+import { TokenbuddyDaemon } from "./daemon.js";
+import { createModuleLogger } from "@tokenbuddy/logging";
+import { resolveBuyerStorePath } from "./buyer-store.js";
+
+const logger = createModuleLogger("tb-proxyd");
+
+const dbPath = resolveBuyerStorePath();
+const controlPort = parsePortEnv("TB_PROXYD_CONTROL_PORT", 17820);
+const proxyPort = parsePortEnv("TB_PROXYD_PROXY_PORT", 17821);
+const sellerRegistryUrl = process.env.TB_PROXYD_SELLER_REGISTRY_URL || "https://tb-wallet-bootstrap.fly.dev/registry/sellers";
+const selectionMode = parseSelectionModeEnv();
+
+const daemon = new TokenbuddyDaemon({
+  controlPort,
+  proxyPort,
+  dbPath,
+  sellerRegistryUrl,
+  selectionMode
+});
+
+logger.info("proxy.process.initializing", "tb-proxyd process initializing", {
+  dbPath,
+  controlPort,
+  proxyPort,
+  sellerRegistryUrl,
+  selectionMode
+});
+daemon.start();
+
+// Handle graceful stop
+process.on("SIGTERM", () => {
+  logger.info("proxy.shutdown", "tb-proxyd received shutdown signal", { signal: "SIGTERM" });
+  daemon.stop();
+  process.exit(0);
+});
+process.on("SIGINT", () => {
+  logger.info("proxy.shutdown", "tb-proxyd received shutdown signal", { signal: "SIGINT" });
+  daemon.stop();
+  process.exit(0);
+});
+
+function parsePortEnv(name: string, fallback: number): number {
+  const rawValue = process.env[name];
+  if (!rawValue) {
+    return fallback;
+  }
+  const port = Number(rawValue);
+  if (!Number.isInteger(port) || port < 0 || port > 65535) {
+    throw new Error(`${name} must be an integer port between 0 and 65535`);
+  }
+  return port;
+}
+
+function parseSelectionModeEnv(): "auto" | "manual" {
+  const rawValue = process.env.TB_PROXYD_SELECTION_MODE || "auto";
+  if (rawValue === "auto" || rawValue === "manual") {
+    return rawValue;
+  }
+  throw new Error("TB_PROXYD_SELECTION_MODE must be auto or manual");
+}

package/src/terminal-detect.ts

@@ -0,0 +1,225 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+export interface TerminalCandidate {
+  id: string;
+  name: string;
+  detected: boolean;
+  configPath: string;
+  reason: string;
+}
+
+const PLACEHOLDER_API_KEY = "TOKENBUDDY_PROXY";
+const DESKTOP_PROFILE_ID = "00000000-0000-4000-8000-000000178210";
+
+export function getHomeDir(): string {
+  return os.homedir();
+}
+
+/**
+ * Detect which coding terminals are installed on the local system.
+ */
+export function detectTerminals(): TerminalCandidate[] {
+  const home = getHomeDir();
+  const candidates: TerminalCandidate[] = [];
+
+  // 1. Claude Code
+  const claudePath = path.join(home, ".claude", "settings.json");
+  const claudeDetected = fs.existsSync(claudePath);
+  candidates.push({
+    id: "claude-code",
+    name: "Claude Code CLI",
+    detected: claudeDetected,
+    configPath: claudePath,
+    reason: claudeDetected ? "Found `~/.claude/settings.json`" : "Missing `~/.claude/settings.json`"
+  });
+
+  // 2. Claude Desktop
+  let desktopPath = "";
+  if (process.platform === "darwin") {
+    desktopPath = path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  } else if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA || path.join(home, "AppData", "Local");
+    desktopPath = path.join(localAppData, "Claude", "claude_desktop_config.json");
+  }
+  const desktopDetected = desktopPath !== "" && fs.existsSync(desktopPath);
+  candidates.push({
+    id: "claude-desktop",
+    name: "Claude Desktop App",
+    detected: desktopDetected,
+    configPath: desktopPath,
+    reason: desktopDetected ? "Found Claude desktop config" : "Missing Claude desktop config"
+  });
+
+  // 3. Openclaw
+  const openclawPath = path.join(home, ".openclaw", "config.json");
+  const openclawDetected = fs.existsSync(openclawPath);
+  candidates.push({
+    id: "openclaw",
+    name: "Openclaw Agent",
+    detected: openclawDetected,
+    configPath: openclawPath,
+    reason: openclawDetected ? "Found `~/.openclaw/config.json`" : "Missing `~/.openclaw/config.json`"
+  });
+
+  // 4. Hermes
+  const hermesPath = path.join(home, ".hermes", "settings.json");
+  const hermesDetected = fs.existsSync(hermesPath);
+  candidates.push({
+    id: "hermes",
+    name: "Hermes Terminal",
+    detected: hermesDetected,
+    configPath: hermesPath,
+    reason: hermesDetected ? "Found `~/.hermes/settings.json`" : "Missing `~/.hermes/settings.json`"
+  });
+
+  return candidates;
+}
+
+/**
+ * Safely rewrite Claude Code settings to route requests through our proxy.
+ */
+export function rewriteClaudeCode(configPath: string, proxyUrl: string, model: string): void {
+  try {
+    const parent = path.dirname(configPath);
+    if (!fs.existsSync(parent)) {
+      fs.mkdirSync(parent, { recursive: true });
+    }
+
+    let config: any = {};
+    if (fs.existsSync(configPath)) {
+      try {
+        config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+      } catch {}
+    }
+
+    if (!config.env || typeof config.env !== "object") {
+      config.env = {};
+    }
+
+    config.env.ANTHROPIC_BASE_URL = proxyUrl;
+    config.env.ANTHROPIC_AUTH_TOKEN = PLACEHOLDER_API_KEY;
+    config.env.ANTHROPIC_MODEL = model;
+    config.env.ANTHROPIC_DEFAULT_SONNET_MODEL = model;
+
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+    console.log(`[terminal-detect] Claude Code successfully routed to ${proxyUrl}`);
+  } catch (err: any) {
+    console.error("[terminal-detect] Failed to rewrite Claude Code config:", err.message);
+  }
+}
+
+/**
+ * Safely rewrite Claude Desktop configuration.
+ */
+export function rewriteClaudeDesktop(configPath: string, proxyUrl: string, model: string): void {
+  try {
+    const dir = path.dirname(configPath);
+    const threepDir = dir.replace(/Claude$/, "Claude-3p");
+    
+    const writeMode = (filePath: string) => {
+      const parent = path.dirname(filePath);
+      if (!fs.existsSync(parent)) {
+        fs.mkdirSync(parent, { recursive: true });
+      }
+      let config: any = {};
+      if (fs.existsSync(filePath)) {
+        try { config = JSON.parse(fs.readFileSync(filePath, "utf8")); } catch {}
+      }
+      config.deploymentMode = "3p";
+      fs.writeFileSync(filePath, JSON.stringify(config, null, 2), "utf8");
+    };
+
+    // 1. Write deployment modes
+    writeMode(configPath);
+    const threepConfigPath = configPath.replace(/Claude/, "Claude-3p");
+    writeMode(threepConfigPath);
+
+    // 2. Write Profile
+    const configLibraryPath = path.join(threepDir, "configLibrary");
+    if (!fs.existsSync(configLibraryPath)) {
+      fs.mkdirSync(configLibraryPath, { recursive: true });
+    }
+
+    const profilePath = path.join(configLibraryPath, `${DESKTOP_PROFILE_ID}.json`);
+    const profile = {
+      disableDeploymentModeChooser: true,
+      inferenceGatewayApiKey: PLACEHOLDER_API_KEY,
+      inferenceGatewayAuthScheme: "bearer",
+      inferenceGatewayBaseUrl: proxyUrl,
+      inferenceProvider: "gateway",
+      inferenceModels: [{ name: model }]
+    };
+    fs.writeFileSync(profilePath, JSON.stringify(profile, null, 2), "utf8");
+
+    // 3. Write _meta.json
+    const metaPath = path.join(configLibraryPath, "_meta.json");
+    let meta: any = {};
+    if (fs.existsSync(metaPath)) {
+      try { meta = JSON.parse(fs.readFileSync(metaPath, "utf8")); } catch {}
+    }
+    let entries = Array.isArray(meta.entries) ? meta.entries : [];
+    entries = entries.filter((e: any) => e.id !== DESKTOP_PROFILE_ID);
+    entries.push({ id: DESKTOP_PROFILE_ID, name: "TokenBuddy" });
+
+    meta.appliedId = DESKTOP_PROFILE_ID;
+    meta.entries = entries;
+    fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2), "utf8");
+
+    console.log(`[terminal-detect] Claude Desktop successfully routed to ${proxyUrl}`);
+  } catch (err: any) {
+    console.error("[terminal-detect] Failed to rewrite Claude Desktop config:", err.message);
+  }
+}
+
+/**
+ * Rewrite Openclaw settings.
+ */
+export function rewriteOpenclaw(configPath: string, proxyUrl: string, model: string): void {
+  try {
+    const parent = path.dirname(configPath);
+    if (!fs.existsSync(parent)) fs.mkdirSync(parent, { recursive: true });
+
+    let config: any = {};
+    if (fs.existsSync(configPath)) {
+      try { config = JSON.parse(fs.readFileSync(configPath, "utf8")); } catch {}
+    }
+
+    config.api_url = proxyUrl;
+    config.api_key = PLACEHOLDER_API_KEY;
+    config.model = model;
+
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+    console.log(`[terminal-detect] Openclaw successfully routed to ${proxyUrl}`);
+  } catch (err: any) {
+    console.error("[terminal-detect] Failed to rewrite Openclaw config:", err.message);
+  }
+}
+
+/**
+ * Rewrite Hermes settings.
+ */
+export function rewriteHermes(configPath: string, proxyUrl: string, model: string): void {
+  try {
+    const parent = path.dirname(configPath);
+    if (!fs.existsSync(parent)) fs.mkdirSync(parent, { recursive: true });
+
+    let config: any = {};
+    if (fs.existsSync(configPath)) {
+      try { config = JSON.parse(fs.readFileSync(configPath, "utf8")); } catch {}
+    }
+
+    if (!config.openai || typeof config.openai !== "object") {
+      config.openai = {};
+    }
+    config.openai.base_url = proxyUrl;
+    config.openai.api_key = PLACEHOLDER_API_KEY;
+    config.openai.model = model;
+
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+    console.log(`[terminal-detect] Hermes successfully routed to ${proxyUrl}`);
+  } catch (err: any) {
+    console.error("[terminal-detect] Failed to rewrite Hermes config:", err.message);
+  }
+}