@smallfishworld/open-code-review-svn 1.11.2-svn.1

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@smallfishworld/open-code-review-svn",
+  "version": "1.11.2-svn.1",
+  "description": "OpenCodeReview CLI fork with SVN workspace review support",
+  "bin": {
+    "ocr": "bin/ocr.js"
+  },
+  "files": [
+    "bin/ocr.js",
+    "scripts/install.js",
+    "scripts/update.js",
+    "scripts/version.js",
+    "scripts/platform.js",
+    "imgs/"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/install.js",
+    "test:github-actions": "node scripts/github-actions/post-review-comments.test.js && node scripts/github-actions/check-translation-sync.test.js && node scripts/github-actions/action-contract.test.js",
+    "test:update": "node scripts/version.test.js",
+    "test:launcher": "node bin/ocr.test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/smallfishworld/open-code-review-svn.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "ocrConfig": {
+    "urlPattern": "https://github.com/smallfishworld/open-code-review-svn/releases/download/v{version}/opencodereview-{os}-{arch}",
+    "checksumPattern": "https://github.com/smallfishworld/open-code-review-svn/releases/download/v{version}/sha256sum.txt"
+  },
+  "optionalDependencies": {
+    "@smallfishworld/ocr-darwin-arm64": "1.11.2-svn.1",
+    "@smallfishworld/ocr-darwin-x64": "1.11.2-svn.1",
+    "@smallfishworld/ocr-linux-arm64": "1.11.2-svn.1",
+    "@smallfishworld/ocr-linux-x64": "1.11.2-svn.1",
+    "@smallfishworld/ocr-win32-arm64": "1.11.2-svn.1",
+    "@smallfishworld/ocr-win32-x64": "1.11.2-svn.1"
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "license": "Apache-2.0"
+}

package/scripts/install.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 alibaba/open-code-review Contributors
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+const crypto = require("crypto");
+
+const { IS_WINDOWS, BINARY_FILENAME: BINARY_NAME, resolveNativeBinary } = require("./platform");
+
+const packageRoot = path.join(__dirname, "..");
+const binDir = path.join(packageRoot, "bin");
+const binaryDest = path.join(binDir, BINARY_NAME);
+
+function info(msg) {
+  console.log(`[INFO]  ${msg}`);
+}
+
+function warn(msg) {
+  console.warn(`[WARN]  ${msg}`);
+}
+
+function error(msg) {
+  console.error(`[ERROR] ${msg}`);
+}
+
+function detectPlatform() {
+  let os = process.platform;
+  let arch = process.arch;
+
+  switch (arch) {
+    case "x64":
+      arch = "amd64";
+      break;
+    case "arm64":
+      arch = "arm64";
+      break;
+    default:
+      throw new Error(
+        `Unsupported architecture: ${arch}. Supported: amd64 (x64), arm64`
+      );
+  }
+
+  switch (os) {
+    case "linux":
+    case "darwin":
+      break;
+    case "win32":
+      os = "windows";
+      break;
+    default:
+      throw new Error(
+        `Unsupported operating system: ${os}. Supported: linux, darwin, win32`
+      );
+  }
+
+  return { os, arch };
+}
+
+function loadPackageJson() {
+  const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
+  if (!pkg.version) {
+    throw new Error("Missing version field in package.json");
+  }
+  if (!pkg.ocrConfig || !pkg.ocrConfig.urlPattern) {
+    throw new Error("Missing ocrConfig.urlPattern in package.json");
+  }
+  return pkg;
+}
+
+function resolveVersion(pkg) {
+  const envVersion = process.env.OCR_VERSION;
+  if (envVersion) {
+    const v = envVersion.startsWith("v") ? envVersion.slice(1) : envVersion;
+    info(`Using pinned version from OCR_VERSION: ${v}`);
+    return v;
+  }
+
+  info(`Using version from package.json: ${pkg.version}`);
+  return pkg.version;
+}
+
+function buildUrl(pattern, vars) {
+  return pattern
+    .replace(/\{version\}/g, vars.version)
+    .replace(/\{os\}/g, vars.os)
+    .replace(/\{arch\}/g, vars.arch);
+}
+
+function download(url, maxRedirects = 10) {
+  if (!url.startsWith("https")) {
+    return Promise.reject(new Error(`Refusing non-HTTPS download: ${url}`));
+  }
+  if (maxRedirects <= 0) {
+    return Promise.reject(new Error(`Too many redirects fetching ${url}`));
+  }
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        res.resume();
+        download(res.headers.location, maxRedirects - 1).then(resolve).catch(reject);
+        return;
+      }
+      if (res.statusCode !== 200) {
+        res.resume();
+        reject(new Error(`HTTP ${res.statusCode} fetching ${url}`));
+        return;
+      }
+      resolve(res);
+    }).on("error", reject);
+  });
+}
+
+async function downloadText(url) {
+  const res = await download(url);
+  return new Promise((resolve, reject) => {
+    let data = "";
+    res.on("data", (chunk) => (data += chunk));
+    res.on("end", () => resolve(data));
+    res.on("error", reject);
+  });
+}
+
+async function downloadBinary(url, destPath) {
+  const res = await download(url);
+  return new Promise((resolve, reject) => {
+    const fileStream = fs.createWriteStream(destPath);
+    res.on("error", (err) => {
+      fileStream.destroy();
+      fs.unlink(destPath, () => {});
+      reject(err);
+    });
+    res.pipe(fileStream);
+    fileStream.on("finish", () => fileStream.close(() => resolve()));
+    fileStream.on("error", (err) => {
+      fs.unlink(destPath, () => {});
+      reject(err);
+    });
+  });
+}
+
+function computeChecksum(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("sha256");
+    const stream = fs.createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+    stream.on("error", reject);
+  });
+}
+
+async function main() {
+  info("OpenCodeReview Installer");
+  info("=========================");
+
+  const existing = resolveNativeBinary();
+  if (existing && existing.fromPlatformPkg) {
+    info("Binary provided by platform package, skipping download.");
+    info(`  ${existing.path}`);
+    return;
+  }
+
+  const { os, arch } = detectPlatform();
+  info(`Detected platform: ${os}/${arch}`);
+
+  const pkg = loadPackageJson();
+  const version = resolveVersion(pkg);
+  const config = pkg.ocrConfig;
+
+  if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir, { recursive: true });
+  }
+
+  if (!IS_WINDOWS) {
+    const jsWrapper = path.join(binDir, "ocr.js");
+    if (fs.existsSync(jsWrapper)) {
+      try {
+        fs.chmodSync(jsWrapper, 0o755);
+      } catch (e) {
+        warn(`Could not make ocr.js executable: ${e.message}`);
+      }
+    }
+  }
+
+  const vars = { version, os, arch };
+  let downloadUrl = buildUrl(config.urlPattern, vars);
+  if (IS_WINDOWS) {
+    downloadUrl += ".exe";
+  }
+  info(`Downloading ${downloadUrl} ...`);
+
+  await downloadBinary(downloadUrl, binaryDest);
+  if (!IS_WINDOWS) {
+    fs.chmodSync(binaryDest, 0o755);
+  }
+
+  if (config.checksumPattern) {
+    const checksumUrl = buildUrl(config.checksumPattern, vars);
+    info("Verifying checksum...");
+    let shaContent;
+    try {
+      shaContent = await downloadText(checksumUrl);
+    } catch (e) {
+      try { fs.unlinkSync(binaryDest); } catch (_) {}
+      throw new Error(`Failed to download checksum from ${checksumUrl}: ${e.message}`);
+    }
+    let actualSha;
+    try {
+      actualSha = await computeChecksum(binaryDest);
+    } catch (e) {
+      try { fs.unlinkSync(binaryDest); } catch (_) {}
+      throw new Error(`Failed to compute checksum for ${binaryDest}: ${e.message}`);
+    }
+
+    let verified = false;
+    for (const line of shaContent.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed.includes(`-${os}-${arch}`)) {
+        const expectedSha = trimmed.split(/\s+/)[0].toLowerCase();
+        if (expectedSha) {
+          if (actualSha !== expectedSha) {
+            try { fs.unlinkSync(binaryDest); } catch (_) {}
+            throw new Error(
+              `Checksum mismatch! Expected: ${expectedSha}, Got: ${actualSha}`
+            );
+          }
+          info("Checksum verified.");
+          verified = true;
+          break;
+        }
+      }
+    }
+    if (!verified) {
+      try { fs.unlinkSync(binaryDest); } catch (_) {}
+      throw new Error(
+        `No matching checksum entry for ${os}-${arch} in ${checksumUrl}`
+      );
+    }
+  }
+
+  info(`Installed: ${binaryDest}`);
+  info("");
+  info("OpenCodeReview is ready!");
+  info("");
+  info("Quick start:");
+  info("  ocr version             Show version info");
+  info("  ocr config set          Configure your LLM provider");
+  info("  ocr review              Start a code review");
+}
+
+if (require.main === module) {
+  main().catch((err) => {
+    error(err.message);
+    process.exit(1);
+  });
+} else {
+  module.exports = {
+    IS_WINDOWS,
+    BINARY_NAME,
+    detectPlatform,
+    loadPackageJson,
+    buildUrl,
+    download,
+    downloadText,
+    downloadBinary,
+    computeChecksum,
+  };
+}

package/scripts/platform.js

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 alibaba/open-code-review Contributors
+
+"use strict";
+
+const path = require("path");
+const fs = require("fs");
+
+const IS_WINDOWS = process.platform === "win32";
+const BINARY_FILENAME = IS_WINDOWS ? "opencodereview.exe" : "opencodereview";
+
+const PLATFORM_PKG = {
+  "darwin-arm64": "@smallfishworld/ocr-darwin-arm64",
+  "darwin-x64": "@smallfishworld/ocr-darwin-x64",
+  "linux-arm64": "@smallfishworld/ocr-linux-arm64",
+  "linux-x64": "@smallfishworld/ocr-linux-x64",
+  "win32-arm64": "@smallfishworld/ocr-win32-arm64",
+  "win32-x64": "@smallfishworld/ocr-win32-x64",
+};
+
+function getPlatformPackageName() {
+  const key = `${process.platform}-${process.arch}`;
+
+  try {
+    const parentPkg = JSON.parse(
+      fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8")
+    );
+    const optDeps = parentPkg.optionalDependencies || {};
+    for (const name of Object.keys(optDeps)) {
+      if (name.endsWith(`-${key}`)) {
+        return name;
+      }
+    }
+  } catch (_) {}
+
+  return PLATFORM_PKG[key] || null;
+}
+
+function resolveNativeBinary() {
+  const pkgName = getPlatformPackageName();
+  if (pkgName) {
+    try {
+      const pkgDir = path.dirname(require.resolve(`${pkgName}/package.json`));
+      const binPath = path.join(pkgDir, "bin", BINARY_FILENAME);
+      if (fs.existsSync(binPath)) {
+        return { path: binPath, fromPlatformPkg: true };
+      }
+    } catch (err) {
+      if (err.code !== "MODULE_NOT_FOUND") {
+        console.warn(`[WARN] Unexpected error resolving ${pkgName}: ${err.message}`);
+      }
+    }
+  }
+
+  const legacyPath = path.join(__dirname, "..", "bin", BINARY_FILENAME);
+  if (fs.existsSync(legacyPath)) {
+    return { path: legacyPath, fromPlatformPkg: false };
+  }
+
+  return null;
+}
+
+module.exports = {
+  IS_WINDOWS,
+  BINARY_FILENAME,
+  PLATFORM_PKG,
+  getPlatformPackageName,
+  resolveNativeBinary,
+};

package/scripts/update.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 alibaba/open-code-review Contributors
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const https = require("https");
+const { spawnSync } = require("child_process");
+
+const { resolveNativeBinary } = require("./platform");
+const { loadPackageJson } = require("./install.js");
+const { SEMVER_RE, parseVersionOutput, semverGt } = require("./version");
+
+const stateDir = path.join(os.homedir(), ".opencodereview");
+const tsFile = path.join(stateDir, "last-update-check");
+const lockFile = path.join(stateDir, "update.lock");
+const hintFile = path.join(stateDir, "update-available");
+
+const DEFAULT_REGISTRY = "https://registry.npmjs.org";
+
+function touchTimestamp() {
+  fs.mkdirSync(stateDir, { recursive: true });
+  const now = new Date();
+  try {
+    fs.utimesSync(tsFile, now, now);
+  } catch (_) {
+    fs.writeFileSync(tsFile, now.toISOString());
+  }
+}
+
+function acquireLock() {
+  fs.mkdirSync(stateDir, { recursive: true });
+  try {
+    fs.writeFileSync(lockFile, String(process.pid), { flag: "wx" });
+    return true;
+  } catch (e) {
+    if (e.code !== "EEXIST") return false;
+    try {
+      const pid = parseInt(fs.readFileSync(lockFile, "utf8").trim(), 10);
+      process.kill(pid, 0);
+      return false;
+    } catch (_) {
+      try {
+        fs.unlinkSync(lockFile);
+        fs.writeFileSync(lockFile, String(process.pid), { flag: "wx" });
+        return true;
+      } catch (_2) {
+        return false;
+      }
+    }
+  }
+}
+
+function releaseLock() {
+  try {
+    fs.unlinkSync(lockFile);
+  } catch (_) {}
+}
+
+function getInstalledVersion(binPath) {
+  try {
+    const result = spawnSync(binPath, ["version"], {
+      encoding: "utf8",
+      timeout: 3000,
+    });
+    return parseVersionOutput(result.stdout);
+  } catch (_) {
+    return null;
+  }
+}
+
+function fetchLatestVersion(pkg) {
+  const registry = (pkg.publishConfig && pkg.publishConfig.registry) || DEFAULT_REGISTRY;
+  const pkgName = pkg.name;
+  if (!pkgName) return Promise.resolve(null);
+  const encodedName = pkgName.replace(/\//g, "%2F");
+  const url = `${registry.replace(/\/$/, "")}/${encodedName}/latest`;
+  if (!url.startsWith("https://")) return Promise.resolve(null);
+
+  return new Promise((resolve) => {
+    const options = {
+      headers: { "User-Agent": "ocr-updater", Accept: "application/json" },
+      timeout: 15000,
+    };
+    const req = https
+      .get(url, options, (res) => {
+        if (res.statusCode !== 200) {
+          res.resume();
+          resolve(null);
+          return;
+        }
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          try {
+            const json = JSON.parse(data);
+            resolve(json.version || null);
+          } catch (_) {
+            resolve(null);
+          }
+        });
+        res.on("error", () => resolve(null));
+      })
+      .on("error", () => resolve(null));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(null);
+    });
+  });
+}
+
+function writeHint(latestVersion, pkgName) {
+  try {
+    fs.writeFileSync(hintFile, JSON.stringify({ version: latestVersion, pkg: pkgName }));
+  } catch (_) {}
+}
+
+function removeHint() {
+  try {
+    fs.unlinkSync(hintFile);
+  } catch (_) {}
+}
+
+async function main() {
+  touchTimestamp();
+
+  if (!acquireLock()) return;
+
+  try {
+    const resolved = resolveNativeBinary();
+    if (!resolved) return;
+
+    const installedVersion = getInstalledVersion(resolved.path);
+    if (!installedVersion) return;
+
+    const pkg = loadPackageJson();
+    const latestVersion = await fetchLatestVersion(pkg);
+    if (!latestVersion) return;
+
+    if (!SEMVER_RE.test(latestVersion)) return;
+
+    if (!semverGt(latestVersion, installedVersion)) {
+      removeHint();
+      return;
+    }
+
+    const pkgName = pkg.name;
+    const IS_WINDOWS = process.platform === "win32";
+    const result = spawnSync("npm", ["i", "-g", `${pkgName}@${latestVersion}`], {
+      encoding: "utf8",
+      timeout: 120000,
+      shell: IS_WINDOWS,
+    });
+
+    if (result.status === 0) {
+      removeHint();
+    } else {
+      writeHint(latestVersion, pkgName);
+    }
+  } catch (_) {
+  } finally {
+    releaseLock();
+  }
+}
+
+main().catch(() => {});

package/scripts/version.js

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 alibaba/open-code-review Contributors
+
+"use strict";
+
+const SEMVER_RE =
+  /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+
+function parseVersionOutput(output) {
+  const match = String(output || "").match(
+    /v(\d+\.\d+(?:\.\d+)?(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)/
+  );
+  return match ? match[1] : null;
+}
+
+function semverGt(a, b) {
+  if (!SEMVER_RE.test(a) || !SEMVER_RE.test(b)) return false;
+
+  const aWithoutBuild = a.replace(/\+.*$/, "");
+  const bWithoutBuild = b.replace(/\+.*$/, "");
+  const pa = aWithoutBuild.replace(/-.*$/, "").split(".").map(Number);
+  const pb = bWithoutBuild.replace(/-.*$/, "").split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if (pa[i] > pb[i]) return true;
+    if (pa[i] < pb[i]) return false;
+  }
+  const aPre = aWithoutBuild.includes("-");
+  const bPre = bWithoutBuild.includes("-");
+  if (bPre && !aPre) return true;
+  return false;
+}
+
+function shouldShowUpdateHint(hintVersion, installedVersion) {
+  if (!SEMVER_RE.test(hintVersion) || !SEMVER_RE.test(installedVersion)) {
+    return false;
+  }
+  return semverGt(hintVersion, installedVersion);
+}
+
+module.exports = {
+  SEMVER_RE,
+  parseVersionOutput,
+  semverGt,
+  shouldShowUpdateHint,
+};