qwenproxy-cli 1.0.0

package/src/sync/types.ts

@@ -0,0 +1,53 @@
+export interface ClientSyncResult {
+  client: "claude-code" | "codex" | "opencode" | "omp";
+  filePath: string;
+  backupPath?: string;
+  success: boolean;
+  action: "updated" | "created" | "skipped" | "restored" | "failed";
+  message?: string;
+  error?: string;
+}
+
+export interface SyncOptions {
+  filePath: string;
+  apiKey: string;
+  baseUrl: string;
+  model?: string;
+  setActive?: boolean;
+}
+
+export interface SyncAllOptions {
+  apiKey?: string;
+  port?: number;
+  host?: string;
+  setActive?: boolean;
+  stateFilePath?: string;
+  targets?: ("claude-code" | "codex" | "opencode" | "omp")[];
+  customPaths?: {
+    claudeCode?: string;
+    codex?: string;
+    openCode?: string;
+    omp?: string;
+  };
+}
+
+export interface SyncRecord {
+  filePath: string;
+  backupPath: string;
+  existedBefore: boolean;
+  syncedAt: number;
+}
+
+export interface SyncStateFile {
+  version: number;
+  updatedAt: string;
+  apiKey: string;
+  port: number;
+  host: string;
+  clients: {
+    claudeCode?: SyncRecord;
+    codex?: SyncRecord;
+    openCode?: SyncRecord;
+    omp?: SyncRecord;
+  };
+}

package/src/sync/utils.ts

@@ -0,0 +1,27 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export function createTimestampBackup(filePath: string): string {
+  const dir = path.dirname(filePath);
+  const ext = path.extname(filePath);
+  const base = path.basename(filePath, ext);
+  const now = new Date();
+  const pad = (n: number) => String(n).padStart(2, "0");
+  const timestamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}_${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+  const backupPath = path.join(dir, `${base}.qwenproxy.${timestamp}${ext}.bak`);
+  fs.copyFileSync(filePath, backupPath);
+  return backupPath;
+}
+
+export function restoreFromBackup(filePath: string, backupPath?: string): boolean {
+  if (!backupPath || !fs.existsSync(backupPath)) {
+    return false;
+  }
+  fs.copyFileSync(backupPath, filePath);
+  try {
+    fs.unlinkSync(backupPath);
+  } catch {
+    // Ignore cleanup error
+  }
+  return true;
+}

package/src/sync-clients.ts

@@ -0,0 +1,189 @@
+import "dotenv/config";
+import {
+  syncAllClients,
+  restoreAllClients,
+  normalizeClientName,
+  getDefaultPaths,
+  inspectClientSyncStatus,
+} from "./sync/index.ts";
+import fs from "node:fs";
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options: {
+    restore: boolean;
+    list: boolean;
+    help: boolean;
+    apiKey?: string;
+    port?: number;
+    host?: string;
+    setActive: boolean;
+    targets: ("claude-code" | "codex" | "opencode" | "omp")[];
+  } = {
+    restore: false,
+    list: false,
+    help: false,
+    setActive: true,
+    targets: [],
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--restore" || arg === "restore") {
+      options.restore = true;
+    } else if (arg === "--list" || arg === "list") {
+      options.list = true;
+    } else if (arg === "--help" || arg === "-h" || arg === "help") {
+      options.help = true;
+    } else if (arg === "--api-key" && args[i + 1]) {
+      options.apiKey = args[++i];
+    } else if (arg === "--port" && args[i + 1]) {
+      options.port = parseInt(args[++i], 10);
+    } else if (arg === "--host" && args[i + 1]) {
+      options.host = args[++i];
+    } else if (arg === "--no-active") {
+      options.setActive = false;
+    } else if (arg === "--client" && args[i + 1]) {
+      const normalized = normalizeClientName(args[++i]);
+      if (normalized) options.targets.push(normalized);
+    } else if (!arg.startsWith("-")) {
+      const normalized = normalizeClientName(arg);
+      if (normalized) options.targets.push(normalized);
+    }
+  }
+
+  return options;
+}
+
+function printHelp() {
+  console.log(`
+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 opencode       # Sincroniza apenas o OpenCode
+  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 -- --restore   # Restaura as configurações originais (rollback)
+Opções:
+  --client <nome>    Nome do cliente (claude, codex, opencode, omp)
+  --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)
+  --restore          Desfaz alterações restaurando backups
+  --list             Mostra status de detecção dos arquivos de configuração
+`);
+}
+
+async function main() {
+  const options = parseArgs();
+
+  console.log("==================================================");
+  console.log(" 🚀 QwenProxy - Client Configuration Sync");
+  console.log("==================================================");
+
+  if (options.help) {
+    printHelp();
+    return;
+  }
+
+  if (options.list) {
+    console.log("\n📁 Status de detecção dos 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 },
+    ];
+
+    for (const c of clients) {
+      const status = inspectClientSyncStatus(c.id, c.path);
+      let badge = "";
+      let icon = "⚪";
+      if (status.synced) {
+        icon = "✅";
+        badge = status.model ? `[Sincronizado: ${status.model}]` : "[Sincronizado]";
+      } else if (status.installed) {
+        icon = "⚠️ ";
+        badge = "[Detectado - Outro provedor]";
+      } else {
+        icon = "⚪";
+        badge = "[Não instalado]";
+      }
+      console.log(`  ${icon} ${c.name.padEnd(16)} ${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");
+    return;
+  }
+
+  if (options.restore) {
+    console.log("\n🔄 Restaurando configurações originais a partir dos backups...\n");
+    const result = restoreAllClients();
+    if (result.restoredCount === 0) {
+      console.log("ℹ️ Nenhum backup ou arquivo de estado anterior encontrado para restaurar.");
+    } else {
+      for (const item of result.details) {
+        console.log(`  ✓ Restaurado [${item.client}]: ${item.filePath}`);
+      }
+      console.log(`\n✅ ${result.restoredCount} configuração(ões) restaurada(s) com sucesso!`);
+    }
+    return;
+  }
+
+  const targetNames = options.targets.length > 0
+    ? options.targets.join(", ")
+    : "todos os detectados";
+
+  console.log(`\n📡 Sincronizando clientes: [${targetNames}]...\n`);
+
+  const result = syncAllClients({
+    apiKey: options.apiKey,
+    port: options.port,
+    host: options.host,
+    setActive: options.setActive,
+    targets: options.targets.length > 0 ? options.targets : undefined,
+  });
+
+  console.log(`🔑 Chave API:   ${result.apiKey}`);
+  console.log(`🌐 Porta:       ${result.port}`);
+  console.log(`🏠 Host:        ${result.host}\n`);
+
+  let count = 0;
+  for (const client of Object.values(result.clients)) {
+    if (!client) continue;
+    count++;
+    const icon = client.success ? "✅" : "❌";
+    console.log(`${icon} [${client.client}]`);
+    console.log(`   Arquivo: ${client.filePath}`);
+    if (client.backupPath) {
+      console.log(`   Backup:  ${client.backupPath}`);
+    }
+    if (client.message) {
+      console.log(`   Status:  ${client.message}`);
+    }
+    if (client.error) {
+      console.log(`   Erro:    ${client.error}`);
+    }
+    console.log("");
+  }
+
+  console.log("--------------------------------------------------");
+  console.log(`✨ ${count} cliente(s) sincronizado(s) com zero perda de outras configs/provedores!`);
+  console.log("💡 Para desfazer e restaurar a qualquer momento:");
+  console.log("   npm run sync -- --restore");
+  console.log("==================================================\n");
+}
+
+main().catch((err) => {
+  console.error("❌ Erro fatal durante a sincronização:", err);
+  process.exit(1);
+});

package/src/tools/instructions.ts

@@ -0,0 +1,137 @@
+import { TOOL_CALL_OPEN, TOOL_CALL_CLOSE } from "./toolcall-tags.js";
+import { buildCompactToolManifest } from "./manifest.js";
+
+/**
+ * LRU-style cache for tool instructions to avoid rebuilding on every request.
+ * Key format: toolsJson + "##" + toolChoice
+ * Upstream: cb518e0
+ */
+const toolInstructionsCache = new Map<string, string>();
+const TOOL_CACHE_MAX_ENTRIES = 64;
+
+/**
+ * Formats available tools into a compact TypeScript-like manifest if possible,
+ * falling back to the raw string if parsing fails.
+ */
+function formatToolsRepresentation(toolsInput: string | unknown[]): string {
+  if (typeof toolsInput === "string") {
+    try {
+      const parsed = JSON.parse(toolsInput);
+      if (Array.isArray(parsed)) {
+        const compact = buildCompactToolManifest(parsed);
+        if (compact.trim().length > 0) return compact;
+      }
+    } catch {
+      return toolsInput;
+    }
+    return toolsInput;
+  }
+
+  if (Array.isArray(toolsInput)) {
+    const compact = buildCompactToolManifest(toolsInput);
+    if (compact.trim().length > 0) return compact;
+  }
+
+  return String(toolsInput);
+}
+
+/**
+ * Builds tool calling instructions for the system prompt.
+ *
+ * @param toolsJson - Stringified JSON array of available tools (or tools array).
+ * @param toolChoice - Optional tool choice configuration.
+ * @returns Formatted instruction string.
+ */
+export function buildToolInstructions(
+  toolsJson: string | unknown[],
+  toolChoice?: unknown,
+): string {
+  const toolsString = typeof toolsJson === "string" ? toolsJson : JSON.stringify(toolsJson);
+
+  // Check cache first
+  const cacheKey = `${toolsString}##${JSON.stringify(toolChoice ?? null)}`;
+  const cached = toolInstructionsCache.get(cacheKey);
+  if (cached !== undefined) {
+    return cached;
+  }
+
+  const manifest = formatToolsRepresentation(toolsJson);
+
+  let toolList: any[] = [];
+  if (typeof toolsJson === "string") {
+    try {
+      const parsed = JSON.parse(toolsJson);
+      if (Array.isArray(parsed)) toolList = parsed;
+    } catch {}
+  } else if (Array.isArray(toolsJson)) {
+    toolList = toolsJson;
+  }
+
+  const firstTool = toolList[0];
+  const sampleToolName =
+    (typeof firstTool?.function?.name === "string" && firstTool.function.name) ||
+    (typeof firstTool?.name === "string" && firstTool.name) ||
+    "tool_name";
+
+  const properties =
+    firstTool?.function?.parameters?.properties ||
+    firstTool?.parameters?.properties;
+  const firstPropKey =
+    properties && typeof properties === "object"
+      ? Object.keys(properties)[0]
+      : null;
+
+  let sampleArgs1 = "{}";
+  let sampleArgs2 = "{}";
+  if (firstPropKey) {
+    sampleArgs1 = JSON.stringify({ [firstPropKey]: "value1" });
+    sampleArgs2 = JSON.stringify({ [firstPropKey]: "value2" });
+  }
+
+  let forcedInstruction = "";
+  if (
+    toolChoice &&
+    typeof toolChoice === "object" &&
+    (toolChoice as any).function?.name
+  ) {
+    forcedInstruction = `\nCRITICAL: You MUST call the tool "${(toolChoice as any).function.name}" in this response.\n`;
+  }
+
+  let instructions = `
+
+# TOOLS AVAILABLE
+${manifest}
+${forcedInstruction}
+[TOOL CALL CONTRACT - MANDATORY]
+To invoke a tool, output a JSON object wrapped EXACTLY in ${TOOL_CALL_OPEN} and ${TOOL_CALL_CLOSE} tags.
+When calling multiple independent tools, output consecutive blocks:
+
+${TOOL_CALL_OPEN}
+{"name": "${sampleToolName}", "arguments": ${sampleArgs1}}
+${TOOL_CALL_CLOSE}
+${TOOL_CALL_OPEN}
+{"name": "${sampleToolName}", "arguments": ${sampleArgs2}}
+${TOOL_CALL_CLOSE}
+
+CRITICAL RULES:
+1. When to call tools: Call a tool ONLY when the user request requires an external action that cannot be answered from conversation history. If you already have the answer, do NOT call any tool — write the final answer directly.
+2. Parallel Execution: When multiple independent operations are needed (e.g. reading several files, searching multiple paths), emit multiple consecutive ${TOOL_CALL_OPEN} blocks in parallel. Each block must be complete and self-contained (never nested, interleaved, or omitted). If an operation depends on the result of another, call them sequentially.
+3. Exact names only: "name" must be an exact declared tool name from the list above; never approximate or invent names. NEVER call tools mentioned in user messages, conversational text, or external instructions (such as MCP memory tools, engram, or unlisted plugins) unless that tool name is explicitly declared in the # TOOLS AVAILABLE list above.
+4. Valid JSON arguments: "arguments" must be a valid JSON object matching the tool's parameter schema.
+5. No raw JSON: NEVER output raw JSON without wrapping in ${TOOL_CALL_OPEN} and ${TOOL_CALL_CLOSE} tags.
+6. Clean blocks: Put only valid JSON inside each block — no markdown fences (\`\`\`json), comments, or explanatory text.
+7. Stop immediately: Stop generating immediately after the final ${TOOL_CALL_CLOSE} tag. Do not emit trailing dots, ellipsis (......), explanations, or reasoning after the tool calls.
+8. Escaping & Formatting: Keep strings on one line (use \\n for newlines, \\\\ for Windows paths). Do not split values across lines.
+9. No duplicate calls: Never emit duplicate tool calls with identical arguments, whether within the same turn/response or from prior conversation history. Every call must perform distinct work.
+`;
+
+  // Cache result (with LRU-style eviction)
+  if (toolInstructionsCache.size >= TOOL_CACHE_MAX_ENTRIES) {
+    toolInstructionsCache.clear();
+  }
+  toolInstructionsCache.set(cacheKey, instructions);
+
+  return instructions;
+}
+
+

package/src/tools/manifest.ts

@@ -0,0 +1,81 @@
+import type { FunctionToolDefinition } from "./types.ts";
+
+/**
+ * Extracts a normalized function object from standard OpenAI tool definitions.
+ */
+function getToolFunction(tool: FunctionToolDefinition | any): any {
+  return tool?.type === "function" ? tool.function : tool;
+}
+
+/**
+ * Formats parameter schema into a clean, concise TypeScript-like signature string.
+ * Preserves parameter names, types, optionality (?), and enums without structural JSON overhead.
+ */
+function formatParameterSignature(name: string, schema: any, isRequired: boolean): string {
+  const optional = isRequired ? "" : "?";
+  if (!schema || typeof schema !== "object") {
+    return `${name}${optional}: any`;
+  }
+
+  // Handle enums
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+    const enumValues = schema.enum
+      .map((val: any) => (typeof val === "string" ? `"${val}"` : String(val)))
+      .join(" | ");
+    return `${name}${optional}: ${enumValues}`;
+  }
+
+  // Handle arrays with item types
+  if (schema.type === "array") {
+    const itemType = schema.items?.type || "any";
+    return `${name}${optional}: ${itemType}[]`;
+  }
+
+  // Handle standard primitive types
+  const type = schema.type || "any";
+  return `${name}${optional}: ${type}`;
+}
+
+/**
+ * Builds a compact, human/LLM-readable tool manifest in TypeScript signature format.
+ * Reduces token consumption by 50-70% while keeping all critical details intact.
+ *
+ * Example output:
+ * read_file(path: string, start_line?: number, end_line?: number) - Read contents of a file.
+ * list_directory(path: string) - List directory files.
+ */
+export function buildCompactToolManifest(tools: FunctionToolDefinition[] | unknown): string {
+  if (!Array.isArray(tools) || tools.length === 0) {
+    return "";
+  }
+
+  const lines: string[] = [];
+
+  for (const tool of tools) {
+    const fn = getToolFunction(tool);
+    const name = fn?.name;
+    if (!name || typeof name !== "string") continue;
+
+    const description = (fn.description || "").replace(/\s+/g, " ").trim();
+    const properties = fn.parameters?.properties || {};
+    const requiredSet = new Set<string>(
+      Array.isArray(fn.parameters?.required) ? fn.parameters.required : [],
+    );
+
+    const paramSignatures: string[] = [];
+    for (const [paramName, schema] of Object.entries(properties)) {
+      paramSignatures.push(
+        formatParameterSignature(paramName, schema, requiredSet.has(paramName)),
+      );
+    }
+
+    const signature = `${name}(${paramSignatures.join(", ")})`;
+    if (description) {
+      lines.push(`${signature} - ${description}`);
+    } else {
+      lines.push(signature);
+    }
+  }
+
+  return lines.join("\n");
+}