@dexlyai/dexly 0.1.2 → 0.1.3

package/dist/host.js

@@ -117,33 +117,22 @@ var require_companion = __commonJS({
 });
 
 // src/host.ts
-var import_node_process4 = __toESM(require("node:process"));
+var import_node_process5 = __toESM(require("node:process"));
 
 // src/host-runtime.ts
-var import_node_process3 = __toESM(require("node:process"));
+var import_node_process4 = __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_process3 = __toESM(require("node:process"));
 var import_node_readline = __toESM(require("node:readline"));
-var import_companion4 = __toESM(require_companion());
+var import_companion5 = __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];
-}
 function currentInstallPath(installRoot) {
   return import_node_path.default.join(installRoot, "current");
 }
@@ -153,11 +142,8 @@ function installMetadataPath(installRoot) {
 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 installedHostLauncherPath(installRoot, platform = process.platform) {
+  return import_node_path.default.join(currentInstallPath(installRoot), "bin", resolveLauncherFileName(platform));
 }
 function buildChromeHostManifest(hostPath, allowedOrigins) {
   return {
@@ -168,9 +154,12 @@ function buildChromeHostManifest(hostPath, allowedOrigins) {
     allowed_origins: allowedOrigins
   };
 }
+function resolveLauncherFileName(platform) {
+  return platform === "win32" ? "dexly-companion-host.cmd" : "dexly-companion-host";
+}
 
 // src/management.ts
-var import_companion3 = __toESM(require_companion());
+var import_companion4 = __toESM(require_companion());
 
 // src/install-metadata.ts
 var import_promises = require("node:fs/promises");
@@ -233,14 +222,171 @@ async function saveInstallMetadata(installRoot, metadata) {
 
 // src/install.ts
 var import_promises2 = require("node:fs/promises");
-var import_node_path3 = __toESM(require("node:path"));
+var import_node_path4 = __toESM(require("node:path"));
 
-// src/tooling.ts
+// 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 defaultChromeAllowedOrigins() {
+  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: defaultChromeAllowedOrigins(),
+      registryKey: options.windowsRegistryKey ?? `HKCU\\Software\\Google\\Chrome\\NativeMessagingHosts\\${import_companion3.DEXLY_COMPANION_HOST_NAME}`
+    };
+  }
+  return {
+    kind: "manifest-file",
+    manifestPath,
+    allowedOrigins: defaultChromeAllowedOrigins(),
+    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_process.default.execPath;
+  const nodePath = import_node_process2.default.execPath;
   const npmPath = resolveExecutablePath("npm") ?? "npm";
   const codexPath = resolveExecutablePath("codex");
   return {
@@ -249,40 +395,38 @@ function detectToolPaths() {
     codexPath
   };
 }
-function resolveExecutablePath(command, env = import_node_process.default.env) {
-  const result = (0, import_node_child_process.spawnSync)("which", [command], {
+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.status !== 0) {
+  if (result.error || result.status !== 0) {
     return null;
   }
-  const executablePath = result.stdout.trim();
-  return executablePath.length > 0 ? executablePath : null;
+  const executablePath = result.stdout.split(/\r?\n/).map((value) => value.trim()).find((value) => value.length > 0);
+  return executablePath ?? null;
 }
-function buildToolEnv(toolPaths, extraPaths = []) {
+function buildToolEnv(toolPaths, extraPaths = [], platform = import_node_process2.default.platform) {
+  const supportedPlatform = assertSupportedPlatform(platform);
+  const pathSeparator = supportedPlatform === "win32" ? ";" : ":";
   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,
+    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,
-    "/usr/local/bin",
-    "/opt/homebrew/bin",
-    "/usr/bin",
-    "/bin",
-    "/usr/sbin",
-    "/sbin",
-    import_node_process.default.env.PATH ?? null
+    ...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_process.default.env,
-    PATH: pathEntries.join(":"),
+    ...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 = (0, import_node_child_process.spawn)(command, args, {
+    const child = spawnManaged(command, args, {
       cwd: options.cwd,
       env: options.env,
       stdio: "pipe"
@@ -310,8 +454,8 @@ async function runCommand(command, args, options = {}) {
     });
   });
 }
-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"], {
+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
   });
@@ -320,8 +464,8 @@ function resolveCodexVersion(codexCommand = import_node_process.default.env.DEXL
   }
   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"], {
+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
   });
@@ -329,76 +473,151 @@ function resolveNpmGlobalBinDir(npmPath, env = import_node_process.default.env)
     return null;
   }
   const prefix = result.stdout.trim();
-  return prefix.length > 0 ? import_node_path2.default.join(prefix, "bin") : null;
+  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/install.ts
-async function rewriteCurrentLauncher(installRoot, toolPaths) {
-  const launcherPath = installedHostLauncherPath(installRoot);
-  await (0, import_promises2.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_promises2.mkdir)(import_node_path4.default.dirname(launcherPath), { recursive: true });
   await (0, import_promises2.writeFile)(
     launcherPath,
     renderHostLauncher({
+      platform: layout.platform,
       nodePath: toolPaths.nodePath,
       hostScriptPath: installedHostScriptPath(installRoot),
       codexPath: toolPaths.codexPath
     }),
     "utf8"
   );
-  await (0, import_promises2.chmod)(launcherPath, 493);
+  await chmodIfSupported(layout.platform, launcherPath);
   return launcherPath;
 }
-async function ensureChromeHostManifest(installRoot, manifestDir) {
-  const manifestPath = installedHostManifestPath(manifestDir);
-  await (0, import_promises2.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_promises2.mkdir)(import_node_path4.default.dirname(manifestPath), { recursive: true });
   await (0, import_promises2.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;
 }
-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_promises2.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
 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_companion3.DEXLY_COMPANION_PACKAGE_NAME}@${specifier}`;
-  const env = buildToolEnv(metadata.tools);
+  const targetSpecifier = `${import_companion4.DEXLY_COMPANION_PACKAGE_NAME}@${specifier}`;
+  const env = buildToolEnv(metadata.tools, [], options.platform);
   await runCommand(metadata.tools.npmPath, [
     "exec",
     "--yes",
     `--package=${targetSpecifier}`,
-    import_companion3.DEXLY_COMPANION_EXECUTABLE_NAME,
+    import_companion4.DEXLY_COMPANION_EXECUTABLE_NAME,
     "install",
     "--channel",
     options.distTag
@@ -414,15 +633,14 @@ async function upgradeInstalledCompanion(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 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.");
@@ -431,8 +649,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,
@@ -443,7 +665,7 @@ async function installCodexWithCompanion(options) {
   return {
     codexPath,
     codexVersion,
-    installCommand: import_companion3.DEXLY_CODEX_INSTALL_COMMAND
+    installCommand: import_companion4.DEXLY_CODEX_INSTALL_COMMAND
   };
 }
 
@@ -461,9 +683,9 @@ var DexlyNativeHost = class {
   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.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;
   }
   async handleMessage(message) {
@@ -723,7 +945,7 @@ var DexlyNativeHost = class {
         null,
         null,
         "codex_not_connected",
-        `${import_companion4.DEXLY_COMPANION_DISPLAY_NAME} is not connected to Codex app-server.`
+        `${import_companion5.DEXLY_COMPANION_DISPLAY_NAME} is not connected to Codex app-server.`
       ));
       return;
     }
@@ -813,19 +1035,19 @@ function writeNativeMessage(output, message) {
 // src/host-runtime.ts
 async function runNativeHost() {
   const host = new DexlyNativeHost({
-    send: (message) => writeNativeMessage(import_node_process3.default.stdout, message),
+    send: (message) => writeNativeMessage(import_node_process4.default.stdout, message),
     requestProcessExit: () => {
-      setTimeout(() => import_node_process3.default.exit(0), 25);
+      setTimeout(() => import_node_process4.default.exit(0), 25);
     }
   });
-  import_node_process3.default.stdout.on("error", (error) => {
+  import_node_process4.default.stdout.on("error", (error) => {
     if ("code" in error && error.code === "EPIPE") {
-      void host.close().finally(() => import_node_process3.default.exit(0));
+      void host.close().finally(() => import_node_process4.default.exit(0));
     }
   });
-  const detachReader = createNativeMessageReader(import_node_process3.default.stdin, (message) => {
+  const detachReader = createNativeMessageReader(import_node_process4.default.stdin, (message) => {
     void host.handleMessage(message).catch((error) => {
-      writeNativeMessage(import_node_process3.default.stdout, {
+      writeNativeMessage(import_node_process4.default.stdout, {
         kind: "host/error",
         action: null,
         requestId: null,
@@ -838,21 +1060,21 @@ async function runNativeHost() {
     detachReader();
     await host.close();
   };
-  import_node_process3.default.stdin.on("end", () => {
-    void shutdown().finally(() => import_node_process3.default.exit(0));
+  import_node_process4.default.stdin.on("end", () => {
+    void shutdown().finally(() => import_node_process4.default.exit(0));
   });
-  import_node_process3.default.on("SIGINT", () => {
-    void shutdown().finally(() => import_node_process3.default.exit(0));
+  import_node_process4.default.on("SIGINT", () => {
+    void shutdown().finally(() => import_node_process4.default.exit(0));
   });
-  import_node_process3.default.on("SIGTERM", () => {
-    void shutdown().finally(() => import_node_process3.default.exit(0));
+  import_node_process4.default.on("SIGTERM", () => {
+    void shutdown().finally(() => import_node_process4.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_process5.default.stderr.write(`${message}
 `);
-  import_node_process4.default.exit(1);
+  import_node_process5.default.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexlyai/dexly",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "type": "commonjs",
   "bin": {
     "dexly": "dist/cli.js"