@dexlyai/dexly 0.1.2 → 0.1.3

package/dist/cli.js

@@ -117,29 +117,21 @@ var require_companion = __commonJS({
 });
 
 // src/cli.ts
-var import_node_path4 = __toESM(require("node:path"));
+var import_node_path5 = __toESM(require("node:path"));
 var import_node_process5 = __toESM(require("node:process"));
-var import_companion6 = __toESM(require_companion());
+var import_companion7 = __toESM(require_companion());
 
 // src/doctor.ts
-var import_promises = require("node:fs/promises");
-var import_node_child_process = require("node:child_process");
+var import_promises2 = require("node:fs/promises");
 var import_node_events = require("node:events");
-var import_companion2 = __toESM(require_companion());
+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.2" : packageJson.version;
+var DEXLY_COMPANION_VERSION = true ? "0.1.3" : 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];
 }
@@ -158,8 +150,8 @@ function versionInstallPath(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 installedHostLauncherPath(installRoot, platform = process.platform) {
+  return import_node_path.default.join(currentInstallPath(installRoot), "bin", resolveLauncherFileName(platform));
 }
 function versionedCliPath(versionRoot) {
   return import_node_path.default.join(versionRoot, "dist", "cli.js");
@@ -167,15 +159,12 @@ function versionedCliPath(versionRoot) {
 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 versionedHostLauncherPath(versionRoot, platform = process.platform) {
+  return import_node_path.default.join(versionRoot, "bin", resolveLauncherFileName(platform));
 }
 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,
@@ -185,6 +174,68 @@ function buildChromeHostManifest(hostPath, allowedOrigins) {
     allowed_origins: allowedOrigins
   };
 }
+function resolveLauncherFileName(platform) {
+  return platform === "win32" ? "dexly-companion-host.cmd" : "dexly-companion-host";
+}
+
+// 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/native-protocol.ts
 var import_node_buffer = require("node:buffer");
@@ -223,33 +274,352 @@ function writeNativeMessage(output, message) {
   output.write(encodeNativeMessage(message));
 }
 
+// src/platform.ts
+var import_node_os = __toESM(require("node:os"));
+var import_node_path2 = __toESM(require("node:path"));
+var import_node_process = __toESM(require("node:process"));
+var import_companion3 = __toESM(require_companion());
+function assertSupportedPlatform(platform = import_node_process.default.platform) {
+  switch (platform) {
+    case "darwin":
+    case "linux":
+    case "win32":
+      return platform;
+    default:
+      throw new Error(
+        `Dexly Companion currently supports macOS, Windows, and Linux only. Unsupported platform: ${platform}.`
+      );
+  }
+}
+function describePlatform(platform = import_node_process.default.platform) {
+  switch (platform) {
+    case "darwin":
+      return "macOS";
+    case "linux":
+      return "Linux";
+    case "win32":
+      return "Windows";
+    default:
+      return platform;
+  }
+}
+function defaultChromeAllowedOrigins2() {
+  return [...import_companion3.DEXLY_FIXED_ALLOWED_ORIGINS];
+}
+function defaultInstallRoot(options = {}) {
+  const platform = assertSupportedPlatform(options.platform);
+  const homeDir = options.homeDir ?? import_node_os.default.homedir();
+  const env = options.env ?? import_node_process.default.env;
+  switch (platform) {
+    case "darwin":
+      return import_node_path2.default.join(homeDir, "Library", "Application Support", "Dexly", "companion");
+    case "linux": {
+      const dataHome = env.XDG_DATA_HOME?.trim() || import_node_path2.default.join(homeDir, ".local", "share");
+      return import_node_path2.default.join(dataHome, "Dexly", "companion");
+    }
+    case "win32": {
+      const localAppData = env.LOCALAPPDATA?.trim() || import_node_path2.default.join(homeDir, "AppData", "Local");
+      return import_node_path2.default.join(localAppData, "Dexly", "companion");
+    }
+  }
+}
+function resolveChromeHostRegistration(options = {}) {
+  const platform = assertSupportedPlatform(options.platform);
+  const homeDir = options.homeDir ?? import_node_os.default.homedir();
+  const env = options.env ?? import_node_process.default.env;
+  const installRoot = options.installRoot ?? defaultInstallRoot({
+    platform,
+    homeDir,
+    env
+  });
+  const manifestPath = options.manifestDir ? import_node_path2.default.join(options.manifestDir, `${import_companion3.DEXLY_COMPANION_HOST_NAME}.json`) : defaultChromeManifestPath({
+    platform,
+    homeDir,
+    env,
+    installRoot
+  });
+  if (platform === "win32") {
+    return {
+      kind: "windows-registry",
+      manifestPath,
+      allowedOrigins: defaultChromeAllowedOrigins2(),
+      registryKey: options.windowsRegistryKey ?? `HKCU\\Software\\Google\\Chrome\\NativeMessagingHosts\\${import_companion3.DEXLY_COMPANION_HOST_NAME}`
+    };
+  }
+  return {
+    kind: "manifest-file",
+    manifestPath,
+    allowedOrigins: defaultChromeAllowedOrigins2(),
+    registryKey: null
+  };
+}
+function resolvePlatformLayout(options = {}) {
+  const platform = assertSupportedPlatform(options.platform);
+  const installRoot = options.installRoot ?? defaultInstallRoot(options);
+  return {
+    platform,
+    installRoot,
+    activationStrategy: platform === "win32" ? "copy" : "symlink",
+    launcherKind: platform === "win32" ? "windows-cmd" : "posix",
+    launcherFileName: platform === "win32" ? "dexly-companion-host.cmd" : "dexly-companion-host",
+    hostRegistration: resolveChromeHostRegistration({
+      ...options,
+      platform,
+      installRoot
+    })
+  };
+}
+function defaultLauncherPathEntries(platform = import_node_process.default.platform, env = import_node_process.default.env) {
+  switch (assertSupportedPlatform(platform)) {
+    case "darwin":
+      return ["/usr/local/bin", "/opt/homebrew/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"];
+    case "linux":
+      return ["/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"];
+    case "win32": {
+      const systemRoot = env.SystemRoot?.trim() || "C:\\Windows";
+      return [import_node_path2.default.join(systemRoot, "System32"), systemRoot];
+    }
+  }
+}
+function renderHostLauncher(options) {
+  const platform = assertSupportedPlatform(options.platform);
+  const pathEntries = [
+    import_node_path2.default.dirname(options.nodePath),
+    options.codexPath ? import_node_path2.default.dirname(options.codexPath) : null,
+    ...defaultLauncherPathEntries(platform, options.env ?? import_node_process.default.env)
+  ].filter((entry, index, entries) => typeof entry === "string" && entries.indexOf(entry) === index);
+  if (platform === "win32") {
+    const lines2 = [
+      "@echo off",
+      "setlocal",
+      `set "PATH=${toBatchLiteral(pathEntries.join(import_node_path2.default.delimiter))};%PATH%"`,
+      options.codexPath ? `set "DEXLY_COMPANION_CODEX_PATH=${toBatchLiteral(options.codexPath)}"` : null,
+      `set "DEXLY_COMPANION_NODE_PATH=${toBatchLiteral(options.nodePath)}"`,
+      `set "DEXLY_COMPANION_HOST_SCRIPT=${toBatchLiteral(options.hostScriptPath)}"`,
+      '"%DEXLY_COMPANION_NODE_PATH%" "%DEXLY_COMPANION_HOST_SCRIPT%" %*'
+    ].filter((line) => typeof line === "string");
+    return `${lines2.join("\r\n")}\r
+`;
+  }
+  const lines = [
+    "#!/bin/sh",
+    "set -eu",
+    `export PATH=${toShellLiteral(pathEntries.join(import_node_path2.default.delimiter))}`,
+    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 defaultChromeManifestPath(options) {
+  switch (options.platform) {
+    case "darwin":
+      return import_node_path2.default.join(
+        options.homeDir,
+        "Library",
+        "Application Support",
+        "Google",
+        "Chrome",
+        "NativeMessagingHosts",
+        `${import_companion3.DEXLY_COMPANION_HOST_NAME}.json`
+      );
+    case "linux": {
+      const configHome = options.env.XDG_CONFIG_HOME?.trim() || import_node_path2.default.join(options.homeDir, ".config");
+      return import_node_path2.default.join(
+        configHome,
+        "google-chrome",
+        "NativeMessagingHosts",
+        `${import_companion3.DEXLY_COMPANION_HOST_NAME}.json`
+      );
+    }
+    case "win32":
+      return import_node_path2.default.join(options.installRoot, "native-host", `${import_companion3.DEXLY_COMPANION_HOST_NAME}.json`);
+  }
+}
+function toShellLiteral(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function toBatchLiteral(value) {
+  return value.replace(/%/g, "%%").replace(/"/g, '""');
+}
+
+// src/tooling.ts
+var import_node_path3 = __toESM(require("node:path"));
+var import_node_process2 = __toESM(require("node:process"));
+var import_node_child_process = require("node:child_process");
+function detectToolPaths() {
+  const nodePath = import_node_process2.default.execPath;
+  const npmPath = resolveExecutablePath("npm") ?? "npm";
+  const codexPath = resolveExecutablePath("codex");
+  return {
+    nodePath,
+    npmPath,
+    codexPath
+  };
+}
+function resolveExecutablePath(command, env = import_node_process2.default.env, platform = import_node_process2.default.platform) {
+  const lookupCommand = platform === "win32" ? "where" : "which";
+  const result = (0, import_node_child_process.spawnSync)(lookupCommand, [command], {
+    encoding: "utf8",
+    env
+  });
+  if (result.error || result.status !== 0) {
+    return null;
+  }
+  const executablePath = result.stdout.split(/\r?\n/).map((value) => value.trim()).find((value) => value.length > 0);
+  return executablePath ?? null;
+}
+function buildToolEnv(toolPaths, extraPaths = [], platform = import_node_process2.default.platform) {
+  const supportedPlatform = assertSupportedPlatform(platform);
+  const pathSeparator = supportedPlatform === "win32" ? ";" : ":";
+  const pathEntries = [
+    import_node_path3.default.dirname(toolPaths.nodePath),
+    import_node_path3.default.dirname(toolPaths.npmPath),
+    toolPaths.codexPath ? import_node_path3.default.dirname(toolPaths.codexPath) : null,
+    ...extraPaths,
+    ...defaultLauncherPathEntries(supportedPlatform, import_node_process2.default.env),
+    import_node_process2.default.env.PATH ?? null
+  ].filter((entry, index, entries) => typeof entry === "string" && entries.indexOf(entry) === index);
+  return {
+    ...import_node_process2.default.env,
+    PATH: pathEntries.join(pathSeparator),
+    ...toolPaths.codexPath ? { DEXLY_COMPANION_CODEX_PATH: toolPaths.codexPath } : {}
+  };
+}
+async function runCommand(command, args, options = {}) {
+  return await new Promise((resolve, reject) => {
+    const child = spawnManaged(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_process2.default.env.DEXLY_COMPANION_CODEX_PATH ?? "codex", env = import_node_process2.default.env) {
+  const result = spawnManagedSync(codexCommand, ["--version"], {
+    encoding: "utf8",
+    env
+  });
+  if (result.error || result.status !== 0) {
+    return null;
+  }
+  return result.stdout.trim() || null;
+}
+function resolveNpmGlobalBinDir(npmPath, env = import_node_process2.default.env, platform = import_node_process2.default.platform) {
+  const result = spawnManagedSync(npmPath, ["config", "get", "prefix"], {
+    encoding: "utf8",
+    env
+  });
+  if (result.error || result.status !== 0) {
+    return null;
+  }
+  const prefix = result.stdout.trim();
+  if (prefix.length === 0) {
+    return null;
+  }
+  return npmGlobalBinDirFromPrefix(prefix, platform);
+}
+function spawnManaged(command, args, options = {}) {
+  const invocation = buildSpawnInvocation(command, args, options.env);
+  return (0, import_node_child_process.spawn)(invocation.command, invocation.args, {
+    ...options,
+    windowsVerbatimArguments: invocation.windowsVerbatimArguments
+  });
+}
+function spawnManagedSync(command, args, options = {}) {
+  const invocation = buildSpawnInvocation(command, args, options.env);
+  return (0, import_node_child_process.spawnSync)(invocation.command, invocation.args, {
+    ...options,
+    windowsVerbatimArguments: invocation.windowsVerbatimArguments
+  });
+}
+function buildSpawnInvocation(command, args, env = import_node_process2.default.env, platform = import_node_process2.default.platform) {
+  if (platform !== "win32" || !isWindowsCommandScript(command, platform)) {
+    return {
+      command,
+      args
+    };
+  }
+  return {
+    command: resolveWindowsCommandShell(env),
+    args: ["/d", "/s", "/c", quoteWindowsCommand([command, ...args])],
+    windowsVerbatimArguments: false
+  };
+}
+function isWindowsCommandScript(command, platform = import_node_process2.default.platform) {
+  if (platform !== "win32") {
+    return false;
+  }
+  const normalized = command.trim().toLowerCase();
+  return normalized.endsWith(".cmd") || normalized.endsWith(".bat");
+}
+function resolveWindowsCommandShell(env = import_node_process2.default.env) {
+  const comSpec = env.ComSpec?.trim();
+  if (comSpec) {
+    return comSpec;
+  }
+  const systemRoot = env.SystemRoot?.trim() || "C:\\Windows";
+  return import_node_path3.default.join(systemRoot, "System32", "cmd.exe");
+}
+function quoteWindowsCommand(parts) {
+  return parts.map(quoteWindowsArgument).join(" ");
+}
+function quoteWindowsArgument(value) {
+  if (value.length === 0) {
+    return '""';
+  }
+  if (!/[ \t"&()^<>|]/.test(value)) {
+    return value;
+  }
+  return `"${value.replace(/"/g, '""')}"`;
+}
+function npmGlobalBinDirFromPrefix(prefix, platform = import_node_process2.default.platform) {
+  return platform === "win32" ? prefix : import_node_path3.default.join(prefix, "bin");
+}
+
 // 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);
+async function runDoctor(options = {}) {
+  const layout = resolvePlatformLayout(options);
+  const installRoot = layout.installRoot;
+  const manifestPath = layout.hostRegistration.manifestPath;
+  const hostLauncherPath = installedHostLauncherPath(installRoot, layout.platform);
   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}`
+    ok: true,
+    detail: `${describePlatform(layout.platform)} supported.`
   });
+  checks.push(await checkHostRegistration(layout.hostRegistration, options.registryReader));
   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."
-  });
+  checks.push(await checkHostManifest(manifestPath, hostLauncherPath));
+  checks.push(await checkNativeHostRuntime(layout.hostRegistration, options.registryReader));
+  checks.push(await checkCodexAvailability(installRoot, layout.platform));
   return {
     ok: checks.every((check) => check.ok),
     checks
@@ -257,7 +627,7 @@ async function runDoctor(options) {
 }
 async function checkPath(label, filePath) {
   try {
-    await (0, import_promises.access)(filePath);
+    await (0, import_promises2.access)(filePath);
     return {
       label,
       ok: true,
@@ -271,16 +641,39 @@ async function checkPath(label, filePath) {
     };
   }
 }
+async function checkHostRegistration(registration, registryReader) {
+  if (registration.kind === "manifest-file") {
+    return {
+      label: "native host registration",
+      ok: true,
+      detail: registration.manifestPath
+    };
+  }
+  const registeredManifestPath = await (registryReader ?? readWindowsRegistryManifestPath)(registration.registryKey ?? "");
+  if (!registeredManifestPath) {
+    return {
+      label: "native host registration",
+      ok: false,
+      detail: `Chrome registry key is missing or empty: ${registration.registryKey}`
+    };
+  }
+  const ok = registeredManifestPath === registration.manifestPath;
+  return {
+    label: "native host registration",
+    ok,
+    detail: ok ? `Registry points to ${registeredManifestPath}` : `Registry points to ${registeredManifestPath}, expected ${registration.manifestPath}`
+  };
+}
 async function checkHostManifest(filePath, expectedHostPath) {
   try {
-    const raw = await (0, import_promises.readFile)(filePath, "utf8");
+    const raw = await (0, import_promises2.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));
+    const ok = manifest.name === import_companion4.DEXLY_COMPANION_HOST_NAME && typeof manifest.path === "string" && manifest.path === expectedHostPath && import_companion4.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."
+      detail: ok ? `Native host manifest is valid, points to ${expectedHostPath}, and includes ${import_companion4.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 {
@@ -290,10 +683,18 @@ async function checkHostManifest(filePath, expectedHostPath) {
     };
   }
 }
-async function checkNativeHostRuntime(manifestPath) {
-  const defaultOrigin = `chrome-extension://${import_companion2.DEXLY_DEV_EXTENSION_ID}/`;
+async function checkNativeHostRuntime(registration, registryReader) {
+  const defaultOrigin = `chrome-extension://${import_companion4.DEXLY_DEV_EXTENSION_ID}/`;
+  const registeredManifestPath = registration.kind === "windows-registry" ? await (registryReader ?? readWindowsRegistryManifestPath)(registration.registryKey ?? "") : registration.manifestPath;
+  if (!registeredManifestPath) {
+    return {
+      label: "native host runtime",
+      ok: false,
+      detail: "Dexly Companion could not resolve the registered native host manifest path."
+    };
+  }
   try {
-    const raw = await (0, import_promises.readFile)(manifestPath, "utf8");
+    const raw = await (0, import_promises2.readFile)(registeredManifestPath, "utf8");
     const manifest = JSON.parse(raw);
     if (typeof manifest.path !== "string" || manifest.path.length === 0) {
       return {
@@ -332,8 +733,32 @@ async function checkNativeHostRuntime(manifestPath) {
     };
   }
 }
+async function checkCodexAvailability(installRoot, platform) {
+  const metadata = await loadInstallMetadata(installRoot);
+  const env = metadata ? buildToolEnv(metadata.tools, [], platform) : process.env;
+  const codexVersion = metadata ? resolveCodexVersion(metadata.tools.codexPath ?? void 0, env) : resolveCodexVersion(void 0, env);
+  if (codexVersion) {
+    return {
+      label: "codex",
+      ok: true,
+      detail: codexVersion
+    };
+  }
+  if (metadata?.tools.codexPath) {
+    return {
+      label: "codex",
+      ok: false,
+      detail: `Codex CLI was not available via stored install metadata (${metadata.tools.codexPath}).`
+    };
+  }
+  return {
+    label: "codex",
+    ok: false,
+    detail: "Codex CLI not found in stored install metadata or PATH."
+  };
+}
 async function runHostHealthCheck(hostPath, origin) {
-  const child = (0, import_node_child_process.spawn)(hostPath, [origin], {
+  const child = spawnManaged(hostPath, [origin], {
     stdio: ["pipe", "pipe", "pipe"]
   });
   const parser = new NativeMessageParser();
@@ -345,8 +770,8 @@ async function runHostHealthCheck(hostPath, origin) {
       }, 3e3);
       const cleanup = () => {
         clearTimeout(timeout);
-        child.stdout.off("data", handleStdout);
-        child.stderr.off("data", handleStderr);
+        child.stdout?.off("data", handleStdout);
+        child.stderr?.off("data", handleStderr);
         child.off("error", handleError);
         child.off("exit", handleExit);
       };
@@ -375,19 +800,19 @@ async function runHostHealthCheck(hostPath, origin) {
           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.stdout?.on("data", handleStdout);
+      child.stderr?.on("data", handleStderr);
       child.once("error", handleError);
       child.once("exit", handleExit);
     });
-    child.stdin.write(
+    child.stdin?.write(
       encodeNativeMessage({
         kind: "host/health",
         requestId: "doctor-health"
       })
     );
     const response = await messagePromise;
-    child.stdin.end();
+    child.stdin?.end();
     await Promise.race([
       (0, import_node_events.once)(child, "exit"),
       new Promise((resolve) => setTimeout(resolve, 250))
@@ -397,14 +822,21 @@ async function runHostHealthCheck(hostPath, origin) {
     child.kill();
   }
 }
-function resolveCodexVersion() {
-  const result = (0, import_node_child_process.spawnSync)("codex", ["--version"], {
-    encoding: "utf8"
-  });
-  if (result.error || result.status !== 0) {
+async function readWindowsRegistryManifestPath(registryKey) {
+  if (!registryKey.trim()) {
+    return null;
+  }
+  try {
+    const result = await runCommand("reg.exe", ["query", registryKey, "/ve"]);
+    const match = result.stdout.split(/\r?\n/).map((line) => line.trim()).find((line) => line.includes("REG_SZ"));
+    if (!match) {
+      return null;
+    }
+    const [, value] = match.split(/REG_SZ/i);
+    return value?.trim() || null;
+  } catch {
     return null;
   }
-  return result.stdout.trim() || null;
 }
 
 // src/host-runtime.ts
@@ -412,220 +844,62 @@ 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());
+var import_companion6 = __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"
-  );
-}
+var import_companion5 = __toESM(require_companion());
 
 // 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
+var import_node_path4 = __toESM(require("node:path"));
 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 layout = resolvePlatformLayout(options);
+  const installRoot = layout.installRoot;
+  const manifestPath = layout.hostRegistration.manifestPath;
+  const hostPath = installedHostLauncherPath(installRoot, layout.platform);
   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 sourceDistDir = import_node_path4.default.join(options.sourcePackageDir, "dist");
+  const sourcePackageJsonPath = import_node_path4.default.join(options.sourcePackageDir, "package.json");
   const installVersion = await readInstallPackageVersion(sourcePackageJsonPath);
   const versionRoot = versionInstallPath(installRoot, installVersion);
   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.mkdir)(import_node_path4.default.join(stagingVersionRoot, "dist"), { recursive: true });
+    await (0, import_promises3.cp)(sourceDistDir, import_node_path4.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 chmodIfSupported(layout.platform, versionedCliPath(stagingVersionRoot));
+    await chmodIfSupported(layout.platform, versionedHostScriptPath(stagingVersionRoot));
+    await (0, import_promises3.mkdir)(import_node_path4.default.dirname(versionedHostLauncherPath(stagingVersionRoot, layout.platform)), { recursive: true });
     await (0, import_promises3.writeFile)(
-      versionedHostLauncherPath(stagingVersionRoot),
+      versionedHostLauncherPath(stagingVersionRoot, layout.platform),
       renderHostLauncher({
+        platform: layout.platform,
         nodePath: toolPaths.nodePath,
         hostScriptPath: installedHostScriptPath(installRoot),
         codexPath: toolPaths.codexPath
       }),
       "utf8"
     );
-    await (0, import_promises3.chmod)(versionedHostLauncherPath(stagingVersionRoot), 493);
+    await chmodIfSupported(layout.platform, versionedHostLauncherPath(stagingVersionRoot, layout.platform));
     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, installVersion);
-  await rewriteCurrentLauncher(installRoot, toolPaths);
-  await ensureChromeHostManifest(installRoot, manifestDir);
+  await activateInstalledVersion(installRoot, installVersion, { platform: layout.platform });
+  await rewriteCurrentLauncher(installRoot, toolPaths, { platform: layout.platform });
+  await ensureChromeHostRegistration(installRoot, {
+    ...options,
+    platform: layout.platform,
+    registryWriter: options.registryWriter
+  });
   const existingMetadata = await loadInstallMetadata(installRoot);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const metadata = {
@@ -651,13 +925,30 @@ async function installCompanion(options) {
     hostPath,
     allowedOrigins,
     version: installVersion,
-    metadataPath: import_node_path3.default.join(installRoot, "install-metadata.json")
+    metadataPath: import_node_path4.default.join(installRoot, "install-metadata.json")
   };
 }
-async function activateInstalledVersion(installRoot, version) {
+async function activateInstalledVersion(installRoot, version, options = {}) {
+  const layout = resolvePlatformLayout({
+    installRoot,
+    platform: options.platform
+  });
   const currentPath = currentInstallPath(installRoot);
+  const versionPath = versionInstallPath(installRoot, version);
+  if (layout.activationStrategy === "copy") {
+    const stagingCurrentPath = `${currentPath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    await (0, import_promises3.rm)(stagingCurrentPath, { recursive: true, force: true });
+    await (0, import_promises3.cp)(versionPath, stagingCurrentPath, { recursive: true });
+    try {
+      await (0, import_promises3.rename)(stagingCurrentPath, currentPath);
+    } catch {
+      await (0, import_promises3.rm)(currentPath, { recursive: true, force: true });
+      await (0, import_promises3.rename)(stagingCurrentPath, currentPath);
+    }
+    return;
+  }
   const tempLinkPath = `${currentPath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  const targetPath = import_node_path3.default.join("versions", version);
+  const targetPath = import_node_path4.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);
@@ -668,30 +959,51 @@ async function activateInstalledVersion(installRoot, version) {
     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 });
+async function rewriteCurrentLauncher(installRoot, toolPaths, options = {}) {
+  const layout = resolvePlatformLayout({
+    installRoot,
+    platform: options.platform
+  });
+  const launcherPath = installedHostLauncherPath(installRoot, layout.platform);
+  await (0, import_promises3.mkdir)(import_node_path4.default.dirname(launcherPath), { recursive: true });
   await (0, import_promises3.writeFile)(
     launcherPath,
     renderHostLauncher({
+      platform: layout.platform,
       nodePath: toolPaths.nodePath,
       hostScriptPath: installedHostScriptPath(installRoot),
       codexPath: toolPaths.codexPath
     }),
     "utf8"
   );
-  await (0, import_promises3.chmod)(launcherPath, 493);
+  await chmodIfSupported(layout.platform, launcherPath);
   return launcherPath;
 }
-async function ensureChromeHostManifest(installRoot, manifestDir) {
-  const manifestPath = installedHostManifestPath(manifestDir);
-  await (0, import_promises3.mkdir)(manifestDir, { recursive: true });
+async function ensureChromeHostRegistration(installRoot, options = {}) {
+  const layout = resolvePlatformLayout({
+    installRoot,
+    platform: options.platform,
+    manifestDir: options.manifestDir,
+    windowsRegistryKey: options.windowsRegistryKey
+  });
+  const manifestPath = layout.hostRegistration.manifestPath;
+  await (0, import_promises3.mkdir)(import_node_path4.default.dirname(manifestPath), { recursive: true });
   await (0, import_promises3.writeFile)(
     manifestPath,
-    `${JSON.stringify(buildChromeHostManifest(installedHostLauncherPath(installRoot), defaultChromeAllowedOrigins()), null, 2)}
+    `${JSON.stringify(
+      buildChromeHostManifest(installedHostLauncherPath(installRoot, layout.platform), layout.hostRegistration.allowedOrigins),
+      null,
+      2
+    )}
 `,
     "utf8"
   );
+  if (layout.hostRegistration.kind === "windows-registry" && layout.hostRegistration.registryKey) {
+    await (options.registryWriter ?? writeWindowsRegistryManifestPath)(
+      layout.hostRegistration.registryKey,
+      manifestPath
+    );
+  }
   return manifestPath;
 }
 async function pruneVersionStore(installRoot, keepVersions) {
@@ -702,14 +1014,14 @@ async function pruneVersionStore(installRoot, keepVersions) {
     if (keep.has(entry)) {
       return;
     }
-    await (0, import_promises3.rm)(import_node_path3.default.join(versionsPath, entry), { recursive: true, force: true });
+    await (0, import_promises3.rm)(import_node_path4.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")
+    import_node_path4.default.join(sourcePackageDir, "dist", "cli.js"),
+    import_node_path4.default.join(sourcePackageDir, "dist", "host.js"),
+    import_node_path4.default.join(sourcePackageDir, "package.json")
   ];
   for (const filePath of requiredPaths) {
     try {
@@ -728,29 +1040,23 @@ async function readInstallPackageVersion(packageJsonPath) {
   }
   return packageJson.version.trim();
 }
-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")}
-`;
+async function chmodIfSupported(platform, targetPath) {
+  if (platform === "win32") {
+    return;
+  }
+  await (0, import_promises3.chmod)(targetPath, 493);
 }
-function toShellLiteral(value) {
-  return `'${value.replace(/'/g, `'"'"'`)}'`;
+async function writeWindowsRegistryManifestPath(registryKey, manifestPath) {
+  await runCommand("reg.exe", [
+    "add",
+    registryKey,
+    "/ve",
+    "/t",
+    "REG_SZ",
+    "/d",
+    manifestPath,
+    "/f"
+  ]);
 }
 
 // src/management.ts
@@ -771,19 +1077,19 @@ function nextMetadata(metadata, nextVersion, channel) {
   };
 }
 async function upgradeInstalledCompanion(options) {
-  const installRoot = options.installRoot ?? defaultInstallRoot();
+  const installRoot = options.installRoot ?? defaultInstallRoot({ platform: options.platform });
   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);
+  const targetSpecifier = `${import_companion5.DEXLY_COMPANION_PACKAGE_NAME}@${specifier}`;
+  const env = buildToolEnv(metadata.tools, [], options.platform);
   await runCommand(metadata.tools.npmPath, [
     "exec",
     "--yes",
     `--package=${targetSpecifier}`,
-    import_companion4.DEXLY_COMPANION_EXECUTABLE_NAME,
+    import_companion5.DEXLY_COMPANION_EXECUTABLE_NAME,
     "install",
     "--channel",
     options.distTag
@@ -799,8 +1105,7 @@ async function upgradeInstalledCompanion(options) {
   };
 }
 async function rollbackInstalledCompanion(options) {
-  const installRoot = options?.installRoot ?? defaultInstallRoot();
-  const manifestDir = options?.manifestDir ?? defaultChromeHostManifestDir();
+  const installRoot = options?.installRoot ?? defaultInstallRoot({ platform: options?.platform });
   const metadata = await loadInstallMetadata(installRoot);
   if (!metadata) {
     throw new Error("Dexly Companion install metadata is missing. Reinstall Dexly Companion first.");
@@ -810,9 +1115,13 @@ async function rollbackInstalledCompanion(options) {
     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);
+  await activateInstalledVersion(installRoot, previousVersion, { platform: options?.platform });
+  await rewriteCurrentLauncher(installRoot, metadata.tools, { platform: options?.platform });
+  await ensureChromeHostRegistration(installRoot, {
+    platform: options?.platform,
+    manifestDir: options?.manifestDir,
+    windowsRegistryKey: options?.windowsRegistryKey
+  });
   const next = nextMetadata(metadata, previousVersion, metadata.currentChannel);
   next.previousVersion = metadata.currentVersion;
   await saveInstallMetadata(installRoot, next);
@@ -822,16 +1131,15 @@ async function rollbackInstalledCompanion(options) {
   };
 }
 async function installCodexWithCompanion(options) {
-  const installRoot = options?.installRoot ?? defaultInstallRoot();
-  const manifestDir = options?.manifestDir ?? defaultChromeHostManifestDir();
+  const installRoot = options?.installRoot ?? defaultInstallRoot({ platform: options?.platform });
   const existingMetadata = await loadInstallMetadata(installRoot);
   const toolPaths = existingMetadata?.tools ?? detectToolPaths();
-  const env = buildToolEnv(toolPaths);
+  const env = buildToolEnv(toolPaths, [], options?.platform);
   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);
+  const globalBinDir = resolveNpmGlobalBinDir(toolPaths.npmPath, env, options?.platform);
+  const nextEnv = buildToolEnv(toolPaths, globalBinDir ? [globalBinDir] : [], options?.platform);
+  const codexPath = resolveExecutablePath("codex", nextEnv, options?.platform);
+  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.");
   }
@@ -839,8 +1147,12 @@ async function installCodexWithCompanion(options) {
     ...toolPaths,
     codexPath
   };
-  await rewriteCurrentLauncher(installRoot, nextToolPaths);
-  await ensureChromeHostManifest(installRoot, manifestDir);
+  await rewriteCurrentLauncher(installRoot, nextToolPaths, { platform: options?.platform });
+  await ensureChromeHostRegistration(installRoot, {
+    platform: options?.platform,
+    manifestDir: options?.manifestDir,
+    windowsRegistryKey: options?.windowsRegistryKey
+  });
   if (existingMetadata) {
     await saveInstallMetadata(installRoot, {
       ...existingMetadata,
@@ -851,7 +1163,7 @@ async function installCodexWithCompanion(options) {
   return {
     codexPath,
     codexVersion,
-    installCommand: import_companion4.DEXLY_CODEX_INSTALL_COMMAND
+    installCommand: import_companion5.DEXLY_CODEX_INSTALL_COMMAND
   };
 }
 
@@ -869,8 +1181,8 @@ var DexlyNativeHost = class {
   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.spawnProcess = options.spawnProcess ?? ((command, args, spawnOptions) => spawnManaged(command, [...args], spawnOptions));
+    this.spawnProcessSync = options.spawnProcessSync ?? ((command, args, spawnOptions) => spawnManagedSync(command, [...args], spawnOptions));
     this.codexCommand = options.codexCommand ?? import_node_process3.default.env.DEXLY_COMPANION_CODEX_PATH ?? "codex";
     this.requestProcessExit = options.requestProcessExit ?? null;
   }
@@ -1131,7 +1443,7 @@ var DexlyNativeHost = class {
         null,
         null,
         "codex_not_connected",
-        `${import_companion5.DEXLY_COMPANION_DISPLAY_NAME} is not connected to Codex app-server.`
+        `${import_companion6.DEXLY_COMPANION_DISPLAY_NAME} is not connected to Codex app-server.`
       ));
       return;
     }
@@ -1266,7 +1578,7 @@ async function runHost() {
 async function runInstall(args) {
   const parsed = parseArgs(args);
   const result = await installCompanion({
-    sourcePackageDir: import_node_path4.default.resolve(__dirname, ".."),
+    sourcePackageDir: import_node_path5.default.resolve(__dirname, ".."),
     installRoot: parsed.installRoot,
     manifestDir: parsed.manifestDir,
     channel: parsed.channel
@@ -1294,7 +1606,7 @@ async function runDoctorCommand(args) {
   }
   if (!result.ok) {
     import_node_process5.default.stdout.write(`
-If Dexly Companion is missing, run ${import_companion6.DEXLY_COMPANION_INSTALL_COMMAND}.
+If Dexly Companion is missing, run ${import_companion7.DEXLY_COMPANION_INSTALL_COMMAND}.
 `);
     import_node_process5.default.exitCode = 1;
   }