openteams-cli 0.3.7

package/bin/cli.js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+
+const { execSync, spawn } = require("child_process");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const AdmZip = require("adm-zip");
+
+const {
+  ensureBinary,
+  BINARY_TAG,
+  CACHE_DIR,
+  LOCAL_DEV_MODE,
+  LOCAL_DIST_DIR,
+  resolveRemoteSource,
+} = require("./download");
+
+const CLI_VERSION = require("../package.json").version;
+
+const APP_NAME = "openteams-cli";
+const INSTALL_DIR = path.join(os.homedir(), ".openteams");
+const BIN_DIR = path.join(INSTALL_DIR, "bin");
+
+function printInfo(message) {
+  console.log(`  ${message}`);
+}
+
+function printStep(step, message) {
+  console.log(`  [${step}] ${message}`);
+}
+
+function printSuccess(message) {
+  console.log(`  OK  ${message}`);
+}
+
+function printError(message) {
+  console.error(`  ERROR  ${message}`);
+}
+
+function getEffectiveArch() {
+  const platform = process.platform;
+  const nodeArch = process.arch;
+
+  if (platform === "darwin") {
+    if (nodeArch === "arm64") return "arm64";
+
+    try {
+      const translated = execSync("sysctl -in sysctl.proc_translated", {
+        encoding: "utf8",
+      }).trim();
+      if (translated === "1") return "arm64";
+    } catch (_err) {}
+
+    return "x64";
+  }
+
+  if (/arm/i.test(nodeArch)) {
+    return "arm64";
+  }
+
+  if (platform === "win32") {
+    const architecture = process.env.PROCESSOR_ARCHITECTURE || "";
+    const wow64 = process.env.PROCESSOR_ARCHITEW6432 || "";
+    if (/arm/i.test(architecture) || /arm/i.test(wow64)) {
+      return "arm64";
+    }
+  }
+
+  return "x64";
+}
+
+function getPlatformTarget() {
+  const platform = process.platform;
+  const arch = getEffectiveArch();
+
+  if (platform === "linux" && arch === "x64") {
+    return { platformDir: "linux-x64", note: null };
+  }
+
+  if (platform === "linux" && arch === "arm64") {
+    return { platformDir: "linux-arm64", note: null };
+  }
+
+  if (platform === "darwin" && arch === "x64") {
+    return { platformDir: "macos-x64", note: null };
+  }
+
+  if (platform === "darwin" && arch === "arm64") {
+    return { platformDir: "macos-arm64", note: null };
+  }
+
+  if (platform === "win32" && arch === "x64") {
+    return { platformDir: "windows-x64", note: null };
+  }
+
+  if (platform === "win32" && arch === "arm64") {
+    return {
+      platformDir: "windows-x64",
+      note:
+        "Windows ARM64 binary is not published yet. Falling back to windows-x64 binary.",
+    };
+  }
+
+  printError(`Unsupported platform: ${platform}-${arch}`);
+  printError("Supported targets: linux-x64, linux-arm64, macos-x64, macos-arm64, windows-x64");
+  process.exit(1);
+}
+
+function getBinaryName() {
+  return process.platform === "win32" ? `${APP_NAME}.exe` : APP_NAME;
+}
+
+function getInstalledBinaryPath() {
+  return path.join(BIN_DIR, getBinaryName());
+}
+
+function showProgress(downloaded, total) {
+  const percent = total > 0 ? Math.round((downloaded / total) * 100) : 0;
+  const downloadedMb = (downloaded / (1024 * 1024)).toFixed(1);
+  const totalMb = total > 0 ? (total / (1024 * 1024)).toFixed(1) : "?";
+  process.stderr.write(
+    `\r   Downloading: ${downloadedMb}MB / ${totalMb}MB (${percent}%)`,
+  );
+}
+
+function extractBinary(zipPath) {
+  fs.mkdirSync(BIN_DIR, { recursive: true });
+
+  const expectedBinaryName = getBinaryName();
+  const expectedPath = path.join(BIN_DIR, expectedBinaryName);
+
+  try {
+    if (fs.existsSync(expectedPath)) {
+      fs.unlinkSync(expectedPath);
+    }
+  } catch (_err) {}
+
+  const zip = new AdmZip(zipPath);
+  zip.extractAllTo(BIN_DIR, true);
+
+  let binaryPath = expectedPath;
+  if (!fs.existsSync(binaryPath)) {
+    const candidates = fs
+      .readdirSync(BIN_DIR)
+      .filter((name) =>
+        [expectedBinaryName, `${expectedBinaryName}.exe`].includes(name),
+      );
+
+    if (candidates.length > 0) {
+      binaryPath = path.join(BIN_DIR, candidates[0]);
+    }
+  }
+
+  if (!fs.existsSync(binaryPath)) {
+    throw new Error(
+      `Extracted binary not found in ${BIN_DIR}. The archive may be invalid.`,
+    );
+  }
+
+  if (process.platform !== "win32") {
+    try {
+      fs.chmodSync(binaryPath, 0o755);
+    } catch (_err) {}
+  }
+
+  return binaryPath;
+}
+
+async function installBinary(options = {}) {
+  const { force = false } = options;
+  const target = getPlatformTarget();
+
+  if (target.note) {
+    console.log(`  WARN  ${target.note}`);
+  }
+
+  printStep("1/2", "Preparing binary package...");
+  fs.mkdirSync(INSTALL_DIR, { recursive: true });
+
+  if (force) {
+    try {
+      fs.rmSync(path.join(CACHE_DIR, BINARY_TAG, target.platformDir, `${APP_NAME}.zip`), { force: true });
+      fs.rmSync(getInstalledBinaryPath(), { force: true });
+    } catch (_err) {}
+  }
+
+  printStep("2/2", "Downloading prebuilt binary...");
+  let zipPath;
+  try {
+    zipPath = await ensureBinary(target.platformDir, showProgress);
+    if (!LOCAL_DEV_MODE) {
+      process.stderr.write("\n");
+    }
+  } catch (err) {
+    process.stderr.write("\n");
+    throw new Error(`Download failed: ${err.message}`);
+  }
+
+  const binaryPath = extractBinary(zipPath);
+
+  printSuccess(`Installed ${APP_NAME} to ${binaryPath}`);
+  return binaryPath;
+}
+
+function isInstalled() {
+  return fs.existsSync(getInstalledBinaryPath());
+}
+
+async function ensureInstalled() {
+  if (isInstalled()) {
+    return getInstalledBinaryPath();
+  }
+
+  printInfo("No local installation found. Installing now...");
+  return installBinary();
+}
+
+function launchBinary(binaryPath, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(binaryPath, args, {
+      stdio: "inherit",
+      env: process.env,
+    });
+
+    child.on("error", (err) => reject(err));
+    child.on("exit", (code) => resolve(code || 0));
+
+    process.on("SIGINT", () => {
+      child.kill("SIGINT");
+    });
+    process.on("SIGTERM", () => {
+      child.kill("SIGTERM");
+    });
+  });
+}
+
+function showHelp() {
+  console.log(`
+Usage: npx openteams-cli [command] [args]
+
+Commands:
+  install       Download and install prebuilt binary only
+  update        Force re-download and reinstall
+  --help, -h    Show help
+  --version     Show CLI version
+
+Default behavior:
+  npx openteams-cli
+  -> install (if needed) + run CLI
+
+Pass-through args:
+  npx openteams-cli -- --help
+`);
+}
+
+function checkNodeVersion() {
+  const major = Number.parseInt(process.versions.node.split(".")[0], 10);
+  if (Number.isNaN(major) || major < 18) {
+    printError(`Node.js 18+ is required, found v${process.versions.node}`);
+    process.exit(1);
+  }
+}
+
+async function main() {
+  checkNodeVersion();
+
+  const rawArgs = process.argv.slice(2);
+  const args = rawArgs[0] === "--" ? rawArgs.slice(1) : rawArgs;
+  const command = args[0];
+
+  if (command === "--help" || command === "-h") {
+    showHelp();
+    return;
+  }
+
+  if (command === "--version" || command === "-v") {
+    console.log(`${APP_NAME} v${CLI_VERSION}`);
+    return;
+  }
+
+  if (command === "install") {
+    await installBinary();
+    console.log("");
+    printInfo("Run `npx openteams-cli` to start.");
+    return;
+  }
+
+  if (command === "update") {
+    await installBinary({ force: true });
+    console.log("");
+    printInfo("Update completed.");
+    return;
+  }
+
+  let runArgs = args;
+  if (command === "start") {
+    runArgs = args.slice(1);
+  }
+
+  console.log("");
+  const binaryPath = await ensureInstalled();
+  console.log("");
+
+  const exitCode = await launchBinary(binaryPath, runArgs);
+  process.exit(exitCode);
+}
+
+main().catch((err) => {
+  printError(err.message || String(err));
+  if (process.env.OPENTEAMS_DEBUG === "1") {
+    console.error(err.stack || err);
+  }
+  process.exit(1);
+});

package/bin/download.js

@@ -0,0 +1,234 @@
+const https = require("https");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const crypto = require("crypto");
+
+const DEFAULT_OSS_BASE_URL = "__OSS_PUBLIC_URL__";
+const DEFAULT_R2_BASE_URL = "https://pub-443f2c6e108c4de4a8c0dadf2c6e06cc.r2.dev";
+const DEFAULT_BINARY_TAG = "v0.3.7-20260323111520";
+
+const OSS_BASE_URL = normalizeBaseUrl(
+  process.env.OPENTEAMS_OSS_BASE_URL || DEFAULT_OSS_BASE_URL,
+);
+const R2_BASE_URL = normalizeBaseUrl(
+  process.env.OPENTEAMS_R2_BASE_URL || DEFAULT_R2_BASE_URL,
+);
+const BINARY_TAG =
+  process.env.OPENTEAMS_BINARY_TAG || DEFAULT_BINARY_TAG;
+
+const INSTALL_DIR = path.join(os.homedir(), ".openteams");
+const CACHE_DIR = path.join(INSTALL_DIR, "cache");
+
+const LOCAL_DIST_DIR = path.join(__dirname, "..", "dist");
+const LOCAL_DEV_MODE =
+  fs.existsSync(LOCAL_DIST_DIR) || process.env.OPENTEAMS_LOCAL === "1";
+
+function normalizeBaseUrl(url) {
+  if (!url) return "";
+  return url.replace(/\/+$/, "");
+}
+
+function isUnresolvedTemplateToken(value) {
+  if (!value) return true;
+  return /^__[A-Z0-9_]+__$/.test(String(value).trim());
+}
+
+function isConfiguredBaseUrl(url) {
+  return Boolean(url) && !isUnresolvedTemplateToken(url);
+}
+
+function resolveRemoteSource() {
+  if (isConfiguredBaseUrl(OSS_BASE_URL)) {
+    return {
+      provider: "oss",
+      baseUrl: OSS_BASE_URL,
+    };
+  }
+
+  if (isConfiguredBaseUrl(R2_BASE_URL)) {
+    return {
+      provider: "r2",
+      baseUrl: R2_BASE_URL,
+    };
+  }
+
+  return null;
+}
+
+function ensureRemoteConfig() {
+  if (LOCAL_DEV_MODE) return;
+
+  const source = resolveRemoteSource();
+  if (!source) {
+    throw new Error(
+      "Binary source URL is not configured. Set OPENTEAMS_OSS_BASE_URL or OPENTEAMS_R2_BASE_URL, or publish npm package with URL injection.",
+    );
+  }
+
+  if (isUnresolvedTemplateToken(BINARY_TAG)) {
+    throw new Error(
+      "Binary tag is not configured. The npm package was published without binary tag injection.",
+    );
+  }
+
+  return source;
+}
+
+function fetchJson(url) {
+  return new Promise((resolve, reject) => {
+    https
+      .get(url, (res) => {
+        if (res.statusCode === 301 || res.statusCode === 302) {
+          return fetchJson(res.headers.location).then(resolve).catch(reject);
+        }
+
+        if (res.statusCode !== 200) {
+          return reject(new Error(`HTTP ${res.statusCode} while fetching ${url}`));
+        }
+
+        let body = "";
+        res.on("data", (chunk) => {
+          body += chunk;
+        });
+        res.on("end", () => {
+          try {
+            resolve(JSON.parse(body));
+          } catch (_err) {
+            reject(new Error(`Invalid JSON response from ${url}`));
+          }
+        });
+      })
+      .on("error", reject);
+  });
+}
+
+function downloadFile(url, destinationPath, expectedSha256, onProgress) {
+  const tempPath = `${destinationPath}.tmp`;
+
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(tempPath);
+    const hash = crypto.createHash("sha256");
+
+    const cleanup = () => {
+      try {
+        fs.unlinkSync(tempPath);
+      } catch (_err) {}
+    };
+
+    https
+      .get(url, (res) => {
+        if (res.statusCode === 301 || res.statusCode === 302) {
+          file.close();
+          cleanup();
+          return downloadFile(
+            res.headers.location,
+            destinationPath,
+            expectedSha256,
+            onProgress,
+          )
+            .then(resolve)
+            .catch(reject);
+        }
+
+        if (res.statusCode !== 200) {
+          file.close();
+          cleanup();
+          return reject(new Error(`HTTP ${res.statusCode} while downloading ${url}`));
+        }
+
+        const totalSize = Number.parseInt(res.headers["content-length"], 10);
+        let downloadedSize = 0;
+
+        res.on("data", (chunk) => {
+          downloadedSize += chunk.length;
+          hash.update(chunk);
+          if (onProgress) {
+            onProgress(downloadedSize, Number.isFinite(totalSize) ? totalSize : 0);
+          }
+        });
+
+        res.pipe(file);
+
+        file.on("finish", () => {
+          file.close();
+
+          const actualSha256 = hash.digest("hex");
+          if (expectedSha256 && actualSha256 !== expectedSha256) {
+            cleanup();
+            return reject(
+              new Error(
+                `Checksum mismatch, expected ${expectedSha256}, got ${actualSha256}`,
+              ),
+            );
+          }
+
+          try {
+            fs.renameSync(tempPath, destinationPath);
+            resolve(destinationPath);
+          } catch (err) {
+            cleanup();
+            reject(err);
+          }
+        });
+      })
+      .on("error", (err) => {
+        file.close();
+        cleanup();
+        reject(err);
+      });
+  });
+}
+
+async function ensureBinary(platform, onProgress) {
+  const binaryName = "openteams-cli";
+
+  if (LOCAL_DEV_MODE) {
+    const localZipPath = path.join(LOCAL_DIST_DIR, platform, `${binaryName}.zip`);
+    if (fs.existsSync(localZipPath)) {
+      return localZipPath;
+    }
+
+    throw new Error(
+      `Local binary not found: ${localZipPath}\nRun your local binary packaging first.`,
+    );
+  }
+
+  const source = ensureRemoteConfig();
+
+  const platformCacheDir = path.join(CACHE_DIR, BINARY_TAG, platform);
+  const zipPath = path.join(platformCacheDir, `${binaryName}.zip`);
+
+  if (fs.existsSync(zipPath)) {
+    return zipPath;
+  }
+
+  fs.mkdirSync(platformCacheDir, { recursive: true });
+
+  const manifest = await fetchJson(
+    `${source.baseUrl}/binaries/${BINARY_TAG}/manifest.json`,
+  );
+  const binaryInfo = manifest.platforms?.[platform]?.[binaryName];
+
+  if (!binaryInfo) {
+    throw new Error(
+      `Binary ${binaryName} is not available for platform ${platform} in tag ${BINARY_TAG}.`,
+    );
+  }
+
+  const binaryUrl = `${source.baseUrl}/binaries/${BINARY_TAG}/${platform}/${binaryName}.zip`;
+  await downloadFile(binaryUrl, zipPath, binaryInfo.sha256, onProgress);
+
+  return zipPath;
+}
+
+module.exports = {
+  OSS_BASE_URL,
+  R2_BASE_URL,
+  BINARY_TAG,
+  CACHE_DIR,
+  LOCAL_DEV_MODE,
+  LOCAL_DIST_DIR,
+  resolveRemoteSource,
+  ensureBinary,
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "openteams-cli",
+  "version": "0.3.7",
+  "description": "OpenTeams CLI - AI-powered development tool",
+  "author": "openteams-lab",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/openteams-lab/openteams"
+  },
+  "homepage": "https://github.com/openteams-lab/openteams",
+  "bugs": {
+    "url": "https://github.com/openteams-lab/openteams/issues"
+  },
+  "keywords": [
+    "ai",
+    "cli",
+    "coding",
+    "assistant",
+    "agent"
+  ],
+  "bin": {
+    "openteams-cli": "bin/cli.js"
+  },
+  "main": "bin/cli.js",
+  "files": [
+    "bin"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "dependencies": {
+    "adm-zip": "^0.5.16"
+  }
+}