chainlesschain 0.162.9 → 0.162.12

package/src/commands/persona.js

@@ -132,6 +132,160 @@ export function registerPersonaCommand(program) {
       logger.log(`  Role: ${updated.role || "(no role defined)"}`);
     });
 
+  // persona list (Phase 3d)
+  persona
+    .command("list")
+    .description(
+      "List named personas registered in config.personas (Phase 3d registry)",
+    )
+    .option("--json", "Emit JSON instead of human-readable", false)
+    .action((options) => {
+      const projectRoot = findProjectRoot(process.cwd());
+      if (!projectRoot) {
+        if (options.json) {
+          logger.log(
+            JSON.stringify({ error: "not in project", code: "NO_PROJECT" }),
+          );
+        } else {
+          logger.error(
+            "Not inside a ChainlessChain project. Run `chainlesschain init` first.",
+          );
+        }
+        process.exit(1);
+      }
+
+      const config = loadProjectConfig(projectRoot);
+      const personas =
+        config?.personas && typeof config.personas === "object"
+          ? config.personas
+          : {};
+      const active = config?.activePersonaName || null;
+      const envName = process.env.CC_PACK_AUTO_PERSONA || null;
+
+      if (options.json) {
+        logger.log(
+          JSON.stringify(
+            {
+              activePersonaName: active,
+              envPersona: envName,
+              personas: Object.fromEntries(
+                Object.entries(personas).map(([k, v]) => [
+                  k,
+                  { name: v?.name || null, role: v?.role || null },
+                ]),
+              ),
+              hasLegacyInlinePersona: Boolean(config?.persona),
+            },
+            null,
+            2,
+          ),
+        );
+        return;
+      }
+
+      if (Object.keys(personas).length === 0) {
+        logger.log("No named personas registered.");
+        if (config?.persona) {
+          logger.log(
+            chalk.dim(
+              "  (Legacy inline `config.persona` is set; it activates as the default.)",
+            ),
+          );
+        }
+        logger.log(
+          `\nAdd one via \`config.personas.<name>\` or by re-running \`cc init -t <template>\` (medical-triage / agriculture-expert / etc.).`,
+        );
+        return;
+      }
+
+      logger.log(chalk.bold("Registered personas:"));
+      for (const [k, v] of Object.entries(personas)) {
+        const marker =
+          k === envName
+            ? chalk.green(" ← CC_PACK_AUTO_PERSONA")
+            : k === active
+              ? chalk.cyan(" ← active")
+              : "";
+        logger.log(`  ${chalk.cyan(k)}${marker}`);
+        if (v?.name) logger.log(`    name: ${v.name}`);
+        if (v?.role) {
+          const oneLine = String(v.role).split("\n")[0].slice(0, 80);
+          logger.log(chalk.dim(`    role: ${oneLine}`));
+        }
+      }
+      if (envName && !personas[envName]) {
+        logger.log(
+          chalk.yellow(
+            `\n  Warning: CC_PACK_AUTO_PERSONA="${envName}" does not match any registered persona.`,
+          ),
+        );
+      }
+    });
+
+  // persona activate (Phase 3d)
+  persona
+    .command("activate <name>")
+    .description(
+      "Activate a named persona from config.personas (Phase 3d; equivalent to `cc skill enable` for persona-category skills)",
+    )
+    .action((name) => {
+      const projectRoot = findProjectRoot(process.cwd());
+      if (!projectRoot) {
+        logger.error(
+          "Not inside a ChainlessChain project. Run `chainlesschain init` first.",
+        );
+        process.exit(1);
+      }
+
+      const configPath = path.join(
+        projectRoot,
+        ".chainlesschain",
+        "config.json",
+      );
+      let config;
+      try {
+        config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      } catch {
+        logger.error("Failed to read config.json");
+        process.exit(1);
+      }
+
+      const personas =
+        config.personas && typeof config.personas === "object"
+          ? config.personas
+          : {};
+      const target = personas[name];
+      if (!target) {
+        const available = Object.keys(personas);
+        logger.error(`No persona named "${name}" in config.personas.`);
+        if (available.length > 0) {
+          logger.log(`Available: ${chalk.cyan(available.join(", "))}`);
+        } else {
+          logger.log(
+            chalk.dim(
+              "  (No named personas registered. See `cc persona list` for details.)",
+            ),
+          );
+        }
+        process.exit(1);
+      }
+
+      config.activePersonaName = name;
+      // Denormalize so `_loadProjectPersona`'s legacy `config.persona` read
+      // path also sees the activation. Single source of truth is
+      // `activePersonaName`, but the inline copy keeps the resolver
+      // backward-compatible without forcing a config-version bump.
+      config.persona = target;
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+
+      logger.success(`Activated persona "${chalk.cyan(name)}".`);
+      logger.log(`  Display name: ${target.name || "(unnamed)"}`);
+      if (target.role) {
+        const oneLine = String(target.role).split("\n")[0].slice(0, 80);
+        logger.log(chalk.dim(`  Role: ${oneLine}`));
+      }
+    });
+
   // persona reset
   persona
     .command("reset")
@@ -160,12 +314,17 @@ export function registerPersonaCommand(program) {
         process.exit(1);
       }
 
-      if (!config.persona) {
+      if (!config.persona && !config.activePersonaName) {
         logger.log("No persona configured. Nothing to reset.");
         return;
       }
 
       delete config.persona;
+      // Phase 3d: also clear the active-name pointer so _loadProjectPersona
+      // doesn't re-resolve through config.personas[activeName]. The personas
+      // registry itself is preserved — user can re-activate with `cc persona
+      // activate <name>`.
+      delete config.activePersonaName;
       fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
       logger.success(
         "Persona removed. The default coding assistant will be used.",

package/src/index.js

@@ -9,11 +9,13 @@ import { registerConfigCommand } from "./commands/config.js";
 import { registerUpdateCommand } from "./commands/update.js";
 import { registerDoctorCommand } from "./commands/doctor.js";
 import { registerPairCommand } from "./commands/pair.js";
+import { registerNotificationCommand } from "./commands/notification.js";
 import { registerDbCommand } from "./commands/db.js";
 import { registerNoteCommand } from "./commands/note.js";
 import { registerChatCommand } from "./commands/chat.js";
 import { registerAskCommand } from "./commands/ask.js";
 import { registerLlmCommand } from "./commands/llm.js";
+import { registerHubCommand } from "./commands/hub.js";
 import {
   registerAgentCommand,
   registerSubAgentV2Command,
@@ -395,6 +397,7 @@ export function createProgram(opts = {}) {
   registerUpdateCommand(program);
   registerDoctorCommand(program);
   registerPairCommand(program);
+  registerNotificationCommand(program);
 
   // Headless commands
   registerDbCommand(program);
@@ -402,6 +405,7 @@ export function createProgram(opts = {}) {
   registerChatCommand(program);
   registerAskCommand(program);
   registerLlmCommand(program);
+  registerHubCommand(program);
   registerAgentCommand(program);
   registerSubAgentV2Command(program);
   registerExecBackendV2Command(program);

package/src/lib/packer/pkg-config-generator.js

@@ -184,35 +184,110 @@ export function generatePkgConfig(ctx) {
       "// check-update`) can read packedCliVersion / updateManifestUrl without",
       "// importing from the packer. No-op in CLI-only builds outside pkg.",
       "globalThis.BAKED = BAKED;",
+      "// .env sidecar parser (per design §13 #4). Returns a flat KEY=VALUE",
+      "// dict; missing file / unreadable -> {}. Skips blank lines, '#' comments,",
+      "// and BOM. Strips matching single/double quote pairs but leaves inner",
+      "// content untouched (no escape-sequence interpretation — power users who",
+      "// need that can set the var from their shell, which wins anyway).",
+      "function _loadDotenv(filePath) {",
+      "  try {",
+      "    if (!filePath || !fs.existsSync(filePath)) return {};",
+      "    const body = fs.readFileSync(filePath, 'utf-8').replace(/^\\uFEFF/, '');",
+      "    const out = {};",
+      "    for (const rawLine of body.split(/\\r?\\n/)) {",
+      "      const line = rawLine.trim();",
+      "      if (!line || line.startsWith('#')) continue;",
+      "      const eq = line.indexOf('=');",
+      "      if (eq <= 0) continue;",
+      "      const key = line.slice(0, eq).trim();",
+      "      let val = line.slice(eq + 1).trim();",
+      "      if (val.length >= 2 &&",
+      "          ((val.startsWith('\"') && val.endsWith('\"')) ||",
+      '           (val.startsWith("\'") && val.endsWith("\'")))) {',
+      "        val = val.slice(1, -1);",
+      "      }",
+      "      out[key] = val;",
+      "    }",
+      "    return out;",
+      "  } catch { return {}; }",
+      "}",
+      "// Schema-aware deep-merge: bundled (base) values fill in missing keys,",
+      "// existing user values win. Used only for .chainlesschain/config.json so",
+      "// new exe schema fields land without clobbering user edits.",
+      "function _deepMerge(base, override) {",
+      "  if (override === null || typeof override !== 'object' || Array.isArray(override)) return override;",
+      "  if (base === null || typeof base !== 'object' || Array.isArray(base)) return override;",
+      "  const out = { ...base };",
+      "  for (const k of Object.keys(override)) {",
+      "    out[k] = (k in base) ? _deepMerge(base[k], override[k]) : override[k];",
+      "  }",
+      "  return out;",
+      "}",
       "// Merge-copy helper: copies src tree into dest, skipping files that",
       "// already exist (preserves user modifications). Used only in project mode.",
-      "function copyRecursiveMerge(src, dest) {",
+      "// Special case: top-level config.json gets deep-merged (user values win,",
+      "// bundled supplies new schema fields).",
+      "function copyRecursiveMerge(src, dest, rootSrc) {",
+      "  if (rootSrc === undefined) rootSrc = src;",
       "  if (!fs.existsSync(src)) return;",
       "  fs.mkdirSync(dest, { recursive: true });",
       "  for (const e of fs.readdirSync(src, { withFileTypes: true })) {",
       "    const sp = path.join(src, e.name), dp = path.join(dest, e.name);",
-      "    if (e.isDirectory()) { copyRecursiveMerge(sp, dp); }",
+      "    if (e.isDirectory()) { copyRecursiveMerge(sp, dp, rootSrc); }",
       "    else if (!fs.existsSync(dp)) { fs.copyFileSync(sp, dp); }",
-      "    else { console.warn('[cc-pack] Keeping existing file (user-modified):', dp); }",
+      "    else {",
+      "      const _rel = path.relative(rootSrc, sp).replace(/\\\\/g, '/');",
+      "      if (_rel === 'config.json') {",
+      "        try {",
+      "          const _userCfg = JSON.parse(fs.readFileSync(dp, 'utf-8'));",
+      "          const _newCfg  = JSON.parse(fs.readFileSync(sp, 'utf-8'));",
+      "          const _merged  = _deepMerge(_newCfg, _userCfg);",
+      "          fs.writeFileSync(dp, JSON.stringify(_merged, null, 2), 'utf-8');",
+      "        } catch (err) { console.warn('[cc-pack] config.json merge failed, keeping existing:', dp, err && err.message); }",
+      "      } else {",
+      "        console.warn('[cc-pack] Keeping existing file (user-modified):', dp);",
+      "      }",
+      "    }",
       "  }",
       "}",
       "// ── Project mode: materialize bundled .chainlesschain/ to user-data dir ──",
       "// BAKED.projectMode is absent (falsy) in CLI-only builds — entire block skipped.",
       "if (BAKED.projectMode) {",
+      "  // Per design §9: prefer %APPDATA% on Windows (Roaming, ~260-char-safe);",
+      "  // fall back to ~ on other platforms or when APPDATA is unset.",
+      "  const _baseDir = (process.platform === 'win32' && process.env.APPDATA)",
+      "    ? process.env.APPDATA",
+      "    : os.homedir();",
+      "  // SHA-16 (64-bit entropy) per design §4.3 — prior SHA-8 had 32-bit entropy",
+      "  // which is too narrow for multi-project + multi-version coexistence.",
       "  const _userDataDir = path.join(",
-      "    os.homedir(), '.chainlesschain-projects',",
-      "    `${BAKED.projectName}-${BAKED.projectConfigSha.slice(0, 8)}`,",
+      "    _baseDir, '.chainlesschain-projects',",
+      "    `${BAKED.projectName}-${BAKED.projectConfigSha.slice(0, 16)}`,",
       "  );",
       "  const _markerFile = path.join(_userDataDir, '.chainlesschain', '.pack-version');",
+      "  const _lockFile   = path.join(_userDataDir, '.chainlesschain', '.materialize.lock');",
       "  const _needsMaterialize =",
       "    BAKED.forceRefreshOnLaunch ||",
       "    !fs.existsSync(_markerFile) ||",
       "    fs.readFileSync(_markerFile, 'utf8').trim() !== BAKED.projectConfigSha;",
+      "  // Concurrent-materialize protection: only the first instance acquires the",
+      "  // lock and does the copy. Other instances skip silently — the marker file",
+      "  // will already be written by the time they get to use the dir.",
+      "  let _lockFd = null;",
       "  if (_needsMaterialize) {",
+      "    try {",
+      "      fs.mkdirSync(path.dirname(_lockFile), { recursive: true });",
+      "      _lockFd = fs.openSync(_lockFile, 'wx');",
+      "    } catch { /* another instance holds the lock */ }",
+      "  }",
+      "  if (_needsMaterialize && _lockFd !== null) {",
       "    copyRecursiveMerge(BAKED.projectBundledDir, path.join(_userDataDir, '.chainlesschain'));",
       "    fs.mkdirSync(path.dirname(_markerFile), { recursive: true });",
       "    fs.writeFileSync(_markerFile, BAKED.projectConfigSha, 'utf8');",
       "  }",
+      "  if (_lockFd !== null) {",
+      "    try { fs.closeSync(_lockFd); fs.unlinkSync(_lockFile); } catch { /* best-effort */ }",
+      "  }",
       "  process.env.CC_PROJECT_ROOT = _userDataDir;",
       "  if (BAKED.projectAllowedSubcommands) {",
       "    process.env.CC_PROJECT_ALLOWED_SUBCOMMANDS = BAKED.projectAllowedSubcommands.join(',');",
@@ -223,6 +298,25 @@ export function generatePkgConfig(ctx) {
       "    process.env.CC_PACK_AUTO_PERSONA = BAKED.projectAutoPersona;",
       "  }",
       "}",
+      "// Phase 3f: .env sidecar loader (per design §13 #4 + §9 LLM API keys).",
+      "// Priority (highest to lowest): explicit process.env (set in shell),",
+      "// <CC_PROJECT_ROOT>/.env, <exePath dir>/.env. We snapshot the original",
+      "// process.env keys before reading so neither .env can mask a user's",
+      "// shell-level export. The userDataDir .env wins over exePath dir when",
+      "// both define the same key because we apply it second.",
+      "{",
+      "  const _origEnvKeys = new Set(Object.keys(process.env));",
+      "  const _exeEnv = _loadDotenv(path.join(path.dirname(process.execPath), '.env'));",
+      "  const _userEnv = process.env.CC_PROJECT_ROOT",
+      "    ? _loadDotenv(path.join(process.env.CC_PROJECT_ROOT, '.env'))",
+      "    : {};",
+      "  for (const _k of Object.keys(_exeEnv)) {",
+      "    if (!_origEnvKeys.has(_k)) process.env[_k] = _exeEnv[_k];",
+      "  }",
+      "  for (const _k of Object.keys(_userEnv)) {",
+      "    if (!_origEnvKeys.has(_k)) process.env[_k] = _userEnv[_k];",
+      "  }",
+      "}",
       "// Double-click from Explorer arrives with no subcommand — without",
       "// this default, commander prints help and exits, which looks like",
       "// a black console 'flash and close'. In project mode the baked",
@@ -231,6 +325,18 @@ export function generatePkgConfig(ctx) {
       "const _hasSub = _rest.some((a) => a && !a.startsWith('-'));",
       "const _argSet = new Set(_rest);",
       "const _hasFlag = (...names) => names.some((n) => _argSet.has(n));",
+      "// Phase 3f: --version --json short-circuit (per design §13 #3). Plain",
+      "// --version goes through commander; the --json combo emits a structured",
+      "// payload with cli + (in project mode) project name/sha. We intercept",
+      "// before commander.parse so the JSON is the only thing on stdout.",
+      "if (_hasFlag('-v', '--version') && _hasFlag('--json')) {",
+      "  const _vOut = { cli: BAKED.packedCliVersion || 'unknown' };",
+      "  if (BAKED.projectMode) {",
+      "    _vOut.project = { name: BAKED.projectName, sha: BAKED.projectConfigSha };",
+      "  }",
+      "  console.log(JSON.stringify(_vOut));",
+      "  process.exit(0);",
+      "}",
       "// Commander short-circuits --version / --help before running any",
       "// command — don't pollute their stdout with the token banner and",
       "// baked defaults they'd never see anyway.",

package/src/runtime/agent-core.js

@@ -255,7 +255,18 @@ Current working directory: ${cwd || process.cwd()}`;
 // ─── Persona support ─────────────────────────────────────────────────────
 
 /**
- * Load persona configuration from project config.json
+ * Load persona configuration from project config.json.
+ *
+ * Resolution order (highest priority first):
+ *   1. CC_PACK_AUTO_PERSONA env var → config.personas[<env>] if present
+ *      (set by `cc pack --project` packed exe at boot, per Phase 3f; the
+ *      Phase 3d resolver lives here so packaged products actually activate
+ *      their bundled persona at runtime)
+ *   2. config.activePersonaName → config.personas[<name>] if present
+ *      (set by `cc persona activate <name>`)
+ *   3. config.persona (the legacy inline single-persona shape; still the
+ *      common case for projects created via `cc init`)
+ *
  * @param {string} cwd - working directory
  * @returns {object|null} persona object or null
  */
@@ -264,7 +275,20 @@ function _loadProjectPersona(cwd) {
     const projectRoot = findProjectRoot(cwd || process.cwd());
     if (!projectRoot) return null;
     const config = loadProjectConfig(projectRoot);
-    return config?.persona || null;
+    if (!config) return null;
+    const personas =
+      config.personas && typeof config.personas === "object"
+        ? config.personas
+        : null;
+    const envName = process.env.CC_PACK_AUTO_PERSONA;
+    if (envName && personas && personas[envName]) {
+      return personas[envName];
+    }
+    const activeName = config.activePersonaName;
+    if (activeName && personas && personas[activeName]) {
+      return personas[activeName];
+    }
+    return config.persona || null;
   } catch {
     return null;
   }

package/src/assets/web-panel/assets/index-EFyvtYMT.js

@@ -1 +0,0 @@
-import{C as o}from"./Col-CezPMM8r.js";import{S as t}from"./index-WmmdmN6b.js";import"./index-BbQx_BA_.js";import"./vendor-M5lGV-wr.js";import"./icons-CLQTHa5-.js";const s=t(o);export{s as default};

package/src/assets/web-panel/assets/index-ohea9DVW.js

@@ -1 +0,0 @@
-import{A as o}from"./Row-Dsz4KRaU.js";import{S as t}from"./index-WmmdmN6b.js";import"./responsiveObserve-CQ1ZgLXP.js";import"./vendor-M5lGV-wr.js";import"./useFlexGapSupport-Ba76kVFx.js";import"./styleChecker-CDEoUvcb.js";import"./index-BbQx_BA_.js";import"./icons-CLQTHa5-.js";const l=t(o);export{l as default};