@hieplp/pi-account-switcher 0.2.3 → 0.3.0

package/src/commands/accounts/subagent.ts

@@ -0,0 +1,50 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import type { AccountSwitcherContext } from "@/types";
+import { errorUtil } from "@/utils";
+import { AccountCommand } from "./shared";
+
+export const useSubagentAccountCommand = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
+  new SubagentAccountCommand(pi, runtime).register();
+};
+
+class SubagentAccountCommand extends AccountCommand {
+  constructor(pi: ExtensionAPI, runtime: AccountSwitcher) {
+    super(pi, runtime, {
+      name: "accounts:subagent",
+      description: "Set the account to use for the next spawned subagent (one-shot or persistent)",
+    });
+  }
+
+  async handler(ctx: AccountSwitcherContext, args?: string): Promise<void> {
+    try {
+      await this.runtime.load();
+      const accounts = this.runtime.getAccounts();
+
+      if (accounts.length === 0) {
+        ctx.ui.notify("No accounts configured.", "info");
+        return;
+      }
+
+      // Interactive: pick an account
+      const account = await this.pickGroupedAccount(ctx, accounts, "Account for subagent");
+      if (!account) return;
+
+      // Ask about oneshot (default: yes)
+      const oneshot = await ctx.ui.confirm(
+        "Apply to next subagent only?",
+        "Yes = one-shot (next subagent only). No = persistent (all subagents until changed).",
+      );
+
+      const varName = oneshot !== false ? "PI_ACCOUNT_SWITCHER_NEXT_ID" : "PI_ACCOUNT_SWITCHER_ACTIVE_ID";
+      process.env[varName] = account.id;
+
+      ctx.ui.notify(
+        `Subagent account set to: ${account.label} (${oneshot !== false ? "next subagent only" : "persistent"}).`,
+        "info",
+      );
+    } catch (e) {
+      ctx.ui.notify(`Failed to set subagent account: ${errorUtil.format(e)}`, "error");
+    }
+  }
+}

package/src/commands/accounts/switch.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 { commandUtil, errorUtil, providerUtil } from "@/utils";
+import { errorUtil } from "@/utils";
 import { AccountCommand } from "./shared";
 
 export const useSwitchAccountCommand = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
@@ -14,38 +14,30 @@ class SwitchAccountCommand extends AccountCommand {
     super(pi, runtime, COMMANDS.accounts.switch);
   }
 
-  async handler(ctx: AccountSwitcherContext): Promise<void> {
+  async handler(ctx: AccountSwitcherContext, args?: string): Promise<void> {
     try {
       await this.runtime.load();
 
-      const active = this.runtime.getActiveAccount();
-      if (!active) {
-        ctx.ui.notify(
-          `No active account. Use ${commandUtil.name(COMMANDS.accounts.list.name)} to activate one first.`,
-          "info",
-        );
+      // With args: activate by ID directly (agent-facing, any provider)
+      if (args) {
+        const account = this.runtime.getAccounts().find((a) => a.id === args.trim());
+        if (!account) {
+          ctx.ui.notify(`Account not found: "${args.trim()}". Use the list_accounts tool to see available accounts.`, "error");
+          return;
+        }
+        const applied = await this.runtime.activateAccount(account, ctx);
+        ctx.ui.notify(`Switched to ${account.label} (${applied}).`, "info");
         return;
       }
 
-      const providers = this.runtime.getProviders();
-      const normalizedActive = providerUtil.normalizeProviderWithCustom(
-        active.piAuth?.provider ?? active.provider,
-        providers,
-      );
-      const peers = this.runtime
-        .getAccounts()
-        .filter(
-          (a) =>
-            providerUtil.normalizeProviderWithCustom(a.piAuth?.provider ?? a.provider, providers) ===
-              normalizedActive && a.id !== active.id,
-        );
-
-      if (peers.length === 0) {
-        ctx.ui.notify(`No other accounts for provider "${active.provider}".`, "info");
+      // Without args: interactive picker from all accounts
+      const accounts = this.runtime.getAccounts();
+      if (accounts.length === 0) {
+        ctx.ui.notify("No accounts configured. Use accounts:add to create one.", "info");
         return;
       }
 
-      const account = await this.pickGroupedAccount(ctx, peers, `Switch account (${active.provider})`);
+      const account = await this.pickGroupedAccount(ctx, accounts, "Pick account to activate");
       if (!account) return;
 
       const applied = await this.runtime.activateAccount(account, ctx);

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/dirs/dirs.ts

@@ -0,0 +1,176 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import type { AccountConfig, AccountSwitcherContext } from "@/types";
+import { COMMANDS } from "@/constants";
+import { BaseCommand } from "../base";
+import { buildGroupedItems } from "../accounts/shared/select";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import type { Dirent } from "node:fs";
+
+export const useDirsCommand = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
+  new DirsCommand(pi, runtime).register();
+};
+
+class DirsCommand extends BaseCommand {
+  constructor(pi: ExtensionAPI, runtime: AccountSwitcher) {
+    super(pi, runtime, COMMANDS.accounts.dirs);
+  }
+
+  async handler(ctx: AccountSwitcherContext): Promise<void> {
+    await this.runtime.load();
+    const accounts = this.runtime.getAccounts();
+    if (accounts.length === 0) {
+      ctx.ui.notify("No accounts configured.", "info");
+      return;
+    }
+
+    // Build entry options: auto-save if active account + CWD both exist
+    const activeAccount = this.runtime.getActiveAccount();
+    const canAutoSave = Boolean(ctx.cwd && activeAccount);
+    const entryOptions = canAutoSave
+      ? ["Auto-save current folder", "Select an account to configure"]
+      : ["Select an account to configure"];
+
+    const entry = await ctx.ui.select("Directory auto-select", entryOptions);
+    if (!entry) return;
+
+    if (entry === "Auto-save current folder") {
+      await this.autoSave(ctx, activeAccount!);
+      return;
+    }
+
+    // Manual: pick account → add/remove
+    await this.manualConfig(ctx, accounts);
+  }
+
+  private async autoSave(ctx: AccountSwitcherContext, account: AccountConfig): Promise<void> {
+    const cwd = ctx.cwd!;
+    const resolved = cwd;
+
+    // Check if already present
+    const current = this.runtime.getAccounts().find((a) => a.id === account.id) ?? account;
+    const dirs = current.dirs ?? [];
+
+    if (dirs.includes(resolved)) {
+      ctx.ui.notify(`Directory already configured for ${current.label}.`, "info");
+      return;
+    }
+
+    const updated: AccountConfig = { ...current, dirs: [...dirs, resolved] };
+    await this.runtime.editAccount(current, updated);
+    ctx.ui.notify(`Added dir: ${resolved}`, "info");
+  }
+
+  private async manualConfig(ctx: AccountSwitcherContext, accounts: AccountConfig[]): Promise<void> {
+    const account = await this.pickAccount(ctx, accounts);
+    if (!account) return;
+
+    await this.manageDirs(ctx, account);
+  }
+
+  private async pickAccount(
+    ctx: AccountSwitcherContext,
+    accounts: AccountConfig[],
+  ): Promise<AccountConfig | undefined> {
+    const items = buildGroupedItems(accounts, this.runtime.getProviders(), this.runtime.getActiveAccount()?.id);
+    const labels: string[] = [];
+    const values: Array<AccountConfig | null> = [];
+    for (const item of items) {
+      if (item.type === "header") {
+        labels.push(item.provider);
+        values.push(null);
+        continue;
+      }
+      labels.push(`  ${this.isActiveAccount(item.account) ? `${item.account.label} (active)` : item.account.label}`);
+      values.push(item.account);
+    }
+    return this.pickGrouped(ctx, "Pick account to configure dirs", labels, values);
+  }
+
+  private async manageDirs(ctx: AccountSwitcherContext, account: AccountConfig): Promise<void> {
+    const current = this.runtime.getAccounts().find((a) => a.id === account.id) ?? account;
+    const dirs = current.dirs ?? [];
+    const dirsDisplay = dirs.length > 0 ? dirs.join(", ") : "(none)";
+    ctx.ui.notify(`Account: ${current.label} | Dirs: ${dirsDisplay}`, "info");
+
+    const options = ["Add directory", "Remove directory"];
+    const action = await ctx.ui.select("Directory auto-select", options);
+    if (!action) return;
+
+    if (action === "Add directory") {
+      const picked = await this.pickDirectory(ctx, homedir());
+      if (!picked) return;
+      const resolved = picked;
+      if (dirs.includes(resolved)) {
+        ctx.ui.notify(`Directory already configured for ${current.label}.`, "info");
+        return;
+      }
+      const updated: AccountConfig = { ...current, dirs: [...dirs, resolved] };
+      await this.runtime.editAccount(current, updated);
+      ctx.ui.notify(`Added dir: ${resolved}`, "info");
+      return;
+    }
+
+    if (action === "Remove directory") {
+      if (dirs.length === 0) {
+        ctx.ui.notify("No directories configured.", "info");
+        return;
+      }
+      const selected = await ctx.ui.select("Remove directory", dirs);
+      if (!selected) return;
+
+      const updatedDirs = dirs.filter((d) => d !== selected);
+      const updated: AccountConfig = { ...current, dirs: updatedDirs.length > 0 ? updatedDirs : undefined };
+      await this.runtime.editAccount(current, updated);
+      ctx.ui.notify(`Removed dir: ${selected}`, "info");
+      return;
+    }
+  }
+
+  private async pickDirectory(ctx: AccountSwitcherContext, startPath: string): Promise<string | undefined> {
+    let currentPath = startPath;
+    while (true) {
+      const entries = this.listDirectories(currentPath);
+      const displayPath = currentPath.replace(homedir(), "~");
+
+      const options: Array<{ label: string; value: string }> = [
+        { label: "✅ Select this directory", value: "__select__" },
+        { label: "⬆  ..", value: "__up__" },
+        ...entries.map((e) => ({ label: `${e}/`, value: e })),
+      ];
+
+      const labels = options.map((o) => o.label);
+      const selected = await ctx.ui.select(`Navigate: ${displayPath}`, labels);
+      if (!selected) return undefined;
+
+      const option = options.find((o) => o.label === selected);
+      if (!option) continue;
+
+      if (option.value === "__select__") return currentPath;
+      if (option.value === "__up__") {
+        const parent = dirname(currentPath);
+        if (parent === currentPath) continue; // at root, can't go up
+        currentPath = parent;
+        continue;
+      }
+      // Navigate into subdirectory
+      currentPath = join(currentPath, option.value);
+    }
+  }
+
+  private listDirectories(dirPath: string): string[] {
+    const result: string[] = [];
+    try {
+      const entries: Dirent[] = require("fs").readdirSync(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && !entry.name.startsWith(".")) {
+          result.push(entry.name);
+        }
+      }
+    } catch {
+      /* permission denied, return what we have */
+    }
+    return result.sort((a, b) => a.localeCompare(b));
+  }
+}

package/src/commands/dirs/index.ts

@@ -0,0 +1,9 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import { useDirsCommand } from "./dirs";
+
+const useDirsCommands = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
+  useDirsCommand(pi, runtime);
+};
+
+export default useDirsCommands;

package/src/commands/index.ts

@@ -2,6 +2,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { AccountSwitcher } from "@/runtime";
 import useProviderCommands from "./providers";
 import useAccountCommands from "./accounts";
+import useDirsCommands from "./dirs";
 import useModelCommands from "./models";
 import useSystemCommands from "./system";
 
@@ -10,6 +11,7 @@ export { BaseCommand } from "./base";
 
 export function registerAllCommands(pi: ExtensionAPI, runtime: AccountSwitcher) {
   useAccountCommands(pi, runtime);
+  useDirsCommands(pi, runtime);
   useProviderCommands(pi, runtime);
   useModelCommands(pi, runtime);
   useSystemCommands(pi, runtime);

package/src/constants/commands.ts

@@ -6,7 +6,7 @@ export const COMMANDS = {
     },
     list: {
       name: "accounts:list",
-      description: "List configured accounts and activate the selected account",
+      description: "(agent tool: use list_accounts tool instead for structured output",
     },
     edit: {
       name: "accounts:edit",
@@ -29,6 +29,10 @@ export const COMMANDS = {
       description:
         "Verify secrets for one or all accounts without activating them (pass 'all'; add 'ping' to send a test request)",
     },
+    dirs: {
+      name: "accounts:dirs",
+      description: "Manage working directories for CWD-based auto-select",
+    },
   },
   providers: {
     add: {

package/src/constants/providers.ts

@@ -14,11 +14,41 @@ export const OAUTH_PROVIDER_IDS = [
   "anthropic",
   "openai-codex",
   "github-copilot",
-  "google-antigravity",
-  "custom",
 ] as const;
 
-export const BUILT_IN_PROVIDER_IDS = ["anthropic", "openai", "openai-codex", "google", "xai", "openrouter"] as const;
+export const BUILT_IN_PROVIDER_IDS = [
+  "amazon-bedrock",
+  "anthropic",
+  "azure-openai-responses",
+  "cerebras",
+  "cloudflare-ai-gateway",
+  "cloudflare-workers-ai",
+  "deepseek",
+  "fireworks",
+  "github-copilot",
+  "google",
+  "google-vertex",
+  "groq",
+  "huggingface",
+  "kimi-coding",
+  "minimax",
+  "minimax-cn",
+  "mistral",
+  "moonshotai",
+  "moonshotai-cn",
+  "openai",
+  "openai-codex",
+  "opencode",
+  "opencode-go",
+  "openrouter",
+  "vercel-ai-gateway",
+  "xai",
+  "xiaomi",
+  "xiaomi-token-plan-ams",
+  "xiaomi-token-plan-cn",
+  "xiaomi-token-plan-sgp",
+  "zai",
+] as const;
 
 export const PROVIDER_ALIASES: Record<string, string> = {
   claude: "anthropic",
@@ -27,10 +57,35 @@ export const PROVIDER_ALIASES: Record<string, string> = {
 };
 
 export const PROVIDER_ENV_KEYS: Record<string, string[]> = {
-  anthropic: ["ANTHROPIC_API_KEY"],
+  anthropic: ["ANTHROPIC_OAUTH_TOKEN", "ANTHROPIC_API_KEY"],
   openai: ["OPENAI_API_KEY"],
   "openai-codex": ["OPENAI_API_KEY"],
-  google: ["GOOGLE_API_KEY", "GEMINI_API_KEY"],
+  google: ["GEMINI_API_KEY"],
+  "google-vertex": ["GOOGLE_CLOUD_API_KEY"],
+  "azure-openai-responses": ["AZURE_OPENAI_API_KEY"],
+  deepseek: ["DEEPSEEK_API_KEY"],
+  groq: ["GROQ_API_KEY"],
+  cerebras: ["CEREBRAS_API_KEY"],
   xai: ["XAI_API_KEY"],
   openrouter: ["OPENROUTER_API_KEY"],
+  "vercel-ai-gateway": ["AI_GATEWAY_API_KEY"],
+  zai: ["ZAI_API_KEY"],
+  mistral: ["MISTRAL_API_KEY"],
+  minimax: ["MINIMAX_API_KEY"],
+  "minimax-cn": ["MINIMAX_CN_API_KEY"],
+  moonshotai: ["MOONSHOT_API_KEY"],
+  "moonshotai-cn": ["MOONSHOT_API_KEY"],
+  huggingface: ["HF_TOKEN"],
+  fireworks: ["FIREWORKS_API_KEY"],
+  opencode: ["OPENCODE_API_KEY"],
+  "opencode-go": ["OPENCODE_API_KEY"],
+  "kimi-coding": ["KIMI_API_KEY"],
+  "cloudflare-workers-ai": ["CLOUDFLARE_API_KEY"],
+  "cloudflare-ai-gateway": ["CLOUDFLARE_API_KEY"],
+  xiaomi: ["XIAOMI_API_KEY"],
+  "xiaomi-token-plan-cn": ["XIAOMI_TOKEN_PLAN_CN_API_KEY"],
+  "xiaomi-token-plan-ams": ["XIAOMI_TOKEN_PLAN_AMS_API_KEY"],
+  "xiaomi-token-plan-sgp": ["XIAOMI_TOKEN_PLAN_SGP_API_KEY"],
+  "github-copilot": ["COPILOT_GITHUB_TOKEN", "GH_TOKEN", "GITHUB_TOKEN"],
+  "amazon-bedrock": [],
 };

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/index.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { AccountSwitcherContext } from "@/types";
-import { useAccountSwitcher, type AccountSwitcher } from "./runtime";
-import { registerAllCommands } from "./commands";
+import { useAccountSwitcher, type AccountSwitcher } from "@/runtime";
+import { registerAllCommands } from "@/commands";
 
 async function accountSwitcher(pi: ExtensionAPI) {
   const runtime: AccountSwitcher = useAccountSwitcher(pi);
@@ -10,6 +10,12 @@ async function accountSwitcher(pi: ExtensionAPI) {
     await runtime.init(ctx as AccountSwitcherContext);
   });
 
+  // Re-assert account status on agent/turn lifecycle so it persists
+  // across TUI redraws, reloads, and powerline updates.
+  pi.on("agent_start", async (_, ctx) => {
+    runtime.refreshStatus(ctx as AccountSwitcherContext);
+  });
+
   pi.on("model_select", async (event, ctx) => {
     await runtime.onModelSelect(event.model.provider, ctx as AccountSwitcherContext);
   });