chati-dev 4.5.7 → 4.5.9

package/src/installer/core.js

@@ -1,15 +1,16 @@
 import { mkdirSync, writeFileSync, copyFileSync, existsSync, readFileSync, readdirSync, statSync } from 'fs';
 import { execFileSync } from 'child_process';
-import { join, dirname, basename } from 'path';
+import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
 import { IDE_CONFIGS, IDE_TO_PROVIDER } from '../config/ide-configs.js';
-import { generateClaudeMCPConfig } from '../config/mcp-configs.js';
+import { mergeClaudeMCPConfig, upsertManagedMcpToml } from '../config/mcp-configs.js';
 import { generateSessionYaml, generateConfigYaml, generateClaudeMd, generateClaudeLocalMd, generateCodexSkill, generateGeminiRouter, generateGrokRouter, generateGeminiSessionLock, generateAgentsOverrideMd, generateCodexConstitutionGuardRules, generateCodexReadProtectionRules } from './templates.js';
 import { generateContextFiles } from '../config/context-file-generator.js';
 import { adaptFrameworkFile, ADAPTABLE_FILES } from '../config/framework-adapter.js';
 import { generateClaudeSettings } from '../config/claude-settings-generator.js';
 import { generateProviderOverlays } from './provider-overlay.js';
+import { applyInstalledPathReplacement } from './path-replacement.js';
 import { verifyManifest } from './manifest.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -192,7 +193,7 @@ export async function installFramework(config) {
       if (existsSync(src)) {
         // Apply path replacement so rules reference .chati.dev/ not chati.dev/
         let content = readFileSync(src, 'utf-8');
-        content = applyPathReplacement(content);
+        content = applyInstalledPathReplacement(content);
         writeFileSync(join(claudeRulesDir, file), content, 'utf-8');
       }
     }
@@ -269,6 +270,7 @@ export const FRAMEWORK_DIRS_TO_COPY = [
  */
 const FRAMEWORK_ROOT_FILES = [
   'constitution.md',
+  'package.json',
 ];
 
 /**
@@ -287,20 +289,6 @@ const TEXT_EXTENSIONS = new Set(['.md', '.js', '.yaml', '.yml', '.json', '.html'
  * Order matters: replace `chati.dev/artifacts/` FIRST (→ `artifacts/`),
  * then `chati.dev/` (→ `.chati.dev/`). Reversing would produce `.chati.dev/artifacts/`.
  */
-function applyPathReplacement(content) {
-  return content
-    // Step 1: artifacts at root (must be before generic replace)
-    .replace(/chati\.dev\/artifacts\//g, 'artifacts/')
-    // Step 2: path strings with slash — but NOT if already prefixed with dot
-    // (negative lookbehind for any char that would create `.chati.dev` already)
-    .replace(/(?<!\.)chati\.dev\//g, '.chati.dev/')
-    // Step 3: quoted dir name in JS join() calls (WITHOUT slash)
-    // Only match 'chati.dev' (the DIRECTORY, with dot) not 'chati-dev' (the NPM PACKAGE, with dash)
-    // Also: avoid double-prefixing if already '.chati.dev' in source
-    .replace(/(?<!\.)'chati\.dev'/g, "'.chati.dev'")
-    .replace(/(?<!\.)"chati\.dev"/g, '".chati.dev"');
-}
-
 /**
  * Recursively copy a directory from source to destination, applying:
  * 1. Path replacement (chati.dev/ → .chati.dev/, artifacts/ at root)
@@ -327,7 +315,7 @@ function copyDirRecursive(srcDir, destDir, provider, relBase = '') {
       if (isText) {
         let content = readFileSync(srcPath, 'utf-8');
         // Always apply path replacement for installed location
-        content = applyPathReplacement(content);
+        content = applyInstalledPathReplacement(content);
         // Provider adaptation on top (for non-Claude)
         if (provider !== 'claude' && ADAPTABLE_FILES.has(relPath)) {
           content = adaptFrameworkFile(content, relPath, provider);
@@ -360,7 +348,7 @@ export function copyFrameworkFiles(destDir, provider = 'claude') {
     const dest = join(destDir, file);
     createDir(dirname(dest));
     let content = readFileSync(src, 'utf-8');
-    content = applyPathReplacement(content);
+    content = applyInstalledPathReplacement(content);
     if (provider !== 'claude' && ADAPTABLE_FILES.has(file)) {
       content = adaptFrameworkFile(content, file, provider);
     }
@@ -429,14 +417,13 @@ Parse the JSON output. This single command already handled: license validation,
     // (Pre-v4.2.2 bug: this file was never written, hooks never ran.)
     writeClaudeSettingsWithMerge(join(targetDir, '.claude', 'settings.json'));
 
-    // MCP config
-    if (selectedMCPs.length > 0) {
-      const mcpConfig = generateClaudeMCPConfig(selectedMCPs);
-      writeFileSync(
-        join(targetDir, '.claude', 'mcp.json'),
-        JSON.stringify(mcpConfig, null, 2) + '\n',
-        'utf-8'
-      );
+    // Claude project-scope MCP config lives at the project root. Preserve
+    // unknown user-managed servers while replacing CHATI's known entries.
+    const mcpPath = join(targetDir, '.mcp.json');
+    if (selectedMCPs.length > 0 || existsSync(mcpPath)) {
+      const existingMcp = existsSync(mcpPath) ? readFileSync(mcpPath, 'utf-8') : '';
+      const mcpConfig = mergeClaudeMCPConfig(existingMcp, selectedMCPs);
+      writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2) + '\n', 'utf-8');
     }
   } else if (ideKey === 'codex-cli') {
     // Codex CLI: chati skill via .agents/skills/chati/SKILL.md (invoke with $chati)
@@ -448,17 +435,18 @@ Parse the JSON output. This single command already handled: license validation,
 
     // Starlark execution policies (Codex sandboxed rule engine)
     createDir(join(targetDir, '.codex', 'rules'));
+    writeCodexConfigWithHooks(join(targetDir, '.codex', 'config.toml'), selectedMCPs);
     writeFileSync(join(targetDir, '.codex', 'rules', 'constitution-guard.rules'), generateCodexConstitutionGuardRules(), 'utf-8');
     writeFileSync(join(targetDir, '.codex', 'rules', 'read-protection.rules'), generateCodexReadProtectionRules(), 'utf-8');
 
     // .codex/hooks.json — license-guard wired to UserPromptSubmit (per-turn enforcement).
-    // Codex hooks.json is experimental (requires [features] codex_hooks = true in
-    // codex config). Without it, license enforcement only happens at slash command
+    // Codex hooks require [features] hooks = true in the active project config.
+    // Without it, license enforcement only happens at skill entry and the router,
     // entry — a long-running terminal session would not be re-validated.
     writeFileSync(
       join(targetDir, '.codex', 'hooks.json'),
       JSON.stringify({
-        $comment: 'chati.dev v4.2.2 — experimental Codex hooks. Requires [features] codex_hooks = true.',
+        $comment: 'chati.dev Codex lifecycle hooks. Requires [features] hooks = true.',
         hooks: {
           UserPromptSubmit: [
             {
@@ -486,7 +474,7 @@ Parse the JSON output. This single command already handled: license validation,
     for (const file of contextFileNames) {
       const src = join(FRAMEWORK_SOURCE, 'context', file);
       if (existsSync(src)) {
-        const content = readFileSync(src, 'utf-8');
+        const content = applyInstalledPathReplacement(readFileSync(src, 'utf-8'));
         writeFileSync(join(geminiContextDir, file), adaptFrameworkFile(content, `context/${file}`, 'gemini'), 'utf-8');
       }
     }
@@ -506,6 +494,11 @@ Parse the JSON output. This single command already handled: license validation,
   } else if (ideKey === 'grok-cli') {
     writeFileSync(join(targetDir, '.grok', 'commands', 'chati.md'), generateGrokRouter({ orchestratorPath }), 'utf-8');
     writeFileSync(join(targetDir, '.grok', 'session-lock.md'), generateClaudeLocalMd(), 'utf-8');
+    const grokConfigPath = join(targetDir, '.grok', 'config.toml');
+    if (selectedMCPs.length > 0 || existsSync(grokConfigPath)) {
+      const existingConfig = existsSync(grokConfigPath) ? readFileSync(grokConfigPath, 'utf-8') : '';
+      writeFileSync(grokConfigPath, upsertManagedMcpToml(existingConfig, selectedMCPs), 'utf-8');
+    }
   } else {
     // VS Code, Cursor, AntiGravity — generic rules file
     if (config.rulesFile) {
@@ -515,6 +508,34 @@ Parse the JSON output. This single command already handled: license validation,
   }
 }
 
+export function writeCodexConfigWithHooks(configPath, selectedMCPs = []) {
+  createDir(dirname(configPath));
+  const original = existsSync(configPath) ? readFileSync(configPath, 'utf-8') : '';
+  let hooksEnabled = original;
+  if (!original.trim()) {
+    hooksEnabled = '[features]\nhooks = true\n';
+  } else if (/^\s*features\.hooks\s*=/m.test(original)) {
+    hooksEnabled = original.replace(/^\s*features\.hooks\s*=.*$/m, 'features.hooks = true');
+  } else if (!/^\s*features\.hooks\s*=\s*true\s*(?:#.*)?$/m.test(original)) {
+    const lines = original.split('\n');
+    const sectionStart = lines.findIndex((line) => /^\s*\[features\]\s*(?:#.*)?$/.test(line));
+    if (sectionStart === -1) {
+      const prefix = original.endsWith('\n') ? original : `${original}\n`;
+      hooksEnabled = `${prefix}\n[features]\nhooks = true\n`;
+    } else {
+      let sectionEnd = lines.findIndex((line, index) => index > sectionStart && /^\s*\[.*\]\s*(?:#.*)?$/.test(line));
+      if (sectionEnd === -1) sectionEnd = lines.length;
+      const hookIndex = lines.findIndex((line, index) =>
+        index > sectionStart && index < sectionEnd && /^\s*hooks\s*=/.test(line)
+      );
+      if (hookIndex !== -1) lines[hookIndex] = 'hooks = true';
+      else lines.splice(sectionEnd, 0, 'hooks = true');
+      hooksEnabled = lines.join('\n');
+    }
+  }
+  writeFileSync(configPath, upsertManagedMcpToml(hooksEnabled, selectedMCPs), 'utf-8');
+}
+
 /**
  * Generate provider-agnostic instructions file content.
  * Used for non-Claude IDEs (.vscode/chati/rules.md, .cursorrules, etc.)
@@ -826,9 +847,14 @@ export function copyCliDependencies(pkgDir, destNodeModules) {
         let p = require.resolve(depName);
         while (p && p !== dirname(p)) {
           p = dirname(p);
-          if (existsSync(join(p, 'package.json')) && basename(p) === depName.split('/').pop()) {
-            depDir = p;
-            break;
+          const candidatePackage = join(p, 'package.json');
+          if (existsSync(candidatePackage)) {
+            try {
+              if (JSON.parse(readFileSync(candidatePackage, 'utf-8')).name === depName) {
+                depDir = p;
+                break;
+              }
+            } catch { /* keep walking */ }
           }
         }
       } catch { continue; }

package/src/installer/path-replacement.js

@@ -0,0 +1,13 @@
+/**
+ * Translate repository paths into their installed-project locations.
+ *
+ * Source files live under `chati.dev/`. Installed framework files live under
+ * `.chati.dev/`, while user-facing artifacts remain at project root.
+ */
+export function applyInstalledPathReplacement(content) {
+  return content
+    .replace(/chati\.dev\/artifacts\//g, 'artifacts/')
+    .replace(/(?<!\.)chati\.dev\//g, '.chati.dev/')
+    .replace(/(?<!\.)'chati\.dev'/g, "'.chati.dev'")
+    .replace(/(?<!\.)"chati\.dev"/g, '".chati.dev"');
+}

package/src/installer/provider-overlay.js

@@ -13,6 +13,7 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { adaptFrameworkFile, ADAPTABLE_FILES } from '../config/framework-adapter.js';
+import { applyInstalledPathReplacement } from './path-replacement.js';
 
 /**
  * Generate adapted framework overlays for all enabled providers.
@@ -41,7 +42,8 @@ export function generateProviderOverlays(targetDir, frameworkSource, allProvider
 
       // Read CANONICAL (Claude) content from source, then adapt for target provider
       const canonicalContent = readFileSync(srcPath, 'utf-8');
-      const adapted = adaptFrameworkFile(canonicalContent, file, provider);
+      const installedContent = applyInstalledPathReplacement(canonicalContent);
+      const adapted = adaptFrameworkFile(installedContent, file, provider);
 
       const destPath = join(overlayDir, file);
       mkdirSync(dirname(destPath), { recursive: true });

package/src/installer-v2/index.js

@@ -35,6 +35,54 @@ function assertString(value, code, label) {
   if (typeof value !== 'string' || value.trim() === '') throw new ContractError(code, `${label} must be a non-empty string`);
 }
 
+function assertExactKeys(value, allowedKeys, label) {
+  assertObject(value, 'INVALID_ARTIFACT', label);
+  const unexpected = Object.keys(value).filter((key) => !allowedKeys.has(key));
+  if (unexpected.length > 0) {
+    throw new ContractError('UNEXPECTED_ARTIFACT_FIELD', `${label} contains unsupported fields: ${unexpected.join(', ')}`);
+  }
+}
+
+const ARTIFACT_KEYS = new Set([
+  'schema_version', 'artifact_type', 'project_id', 'created_at', 'installation',
+  'capability_snapshot', 'brain_read_capability', 'managed_paths',
+  'installation_artifact_id', 'digest',
+]);
+const INSTALLATION_KEYS = new Set([
+  'installation_id', 'profile', 'enabled_providers', 'capability_snapshot_ref',
+  'policy_ref', 'primary_binding', 'primary_harness', 'external_integrations',
+]);
+const BINDING_KEYS = new Set([
+  'provider_id', 'harness_id', 'allowed_models', 'allowed_reasoning_configurations',
+]);
+const SNAPSHOT_KEYS = new Set(['snapshot_id', 'expires_at', 'models']);
+const MODEL_KEYS = new Set([
+  'provider_id', 'model_id', 'actions', 'adjudication_priority',
+  'highest_reasoning_configuration', 'routing_priority', 'tier', 'natural_role',
+]);
+
+function assertClosedArtifactSchema(artifact) {
+  assertExactKeys(artifact, ARTIFACT_KEYS, 'artifact');
+  assertExactKeys(artifact.installation, INSTALLATION_KEYS, 'installation');
+  for (const binding of artifact.installation.enabled_providers ?? []) {
+    assertExactKeys(binding, BINDING_KEYS, 'enabled provider binding');
+  }
+  if (artifact.installation.primary_binding !== undefined) {
+    assertExactKeys(artifact.installation.primary_binding, new Set(['provider_id', 'harness_id']), 'primary_binding');
+  }
+  if (artifact.installation.external_integrations !== undefined) {
+    assertExactKeys(artifact.installation.external_integrations, new Set(['clickup']), 'external_integrations');
+  }
+  assertExactKeys(artifact.capability_snapshot, SNAPSHOT_KEYS, 'capability_snapshot');
+  for (const model of artifact.capability_snapshot.models ?? []) {
+    assertExactKeys(model, MODEL_KEYS, 'capability model');
+  }
+  const brainKeys = artifact.brain_read_capability?.status === 'configured'
+    ? new Set(['status', 'mode', 'policy_ref'])
+    : new Set(['status']);
+  assertExactKeys(artifact.brain_read_capability, brainKeys, 'brain_read_capability');
+}
+
 function readClock(clock) {
   if (typeof clock !== 'function') throw new ContractError('MISSING_CLOCK', 'a deterministic clock function is required');
   const result = clock();
@@ -127,6 +175,7 @@ export function doctorV2(artifact, { clock = () => new Date() } = {}) {
   const checks = [];
   try {
     assertObject(artifact, 'INVALID_ARTIFACT', 'artifact');
+    assertClosedArtifactSchema(artifact);
     if (artifact.schema_version !== INSTALLATION_SCHEMA_VERSION || artifact.artifact_type !== 'chati-installation') {
       throw new ContractError('UNSUPPORTED_INSTALLATION_ARTIFACT', 'expected a chati installation artifact v2');
     }
@@ -138,6 +187,12 @@ export function doctorV2(artifact, { clock = () => new Date() } = {}) {
     if (!Array.isArray(artifact.managed_paths) || !artifact.managed_paths.every((path) => ensureRelativePath(path))) {
       throw new ContractError('INVALID_MANAGED_PATH', 'managed_paths must be valid project-relative paths');
     }
+    if (!artifact.managed_paths.includes(INSTALLATION_ARTIFACT_PATH)) {
+      throw new ContractError('INVALID_MANAGED_PATH', `managed_paths must include ${INSTALLATION_ARTIFACT_PATH}`);
+    }
+    if (new Set(artifact.managed_paths).size !== artifact.managed_paths.length) {
+      throw new ContractError('DUPLICATE_MANAGED_PATH', 'managed_paths must be unique');
+    }
     checks.push({ name: 'artifact', status: 'pass', message: 'artifact schema and digest are valid' });
     checks.push({ name: 'selected-bindings', status: 'pass', message: 'only explicitly selected provider/harness bindings are present' });
     checks.push({ name: 'brain-capability', status: 'pass', message: 'Brain capability is absent or read-only' });