@apilift/cli 1.0.2

package/dist/apilift-register-native-host.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+
+// src/bin/register-native-host.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { basename, dirname as dirname2, isAbsolute as isAbsolute2, join as join2, resolve as resolve2 } from "node:path";
+
+// src/native-host/registration.ts
+import { createHash } from "node:crypto";
+import { homedir, platform } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { chmod, mkdir, readFile, rename, writeFile, copyFile } from "node:fs/promises";
+var fingerprint = (bytes) => createHash("sha256").update(bytes).digest("hex");
+var hostNames = /* @__PURE__ */ new Set(["com.apilift.browser", "com.apilift.browser.dev"]);
+var validId = /^[a-p]{32}$/;
+var posixQuote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+function manifestDirectory(env = process.env) {
+  if (env.APILIFT_NATIVE_MESSAGING_DIR) return resolve(env.APILIFT_NATIVE_MESSAGING_DIR);
+  const home = homedir();
+  if (platform() === "darwin") return join(home, "Library", "Application Support", "Google", "Chrome", "NativeMessagingHosts");
+  if (platform() === "win32") throw new Error("Windows native-host registration needs a data-root manifest and HKCU registry entry");
+  return join(home, ".config", "google-chrome", "NativeMessagingHosts");
+}
+async function registerNativeHost(options2) {
+  const env = options2.env ?? process.env;
+  const hostName = options2.hostName ?? "com.apilift.browser";
+  if (!hostNames.has(hostName)) throw new Error("Unknown Apilift native host name");
+  if (!validId.test(options2.extensionId)) throw new Error("Extension id must be 32 a\u2013p characters");
+  if (![options2.root, options2.hostScript, options2.nodePath ?? process.execPath].every(isAbsolute)) throw new Error("Native host paths must be absolute");
+  const siteUrl = options2.siteUrl ? new URL(options2.siteUrl) : null;
+  if (siteUrl && (!["http:", "https:"].includes(siteUrl.protocol) || siteUrl.origin !== options2.siteUrl)) throw new Error("Native host site URL must be an http(s) origin");
+  const root = resolve(options2.root), hostScript = resolve(options2.hostScript), nodePath = resolve(options2.nodePath ?? process.execPath);
+  const nativeRoot = join(root, "native-host");
+  const manifestRoot = env.APILIFT_NATIVE_MESSAGING_DIR ? resolve(env.APILIFT_NATIVE_MESSAGING_DIR) : platform() === "win32" ? nativeRoot : manifestDirectory(env);
+  const launcher = join(nativeRoot, platform() === "win32" ? "launcher.cmd" : "launcher.sh");
+  const manifest = join(manifestRoot, `${hostName}.json`);
+  const receiptPath = join(nativeRoot, "registration.json");
+  const previous = await readFile(receiptPath, "utf8").then((value) => JSON.parse(value)).catch(() => ({}));
+  const guard = async (path) => {
+    const bytes = await readFile(path).catch(() => null);
+    if (!bytes || fingerprint(bytes) === previous[path]) return;
+    if (!options2.allowReplaceUnowned) throw new Error(`Native host registration is not owned by Apilift: ${path}`);
+    await mkdir(join(nativeRoot, "backup"), { recursive: true, mode: 448 });
+    await copyFile(path, join(nativeRoot, "backup", `${fingerprint(bytes)}-${Date.now()}`));
+  };
+  await guard(launcher);
+  await guard(manifest);
+  await mkdir(nativeRoot, { recursive: true, mode: 448 });
+  await mkdir(manifestRoot, { recursive: true, mode: 448 });
+  const launcherText = platform() === "win32" ? `@echo off\r
+set "APILIFT_HOME=${root}"\r
+set "APILIFT_NATIVE_HOST_NAME=${hostName}"\r
+${siteUrl ? `set "APILIFT_URL=${siteUrl.origin}"\r
+` : ""}${env.APILIFT_NATIVE_MESSAGING_DIR ? `set "APILIFT_NATIVE_MESSAGING_DIR=${manifestRoot}"\r
+` : ""}"${nodePath}" "${hostScript}" %*\r
+` : `#!/bin/sh
+APILIFT_HOME=${posixQuote(root)} APILIFT_NATIVE_HOST_NAME=${posixQuote(hostName)} ${siteUrl ? `APILIFT_URL=${posixQuote(siteUrl.origin)} ` : ""}${env.APILIFT_NATIVE_MESSAGING_DIR ? `APILIFT_NATIVE_MESSAGING_DIR=${posixQuote(manifestRoot)} ` : ""}exec ${posixQuote(nodePath)} ${posixQuote(hostScript)} "$@"
+`;
+  const manifestText = JSON.stringify({ name: hostName, description: "Apilift browser bridge", path: launcher, type: "stdio", allowed_origins: [`chrome-extension://${options2.extensionId}/`] }, null, 2) + "\n";
+  const atomicWrite = async (path, bytes, mode) => {
+    const temp = join(dirname(path), `.${hostName}-${process.pid}-${Date.now()}.tmp`);
+    await writeFile(temp, bytes, { mode });
+    await chmod(temp, mode);
+    await rename(temp, path);
+  };
+  await atomicWrite(launcher, launcherText, platform() === "win32" ? 384 : 448);
+  await atomicWrite(manifest, manifestText, 384);
+  const receipt = { ...previous, [launcher]: fingerprint(launcherText), [manifest]: fingerprint(manifestText) };
+  await atomicWrite(receiptPath, JSON.stringify(receipt, null, 2) + "\n", 384);
+  if (platform() === "win32" && !env.APILIFT_NATIVE_MESSAGING_DIR) {
+    const { execFileSync } = await import("node:child_process");
+    execFileSync("reg.exe", ["add", `HKCU\\Software\\Google\\Chrome\\NativeMessagingHosts\\${hostName}`, "/ve", "/t", "REG_SZ", "/d", manifest, "/f"], { stdio: "ignore" });
+  }
+  return { launcher, manifest, hostName };
+}
+
+// src/bin/register-native-host.ts
+function options(argv) {
+  const values = /* @__PURE__ */ new Map();
+  let replaceStaleOwned = false;
+  for (let index = 0; index < argv.length; index++) {
+    const flag = argv[index];
+    if (flag === "--replace-stale-owned") {
+      replaceStaleOwned = true;
+      continue;
+    }
+    if (!["--root", "--host-script", "--extension-id", "--host-name", "--site-url"].includes(flag)) throw new Error(`Unknown registration option: ${flag}`);
+    const value = argv[++index];
+    if (!value || value.startsWith("--") || values.has(flag)) throw new Error(`Registration option ${flag} needs one value`);
+    values.set(flag, value);
+  }
+  const root = values.get("--root"), hostScript = values.get("--host-script"), extensionId = values.get("--extension-id");
+  if (!root || !hostScript || !extensionId || !isAbsolute2(root) || !isAbsolute2(hostScript)) throw new Error("Use absolute --root and --host-script paths and pass --extension-id");
+  return { root: resolve2(root), hostScript: resolve2(hostScript), extensionId, hostName: values.get("--host-name") ?? "com.apilift.browser.dev", siteUrl: values.get("--site-url"), replaceStaleOwned };
+}
+function staleOwnedByThisWorktree(input) {
+  if (input.hostName !== "com.apilift.browser.dev" || process.env.APILIFT_NATIVE_MESSAGING_DIR) return false;
+  const state = dirname2(input.root), runtimePath = join2(state, "runtime.json");
+  try {
+    const runtime = JSON.parse(readFileSync(runtimePath, "utf8"));
+    const currentRoot = resolve2(process.cwd());
+    const instance = createHash2("sha256").update(currentRoot).digest("hex").slice(0, 10);
+    if (runtime.schema !== "apilift.dev/v1" || resolve2(runtime.root ?? "") !== currentRoot || resolve2(runtime.state ?? "") !== state || runtime.instance !== instance || input.root !== join2(state, "cli")) return false;
+    const path = join2(manifestDirectory(process.env), `${input.hostName}.json`);
+    if (!existsSync(path)) return false;
+    const manifest = JSON.parse(readFileSync(path, "utf8"));
+    const oldPath = manifest.path ?? "";
+    return manifest.name === input.hostName && basename(oldPath) === "apilift-native-host" && realpathSync(dirname2(oldPath)) === realpathSync(state) && manifest.allowed_origins?.length === 1 && manifest.allowed_origins[0] === `chrome-extension://${input.extensionId}/`;
+  } catch {
+    return false;
+  }
+}
+try {
+  const input = options(process.argv.slice(2));
+  if (input.replaceStaleOwned && !staleOwnedByThisWorktree(input)) throw new Error("The existing registration is not the former native host for this worktree");
+  const installed = await registerNativeHost({ root: input.root, hostScript: input.hostScript, extensionId: input.extensionId, hostName: input.hostName, siteUrl: input.siteUrl, allowReplaceUnowned: input.replaceStaleOwned });
+  process.stdout.write(JSON.stringify({ hostName: installed.hostName, extensionId: input.extensionId, launcher: installed.launcher, manifest: installed.manifest, receipt: join2(input.root, "native-host", "registration.json") }) + "\n");
+} catch (error) {
+  process.stderr.write(`${error instanceof Error ? error.message : "Native host registration failed"}
+`);
+  process.exitCode = 1;
+}