@hieplp/pi-account-switcher 0.2.4 → 0.3.0

package/src/services/accounts.ts

@@ -4,6 +4,7 @@ import { accountUtil, providerUtil, uiUtil } from "@/utils";
 
 export interface AccountService {
   load(): Promise<void>;
+  setSessionKey(sessionKey: string): void;
   getAccounts(): AccountConfig[];
   findAccountsByProvider(provider: string, providers: ProviderConfig[]): AccountConfig[];
   getActiveAccount(): AccountConfig | undefined;
@@ -13,6 +14,8 @@ export interface AccountService {
   activateAccount(account: AccountConfig, ctx: AccountSwitcherContext, authProvider?: string): Promise<string>;
   getActiveModelState(): { id: string; provider: string } | undefined;
   saveActiveModel(id: string, provider: string): Promise<void>;
+  setDefaultAccountId(id: string): Promise<void>;
+  getDefaultAccountId(): Promise<string | undefined>;
 }
 
 export function useAccountService(accountsPath: string, statePath?: string): AccountService {
@@ -28,18 +31,51 @@ class AccountServiceImpl implements AccountService {
   private activeAccountId: string | undefined;
   private activeModelId: string | undefined;
   private activeModelProvider: string | undefined;
+  private sessionKey: string | undefined;
 
   constructor(
     private readonly store: AccountStore,
     private readonly stateStore: StateStore,
   ) {}
 
+  setSessionKey(sessionKey: string): void {
+    this.sessionKey = sessionKey;
+  }
+
   async load(): Promise<void> {
+    // Apply config TTL to state store before loading
+    const config = await this.store.loadConfig();
+    this.stateStore.setCleanupDays(config.stateCleanupDays ?? 30);
+
     this.accounts = await this.store.load();
-    const state = await this.stateStore.load();
-    this.activeAccountId = state.activeAccountId;
-    this.activeModelId = state.activeModelId;
-    this.activeModelProvider = state.activeModelProvider;
+    const key = this.sessionKey ?? "default";
+    const state = await this.stateStore.loadSession(key);
+
+    // Session key state only — no fallback to defaultAccountId here.
+    // The full cascade (session → dirs → defaultAccountId) is in runtime.init()
+    // so dir-based matching runs before we fall back to the default.
+    if (state.activeAccountId) {
+      this.activeAccountId = state.activeAccountId;
+      this.activeModelId = state.activeModelId;
+      this.activeModelProvider = state.activeModelProvider;
+    }
+
+    // Legacy cleanup (always runs): if sessions.default still exists from
+    // old format migration, promote its account to config-level default
+    // (if not set yet) and clear the key. This is dead data — sessions
+    // should only have per-session keys once migration completes.
+    if (await this.stateStore.sessionExists("default")) {
+      const legacyDefault = await this.stateStore.loadSession("default");
+      if (legacyDefault.activeAccountId && !(await this.getDefaultAccountId())) {
+        await this.setDefaultAccountId(legacyDefault.activeAccountId);
+      }
+      await this.stateStore.deleteSession("default");
+      if (!this.activeAccountId && legacyDefault.activeAccountId) {
+        this.activeAccountId = legacyDefault.activeAccountId;
+        this.activeModelId = legacyDefault.activeModelId;
+        this.activeModelProvider = legacyDefault.activeModelProvider;
+      }
+    }
   }
 
   getAccounts(): AccountConfig[] {
@@ -100,17 +136,28 @@ class AccountServiceImpl implements AccountService {
       applied = accountUtil.applyResolvedAccountEnv(account, resolved, ctx.modelRegistry, authProvider);
     }
     this.activeAccountId = account.id;
+    // Persist active account ID for subagent (cross-process) inheritance
+    process.env.PI_ACCOUNT_SWITCHER_ACTIVE_ID = account.id;
     await this.flushState();
     uiUtil.setAccountStatus(ctx.ui, account.label);
     if (account.piAuth) return "via OAuth";
     return applied.length > 0 ? applied.join(", ") : "";
   }
 
+  async setDefaultAccountId(id: string): Promise<void> {
+    await this.store.setDefaultAccountId(id);
+  }
+
+  async getDefaultAccountId(): Promise<string | undefined> {
+    const config = await this.store.loadConfig();
+    return config.defaultAccountId;
+  }
+
   private async flushState(): Promise<void> {
-    await this.stateStore.save({
+    await this.stateStore.saveSession(this.sessionKey ?? "default", {
       activeAccountId: this.activeAccountId,
       activeModelId: this.activeModelId,
       activeModelProvider: this.activeModelProvider,
     });
   }
-}
+}

package/src/storage/accounts.ts

@@ -5,9 +5,11 @@ import { errorUtil, fileUtil } from "@/utils";
 
 export interface AccountStore {
   load(): Promise<AccountConfig[]>;
+  loadConfig(): Promise<AccountSwitcherConfig>;
   addAccount(account: AccountConfig): Promise<AccountConfig[]>;
   replaceAccount(originalId: string, account: AccountConfig): Promise<AccountConfig[]>;
   removeAccount(id: string): Promise<AccountConfig[]>;
+  setDefaultAccountId(id: string): Promise<void>;
 }
 
 export function useAccountStore(path: string) {
@@ -22,18 +24,20 @@ class AccountStoreImpl implements AccountStore {
   constructor(private readonly path: string) {}
 
   async load(): Promise<AccountConfig[]> {
+    const config = await this.loadConfig();
+    return config.accounts;
+  }
+
+  async loadConfig(): Promise<AccountSwitcherConfig> {
     try {
       const raw = await readFile(this.path, "utf8");
       const parsed = configSchema.parse(JSON.parse(raw));
-
-      const { accounts } = parsed;
-      accountValidator.assertNoDuplicateAccounts(accounts);
-      accountValidator.assertAccountsHaveCredentials(accounts);
-
-      return accounts;
+      accountValidator.assertNoDuplicateAccounts(parsed.accounts);
+      accountValidator.assertAccountsHaveCredentials(parsed.accounts);
+      return parsed;
     } catch (error) {
       if (fileUtil.isMissingFileError(error)) {
-        return [];
+        return { accounts: [] };
       }
       throw new Error(`Failed to load accounts at ${this.path}: ${errorUtil.format(error)}`);
     }
@@ -67,9 +71,23 @@ class AccountStoreImpl implements AccountStore {
   }
 
   private async save(accounts: AccountConfig[]): Promise<void> {
-    const config: AccountSwitcherConfig = { accounts };
+    const { defaultAccountId, stateCleanupDays } = await this.loadConfig();
+    const config: AccountSwitcherConfig = {
+      accounts,
+      ...(defaultAccountId ? { defaultAccountId } : {}),
+      ...(stateCleanupDays !== undefined ? { stateCleanupDays } : {}),
+    };
     await fileUtil.writePrivateJson(this.path, config);
   }
+
+  async setDefaultAccountId(id: string): Promise<void> {
+    const config = await this.loadConfig();
+    if (!config.accounts.some((a) => a.id === id)) {
+      throw new Error(`Account not found: ${id}`);
+    }
+    const updated: AccountSwitcherConfig = { ...config, defaultAccountId: id };
+    await fileUtil.writePrivateJson(this.path, updated);
+  }
 }
 
 // ===============================================================================================
@@ -106,4 +124,4 @@ const accountValidator = {
       throw new Error(`Accounts missing credentials: ${missing.sort().join(", ")}`);
     }
   },
-};
+};

package/src/storage/state.ts

@@ -3,36 +3,77 @@ import z from "zod";
 import { STATE_PATH } from "@/constants";
 import { fileUtil } from "@/utils";
 
-const appStateSchema = z.object({
+const sessionStateSchema = z.object({
   activeAccountId: z.string().optional(),
   activeModelId: z.string().optional(),
   activeModelProvider: z.string().optional(),
+  lastActive: z.string().optional(),
 });
 
-export interface AppState {
+const appStateSchema = z.preprocess(
+  (raw) => {
+    // Migrate legacy flat format: { activeAccountId, ... } → { sessions: { default: { ... } } }
+    if (
+      raw &&
+      typeof raw === "object" &&
+      !("sessions" in raw) &&
+      ("activeAccountId" in raw || "activeModelId" in raw)
+    ) {
+      return { sessions: { default: raw } };
+    }
+    return raw;
+  },
+  z.object({
+    sessions: z.record(z.string(), sessionStateSchema).default({}),
+  }),
+);
+
+export interface SessionState {
   activeAccountId?: string;
   activeModelId?: string;
   activeModelProvider?: string;
+  lastActive?: string;
+}
+
+export interface AppState {
+  sessions: Record<string, SessionState>;
 }
 
 export interface StateStore {
   load(): Promise<AppState>;
   save(state: AppState): Promise<void>;
+  loadSession(sessionKey: string): Promise<SessionState>;
+  saveSession(sessionKey: string, state: SessionState): Promise<void>;
+  deleteSession(sessionKey: string): Promise<void>;
+  sessionExists(sessionKey: string): Promise<boolean>;
+  setCleanupDays(days: number): void;
 }
 
 export function useStateStore(path = STATE_PATH): StateStore {
   return new StateStoreImpl(path);
 }
 
+// ===============================================================================================
+// State Store Implementation
+// ===============================================================================================
+
+const HARD_CAP = 500;
+
 class StateStoreImpl implements StateStore {
+  private cleanupDays = 30;
+
   constructor(private readonly path: string) {}
 
+  setCleanupDays(days: number): void {
+    this.cleanupDays = days;
+  }
+
   async load(): Promise<AppState> {
     try {
       const raw = await readFile(this.path, "utf8");
       return appStateSchema.parse(JSON.parse(raw));
     } catch (error) {
-      if (fileUtil.isMissingFileError(error)) return {};
+      if (fileUtil.isMissingFileError(error)) return { sessions: {} };
       throw error;
     }
   }
@@ -40,4 +81,81 @@ class StateStoreImpl implements StateStore {
   async save(state: AppState): Promise<void> {
     await fileUtil.writePrivateJson(this.path, state);
   }
-}
+
+  async loadSession(sessionKey: string): Promise<SessionState> {
+    const appState = await this.load();
+    return appState.sessions[sessionKey] ?? {};
+  }
+
+  async saveSession(sessionKey: string, state: SessionState): Promise<void> {
+    const appState = await this.load();
+
+    // Migration: timestamp any pre-upgrade entries so they become TTL-eligible
+    for (const [key, entry] of Object.entries(appState.sessions)) {
+      if (!entry.lastActive) {
+        appState.sessions[key] = { ...entry, lastActive: new Date().toISOString() };
+      }
+    }
+
+    // Stamp lastActive on the session being written
+    const stampedState: SessionState = { ...state, lastActive: new Date().toISOString() };
+    appState.sessions[sessionKey] = stampedState;
+
+    // Prune before saving
+    const pruned = this.pruneSessions(appState.sessions);
+    appState.sessions = pruned;
+
+    await this.save(appState);
+  }
+
+  async deleteSession(sessionKey: string): Promise<void> {
+    const appState = await this.load();
+    delete appState.sessions[sessionKey];
+    await this.save(appState);
+  }
+
+  async sessionExists(sessionKey: string): Promise<boolean> {
+    const appState = await this.load();
+    return sessionKey in appState.sessions;
+  }
+
+  /**
+   * Prune sessions in two passes:
+   * 1. TTL eviction: remove entries where lastActive exists AND entry is older than cleanupDays
+   * 2. Hard cap: if entries > 500, keep only the 500 most recent
+   *
+   * Entries without lastActive are preserved (pre-upgrade safety).
+   * Entries with invalid lastActive are treated as "recent enough" (not evicted).
+   */
+  private pruneSessions(sessions: Record<string, SessionState>): Record<string, SessionState> {
+    const entries = Object.entries(sessions);
+    const now = Date.now();
+    const ttlMs = this.cleanupDays * 86400000;
+
+    // TTL pass — keep entries that are either:
+    // - without lastActive (pre-upgrade safety)
+    // - with valid lastActive that is within TTL
+    const ttlFiltered = entries.filter(([, state]) => {
+      if (!state.lastActive) return true; // Preserve pre-upgrade entries
+      const ts = new Date(state.lastActive).getTime();
+      if (isNaN(ts)) return true; // Preserve invalid timestamps
+      return now - ts <= ttlMs;
+    });
+
+    // Hard cap pass — keep only the 500 most recent
+    if (ttlFiltered.length <= HARD_CAP) {
+      return Object.fromEntries(ttlFiltered);
+    }
+
+    // Sort by lastActive ascending (oldest first), treating undefined as 0
+    const sorted = [...ttlFiltered].sort(([, a], [, b]) => {
+      const aTs = a.lastActive ? new Date(a.lastActive).getTime() : 0;
+      const bTs = b.lastActive ? new Date(b.lastActive).getTime() : 0;
+      return aTs - bTs;
+    });
+
+    // Keep the last 500 (most recent)
+    const trimmed = sorted.slice(-HARD_CAP);
+    return Object.fromEntries(trimmed);
+  }
+}

package/src/types/accounts.ts

@@ -29,6 +29,8 @@ export interface AccountConfig {
   usesProviderApiKey?: boolean;
   /** Optional model to switch to when this account is activated. */
   model?: string;
+  /** Directories where this account should be the default (CWD-based auto-select). */
+  dirs?: string[];
   /** Captured Pi /login credentials for built-in OAuth/subscription providers. */
   piAuth?: {
     provider: ProviderId;

package/src/types/config.ts

@@ -3,4 +3,8 @@ import { AccountConfig } from "./accounts";
 export interface AccountSwitcherConfig {
   accounts: AccountConfig[];
   switchMode?: "env";
-}
+  /** Config-level fallback account when no session state or dirs match. */
+  defaultAccountId?: string;
+  /** Number of days after which inactive sessions are eligible for GC. Default: 30. */
+  stateCleanupDays?: number;
+}

package/src/utils/accounts.ts

@@ -7,6 +7,8 @@ import { providerUtil } from "./providers";
 
 export const accountUtil = {
   clearAccountEnv: async (account: AccountConfig, modelRegistry?: ModelRegistry): Promise<void> => {
+    // Clear the cross-process inheritance env var
+    delete process.env.PI_ACCOUNT_SWITCHER_ACTIVE_ID;
     const authProvider = account.piAuth?.provider ?? providerUtil.normalizeProvider(account.provider);
     if (!account.piAuth && account.env) {
       for (const envName of Object.keys(account.env)) {
@@ -88,6 +90,56 @@ export const accountUtil = {
   },
 };
 
+function normalizeDir(dir: string): string {
+  return dir.replace(/\/$/, "");
+}
+
+/**
+ * Check if an account has a specific directory.
+ * Normalizes trailing slashes before comparison.
+ */
+export function hasDir<T extends { dirs?: string[] }>(account: T, dir: string): boolean {
+  const dirs = account.dirs;
+  if (!dirs || dirs.length === 0) return false;
+  const normalized = normalizeDir(dir);
+  return dirs.some((d) => normalizeDir(d) === normalized);
+}
+
+/**
+ * Add a directory to an account.
+ * Returns a new AccountConfig with the dir added, or null if the dir already exists.
+ * Dirs are kept sorted for consistent display.
+ */
+export function addDirToAccount<T extends { id: string; label: string; provider: string; dirs?: string[] }>(
+  account: T,
+  dir: string,
+): T | null {
+  if (hasDir(account, dir)) return null;
+
+  const existing = account.dirs ?? [];
+  const newDirs = [...existing, dir].sort();
+  return { ...account, dirs: newDirs };
+}
+
+/**
+ * Remove a directory from an account.
+ * Returns a new AccountConfig with the dir removed, or null if the dir does not exist.
+ */
+export function removeDirFromAccount<T extends { id: string; label: string; provider: string; dirs?: string[] }>(
+  account: T,
+  dir: string,
+): T | null {
+  const dirs = account.dirs;
+  if (!dirs || dirs.length === 0) return null;
+
+  const normalized = normalizeDir(dir);
+  const filtered = dirs.filter((d) => normalizeDir(d) !== normalized);
+
+  if (filtered.length === dirs.length) return null;
+  if (filtered.length === 0) return { ...account, dirs: undefined };
+  return { ...account, dirs: filtered };
+}
+
 function closeCachedSessions(): void {
   // 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.

package/src/utils/common.ts

@@ -1,4 +1,5 @@
 import { exec, execFile } from "node:child_process";
+import { homedir } from "node:os";
 import { promisify } from "node:util";
 
 const execAsync = promisify(exec);
@@ -87,3 +88,29 @@ export const commonUtil = {
     return results;
   },
 };
+
+/**
+ * Find the account whose dirs contain the longest prefix of cwd.
+ * Returns the account id, or undefined if no match.
+ * On tie (same dir length on two accounts), first-in-array wins.
+ */
+export function findLongestMatchingDir<T extends { id: string; dirs?: string[] }>(
+  accounts: T[],
+  cwd: string,
+): string | undefined {
+  let bestId: string | undefined;
+  let bestLen = -1;
+  for (const account of accounts) {
+    const dirs = account.dirs;
+    if (!dirs || dirs.length === 0) continue;
+    for (const dir of dirs) {
+      const resolved = dir.startsWith("~") ? dir.replace("~", homedir()) : dir;
+      const normalized = resolved.replace(/\/+$/, "");
+      if ((cwd === normalized || cwd.startsWith(normalized + "/")) && normalized.length > bestLen) {
+        bestLen = normalized.length;
+        bestId = account.id;
+      }
+    }
+  }
+  return bestId;
+}

package/src/utils/filterable-selector.ts

@@ -1,4 +1,13 @@
-import { Container, fuzzyFilter, getKeybindings, Input, Spacer, Text, type Focusable, type Component } 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";
 
 /**

package/src/utils/providers.ts

@@ -22,9 +22,10 @@ export const providerUtil = {
     );
   },
 
-  providerChoices: (customProviders: ProviderConfig[] = []): string[] => {
+  providerChoices: (customProviders: ProviderConfig[] = [], piProviderIds: string[] = []): string[] => {
     const customIds = customProviders.map((p) => providerUtil.normalizeProvider(p.id)).sort();
-    return [...BUILT_IN_PROVIDER_IDS, ...customIds, "custom"];
+    const dynamicIds = [...new Set(piProviderIds.map(providerUtil.normalizeProvider))].sort();
+    return [...new Set([...BUILT_IN_PROVIDER_IDS, ...dynamicIds, ...customIds, "custom"])];
   },
 
   hasProvider: (provider: string, providers: ProviderConfig[]): boolean => {