cc-cast 1.3.5

package/src/store/cc-switch.ts

@@ -0,0 +1,145 @@
+import Database from "better-sqlite3";
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import type { DataStore, Profile } from "./interface.js";
+import { t } from "../i18n/index.js";
+
+const DB_PATH = join(homedir(), ".cc-switch", "cc-switch.db");
+const SETTINGS_PATH = join(homedir(), ".cc-switch", "settings.json");
+
+export function ccSwitchExists(): boolean {
+  return existsSync(DB_PATH);
+}
+
+export class CcSwitchStore implements DataStore {
+  private db: Database.Database;
+
+  constructor() {
+    if (!existsSync(DB_PATH)) {
+      throw new Error(t("store.db_not_found", { path: DB_PATH }));
+    }
+    this.db = new Database(DB_PATH);
+  }
+
+  list(): Profile[] {
+    const rows = this.db
+      .prepare(
+        `SELECT id, name, settings_config FROM providers WHERE app_type = 'claude' ORDER BY sort_index`
+      )
+      .all() as Array<{ id: string; name: string; settings_config: string }>;
+
+    return rows.map((row) => ({
+      id: row.id,
+      name: row.name,
+      settingsConfig: JSON.parse(row.settings_config),
+    }));
+  }
+
+  get(name: string): Profile | undefined {
+    const row = this.db
+      .prepare(
+        `SELECT id, name, settings_config FROM providers WHERE app_type = 'claude' AND name = ?`
+      )
+      .get(name) as
+      | { id: string; name: string; settings_config: string }
+      | undefined;
+
+    if (!row) return undefined;
+    return {
+      id: row.id,
+      name: row.name,
+      settingsConfig: JSON.parse(row.settings_config),
+    };
+  }
+
+  save(name: string, settingsConfig: Record<string, unknown>): void {
+    const existing = this.get(name);
+    if (existing) {
+      this.db
+        .prepare(
+          `UPDATE providers SET settings_config = ? WHERE app_type = 'claude' AND name = ?`
+        )
+        .run(JSON.stringify(settingsConfig), name);
+    } else {
+      const maxSort = this.db
+        .prepare(
+          `SELECT COALESCE(MAX(sort_index), -1) as max_sort FROM providers WHERE app_type = 'claude'`
+        )
+        .get() as { max_sort: number } | undefined;
+      const sortIndex = (maxSort?.max_sort ?? -1) + 1;
+
+      const id = crypto.randomUUID();
+      this.db
+        .prepare(
+          `INSERT INTO providers (
+            id, app_type, name, settings_config, website_url, category,
+            created_at, sort_index, notes, icon, icon_color, meta, is_current, in_failover_queue
+          ) VALUES (?, 'claude', ?, ?, NULL, NULL, ?, ?, NULL, NULL, NULL, '{}', 0, 0)`
+        )
+        .run(id, name, JSON.stringify(settingsConfig), Date.now(), sortIndex);
+    }
+  }
+
+  remove(name: string): boolean {
+    const result = this.db
+      .prepare(
+        `DELETE FROM providers WHERE app_type = 'claude' AND name = ?`
+      )
+      .run(name);
+    return result.changes > 0;
+  }
+
+  getCurrent(): string | undefined {
+    // Prefer DB is_current so we stay in sync with cc-switch UI
+    const dbRow = this.db
+      .prepare(
+        `SELECT name FROM providers WHERE app_type = 'claude' AND is_current = 1 LIMIT 1`
+      )
+      .get() as { name: string } | undefined;
+    if (dbRow) return dbRow.name;
+
+    // Fallback to settings.json
+    if (!existsSync(SETTINGS_PATH)) return undefined;
+    try {
+      const settings = JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
+      const currentId = settings.currentProviderClaude;
+      if (!currentId) return undefined;
+      const row = this.db
+        .prepare(
+          `SELECT name FROM providers WHERE app_type = 'claude' AND id = ?`
+        )
+        .get(currentId) as { name: string } | undefined;
+      return row?.name;
+    } catch {
+      return undefined;
+    }
+  }
+
+  setCurrent(name: string): void {
+    const profile = this.get(name);
+    if (!profile) throw new Error(t("error.not_found", { name }));
+
+    const tx = this.db.transaction(() => {
+      this.db
+        .prepare(`UPDATE providers SET is_current = 0 WHERE app_type = 'claude'`)
+        .run();
+      this.db
+        .prepare(
+          `UPDATE providers SET is_current = 1 WHERE app_type = 'claude' AND id = ?`
+        )
+        .run(profile.id);
+    });
+    tx();
+
+    const settings = existsSync(SETTINGS_PATH)
+      ? JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"))
+      : {};
+    settings.currentProviderClaude = profile.id;
+    writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+  }
+
+  close(): void {
+    this.db.close();
+  }
+}

package/src/store/interface.ts

@@ -0,0 +1 @@
+export type { DataStore, Profile } from "../types.js";

package/src/store/standalone.ts

@@ -0,0 +1,80 @@
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import type { DataStore, Profile } from "./interface.js";
+import { t } from "../i18n/index.js";
+
+const CC_CAST_DIR = join(homedir(), ".cc-cast");
+const CONFIG_PATH = join(CC_CAST_DIR, "config.json");
+
+interface StandaloneConfig {
+  current?: string;
+  profiles: Record<string, Record<string, unknown>>;
+}
+
+function ensureDir(): void {
+  if (!existsSync(CC_CAST_DIR)) {
+    mkdirSync(CC_CAST_DIR, { recursive: true });
+  }
+}
+
+function readConfig(): StandaloneConfig {
+  if (!existsSync(CONFIG_PATH)) {
+    return { profiles: {} };
+  }
+  return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+}
+
+function writeConfig(config: StandaloneConfig): void {
+  ensureDir();
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+export class StandaloneStore implements DataStore {
+  list(): Profile[] {
+    const config = readConfig();
+    return Object.entries(config.profiles).map(([name, settingsConfig]) => ({
+      id: name,
+      name,
+      settingsConfig,
+    }));
+  }
+
+  get(name: string): Profile | undefined {
+    const config = readConfig();
+    const settingsConfig = config.profiles[name];
+    if (!settingsConfig) return undefined;
+    return { id: name, name, settingsConfig };
+  }
+
+  save(name: string, settingsConfig: Record<string, unknown>): void {
+    const config = readConfig();
+    config.profiles[name] = settingsConfig;
+    writeConfig(config);
+  }
+
+  remove(name: string): boolean {
+    const config = readConfig();
+    if (!(name in config.profiles)) return false;
+    delete config.profiles[name];
+    if (config.current === name) {
+      config.current = undefined;
+    }
+    writeConfig(config);
+    return true;
+  }
+
+  getCurrent(): string | undefined {
+    return readConfig().current;
+  }
+
+  setCurrent(name: string): void {
+    const config = readConfig();
+    if (!(name in config.profiles)) {
+      throw new Error(t("error.not_found", { name }));
+    }
+    config.current = name;
+    writeConfig(config);
+  }
+
+}

package/src/types.ts

@@ -0,0 +1,19 @@
+export interface Profile {
+  id: string;
+  name: string;
+  settingsConfig: Record<string, unknown>;
+}
+
+export interface DataStore {
+  list(): Profile[];
+  get(name: string): Profile | undefined;
+  save(name: string, settingsConfig: Record<string, unknown>): void;
+  remove(name: string): boolean;
+  getCurrent(): string | undefined;
+  setCurrent(name: string): void;
+}
+
+export interface RcConfig {
+  aliases?: Record<string, string>;
+  locale?: "zh" | "en";
+}

package/src/utils.ts

@@ -0,0 +1,47 @@
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { spawnSync } from "child_process";
+import type { RcConfig } from "./types.js";
+import type { DataStore } from "./store/interface.js";
+import { StandaloneStore } from "./store/standalone.js";
+import { CcSwitchStore, ccSwitchExists } from "./store/cc-switch.js";
+
+const CC_CAST_DIR = join(homedir(), ".cc-cast");
+const RC_PATH = join(CC_CAST_DIR, "rc.json");
+
+export function readRc(): RcConfig {
+  if (!existsSync(RC_PATH)) {
+    writeRc({});
+    return {};
+  }
+  try {
+    return JSON.parse(readFileSync(RC_PATH, "utf-8"));
+  } catch {
+    writeRc({});
+    return {};
+  }
+}
+
+export function writeRc(rc: RcConfig): void {
+  if (!existsSync(CC_CAST_DIR)) {
+    mkdirSync(CC_CAST_DIR, { recursive: true });
+  }
+  writeFileSync(RC_PATH, JSON.stringify(rc, null, 2));
+}
+
+export function getStore(): DataStore {
+  if (ccSwitchExists()) {
+    return new CcSwitchStore();
+  }
+  return new StandaloneStore();
+}
+
+export function isCcSwitchGuiRunning(): boolean {
+  try {
+    const result = spawnSync("pgrep", ["-f", "cc-switch"], { encoding: "utf-8" });
+    return result.status === 0 && (result.stdout?.trim().length ?? 0) > 0;
+  } catch {
+    return false;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true
+  },
+  "include": ["src"]
+}