@hieplp/pi-account-switcher 0.2.2 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hieplp/pi-account-switcher",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "type": "module",
   "description": "Pi extension for quickly switching between multiple accounts/API keys per provider.",
   "license": "MIT",
@@ -52,5 +52,6 @@
     "extensions": [
       "./src/extension.ts"
     ]
-  }
+  },
+  "packageManager": "pnpm@11.5.0+sha512.dbfcc4f81cf48597afd4bc391ffdf12c11f1a9fb83a395bfa6b0a2d9cc2fd8ffebafdb1ccbd529632153f793904c2615b7f09fe1a345473fd1c35845172a8eb1"
 }

package/src/commands/accounts/edit.ts

@@ -19,7 +19,7 @@ class EditAccountCommand extends AccountCommand {
       const original = await this.loadAndSelectAccount(ctx, "Select account to edit");
       if (!original) return;
 
-      const updated = await new AccountConfigBuilder(ctx.ui, this.runtime.getProviders(), original).collect();
+      const updated = await new AccountConfigBuilder(ctx.ui, this.runtime.getProviders(), original).collect(true);
       if (!updated) return;
 
       await this.runtime.editAccount(original, updated);

package/src/commands/accounts/shared/prompts.ts

@@ -37,12 +37,14 @@ export class AccountConfigBuilder {
   }
 
   async withProvider(): Promise<this> {
-    const choice = await uiUtil.filteredSelect(this.ui, "Provider", providerUtil.providerChoices(this.customProviders));
+    const choices = providerUtil.providerChoices(this.customProviders);
+    const choice = await uiUtil.filteredSelect(this.ui, "Provider", choices);
     if (!choice) return this;
 
     const raw = choice === "custom" ? await this.prompt("Custom provider", "provider-id").asText() : choice;
     const provider = providerUtil.normalizeProvider(raw ?? "");
-    if (!provider) throw new Error("Provider is required");
+    // If provider is empty (user cancelled), return early. collect() will detect missing provider and return undefined.
+    if (!provider) return this;
 
     this.config.provider = provider;
     this.customProvider = providerUtil.findProvider(provider, this.customProviders);
@@ -101,21 +103,32 @@ export class AccountConfigBuilder {
     const { provider } = this.config;
     if (!provider) return this;
 
+    const hasExistingCredentials =
+      !!this.config.env || !!this.config.providerApiKey || !!this.config.usesProviderApiKey || !!this.config.piAuth;
+
     if (this.customProvider) {
       const apiKey = await this.promptForCustomProviderApiKey(this.customProvider);
-      if (apiKey || this.customProvider.apiKey) {
-        if (apiKey) {
-          this.config.providerApiKey = apiKey;
-        } else {
+      if (apiKey) {
+        this.config.providerApiKey = apiKey;
+        return this;
+      }
+      if (!hasExistingCredentials) {
+        if (this.customProvider.apiKey) {
           this.config.usesProviderApiKey = true;
+          return this;
         }
-        return this;
+      } else {
+        // Has existing credentials — fall through to let user choose "keep current" or update
       }
     }
 
     const envKeys = providerUtil.requiredEnvKeysForProvider(provider, this.customProviders);
-    const envChoice = await this.ui.select("Credential env var", [...envKeys, "custom"]);
-    if (!envChoice) return this;
+    const envChoice = await this.ui.select("Credential env var", [
+      ...envKeys,
+      "custom",
+      ...(hasExistingCredentials ? ["keep current"] : []),
+    ]);
+    if (!envChoice || envChoice === "keep current") return this;
 
     const envName = envChoice === "custom" ? await this.prompt("Env var name", "PROVIDER_API_KEY").asText() : envChoice;
     if (!envName) throw new Error("Env var name is required");
@@ -150,7 +163,12 @@ export class AccountConfigBuilder {
     };
   }
 
-  async collect(): Promise<AccountConfig | undefined> {
+  /**
+   * Collect account configuration interactively.
+   * @param isEdit - When true, allows keeping existing credentials without re-entering them.
+   *                 Empty input for most fields will preserve the current value.
+   */
+  async collect(isEdit = false): Promise<AccountConfig | undefined> {
     await this.withProvider();
     if (!this.config.provider) return undefined;
 
@@ -159,7 +177,13 @@ export class AccountConfigBuilder {
     await this.withModel();
     await this.withCredentials();
 
-    if (!this.config.env && !this.config.providerApiKey && !this.config.usesProviderApiKey && !this.config.piAuth) {
+    if (
+      !isEdit &&
+      !this.config.env &&
+      !this.config.providerApiKey &&
+      !this.config.usesProviderApiKey &&
+      !this.config.piAuth
+    ) {
       this.ui.notify("No credentials configured. Account not saved.", "info");
       return undefined;
     }

package/src/commands/accounts/verify.ts

@@ -1,4 +1,4 @@
-import { completeSimple, type Api, type Model } from "@earendil-works/pi-ai";
+import type { Api, Model } from "@earendil-works/pi-ai";
 import type { AuthCredential, ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { AccountSwitcher } from "@/runtime";
 import type { AccountConfig, AccountSwitcherContext, ProviderConfig, SecretSource } from "@/types";
@@ -209,6 +209,7 @@ class VerifyAccountsCommand extends AccountCommand {
     try {
       ctx.ui.notify(`${prefix} ping: sending request via ${model.provider}/${model.id}...`, "info");
 
+      const { completeSimple } = await import("@earendil-works/pi-ai");
       const response = await completeSimple(
         model,
         {

package/src/commands/base.ts

@@ -73,8 +73,14 @@ export abstract class BaseCommand implements Command {
     return providerUtil.normalizeProvider(active?.provider ?? "") === provider.id;
   }
 
-  protected isActiveModel(ctx: AccountSwitcherContext, modelId: string): boolean {
-    return ctx.model?.id === modelId;
+  protected isActiveModel(ctx: AccountSwitcherContext, modelId: string, provider?: string): boolean {
+    if (ctx.model?.id !== modelId) return false;
+    if (!provider) return true;
+    const providers = this.runtime.getProviders();
+    return (
+      providerUtil.normalizeProviderWithCustom(ctx.model.provider, providers) ===
+      providerUtil.normalizeProviderWithCustom(provider, providers)
+    );
   }
 
   abstract handler(ctx: AccountSwitcherContext, args?: string): Promise<void>;

package/src/commands/models/list.ts

@@ -2,7 +2,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { AccountSwitcher } from "@/runtime";
 import type { AccountSwitcherContext } from "@/types";
 import { COMMANDS } from "@/constants";
-import { errorUtil } from "@/utils";
+import { errorUtil, providerUtil } from "@/utils";
 import { ModelCommand } from "./shared";
 
 export const useListModelsCommand = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
@@ -18,9 +18,16 @@ class ListModelsCommand extends ModelCommand {
     try {
       await this.runtime.load();
 
-      const provider = ctx.model?.provider;
+      const providers = this.runtime.getProviders();
+      const activeAccount = this.runtime.getActiveAccount();
+      const activeProvider =
+        activeAccount?.piAuth?.provider ??
+        (activeAccount
+          ? (providerUtil.findProvider(activeAccount.provider, providers)?.piAuthProvider ?? activeAccount.provider)
+          : undefined);
+      const provider = activeProvider ?? ctx.model?.provider;
       if (!provider) {
-        ctx.ui.notify("No active model.", "info");
+        ctx.ui.notify("No active account or model.", "info");
         return;
       }
 
@@ -30,8 +37,11 @@ class ListModelsCommand extends ModelCommand {
         return;
       }
 
-      const currentId = ctx.model?.id;
-      const model = await this.pick(ctx, `Models (${provider})`, models, (m) =>
+      const normalizedProvider = providerUtil.normalizeProviderWithCustom(provider, providers);
+      const currentBelongsToProvider =
+        ctx.model && providerUtil.normalizeProviderWithCustom(ctx.model.provider, providers) === normalizedProvider;
+      const currentId = currentBelongsToProvider ? ctx.model?.id : undefined;
+      const model = await this.pick(ctx, `Models (${normalizedProvider})`, models, (m) =>
         m.id === currentId ? `${m.id} ✓` : m.id,
       );
       if (!model) return;

package/src/commands/models/remove.ts

@@ -19,7 +19,7 @@ class RemoveModelCommand extends ModelCommand {
       const providerConfig = await this.loadProvider(ctx);
       if (!providerConfig) return;
 
-      const removable = (providerConfig.models ?? []).filter((m) => !this.isActiveModel(ctx, m.id));
+      const removable = (providerConfig.models ?? []).filter((m) => !this.isActiveModel(ctx, m.id, providerConfig.id));
       if (removable.length === 0) {
         ctx.ui.notify(`Provider "${providerConfig.id}" has no removable model configs.`, "info");
         return;

package/src/commands/models/shared/base.ts

@@ -13,13 +13,17 @@ export abstract class ModelCommand extends BaseCommand {
   protected async loadProvider(ctx: AccountSwitcherContext): Promise<ProviderConfig | undefined> {
     await this.runtime.load();
 
-    const provider = ctx.model?.provider;
+    // Prefer the active account's provider so that switching to an account whose
+    // provider has no models yet still targets the correct (new) provider.
+    const activeAccount = this.runtime.getActiveAccount();
+    const providers = this.runtime.getProviders();
+    const provider = activeAccount?.provider ?? ctx.model?.provider;
     if (!provider) {
       ctx.ui.notify("No active model. Use models:list to select one first.", "info");
       return undefined;
     }
 
-    const config = providerUtil.findProvider(provider, this.runtime.getProviders());
+    const config = providerUtil.findProvider(provider, providers);
     if (!config) {
       ctx.ui.notify(`"${provider}" is a built-in provider. This command only works with custom providers.`, "info");
       return undefined;

package/src/commands/providers/shared/prompts.ts

@@ -48,22 +48,22 @@ export class ProviderConfigBuilder {
 
   async withId(): Promise<this> {
     const raw = await this.prompt("Provider id", this.defaults.id).asText();
-    if (!raw) throw new Error("Provider id is required");
-    this.config.id = providerUtil.normalizeProvider(raw);
+    this.config.id = providerUtil.normalizeProvider(raw || this.defaults.id);
+    if (!this.config.id) throw new Error("Provider id is required");
     return this;
   }
 
   async withLabel(): Promise<this> {
     const id = this.config.id ?? "";
-    this.config.label = await this.prompt("Provider label", this.defaults.label ?? id).asText();
+    const hint = this.defaults.label ?? id;
+    this.config.label = (await this.prompt("Provider label", hint).asText()) ?? hint;
     return this;
   }
 
   async withBaseUrl(): Promise<this> {
-    this.config.baseUrl = await this.prompt(
-      "Base URL (blank for account-only provider)",
-      this.defaults.baseUrl,
-    ).asText();
+    this.config.baseUrl =
+      (await this.prompt("Base URL (blank for account-only provider)", this.defaults.baseUrl).asText()) ??
+      this.defaults.baseUrl;
     return this;
   }
 
@@ -78,26 +78,23 @@ export class ProviderConfigBuilder {
 
   async withApiKey(): Promise<this> {
     const id = this.config.id ?? "";
-    this.config.apiKey = await this.prompt(
-      "Pi apiKey env var/name or raw key",
-      this.defaults.apiKey ?? `${id.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_API_KEY`,
-    ).asText();
+    const hint = this.defaults.apiKey ?? `${id.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_API_KEY`;
+    this.config.apiKey =
+      (await this.prompt("Pi apiKey env var/name or raw key", hint).asText()) ?? this.defaults.apiKey;
     return this;
   }
 
   async withEnvKeys(): Promise<this> {
     const { apiKey } = this.config;
-    this.config.envKeys = await this.prompt(
-      "Env key suggestions (comma-separated)",
-      (this.defaults.envKeys ?? (apiKey ? [apiKey] : [DEFAULTS.envKey])).join(", "),
-    ).asCsv();
+    const defaultKeys = this.defaults.envKeys ?? (apiKey ? [apiKey] : [DEFAULTS.envKey]);
+    const csv = await this.prompt("Env key suggestions (comma-separated)", defaultKeys.join(", ")).asCsv();
+    this.config.envKeys = csv.length > 0 ? csv : defaultKeys;
     return this;
   }
 
   async withAliases(): Promise<this> {
-    this.config.aliases = (
-      await this.prompt("Aliases (comma-separated, optional)", this.defaults.aliases.join(", ")).asCsv()
-    ).map(providerUtil.normalizeProvider);
+    const csv = await this.prompt("Aliases (comma-separated, optional)", this.defaults.aliases.join(", ")).asCsv();
+    this.config.aliases = csv.length > 0 ? csv.map(providerUtil.normalizeProvider) : this.defaults.aliases;
     return this;
   }
 
@@ -109,15 +106,16 @@ export class ProviderConfigBuilder {
     if (rawModels?.some((item) => typeof item !== "object" || item === null || Array.isArray(item))) {
       throw new Error("models must be an array of objects");
     }
-    this.config.models = rawModels as ProviderConfig["models"];
+    this.config.models = (rawModels as ProviderConfig["models"]) ?? this.defaults.models;
     return this;
   }
 
   async withCompat(): Promise<this> {
-    this.config.compat = await this.prompt(
-      "Compat JSON object (optional)",
-      this.defaults.compat ? JSON.stringify(this.defaults.compat) : "",
-    ).asJsonRecord("compat");
+    this.config.compat =
+      (await this.prompt(
+        "Compat JSON object (optional)",
+        this.defaults.compat ? JSON.stringify(this.defaults.compat) : "",
+      ).asJsonRecord("compat")) ?? this.defaults.compat;
     return this;
   }
 
@@ -127,7 +125,8 @@ export class ProviderConfigBuilder {
       "Configure Pi OAuth provider id?",
       "Only choose yes if this provider maps to a Pi /login auth entry.",
     ))
-      ? await this.prompt("Pi auth provider id", this.defaults.piAuthProvider ?? id).asText()
+      ? ((await this.prompt("Pi auth provider id", this.defaults.piAuthProvider ?? id).asText()) ??
+        this.defaults.piAuthProvider)
       : this.defaults.piAuthProvider;
     return this;
   }

package/src/extension.ts

@@ -1,15 +1,47 @@
 import { createJiti } from "@mariozechner/jiti";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { createRequire } from "node:module";
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 
 export default async function accountSwitcherBootstrap(pi: ExtensionAPI) {
   const srcDir = dirname(fileURLToPath(import.meta.url));
-  const jiti = createJiti(import.meta.url, {
-    alias: {
-      "@": srcDir,
-    },
-  });
+
+  // Resolve @earendil-works/* from the pi loader's context so the same
+  // module instances are used (avoids duplicate singletons / instanceof mismatches).
+  const loaderRequire = createRequire(import.meta.url);
+  const resolveOrUndefined = (id: string): string | undefined => {
+    try {
+      return loaderRequire.resolve(id);
+    } catch {
+      return undefined;
+    }
+  };
+
+  const piAiEntry = resolveOrUndefined("@earendil-works/pi-ai");
+  const piCodingAgentEntry = resolveOrUndefined("@earendil-works/pi-coding-agent");
+  const piAgentCoreEntry = resolveOrUndefined("@earendil-works/pi-agent-core");
+  const piTuiEntry = resolveOrUndefined("@earendil-works/pi-tui");
+
+  const alias: Record<string, string> = { "@": srcDir };
+  if (piAiEntry) {
+    alias["@earendil-works/pi-ai"] = piAiEntry;
+    alias["@mariozechner/pi-ai"] = piAiEntry;
+  }
+  if (piCodingAgentEntry) {
+    alias["@earendil-works/pi-coding-agent"] = piCodingAgentEntry;
+    alias["@mariozechner/pi-coding-agent"] = piCodingAgentEntry;
+  }
+  if (piAgentCoreEntry) {
+    alias["@earendil-works/pi-agent-core"] = piAgentCoreEntry;
+    alias["@mariozechner/pi-agent-core"] = piAgentCoreEntry;
+  }
+  if (piTuiEntry) {
+    alias["@earendil-works/pi-tui"] = piTuiEntry;
+    alias["@mariozechner/pi-tui"] = piTuiEntry;
+  }
+
+  const jiti = createJiti(import.meta.url, { alias });
 
   const extension = await jiti.import<(pi: ExtensionAPI) => void | Promise<void>>("./index", {
     default: true,

package/src/runtime/account-switcher-runtime.ts

@@ -13,6 +13,10 @@ function resolveAuthProvider(account: AccountConfig, providers: ProviderConfig[]
   return provider?.piAuthProvider ?? providerUtil.normalizeProvider(account.provider);
 }
 
+function resolveAccountProvider(account: AccountConfig, providers: ProviderConfig[]): string {
+  return providerUtil.normalizeProviderWithCustom(resolveAuthProvider(account, providers), providers);
+}
+
 export default class AccountSwitcherRuntime implements AccountSwitcher {
   private accountService: AccountService;
   private modelService: ModelService;
@@ -49,8 +53,16 @@ export default class AccountSwitcherRuntime implements AccountSwitcher {
     // leave Pi's default model selection untouched.
     const modelState = this.accountService.getActiveModelState();
     if (modelState) {
-      const model = ctx.modelRegistry.find(modelState.provider, modelState.id);
-      if (model) await this.modelService.applyModel(model, ctx);
+      const providers = this.providerService.getProviders();
+      const activeProvider = active ? resolveAccountProvider(active, providers) : undefined;
+      const savedProvider = providerUtil.normalizeProviderWithCustom(modelState.provider, providers);
+
+      // Only restore a saved model when it belongs to the active account's provider.
+      // Otherwise Pi can start with credentials for one provider and a model from another.
+      if (!activeProvider || savedProvider === activeProvider) {
+        const model = ctx.modelRegistry.find(modelState.provider, modelState.id);
+        if (model) await this.modelService.applyModel(model, ctx);
+      }
     }
   }
 
@@ -94,10 +106,7 @@ export default class AccountSwitcherRuntime implements AccountSwitcher {
   findAccountsByProvider(provider: string): AccountConfig[] {
     const providers = this.providerService.getProviders();
     const normalized = providerUtil.normalizeProviderWithCustom(provider, providers);
-    return this.accountService.getAccounts().filter((a) => {
-      const accountProvider = providerUtil.normalizeProviderWithCustom(resolveAuthProvider(a, providers), providers);
-      return accountProvider === normalized;
-    });
+    return this.accountService.getAccounts().filter((a) => resolveAccountProvider(a, providers) === normalized);
   }
 
   getActiveAccount(): AccountConfig | undefined {
@@ -123,17 +132,14 @@ export default class AccountSwitcherRuntime implements AccountSwitcher {
 
     // piAuth accounts authenticate via a separate provider (e.g. github-copilot),
     // so use that for model lookup rather than the account's own provider field.
-    const accountProvider = providerUtil.normalizeProviderWithCustom(
-      resolveAuthProvider(account, providers),
-      providers,
-    );
+    const accountProvider = resolveAccountProvider(account, providers);
     const currentProvider = ctx.model
       ? providerUtil.normalizeProviderWithCustom(ctx.model.provider, providers)
       : undefined;
 
     // Skip model selection if the active model already belongs to the same provider.
     if (accountProvider !== currentProvider) {
-      const model = await modelUtil.pickModel(ctx, account, providers);
+      const model = await modelUtil.pickModel(ctx, account, providers, accountProvider);
       if (model) await this.applyModel(model, ctx);
     }
 

package/src/utils/accounts.ts

@@ -1,4 +1,3 @@
-import * as piAi from "@earendil-works/pi-ai";
 import { readFile } from "node:fs/promises";
 import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
 import type { AccountConfig, SecretSource } from "@/types";
@@ -90,10 +89,18 @@ export const accountUtil = {
 };
 
 function closeCachedSessions(): void {
-  const helpers = piAi as {
-    cleanupSessionResources?: () => void;
-    closeOpenAICodexWebSocketSessions?: () => void;
-  };
-  helpers.cleanupSessionResources?.();
-  helpers.closeOpenAICodexWebSocketSessions?.();
+  // Dynamic import so the module is not required at load time — @earendil-works/pi-ai
+  // is a peerDependency provided by the pi agent host, not bundled with this package.
+  import("@earendil-works/pi-ai")
+    .then((piAi) => {
+      const helpers = piAi as {
+        cleanupSessionResources?: () => void;
+        closeOpenAICodexWebSocketSessions?: () => void;
+      };
+      helpers.cleanupSessionResources?.();
+      helpers.closeOpenAICodexWebSocketSessions?.();
+    })
+    .catch(() => {
+      // pi-ai not available in this environment — skip session cleanup
+    });
 }

package/src/utils/filterable-selector.ts

@@ -1,7 +1,22 @@
-import { DynamicBorder } from "@earendil-works/pi-coding-agent";
-import { Container, fuzzyFilter, getKeybindings, Input, Spacer, Text, type Focusable } from "@earendil-works/pi-tui";
+import { Container, fuzzyFilter, getKeybindings, Input, Spacer, Text, type Focusable, type Component } from "@earendil-works/pi-tui";
 import type { ThemeColor } from "@earendil-works/pi-coding-agent";
 
+/**
+ * Local implementation of DynamicBorder to avoid a hard runtime dependency
+ * on @earendil-works/pi-coding-agent (which is a peer dep not available in
+ * the pi agent's npm node_modules at extension load time).
+ */
+class DynamicBorder implements Component {
+  private color: (str: string) => string;
+  constructor(color: (str: string) => string = (str) => str) {
+    this.color = color;
+  }
+  invalidate() {}
+  render(width: number): string[] {
+    return [this.color("─".repeat(Math.max(1, width)))];
+  }
+}
+
 type Theme = { fg: (color: ThemeColor, text: string) => string; bold: (text: string) => string };
 
 export class FilterableMultiSelectComponent extends Container implements Focusable {

package/src/utils/models.ts

@@ -10,8 +10,10 @@ export const modelUtil = {
     ctx: AccountSwitcherContext,
     account: AccountConfig,
     providers: ProviderConfig[],
+    resolvedProvider?: string,
   ): Promise<ProviderModel | undefined> => {
-    const accountProvider = normalizeProvider(account.piAuth?.provider ?? account.provider, providers);
+    const accountProvider =
+      resolvedProvider ?? normalizeProvider(account.piAuth?.provider ?? account.provider, providers);
     const candidates = getProviderModels(ctx, providers, accountProvider);
 
     if (candidates.length === 0) {