@minniexcode/codex-switch 0.0.6 → 0.0.8

package/dist/interaction/add-interactive.js

@@ -4,13 +4,12 @@ exports.COMMON_TAG_CHOICES = void 0;
 exports.collectAddInput = collectAddInput;
 exports.createNonInteractiveAddError = createNonInteractiveAddError;
 exports.promptTags = promptTags;
-exports.parseTags = parseTags;
 const errors_1 = require("../domain/errors");
 exports.COMMON_TAG_CHOICES = ["free", "paid", "daily", "backup"];
 /**
  * Collects add command inputs interactively when required values are missing.
  */
-async function collectAddInput(runtime, defaults, providerExists) {
+async function collectAddInput(runtime, defaults, providerExists, profileExists) {
     runtime.writeLine("Interactive add mode");
     runtime.writeLine("Provide the missing required fields. Press Enter to skip optional fields.");
     const providerName = defaults.providerName
@@ -20,13 +19,19 @@ async function collectAddInput(runtime, defaults, providerExists) {
     const apiKey = defaults.apiKey
         ? normalizeRequiredValue(defaults.apiKey)
         : await promptConfirmedSecret(runtime, "API key", "Confirm API key");
-    const baseUrl = defaults.baseUrl ?? normalizeOptionalValue(await runtime.inputText("Base URL (optional)"));
+    const createProfile = !profileExists(profile);
+    const model = createProfile ? await promptRequiredValue(runtime, `Model for new profile "${profile}"`) : null;
+    const baseUrl = createProfile
+        ? (defaults.baseUrl ? normalizeRequiredValue(defaults.baseUrl) : await promptRequiredValue(runtime, `Base URL for new profile "${profile}"`))
+        : defaults.baseUrl ?? normalizeOptionalValue(await runtime.inputText("Base URL (optional)"));
     const note = defaults.note ?? normalizeOptionalValue(await runtime.inputText("Note (optional)"));
     const tags = defaults.tags.length > 0 ? defaults.tags : await promptTags(runtime);
     return {
         providerName,
         profile,
         apiKey,
+        createProfile,
+        model,
         baseUrl,
         note,
         tags,
@@ -87,22 +92,8 @@ function normalizeOptionalValue(value) {
 }
 async function promptTags(runtime, defaults = []) {
     const defaultPresetTags = defaults.filter(isCommonTag);
-    const defaultCustomTags = defaults.filter((tag) => !isCommonTag(tag));
-    const presetTags = await runtime.selectMany("Select tags (optional)", exports.COMMON_TAG_CHOICES.map((tag) => ({ value: tag, label: tag })), { defaultValues: defaultPresetTags });
-    const customTags = parseTags(await runtime.inputText("Custom tags (optional, comma-separated)", {
-        defaultValue: defaultCustomTags.join(", "),
-    }));
-    return dedupeTags([...presetTags, ...customTags]);
-}
-function parseTags(value) {
-    return dedupeTags(value
-        .split(",")
-        .map((tag) => tag.trim())
-        .filter((tag) => tag.length > 0));
+    return runtime.selectMany("Select tags (optional)", exports.COMMON_TAG_CHOICES.map((tag) => ({ value: tag, label: tag })), { defaultValues: defaultPresetTags });
 }
 function isCommonTag(tag) {
     return exports.COMMON_TAG_CHOICES.includes(tag);
 }
-function dedupeTags(tags) {
-    return Array.from(new Set(tags));
-}

package/dist/interaction/interactive.js

@@ -44,6 +44,7 @@ exports.getRollbackSummaryById = getRollbackSummaryById;
 exports.confirmRollback = confirmRollback;
 exports.chooseSetupStrategy = chooseSetupStrategy;
 exports.chooseCodexDir = chooseCodexDir;
+exports.confirmCreateCodexDir = confirmCreateCodexDir;
 exports.chooseSetupProfiles = chooseSetupProfiles;
 exports.collectSetupProviderDetails = collectSetupProviderDetails;
 exports.collectEditInput = collectEditInput;
@@ -61,6 +62,9 @@ const add_interactive_1 = require("./add-interactive");
 function canPrompt(runtime, jsonMode) {
     return !jsonMode && runtime.isInteractive();
 }
+/**
+ * Prompts the user to choose one configured provider when a command omitted its target.
+ */
 async function promptForProviderSelection(runtime, providersPath, message) {
     const providers = (0, providers_repo_1.readProvidersFile)(providersPath);
     const choices = Object.entries(providers.providers)
@@ -75,6 +79,9 @@ async function promptForProviderSelection(runtime, providersPath, message) {
     }
     return runtime.selectOne(message, choices);
 }
+/**
+ * Confirms destructive provider removal and turns a declined prompt into a typed cancellation.
+ */
 async function confirmProviderRemoval(runtime, providerName) {
     const confirmed = await runtime.confirmAction(`Remove provider "${providerName}"?`, {
         defaultValue: false,
@@ -83,6 +90,9 @@ async function confirmProviderRemoval(runtime, providerName) {
         throw (0, errors_1.cliError)("PROMPT_CANCELLED", `Removal cancelled for provider "${providerName}".`);
     }
 }
+/**
+ * Confirms provider import semantics, including whether the file will merge or replace the registry.
+ */
 async function confirmImport(runtime, sourceFile, merge = false) {
     const confirmed = await runtime.confirmAction(merge
         ? `Import providers from ${path.resolve(sourceFile)} and merge into the current registry?`
@@ -91,22 +101,37 @@ async function confirmImport(runtime, sourceFile, merge = false) {
         throw (0, errors_1.cliError)("PROMPT_CANCELLED", "Import cancelled.");
     }
 }
+/**
+ * Confirms whether an existing export target may be overwritten.
+ */
 async function confirmExportOverwrite(runtime, targetFile) {
     return runtime.confirmAction(`Overwrite existing export target ${path.resolve(targetFile)}?`, {
         defaultValue: false,
     });
 }
+/**
+ * Resolves whether the export target already exists after normalizing to an absolute path.
+ */
 function exportTargetExists(targetFile) {
     return fs.existsSync(path.resolve(targetFile));
 }
+/**
+ * Builds a rollback preview for the latest managed backup.
+ */
 function getRollbackSummary(latestBackupPath) {
     const manifest = (0, backup_repo_1.loadLatestManifest)(latestBackupPath);
     return buildRollbackSummary(manifest);
 }
+/**
+ * Builds a rollback preview for one explicit backup id.
+ */
 function getRollbackSummaryById(backupsDir, backupId) {
     const manifest = (0, backup_repo_1.loadManifestById)(backupsDir, backupId);
     return buildRollbackSummary(manifest);
 }
+/**
+ * Converts a backup manifest into the human preview shown before rollback confirmation.
+ */
 function buildRollbackSummary(manifest) {
     const previewLines = [
         "Rollback preview",
@@ -119,6 +144,9 @@ function buildRollbackSummary(manifest) {
     ];
     return { manifest, previewLines };
 }
+/**
+ * Prints the rollback preview and requires explicit confirmation before restore proceeds.
+ */
 async function confirmRollback(runtime, latestBackupPath, backupsDir, backupId) {
     const { previewLines } = backupId && backupsDir
         ? getRollbackSummaryById(backupsDir, backupId)
@@ -133,13 +161,19 @@ async function confirmRollback(runtime, latestBackupPath, backupsDir, backupId)
         throw (0, errors_1.cliError)("PROMPT_CANCELLED", "Rollback cancelled.");
     }
 }
+/**
+ * Prompts for setup merge strategy when providers.json already exists.
+ */
 async function chooseSetupStrategy(runtime) {
-    return runtime.selectOne("providers.json already exists. Choose a setup strategy.", [
+    return runtime.selectOne("providers.json already exists. Choose a migrate strategy.", [
         { value: "merge", label: "merge", hint: "keep existing providers and override by imported names" },
         { value: "overwrite", label: "overwrite", hint: "replace the existing registry" },
-        { value: "cancel", label: "cancel", hint: "abort setup without writing" },
+        { value: "cancel", label: "cancel", hint: "abort migrate without writing" },
     ]);
 }
+/**
+ * Resolves the Codex directory from discovered candidates or a manually entered path.
+ */
 async function chooseCodexDir(runtime, candidates) {
     if (candidates.length === 0) {
         const manual = (await runtime.inputText("Codex directory path")).trim();
@@ -170,6 +204,17 @@ async function chooseCodexDir(runtime, candidates) {
     }
     return (0, codex_paths_1.resolveCodexDir)(manual);
 }
+/**
+ * Confirms whether a missing Codex directory should be created during init.
+ */
+async function confirmCreateCodexDir(runtime, codexDir) {
+    return runtime.confirmAction(`Create missing Codex directory ${codexDir}?`, {
+        defaultValue: false,
+    });
+}
+/**
+ * Lets setup adopt a subset of unmanaged config profiles into providers.json.
+ */
 async function chooseSetupProfiles(runtime, profiles) {
     if (profiles.length === 0) {
         return [];
@@ -177,29 +222,57 @@ 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}`,
+        hint: `${profile.model} | ${profile.baseUrl} | ${profile.envKey}`,
     })));
 }
-async function collectSetupProviderDetails(runtime, profiles) {
+/**
+ * Collects provider metadata for each adopted config profile during setup.
+ */
+async function collectSetupProviderDetails(runtime, profiles, defaultsByProfile = {}) {
     const result = {};
     for (const profile of profiles) {
+        const defaults = defaultsByProfile[profile] ?? {};
         const providerName = (await runtime.inputText(`Provider name for profile "${profile}"`, {
-            defaultValue: 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 ?? "",
+        })).trim();
+        const note = (await runtime.inputText(`Note for profile "${profile}" (optional)`, {
+            defaultValue: defaults.note ?? "",
         })).trim();
-        const apiKey = (await runtime.inputSecret(`API key for profile "${profile}"`)).trim();
-        const baseUrl = (await runtime.inputText(`Base URL for profile "${profile}" (optional)`)).trim();
-        const note = (await runtime.inputText(`Note for profile "${profile}" (optional)`)).trim();
         const tags = await (0, add_interactive_1.promptTags)(runtime);
         result[profile] = {
-            providerName: providerName || profile,
+            providerName: providerName || defaults.providerName || profile,
             apiKey,
-            baseUrl: baseUrl || undefined,
-            note: note || undefined,
+            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.
             tags: tags.length > 0 ? tags : undefined,
         };
     }
     return result;
 }
+/**
+ * Re-prompts until a required secret value is provided, optionally falling back to a non-empty default.
+ */
+async function promptRequiredSecret(runtime, label, defaultValue) {
+    while (true) {
+        const value = (await runtime.inputSecret(label)).trim() || defaultValue || "";
+        if (value.length > 0) {
+            return value;
+        }
+        runtime.writeLine(`${label} is required.`);
+    }
+}
+/**
+ * Collects editable provider fields, preserving current values when prompts are left blank.
+ */
 async function collectEditInput(runtime, current) {
     const profile = (await runtime.inputText("Profile", { defaultValue: current.profile })).trim();
     const apiKey = (await runtime.inputSecret("API key")).trim() || current.apiKey;

package/dist/runtime/codex-probe.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.codexRuntimeProbe = void 0;
 exports.probeCodexRuntime = probeCodexRuntime;
 const codex_cli_1 = require("./codex-cli");
+/**
+ * Default dependency probe implementation for the local codex CLI runtime.
+ */
 exports.codexRuntimeProbe = {
     probe(options) {
         if (options?.minVersion) {
@@ -11,6 +14,9 @@ exports.codexRuntimeProbe = {
         return probeCodexRuntime();
     },
 };
+/**
+ * Checks whether the codex CLI is installed and, optionally, satisfies a minimum version.
+ */
 function probeCodexRuntime(minVersion) {
     const availability = (0, codex_cli_1.checkCodexAvailable)();
     if (!availability.ok) {
@@ -31,6 +37,7 @@ function probeCodexRuntime(minVersion) {
         };
     }
     if (minVersion) {
+        // Reuse the dedicated semver check so doctor and setup report the same unsupported-version behavior.
         const versionCheck = (0, codex_cli_1.checkCodexVersion)(minVersion);
         if (!versionCheck.ok) {
             return {

package/dist/runtime/copilot-adapter.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.probeCopilotSdkRuntime = probeCopilotSdkRuntime;
+exports.requireCopilotSdk = requireCopilotSdk;
+exports.readCopilotAuthState = readCopilotAuthState;
+exports.sendCopilotChatCompletion = sendCopilotChatCompletion;
+const errors_1 = require("../domain/errors");
+const copilot_sdk_loader_1 = require("./copilot-sdk-loader");
+const copilot_installer_1 = require("./copilot-installer");
+/**
+ * Probes whether the optional Copilot SDK runtime is installed and loadable.
+ */
+function probeCopilotSdkRuntime() {
+    const status = (0, copilot_installer_1.probeCopilotSdkInstall)();
+    if (!status.installed) {
+        return {
+            ok: false,
+            runtime: "copilot-sdk",
+            reason: "missing",
+            cause: "The optional Copilot SDK runtime is not installed.",
+            details: {
+                installDir: status.installDir,
+                packageName: status.packageName,
+            },
+        };
+    }
+    return {
+        ok: true,
+        runtime: "copilot-sdk",
+        version: status.packageVersion ?? undefined,
+        details: {
+            installDir: status.installDir,
+            packageName: status.packageName,
+        },
+    };
+}
+/**
+ * Loads the lazily installed Copilot SDK and returns the module.
+ */
+async function requireCopilotSdk() {
+    return (0, copilot_sdk_loader_1.loadCopilotSdk)();
+}
+/**
+ * Probes whether the lazily installed Copilot SDK can create a usable session.
+ */
+async function readCopilotAuthState() {
+    const runtime = probeCopilotSdkRuntime();
+    if (!runtime.ok) {
+        throw (0, errors_1.cliError)("COPILOT_SDK_MISSING", "The optional Copilot SDK runtime is not installed.", runtime.details);
+    }
+    const { client, session } = await createCopilotSession();
+    await stopCopilotClient(client);
+    return {
+        ready: Boolean(session),
+        source: "official-sdk",
+        mode: "session",
+    };
+}
+/**
+ * Executes a single chat-completions style request through the optional Copilot SDK when available.
+ */
+async function sendCopilotChatCompletion(args) {
+    const { client, session, sdk } = await createCopilotSession();
+    try {
+        const sendAndWait = resolveCallable(session, "sendAndWait") ?? resolveCallable(sdk, "sendAndWait");
+        if (!sendAndWait) {
+            throw (0, errors_1.cliError)("COPILOT_SDK_UNSUPPORTED", "The installed Copilot SDK does not expose a supported sendAndWait API.", {
+                provider: args.provider,
+            });
+        }
+        const prompt = Array.isArray(args.payload.messages)
+            ? args.payload.messages
+                .map((entry) => {
+                const message = entry;
+                return `${String(message.role ?? "user")}: ${String(message.content ?? "")}`;
+            })
+                .join("\n")
+            : "";
+        const result = await Promise.resolve(sendAndWait({ model: args.payload.model, prompt }));
+        const content = typeof result === "string"
+            ? result
+            : typeof result?.content === "string"
+                ? String(result.content)
+                : typeof result?.data === "object" &&
+                    typeof result.data.content === "string"
+                    ? String(result.data.content)
+                    : JSON.stringify(result);
+        return {
+            id: `copilot-${Date.now()}`,
+            object: "chat.completion",
+            created: Math.floor(Date.now() / 1000),
+            model: args.payload.model ?? "copilot",
+            choices: [
+                {
+                    index: 0,
+                    message: {
+                        role: "assistant",
+                        content,
+                    },
+                    finish_reason: "stop",
+                },
+            ],
+        };
+    }
+    finally {
+        await stopCopilotClient(client);
+    }
+}
+async function createCopilotSession() {
+    const sdk = (await requireCopilotSdk());
+    const client = createCopilotClient(sdk);
+    const createSession = resolveCallable(client ? client : null, "createSession") ?? resolveCallable(sdk, "createSession");
+    if (!createSession) {
+        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({})));
+        return {
+            sdk,
+            client,
+            session,
+        };
+    }
+    catch (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),
+        });
+    }
+}
+function createCopilotClient(sdk) {
+    const ClientCtor = resolveConstructor(sdk, "CopilotClient");
+    if (!ClientCtor) {
+        return null;
+    }
+    try {
+        return new ClientCtor();
+    }
+    catch (error) {
+        throw (0, errors_1.cliError)("COPILOT_SDK_UNSUPPORTED", "The installed Copilot SDK CopilotClient could not be constructed.", {
+            cause: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+async function stopCopilotClient(client) {
+    if (client && typeof client.stop === "function") {
+        await Promise.resolve(client.stop());
+    }
+}
+function resolveCallable(target, name) {
+    if (!target) {
+        return null;
+    }
+    const direct = target[name];
+    if (typeof direct === "function") {
+        return direct;
+    }
+    const nestedDefault = target.default;
+    if (nestedDefault && typeof nestedDefault[name] === "function") {
+        return nestedDefault[name];
+    }
+    return null;
+}
+function resolveConstructor(target, name) {
+    const direct = target[name];
+    if (typeof direct === "function") {
+        return direct;
+    }
+    const nestedDefault = target.default;
+    if (nestedDefault && typeof nestedDefault[name] === "function") {
+        return nestedDefault[name];
+    }
+    return null;
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const copilot_bridge_1 = require("./copilot-bridge");
+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 apiKey = process.env.CODEX_SWITCH_BRIDGE_API_KEY ?? "";
+    await (0, copilot_bridge_1.startCopilotBridgeServer)({
+        host,
+        port,
+        apiKey,
+        executeChatCompletion: async (payload) => (0, copilot_adapter_1.sendCopilotChatCompletion)({
+            provider,
+            payload,
+        }),
+    });
+}
+if (require.main === module) {
+    void main().catch((error) => {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exit(1);
+    });
+}