coder-config 0.40.1

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "coder-config",
+  "version": "0.40.1",
+  "description": "Configuration manager for AI coding tools - Claude Code, Gemini CLI, Codex CLI, Antigravity. Manage MCPs, rules, permissions, memory, and workstreams.",
+  "author": "regression.io",
+  "main": "config-loader.js",
+  "type": "commonjs",
+  "bin": {
+    "coder-config": "cli.js",
+    "claude-config": "cli.js"
+  },
+  "scripts": {
+    "start": "node cli.js ui",
+    "display": "node cli.js display",
+    "ui": "node cli.js ui",
+    "ui:dev": "cd ui && npm run dev",
+    "ui:build": "cd ui && npm run build",
+    "version:sync": "node scripts/sync-version.js",
+    "version:bump": "node scripts/sync-version.js --bump",
+    "build": "cd ui && npm install && npm run build",
+    "build:ci": "cd ui && npm install && npm run build",
+    "prepublishOnly": "npm run build",
+    "postinstall": "node scripts/postinstall.js",
+    "test": "node --test test/*.test.js",
+    "release": "./scripts/release.sh",
+    "tauri:prepare": "node scripts/tauri-prepare.js",
+    "tauri:dev": "npm run build && cargo tauri dev",
+    "tauri:build": "npm run tauri:prepare && cargo tauri build"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "anthropic",
+    "gemini",
+    "codex",
+    "openai",
+    "antigravity",
+    "ai",
+    "coding-assistant",
+    "configuration",
+    "mcp",
+    "model-context-protocol",
+    "cli"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@iarna/toml": "^3.0.0",
+    "js-yaml": "^4.1.1",
+    "node-pty": "^1.1.0",
+    "ws": "^8.19.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/regression-io/claude-config.git"
+  },
+  "bugs": {
+    "url": "https://github.com/regression-io/claude-config/issues"
+  },
+  "homepage": "https://github.com/regression-io/claude-config#readme",
+  "files": [
+    "cli.js",
+    "config-loader.js",
+    "lib/**",
+    "ui/server.cjs",
+    "ui/terminal-server.cjs",
+    "ui/routes/**",
+    "ui/dist/**",
+    "templates/**",
+    "shared/**",
+    "scripts/**",
+    "hooks/**",
+    "README.md"
+  ],
+  "devDependencies": {
+    "playwright": "^1.57.0"
+  }
+}

package/scripts/capture-screenshots.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+/**
+ * Capture screenshots for the tutorial using Playwright
+ * Run: node scripts/capture-screenshots.js
+ */
+
+const { chromium } = require('playwright');
+const path = require('path');
+const fs = require('fs');
+
+const OUTPUT_DIR = path.join(__dirname, '..', 'ui', 'public', 'tutorial');
+const BASE_URL = 'http://localhost:3333';
+
+// Ensure output directory exists
+if (!fs.existsSync(OUTPUT_DIR)) {
+  fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+}
+
+async function captureScreenshots() {
+  console.log('Launching browser...');
+  const browser = await chromium.launch({ headless: true });
+  const context = await browser.newContext({
+    viewport: { width: 1400, height: 900 },
+    deviceScaleFactor: 2, // Retina quality
+  });
+  const page = await context.newPage();
+
+  // Clear the welcome modal flag so we can capture it
+  await page.goto(BASE_URL);
+  await page.evaluate(() => localStorage.removeItem('claude-config-welcome-seen'));
+  await page.reload();
+  await page.waitForTimeout(1000);
+
+  // 1. Welcome Modal
+  console.log('Capturing: welcome-modal.png');
+  await page.waitForSelector('[role="dialog"]', { timeout: 5000 }).catch(() => {});
+  const welcomeModal = await page.$('[role="dialog"]');
+  if (welcomeModal) {
+    await welcomeModal.screenshot({ path: path.join(OUTPUT_DIR, 'welcome-modal.png') });
+    // Dismiss the modal
+    await page.click('button:has-text("Skip")');
+    await page.waitForTimeout(500);
+  }
+
+  // 2. Full sidebar
+  console.log('Capturing: sidebar.png');
+  const sidebar = await page.$('aside');
+  if (sidebar) {
+    await sidebar.screenshot({ path: path.join(OUTPUT_DIR, 'sidebar.png') });
+  }
+
+  // 3. Project Switcher
+  console.log('Capturing: project-switcher.png');
+  await page.click('button:has-text("Select project")').catch(() => {});
+  await page.waitForTimeout(300);
+  const projectDropdown = await page.$('[role="listbox"], [data-radix-popper-content-wrapper]');
+  if (projectDropdown) {
+    await projectDropdown.screenshot({ path: path.join(OUTPUT_DIR, 'project-switcher.png') });
+    await page.keyboard.press('Escape');
+  }
+
+  // 4. All Projects View
+  console.log('Capturing: projects-view.png');
+  await page.click('button:has-text("All Projects")');
+  await page.waitForTimeout(500);
+  const mainContent = await page.$('main');
+  if (mainContent) {
+    await mainContent.screenshot({ path: path.join(OUTPUT_DIR, 'projects-view.png') });
+  }
+
+  // 5. Project Explorer
+  console.log('Capturing: project-explorer.png');
+  await page.click('button:has-text("Project Explorer")');
+  await page.waitForTimeout(500);
+  await mainContent?.screenshot({ path: path.join(OUTPUT_DIR, 'project-explorer.png') });
+
+  // 6. MCP Registry
+  console.log('Capturing: mcp-registry.png');
+  await page.click('button:has-text("MCP Registry")');
+  await page.waitForTimeout(500);
+  await mainContent?.screenshot({ path: path.join(OUTPUT_DIR, 'mcp-registry.png') });
+
+  // 7. Plugins View
+  console.log('Capturing: plugins-view.png');
+  await page.click('button:has-text("Plugins")');
+  await page.waitForTimeout(500);
+  await mainContent?.screenshot({ path: path.join(OUTPUT_DIR, 'plugins-view.png') });
+
+  // 8. Memory View
+  console.log('Capturing: memory-view.png');
+  await page.click('button:has-text("Memory")');
+  await page.waitForTimeout(500);
+  await mainContent?.screenshot({ path: path.join(OUTPUT_DIR, 'memory-view.png') });
+
+  // Dismiss any toasts/overlays that might be blocking
+  await page.keyboard.press('Escape');
+  await page.waitForTimeout(300);
+
+  // 9. Claude Code Settings
+  console.log('Capturing: claude-settings.png');
+  await page.click('button:has-text("Claude Code")', { force: true });
+  await page.waitForTimeout(800);
+  const mainAfterClaude = await page.$('main');
+  await mainAfterClaude?.screenshot({ path: path.join(OUTPUT_DIR, 'claude-settings.png') });
+
+  // 10. Permissions section specifically
+  console.log('Capturing: permissions.png');
+  const permissionsSection = await page.$('[class*="space-y"]');
+  if (permissionsSection) {
+    await permissionsSection.screenshot({ path: path.join(OUTPUT_DIR, 'permissions.png') });
+  }
+
+  // 11. Workstreams View
+  console.log('Capturing: workstreams-view.png');
+  await page.click('button:has-text("Workstreams")', { force: true });
+  await page.waitForTimeout(800);
+  const mainAfterWorkstreams = await page.$('main');
+  await mainAfterWorkstreams?.screenshot({ path: path.join(OUTPUT_DIR, 'workstreams-view.png') });
+
+  // 12. Tutorial View
+  console.log('Capturing: tutorial-view.png');
+  await page.click('button:has-text("Tutorial")', { force: true });
+  await page.waitForTimeout(800);
+  const mainAfterTutorial = await page.$('main');
+  await mainAfterTutorial?.screenshot({ path: path.join(OUTPUT_DIR, 'tutorial-view.png') });
+
+  // 13. Header area
+  console.log('Capturing: header.png');
+  const header = await page.$('header');
+  if (header) {
+    await header.screenshot({ path: path.join(OUTPUT_DIR, 'header.png') });
+  }
+
+  await browser.close();
+  console.log(`\nScreenshots saved to: ${OUTPUT_DIR}`);
+  console.log('Files:', fs.readdirSync(OUTPUT_DIR).join(', '));
+}
+
+captureScreenshots().catch(err => {
+  console.error('Error capturing screenshots:', err);
+  process.exit(1);
+});

package/scripts/postinstall.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+
+/**
+ * Post-install script for coder-config
+ * Sets up default configuration if not present
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const home = os.homedir();
+const claudeDir = path.join(home, '.claude');
+const configPath = path.join(claudeDir, 'config.json');
+
+// Default configuration
+const defaultConfig = {
+  toolsDir: path.join(home, 'mcp-tools'),
+  registryPath: path.join(claudeDir, 'registry.json'),
+  ui: {
+    port: 3333,
+    openBrowser: true
+  }
+};
+
+// Create ~/.claude if it doesn't exist
+if (!fs.existsSync(claudeDir)) {
+  fs.mkdirSync(claudeDir, { recursive: true });
+  console.log('Created ~/.claude directory');
+}
+
+// Create config.json if it doesn't exist
+if (!fs.existsSync(configPath)) {
+  fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2) + '\n');
+  console.log('Created ~/.claude/config.json with defaults');
+  console.log(`  Tools directory: ${defaultConfig.toolsDir}`);
+}
+
+// Create default registry if it doesn't exist
+const registryPath = path.join(claudeDir, 'registry.json');
+if (!fs.existsSync(registryPath)) {
+  const defaultRegistry = {
+    mcpServers: {}
+  };
+  fs.writeFileSync(registryPath, JSON.stringify(defaultRegistry, null, 2) + '\n');
+  console.log('Created ~/.claude/registry.json');
+}
+
+// Test and rebuild node-pty if needed (prebuilds may not match Node version)
+function testNodePty() {
+  const { execFileSync } = require('child_process');
+  // Use subprocess to avoid require cache issues
+  const testScript = `
+    try {
+      const pty = require('node-pty');
+      const p = pty.spawn(process.platform === 'win32' ? 'cmd.exe' : '/bin/sh', ['-c', 'exit 0']);
+      p.kill();
+      process.exit(0);
+    } catch (e) {
+      process.exit(1);
+    }
+  `;
+  try {
+    execFileSync(process.execPath, ['-e', testScript], {
+      cwd: path.join(__dirname, '..'),
+      stdio: 'ignore'
+    });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function rebuildNodePty() {
+  const { execFileSync } = require('child_process');
+  const nodePtyPath = path.join(__dirname, '..', 'node_modules', 'node-pty');
+
+  if (!fs.existsSync(nodePtyPath)) {
+    console.log('node-pty not installed, skipping rebuild check');
+    return;
+  }
+
+  console.log('Testing node-pty compatibility...');
+
+  if (testNodePty()) {
+    console.log('node-pty working correctly');
+    return;
+  }
+
+  console.log('node-pty prebuild incompatible with Node ' + process.version);
+  console.log('Rebuilding from source (this may take a minute)...');
+
+  try {
+    // Use npm rebuild with build-from-source env var
+    execFileSync('npm', ['rebuild', 'node-pty'], {
+      cwd: path.join(__dirname, '..'),
+      stdio: 'inherit',
+      env: { ...process.env, npm_config_build_from_source: 'true' }
+    });
+
+    if (testNodePty()) {
+      console.log('node-pty rebuilt successfully');
+    } else {
+      console.warn('Warning: node-pty rebuild may have failed. Terminal features may not work.');
+      console.warn('Try: cd node_modules/node-pty && npm install --build-from-source');
+    }
+  } catch (e) {
+    console.warn('Warning: Could not rebuild node-pty:', e.message);
+    console.warn('Terminal features may not work. You may need build tools installed.');
+  }
+}
+
+rebuildNodePty();
+
+console.log('\n✓ Coder Config installed successfully!');
+console.log('');
+console.log('Commands:');
+console.log('  coder-config ui      Start the web UI');
+console.log('  coder-config init    Initialize a project');
+console.log('  coder-config --help  Show all commands');
+console.log('');
+console.log('Note: "claude-config" also works as an alias.\n');

package/scripts/release.sh

@@ -0,0 +1,71 @@
+#!/bin/bash
+# Auto-release script: bumps patch version, commits, tags, and pushes
+# Usage: ./scripts/release.sh "commit message"
+#        ./scripts/release.sh "commit message" --minor
+#        ./scripts/release.sh "commit message" --major
+
+set -e
+
+if [ -z "$1" ]; then
+  echo "Usage: $0 \"commit message\" [--minor|--major]"
+  exit 1
+fi
+
+MESSAGE="$1"
+BUMP_TYPE="${2:---patch}"
+
+# Get current version
+CURRENT_VERSION=$(node -p "require('./package.json').version")
+
+# Parse version
+IFS='.' read -r MAJOR MINOR PATCH <<< "$CURRENT_VERSION"
+
+# Bump based on type
+case "$BUMP_TYPE" in
+  --major)
+    MAJOR=$((MAJOR + 1))
+    MINOR=0
+    PATCH=0
+    ;;
+  --minor)
+    MINOR=$((MINOR + 1))
+    PATCH=0
+    ;;
+  --patch|*)
+    PATCH=$((PATCH + 1))
+    ;;
+esac
+
+NEW_VERSION="$MAJOR.$MINOR.$PATCH"
+TAG="v$NEW_VERSION"
+
+echo "Releasing $CURRENT_VERSION -> $NEW_VERSION"
+
+# Update version in package.json
+node -e "
+const fs = require('fs');
+const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+pkg.version = '$NEW_VERSION';
+fs.writeFileSync('package.json', JSON.stringify(pkg, null, 2) + '\n');
+"
+
+# Sync version to other files
+npm run version:sync
+
+# Stage all changes
+git add -A
+
+# Commit
+git commit -m "$MESSAGE
+
+Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>"
+
+# Tag
+git tag "$TAG"
+
+# Push with tags
+git push && git push --tags
+
+echo ""
+echo "✅ Released $TAG"
+echo "   CI will publish to npm automatically"

package/scripts/sync-version.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+/**
+ * Sync version from package.json to all version locations
+ * This ensures version is consistent across the codebase
+ *
+ * Usage:
+ *   node sync-version.js           # Sync current version
+ *   node sync-version.js --bump    # Bump patch version then sync
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const rootDir = path.join(__dirname, '..');
+const packageJsonPath = path.join(rootDir, 'package.json');
+const constantsPath = path.join(rootDir, 'lib', 'constants.js');
+const uiPackageJsonPath = path.join(rootDir, 'ui', 'package.json');
+const tauriConfigPath = path.join(rootDir, 'src-tauri', 'tauri.conf.json');
+
+// Read version from package.json (source of truth)
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+let version = packageJson.version;
+
+// Check for --bump flag
+const shouldBump = process.argv.includes('--bump');
+
+if (shouldBump) {
+  // Bump patch version
+  const parts = version.split('.');
+  parts[2] = parseInt(parts[2], 10) + 1;
+  version = parts.join('.');
+
+  // Update package.json with new version
+  packageJson.version = version;
+  fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf8');
+  console.log(`Bumped version: ${packageJson.version.replace(/\.\d+$/, `.${parseInt(parts[2]) - 1}`)} -> ${version}`);
+} else {
+  console.log(`Syncing version: ${version}`);
+}
+
+// Update lib/constants.js
+let constants = fs.readFileSync(constantsPath, 'utf8');
+const versionRegex = /const VERSION = ['"][^'"]+['"]/;
+
+if (versionRegex.test(constants)) {
+  const oldVersion = constants.match(versionRegex)[0];
+  constants = constants.replace(versionRegex, `const VERSION = '${version}'`);
+  fs.writeFileSync(constantsPath, constants, 'utf8');
+  console.log(`  lib/constants.js: ${oldVersion} -> const VERSION = '${version}'`);
+} else {
+  console.error('Warning: Could not find VERSION constant in lib/constants.js');
+}
+
+// Update ui/package.json
+if (fs.existsSync(uiPackageJsonPath)) {
+  const uiPackageJson = JSON.parse(fs.readFileSync(uiPackageJsonPath, 'utf8'));
+  if (uiPackageJson.version !== version) {
+    const oldVersion = uiPackageJson.version;
+    uiPackageJson.version = version;
+    fs.writeFileSync(uiPackageJsonPath, JSON.stringify(uiPackageJson, null, 2) + '\n', 'utf8');
+    console.log(`  ui/package.json: ${oldVersion} -> ${version}`);
+  }
+}
+
+// Update src-tauri/tauri.conf.json
+if (fs.existsSync(tauriConfigPath)) {
+  const tauriConfig = JSON.parse(fs.readFileSync(tauriConfigPath, 'utf8'));
+  if (tauriConfig.version !== version) {
+    const oldVersion = tauriConfig.version;
+    tauriConfig.version = version;
+    fs.writeFileSync(tauriConfigPath, JSON.stringify(tauriConfig, null, 2) + '\n', 'utf8');
+    console.log(`  src-tauri/tauri.conf.json: ${oldVersion} -> ${version}`);
+  }
+}
+
+console.log('Version sync complete!');