ccjk 2.3.1 → 2.4.1

package/dist/chunks/platform.mjs

@@ -1,4 +1,4 @@
-import * as nodeFs from 'node:fs';
+import * as fs from 'node:fs';
 import { homedir, platform } from 'node:os';
 import process__default from 'node:process';
 import { dirname } from 'pathe';
@@ -14,7 +14,7 @@ function getPlatform() {
   return "linux";
 }
 function isTermux() {
-  return !!(process__default.env.PREFIX && process__default.env.PREFIX.includes("com.termux")) || !!process__default.env.TERMUX_VERSION || nodeFs.existsSync("/data/data/com.termux/files/usr");
+  return !!(process__default.env.PREFIX && process__default.env.PREFIX.includes("com.termux")) || !!process__default.env.TERMUX_VERSION || fs.existsSync("/data/data/com.termux/files/usr");
 }
 function getTermuxPrefix() {
   return process__default.env.PREFIX || "/data/data/com.termux/files/usr";
@@ -26,16 +26,16 @@ function isWSL() {
   if (process__default.env.WSL_DISTRO_NAME) {
     return true;
   }
-  if (nodeFs.existsSync("/proc/version")) {
+  if (fs.existsSync("/proc/version")) {
     try {
-      const version = nodeFs.readFileSync("/proc/version", "utf8");
+      const version = fs.readFileSync("/proc/version", "utf8");
       if (version.includes("Microsoft") || version.includes("WSL")) {
         return true;
       }
     } catch {
     }
   }
-  if (nodeFs.existsSync("/mnt/c")) {
+  if (fs.existsSync("/mnt/c")) {
     return true;
   }
   return false;
@@ -44,9 +44,9 @@ function getWSLDistro() {
   if (process__default.env.WSL_DISTRO_NAME) {
     return process__default.env.WSL_DISTRO_NAME;
   }
-  if (nodeFs.existsSync("/etc/os-release")) {
+  if (fs.existsSync("/etc/os-release")) {
     try {
-      const osRelease = nodeFs.readFileSync("/etc/os-release", "utf8");
+      const osRelease = fs.readFileSync("/etc/os-release", "utf8");
       const nameMatch = osRelease.match(/^PRETTY_NAME="(.+)"$/m);
       if (nameMatch) {
         return nameMatch[1];
@@ -61,9 +61,9 @@ function getWSLInfo() {
     return null;
   }
   let version = null;
-  if (nodeFs.existsSync("/proc/version")) {
+  if (fs.existsSync("/proc/version")) {
     try {
-      version = nodeFs.readFileSync("/proc/version", "utf8").trim();
+      version = fs.readFileSync("/proc/version", "utf8").trim();
     } catch {
     }
   }
@@ -140,7 +140,7 @@ function isPathInsideHome(path) {
 }
 function canWriteToPath(path) {
   try {
-    nodeFs.accessSync(path, WRITE_CHECK_FLAG);
+    fs.accessSync(path, WRITE_CHECK_FLAG);
     return true;
   } catch {
     return false;
@@ -175,7 +175,7 @@ async function commandExists(command) {
       `/data/data/com.termux/files/usr/bin/${command}`
     ];
     for (const path of possiblePaths) {
-      if (nodeFs.existsSync(path)) {
+      if (fs.existsSync(path)) {
         return true;
       }
     }
@@ -189,14 +189,14 @@ async function commandExists(command) {
       `${home}/.local/bin/${command}`
     ];
     for (const path of commonPaths) {
-      if (nodeFs.existsSync(path)) {
+      if (fs.existsSync(path)) {
         return true;
       }
     }
     if (getPlatform() === "macos") {
       const homebrewPaths = await getHomebrewCommandPaths(command);
       for (const path of homebrewPaths) {
-        if (nodeFs.existsSync(path)) {
+        if (fs.existsSync(path)) {
           return true;
         }
       }
@@ -217,9 +217,9 @@ async function getHomebrewCommandPaths(command) {
   }
   for (const prefix of homebrewPrefixes) {
     const cellarNodePath = `${prefix}/Cellar/node`;
-    if (nodeFs.existsSync(cellarNodePath)) {
+    if (fs.existsSync(cellarNodePath)) {
       try {
-        const versions = nodeFs.readdirSync(cellarNodePath);
+        const versions = fs.readdirSync(cellarNodePath);
         for (const version of versions) {
           const binPath = `${cellarNodePath}/${version}/bin/${command}`;
           paths.push(binPath);
@@ -236,9 +236,9 @@ async function getHomebrewCommandPaths(command) {
   if (caskName) {
     for (const prefix of homebrewPrefixes) {
       const caskroomPath = `${prefix}/Caskroom/${caskName}`;
-      if (nodeFs.existsSync(caskroomPath)) {
+      if (fs.existsSync(caskroomPath)) {
         try {
-          const versions = nodeFs.readdirSync(caskroomPath).filter((v) => !v.startsWith("."));
+          const versions = fs.readdirSync(caskroomPath).filter((v) => !v.startsWith("."));
           for (const version of versions) {
             const binPath = `${caskroomPath}/${version}/${command}`;
             paths.push(binPath);
@@ -267,14 +267,14 @@ async function findCommandPath(command) {
     `${home}/.local/bin/${command}`
   ];
   for (const path of commonPaths) {
-    if (nodeFs.existsSync(path)) {
+    if (fs.existsSync(path)) {
       return path;
     }
   }
   if (getPlatform() === "macos") {
     const homebrewPaths = await getHomebrewCommandPaths(command);
     for (const path of homebrewPaths) {
-      if (nodeFs.existsSync(path)) {
+      if (fs.existsSync(path)) {
         return path;
       }
     }
@@ -286,7 +286,56 @@ async function findCommandPath(command) {
       `${termuxPrefix}/usr/bin/${command}`
     ];
     for (const path of termuxPaths) {
-      if (nodeFs.existsSync(path)) {
+      if (fs.existsSync(path)) {
+        return path;
+      }
+    }
+  }
+  return null;
+}
+async function findRealCommandPath(command) {
+  const platform2 = getPlatform();
+  if (platform2 !== "windows") {
+    try {
+      const res = await exec("bash", ["-c", `type -P ${command}`]);
+      if (res.exitCode === 0 && res.stdout) {
+        const path = res.stdout.trim();
+        if (path && fs.existsSync(path)) {
+          return path;
+        }
+      }
+    } catch {
+    }
+  }
+  const home = homedir();
+  const commonPaths = [
+    `/usr/local/bin/${command}`,
+    `/opt/homebrew/bin/${command}`,
+    `/usr/bin/${command}`,
+    `/bin/${command}`,
+    `${home}/.local/bin/${command}`
+  ];
+  for (const path of commonPaths) {
+    if (fs.existsSync(path)) {
+      return path;
+    }
+  }
+  if (platform2 === "macos") {
+    const homebrewPaths = await getHomebrewCommandPaths(command);
+    for (const path of homebrewPaths) {
+      if (fs.existsSync(path)) {
+        return path;
+      }
+    }
+  }
+  if (isTermux()) {
+    const termuxPrefix = getTermuxPrefix();
+    const termuxPaths = [
+      `${termuxPrefix}/bin/${command}`,
+      `${termuxPrefix}/usr/bin/${command}`
+    ];
+    for (const path of termuxPaths) {
+      if (fs.existsSync(path)) {
         return path;
       }
     }
@@ -318,4 +367,4 @@ function getRecommendedInstallMethods(codeType) {
   return ["npm"];
 }
 
-export { commandExists, findCommandPath, getHomebrewCommandPaths, getMcpCommand, getPlatform, getRecommendedInstallMethods, getSystemRoot, getTermuxPrefix, getWSLDistro, getWSLInfo, isTermux, isWSL, isWindows, normalizeTomlPath, shouldUseSudoForGlobalInstall, wrapCommandWithSudo };
+export { commandExists, findCommandPath, findRealCommandPath, getHomebrewCommandPaths, getMcpCommand, getPlatform, getRecommendedInstallMethods, getSystemRoot, getTermuxPrefix, getWSLDistro, getWSLInfo, isTermux, isWSL, isWindows, normalizeTomlPath, shouldUseSudoForGlobalInstall, wrapCommandWithSudo };

package/dist/chunks/silent-updater.mjs

@@ -0,0 +1,396 @@
+import { existsSync, readFileSync, writeFileSync, appendFileSync, unlinkSync, mkdirSync } from 'node:fs';
+import { platform } from 'node:os';
+import process__default from 'node:process';
+import { join } from 'pathe';
+import { CCJK_CONFIG_DIR } from './constants.mjs';
+import { getCloudState, updateCloudState } from './auto-bootstrap.mjs';
+import './index2.mjs';
+import 'node:url';
+import 'i18next';
+import 'i18next-fs-backend';
+import 'node:crypto';
+
+const UPGRADE_LOG_DIR = join(CCJK_CONFIG_DIR, "cloud", "logs");
+const UPGRADE_LOG_FILE = join(UPGRADE_LOG_DIR, "upgrades.log");
+const UPGRADE_LOCK_FILE = join(CCJK_CONFIG_DIR, "cloud", ".upgrade.lock");
+const UPGRADE_CHECK_INTERVAL = 6 * 60 * 60 * 1e3;
+const UPGRADE_TIMEOUT = 5 * 60 * 1e3;
+async function checkAllToolVersions() {
+  const results = [];
+  const [ccjk, claudeCode, ccr] = await Promise.all([
+    checkCcjkVersion(),
+    checkClaudeCodeVersion(),
+    checkCcrVersion()
+  ]);
+  results.push(ccjk, claudeCode, ccr);
+  return results;
+}
+async function checkCcjkVersion() {
+  try {
+    const currentVersion = getCurrentCcjkVersion();
+    const latestVersion = await fetchLatestNpmVersion("ccjk");
+    return {
+      tool: "ccjk",
+      installed: true,
+      currentVersion,
+      latestVersion,
+      needsUpdate: latestVersion ? isNewerVersion(latestVersion, currentVersion) : false,
+      installMethod: "npm"
+    };
+  } catch {
+    return {
+      tool: "ccjk",
+      installed: true,
+      currentVersion: getCurrentCcjkVersion(),
+      latestVersion: null,
+      needsUpdate: false,
+      installMethod: "npm"
+    };
+  }
+}
+async function checkClaudeCodeVersion() {
+  try {
+    const { exec } = await import('tinyexec');
+    const result = await exec("claude", ["--version"], { timeout: 5e3 });
+    if (result.exitCode !== 0) {
+      return {
+        tool: "claude-code",
+        installed: false,
+        currentVersion: null,
+        latestVersion: null,
+        needsUpdate: false,
+        installMethod: "unknown"
+      };
+    }
+    const currentVersion = result.stdout.trim().replace(/^v/, "");
+    const latestVersion = await fetchLatestNpmVersion("@anthropic-ai/claude-code");
+    const installMethod = await detectClaudeCodeInstallMethod();
+    return {
+      tool: "claude-code",
+      installed: true,
+      currentVersion,
+      latestVersion,
+      needsUpdate: latestVersion ? isNewerVersion(latestVersion, currentVersion) : false,
+      installMethod
+    };
+  } catch {
+    return {
+      tool: "claude-code",
+      installed: false,
+      currentVersion: null,
+      latestVersion: null,
+      needsUpdate: false,
+      installMethod: "unknown"
+    };
+  }
+}
+async function checkCcrVersion() {
+  try {
+    const { exec } = await import('tinyexec');
+    const result = await exec("ccr", ["--version"], { timeout: 5e3 });
+    if (result.exitCode !== 0) {
+      return {
+        tool: "ccr",
+        installed: false,
+        currentVersion: null,
+        latestVersion: null,
+        needsUpdate: false,
+        installMethod: "unknown"
+      };
+    }
+    const currentVersion = result.stdout.trim().replace(/^v/, "");
+    const latestVersion = await fetchLatestNpmVersion("@musistudio/claude-code-router");
+    return {
+      tool: "ccr",
+      installed: true,
+      currentVersion,
+      latestVersion,
+      needsUpdate: latestVersion ? isNewerVersion(latestVersion, currentVersion) : false,
+      installMethod: "npm"
+    };
+  } catch {
+    return {
+      tool: "ccr",
+      installed: false,
+      currentVersion: null,
+      latestVersion: null,
+      needsUpdate: false,
+      installMethod: "unknown"
+    };
+  }
+}
+function getCurrentCcjkVersion() {
+  try {
+    const packagePath = join(__dirname, "../../../package.json");
+    if (existsSync(packagePath)) {
+      const pkg = JSON.parse(readFileSync(packagePath, "utf-8"));
+      return pkg.version || "unknown";
+    }
+  } catch {
+  }
+  return "unknown";
+}
+async function fetchLatestNpmVersion(packageName) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 1e4);
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+      signal: controller.signal
+    });
+    if (response.ok) {
+      const data = await response.json();
+      return data.version;
+    }
+  } catch {
+  } finally {
+    clearTimeout(timeoutId);
+  }
+  return null;
+}
+async function detectClaudeCodeInstallMethod() {
+  try {
+    const { exec } = await import('tinyexec');
+    if (platform() === "darwin") {
+      const brewResult = await exec("brew", ["list", "--cask", "claude-code"], { timeout: 5e3 });
+      if (brewResult.exitCode === 0) {
+        return "homebrew";
+      }
+    }
+    const npmResult = await exec("npm", ["list", "-g", "@anthropic-ai/claude-code"], { timeout: 5e3 });
+    if (npmResult.exitCode === 0 && npmResult.stdout.includes("@anthropic-ai/claude-code")) {
+      return "npm";
+    }
+    return "curl";
+  } catch {
+    return "unknown";
+  }
+}
+function isNewerVersion(latest, current) {
+  if (!latest || !current || current === "unknown")
+    return false;
+  const latestParts = latest.split(".").map(Number);
+  const currentParts = current.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const l = latestParts[i] || 0;
+    const c = currentParts[i] || 0;
+    if (l > c)
+      return true;
+    if (l < c)
+      return false;
+  }
+  return false;
+}
+async function performSilentUpgradeAll() {
+  const startTime = Date.now();
+  const results = [];
+  if (isUpgradeLocked()) {
+    return {
+      success: false,
+      results: [],
+      totalDuration: 0,
+      upgradedCount: 0,
+      failedCount: 0
+    };
+  }
+  try {
+    createUpgradeLock();
+    const versions = await checkAllToolVersions();
+    const toolsToUpgrade = versions.filter((v) => v.needsUpdate && v.installed);
+    for (const tool of toolsToUpgrade) {
+      const result = await upgradeTool(tool);
+      results.push(result);
+      logUpgrade({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        tool: tool.tool,
+        fromVersion: tool.currentVersion || "unknown",
+        toVersion: tool.latestVersion || "unknown",
+        success: result.success,
+        error: result.error,
+        duration: result.duration
+      });
+    }
+    const totalDuration = Date.now() - startTime;
+    const upgradedCount = results.filter((r) => r.upgraded).length;
+    const failedCount = results.filter((r) => !r.success).length;
+    const state = getCloudState();
+    updateCloudState({
+      lastUpgradeCheckAt: (/* @__PURE__ */ new Date()).toISOString(),
+      upgradeStats: {
+        totalChecks: state.upgradeStats.totalChecks + 1,
+        upgradesApplied: state.upgradeStats.upgradesApplied + upgradedCount,
+        upgradesFailed: state.upgradeStats.upgradesFailed + failedCount
+      }
+    });
+    return {
+      success: failedCount === 0,
+      results,
+      totalDuration,
+      upgradedCount,
+      failedCount
+    };
+  } finally {
+    releaseUpgradeLock();
+  }
+}
+async function upgradeTool(info) {
+  const startTime = Date.now();
+  try {
+    switch (info.tool) {
+      case "ccjk":
+        return await upgradeCcjk(info, startTime);
+      case "claude-code":
+        return await upgradeClaudeCode(info, startTime);
+      case "ccr":
+        return await upgradeCcr(info, startTime);
+      default:
+        return {
+          tool: info.tool,
+          success: false,
+          upgraded: false,
+          error: "Unknown tool",
+          duration: Date.now() - startTime
+        };
+    }
+  } catch (error) {
+    return {
+      tool: info.tool,
+      success: false,
+      upgraded: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+      duration: Date.now() - startTime
+    };
+  }
+}
+async function upgradeCcjk(info, startTime) {
+  const { exec } = await import('tinyexec');
+  const result = await exec("npm", ["update", "-g", "ccjk"], {
+    timeout: UPGRADE_TIMEOUT
+  });
+  return {
+    tool: "ccjk",
+    success: result.exitCode === 0,
+    upgraded: result.exitCode === 0,
+    fromVersion: info.currentVersion || void 0,
+    toVersion: info.latestVersion || void 0,
+    error: result.exitCode !== 0 ? result.stderr : void 0,
+    duration: Date.now() - startTime
+  };
+}
+async function upgradeClaudeCode(info, startTime) {
+  const { exec } = await import('tinyexec');
+  let result;
+  switch (info.installMethod) {
+    case "homebrew":
+      result = await exec("brew", ["upgrade", "--cask", "claude-code"], {
+        timeout: UPGRADE_TIMEOUT
+      });
+      break;
+    case "npm":
+      result = await exec("npm", ["update", "-g", "@anthropic-ai/claude-code"], {
+        timeout: UPGRADE_TIMEOUT
+      });
+      break;
+    case "curl":
+    default:
+      result = await exec("claude", ["update"], {
+        timeout: UPGRADE_TIMEOUT
+      });
+      break;
+  }
+  return {
+    tool: "claude-code",
+    success: result.exitCode === 0,
+    upgraded: result.exitCode === 0,
+    fromVersion: info.currentVersion || void 0,
+    toVersion: info.latestVersion || void 0,
+    error: result.exitCode !== 0 ? result.stderr : void 0,
+    duration: Date.now() - startTime
+  };
+}
+async function upgradeCcr(info, startTime) {
+  const { exec } = await import('tinyexec');
+  const result = await exec("npm", ["update", "-g", "@musistudio/claude-code-router"], {
+    timeout: UPGRADE_TIMEOUT
+  });
+  return {
+    tool: "ccr",
+    success: result.exitCode === 0,
+    upgraded: result.exitCode === 0,
+    fromVersion: info.currentVersion || void 0,
+    toVersion: info.latestVersion || void 0,
+    error: result.exitCode !== 0 ? result.stderr : void 0,
+    duration: Date.now() - startTime
+  };
+}
+function isUpgradeLocked() {
+  if (!existsSync(UPGRADE_LOCK_FILE)) {
+    return false;
+  }
+  try {
+    const lockData = JSON.parse(readFileSync(UPGRADE_LOCK_FILE, "utf-8"));
+    const lockTime = new Date(lockData.timestamp).getTime();
+    const now = Date.now();
+    if (now - lockTime > 10 * 60 * 1e3) {
+      releaseUpgradeLock();
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createUpgradeLock() {
+  ensureLogDir();
+  writeFileSync(UPGRADE_LOCK_FILE, JSON.stringify({
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    pid: process__default.pid
+  }));
+}
+function releaseUpgradeLock() {
+  try {
+    if (existsSync(UPGRADE_LOCK_FILE)) {
+      unlinkSync(UPGRADE_LOCK_FILE);
+    }
+  } catch {
+  }
+}
+function ensureLogDir() {
+  if (!existsSync(UPGRADE_LOG_DIR)) {
+    mkdirSync(UPGRADE_LOG_DIR, { recursive: true });
+  }
+}
+function logUpgrade(entry) {
+  ensureLogDir();
+  const logLine = [
+    entry.timestamp,
+    entry.tool,
+    entry.fromVersion,
+    "->",
+    entry.toVersion,
+    entry.success ? "SUCCESS" : "FAILED",
+    entry.error || "",
+    `${entry.duration}ms`
+  ].join(" | ");
+  appendFileSync(UPGRADE_LOG_FILE, `${logLine}
+`);
+}
+function shouldCheckForUpgrades() {
+  const state = getCloudState();
+  if (!state.silentUpgradeEnabled) {
+    return false;
+  }
+  if (!state.lastUpgradeCheckAt) {
+    return true;
+  }
+  const lastCheck = new Date(state.lastUpgradeCheckAt).getTime();
+  const now = Date.now();
+  return now - lastCheck >= UPGRADE_CHECK_INTERVAL;
+}
+async function checkAndUpgradeIfNeeded() {
+  if (!shouldCheckForUpgrades()) {
+    return null;
+  }
+  return performSilentUpgradeAll();
+}
+
+export { UPGRADE_CHECK_INTERVAL, UPGRADE_LOCK_FILE, UPGRADE_LOG_DIR, UPGRADE_LOG_FILE, UPGRADE_TIMEOUT, checkAndUpgradeIfNeeded as autoUpgrade, checkAllToolVersions, checkAndUpgradeIfNeeded, checkAllToolVersions as checkVersions, performSilentUpgradeAll, shouldCheckForUpgrades, performSilentUpgradeAll as upgradeAll };

package/dist/chunks/skills-sync.mjs

@@ -121,7 +121,7 @@ function extractMetadata(data, filePath) {
   return metadata;
 }
 
-const CLOUD_API_BASE_URL = process__default.env.CCJK_CLOUD_API_URL || "https://api.ccjk.dev/v1";
+const CLOUD_API_BASE_URL = process__default.env.CCJK_CLOUD_API_URL || "https://api.api.claudehome.cn/v1";
 const SYNC_STATE_FILE = join(CCJK_CONFIG_DIR, "skills-sync-state.json");
 const DEFAULT_TIMEOUT = 3e4;
 function loadSyncState() {