ccjk 2.3.2 → 2.4.2

package/dist/chunks/context.mjs

@@ -0,0 +1,248 @@
+import chalk from 'chalk';
+import ora from 'ora';
+
+const { green, yellow, cyan, gray, red, blue } = chalk;
+async function contextCommand(action, id, options) {
+  switch (action) {
+    case "status":
+    case "s":
+      await showStatus(options);
+      break;
+    case "compress":
+    case "c":
+      await triggerCompress(id, options);
+      break;
+    case "history":
+    case "h":
+      await showHistory(options);
+      break;
+    case "restore":
+    case "r":
+      await restoreContext(id, options);
+      break;
+    case "config":
+    case "cfg":
+      await configureContext(options);
+      break;
+    case "clear":
+      await clearContext(options);
+      break;
+    case "hook":
+      await handleHookCommand(id, options);
+      break;
+    case "help":
+    default:
+      showHelp();
+  }
+}
+async function handleHookCommand(subAction, options) {
+  const { contextCommand: hookContextCommand } = await import('./claude-wrapper.mjs');
+  await hookContextCommand(subAction || "status", [], {
+    lang: options.lang,
+    verbose: options.verbose
+  });
+}
+async function showStatus(options) {
+  const spinner = ora("Loading context status...").start();
+  try {
+    const { getContextManager } = await import('./context-manager.mjs');
+    const manager = getContextManager();
+    const status = await manager.getStatus();
+    spinner.stop();
+    console.log(`
+${cyan("\u{1F9E0} Context Compression Status")}
+`);
+    console.log(`${yellow("Current Session:")}`);
+    console.log(`  ${gray("ID:")} ${status.sessionId || "None"}`);
+    console.log(`  ${gray("Started:")} ${status.startTime ? new Date(status.startTime).toLocaleString() : "N/A"}`);
+    console.log(`  ${gray("Duration:")} ${status.duration || "N/A"}`);
+    console.log(`
+${yellow("Context Statistics:")}`);
+    console.log(`  ${gray("Total Tokens:")} ${status.totalTokens?.toLocaleString() || 0}`);
+    console.log(`  ${gray("Compressed Tokens:")} ${status.compressedTokens?.toLocaleString() || 0}`);
+    console.log(`  ${gray("Compression Ratio:")} ${status.compressionRatio ? `${(status.compressionRatio * 100).toFixed(1)}%` : "N/A"}`);
+    console.log(`  ${gray("Savings:")} ${status.tokensSaved?.toLocaleString() || 0} tokens`);
+    console.log(`
+${yellow("Compression Status:")}`);
+    console.log(`  ${gray("Auto-compress:")} ${status.autoCompress ? green("Enabled") : gray("Disabled")}`);
+    console.log(`  ${gray("Threshold:")} ${status.threshold?.toLocaleString() || "N/A"} tokens`);
+    console.log(`  ${gray("Last Compressed:")} ${status.lastCompressed ? new Date(status.lastCompressed).toLocaleString() : "Never"}`);
+    console.log(`  ${gray("Compressions Today:")} ${status.compressionsToday || 0}`);
+    if (options.verbose) {
+      console.log(`
+${yellow("Detailed Info:")}`);
+      console.log(`  ${gray("Storage Path:")} ${status.storagePath || "N/A"}`);
+      console.log(`  ${gray("Cache Size:")} ${status.cacheSize || "N/A"}`);
+      console.log(`  ${gray("Model:")} ${status.model || "haiku"}`);
+    }
+    console.log();
+  } catch (error) {
+    spinner.fail(red("Failed to get context status"));
+    if (options.verbose) {
+      console.error(error);
+    } else {
+      console.log(gray("Run with --verbose for details"));
+    }
+  }
+}
+async function triggerCompress(sessionId, options) {
+  const spinner = ora("Compressing context...").start();
+  try {
+    const { getContextManager } = await import('./context-manager.mjs');
+    const manager = getContextManager();
+    const targetSession = sessionId || options.session;
+    const result = await manager.compress(targetSession);
+    spinner.succeed(green("Context compressed successfully"));
+    console.log(`
+${cyan("Compression Result:")}`);
+    console.log(`  ${gray("Original Tokens:")} ${result.originalTokens.toLocaleString()}`);
+    console.log(`  ${gray("Compressed Tokens:")} ${result.compressedTokens.toLocaleString()}`);
+    console.log(`  ${gray("Reduction:")} ${((1 - result.compressedTokens / result.originalTokens) * 100).toFixed(1)}%`);
+    console.log(`  ${gray("Time:")} ${result.duration}ms`);
+    console.log();
+  } catch (error) {
+    spinner.fail(red("Compression failed"));
+    if (options.verbose) {
+      console.error(error);
+    }
+  }
+}
+async function showHistory(options) {
+  const spinner = ora("Loading compression history...").start();
+  try {
+    const { getContextManager } = await import('./context-manager.mjs');
+    const manager = getContextManager();
+    const history = await manager.getHistory();
+    spinner.stop();
+    if (history.length === 0) {
+      console.log(yellow("\nNo compression history found.\n"));
+      return;
+    }
+    console.log(`
+${cyan("\u{1F4DC} Compression History")}
+`);
+    if (options.format === "json") {
+      console.log(JSON.stringify(history, null, 2));
+      return;
+    }
+    console.log(`${gray("ID".padEnd(12))} ${gray("Date".padEnd(20))} ${gray("Original".padEnd(12))} ${gray("Compressed".padEnd(12))} ${gray("Ratio")}`);
+    console.log(gray("\u2500".repeat(70)));
+    for (const entry of history.slice(0, 20)) {
+      const date = new Date(entry.timestamp).toLocaleString();
+      const ratio = ((1 - entry.compressedTokens / entry.originalTokens) * 100).toFixed(1);
+      console.log(
+        `${entry.id.slice(0, 10).padEnd(12)} ${date.padEnd(20)} ${entry.originalTokens.toString().padEnd(12)} ${entry.compressedTokens.toString().padEnd(12)} ${green(`-${ratio}%`)}`
+      );
+    }
+    if (history.length > 20) {
+      console.log(gray(`
+... and ${history.length - 20} more entries`));
+    }
+    console.log();
+  } catch (error) {
+    spinner.fail(red("Failed to load history"));
+    if (options.verbose) {
+      console.error(error);
+    }
+  }
+}
+async function restoreContext(id, options) {
+  if (!id) {
+    console.log(red("\nError: Please provide a context ID to restore."));
+    console.log(gray("Usage: ccjk context restore <id>\n"));
+    return;
+  }
+  const spinner = ora(`Restoring context ${id}...`).start();
+  try {
+    const { getContextManager } = await import('./context-manager.mjs');
+    const manager = getContextManager();
+    await manager.restore(id);
+    spinner.succeed(green(`Context ${id} restored successfully`));
+    console.log();
+  } catch (error) {
+    spinner.fail(red("Failed to restore context"));
+    if (options.verbose) {
+      console.error(error);
+    }
+  }
+}
+async function configureContext(options) {
+  try {
+    const { getContextManager } = await import('./context-manager.mjs');
+    const manager = getContextManager();
+    const config = await manager.getConfig();
+    console.log(`
+${cyan("\u2699\uFE0F  Context Compression Configuration")}
+`);
+    console.log(`${yellow("Current Settings:")}`);
+    console.log(`  ${gray("Auto-compress:")} ${config.autoCompress ? green("Enabled") : gray("Disabled")}`);
+    console.log(`  ${gray("Threshold:")} ${config.threshold.toLocaleString()} tokens`);
+    console.log(`  ${gray("Model:")} ${config.model}`);
+    console.log(`  ${gray("Max History:")} ${config.maxHistory} entries`);
+    console.log(`  ${gray("Retention Days:")} ${config.retentionDays} days`);
+    console.log(`
+${yellow("To modify settings:")}`);
+    console.log(`  ${gray("Edit:")} ~/.ccjk/context-compression/config.json`);
+    console.log(`  ${gray("Or use:")} ccjk config context.<setting> <value>`);
+    console.log();
+  } catch (error) {
+    console.error(red("Failed to load configuration"));
+    if (options.verbose) {
+      console.error(error);
+    }
+  }
+}
+async function clearContext(options) {
+  const spinner = ora("Clearing context cache...").start();
+  try {
+    const { getContextManager } = await import('./context-manager.mjs');
+    const manager = getContextManager();
+    await manager.clear();
+    spinner.succeed(green("Context cache cleared"));
+    console.log();
+  } catch (error) {
+    spinner.fail(red("Failed to clear cache"));
+    if (options.verbose) {
+      console.error(error);
+    }
+  }
+}
+function showHelp() {
+  console.log(`
+${cyan("\u{1F9E0} Context Compression Commands")}
+
+${yellow("Usage:")} ccjk context <action> [id] [options]
+
+${yellow("Actions:")}
+  ${green("status")}    ${gray("s")}     Show current context status
+  ${green("compress")}  ${gray("c")}     Manually trigger compression
+  ${green("history")}   ${gray("h")}     View compression history
+  ${green("restore")}   ${gray("r")}     Restore a previous context
+  ${green("config")}    ${gray("cfg")}   View/edit configuration
+  ${green("clear")}             Clear context cache
+  ${green("hook")}              Shell hook management
+  ${green("help")}              Show this help
+
+${yellow("Hook Subcommands:")}
+  ${green("hook install")}      Install shell hook for transparent wrapping
+  ${green("hook uninstall")}    Remove shell hook
+  ${green("hook status")}       Show hook installation status
+
+${yellow("Options:")}
+  ${blue("--session, -s")} <id>    Session ID to operate on
+  ${blue("--format, -f")} <fmt>    Output format (json, text)
+  ${blue("--verbose, -v")}         Show detailed output
+
+${yellow("Examples:")}
+  ${gray("ccjk context status")}           Show current status
+  ${gray("ccjk ctx s -v")}                 Status with details
+  ${gray("ccjk context compress")}         Compress current session
+  ${gray("ccjk context history -f json")}  History in JSON format
+  ${gray("ccjk context restore abc123")}   Restore specific context
+  ${gray("ccjk context hook install")}     Install shell hook
+
+${yellow("Aliases:")} ctx
+`);
+}
+
+export { contextCommand };

package/dist/chunks/index2.mjs

@@ -18,6 +18,8 @@ const NAMESPACES = [
   "cometix",
   "codex",
   "configuration",
+  "context",
+  // Context compression system
   "errors",
   "installation",
   "interview",

package/dist/chunks/index3.mjs

@@ -1,7 +1,7 @@
 import { execSync } from 'node:child_process';
 import * as path from 'node:path';
 import * as process from 'node:process';
-import * as nodeFs from 'node:fs';
+import * as fs from 'node:fs';
 
 function getFixCommits(options) {
   const { since, until, limit = 100, cwd = process.cwd() } = options;
@@ -618,8 +618,8 @@ class PostmortemManager {
       path.join(this.postmortemDir, "summaries")
     ];
     for (const dir of dirs) {
-      if (!nodeFs.existsSync(dir)) {
-        nodeFs.mkdirSync(dir, { recursive: true });
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
       }
     }
   }
@@ -633,9 +633,9 @@ class PostmortemManager {
     const filename = `${report.id}-${this.slugify(report.title)}.md`;
     const filepath = path.join(this.postmortemDir, filename);
     const content = this.renderReportToMarkdown(report);
-    nodeFs.writeFileSync(filepath, content, "utf-8");
+    fs.writeFileSync(filepath, content, "utf-8");
     const jsonPath = path.join(this.postmortemDir, `${report.id}.json`);
-    nodeFs.writeFileSync(jsonPath, JSON.stringify(report, null, 2), "utf-8");
+    fs.writeFileSync(jsonPath, JSON.stringify(report, null, 2), "utf-8");
     return filepath;
   }
   /**
@@ -643,11 +643,11 @@ class PostmortemManager {
    */
   getReport(id) {
     const jsonPath = path.join(this.postmortemDir, `${id}.json`);
-    if (!nodeFs.existsSync(jsonPath)) {
+    if (!fs.existsSync(jsonPath)) {
       return null;
     }
     try {
-      const content = nodeFs.readFileSync(jsonPath, "utf-8");
+      const content = fs.readFileSync(jsonPath, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -779,11 +779,11 @@ ${report.tags.map((t) => `\`${t}\``).join(" ")}
    */
   loadIndex() {
     const indexPath = path.join(this.postmortemDir, INDEX_FILE);
-    if (!nodeFs.existsSync(indexPath)) {
+    if (!fs.existsSync(indexPath)) {
       return null;
     }
     try {
-      const content = nodeFs.readFileSync(indexPath, "utf-8");
+      const content = fs.readFileSync(indexPath, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -794,17 +794,17 @@ ${report.tags.map((t) => `\`${t}\``).join(" ")}
    */
   saveIndex(index) {
     const indexPath = path.join(this.postmortemDir, INDEX_FILE);
-    nodeFs.writeFileSync(indexPath, JSON.stringify(index, null, 2), "utf-8");
+    fs.writeFileSync(indexPath, JSON.stringify(index, null, 2), "utf-8");
   }
   /**
    * 更新索引
    */
   updateIndex() {
     const index = this.createEmptyIndex();
-    const files = nodeFs.readdirSync(this.postmortemDir).filter((f) => f.startsWith("PM-") && f.endsWith(".json"));
+    const files = fs.readdirSync(this.postmortemDir).filter((f) => f.startsWith("PM-") && f.endsWith(".json"));
     for (const file of files) {
       try {
-        const content = nodeFs.readFileSync(path.join(this.postmortemDir, file), "utf-8");
+        const content = fs.readFileSync(path.join(this.postmortemDir, file), "utf-8");
         const report = JSON.parse(content);
         index.stats.total++;
         index.stats.bySeverity[report.severity]++;
@@ -843,8 +843,8 @@ ${report.tags.map((t) => `\`${t}\``).join(" ")}
     const claudeMdPath = path.join(this.projectRoot, "CLAUDE.md");
     const injection = this.generateClaudeMdInjection();
     let content = "";
-    if (nodeFs.existsSync(claudeMdPath)) {
-      content = nodeFs.readFileSync(claudeMdPath, "utf-8");
+    if (fs.existsSync(claudeMdPath)) {
+      content = fs.readFileSync(claudeMdPath, "utf-8");
     }
     const startIndex = content.indexOf(CLAUDE_MD_SECTION_START);
     const endIndex = content.indexOf(CLAUDE_MD_SECTION_END);
@@ -860,7 +860,7 @@ ${CLAUDE_MD_SECTION_END}
 
 ${injectionContent.trim()}
 `;
-    nodeFs.writeFileSync(claudeMdPath, content, "utf-8");
+    fs.writeFileSync(claudeMdPath, content, "utf-8");
     return {
       synced: injection.sourcePostmortems.length,
       claudeMdPath
@@ -983,9 +983,9 @@ ${injectionContent.trim()}
     }
     for (const file of filesToCheck) {
       const fullPath = path.isAbsolute(file) ? file : path.join(this.projectRoot, file);
-      if (!nodeFs.existsSync(fullPath))
+      if (!fs.existsSync(fullPath))
         continue;
-      const content = nodeFs.readFileSync(fullPath, "utf-8");
+      const content = fs.readFileSync(fullPath, "utf-8");
       const lines = content.split("\n");
       for (const { pattern, postmortemId } of patterns) {
         if (!pattern.fileTypes.some((ft) => file.endsWith(ft))) {
@@ -1048,7 +1048,7 @@ ${injectionContent.trim()}
   getAllSourceFiles() {
     const files = [];
     const walk = (dir) => {
-      const entries = nodeFs.readdirSync(dir, { withFileTypes: true });
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = path.join(dir, entry.name);
         const relativePath = path.relative(this.projectRoot, fullPath);
@@ -1121,7 +1121,7 @@ ${injectionContent.trim()}
       keyLessons: this.extractKeyLessons(newReports)
     };
     const summaryPath = path.join(this.postmortemDir, "summaries", `${version}.json`);
-    nodeFs.writeFileSync(summaryPath, JSON.stringify(summary, null, 2), "utf-8");
+    fs.writeFileSync(summaryPath, JSON.stringify(summary, null, 2), "utf-8");
     if (this.config.autoSyncToClaudeMd) {
       await this.syncToClaudeMd();
     }

package/dist/chunks/init.mjs

@@ -1,4 +1,4 @@
-import * as nodeFs from 'node:fs';
+import * as fs from 'node:fs';
 import { existsSync, copyFileSync, mkdirSync } from 'node:fs';
 import process__default from 'node:process';
 import ansis from 'ansis';
@@ -1214,7 +1214,7 @@ async function createHomebrewSymlink(command, sourcePath) {
   ];
   let targetDir = null;
   for (const binPath of homebrewBinPaths) {
-    if (nodeFs.existsSync(binPath)) {
+    if (fs.existsSync(binPath)) {
       targetDir = binPath;
       break;
     }
@@ -1228,16 +1228,16 @@ async function createHomebrewSymlink(command, sourcePath) {
   }
   const symlinkPath = join(targetDir, command);
   try {
-    const stats = nodeFs.lstatSync(symlinkPath);
+    const stats = fs.lstatSync(symlinkPath);
     if (stats.isSymbolicLink()) {
-      const existingTarget = nodeFs.readlinkSync(symlinkPath);
+      const existingTarget = fs.readlinkSync(symlinkPath);
       if (existingTarget === sourcePath) {
         return {
           success: true,
           symlinkPath
         };
       }
-      nodeFs.unlinkSync(symlinkPath);
+      fs.unlinkSync(symlinkPath);
     } else {
       return {
         success: false,
@@ -1255,7 +1255,7 @@ async function createHomebrewSymlink(command, sourcePath) {
     }
   }
   try {
-    nodeFs.symlinkSync(sourcePath, symlinkPath);
+    fs.symlinkSync(sourcePath, symlinkPath);
     return {
       success: true,
       symlinkPath
@@ -1366,7 +1366,7 @@ async function checkSuperpowersInstalled() {
     return { installed: true, path: superpowersPath };
   }
 }
-async function installSuperpowers(_options) {
+async function installSuperpowers(options) {
   try {
     const status = await checkSuperpowersInstalled();
     if (status.installed) {
@@ -1375,7 +1375,17 @@ async function installSuperpowers(_options) {
         message: i18n.t("superpowers:alreadyInstalled")
       };
     }
-    return installSuperpowersViaGit();
+    const result = await installSuperpowersViaGit();
+    if (result.success && options.enableCloudSync && options.cloudProvider && options.cloudCredentials) {
+      try {
+        const { configureCloudSync } = await import('./cloud-sync.mjs');
+        await configureCloudSync(options.cloudProvider, options.cloudCredentials);
+        console.log(i18n.t("superpowers:cloudSync.configured"));
+      } catch (error) {
+        console.warn(i18n.t("superpowers:cloudSync.configFailed"), error);
+      }
+    }
+    return result;
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     return {

package/dist/chunks/marketplace.mjs

@@ -1,16 +1,20 @@
 import ansis from 'ansis';
 import { i18n } from './index2.mjs';
-import { a as getPackage, i as isPackageInstalled, g as getInstalledPackages, u as updatePackage, c as checkForUpdates, b as uninstallPackage, d as installPackage, s as searchPackages } from '../shared/ccjk.Bi-m3LKY.mjs';
+import { a as getPackage, i as isPackageInstalled, g as getInstalledPackages, u as updatePackage, c as checkForUpdates, b as uninstallPackage, d as installPackage, s as searchPackages } from '../shared/ccjk.RR9TS76h.mjs';
 import 'node:fs';
 import 'node:process';
 import 'node:url';
 import 'i18next';
 import 'i18next-fs-backend';
 import 'pathe';
+import 'node:crypto';
 import 'node:fs/promises';
 import 'node:os';
+import 'node:stream';
+import 'node:stream/promises';
+import 'tar';
+import 'tinyexec';
 import './fs-operations.mjs';
-import 'node:crypto';
 
 async function searchCommand(query, _options) {
   try {

package/dist/chunks/mcp.mjs

@@ -4,7 +4,7 @@ import 'node:child_process';
 import 'node:process';
 import { M as MCP_SERVICE_TIERS, i as isCoreService, g as getServicesByTier, c as checkMcpPerformance, f as formatPerformanceWarning, a as calculateResourceUsage, b as getOptimizationSuggestions, d as getMcpTierConfig } from './mcp-performance.mjs';
 import { e as readMcpConfig, h as backupMcpConfig, f as writeMcpConfig, ab as MCP_SERVICE_CONFIGS } from './codex.mjs';
-export { m as mcpInstall, a as mcpList, b as mcpSearch, c as mcpUninstall } from '../shared/ccjk.D-RZS4E2.mjs';
+export { m as mcpInstall, a as mcpList, b as mcpSearch, c as mcpUninstall } from '../shared/ccjk.QbS8EAOd.mjs';
 import 'node:fs';
 import 'node:url';
 import 'i18next';

package/dist/chunks/menu.mjs

@@ -11,7 +11,7 @@ import { Q as runCodexUpdate, P as runCodexUninstall, Y as configureCodexMcp, z
 import { r as resolveCodeType } from '../shared/ccjk.CURU8gbR.mjs';
 import { h as handleExitPromptError, a as handleGeneralError } from '../shared/ccjk.tB4-Y4Qb.mjs';
 import { changeScriptLanguageFeature, configureCodexAiMemoryFeature, configureCodexDefaultModelFeature, configureEnvPermissionFeature, configureAiMemoryFeature, configureDefaultModelFeature, configureMcpFeature, configureApiFeature } from './features.mjs';
-import { c as checkForUpdates, g as getInstalledPackages, s as searchPackages } from '../shared/ccjk.Bi-m3LKY.mjs';
+import { c as checkForUpdates, g as getInstalledPackages, s as searchPackages } from '../shared/ccjk.RR9TS76h.mjs';
 import { p as promptBoolean, a as addNumbersToChoices } from '../shared/ccjk.DhBeLRzf.mjs';
 import { isSmartGuideInstalled, generateSkillReferenceCard, removeSmartGuide, injectSmartGuide, generateQuickActionsPanel, QUICK_ACTIONS } from './smart-guide.mjs';
 import { executeCcusage } from './ccu.mjs';
@@ -25,7 +25,7 @@ import { configSwitchCommand } from './config-switch.mjs';
 import { d as detectProjectContext, h as getProjectTypeLabel, b as getApplicableRules, c as getContextFiles, j as getContextFileTypeLabel, r as readContextFile, m as mergeContextContent, e as generateContextContent, w as writeContextFile, f as getRecommendedRules, k as formatFileSize } from '../shared/ccjk.ByTIGCUC.mjs';
 import { doctor, workspaceDiagnostics } from './doctor.mjs';
 import { ensureDir, writeFileAtomic, exists, readJsonFile } from './fs-operations.mjs';
-import { a as mcpList, c as mcpUninstall, m as mcpInstall, d as mcpTrending, b as mcpSearch } from '../shared/ccjk.D-RZS4E2.mjs';
+import { a as mcpList, c as mcpUninstall, m as mcpInstall, d as mcpTrending, b as mcpSearch } from '../shared/ccjk.QbS8EAOd.mjs';
 import { notificationCommand } from './notification.mjs';
 import { uninstall } from './uninstall.mjs';
 import { update } from './update.mjs';
@@ -1471,7 +1471,7 @@ class CloudHooksSyncClient {
   timeout;
   enableLogging;
   constructor(options = {}) {
-    this.baseUrl = options.baseUrl || "https://api.ccjk.dev/v1/hooks";
+    this.baseUrl = options.baseUrl || "https://api.api.claudehome.cn/v1/hooks";
     this.apiKey = options.apiKey;
     this.timeout = options.timeout || 3e4;
     this.enableLogging = options.enableLogging || false;

package/dist/chunks/notification.mjs

@@ -1,14 +1,14 @@
 import ansis from 'ansis';
 import inquirer from 'inquirer';
 import { i18n } from './index2.mjs';
-import * as nodeFs from 'node:fs';
-import nodeFs__default, { existsSync, readFileSync, mkdirSync, unlinkSync } from 'node:fs';
+import * as fs from 'node:fs';
+import fs__default, { existsSync, readFileSync, mkdirSync, unlinkSync } from 'node:fs';
 import * as os from 'node:os';
 import os__default, { homedir } from 'node:os';
 import { join } from 'pathe';
 import { writeFileAtomic } from './fs-operations.mjs';
 import { Buffer } from 'node:buffer';
-import crypto from 'node:crypto';
+import crypto__default from 'node:crypto';
 import { exec } from 'node:child_process';
 import * as path from 'node:path';
 import path__default from 'node:path';
@@ -24,7 +24,7 @@ const TOKEN_PREFIX = "ccjk_";
 const TOKEN_LENGTH = 64;
 const TOKEN_VERSION = 1;
 function generateDeviceToken() {
-  const randomBytes = crypto.randomBytes(TOKEN_LENGTH / 2);
+  const randomBytes = crypto__default.randomBytes(TOKEN_LENGTH / 2);
   const randomHex = randomBytes.toString("hex");
   return `${TOKEN_PREFIX}${TOKEN_VERSION}${randomHex}`;
 }
@@ -71,17 +71,17 @@ function generateMachineId() {
     // Limit to first 3 MACs
   ];
   const combined = components.join("|");
-  return crypto.createHash("sha256").update(combined).digest("hex").slice(0, 32);
+  return crypto__default.createHash("sha256").update(combined).digest("hex").slice(0, 32);
 }
 function deriveEncryptionKey() {
   const machineId = generateMachineId();
   const salt = "ccjk-notification-token-v1";
-  return crypto.pbkdf2Sync(machineId, salt, 1e5, 32, "sha256");
+  return crypto__default.pbkdf2Sync(machineId, salt, 1e5, 32, "sha256");
 }
 function encryptToken(token) {
   const key = deriveEncryptionKey();
-  const iv = crypto.randomBytes(16);
-  const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+  const iv = crypto__default.randomBytes(16);
+  const cipher = crypto__default.createCipheriv("aes-256-gcm", key, iv);
   let encrypted = cipher.update(token, "utf8", "hex");
   encrypted += cipher.final("hex");
   const authTag = cipher.getAuthTag();
@@ -97,7 +97,7 @@ function decryptToken(encryptedToken) {
     const key = deriveEncryptionKey();
     const iv = Buffer.from(ivHex, "hex");
     const authTag = Buffer.from(authTagHex, "hex");
-    const decipher = crypto.createDecipheriv("aes-256-gcm", key, iv);
+    const decipher = crypto__default.createDecipheriv("aes-256-gcm", key, iv);
     decipher.setAuthTag(authTag);
     let decrypted = decipher.update(encrypted, "hex", "utf8");
     decrypted += decipher.final("utf8");
@@ -588,8 +588,8 @@ else:
       });
     } finally {
       try {
-        if (nodeFs.existsSync(TEMP_NOTIFICATION_FILE)) {
-          nodeFs.unlinkSync(TEMP_NOTIFICATION_FILE);
+        if (fs.existsSync(TEMP_NOTIFICATION_FILE)) {
+          fs.unlinkSync(TEMP_NOTIFICATION_FILE);
         }
       } catch {
       }
@@ -744,10 +744,10 @@ else:
 }
 async function loadLocalNotificationConfig() {
   try {
-    if (!nodeFs.existsSync(CONFIG_FILE)) {
+    if (!fs.existsSync(CONFIG_FILE)) {
       return { ...DEFAULT_CONFIG };
     }
-    const content = nodeFs.readFileSync(CONFIG_FILE, "utf-8");
+    const content = fs.readFileSync(CONFIG_FILE, "utf-8");
     const config = JSON.parse(content);
     return {
       ...DEFAULT_CONFIG,
@@ -760,8 +760,8 @@ async function loadLocalNotificationConfig() {
 }
 async function saveLocalNotificationConfig(config) {
   try {
-    if (!nodeFs.existsSync(CONFIG_DIR)) {
-      nodeFs.mkdirSync(CONFIG_DIR, { recursive: true });
+    if (!fs.existsSync(CONFIG_DIR)) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
     }
     const existingConfig = await loadLocalNotificationConfig();
     const newConfig = { ...existingConfig, ...config };
@@ -936,13 +936,13 @@ const CONFIG_FILE_PATH = path__default.join(CCJK_CONFIG_DIR, "config.toml");
 const SECRETS_FILE_PATH = path__default.join(CCJK_CONFIG_DIR, ".notification-secrets");
 async function loadNotificationConfig() {
   try {
-    if (!nodeFs__default.existsSync(CCJK_CONFIG_DIR)) {
-      nodeFs__default.mkdirSync(CCJK_CONFIG_DIR, { recursive: true });
+    if (!fs__default.existsSync(CCJK_CONFIG_DIR)) {
+      fs__default.mkdirSync(CCJK_CONFIG_DIR, { recursive: true });
     }
-    if (!nodeFs__default.existsSync(CONFIG_FILE_PATH)) {
+    if (!fs__default.existsSync(CONFIG_FILE_PATH)) {
       return { ...DEFAULT_NOTIFICATION_CONFIG };
     }
-    const configContent = nodeFs__default.readFileSync(CONFIG_FILE_PATH, "utf-8");
+    const configContent = fs__default.readFileSync(CONFIG_FILE_PATH, "utf-8");
     const config = parse(configContent);
     const notificationConfig = config.notification;
     if (!notificationConfig) {
@@ -978,10 +978,10 @@ async function loadNotificationConfig() {
 }
 async function loadDeviceToken() {
   try {
-    if (!nodeFs__default.existsSync(SECRETS_FILE_PATH)) {
+    if (!fs__default.existsSync(SECRETS_FILE_PATH)) {
       return null;
     }
-    const secretsContent = nodeFs__default.readFileSync(SECRETS_FILE_PATH, "utf-8");
+    const secretsContent = fs__default.readFileSync(SECRETS_FILE_PATH, "utf-8");
     const secrets = JSON.parse(secretsContent);
     if (!secrets.deviceToken) {
       return null;
@@ -994,12 +994,12 @@ async function loadDeviceToken() {
 }
 async function saveNotificationConfig(config) {
   try {
-    if (!nodeFs__default.existsSync(CCJK_CONFIG_DIR)) {
-      nodeFs__default.mkdirSync(CCJK_CONFIG_DIR, { recursive: true });
+    if (!fs__default.existsSync(CCJK_CONFIG_DIR)) {
+      fs__default.mkdirSync(CCJK_CONFIG_DIR, { recursive: true });
     }
     let existingConfig = {};
-    if (nodeFs__default.existsSync(CONFIG_FILE_PATH)) {
-      const configContent = nodeFs__default.readFileSync(CONFIG_FILE_PATH, "utf-8");
+    if (fs__default.existsSync(CONFIG_FILE_PATH)) {
+      const configContent = fs__default.readFileSync(CONFIG_FILE_PATH, "utf-8");
       existingConfig = parse(configContent);
     }
     const notificationConfig = { ...config };
@@ -1021,8 +1021,8 @@ async function saveDeviceToken(token) {
   try {
     const encryptedToken = encryptToken(token);
     let secrets = {};
-    if (nodeFs__default.existsSync(SECRETS_FILE_PATH)) {
-      const secretsContent = nodeFs__default.readFileSync(SECRETS_FILE_PATH, "utf-8");
+    if (fs__default.existsSync(SECRETS_FILE_PATH)) {
+      const secretsContent = fs__default.readFileSync(SECRETS_FILE_PATH, "utf-8");
       secrets = JSON.parse(secretsContent);
     }
     secrets.deviceToken = encryptedToken;

package/dist/chunks/package.mjs

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