qwenproxy-cli 1.0.28 → 1.0.30

package/src/sync/openclaw.ts

@@ -0,0 +1,237 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { ClientSyncResult, SyncOptions } from "./types.ts";
+import { createTimestampBackup, restoreFromBackup } from "./utils.ts";
+
+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;
+}
+
+function buildOpenClawProviderObject(
+  baseUrl: string,
+  apiKey: string,
+  model: string = "qwen3.8-max",
+): Record<string, any> {
+  const models = [
+    {
+      id: model,
+      name: model === "qwen3.8-max" ? "Qwen 3.8 Max" : model,
+      reasoning: true,
+      supportsReasoningEffort: true,
+      supportedReasoningEfforts: ["low", "medium", "high"],
+      contextWindow: 1000000,
+      maxTokens: 65536,
+    },
+  ];
+
+  if (model !== "qwen3.7-plus") {
+    models.push({
+      id: "qwen3.7-plus",
+      name: "Qwen 3.7 Plus",
+      reasoning: true,
+      supportsReasoningEffort: true,
+      supportedReasoningEfforts: ["low", "medium", "high"],
+      contextWindow: 1000000,
+      maxTokens: 65536,
+    });
+  }
+
+  return {
+    baseUrl,
+    apiKey,
+    api: "openai-completions",
+    models,
+  };
+}
+
+export function syncOpenClaw(options: SyncOptions): ClientSyncResult {
+  const { filePath, apiKey, baseUrl, model = "qwen3.8-max", reasoningEffort = "high" } = 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 = buildOpenClawProviderObject(baseUrl, apiKey, model);
+    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 = {
+        models: {
+          mode: "merge",
+          providers: {
+            qwenproxy: providerObj,
+          },
+        },
+        agents: {
+          defaults: {
+            model: {
+              primary: `qwenproxy/${model}`,
+            },
+            thinking: {
+              effort: reasoningEffort,
+            },
+          },
+        },
+      };
+      fs.writeFileSync(filePath, JSON.stringify(initial, null, 2) + "\n", "utf-8");
+    } else {
+      // Check if "qwenproxy" already exists under providers
+      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 providersMatch = content.match(/"providers"\s*:\s*\{/);
+        if (providersMatch && providersMatch.index !== undefined) {
+          const insertIdx = providersMatch.index + providersMatch[0].length;
+          content =
+            content.slice(0, insertIdx) +
+            "\n" +
+            qwenEntry +
+            "," +
+            content.slice(insertIdx);
+        } else {
+          // If "providers" does not exist, check if "models" exists
+          const modelsMatch = content.match(/"models"\s*:\s*\{/);
+          if (modelsMatch && modelsMatch.index !== undefined) {
+            const insertIdx = modelsMatch.index + modelsMatch[0].length;
+            const providersBlock = `\n    "providers": {\n${qwenEntry}\n    },`;
+            content = content.slice(0, insertIdx) + providersBlock + content.slice(insertIdx);
+          } else {
+            // Append models before the last closing brace
+            const lastBraceIdx = content.lastIndexOf("}");
+            if (lastBraceIdx !== -1) {
+              const comma = content.slice(0, lastBraceIdx).trimEnd().endsWith("{") ? "" : ",";
+              const modelsBlock = `${comma}\n  "models": {\n    "mode": "merge",\n    "providers": {\n${qwenEntry}\n    }\n  }\n`;
+              content = content.slice(0, lastBraceIdx).trimEnd() + modelsBlock + "}\n";
+            }
+          }
+        }
+      }
+
+      fs.writeFileSync(filePath, content, "utf-8");
+    }
+
+    return {
+      client: "openclaw",
+      filePath,
+      backupPath,
+      success: true,
+      action: backupPath ? "updated" : "created",
+      message: `Configured OpenClaw with provider qwenproxy (${baseUrl}) and reasoning effort ${reasoningEffort}`,
+    };
+  } catch (err: any) {
+    return {
+      client: "openclaw",
+      filePath,
+      success: false,
+      action: "failed",
+      error: err?.message || String(err),
+    };
+  }
+}
+
+export function restoreOpenClaw(filePath: string, backupPath?: string): ClientSyncResult {
+  const restored = restoreFromBackup(filePath, backupPath);
+  return {
+    client: "openclaw",
+    filePath,
+    backupPath,
+    success: restored,
+    action: restored ? "restored" : "failed",
+    message: restored ? "Restored OpenClaw config from backup" : "Backup file not found",
+  };
+}

package/src/sync/types.ts

@@ -1,7 +1,20 @@
+export type SyncClientName =
+  | "claude-code"
+  | "codex"
+  | "opencode"
+  | "omp"
+  | "hermes"
+  | "openclaw"
+  | "kilo"
+  | "cline"
+  | "zed"
+  | "aider";
+
 export interface ClientSyncResult {
-  client: "claude-code" | "codex" | "opencode" | "omp";
+  client: SyncClientName;
   filePath: string;
   backupPath?: string;
+  extraBackupPath?: string;
   success: boolean;
   action: "updated" | "created" | "skipped" | "restored" | "failed";
   message?: string;
@@ -14,6 +27,8 @@ export interface SyncOptions {
   baseUrl: string;
   model?: string;
   setActive?: boolean;
+  reasoningEffort?: "low" | "medium" | "high" | "none";
+  modelSettingsPath?: string;
 }
 
 export interface SyncAllOptions {
@@ -22,15 +37,20 @@ export interface SyncAllOptions {
   host?: string;
   setActive?: boolean;
   stateFilePath?: string;
-  targets?: ("claude-code" | "codex" | "opencode" | "omp")[];
+  targets?: SyncClientName[];
   customPaths?: {
     claudeCode?: string;
     codex?: string;
     openCode?: string;
     omp?: string;
+    hermes?: string;
+    openClaw?: string;
+    kilo?: string;
+    cline?: string;
+    zed?: string;
+    aider?: string;
   };
 }
-
 export interface SyncRecord {
   filePath: string;
   backupPath: string;
@@ -49,5 +69,11 @@ export interface SyncStateFile {
     codex?: SyncRecord;
     openCode?: SyncRecord;
     omp?: SyncRecord;
+    hermes?: SyncRecord;
+    openClaw?: SyncRecord;
+    kilo?: SyncRecord;
+    cline?: SyncRecord;
+    zed?: SyncRecord;
+    aider?: SyncRecord;
   };
 }

package/src/sync/zed.ts

@@ -0,0 +1,210 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { ClientSyncResult, SyncOptions } from "./types.ts";
+import { createTimestampBackup, restoreFromBackup } from "./utils.ts";
+
+function parseJsonWithComments(raw: string): Record<string, any> {
+  let result = "";
+  let inString = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let escape = false;
+
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i];
+    const nextCh = raw[i + 1] || "";
+
+    if (inLineComment) {
+      if (ch === "\n") {
+        inLineComment = false;
+        result += ch;
+      }
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && nextCh === "/") {
+        inBlockComment = false;
+        i++;
+      }
+      continue;
+    }
+    if (inString) {
+      result += ch;
+      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;
+      result += ch;
+      continue;
+    }
+
+    result += ch;
+  }
+
+  const cleaned = result.replace(/,\s*([\}\]])/g, "$1");
+  return JSON.parse(cleaned);
+}
+
+function buildZedAvailableModels(primaryModel: string = "qwen3.8-max"): any[] {
+  const models = [
+    {
+      name: primaryModel,
+      max_tokens: 1000000,
+      max_output_tokens: 131072,
+      max_completion_tokens: 131072,
+      capabilities: {
+        tools: true,
+        images: true,
+        parallel_tool_calls: true,
+        prompt_cache_key: true,
+        chat_completions: true,
+        interleaved_reasoning: true,
+      },
+    },
+    {
+      name: `${primaryModel}-thinking`,
+      max_tokens: 1000000,
+      max_output_tokens: 131072,
+      max_completion_tokens: 131072,
+      capabilities: {
+        tools: true,
+        images: true,
+        parallel_tool_calls: true,
+        prompt_cache_key: true,
+        chat_completions: true,
+        interleaved_reasoning: true,
+      },
+    },
+    {
+      name: `${primaryModel}-fast`,
+      max_tokens: 1000000,
+      max_output_tokens: 131072,
+      max_completion_tokens: 131072,
+      capabilities: {
+        tools: true,
+        images: true,
+        parallel_tool_calls: true,
+        prompt_cache_key: true,
+        chat_completions: true,
+        interleaved_reasoning: true,
+      },
+    },
+  ];
+
+  if (primaryModel !== "qwen3.7-plus") {
+    models.push({
+      name: "qwen3.7-plus",
+      max_tokens: 1000000,
+      max_output_tokens: 65536,
+      max_completion_tokens: 65536,
+      capabilities: {
+        tools: true,
+        images: true,
+        parallel_tool_calls: true,
+        prompt_cache_key: true,
+        chat_completions: true,
+        interleaved_reasoning: true,
+      },
+    });
+  }
+
+  return models;
+}
+
+export function syncZed(options: SyncOptions): ClientSyncResult {
+  const { filePath, baseUrl, model = "qwen3.8-max", setActive = true } = options;
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+
+    let backupPath: string | undefined;
+    let existingSettings: Record<string, any> = {};
+
+    if (fs.existsSync(filePath)) {
+      backupPath = createTimestampBackup(filePath);
+      try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        existingSettings = parseJsonWithComments(content);
+      } catch {
+        existingSettings = {};
+      }
+    }
+
+    const languageModels = existingSettings.language_models || {};
+    const openaiCompatible = languageModels.openai_compatible || {};
+
+    openaiCompatible.QwenProxy = {
+      api_url: baseUrl,
+      available_models: buildZedAvailableModels(model),
+    };
+
+    const updatedSettings: Record<string, any> = {
+      ...existingSettings,
+      language_models: {
+        ...languageModels,
+        openai_compatible: openaiCompatible,
+      },
+    };
+
+    if (setActive) {
+      const existingAgent = existingSettings.agent || {};
+      updatedSettings.agent = {
+        ...existingAgent,
+        default_model: {
+          provider: "QwenProxy",
+          model,
+          enable_thinking: true,
+        },
+      };
+    }
+
+    fs.writeFileSync(filePath, JSON.stringify(updatedSettings, null, 2) + "\n", "utf-8");
+
+    return {
+      client: "zed",
+      filePath,
+      backupPath,
+      success: true,
+      action: backupPath ? "updated" : "created",
+      message: `Configured Zed Editor with QwenProxy (${baseUrl}) and model ${model}`,
+    };
+  } catch (err: any) {
+    return {
+      client: "zed",
+      filePath,
+      success: false,
+      action: "failed",
+      error: err?.message || String(err),
+    };
+  }
+}
+
+export function restoreZed(filePath: string, backupPath?: string): ClientSyncResult {
+  const restored = restoreFromBackup(filePath, backupPath);
+  return {
+    client: "zed",
+    filePath,
+    backupPath,
+    success: restored,
+    action: restored ? "restored" : "failed",
+    message: restored ? "Restored Zed settings from backup" : "Backup file not found",
+  };
+}

package/src/sync-clients.ts

@@ -6,7 +6,7 @@ import {
   getDefaultPaths,
   inspectClientSyncStatus,
 } from "./sync/index.ts";
-import fs from "node:fs";
+import type { SyncClientName } from "./sync/types.ts";
 
 function parseArgs() {
   const args = process.argv.slice(2);
@@ -18,7 +18,7 @@ function parseArgs() {
     port?: number;
     host?: string;
     setActive: boolean;
-    targets: ("claude-code" | "codex" | "opencode" | "omp")[];
+    targets: SyncClientName[];
   } = {
     restore: false,
     list: false,
@@ -61,20 +61,27 @@ Uso:
   npm run sync [clientes...] [opções]
 
 Exemplos:
-  npm run sync                # Sincroniza todos os clientes detectados
-  npm run sync claude         # Sincroniza apenas o Claude Code
-  npm run sync codex          # Sincroniza apenas o Codex CLI
+  npm run sync                # Sincroniza todos os 10 clientes detectados
+  npm run sync hermes         # Sincroniza apenas o Hermes Agent
   npm run sync opencode       # Sincroniza apenas o OpenCode
+  npm run sync claude         # Sincroniza apenas o Claude Code
+  npm run sync openclaw       # Sincroniza apenas o OpenClaw
+  npm run sync kilo           # Sincroniza apenas o Kilo Code
+  npm run sync cline          # Sincroniza Cline & Zoo Code
   npm run sync omp            # Sincroniza apenas o OMP (Oh My Pi)
-  npm run sync claude codex   # Sincroniza Claude Code e Codex
-  npm run sync -- --list      # Lista os arquivos dos clientes detectados
+  npm run sync codex          # Sincroniza apenas o Codex CLI
+  npm run sync zed            # Sincroniza apenas o Zed Editor
+  npm run sync aider          # Sincroniza apenas o Aider
+  npm run sync claude codex   # Sincroniza múltiplos clientes específicos
+  npm run sync -- --list      # Lista status de detecção de todos os 10 clientes
   npm run sync -- --restore   # Restaura as configurações originais (rollback)
+
 Opções:
-  --client <nome>    Nome do cliente (claude, codex, opencode, omp)
+  --client <nome>    Nome do cliente (hermes, opencode, claude, openclaw, kilo, cline, omp, codex, zed, aider)
   --api-key <chave>  Sobrescrever chave de API (padrão: lê do .env ou usa sk-qwenproxy-local)
   --port <porta>     Sobrescrever porta do servidor (padrão: lê do .env ou usa 7936)
   --host <host>      Sobrescrever host do servidor (padrão: 127.0.0.1)
-  --no-active        Não definir o modelo ativo no Codex (apenas adiciona o provider)
+  --no-active        Não definir o modelo ativo como padrão (apenas adiciona o provider)
   --restore          Desfaz alterações restaurando backups
   --list             Mostra status de detecção dos arquivos de configuração
 `);
@@ -84,7 +91,7 @@ async function main() {
   const options = parseArgs();
 
   console.log("==================================================");
-  console.log(" 🚀 QwenProxy - Client Configuration Sync");
+  console.log(" 🚀 QwenProxy - Top 10 Client Configuration Sync");
   console.log("==================================================");
 
   if (options.help) {
@@ -93,13 +100,19 @@ async function main() {
   }
 
   if (options.list) {
-    console.log("\n📁 Status de detecção dos clientes no seu computador:\n");
+    console.log("\n📁 Status de detecção dos 10 clientes no seu computador:\n");
     const defaultPaths = getDefaultPaths();
-    const clients = [
-      { id: "claude-code" as const, name: "Claude Code", path: defaultPaths.claudeCode },
-      { id: "codex" as const, name: "Codex CLI", path: defaultPaths.codex },
-      { id: "opencode" as const, name: "OpenCode", path: defaultPaths.openCode },
-      { id: "omp" as const, name: "OMP (Oh My Pi)", path: defaultPaths.omp },
+    const clients: { id: SyncClientName; name: string; path: string }[] = [
+      { id: "hermes", name: "1. Hermes Agent", path: defaultPaths.hermes },
+      { id: "opencode", name: "2. OpenCode", path: defaultPaths.openCode },
+      { id: "claude-code", name: "3. Claude Code", path: defaultPaths.claudeCode },
+      { id: "openclaw", name: "4. OpenClaw", path: defaultPaths.openClaw },
+      { id: "kilo", name: "5. Kilo Code", path: defaultPaths.kilo },
+      { id: "cline", name: "6. Cline & Zoo", path: defaultPaths.cline },
+      { id: "omp", name: "7. OMP (Oh My Pi)", path: defaultPaths.omp },
+      { id: "codex", name: "8. Codex CLI", path: defaultPaths.codex },
+      { id: "zed", name: "9. Zed Editor", path: defaultPaths.zed },
+      { id: "aider", name: "10. Aider", path: defaultPaths.aider },
     ];
 
     for (const c of clients) {
@@ -116,12 +129,13 @@ async function main() {
         icon = "⚪";
         badge = "[Não instalado]";
       }
-      console.log(`  ${icon} ${c.name.padEnd(16)} ${badge}`);
+      console.log(`  ${icon} ${c.name.padEnd(20)} ${badge}`);
       console.log(`     ${c.path}`);
     }
     console.log("\nPara sincronizar um ou todos, execute:");
     console.log("  npm run sync");
-    console.log("  npm run sync claude\n");
+    console.log("  npm run sync hermes");
+    console.log("  npm run sync claude cline zed\n");
     return;
   }
 

package/src/update-cli.ts

@@ -68,6 +68,46 @@ export function isNewerVersion(current: string, latest: string): boolean {
   return false;
 }
 
+export async function fetchLatestNpmVersion(packageName: string): Promise<string> {
+  // 1. Direct fast HTTP query to registry.npmjs.org (bypasses child process & Windows npm.cmd cold start)
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 6000);
+    const res = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+      headers: { Accept: "application/json" },
+      signal: controller.signal,
+    });
+    clearTimeout(timer);
+    if (res.ok) {
+      const data = (await res.json()) as { version?: string };
+      if (data.version && typeof data.version === "string") {
+        return data.version.trim();
+      }
+    }
+  } catch {}
+
+  // 2. Fallback: npm view via CLI with a generous 30s timeout and clean semver extraction
+  try {
+    const fullCmd = `npm view ${packageName} version`;
+    const res = spawnSync(fullCmd, {
+      encoding: "utf-8",
+      shell: true,
+      timeout: 30000,
+    });
+    if (res.stdout) {
+      const lines = res.stdout.trim().split(/\r?\n/);
+      for (const line of lines.reverse()) {
+        const cleaned = line.trim().replace(/^v/i, "");
+        if (/^\d+\.\d+\.\d+/.test(cleaned)) {
+          return cleaned;
+        }
+      }
+    }
+  } catch {}
+
+  return "";
+}
+
 export async function runUpdateCommand(): Promise<void> {
   let pkg: any = { name: "qwenproxy-cli", version: "1.0.0" };
   try {
@@ -82,16 +122,7 @@ export async function runUpdateCommand(): Promise<void> {
   console.log(`⚙️ [QwenProxy] Gerenciador de pacotes detectado: ${pm}`);
   console.log(`🔍 [QwenProxy] Verificando se há novas versões de ${packageName} no npm registry...`);
 
-  let latestVersion = "";
-  try {
-    const fullCmd = `npm view ${packageName} version`;
-    const res = spawnSync(fullCmd, {
-      encoding: "utf-8",
-      shell: true,
-      timeout: 10000,
-    });
-    latestVersion = res.stdout ? res.stdout.trim() : "";
-  } catch {}
+  const latestVersion = await fetchLatestNpmVersion(packageName);
 
   if (!latestVersion) {
     console.warn("⚠️  [QwenProxy] Não foi possível consultar o registro online.");