opencode-account-manager 0.4.1

package/src/cli.ts

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+import fs from "fs";
+import path from "path";
+import { Command } from "commander";
+import chalk from "chalk";
+import {
+  buildPortableExport,
+  createEmptyPluginAccountsFile,
+  extractAccountsFromImport,
+  mergeAccounts,
+  readPluginAccountsFile,
+  summarizeAccounts,
+  writePluginAccountsFile,
+} from "./core/accounts";
+import { getPluginAccountsPath, getAmFolderPath } from "./core/paths";
+import { importFromAmFolder, isAmFolder } from "./core/importers/amJson";
+import { writeJsonFile } from "./core/utils";
+import { startTuiDashboard } from "./tui";
+
+function formatTimestamp(timestamp?: number): string {
+  if (!timestamp) return "-";
+  return new Date(timestamp).toLocaleString();
+}
+
+function isLimited(rateLimitResetTimes?: Record<string, number>): boolean {
+  if (!rateLimitResetTimes) return false;
+  const now = Date.now();
+  return Object.values(rateLimitResetTimes).some((value) => value > now);
+}
+
+function safeReadPluginFile(pluginPath: string) {
+  try {
+    return readPluginAccountsFile(pluginPath);
+  } catch {
+    return createEmptyPluginAccountsFile();
+  }
+}
+
+const program = new Command();
+
+program
+  .name("ocam")
+  .description("OpenCode Account Manager - TUI dashboard and CLI for managing accounts")
+  .version("0.4.0");
+
+// Default command - show dashboard
+program
+  .command("dashboard", { isDefault: true })
+  .description("Start the TUI dashboard (default)")
+  .option("--plugin-path <path>", "Path to plugin accounts file")
+  .action((options) => {
+    startTuiDashboard({
+      pluginPath: options.pluginPath,
+    });
+  });
+
+program
+  .command("list")
+  .description("List plugin accounts")
+  .option("--plugin-path <path>", "Path to plugin accounts file")
+  .action((options) => {
+    const pluginPath = getPluginAccountsPath(options.pluginPath);
+    const file = safeReadPluginFile(pluginPath);
+    const summary = summarizeAccounts(file.accounts);
+
+    console.log(chalk.bold("=== Account List ===\n"));
+    console.log(`Total: ${summary.total} | Available: ${chalk.green(summary.available)} | Limited: ${chalk.yellow(summary.limited)}\n`);
+
+    for (const account of file.accounts) {
+      const limited = isLimited(account.rateLimitResetTimes);
+      const status = limited ? chalk.yellow("[LIMITED]") : chalk.green("[  OK  ]");
+      console.log(`${status} ${account.email}`);
+      
+      if (limited && account.rateLimitResetTimes) {
+        const now = Date.now();
+        for (const [model, resetTime] of Object.entries(account.rateLimitResetTimes)) {
+          if (resetTime > now) {
+            const hours = ((resetTime - now) / 3600000).toFixed(1);
+            console.log(chalk.gray(`          └─ ${model}: ${hours}h`));
+          }
+        }
+      }
+    }
+  });
+
+program
+  .command("export")
+  .description("Export accounts to a portable JSON file")
+  .option("--plugin-path <path>", "Path to plugin accounts file")
+  .option("-o, --out <path>", "Output file path", `antigravity-export-${Date.now()}.json`)
+  .action((options) => {
+    const pluginPath = getPluginAccountsPath(options.pluginPath);
+    const file = safeReadPluginFile(pluginPath);
+    
+    if (file.accounts.length === 0) {
+      console.log(chalk.yellow("No accounts to export."));
+      return;
+    }
+
+    const exportFile = buildPortableExport(file.accounts);
+    writeJsonFile(options.out, exportFile);
+    console.log(chalk.green(`Exported ${file.accounts.length} accounts to ${options.out}`));
+  });
+
+program
+  .command("import")
+  .description("Import accounts from file or AM folder")
+  .argument("<source>", "Path to JSON file or AM folder (~/.antigravity_tools)")
+  .option("--plugin-path <path>", "Path to plugin accounts file")
+  .option("-m, --mode <merge|replace>", "Import mode", "merge")
+  .action((source, options) => {
+    const pluginPath = getPluginAccountsPath(options.pluginPath);
+    const mode = options.mode === "replace" ? "replace" : "merge";
+    const existingFile = safeReadPluginFile(pluginPath);
+    const beforeCount = existingFile.accounts.length;
+
+    let incomingAccounts: any[] = [];
+    let sourceType = "";
+
+    // Check if source is AM folder
+    if (fs.existsSync(source) && fs.statSync(source).isDirectory()) {
+      if (isAmFolder(source)) {
+        sourceType = "AM folder";
+        const result = importFromAmFolder(source);
+        
+        if (result.errors.length > 0) {
+          console.log(chalk.red(`Error: ${result.errors.join(", ")}`));
+          return;
+        }
+        
+        incomingAccounts = result.accounts;
+        
+        if (result.skipped.length > 0) {
+          console.log(chalk.gray(`Skipped: ${result.skipped.length} accounts`));
+        }
+      } else {
+        console.log(chalk.red("Directory is not a valid AM folder"));
+        return;
+      }
+    } else if (fs.existsSync(source)) {
+      // It's a file
+      sourceType = "JSON file";
+      try {
+        const raw = fs.readFileSync(source, "utf8");
+        const data = JSON.parse(raw);
+        incomingAccounts = extractAccountsFromImport(data);
+      } catch (err) {
+        console.log(chalk.red(`Failed to parse file: ${err}`));
+        return;
+      }
+    } else {
+      console.log(chalk.red(`Source not found: ${source}`));
+      return;
+    }
+
+    if (incomingAccounts.length === 0) {
+      console.log(chalk.yellow("No valid accounts found in source."));
+      return;
+    }
+
+    const merged = mergeAccounts(existingFile, incomingAccounts, mode);
+    writePluginAccountsFile(pluginPath, merged);
+
+    const added = merged.accounts.length - beforeCount;
+    console.log(chalk.green(`\nImport complete!`));
+    console.log(`Source: ${sourceType}`);
+    console.log(`Mode: ${mode}`);
+    console.log(`Found: ${incomingAccounts.length} accounts`);
+    console.log(`Added: ${added} new`);
+    console.log(`Total: ${merged.accounts.length} accounts`);
+  });
+
+program
+  .command("import-am")
+  .description("Import accounts from Antigravity Manager")
+  .option("--am-path <path>", "Path to AM folder", getAmFolderPath())
+  .option("--plugin-path <path>", "Path to plugin accounts file")
+  .option("-m, --mode <merge|replace>", "Import mode", "merge")
+  .action((options) => {
+    const pluginPath = getPluginAccountsPath(options.pluginPath);
+    const result = importFromAmFolder(options.amPath);
+
+    if (result.errors.length > 0) {
+      console.log(chalk.red(`Error: ${result.errors.join(", ")}`));
+      return;
+    }
+
+    if (result.accounts.length === 0) {
+      console.log(chalk.yellow("No accounts found in AM."));
+      if (result.skipped.length > 0) {
+        console.log(chalk.gray(`Skipped: ${result.skipped.join(", ")}`));
+      }
+      return;
+    }
+
+    const mode = options.mode === "replace" ? "replace" : "merge";
+    const existingFile = safeReadPluginFile(pluginPath);
+    const merged = mergeAccounts(existingFile, result.accounts, mode);
+    writePluginAccountsFile(pluginPath, merged);
+
+    console.log(chalk.green(`\nImported from AM!`));
+    console.log(`Found: ${result.accounts.length} accounts`);
+    console.log(`Skipped: ${result.skipped.length}`);
+    console.log(`Total: ${merged.accounts.length} accounts`);
+  });
+
+program.parse();

package/src/core/accounts.ts

@@ -0,0 +1,215 @@
+import fs from "fs";
+import path from "path";
+import {
+  Account,
+  PluginAccountsFile,
+  PortableExportFile,
+  RateLimitResetTimes,
+} from "./types";
+import { getPluginAccountsPath } from "./paths";
+import { readJsonFile, toLowerTrim, writeJsonFile } from "./utils";
+
+export type MergeMode = "merge" | "replace";
+export type ImportFormat = "portable" | "plugin";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function isAccountCandidate(value: unknown): value is Account {
+  if (!isRecord(value)) return false;
+  if (typeof value.email !== "string") return false;
+  return value.email.includes("@");
+}
+
+function normalizeAccount(account: Account): Account {
+  return {
+    ...account,
+    email: account.email.trim(),
+  };
+}
+
+export function normalizePluginAccounts(data: PluginAccountsFile): PluginAccountsFile {
+  const accounts = Array.isArray(data.accounts)
+    ? data.accounts.filter(isAccountCandidate).map(normalizeAccount)
+    : [];
+
+  return {
+    version: typeof data.version === "number" ? data.version : 3,
+    accounts,
+    activeIndex: typeof data.activeIndex === "number" ? data.activeIndex : undefined,
+    activeIndexByFamily:
+      data.activeIndexByFamily && isRecord(data.activeIndexByFamily)
+        ? (data.activeIndexByFamily as Record<string, number>)
+        : undefined,
+  };
+}
+
+export function createEmptyPluginAccountsFile(): PluginAccountsFile {
+  return {
+    version: 3,
+    accounts: [],
+    activeIndex: 0,
+    activeIndexByFamily: {},
+  };
+}
+
+export function readPluginAccountsFile(filePath?: string): PluginAccountsFile {
+  const resolvedPath = getPluginAccountsPath(filePath);
+  if (!fs.existsSync(resolvedPath)) {
+    throw new Error(
+      `Plugin accounts file not found at ${resolvedPath}. ` +
+        "Login at least one account first or provide --plugin-path."
+    );
+  }
+  const data = readJsonFile<PluginAccountsFile>(resolvedPath);
+  return normalizePluginAccounts(data);
+}
+
+export function writePluginAccountsFile(
+  filePath: string | undefined,
+  data: PluginAccountsFile
+): void {
+  const resolvedPath = getPluginAccountsPath(filePath);
+  const normalized = normalizePluginAccounts(data);
+  const dir = path.dirname(resolvedPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  writeJsonFile(resolvedPath, normalized);
+}
+
+function mergeRateLimits(
+  existing?: RateLimitResetTimes,
+  incoming?: RateLimitResetTimes
+): RateLimitResetTimes | undefined {
+  if (!existing && !incoming) return undefined;
+  return { ...(existing || {}), ...(incoming || {}) };
+}
+
+function mergeFingerprintHistory(
+  existing?: Account["fingerprintHistory"],
+  incoming?: Account["fingerprintHistory"]
+): Account["fingerprintHistory"] | undefined {
+  if (!existing && !incoming) return undefined;
+  const list = [...(existing || []), ...(incoming || [])];
+  return list.length > 0 ? list : undefined;
+}
+
+export function mergeAccount(existing: Account, incoming: Account): Account {
+  return {
+    ...existing,
+    ...incoming,
+    email: incoming.email || existing.email,
+    refreshToken: incoming.refreshToken || existing.refreshToken,
+    fingerprint: incoming.fingerprint || existing.fingerprint,
+    rateLimitResetTimes: mergeRateLimits(
+      existing.rateLimitResetTimes,
+      incoming.rateLimitResetTimes
+    ),
+    fingerprintHistory: mergeFingerprintHistory(
+      existing.fingerprintHistory,
+      incoming.fingerprintHistory
+    ),
+  };
+}
+
+export function mergeAccounts(
+  existingFile: PluginAccountsFile,
+  incomingAccounts: Account[],
+  mode: MergeMode
+): PluginAccountsFile {
+  const base = normalizePluginAccounts(existingFile);
+  const incoming = incomingAccounts
+    .filter(isAccountCandidate)
+    .map(normalizeAccount);
+
+  if (mode === "replace") {
+    return {
+      version: base.version || 3,
+      accounts: incoming,
+      activeIndex: 0,
+      activeIndexByFamily: {},
+    };
+  }
+
+  const byEmail = new Map<string, Account>();
+  for (const account of base.accounts) {
+    byEmail.set(toLowerTrim(account.email), account);
+  }
+
+  for (const account of incoming) {
+    const key = toLowerTrim(account.email);
+    const existing = byEmail.get(key);
+    if (existing) {
+      byEmail.set(key, mergeAccount(existing, account));
+    } else {
+      byEmail.set(key, account);
+    }
+  }
+
+  return {
+    ...base,
+    accounts: Array.from(byEmail.values()),
+  };
+}
+
+export function buildPortableExport(accounts: Account[]): PortableExportFile {
+  return {
+    version: 1,
+    exportedAt: Date.now(),
+    exportedFrom: "antigravity-sync",
+    accounts: accounts.map(normalizeAccount),
+  };
+}
+
+export function detectImportFormat(data: unknown): ImportFormat | "unknown" {
+  if (!isRecord(data)) return "unknown";
+  if (data.exportedFrom === "antigravity-sync") return "portable";
+  if (typeof data.version === "number" && Array.isArray(data.accounts)) {
+    return "plugin";
+  }
+  return "unknown";
+}
+
+export function extractAccountsFromImport(
+  data: unknown,
+  format?: ImportFormat
+): Account[] {
+  if (Array.isArray(data)) {
+    return data.filter(isAccountCandidate).map(normalizeAccount);
+  }
+  if (!isRecord(data)) {
+    throw new Error("Import data must be an object or an array of accounts.");
+  }
+  const detected = format || detectImportFormat(data);
+  if (detected === "unknown") {
+    throw new Error("Unsupported import format. Provide a portable export or plugin file.");
+  }
+  const accounts = Array.isArray(data.accounts) ? data.accounts : [];
+  return accounts.filter(isAccountCandidate).map(normalizeAccount);
+}
+
+export function sanitizeAccountForPublic(account: Account): Account {
+  const { refreshToken, ...rest } = account;
+  return rest;
+}
+
+export function summarizeAccounts(accounts: Account[]): {
+  total: number;
+  limited: number;
+  available: number;
+} {
+  const now = Date.now();
+  let limited = 0;
+  for (const account of accounts) {
+    const resets = account.rateLimitResetTimes || {};
+    const isLimited = Object.values(resets).some((value) => value > now);
+    if (isLimited) limited += 1;
+  }
+  return {
+    total: accounts.length,
+    limited,
+    available: accounts.length - limited,
+  };
+}

package/src/core/config-store.ts

@@ -0,0 +1,212 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface AppConfig {
+  lastExportFolder?: string;
+  lastImportFolder?: string;
+  defaultExportFormat?: "encrypted" | "plain";
+  recentFolders?: string[];
+}
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+const CONFIG_FILENAME = "ocam-config.json";
+const MAX_RECENT_FOLDERS = 5;
+
+// ============================================================================
+// Path Functions
+// ============================================================================
+
+/**
+ * Get the config directory path
+ */
+function getConfigDir(): string {
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+    return path.join(appData, "opencode");
+  }
+  return path.join(os.homedir(), ".config", "opencode");
+}
+
+/**
+ * Get the full path to config file
+ */
+export function getConfigPath(): string {
+  return path.join(getConfigDir(), CONFIG_FILENAME);
+}
+
+// ============================================================================
+// Config Functions
+// ============================================================================
+
+/**
+ * Read config file, return empty config if not exists
+ */
+export function readConfig(): AppConfig {
+  const configPath = getConfigPath();
+  
+  if (!fs.existsSync(configPath)) {
+    return {};
+  }
+
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    return JSON.parse(content) as AppConfig;
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Write config file
+ */
+export function writeConfig(config: AppConfig): void {
+  const configPath = getConfigPath();
+  const configDir = path.dirname(configPath);
+
+  // Ensure directory exists
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+
+  const content = JSON.stringify(config, null, 2);
+  fs.writeFileSync(configPath, content, "utf-8");
+}
+
+/**
+ * Update last export folder and add to recent folders
+ */
+export function updateLastExportFolder(folder: string): void {
+  const config = readConfig();
+  config.lastExportFolder = folder;
+  config.recentFolders = addToRecentFolders(config.recentFolders || [], folder);
+  writeConfig(config);
+}
+
+/**
+ * Update last import folder and add to recent folders
+ */
+export function updateLastImportFolder(folder: string): void {
+  const config = readConfig();
+  config.lastImportFolder = folder;
+  config.recentFolders = addToRecentFolders(config.recentFolders || [], folder);
+  writeConfig(config);
+}
+
+/**
+ * Get recent folders list
+ */
+export function getRecentFolders(): string[] {
+  const config = readConfig();
+  return config.recentFolders || [];
+}
+
+/**
+ * Get last export folder or default
+ */
+export function getLastExportFolder(): string {
+  const config = readConfig();
+  return config.lastExportFolder || process.cwd();
+}
+
+/**
+ * Get last import folder or default
+ */
+export function getLastImportFolder(): string {
+  const config = readConfig();
+  return config.lastImportFolder || process.cwd();
+}
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/**
+ * Add folder to recent list, keeping max items and removing duplicates
+ */
+function addToRecentFolders(recent: string[], folder: string): string[] {
+  // Normalize path
+  const normalized = path.normalize(folder);
+  
+  // Remove if already exists
+  const filtered = recent.filter(f => path.normalize(f) !== normalized);
+  
+  // Add to front
+  filtered.unshift(normalized);
+  
+  // Keep only max items
+  return filtered.slice(0, MAX_RECENT_FOLDERS);
+}
+
+// ============================================================================
+// Quick Locations
+// ============================================================================
+
+export interface QuickLocation {
+  label: string;
+  path: string;
+  exists: boolean;
+}
+
+/**
+ * Get list of quick locations for file browser
+ */
+export function getQuickLocations(): QuickLocation[] {
+  const home = os.homedir();
+  const locations: QuickLocation[] = [];
+
+  // Current directory
+  locations.push({
+    label: "Current Directory",
+    path: process.cwd(),
+    exists: true,
+  });
+
+  // Desktop
+  const desktop = path.join(home, "Desktop");
+  locations.push({
+    label: "Desktop",
+    path: desktop,
+    exists: fs.existsSync(desktop),
+  });
+
+  // Documents
+  const documents = path.join(home, "Documents");
+  locations.push({
+    label: "Documents",
+    path: documents,
+    exists: fs.existsSync(documents),
+  });
+
+  // Downloads
+  const downloads = path.join(home, "Downloads");
+  locations.push({
+    label: "Downloads",
+    path: downloads,
+    exists: fs.existsSync(downloads),
+  });
+
+  // Last export folder (if different from above)
+  const config = readConfig();
+  if (config.lastExportFolder && fs.existsSync(config.lastExportFolder)) {
+    const isAlreadyListed = locations.some(
+      loc => path.normalize(loc.path) === path.normalize(config.lastExportFolder!)
+    );
+    if (!isAlreadyListed) {
+      locations.push({
+        label: "Recent Export",
+        path: config.lastExportFolder,
+        exists: true,
+      });
+    }
+  }
+
+  return locations.filter(loc => loc.exists);
+}