qwenproxy-cli 1.0.0

package/src/sync/index.ts

@@ -0,0 +1,362 @@
+import "dotenv/config";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+import { config } from "../core/config.ts";
+import { getSyncStatePath } from "../core/paths.ts";
+import type {
+  ClientSyncResult,
+  SyncAllOptions,
+  SyncRecord,
+  SyncStateFile,
+} from "./types.ts";
+import { syncClaudeCode, restoreClaudeCode } from "./claude-code.ts";
+import { syncCodex, restoreCodex } from "./codex.ts";
+import { syncOpenCode, restoreOpenCode } from "./opencode.ts";
+import { syncOmp, restoreOmp } from "./omp.ts";
+
+export function resolveApiKey(overrideKey?: string, configKey?: string): string {
+  if (overrideKey && overrideKey.trim().length > 0) {
+    return overrideKey.trim();
+  }
+  const envKey = process.env.API_KEY || process.env.ADMIN_PASSWORD || configKey;
+  if (envKey && envKey.trim().length > 0) {
+    return envKey.trim();
+  }
+  return "sk-qwenproxy-local";
+}
+export function normalizeClientName(name: string): "claude-code" | "codex" | "opencode" | "omp" | null {
+  const clean = name.trim().toLowerCase().replace(/[-_ ]/g, "");
+  if (clean === "claude" || clean === "claudecode" || clean === "anthropic") return "claude-code";
+  if (clean === "codex" || clean === "codexcli" || clean === "openai") return "codex";
+  if (clean === "opencode") return "opencode";
+  if (clean === "omp" || clean === "ohmypi") return "omp";
+  return null;
+}
+
+export function resolveBaseUrls(port = 7936, host = "127.0.0.1"): {
+  anthropicBaseUrl: string;
+  openaiBaseUrl: string;
+} {
+  const cleanHost = host === "0.0.0.0" ? "127.0.0.1" : host;
+  return {
+    anthropicBaseUrl: `http://${cleanHost}:${port}`,
+    openaiBaseUrl: `http://${cleanHost}:${port}/v1`,
+  };
+}
+
+export function getDefaultPaths(): {
+  claudeCode: string;
+  codex: string;
+  openCode: string;
+  omp: string;
+} {
+  const home = os.homedir();
+
+  // OpenCode can be ~/.config/opencode/opencode.jsonc or ~/.opencode/opencode.jsonc
+  const openCodeCandidates = [
+    path.join(home, ".config", "opencode", "opencode.jsonc"),
+    path.join(home, ".config", "opencode", "opencode.json"),
+    path.join(home, ".opencode", "opencode.jsonc"),
+    path.join(home, ".opencode", "opencode.json"),
+  ];
+  const existingOpenCode = openCodeCandidates.find((p) => fs.existsSync(p));
+
+  return {
+    claudeCode: path.join(home, ".claude", "settings.json"),
+    codex: process.env.CODEX_HOME
+      ? path.join(process.env.CODEX_HOME, "config.toml")
+      : path.join(home, ".codex", "config.toml"),
+    openCode: existingOpenCode || openCodeCandidates[0],
+    omp: path.join(home, ".omp", "agent", "models.yml"),
+  };
+}
+
+export function getDefaultStateFilePath(): string {
+  return getSyncStatePath();
+}
+export interface ClientDetectionStatus {
+  id: "claude-code" | "codex" | "opencode" | "omp";
+  installed: boolean;
+  synced: boolean;
+  model?: string;
+  url?: string;
+}
+
+/**
+ * Inspects a client configuration file to determine whether the client is installed
+ * and whether it is actively configured to route to QwenProxy.
+ */
+export function inspectClientSyncStatus(
+  id: "claude-code" | "codex" | "opencode" | "omp",
+  filePath?: string,
+  port = 7936,
+): ClientDetectionStatus {
+  const defaultPaths = getDefaultPaths();
+  const targetPath =
+    filePath ||
+    (id === "claude-code"
+      ? defaultPaths.claudeCode
+      : id === "codex"
+        ? defaultPaths.codex
+        : id === "opencode"
+          ? defaultPaths.openCode
+          : defaultPaths.omp);
+
+  if (!fs.existsSync(targetPath)) {
+    return { id, installed: false, synced: false };
+  }
+
+  try {
+    const raw = fs.readFileSync(targetPath, "utf-8");
+
+    if (id === "claude-code") {
+      const data = JSON.parse(raw);
+      const url = data?.env?.ANTHROPIC_BASE_URL || "";
+      const model = data?.env?.ANTHROPIC_MODEL || data?.model || "";
+      const isSynced =
+        (url.includes(String(port)) || url.includes("qwenproxy")) &&
+        (model.toLowerCase().includes("qwen") || Boolean(data?.env?.ANTHROPIC_AUTH_TOKEN));
+      return {
+        id,
+        installed: true,
+        synced: isSynced,
+        model: model || undefined,
+        url: url || undefined,
+      };
+    }
+
+    if (id === "codex") {
+      const hasProvider = raw.includes("[model_providers.qwenproxy]");
+      const isProviderActive = /^model_provider\s*=\s*["']qwenproxy["']/m.test(raw);
+      const modelMatch = raw.match(/^model\s*=\s*["']([^"']+)["']/m);
+      const model = modelMatch ? modelMatch[1] : undefined;
+      return {
+        id,
+        installed: true,
+        synced: hasProvider && isProviderActive,
+        model,
+      };
+    }
+
+    if (id === "opencode") {
+      const hasQwen =
+        raw.includes('"qwenproxy"') &&
+        (raw.includes(String(port)) || raw.includes("QwenProxy") || raw.includes("qwen3"));
+      return {
+        id,
+        installed: true,
+        synced: hasQwen,
+      };
+    }
+
+    if (id === "omp") {
+      const hasQwen =
+        /^ {2}qwenproxy:\s*$/m.test(raw) ||
+        raw.includes("qwenproxy:") ||
+        (raw.includes(String(port)) && raw.includes("qwen3"));
+      return {
+        id,
+        installed: true,
+        synced: hasQwen,
+      };
+    }
+  } catch {
+    return { id, installed: true, synced: false };
+  }
+
+  return { id, installed: true, synced: false };
+}
+
+export interface SyncAllResult {
+  apiKey: string;
+  port: number;
+  host: string;
+  clients: {
+    claudeCode?: ClientSyncResult;
+    codex?: ClientSyncResult;
+    openCode?: ClientSyncResult;
+    omp?: ClientSyncResult;
+  };
+}
+
+export function syncAllClients(options: SyncAllOptions = {}): SyncAllResult {
+  const defaultPaths = getDefaultPaths();
+  const paths = {
+    claudeCode: options.customPaths?.claudeCode || defaultPaths.claudeCode,
+    codex: options.customPaths?.codex || defaultPaths.codex,
+    openCode: options.customPaths?.openCode || defaultPaths.openCode,
+    omp: options.customPaths?.omp || defaultPaths.omp,
+  };
+
+  const port = options.port ?? (config.server?.port || 7936);
+  const configuredHost = config.server?.host;
+  const host = options.host ?? (configuredHost && configuredHost !== "0.0.0.0" ? configuredHost : "127.0.0.1");
+  const apiKey = resolveApiKey(options.apiKey, config.apiKey);
+  const { anthropicBaseUrl, openaiBaseUrl } = resolveBaseUrls(port, host);
+  const stateFilePath = options.stateFilePath || getDefaultStateFilePath();
+
+  const results: SyncAllResult = {
+    apiKey,
+    port,
+    host,
+    clients: {},
+  };
+
+  const stateRecords: SyncStateFile["clients"] = {};
+  const shouldSync = (client: "claude-code" | "codex" | "opencode" | "omp") => {
+    if (!options.targets || options.targets.length === 0) return true;
+    return options.targets.includes(client);
+  };
+
+  // 1. Claude Code
+  if (shouldSync("claude-code")) {
+    const claudeExisted = fs.existsSync(paths.claudeCode);
+    const claudeRes = syncClaudeCode({
+      filePath: paths.claudeCode,
+      apiKey,
+      baseUrl: anthropicBaseUrl,
+    });
+    results.clients.claudeCode = claudeRes;
+    if (claudeRes.success && claudeRes.backupPath) {
+      stateRecords.claudeCode = {
+        filePath: paths.claudeCode,
+        backupPath: claudeRes.backupPath,
+        existedBefore: claudeExisted,
+        syncedAt: Date.now(),
+      };
+    }
+  }
+
+  // 2. Codex
+  if (shouldSync("codex")) {
+    const codexExisted = fs.existsSync(paths.codex);
+    const codexRes = syncCodex({
+      filePath: paths.codex,
+      apiKey,
+      baseUrl: openaiBaseUrl,
+      setActive: options.setActive ?? true,
+    });
+    results.clients.codex = codexRes;
+    if (codexRes.success && codexRes.backupPath) {
+      stateRecords.codex = {
+        filePath: paths.codex,
+        backupPath: codexRes.backupPath,
+        existedBefore: codexExisted,
+        syncedAt: Date.now(),
+      };
+    }
+  }
+
+  // 3. OpenCode
+  if (shouldSync("opencode")) {
+    const openCodeExisted = fs.existsSync(paths.openCode);
+    const openCodeRes = syncOpenCode({
+      filePath: paths.openCode,
+      apiKey,
+      baseUrl: openaiBaseUrl,
+    });
+    results.clients.openCode = openCodeRes;
+    if (openCodeRes.success && openCodeRes.backupPath) {
+      stateRecords.openCode = {
+        filePath: paths.openCode,
+        backupPath: openCodeRes.backupPath,
+        existedBefore: openCodeExisted,
+        syncedAt: Date.now(),
+      };
+    }
+  }
+
+  // 4. OMP
+  if (shouldSync("omp")) {
+    const ompExisted = fs.existsSync(paths.omp);
+    const ompRes = syncOmp({
+      filePath: paths.omp,
+      apiKey,
+      baseUrl: openaiBaseUrl,
+    });
+    results.clients.omp = ompRes;
+    if (ompRes.success && ompRes.backupPath) {
+      stateRecords.omp = {
+        filePath: paths.omp,
+        backupPath: ompRes.backupPath,
+        existedBefore: ompExisted,
+        syncedAt: Date.now(),
+      };
+    }
+  }
+
+  // Persist sync state
+  try {
+    fs.mkdirSync(path.dirname(stateFilePath), { recursive: true });
+    const stateContent: SyncStateFile = {
+      version: 1,
+      updatedAt: new Date().toISOString(),
+      apiKey,
+      port,
+      host,
+      clients: stateRecords,
+    };
+    fs.writeFileSync(stateFilePath, JSON.stringify(stateContent, null, 2) + "\n", "utf-8");
+  } catch (err) {
+    console.error("Warning: could not write sync state file:", err);
+  }
+
+  return results;
+}
+
+export interface RestoreAllResult {
+  restoredCount: number;
+  details: ClientSyncResult[];
+}
+
+export function restoreAllClients(options: { stateFilePath?: string } = {}): RestoreAllResult {
+  const stateFilePath = options.stateFilePath || getDefaultStateFilePath();
+  const details: ClientSyncResult[] = [];
+  let restoredCount = 0;
+
+  if (!fs.existsSync(stateFilePath)) {
+    return { restoredCount: 0, details };
+  }
+
+  try {
+    const raw = fs.readFileSync(stateFilePath, "utf-8");
+    const state: SyncStateFile = JSON.parse(raw);
+
+    if (state.clients.claudeCode?.backupPath) {
+      const res = restoreClaudeCode(state.clients.claudeCode.filePath, state.clients.claudeCode.backupPath);
+      details.push(res);
+      if (res.success) restoredCount++;
+    }
+
+    if (state.clients.codex?.backupPath) {
+      const res = restoreCodex(state.clients.codex.filePath, state.clients.codex.backupPath);
+      details.push(res);
+      if (res.success) restoredCount++;
+    }
+
+    if (state.clients.openCode?.backupPath) {
+      const res = restoreOpenCode(state.clients.openCode.filePath, state.clients.openCode.backupPath);
+      details.push(res);
+      if (res.success) restoredCount++;
+    }
+
+    if (state.clients.omp?.backupPath) {
+      const res = restoreOmp(state.clients.omp.filePath, state.clients.omp.backupPath);
+      details.push(res);
+      if (res.success) restoredCount++;
+    }
+
+    // Remove state file after successful restoration
+    try {
+      fs.unlinkSync(stateFilePath);
+    } catch {
+      // Ignore
+    }
+  } catch (err) {
+    console.error("Error reading sync state file:", err);
+  }
+
+  return { restoredCount, details };
+}

package/src/sync/omp.ts

@@ -0,0 +1,105 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { ClientSyncResult, SyncOptions } from "./types.ts";
+import { createTimestampBackup, restoreFromBackup } from "./utils.ts";
+
+function buildOmpProviderYaml(baseUrl: string, apiKey: string): string {
+  return `  qwenproxy:
+    baseUrl: ${baseUrl}
+    api: openai-completions
+    apiKey: "${apiKey}"
+    compat:
+      supportsStore: true
+      supportsReasoningEffort: true
+      maxTokensField: max_completion_tokens
+    models:
+      - id: qwen3.8-max
+        name: Qwen3.8-Max
+        input: [text, image]
+        contextWindow: 1000000
+        maxTokens: 131072
+        reasoning: true
+        thinking:
+          mode: effort
+          efforts: [low, medium, high]
+      - id: qwen3.7-plus
+        name: Qwen3.7-Plus
+        input: [text, image]
+        contextWindow: 1000000
+        maxTokens: 131072
+        reasoning: true
+        thinking:
+          mode: effort
+          efforts: [low, medium, high]
+`;
+}
+
+export function syncOmp(options: SyncOptions): ClientSyncResult {
+  const { filePath, apiKey, baseUrl } = options;
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+
+    let backupPath: string | undefined;
+    let content = "";
+
+    if (fs.existsSync(filePath)) {
+      backupPath = createTimestampBackup(filePath);
+      content = fs.readFileSync(filePath, "utf-8");
+    }
+
+    const providerBlock = buildOmpProviderYaml(baseUrl, apiKey);
+
+    if (!content.trim()) {
+      content = `providers:\n${providerBlock}`;
+    } else {
+      // Check if "qwenproxy:" already exists under "providers:"
+      const existingQwenRegex = /^ {2}qwenproxy:[\s\S]*?(?=(?:^ {2}[a-zA-Z0-9_-]+:|\Z))/m;
+      if (existingQwenRegex.test(content)) {
+        content = content.replace(existingQwenRegex, providerBlock);
+      } else {
+        const providersMatch = content.match(/^providers:\s*$/m);
+        if (providersMatch && providersMatch.index !== undefined) {
+          const insertIdx = providersMatch.index + providersMatch[0].length;
+          content =
+            content.slice(0, insertIdx) +
+            "\n" +
+            providerBlock +
+            content.slice(insertIdx);
+        } else {
+          content = content.trimEnd() + "\n\nproviders:\n" + providerBlock;
+        }
+      }
+    }
+
+    fs.writeFileSync(filePath, content.trimEnd() + "\n", "utf-8");
+
+    return {
+      client: "omp",
+      filePath,
+      backupPath,
+      success: true,
+      action: backupPath ? "updated" : "created",
+      message: `Configured OMP with provider qwenproxy (${baseUrl})`,
+    };
+  } catch (err: any) {
+    return {
+      client: "omp",
+      filePath,
+      success: false,
+      action: "failed",
+      error: err?.message || String(err),
+    };
+  }
+}
+
+export function restoreOmp(filePath: string, backupPath?: string): ClientSyncResult {
+  const restored = restoreFromBackup(filePath, backupPath);
+  return {
+    client: "omp",
+    filePath,
+    backupPath,
+    success: restored,
+    action: restored ? "restored" : "failed",
+    message: restored ? "Restored OMP models config from backup" : "Backup file not found",
+  };
+}

package/src/sync/opencode.ts

@@ -0,0 +1,214 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { ClientSyncResult, SyncOptions } from "./types.ts";
+import { createTimestampBackup, restoreFromBackup } from "./utils.ts";
+
+function buildOpenCodeProviderObject(baseUrl: string, apiKey: string): Record<string, any> {
+  return {
+    npm: "@ai-sdk/openai-compatible",
+    name: "QwenProxy",
+    options: {
+      baseURL: baseUrl,
+      apiKey: apiKey,
+    },
+    models: {
+      "qwen3.8-max": {
+        name: "Qwen 3.8 Max",
+        limit: { context: 1048576, output: 65536 },
+        modalities: { input: ["text", "image"], output: ["text"] },
+        reasoning: true,
+        variants: {
+          low: { effort: "low" },
+          medium: { effort: "medium" },
+          high: { effort: "high" },
+        },
+      },
+      "qwen3.7-plus": {
+        name: "Qwen 3.7 Plus",
+        limit: { context: 1048576, output: 65536 },
+        modalities: { input: ["text", "image"], output: ["text"] },
+        reasoning: true,
+        variants: {
+          low: { effort: "low" },
+          medium: { effort: "medium" },
+          high: { effort: "high" },
+        },
+      },
+    },
+  };
+}
+function findKeyObjectSpan(content: string, key: string): { start: number; end: number; hasTrailingComma: boolean } | null {
+  const regex = new RegExp(`"${key}"\\s*:\\s*\\{`);
+  const match = content.match(regex);
+  if (!match || match.index === undefined) return null;
+
+  const startIndex = match.index;
+  const braceIndex = content.indexOf("{", startIndex + match[0].length - 1);
+  if (braceIndex === -1) return null;
+
+  let depth = 0;
+  let inString = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let escape = false;
+
+  for (let i = braceIndex; i < content.length; i++) {
+    const ch = content[i];
+    const nextCh = content[i + 1] || "";
+
+    if (inLineComment) {
+      if (ch === "\n") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && nextCh === "/") {
+        inBlockComment = false;
+        i++;
+      }
+      continue;
+    }
+    if (inString) {
+      if (escape) {
+        escape = false;
+      } else if (ch === "\\") {
+        escape = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+
+    if (ch === "/" && nextCh === "/") {
+      inLineComment = true;
+      i++;
+      continue;
+    }
+    if (ch === "/" && nextCh === "*") {
+      inBlockComment = true;
+      i++;
+      continue;
+    }
+
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+
+    if (ch === "{") {
+      depth++;
+    } else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        let endIndex = i + 1;
+        let hasTrailingComma = false;
+        while (endIndex < content.length && /[\s,]/.test(content[endIndex])) {
+          if (content[endIndex] === ",") {
+            hasTrailingComma = true;
+            endIndex++;
+            break;
+          }
+          if (content[endIndex] === "\n") {
+            break;
+          }
+          endIndex++;
+        }
+        return { start: startIndex, end: endIndex, hasTrailingComma };
+      }
+    }
+  }
+
+  return null;
+}
+
+export function syncOpenCode(options: SyncOptions): ClientSyncResult {
+  const { filePath, apiKey, baseUrl } = options;
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+
+    let backupPath: string | undefined;
+    let content = "";
+
+    if (fs.existsSync(filePath)) {
+      backupPath = createTimestampBackup(filePath);
+      content = fs.readFileSync(filePath, "utf-8");
+    }
+
+    const providerObj = buildOpenCodeProviderObject(baseUrl, apiKey);
+    const providerJson = JSON.stringify(providerObj, null, 6)
+      .split("\n")
+      .map((line, idx) => (idx === 0 ? line : "    " + line))
+      .join("\n");
+
+    const qwenEntry = `    "qwenproxy": ${providerJson}`;
+
+    if (!content.trim()) {
+      const initial = {
+        $schema: "https://opencode.ai/config.json",
+        provider: {
+          qwenproxy: providerObj,
+        },
+      };
+      fs.writeFileSync(filePath, JSON.stringify(initial, null, 2) + "\n", "utf-8");
+    } else {
+      // Check if "qwenproxy" already exists under "provider" with balanced braces
+      const existingSpan = findKeyObjectSpan(content, "qwenproxy");
+      if (existingSpan) {
+        const comma = existingSpan.hasTrailingComma ? "," : "";
+        content =
+          content.slice(0, existingSpan.start) +
+          `"qwenproxy": ${providerJson}${comma}` +
+          content.slice(existingSpan.end);
+      } else {
+        const providerMatch = content.match(/"provider"\s*:\s*\{/);
+        if (providerMatch && providerMatch.index !== undefined) {
+          const insertIdx = providerMatch.index + providerMatch[0].length;
+          content =
+            content.slice(0, insertIdx) +
+            "\n" +
+            qwenEntry +
+            "," +
+            content.slice(insertIdx);
+        } else {
+          // If no "provider" object exists, add it before the final closing brace
+          const lastBraceIdx = content.lastIndexOf("}");
+          if (lastBraceIdx !== -1) {
+            const comma = content.slice(0, lastBraceIdx).trimEnd().endsWith("{") ? "" : ",";
+            content =
+              content.slice(0, lastBraceIdx).trimEnd() +
+              `${comma}\n  "provider": {\n${qwenEntry}\n  }\n}\n`;
+          }
+        }
+      }
+      fs.writeFileSync(filePath, content, "utf-8");
+    }
+
+    return {
+      client: "opencode",
+      filePath,
+      backupPath,
+      success: true,
+      action: backupPath ? "updated" : "created",
+      message: `Configured OpenCode with provider qwenproxy (${baseUrl})`,
+    };
+  } catch (err: any) {
+    return {
+      client: "opencode",
+      filePath,
+      success: false,
+      action: "failed",
+      error: err?.message || String(err),
+    };
+  }
+}
+
+export function restoreOpenCode(filePath: string, backupPath?: string): ClientSyncResult {
+  const restored = restoreFromBackup(filePath, backupPath);
+  return {
+    client: "opencode",
+    filePath,
+    backupPath,
+    success: restored,
+    action: restored ? "restored" : "failed",
+    message: restored ? "Restored OpenCode config from backup" : "Backup file not found",
+  };
+}