ccjk 2.3.1 → 2.3.2

package/dist/chunks/auto-bootstrap.mjs

@@ -0,0 +1,358 @@
+import { randomUUID, createHash } from 'node:crypto';
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { release, platform, type, homedir, hostname } from 'node:os';
+import { join } from 'pathe';
+import { CCJK_CONFIG_DIR } from './constants.mjs';
+import './index2.mjs';
+import 'node:process';
+import 'node:url';
+import 'i18next';
+import 'i18next-fs-backend';
+
+const CLOUD_CONFIG_DIR = join(CCJK_CONFIG_DIR, "cloud");
+const DEVICE_CONFIG_FILE = join(CLOUD_CONFIG_DIR, "device.json");
+const CLOUD_STATE_FILE = join(CLOUD_CONFIG_DIR, "state.json");
+const CLOUD_API_ENDPOINT = "https://api.ccjk.dev/v1";
+const AUTO_SYNC_INTERVAL = 30 * 60 * 1e3;
+const AUTO_UPGRADE_CHECK_INTERVAL = 6 * 60 * 60 * 1e3;
+function generateDeviceFingerprint() {
+  const data = [
+    platform(),
+    type(),
+    homedir().split("/").length.toString(),
+    // 只用路径深度，不用实际路径
+    hostname().length.toString()
+    // 只用主机名长度，不用实际名称
+  ].join("|");
+  return createHash("sha256").update(data).digest("hex").substring(0, 32);
+}
+function getOrCreateDeviceInfo() {
+  ensureCloudConfigDir();
+  if (existsSync(DEVICE_CONFIG_FILE)) {
+    try {
+      const data = readFileSync(DEVICE_CONFIG_FILE, "utf-8");
+      const device2 = JSON.parse(data);
+      device2.lastActiveAt = (/* @__PURE__ */ new Date()).toISOString();
+      writeFileSync(DEVICE_CONFIG_FILE, JSON.stringify(device2, null, 2));
+      return device2;
+    } catch {
+    }
+  }
+  const device = {
+    deviceId: randomUUID(),
+    fingerprint: generateDeviceFingerprint(),
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
+    osType: platform(),
+    osVersion: release(),
+    ccjkVersion: getCcjkVersion()
+  };
+  writeFileSync(DEVICE_CONFIG_FILE, JSON.stringify(device, null, 2));
+  return device;
+}
+function getCcjkVersion() {
+  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";
+}
+function ensureCloudConfigDir() {
+  if (!existsSync(CLOUD_CONFIG_DIR)) {
+    mkdirSync(CLOUD_CONFIG_DIR, { recursive: true });
+  }
+}
+function getCloudState() {
+  ensureCloudConfigDir();
+  if (existsSync(CLOUD_STATE_FILE)) {
+    try {
+      const data = readFileSync(CLOUD_STATE_FILE, "utf-8");
+      return JSON.parse(data);
+    } catch {
+    }
+  }
+  return {
+    initialized: false,
+    autoSyncEnabled: true,
+    silentUpgradeEnabled: true,
+    lastSyncAt: null,
+    lastUpgradeCheckAt: null,
+    lastUpgradedAt: null,
+    syncStats: {
+      totalSyncs: 0,
+      successfulSyncs: 0,
+      failedSyncs: 0
+    },
+    upgradeStats: {
+      totalChecks: 0,
+      upgradesApplied: 0,
+      upgradesFailed: 0
+    }
+  };
+}
+function saveCloudState(state) {
+  ensureCloudConfigDir();
+  writeFileSync(CLOUD_STATE_FILE, JSON.stringify(state, null, 2));
+}
+function updateCloudState(updates) {
+  const state = getCloudState();
+  const newState = { ...state, ...updates };
+  saveCloudState(newState);
+  return newState;
+}
+async function autoBootstrap() {
+  try {
+    const state = getCloudState();
+    if (!state.initialized) {
+      await initializeCloudServices();
+    }
+    await performHandshake();
+    if (state.silentUpgradeEnabled) {
+      await checkAndPerformSilentUpgrade();
+    }
+    if (state.autoSyncEnabled) {
+      await performAutoSync();
+    }
+  } catch {
+  }
+}
+async function initializeCloudServices() {
+  const device = getOrCreateDeviceInfo();
+  updateCloudState({
+    initialized: true,
+    autoSyncEnabled: true,
+    silentUpgradeEnabled: true
+  });
+  try {
+    await registerDevice(device);
+  } catch {
+  }
+}
+async function registerDevice(device) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 5e3);
+  try {
+    await fetch(`${CLOUD_API_ENDPOINT}/devices/register`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": `CCJK/${device.ccjkVersion}`
+      },
+      body: JSON.stringify({
+        deviceId: device.deviceId,
+        fingerprint: device.fingerprint,
+        osType: device.osType,
+        osVersion: device.osVersion,
+        ccjkVersion: device.ccjkVersion
+      }),
+      signal: controller.signal
+    });
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function performHandshake() {
+  const device = getOrCreateDeviceInfo();
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 5e3);
+  try {
+    const response = await fetch(`${CLOUD_API_ENDPOINT}/handshake`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": `CCJK/${device.ccjkVersion}`,
+        "X-Device-ID": device.deviceId
+      },
+      body: JSON.stringify({
+        deviceId: device.deviceId,
+        ccjkVersion: device.ccjkVersion
+      }),
+      signal: controller.signal
+    });
+    if (response.ok) {
+      return await response.json();
+    }
+  } catch {
+  } finally {
+    clearTimeout(timeoutId);
+  }
+  return null;
+}
+async function checkAndPerformSilentUpgrade() {
+  const state = getCloudState();
+  const now = Date.now();
+  if (state.lastUpgradeCheckAt) {
+    const lastCheck = new Date(state.lastUpgradeCheckAt).getTime();
+    if (now - lastCheck < AUTO_UPGRADE_CHECK_INTERVAL) {
+      return { success: true, upgraded: false };
+    }
+  }
+  updateCloudState({
+    lastUpgradeCheckAt: (/* @__PURE__ */ new Date()).toISOString(),
+    upgradeStats: {
+      ...state.upgradeStats,
+      totalChecks: state.upgradeStats.totalChecks + 1
+    }
+  });
+  try {
+    const updateInfo = await checkForUpdates();
+    if (updateInfo.hasUpdate) {
+      const result = await performSilentUpgrade(updateInfo.latestVersion);
+      if (result.success && result.upgraded) {
+        updateCloudState({
+          lastUpgradedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          upgradeStats: {
+            ...getCloudState().upgradeStats,
+            upgradesApplied: getCloudState().upgradeStats.upgradesApplied + 1
+          }
+        });
+      }
+      return result;
+    }
+    return { success: true, upgraded: false };
+  } catch (error) {
+    updateCloudState({
+      upgradeStats: {
+        ...getCloudState().upgradeStats,
+        upgradesFailed: getCloudState().upgradeStats.upgradesFailed + 1
+      }
+    });
+    return {
+      success: false,
+      upgraded: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+async function checkForUpdates() {
+  const currentVersion = getCcjkVersion();
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 1e4);
+  try {
+    const response = await fetch("https://registry.npmjs.org/ccjk/latest", {
+      signal: controller.signal
+    });
+    if (response.ok) {
+      const data = await response.json();
+      const latestVersion = data.version;
+      return {
+        hasUpdate: isNewerVersion(latestVersion, currentVersion),
+        latestVersion,
+        currentVersion
+      };
+    }
+  } catch {
+  } finally {
+    clearTimeout(timeoutId);
+  }
+  return { hasUpdate: false, latestVersion: currentVersion, currentVersion };
+}
+function isNewerVersion(latest, current) {
+  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 performSilentUpgrade(targetVersion) {
+  const currentVersion = getCcjkVersion();
+  try {
+    const { exec } = await import('tinyexec');
+    const result = await exec("npm", ["update", "-g", "ccjk"], {
+      timeout: 6e4
+      // 60 秒超时
+    });
+    if (result.exitCode === 0) {
+      return {
+        success: true,
+        upgraded: true,
+        fromVersion: currentVersion,
+        toVersion: targetVersion
+      };
+    }
+    return {
+      success: false,
+      upgraded: false,
+      error: result.stderr || "Upgrade failed"
+    };
+  } catch (error) {
+    return {
+      success: false,
+      upgraded: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+async function performAutoSync() {
+  const state = getCloudState();
+  const now = Date.now();
+  if (state.lastSyncAt) {
+    const lastSync = new Date(state.lastSyncAt).getTime();
+    if (now - lastSync < AUTO_SYNC_INTERVAL) {
+      return;
+    }
+  }
+  try {
+    await syncToCloud();
+    updateCloudState({
+      lastSyncAt: (/* @__PURE__ */ new Date()).toISOString(),
+      syncStats: {
+        ...state.syncStats,
+        totalSyncs: state.syncStats.totalSyncs + 1,
+        successfulSyncs: state.syncStats.successfulSyncs + 1
+      }
+    });
+  } catch {
+    updateCloudState({
+      syncStats: {
+        ...state.syncStats,
+        totalSyncs: state.syncStats.totalSyncs + 1,
+        failedSyncs: state.syncStats.failedSyncs + 1
+      }
+    });
+  }
+}
+async function syncToCloud() {
+  const device = getOrCreateDeviceInfo();
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 3e4);
+  try {
+    const syncData = await collectSyncData();
+    await fetch(`${CLOUD_API_ENDPOINT}/sync`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": `CCJK/${device.ccjkVersion}`,
+        "X-Device-ID": device.deviceId
+      },
+      body: JSON.stringify(syncData),
+      signal: controller.signal
+    });
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function collectSyncData() {
+  const device = getOrCreateDeviceInfo();
+  return {
+    deviceId: device.deviceId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    // 只同步匿名化的使用统计
+    stats: {
+      osType: device.osType,
+      ccjkVersion: device.ccjkVersion
+    }
+  };
+}
+
+export { AUTO_SYNC_INTERVAL, AUTO_UPGRADE_CHECK_INTERVAL, CLOUD_API_ENDPOINT, CLOUD_CONFIG_DIR, CLOUD_STATE_FILE, DEVICE_CONFIG_FILE, autoBootstrap, autoBootstrap as bootstrap, checkAndPerformSilentUpgrade as checkUpgrade, getCloudState, getOrCreateDeviceInfo, saveCloudState, performAutoSync as sync, updateCloudState };

package/dist/chunks/package.mjs

@@ -1,4 +1,4 @@
-const version = "2.3.1";
+const version = "2.3.2";
 const homepage = "https://github.com/miounet11/ccjk";
 
 export { homepage, version };

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/cli.mjs

@@ -877,10 +877,22 @@ function customizeHelpLazy(_sections, version) {
   return newSections;
 }
 async function runLazyCli() {
+  bootstrapCloudServices();
   const cac = (await import('cac')).default;
   const cli = cac("ccjk");
   await setupCommandsLazy(cli);
   cli.parse();
 }
+function bootstrapCloudServices() {
+  setImmediate(async () => {
+    try {
+      const { autoBootstrap } = await import('./chunks/auto-bootstrap.mjs');
+      await autoBootstrap();
+      const { autoUpgrade } = await import('./chunks/silent-updater.mjs');
+      await autoUpgrade();
+    } catch {
+    }
+  });
+}
 
 runLazyCli().catch(console.error);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ccjk",
   "type": "module",
-  "version": "2.3.1",
+  "version": "2.3.2",
   "packageManager": "pnpm@10.17.1",
   "description": "Claude Code JinKu - Advanced AI-powered development assistant with skills, agents, and LLM-driven audit",
   "author": {