qwenproxy-cli 1.0.31 → 1.0.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qwenproxy-cli",
-  "version": "1.0.31",
+  "version": "1.0.32",
   "description": "High-performance OpenAI & Anthropic compatible API gateway for Qwen with multi-account rotation, interactive TUI, and resilient tool calling.",
   "main": "src/index.ts",
   "bin": {

package/src/sync/index.ts

@@ -151,6 +151,98 @@ export interface ClientDetectionStatus {
   url?: string;
 }
 
+export function isExecutableInPath(name: string): boolean {
+  const envPath = process.env.PATH || "";
+  const dirs = envPath.split(path.delimiter).filter(Boolean);
+  const extensions = process.platform === "win32"
+    ? (process.env.PATHEXT || ".COM;.EXE;.BAT;.CMD").split(";").map((e) => e.toLowerCase())
+    : [""];
+
+  for (const dir of dirs) {
+    for (const ext of extensions) {
+      const fullPath = path.join(dir, name + ext);
+      try {
+        if (fs.existsSync(fullPath) && !fs.statSync(fullPath).isDirectory()) {
+          return true;
+        }
+      } catch {}
+    }
+  }
+  return false;
+}
+
+export function isVscodeExtensionInstalled(pattern: RegExp): boolean {
+  const home = os.homedir();
+  const candidateDirs = [
+    path.join(home, ".vscode", "extensions"),
+    path.join(home, ".vscode-insiders", "extensions"),
+    path.join(home, ".cursor", "extensions"),
+    path.join(home, ".windsurf", "extensions"),
+  ];
+  for (const d of candidateDirs) {
+    if (fs.existsSync(d)) {
+      try {
+        const entries = fs.readdirSync(d);
+        if (entries.some((e) => pattern.test(e))) return true;
+      } catch {}
+    }
+  }
+  return false;
+}
+
+export function isZedInstalled(): boolean {
+  if (isExecutableInPath("zed")) return true;
+  if (process.platform === "win32") {
+    const local = process.env.LOCALAPPDATA || "";
+    if (fs.existsSync(path.join(local, "Programs", "Zed"))) return true;
+  } else if (process.platform === "darwin") {
+    if (fs.existsSync("/Applications/Zed.app")) return true;
+  }
+  return false;
+}
+
+export function isMatchingLocalHost(text: string, port = 7936): boolean {
+  if (!text) return false;
+  const configuredPort = config.server?.port || 7936;
+  const ports = new Set([String(port), String(configuredPort), "7936", "3000"]);
+  const isLocal = text.includes("127.0.0.1") || text.includes("localhost") || text.includes("0.0.0.0");
+  return isLocal && Array.from(ports).some((p) => text.includes(`:${p}`));
+}
+
+export function isClientToolInstalled(
+  id: SyncClientName,
+  targetPath: string,
+  isCustomTestPath = false,
+): boolean {
+  if (isCustomTestPath) {
+    return fs.existsSync(targetPath);
+  }
+  switch (id) {
+    case "hermes":
+      return isExecutableInPath("hermes");
+    case "openclaw":
+      return isExecutableInPath("openclaw") || isExecutableInPath("clawdbot") || isExecutableInPath("moltbot");
+    case "aider":
+      return isExecutableInPath("aider");
+    case "kilo":
+      return isExecutableInPath("kilo") || isVscodeExtensionInstalled(/kilo/i);
+    case "cline":
+      return isExecutableInPath("cline") || isVscodeExtensionInstalled(/cline|zoo-code|roo-cline/i);
+    case "zed":
+      return isZedInstalled();
+    case "claude-code":
+      return isExecutableInPath("claude") || fs.existsSync(targetPath);
+    case "codex":
+      return isExecutableInPath("codex") || fs.existsSync(targetPath);
+    case "opencode":
+      return isExecutableInPath("opencode") || fs.existsSync(targetPath);
+    case "omp":
+      return isExecutableInPath("omp") || fs.existsSync(targetPath);
+    default:
+      return fs.existsSync(targetPath);
+  }
+}
+
 /**
  * Inspects a client configuration file to determine whether the client is installed
  * and whether it is actively configured to route to QwenProxy.
@@ -161,37 +253,26 @@ export function inspectClientSyncStatus(
   port = 7936,
 ): ClientDetectionStatus {
   const defaultPaths = getDefaultPaths();
-  const targetPath =
-    filePath ||
-    (id === "claude-code"
-      ? defaultPaths.claudeCode
-      : id === "codex"
-        ? defaultPaths.codex
-        : id === "opencode"
-          ? defaultPaths.openCode
-          : id === "omp"
-            ? defaultPaths.omp
-            : id === "hermes"
-              ? defaultPaths.hermes
-              : id === "openclaw"
-                ? defaultPaths.openClaw
-                : id === "kilo"
-                  ? defaultPaths.kilo
-                  : id === "cline"
-                    ? defaultPaths.cline
-                    : id === "zed"
-                      ? defaultPaths.zed
-                      : defaultPaths.aider);
+  const defaultTarget = (defaultPaths as Record<string, string>)[id] || "";
+  const isCustomTestPath = Boolean(
+    filePath && defaultTarget && path.resolve(filePath) !== path.resolve(defaultTarget),
+  );
+  const targetPath = filePath || defaultTarget;
 
   if (!fs.existsSync(targetPath)) {
     return { id, installed: false, synced: false };
   }
 
+  const toolInstalled = isClientToolInstalled(id, targetPath, isCustomTestPath);
+  if (!toolInstalled) {
+    return { id, installed: false, synced: false };
+  }
+
   try {
     if (id === "cline") {
-      // Inspect SQLite DB
       let isSynced = false;
       let model: string | undefined;
+      let rowExists = false;
       try {
         const db = new Database(targetPath, { readonly: true });
         const row = db
@@ -201,18 +282,19 @@ export function inspectClientSyncStatus(
           .get() as { value: string } | undefined;
         db.close();
         if (row && row.value) {
+          rowExists = true;
           const parsed = JSON.parse(row.value);
           const url = parsed.openAiBaseUrl || "";
           model = parsed.openAiModelId;
-          isSynced = Boolean(
-            url &&
-              (url.includes(String(port)) ||
-                url.includes(`127.0.0.1:${port}`) ||
-                url.includes(`localhost:${port}`)),
-          );
+          isSynced = isMatchingLocalHost(url, port);
         }
       } catch {}
-      return { id, installed: true, synced: isSynced, model };
+
+      const isInstalled = isCustomTestPath
+        ? true
+        : rowExists || isExecutableInPath("cline") || isVscodeExtensionInstalled(/cline|zoo-code|roo-cline/i);
+
+      return { id, installed: isInstalled, synced: isInstalled && isSynced, model };
     }
 
     const raw = fs.readFileSync(targetPath, "utf-8");
@@ -221,12 +303,8 @@ export function inspectClientSyncStatus(
       const data = JSON.parse(raw);
       const url = data?.env?.ANTHROPIC_BASE_URL || "";
       const model = data?.env?.ANTHROPIC_MODEL || data?.model || "";
-      const isLocalHost =
-        url.includes(String(port)) ||
-        url.includes(`127.0.0.1:${port}`) ||
-        url.includes(`localhost:${port}`);
       const isSynced =
-        isLocalHost &&
+        isMatchingLocalHost(url, port) &&
         (model.toLowerCase().includes("qwen") || Boolean(data?.env?.ANTHROPIC_AUTH_TOKEN));
       return {
         id,
@@ -244,13 +322,11 @@ export function inspectClientSyncStatus(
       const model = modelMatch ? modelMatch[1] : undefined;
       const urlMatch = raw.match(/\[model_providers\.qwenproxy\][\s\S]*?base_url\s*=\s*["']([^"']+)["']/);
       const url = urlMatch ? urlMatch[1] : "";
-      const isLocalHost = Boolean(
-        url && (url.includes(String(port)) || url.includes(`127.0.0.1:${port}`) || url.includes(`localhost:${port}`)),
-      );
+      const isSynced = hasProvider && isProviderActive && isMatchingLocalHost(url, port);
       return {
         id,
         installed: true,
-        synced: hasProvider && isProviderActive && isLocalHost,
+        synced: isSynced,
         model,
       };
     }
@@ -261,20 +337,13 @@ export function inspectClientSyncStatus(
         const data = JSON.parse(raw);
         const provider = data?.provider?.qwenproxy;
         const url = provider?.options?.baseURL || "";
-        const isLocalHost =
-          url.includes(String(port)) ||
-          url.includes(`127.0.0.1:${port}`) ||
-          url.includes(`localhost:${port}`);
-        isSynced = Boolean(provider && isLocalHost);
+        const isSynced = Boolean(provider && isMatchingLocalHost(url, port));
+        return { id, installed: true, synced: isSynced };
       } catch {
         const qwenBlockMatch = raw.match(/"qwenproxy"\s*:\s*\{[\s\S]*?"baseURL"\s*:\s*"([^"]+)"/);
         const url = qwenBlockMatch ? qwenBlockMatch[1] : "";
-        isSynced = Boolean(
-          url &&
-            (url.includes(String(port)) ||
-              url.includes(`127.0.0.1:${port}`) ||
-              url.includes(`localhost:${port}`)),
-        );
+        const isSynced = Boolean(url && isMatchingLocalHost(url, port));
+        return { id, installed: true, synced: isSynced };
       }
       return {
         id,
@@ -290,12 +359,7 @@ export function inspectClientSyncStatus(
       if (ompMatch) {
         const urlMatch = ompMatch[1].match(/baseUrl:\s*(\S+)/);
         url = urlMatch ? urlMatch[1].replace(/['"]/g, "") : undefined;
-        isSynced = Boolean(
-          url &&
-            (url.includes(String(port)) ||
-              url.includes(`127.0.0.1:${port}`) ||
-              url.includes(`localhost:${port}`)),
-        );
+        isSynced = Boolean(url && isMatchingLocalHost(url, port));
       }
       return {
         id,
@@ -306,47 +370,27 @@ export function inspectClientSyncStatus(
     }
 
     if (id === "hermes") {
-      const isLocalHost =
-        raw.includes(String(port)) ||
-        raw.includes(`127.0.0.1:${port}`) ||
-        raw.includes(`localhost:${port}`);
-      const isSynced = isLocalHost && (raw.includes("qwenproxy") || raw.includes("qwen"));
+      const isSynced = isMatchingLocalHost(raw, port) && (raw.includes("qwenproxy") || raw.includes("qwen"));
       return { id, installed: true, synced: isSynced };
     }
 
     if (id === "openclaw") {
-      const isLocalHost =
-        raw.includes(String(port)) ||
-        raw.includes(`127.0.0.1:${port}`) ||
-        raw.includes(`localhost:${port}`);
-      const isSynced = isLocalHost && raw.includes("qwenproxy");
+      const isSynced = isMatchingLocalHost(raw, port) && raw.includes("qwenproxy");
       return { id, installed: true, synced: isSynced };
     }
 
     if (id === "kilo") {
-      const isLocalHost =
-        raw.includes(String(port)) ||
-        raw.includes(`127.0.0.1:${port}`) ||
-        raw.includes(`localhost:${port}`);
-      const isSynced = isLocalHost && raw.includes("qwenproxy");
+      const isSynced = isMatchingLocalHost(raw, port) && raw.includes("qwenproxy");
       return { id, installed: true, synced: isSynced };
     }
 
     if (id === "zed") {
-      const isLocalHost =
-        raw.includes(String(port)) ||
-        raw.includes(`127.0.0.1:${port}`) ||
-        raw.includes(`localhost:${port}`);
-      const isSynced = isLocalHost && raw.includes("QwenProxy");
+      const isSynced = isMatchingLocalHost(raw, port) && raw.includes("QwenProxy");
       return { id, installed: true, synced: isSynced };
     }
 
     if (id === "aider") {
-      const isLocalHost =
-        raw.includes(String(port)) ||
-        raw.includes(`127.0.0.1:${port}`) ||
-        raw.includes(`localhost:${port}`);
-      const isSynced = isLocalHost && raw.includes("qwen");
+      const isSynced = isMatchingLocalHost(raw, port) && raw.includes("qwen");
       return { id, installed: true, synced: isSynced };
     }
   } catch {