kagi-cli 0.1.4

package/README.md

@@ -0,0 +1,19 @@
+# kagi-cli
+
+This package installs the native `kagi` CLI binary for the current platform.
+
+Global install examples:
+
+```bash
+npm install -g kagi-cli
+pnpm add -g kagi-cli
+bun add -g kagi-cli
+```
+
+Then run:
+
+```bash
+kagi --help
+```
+
+The package name is `kagi-cli`, but the installed command is always `kagi`.

package/bin/kagi.cjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+const { spawn } = require("node:child_process");
+const { ensureInstalled, getBinaryPath } = require("../lib/install.cjs");
+
+async function main() {
+  await ensureInstalled({ quiet: false });
+
+  const child = spawn(getBinaryPath(), process.argv.slice(2), {
+    stdio: "inherit",
+  });
+
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+
+    process.exit(code ?? 0);
+  });
+
+  child.on("error", (error) => {
+    console.error(`failed to start kagi: ${error.message}`);
+    process.exit(1);
+  });
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/lib/install.cjs

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const fsp = require("node:fs/promises");
+const https = require("node:https");
+const path = require("node:path");
+
+const packageRoot = path.resolve(__dirname, "..");
+const packageJson = require(path.join(packageRoot, "package.json"));
+
+const binaryBaseName = process.platform === "win32" ? "kagi.exe" : "kagi";
+const releaseTag = `v${packageJson.version}`;
+const repo = "Microck/kagi-cli";
+
+function detectTarget() {
+  const os = process.platform;
+  const arch = process.arch;
+
+  const archPart =
+    arch === "x64" ? "x86_64" :
+    arch === "arm64" ? "aarch64" :
+    null;
+
+  if (!archPart) {
+    throw new Error(`unsupported CPU architecture for kagi: ${arch}`);
+  }
+
+  const osPart =
+    os === "linux" ? "unknown-linux-gnu" :
+    os === "darwin" ? "apple-darwin" :
+    os === "win32" ? "pc-windows-msvc" :
+    null;
+
+  if (!osPart) {
+    throw new Error(`unsupported operating system for kagi: ${os}`);
+  }
+
+  return `${archPart}-${osPart}`;
+}
+
+function getBinaryPath() {
+  return path.join(packageRoot, "vendor", detectTarget(), binaryBaseName);
+}
+
+function getAssetFileName() {
+  return `${binaryBaseName.replace(/\.exe$/, "")}-${releaseTag}-${detectTarget()}${process.platform === "win32" ? ".exe" : ""}`;
+}
+
+function getAssetUrl() {
+  return `https://github.com/${repo}/releases/download/${releaseTag}/${getAssetFileName()}`;
+}
+
+function download(url, destination) {
+  return new Promise((resolve, reject) => {
+    const request = https.get(
+      url,
+      {
+        headers: {
+          "User-Agent": "kagi-cli-installer",
+          "Accept": "application/octet-stream",
+        },
+      },
+      (response) => {
+        if (
+          response.statusCode &&
+          response.statusCode >= 300 &&
+          response.statusCode < 400 &&
+          response.headers.location
+        ) {
+          response.resume();
+          download(response.headers.location, destination).then(resolve, reject);
+          return;
+        }
+
+        if (response.statusCode !== 200) {
+          response.resume();
+          reject(
+            new Error(
+              `failed to download ${url} - HTTP ${response.statusCode ?? "unknown"}`
+            )
+          );
+          return;
+        }
+
+        const file = fs.createWriteStream(destination, { mode: 0o755 });
+        response.pipe(file);
+
+        file.on("finish", () => {
+          file.close(resolve);
+        });
+
+        file.on("error", (error) => {
+          reject(error);
+        });
+      }
+    );
+
+    request.on("error", reject);
+  });
+}
+
+async function ensureInstalled({ quiet }) {
+  const binaryPath = getBinaryPath();
+
+  try {
+    await fsp.access(binaryPath, fs.constants.X_OK);
+    return binaryPath;
+  } catch {
+    const vendorDir = path.dirname(binaryPath);
+    const tempPath = `${binaryPath}.tmp`;
+    const assetUrl = getAssetUrl();
+
+    if (!quiet) {
+      console.error(`Downloading native kagi binary from ${assetUrl}`);
+    }
+
+    await fsp.mkdir(vendorDir, { recursive: true });
+    await download(assetUrl, tempPath);
+    await fsp.rename(tempPath, binaryPath);
+
+    if (process.platform !== "win32") {
+      await fsp.chmod(binaryPath, 0o755);
+    }
+
+    return binaryPath;
+  }
+}
+
+if (require.main === module) {
+  ensureInstalled({ quiet: false }).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  detectTarget,
+  ensureInstalled,
+  getAssetFileName,
+  getAssetUrl,
+  getBinaryPath,
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "kagi-cli",
+  "version": "0.1.4",
+  "description": "Node wrapper that installs the native kagi CLI binary",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Microck/kagi-cli.git"
+  },
+  "homepage": "https://github.com/Microck/kagi-cli#readme",
+  "bugs": {
+    "url": "https://github.com/Microck/kagi-cli/issues"
+  },
+  "bin": {
+    "kagi": "bin/kagi.cjs"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "node lib/install.cjs"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "keywords": [
+    "kagi",
+    "cli",
+    "search",
+    "terminal",
+    "rust"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "preferGlobal": true
+}