coder-config 0.40.1

package/ui/routes/subprojects.js

@@ -0,0 +1,208 @@
+/**
+ * Subprojects Routes
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Get subprojects for a directory
+ */
+function getSubprojectsForDir(manager, config, dir) {
+  const subprojects = [];
+
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith('.')) continue;
+
+      const fullPath = path.join(dir, entry.name);
+      const hasGit = fs.existsSync(path.join(fullPath, '.git'));
+
+      if (hasGit) {
+        const hasClaudeDir = fs.existsSync(path.join(fullPath, '.claude'));
+        const hasPackageJson = fs.existsSync(path.join(fullPath, 'package.json'));
+        const hasPyproject = fs.existsSync(path.join(fullPath, 'pyproject.toml'));
+        const hasCargoToml = fs.existsSync(path.join(fullPath, 'Cargo.toml'));
+
+        const configPath = path.join(fullPath, '.claude', 'mcps.json');
+        const hasConfig = fs.existsSync(configPath);
+        const mcpConfig = hasConfig ? manager.loadJson(configPath) : null;
+
+        subprojects.push({
+          dir: fullPath,
+          name: entry.name,
+          relativePath: entry.name,
+          hasConfig,
+          markers: {
+            claude: hasClaudeDir,
+            git: hasGit,
+            npm: hasPackageJson,
+            python: hasPyproject,
+            rust: hasCargoToml
+          },
+          mcpCount: mcpConfig ? (mcpConfig.include?.length || 0) + Object.keys(mcpConfig.mcpServers || {}).length : 0
+        });
+      }
+    }
+  } catch (e) {
+    // Permission denied or other errors - skip
+  }
+
+  // Add manual sub-projects from config
+  const manualSubprojects = config.manualSubprojects?.[dir] || [];
+  for (const subDir of manualSubprojects) {
+    if (subprojects.some(p => p.dir === subDir)) continue;
+    if (!fs.existsSync(subDir)) continue;
+
+    const name = path.basename(subDir);
+    const hasGit = fs.existsSync(path.join(subDir, '.git'));
+    const hasClaudeDir = fs.existsSync(path.join(subDir, '.claude'));
+    const hasPackageJson = fs.existsSync(path.join(subDir, 'package.json'));
+    const hasPyproject = fs.existsSync(path.join(subDir, 'pyproject.toml'));
+    const hasCargoToml = fs.existsSync(path.join(subDir, 'Cargo.toml'));
+
+    const configPath = path.join(subDir, '.claude', 'mcps.json');
+    const hasConfig = fs.existsSync(configPath);
+    const mcpConfig = hasConfig ? manager.loadJson(configPath) : null;
+
+    let relativePath = path.relative(dir, subDir);
+    if (relativePath.startsWith('..')) {
+      relativePath = subDir.replace(os.homedir(), '~');
+    }
+
+    subprojects.push({
+      dir: subDir,
+      name,
+      relativePath,
+      hasConfig,
+      isManual: true,
+      markers: {
+        claude: hasClaudeDir,
+        git: hasGit,
+        npm: hasPackageJson,
+        python: hasPyproject,
+        rust: hasCargoToml
+      },
+      mcpCount: mcpConfig ? (mcpConfig.include?.length || 0) + Object.keys(mcpConfig.mcpServers || {}).length : 0
+    });
+  }
+
+  // Filter out hidden sub-projects
+  const hiddenList = config.hiddenSubprojects?.[dir] || [];
+  return subprojects.filter(sub => !hiddenList.includes(sub.dir));
+}
+
+/**
+ * Add a manual sub-project
+ */
+function addManualSubproject(config, saveConfig, projectDir, subprojectDir) {
+  const resolvedProject = path.resolve(projectDir.replace(/^~/, os.homedir()));
+  const resolvedSubproject = path.resolve(subprojectDir.replace(/^~/, os.homedir()));
+
+  if (!fs.existsSync(resolvedSubproject)) {
+    return { success: false, error: 'Directory not found' };
+  }
+
+  if (!config.manualSubprojects) {
+    config.manualSubprojects = {};
+  }
+  if (!config.manualSubprojects[resolvedProject]) {
+    config.manualSubprojects[resolvedProject] = [];
+  }
+
+  if (!config.manualSubprojects[resolvedProject].includes(resolvedSubproject)) {
+    config.manualSubprojects[resolvedProject].push(resolvedSubproject);
+    saveConfig(config);
+  }
+
+  return { success: true, resolvedPath: resolvedSubproject };
+}
+
+/**
+ * Remove a manual sub-project
+ */
+function removeManualSubproject(config, saveConfig, projectDir, subprojectDir) {
+  const resolvedProject = path.resolve(projectDir.replace(/^~/, os.homedir()));
+  const resolvedSubproject = path.resolve(subprojectDir.replace(/^~/, os.homedir()));
+
+  if (config.manualSubprojects?.[resolvedProject]) {
+    config.manualSubprojects[resolvedProject] =
+      config.manualSubprojects[resolvedProject].filter(d => d !== resolvedSubproject);
+
+    if (config.manualSubprojects[resolvedProject].length === 0) {
+      delete config.manualSubprojects[resolvedProject];
+    }
+    saveConfig(config);
+  }
+
+  return { success: true };
+}
+
+/**
+ * Hide a sub-project
+ */
+function hideSubproject(config, saveConfig, projectDir, subprojectDir) {
+  const resolvedProject = path.resolve(projectDir.replace(/^~/, os.homedir()));
+  const resolvedSubproject = path.resolve(subprojectDir.replace(/^~/, os.homedir()));
+
+  if (!config.hiddenSubprojects) {
+    config.hiddenSubprojects = {};
+  }
+  if (!config.hiddenSubprojects[resolvedProject]) {
+    config.hiddenSubprojects[resolvedProject] = [];
+  }
+
+  if (!config.hiddenSubprojects[resolvedProject].includes(resolvedSubproject)) {
+    config.hiddenSubprojects[resolvedProject].push(resolvedSubproject);
+    saveConfig(config);
+  }
+
+  return { success: true };
+}
+
+/**
+ * Unhide a sub-project
+ */
+function unhideSubproject(config, saveConfig, projectDir, subprojectDir) {
+  const resolvedProject = path.resolve(projectDir.replace(/^~/, os.homedir()));
+  const resolvedSubproject = path.resolve(subprojectDir.replace(/^~/, os.homedir()));
+
+  if (config.hiddenSubprojects?.[resolvedProject]) {
+    config.hiddenSubprojects[resolvedProject] =
+      config.hiddenSubprojects[resolvedProject].filter(d => d !== resolvedSubproject);
+
+    if (config.hiddenSubprojects[resolvedProject].length === 0) {
+      delete config.hiddenSubprojects[resolvedProject];
+    }
+    saveConfig(config);
+  }
+
+  return { success: true };
+}
+
+/**
+ * Get hidden subprojects
+ */
+function getHiddenSubprojects(config, projectDir) {
+  const resolvedProject = path.resolve(projectDir.replace(/^~/, os.homedir()));
+  const hiddenList = config.hiddenSubprojects?.[resolvedProject] || [];
+
+  return hiddenList.map(dir => ({
+    dir,
+    name: path.basename(dir),
+    exists: fs.existsSync(dir)
+  }));
+}
+
+module.exports = {
+  getSubprojectsForDir,
+  addManualSubproject,
+  removeManualSubproject,
+  hideSubproject,
+  unhideSubproject,
+  getHiddenSubprojects,
+};

package/ui/routes/tool-sync.js

@@ -0,0 +1,127 @@
+/**
+ * Tool Sync Routes (Claude <-> Gemini <-> Antigravity)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Get the folder name for a tool
+ */
+function getToolFolder(tool) {
+  const folders = {
+    claude: '.claude',
+    gemini: '.gemini',
+    antigravity: '.agent'
+  };
+  return folders[tool] || '.claude';
+}
+
+/**
+ * Get preview of files that would be synced between tools
+ */
+function getSyncPreview(projectDir, source = 'claude', target = 'antigravity') {
+  const sourceFolder = getToolFolder(source);
+  const targetFolder = getToolFolder(target);
+  const sourceRulesDir = path.join(projectDir, sourceFolder, 'rules');
+  const targetRulesDir = path.join(projectDir, targetFolder, 'rules');
+
+  const result = {
+    source: { tool: source, folder: sourceFolder, rulesDir: sourceRulesDir },
+    target: { tool: target, folder: targetFolder, rulesDir: targetRulesDir },
+    files: [],
+    sourceExists: fs.existsSync(sourceRulesDir),
+    targetExists: fs.existsSync(targetRulesDir),
+  };
+
+  if (!result.sourceExists) {
+    return { ...result, error: `Source rules folder not found: ${sourceRulesDir}` };
+  }
+
+  // Get source files
+  const sourceFiles = fs.readdirSync(sourceRulesDir).filter(f => f.endsWith('.md'));
+
+  // Get target files for comparison
+  const targetFiles = result.targetExists
+    ? fs.readdirSync(targetRulesDir).filter(f => f.endsWith('.md'))
+    : [];
+
+  for (const file of sourceFiles) {
+    const sourcePath = path.join(sourceRulesDir, file);
+    const targetPath = path.join(targetRulesDir, file);
+    const sourceContent = fs.readFileSync(sourcePath, 'utf8');
+    const existsInTarget = targetFiles.includes(file);
+
+    let status = 'new';
+    let targetContent = null;
+
+    if (existsInTarget) {
+      targetContent = fs.readFileSync(targetPath, 'utf8');
+      status = sourceContent === targetContent ? 'identical' : 'different';
+    }
+
+    result.files.push({
+      name: file,
+      sourcePath,
+      targetPath,
+      status,
+      sourceSize: sourceContent.length,
+      targetSize: targetContent?.length || 0,
+    });
+  }
+
+  return result;
+}
+
+/**
+ * Sync rules between tools
+ */
+function syncRules(projectDir, source = 'claude', target = 'antigravity', files = null) {
+  const sourceFolder = getToolFolder(source);
+  const targetFolder = getToolFolder(target);
+  const sourceRulesDir = path.join(projectDir, sourceFolder, 'rules');
+  const targetRulesDir = path.join(projectDir, targetFolder, 'rules');
+
+  if (!fs.existsSync(sourceRulesDir)) {
+    return { success: false, error: `Source rules folder not found: ${sourceRulesDir}` };
+  }
+
+  // Create target rules directory if it doesn't exist
+  if (!fs.existsSync(targetRulesDir)) {
+    fs.mkdirSync(targetRulesDir, { recursive: true });
+  }
+
+  // Get files to sync
+  const sourceFiles = fs.readdirSync(sourceRulesDir).filter(f => f.endsWith('.md'));
+  const filesToSync = files ? sourceFiles.filter(f => files.includes(f)) : sourceFiles;
+
+  const results = {
+    success: true,
+    synced: [],
+    skipped: [],
+    errors: [],
+  };
+
+  for (const file of filesToSync) {
+    try {
+      const sourcePath = path.join(sourceRulesDir, file);
+      const targetPath = path.join(targetRulesDir, file);
+      const content = fs.readFileSync(sourcePath, 'utf8');
+      fs.writeFileSync(targetPath, content);
+      results.synced.push(file);
+    } catch (err) {
+      results.errors.push({ file, error: err.message });
+    }
+  }
+
+  if (results.errors.length > 0) {
+    results.success = results.synced.length > 0;
+  }
+
+  return results;
+}
+
+module.exports = {
+  getSyncPreview,
+  syncRules,
+};

package/ui/routes/updates.js

@@ -0,0 +1,339 @@
+/**
+ * Updates Routes
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { execSync } = require('child_process');
+
+/**
+ * Get version from file (checks both config-loader.js and lib/constants.js)
+ */
+function getVersionFromFile(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+
+    // First try the file directly
+    let content = fs.readFileSync(filePath, 'utf8');
+    let match = content.match(/const VERSION = ['"]([^'"]+)['"]/);
+    if (match) return match[1];
+
+    // If not found and this is config-loader.js, check lib/constants.js
+    if (filePath.endsWith('config-loader.js')) {
+      const constantsPath = path.join(path.dirname(filePath), 'lib', 'constants.js');
+      if (fs.existsSync(constantsPath)) {
+        content = fs.readFileSync(constantsPath, 'utf8');
+        match = content.match(/const VERSION = ['"]([^'"]+)['"]/);
+        if (match) return match[1];
+      }
+    }
+
+    return null;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Fetch npm version and verify it's installable
+ * Returns version only if the tarball is accessible (CDN propagated)
+ */
+function fetchNpmVersion() {
+  return new Promise((resolve) => {
+    const url = 'https://registry.npmjs.org/@regression-io/claude-config/latest';
+    const req = https.get(url, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          const version = parsed.version;
+          const tarballUrl = parsed.dist?.tarball;
+
+          if (!version || !tarballUrl) {
+            console.log('[update-check] npm registry response missing version or tarball');
+            resolve(null);
+            return;
+          }
+
+          // Verify tarball is accessible (HEAD request)
+          const tarball = new URL(tarballUrl);
+          const options = {
+            hostname: tarball.hostname,
+            path: tarball.pathname,
+            method: 'HEAD'
+          };
+
+          const verifyReq = https.request(options, (verifyRes) => {
+            // 200 = accessible, anything else = not yet propagated
+            if (verifyRes.statusCode === 200) {
+              resolve(version);
+            } else {
+              console.log(`[update-check] tarball not accessible (status ${verifyRes.statusCode})`);
+              resolve(null);
+            }
+          });
+          verifyReq.setTimeout(5000, () => {
+            console.log('[update-check] tarball verification timed out');
+            verifyReq.destroy();
+            resolve(null);
+          });
+          verifyReq.on('error', (e) => {
+            console.log('[update-check] tarball verification error:', e.message);
+            resolve(null);
+          });
+          verifyReq.end();
+        } catch (e) {
+          console.log('[update-check] failed to parse npm response:', e.message);
+          resolve(null);
+        }
+      });
+    });
+    req.setTimeout(10000, () => {
+      console.log('[update-check] npm registry request timed out');
+      req.destroy();
+      resolve(null);
+    });
+    req.on('error', (e) => {
+      console.log('[update-check] npm registry error:', e.message);
+      resolve(null);
+    });
+  });
+}
+
+/**
+ * Check if source is newer version
+ */
+function isNewerVersion(source, installed) {
+  if (!source || !installed) return false;
+
+  const parseVersion = (v) => v.split('.').map(n => parseInt(n, 10) || 0);
+  const s = parseVersion(source);
+  const i = parseVersion(installed);
+
+  for (let j = 0; j < Math.max(s.length, i.length); j++) {
+    const sv = s[j] || 0;
+    const iv = i[j] || 0;
+    if (sv > iv) return true;
+    if (sv < iv) return false;
+  }
+  return false;
+}
+
+/**
+ * Check for updates
+ */
+async function checkForUpdates(manager, dirname) {
+  // Get current installed version
+  const installedVersion = getVersionFromFile(
+    path.join(dirname, '..', 'config-loader.js')
+  );
+
+  // Check npm for latest version
+  const npmVersion = await fetchNpmVersion();
+
+  console.log(`[update-check] installed: ${installedVersion}, npm: ${npmVersion}`);
+
+  if (npmVersion && isNewerVersion(npmVersion, installedVersion)) {
+    console.log('[update-check] update available');
+    return {
+      updateAvailable: true,
+      installedVersion,
+      latestVersion: npmVersion,
+      sourceVersion: npmVersion, // legacy alias for v0.37.0 compatibility
+      updateMethod: 'npm',
+      installDir: manager.installDir
+    };
+  }
+
+  // No update available from npm
+  return {
+    updateAvailable: false,
+    installedVersion,
+    latestVersion: npmVersion || installedVersion,
+    sourceVersion: npmVersion || installedVersion, // legacy alias for v0.37.0 compatibility
+    installDir: manager.installDir
+  };
+}
+
+/**
+ * Perform npm update
+ */
+async function performNpmUpdate(targetVersion) {
+  const maxRetries = 3;
+  const retryDelayMs = 5000;
+
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      // Use npm install @latest instead of npm update for reliable updates
+      execSync('npm install -g @regression-io/claude-config@latest', {
+        stdio: 'pipe',
+        timeout: 120000
+      });
+
+      return {
+        success: true,
+        updateMethod: 'npm',
+        newVersion: targetVersion || 'latest',
+        message: 'Updated via npm. Please restart the UI to use the new version.'
+      };
+    } catch (error) {
+      const isEtarget = error.message.includes('ETARGET') || error.message.includes('No matching version');
+
+      // Retry on ETARGET (CDN propagation delay) if we have retries left
+      if (isEtarget && attempt < maxRetries) {
+        await new Promise(resolve => setTimeout(resolve, retryDelayMs));
+        continue;
+      }
+
+      // Final attempt failed or non-retryable error
+      if (isEtarget) {
+        return {
+          success: false,
+          error: `Version not yet available on npm CDN. Please try again in a minute. (${error.message})`
+        };
+      }
+      return { success: false, error: error.message };
+    }
+  }
+}
+
+/**
+ * Copy directory recursively
+ */
+function copyDirRecursive(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Perform local update
+ */
+function performLocalUpdate(sourcePath, manager) {
+  try {
+    const installDir = manager.installDir;
+
+    if (!fs.existsSync(sourcePath)) {
+      return { success: false, error: 'Source path not found' };
+    }
+
+    const sourceLoaderPath = path.join(sourcePath, 'config-loader.js');
+    if (!fs.existsSync(sourceLoaderPath)) {
+      return { success: false, error: 'config-loader.js not found in source' };
+    }
+
+    const updated = [];
+
+    // Copy core files
+    const filesToCopy = [
+      { src: 'config-loader.js', dest: 'config-loader.js' },
+      { src: 'shared/mcp-registry.json', dest: 'shared/mcp-registry.json' },
+      { src: 'shell/claude-config.zsh', dest: 'shell/claude-config.zsh' },
+      { src: 'bin/claude-config', dest: 'bin/claude-config' }
+    ];
+
+    for (const { src, dest } of filesToCopy) {
+      const srcPath = path.join(sourcePath, src);
+      const destPath = path.join(installDir, dest);
+
+      if (fs.existsSync(srcPath)) {
+        const destDir = path.dirname(destPath);
+        if (!fs.existsSync(destDir)) {
+          fs.mkdirSync(destDir, { recursive: true });
+        }
+        fs.copyFileSync(srcPath, destPath);
+        updated.push(src);
+      }
+    }
+
+    // Copy UI dist files
+    const uiDistSourceDir = path.join(sourcePath, 'ui', 'dist');
+    const uiDistDestDir = path.join(installDir, 'ui', 'dist');
+    if (fs.existsSync(uiDistSourceDir)) {
+      copyDirRecursive(uiDistSourceDir, uiDistDestDir);
+      updated.push('ui/dist/');
+    }
+
+    // Copy UI server files
+    const uiServerFiles = ['server.cjs', 'terminal-server.cjs'];
+    for (const file of uiServerFiles) {
+      const uiServerSrc = path.join(sourcePath, 'ui', file);
+      const uiServerDest = path.join(installDir, 'ui', file);
+      if (fs.existsSync(uiServerSrc)) {
+        const uiDir = path.dirname(uiServerDest);
+        if (!fs.existsSync(uiDir)) {
+          fs.mkdirSync(uiDir, { recursive: true });
+        }
+        fs.copyFileSync(uiServerSrc, uiServerDest);
+        updated.push('ui/' + file);
+      }
+    }
+
+    // Copy templates
+    const templatesSourceDir = path.join(sourcePath, 'templates');
+    const templatesDestDir = path.join(installDir, 'templates');
+    if (fs.existsSync(templatesSourceDir)) {
+      copyDirRecursive(templatesSourceDir, templatesDestDir);
+      updated.push('templates/');
+    }
+
+    // Make bin script executable
+    const binPath = path.join(installDir, 'bin', 'claude-config');
+    if (fs.existsSync(binPath)) {
+      fs.chmodSync(binPath, '755');
+    }
+
+    const newVersion = getVersionFromFile(path.join(installDir, 'config-loader.js'));
+
+    return {
+      success: true,
+      updateMethod: 'local',
+      updated,
+      newVersion
+    };
+
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Perform update
+ */
+async function performUpdate(options, manager) {
+  const { updateMethod, sourcePath, targetVersion } = options;
+
+  if (updateMethod === 'npm') {
+    return await performNpmUpdate(targetVersion);
+  }
+
+  if (sourcePath) {
+    return performLocalUpdate(sourcePath, manager);
+  }
+
+  return { success: false, error: 'No update method specified' };
+}
+
+module.exports = {
+  getVersionFromFile,
+  fetchNpmVersion,
+  isNewerVersion,
+  checkForUpdates,
+  performUpdate,
+  performNpmUpdate,
+  performLocalUpdate,
+};