@dexlyai/dexly 0.1.0

package/dist/host.js

@@ -0,0 +1,859 @@
+#!/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/host.ts
+var import_node_process4 = __toESM(require("node:process"));
+
+// src/host-runtime.ts
+var import_node_process3 = __toESM(require("node:process"));
+
+// src/codex-host.ts
+var import_node_process2 = __toESM(require("node:process"));
+var import_node_child_process2 = require("node:child_process");
+var import_node_readline = __toESM(require("node:readline"));
+var import_companion4 = __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 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 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 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/management.ts
+var import_companion3 = __toESM(require_companion());
+
+// src/install-metadata.ts
+var import_promises = require("node:fs/promises");
+var import_companion2 = __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_promises.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_companion2.DEXLY_COMPANION_PACKAGE_NAME,
+      executableName: import_companion2.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_promises.writeFile)(
+    installMetadataPath(installRoot),
+    `${JSON.stringify(metadata, null, 2)}
+`,
+    "utf8"
+  );
+}
+
+// src/install.ts
+var import_promises2 = require("node:fs/promises");
+var import_node_path3 = __toESM(require("node:path"));
+
+// src/tooling.ts
+var import_node_path2 = __toESM(require("node:path"));
+var import_node_process = __toESM(require("node:process"));
+var import_node_child_process = 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_process.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_process.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 resolveCodexVersion(codexCommand = import_node_process.default.env.DEXLY_COMPANION_CODEX_PATH ?? "codex", env = import_node_process.default.env) {
+  const result = (0, import_node_child_process.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_process.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 rewriteCurrentLauncher(installRoot, toolPaths) {
+  const launcherPath = installedHostLauncherPath(installRoot);
+  await (0, import_promises2.mkdir)(import_node_path3.default.dirname(launcherPath), { recursive: true });
+  await (0, import_promises2.writeFile)(
+    launcherPath,
+    renderHostLauncher({
+      nodePath: toolPaths.nodePath,
+      hostScriptPath: installedHostScriptPath(installRoot),
+      codexPath: toolPaths.codexPath
+    }),
+    "utf8"
+  );
+  await (0, import_promises2.chmod)(launcherPath, 493);
+  return launcherPath;
+}
+async function ensureChromeHostManifest(installRoot, manifestDir) {
+  const manifestPath = installedHostManifestPath(manifestDir);
+  await (0, import_promises2.mkdir)(manifestDir, { recursive: true });
+  await (0, import_promises2.writeFile)(
+    manifestPath,
+    `${JSON.stringify(buildChromeHostManifest(installedHostLauncherPath(installRoot), defaultChromeAllowedOrigins()), null, 2)}
+`,
+    "utf8"
+  );
+  return manifestPath;
+}
+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
+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_companion3.DEXLY_COMPANION_PACKAGE_NAME}@${specifier}`;
+  const env = buildToolEnv(metadata.tools);
+  await runCommand(metadata.tools.npmPath, [
+    "exec",
+    "--yes",
+    `--package=${targetSpecifier}`,
+    import_companion3.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 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 = resolveCodexVersion(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_companion3.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_process2.spawn;
+    this.spawnProcessSync = options.spawnProcessSync ?? import_node_child_process2.spawnSync;
+    this.codexCommand = options.codexCommand ?? import_node_process2.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_companion4.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/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/host-runtime.ts
+async function runNativeHost() {
+  const host = new DexlyNativeHost({
+    send: (message) => writeNativeMessage(import_node_process3.default.stdout, message),
+    requestProcessExit: () => {
+      setTimeout(() => import_node_process3.default.exit(0), 25);
+    }
+  });
+  import_node_process3.default.stdout.on("error", (error) => {
+    if ("code" in error && error.code === "EPIPE") {
+      void host.close().finally(() => import_node_process3.default.exit(0));
+    }
+  });
+  const detachReader = createNativeMessageReader(import_node_process3.default.stdin, (message) => {
+    void host.handleMessage(message).catch((error) => {
+      writeNativeMessage(import_node_process3.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_process3.default.stdin.on("end", () => {
+    void shutdown().finally(() => import_node_process3.default.exit(0));
+  });
+  import_node_process3.default.on("SIGINT", () => {
+    void shutdown().finally(() => import_node_process3.default.exit(0));
+  });
+  import_node_process3.default.on("SIGTERM", () => {
+    void shutdown().finally(() => import_node_process3.default.exit(0));
+  });
+}
+
+// src/host.ts
+void runNativeHost().catch((error) => {
+  const message = error instanceof Error ? error.message : "Dexly Companion host failed.";
+  import_node_process4.default.stderr.write(`${message}
+`);
+  import_node_process4.default.exit(1);
+});