@wolffycode/selo 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wang Bingkun
+
+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,76 @@
+# selo
+
+在终端中读取 `CC Switch` 的 Claude provider，并用选中的配置启动 `claude`。
+
+`selo` 是个人开发者工具，不是 `CC Switch` 官方工具。
+
+它解决两个问题：
+
+- 避开 Unix/Linux/macOS 上 `cc` 命令和系统编译器的命名冲突
+- 在终端里快速切换不同 Claude provider，并尽量与 `CC Switch` 当前状态保持一致
+
+## Prerequisites
+
+- 已安装并配置 `CC Switch`
+- 已安装 `claude` CLI
+- 已安装系统 `sqlite3`
+
+`selo` 把 `CC Switch` 当成硬性前提。它不会自己管理 provider，也不会替你安装 `claude`。
+
+## Install
+
+当前仓库代码已经可用，但**还没有发布到 npm**。
+
+### Local development
+
+在本机调试时，使用：
+
+```bash
+cd /Users/wangbingkun/Desktop/person/selo
+env npm_config_prefix=$HOME/.local npm link
+```
+
+### After npm publish
+
+发布到 npm 之后，再使用：
+
+```bash
+npm i -g @wolffycode/selo
+```
+
+## Usage
+
+```bash
+selo
+selo -v
+selo -d
+```
+
+`-d` 会把 `--dangerously-skip-permissions` 传给 `claude`。
+
+## How It Works
+
+- 从 `~/.cc-switch/cc-switch.db` 读取 Claude providers
+- 从 `~/.cc-switch/settings.json` 读取当前选中的 Claude provider
+- 如果 provider 开启了 `commonConfigEnabled`，会合并 `common_config_claude`
+- 打开 picker 时监听 `CC Switch` 配置变化，列表会自动刷新
+- 按下回车启动前，会再次按 provider id 读取最新配置
+- 真正启动 `claude` 时，会写入一份临时 settings 文件，运行中的 Claude 会话不会被后续的 `CC Switch` 改动污染
+
+## Consistency Rules
+
+默认高亮优先级：
+
+1. `CC Switch.settings.json.currentProviderClaude`
+2. `providers.is_current = 1`
+3. `selo` 本地记录的上次选择
+4. 第一条 provider
+
+这和你当前本地 `cc` 最大的区别是：`selo` 不会让自己的本地状态覆盖 `CC Switch` 当前 provider。
+
+## Development
+
+```bash
+npm test
+node bin/selo.js -v
+```

package/bin/selo.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+const { run } = require('../src/cli.js');
+
+run(process.argv.slice(2)).catch((error) => {
+  if (error && error.signal) {
+    process.kill(process.pid, error.signal);
+    return;
+  }
+  process.stderr.write(`${error.message}\n`);
+  process.exit(error && error.exitCode ? error.exitCode : 1);
+}).then((exitCode) => {
+  if (typeof exitCode === 'number') {
+    process.exit(exitCode);
+  }
+});

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@wolffycode/selo",
+  "version": "0.1.0",
+  "description": "Launch Claude with providers from CC Switch.",
+  "type": "commonjs",
+  "license": "MIT",
+  "bin": {
+    "selo": "bin/selo.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test"
+  },
+  "keywords": [
+    "claude",
+    "cc-switch",
+    "cli",
+    "launcher"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/WolffyCode/selo.git"
+  },
+  "bugs": {
+    "url": "https://github.com/WolffyCode/selo/issues"
+  },
+  "homepage": "https://github.com/WolffyCode/selo#readme",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/cli.js

@@ -0,0 +1,352 @@
+const fs = require('node:fs');
+const readline = require('node:readline');
+const { execFileSync, spawn } = require('node:child_process');
+
+const { version: VERSION } = require('../package.json');
+const { createLaunchPlan } = require('./core/launch.js');
+const { getSubText, resolveDefaultProviderId } = require('./core/provider.js');
+const {
+  DB_PATH,
+  SETTINGS_PATH,
+  getFingerprint,
+  loadCommonClaudeSettings,
+  loadProviderById,
+  loadSnapshot,
+} = require('./store/cc-switch.js');
+const { loadSeloSettings, saveSeloSettings } = require('./store/selo-config.js');
+
+function buildVersionString(version = VERSION) {
+  return `selo v${version}`;
+}
+
+function parseCliArgs(argv) {
+  const args = [...argv];
+
+  if (args[0] === '-v' || args[0] === '--version') {
+    return {
+      showVersion: true,
+      danger: false,
+      claudeArgs: [],
+    };
+  }
+
+  let danger = false;
+  if (args[0] === '-d') {
+    danger = true;
+    args.shift();
+  }
+
+  return {
+    showVersion: false,
+    danger,
+    claudeArgs: args,
+  };
+}
+
+function reconcileSelection(
+  selectedId,
+  previousRows,
+  nextRows,
+  switchSettings = {},
+  seloSettings = {}
+) {
+  if (!Array.isArray(nextRows) || nextRows.length === 0) {
+    return null;
+  }
+
+  if (selectedId && nextRows.some((row) => row.id === selectedId)) {
+    return selectedId;
+  }
+
+  return resolveDefaultProviderId(nextRows, switchSettings, seloSettings);
+}
+
+function assertClaudeAvailable({ execFileSyncFn = execFileSync } = {}) {
+  try {
+    execFileSyncFn('claude', ['--version'], { stdio: 'ignore' });
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      throw new Error('claude CLI is required. Please install Claude Code first.');
+    }
+
+    throw error;
+  }
+}
+
+function createSnapshotWatcher({
+  switchDir = require('node:path').dirname(DB_PATH),
+  pollIntervalMs = 750,
+  watchFn = fs.watch,
+  getFingerprintFn = getFingerprint,
+  onChange,
+  onError,
+  initialFingerprint,
+  setIntervalFn = setInterval,
+  clearIntervalFn = clearInterval,
+} = {}) {
+  let closed = false;
+  let currentFingerprint = initialFingerprint;
+  let checking = false;
+  let queued = false;
+  let watcher = null;
+
+  const fingerprintsEqual = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+
+  const check = async () => {
+    if (closed || checking) {
+      queued = true;
+      return;
+    }
+
+    checking = true;
+    try {
+      const nextFingerprint = await getFingerprintFn();
+      if (!fingerprintsEqual(nextFingerprint, currentFingerprint)) {
+        currentFingerprint = nextFingerprint;
+        await onChange(nextFingerprint);
+      }
+    } catch (error) {
+      if (onError) {
+        onError(error);
+      }
+    } finally {
+      checking = false;
+      if (queued && !closed) {
+        queued = false;
+        void check();
+      }
+    }
+  };
+
+  try {
+    watcher = watchFn(switchDir, () => {
+      void check();
+    });
+  } catch (error) {
+    if (onError) {
+      onError(error);
+    }
+  }
+
+  const interval = setIntervalFn(() => {
+    void check();
+  }, pollIntervalMs);
+
+  if (typeof interval.unref === 'function') {
+    interval.unref();
+  }
+
+  return {
+    close() {
+      closed = true;
+      if (watcher) {
+        watcher.close();
+      }
+      clearIntervalFn(interval);
+    },
+  };
+}
+
+function clearScreen(stream) {
+  stream.write('\x1b[2J\x1b[H');
+}
+
+function restoreTerminal(input) {
+  if (input.isTTY && typeof input.setRawMode === 'function') {
+    input.setRawMode(false);
+  }
+  input.pause();
+}
+
+function drawPicker(stream, rows, selectedId, footerMessage = '') {
+  const B = '\x1b[1m';
+  const CY = '\x1b[36m';
+  const D = '\x1b[2m';
+  const R = '\x1b[0m';
+
+  clearScreen(stream);
+  stream.write('\n  ' + CY + B + 'SELO - Select Provider' + R + '\n\n');
+  rows.forEach((row) => {
+    const active = row.id === selectedId;
+    const prefix = active ? '  ' + CY + B + '\u276f ' + R : '    ';
+    const name = active ? B + row.name + R : row.name;
+    const sub = D + getSubText(row) + R;
+    stream.write(prefix + name + '\n');
+    stream.write('    ' + sub + '\n');
+  });
+
+  stream.write('\n  ' + D + '\u2191\u2193 navigate  Enter select  Esc cancel' + R + '\n');
+  if (footerMessage) {
+    stream.write('\n  ' + footerMessage + '\n');
+  }
+}
+
+async function run(argv = [], deps = {}) {
+  const {
+    stdin = process.stdin,
+    stdout = process.stdout,
+    stderr = process.stderr,
+    spawnFn = spawn,
+    loadSnapshotFn = loadSnapshot,
+    loadProviderByIdFn = loadProviderById,
+    loadCommonClaudeSettingsFn = loadCommonClaudeSettings,
+    loadSeloSettingsFn = loadSeloSettings,
+    saveSeloSettingsFn = saveSeloSettings,
+    createLaunchPlanFn = createLaunchPlan,
+    createSnapshotWatcherFn = createSnapshotWatcher,
+    assertClaudeAvailableFn = assertClaudeAvailable,
+  } = deps;
+  const parsedArgs = parseCliArgs(argv);
+
+  if (parsedArgs.showVersion) {
+    stdout.write(buildVersionString(VERSION) + '\n');
+    return 0;
+  }
+
+  if (!stdin.isTTY || typeof stdin.setRawMode !== 'function') {
+    throw new Error('selo requires an interactive terminal.');
+  }
+
+  let snapshot = await loadSnapshotFn();
+  let seloSettings = await loadSeloSettingsFn();
+  let selectedId = resolveDefaultProviderId(
+    snapshot.providers,
+    snapshot.switchSettings,
+    seloSettings
+  );
+  let footerMessage = '';
+  let reloading = false;
+  let queuedReload = false;
+
+  const reloadSnapshot = async () => {
+    if (reloading) {
+      queuedReload = true;
+      return;
+    }
+
+    reloading = true;
+    try {
+      do {
+        queuedReload = false;
+        const nextSnapshot = await loadSnapshotFn();
+        selectedId = reconcileSelection(
+          selectedId,
+          snapshot.providers,
+          nextSnapshot.providers,
+          nextSnapshot.switchSettings,
+          seloSettings
+        );
+        snapshot = nextSnapshot;
+        footerMessage = 'CC Switch updated. Picker reloaded.';
+        drawPicker(stderr, snapshot.providers, selectedId, footerMessage);
+      } while (queuedReload);
+    } catch (error) {
+      footerMessage = `Reload failed: ${error.message}`;
+      drawPicker(stderr, snapshot.providers, selectedId, footerMessage);
+    } finally {
+      reloading = false;
+    }
+  };
+
+  const watcher = createSnapshotWatcherFn({
+    initialFingerprint: snapshot.fingerprint,
+    onChange: reloadSnapshot,
+    onError: (error) => {
+      footerMessage = `Watch failed: ${error.message}`;
+      drawPicker(stderr, snapshot.providers, selectedId, footerMessage);
+    },
+  });
+
+  readline.emitKeypressEvents(stdin);
+  stdin.setRawMode(true);
+  stdin.resume();
+  drawPicker(stderr, snapshot.providers, selectedId, footerMessage);
+
+  return new Promise((resolve, reject) => {
+    const finish = (error, exitCode = 0) => {
+      watcher.close();
+      stdin.removeListener('keypress', onKeypress);
+      restoreTerminal(stdin);
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve(exitCode);
+    };
+
+    const onKeypress = async (_, key) => {
+      if (key.name === 'up' || key.name === 'down') {
+        const rows = snapshot.providers;
+        const currentIndex = Math.max(0, rows.findIndex((row) => row.id === selectedId));
+        const delta = key.name === 'up' ? -1 : 1;
+        const nextIndex = (currentIndex + delta + rows.length) % rows.length;
+        selectedId = rows[nextIndex].id;
+        footerMessage = '';
+        drawPicker(stderr, rows, selectedId, footerMessage);
+        return;
+      }
+
+      if (key.name === 'return') {
+        watcher.close();
+        stdin.removeListener('keypress', onKeypress);
+        restoreTerminal(stdin);
+        clearScreen(stderr);
+
+        try {
+          const latestProvider = loadProviderByIdFn(selectedId);
+          const commonSettings = loadCommonClaudeSettingsFn();
+          seloSettings = await loadSeloSettingsFn();
+          await saveSeloSettingsFn({
+            ...seloSettings,
+            lastProviderClaude: latestProvider.id,
+          });
+          assertClaudeAvailableFn();
+
+          const launchPlan = await createLaunchPlanFn({
+            provider: latestProvider,
+            commonSettings,
+            danger: parsedArgs.danger,
+            claudeArgs: parsedArgs.claudeArgs,
+          });
+
+          const child = spawnFn(launchPlan.command, launchPlan.args, {
+            stdio: 'inherit',
+            env: launchPlan.env,
+          });
+
+          child.on('error', async (error) => {
+            await launchPlan.cleanup();
+            reject(error.code === 'ENOENT'
+              ? new Error('claude CLI is required. Please install Claude Code first.')
+              : error);
+          });
+          child.on('exit', async (code, signal) => {
+            await launchPlan.cleanup();
+            if (signal) {
+              reject({ signal });
+              return;
+            }
+            resolve(code ?? 0);
+          });
+        } catch (error) {
+          reject(error);
+        }
+        return;
+      }
+
+      if (key.name === 'escape' || (key.ctrl && key.name === 'c')) {
+        finish(null, 1);
+      }
+    };
+
+    stdin.on('keypress', onKeypress);
+  });
+}
+
+module.exports = {
+  buildVersionString,
+  createSnapshotWatcher,
+  parseCliArgs,
+  reconcileSelection,
+  run,
+};

package/src/core/launch.js

@@ -0,0 +1,87 @@
+const fs = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+
+const {
+  buildChildEnv,
+  getPreferredModel,
+  resolveEffectiveSettings,
+} = require('./provider.js');
+
+async function createLaunchPlan({
+  provider,
+  commonSettings,
+  danger,
+  claudeArgs,
+  tempDir,
+  mkdtempFn = fs.mkdtemp,
+  writeFileFn = fs.writeFile,
+  unlinkFn = fs.unlink,
+  rmFn = fs.rm,
+} = {}) {
+  const settings = resolveEffectiveSettings(provider, commonSettings);
+  const ownedTempDir = tempDir || await mkdtempFn(path.join(os.tmpdir(), 'selo-settings-'));
+  const settingsPath = path.join(
+    ownedTempDir,
+    `claude-settings-${process.pid}-${Date.now()}.json`
+  );
+
+  await writeFileFn(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+
+  let cleaned = false;
+  const cleanup = async () => {
+    if (cleaned) {
+      return;
+    }
+
+    cleaned = true;
+
+    try {
+      await unlinkFn(settingsPath);
+    } catch (error) {
+      if (!error || error.code !== 'ENOENT') {
+        throw error;
+      }
+    }
+
+    if (!tempDir) {
+      try {
+        await rmFn(ownedTempDir, { recursive: true, force: true });
+      } catch (error) {
+        if (!error || error.code !== 'ENOENT') {
+          throw error;
+        }
+      }
+    }
+  };
+
+  const launchArgs = Array.isArray(claudeArgs) ? [...claudeArgs] : [];
+  const args = ['--setting-sources', 'project,local', '--settings', settingsPath];
+  const hasExplicitModelArg = launchArgs.some(
+    (arg, index) => arg === '--model' && index < launchArgs.length - 1
+  );
+  const preferredModel = getPreferredModel(settings);
+
+  if (preferredModel && !hasExplicitModelArg) {
+    args.push('--model', preferredModel);
+  }
+
+  if (danger) {
+    args.push('--dangerously-skip-permissions');
+  }
+
+  args.push(...launchArgs);
+
+  return {
+    command: 'claude',
+    args,
+    env: buildChildEnv(settings),
+    settings,
+    settingsPath,
+    cleanup,
+  };
+}
+
+module.exports = {
+  createLaunchPlan,
+};

package/src/core/provider.js

@@ -0,0 +1,171 @@
+const ENV_RESET_KEYS = new Set([
+  'API_TIMEOUT_MS',
+  'CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC',
+]);
+
+function parseJson(text, errorMessage) {
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new Error(`${errorMessage}: ${error.message}`);
+  }
+}
+
+function parseProviderSettings(provider) {
+  return parseJson(
+    provider.settings_config,
+    `Invalid settings_config for provider "${provider.name}"`
+  );
+}
+
+function parseProviderMeta(provider) {
+  if (!provider || typeof provider.meta !== 'string' || provider.meta.trim() === '') {
+    return {};
+  }
+
+  return parseJson(provider.meta, `Invalid meta for provider "${provider.name}"`);
+}
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function cloneJson(value) {
+  return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
+}
+
+function mergeSettings(baseSettings = {}, overrideSettings = {}) {
+  const merged = isPlainObject(baseSettings) ? cloneJson(baseSettings) : {};
+
+  if (!isPlainObject(overrideSettings)) {
+    return merged;
+  }
+
+  Object.entries(overrideSettings).forEach(([key, value]) => {
+    if (isPlainObject(value) && isPlainObject(merged[key])) {
+      merged[key] = mergeSettings(merged[key], value);
+      return;
+    }
+
+    merged[key] = cloneJson(value);
+  });
+
+  return merged;
+}
+
+function getPreferredModel(settings = {}) {
+  const env = settings.env && typeof settings.env === 'object' ? settings.env : {};
+
+  return env.ANTHROPIC_MODEL
+    || env.ANTHROPIC_DEFAULT_OPUS_MODEL
+    || env.ANTHROPIC_DEFAULT_SONNET_MODEL
+    || env.ANTHROPIC_DEFAULT_HAIKU_MODEL
+    || env.ANTHROPIC_REASONING_MODEL
+    || settings.model
+    || '';
+}
+
+function normalizeProviderSettings(settings = {}) {
+  const normalized = JSON.parse(JSON.stringify(settings || {}));
+  const env = normalized.env && typeof normalized.env === 'object' ? normalized.env : {};
+  normalized.env = env;
+
+  const preferredModel = getPreferredModel(normalized);
+  if (preferredModel && !env.ANTHROPIC_MODEL) {
+    env.ANTHROPIC_MODEL = preferredModel;
+  }
+
+  if (preferredModel && !env.ANTHROPIC_REASONING_MODEL) {
+    env.ANTHROPIC_REASONING_MODEL = preferredModel;
+  }
+
+  if (preferredModel) {
+    normalized.model = preferredModel;
+  }
+
+  return normalized;
+}
+
+function getBaseUrl(settingsConfig) {
+  try {
+    const cfg = JSON.parse(settingsConfig);
+    return cfg.env && cfg.env.ANTHROPIC_BASE_URL ? cfg.env.ANTHROPIC_BASE_URL : '';
+  } catch {
+    return '';
+  }
+}
+
+function getSubText(row) {
+  if (row.notes && row.notes.trim()) {
+    return row.notes;
+  }
+
+  return getBaseUrl(row.settings_config);
+}
+
+function resolveEffectiveSettings(provider, commonSettings = {}) {
+  const providerSettings = parseProviderSettings(provider);
+  const providerMeta = parseProviderMeta(provider);
+  return normalizeProviderSettings(
+    providerMeta.commonConfigEnabled
+      ? mergeSettings(commonSettings, providerSettings)
+      : providerSettings
+  );
+}
+
+function buildChildEnv(settings) {
+  const childEnv = { ...process.env };
+
+  Object.keys(childEnv).forEach((key) => {
+    if (key.startsWith('ANTHROPIC_') || ENV_RESET_KEYS.has(key)) {
+      delete childEnv[key];
+    }
+  });
+
+  if (settings.env && typeof settings.env === 'object') {
+    Object.assign(childEnv, settings.env);
+  }
+
+  return childEnv;
+}
+
+function resolveDefaultProviderId(rows, switchSettings = {}, seloSettings = {}) {
+  if (!Array.isArray(rows) || rows.length === 0) {
+    return null;
+  }
+
+  if (switchSettings.currentProviderClaude) {
+    const currentRow = rows.find((row) => row.id === switchSettings.currentProviderClaude);
+    if (currentRow) {
+      return currentRow.id;
+    }
+  }
+
+  const isCurrentRow = rows.find((row) => Number(row.is_current) === 1 || row.is_current === true);
+  if (isCurrentRow) {
+    return isCurrentRow.id;
+  }
+
+  if (seloSettings.lastProviderClaude) {
+    const lastRow = rows.find((row) => row.id === seloSettings.lastProviderClaude);
+    if (lastRow) {
+      return lastRow.id;
+    }
+  }
+
+  return rows[0].id;
+}
+
+module.exports = {
+  buildChildEnv,
+  getBaseUrl,
+  getPreferredModel,
+  getSubText,
+  mergeSettings,
+  normalizeProviderSettings,
+  parseJson,
+  parseProviderMeta,
+  parseProviderSettings,
+  resolveDefaultProviderId,
+  resolveEffectiveSettings,
+};

package/src/store/cc-switch.js

@@ -0,0 +1,180 @@
+const fs = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const { parseJson } = require('../core/provider.js');
+
+const SWITCH_DIR = path.join(os.homedir(), '.cc-switch');
+const DB_PATH = path.join(SWITCH_DIR, 'cc-switch.db');
+const SETTINGS_PATH = path.join(SWITCH_DIR, 'settings.json');
+const PROVIDERS_SQL = [
+  'SELECT',
+  'id,',
+  'name,',
+  'notes,',
+  'settings_config,',
+  'meta,',
+  'is_current',
+  'FROM providers',
+  "WHERE app_type='claude'",
+  'ORDER BY created_at;',
+].join(' ');
+const COMMON_CLAUDE_CONFIG_SQL = [
+  'SELECT value',
+  'FROM settings',
+  "WHERE key='common_config_claude'",
+  'LIMIT 1;',
+].join(' ');
+
+function normalizeSqliteError(error, dbPath) {
+  if (error && error.code === 'ENOENT') {
+    return new Error('sqlite3 is required. Please install sqlite3 to let selo read CC Switch data.');
+  }
+
+  const message = [
+    error && error.message,
+    error && error.stderr && String(error.stderr),
+  ].filter(Boolean).join('\n');
+
+  if (
+    message.includes('unable to open database file')
+    || message.includes('no such table')
+    || message.includes('no such file')
+  ) {
+    return new Error(`CC Switch DB not found at ${dbPath}. Please install CC Switch first.`);
+  }
+
+  return error;
+}
+
+function queryJson(sql, { dbPath = DB_PATH, execFileSyncFn = execFileSync } = {}) {
+  let output;
+
+  try {
+    output = execFileSyncFn('sqlite3', ['-json', dbPath, sql], {
+      encoding: 'utf8',
+    });
+  } catch (error) {
+    throw normalizeSqliteError(error, dbPath);
+  }
+
+  return parseJson(output || '[]', `Invalid JSON returned from ${dbPath}`);
+}
+
+function loadProviders({ dbPath = DB_PATH, queryJsonFn = queryJson } = {}) {
+  const rows = queryJsonFn(PROVIDERS_SQL, { dbPath });
+
+  if (!Array.isArray(rows) || rows.length === 0) {
+    throw new Error('No Claude providers found in CC Switch.\nPlease configure providers in CC Switch first.');
+  }
+
+  return rows;
+}
+
+function loadProviderById(providerId, { dbPath = DB_PATH, queryJsonFn = queryJson } = {}) {
+  const safeId = String(providerId).replace(/'/g, "''");
+  const rows = queryJsonFn([
+    'SELECT',
+    'id,',
+    'name,',
+    'notes,',
+    'settings_config,',
+    'meta,',
+    'is_current',
+    'FROM providers',
+    "WHERE app_type='claude'",
+    `AND id='${safeId}'`,
+    'LIMIT 1;',
+  ].join(' '), { dbPath });
+
+  if (!Array.isArray(rows) || rows.length === 0) {
+    throw new Error(`Selected provider "${providerId}" was removed from CC Switch. Please reopen selo and try again.`);
+  }
+
+  return rows[0];
+}
+
+function loadCommonClaudeSettings({ dbPath = DB_PATH, queryJsonFn = queryJson } = {}) {
+  const rows = queryJsonFn(COMMON_CLAUDE_CONFIG_SQL, { dbPath });
+  if (!Array.isArray(rows) || rows.length === 0) {
+    return {};
+  }
+
+  const [row] = rows;
+  if (!row || typeof row.value !== 'string' || row.value.trim() === '') {
+    return {};
+  }
+
+  return parseJson(row.value, `Invalid common Claude config in ${dbPath}`);
+}
+
+async function loadSwitchSettings({ settingsPath = SETTINGS_PATH, readFileFn = fs.readFile } = {}) {
+  try {
+    const text = await readFileFn(settingsPath, 'utf8');
+    return parseJson(text, `Invalid CC Switch settings file at ${settingsPath}`);
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      return {};
+    }
+
+    throw error;
+  }
+}
+
+async function getFingerprint({
+  dbPath = DB_PATH,
+  settingsPath = SETTINGS_PATH,
+  statFn = fs.stat,
+} = {}) {
+  const [dbStats, settingsStats] = await Promise.all([
+    statFn(dbPath),
+    statFn(settingsPath).catch((error) => {
+      if (error && error.code === 'ENOENT') {
+        return null;
+      }
+      throw error;
+    }),
+  ]);
+
+  return {
+    dbMtimeMs: Number(dbStats.mtimeMs || 0),
+    dbSize: Number(dbStats.size || 0),
+    settingsMtimeMs: Number(settingsStats && settingsStats.mtimeMs || 0),
+    settingsSize: Number(settingsStats && settingsStats.size || 0),
+  };
+}
+
+async function loadSnapshot({
+  loadProvidersFn = loadProviders,
+  loadCommonClaudeSettingsFn = loadCommonClaudeSettings,
+  loadSwitchSettingsFn = loadSwitchSettings,
+  getFingerprintFn = getFingerprint,
+} = {}) {
+  const [providers, commonSettings, switchSettings, fingerprint] = await Promise.all([
+    Promise.resolve(loadProvidersFn()),
+    Promise.resolve(loadCommonClaudeSettingsFn()),
+    Promise.resolve(loadSwitchSettingsFn()),
+    Promise.resolve(getFingerprintFn()),
+  ]);
+
+  return {
+    providers,
+    commonSettings,
+    switchSettings,
+    fingerprint,
+  };
+}
+
+module.exports = {
+  DB_PATH,
+  SETTINGS_PATH,
+  getFingerprint,
+  loadCommonClaudeSettings,
+  loadProviderById,
+  loadProviders,
+  loadSnapshot,
+  loadSwitchSettings,
+  normalizeSqliteError,
+  queryJson,
+};

package/src/store/selo-config.js

@@ -0,0 +1,53 @@
+const fs = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+
+const { parseJson } = require('../core/provider.js');
+
+function getConfigDir(platform = process.platform) {
+  if (platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support', 'selo');
+  }
+
+  if (platform === 'win32') {
+    return path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), 'selo');
+  }
+
+  return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'selo');
+}
+
+function getSettingsPath(configDir = getConfigDir()) {
+  return path.join(configDir, 'settings.json');
+}
+
+async function loadSeloSettings({ settingsPath = getSettingsPath(), readFileFn = fs.readFile } = {}) {
+  try {
+    const text = await readFileFn(settingsPath, 'utf8');
+    return parseJson(text, `Invalid selo settings file at ${settingsPath}`);
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      return {};
+    }
+
+    throw error;
+  }
+}
+
+async function saveSeloSettings(
+  settings,
+  {
+    settingsPath = getSettingsPath(),
+    mkdirFn = fs.mkdir,
+    writeFileFn = fs.writeFile,
+  } = {}
+) {
+  await mkdirFn(path.dirname(settingsPath), { recursive: true });
+  await writeFileFn(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+}
+
+module.exports = {
+  getConfigDir,
+  getSettingsPath,
+  loadSeloSettings,
+  saveSeloSettings,
+};