@minniexcode/codex-switch 0.0.8 → 0.0.10

package/dist/domain/setup.js

@@ -2,21 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildSetupDrafts = buildSetupDrafts;
 exports.findIncompleteSetupProfiles = findIncompleteSetupProfiles;
+exports.collectMigrateAdoptability = collectMigrateAdoptability;
+const config_1 = require("./config");
 const providers_1 = require("./providers");
 /**
  * Creates initial provider drafts from config profile names.
  */
-function buildSetupDrafts(profiles, detailsByProfile) {
+function buildSetupDrafts(profiles, detailsByProfile, runtimeByProfile) {
     return profiles.map((profile) => {
         const detail = detailsByProfile[profile] ?? {};
+        const runtime = runtimeByProfile[profile];
         const providerName = (detail.providerName ?? profile).trim();
         return {
             providerName,
             record: (0, providers_1.cleanProviderRecord)({
                 profile,
                 apiKey: detail.apiKey ?? "",
-                envKey: detail.envKey ?? "",
-                baseUrl: detail.baseUrl,
+                baseUrl: detail.baseUrl ?? runtime?.baseUrl,
                 note: detail.note,
                 tags: detail.tags,
             }),
@@ -29,3 +31,56 @@ function buildSetupDrafts(profiles, detailsByProfile) {
 function findIncompleteSetupProfiles(drafts) {
     return drafts.filter((draft) => draft.record.apiKey.trim() === "").map((draft) => draft.record.profile);
 }
+/**
+ * Collects the unmanaged profiles that can be safely adopted by migrate.
+ */
+function collectMigrateAdoptability(document, providers) {
+    const views = (0, config_1.buildManagedProfileViews)(document, providers)
+        .filter((view) => view.source !== "orphaned-reference")
+        .sort((left, right) => left.name.localeCompare(right.name));
+    const modelProvidersByName = new Map(document.modelProviders.map((provider) => [provider.name, provider]));
+    const availableProfiles = views.map((view) => view.name);
+    const adoptableProfileDetails = [];
+    const blockingReasonsByProfile = {};
+    for (const view of views) {
+        const reasons = [];
+        if (!view.model) {
+            reasons.push("model is missing.");
+        }
+        if (!view.modelProvider) {
+            reasons.push("model_provider is missing.");
+        }
+        else {
+            if (view.modelProvider !== view.name) {
+                reasons.push(`model_provider must match the profile name "${view.name}".`);
+            }
+            const modelProviderSection = modelProvidersByName.get(view.modelProvider);
+            if (!modelProviderSection) {
+                reasons.push(`model_providers.${view.modelProvider} section is missing.`);
+            }
+            else {
+                if (!modelProviderSection.baseUrl) {
+                    reasons.push(`model_providers.${view.modelProvider}.base_url is missing.`);
+                }
+            }
+        }
+        if (view.source !== "unmanaged") {
+            reasons.push("profile is already managed by providers.json.");
+        }
+        if (reasons.length === 0) {
+            adoptableProfileDetails.push({
+                name: view.name,
+                model: view.model,
+                baseUrl: view.baseUrl,
+            });
+            continue;
+        }
+        blockingReasonsByProfile[view.name] = reasons;
+    }
+    return {
+        availableProfiles,
+        adoptableProfiles: adoptableProfileDetails.map((profile) => profile.name),
+        blockingReasonsByProfile,
+        adoptableProfileDetails,
+    };
+}

package/dist/interaction/add-interactive.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.COMMON_TAG_CHOICES = void 0;
 exports.collectAddInput = collectAddInput;
+exports.collectCopilotAddInput = collectCopilotAddInput;
 exports.createNonInteractiveAddError = createNonInteractiveAddError;
 exports.promptTags = promptTags;
 const errors_1 = require("../domain/errors");
@@ -37,10 +38,51 @@ async function collectAddInput(runtime, defaults, providerExists, profileExists)
         tags,
     };
 }
+/**
+ * Collects Copilot add command inputs interactively when required values are missing.
+ */
+async function collectCopilotAddInput(runtime, defaults, providerExists, profileExists, options) {
+    runtime.writeLine("Interactive add mode");
+    runtime.writeLine("Provide the missing Copilot provider fields. Press Enter to keep optional values empty.");
+    const providerName = defaults.providerName
+        ? normalizeRequiredValue(defaults.providerName)
+        : await promptProviderName(runtime, providerExists);
+    const profile = defaults.profile ? normalizeRequiredValue(defaults.profile) : await promptRequiredValue(runtime, "Profile");
+    const createProfile = !profileExists(profile);
+    const model = createProfile
+        ? defaults.model
+            ? normalizeRequiredValue(defaults.model)
+            : await promptRequiredValue(runtime, `Model for new profile "${profile}"`)
+        : defaults.model ?? null;
+    const note = defaults.note ?? normalizeOptionalValue(await runtime.inputText("Note (optional)"));
+    const tags = defaults.tags.length > 0 ? defaults.tags : await promptTags(runtime);
+    const bridgeHost = options?.bridgeHost ?? normalizeOptionalValue(await runtime.inputText("Bridge host (optional)", { defaultValue: "127.0.0.1" }));
+    const bridgePortText = options?.bridgePort !== undefined && options.bridgePort !== null
+        ? String(options.bridgePort)
+        : await runtime.inputText("Bridge port (optional)", { defaultValue: "41415" });
+    const bridgePort = normalizeBridgePort(runtime, bridgePortText);
+    const bridgeApiKey = options?.bridgeApiKey ?? normalizeOptionalValue(await runtime.inputSecret("Bridge API key (optional)"));
+    return {
+        providerName,
+        profile,
+        createProfile,
+        model,
+        note,
+        tags,
+        bridgeApiKey,
+        bridgeHost,
+        bridgePort,
+    };
+}
 /**
  * Throws a consistent error when interactive add is unavailable.
  */
-function createNonInteractiveAddError() {
+function createNonInteractiveAddError(options) {
+    if (options?.copilot) {
+        return (0, errors_1.cliError)("INVALID_ARGUMENT", "add --copilot requires <provider> and --profile when running without an interactive TTY.", {
+            suggestion: "Run in a terminal TTY or pass <provider>, --profile, and any optional Copilot bridge flags explicitly.",
+        });
+    }
     return (0, errors_1.cliError)("INVALID_ARGUMENT", "add requires <provider>, --profile, and --api-key when running without an interactive TTY.", {
         suggestion: "Run in a terminal TTY or pass all required values explicitly.",
     });
@@ -90,6 +132,18 @@ function normalizeOptionalValue(value) {
     const normalized = value.trim();
     return normalized === "" ? null : normalized;
 }
+function normalizeBridgePort(runtime, value) {
+    const normalized = value.trim();
+    if (normalized === "") {
+        return null;
+    }
+    const parsed = Number(normalized);
+    if (Number.isInteger(parsed) && parsed > 0) {
+        return parsed;
+    }
+    runtime.writeLine("Bridge port must be a positive integer. Falling back to the default port.");
+    return null;
+}
 async function promptTags(runtime, defaults = []) {
     const defaultPresetTags = defaults.filter(isCommonTag);
     return runtime.selectMany("Select tags (optional)", exports.COMMON_TAG_CHOICES.map((tag) => ({ value: tag, label: tag })), { defaultValues: defaultPresetTags });

package/dist/interaction/interactive.js

@@ -222,7 +222,7 @@ async function chooseSetupProfiles(runtime, profiles) {
     return runtime.selectMany("Choose unmanaged config profiles to adopt into providers.json.", profiles.map((profile) => ({
         value: profile.name,
         label: profile.name,
-        hint: `${profile.model} | ${profile.baseUrl} | ${profile.envKey}`,
+        hint: `${profile.model} | ${profile.baseUrl}`,
     })));
 }
 /**
@@ -235,9 +235,6 @@ async function collectSetupProviderDetails(runtime, profiles, defaultsByProfile
         const providerName = (await runtime.inputText(`Provider name for profile "${profile}"`, {
             defaultValue: defaults.providerName ?? profile,
         })).trim();
-        if (defaults.envKey) {
-            runtime.writeLine(`Runtime env key for "${profile}": ${defaults.envKey}`);
-        }
         const apiKey = await promptRequiredSecret(runtime, `API key for profile "${profile}"`, defaults.apiKey?.trim() || undefined);
         const baseUrl = (await runtime.inputText(`Base URL note for profile "${profile}" (optional)`, {
             defaultValue: defaults.baseUrl ?? "",
@@ -249,7 +246,6 @@ async function collectSetupProviderDetails(runtime, profiles, defaultsByProfile
         result[profile] = {
             providerName: providerName || defaults.providerName || profile,
             apiKey,
-            envKey: defaults.envKey,
             baseUrl: baseUrl || defaults.baseUrl || undefined,
             note: note || defaults.note || undefined,
             // Empty selections are omitted so downstream setup validation can distinguish unset from explicit data.

package/dist/runtime/copilot-adapter.js

@@ -114,7 +114,7 @@ async function createCopilotSession() {
         throw (0, errors_1.cliError)("COPILOT_SDK_UNSUPPORTED", "The installed Copilot SDK does not expose a supported createSession API.", {});
     }
     try {
-        const session = (await Promise.resolve(createSession({})));
+        const session = (await Promise.resolve(createSession(createSessionOptions(sdk))));
         return {
             sdk,
             client,
@@ -122,11 +122,30 @@ async function createCopilotSession() {
         };
     }
     catch (error) {
+        if (classifyCopilotSessionError(error) === "unsupported") {
+            throw (0, errors_1.cliError)("COPILOT_SDK_UNSUPPORTED", "The installed Copilot SDK does not expose a compatible permission-handling session API.", {
+                cause: error instanceof Error ? error.message : String(error),
+            });
+        }
         throw (0, errors_1.cliError)("COPILOT_AUTH_REQUIRED", "Copilot authentication is required before the local bridge can be used.", {
             cause: error instanceof Error ? error.message : String(error),
         });
     }
 }
+/**
+ * Builds the session options used consistently across auth probes and request execution.
+ */
+function createSessionOptions(sdk) {
+    const approveAll = resolveApproveAll(sdk);
+    if (approveAll) {
+        return {
+            onPermissionRequest: (request) => approveAll(request),
+        };
+    }
+    return {
+        onPermissionRequest: () => true,
+    };
+}
 function createCopilotClient(sdk) {
     const ClientCtor = resolveConstructor(sdk, "CopilotClient");
     if (!ClientCtor) {
@@ -146,6 +165,16 @@ async function stopCopilotClient(client) {
         await Promise.resolve(client.stop());
     }
 }
+/**
+ * Distinguishes true auth failures from SDK API-shape mismatches.
+ */
+function classifyCopilotSessionError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/onPermissionRequest/i.test(message) || /permission/i.test(message)) {
+        return "unsupported";
+    }
+    return "auth";
+}
 function resolveCallable(target, name) {
     if (!target) {
         return null;
@@ -171,3 +200,17 @@ function resolveConstructor(target, name) {
     }
     return null;
 }
+/**
+ * Resolves the SDK-provided permission helper when available.
+ */
+function resolveApproveAll(target) {
+    const direct = target.approveAll;
+    if (typeof direct === "function") {
+        return direct;
+    }
+    const nestedDefault = target.default;
+    if (nestedDefault && typeof nestedDefault.approveAll === "function") {
+        return nestedDefault.approveAll;
+    }
+    return null;
+}

package/dist/runtime/copilot-bridge-worker.js

@@ -5,7 +5,7 @@ const copilot_adapter_1 = require("./copilot-adapter");
 async function main() {
     const provider = process.env.CODEX_SWITCH_BRIDGE_PROVIDER ?? "copilot";
     const host = process.env.CODEX_SWITCH_BRIDGE_HOST ?? "127.0.0.1";
-    const port = Number(process.env.CODEX_SWITCH_BRIDGE_PORT ?? "4141");
+    const port = Number(process.env.CODEX_SWITCH_BRIDGE_PORT ?? "41415");
     const apiKey = process.env.CODEX_SWITCH_BRIDGE_API_KEY ?? "";
     await (0, copilot_bridge_1.startCopilotBridgeServer)({
         host,

package/dist/runtime/copilot-bridge.js

@@ -37,6 +37,7 @@ exports.setCopilotBridgeSpawnImplementation = setCopilotBridgeSpawnImplementatio
 exports.resetCopilotBridgeSpawnImplementation = resetCopilotBridgeSpawnImplementation;
 exports.probeCopilotBridgeRuntime = probeCopilotBridgeRuntime;
 exports.ensureCopilotBridge = ensureCopilotBridge;
+exports.startOrReuseCopilotBridge = startOrReuseCopilotBridge;
 exports.createCopilotBridgeRequestHandler = createCopilotBridgeRequestHandler;
 exports.startCopilotBridgeServer = startCopilotBridgeServer;
 exports.waitForCopilotBridgeHealth = waitForCopilotBridgeHealth;
@@ -64,8 +65,17 @@ function resetCopilotBridgeSpawnImplementation() {
 /**
  * Returns the last known Copilot bridge runtime status.
  */
-async function probeCopilotBridgeRuntime(provider) {
-    const state = (0, runtime_state_repo_1.readCopilotBridgeState)();
+async function probeCopilotBridgeRuntime(provider, persistedState) {
+    const state = persistedState === undefined ? (0, runtime_state_repo_1.readCopilotBridgeState)() : persistedState;
+    if (state && (!provider || !(0, providers_1.isCopilotBridgeProvider)(provider))) {
+        return {
+            ok: false,
+            runtime: "copilot-bridge",
+            reason: "failed",
+            cause: "Copilot bridge runtime state exists but no active Copilot bridge provider is selected.",
+            details: state,
+        };
+    }
     if (!provider || !(0, providers_1.isCopilotBridgeProvider)(provider)) {
         return {
             ok: false,
@@ -127,6 +137,12 @@ async function probeCopilotBridgeRuntime(provider) {
  * Starts or reuses a Copilot bridge worker, then verifies its health before returning.
  */
 async function ensureCopilotBridge(providerName, provider) {
+    return startOrReuseCopilotBridge(providerName, provider);
+}
+/**
+ * Starts or reuses a Copilot bridge worker and reports the chosen port.
+ */
+async function startOrReuseCopilotBridge(providerName, provider) {
     if (!(0, providers_1.isCopilotBridgeProvider)(provider)) {
         throw (0, errors_1.cliError)("RUNTIME_PROVIDER_INVALID", "Provider is not backed by a Copilot bridge runtime.", {
             provider: providerName,
@@ -140,6 +156,7 @@ async function ensureCopilotBridge(providerName, provider) {
     }
     const expectedBaseUrl = (0, providers_1.buildCopilotBridgeBaseUrl)(runtime);
     const current = (0, runtime_state_repo_1.readCopilotBridgeState)();
+    let replaced = false;
     if (current && current.provider === providerName && current.baseUrl === expectedBaseUrl) {
         const healthy = await healthcheckCopilotBridge(current.host, current.port);
         if (healthy.ok) {
@@ -149,19 +166,20 @@ async function ensureCopilotBridge(providerName, provider) {
             });
             return {
                 baseUrl: expectedBaseUrl,
+                host: current.host,
+                port: current.port,
                 reused: true,
+                portChanged: false,
+                replaced: false,
             };
         }
     }
-    const portCheck = await checkPortAvailability(runtime.bridgeHost, runtime.bridgePort);
-    if (!portCheck.ok) {
-        throw (0, errors_1.cliError)("BRIDGE_PORT_CONFLICT", "Copilot bridge port is already in use.", {
-            provider: providerName,
-            host: runtime.bridgeHost,
-            port: runtime.bridgePort,
-            cause: portCheck.cause,
-        });
+    if (current && current.provider !== providerName) {
+        stopCopilotBridge();
+        replaced = true;
     }
+    const selectedPort = await selectBridgePort(runtime.bridgeHost, runtime.bridgePort);
+    const selectedBaseUrl = `http://${runtime.bridgeHost}:${selectedPort}${runtime.bridgePath}`;
     const workerPath = path.join(__dirname, "copilot-bridge-worker.js");
     let child;
     try {
@@ -172,9 +190,9 @@ async function ensureCopilotBridge(providerName, provider) {
                 ...process.env,
                 CODEX_SWITCH_BRIDGE_PROVIDER: providerName,
                 CODEX_SWITCH_BRIDGE_HOST: runtime.bridgeHost,
-                CODEX_SWITCH_BRIDGE_PORT: String(runtime.bridgePort),
+                CODEX_SWITCH_BRIDGE_PORT: String(selectedPort),
                 CODEX_SWITCH_BRIDGE_API_KEY: provider.apiKey,
-                CODEX_SWITCH_BRIDGE_BASE_URL: expectedBaseUrl,
+                CODEX_SWITCH_BRIDGE_BASE_URL: selectedBaseUrl,
             },
         });
     }
@@ -182,27 +200,27 @@ async function ensureCopilotBridge(providerName, provider) {
         throw (0, errors_1.cliError)("BRIDGE_START_FAILED", "Failed to start the Copilot bridge worker.", {
             provider: providerName,
             host: runtime.bridgeHost,
-            port: runtime.bridgePort,
+            port: selectedPort,
             cause: error instanceof Error ? error.message : String(error),
         });
     }
     child.unref();
     const startedAt = new Date().toISOString();
-    const healthy = await waitForCopilotBridgeStartup(child, runtime.bridgeHost, runtime.bridgePort, 15, 200);
+    const healthy = await waitForCopilotBridgeStartup(child, runtime.bridgeHost, selectedPort, 15, 200);
     if (!healthy.ok) {
         (0, runtime_state_repo_1.clearCopilotBridgeState)();
         if (healthy.reason === "start-failed") {
             throw (0, errors_1.cliError)("BRIDGE_START_FAILED", "Copilot bridge worker exited before becoming healthy.", {
                 provider: providerName,
                 host: runtime.bridgeHost,
-                port: runtime.bridgePort,
+                port: selectedPort,
                 cause: healthy.cause,
             });
         }
         throw (0, errors_1.cliError)("BRIDGE_HEALTHCHECK_FAILED", "Copilot bridge did not become healthy after startup.", {
             provider: providerName,
             host: runtime.bridgeHost,
-            port: runtime.bridgePort,
+            port: selectedPort,
             cause: healthy.cause,
         });
     }
@@ -210,15 +228,19 @@ async function ensureCopilotBridge(providerName, provider) {
         provider: providerName,
         pid: child.pid ?? null,
         host: runtime.bridgeHost,
-        port: runtime.bridgePort,
-        baseUrl: expectedBaseUrl,
+        port: selectedPort,
+        baseUrl: selectedBaseUrl,
         startedAt,
         lastHealthcheckAt: new Date().toISOString(),
     };
     (0, runtime_state_repo_1.writeCopilotBridgeState)(state);
     return {
-        baseUrl: expectedBaseUrl,
+        baseUrl: selectedBaseUrl,
+        host: runtime.bridgeHost,
+        port: selectedPort,
         reused: false,
+        portChanged: selectedPort !== runtime.bridgePort,
+        replaced,
     };
 }
 /**
@@ -342,6 +364,25 @@ async function checkPortAvailability(host, port) {
         });
     });
 }
+async function selectBridgePort(host, preferredPort) {
+    const preferred = await checkPortAvailability(host, preferredPort);
+    if (preferred.ok) {
+        return preferredPort;
+    }
+    for (let port = 10000; port <= 99999; port += 1) {
+        if (port === preferredPort) {
+            continue;
+        }
+        const available = await checkPortAvailability(host, port);
+        if (available.ok) {
+            return port;
+        }
+    }
+    throw (0, errors_1.cliError)("BRIDGE_PORT_CONFLICT", "Unable to find a free 5-digit bridge port.", {
+        host,
+        port: preferredPort,
+    });
+}
 async function waitForCopilotBridgeStartup(child, host, port, attempts, delayMs) {
     let startupFailure = null;
     const onError = (error) => {

package/dist/runtime/copilot-cli.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setCopilotCliSpawnImplementation = setCopilotCliSpawnImplementation;
+exports.resetCopilotCliSpawnImplementation = resetCopilotCliSpawnImplementation;
+exports.checkCopilotCliAvailable = checkCopilotCliAvailable;
+exports.runCopilotLogin = runCopilotLogin;
+const node_child_process_1 = require("node:child_process");
+let spawnImplementation = node_child_process_1.spawnSync;
+/**
+ * Overrides the spawn implementation for Copilot CLI tests.
+ */
+function setCopilotCliSpawnImplementation(spawnLike) {
+    spawnImplementation = spawnLike;
+}
+/**
+ * Restores the default spawn implementation after tests.
+ */
+function resetCopilotCliSpawnImplementation() {
+    spawnImplementation = node_child_process_1.spawnSync;
+}
+/**
+ * Checks whether the GitHub Copilot CLI is available on PATH.
+ */
+function checkCopilotCliAvailable() {
+    const invocation = getCopilotInvocation(["--help"]);
+    const result = spawnImplementation(invocation.command, invocation.args, {
+        stdio: "pipe",
+        encoding: "utf8",
+        shell: false,
+    });
+    if (result.error || result.status !== 0) {
+        return {
+            ok: false,
+            cause: result.error?.message ?? (result.stderr.trim() || "Unknown failure"),
+        };
+    }
+    return { ok: true };
+}
+/**
+ * Launches the official `copilot login` flow in the current terminal.
+ */
+function runCopilotLogin(options) {
+    const args = ["login"];
+    if (options?.host) {
+        args.push("--hostname", options.host);
+    }
+    const invocation = getCopilotInvocation(args);
+    const result = spawnImplementation(invocation.command, invocation.args, {
+        stdio: "inherit",
+        shell: false,
+    });
+    if (result.error || result.status !== 0) {
+        throw new Error(result.error?.message ?? `copilot login exited with status ${String(result.status)}`);
+    }
+}
+/**
+ * Resolves a cross-platform invocation for the Copilot CLI.
+ */
+function getCopilotInvocation(args) {
+    if (process.platform === "win32") {
+        return {
+            command: process.env.ComSpec || "cmd.exe",
+            args: ["/d", "/s", "/c", ["copilot", ...args].join(" ")],
+        };
+    }
+    return {
+        command: "copilot",
+        args,
+    };
+}

package/dist/runtime/copilot-installer.js

@@ -107,19 +107,66 @@ function installCopilotSdk() {
     if (!fs.existsSync(packageJsonPath)) {
         fs.writeFileSync(packageJsonPath, `${JSON.stringify({ name: "codex-switch-copilot-runtime", private: true, version: "0.0.0" }, null, 2)}\n`, "utf8");
     }
-    const command = process.platform === "win32" ? "npm.cmd" : "npm";
-    const result = spawnImplementation(command, ["install", "--no-save", `${COPILOT_SDK_PACKAGE}@${COPILOT_SDK_VERSION}`], {
+    const installCommand = resolveNpmInstallCommand();
+    const result = spawnImplementation(installCommand.command, installCommand.args, {
         cwd: installDir,
         stdio: "pipe",
         encoding: "utf8",
         shell: false,
     });
+    if (result.error) {
+        throw (0, errors_1.cliError)("COPILOT_SDK_INSTALL_FAILED", "Failed to install the optional Copilot SDK runtime.", {
+            installDir,
+            packageName: COPILOT_SDK_PACKAGE,
+            cause: result.error.message,
+            errorCode: result.error.code ?? null,
+            command: installCommand.command,
+            args: installCommand.args,
+        });
+    }
     if (result.status !== 0) {
         throw (0, errors_1.cliError)("COPILOT_SDK_INSTALL_FAILED", "Failed to install the optional Copilot SDK runtime.", {
             installDir,
             packageName: COPILOT_SDK_PACKAGE,
             cause: result.stderr || result.stdout || `npm exited with status ${String(result.status)}`,
+            command: installCommand.command,
+            args: installCommand.args,
         });
     }
     return probeCopilotSdkInstall();
 }
+/**
+ * Resolves a stable npm install invocation for the optional Copilot SDK runtime.
+ */
+function resolveNpmInstallCommand() {
+    const installArgs = ["install", "--no-save", `${COPILOT_SDK_PACKAGE}@${COPILOT_SDK_VERSION}`];
+    const npmCliPath = resolveNpmCliPath();
+    if (npmCliPath) {
+        return {
+            command: process.execPath,
+            args: [npmCliPath, ...installArgs],
+        };
+    }
+    return {
+        command: process.platform === "win32" ? "npm.cmd" : "npm",
+        args: installArgs,
+    };
+}
+/**
+ * Finds a locally available npm CLI script near the active Node runtime.
+ */
+function resolveNpmCliPath() {
+    const execDir = path.dirname(process.execPath);
+    const candidates = [
+        process.env.npm_execpath,
+        path.join(execDir, "node_modules", "npm", "bin", "npm-cli.js"),
+        path.join(execDir, "..", "node_modules", "npm", "bin", "npm-cli.js"),
+        path.join(execDir, "..", "..", "node_modules", "npm", "bin", "npm-cli.js"),
+    ];
+    for (const candidate of candidates) {
+        if (candidate && fs.existsSync(candidate)) {
+            return path.resolve(candidate);
+        }
+    }
+    return null;
+}