0xray 3.4.1 → 3.4.3

package/scripts/node/release.js

@@ -1,159 +1,17 @@
 #!/usr/bin/env node
-
 /**
- * One-command release: bump → build → commit → publish → push
- *
- * Usage:
- *   node scripts/node/release.js          # patch bump
- *   node scripts/node/release.js minor    # minor bump
- *   node scripts/node/release.js major    # major bump
- *   node scripts/node/release.js --dry-run # preview without publishing
+ * @deprecated Use release.mjs — npm run release:patch|minor|major
  */
-
 import { execSync } from "child_process";
-import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const rootDir = path.resolve(__dirname, "../..");
 
-const RED = "\x1b[31m";
-const GREEN = "\x1b[32m";
-const YELLOW = "\x1b[33m";
-const BLUE = "\x1b[36m";
-const BOLD = "\x1b[1m";
-const RESET = "\x1b[0m";
-
-const dryRun = process.argv.includes("--dry-run");
-const bumpType = process.argv.find((a) => ["patch", "minor", "major"].includes(a)) || "patch";
-
-function run(cmd, label) {
-  console.log(`${BLUE}▸ ${label}${RESET}`);
-  try {
-    execSync(cmd, { cwd: rootDir, stdio: "pipe", encoding: "utf-8" });
-    console.log(`${GREEN}  ✓ ${label} done${RESET}`);
-    return true;
-  } catch (e) {
-    console.log(`${RED}  ✗ ${label} failed: ${e.message?.slice(0, 200) || e}${RESET}`);
-    return false;
-  }
-}
-
-function runInherit(cmd, label) {
-  console.log(`${BLUE}▸ ${label}${RESET}`);
-  try {
-    execSync(cmd, { cwd: rootDir, stdio: "inherit" });
-    console.log(`${GREEN}  ✓ ${label} done${RESET}`);
-    return true;
-  } catch (e) {
-    console.log(`${RED}  ✗ ${label} failed${RESET}`);
-    return false;
-  }
-}
-
-function main() {
-  const pkg = JSON.parse(fs.readFileSync(path.join(rootDir, "package.json"), "utf-8"));
-  const currentVersion = pkg.version;
-
-  const parts = currentVersion.split(".").map(Number);
-  if (bumpType === "major") parts[0]++;
-  else if (bumpType === "minor") parts[1]++;
-  else parts[2]++;
-  if (bumpType === "major" || bumpType === "minor") parts[2] = 0;
-  const nextVersion = parts.join(".");
-
-  console.log(`\n${BOLD}${BLUE}🚀 xray Release${RESET}`);
-  console.log(`${BOLD}  ${currentVersion} → ${nextVersion} (${bumpType})${RESET}\n`);
-
-  if (dryRun) {
-    console.log(`${YELLOW}DRY RUN — no changes will be made${RESET}\n`);
-  }
-
-  // Step 1: Tests
-  if (!runInherit("npm run test:comprehensive", "Tests")) {
-    process.exit(1);
-  }
-
-  // Step 2: Version bump (version:sync runs automatically via preversion hook)
-  if (!dryRun) {
-    if (!run(`npm version ${bumpType} --no-git-tag-version`, `Bump to ${nextVersion}`)) {
-      process.exit(1);
-    }
-  }
-
-  // Step 3: Build
-  if (!run("npm run build", "Build")) {
-    process.exit(1);
-  }
-
-  // Step 4: Commit
-  if (!dryRun) {
-    if (!run("git add -A", "Stage changes")) {
-      process.exit(1);
-    }
-    const commitMsg = `v${nextVersion}`;
-    try {
-      execSync(`git commit -m "${commitMsg}"`, { cwd: rootDir, stdio: "pipe", encoding: "utf-8" });
-      console.log(`${GREEN}  ✓ Committed: ${commitMsg}${RESET}`);
-    } catch (e) {
-      const output = e.stdout || e.stderr || "";
-      if (output.includes("nothing to commit")) {
-        console.log(`${YELLOW}  ⚠ Nothing to commit${RESET}`);
-      } else if (output.includes("BLOCKED")) {
-        // Pre-commit hook blocked — likely version compliance
-        // Try with --no-verify since we manage versions ourselves
-        console.log(`${YELLOW}  ⚠ Pre-commit blocked, retrying with --no-verify...${RESET}`);
-        try {
-          execSync(`git commit --no-verify -m "${commitMsg}"`, { cwd: rootDir, stdio: "pipe", encoding: "utf-8" });
-          console.log(`${GREEN}  ✓ Committed (no-verify): ${commitMsg}${RESET}`);
-        } catch (e2) {
-          console.log(`${RED}  ✗ Commit failed: ${e2.message?.slice(0, 200)}${RESET}`);
-          process.exit(1);
-        }
-      } else {
-        console.log(`${RED}  ✗ Commit failed: ${output.slice(0, 200)}${RESET}`);
-        process.exit(1);
-      }
-    }
-  }
-
-  // Step 5: Publish
-  if (!dryRun) {
-    console.log(`${BLUE}▸ Publishing to npm${RESET}`);
-    try {
-      execSync("npm publish --access public", { cwd: rootDir, stdio: "inherit" });
-      console.log(`${GREEN}  ✓ Published xray@${nextVersion}${RESET}`);
-    } catch (e) {
-      const errMsg = (e.stderr?.toString() || "") + (e.message || "");
-      if (errMsg.includes("previously published")) {
-        console.log(`${GREEN}  ✓ Already published xray@${nextVersion}${RESET}`);
-      } else {
-        console.log(`${RED}  ✗ Publish failed. Trying with --ignore-scripts...${RESET}`);
-        try {
-          execSync("npm publish --access public --ignore-scripts", { cwd: rootDir, stdio: "pipe", encoding: "utf-8" });
-          console.log(`${GREEN}  ✓ Published xray@${nextVersion} (ignore-scripts)${RESET}`);
-        } catch (e2) {
-          const errMsg2 = (e2.stderr?.toString() || "") + (e2.message || "");
-          if (errMsg2.includes("previously published")) {
-            console.log(`${GREEN}  ✓ Already published xray@${nextVersion}${RESET}`);
-          } else {
-            console.log(`${RED}  ✗ Publish failed: ${errMsg2.slice(0, 200)}${RESET}`);
-            process.exit(1);
-          }
-        }
-      }
-    }
-  }
-
-  // Step 6: Push
-  if (!dryRun) {
-    if (!run("git push", "Push to remote")) {
-      process.exit(1);
-    }
-  }
+console.error("\n⚠️  release.js is deprecated. Use: npm run release:patch (release.mjs)\n");
 
-  console.log(`\n${BOLD}${GREEN}✅ Released xray@${nextVersion}${RESET}\n`);
-}
+const bump = process.argv.find((a) => ["patch", "minor", "major"].includes(a)) || "patch";
+const dry = process.argv.includes("--dry-run") ? " --dry-run" : "";
 
-main();
+execSync(`node scripts/node/release.mjs ${bump}${dry}`, { cwd: rootDir, stdio: "inherit" });

package/scripts/node/release.mjs

@@ -1,213 +1,138 @@
 #!/usr/bin/env node
 
 /**
- * Proper Release Script for xray
- * 
- * Safe release process that:
- * 1. Bumps version
- * 2. Commits version changes
- * 3. Creates git tag
- * 4. Pushes to origin
- * 5. Builds (stops on error)
- * 6. Publishes to npm (only if build succeeds)
- * 7. Generates release tweet
- * 
+ * Canonical 0xRay release script.
+ *
+ * 1. Bump version from npm registry baseline (reconcile-version)
+ * 2. Release gate once (build + test + consumer smoke)
+ * 3. Update CHANGELOG / README / AGENTS / docs (version-manager --artifacts-only)
+ * 4. Commit release artifacts → push
+ * 5. Verify gate (reconcile + git + release docs + smoke)
+ * 6. Tag → push tag → npm publish
+ *
  * Usage:
  *   npm run release:patch
- *   npm run release:minor  
+ *   npm run release:minor
  *   npm run release:major
+ *   node scripts/node/release.mjs patch --dry-run
  */
 
-import { execSync } from 'child_process';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { getReleaseArtifactPaths } from "./version-manager.mjs";
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const rootDir = process.cwd();
-
-function getCurrentVersion() {
-  const pkg = JSON.parse(fs.readFileSync(path.join(rootDir, 'package.json'), 'utf-8'));
-  return pkg.version;
-}
-
-function parseVersion(version) {
-  const parts = version.split('.');
-  return {
-    major: parseInt(parts[0], 10),
-    minor: parseInt(parts[1], 10),
-    patch: parseInt(parts[2], 10)
-  };
+const args = process.argv.slice(2);
+const dryRun = args.includes("--dry-run");
+const releaseType = args.find((a) => ["major", "minor", "patch"].includes(a)) || "patch";
+
+function run(cmd, label) {
+  console.log(`\n> ${cmd}`);
+  if (dryRun) {
+    console.log(`  (dry-run skip: ${label})`);
+    return;
+  }
+  execSync(cmd, { cwd: rootDir, stdio: "inherit", encoding: "utf-8" });
 }
 
-function bumpVersion(current, type) {
-  const v = parseVersion(current);
-  
-  switch (type) {
-    case 'major':
-      v.major++;
-      v.minor = 0;
-      v.patch = 0;
-      break;
-    case 'minor':
-      v.minor++;
-      v.patch = 0;
-      break;
-    case 'patch':
-      v.patch++;
-      break;
-    default:
-      return type;
-  }
-  
-  return `${v.major}.${v.minor}.${v.patch}`;
+function readVersion() {
+  return JSON.parse(fs.readFileSync(path.join(rootDir, "package.json"), "utf-8")).version;
 }
 
-function runCommand(cmd, errorMsg) {
-  try {
-    console.log(`\n> ${cmd}`);
-    execSync(cmd, { 
-      cwd: rootDir, 
-      stdio: 'inherit',
-      encoding: 'utf-8'
-    });
-  } catch (error) {
-    console.error(`\n❌ ${errorMsg}`);
-    console.error(error.message);
-    process.exit(1);
-  }
+function currentBranch() {
+  return execSync("git rev-parse --abbrev-ref HEAD", { cwd: rootDir, encoding: "utf-8" }).trim();
 }
 
 async function main() {
-  const args = process.argv.slice(2);
-  const releaseType = args[0] || 'patch';
-  
-  if (!['major', 'minor', 'patch'].includes(releaseType)) {
-    console.error('Usage: node scripts/node/release.mjs [major|minor|patch]');
+  if (!["major", "minor", "patch"].includes(releaseType)) {
+    console.error("Usage: node scripts/node/release.mjs [patch|minor|major] [--dry-run]");
     process.exit(1);
   }
 
-  console.log('╔════════════════════════════════════════════════════════╗');
-  console.log('║        🚀 xray Release Script                          ║');
-  console.log('╚════════════════════════════════════════════════════════╝');
-  
-  const currentVersion = getCurrentVersion();
-  console.log(`\n📌 Current version (local): ${currentVersion}`);
-
-  // Better design: always compute target from the *published* version on npm
-  // This removes the brittle "must be exactly one ahead" problem.
-  let publishedVersion;
-  try {
-    publishedVersion = execSync('npm view 0xray version', { encoding: 'utf-8' }).trim();
-    console.log(`📌 Latest published on npm: ${publishedVersion}`);
-  } catch {
-    publishedVersion = '0.0.0';
-    console.log('⚠️  Could not fetch published version from npm (using 0.0.0)');
-  }
+  console.log("╔════════════════════════════════════════════════════════╗");
+  console.log("║        🚀 0xRay Release (canonical)                   ║");
+  console.log("╚════════════════════════════════════════════════════════╝");
+  if (dryRun) console.log("\n⚠️  DRY RUN — no writes, commits, tags, or publish\n");
 
-  const targetVersion = bumpVersion(publishedVersion, releaseType);
-  console.log(`📌 Target version (computed from registry): ${targetVersion}`);
-  console.log(`📌 Release type: ${releaseType}`);
-
-  // Safety: if local is somehow ahead of what we computed, warn but continue
-  if (currentVersion !== targetVersion) {
-    console.log(`⚠️  Local version (${currentVersion}) differs from computed target. Using computed target ${targetVersion}.`);
+  // 1. Version bump from npm SSOT
+  console.log(`\n📦 Step 1: Bump ${releaseType} from npm baseline`);
+  if (dryRun) {
+    execSync(`node scripts/node/reconcile-version.mjs ${releaseType}`, { cwd: rootDir, stdio: "inherit" });
+  } else {
+    run(`node scripts/node/reconcile-version.mjs ${releaseType} --apply`, "version bump");
   }
-
-  const newVersion = targetVersion;
-
-  // Step 1: Build
-  console.log('\n📦 Step 1: Building...');
-  runCommand('npm run build', 'Build failed');
-
-  // Step 2: Update package.json
-  console.log('\n📦 Step 2: Updating version in package.json...');
-  const pkgPath = path.join(rootDir, 'package.json');
-  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-  pkg.version = newVersion;
-  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
-
-  // Step 2.5: Sync version across config and doc files
-  console.log('\n📦 Step 2.5: Syncing version across config and docs...');
-  try {
-    execSync('node scripts/node/sync-versions.mjs --apply', { cwd: rootDir, stdio: 'inherit' });
-  } catch (e) {
-    console.log('⚠️  Version sync had issues (non-blocking)');
+  const newVersion = dryRun
+    ? execSync(`node scripts/node/reconcile-version.mjs ${releaseType} --print-target`, {
+        cwd: rootDir,
+        encoding: "utf-8",
+      }).trim()
+    : readVersion();
+  console.log(`📌 Release version: ${newVersion}`);
+
+  // 2. Single gate before commit
+  console.log("\n📦 Step 2: Release gate (build + test + smoke)");
+  run("node scripts/node/release-gate.mjs", "release gate");
+
+  // 3. Changelog + doc artifacts
+  console.log("\n📦 Step 3: Release artifacts (CHANGELOG, README, AGENTS, docs)");
+  run("node scripts/node/version-manager.mjs --artifacts-only", "release artifacts");
+
+  // 4. Commit + push
+  console.log("\n📦 Step 4: Commit & push");
+  const releaseFiles = getReleaseArtifactPaths();
+  if (!dryRun) {
+    run(`git add ${releaseFiles.join(" ")}`, "git add");
+    try {
+      execSync(`git commit --no-verify -m "release: v${newVersion}"`, { cwd: rootDir, stdio: "inherit" });
+    } catch (e) {
+      const out = String(e.stdout || e.stderr || "");
+      if (!out.includes("nothing to commit")) throw e;
+      console.log("ℹ️  Nothing to commit (release files unchanged)");
+    }
+  } else {
+    console.log(`  would: git add ${releaseFiles.join(" ")} && git commit -m "release: v${newVersion}"`);
   }
 
-  // Step 3: Commit
-  console.log('\n📦 Step 3: Committing version bump...');
-  runCommand('git add -A', 'git add failed');
-  runCommand(`git commit --no-verify -m "release: v${newVersion}"`, 'git commit failed');
-
-  // Step 4: Tag
-  console.log('\n📦 Step 4: Creating git tag...');
-  try {
-    execSync(
-      `git tag -a v${newVersion} -m "Release v${newVersion}"`,
-      { cwd: rootDir, stdio: 'inherit' }
-    );
+  const branch = currentBranch();
+  run(`git push origin ${branch}`, "git push");
+
+  // 5. Post-push verify before tag
+  console.log("\n📦 Step 5: Verify gate (reconcile + git + smoke)");
+  run("node scripts/node/release-gate.mjs --verify-only", "verify gate");
+
+  // 6. Tag
+  console.log("\n📦 Step 6: Tag");
+  if (!dryRun) {
+    execSync(`git tag -a v${newVersion} -m "Release v${newVersion}"`, { cwd: rootDir, stdio: "inherit" });
     console.log(`✅ Created tag v${newVersion}`);
-  } catch (error) {
-    console.log('⚠️  Tag may already exist');
+  } else {
+    console.log(`  would: git tag -a v${newVersion}`);
   }
-  
-  // Step 5: Push
-  console.log('\n📦 Step 5: Pushing to origin...');
-  runCommand('git push origin main', 'Failed to push to origin');
-  runCommand(`git push origin v${newVersion}`, 'Failed to push tag');
-
-  // Step 6: Publish to npm
-  console.log('\n📦 Step 6: Publishing to npm...');
-  runCommand('npm publish --access public', 'npm publish failed');
-  console.log(`✅ Published xray@${newVersion} to npm`);
-
-  console.log('\n╔════════════════════════════════════════════════════════╗');
-  console.log('║        ✅ Release Complete!                            ║');
-  console.log('╚════════════════════════════════════════════════════════╝');
-  console.log(`\n📦 Package: xray@${newVersion}`);
-  console.log(`🏷  Tag: v${newVersion}`);
-
-  // Generate tweet
-  const tweetPath = path.join(rootDir, 'tweets', `v${newVersion}.md`);
-  const tweetDir = path.join(rootDir, 'tweets');
-  if (!fs.existsSync(tweetDir)) fs.mkdirSync(tweetDir, { recursive: true });
-
-  const recentCommits = (() => {
-    try {
-      const prevTag = execSync('git describe --tags --abbrev=0 HEAD~5 2>/dev/null || echo "HEAD~10"', { cwd: rootDir, encoding: 'utf-8' }).trim();
-      return execSync(`git log ${prevTag}..HEAD --oneline`, { cwd: rootDir, encoding: 'utf-8' }).trim();
-    } catch {
-      try { return execSync('git log -10 --oneline', { cwd: rootDir, encoding: 'utf-8' }).trim(); }
-      catch { return '(could not read commits)'; }
+  run(`git push origin v${newVersion}`, "push tag");
+
+  // 7. Publish
+  console.log("\n📦 Step 7: npm publish");
+  run("npm publish --access public", "npm publish");
+
+  console.log("\n╔════════════════════════════════════════════════════════╗");
+  console.log("║        ✅ Release Complete!                            ║");
+  console.log("╚════════════════════════════════════════════════════════╝");
+  if (!dryRun) {
+    console.log(`\n📦 0xray@${newVersion}  🏷  v${newVersion}\n`);
+    const tweetPath = path.join(rootDir, "tweets", `v${newVersion}.md`);
+    if (!fs.existsSync(tweetPath)) {
+      fs.mkdirSync(path.join(rootDir, "tweets"), { recursive: true });
+      fs.writeFileSync(
+        tweetPath,
+        `🎉 0xRay v${newVersion} is LIVE - {THEME}!\n...\n\`\`\`\nnpm install 0xray@latest\n\`\`\`\n`,
+      );
+      console.log(`📝 Tweet template: tweets/v${newVersion}.md`);
     }
-  })();
-
-  const tweet = `🎉 xray v${newVersion} is LIVE - {THEME}!
-{EMOJI} {feature - consumer benefit}
-{EMOJI} {feature - consumer benefit}
-{EMOJI} {feature - consumer benefit}
-{EMOJI} {feature - consumer benefit}
-{EMOJI} {feature - consumer benefit}
-\`\`\`
-npm install xray@latest
-\`\`\`
-What xray is: {one sentence positioning}
-#xray #AIOps #DevTools #SelfHealing #NPM`;
-
-  if (!fs.existsSync(tweetPath)) {
-    fs.writeFileSync(tweetPath, tweet);
-    console.log(`\n📝 Tweet template saved to tweets/v${newVersion}.md — FILL IN THE BLANKS`);
-  } else {
-    console.log(`\n📝 Tweet already exists at tweets/v${newVersion}.md`);
   }
-
-  console.log(`\n📋 Recent commits for tweet bullets:\n${recentCommits.split('\n').map(l => '   ' + l).join('\n')}`);
-  console.log('\n📖 Tweet format guide: tweets/FORMAT.md');
-  console.log('\n🎉 All done!\n');
 }
 
-main().catch(error => {
-  console.error('\n❌ Release failed:', error.message);
+main().catch((err) => {
+  console.error("\n❌ Release failed:", err.message);
   process.exit(1);
 });

package/scripts/node/setup.cjs

@@ -6,7 +6,11 @@ const path = require("path");
 const packageRoot = path.join(__dirname, "..", "..");
 const homeDir = require("os").homedir();
 
-const { resolveConsumerTargetDir, isConsumerInstall } = require("./install-bridges.cjs");
+const {
+  resolveConsumerTargetDir,
+  isConsumerInstall,
+  deployXrayConfig,
+} = require("./install-bridges.cjs");
 let targetDir = resolveConsumerTargetDir(packageRoot, process.env.PWD || process.cwd());
 
 const resolvedPackage = path.resolve(packageRoot);
@@ -215,29 +219,15 @@ if (fs.existsSync(hermesSkillSource)) {
   } catch (e) { console.warn(`⚠️ Hermes skill: ${e.message}`); }
 }
 
-// 8. Deploy .xray/ config files (codex.json, features.json, config.json) for consumer installs
-const xraySourceDir = path.join(packageRoot, ".xray");
-const xrayTargetDir = path.join(targetDir, ".xray");
-const CONFIG_FILES = ["codex.json", "features.json", "config.json"];
-
-if (fs.existsSync(xraySourceDir) && resolvedPackage !== resolvedTarget) {
+// 8. Deploy .xray/ config files (codex.json, features.json, features.schema.json, config.json)
+if (resolvedPackage !== resolvedTarget) {
   try {
-    if (!fs.existsSync(xrayTargetDir)) fs.mkdirSync(xrayTargetDir, { recursive: true });
-    let copied = 0;
-    for (const file of CONFIG_FILES) {
-      const src = path.join(xraySourceDir, file);
-      const dst = path.join(xrayTargetDir, file);
-      if (!fs.existsSync(src)) continue;
-      const shouldCopy = !fs.existsSync(dst) ||
-        fs.statSync(src).mtime > fs.statSync(dst).mtime;
-      if (shouldCopy) {
-        fs.copyFileSync(src, dst);
-        copied++;
-      }
-    }
-    if (copied > 0) console.log(`✅ .xray/: ${copied} config files deployed`);
+    const deployed = deployXrayConfig(targetDir, packageRoot, () => {});
+    if (deployed > 0) console.log(`✅ .xray/: ${deployed} config files deployed`);
     else console.log("ℹ️  .xray/: up to date");
-  } catch (e) { console.warn(`⚠️ .xray/ deploy: ${e.message}`); }
+  } catch (e) {
+    console.warn(`⚠️ .xray/ deploy: ${e.message}`);
+  }
 }
 
 console.log("\n✅ xray setup complete.\n");