@hieplp/pi-account-switcher 0.2.0

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

@@ -0,0 +1,44 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import type { AccountSwitcherContext, ProviderConfig } from "@/types";
+import { BaseCommand, type CommandMeta } from "../../base";
+import { providerUtil } from "@/utils";
+import type { ProviderModel } from "./select";
+
+export abstract class ModelCommand extends BaseCommand {
+  constructor(pi: ExtensionAPI, runtime: AccountSwitcher, meta: CommandMeta) {
+    super(pi, runtime, meta);
+  }
+
+  protected async loadProvider(ctx: AccountSwitcherContext): Promise<ProviderConfig | undefined> {
+    await this.runtime.load();
+
+    const 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());
+    if (!config) {
+      ctx.ui.notify(`"${provider}" is a built-in provider. This command only works with custom providers.`, "info");
+      return undefined;
+    }
+
+    return config;
+  }
+
+  protected getModels(ctx: AccountSwitcherContext, provider: string): ProviderModel[] {
+    const providers = this.runtime.getProviders();
+    const normalized = providerUtil.normalizeProviderWithCustom(provider, providers);
+    const seen = new Set<string>();
+    const result: ProviderModel[] = [];
+    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 (providerUtil.normalizeProviderWithCustom(m.provider, providers) === normalized) result.push(m);
+    }
+    return result;
+  }
+}

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

@@ -0,0 +1,3 @@
+export * from "./base";
+export * from "./prompts";
+export * from "./select";

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

@@ -0,0 +1,36 @@
+import type { ExtensionUIContext } from "@mariozechner/pi-coding-agent";
+import type { ProviderModelConfig } from "@/types";
+import { uiUtil } from "@/utils";
+
+export class ModelConfigBuilder {
+  private readonly prompt: ReturnType<typeof uiUtil.prompt>;
+  private config: Partial<ProviderModelConfig> = {};
+
+  constructor(readonly ui: ExtensionUIContext) {
+    this.prompt = uiUtil.prompt(ui);
+  }
+
+  async withId(): Promise<this> {
+    const raw = await this.prompt("Model id", "my-model").asText();
+    if (!raw) throw new Error("Model id is required");
+    this.config.id = raw.trim();
+    return this;
+  }
+
+  async withName(): Promise<this> {
+    this.config.name = await this.prompt("Display name (optional)", this.config.id).asText();
+    return this;
+  }
+
+  build(): ProviderModelConfig {
+    const { id } = this.config;
+    if (!id) throw new Error("Model id is required");
+    return { ...this.config, id };
+  }
+
+  async collect(): Promise<ProviderModelConfig> {
+    await this.withId();
+    await this.withName();
+    return this.build();
+  }
+}

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

@@ -0,0 +1,37 @@
+import type { Api, Model } from "@mariozechner/pi-ai";
+import type { ProviderConfig } from "@/types";
+import { providerUtil } from "@/utils";
+
+export type ProviderModel = Model<Api>;
+
+export type ModelItem = { type: "header"; provider: string } | { type: "model"; model: ProviderModel; active: boolean };
+
+export function buildGroupedModelItems(
+  models: ProviderModel[],
+  providers: ProviderConfig[],
+  activeId: string | undefined,
+): ModelItem[] {
+  const sorted = [...models].sort((a, b) => {
+    const pa = providerUtil.normalizeProviderWithCustom(a.provider, providers);
+    const pb = providerUtil.normalizeProviderWithCustom(b.provider, providers);
+    return pa.localeCompare(pb) || a.id.localeCompare(b.id);
+  });
+
+  const items: ModelItem[] = [];
+  let prevProvider: string | undefined;
+
+  for (const model of sorted) {
+    const provider = providerUtil.normalizeProviderWithCustom(model.provider, providers);
+    if (prevProvider !== provider) {
+      items.push({ type: "header", provider });
+      prevProvider = provider;
+    }
+    items.push({ type: "model", model, active: model.id === activeId });
+  }
+  return items;
+}
+
+export function formatModelItem(item: Extract<ModelItem, { type: "model" }>): string {
+  const marker = item.active ? "✓" : "·";
+  return `    ${marker} ${item.model.id}`;
+}

package/src/commands/providers/add.ts

@@ -0,0 +1,28 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import { COMMANDS } from "@/constants";
+import type { AccountSwitcherContext } from "@/types";
+import { ProviderConfigBuilder } from "./shared";
+import { BaseCommand } from "../base";
+import { errorUtil } from "@/utils";
+
+export const useAddProviderCommand = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
+  new AddProviderCommand(pi, runtime).register();
+};
+
+class AddProviderCommand extends BaseCommand {
+  constructor(pi: ExtensionAPI, runtime: AccountSwitcher) {
+    super(pi, runtime, COMMANDS.providers.add);
+  }
+
+  async handler(ctx: AccountSwitcherContext): Promise<void> {
+    try {
+      await this.runtime.load();
+      const provider = await new ProviderConfigBuilder(ctx.ui).collect();
+      await this.runtime.addProvider(provider);
+      ctx.ui.notify(`Provider "${provider.id}" added.`, "info");
+    } catch (e) {
+      ctx.ui.notify(`Failed to add provider: ${errorUtil.format(e)}`, "error");
+    }
+  }
+}

package/src/commands/providers/edit.ts

@@ -0,0 +1,29 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import { COMMANDS } from "@/constants";
+import type { AccountSwitcherContext } from "@/types";
+import { ProviderConfigBuilder, ProviderCommand } from "./shared";
+import { errorUtil } from "@/utils";
+
+export const useEditProviderCommand = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
+  new EditProviderCommand(pi, runtime).register();
+};
+
+class EditProviderCommand extends ProviderCommand {
+  constructor(pi: ExtensionAPI, runtime: AccountSwitcher) {
+    super(pi, runtime, COMMANDS.providers.edit);
+  }
+
+  async handler(ctx: AccountSwitcherContext): Promise<void> {
+    try {
+      const original = await this.loadAndSelectProvider(ctx, "Select provider to edit");
+      if (!original) return;
+
+      const updated = await new ProviderConfigBuilder(ctx.ui, original).collect();
+      await this.runtime.editProvider(original, updated);
+      ctx.ui.notify(`Provider "${updated.id}" updated.`, "info");
+    } catch (e) {
+      ctx.ui.notify(`Failed to edit provider: ${errorUtil.format(e)}`, "error");
+    }
+  }
+}

package/src/commands/providers/index.ts

@@ -0,0 +1,15 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import { useAddProviderCommand } from "./add";
+import { useEditProviderCommand } from "./edit";
+import { useListProvidersCommand } from "./list";
+import { useRemoveProviderCommand } from "./remove";
+
+const useProviderCommands = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
+  useAddProviderCommand(pi, runtime);
+  useEditProviderCommand(pi, runtime);
+  useListProvidersCommand(pi, runtime);
+  useRemoveProviderCommand(pi, runtime);
+};
+
+export default useProviderCommands;

package/src/commands/providers/list.ts

@@ -0,0 +1,38 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import { COMMANDS } from "@/constants";
+import { ProviderCommand } from "./shared";
+import type { AccountSwitcherContext, ProviderConfig } from "@/types";
+import { errorUtil } from "@/utils";
+
+export const useListProvidersCommand = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
+  new ListProvidersCommand(pi, runtime).register();
+};
+
+class ListProvidersCommand extends ProviderCommand {
+  constructor(pi: ExtensionAPI, runtime: AccountSwitcher) {
+    super(pi, runtime, COMMANDS.providers.list);
+  }
+
+  async handler(ctx: AccountSwitcherContext): Promise<void> {
+    try {
+      const providers = await this.loadProviders(ctx);
+      if (!providers) return;
+      await ctx.ui.select("Providers", providers.map((p) => this.format(p)));
+    } catch (e) {
+      ctx.ui.notify(`Failed to list providers: ${errorUtil.format(e)}`, "error");
+    }
+  }
+
+  private format(p: ProviderConfig): string {
+    const details = [
+      p.envKeys?.length ? `env: ${p.envKeys.join(", ")}` : undefined,
+      p.baseUrl && `baseUrl: ${p.baseUrl}`,
+      p.api && `api: ${p.api}`,
+      p.models && `models: ${p.models.length}`,
+    ]
+      .filter(Boolean)
+      .join("; ");
+    return `custom — ${p.label ?? p.id} (${p.id})${details ? ` ${details}` : ""}`;
+  }
+}

package/src/commands/providers/remove.ts

@@ -0,0 +1,46 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import { COMMANDS } from "@/constants";
+import type { AccountSwitcherContext } from "@/types";
+import { errorUtil, providerUtil } from "@/utils";
+import { ProviderCommand, selectProvider } from "./shared";
+
+export const useRemoveProviderCommand = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
+  new RemoveProviderCommand(pi, runtime).register();
+};
+
+class RemoveProviderCommand extends ProviderCommand {
+  constructor(pi: ExtensionAPI, runtime: AccountSwitcher) {
+    super(pi, runtime, COMMANDS.providers.remove);
+  }
+
+  async handler(ctx: AccountSwitcherContext): Promise<void> {
+    try {
+      const providers = await this.loadProviders(ctx);
+      if (!providers) return;
+
+      const accounts = this.runtime.getAccounts();
+      const removable = providers.filter(
+        (p) => !accounts.some((a) => providerUtil.normalizeProviderWithCustom(a.provider, providers) === p.id),
+      );
+      if (removable.length === 0) {
+        ctx.ui.notify("No providers to remove.", "info");
+        return;
+      }
+
+      const provider = await selectProvider(ctx.ui, "Remove provider", removable);
+      if (!provider) return;
+
+      const confirmed = await ctx.ui.confirm(
+        "Remove provider?",
+        `Remove "${provider.label ?? provider.id}" (${provider.id})?`,
+      );
+      if (!confirmed) return;
+
+      await this.runtime.removeProvider(provider);
+      ctx.ui.notify(`Removed provider "${provider.label ?? provider.id}".`, "info");
+    } catch (e) {
+      ctx.ui.notify(`Failed to remove provider: ${errorUtil.format(e)}`, "error");
+    }
+  }
+}

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

@@ -0,0 +1,30 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import type { AccountSwitcherContext, ProviderConfig } from "@/types";
+import { BaseCommand, type CommandMeta } from "../../base";
+import { selectProvider } from ".";
+
+export abstract class ProviderCommand extends BaseCommand {
+  constructor(pi: ExtensionAPI, runtime: AccountSwitcher, meta: CommandMeta) {
+    super(pi, runtime, meta);
+  }
+
+  protected async loadProviders(ctx: AccountSwitcherContext): Promise<ProviderConfig[] | undefined> {
+    await this.runtime.load();
+    const providers = this.runtime.getProviders();
+    if (providers.length === 0) {
+      ctx.ui.notify("No custom providers configured.", "info");
+      return undefined;
+    }
+    return providers;
+  }
+
+  protected async loadAndSelectProvider(
+    ctx: AccountSwitcherContext,
+    label: string,
+  ): Promise<ProviderConfig | undefined> {
+    const providers = await this.loadProviders(ctx);
+    if (!providers) return undefined;
+    return selectProvider(ctx.ui, label, providers);
+  }
+}

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

@@ -0,0 +1,3 @@
+export * from "./prompts";
+export * from "./select";
+export * from "./base";

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

@@ -0,0 +1,172 @@
+import type { ExtensionUIContext } from "@mariozechner/pi-coding-agent";
+import type { ProviderApi, ProviderConfig } from "@/types";
+import { PROVIDER_API_TYPES } from "@/constants";
+import { providerUtil, uiUtil } from "@/utils";
+
+const DEFAULTS = {
+  id: "my-provider",
+  baseUrl: "https://api.example.com/v1",
+  api: "openai-completions",
+  envKey: "PROVIDER_API_KEY",
+} as const;
+
+export class ProviderConfigBuilder {
+  private readonly prompt: ReturnType<typeof uiUtil.prompt>;
+  private readonly defaults: {
+    id: string;
+    label?: string;
+    baseUrl: string;
+    api: string;
+    apiKey?: string;
+    envKeys?: string[];
+    aliases: string[];
+    models?: ProviderConfig["models"];
+    compat?: ProviderConfig["compat"];
+    piAuthProvider?: string;
+  };
+
+  private config: Partial<ProviderConfig> = {};
+
+  constructor(
+    private readonly ui: ExtensionUIContext,
+    original?: ProviderConfig,
+  ) {
+    this.prompt = uiUtil.prompt(ui);
+    this.defaults = {
+      id: original?.id ?? DEFAULTS.id,
+      label: original?.label ?? original?.name,
+      baseUrl: original?.baseUrl ?? DEFAULTS.baseUrl,
+      api: original?.api ?? DEFAULTS.api,
+      apiKey: original?.apiKey,
+      envKeys: original?.envKeys,
+      aliases: original?.aliases ?? [],
+      models: original?.models,
+      compat: original?.compat,
+      piAuthProvider: original?.piAuthProvider,
+    };
+  }
+
+  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);
+    return this;
+  }
+
+  async withLabel(): Promise<this> {
+    const id = this.config.id ?? "";
+    this.config.label = await this.prompt("Provider label", this.defaults.label ?? id).asText();
+    return this;
+  }
+
+  async withBaseUrl(): Promise<this> {
+    this.config.baseUrl = await this.prompt(
+      "Base URL (blank for account-only provider)",
+      this.defaults.baseUrl,
+    ).asText();
+    return this;
+  }
+
+  async withApi(): Promise<this> {
+    const current = this.defaults.api ?? DEFAULTS.api;
+    const options = (PROVIDER_API_TYPES as readonly string[]).includes(current)
+      ? [...PROVIDER_API_TYPES]
+      : [current, ...PROVIDER_API_TYPES];
+    this.config.api = (await uiUtil.filteredSelect(this.ui, "Pi API type", options)) ?? current;
+    return this;
+  }
+
+  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();
+    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();
+    return this;
+  }
+
+  async withAliases(): Promise<this> {
+    this.config.aliases = (
+      await this.prompt("Aliases (comma-separated, optional)", this.defaults.aliases.join(", ")).asCsv()
+    ).map(providerUtil.normalizeProvider);
+    return this;
+  }
+
+  async withModels(): Promise<this> {
+    const rawModels = await this.prompt(
+      "Models JSON array (optional)",
+      this.defaults.models ? JSON.stringify(this.defaults.models) : "",
+    ).asJsonArray("models");
+    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"];
+    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");
+    return this;
+  }
+
+  async withPiAuthProvider(): Promise<this> {
+    const id = this.config.id ?? this.defaults.id;
+    this.config.piAuthProvider = (await this.ui.confirm(
+      "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()
+      : this.defaults.piAuthProvider;
+    return this;
+  }
+
+  build(): ProviderConfig {
+    const { id, label, envKeys, aliases, baseUrl, api, apiKey, models, compat, piAuthProvider } = this.config;
+
+    if (!id) {
+      throw new Error("Provider id is required");
+    }
+
+    const resolvedLabel = label ?? id;
+    const resolvedApi = api || (baseUrl || apiKey || models ? DEFAULTS.api : undefined);
+    return {
+      id,
+      label: resolvedLabel,
+      name: resolvedLabel,
+      envKeys: envKeys ?? [],
+      aliases: aliases ?? [],
+      ...(baseUrl && { baseUrl }),
+      ...(resolvedApi && { api: resolvedApi }),
+      ...(apiKey && { apiKey }),
+      ...(models && { models }),
+      ...(compat && { compat }),
+      ...(piAuthProvider && { piAuthProvider }),
+    };
+  }
+
+  async collect(): Promise<ProviderConfig> {
+    await this.withId();
+    await this.withLabel();
+    await this.withBaseUrl();
+    await this.withApi();
+    await this.withApiKey();
+    await this.withEnvKeys();
+    await this.withAliases();
+    await this.withModels();
+    await this.withCompat();
+    await this.withPiAuthProvider();
+    return this.build();
+  }
+}

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

@@ -0,0 +1,24 @@
+import type { ExtensionUIContext } from "@mariozechner/pi-coding-agent";
+import type { ProviderConfig } from "@/types";
+
+export async function selectProvider(
+  ui: ExtensionUIContext,
+  title: string,
+  providers: ProviderConfig[],
+): Promise<ProviderConfig | undefined> {
+  const labelCounts = new Map<string, number>();
+  for (const p of providers) {
+    labelCounts.set(p.label ?? p.id, (labelCounts.get(p.label ?? p.id) ?? 0) + 1);
+  }
+
+  const labelMap = new Map<string, ProviderConfig>();
+  for (const p of providers) {
+    const base = p.label ?? p.id;
+    const display = (labelCounts.get(base) ?? 0) > 1 ? `${base} (${p.id})` : base;
+    labelMap.set(display, p);
+  }
+
+  const choice = await ui.select(title, [...labelMap.keys()]);
+  if (!choice) return undefined;
+  return labelMap.get(choice);
+}

package/src/commands/system/index.ts

@@ -0,0 +1,7 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import { useResetCommand } from "./reset";
+
+export default function useSystemCommands(pi: ExtensionAPI, runtime: AccountSwitcher) {
+  useResetCommand(pi, runtime);
+}

package/src/commands/system/reset.ts

@@ -0,0 +1,36 @@
+import { rm } from "node:fs/promises";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import { ACCOUNTS_PATH, COMMANDS, PROVIDERS_PATH, STATE_PATH } from "@/constants";
+import type { AccountSwitcherContext } from "@/types";
+import { BaseCommand } from "../base";
+import { errorUtil, uiUtil } from "@/utils";
+
+export const useResetCommand = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
+  new ResetCommand(pi, runtime).register();
+};
+
+class ResetCommand extends BaseCommand {
+  constructor(pi: ExtensionAPI, runtime: AccountSwitcher) {
+    super(pi, runtime, COMMANDS.system.reset);
+  }
+
+  async handler(ctx: AccountSwitcherContext): Promise<void> {
+    try {
+      const confirmed = await ctx.ui.confirm(
+        "Reset all extension data?",
+        "This will permanently delete all accounts, providers, and state. This cannot be undone.",
+      );
+      if (!confirmed) return;
+
+      await Promise.all([ACCOUNTS_PATH, PROVIDERS_PATH, STATE_PATH].map((path) => rm(path, { force: true })));
+
+      await this.runtime.load();
+      uiUtil.setAccountStatus(ctx.ui, undefined);
+
+      ctx.ui.notify("Extension data reset to factory defaults.", "info");
+    } catch (e) {
+      ctx.ui.notify(`Failed to reset: ${errorUtil.format(e)}`, "error");
+    }
+  }
+}

package/src/constants/commands.ts

@@ -0,0 +1,66 @@
+export const COMMANDS = {
+  accounts: {
+    add: {
+      name: "accounts:add",
+      description: "Add a new provider account from inside Pi",
+    },
+    list: {
+      name: "accounts:list",
+      description: "List configured accounts and activate the selected account",
+    },
+    edit: {
+      name: "accounts:edit",
+      description: "Edit a configured account",
+    },
+    remove: {
+      name: "accounts:remove",
+      description: "Remove a configured account",
+    },
+    switch: {
+      name: "accounts:switch",
+      description: "Switch to another account within the current provider",
+    },
+    oauth: {
+      name: "accounts:oauth",
+      description: "Import Pi /login OAuth credentials as a switchable account",
+    },
+  },
+  providers: {
+    add: {
+      name: "providers:add",
+      description: "Add a reusable custom provider",
+    },
+    edit: {
+      name: "providers:edit",
+      description: "Edit a configured custom provider",
+    },
+    list: {
+      name: "providers:list",
+      description: "List configured custom providers",
+    },
+    remove: {
+      name: "providers:remove",
+      description: "Remove a configured custom provider",
+    },
+  },
+  models: {
+    list: {
+      name: "models:list",
+      description: "List all available models and switch to the selected one",
+    },
+    add: {
+      name: "models:add",
+      description: "Add a custom model config to the current provider",
+    },
+    remove: {
+      name: "models:remove",
+      description: "Remove a custom model config from the current provider",
+    },
+  },
+  system: {
+    reset: {
+      name: "system:reset",
+      description: "Reset all extension data (accounts, providers, state) to factory defaults",
+    },
+  },
+} as const;

package/src/constants/config.ts

@@ -0,0 +1,6 @@
+import type { AccountSwitcherConfig } from "@/types";
+
+export const DEFAULT_CONFIG: AccountSwitcherConfig = {
+  accounts: [],
+  switchMode: "env",
+};

package/src/constants/index.ts

@@ -0,0 +1,4 @@
+export * from "./commands";
+export * from "./config";
+export * from "./paths";
+export * from "./providers";

package/src/constants/paths.ts

@@ -0,0 +1,8 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const APP_DIR = join(homedir(), ".pi", "account-switcher");
+export const ACCOUNTS_PATH = join(APP_DIR, "accounts.json");
+export const PROVIDERS_PATH = join(APP_DIR, "providers.json");
+export const STATE_PATH = join(APP_DIR, "state.json");
+export const PI_AUTH_PATH = join(homedir(), ".pi", "agent", "auth.json");