@lark-codem/codem-cli 0.1.185 → 0.1.187-windows-daemon-host.100100730469.0.gd9c67df

package/bin/codem.js

@@ -18,6 +18,11 @@ import { createRequire } from "node:module";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
+import {
+  applyHostedWindowsChildOptions,
+  watchWindowsDaemonHostMigration
+} from "./platform-child-process.js";
+
 const require = createRequire(import.meta.url);
 const LAUNCHER_DIR = path.dirname(fileURLToPath(import.meta.url));
 const PACKAGE_ROOT = path.resolve(LAUNCHER_DIR, "..");
@@ -51,7 +56,7 @@ function resolvePlatformBinary() {
 // spawn 的失败有两条互斥出口：只有 EACCES / EAGAIN / EMFILE / ENFILE / ENOENT
 // 会被 Node 降级成异步 `error` 事件，其余 errno（ENOEXEC / ENOTDIR / EPERM，以及
 // Windows 上杀软 / EDR 拦截 CreateProcessW 时 libuv 报的 UNKNOWN=-4094）在
-// `child_process.spawn()` 里直接 `throw new ErrnoException(err, 'spawn')`。
+// `child_process.spawn` 里直接 `throw new ErrnoException(err, 'spawn')`。
 // stderr 同步写。本文件里每一条诊断后面都紧跟 process.exit，而 process.exit()
 // 按 Node 官方契约会**放弃尚未完成的 stdout/stderr I/O**（"a note on process I/O"）。
 // stderr 是否同步取决于它接的是什么：
@@ -144,8 +149,18 @@ const binaryPath = resolvePlatformBinary();
 
 if (binaryPath) {
   let child;
+  let stopWindowsHostMigrationWatch = () => {};
   try {
-    child = spawn(binaryPath, process.argv.slice(2), { stdio: "inherit" });
+    child = spawn(
+      binaryPath,
+      process.argv.slice(2),
+      applyHostedWindowsChildOptions({ stdio: "inherit" })
+    );
+    stopWindowsHostMigrationWatch = watchWindowsDaemonHostMigration({
+      binaryPath,
+      daemonPid: child.pid,
+      launcherPid: process.pid
+    });
   } catch (error) {
     reportSpawnFailure(binaryPath, error);
   }
@@ -175,6 +190,7 @@ if (binaryPath) {
   });
 
   child.on("exit", (code, signal) => {
+    stopWindowsHostMigrationWatch();
     for (const [registeredSignal, handler] of signalHandlers) {
       process.removeListener(registeredSignal, handler);
     }

package/bin/platform-child-process.js

@@ -0,0 +1,178 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+const WINDOWS_LEGACY_DAEMON_CAPABILITY = "shutdown_for_service_operation";
+const WINDOWS_LEGACY_DAEMON_CAPABILITY_RELATIVE_PATH = path.join(
+  "runtime",
+  "legacy-daemon-control",
+  "capability.json"
+);
+
+// The dedicated Windows daemon Host owns the top-level console policy.  Every
+// child it can reach must stay hidden, and a local spawn option must not be able
+// to undo that invariant.  Interactive and non-Windows launches keep their
+// options object untouched.
+export function applyHostedWindowsChildOptions(
+  options = {},
+  {
+    // Hosted mode belongs to the current daemon process, not to the child env
+    // object supplied by an individual caller. Otherwise a caller could omit
+    // or replace `options.env` and accidentally bypass the console invariant.
+    env = process.env,
+    platform = process.platform
+  } = {}
+) {
+  if (platform !== "win32" || env?.CODEM_DAEMON_HOSTED_WINDOWS !== "1") {
+    return options;
+  }
+
+  return {
+    ...options,
+    windowsHide: true
+  };
+}
+
+export function shouldWatchWindowsDaemonHostMigration({
+  platform = process.platform,
+  argv = process.argv.slice(2),
+  env = process.env
+} = {}) {
+  return platform === "win32" &&
+    argv[0] === "daemon" &&
+    env?.CODEM_DAEMON_HOSTED_WINDOWS !== "1" &&
+    typeof env?.CODEM_DAEMON_RUNTIME_CLIENT_INSTANCE_ID === "string" &&
+    env.CODEM_DAEMON_RUNTIME_CLIENT_INSTANCE_ID.trim() !== "";
+}
+
+export function isCurrentWindowsLegacyDaemonCapability(
+  value,
+  { daemonPid, startedAtMs } = {}
+) {
+  return value?.schemaVersion === 1 &&
+    value?.protocolVersion === 1 &&
+    value?.capability === WINDOWS_LEGACY_DAEMON_CAPABILITY &&
+    Number(value?.rootIdentity?.pid) === daemonPid &&
+    Number(value?.publishedAtUnixMs) >= startedAtMs;
+}
+
+export function launchWindowsDaemonHostMigration({
+  binaryPath,
+  launcherPid = process.pid,
+  env = process.env,
+  spawnImpl = spawn
+} = {}) {
+  if (String(binaryPath).includes("'")) {
+    throw new Error("CodeM runtime path cannot be represented in the Windows migration handoff");
+  }
+  const workingDirectory = path.win32.dirname(binaryPath);
+  if (workingDirectory.includes("'")) {
+    throw new Error("CodeM working directory cannot be represented in the Windows migration handoff");
+  }
+  const commandLine = `"${binaryPath}" service start --windows-migration-launcher-pid ${launcherPid}`;
+  const script = [
+    "$startup = ([wmiclass]'Win32_ProcessStartup').CreateInstance()",
+    "$startup.ShowWindow = 0",
+    `$result = ([wmiclass]'Win32_Process').Create('${commandLine}', '${workingDirectory}', $startup)`,
+    "if ($null -eq $result -or [int]$result.ReturnValue -ne 0) { exit 1 }"
+  ].join("\r\n");
+  const powershellPath = path.win32.join(
+    env?.SystemRoot || String.raw`C:\Windows`,
+    "System32",
+    "WindowsPowerShell",
+    "v1.0",
+    "powershell.exe"
+  );
+  const bridge = spawnImpl(powershellPath, [
+    "-NoLogo",
+    "-NoProfile",
+    "-NonInteractive",
+    "-WindowStyle",
+    "Hidden",
+    "-EncodedCommand",
+    Buffer.from(script, "utf16le").toString("base64")
+  ], {
+    env,
+    stdio: "ignore",
+    windowsHide: true
+  });
+  // Task Scheduler may place the launcher in a Job. CREATE_NEW_PROCESS_GROUP
+  // (`detached` in Node) does not escape that Job. Windows PowerShell delegates
+  // the exact worker creation to Win32_Process.Create, whose documented
+  // contract creates it outside the caller's Job; the short-lived bridge can
+  // then remain inside the Task without owning migration lifetime.
+  bridge.once?.("error", () => {});
+  bridge.unref?.();
+  return bridge;
+}
+
+export function watchWindowsDaemonHostMigration({
+  binaryPath,
+  daemonPid,
+  launcherPid = process.pid,
+  argv = process.argv.slice(2),
+  env = process.env,
+  platform = process.platform,
+  codemHome = env?.CODEM_HOME || path.join(env?.USERPROFILE || os.homedir(), ".codem"),
+  fsImpl = fs,
+  spawnImpl = spawn,
+  pollIntervalMs = 250,
+  timeoutMs = 60_000,
+  nowImpl = Date.now,
+  setTimeoutImpl = setTimeout,
+  clearTimeoutImpl = clearTimeout
+} = {}) {
+  if (!shouldWatchWindowsDaemonHostMigration({ platform, argv, env })) {
+    return () => {};
+  }
+
+  const capabilityPath = path.join(codemHome, WINDOWS_LEGACY_DAEMON_CAPABILITY_RELATIVE_PATH);
+  const startedAtMs = nowImpl();
+  let stopped = false;
+  let timer = null;
+
+  const stop = () => {
+    stopped = true;
+    if (timer !== null) {
+      clearTimeoutImpl(timer);
+      timer = null;
+    }
+  };
+  const schedule = () => {
+    if (stopped) return;
+    timer = setTimeoutImpl(() => {
+      timer = null;
+      void probe();
+    }, pollIntervalMs);
+    timer?.unref?.();
+  };
+  const probe = async () => {
+    if (stopped) return;
+    try {
+      const value = JSON.parse(await fsImpl.readFile(capabilityPath, "utf8"));
+      if (isCurrentWindowsLegacyDaemonCapability(value, { daemonPid, startedAtMs })) {
+        stop();
+        launchWindowsDaemonHostMigration({
+          binaryPath,
+          launcherPid,
+          env,
+          spawnImpl
+        });
+        return;
+      }
+    } catch {
+      // Capability publication is atomic and expected to be absent while the
+      // daemon starts. A malformed/unreadable file is never accepted; keep the
+      // bounded watcher alive so a later valid replacement can win.
+    }
+    if (nowImpl() - startedAtMs >= timeoutMs) {
+      stop();
+      return;
+    }
+    schedule();
+  };
+
+  void probe();
+  return stop;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-codem/codem-cli",
-  "version": "0.1.185",
+  "version": "0.1.187-windows-daemon-host.100100730469.0.gd9c67df",
   "type": "module",
   "description": "CodeM local CLI for Feishu-driven coding sessions",
   "license": "SEE LICENSE IN LICENSE",
@@ -26,15 +26,15 @@
     "access": "public"
   },
   "dependencies": {
-    "@lark-codem/codem-core": "0.8.14"
+    "@lark-codem/codem-core": "0.8.16-windows-daemon-host.100100730469.0.gb96411f"
   },
   "optionalDependencies": {
-    "@lark-codem/codem-cli-darwin-arm64": "0.1.185",
-    "@lark-codem/codem-cli-darwin-x64": "0.1.185",
-    "@lark-codem/codem-cli-linux-x64": "0.1.185",
-    "@lark-codem/codem-cli-linux-arm64": "0.1.185",
-    "@lark-codem/codem-cli-win32-arm64": "0.1.185",
-    "@lark-codem/codem-cli-win32-x64": "0.1.185"
+    "@lark-codem/codem-cli-darwin-arm64": "0.1.187-windows-daemon-host.100100730469.0.gd9c67df",
+    "@lark-codem/codem-cli-darwin-x64": "0.1.187-windows-daemon-host.100100730469.0.gd9c67df",
+    "@lark-codem/codem-cli-linux-x64": "0.1.187-windows-daemon-host.100100730469.0.gd9c67df",
+    "@lark-codem/codem-cli-linux-arm64": "0.1.187-windows-daemon-host.100100730469.0.gd9c67df",
+    "@lark-codem/codem-cli-win32-arm64": "0.1.187-windows-daemon-host.100100730469.0.gd9c67df",
+    "@lark-codem/codem-cli-win32-x64": "0.1.187-windows-daemon-host.100100730469.0.gd9c67df"
   },
   "engines": {
     "node": ">=18"