opencode-switch-cli 1.0.0

package/dist/bin.mjs

@@ -0,0 +1,1171 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import os from "os";
+import path2 from "path";
+import pc from "picocolors";
+
+// src/config/json-file.ts
+import { copyFile, mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+function cloneValue(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+async function fileExists(filePath) {
+  try {
+    await readFile(filePath, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createJsonFileStore() {
+  return {
+    async read({ filePath, defaultValue }) {
+      if (!await fileExists(filePath)) {
+        const initialValue = cloneValue(defaultValue);
+        await mkdir(path.dirname(filePath), { recursive: true });
+        await writeFile(filePath, `${JSON.stringify(initialValue, null, 2)}
+`, "utf8");
+        return initialValue;
+      }
+      const content = await readFile(filePath, "utf8");
+      return JSON.parse(content);
+    },
+    async write({
+      filePath,
+      value,
+      backupExisting = false
+    }) {
+      await mkdir(path.dirname(filePath), { recursive: true });
+      if (backupExisting && await fileExists(filePath)) {
+        await copyFile(filePath, `${filePath}.bak`);
+      }
+      await writeFile(filePath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+    }
+  };
+}
+
+// src/config/opencode-repository.ts
+var DEFAULT_OPENCODE_CONFIG = {
+  provider: {},
+  model: null,
+  small_model: null
+};
+function normalizeOpenCodeConfig(value) {
+  if (!value) {
+    return { ...DEFAULT_OPENCODE_CONFIG };
+  }
+  const { provider, model, small_model, ...rest } = value;
+  return {
+    ...rest,
+    provider: provider ?? {},
+    model: model ?? null,
+    small_model: small_model ?? null
+  };
+}
+function createOpencodeRepository(input) {
+  const { filePath, jsonStore } = input;
+  return {
+    async read() {
+      const config = await jsonStore.read({ filePath, defaultValue: DEFAULT_OPENCODE_CONFIG });
+      return normalizeOpenCodeConfig(config);
+    },
+    async write(config) {
+      await jsonStore.write({
+        filePath,
+        value: normalizeOpenCodeConfig(config),
+        backupExisting: true
+      });
+    }
+  };
+}
+
+// src/config/switch-repository.ts
+var DEFAULT_SWITCH_CONFIG = {
+  activeVendor: null,
+  managedProviders: []
+};
+function normalizeSwitchConfig(value) {
+  return {
+    activeVendor: value?.activeVendor ?? null,
+    managedProviders: (value?.managedProviders ?? []).map((provider) => ({
+      vendorName: provider.vendorName,
+      models: (provider.models ?? []).map((model) => ({
+        modelType: model.modelType,
+        realModel: model.realModel,
+        activeKeyAlias: model.activeKeyAlias ?? null,
+        keys: (model.keys ?? []).map((key) => ({
+          keyAlias: key.keyAlias,
+          apiKey: key.apiKey,
+          ...key.baseURL ? { baseURL: key.baseURL } : {}
+        }))
+      }))
+    }))
+  };
+}
+function createSwitchRepository(input) {
+  const { filePath, jsonStore } = input;
+  return {
+    async read() {
+      const config = await jsonStore.read({ filePath, defaultValue: DEFAULT_SWITCH_CONFIG });
+      return normalizeSwitchConfig(config);
+    },
+    async write(config) {
+      await jsonStore.write({
+        filePath,
+        value: normalizeSwitchConfig(config)
+      });
+    }
+  };
+}
+
+// src/prompt-client.ts
+import {
+  cancel,
+  confirm,
+  intro,
+  isCancel,
+  note,
+  outro,
+  password,
+  select,
+  spinner,
+  text
+} from "@clack/prompts";
+function unwrapCanceled(value) {
+  if (isCancel(value)) {
+    cancel("Canceled");
+    throw new Error("Canceled");
+  }
+  return value;
+}
+function createPromptClient() {
+  return {
+    intro(message) {
+      intro(message);
+    },
+    outro(message) {
+      outro(message);
+    },
+    note(message, title) {
+      note(message, title);
+    },
+    async select(input) {
+      return unwrapCanceled(
+        await select({
+          message: input.message,
+          options: input.options.map((option) => ({
+            value: option.value,
+            label: option.label,
+            ...option.hint ? { hint: option.hint } : {}
+          }))
+        })
+      );
+    },
+    async text(input) {
+      return unwrapCanceled(
+        await text({
+          message: input.message,
+          ...input.placeholder ? { placeholder: input.placeholder } : {},
+          ...input.defaultValue ? { defaultValue: input.defaultValue } : {},
+          validate(value) {
+            return value?.trim().length ? void 0 : "Required";
+          }
+        })
+      );
+    },
+    async password(input) {
+      return unwrapCanceled(
+        await password({
+          message: input.message,
+          ...input.placeholder ? { placeholder: input.placeholder } : {},
+          validate(value) {
+            return value?.trim().length ? void 0 : "Required";
+          }
+        })
+      );
+    },
+    async confirm(input) {
+      return unwrapCanceled(
+        await confirm({
+          message: input.message,
+          ...input.initialValue !== void 0 ? { initialValue: input.initialValue } : {}
+        })
+      );
+    },
+    async withSpinner(message, action) {
+      const s = spinner();
+      s.start(message);
+      try {
+        const result = await action();
+        s.stop("Done");
+        return result;
+      } catch (error) {
+        s.stop("Failed");
+        throw error;
+      }
+    }
+  };
+}
+
+// src/types.ts
+var SUPPORTED_MODEL_TYPES = ["gpt-5.4", "gemini"];
+
+// src/services/model-service.ts
+function isSupportedModelType(modelType) {
+  return SUPPORTED_MODEL_TYPES.includes(modelType);
+}
+function requireSupportedModelType(modelType) {
+  if (!isSupportedModelType(modelType)) {
+    throw new Error("Unsupported model type");
+  }
+  return modelType;
+}
+function upsertManagedProvider(providers, nextProvider) {
+  const providerIndex = providers.findIndex((provider) => provider.vendorName === nextProvider.vendorName);
+  if (providerIndex === -1) {
+    return [...providers, nextProvider];
+  }
+  return providers.map((provider, index) => index === providerIndex ? nextProvider : provider);
+}
+function upsertManagedModel(providers, vendorName, nextModel) {
+  const existingProvider = providers.find((provider) => provider.vendorName === vendorName);
+  const existingModels = existingProvider?.models ?? [];
+  const otherModels = existingModels.filter((model) => model.modelType !== nextModel.modelType);
+  const nextProvider = {
+    vendorName,
+    models: [...otherModels, nextModel]
+  };
+  return upsertManagedProvider(providers, nextProvider);
+}
+function getManagedProvider(config, vendorName) {
+  return config.managedProviders.find((provider) => provider.vendorName === vendorName);
+}
+function getManagedModel(provider, modelType) {
+  return provider?.models.find((model) => model.modelType === modelType);
+}
+function requireManagedModel(config, vendorName, modelType) {
+  const managedModel = getManagedModel(getManagedProvider(config, vendorName), modelType);
+  if (!managedModel) {
+    throw new Error(`Unknown model: ${vendorName}/${modelType}`);
+  }
+  return managedModel;
+}
+function mergeProviderOptions(existingOptions, nextOptions) {
+  const mergedOptions = {
+    ...existingOptions ?? {},
+    ...nextOptions.baseURL ? { baseURL: nextOptions.baseURL } : {},
+    ...nextOptions.apiKey ? { apiKey: nextOptions.apiKey } : {}
+  };
+  return Object.keys(mergedOptions).length > 0 ? mergedOptions : void 0;
+}
+function findTemplateModel(input) {
+  const currentProviderModel = input.opencodeConfig.provider[input.vendorName]?.models[input.modelType];
+  if (currentProviderModel) {
+    return currentProviderModel;
+  }
+  const duckTemplateModel = input.opencodeConfig.provider.duck?.models[input.modelType];
+  if (duckTemplateModel) {
+    return duckTemplateModel;
+  }
+  return Object.values(input.opencodeConfig.provider).map((provider) => provider.models[input.modelType]).find((model) => model !== void 0);
+}
+function applyActiveKeyToPrimaryModel(input) {
+  const { opencodeConfig, switchConfig, vendorName, modelType, key } = input;
+  const provider = opencodeConfig.provider[vendorName];
+  const primaryPointer = opencodeConfig.model;
+  if (!provider || switchConfig.activeVendor !== vendorName || primaryPointer !== `${vendorName}/${modelType}`) {
+    return opencodeConfig;
+  }
+  const mergedOptions = key ? mergeProviderOptions(provider.options, {
+    apiKey: key.apiKey,
+    ...key.baseURL ? { baseURL: key.baseURL } : {}
+  }) : void 0;
+  const nextProvider = key ? {
+    ...provider,
+    ...mergedOptions ? { options: mergedOptions } : {}
+  } : provider;
+  return {
+    ...opencodeConfig,
+    provider: {
+      ...opencodeConfig.provider,
+      [vendorName]: nextProvider
+    }
+  };
+}
+function createModelService(input) {
+  const { opencodeRepository, switchRepository } = input;
+  return {
+    async addModel(model) {
+      const supportedModelType = requireSupportedModelType(model.modelType);
+      const opencodeConfig = await opencodeRepository.read();
+      const provider = opencodeConfig.provider[model.vendorName];
+      if (!provider) {
+        throw new Error(`Unknown vendor: ${model.vendorName}`);
+      }
+      const nextOpencodeConfig = {
+        ...opencodeConfig,
+        provider: {
+          ...opencodeConfig.provider,
+          [model.vendorName]: {
+            ...provider,
+            models: {
+              ...provider.models,
+              [supportedModelType]: {
+                ...findTemplateModel({
+                  opencodeConfig,
+                  vendorName: model.vendorName,
+                  modelType: supportedModelType
+                }) ?? {},
+                name: model.realModel
+              }
+            }
+          }
+        }
+      };
+      await opencodeRepository.write(nextOpencodeConfig);
+      const switchConfig = await switchRepository.read();
+      const existingModel = getManagedModel(getManagedProvider(switchConfig, model.vendorName), supportedModelType);
+      const nextSwitchConfig = {
+        ...switchConfig,
+        managedProviders: upsertManagedModel(switchConfig.managedProviders, model.vendorName, {
+          modelType: supportedModelType,
+          realModel: model.realModel,
+          activeKeyAlias: existingModel?.activeKeyAlias ?? null,
+          keys: existingModel?.keys ?? []
+        })
+      };
+      await switchRepository.write(nextSwitchConfig);
+    },
+    async addKey(input2) {
+      const modelType = requireSupportedModelType(input2.modelType);
+      const opencodeConfig = await opencodeRepository.read();
+      if (!opencodeConfig.provider[input2.vendorName]) {
+        throw new Error(`Unknown vendor: ${input2.vendorName}`);
+      }
+      const switchConfig = await switchRepository.read();
+      const managedModel = requireManagedModel(switchConfig, input2.vendorName, modelType);
+      const otherKeys = managedModel.keys.filter((key) => key.keyAlias !== input2.keyAlias);
+      const nextKey = {
+        keyAlias: input2.keyAlias,
+        apiKey: input2.apiKey,
+        ...input2.baseURL ? { baseURL: input2.baseURL } : {}
+      };
+      const nextModel = {
+        ...managedModel,
+        activeKeyAlias: managedModel.activeKeyAlias ?? input2.keyAlias,
+        keys: [...otherKeys, nextKey].sort((left, right) => left.keyAlias.localeCompare(right.keyAlias))
+      };
+      const nextSwitchConfig = {
+        ...switchConfig,
+        managedProviders: upsertManagedModel(switchConfig.managedProviders, input2.vendorName, nextModel)
+      };
+      await switchRepository.write(nextSwitchConfig);
+      const activeKey = nextModel.keys.find((key) => key.keyAlias === nextModel.activeKeyAlias);
+      const nextOpencodeConfig = applyActiveKeyToPrimaryModel({
+        opencodeConfig,
+        switchConfig: nextSwitchConfig,
+        vendorName: input2.vendorName,
+        modelType,
+        key: activeKey
+      });
+      if (nextOpencodeConfig !== opencodeConfig) {
+        await opencodeRepository.write(nextOpencodeConfig);
+      }
+    },
+    async listModels(vendorName) {
+      const switchConfig = await switchRepository.read();
+      const managedProvider = getManagedProvider(switchConfig, vendorName);
+      return (managedProvider?.models ?? []).slice().sort((left, right) => left.modelType.localeCompare(right.modelType)).map((model) => ({
+        vendorName,
+        modelType: model.modelType,
+        realModel: model.realModel,
+        activeKeyAlias: model.activeKeyAlias,
+        keyCount: model.keys.length
+      }));
+    },
+    async listKeys(vendorName, modelType) {
+      const supportedModelType = requireSupportedModelType(modelType);
+      const switchConfig = await switchRepository.read();
+      const managedModel = requireManagedModel(switchConfig, vendorName, supportedModelType);
+      return managedModel.keys.slice().sort((left, right) => left.keyAlias.localeCompare(right.keyAlias)).map((key) => ({
+        keyAlias: key.keyAlias,
+        isActive: key.keyAlias === managedModel.activeKeyAlias
+      }));
+    },
+    async useKey(vendorName, modelType, keyAlias) {
+      const supportedModelType = requireSupportedModelType(modelType);
+      const switchConfig = await switchRepository.read();
+      const managedModel = requireManagedModel(switchConfig, vendorName, supportedModelType);
+      const activeKey = managedModel.keys.find((key) => key.keyAlias === keyAlias);
+      if (!activeKey) {
+        throw new Error(`Unknown key: ${vendorName}/${supportedModelType}/${keyAlias}`);
+      }
+      const nextModel = {
+        ...managedModel,
+        activeKeyAlias: keyAlias
+      };
+      const nextSwitchConfig = {
+        ...switchConfig,
+        managedProviders: upsertManagedModel(switchConfig.managedProviders, vendorName, nextModel)
+      };
+      await switchRepository.write(nextSwitchConfig);
+      const opencodeConfig = await opencodeRepository.read();
+      const nextOpencodeConfig = applyActiveKeyToPrimaryModel({
+        opencodeConfig,
+        switchConfig: nextSwitchConfig,
+        vendorName,
+        modelType: supportedModelType,
+        key: activeKey
+      });
+      if (nextOpencodeConfig !== opencodeConfig) {
+        await opencodeRepository.write(nextOpencodeConfig);
+      }
+    },
+    async removeModel(vendorName, modelType) {
+      const supportedModelType = requireSupportedModelType(modelType);
+      const opencodeConfig = await opencodeRepository.read();
+      const provider = opencodeConfig.provider[vendorName];
+      if (!provider) {
+        throw new Error(`Unknown vendor: ${vendorName}`);
+      }
+      const nextModels = { ...provider.models };
+      delete nextModels[supportedModelType];
+      const targetModelPointer = `${vendorName}/${supportedModelType}`;
+      await opencodeRepository.write({
+        ...opencodeConfig,
+        provider: {
+          ...opencodeConfig.provider,
+          [vendorName]: {
+            ...provider,
+            models: nextModels
+          }
+        },
+        model: opencodeConfig.model === targetModelPointer ? null : opencodeConfig.model,
+        small_model: opencodeConfig.small_model === targetModelPointer ? null : opencodeConfig.small_model
+      });
+      const switchConfig = await switchRepository.read();
+      await switchRepository.write({
+        ...switchConfig,
+        managedProviders: switchConfig.managedProviders.map((providerMetadata) => {
+          if (providerMetadata.vendorName !== vendorName) {
+            return providerMetadata;
+          }
+          return {
+            ...providerMetadata,
+            models: providerMetadata.models.filter(
+              (modelMetadata) => modelMetadata.modelType !== supportedModelType
+            )
+          };
+        })
+      });
+    },
+    async removeKey(vendorName, modelType, keyAlias) {
+      const supportedModelType = requireSupportedModelType(modelType);
+      const switchConfig = await switchRepository.read();
+      const managedModel = requireManagedModel(switchConfig, vendorName, supportedModelType);
+      if (!managedModel.keys.some((key) => key.keyAlias === keyAlias)) {
+        throw new Error(`Unknown key: ${vendorName}/${supportedModelType}/${keyAlias}`);
+      }
+      const nextKeys = managedModel.keys.filter((key) => key.keyAlias !== keyAlias);
+      const nextActiveKeyAlias = managedModel.activeKeyAlias === keyAlias ? nextKeys[0]?.keyAlias ?? null : managedModel.activeKeyAlias;
+      const nextModel = {
+        ...managedModel,
+        activeKeyAlias: nextActiveKeyAlias,
+        keys: nextKeys
+      };
+      const nextSwitchConfig = {
+        ...switchConfig,
+        managedProviders: upsertManagedModel(switchConfig.managedProviders, vendorName, nextModel)
+      };
+      await switchRepository.write(nextSwitchConfig);
+      const opencodeConfig = await opencodeRepository.read();
+      const activeKey = nextModel.keys.find((key) => key.keyAlias === nextActiveKeyAlias);
+      const nextOpencodeConfig = applyActiveKeyToPrimaryModel({
+        opencodeConfig,
+        switchConfig: nextSwitchConfig,
+        vendorName,
+        modelType: supportedModelType,
+        key: activeKey
+      });
+      if (nextOpencodeConfig !== opencodeConfig) {
+        await opencodeRepository.write(nextOpencodeConfig);
+      }
+    }
+  };
+}
+
+// src/services/vendor-service.ts
+function upsertManagedProvider2(managedProviders, vendorName) {
+  const existingProvider = managedProviders.find((provider) => provider.vendorName === vendorName);
+  if (existingProvider) {
+    return managedProviders;
+  }
+  return [...managedProviders, { vendorName, models: [] }];
+}
+function createProviderOptions(input) {
+  const options = {
+    ...input.templateOptions ?? {},
+    ...input.existingOptions ?? {},
+    ...input.baseURL ? { baseURL: input.baseURL } : {},
+    ...input.apiKey ? { apiKey: input.apiKey } : {}
+  };
+  return Object.keys(options).length > 0 ? options : void 0;
+}
+function selectModelPointers(vendorName, provider) {
+  const availableModelTypes = Object.keys(provider.models).sort();
+  if (availableModelTypes.length === 0) {
+    return {
+      model: null,
+      smallModel: null
+    };
+  }
+  const primaryModelType = provider.models["gpt-5.4"] ? "gpt-5.4" : availableModelTypes[0];
+  const smallModelType = provider.models.gemini ? "gemini" : primaryModelType;
+  return {
+    model: primaryModelType ? `${vendorName}/${primaryModelType}` : null,
+    smallModel: smallModelType ? `${vendorName}/${smallModelType}` : null
+  };
+}
+function findActiveModelKey(input) {
+  const managedProvider = input.switchConfig.managedProviders.find(
+    (provider) => provider.vendorName === input.vendorName
+  );
+  const managedModel = managedProvider?.models.find((model) => model.modelType === input.modelType);
+  if (!managedModel?.activeKeyAlias) {
+    return void 0;
+  }
+  return managedModel.keys.find((key) => key.keyAlias === managedModel.activeKeyAlias);
+}
+function createVendorService(input) {
+  const { opencodeRepository, switchRepository } = input;
+  return {
+    async addVendor(vendor) {
+      const opencodeConfig = await opencodeRepository.read();
+      const existingProvider = opencodeConfig.provider[vendor.vendorName];
+      const providerOptions = createProviderOptions({
+        templateOptions: vendor.templateOptions,
+        existingOptions: existingProvider?.options,
+        ...vendor.baseURL ? { baseURL: vendor.baseURL } : {},
+        ...vendor.apiKey ? { apiKey: vendor.apiKey } : {}
+      }) ?? existingProvider?.options;
+      const providerConfig = {
+        ...existingProvider ?? {},
+        name: vendor.vendorName,
+        npm: vendor.npm,
+        models: existingProvider?.models ?? {},
+        ...providerOptions ? { options: providerOptions } : {}
+      };
+      const nextConfig = {
+        ...opencodeConfig,
+        provider: {
+          ...opencodeConfig.provider,
+          [vendor.vendorName]: providerConfig
+        }
+      };
+      await opencodeRepository.write(nextConfig);
+      const switchConfig = await switchRepository.read();
+      const nextSwitchConfig = {
+        ...switchConfig,
+        managedProviders: upsertManagedProvider2(switchConfig.managedProviders, vendor.vendorName)
+      };
+      await switchRepository.write(nextSwitchConfig);
+    },
+    async listVendors() {
+      const opencodeConfig = await opencodeRepository.read();
+      const switchConfig = await switchRepository.read();
+      const managedProviders = new Map(
+        switchConfig.managedProviders.map((provider) => [provider.vendorName, provider])
+      );
+      return Object.keys(opencodeConfig.provider).sort().map((vendorName) => {
+        const managedProvider = managedProviders.get(vendorName);
+        const provider = opencodeConfig.provider[vendorName];
+        return {
+          vendorName,
+          managed: managedProvider !== void 0,
+          modelCount: managedProvider?.models.length ?? Object.keys(provider?.models ?? {}).length
+        };
+      });
+    },
+    async useVendor(vendorName) {
+      const opencodeConfig = await opencodeRepository.read();
+      const provider = opencodeConfig.provider[vendorName];
+      if (!provider) {
+        throw new Error(`Unknown vendor: ${vendorName}`);
+      }
+      const pointers = selectModelPointers(vendorName, provider);
+      const switchConfig = await switchRepository.read();
+      const primaryModelType = pointers.model?.split("/")[1] ?? null;
+      const activeKey = findActiveModelKey({
+        switchConfig,
+        vendorName,
+        modelType: primaryModelType
+      });
+      const providerOptions = activeKey ? {
+        ...provider.options ?? {},
+        apiKey: activeKey.apiKey,
+        ...activeKey.baseURL ? { baseURL: activeKey.baseURL } : {}
+      } : provider.options;
+      await opencodeRepository.write({
+        ...opencodeConfig,
+        model: pointers.model,
+        small_model: pointers.smallModel,
+        provider: {
+          ...opencodeConfig.provider,
+          [vendorName]: {
+            ...provider,
+            ...providerOptions ? { options: providerOptions } : {}
+          }
+        }
+      });
+      await switchRepository.write({
+        ...switchConfig,
+        activeVendor: vendorName
+      });
+    },
+    async removeVendor(vendorName) {
+      const opencodeConfig = await opencodeRepository.read();
+      if (!opencodeConfig.provider[vendorName]) {
+        throw new Error(`Unknown vendor: ${vendorName}`);
+      }
+      const nextProviders = { ...opencodeConfig.provider };
+      delete nextProviders[vendorName];
+      await opencodeRepository.write({
+        ...opencodeConfig,
+        provider: nextProviders,
+        model: opencodeConfig.model?.startsWith(`${vendorName}/`) ? null : opencodeConfig.model,
+        small_model: opencodeConfig.small_model?.startsWith(`${vendorName}/`) ? null : opencodeConfig.small_model
+      });
+      const switchConfig = await switchRepository.read();
+      await switchRepository.write({
+        activeVendor: switchConfig.activeVendor === vendorName ? null : switchConfig.activeVendor,
+        managedProviders: switchConfig.managedProviders.filter(
+          (provider) => provider.vendorName !== vendorName
+        )
+      });
+    }
+  };
+}
+
+// src/cli.ts
+var DEFAULT_VENDOR_NPM = "@ai-sdk/openai";
+function resolveConfigPaths(homeDir) {
+  const configDir = path2.join(homeDir, ".config", "opencode");
+  return {
+    opencodeConfigPath: path2.join(configDir, "opencode.json"),
+    switchConfigPath: path2.join(configDir, "opencode-switch.json")
+  };
+}
+function parseFlags(args) {
+  const flags = {};
+  for (let index = 0; index < args.length; index += 2) {
+    const key = args[index];
+    const value = args[index + 1];
+    if (!key?.startsWith("--") || value === void 0) {
+      throw new Error(`Invalid arguments: ${args.join(" ")}`);
+    }
+    flags[key.slice(2)] = value;
+  }
+  return flags;
+}
+function formatList(lines) {
+  return lines.length > 0 ? `${lines.join("\n")}
+` : "";
+}
+function formatVendorDashboard(input) {
+  if (input.vendors.length === 0) {
+    return [pc.bold("OpenCode Switch"), "No vendors configured yet."].join("\n");
+  }
+  return [
+    pc.bold("OpenCode Switch"),
+    ...input.vendors.map((vendor, index) => {
+      const marker = vendor.vendorName === input.activeVendor ? pc.cyan(">") : "-";
+      const activeLabel = vendor.vendorName === input.activeVendor ? ` ${pc.green("[active]")}` : "";
+      return `${marker} ${pc.bold(vendor.vendorName)}${activeLabel}  models:${vendor.modelCount}`;
+    })
+  ].join("\n");
+}
+function createCliContext(homeDir, promptClient) {
+  const { opencodeConfigPath, switchConfigPath } = resolveConfigPaths(homeDir);
+  const jsonStore = createJsonFileStore();
+  const opencodeRepository = createOpencodeRepository({ filePath: opencodeConfigPath, jsonStore });
+  const switchRepository = createSwitchRepository({ filePath: switchConfigPath, jsonStore });
+  return {
+    opencodeRepository,
+    promptClient,
+    switchRepository,
+    vendorService: createVendorService({ opencodeRepository, switchRepository }),
+    modelService: createModelService({ opencodeRepository, switchRepository })
+  };
+}
+function stripSensitiveTemplateOptions(options) {
+  if (!options) {
+    return void 0;
+  }
+  const nextOptions = { ...options };
+  delete nextOptions.apiKey;
+  delete nextOptions.baseURL;
+  return nextOptions;
+}
+function asSupportedModelType(modelType) {
+  if (!SUPPORTED_MODEL_TYPES.includes(modelType)) {
+    throw new Error("Unsupported model type");
+  }
+  return modelType;
+}
+async function selectVendor(context, message) {
+  const vendors = await context.vendorService.listVendors();
+  if (vendors.length === 0) {
+    throw new Error("No vendors configured");
+  }
+  return context.promptClient.select({
+    message,
+    options: vendors.map((vendor) => ({
+      value: vendor.vendorName,
+      label: vendor.vendorName,
+      hint: `${vendor.modelCount} model(s)`
+    }))
+  });
+}
+async function selectModelForKeys(context, vendorName) {
+  while (true) {
+    const models = await context.modelService.listModels(vendorName);
+    const selected = await context.promptClient.select({
+      message: `Pick a model for ${vendorName}`,
+      options: [
+        ...models.map((model) => ({
+          value: model.modelType,
+          label: model.modelType,
+          hint: `${model.realModel}${model.activeKeyAlias ? ` | active:${model.activeKeyAlias}` : ""}`
+        })),
+        {
+          value: "__add_new_model__",
+          label: "Add new model",
+          hint: "Create a model before choosing keys"
+        }
+      ]
+    });
+    if (selected !== "__add_new_model__") {
+      return asSupportedModelType(selected);
+    }
+    const modelType = asSupportedModelType(
+      await context.promptClient.select({
+        message: `Choose a model type for ${vendorName}`,
+        options: SUPPORTED_MODEL_TYPES.map((supportedType) => ({
+          value: supportedType,
+          label: supportedType
+        }))
+      })
+    );
+    const realModel = await context.promptClient.text({
+      message: `Real model id for ${vendorName}/${modelType}`,
+      placeholder: modelType === "gpt-5.4" ? "duck/gpt-5.4" : "google/gemini-2.5-flash"
+    });
+    await context.promptClient.withSpinner(`Adding ${vendorName}/${modelType}`, async () => {
+      await context.modelService.addModel({ vendorName, modelType, realModel });
+    });
+    context.promptClient.note(`${vendorName}/${modelType} is ready.`, "Model added");
+  }
+}
+async function runInteractiveRemoveVendor(context) {
+  context.promptClient.intro("Remove vendor");
+  const vendors = await context.vendorService.listVendors();
+  if (vendors.length === 0) {
+    return { exitCode: 1, stdout: "", stderr: "No vendors configured\n" };
+  }
+  const vendorName = await selectVendor(context, "Choose a vendor to remove");
+  const targetVendor = vendors.find((vendor) => vendor.vendorName === vendorName);
+  const confirmed = await context.promptClient.confirm({
+    message: `Delete ${vendorName} and its ${targetVendor?.modelCount ?? 0} model(s)?`,
+    initialValue: false
+  });
+  if (!confirmed) {
+    context.promptClient.outro("No changes made.");
+    return { exitCode: 0, stdout: "Canceled removal\n", stderr: "" };
+  }
+  await context.promptClient.withSpinner(`Removing ${vendorName}`, async () => {
+    await context.vendorService.removeVendor(vendorName);
+  });
+  context.promptClient.outro(`${vendorName} removed.`);
+  return {
+    exitCode: 0,
+    stdout: `Removed vendor ${vendorName}
+`,
+    stderr: ""
+  };
+}
+async function runInteractiveAddKey(context) {
+  context.promptClient.intro("Add or switch key");
+  const vendorName = await selectVendor(context, "Choose a vendor");
+  const modelType = await selectModelForKeys(context, vendorName);
+  const keyAlias = await context.promptClient.text({
+    message: `Remark for ${vendorName}/${modelType}`,
+    placeholder: "project-a"
+  });
+  const apiKey = await context.promptClient.password({
+    message: `API key for ${vendorName}/${modelType}`,
+    placeholder: "sk-..."
+  });
+  await context.promptClient.withSpinner(`Saving key ${keyAlias}`, async () => {
+    await context.modelService.addKey({ vendorName, modelType, keyAlias, apiKey });
+    await context.modelService.useKey(vendorName, modelType, keyAlias);
+  });
+  context.promptClient.outro(`Active key for ${vendorName}/${modelType}: ${keyAlias}`);
+  return {
+    exitCode: 0,
+    stdout: `Added key ${keyAlias} for ${vendorName}/${modelType}
+`,
+    stderr: ""
+  };
+}
+async function runInteractiveSwitchKey(context) {
+  context.promptClient.intro("Switch key");
+  const vendorName = await selectVendor(context, "Choose a vendor");
+  const models = await context.modelService.listModels(vendorName);
+  if (models.length === 0) {
+    return { exitCode: 1, stdout: "", stderr: `No models configured for ${vendorName}
+` };
+  }
+  const modelType = asSupportedModelType(
+    await context.promptClient.select({
+      message: `Choose a model for ${vendorName}`,
+      options: models.map((model) => ({
+        value: model.modelType,
+        label: model.modelType,
+        hint: model.activeKeyAlias ? `active:${model.activeKeyAlias}` : `${model.keyCount} key(s)`
+      }))
+    })
+  );
+  const keys = await context.modelService.listKeys(vendorName, modelType);
+  if (keys.length === 0) {
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: `No keys configured for ${vendorName}/${modelType}
+`
+    };
+  }
+  const keyAlias = await context.promptClient.select({
+    message: `Choose the active key for ${vendorName}/${modelType}`,
+    options: keys.map((key) => ({
+      value: key.keyAlias,
+      label: key.keyAlias,
+      hint: key.isActive ? "active" : "saved key"
+    }))
+  });
+  await context.promptClient.withSpinner(`Switching to ${keyAlias}`, async () => {
+    await context.modelService.useKey(vendorName, modelType, keyAlias);
+  });
+  context.promptClient.outro(`Active key for ${vendorName}/${modelType}: ${keyAlias}`);
+  return {
+    exitCode: 0,
+    stdout: `Using key ${keyAlias} for ${vendorName}/${modelType}
+`,
+    stderr: ""
+  };
+}
+async function runInteractiveRemoveKey(context) {
+  context.promptClient.intro("Remove key");
+  const vendorName = await selectVendor(context, "Choose a vendor");
+  const models = await context.modelService.listModels(vendorName);
+  if (models.length === 0) {
+    return { exitCode: 1, stdout: "", stderr: `No models configured for ${vendorName}
+` };
+  }
+  const modelType = asSupportedModelType(
+    await context.promptClient.select({
+      message: `Choose a model for ${vendorName}`,
+      options: models.map((model) => ({
+        value: model.modelType,
+        label: model.modelType,
+        hint: `${model.keyCount} key(s)`
+      }))
+    })
+  );
+  const keys = await context.modelService.listKeys(vendorName, modelType);
+  if (keys.length === 0) {
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: `No keys configured for ${vendorName}/${modelType}
+`
+    };
+  }
+  const keyAlias = await context.promptClient.select({
+    message: `Choose a key to remove from ${vendorName}/${modelType}`,
+    options: keys.map((key) => ({
+      value: key.keyAlias,
+      label: key.keyAlias,
+      hint: key.isActive ? "active" : "saved key"
+    }))
+  });
+  const confirmed = await context.promptClient.confirm({
+    message: `Remove key ${keyAlias} from ${vendorName}/${modelType}?`,
+    initialValue: false
+  });
+  if (!confirmed) {
+    context.promptClient.outro("No changes made.");
+    return { exitCode: 0, stdout: "Canceled removal\n", stderr: "" };
+  }
+  await context.promptClient.withSpinner(`Removing ${keyAlias}`, async () => {
+    await context.modelService.removeKey(vendorName, modelType, keyAlias);
+  });
+  context.promptClient.outro(`Removed ${keyAlias} from ${vendorName}/${modelType}.`);
+  return {
+    exitCode: 0,
+    stdout: `Removed key ${keyAlias} from ${vendorName}/${modelType}
+`,
+    stderr: ""
+  };
+}
+async function executeCli(args, options = {}) {
+  const homeDir = options.homeDir ?? process.env.OPENCODE_SWITCH_HOME ?? os.homedir();
+  const context = createCliContext(homeDir, options.promptClient ?? createPromptClient());
+  try {
+    const [resource, action, ...rest] = args;
+    if (resource === "ls") {
+      const vendors = await context.vendorService.listVendors();
+      const switchConfig = await context.switchRepository.read();
+      return {
+        exitCode: 0,
+        stdout: `${formatVendorDashboard({ activeVendor: switchConfig.activeVendor, vendors })}
+`,
+        stderr: ""
+      };
+    }
+    if (resource === "add") {
+      const name = action;
+      const url = rest[0];
+      if (!name || !url) {
+        throw new Error("Usage: add <name> <url>");
+      }
+      const opencodeConfig = await context.opencodeRepository.read();
+      const templateOptions = stripSensitiveTemplateOptions(opencodeConfig.provider.duck?.options);
+      await context.vendorService.addVendor({
+        vendorName: name,
+        npm: DEFAULT_VENDOR_NPM,
+        baseURL: url,
+        ...templateOptions ? { templateOptions } : {}
+      });
+      return {
+        exitCode: 0,
+        stdout: `Added vendor ${name}
+`,
+        stderr: ""
+      };
+    }
+    if (resource === "rm") {
+      return runInteractiveRemoveVendor(context);
+    }
+    if (resource === "addk") {
+      return runInteractiveAddKey(context);
+    }
+    if (resource === "switch") {
+      return runInteractiveSwitchKey(context);
+    }
+    if (resource === "rmk") {
+      return runInteractiveRemoveKey(context);
+    }
+    if (resource === "vendor" && action === "add") {
+      const [vendorName, ...flagArgs] = rest;
+      if (!vendorName) {
+        throw new Error("Missing vendor name");
+      }
+      const flags = parseFlags(flagArgs);
+      if (!flags.npm) {
+        throw new Error("Missing required flag: --npm");
+      }
+      await context.vendorService.addVendor({
+        vendorName,
+        npm: flags.npm,
+        ...flags["base-url"] ? { baseURL: flags["base-url"] } : {},
+        ...flags["api-key"] ? { apiKey: flags["api-key"] } : {}
+      });
+      return {
+        exitCode: 0,
+        stdout: `Added vendor ${vendorName}
+`,
+        stderr: ""
+      };
+    }
+    if (resource === "vendor" && action === "list") {
+      const vendors = await context.vendorService.listVendors();
+      const lines = vendors.map((vendor) => `${vendor.vendorName} (${vendor.modelCount})`);
+      return {
+        exitCode: 0,
+        stdout: formatList(lines),
+        stderr: ""
+      };
+    }
+    if (resource === "vendor" && action === "use") {
+      const [vendorName] = rest;
+      if (!vendorName) {
+        throw new Error("Missing vendor name");
+      }
+      await context.vendorService.useVendor(vendorName);
+      return {
+        exitCode: 0,
+        stdout: `Using vendor ${vendorName}
+`,
+        stderr: ""
+      };
+    }
+    if (resource === "vendor" && action === "remove") {
+      const [vendorName] = rest;
+      if (!vendorName) {
+        throw new Error("Missing vendor name");
+      }
+      await context.vendorService.removeVendor(vendorName);
+      return {
+        exitCode: 0,
+        stdout: `Removed vendor ${vendorName}
+`,
+        stderr: ""
+      };
+    }
+    if (resource === "model" && action === "add") {
+      const [vendorName, modelType, ...flagArgs] = rest;
+      if (!vendorName || !modelType) {
+        throw new Error("Missing vendor name or model type");
+      }
+      const flags = parseFlags(flagArgs);
+      if (!flags.model) {
+        throw new Error("Missing required flag: --model");
+      }
+      await context.modelService.addModel({
+        vendorName,
+        modelType: asSupportedModelType(modelType),
+        realModel: flags.model,
+        ...flags["api-key"] ? { apiKey: flags["api-key"] } : {},
+        ...flags["base-url"] ? { baseURL: flags["base-url"] } : {}
+      });
+      return {
+        exitCode: 0,
+        stdout: `Added model ${modelType} for ${vendorName}
+`,
+        stderr: ""
+      };
+    }
+    if (resource === "model" && action === "list") {
+      const [vendorName] = rest;
+      if (!vendorName) {
+        throw new Error("Missing vendor name");
+      }
+      const models = await context.modelService.listModels(vendorName);
+      const lines = models.map(
+        (model) => model.activeKeyAlias ? `${model.modelType} -> ${model.realModel} (key: ${model.activeKeyAlias})` : `${model.modelType} -> ${model.realModel}`
+      );
+      return {
+        exitCode: 0,
+        stdout: formatList(lines),
+        stderr: ""
+      };
+    }
+    if (resource === "model" && action === "remove") {
+      const [vendorName, modelType] = rest;
+      if (!vendorName || !modelType) {
+        throw new Error("Missing vendor name or model type");
+      }
+      await context.modelService.removeModel(vendorName, asSupportedModelType(modelType));
+      return {
+        exitCode: 0,
+        stdout: `Removed model ${modelType} from ${vendorName}
+`,
+        stderr: ""
+      };
+    }
+    if (resource === "key" && action === "add") {
+      const [vendorName, modelType, keyAlias, ...flagArgs] = rest;
+      if (!vendorName || !modelType || !keyAlias) {
+        throw new Error("Missing vendor name, model type, or key alias");
+      }
+      const flags = parseFlags(flagArgs);
+      if (!flags["api-key"]) {
+        throw new Error("Missing required flag: --api-key");
+      }
+      await context.modelService.addKey({
+        vendorName,
+        modelType: asSupportedModelType(modelType),
+        keyAlias,
+        apiKey: flags["api-key"],
+        ...flags["base-url"] ? { baseURL: flags["base-url"] } : {}
+      });
+      return {
+        exitCode: 0,
+        stdout: `Added key ${keyAlias} for ${vendorName}/${modelType}
+`,
+        stderr: ""
+      };
+    }
+    if (resource === "key" && action === "list") {
+      const [vendorName, modelType] = rest;
+      if (!vendorName || !modelType) {
+        throw new Error("Missing vendor name or model type");
+      }
+      const keys = await context.modelService.listKeys(vendorName, asSupportedModelType(modelType));
+      const lines = keys.map((key) => key.isActive ? `${key.keyAlias} (active)` : key.keyAlias);
+      return {
+        exitCode: 0,
+        stdout: formatList(lines),
+        stderr: ""
+      };
+    }
+    if (resource === "key" && action === "use") {
+      const [vendorName, modelType, keyAlias] = rest;
+      if (!vendorName || !modelType || !keyAlias) {
+        throw new Error("Missing vendor name, model type, or key alias");
+      }
+      await context.modelService.useKey(vendorName, asSupportedModelType(modelType), keyAlias);
+      return {
+        exitCode: 0,
+        stdout: `Using key ${keyAlias} for ${vendorName}/${modelType}
+`,
+        stderr: ""
+      };
+    }
+    if (resource === "key" && action === "remove") {
+      const [vendorName, modelType, keyAlias] = rest;
+      if (!vendorName || !modelType || !keyAlias) {
+        throw new Error("Missing vendor name, model type, or key alias");
+      }
+      await context.modelService.removeKey(vendorName, asSupportedModelType(modelType), keyAlias);
+      return {
+        exitCode: 0,
+        stdout: `Removed key ${keyAlias} from ${vendorName}/${modelType}
+`,
+        stderr: ""
+      };
+    }
+    throw new Error("Unknown command");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: `${message}
+`
+    };
+  }
+}
+async function runCli(args, options = {}) {
+  const result = await executeCli(args, options);
+  const stdout = options.stdout ?? process.stdout;
+  const stderr = options.stderr ?? process.stderr;
+  if (result.stdout) {
+    stdout.write(result.stdout);
+  }
+  if (result.stderr) {
+    stderr.write(result.stderr);
+  }
+  return result.exitCode;
+}
+
+// src/bin.ts
+async function main() {
+  const exitCode = await runCli(process.argv.slice(2));
+  process.exitCode = exitCode;
+}
+void main();
+//# sourceMappingURL=bin.mjs.map