@onequery/cli 0.1.2-linux-x64 → 0.1.2

package/bin/onequery.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { chmodSync, existsSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  CLI_BINARY_NAME,
+  CLI_PACKAGE_NAME,
+  CLI_SERVER_BINARY_NAME,
+  PLATFORM_PACKAGE_BY_TARGET,
+  resolveTargetTriple,
+} from "./package-constants.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const require = createRequire(import.meta.url);
+
+const { platform, arch } = process;
+const targetTriple = resolveTargetTriple(platform, arch);
+
+const platformPackage = PLATFORM_PACKAGE_BY_TARGET[targetTriple];
+if (!platformPackage) {
+  throw new Error(`Unsupported target triple: ${targetTriple}`);
+}
+
+// CONTEXT: platform packages are installed through npm alias names so the
+// launcher resolves the alias folder, not the underlying published package id.
+const localVendorRoot = path.join(__dirname, "..", "vendor");
+const localBinaryPath = path.join(
+  localVendorRoot,
+  targetTriple,
+  "onequery",
+  CLI_BINARY_NAME
+);
+const packageRoot = path.resolve(__dirname, "..");
+
+let vendorRoot;
+try {
+  const packageJsonPath = require.resolve(`${platformPackage}/package.json`);
+  vendorRoot = path.join(path.dirname(packageJsonPath), "vendor");
+} catch {
+  if (existsSync(localBinaryPath)) {
+    vendorRoot = localVendorRoot;
+  } else {
+    const packageManager = detectPackageManager();
+    const reinstallCommand =
+      packageManager === "bun"
+        ? `bun install -g ${CLI_PACKAGE_NAME}@latest`
+        : `npm install -g ${CLI_PACKAGE_NAME}@latest`;
+    throw new Error(
+      `Missing optional dependency ${platformPackage}. Reinstall OneQuery CLI: ${reinstallCommand}`
+    );
+  }
+}
+
+const binaryPath = path.join(
+  vendorRoot,
+  targetTriple,
+  "onequery",
+  CLI_BINARY_NAME
+);
+const serverBinaryPath = path.join(
+  vendorRoot,
+  targetTriple,
+  "server",
+  CLI_SERVER_BINARY_NAME
+);
+
+ensureExecutable(binaryPath);
+if (existsSync(serverBinaryPath)) {
+  ensureExecutable(serverBinaryPath);
+}
+
+const child = spawn(binaryPath, process.argv.slice(2), {
+  env: {
+    ...process.env,
+    ONEQUERY_NPM_ROOT: process.env.ONEQUERY_NPM_ROOT ?? packageRoot,
+    ONEQUERY_RUNTIME_ROOT: process.env.ONEQUERY_RUNTIME_ROOT ?? packageRoot,
+    ONEQUERY_SERVER_EXECUTABLE:
+      process.env.ONEQUERY_SERVER_EXECUTABLE ?? serverBinaryPath,
+  },
+  stdio: "inherit",
+});
+
+child.on("error", (error) => {
+  console.error(error);
+  process.exit(1);
+});
+
+const forwardSignal = (signal) => {
+  if (child.killed) {
+    return;
+  }
+
+  try {
+    child.kill(signal);
+  } catch {
+    // Ignore forwarding failures if the child already exited.
+  }
+};
+
+["SIGINT", "SIGTERM", "SIGHUP"].forEach((signal) => {
+  process.on(signal, () => forwardSignal(signal));
+});
+
+const childResult = await new Promise((resolve) => {
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      resolve({ signal, type: "signal" });
+      return;
+    }
+
+    resolve({ exitCode: code ?? 1, type: "code" });
+  });
+});
+
+if (childResult.type === "signal") {
+  process.kill(process.pid, childResult.signal);
+} else {
+  process.exit(childResult.exitCode);
+}
+
+function detectPackageManager() {
+  const userAgent = process.env.npm_config_user_agent ?? "";
+  if (/\bbun\//.test(userAgent)) {
+    return "bun";
+  }
+
+  const execPath = process.env.npm_execpath ?? "";
+  if (execPath.includes("bun")) {
+    return "bun";
+  }
+
+  if (
+    __dirname.includes(".bun/install/global") ||
+    __dirname.includes(".bun\\install\\global")
+  ) {
+    return "bun";
+  }
+
+  return userAgent ? "npm" : null;
+}
+
+function ensureExecutable(filePath) {
+  const currentMode = statSync(filePath).mode & 0o777;
+  if ((currentMode & 0o111) !== 0) {
+    return;
+  }
+
+  // CONTEXT: npm tarballs store vendored native binaries without execute bits,
+  // so restore the expected mode before spawning the packaged CLI binary.
+  chmodSync(filePath, currentMode | 0o755);
+}

package/bin/package-constants.js

@@ -0,0 +1,95 @@
+export const CLI_PACKAGE_NAME = "@onequery/cli";
+export const CLI_BINARY_NAME = "onequery";
+export const CLI_SERVER_BINARY_NAME = "onequery-server";
+export const CLI_NPM_TARBALL_PREFIX = "onequery-npm";
+export const CLI_NPM_STAGE_DIR_PREFIX = `${CLI_NPM_TARBALL_PREFIX}-stage-`;
+export const CLI_NPM_PACK_DIR_PREFIX = `${CLI_NPM_TARBALL_PREFIX}-pack-`;
+export const CLI_STAGE_PACKAGE_DIR_PREFIX = "onequery-cli-";
+
+export const PLATFORM_PACKAGES = {
+  "cli-darwin-arm64": {
+    optionalDependencyName: "onequery-darwin-arm64",
+    npmTag: "darwin-arm64",
+    targetTriple: "aarch64-apple-darwin",
+    os: "darwin",
+    cpu: "arm64",
+  },
+  "cli-darwin-x64": {
+    optionalDependencyName: "onequery-darwin-x64",
+    npmTag: "darwin-x64",
+    targetTriple: "x86_64-apple-darwin",
+    os: "darwin",
+    cpu: "x64",
+  },
+  "cli-linux-arm64": {
+    optionalDependencyName: "onequery-linux-arm64",
+    npmTag: "linux-arm64",
+    targetTriple: "aarch64-unknown-linux-musl",
+    os: "linux",
+    cpu: "arm64",
+  },
+  "cli-linux-x64": {
+    optionalDependencyName: "onequery-linux-x64",
+    npmTag: "linux-x64",
+    targetTriple: "x86_64-unknown-linux-musl",
+    os: "linux",
+    cpu: "x64",
+  },
+};
+
+export const PLATFORM_PACKAGE_BY_TARGET = Object.fromEntries(
+  Object.values(PLATFORM_PACKAGES).map((platformPackage) => [
+    platformPackage.targetTriple,
+    platformPackage.optionalDependencyName,
+  ])
+);
+
+export const SERVER_COMPILE_TARGET_BY_RUST_TARGET = {
+  "aarch64-apple-darwin": "bun-darwin-arm64",
+  "aarch64-unknown-linux-musl": "bun-linux-arm64-musl",
+  "x86_64-apple-darwin": "bun-darwin-x64",
+  "x86_64-unknown-linux-musl": "bun-linux-x64-musl",
+};
+
+export function packageStagingDirPrefix(packageName) {
+  return `${CLI_STAGE_PACKAGE_DIR_PREFIX}${packageName}-`;
+}
+
+export function resolveTargetTriple(platform, arch) {
+  switch (platform) {
+    case "linux":
+    case "android": {
+      switch (arch) {
+        case "x64":
+          return "x86_64-unknown-linux-musl";
+        case "arm64":
+          return "aarch64-unknown-linux-musl";
+        default:
+          break;
+      }
+      break;
+    }
+    case "darwin": {
+      switch (arch) {
+        case "x64":
+          return "x86_64-apple-darwin";
+        case "arm64":
+          return "aarch64-apple-darwin";
+        default:
+          break;
+      }
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+
+  if (platform === "win32") {
+    throw new Error(
+      "Unsupported platform: win32. The published OneQuery package currently supports macOS and Linux only."
+    );
+  }
+
+  throw new Error(`Unsupported platform: ${platform} (${arch})`);
+}

package/package.json

@@ -1,27 +1,32 @@
 {
-  "cpu": [
-    "x64"
-  ],
+  "name": "@onequery/cli",
+  "version": "0.1.2",
   "description": "OneQuery CLI",
-  "files": [
-    "vendor",
-    "README.md"
-  ],
   "license": "Apache-2.0",
-  "name": "@onequery/cli",
-  "os": [
-    "linux"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/wordbricks/onequery.git",
     "directory": "apps/cli"
   },
-  "version": "0.1.2-linux-x64",
+  "bin": {
+    "onequery": "bin/onequery.js"
+  },
+  "files": [
+    "bin",
+    "runtime",
+    "README.md"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
   "engines": {
     "node": ">=18"
+  },
+  "optionalDependencies": {
+    "onequery-darwin-arm64": "npm:@onequery/cli@0.1.2-darwin-arm64",
+    "onequery-darwin-x64": "npm:@onequery/cli@0.1.2-darwin-x64",
+    "onequery-linux-arm64": "npm:@onequery/cli@0.1.2-linux-arm64",
+    "onequery-linux-x64": "npm:@onequery/cli@0.1.2-linux-x64"
   }
 }