@hieplp/pi-account-switcher 0.2.0 → 0.2.1

package/README.md

@@ -85,6 +85,8 @@ After installing, reload Pi and add your first account:
 | Command | Description |
 |---|---|
 | `/system:reset` | Delete all accounts, providers, and state |
+| `/system:export` | Export all accounts, providers, and state to a JSON file |
+| `/system:import` | Import accounts, providers, and state from a JSON file |
 
 ---
 
@@ -157,6 +159,26 @@ Custom providers are stored at `~/.pi/account-switcher/providers.json` and suppo
 
 ---
 
+## Export / Import
+
+Back up or migrate your full configuration with two commands:
+
+```
+/system:export          # prompts for a path, defaults to ~/pi-account-switcher-export.json
+/system:export ~/backup.json  # export to a specific path
+```
+
+The export file contains all accounts, providers, and active-selection state as a single JSON bundle. To restore on another machine (or after a reset):
+
+```
+/system:import          # prompts for a path, defaults to ~/pi-account-switcher-export.json
+/system:import ~/backup.json  # import from a specific path
+```
+
+> **Warning:** import replaces all existing data. A confirmation prompt is shown before anything is written.
+
+---
+
 ## Config Reference
 
 ### Accounts — `~/.pi/account-switcher/accounts.json`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hieplp/pi-account-switcher",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "type": "module",
   "description": "Pi extension for quickly switching between multiple accounts/API keys per provider.",
   "license": "MIT",

package/src/commands/base.ts

@@ -19,7 +19,7 @@ export interface CommandMeta {
 
 export interface Command extends CommandMeta {
   register(): void;
-  handler(ctx: AccountSwitcherContext): Promise<void>;
+  handler(ctx: AccountSwitcherContext, args?: string): Promise<void>;
 }
 
 export abstract class BaseCommand implements Command {
@@ -38,7 +38,7 @@ export abstract class BaseCommand implements Command {
   register(): void {
     this.pi.registerCommand(this.name, {
       description: this.description,
-      handler: (_, ctx) => this.handler(ctx),
+      handler: (args, ctx) => this.handler(ctx, args),
     });
   }
 
@@ -77,5 +77,5 @@ export abstract class BaseCommand implements Command {
     return ctx.model?.id === modelId;
   }
 
-  abstract handler(ctx: AccountSwitcherContext): Promise<void>;
+  abstract handler(ctx: AccountSwitcherContext, args?: string): Promise<void>;
 }

package/src/commands/system/export.ts

@@ -0,0 +1,52 @@
+import { readFile } from "node:fs/promises";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import { COMMANDS, DEFAULT_EXPORT_PATH, STATE_PATH } from "@/constants";
+import type { AccountSwitcherContext } from "@/types";
+import { BaseCommand } from "../base";
+import { errorUtil, fileUtil } from "@/utils";
+
+
+export const useExportCommand = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
+  new ExportCommand(pi, runtime).register();
+};
+
+class ExportCommand extends BaseCommand {
+  constructor(pi: ExtensionAPI, runtime: AccountSwitcher) {
+    super(pi, runtime, COMMANDS.system.export);
+  }
+
+  async handler(ctx: AccountSwitcherContext, args?: string): Promise<void> {
+    try {
+      const target = args?.trim() || (await ctx.ui.input("Export file (blank for default)", DEFAULT_EXPORT_PATH));
+      if (target === undefined) {
+        ctx.ui.notify("Export cancelled.", "info");
+        return;
+      }
+
+      const state = await loadState();
+      const exportData = {
+        version: 1,
+        exportedAt: new Date().toISOString(),
+        accounts: this.runtime.getAccounts(),
+        providers: this.runtime.getProviders(),
+        state,
+      };
+
+      const path = fileUtil.expandHome(target.trim() || DEFAULT_EXPORT_PATH);
+      await fileUtil.writePrivateJson(path, exportData);
+      ctx.ui.notify(`Exported account switcher data to ${path}.`, "info");
+    } catch (e) {
+      ctx.ui.notify(`Failed to export: ${errorUtil.format(e)}`, "error");
+    }
+  }
+}
+
+async function loadState(): Promise<unknown> {
+  try {
+    return JSON.parse(await readFile(STATE_PATH, "utf8"));
+  } catch (error) {
+    if (fileUtil.isMissingFileError(error)) return {};
+    throw error;
+  }
+}

package/src/commands/system/import.ts

@@ -0,0 +1,96 @@
+import { readFile } from "node:fs/promises";
+import z from "zod";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { AccountSwitcher } from "@/runtime";
+import { ACCOUNTS_PATH, COMMANDS, DEFAULT_EXPORT_PATH, PROVIDERS_PATH, STATE_PATH } from "@/constants";
+import { accountSchema, providerSchema } from "@/schemas";
+import type { AccountConfig, AccountSwitcherContext, ProviderConfig } from "@/types";
+import { BaseCommand } from "../base";
+import { errorUtil, fileUtil, uiUtil } from "@/utils";
+
+const importStateSchema = z
+  .object({
+    activeAccountId: z.string().optional(),
+    activeModelId: z.string().optional(),
+    activeModelProvider: z.string().optional(),
+  })
+  .default({});
+
+const exportBundleSchema = z.object({
+  version: z.number().optional(),
+  accounts: z.array(accountSchema).default([]),
+  providers: z.array(providerSchema.extend({ id: z.string().min(1) })).default([]),
+  state: importStateSchema,
+});
+
+type ImportBundle = {
+  accounts: AccountConfig[];
+  providers: ProviderConfig[];
+  state: z.infer<typeof importStateSchema>;
+};
+
+export const useImportCommand = (pi: ExtensionAPI, runtime: AccountSwitcher) => {
+  new ImportCommand(pi, runtime).register();
+};
+
+class ImportCommand extends BaseCommand {
+  constructor(pi: ExtensionAPI, runtime: AccountSwitcher) {
+    super(pi, runtime, COMMANDS.system.import);
+  }
+
+  async handler(ctx: AccountSwitcherContext, args?: string): Promise<void> {
+    try {
+      const source = args?.trim() || (await ctx.ui.input("Import file (blank for default)", DEFAULT_EXPORT_PATH));
+      if (source === undefined) {
+        ctx.ui.notify("Import cancelled.", "info");
+        return;
+      }
+
+      const path = fileUtil.expandHome(source.trim() || DEFAULT_EXPORT_PATH);
+      const bundle = parseImportBundle(JSON.parse(await readFile(path, "utf8")));
+
+      const confirmed = await ctx.ui.confirm(
+        "Import account switcher data?",
+        `This will replace all existing accounts, providers, and state with data from ${path}.`,
+      );
+      if (!confirmed) {
+        ctx.ui.notify("Import cancelled.", "info");
+        return;
+      }
+
+      await fileUtil.writePrivateJson(ACCOUNTS_PATH, { accounts: bundle.accounts });
+      await fileUtil.writePrivateJson(PROVIDERS_PATH, { providers: bundle.providers });
+      await fileUtil.writePrivateJson(STATE_PATH, bundle.state);
+
+      await this.runtime.load();
+      await this.runtime.init(ctx);
+      uiUtil.setAccountStatus(ctx.ui, this.runtime.getActiveAccount()?.label);
+
+      ctx.ui.notify(
+        `Imported ${bundle.accounts.length} accounts and ${bundle.providers.length} providers from ${path}.`,
+        "info",
+      );
+    } catch (e) {
+      ctx.ui.notify(`Failed to import: ${errorUtil.format(e)}`, "error");
+    }
+  }
+}
+
+function parseImportBundle(raw: unknown): ImportBundle {
+  const parsed = exportBundleSchema.parse(raw);
+  assertNoDuplicateIds("account", parsed.accounts.map((account) => account.id));
+  assertNoDuplicateIds("provider", parsed.providers.map((provider) => provider.id));
+  return parsed;
+}
+
+function assertNoDuplicateIds(kind: string, ids: string[]): void {
+  const seen = new Set<string>();
+  const duplicates = new Set<string>();
+  for (const id of ids) {
+    if (seen.has(id)) duplicates.add(id);
+    else seen.add(id);
+  }
+  if (duplicates.size > 0) {
+    throw new Error(`Duplicate ${kind} ids: ${Array.from(duplicates).sort().join(", ")}`);
+  }
+}

package/src/commands/system/index.ts

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

package/src/constants/commands.ts

@@ -62,5 +62,13 @@ export const COMMANDS = {
       name: "system:reset",
       description: "Reset all extension data (accounts, providers, state) to factory defaults",
     },
+    export: {
+      name: "system:export",
+      description: "Export all extension data (accounts, providers, state) to a JSON file",
+    },
+    import: {
+      name: "system:import",
+      description: "Import extension data (accounts, providers, state) from a JSON file",
+    },
   },
 } as const;

package/src/constants/paths.ts

@@ -5,4 +5,5 @@ 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");
+export const PI_AUTH_PATH = join(homedir(), ".pi", "agent", "auth.json");
+export const DEFAULT_EXPORT_PATH = "~/pi-account-switcher-export.json";