@dhruv2mars/offdex 0.0.1

package/README.md

@@ -0,0 +1,31 @@
+# @dhruv2mars/offdex
+
+Install the Offdex bridge CLI globally:
+
+```bash
+npm install -g @dhruv2mars/offdex
+```
+
+Then run:
+
+```bash
+offdex
+```
+
+The package downloads the matching native runtime for your platform from GitHub Releases.
+
+Supported targets:
+
+- macOS `arm64`
+- macOS `x64`
+- Linux `arm64`
+- Linux `x64`
+- Windows `x64`
+
+Common usage:
+
+```bash
+offdex bridge --host 0.0.0.0 --port 42420
+offdex bridge --control-plane-url https://control.offdex.app
+offdex --help
+```

package/bin/install-lib.js

@@ -0,0 +1,326 @@
+import { createHash } from "node:crypto";
+import { createWriteStream, existsSync, readFileSync } from "node:fs";
+import { chmod, mkdir, rename, rm, writeFile } from "node:fs/promises";
+import http from "node:http";
+import https from "node:https";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const REPO = "Dhruv2mars/offdex";
+const SUPPORTED_TARGETS = new Map([
+  ["darwin:arm64", "bun-darwin-arm64"],
+  ["darwin:x64", "bun-darwin-x64"],
+  ["linux:arm64", "bun-linux-arm64"],
+  ["linux:x64", "bun-linux-x64-baseline"],
+  ["win32:x64", "bun-windows-x64-baseline"]
+]);
+
+export function supportedPlatformMatrix() {
+  return [...SUPPORTED_TARGETS.keys()].map((key) => {
+    const [platform, arch] = key.split(":");
+    return { platform, arch, target: SUPPORTED_TARGETS.get(key) };
+  });
+}
+
+export function isSupportedPlatform(platform = process.platform, arch = process.arch) {
+  return SUPPORTED_TARGETS.has(`${platform}:${arch}`);
+}
+
+export function supportedPlatformList() {
+  return supportedPlatformMatrix().map(({ platform, arch }) => `${platform}/${arch}`);
+}
+
+export function targetForPlatform(platform = process.platform, arch = process.arch) {
+  const target = SUPPORTED_TARGETS.get(`${platform}:${arch}`);
+  if (!target) {
+    throw new Error(`unsupported_platform:${platform}-${arch}`);
+  }
+  return target;
+}
+
+export function assertSupportedPlatform(platform = process.platform, arch = process.arch) {
+  if (isSupportedPlatform(platform, arch)) {
+    return;
+  }
+  throw new Error(`unsupported_platform:${platform}-${arch}`);
+}
+
+export function binNameForPlatform(platform = process.platform) {
+  return platform === "win32" ? "offdex.exe" : "offdex";
+}
+
+export function assetNameFor(platform = process.platform, arch = process.arch) {
+  const ext = platform === "win32" ? ".exe" : "";
+  return `offdex-${platform}-${arch}${ext}`;
+}
+
+export function checksumsAssetNameFor(platform = process.platform, arch = process.arch) {
+  return `checksums-${platform}-${arch}.txt`;
+}
+
+export function resolveInstallRoot(env = process.env, home = homedir()) {
+  return env.OFFDEX_INSTALL_ROOT || join(home, ".offdex");
+}
+
+export function resolveInstallMetaPath(env = process.env, home = homedir()) {
+  return join(resolveInstallRoot(env, home), "install-meta.json");
+}
+
+export function resolveInstalledBin(env = process.env, platform = process.platform, home = homedir()) {
+  return join(resolveInstallRoot(env, home), "bin", binNameForPlatform(platform));
+}
+
+export function packageManagerHintFromEnv(env = process.env) {
+  const execPath = String(env.npm_execpath || "").toLowerCase();
+  if (execPath.includes("bun")) return "bun";
+  if (execPath.includes("pnpm")) return "pnpm";
+  if (execPath.includes("yarn")) return "yarn";
+  if (execPath.includes("npm")) return "npm";
+
+  const ua = String(env.npm_config_user_agent || "").toLowerCase();
+  if (ua.startsWith("bun/")) return "bun";
+  if (ua.startsWith("pnpm/")) return "pnpm";
+  if (ua.startsWith("yarn/")) return "yarn";
+  if (ua.startsWith("npm/")) return "npm";
+
+  return null;
+}
+
+export function shouldInstallBinary({ binExists, installedVersion, packageVersion }) {
+  if (!binExists) return true;
+  if (!packageVersion) return false;
+  return installedVersion !== packageVersion;
+}
+
+export function resolvePackageVersion(packageJsonPath, env = process.env) {
+  try {
+    const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    return typeof pkg.version === "string" && pkg.version.length > 0
+      ? pkg.version
+      : (env.npm_package_version || "0.0.0");
+  } catch {
+    return env.npm_package_version || "0.0.0";
+  }
+}
+
+export function isWorkspaceCheckout(packageJsonPath) {
+  try {
+    const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    return pkg?.name === "offdex" && Array.isArray(pkg?.workspaces);
+  } catch {
+    return false;
+  }
+}
+
+export function shouldSkipPackageInstall({
+  env = process.env,
+  packageRoot
+}) {
+  if (env.OFFDEX_SKIP_INSTALL === "1") {
+    return true;
+  }
+
+  const workspaceRootPackageJson = join(packageRoot, "..", "..", "package.json");
+  return isWorkspaceCheckout(workspaceRootPackageJson);
+}
+
+export function parseChecksumForAsset(text, asset) {
+  if (typeof text !== "string") return null;
+  for (const line of text.split(/\r?\n/)) {
+    const match = line.trim().match(/^([a-fA-F0-9]{64})\s+\*?(.+)$/);
+    if (!match) continue;
+    const candidate = match[2].trim().replace(/^[.][/\\]/, "");
+    if (candidate !== asset) continue;
+    return match[1].toLowerCase();
+  }
+  return null;
+}
+
+function requestProtocolFor(url) {
+  return new URL(url).protocol;
+}
+
+export function requestText(url, redirects = 0) {
+  if (redirects > 5) {
+    throw new Error("too_many_redirects");
+  }
+  return new Promise((resolve, reject) => {
+    const transport = requestProtocolFor(url) === "http:" ? http : https;
+    const request = transport.get(
+      url,
+      {
+        agent: false,
+        headers: {
+          Connection: "close",
+          "User-Agent": "offdex-installer"
+        }
+      },
+      (response) => {
+        if (
+          response.statusCode &&
+          response.statusCode >= 300 &&
+          response.statusCode < 400 &&
+          response.headers.location
+        ) {
+          response.resume();
+          requestText(response.headers.location, redirects + 1).then(resolve, reject);
+          return;
+        }
+        if (response.statusCode !== 200) {
+          response.resume();
+          reject(new Error(`http ${response.statusCode}`));
+          return;
+        }
+        let data = "";
+        response.setEncoding("utf8");
+        response.on("data", (chunk) => {
+          data += chunk;
+        });
+        response.on("end", () => resolve(data));
+      }
+    );
+    request.on("error", reject);
+  });
+}
+
+export function download(url, outputPath, redirects = 0) {
+  if (redirects > 5) {
+    throw new Error("too_many_redirects");
+  }
+  const partPath = `${outputPath}.part`;
+  return new Promise((resolve, reject) => {
+    const transport = requestProtocolFor(url) === "http:" ? http : https;
+    const request = transport.get(
+      url,
+      {
+        agent: false,
+        headers: {
+          Connection: "close",
+          "User-Agent": "offdex-installer"
+        }
+      },
+      (response) => {
+        if (
+          response.statusCode &&
+          response.statusCode >= 300 &&
+          response.statusCode < 400 &&
+          response.headers.location
+        ) {
+          response.resume();
+          download(response.headers.location, outputPath, redirects + 1).then(resolve, reject);
+          return;
+        }
+        if (response.statusCode !== 200) {
+          response.resume();
+          reject(new Error(`http ${response.statusCode}`));
+          return;
+        }
+        const file = createWriteStream(partPath);
+        file.on("error", async (error) => {
+          await rm(partPath, { force: true });
+          reject(error);
+        });
+        response.on("error", async (error) => {
+          await rm(partPath, { force: true });
+          reject(error);
+        });
+        response.pipe(file);
+        file.on("finish", () => {
+          file.close(async () => {
+            try {
+              await rename(partPath, outputPath);
+              resolve();
+            } catch (error) {
+              await rm(partPath, { force: true });
+              reject(error);
+            }
+          });
+        });
+      }
+    );
+    request.on("error", async (error) => {
+      await rm(partPath, { force: true });
+      reject(error);
+    });
+  });
+}
+
+export async function installRuntime({
+  version,
+  env = process.env,
+  platform = process.platform,
+  arch = process.arch,
+  home = homedir(),
+  downloadFn = download,
+  requestTextFn = requestText
+}) {
+  assertSupportedPlatform(platform, arch);
+  const installRoot = resolveInstallRoot(env, home);
+  const installBin = resolveInstalledBin(env, platform, home);
+  const installMeta = resolveInstallMetaPath(env, home);
+  const asset = assetNameFor(platform, arch);
+  const checksumsAsset = checksumsAssetNameFor(platform, arch);
+  const baseUrl = env.OFFDEX_RELEASE_BASE_URL
+    || `https://github.com/${REPO}/releases/download/v${version}`;
+
+  await mkdir(join(installRoot, "bin"), { recursive: true });
+
+  let checksumsText;
+  try {
+    checksumsText = await requestTextFn(`${baseUrl}/${checksumsAsset}`);
+  } catch {
+    throw new Error(`failed_download:${checksumsAsset}`);
+  }
+  const expectedChecksum = parseChecksumForAsset(checksumsText, asset);
+  if (!expectedChecksum) {
+    throw new Error(`missing_checksum:${asset}`);
+  }
+
+  const tempPath = `${installBin}.download`;
+  try {
+    try {
+      await downloadFn(`${baseUrl}/${asset}`, tempPath);
+    } catch {
+      throw new Error(`failed_download:${asset}`);
+    }
+    const actualChecksum = createHash("sha256").update(readFileSync(tempPath)).digest("hex");
+    if (actualChecksum !== expectedChecksum) {
+      throw new Error(`checksum_mismatch:${asset}`);
+    }
+    if (platform !== "win32") {
+      await chmod(tempPath, 0o755);
+    }
+    await rm(installBin, { force: true });
+    await rename(tempPath, installBin);
+  } catch (error) {
+    await rm(tempPath, { force: true });
+    throw error;
+  }
+  if (platform !== "win32") {
+    await chmod(installBin, 0o755);
+  }
+
+  await writeFile(
+    installMeta,
+    JSON.stringify(
+      {
+        packageManager: packageManagerHintFromEnv(env),
+        version
+      },
+      null,
+      2
+    )
+  );
+
+  return { asset, installBin, installRoot, version };
+}
+
+export function readInstalledVersion(env = process.env, home = homedir()) {
+  const metaPath = resolveInstallMetaPath(env, home);
+  if (!existsSync(metaPath)) return null;
+  try {
+    return JSON.parse(readFileSync(metaPath, "utf8")).version || null;
+  } catch {
+    return null;
+  }
+}

package/bin/install.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import {
+  installRuntime,
+  resolvePackageVersion,
+  shouldSkipPackageInstall,
+  supportedPlatformList
+} from "./install-lib.js";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const packageRoot = join(here, "..");
+const packageVersion = resolvePackageVersion(join(packageRoot, "package.json"), process.env);
+
+if (shouldSkipPackageInstall({ env: process.env, packageRoot })) {
+  console.log("offdex: skipping native runtime install inside workspace checkout");
+  process.exit(0);
+}
+
+installRuntime({ version: packageVersion })
+  .then(({ installBin }) => {
+    console.log(`offdex: installed ${installBin}`);
+  })
+  .catch((error) => {
+    const message = error instanceof Error ? error.message : "unknown";
+    console.error(`offdex: install failed (${message})`);
+    if (typeof message === "string" && message.startsWith("unsupported_platform:")) {
+      console.error(`offdex: supported targets are ${supportedPlatformList().join(", ")}`);
+    }
+    process.exit(1);
+  });

package/bin/offdex-lib.js

@@ -0,0 +1,21 @@
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { readInstalledVersion, resolveInstalledBin, shouldInstallBinary } from "./install-lib.js";
+
+export function resolvePackageBinDir(moduleUrl = import.meta.url) {
+  return dirname(fileURLToPath(moduleUrl));
+}
+
+export function readPackageVersion(moduleUrl = import.meta.url) {
+  const binDir = resolvePackageBinDir(moduleUrl);
+  const packageJsonPath = join(binDir, "..", "package.json");
+  const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  return pkg.version;
+}
+
+export function installedVersion(env = process.env) {
+  return readInstalledVersion(env);
+}
+
+export { resolveInstalledBin, shouldInstallBinary };

package/bin/offdex.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+import { existsSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { join } from "node:path";
+
+import {
+  installedVersion,
+  readPackageVersion,
+  resolveInstalledBin,
+  resolvePackageBinDir,
+  shouldInstallBinary
+} from "./offdex-lib.js";
+
+const args = process.argv.slice(2);
+const installedBin = resolveInstalledBin(process.env, process.platform);
+const packageVersion = readPackageVersion();
+const currentInstalledVersion = installedVersion(process.env);
+
+if (
+  shouldInstallBinary({
+    binExists: existsSync(installedBin),
+    installedVersion: currentInstalledVersion,
+    packageVersion
+  })
+) {
+  console.error("offdex: setting up native runtime...");
+  const here = resolvePackageBinDir(import.meta.url);
+  const installer = join(here, "install.js");
+  const install = spawnSync(process.execPath, [installer], {
+    stdio: "inherit",
+    env: process.env
+  });
+  if (install.status !== 0 || !existsSync(installedBin)) {
+    console.error("offdex: install missing. try reinstall: npm i -g @dhruv2mars/offdex");
+    process.exit(1);
+  }
+}
+
+const result = spawnSync(installedBin, args, {
+  stdio: "inherit",
+  env: process.env
+});
+process.exit(result.status ?? 1);

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@dhruv2mars/offdex",
+  "version": "0.0.1",
+  "description": "Codex mobile bridge CLI for Offdex",
+  "type": "module",
+  "bin": {
+    "offdex": "bin/offdex.js"
+  },
+  "files": [
+    "bin"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "offdex": "node bin/offdex.js",
+    "postinstall": "node bin/install.js",
+    "build": "node -e \"process.exit(0)\"",
+    "check": "node --check bin/offdex.js && node --check bin/offdex-lib.js && node --check bin/install.js && node --check bin/install-lib.js && node --test test/*.test.js",
+    "test": "node --test test/*.test.js"
+  },
+  "homepage": "https://github.com/Dhruv2mars/offdex#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Dhruv2mars/offdex.git",
+    "directory": "packages/npm"
+  },
+  "bugs": {
+    "url": "https://github.com/Dhruv2mars/offdex/issues"
+  },
+  "keywords": [
+    "codex",
+    "offdex",
+    "cli",
+    "bridge"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "preferGlobal": true,
+  "license": "MIT"
+}