@dexlyai/dexly 0.1.0

package/dist/cli.js

@@ -0,0 +1,1404 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../DexlyProtocol/dist/companion.js
+var require_companion = __commonJS({
+  "../DexlyProtocol/dist/companion.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.DEFAULT_DIRECT_WEBSOCKET_ENDPOINT = exports2.DEXLY_FIXED_ALLOWED_ORIGINS = exports2.DEXLY_DEFAULT_RELEASE_CHANNEL_BY_BUILD = exports2.DEXLY_FIXED_EXTENSION_IDS = exports2.DEXLY_EXTENSION_IDENTITIES = exports2.DEXLY_PROD_EXTENSION_ID = exports2.DEXLY_PROD_EXTENSION_PUBLIC_KEY = exports2.DEXLY_DEV_EXTENSION_ID = exports2.DEXLY_DEV_EXTENSION_PUBLIC_KEY = exports2.DEXLY_CODEX_INSTALL_DOCS_URL = exports2.DEXLY_CODEX_UPGRADE_COMMAND = exports2.DEXLY_CODEX_INSTALL_COMMAND = exports2.DEXLY_COMPANION_CONNECT_COOLDOWN_MS = exports2.DEXLY_COMPANION_GLOBAL_INSTALL_COMMAND = exports2.DEXLY_COMPANION_UPGRADE_COMMAND = exports2.DEXLY_COMPANION_DOCTOR_COMMAND = exports2.DEXLY_COMPANION_INSTALL_COMMAND = exports2.DEXLY_NATIVE_CONNECTION_ENDPOINT = exports2.DEXLY_COMPANION_EXECUTABLE_NAME = exports2.DEXLY_COMPANION_PACKAGE_NAME = exports2.DEXLY_COMPANION_DISPLAY_NAME = exports2.DEXLY_COMPANION_HOST_NAME = void 0;
+    exports2.resolveDexlyExtensionBuildChannel = resolveDexlyExtensionBuildChannel;
+    exports2.getDexlyExtensionIdentity = getDexlyExtensionIdentity;
+    exports2.isDexlyFixedExtensionId = isDexlyFixedExtensionId;
+    exports2.toChromeExtensionOrigin = toChromeExtensionOrigin;
+    exports2.resolveDexlyExtensionBuildChannelFromExtensionId = resolveDexlyExtensionBuildChannelFromExtensionId;
+    exports2.normalizeCompanionReleaseChannel = normalizeCompanionReleaseChannel;
+    exports2.DEXLY_COMPANION_HOST_NAME = "ai.dexly.companion";
+    exports2.DEXLY_COMPANION_DISPLAY_NAME = "Dexly Companion";
+    exports2.DEXLY_COMPANION_PACKAGE_NAME = "@dexlyai/dexly";
+    exports2.DEXLY_COMPANION_EXECUTABLE_NAME = "dexly";
+    exports2.DEXLY_NATIVE_CONNECTION_ENDPOINT = "native://ai.dexly.companion";
+    exports2.DEXLY_COMPANION_INSTALL_COMMAND = "npx -y @dexlyai/dexly install";
+    exports2.DEXLY_COMPANION_DOCTOR_COMMAND = "npx -y @dexlyai/dexly doctor";
+    exports2.DEXLY_COMPANION_UPGRADE_COMMAND = "npx -y @dexlyai/dexly upgrade";
+    exports2.DEXLY_COMPANION_GLOBAL_INSTALL_COMMAND = "npm i -g @dexlyai/dexly && dexly install";
+    exports2.DEXLY_COMPANION_CONNECT_COOLDOWN_MS = 15e3;
+    exports2.DEXLY_CODEX_INSTALL_COMMAND = "npm install -g @openai/codex";
+    exports2.DEXLY_CODEX_UPGRADE_COMMAND = "codex --upgrade";
+    exports2.DEXLY_CODEX_INSTALL_DOCS_URL = "https://help.openai.com/en/articles/11096431-openai-codex-ci-getting-started";
+    exports2.DEXLY_DEV_EXTENSION_PUBLIC_KEY = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA6fpo7R5tslk/4402QrobrFaQUyW2jk+cgG60FE51YtcQUWtdI8WEyIZBg7bTkpwjt/cvcCWg6B5P/iOZNYoq0o3RxyeqT+8IjuYA0d2kYUaCOoshPsLdEvLTTr3SQ1bg0r2naivw92KxVgZ2fcZuS4kNy6qYhBCWitvTLvDVCnjRN13UT9buskxnsv0Cr+kh7vr/YXA2Boy2jwQyZXEDg9FvnSJF5yEAK6GLzlkvfIKXifxBSMdNaOVp8hKOxR9WjFTotBwZ6mgJXKCNgG+7Xd54xkWRaomU7CEohfvkmmxM9gpJ3S1VqmauogSbkzwCcJQJ1csdU/7TWQ4+hOuKLQIDAQAB";
+    exports2.DEXLY_DEV_EXTENSION_ID = "mjihblbjfhdhaidkanpjbnmmcljbafdn";
+    exports2.DEXLY_PROD_EXTENSION_PUBLIC_KEY = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAmxkxUCWY3dbeEhjPxW7hOstyhtteCX3blvOTTGoGjju2p+je8eNVo7YDSqlgwRvOQw5N9LWmwb5Ui9wwVhQtLWyYqqq4aTVIAQhUhPDG6gRAUlLMXb/8e+ErWVx707d+aOVTgdc41qA2TVeUelVv/ARjcHL+xcxtk9pcmEMUGnWcZ1kPVx5FTQlLvEpFLVFsTMA6sff/6ba00/S1J28rEUdo2I61Dqku3ceMe3wNmLO4LJ9dj4dLxuYzpF/zH9vEVPWlYgyZY/NGadaAv1rxW4BSboqEOAK54vzcd5FfbxmvuYcRCVyN2A6WRU6sFUFpNrlzTOl+PpogNh+pa2qgxwIDAQAB";
+    exports2.DEXLY_PROD_EXTENSION_ID = "mkgnndfbolkjpiijcpkhmgjjhgcibdnp";
+    exports2.DEXLY_EXTENSION_IDENTITIES = {
+      development: {
+        channel: "development",
+        label: "development",
+        extensionId: exports2.DEXLY_DEV_EXTENSION_ID,
+        publicKey: exports2.DEXLY_DEV_EXTENSION_PUBLIC_KEY
+      },
+      production: {
+        channel: "production",
+        label: "production",
+        extensionId: exports2.DEXLY_PROD_EXTENSION_ID,
+        publicKey: exports2.DEXLY_PROD_EXTENSION_PUBLIC_KEY
+      }
+    };
+    exports2.DEXLY_FIXED_EXTENSION_IDS = [
+      exports2.DEXLY_EXTENSION_IDENTITIES.development.extensionId,
+      exports2.DEXLY_EXTENSION_IDENTITIES.production.extensionId
+    ];
+    exports2.DEXLY_DEFAULT_RELEASE_CHANNEL_BY_BUILD = {
+      development: "beta",
+      production: "latest"
+    };
+    function resolveDexlyExtensionBuildChannel(value) {
+      switch (value?.trim().toLowerCase()) {
+        case "dev":
+        case "development":
+          return "development";
+        case "prod":
+        case "production":
+          return "production";
+        default:
+          return "production";
+      }
+    }
+    function getDexlyExtensionIdentity(channel) {
+      return exports2.DEXLY_EXTENSION_IDENTITIES[channel];
+    }
+    function isDexlyFixedExtensionId(extensionId) {
+      return typeof extensionId === "string" && exports2.DEXLY_FIXED_EXTENSION_IDS.some((candidate) => candidate === extensionId);
+    }
+    function toChromeExtensionOrigin(extensionId) {
+      return `chrome-extension://${extensionId}/`;
+    }
+    function resolveDexlyExtensionBuildChannelFromExtensionId(extensionId) {
+      return extensionId === exports2.DEXLY_DEV_EXTENSION_ID ? "development" : "production";
+    }
+    function normalizeCompanionReleaseChannel(value) {
+      switch (value?.trim().toLowerCase()) {
+        case "latest":
+        case "beta":
+        case "canary":
+          return value.trim().toLowerCase();
+        default:
+          return null;
+      }
+    }
+    exports2.DEXLY_FIXED_ALLOWED_ORIGINS = exports2.DEXLY_FIXED_EXTENSION_IDS.map(toChromeExtensionOrigin);
+    exports2.DEFAULT_DIRECT_WEBSOCKET_ENDPOINT = "ws://127.0.0.1:4500";
+  }
+});
+
+// src/cli.ts
+var import_node_path4 = __toESM(require("node:path"));
+var import_node_process5 = __toESM(require("node:process"));
+var import_companion6 = __toESM(require_companion());
+
+// src/doctor.ts
+var import_promises = require("node:fs/promises");
+var import_node_child_process = require("node:child_process");
+var import_node_events = require("node:events");
+var import_companion2 = __toESM(require_companion());
+
+// src/constants.ts
+var import_node_os = __toESM(require("node:os"));
+var import_node_path = __toESM(require("node:path"));
+var import_companion = __toESM(require_companion());
+var DEXLY_COMPANION_VERSION = true ? "0.1.0" : packageJson.version;
+var DEXLY_COMPANION_DESCRIPTION = "Dexly native bridge for Codex";
+var DEXLY_COMPANION_METADATA_FILE_NAME = "install-metadata.json";
+function defaultInstallRoot(homeDir = import_node_os.default.homedir()) {
+  return import_node_path.default.join(homeDir, "Library", "Application Support", "Dexly", "companion");
+}
+function defaultChromeHostManifestDir(homeDir = import_node_os.default.homedir()) {
+  return import_node_path.default.join(homeDir, "Library", "Application Support", "Google", "Chrome", "NativeMessagingHosts");
+}
+function defaultChromeAllowedOrigins() {
+  return [...import_companion.DEXLY_FIXED_ALLOWED_ORIGINS];
+}
+function versionStorePath(installRoot) {
+  return import_node_path.default.join(installRoot, "versions");
+}
+function currentInstallPath(installRoot) {
+  return import_node_path.default.join(installRoot, "current");
+}
+function installMetadataPath(installRoot) {
+  return import_node_path.default.join(installRoot, DEXLY_COMPANION_METADATA_FILE_NAME);
+}
+function versionInstallPath(installRoot, version) {
+  return import_node_path.default.join(versionStorePath(installRoot), version);
+}
+function installedHostScriptPath(installRoot) {
+  return import_node_path.default.join(currentInstallPath(installRoot), "dist", "host.js");
+}
+function installedHostLauncherPath(installRoot) {
+  return import_node_path.default.join(currentInstallPath(installRoot), "bin", "dexly-companion-host");
+}
+function versionedCliPath(versionRoot) {
+  return import_node_path.default.join(versionRoot, "dist", "cli.js");
+}
+function versionedHostScriptPath(versionRoot) {
+  return import_node_path.default.join(versionRoot, "dist", "host.js");
+}
+function versionedHostLauncherPath(versionRoot) {
+  return import_node_path.default.join(versionRoot, "bin", "dexly-companion-host");
+}
+function versionedPackageJsonPath(versionRoot) {
+  return import_node_path.default.join(versionRoot, "package.json");
+}
+function installedHostManifestPath(manifestDir) {
+  return import_node_path.default.join(manifestDir, `${import_companion.DEXLY_COMPANION_HOST_NAME}.json`);
+}
+function buildChromeHostManifest(hostPath, allowedOrigins) {
+  return {
+    name: import_companion.DEXLY_COMPANION_HOST_NAME,
+    description: DEXLY_COMPANION_DESCRIPTION,
+    path: hostPath,
+    type: "stdio",
+    allowed_origins: allowedOrigins
+  };
+}
+
+// src/native-protocol.ts
+var import_node_buffer = require("node:buffer");
+function encodeNativeMessage(message) {
+  const body = import_node_buffer.Buffer.from(JSON.stringify(message), "utf8");
+  const header = import_node_buffer.Buffer.alloc(4);
+  header.writeUInt32LE(body.byteLength, 0);
+  return import_node_buffer.Buffer.concat([header, body]);
+}
+var NativeMessageParser = class {
+  buffered = import_node_buffer.Buffer.alloc(0);
+  push(chunk, handleMessage) {
+    this.buffered = import_node_buffer.Buffer.concat([this.buffered, chunk]);
+    while (this.buffered.byteLength >= 4) {
+      const bodyLength = this.buffered.readUInt32LE(0);
+      if (this.buffered.byteLength < bodyLength + 4) {
+        return;
+      }
+      const body = this.buffered.subarray(4, bodyLength + 4);
+      this.buffered = this.buffered.subarray(bodyLength + 4);
+      handleMessage(JSON.parse(body.toString("utf8")));
+    }
+  }
+};
+function createNativeMessageReader(input, handleMessage) {
+  const parser = new NativeMessageParser();
+  const onData = (chunk) => {
+    parser.push(import_node_buffer.Buffer.isBuffer(chunk) ? chunk : import_node_buffer.Buffer.from(chunk), handleMessage);
+  };
+  input.on("data", onData);
+  return () => {
+    input.off("data", onData);
+  };
+}
+function writeNativeMessage(output, message) {
+  output.write(encodeNativeMessage(message));
+}
+
+// src/doctor.ts
+async function runDoctor(options) {
+  const installRoot = options?.installRoot ?? defaultInstallRoot();
+  const manifestDir = options?.manifestDir ?? defaultChromeHostManifestDir();
+  const manifestPath = installedHostManifestPath(manifestDir);
+  const hostLauncherPath = installedHostLauncherPath(installRoot);
+  const hostScriptPath = installedHostScriptPath(installRoot);
+  const metadataPath = installMetadataPath(installRoot);
+  const checks = [];
+  checks.push({
+    label: "platform",
+    ok: process.platform === "darwin",
+    detail: process.platform === "darwin" ? "macOS supported." : `Unsupported platform: ${process.platform}`
+  });
+  checks.push(await checkPath("host launcher", hostLauncherPath));
+  checks.push(await checkPath("host bundle", hostScriptPath));
+  checks.push(await checkPath("install metadata", metadataPath));
+  checks.push(await checkPath("native host manifest", manifestPath));
+  const manifestCheck = await checkHostManifest(manifestPath, hostLauncherPath);
+  checks.push(manifestCheck);
+  checks.push(await checkNativeHostRuntime(manifestPath));
+  const codexVersion = resolveCodexVersion();
+  checks.push({
+    label: "codex",
+    ok: codexVersion != null,
+    detail: codexVersion ?? "Codex CLI not found in PATH."
+  });
+  return {
+    ok: checks.every((check) => check.ok),
+    checks
+  };
+}
+async function checkPath(label, filePath) {
+  try {
+    await (0, import_promises.access)(filePath);
+    return {
+      label,
+      ok: true,
+      detail: filePath
+    };
+  } catch {
+    return {
+      label,
+      ok: false,
+      detail: `Missing: ${filePath}`
+    };
+  }
+}
+async function checkHostManifest(filePath, expectedHostPath) {
+  try {
+    const raw = await (0, import_promises.readFile)(filePath, "utf8");
+    const manifest = JSON.parse(raw);
+    const allowedOrigins = Array.isArray(manifest.allowed_origins) ? manifest.allowed_origins.filter((value) => typeof value === "string") : [];
+    const ok = manifest.name === import_companion2.DEXLY_COMPANION_HOST_NAME && typeof manifest.path === "string" && manifest.path === expectedHostPath && import_companion2.DEXLY_FIXED_ALLOWED_ORIGINS.every((origin) => allowedOrigins.includes(origin));
+    return {
+      label: "manifest contents",
+      ok,
+      detail: ok ? `Native host manifest is valid, points to ${expectedHostPath}, and includes ${import_companion2.DEXLY_FIXED_ALLOWED_ORIGINS.join(", ")}` : "Native host manifest is missing the expected name, expected launcher path, or one of Dexly's fixed extension origins."
+    };
+  } catch (error) {
+    return {
+      label: "manifest contents",
+      ok: false,
+      detail: error instanceof Error ? error.message : "Unable to read native host manifest."
+    };
+  }
+}
+async function checkNativeHostRuntime(manifestPath) {
+  const defaultOrigin = `chrome-extension://${import_companion2.DEXLY_DEV_EXTENSION_ID}/`;
+  try {
+    const raw = await (0, import_promises.readFile)(manifestPath, "utf8");
+    const manifest = JSON.parse(raw);
+    if (typeof manifest.path !== "string" || manifest.path.length === 0) {
+      return {
+        label: "native host runtime",
+        ok: false,
+        detail: "Native host manifest does not contain a valid executable path."
+      };
+    }
+    const response = await runHostHealthCheck(manifest.path, defaultOrigin);
+    if (response.kind === "host/error") {
+      return {
+        label: "native host runtime",
+        ok: false,
+        detail: `${response.code}: ${response.message}`
+      };
+    }
+    if (response.kind !== "host/result" || response.action !== "host/health") {
+      return {
+        label: "native host runtime",
+        ok: false,
+        detail: `Dexly Companion returned an unexpected message kind: ${response.kind}`
+      };
+    }
+    const healthResult = response.result;
+    const codexSuffix = healthResult.codexVersion ? ` and ${healthResult.codexVersion}` : "";
+    return {
+      label: "native host runtime",
+      ok: true,
+      detail: `Responded to host/health with ${healthResult.hostVersion}${codexSuffix}.`
+    };
+  } catch (error) {
+    return {
+      label: "native host runtime",
+      ok: false,
+      detail: error instanceof Error ? error.message : "Dexly Companion host smoke test failed."
+    };
+  }
+}
+async function runHostHealthCheck(hostPath, origin) {
+  const child = (0, import_node_child_process.spawn)(hostPath, [origin], {
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const parser = new NativeMessageParser();
+  const stderrChunks = [];
+  try {
+    const messagePromise = new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("Dexly Companion did not answer a native host health check within 3 seconds."));
+      }, 3e3);
+      const cleanup = () => {
+        clearTimeout(timeout);
+        child.stdout.off("data", handleStdout);
+        child.stderr.off("data", handleStderr);
+        child.off("error", handleError);
+        child.off("exit", handleExit);
+      };
+      const finishResolve = (message) => {
+        cleanup();
+        resolve(message);
+      };
+      const finishReject = (error) => {
+        cleanup();
+        reject(error);
+      };
+      const handleStdout = (chunk) => {
+        parser.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk), (message) => {
+          finishResolve(message);
+        });
+      };
+      const handleStderr = (chunk) => {
+        stderrChunks.push((Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)).toString("utf8"));
+      };
+      const handleError = (error) => {
+        finishReject(error);
+      };
+      const handleExit = (code, signal) => {
+        const stderrTail = stderrChunks.join("").trim();
+        finishReject(new Error(
+          stderrTail ? `Dexly Companion exited before replying (code ${code ?? "null"}, signal ${signal ?? "null"}): ${stderrTail}` : `Dexly Companion exited before replying (code ${code ?? "null"}, signal ${signal ?? "null"}).`
+        ));
+      };
+      child.stdout.on("data", handleStdout);
+      child.stderr.on("data", handleStderr);
+      child.once("error", handleError);
+      child.once("exit", handleExit);
+    });
+    child.stdin.write(
+      encodeNativeMessage({
+        kind: "host/health",
+        requestId: "doctor-health"
+      })
+    );
+    const response = await messagePromise;
+    child.stdin.end();
+    await Promise.race([
+      (0, import_node_events.once)(child, "exit"),
+      new Promise((resolve) => setTimeout(resolve, 250))
+    ]);
+    return response;
+  } finally {
+    child.kill();
+  }
+}
+function resolveCodexVersion() {
+  const result = (0, import_node_child_process.spawnSync)("codex", ["--version"], {
+    encoding: "utf8"
+  });
+  if (result.error || result.status !== 0) {
+    return null;
+  }
+  return result.stdout.trim() || null;
+}
+
+// src/host-runtime.ts
+var import_node_process4 = __toESM(require("node:process"));
+
+// src/codex-host.ts
+var import_node_process3 = __toESM(require("node:process"));
+var import_node_child_process3 = require("node:child_process");
+var import_node_readline = __toESM(require("node:readline"));
+var import_companion5 = __toESM(require_companion());
+
+// src/management.ts
+var import_promises4 = require("node:fs/promises");
+var import_companion4 = __toESM(require_companion());
+
+// src/install-metadata.ts
+var import_promises2 = require("node:fs/promises");
+var import_companion3 = __toESM(require_companion());
+function normalizeString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function normalizeToolPaths(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const candidate = value;
+  const nodePath = normalizeString(candidate.nodePath);
+  const npmPath = normalizeString(candidate.npmPath);
+  if (!nodePath || !npmPath) {
+    return null;
+  }
+  return {
+    nodePath,
+    npmPath,
+    codexPath: normalizeString(candidate.codexPath)
+  };
+}
+async function loadInstallMetadata(installRoot) {
+  try {
+    const raw = await (0, import_promises2.readFile)(installMetadataPath(installRoot), "utf8");
+    const parsed = JSON.parse(raw);
+    const tools = normalizeToolPaths(parsed.tools);
+    const currentVersion = normalizeString(parsed.currentVersion);
+    const installedAt = normalizeString(parsed.installedAt);
+    const updatedAt = normalizeString(parsed.updatedAt);
+    if (!tools || !currentVersion || !installedAt || !updatedAt) {
+      return null;
+    }
+    const knownGoodVersions = Array.isArray(parsed.knownGoodVersions) ? parsed.knownGoodVersions.filter((value) => typeof value === "string" && value.trim().length > 0) : [currentVersion];
+    return {
+      schemaVersion: 1,
+      packageName: import_companion3.DEXLY_COMPANION_PACKAGE_NAME,
+      executableName: import_companion3.DEXLY_COMPANION_EXECUTABLE_NAME,
+      currentVersion,
+      previousVersion: normalizeString(parsed.previousVersion),
+      knownGoodVersions: knownGoodVersions.length > 0 ? knownGoodVersions : [currentVersion],
+      currentChannel: normalizeString(parsed.currentChannel),
+      installedAt,
+      updatedAt,
+      tools
+    };
+  } catch {
+    return null;
+  }
+}
+async function saveInstallMetadata(installRoot, metadata) {
+  await (0, import_promises2.writeFile)(
+    installMetadataPath(installRoot),
+    `${JSON.stringify(metadata, null, 2)}
+`,
+    "utf8"
+  );
+}
+
+// src/install.ts
+var import_promises3 = require("node:fs/promises");
+var import_node_path3 = __toESM(require("node:path"));
+var import_node_process2 = __toESM(require("node:process"));
+
+// src/tooling.ts
+var import_node_path2 = __toESM(require("node:path"));
+var import_node_process = __toESM(require("node:process"));
+var import_node_child_process2 = require("node:child_process");
+function detectToolPaths() {
+  const nodePath = import_node_process.default.execPath;
+  const npmPath = resolveExecutablePath("npm") ?? "npm";
+  const codexPath = resolveExecutablePath("codex");
+  return {
+    nodePath,
+    npmPath,
+    codexPath
+  };
+}
+function resolveExecutablePath(command, env = import_node_process.default.env) {
+  const result = (0, import_node_child_process2.spawnSync)("which", [command], {
+    encoding: "utf8",
+    env
+  });
+  if (result.status !== 0) {
+    return null;
+  }
+  const executablePath = result.stdout.trim();
+  return executablePath.length > 0 ? executablePath : null;
+}
+function buildToolEnv(toolPaths, extraPaths = []) {
+  const pathEntries = [
+    import_node_path2.default.dirname(toolPaths.nodePath),
+    import_node_path2.default.dirname(toolPaths.npmPath),
+    toolPaths.codexPath ? import_node_path2.default.dirname(toolPaths.codexPath) : null,
+    ...extraPaths,
+    "/usr/local/bin",
+    "/opt/homebrew/bin",
+    "/usr/bin",
+    "/bin",
+    "/usr/sbin",
+    "/sbin",
+    import_node_process.default.env.PATH ?? null
+  ].filter((entry, index, entries) => typeof entry === "string" && entries.indexOf(entry) === index);
+  return {
+    ...import_node_process.default.env,
+    PATH: pathEntries.join(":"),
+    ...toolPaths.codexPath ? { DEXLY_COMPANION_CODEX_PATH: toolPaths.codexPath } : {}
+  };
+}
+async function runCommand(command, args, options = {}) {
+  return await new Promise((resolve, reject) => {
+    const child = (0, import_node_child_process2.spawn)(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: "pipe"
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += (Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)).toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += (Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)).toString("utf8");
+    });
+    child.once("error", (error) => {
+      reject(error);
+    });
+    child.once("exit", (code, signal) => {
+      if (code === 0) {
+        resolve({ stdout, stderr });
+        return;
+      }
+      const detail = stderr.trim() || stdout.trim();
+      reject(new Error(
+        detail.length > 0 ? `${command} ${args.join(" ")} failed (${code ?? signal ?? "unknown"}): ${detail}` : `${command} ${args.join(" ")} failed (${code ?? signal ?? "unknown"}).`
+      ));
+    });
+  });
+}
+function resolveCodexVersion2(codexCommand = import_node_process.default.env.DEXLY_COMPANION_CODEX_PATH ?? "codex", env = import_node_process.default.env) {
+  const result = (0, import_node_child_process2.spawnSync)(codexCommand, ["--version"], {
+    encoding: "utf8",
+    env
+  });
+  if (result.error || result.status !== 0) {
+    return null;
+  }
+  return result.stdout.trim() || null;
+}
+function resolveNpmGlobalBinDir(npmPath, env = import_node_process.default.env) {
+  const result = (0, import_node_child_process2.spawnSync)(npmPath, ["config", "get", "prefix"], {
+    encoding: "utf8",
+    env
+  });
+  if (result.error || result.status !== 0) {
+    return null;
+  }
+  const prefix = result.stdout.trim();
+  return prefix.length > 0 ? import_node_path2.default.join(prefix, "bin") : null;
+}
+
+// src/install.ts
+async function installCompanion(options) {
+  if (import_node_process2.default.platform !== "darwin") {
+    throw new Error("Dexly Companion phase one currently supports macOS only.");
+  }
+  await assertInstallablePackageExists(options.sourcePackageDir);
+  const installRoot = options.installRoot ?? defaultInstallRoot();
+  const manifestDir = options.manifestDir ?? defaultChromeHostManifestDir();
+  const manifestPath = installedHostManifestPath(manifestDir);
+  const hostPath = installedHostLauncherPath(installRoot);
+  const allowedOrigins = defaultChromeAllowedOrigins();
+  const toolPaths = options.toolPaths ?? detectToolPaths();
+  const sourceDistDir = import_node_path3.default.join(options.sourcePackageDir, "dist");
+  const sourcePackageJsonPath = import_node_path3.default.join(options.sourcePackageDir, "package.json");
+  const versionRoot = versionInstallPath(installRoot, DEXLY_COMPANION_VERSION);
+  const stagingVersionRoot = `${versionRoot}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  await (0, import_promises3.mkdir)(versionStorePath(installRoot), { recursive: true });
+  await (0, import_promises3.rm)(stagingVersionRoot, { recursive: true, force: true });
+  try {
+    await (0, import_promises3.mkdir)(import_node_path3.default.join(stagingVersionRoot, "dist"), { recursive: true });
+    await (0, import_promises3.cp)(sourceDistDir, import_node_path3.default.join(stagingVersionRoot, "dist"), { recursive: true });
+    await (0, import_promises3.copyFile)(sourcePackageJsonPath, versionedPackageJsonPath(stagingVersionRoot));
+    await (0, import_promises3.chmod)(versionedCliPath(stagingVersionRoot), 493);
+    await (0, import_promises3.chmod)(versionedHostScriptPath(stagingVersionRoot), 493);
+    await (0, import_promises3.mkdir)(import_node_path3.default.dirname(versionedHostLauncherPath(stagingVersionRoot)), { recursive: true });
+    await (0, import_promises3.writeFile)(
+      versionedHostLauncherPath(stagingVersionRoot),
+      renderHostLauncher({
+        nodePath: toolPaths.nodePath,
+        hostScriptPath: installedHostScriptPath(installRoot),
+        codexPath: toolPaths.codexPath
+      }),
+      "utf8"
+    );
+    await (0, import_promises3.chmod)(versionedHostLauncherPath(stagingVersionRoot), 493);
+    await (0, import_promises3.rm)(versionRoot, { recursive: true, force: true });
+    await (0, import_promises3.rename)(stagingVersionRoot, versionRoot);
+  } catch (error) {
+    await (0, import_promises3.rm)(stagingVersionRoot, { recursive: true, force: true }).catch(() => void 0);
+    throw error;
+  }
+  await activateInstalledVersion(installRoot, DEXLY_COMPANION_VERSION);
+  await rewriteCurrentLauncher(installRoot, toolPaths);
+  await ensureChromeHostManifest(installRoot, manifestDir);
+  const existingMetadata = await loadInstallMetadata(installRoot);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const metadata = {
+    schemaVersion: 1,
+    packageName: "@dexlyai/dexly",
+    executableName: "dexly",
+    currentVersion: DEXLY_COMPANION_VERSION,
+    previousVersion: existingMetadata && existingMetadata.currentVersion !== DEXLY_COMPANION_VERSION ? existingMetadata.currentVersion : existingMetadata?.previousVersion ?? null,
+    knownGoodVersions: [
+      DEXLY_COMPANION_VERSION,
+      ...(existingMetadata?.knownGoodVersions ?? []).filter((version) => version !== DEXLY_COMPANION_VERSION)
+    ].slice(0, 2),
+    currentChannel: options.channel ?? existingMetadata?.currentChannel ?? null,
+    installedAt: existingMetadata?.installedAt ?? now,
+    updatedAt: now,
+    tools: toolPaths
+  };
+  await saveInstallMetadata(installRoot, metadata);
+  await pruneVersionStore(installRoot, metadata.knownGoodVersions);
+  return {
+    installRoot,
+    manifestPath,
+    hostPath,
+    allowedOrigins,
+    version: DEXLY_COMPANION_VERSION,
+    metadataPath: import_node_path3.default.join(installRoot, "install-metadata.json")
+  };
+}
+async function activateInstalledVersion(installRoot, version) {
+  const currentPath = currentInstallPath(installRoot);
+  const tempLinkPath = `${currentPath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  const targetPath = import_node_path3.default.join("versions", version);
+  await (0, import_promises3.mkdir)(installRoot, { recursive: true });
+  await (0, import_promises3.rm)(tempLinkPath, { recursive: true, force: true });
+  await (0, import_promises3.symlink)(targetPath, tempLinkPath);
+  try {
+    await (0, import_promises3.rename)(tempLinkPath, currentPath);
+  } catch {
+    await (0, import_promises3.rm)(currentPath, { recursive: true, force: true });
+    await (0, import_promises3.rename)(tempLinkPath, currentPath);
+  }
+}
+async function rewriteCurrentLauncher(installRoot, toolPaths) {
+  const launcherPath = installedHostLauncherPath(installRoot);
+  await (0, import_promises3.mkdir)(import_node_path3.default.dirname(launcherPath), { recursive: true });
+  await (0, import_promises3.writeFile)(
+    launcherPath,
+    renderHostLauncher({
+      nodePath: toolPaths.nodePath,
+      hostScriptPath: installedHostScriptPath(installRoot),
+      codexPath: toolPaths.codexPath
+    }),
+    "utf8"
+  );
+  await (0, import_promises3.chmod)(launcherPath, 493);
+  return launcherPath;
+}
+async function ensureChromeHostManifest(installRoot, manifestDir) {
+  const manifestPath = installedHostManifestPath(manifestDir);
+  await (0, import_promises3.mkdir)(manifestDir, { recursive: true });
+  await (0, import_promises3.writeFile)(
+    manifestPath,
+    `${JSON.stringify(buildChromeHostManifest(installedHostLauncherPath(installRoot), defaultChromeAllowedOrigins()), null, 2)}
+`,
+    "utf8"
+  );
+  return manifestPath;
+}
+async function pruneVersionStore(installRoot, keepVersions) {
+  const keep = new Set(keepVersions);
+  const versionsPath = versionStorePath(installRoot);
+  const entries = await (0, import_promises3.readdir)(versionsPath).catch(() => []);
+  await Promise.all(entries.map(async (entry) => {
+    if (keep.has(entry)) {
+      return;
+    }
+    await (0, import_promises3.rm)(import_node_path3.default.join(versionsPath, entry), { recursive: true, force: true });
+  }));
+}
+async function assertInstallablePackageExists(sourcePackageDir) {
+  const requiredPaths = [
+    import_node_path3.default.join(sourcePackageDir, "dist", "cli.js"),
+    import_node_path3.default.join(sourcePackageDir, "dist", "host.js"),
+    import_node_path3.default.join(sourcePackageDir, "package.json")
+  ];
+  for (const filePath of requiredPaths) {
+    try {
+      await (0, import_promises3.access)(filePath);
+    } catch {
+      throw new Error(
+        `Dexly Companion build output is missing ${filePath}. Run npm install && npm run dexly:build before install.`
+      );
+    }
+  }
+}
+function renderHostLauncher(options) {
+  const pathEntries = [
+    import_node_path3.default.dirname(options.nodePath),
+    options.codexPath ? import_node_path3.default.dirname(options.codexPath) : null,
+    "/usr/local/bin",
+    "/opt/homebrew/bin",
+    "/usr/bin",
+    "/bin",
+    "/usr/sbin",
+    "/sbin"
+  ].filter((entry, index, entries) => typeof entry === "string" && entries.indexOf(entry) === index);
+  const lines = [
+    "#!/bin/sh",
+    "set -eu",
+    `export PATH=${toShellLiteral(pathEntries.join(":"))}`,
+    options.codexPath ? `export DEXLY_COMPANION_CODEX_PATH=${toShellLiteral(options.codexPath)}` : null,
+    `exec ${toShellLiteral(options.nodePath)} ${toShellLiteral(options.hostScriptPath)} "$@"`
+  ].filter((line) => typeof line === "string");
+  return `${lines.join("\n")}
+`;
+}
+function toShellLiteral(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+
+// src/management.ts
+function dedupeVersions(versions) {
+  return versions.filter((value, index) => versions.indexOf(value) === index);
+}
+function nextMetadata(metadata, nextVersion, channel) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const currentVersion = metadata.currentVersion;
+  const knownGoodVersions = dedupeVersions([nextVersion, currentVersion, ...metadata.knownGoodVersions]).slice(0, 2);
+  return {
+    ...metadata,
+    currentVersion: nextVersion,
+    previousVersion: currentVersion === nextVersion ? metadata.previousVersion : currentVersion,
+    knownGoodVersions,
+    currentChannel: channel,
+    updatedAt: now
+  };
+}
+async function upgradeInstalledCompanion(options) {
+  const installRoot = options.installRoot ?? defaultInstallRoot();
+  const metadata = await loadInstallMetadata(installRoot);
+  if (!metadata) {
+    throw new Error("Dexly Companion install metadata is missing. Reinstall Dexly Companion first.");
+  }
+  const specifier = options.version?.trim() ? options.version.trim() : options.distTag.trim();
+  const targetSpecifier = `${import_companion4.DEXLY_COMPANION_PACKAGE_NAME}@${specifier}`;
+  const env = buildToolEnv(metadata.tools);
+  await runCommand(metadata.tools.npmPath, [
+    "exec",
+    "--yes",
+    `--package=${targetSpecifier}`,
+    import_companion4.DEXLY_COMPANION_EXECUTABLE_NAME,
+    "install",
+    "--channel",
+    options.distTag
+  ], { env });
+  const nextInstallMetadata = await loadInstallMetadata(installRoot);
+  if (!nextInstallMetadata) {
+    throw new Error("Dexly Companion upgraded, but the updated install metadata could not be read.");
+  }
+  return {
+    previousVersion: metadata.currentVersion,
+    currentVersion: nextInstallMetadata.currentVersion,
+    targetSpecifier
+  };
+}
+async function rollbackInstalledCompanion(options) {
+  const installRoot = options?.installRoot ?? defaultInstallRoot();
+  const manifestDir = options?.manifestDir ?? defaultChromeHostManifestDir();
+  const metadata = await loadInstallMetadata(installRoot);
+  if (!metadata) {
+    throw new Error("Dexly Companion install metadata is missing. Reinstall Dexly Companion first.");
+  }
+  const previousVersion = metadata.knownGoodVersions.find((version) => version !== metadata.currentVersion);
+  if (!previousVersion) {
+    throw new Error("Dexly Companion does not have a previous known-good version to roll back to.");
+  }
+  await (0, import_promises4.access)(versionInstallPath(installRoot, previousVersion));
+  await activateInstalledVersion(installRoot, previousVersion);
+  await rewriteCurrentLauncher(installRoot, metadata.tools);
+  await ensureChromeHostManifest(installRoot, manifestDir);
+  const next = nextMetadata(metadata, previousVersion, metadata.currentChannel);
+  next.previousVersion = metadata.currentVersion;
+  await saveInstallMetadata(installRoot, next);
+  return {
+    currentVersion: previousVersion,
+    previousVersion: metadata.currentVersion
+  };
+}
+async function installCodexWithCompanion(options) {
+  const installRoot = options?.installRoot ?? defaultInstallRoot();
+  const manifestDir = options?.manifestDir ?? defaultChromeHostManifestDir();
+  const existingMetadata = await loadInstallMetadata(installRoot);
+  const toolPaths = existingMetadata?.tools ?? detectToolPaths();
+  const env = buildToolEnv(toolPaths);
+  await runCommand(toolPaths.npmPath, ["install", "-g", "@openai/codex"], { env });
+  const globalBinDir = resolveNpmGlobalBinDir(toolPaths.npmPath, env);
+  const nextEnv = buildToolEnv(toolPaths, globalBinDir ? [globalBinDir] : []);
+  const codexPath = resolveExecutablePath("codex", nextEnv);
+  const codexVersion = resolveCodexVersion2(codexPath ?? void 0, nextEnv);
+  if (!codexPath || !codexVersion) {
+    throw new Error("Codex install completed, but Dexly Companion could not resolve the installed codex binary.");
+  }
+  const nextToolPaths = {
+    ...toolPaths,
+    codexPath
+  };
+  await rewriteCurrentLauncher(installRoot, nextToolPaths);
+  await ensureChromeHostManifest(installRoot, manifestDir);
+  if (existingMetadata) {
+    await saveInstallMetadata(installRoot, {
+      ...existingMetadata,
+      tools: nextToolPaths,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  return {
+    codexPath,
+    codexVersion,
+    installCommand: import_companion4.DEXLY_CODEX_INSTALL_COMMAND
+  };
+}
+
+// src/codex-host.ts
+var STDERR_RING_BUFFER_LIMIT = 40;
+var DexlyNativeHost = class {
+  send;
+  spawnProcess;
+  spawnProcessSync;
+  codexCommand;
+  requestProcessExit;
+  child = null;
+  childStdoutReader = null;
+  expectedChildExit = false;
+  stderrLines = [];
+  constructor(options) {
+    this.send = options.send;
+    this.spawnProcess = options.spawnProcess ?? import_node_child_process3.spawn;
+    this.spawnProcessSync = options.spawnProcessSync ?? import_node_child_process3.spawnSync;
+    this.codexCommand = options.codexCommand ?? import_node_process3.default.env.DEXLY_COMPANION_CODEX_PATH ?? "codex";
+    this.requestProcessExit = options.requestProcessExit ?? null;
+  }
+  async handleMessage(message) {
+    switch (message.kind) {
+      case "host/health":
+        this.send({
+          kind: "host/result",
+          action: "host/health",
+          requestId: message.requestId,
+          result: this.buildHealthResult()
+        });
+        return;
+      case "host/connect":
+        await this.handleConnect(message);
+        return;
+      case "host/disconnect":
+        await this.stopChild();
+        this.send({
+          kind: "host/result",
+          action: "host/disconnect",
+          requestId: message.requestId,
+          result: {
+            disconnected: true
+          }
+        });
+        return;
+      case "host/update":
+        await this.handleUpdate(message);
+        return;
+      case "host/install-codex":
+        await this.handleInstallCodex(message);
+        return;
+      case "codex/jsonrpc":
+        this.forwardJsonRpc(message.payload);
+        return;
+    }
+  }
+  async close() {
+    await this.stopChild();
+  }
+  buildHealthResult() {
+    const codexVersion = this.resolveCodexVersion();
+    return {
+      ready: codexVersion != null,
+      hostVersion: DEXLY_COMPANION_VERSION,
+      codexVersion,
+      codexInstalled: codexVersion != null,
+      capabilities: {
+        update: true,
+        installCodex: true,
+        rollback: true
+      }
+    };
+  }
+  async handleConnect(request) {
+    if (this.child) {
+      this.send({
+        kind: "host/result",
+        action: "host/connect",
+        requestId: request.requestId,
+        result: {
+          connected: true,
+          ...this.buildHealthResult()
+        }
+      });
+      return;
+    }
+    const codexVersion = this.resolveCodexVersion();
+    if (!codexVersion) {
+      this.send(this.buildError(
+        "host/connect",
+        request.requestId,
+        "codex_not_found",
+        "Codex CLI was not found. Install Codex locally and run Dexly Companion install again."
+      ));
+      return;
+    }
+    this.stderrLines = [];
+    this.expectedChildExit = false;
+    try {
+      const child = this.spawnProcess(this.codexCommand, ["app-server", "--listen", "stdio://"], {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      await new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (error) => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          child.off("error", handleError);
+          child.off("spawn", handleSpawn);
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve();
+        };
+        const handleError = (error) => {
+          finish(error);
+        };
+        const handleSpawn = () => {
+          finish(null);
+        };
+        child.once("error", handleError);
+        child.once("spawn", handleSpawn);
+      });
+      this.child = child;
+      this.attachChildListeners(child);
+      this.send({
+        kind: "host/result",
+        action: "host/connect",
+        requestId: request.requestId,
+        result: {
+          connected: true,
+          hostVersion: DEXLY_COMPANION_VERSION,
+          codexVersion,
+          codexInstalled: true,
+          capabilities: {
+            update: true,
+            installCodex: true,
+            rollback: true
+          }
+        }
+      });
+    } catch (error) {
+      this.send(this.buildError(
+        "host/connect",
+        request.requestId,
+        "codex_spawn_failed",
+        error instanceof Error ? error.message : "Dexly Companion could not start Codex app-server."
+      ));
+    }
+  }
+  async handleUpdate(request) {
+    if (this.child) {
+      this.send(this.buildError(
+        "host/update",
+        request.requestId,
+        "host_busy",
+        "Dexly Companion cannot update while a live Codex session is running."
+      ));
+      return;
+    }
+    try {
+      const result = await upgradeInstalledCompanion({
+        distTag: request.params.distTag,
+        version: request.params.version ?? null
+      });
+      this.send({
+        kind: "host/result",
+        action: "host/update",
+        requestId: request.requestId,
+        result: {
+          updated: true,
+          previousVersion: result.previousVersion,
+          targetSpecifier: result.targetSpecifier,
+          ...this.buildHealthResult()
+        }
+      });
+      this.requestProcessExit?.();
+    } catch (error) {
+      this.send(this.buildError(
+        "host/update",
+        request.requestId,
+        "host_update_failed",
+        error instanceof Error ? error.message : "Dexly Companion could not update itself."
+      ));
+    }
+  }
+  async handleInstallCodex(request) {
+    if (this.child) {
+      this.send(this.buildError(
+        "host/install-codex",
+        request.requestId,
+        "host_busy",
+        "Dexly Companion cannot install Codex while a live Codex session is running."
+      ));
+      return;
+    }
+    try {
+      const result = await installCodexWithCompanion();
+      this.send({
+        kind: "host/result",
+        action: "host/install-codex",
+        requestId: request.requestId,
+        result: {
+          installed: true,
+          installCommand: result.installCommand,
+          ...this.buildHealthResult()
+        }
+      });
+    } catch (error) {
+      this.send(this.buildError(
+        "host/install-codex",
+        request.requestId,
+        "codex_install_failed",
+        error instanceof Error ? error.message : "Dexly Companion could not install Codex."
+      ));
+    }
+  }
+  attachChildListeners(child) {
+    this.childStdoutReader = import_node_readline.default.createInterface({
+      input: child.stdout
+    });
+    this.childStdoutReader.on("line", (line) => {
+      if (!line.trim()) {
+        return;
+      }
+      try {
+        this.send({
+          kind: "codex/jsonrpc",
+          payload: JSON.parse(line)
+        });
+      } catch {
+        this.send(this.buildError(
+          null,
+          null,
+          "codex_protocol_error",
+          "Dexly Companion received malformed JSON from Codex app-server.",
+          {
+            line
+          }
+        ));
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      const lines = chunk.toString("utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+      this.stderrLines.push(...lines);
+      if (this.stderrLines.length > STDERR_RING_BUFFER_LIMIT) {
+        this.stderrLines.splice(0, this.stderrLines.length - STDERR_RING_BUFFER_LIMIT);
+      }
+    });
+    child.on("exit", (code, signal) => {
+      const stderrTail = this.stderrLines.length > 0 ? this.stderrLines.join("\n") : null;
+      this.cleanupChild();
+      if (this.expectedChildExit) {
+        this.expectedChildExit = false;
+        return;
+      }
+      this.send(this.buildError(
+        null,
+        null,
+        "codex_exit",
+        "Codex app-server exited unexpectedly.",
+        {
+          code,
+          signal,
+          stderrTail
+        }
+      ));
+    });
+  }
+  forwardJsonRpc(payload) {
+    if (!this.child) {
+      this.send(this.buildError(
+        null,
+        null,
+        "codex_not_connected",
+        `${import_companion5.DEXLY_COMPANION_DISPLAY_NAME} is not connected to Codex app-server.`
+      ));
+      return;
+    }
+    this.child.stdin.write(`${JSON.stringify(payload)}
+`);
+  }
+  async stopChild() {
+    const child = this.child;
+    if (!child) {
+      return;
+    }
+    this.expectedChildExit = true;
+    await new Promise((resolve) => {
+      const finish = () => {
+        child.off("exit", finish);
+        resolve();
+      };
+      child.once("exit", finish);
+      child.kill();
+    });
+    this.cleanupChild();
+    this.expectedChildExit = false;
+  }
+  cleanupChild() {
+    this.childStdoutReader?.close();
+    this.childStdoutReader = null;
+    this.child = null;
+  }
+  resolveCodexVersion() {
+    const result = this.spawnProcessSync(this.codexCommand, ["--version"], {
+      encoding: "utf8"
+    });
+    if (result.error || result.status !== 0) {
+      return null;
+    }
+    return result.stdout.trim() || null;
+  }
+  buildError(action, requestId, code, message, details) {
+    return {
+      kind: "host/error",
+      action,
+      requestId,
+      code,
+      message,
+      details
+    };
+  }
+};
+
+// src/host-runtime.ts
+async function runNativeHost() {
+  const host = new DexlyNativeHost({
+    send: (message) => writeNativeMessage(import_node_process4.default.stdout, message),
+    requestProcessExit: () => {
+      setTimeout(() => import_node_process4.default.exit(0), 25);
+    }
+  });
+  import_node_process4.default.stdout.on("error", (error) => {
+    if ("code" in error && error.code === "EPIPE") {
+      void host.close().finally(() => import_node_process4.default.exit(0));
+    }
+  });
+  const detachReader = createNativeMessageReader(import_node_process4.default.stdin, (message) => {
+    void host.handleMessage(message).catch((error) => {
+      writeNativeMessage(import_node_process4.default.stdout, {
+        kind: "host/error",
+        action: null,
+        requestId: null,
+        code: "host_runtime_error",
+        message: error instanceof Error ? error.message : "Dexly Companion host failed."
+      });
+    });
+  });
+  const shutdown = async () => {
+    detachReader();
+    await host.close();
+  };
+  import_node_process4.default.stdin.on("end", () => {
+    void shutdown().finally(() => import_node_process4.default.exit(0));
+  });
+  import_node_process4.default.on("SIGINT", () => {
+    void shutdown().finally(() => import_node_process4.default.exit(0));
+  });
+  import_node_process4.default.on("SIGTERM", () => {
+    void shutdown().finally(() => import_node_process4.default.exit(0));
+  });
+}
+
+// src/cli.ts
+async function main() {
+  const [, , rawCommand, ...args] = import_node_process5.default.argv;
+  const command = resolveCommand(rawCommand);
+  switch (command) {
+    case "host":
+      await runHost();
+      return;
+    case "install":
+      await runInstall(args);
+      return;
+    case "doctor":
+      await runDoctorCommand(args);
+      return;
+    case "upgrade":
+      await runUpgradeCommand(args);
+      return;
+    case "rollback":
+      await runRollbackCommand(args);
+      return;
+    case "install-codex":
+      await runInstallCodexCommand(args);
+      return;
+    case "version":
+      import_node_process5.default.stdout.write(`${DEXLY_COMPANION_VERSION}
+`);
+      return;
+    default:
+      throw new Error(`Unknown Dexly Companion command: ${command}`);
+  }
+}
+function resolveCommand(rawCommand) {
+  if (rawCommand?.startsWith("chrome-extension://") || rawCommand?.startsWith("--parent-window=")) {
+    return "host";
+  }
+  if (!rawCommand) {
+    return import_node_process5.default.stdin.isTTY ? "version" : "host";
+  }
+  return rawCommand;
+}
+async function runHost() {
+  await runNativeHost();
+}
+async function runInstall(args) {
+  const parsed = parseArgs(args);
+  const result = await installCompanion({
+    sourcePackageDir: import_node_path4.default.resolve(__dirname, ".."),
+    installRoot: parsed.installRoot,
+    manifestDir: parsed.manifestDir,
+    channel: parsed.channel
+  });
+  import_node_process5.default.stdout.write(
+    [
+      "Dexly Companion installed.",
+      `Install root: ${result.installRoot}`,
+      `Host manifest: ${result.manifestPath}`,
+      `Host path: ${result.hostPath}`,
+      `Version: ${result.version}`,
+      `Allowed origins: ${result.allowedOrigins.join(", ")}`
+    ].join("\n") + "\n"
+  );
+}
+async function runDoctorCommand(args) {
+  const parsed = parseArgs(args);
+  const result = await runDoctor({
+    installRoot: parsed.installRoot,
+    manifestDir: parsed.manifestDir
+  });
+  for (const check of result.checks) {
+    import_node_process5.default.stdout.write(`${check.ok ? "OK" : "FAIL"} ${check.label}: ${check.detail}
+`);
+  }
+  if (!result.ok) {
+    import_node_process5.default.stdout.write(`
+If Dexly Companion is missing, run ${import_companion6.DEXLY_COMPANION_INSTALL_COMMAND}.
+`);
+    import_node_process5.default.exitCode = 1;
+  }
+}
+async function runUpgradeCommand(args) {
+  const parsed = parseArgs(args);
+  const result = await upgradeInstalledCompanion({
+    installRoot: parsed.installRoot,
+    manifestDir: parsed.manifestDir,
+    distTag: parsed.distTag ?? parsed.channel ?? "latest",
+    version: parsed.version
+  });
+  import_node_process5.default.stdout.write(
+    [
+      "Dexly Companion upgraded.",
+      `Previous version: ${result.previousVersion}`,
+      `Current version: ${result.currentVersion}`,
+      `Target specifier: ${result.targetSpecifier}`
+    ].join("\n") + "\n"
+  );
+}
+async function runRollbackCommand(args) {
+  const parsed = parseArgs(args);
+  const result = await rollbackInstalledCompanion({
+    installRoot: parsed.installRoot,
+    manifestDir: parsed.manifestDir
+  });
+  import_node_process5.default.stdout.write(
+    [
+      "Dexly Companion rolled back.",
+      `Current version: ${result.currentVersion}`,
+      `Replaced version: ${result.previousVersion}`
+    ].join("\n") + "\n"
+  );
+}
+async function runInstallCodexCommand(args) {
+  const parsed = parseArgs(args);
+  const result = await installCodexWithCompanion({
+    installRoot: parsed.installRoot,
+    manifestDir: parsed.manifestDir
+  });
+  import_node_process5.default.stdout.write(
+    [
+      "Codex installed for Dexly Companion.",
+      `Codex path: ${result.codexPath}`,
+      `Codex version: ${result.codexVersion}`,
+      `Install command: ${result.installCommand}`
+    ].join("\n") + "\n"
+  );
+}
+function parseArgs(args) {
+  const parsed = {};
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    const next = args[index + 1];
+    if (arg === "--extension-id" || arg.startsWith("--extension-id=")) {
+      throw new Error(
+        "Dynamic extension ids are no longer supported. Dexly Companion now trusts only Dexly's fixed development and production extension ids."
+      );
+    }
+    if (arg === "--install-root" && typeof next === "string") {
+      parsed.installRoot = next;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--install-root=")) {
+      parsed.installRoot = arg.slice("--install-root=".length);
+      continue;
+    }
+    if (arg === "--manifest-dir" && typeof next === "string") {
+      parsed.manifestDir = next;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--manifest-dir=")) {
+      parsed.manifestDir = arg.slice("--manifest-dir=".length);
+      continue;
+    }
+    if (arg === "--channel" && typeof next === "string") {
+      parsed.channel = next;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--channel=")) {
+      parsed.channel = arg.slice("--channel=".length);
+      continue;
+    }
+    if (arg === "--dist-tag" && typeof next === "string") {
+      parsed.distTag = next;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--dist-tag=")) {
+      parsed.distTag = arg.slice("--dist-tag=".length);
+      continue;
+    }
+    if (arg === "--version" && typeof next === "string") {
+      parsed.version = next;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--version=")) {
+      parsed.version = arg.slice("--version=".length);
+      continue;
+    }
+  }
+  return parsed;
+}
+void main().catch((error) => {
+  const message = error instanceof Error ? error.message : "Dexly Companion command failed.";
+  import_node_process5.default.stderr.write(`${message}
+`);
+  import_node_process5.default.exit(1);
+});