@hieplp/pi-account-switcher 0.2.0

package/src/utils/common.ts

@@ -0,0 +1,74 @@
+import { exec, execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
+
+export const commonUtil = {
+  unique: (values: string[]): string[] => {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+  },
+
+  isLikelyEnvKey: (value: string): boolean => {
+    return /^[A-Z][A-Z0-9_]*$/.test(value);
+  },
+
+  omitUndefined: <T extends Record<string, unknown>>(value: T): T => {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined)) as T;
+  },
+
+  parseCsv: (value: string): string[] => {
+    return [
+      ...new Set(
+        value
+          .split(",")
+          .map((p) => p.trim())
+          .filter(Boolean),
+      ),
+    ];
+  },
+
+  blankToUndefined: (value: string | undefined): string | undefined => {
+    const trimmed = value?.trim();
+    return trimmed || undefined;
+  },
+
+  parseJsonArray: (value: string | undefined, field: string): unknown[] | undefined => {
+    const trimmed = value?.trim();
+    if (!trimmed) return undefined;
+    const parsed = JSON.parse(trimmed) as unknown;
+    if (!Array.isArray(parsed)) throw new Error(`${field} must be a JSON array`);
+    return parsed;
+  },
+
+  parseJsonRecord: (value: string | undefined, field: string): Record<string, unknown> | undefined => {
+    const trimmed = value?.trim();
+    if (!trimmed) return undefined;
+    const parsed = JSON.parse(trimmed) as unknown;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      throw new Error(`${field} must be a JSON object`);
+    return parsed as Record<string, unknown>;
+  },
+
+  slugify: (value: string): string => {
+    return value
+      .toLowerCase()
+      .trim()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-+|-+$/g, "");
+  },
+
+  runCommand: async (command: string): Promise<string> => {
+    const { stdout } = await execAsync(command, { timeout: 15_000, maxBuffer: 1024 * 1024, env: process.env });
+    return stdout.trim();
+  },
+
+  runOpRead: async (reference: string): Promise<string> => {
+    const { stdout } = await execFileAsync("op", ["read", reference], {
+      timeout: 15_000,
+      maxBuffer: 1024 * 1024,
+      env: process.env,
+    });
+    return stdout.trim();
+  },
+};

package/src/utils/errors.ts

@@ -0,0 +1,16 @@
+import z from "zod";
+
+export const errorUtil = {
+  format: (error: unknown): string => {
+    if (error instanceof z.ZodError) {
+      return error.issues
+        .map((issue) => `${errorUtil.formatPath(issue.path)}: ${issue.message}`)
+        .join("; ");
+    }
+    return error instanceof Error ? error.message : String(error);
+  },
+
+  formatPath: (path: PropertyKey[]): string => {
+    return path.length > 0 ? path.join(".") : "root";
+  },
+};

package/src/utils/files.ts

@@ -0,0 +1,25 @@
+import { chmod, mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+export const fileUtil = {
+  isMissingFileError: (error: unknown): boolean => {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+  },
+
+  expandHome: (path: string): string => {
+    if (path === "~" || path.startsWith("~/")) {
+      const home = process.env.HOME;
+      if (!home) throw new Error("HOME environment variable is not set");
+      return path === "~" ? home : `${home}${path.slice(1)}`;
+    }
+    return path;
+  },
+
+  writePrivateJson: async (path: string, value: unknown): Promise<void> => {
+    const dir = dirname(path);
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    await chmod(dir, 0o700);
+    await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    await chmod(path, 0o600);
+  },
+};

package/src/utils/filterable-selector.ts

@@ -0,0 +1,114 @@
+import { DynamicBorder } from "@mariozechner/pi-coding-agent";
+import { Container, fuzzyFilter, getKeybindings, Input, Spacer, Text, type Focusable } from "@mariozechner/pi-tui";
+import type { ThemeColor } from "@mariozechner/pi-coding-agent";
+
+type Theme = { fg: (color: ThemeColor, text: string) => string; bold: (text: string) => string };
+
+export class FilterableExtensionSelectorComponent extends Container implements Focusable {
+  private readonly searchInput: Input;
+  private readonly listContainer: Container;
+  private readonly theme: Theme;
+  private allOptions: string[];
+  private filteredOptions: string[];
+  private selectedIndex = 0;
+
+  _focused = false;
+  get focused() {
+    return this._focused;
+  }
+  set focused(value: boolean) {
+    this._focused = value;
+    this.searchInput.focused = value;
+  }
+
+  constructor(
+    title: string,
+    options: string[],
+    private readonly onDone: (selected: string | undefined) => void,
+    theme: Theme,
+  ) {
+    super();
+    this.theme = theme;
+    this.allOptions = options;
+    this.filteredOptions = options;
+
+    const borderColor = (str: string) => theme.fg("border", str);
+    this.addChild(new DynamicBorder(borderColor));
+    this.addChild(new Spacer(1));
+    this.addChild(new Text(theme.fg("accent", theme.bold(title)), 1, 0));
+    this.addChild(new Spacer(1));
+
+    this.searchInput = new Input();
+    this.searchInput.onSubmit = () => this.confirm();
+    this.addChild(this.searchInput);
+    this.addChild(new Spacer(1));
+
+    this.listContainer = new Container();
+    this.addChild(this.listContainer);
+    this.addChild(new Spacer(1));
+
+    const hint = (key: string, desc: string) => theme.fg("dim", key) + theme.fg("muted", ` ${desc}`);
+    this.addChild(
+      new Text(hint("↑↓", "navigate") + "  " + hint("Enter", "select") + "  " + hint("Esc", "cancel"), 1, 0),
+    );
+    this.addChild(new Spacer(1));
+    this.addChild(new DynamicBorder(borderColor));
+
+    this.updateList();
+  }
+
+  handleInput(keyData: string) {
+    const kb = getKeybindings();
+    if (kb.matches(keyData, "tui.select.up")) {
+      if (this.filteredOptions.length === 0) return;
+      this.selectedIndex = this.selectedIndex === 0 ? this.filteredOptions.length - 1 : this.selectedIndex - 1;
+      this.updateList();
+    } else if (kb.matches(keyData, "tui.select.down")) {
+      if (this.filteredOptions.length === 0) return;
+      this.selectedIndex = this.selectedIndex === this.filteredOptions.length - 1 ? 0 : this.selectedIndex + 1;
+      this.updateList();
+    } else if (kb.matches(keyData, "tui.select.confirm")) {
+      this.confirm();
+    } else if (kb.matches(keyData, "tui.select.cancel")) {
+      this.onDone(undefined);
+    } else {
+      this.searchInput.handleInput(keyData);
+      this.applyFilter(this.searchInput.getValue());
+    }
+  }
+
+  private confirm() {
+    const option = this.filteredOptions[this.selectedIndex];
+    if (option) this.onDone(option);
+  }
+
+  private applyFilter(query: string) {
+    this.filteredOptions = query ? fuzzyFilter(this.allOptions, query, (o) => o) : this.allOptions;
+    this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.filteredOptions.length - 1));
+    this.updateList();
+  }
+
+  private updateList() {
+    this.listContainer.clear();
+    const maxVisible = 12;
+    const total = this.filteredOptions.length;
+    const start = Math.max(0, Math.min(this.selectedIndex - Math.floor(maxVisible / 2), total - maxVisible));
+    const end = Math.min(start + maxVisible, total);
+
+    for (let i = start; i < end; i++) {
+      const isSelected = i === this.selectedIndex;
+      const line = isSelected
+        ? this.theme.fg("accent", `→ ${this.filteredOptions[i]}`)
+        : `  ${this.filteredOptions[i]}`;
+      this.listContainer.addChild(new Text(line, 0, 0));
+    }
+
+    if (start > 0 || end < total) {
+      this.listContainer.addChild(new Text(this.theme.fg("muted", `  (${this.selectedIndex + 1}/${total})`), 0, 0));
+    }
+
+    if (total === 0) {
+      this.listContainer.addChild(new Text(this.theme.fg("muted", "  No matches"), 0, 0));
+    }
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1,7 @@
+export * from "./files";
+export * from "./errors";
+export * from "./common";
+export * from "./models";
+export * from "./providers";
+export * from "./ui";
+export * from "./accounts";

package/src/utils/models.ts

@@ -0,0 +1,76 @@
+import type { Api, Model } from "@mariozechner/pi-ai";
+import type { AccountConfig, AccountSwitcherContext, ProviderConfig } from "@/types";
+import { providerUtil } from "./providers";
+import { uiUtil } from "./ui";
+
+type ProviderModel = Model<Api>;
+
+export const modelUtil = {
+  pickModel: async (
+    ctx: AccountSwitcherContext,
+    account: AccountConfig,
+    providers: ProviderConfig[],
+  ): Promise<ProviderModel | undefined> => {
+    const accountProvider = normalizeProvider(account.piAuth?.provider ?? account.provider, providers);
+    const candidates = getProviderModels(ctx, providers, accountProvider);
+
+    if (candidates.length === 0) {
+      ctx.ui.notify(`Account switched, but no ${accountProvider} models found. Use /model to select one.`, "warning");
+      return undefined;
+    }
+
+    return (
+      resolveConfiguredModel(account, candidates, ctx, accountProvider) ??
+      promptForModel(ctx, candidates, accountProvider)
+    );
+  },
+};
+
+function normalizeProvider(provider: string, providers: ProviderConfig[]): string {
+  return providerUtil.normalizeProviderWithCustom(provider, providers);
+}
+
+function getProviderModels(
+  ctx: AccountSwitcherContext,
+  providers: ProviderConfig[],
+  accountProvider: string,
+): ProviderModel[] {
+  const seen = new Set<string>();
+  const result: ProviderModel[] = [];
+
+  // getAvailable() first so preferred models appear before fallbacks from getAll()
+  for (const m of [...ctx.modelRegistry.getAvailable(), ...ctx.modelRegistry.getAll()]) {
+    const key = `${m.provider}/${m.id}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    if (normalizeProvider(m.provider, providers) === accountProvider) result.push(m);
+  }
+
+  return result;
+}
+
+function resolveConfiguredModel(
+  account: AccountConfig,
+  candidates: ProviderModel[],
+  ctx: AccountSwitcherContext,
+  accountProvider: string,
+): ProviderModel | undefined {
+  if (account.model) {
+    return ctx.modelRegistry.find(accountProvider, account.model) ?? candidates.find((m) => m.id === account.model);
+  }
+  if (candidates.length === 1) return candidates[0];
+  return undefined;
+}
+
+async function promptForModel(
+  ctx: AccountSwitcherContext,
+  candidates: ProviderModel[],
+  accountProvider: string,
+): Promise<ProviderModel | undefined> {
+  const selectedId = await uiUtil.filteredSelect(
+    ctx.ui,
+    `Select model (${accountProvider})`,
+    candidates.map((m) => m.id),
+  );
+  return candidates.find((m) => m.id === selectedId);
+}

package/src/utils/providers.ts

@@ -0,0 +1,49 @@
+import type { ProviderConfig } from "@/types";
+import { BUILT_IN_PROVIDER_IDS, PROVIDER_ALIASES, PROVIDER_ENV_KEYS } from "@/constants";
+
+export const providerUtil = {
+  normalizeProvider: (value: string): string => {
+    const p = value.toLowerCase().trim().replace(/\s+/g, "-");
+    return PROVIDER_ALIASES[p] ?? p;
+  },
+
+  normalizeProviderWithCustom: (provider: string, customProviders: ProviderConfig[] = []): string => {
+    const normalized = providerUtil.normalizeProvider(provider);
+    const custom = customProviders.find((candidate) => {
+      const names = [candidate.id, ...(candidate.aliases ?? [])].map(providerUtil.normalizeProvider);
+      return names.includes(normalized);
+    });
+    return custom ? providerUtil.normalizeProvider(custom.id) : normalized;
+  },
+
+  isBuiltInProviderId: (provider: string): boolean => {
+    return BUILT_IN_PROVIDER_IDS.includes(
+      providerUtil.normalizeProvider(provider) as (typeof BUILT_IN_PROVIDER_IDS)[number],
+    );
+  },
+
+  providerChoices: (customProviders: ProviderConfig[] = []): string[] => {
+    const customIds = customProviders.map((p) => providerUtil.normalizeProvider(p.id)).sort();
+    return [...BUILT_IN_PROVIDER_IDS, ...customIds, "custom"];
+  },
+
+  hasProvider: (provider: string, providers: ProviderConfig[]): boolean => {
+    return providers.some(
+      (c) =>
+        providerUtil.normalizeProvider(c.id) === provider ||
+        (c.aliases ?? []).map(providerUtil.normalizeProvider).includes(provider),
+    );
+  },
+
+  findProvider: (provider: string, providers: ProviderConfig[]): ProviderConfig | undefined => {
+    const normalized = providerUtil.normalizeProviderWithCustom(provider, providers);
+    return providers.find((c) => providerUtil.normalizeProvider(c.id) === normalized);
+  },
+
+  requiredEnvKeysForProvider: (provider: string, customProviders: ProviderConfig[] = []): string[] => {
+    const custom = providerUtil.findProvider(provider, customProviders);
+    return (
+      custom?.envKeys ?? PROVIDER_ENV_KEYS[providerUtil.normalizeProviderWithCustom(provider, customProviders)] ?? []
+    );
+  },
+};

package/src/utils/ui.ts

@@ -0,0 +1,49 @@
+import type { ExtensionUIContext } from "@mariozechner/pi-coding-agent";
+import { commonUtil } from "./common.js";
+import { FilterableExtensionSelectorComponent } from "./filterable-selector.js";
+
+function deduplicateLabels(labels: string[]): string[] {
+  const seen = new Map<string, number>();
+  return labels.map((label) => {
+    const n = (seen.get(label) ?? 0) + 1;
+    seen.set(label, n);
+    return n > 1 ? `${label} (${n})` : label;
+  });
+}
+
+export const uiUtil = {
+  /** Returns a prompt builder for a single input, parsed as text, CSV, JSON array, or JSON record. */
+  prompt: (ui: ExtensionUIContext) => (title: string, hint?: string) => ({
+    asText: async () => commonUtil.blankToUndefined(await ui.input(title, hint)),
+    asCsv: async () => commonUtil.parseCsv((await ui.input(title, hint)) ?? ""),
+    asJsonArray: async (field: string) => commonUtil.parseJsonArray(await ui.input(title, hint), field),
+    asJsonRecord: async (field: string) => commonUtil.parseJsonRecord(await ui.input(title, hint), field),
+  }),
+
+  setAccountStatus: (ui: ExtensionUIContext, label: string | undefined): void => {
+    ui.setStatus("account", label ? `👤 ${label}` : undefined);
+  },
+
+  /** Like filteredSelect but skips items where the corresponding value is null (used for group headers). */
+  filteredGroupedSelect: async <T>(
+    ui: ExtensionUIContext,
+    title: string,
+    labels: string[],
+    values: Array<T | null>,
+  ): Promise<T | undefined> => {
+    const deduped = deduplicateLabels(labels);
+    while (true) {
+      const selected = await uiUtil.filteredSelect(ui, title, deduped);
+      if (selected === undefined) return undefined;
+      const value = values[deduped.indexOf(selected)];
+      if (value !== null) return value;
+    }
+  },
+
+  /** Show a selector using the custom filterable component. */
+  filteredSelect: (ui: ExtensionUIContext, title: string, options: string[]): Promise<string | undefined> => {
+    return ui.custom<string | undefined>(
+      (_tui, theme, _keybindings, done) => new FilterableExtensionSelectorComponent(title, options, done, theme),
+    );
+  },
+};