ccjk 2.4.3 → 2.5.0

package/dist/chunks/mcp.mjs

@@ -3,8 +3,9 @@ import { i18n } from './index2.mjs';
 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.QbS8EAOd.mjs';
+import { r as readMcpConfig, b as backupMcpConfig, w as writeMcpConfig } from './config.mjs';
+export { m as mcpInstall, a as mcpList, b as mcpSearch, c as mcpUninstall } from '../shared/ccjk.uVUeWAt8.mjs';
+import { M as MCP_SERVICE_CONFIGS } from './codex.mjs';
 import 'node:fs';
 import 'node:url';
 import 'i18next';
@@ -12,17 +13,18 @@ import 'i18next-fs-backend';
 import 'pathe';
 import 'dayjs';
 import 'inquirer';
-import 'ora';
-import 'semver';
-import 'smol-toml';
-import 'tinyexec';
 import './constants.mjs';
 import 'node:os';
-import './ccjk-config.mjs';
+import './json-config.mjs';
 import './fs-operations.mjs';
 import 'node:crypto';
 import 'node:fs/promises';
 import './platform.mjs';
+import 'tinyexec';
+import 'ora';
+import 'semver';
+import 'smol-toml';
+import './ccjk-config.mjs';
 import '../shared/ccjk.DhBeLRzf.mjs';
 import 'inquirer-toggle';
 import './prompts.mjs';
@@ -418,7 +420,7 @@ async function useProfile(profileId, options = {}) {
 }
 
 async function mcpStatus(options = {}) {
-  const { readMcpConfig } = await import('./codex.mjs').then(function (n) { return n.ag; });
+  const { readMcpConfig } = await import('./config.mjs').then(function (n) { return n.C; });
   const { checkMcpPerformance, formatPerformanceWarning } = await import('./mcp-performance.mjs').then(function (n) { return n.e; });
   const { MCP_SERVICE_TIERS } = await import('./mcp-performance.mjs').then(function (n) { return n.m; });
   const lang = options.lang || i18n.language || "en";

package/dist/chunks/menu.mjs

@@ -6,9 +6,9 @@ import { join } from 'pathe';
 import { CODE_TOOL_BANNERS, CLAUDE_DIR, isCodeToolType, DEFAULT_CODE_TOOL_TYPE } from './constants.mjs';
 import { ensureI18nInitialized, i18n } from './index2.mjs';
 import { a as displayBannerWithInfo } from '../shared/ccjk.BhKlRJ0h.mjs';
-import { u as updateZcfConfig, a as readZcfConfig } from './ccjk-config.mjs';
-import { Q as runCodexUpdate, P as runCodexUninstall, Y as configureCodexMcp, z as configureCodexApi, S as runCodexWorkflowImportWithLanguageSelection, N as runCodexFullInit } from './codex.mjs';
-import { r as resolveCodeType } from '../shared/ccjk.CURU8gbR.mjs';
+import { updateZcfConfig, readZcfConfig } from './ccjk-config.mjs';
+import { C as runCodexUpdate, B as runCodexUninstall, K as configureCodexMcp, i as configureCodexApi, E as runCodexWorkflowImportWithLanguageSelection, z as runCodexFullInit } from './codex.mjs';
+import { r as resolveCodeType } from '../shared/ccjk.CUdzQluX.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.RR9TS76h.mjs';
@@ -22,10 +22,10 @@ import { homedir } from 'node:os';
 import { runCcrStop, runCcrStart, runCcrRestart, runCcrStatus, runCcrUi } from './commands2.mjs';
 import { checkUpdates } from './check-updates.mjs';
 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 { 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.Dut3wyoP.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.QbS8EAOd.mjs';
+import { a as mcpList, c as mcpUninstall, m as mcpInstall, d as mcpTrending, b as mcpSearch } from '../shared/ccjk.uVUeWAt8.mjs';
 import { notificationCommand } from './notification.mjs';
 import { uninstall } from './uninstall.mjs';
 import { update } from './update.mjs';

package/dist/chunks/package.mjs

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

package/dist/chunks/permissions.mjs

@@ -0,0 +1,420 @@
+import process__default from 'node:process';
+import chalk from 'chalk';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'pathe';
+
+class PermissionManager {
+  permissions = [];
+  configPath;
+  constructor(configPath) {
+    this.configPath = configPath || join(homedir(), ".ccjk", "config.json");
+    this.loadPermissions();
+  }
+  /**
+   * Load permissions from config file
+   */
+  loadPermissions() {
+    try {
+      if (!existsSync(this.configPath)) {
+        this.permissions = [];
+        return;
+      }
+      const configContent = readFileSync(this.configPath, "utf-8");
+      const config = JSON.parse(configContent);
+      if (config.permissions) {
+        this.permissions = [];
+        if (Array.isArray(config.permissions.allow)) {
+          config.permissions.allow.forEach((pattern) => {
+            this.permissions.push({
+              type: "allow",
+              pattern,
+              scope: "global"
+            });
+          });
+        }
+        if (Array.isArray(config.permissions.deny)) {
+          config.permissions.deny.forEach((pattern) => {
+            this.permissions.push({
+              type: "deny",
+              pattern,
+              scope: "global"
+            });
+          });
+        }
+      }
+    } catch (_error) {
+      this.permissions = [];
+    }
+  }
+  /**
+   * Save permissions to config file
+   */
+  savePermissions() {
+    try {
+      let config = {};
+      if (existsSync(this.configPath)) {
+        const configContent = readFileSync(this.configPath, "utf-8");
+        config = JSON.parse(configContent);
+      }
+      config.permissions = {
+        allow: this.permissions.filter((p) => p.type === "allow").map((p) => p.pattern),
+        deny: this.permissions.filter((p) => p.type === "deny").map((p) => p.pattern)
+      };
+      writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
+    } catch (error) {
+      throw new Error(`Failed to save permissions: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * Check if an action on a resource is permitted
+   * @param action - The action to check (e.g., "read", "write", "admin")
+   * @param resource - The resource identifier (e.g., "Provider(302ai)", "Model(claude-opus)")
+   * @returns Permission check result
+   */
+  checkPermission(action, resource) {
+    const target = `${resource}:${action}`;
+    for (const permission of this.permissions) {
+      if (permission.type === "deny" && this.matchPattern(permission.pattern, target)) {
+        return {
+          allowed: false,
+          matchedRule: permission,
+          reason: `Denied by rule: ${permission.pattern}`
+        };
+      }
+    }
+    for (const permission of this.permissions) {
+      if (permission.type === "allow" && this.matchPattern(permission.pattern, target)) {
+        return {
+          allowed: true,
+          matchedRule: permission,
+          reason: `Allowed by rule: ${permission.pattern}`
+        };
+      }
+    }
+    return {
+      allowed: false,
+      reason: "No matching permission rule found (default deny)"
+    };
+  }
+  /**
+   * Match a pattern against a target string
+   * Supports wildcards: * (any characters), ? (single character)
+   * @param pattern - Pattern with wildcards
+   * @param target - Target string to match
+   * @returns True if pattern matches target
+   */
+  matchPattern(pattern, target) {
+    const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    const regex = new RegExp(`^${regexPattern}$`, "i");
+    return regex.test(target);
+  }
+  /**
+   * Add a permission rule
+   * @param permission - Permission to add
+   */
+  addPermission(permission) {
+    const existingIndex = this.permissions.findIndex(
+      (p) => p.pattern === permission.pattern && p.type === permission.type
+    );
+    if (existingIndex >= 0) {
+      this.permissions[existingIndex] = {
+        ...permission,
+        createdAt: this.permissions[existingIndex].createdAt || (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } else {
+      this.permissions.push({
+        ...permission,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    this.savePermissions();
+  }
+  /**
+   * Remove a permission rule by pattern
+   * @param pattern - Pattern to remove
+   * @param type - Optional type filter
+   * @returns Number of rules removed
+   */
+  removePermission(pattern, type) {
+    const initialLength = this.permissions.length;
+    this.permissions = this.permissions.filter((p) => {
+      if (type) {
+        return !(p.pattern === pattern && p.type === type);
+      }
+      return p.pattern !== pattern;
+    });
+    const removedCount = initialLength - this.permissions.length;
+    if (removedCount > 0) {
+      this.savePermissions();
+    }
+    return removedCount;
+  }
+  /**
+   * List all permissions
+   * @param type - Optional filter by type
+   * @param scope - Optional filter by scope
+   * @returns Array of permissions
+   */
+  listPermissions(type, scope) {
+    let filtered = [...this.permissions];
+    if (type) {
+      filtered = filtered.filter((p) => p.type === type);
+    }
+    if (scope) {
+      filtered = filtered.filter((p) => p.scope === scope);
+    }
+    return filtered;
+  }
+  /**
+   * Clear all permissions
+   * @param type - Optional type to clear (if not specified, clears all)
+   */
+  clearPermissions(type) {
+    if (type) {
+      this.permissions = this.permissions.filter((p) => p.type !== type);
+    } else {
+      this.permissions = [];
+    }
+    this.savePermissions();
+  }
+  /**
+   * Get permission statistics
+   */
+  getStats() {
+    return {
+      total: this.permissions.length,
+      allow: this.permissions.filter((p) => p.type === "allow").length,
+      deny: this.permissions.filter((p) => p.type === "deny").length
+    };
+  }
+  /**
+   * Export permissions to JSON
+   */
+  exportPermissions() {
+    return {
+      allow: this.permissions.filter((p) => p.type === "allow").map((p) => p.pattern),
+      deny: this.permissions.filter((p) => p.type === "deny").map((p) => p.pattern)
+    };
+  }
+  /**
+   * Import permissions from JSON
+   * @param config - Permission configuration to import
+   * @param merge - If true, merge with existing permissions; if false, replace
+   */
+  importPermissions(config, merge = false) {
+    if (!merge) {
+      this.permissions = [];
+    }
+    if (Array.isArray(config.allow)) {
+      config.allow.forEach((pattern) => {
+        this.addPermission({
+          type: "allow",
+          pattern,
+          scope: "global"
+        });
+      });
+    }
+    if (Array.isArray(config.deny)) {
+      config.deny.forEach((pattern) => {
+        this.addPermission({
+          type: "deny",
+          pattern,
+          scope: "global"
+        });
+      });
+    }
+  }
+}
+
+const permissionManager = PermissionManager.getInstance();
+async function listPermissions(options) {
+  const format = options.format || "table";
+  const verbose = options.verbose || false;
+  const permissions = permissionManager.getAllPermissions();
+  if (format === "json") {
+    console.log(JSON.stringify(permissions, null, 2));
+    return;
+  }
+  console.log(chalk.bold("\n\u{1F4CB} CCJK Permissions\n"));
+  if (permissions.length === 0) {
+    console.log(chalk.yellow("No permissions configured."));
+    return;
+  }
+  if (format === "list") {
+    for (const perm of permissions) {
+      const levelColor = getLevelColor(perm.level);
+      console.log(`${chalk.cyan(perm.resource)}: ${levelColor(perm.level)}`);
+      if (verbose && perm.metadata) {
+        console.log(chalk.gray(`  Metadata: ${JSON.stringify(perm.metadata)}`));
+      }
+    }
+  } else {
+    console.log(chalk.bold("Resource".padEnd(40)) + chalk.bold("Level".padEnd(15)) + chalk.bold("Granted At"));
+    console.log("\u2500".repeat(70));
+    for (const perm of permissions) {
+      const levelColor = getLevelColor(perm.level);
+      const resource = perm.resource.padEnd(40);
+      const level = levelColor(perm.level.padEnd(15));
+      const grantedAt = new Date(perm.grantedAt).toLocaleString();
+      console.log(`${resource}${level}${grantedAt}`);
+      if (verbose && perm.metadata) {
+        console.log(chalk.gray(`  Metadata: ${JSON.stringify(perm.metadata)}`));
+      }
+    }
+  }
+  console.log();
+}
+async function checkPermission(resource, options) {
+  if (!resource) {
+    console.error(chalk.red("Error: Resource is required"));
+    console.log("Usage: ccjk permissions check <resource>");
+    process__default.exit(1);
+  }
+  const verbose = options.verbose || false;
+  console.log(chalk.bold(`
+\u{1F50D} Checking permission for: ${chalk.cyan(resource)}
+`));
+  const hasPermission = await permissionManager.checkPermission(resource, "read");
+  const permission = permissionManager.getPermission(resource);
+  if (hasPermission) {
+    console.log(chalk.green("\u2713 Permission granted"));
+    if (permission) {
+      const levelColor = getLevelColor(permission.level);
+      console.log(`  Level: ${levelColor(permission.level)}`);
+      console.log(`  Granted at: ${new Date(permission.grantedAt).toLocaleString()}`);
+      if (verbose && permission.metadata) {
+        console.log(`  Metadata: ${JSON.stringify(permission.metadata, null, 2)}`);
+      }
+    }
+  } else {
+    console.log(chalk.red("\u2717 Permission denied"));
+    console.log(chalk.yellow('  Use "ccjk permissions grant" to grant permission'));
+  }
+  console.log();
+}
+async function grantPermission(resource, _options) {
+  if (!resource) {
+    console.error(chalk.red("Error: Resource is required"));
+    console.log("Usage: ccjk permissions grant <resource>");
+    process__default.exit(1);
+  }
+  console.log(chalk.bold(`
+\u2713 Granting permission for: ${chalk.cyan(resource)}
+`));
+  await permissionManager.grantPermission(resource, "full", {
+    grantedBy: "cli",
+    grantedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  console.log(chalk.green("Permission granted successfully!"));
+  console.log();
+}
+async function revokePermission(resource, _options) {
+  if (!resource) {
+    console.error(chalk.red("Error: Resource is required"));
+    console.log("Usage: ccjk permissions revoke <resource>");
+    process__default.exit(1);
+  }
+  console.log(chalk.bold(`
+\u2717 Revoking permission for: ${chalk.cyan(resource)}
+`));
+  await permissionManager.revokePermission(resource);
+  console.log(chalk.green("Permission revoked successfully!"));
+  console.log();
+}
+async function resetPermissions(_options) {
+  console.log(chalk.bold("\n\u26A0\uFE0F  Resetting all permissions\n"));
+  const readline = await import('node:readline');
+  const rl = readline.createInterface({
+    input: process__default.stdin,
+    output: process__default.stdout
+  });
+  const answer = await new Promise((resolve) => {
+    rl.question(chalk.yellow("Are you sure you want to reset all permissions? (yes/no): "), resolve);
+  });
+  rl.close();
+  if (answer.toLowerCase() !== "yes") {
+    console.log(chalk.gray("Operation cancelled."));
+    return;
+  }
+  await permissionManager.clearAllPermissions();
+  console.log(chalk.green("All permissions have been reset!"));
+  console.log();
+}
+async function exportPermissions(filePath, _options) {
+  const fs = await import('node:fs/promises');
+  const path = await import('node:path');
+  const outputPath = filePath || path.join(process__default.cwd(), "permissions.json");
+  console.log(chalk.bold(`
+\u{1F4E4} Exporting permissions to: ${chalk.cyan(outputPath)}
+`));
+  const permissions = permissionManager.getAllPermissions();
+  await fs.writeFile(outputPath, JSON.stringify(permissions, null, 2), "utf-8");
+  console.log(chalk.green(`Exported ${permissions.length} permissions successfully!`));
+  console.log();
+}
+async function importPermissions(filePath, _options) {
+  if (!filePath) {
+    console.error(chalk.red("Error: File path is required"));
+    console.log("Usage: ccjk permissions import <file>");
+    process__default.exit(1);
+  }
+  const fs = await import('node:fs/promises');
+  console.log(chalk.bold(`
+\u{1F4E5} Importing permissions from: ${chalk.cyan(filePath)}
+`));
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    const permissions = JSON.parse(content);
+    if (!Array.isArray(permissions)) {
+      throw new TypeError("Invalid permissions file format");
+    }
+    await permissionManager.clearAllPermissions();
+    for (const perm of permissions) {
+      await permissionManager.grantPermission(perm.resource, perm.level, perm.metadata);
+    }
+    console.log(chalk.green(`Imported ${permissions.length} permissions successfully!`));
+  } catch (error) {
+    console.error(chalk.red("Error importing permissions:"), error);
+    process__default.exit(1);
+  }
+  console.log();
+}
+function permissionsHelp(_options) {
+  console.log(chalk.bold("\n\u{1F4CB} CCJK Permissions Management\n"));
+  console.log(chalk.bold("Usage:"));
+  console.log("  ccjk permissions [action] [...args]\n");
+  console.log(chalk.bold("Actions:"));
+  console.log("  list              List all permissions");
+  console.log("  check <resource>  Check permission for a resource");
+  console.log("  grant <resource>  Grant permission for a resource");
+  console.log("  revoke <resource> Revoke permission for a resource");
+  console.log("  reset             Reset all permissions");
+  console.log("  export [file]     Export permissions to a file");
+  console.log("  import <file>     Import permissions from a file\n");
+  console.log(chalk.bold("Options:"));
+  console.log("  --format, -f      Output format (table|json|list)");
+  console.log("  --verbose, -v     Verbose output\n");
+  console.log(chalk.bold("Examples:"));
+  console.log("  ccjk permissions list");
+  console.log("  ccjk permissions check file:///path/to/file");
+  console.log("  ccjk permissions grant mcp://server-name");
+  console.log("  ccjk permissions export permissions.json");
+  console.log("  ccjk permissions import permissions.json\n");
+}
+function getLevelColor(level) {
+  switch (level) {
+    case "none":
+      return chalk.red;
+    case "read":
+      return chalk.yellow;
+    case "write":
+      return chalk.blue;
+    case "full":
+      return chalk.green;
+    default:
+      return chalk.gray;
+  }
+}
+
+export { checkPermission, exportPermissions, grantPermission, importPermissions, listPermissions, permissionsHelp, resetPermissions, revokePermission };

package/dist/chunks/prompts.mjs

@@ -4,7 +4,7 @@ import inquirer from 'inquirer';
 import { version } from './package.mjs';
 import { LANG_LABELS, getAiOutputLanguageLabel, SUPPORTED_LANGS, AI_OUTPUT_LANGUAGES } from './constants.mjs';
 import { ensureI18nInitialized, i18n } from './index2.mjs';
-import { a as readZcfConfig, u as updateZcfConfig } from './ccjk-config.mjs';
+import { readZcfConfig, updateZcfConfig } from './ccjk-config.mjs';
 import { a as addNumbersToChoices, p as promptBoolean } from '../shared/ccjk.DhBeLRzf.mjs';
 import 'node:os';
 import 'pathe';
@@ -16,6 +16,7 @@ import 'smol-toml';
 import './fs-operations.mjs';
 import 'node:crypto';
 import 'node:fs/promises';
+import './json-config.mjs';
 import 'dayjs';
 import 'inquirer-toggle';