nolo-cli 0.71.0 → 0.72.0

package/chromeCommands-VOIRNJBL.js

@@ -0,0 +1,499 @@
+import {
+  NOLO_CHROME_CONNECTOR_EXTENSION_ID,
+  NOLO_CHROME_CONNECTOR_PROTOCOL_VERSION,
+  REQUIRED_CHROME_CONNECTOR_FEATURES,
+  createChromeConnectorClient
+} from "./chunk-QCZX4FTW.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import "./chunk-KUG52IAP.js";
+import "./chunk-4VNS5WPM.js";
+
+// packages/cli/chromeCommands.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+
+// packages/desktop-chrome-connector/nativeHostInstall.mjs
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createHash, randomBytes } from "node:crypto";
+import { dirname, resolve } from "node:path";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+var DEFAULT_CONNECTOR_ROOT = dirname(fileURLToPath(import.meta.url));
+function extensionIdFromPublicKey(publicKeyBase64) {
+  const digest = createHash("sha256").update(Buffer.from(publicKeyBase64, "base64")).digest();
+  return Array.from(
+    digest.subarray(0, 16),
+    (byte) => `${String.fromCharCode(97 + (byte >> 4))}${String.fromCharCode(97 + (byte & 15))}`
+  ).join("");
+}
+function resolveNodePath() {
+  if (typeof Bun !== "undefined" && typeof Bun.which === "function") {
+    const bunResolvedNode = Bun.which("node");
+    if (bunResolvedNode) return bunResolvedNode;
+  }
+  const resolved = execFileSync("/usr/bin/env", ["node", "-p", "process.execPath"], {
+    encoding: "utf8"
+  }).trim();
+  return resolved || "node";
+}
+function nativeMessagingHostsDir({
+  home = process.env.HOME || "",
+  platform = process.platform
+} = {}) {
+  if (platform === "darwin") {
+    return resolve(home, "Library/Application Support/Google/Chrome/NativeMessagingHosts");
+  }
+  if (platform === "linux") {
+    return resolve(home, ".config/google-chrome/NativeMessagingHosts");
+  }
+  throw new Error(
+    `Native host installation is not implemented for platform "${platform}". Windows needs a registry value under HKCU\\Software\\Google\\Chrome\\NativeMessagingHosts pointing at the manifest file, plus an executable launcher: Chrome starts the manifest's path as a process, so a shell wrapper will not work there.`
+  );
+}
+function resolveNativeHostInstallPaths({
+  home = process.env.HOME || "",
+  connectorRoot = DEFAULT_CONNECTOR_ROOT,
+  platform = process.platform
+} = {}) {
+  const supportDir = resolve(home, "Library/Application Support/Nolo/ChromeConnector");
+  return {
+    connectorRoot,
+    extensionManifestPath: resolve(connectorRoot, "extension", "manifest.json"),
+    hostPath: resolve(connectorRoot, "native-host", "nolo-chrome-native-host.mjs"),
+    templatePath: resolve(connectorRoot, "native-host", "com.nolo.chrome_connector.json"),
+    nativeManifestPath: resolve(
+      nativeMessagingHostsDir({ home, platform }),
+      "com.nolo.chrome_connector.json"
+    ),
+    supportDir,
+    tokenPath: resolve(supportDir, "token"),
+    wrapperPath: resolve(supportDir, "nolo-chrome-native-host")
+  };
+}
+function installNativeHostManifest({
+  home = process.env.HOME || "",
+  connectorRoot = DEFAULT_CONNECTOR_ROOT,
+  platform = process.platform,
+  extensionId,
+  nodePath
+} = {}) {
+  const paths = resolveNativeHostInstallPaths({ home, connectorRoot, platform });
+  const manifest = JSON.parse(readFileSync(paths.templatePath, "utf8"));
+  const extensionManifest = JSON.parse(readFileSync(paths.extensionManifestPath, "utf8"));
+  const resolvedExtensionId = extensionId || extensionIdFromPublicKey(extensionManifest.key);
+  const resolvedNodePath = nodePath || resolveNodePath();
+  mkdirSync(paths.supportDir, { recursive: true });
+  const existingToken = existsSync(paths.tokenPath) ? readFileSync(paths.tokenPath, "utf8").trim() : "";
+  const token = existingToken || randomBytes(32).toString("hex");
+  writeFileSync(paths.tokenPath, `${token}
+`, { mode: 384 });
+  writeFileSync(
+    paths.wrapperPath,
+    `#!/bin/sh
+NOLO_CHROME_CONNECTOR_TOKEN=${JSON.stringify(token)} exec ${JSON.stringify(resolvedNodePath)} ${JSON.stringify(paths.hostPath)}
+`
+  );
+  chmodSync(paths.wrapperPath, 493);
+  manifest.path = paths.wrapperPath;
+  manifest.allowed_origins = [`chrome-extension://${resolvedExtensionId}/`];
+  mkdirSync(dirname(paths.nativeManifestPath), { recursive: true });
+  writeFileSync(paths.nativeManifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+  return {
+    extensionId: resolvedExtensionId,
+    nodePath: resolvedNodePath,
+    tokenPath: paths.tokenPath,
+    ...paths
+  };
+}
+
+// packages/cli/chromeCommands.ts
+var CLI_CONNECTOR_ROOT_CANDIDATES = [
+  "../desktop-chrome-connector",
+  "../../desktop-chrome-connector",
+  "../integrations/connector",
+  "../../integrations/connector"
+];
+var FULL_SUPPORT_CHROME_FEATURES = [
+  ...new Set(Object.values(REQUIRED_CHROME_CONNECTOR_FEATURES).flat())
+].sort();
+function pickCliConnectorRoot(candidates) {
+  for (const candidate of candidates) {
+    if (existsSync2(resolve2(candidate, "extension", "manifest.json"))) return candidate;
+  }
+  return null;
+}
+function resolveCliConnectorRoot(args = {}) {
+  const env = args.env ?? process.env;
+  const moduleDir = args.moduleDir ?? import.meta.dir;
+  const override = (env.NOLO_CHROME_CONNECTOR_ROOT ?? "").trim();
+  if (override) {
+    const resolvedOverride = resolve2(override);
+    if (!existsSync2(resolve2(resolvedOverride, "extension", "manifest.json"))) {
+      throw new Error(
+        `NOLO_CHROME_CONNECTOR_ROOT is set to ${resolvedOverride}, but it contains no extension/manifest.json. Unset it or point it at a Nolo Chrome connector checkout.`
+      );
+    }
+    return resolvedOverride;
+  }
+  const candidates = CLI_CONNECTOR_ROOT_CANDIDATES.map(
+    (relative) => resolve2(moduleDir, relative)
+  );
+  const found = pickCliConnectorRoot(candidates);
+  if (!found) {
+    throw new Error(
+      `Nolo Chrome connector sources not found. Run the CLI from a repo checkout that contains packages/desktop-chrome-connector, or set NOLO_CHROME_CONNECTOR_ROOT. Probed: ${candidates.join(", ")}`
+    );
+  }
+  return found;
+}
+function detectWorktreeCheckout(connectorRoot) {
+  const resolvedRoot = resolve2(connectorRoot);
+  let dir = resolvedRoot;
+  let checkoutRoot = null;
+  for (let depth = 0; depth < 8; depth += 1) {
+    const gitEntry = resolve2(dir, ".git");
+    if (existsSync2(gitEntry)) {
+      let isGitFile = null;
+      try {
+        isGitFile = statSync(gitEntry).isFile();
+      } catch {
+      }
+      if (isGitFile === true) {
+        try {
+          const match = /^gitdir:\s*(.+)$/m.exec(readFileSync2(gitEntry, "utf8"));
+          const gitDir = match ? resolve2(dir, match[1].trim()) : null;
+          if (gitDir && gitDir.split(/[\\/]+/).includes("worktrees")) {
+            return { worktreeRoot: dir, mainRoot: resolve2(gitDir, "..", "..", "..") };
+          }
+        } catch {
+        }
+      } else if (isGitFile === false) {
+        checkoutRoot = dir;
+      }
+      break;
+    }
+    const parent = resolve2(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  const segments = resolvedRoot.split(/[\\/]+/);
+  const markerIndex = segments.indexOf(".worktrees");
+  if (markerIndex <= 0) return null;
+  if (checkoutRoot) {
+    const checkoutDepth = resolve2(checkoutRoot).split(/[\\/]+/).length;
+    if (markerIndex < checkoutDepth) return null;
+  }
+  return {
+    worktreeRoot: segments.slice(0, markerIndex + 2).join("/"),
+    mainRoot: segments.slice(0, markerIndex).join("/") || "/"
+  };
+}
+function readExtensionManifest(connectorRoot) {
+  try {
+    return JSON.parse(
+      readFileSync2(resolve2(connectorRoot, "extension", "manifest.json"), "utf8")
+    );
+  } catch {
+    return null;
+  }
+}
+function readJsonFile(path) {
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function probeConnectorRpc(requestChrome) {
+  try {
+    const connectorInfo = await requestChrome("connector_info", {}) ?? {};
+    const features = Array.isArray(connectorInfo.features) ? connectorInfo.features.filter(
+      (entry) => typeof entry === "string"
+    ) : [];
+    return {
+      online: true,
+      extensionId: typeof connectorInfo.extensionId === "string" ? connectorInfo.extensionId : null,
+      protocolVersion: typeof connectorInfo.protocolVersion === "string" ? connectorInfo.protocolVersion : null,
+      features
+    };
+  } catch (error) {
+    return {
+      online: false,
+      extensionId: null,
+      protocolVersion: null,
+      features: [],
+      error: {
+        code: error?.code ?? "CHROME_CONNECTOR_ERROR",
+        message: toErrorMessage(error)
+      }
+    };
+  }
+}
+function resolveStatusNextStep(report) {
+  if (!report.connectorRoot) {
+    if (report.rpc.online && report.rpc.protocolVersion === report.rpc.expectedProtocolVersion) {
+      return "Chrome connector is online, but this CLI cannot see a connector checkout, so `nolo chrome install` / manifest checks are unavailable here. Set NOLO_CHROME_CONNECTOR_ROOT (or run the CLI from a repo checkout) to enable them.";
+    }
+    return "Run the CLI from a repo checkout that contains packages/desktop-chrome-connector, or set NOLO_CHROME_CONNECTOR_ROOT to one, then rerun `nolo chrome status`.";
+  }
+  if (!report.nativeHost.supported) {
+    return `This platform has no supported native messaging host install (Chrome looks the host up through a registry value on Windows), so non-interactive install is not available: ${report.nativeHost.platformError ?? "unsupported platform"}`;
+  }
+  if (!report.nativeHost.installed || !report.token.present) {
+    return "nolo chrome install";
+  }
+  if (!report.nativeHost.wrapperPathMatches || !report.nativeHost.allowedOriginMatches) {
+    const installedWrapperPath = report.nativeHost.installedWrapperPath;
+    if (!report.nativeHost.wrapperPathMatches && installedWrapperPath && installedWrapperPath !== report.nativeHost.wrapperPath && existsSync2(installedWrapperPath)) {
+      return `Native host is installed for a different checkout (${installedWrapperPath}); this CLI is looking at ${report.connectorRoot}. Run \`nolo chrome status\` from the checkout that installed it, or run \`nolo chrome install\` from here only if Chrome should switch to this one.`;
+    }
+    return "nolo chrome install (the installed manifest does not point at this checkout's wrapper / extension id, which Chrome silently ignores)";
+  }
+  if (!report.rpc.online) {
+    return `Load the unpacked extension from ${report.extension.path} in chrome://extensions (Developer mode) or install it from the Chrome Web Store, then rerun \`nolo chrome status\`.`;
+  }
+  if (report.rpc.extensionId && report.rpc.extensionId !== report.extension.expectedId) {
+    return `The connected extension (${report.rpc.extensionId}) is not the connector at ${report.extension.path}; remove the other copy and rerun \`nolo chrome status\`.`;
+  }
+  if (report.rpc.protocolVersion !== report.rpc.expectedProtocolVersion) {
+    return `nolo chrome reload (the running extension does not speak protocol ${report.rpc.expectedProtocolVersion}; a reload restarts the worker with the files on disk)`;
+  }
+  if (report.rpc.missingFeatures.length > 0) {
+    return `nolo chrome reload (the running extension is missing ${report.rpc.missingFeatures.join(", ")}); if that persists, the checkout's extension is older than the CLI expects.`;
+  }
+  return "Chrome connector is online: chrome_* tools execute against this Chrome profile.";
+}
+async function buildChromeConnectorStatus(args = {}) {
+  const env = args.env ?? process.env;
+  const home = args.home ?? env.HOME ?? "";
+  const platform = args.platform ?? process.platform;
+  let connectorRoot = args.connectorRoot ?? null;
+  let rootError = null;
+  if (!connectorRoot) {
+    try {
+      connectorRoot = resolveCliConnectorRoot({ env });
+    } catch (error) {
+      rootError = toErrorMessage(error);
+    }
+  }
+  const extensionManifest = connectorRoot ? readExtensionManifest(connectorRoot) : null;
+  const expectedId = extensionManifest && typeof extensionManifest.key === "string" ? extensionIdFromPublicKey(extensionManifest.key) : NOLO_CHROME_CONNECTOR_EXTENSION_ID;
+  const report = {
+    ok: false,
+    connectorRoot,
+    extension: {
+      path: connectorRoot ? resolve2(connectorRoot, "extension") : null,
+      expectedId
+    },
+    nativeHost: {
+      supported: true,
+      installed: false,
+      manifestPath: null,
+      wrapperPath: null,
+      installedWrapperPath: null,
+      wrapperPathMatches: false,
+      allowedOriginMatches: false
+    },
+    token: { path: null, present: false },
+    rpc: {
+      online: false,
+      extensionId: null,
+      protocolVersion: null,
+      features: [],
+      missingFeatures: [...FULL_SUPPORT_CHROME_FEATURES],
+      expectedProtocolVersion: NOLO_CHROME_CONNECTOR_PROTOCOL_VERSION
+    },
+    nextStep: ""
+  };
+  const requestChrome = args.requestChrome ?? createChromeConnectorClient().request;
+  const probe = await probeConnectorRpc(requestChrome);
+  report.rpc.online = probe.online;
+  report.rpc.extensionId = probe.extensionId;
+  report.rpc.protocolVersion = probe.protocolVersion;
+  report.rpc.features = probe.features;
+  report.rpc.missingFeatures = FULL_SUPPORT_CHROME_FEATURES.filter(
+    (feature) => !probe.features.includes(feature)
+  );
+  if (!probe.online) report.rpc.error = probe.error;
+  if (!connectorRoot) {
+    if (rootError) report.connectorRootError = rootError;
+    report.ok = report.rpc.online && probe.extensionId === expectedId && probe.protocolVersion === NOLO_CHROME_CONNECTOR_PROTOCOL_VERSION && report.rpc.missingFeatures.length === 0;
+    report.nextStep = resolveStatusNextStep(report);
+    return report;
+  }
+  let paths = null;
+  try {
+    paths = resolveNativeHostInstallPaths({ home, connectorRoot, platform });
+  } catch (error) {
+    report.nativeHost.supported = false;
+    report.nativeHost.platformError = toErrorMessage(error);
+    report.nextStep = resolveStatusNextStep(report);
+    return report;
+  }
+  report.nativeHost.manifestPath = paths.nativeManifestPath;
+  report.nativeHost.wrapperPath = paths.wrapperPath;
+  report.token.path = paths.tokenPath;
+  const installedManifest = existsSync2(paths.nativeManifestPath) ? readJsonFile(paths.nativeManifestPath) : null;
+  report.nativeHost.installed = installedManifest !== null;
+  report.nativeHost.installedWrapperPath = typeof installedManifest?.path === "string" ? installedManifest.path : null;
+  report.nativeHost.wrapperPathMatches = report.nativeHost.installedWrapperPath === paths.wrapperPath;
+  const expectedOrigin = `chrome-extension://${expectedId}/`;
+  report.nativeHost.allowedOriginMatches = Array.isArray(installedManifest?.allowed_origins) && installedManifest.allowed_origins.includes(expectedOrigin);
+  if (existsSync2(paths.tokenPath)) {
+    try {
+      report.token.present = readFileSync2(paths.tokenPath, "utf8").trim().length > 0;
+    } catch {
+      report.token.present = false;
+    }
+  }
+  report.ok = report.nativeHost.supported && report.nativeHost.installed && report.nativeHost.wrapperPathMatches && report.nativeHost.allowedOriginMatches && report.token.present && probe.online && probe.extensionId === expectedId && probe.protocolVersion === NOLO_CHROME_CONNECTOR_PROTOCOL_VERSION && report.rpc.missingFeatures.length === 0;
+  report.nextStep = resolveStatusNextStep(report);
+  return report;
+}
+function yesNo(value) {
+  return value ? "ok" : "mismatch";
+}
+function formatChromeConnectorStatus(report) {
+  const lines = ["Nolo Chrome connector"];
+  lines.push(
+    `  connector source : ${report.connectorRoot ?? "(not found)"}`
+  );
+  lines.push(
+    `  extension        : ${report.extension.path ?? "(not found)"} (id ${report.extension.expectedId})`
+  );
+  lines.push(
+    `  native manifest  : ${!report.nativeHost.supported ? "(unsupported platform)" : report.nativeHost.manifestPath ? `${report.nativeHost.manifestPath} [${report.nativeHost.installed ? "installed" : "missing"}]` : "(not resolved)"}`
+  );
+  if (report.nativeHost.supported && report.nativeHost.installed) {
+    lines.push(`    wrapper path   : ${yesNo(report.nativeHost.wrapperPathMatches)} (${report.nativeHost.installedWrapperPath ?? "unreadable"})`);
+    lines.push(`    allowed origins: ${yesNo(report.nativeHost.allowedOriginMatches)}`);
+  }
+  lines.push(
+    `  token            : ${report.token.present ? "present" : "missing"}${report.token.path ? ` ${report.token.path}` : ""}`
+  );
+  const rpc = report.rpc;
+  if (rpc.online) {
+    lines.push(
+      `  RPC              : online  extension ${rpc.extensionId ?? "unknown"}  protocolVersion ${rpc.protocolVersion ?? "unknown"}  features ${rpc.features.length > 0 ? rpc.features.join(", ") : "(none)"}`
+    );
+  } else {
+    lines.push(
+      `  RPC              : offline  ${rpc.error ? `${rpc.error.code}: ${rpc.error.message}` : ""}`.trimEnd()
+    );
+  }
+  lines.push(`Next step: ${report.nextStep}`);
+  return `${lines.join("\n")}
+`;
+}
+async function runChromeStatusCommand(args, deps = {}) {
+  const output = deps.output ?? process.stdout;
+  let report;
+  try {
+    report = await buildChromeConnectorStatus(deps);
+  } catch (error) {
+    output.write(`[nolo] Chrome connector status failed: ${toErrorMessage(error)}
+`);
+    return 1;
+  }
+  if (args.includes("--json")) {
+    output.write(`${JSON.stringify(report, null, 2)}
+`);
+  } else {
+    output.write(formatChromeConnectorStatus(report));
+  }
+  return report.ok ? 0 : 1;
+}
+async function runChromeInstallCommand(args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const install = deps.installNativeHost ?? installNativeHostManifest;
+  let connectorRoot;
+  try {
+    connectorRoot = deps.connectorRoot ?? resolveCliConnectorRoot({ env });
+  } catch (error) {
+    output.write(`[nolo] Chrome native host install failed: ${toErrorMessage(error)}
+`);
+    return 1;
+  }
+  const explicitRoot = (env.NOLO_CHROME_CONNECTOR_ROOT ?? "").trim().length > 0;
+  const worktree = detectWorktreeCheckout(connectorRoot);
+  if (worktree && !explicitRoot && !args.includes("--force")) {
+    output.write(
+      `[nolo] Chrome native host install failed: refusing to install from a git worktree (${worktree.worktreeRoot}). The wrapper it would write execs the native host inside that worktree, so the connector would stop working as soon as the worktree is removed. Run this from the main checkout${worktree.mainRoot ? ` (${worktree.mainRoot})` : ""}, or re-run with --force / NOLO_CHROME_CONNECTOR_ROOT=<checkout> if Chrome should really use this one.
+`
+    );
+    return 1;
+  }
+  let result;
+  try {
+    result = install({
+      home: deps.home ?? env.HOME ?? "",
+      connectorRoot,
+      ...deps.platform ? { platform: deps.platform } : {},
+      ...deps.nodePath ? { nodePath: deps.nodePath } : {}
+    });
+  } catch (error) {
+    output.write(`[nolo] Chrome native host install failed: ${toErrorMessage(error)}
+`);
+    return 1;
+  }
+  if (args.includes("--json")) {
+    output.write(`${JSON.stringify({ ok: true, ...result }, null, 2)}
+`);
+  } else {
+    output.write(
+      [
+        "Nolo Chrome connector native host installed.",
+        `  manifest : ${result.nativeManifestPath}`,
+        `  wrapper  : ${result.wrapperPath} -> ${result.nodePath}`,
+        `  token    : ${result.tokenPath} (an existing token is kept, so reruns are idempotent)`,
+        `  extension: ${result.extensionId}`,
+        `Next step: load the unpacked extension from ${resolve2(connectorRoot, "extension")} in chrome://extensions (Developer mode) or install it from the Chrome Web Store, then run \`nolo chrome status\`.`,
+        ""
+      ].join("\n")
+    );
+  }
+  return 0;
+}
+async function runChromeReloadCommand(args, deps = {}) {
+  const output = deps.output ?? process.stdout;
+  const requestChrome = deps.requestChrome ?? createChromeConnectorClient().request;
+  try {
+    const result = await requestChrome("reload_extension", {});
+    if (args.includes("--json")) {
+      output.write(`${JSON.stringify({ ok: true, result }, null, 2)}
+`);
+    } else {
+      output.write(
+        `Reload requested: ${JSON.stringify(result ?? {})}
+The connector service worker restarts within ~1s; verify with \`nolo chrome status\`.
+`
+      );
+    }
+    return 0;
+  } catch (error) {
+    const code = error?.code ?? "CHROME_CONNECTOR_ERROR";
+    output.write(`[nolo] Chrome connector reload failed: ${code} ${toErrorMessage(error)}
+`);
+    if (code === "CHROME_CONNECTOR_UNAVAILABLE") {
+      output.write(
+        "The native host is not reachable: load the unpacked connector extension in chrome://extensions (or start Chrome), then rerun `nolo chrome reload`.\n"
+      );
+    }
+    return 1;
+  }
+}
+export {
+  CLI_CONNECTOR_ROOT_CANDIDATES,
+  FULL_SUPPORT_CHROME_FEATURES,
+  buildChromeConnectorStatus,
+  detectWorktreeCheckout,
+  formatChromeConnectorStatus,
+  resolveCliConnectorRoot,
+  runChromeInstallCommand,
+  runChromeReloadCommand,
+  runChromeStatusCommand
+};