opencode-account-manager 0.6.4 → 0.6.5

package/src/core/health-orchestrator.ts

@@ -0,0 +1,224 @@
+import { Account, AccountHealthResult, AccountHealthStatus } from "./types";
+import {
+  getHealthCache,
+  getHealthSettings,
+  normalizeHealthKey,
+  setHealthCacheEntry,
+} from "./config-store";
+import { checkAccountHealthOAuth } from "./health-oauth";
+import { collectLogHealthResults, mergeAccountHealth } from "./health-log";
+
+export type HealthSkipReason = "no_refresh_token" | "cooldown" | "disabled";
+
+export interface HealthCheckOptions {
+  emails?: string[];
+  force?: boolean;
+  includeLogs?: boolean;
+  onProgress?: (current: number, total: number, message: string) => void;
+}
+
+export interface HealthCheckItem {
+  email: string;
+  result: AccountHealthResult;
+  skipped?: boolean;
+  skipReason?: HealthSkipReason;
+  cached?: boolean;
+}
+
+export interface HealthCheckResult {
+  items: HealthCheckItem[];
+  counts: {
+    total: number;
+    checked: number;
+    skipped: number;
+    cached: number;
+    byStatus: Record<AccountHealthStatus, number>;
+  };
+  timing: {
+    startedAt: number;
+    completedAt: number;
+    durationMs: number;
+  };
+}
+
+function createBaseResult(message: string): AccountHealthResult {
+  return {
+    status: "not_checked",
+    source: "manual",
+    checkedAt: Date.now(),
+    message,
+  };
+}
+
+function mergeStatusCounts(
+  counts: Record<AccountHealthStatus, number>,
+  status: AccountHealthStatus
+) {
+  counts[status] = (counts[status] || 0) + 1;
+}
+
+async function runWithConcurrency<T, R>(
+  items: T[],
+  limit: number,
+  task: (item: T) => Promise<R>
+): Promise<R[]> {
+  const results: R[] = new Array(items.length);
+  const executing = new Set<Promise<void>>();
+  const tasks: Promise<void>[] = [];
+
+  const safeLimit = Math.max(1, limit || 1);
+
+  for (let index = 0; index < items.length; index += 1) {
+    const item = items[index];
+    const promise = (async () => {
+      results[index] = await task(item);
+    })();
+    tasks.push(promise);
+    executing.add(promise);
+
+    const clean = () => executing.delete(promise);
+    promise.finally(clean).catch(clean);
+
+    if (executing.size >= safeLimit) {
+      await Promise.race(executing);
+    }
+  }
+
+  await Promise.all(tasks);
+  return results;
+}
+
+export async function checkAccountsHealth(
+  accounts: Account[],
+  options: HealthCheckOptions = {}
+): Promise<HealthCheckResult> {
+  const startedAt = Date.now();
+  const includeLogs = options.includeLogs ?? true;
+  const force = options.force ?? false;
+  const settings = getHealthSettings();
+  const cache = getHealthCache();
+  const logResults = includeLogs ? collectLogHealthResults() : {};
+
+  const emailFilter = options.emails?.map((email) => normalizeHealthKey(email));
+  const filteredAccounts = emailFilter
+    ? accounts.filter((acc) => emailFilter.includes(normalizeHealthKey(acc.email)))
+    : accounts;
+
+  const items: HealthCheckItem[] = [];
+  const toCheck: Array<{ email: string; refreshToken: string }> = [];
+  const now = Date.now();
+
+  for (const account of filteredAccounts) {
+    const email = account.email;
+    const key = normalizeHealthKey(email);
+    const cached = !force ? cache[key] : undefined;
+
+    if (cached && now - cached.checkedAt <= settings.ttlMs) {
+      const merged = mergeAccountHealth(cached, logResults[key]) || cached;
+      items.push({ email, result: merged, cached: true });
+      continue;
+    }
+
+    if (!force && cached && now - cached.checkedAt < settings.cooldownMs) {
+      const base = createBaseResult("Cooldown active");
+      const merged = mergeAccountHealth(base, logResults[key]) || base;
+      items.push({
+        email,
+        result: merged,
+        skipped: true,
+        skipReason: "cooldown",
+      });
+      continue;
+    }
+
+    if (account.enabled === false) {
+      const base = createBaseResult("Account disabled");
+      const merged = mergeAccountHealth(base, logResults[key]) || base;
+      items.push({
+        email,
+        result: merged,
+        skipped: true,
+        skipReason: "disabled",
+      });
+      continue;
+    }
+
+    if (!account.refreshToken) {
+      const base = createBaseResult("Missing refresh token");
+      const merged = mergeAccountHealth(base, logResults[key]) || base;
+      items.push({
+        email,
+        result: merged,
+        skipped: true,
+        skipReason: "no_refresh_token",
+      });
+      continue;
+    }
+
+    toCheck.push({ email, refreshToken: account.refreshToken });
+  }
+
+  let completed = 0;
+  const total = toCheck.length;
+
+  const checkedResults = await runWithConcurrency(
+    toCheck,
+    settings.maxConcurrency,
+    async (item) => {
+      if (options.onProgress) {
+        options.onProgress(completed, total, `Checking ${item.email}...`);
+      }
+      
+      const oauthResult = await checkAccountHealthOAuth(item.refreshToken);
+      const key = normalizeHealthKey(item.email);
+      const merged = mergeAccountHealth(oauthResult, logResults[key]) || oauthResult;
+      setHealthCacheEntry(item.email, merged);
+      
+      completed++;
+      if (options.onProgress) {
+        options.onProgress(completed, total, `Finished ${item.email}`);
+      }
+      
+      return { email: item.email, result: merged };
+    }
+  );
+
+  for (const entry of checkedResults) {
+    items.push({ email: entry.email, result: entry.result });
+  }
+
+  const counts: HealthCheckResult["counts"] = {
+    total: filteredAccounts.length,
+    checked: checkedResults.length,
+    skipped: items.filter((item) => item.skipped).length,
+    cached: items.filter((item) => item.cached).length,
+    byStatus: {
+      ok: 0,
+      verification_required: 0,
+      revoked: 0,
+      disabled: 0,
+      deleted: 0,
+      password_changed: 0,
+      network_error: 0,
+      unknown_error: 0,
+      not_checked: 0,
+      not_configured: 0,
+    },
+  };
+
+  for (const item of items) {
+    mergeStatusCounts(counts.byStatus, item.result.status);
+  }
+
+  const completedAt = Date.now();
+
+  return {
+    items,
+    counts,
+    timing: {
+      startedAt,
+      completedAt,
+      durationMs: completedAt - startedAt,
+    },
+  };
+}

package/src/core/importers/amExport.ts

@@ -1,177 +1,177 @@
-/**
- * Import accounts from Antigravity Manager EXPORTED files
- * 
- * AM Export Format (from app export button):
- * [
- *   { "email": "xxx@gmail.com", "refresh_token": "1//..." },
- *   ...
- * ]
- * 
- * This is different from AM folder structure (accounts.json + accounts/*.json)
- */
-
-import fs from "fs";
-import { Account } from "../types";
-
-/**
- * Single entry in AM export file
- */
-export interface AMExportEntry {
-  email: string;
-  refresh_token: string;
-}
-
-/**
- * Type guard to check if data is an AM export file (array of entries)
- */
-export function isAMExportFile(data: unknown): data is AMExportEntry[] {
-  if (!Array.isArray(data)) return false;
-  if (data.length === 0) return true; // Empty array is valid
-  
-  // Check first few entries to be sure
-  const sample = data.slice(0, 3);
-  return sample.every(item => 
-    typeof item === "object" &&
-    item !== null &&
-    typeof (item as Record<string, unknown>).email === "string" &&
-    typeof (item as Record<string, unknown>).refresh_token === "string"
-  );
-}
-
-/**
- * Generate a new fingerprint for imported accounts
- */
-function generateFingerprint() {
-  const randomHex = (len: number) => {
-    let result = "";
-    for (let i = 0; i < len; i++) {
-      result += Math.floor(Math.random() * 16).toString(16);
-    }
-    return result;
-  };
-
-  const platforms = ["win32/x64", "win32/arm64", "darwin/x64", "darwin/arm64"];
-  const ides = ["ANDROID_STUDIO", "INTELLIJ", "IDE_UNSPECIFIED"];
-  const clients = [
-    "google-cloud-sdk android-studio/2024.1",
-    "google-cloud-sdk intellij/2024.1",
-    "google-cloud-sdk vscode/1.87.0",
-  ];
-
-  const platform = platforms[Math.floor(Math.random() * platforms.length)];
-
-  return {
-    deviceId: crypto.randomUUID(),
-    sessionToken: randomHex(32),
-    userAgent: `antigravity/1.15.8 ${platform}`,
-    apiClient: clients[Math.floor(Math.random() * clients.length)],
-    clientMetadata: {
-      ideType: ides[Math.floor(Math.random() * ides.length)],
-      platform: platform.startsWith("darwin") ? "MACOS" : "WINDOWS",
-      pluginType: "GEMINI",
-      osVersion: platform.startsWith("darwin") ? "14.2.1" : "10.0.19042",
-      arch: platform.split("/")[1],
-      sqmId: `{${crypto.randomUUID().toUpperCase()}}`,
-    },
-    quotaUser: `device-${randomHex(16)}`,
-    createdAt: Date.now(),
-  };
-}
-
-export interface ImportFromAMExportResult {
-  accounts: Account[];
-  skipped: string[];
-  errors: string[];
-  source: "am-export";
-}
-
-/**
- * Import accounts from AM export file content
- */
-export function importFromAMExportContent(entries: AMExportEntry[]): ImportFromAMExportResult {
-  const result: ImportFromAMExportResult = {
-    accounts: [],
-    skipped: [],
-    errors: [],
-    source: "am-export",
-  };
-
-  for (const entry of entries) {
-    // Validate email
-    if (!entry.email || !entry.email.includes("@")) {
-      result.skipped.push(`Invalid email: ${entry.email || "(empty)"}`);
-      continue;
-    }
-
-    // Validate refresh_token
-    if (!entry.refresh_token || !entry.refresh_token.startsWith("1//")) {
-      result.skipped.push(`${entry.email} (invalid or missing refresh_token)`);
-      continue;
-    }
-
-    // Convert to Plugin account format
-    const account: Account = {
-      email: entry.email.trim(),
-      refreshToken: entry.refresh_token,
-      addedAt: Date.now(),
-      lastUsed: Date.now(),
-      fingerprint: generateFingerprint(),
-      enabled: true,
-    };
-
-    result.accounts.push(account);
-  }
-
-  return result;
-}
-
-/**
- * Import accounts from AM export file path
- */
-export function importFromAMExportFile(filePath: string): ImportFromAMExportResult {
-  const result: ImportFromAMExportResult = {
-    accounts: [],
-    skipped: [],
-    errors: [],
-    source: "am-export",
-  };
-
-  // Check if file exists
-  if (!fs.existsSync(filePath)) {
-    result.errors.push(`File not found: ${filePath}`);
-    return result;
-  }
-
-  // Read and parse file
-  let data: unknown;
-  try {
-    const content = fs.readFileSync(filePath, "utf-8");
-    data = JSON.parse(content);
-  } catch (err) {
-    result.errors.push(`Failed to parse file: ${err}`);
-    return result;
-  }
-
-  // Validate format
-  if (!isAMExportFile(data)) {
-    result.errors.push("Invalid AM export format. Expected array of {email, refresh_token}");
-    return result;
-  }
-
-  return importFromAMExportContent(data);
-}
-
-/**
- * Check if a file is an AM export file (by reading and checking format)
- */
-export function isAMExportFilePath(filePath: string): boolean {
-  if (!fs.existsSync(filePath)) return false;
-  
-  try {
-    const content = fs.readFileSync(filePath, "utf-8");
-    const data = JSON.parse(content);
-    return isAMExportFile(data);
-  } catch {
-    return false;
-  }
-}
+/**
+ * Import accounts from Antigravity Manager EXPORTED files
+ * 
+ * AM Export Format (from app export button):
+ * [
+ *   { "email": "xxx@gmail.com", "refresh_token": "1//..." },
+ *   ...
+ * ]
+ * 
+ * This is different from AM folder structure (accounts.json + accounts/*.json)
+ */
+
+import fs from "fs";
+import { Account } from "../types";
+
+/**
+ * Single entry in AM export file
+ */
+export interface AMExportEntry {
+  email: string;
+  refresh_token: string;
+}
+
+/**
+ * Type guard to check if data is an AM export file (array of entries)
+ */
+export function isAMExportFile(data: unknown): data is AMExportEntry[] {
+  if (!Array.isArray(data)) return false;
+  if (data.length === 0) return true; // Empty array is valid
+  
+  // Check first few entries to be sure
+  const sample = data.slice(0, 3);
+  return sample.every(item => 
+    typeof item === "object" &&
+    item !== null &&
+    typeof (item as Record<string, unknown>).email === "string" &&
+    typeof (item as Record<string, unknown>).refresh_token === "string"
+  );
+}
+
+/**
+ * Generate a new fingerprint for imported accounts
+ */
+function generateFingerprint() {
+  const randomHex = (len: number) => {
+    let result = "";
+    for (let i = 0; i < len; i++) {
+      result += Math.floor(Math.random() * 16).toString(16);
+    }
+    return result;
+  };
+
+  const platforms = ["win32/x64", "win32/arm64", "darwin/x64", "darwin/arm64"];
+  const ides = ["ANDROID_STUDIO", "INTELLIJ", "IDE_UNSPECIFIED"];
+  const clients = [
+    "google-cloud-sdk android-studio/2024.1",
+    "google-cloud-sdk intellij/2024.1",
+    "google-cloud-sdk vscode/1.87.0",
+  ];
+
+  const platform = platforms[Math.floor(Math.random() * platforms.length)];
+
+  return {
+    deviceId: crypto.randomUUID(),
+    sessionToken: randomHex(32),
+    userAgent: `antigravity/1.15.8 ${platform}`,
+    apiClient: clients[Math.floor(Math.random() * clients.length)],
+    clientMetadata: {
+      ideType: ides[Math.floor(Math.random() * ides.length)],
+      platform: platform.startsWith("darwin") ? "MACOS" : "WINDOWS",
+      pluginType: "GEMINI",
+      osVersion: platform.startsWith("darwin") ? "14.2.1" : "10.0.19042",
+      arch: platform.split("/")[1],
+      sqmId: `{${crypto.randomUUID().toUpperCase()}}`,
+    },
+    quotaUser: `device-${randomHex(16)}`,
+    createdAt: Date.now(),
+  };
+}
+
+export interface ImportFromAMExportResult {
+  accounts: Account[];
+  skipped: string[];
+  errors: string[];
+  source: "am-export";
+}
+
+/**
+ * Import accounts from AM export file content
+ */
+export function importFromAMExportContent(entries: AMExportEntry[]): ImportFromAMExportResult {
+  const result: ImportFromAMExportResult = {
+    accounts: [],
+    skipped: [],
+    errors: [],
+    source: "am-export",
+  };
+
+  for (const entry of entries) {
+    // Validate email
+    if (!entry.email || !entry.email.includes("@")) {
+      result.skipped.push(`Invalid email: ${entry.email || "(empty)"}`);
+      continue;
+    }
+
+    // Validate refresh_token
+    if (!entry.refresh_token || !entry.refresh_token.startsWith("1//")) {
+      result.skipped.push(`${entry.email} (invalid or missing refresh_token)`);
+      continue;
+    }
+
+    // Convert to Plugin account format
+    const account: Account = {
+      email: entry.email.trim(),
+      refreshToken: entry.refresh_token,
+      addedAt: Date.now(),
+      lastUsed: Date.now(),
+      fingerprint: generateFingerprint(),
+      enabled: true,
+    };
+
+    result.accounts.push(account);
+  }
+
+  return result;
+}
+
+/**
+ * Import accounts from AM export file path
+ */
+export function importFromAMExportFile(filePath: string): ImportFromAMExportResult {
+  const result: ImportFromAMExportResult = {
+    accounts: [],
+    skipped: [],
+    errors: [],
+    source: "am-export",
+  };
+
+  // Check if file exists
+  if (!fs.existsSync(filePath)) {
+    result.errors.push(`File not found: ${filePath}`);
+    return result;
+  }
+
+  // Read and parse file
+  let data: unknown;
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    data = JSON.parse(content);
+  } catch (err) {
+    result.errors.push(`Failed to parse file: ${err}`);
+    return result;
+  }
+
+  // Validate format
+  if (!isAMExportFile(data)) {
+    result.errors.push("Invalid AM export format. Expected array of {email, refresh_token}");
+    return result;
+  }
+
+  return importFromAMExportContent(data);
+}
+
+/**
+ * Check if a file is an AM export file (by reading and checking format)
+ */
+export function isAMExportFilePath(filePath: string): boolean {
+  if (!fs.existsSync(filePath)) return false;
+  
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(content);
+    return isAMExportFile(data);
+  } catch {
+    return false;
+  }
+}