@love-moon/conductor-cli 0.2.23 → 0.2.25

package/bin/conductor-update.js

@@ -17,6 +17,10 @@ import {
   isNewerVersion,
   detectPackageManager,
 } from "../src/version-check.js";
+import {
+  ensurePnpmOnlyBuiltDependencies,
+  repairAndVerifyGlobalNodePty,
+} from "../src/native-deps.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -140,41 +144,50 @@ async function confirmUpdate(version) {
 }
 
 async function performUpdate() {
-  return new Promise((resolve, reject) => {
-    // 检测使用的包管理器
-    const packageManager = detectPackageManager({
-      launcherPath: process.env.CONDUCTOR_LAUNCHER_SCRIPT || process.argv[1],
-      packageRoot: PKG_ROOT,
+  const packageManager = detectPackageManager({
+    launcherPath: process.env.CONDUCTOR_LAUNCHER_SCRIPT || process.argv[1],
+    packageRoot: PKG_ROOT,
+  });
+  console.log(`   Using package manager: ${colorize(packageManager, "cyan")}`);
+  console.log("");
+
+  if (packageManager === "pnpm") {
+    console.log("   Preparing pnpm native dependency allowlist...");
+    await ensurePnpmOnlyBuiltDependencies({
+      runCommand: runBufferedCommand,
+      dependencies: ["node-pty"],
+      global: true,
     });
-    console.log(`   Using package manager: ${colorize(packageManager, "cyan")}`);
     console.log("");
-    
-    let cmd, args;
-    
-    switch (packageManager) {
-      case "pnpm":
-        cmd = "pnpm";
-        args = ["add", "-g", `${PACKAGE_NAME}@latest`];
-        break;
-      case "yarn":
-        cmd = "yarn";
-        args = ["global", "add", `${PACKAGE_NAME}@latest`];
-        break;
-      case "npm":
-      default:
-        cmd = "npm";
-        args = ["install", "-g", `${PACKAGE_NAME}@latest`];
-        break;
-    }
-    
-    console.log(`   Running: ${colorize(`${cmd} ${args.join(" ")}`, "cyan")}`);
-    console.log("");
-    
+  }
+
+  let cmd, args;
+
+  switch (packageManager) {
+    case "pnpm":
+      cmd = "pnpm";
+      args = ["add", "-g", `${PACKAGE_NAME}@latest`];
+      break;
+    case "yarn":
+      cmd = "yarn";
+      args = ["global", "add", `${PACKAGE_NAME}@latest`];
+      break;
+    case "npm":
+    default:
+      cmd = "npm";
+      args = ["install", "-g", `${PACKAGE_NAME}@latest`];
+      break;
+  }
+
+  console.log(`   Running: ${colorize(`${cmd} ${args.join(" ")}`, "cyan")}`);
+  console.log("");
+
+  await new Promise((resolve, reject) => {
     const child = spawn(cmd, args, {
       stdio: "inherit",
       shell: true
     });
-    
+
     child.on("close", (code) => {
       if (code === 0) {
         resolve();
@@ -182,11 +195,59 @@ async function performUpdate() {
         reject(new Error(`Exit code ${code}`));
       }
     });
-    
+
     child.on("error", (error) => {
       reject(error);
     });
   });
+
+  console.log("   Repairing and verifying node-pty native binding...");
+  await repairAndVerifyGlobalNodePty({
+    packageManager,
+    packageName: PACKAGE_NAME,
+    runCommand: runBufferedCommand,
+    nodeExecutable: process.execPath,
+  });
+}
+
+function runBufferedCommand(command, args, options = {}) {
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    const child = spawn(command, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: false,
+      env: options.env || process.env,
+      cwd: options.cwd || process.cwd(),
+    });
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+        // ignore timeout failures
+      }
+    }, options.timeoutMs || 20_000);
+
+    child.stdout?.on("data", (chunk) => {
+      if (stdout.length < 16_000) stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      if (stderr.length < 16_000) stderr += chunk.toString();
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({ success: code === 0, code, stdout, stderr });
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      resolve({
+        success: false,
+        code: -1,
+        stdout,
+        stderr: error instanceof Error ? error.message : String(error),
+      });
+    });
+  });
 }
 
 function showHelpMessage() {

package/bin/conductor-verify-node-pty.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+import process from "node:process";
+
+import { verifyNodePtyForPackageDirectory } from "../src/native-deps.js";
+
+async function main() {
+  const packageDirectory = process.argv[2];
+  if (!packageDirectory) {
+    process.stderr.write("Usage: conductor-verify-node-pty <package-directory>\n");
+    process.exit(1);
+    return;
+  }
+
+  await verifyNodePtyForPackageDirectory({
+    packageDirectory,
+  });
+  process.stdout.write("Verified node-pty native binding\n");
+}
+
+main().catch((error) => {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+  process.exit(1);
+});

package/bin/conductor.js

@@ -87,7 +87,9 @@ const isDirectExecution = (() => {
     return false;
   }
   try {
-    return pathToFileURL(entryPath).href === import.meta.url;
+    const entryRealPath = fs.realpathSync(entryPath);
+    const currentRealPath = fs.realpathSync(__filename);
+    return pathToFileURL(entryRealPath).href === pathToFileURL(currentRealPath).href;
   } catch {
     return false;
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.23",
-  "gitCommitId": "e1d19e3",
+  "version": "0.2.25",
+  "gitCommitId": "6d7b348",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -17,8 +17,8 @@
     "test": "node --test test/*.test.js"
   },
   "dependencies": {
-    "@love-moon/ai-sdk": "0.2.23",
-    "@love-moon/conductor-sdk": "0.2.23",
+    "@love-moon/ai-sdk": "0.2.25",
+    "@love-moon/conductor-sdk": "0.2.25",
     "dotenv": "^16.4.5",
     "enquirer": "^2.4.1",
     "js-yaml": "^4.1.1",

package/src/daemon.js

@@ -20,6 +20,10 @@ import {
   isInUpdateWindow,
   isManagedInstallPath,
 } from "./version-check.js";
+import {
+  ensurePnpmOnlyBuiltDependencies,
+  repairAndVerifyGlobalNodePty,
+} from "./native-deps.js";
 
 dotenv.config();
 
@@ -48,6 +52,39 @@ const DEFAULT_TERMINAL_RING_BUFFER_MAX_BYTES = 2 * 1024 * 1024;
 const DEFAULT_RTC_MODULE_CANDIDATES = ["@roamhq/wrtc", "wrtc"];
 let nodePtySpawnPromise = null;
 
+function resolveNodePtySpawnExport(mod) {
+  if (typeof mod?.spawn === "function") {
+    return mod.spawn;
+  }
+  if (mod?.default && typeof mod.default.spawn === "function") {
+    return mod.default.spawn.bind(mod.default);
+  }
+  throw new Error("node-pty spawn export not found");
+}
+
+export function probePtyTaskCapability({
+  requireFn = moduleRequire,
+  ensureSpawnHelperExecutableFn = ensureNodePtySpawnHelperExecutable,
+} = {}) {
+  try {
+    const spawnHelperInfo = ensureSpawnHelperExecutableFn();
+    const spawnPty = resolveNodePtySpawnExport(requireFn("node-pty"));
+    return {
+      enabled: true,
+      reason: null,
+      spawnHelperInfo,
+      spawnPty,
+    };
+  } catch (error) {
+    return {
+      enabled: false,
+      reason: error instanceof Error ? error.message : String(error),
+      spawnHelperInfo: null,
+      spawnPty: null,
+    };
+  }
+}
+
 function appendDaemonLog(line) {
   try {
     fs.mkdirSync(DAEMON_LOG_DIR, { recursive: true });
@@ -154,20 +191,48 @@ async function defaultCreatePty(command, args, options) {
     if (spawnHelperInfo?.updated) {
       log(`Enabled execute permission on node-pty spawn-helper: ${spawnHelperInfo.helperPath}`);
     }
-    nodePtySpawnPromise = import("node-pty").then((mod) => {
-      if (typeof mod.spawn === "function") {
-        return mod.spawn;
-      }
-      if (mod.default && typeof mod.default.spawn === "function") {
-        return mod.default.spawn.bind(mod.default);
-      }
-      throw new Error("node-pty spawn export not found");
-    });
+    nodePtySpawnPromise = Promise.resolve(resolveNodePtySpawnExport(moduleRequire("node-pty")));
   }
   const spawnPty = await nodePtySpawnPromise;
   return spawnPty(command, args, options);
 }
 
+export function resolveDefaultPtyShell({
+  explicitShell,
+  envShell = process.env.SHELL,
+  comspec = process.env.COMSPEC,
+  platform = process.platform,
+  existsSync = fs.existsSync,
+} = {}) {
+  const normalizedExplicitShell = normalizeOptionalString(explicitShell);
+  if (normalizedExplicitShell) {
+    return normalizedExplicitShell;
+  }
+
+  const normalizedEnvShell = normalizeOptionalString(envShell);
+  if (normalizedEnvShell) {
+    return normalizedEnvShell;
+  }
+
+  if (platform === "win32") {
+    return normalizeOptionalString(comspec) || "cmd.exe";
+  }
+
+  if (platform === "darwin") {
+    return "/bin/zsh";
+  }
+
+  if (existsSync("/bin/bash")) {
+    return "/bin/bash";
+  }
+
+  if (existsSync("/bin/sh")) {
+    return "/bin/sh";
+  }
+
+  return "/bin/bash";
+}
+
 export function ensureNodePtySpawnHelperExecutable(deps = {}) {
   const platform = deps.platform || process.platform;
   if (platform === "win32") {
@@ -719,13 +784,40 @@ export function startDaemon(config = {}, deps = {}) {
   let rtcAvailabilityLogKey = null;
   const logCollector = createLogCollector(BACKEND_HTTP);
   const createPtyFn = deps.createPty || defaultCreatePty;
+  const resolvePtyTaskCapabilityFn =
+    deps.resolvePtyTaskCapability ||
+    (deps.createPty
+      ? (() => ({ enabled: true, reason: null, spawnHelperInfo: null, spawnPty: null }))
+      : probePtyTaskCapability);
+  let ptyTaskCapability;
+  try {
+    ptyTaskCapability = resolvePtyTaskCapabilityFn();
+  } catch (error) {
+    ptyTaskCapability = {
+      enabled: false,
+      reason: error instanceof Error ? error.message : String(error),
+      spawnHelperInfo: null,
+      spawnPty: null,
+    };
+  }
+  const ptyTaskCapabilityEnabled = ptyTaskCapability?.enabled !== false;
+  const ptyTaskCapabilityError = normalizeOptionalString(ptyTaskCapability?.reason);
+  if (ptyTaskCapability?.spawnHelperInfo?.updated) {
+    log(`Enabled execute permission on node-pty spawn-helper: ${ptyTaskCapability.spawnHelperInfo.helperPath}`);
+  }
+  if (!ptyTaskCapabilityEnabled) {
+    logError(`[pty] Disabled PTY capability: ${ptyTaskCapabilityError || "unknown error"}`);
+  }
+  const extraHeaders = {
+    "x-conductor-host": AGENT_NAME,
+    "x-conductor-backends": SUPPORTED_BACKENDS.join(","),
+    "x-conductor-version": cliVersion,
+  };
+  if (ptyTaskCapabilityEnabled) {
+    extraHeaders["x-conductor-capabilities"] = "pty_task";
+  }
   const client = createWebSocketClient(sdkConfig, {
-    extraHeaders: {
-      "x-conductor-host": AGENT_NAME,
-      "x-conductor-backends": SUPPORTED_BACKENDS.join(","),
-      "x-conductor-capabilities": "pty_task",
-      "x-conductor-version": cliVersion,
-    },
+    extraHeaders,
     onConnected: ({ isReconnect, connectedAt } = { isReconnect: false, connectedAt: Date.now() }) => {
       wsConnected = true;
       lastConnectedAt = connectedAt || Date.now();
@@ -1081,6 +1173,14 @@ export function startDaemon(config = {}, deps = {}) {
     });
   }
 
+  function runBufferedCommand(command, args, options = {}) {
+    return runCommand(
+      command,
+      args,
+      typeof options === "number" ? options : options?.timeoutMs ?? 120_000,
+    );
+  }
+
   async function readInstalledCliVersion() {
     const commandAttempts = versionCheckScript
       ? [{
@@ -1117,6 +1217,16 @@ export function startDaemon(config = {}, deps = {}) {
       packageRoot: installedPackageRoot,
     });
     const pkgSpec = `${PACKAGE_NAME}@${targetVersion}`;
+
+    if (pm === "pnpm") {
+      log("[auto-update] Preparing pnpm native dependency allowlist for node-pty");
+      await ensurePnpmOnlyBuiltDependencies({
+        runCommand: runBufferedCommand,
+        dependencies: ["node-pty"],
+        global: true,
+      });
+    }
+
     log(`[auto-update] Installing ${pkgSpec} via ${pm}...`);
 
     // Step 1: install
@@ -1145,7 +1255,19 @@ export function startDaemon(config = {}, deps = {}) {
       throw new Error(`Version verification failed: ${verifyErr?.message || verifyErr}`);
     }
 
-    log(`[auto-update] Verified ${targetVersion}. Restarting daemon...`);
+    // Step 4: repair and verify native dependencies before shutting down the healthy daemon.
+    try {
+      await repairAndVerifyGlobalNodePty({
+        packageManager: pm,
+        packageName: PACKAGE_NAME,
+        runCommand: runBufferedCommand,
+        nodeExecutable: process.execPath,
+      });
+    } catch (verifyErr) {
+      throw new Error(`Native dependency verification failed: ${verifyErr?.message || verifyErr}`);
+    }
+
+    log(`[auto-update] Verified ${targetVersion} and node-pty. Restarting daemon...`);
 
     let logFd = null;
     if (isBackgroundProcess) {
@@ -1160,10 +1282,10 @@ export function startDaemon(config = {}, deps = {}) {
       logFd = fs.openSync(DAEMON_LOG_PATH, "a");
     }
 
-    // Step 4: graceful shutdown
+    // Step 5: graceful shutdown
     await shutdownDaemon("auto-update");
 
-    // Step 5: re-spawn (only in background/nohup mode)
+    // Step 6: re-spawn (only in background/nohup mode)
     if (isBackgroundProcess) {
       const handoffToken = `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
       const handoffExpiresAt = Date.now() + 15_000;
@@ -1430,6 +1552,31 @@ export function startDaemon(config = {}, deps = {}) {
     });
   }
 
+  function rejectCreatePtyTaskUnavailable(payload) {
+    const taskId = payload?.task_id ? String(payload.task_id) : "";
+    const projectId = payload?.project_id ? String(payload.project_id) : "";
+    const ptySessionId = payload?.pty_session_id ? String(payload.pty_session_id) : null;
+    const requestId = payload?.request_id ? String(payload.request_id) : "";
+    const message = ptyTaskCapabilityError
+      ? `pty runtime unavailable: ${ptyTaskCapabilityError}`
+      : "pty runtime unavailable";
+    log(`Rejecting create_pty_task for ${taskId || "unknown"}: ${message}`);
+    sendAgentCommandAck({
+      requestId,
+      taskId,
+      eventType: "create_pty_task",
+      accepted: false,
+    }).catch(() => {});
+    sendTerminalEvent("terminal_error", {
+      task_id: taskId || undefined,
+      project_id: projectId || undefined,
+      pty_session_id: ptySessionId,
+      message,
+    }).catch((err) => {
+      logError(`Failed to report PTY capability rejection for ${taskId || "unknown"}: ${err?.message || err}`);
+    });
+  }
+
   function sendPtyTransportSignal(payload) {
     return client.sendJson({
       type: "pty_transport_signal",
@@ -1656,10 +1803,13 @@ export function startDaemon(config = {}, deps = {}) {
       normalizeOptionalString(normalizedLaunchConfig.toolPreset)
         ? "tool_preset"
         : "shell");
-    const preferredShell =
-      normalizeOptionalString(normalizedLaunchConfig.shell) ||
-      process.env.SHELL ||
-      "/bin/zsh";
+    const preferredShell = resolveDefaultPtyShell({
+      explicitShell: normalizedLaunchConfig.shell,
+      envShell: process.env.SHELL,
+      comspec: process.env.COMSPEC,
+      platform: process.platform,
+      existsSync: existsSyncFn,
+    });
     const cwd =
       normalizeOptionalString(normalizedLaunchConfig.cwd) ||
       fallbackCwd;
@@ -1907,6 +2057,16 @@ export function startDaemon(config = {}, deps = {}) {
       return;
     }
 
+    if (daemonShuttingDown) {
+      rejectCreatePtyTaskDuringShutdown(payload);
+      return;
+    }
+
+    if (!ptyTaskCapabilityEnabled) {
+      rejectCreatePtyTaskUnavailable(payload);
+      return;
+    }
+
     if (requestId && !markRequestSeen(requestId)) {
       log(`Duplicate create_pty_task ignored for ${taskId} (request_id=${requestId})`);
       sendAgentCommandAck({
@@ -1918,11 +2078,6 @@ export function startDaemon(config = {}, deps = {}) {
       return;
     }
 
-    if (daemonShuttingDown) {
-      rejectCreatePtyTaskDuringShutdown(payload);
-      return;
-    }
-
     if (activeTaskProcesses.has(taskId) || activePtySessions.has(taskId)) {
       log(`Duplicate create_pty_task ignored for ${taskId}: task already active`);
       sendAgentCommandAck({

package/src/native-deps.js

@@ -0,0 +1,323 @@
+import path from "node:path";
+import process from "node:process";
+import { spawn as spawnProcess } from "node:child_process";
+
+function defaultRunCommand(command, args, options = {}) {
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    const child = spawnProcess(command, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: options.env || { ...process.env },
+      cwd: options.cwd || process.cwd(),
+    });
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+        // ignore timeout kill failures
+      }
+    }, options.timeoutMs || 20_000);
+    child.stdout?.on("data", (chunk) => {
+      if (stdout.length < 16_000) {
+        stdout += chunk.toString();
+      }
+    });
+    child.stderr?.on("data", (chunk) => {
+      if (stderr.length < 16_000) {
+        stderr += chunk.toString();
+      }
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({ success: code === 0, code, stdout, stderr });
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      resolve({
+        success: false,
+        code: -1,
+        stdout,
+        stderr: error instanceof Error ? error.message : String(error),
+      });
+    });
+  });
+}
+
+function quoteForSingleQuotedShell(value) {
+  return String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+
+export function shouldIgnoreNodePtyVerificationErrorMessage(message) {
+  const normalized = String(message || "")
+    .trim()
+    .toLowerCase();
+  return normalized === "read eio" || normalized.endsWith(": read eio");
+}
+
+export function normalizeBuiltDependencyList(value) {
+  if (Array.isArray(value)) {
+    return value
+      .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+      .filter(Boolean);
+  }
+  if (typeof value !== "string") {
+    return [];
+  }
+  const trimmed = value.trim();
+  if (!trimmed || trimmed === "undefined" || trimmed === "null") {
+    return [];
+  }
+  try {
+    return normalizeBuiltDependencyList(JSON.parse(trimmed));
+  } catch {
+    return trimmed
+      .split(",")
+      .map((entry) => entry.trim())
+      .filter(Boolean);
+  }
+}
+
+export function mergeBuiltDependencies(existing, required) {
+  const merged = new Set(normalizeBuiltDependencyList(existing));
+  for (const dependency of normalizeBuiltDependencyList(required)) {
+    merged.add(dependency);
+  }
+  return [...merged];
+}
+
+export async function ensurePnpmOnlyBuiltDependencies({
+  runCommand = defaultRunCommand,
+  dependencies = ["node-pty"],
+  global = true,
+} = {}) {
+  const scopeArgs = global ? ["--global"] : ["--location=project"];
+  const currentResult = await runCommand("pnpm", [
+    "config",
+    "get",
+    ...scopeArgs,
+    "onlyBuiltDependencies",
+    "--json",
+  ]);
+  const current = normalizeBuiltDependencyList(currentResult.stdout);
+  const merged = mergeBuiltDependencies(current, dependencies);
+  if (merged.length === current.length && merged.every((entry, index) => entry === current[index])) {
+    return merged;
+  }
+  const setResult = await runCommand("pnpm", [
+    "config",
+    "set",
+    ...scopeArgs,
+    "onlyBuiltDependencies",
+    JSON.stringify(merged),
+  ]);
+  if (!setResult.success) {
+    throw new Error(
+      `Failed to configure pnpm onlyBuiltDependencies: ${String(
+        setResult.stderr || setResult.stdout || "unknown error",
+      ).trim()}`,
+    );
+  }
+  return merged;
+}
+
+export async function resolveGlobalPackageDirectory({
+  packageManager,
+  packageName,
+  runCommand = defaultRunCommand,
+} = {}) {
+  if (!packageManager || !packageName) {
+    throw new Error("packageManager and packageName are required");
+  }
+
+  let command;
+  let args;
+  let normalizeRoot = (value) => value;
+
+  if (packageManager === "pnpm" || packageManager === "npm") {
+    command = packageManager;
+    args = ["root", "-g"];
+  } else if (packageManager === "yarn") {
+    command = "yarn";
+    args = ["global", "dir"];
+    normalizeRoot = (value) => path.join(value, "node_modules");
+  } else {
+    throw new Error(`Unsupported package manager: ${packageManager}`);
+  }
+
+  const result = await runCommand(command, args);
+  if (!result.success) {
+    throw new Error(
+      `Failed to resolve global package root via ${packageManager}: ${String(
+        result.stderr || result.stdout || "unknown error",
+      ).trim()}`,
+    );
+  }
+
+  const rawRoot = String(result.stdout || "")
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .at(-1);
+  if (!rawRoot) {
+    throw new Error(`Global package root for ${packageManager} is empty`);
+  }
+
+  return path.join(normalizeRoot(rawRoot), packageName);
+}
+
+export function buildNodePtyVerificationScript() {
+  return String.raw`
+const fs = require('node:fs');
+const path = require('node:path');
+const { createRequire } = require('node:module');
+const shouldIgnoreNodePtyVerificationErrorMessage = ${shouldIgnoreNodePtyVerificationErrorMessage.toString()};
+
+const packageDir = process.argv[1];
+if (!packageDir) {
+  throw new Error('package directory is required');
+}
+const packageJsonPath = path.join(packageDir, 'package.json');
+const req = createRequire(packageJsonPath);
+const nodePty = req('node-pty');
+const spawn = typeof nodePty.spawn === 'function'
+  ? nodePty.spawn
+  : (nodePty.default && typeof nodePty.default.spawn === 'function'
+      ? nodePty.default.spawn.bind(nodePty.default)
+      : null);
+
+if (!spawn) {
+  throw new Error('node-pty spawn export not found');
+}
+
+const shell = process.platform === 'win32'
+  ? (process.env.COMSPEC || 'cmd.exe')
+  : (fs.existsSync('/bin/bash') ? '/bin/bash' : '/bin/sh');
+const shellArgs = process.platform === 'win32'
+  ? ['/d', '/s', '/c', 'exit 0']
+  : ['-lc', 'exit 0'];
+
+const child = spawn(shell, shellArgs, {
+  name: 'conductor-node-pty-check',
+  cols: 80,
+  rows: 24,
+  cwd: process.cwd(),
+  env: process.env,
+});
+
+let settled = false;
+const finish = (code, error) => {
+  if (settled) return;
+  settled = true;
+  clearTimeout(timer);
+  if (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+    return;
+  }
+  if (typeof code === 'number' && code !== 0) {
+    console.error('node-pty smoke test exited with code ' + code);
+    process.exit(1);
+    return;
+  }
+  console.log('Verified node-pty native binding');
+  process.exit(0);
+};
+
+const timer = setTimeout(() => {
+  try {
+    child.kill();
+  } catch {
+    // ignore kill failures
+  }
+  finish(null, new Error('node-pty smoke test timed out'));
+}, 5000);
+
+child.on('exit', (code) => finish(code, null));
+child.on('error', (error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  if (shouldIgnoreNodePtyVerificationErrorMessage(message)) {
+    return;
+  }
+  finish(null, error);
+});
+`;
+}
+
+export async function verifyNodePtyForPackageDirectory({
+  packageDirectory,
+  runCommand = defaultRunCommand,
+  nodeExecutable = process.execPath,
+} = {}) {
+  if (!packageDirectory) {
+    throw new Error("packageDirectory is required");
+  }
+  const result = await runCommand(nodeExecutable, ["-e", buildNodePtyVerificationScript(), packageDirectory], {
+    timeoutMs: 15_000,
+  });
+  if (!result.success) {
+    throw new Error(
+      `node-pty verification failed for ${packageDirectory}: ${String(
+        result.stderr || result.stdout || "unknown error",
+      ).trim()}`,
+    );
+  }
+  return result;
+}
+
+export async function repairAndVerifyGlobalNodePty({
+  packageManager,
+  packageName,
+  runCommand = defaultRunCommand,
+  nodeExecutable = process.execPath,
+  dependencies = ["node-pty"],
+  packageSpec = null,
+} = {}) {
+  if (!packageManager || !packageName) {
+    throw new Error("packageManager and packageName are required");
+  }
+
+  if (packageManager === "pnpm") {
+    await ensurePnpmOnlyBuiltDependencies({ runCommand, dependencies, global: true });
+  }
+
+  if (packageManager === "pnpm") {
+    const rebuildResult = await runCommand("pnpm", ["rebuild", "-g", ...dependencies]);
+    if (!rebuildResult.success) {
+      throw new Error(
+        `pnpm rebuild failed: ${String(rebuildResult.stderr || rebuildResult.stdout || "unknown error").trim()}`,
+      );
+    }
+  } else if (packageManager === "npm") {
+    const rebuildArgs = ["rebuild", "-g"];
+    if (packageSpec) {
+      rebuildArgs.push(packageSpec);
+    } else {
+      rebuildArgs.push(packageName);
+    }
+    const rebuildResult = await runCommand("npm", rebuildArgs);
+    if (!rebuildResult.success) {
+      throw new Error(
+        `npm rebuild failed: ${String(rebuildResult.stderr || rebuildResult.stdout || "unknown error").trim()}`,
+      );
+    }
+  }
+
+  const packageDirectory = await resolveGlobalPackageDirectory({
+    packageManager,
+    packageName,
+    runCommand,
+  });
+  await verifyNodePtyForPackageDirectory({
+    packageDirectory,
+    runCommand,
+    nodeExecutable,
+  });
+  return packageDirectory;
+}
+
+export function buildNodePtyShellVerificationCommand(scriptPath, packageDirectory) {
+  const quotedScriptPath = quoteForSingleQuotedShell(scriptPath);
+  const quotedPackageDirectory = quoteForSingleQuotedShell(packageDirectory);
+  return `node '${quotedScriptPath}' '${quotedPackageDirectory}'`;
+}