gemix 0.0.1 → 0.1.0

package/src/storage/accounts.ts

@@ -1,285 +0,0 @@
-import { promises as fs } from 'node:fs';
-import { execSync } from 'node:child_process';
-import {
-  getAccountsFilePath,
-  getActiveFilePath,
-  getAccountTokensPath,
-  getAccountDir,
-  ensureGemxDir,
-  ensureAccountDir,
-  getGeminiOAuthCredsPath,
-  getGeminiGoogleAccountsPath,
-  getAntigravityOAuthTokenPath,
-} from './paths.js';
-import { refreshTokens } from '../auth/oauth.js';
-
-export interface AccountLimits {
-  requestsPerDay: number;
-  tokensPerDay: number;
-}
-
-export interface AccountInfo {
-  email: string;
-  name: string;
-  picture?: string;
-  limits: AccountLimits;
-  created: string;
-  lastUsed: string | null;
-}
-
-export interface AccountsData {
-  accounts: Record<string, AccountInfo>;
-  active: string | null;
-}
-
-export interface TokenData {
-  access_token: string;
-  refresh_token: string;
-  id_token?: string;
-  scope: string;
-  token_type: string;
-  expiry_date: number;
-}
-
-export interface GoogleAccountsData {
-  active: string;
-  old: string[];
-}
-
-const DEFAULT_LIMITS: AccountLimits = {
-  requestsPerDay: 500,
-  tokensPerDay: 1000000,
-};
-
-export async function loadAccounts(): Promise<AccountsData> {
-  await ensureGemxDir();
-  const filePath = getAccountsFilePath();
-  try {
-    const content = await fs.readFile(filePath, 'utf-8');
-    return JSON.parse(content) as AccountsData;
-  } catch {
-    return { accounts: {}, active: null };
-  }
-}
-
-export async function saveAccounts(data: AccountsData): Promise<void> {
-  await ensureGemxDir();
-  const filePath = getAccountsFilePath();
-  await fs.writeFile(filePath, JSON.stringify(data, null, 2), { mode: 0o600 });
-}
-
-export async function loadTokens(username: string): Promise<TokenData | null> {
-  const tokensPath = getAccountTokensPath(username);
-  try {
-    const content = await fs.readFile(tokensPath, 'utf-8');
-    return JSON.parse(content) as TokenData;
-  } catch {
-    return null;
-  }
-}
-
-export async function saveTokens(username: string, tokens: TokenData): Promise<void> {
-  await ensureAccountDir(username);
-  const tokensPath = getAccountTokensPath(username);
-  await fs.writeFile(tokensPath, JSON.stringify(tokens, null, 2), { mode: 0o600 });
-}
-
-export async function loadGoogleAccounts(): Promise<GoogleAccountsData> {
-  const filePath = getGeminiGoogleAccountsPath();
-  try {
-    const content = await fs.readFile(filePath, 'utf-8');
-    return JSON.parse(content) as GoogleAccountsData;
-  } catch {
-    return { active: '', old: [] };
-  }
-}
-
-export async function saveGoogleAccounts(data: GoogleAccountsData): Promise<void> {
-  const filePath = getGeminiGoogleAccountsPath();
-  const dir = filePath.substring(0, filePath.lastIndexOf('/'));
-  await fs.mkdir(dir, { recursive: true });
-  await fs.writeFile(filePath, JSON.stringify(data, null, 2), { mode: 0o600 });
-}
-
-export async function updateGoogleAccountsActive(email: string): Promise<void> {
-  const data = await loadGoogleAccounts();
-
-  if (data.active && data.active !== email) {
-    data.old = [...(data.old || []), data.active];
-  }
-
-  data.active = email;
-  await saveGoogleAccounts(data);
-}
-
-export async function copyTokensToAntigravity(tokens: TokenData): Promise<boolean> {
-  try {
-    const antigravityPath = getAntigravityOAuthTokenPath();
-    const dir = antigravityPath.substring(0, antigravityPath.lastIndexOf('/'));
-    await fs.mkdir(dir, { recursive: true });
-
-    const antigravityData = {
-      token: {
-        access_token: tokens.access_token,
-        token_type: tokens.token_type,
-        refresh_token: tokens.refresh_token,
-        expiry: new Date(tokens.expiry_date).toISOString(),
-      },
-      auth_method: 'consumer',
-    };
-
-    await fs.writeFile(antigravityPath, JSON.stringify(antigravityData, null, 2), { mode: 0o600 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export async function copyTokensToKeychain(tokens: TokenData): Promise<boolean> {
-  try {
-    const keychainData = {
-      token: {
-        access_token: tokens.access_token,
-        token_type: tokens.token_type,
-        refresh_token: tokens.refresh_token,
-        expiry: new Date(tokens.expiry_date).toISOString(),
-      },
-      auth_method: 'consumer',
-    };
-
-    const password = `go-keyring-base64:${Buffer.from(JSON.stringify(keychainData)).toString('base64')}`;
-
-    try {
-      execSync(`security delete-generic-password -s "gemini" -a "antigravity" 2>/dev/null`, { stdio: 'ignore' });
-    } catch {
-      // Ignore if entry doesn't exist
-    }
-
-    execSync(`security add-generic-password -s "gemini" -a "antigravity" -w "${password}" -U`, { stdio: 'ignore' });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export async function getActiveUsername(): Promise<string | null> {
-  const activePath = getActiveFilePath();
-  try {
-    return await fs.readFile(activePath, 'utf-8');
-  } catch {
-    return null;
-  }
-}
-
-export async function setActiveUsername(username: string): Promise<void> {
-  await ensureGemxDir();
-  const activePath = getActiveFilePath();
-  await fs.writeFile(activePath, username, { mode: 0o600 });
-}
-
-export async function copyTokensToGemini(username: string): Promise<boolean> {
-  const tokens = await loadTokens(username);
-  if (!tokens) return false;
-
-  const geminiPath = getGeminiOAuthCredsPath();
-  const geminiDir = geminiPath.substring(0, geminiPath.lastIndexOf('/'));
-  await fs.mkdir(geminiDir, { recursive: true });
-  await fs.writeFile(geminiPath, JSON.stringify(buildGeminiCredsObject(tokens), null, 2), { mode: 0o600 });
-  return true;
-}
-
-export async function addAccount(
-  username: string,
-  email: string,
-  name: string,
-  picture: string | undefined,
-  tokens: TokenData,
-  limits: AccountLimits = DEFAULT_LIMITS
-): Promise<void> {
-  const accounts = await loadAccounts();
-
-  accounts.accounts[username] = {
-    email,
-    name,
-    picture,
-    limits,
-    created: new Date().toISOString(),
-    lastUsed: null,
-  };
-
-  await saveTokens(username, tokens);
-  await saveAccounts(accounts);
-
-  if (!accounts.active) {
-    await setActiveUsername(username);
-    accounts.active = username;
-    await saveAccounts(accounts);
-    await updateGoogleAccountsActive(email);
-  }
-}
-
-export async function removeAccount(username: string): Promise<boolean> {
-  const accounts = await loadAccounts();
-  if (!accounts.accounts[username]) return false;
-
-  delete accounts.accounts[username];
-
-  if (accounts.active === username) {
-    const remaining = Object.keys(accounts.accounts);
-    accounts.active = remaining.length > 0 ? remaining[0] : null;
-  }
-
-  await fs.rm(getAccountDir(username), { recursive: true, force: true });
-  await saveAccounts(accounts);
-  return true;
-}
-
-export function buildGeminiCredsObject(tokens: TokenData): Record<string, unknown> {
-  const creds: Record<string, unknown> = {
-    access_token: tokens.access_token,
-    refresh_token: tokens.refresh_token,
-    scope: tokens.scope,
-    token_type: tokens.token_type,
-    expiry_date: tokens.expiry_date,
-  };
-  if (tokens.id_token) {
-    creds.id_token = tokens.id_token;
-  }
-  return creds;
-}
-
-export async function switchAccount(username: string): Promise<boolean> {
-  const accounts = await loadAccounts();
-  if (!accounts.accounts[username]) return false;
-
-  let tokens = await loadTokens(username);
-  if (!tokens) return false;
-
-  // Refresh tokens if expired
-  const now = Date.now();
-  const fiveMinutes = 5 * 60 * 1000;
-  if (tokens.expiry_date && tokens.expiry_date - now < fiveMinutes) {
-    const refreshed = await refreshTokens(tokens);
-    if (refreshed) {
-      tokens = refreshed;
-      await saveTokens(username, tokens);
-    }
-  }
-
-  await fs.mkdir(getGeminiOAuthCredsPath().substring(0, getGeminiOAuthCredsPath().lastIndexOf('/')), { recursive: true });
-  await fs.writeFile(getGeminiOAuthCredsPath(), JSON.stringify(buildGeminiCredsObject(tokens), null, 2), { mode: 0o600 });
-  await copyTokensToAntigravity(tokens);
-  await copyTokensToKeychain(tokens);
-
-  await updateGoogleAccountsActive(accounts.accounts[username].email);
-
-  accounts.active = username;
-  accounts.accounts[username].lastUsed = new Date().toISOString();
-  await saveAccounts(accounts);
-  await setActiveUsername(username);
-  return true;
-}
-
-export function validateUsername(username: string): boolean {
-  return /^[a-zA-Z0-9]([a-zA-Z0-9-]{1,28}[a-zA-Z0-9])?$/.test(username);
-}

package/src/storage/paths.ts

@@ -1,56 +0,0 @@
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { promises as fs } from 'node:fs';
-
-const GEMX_DIR = '.gemx';
-const GEMINI_DIR = '.gemini';
-const ACCOUNTS_FILE = 'accounts.json';
-const ACTIVE_FILE = 'active';
-const ACCOUNTS_DIR = 'accounts';
-const OAUTH_CREDS_FILE = 'oauth_creds.json';
-const GOOGLE_ACCOUNTS_FILE = 'google_accounts.json';
-
-export function getGemxDir(): string {
-  return path.join(os.homedir(), GEMX_DIR);
-}
-
-export function getAccountsFilePath(): string {
-  return path.join(getGemxDir(), ACCOUNTS_FILE);
-}
-
-export function getActiveFilePath(): string {
-  return path.join(getGemxDir(), ACTIVE_FILE);
-}
-
-export function getAccountsDir(): string {
-  return path.join(getGemxDir(), ACCOUNTS_DIR);
-}
-
-export function getAccountDir(username: string): string {
-  return path.join(getAccountsDir(), username);
-}
-
-export function getAccountTokensPath(username: string): string {
-  return path.join(getAccountDir(username), 'tokens.json');
-}
-
-export function getGeminiOAuthCredsPath(): string {
-  return path.join(os.homedir(), GEMINI_DIR, OAUTH_CREDS_FILE);
-}
-
-export function getGeminiGoogleAccountsPath(): string {
-  return path.join(os.homedir(), GEMINI_DIR, GOOGLE_ACCOUNTS_FILE);
-}
-
-export function getAntigravityOAuthTokenPath(): string {
-  return path.join(os.homedir(), GEMINI_DIR, 'antigravity-cli', 'antigravity-oauth-token');
-}
-
-export async function ensureGemxDir(): Promise<void> {
-  await fs.mkdir(getGemxDir(), { recursive: true });
-  await fs.mkdir(getAccountsDir(), { recursive: true });
-}
-
-export async function ensureAccountDir(username: string): Promise<void> {
-  await fs.mkdir(getAccountDir(username), { recursive: true });
-}

package/src/utils/table.ts

@@ -1,58 +0,0 @@
-import Table from 'cli-table3';
-import type { AccountInfo } from '../storage/accounts.js';
-
-interface AccountRow {
-  username: string;
-  email: string;
-  limits: string;
-  status: string;
-}
-
-export function formatAccountTable(
-  accounts: Record<string, AccountInfo>,
-  activeUsername: string | null
-): string {
-  const table = new Table({
-    head: ['USERNAME', 'EMAIL', 'LIMITS', 'STATUS'],
-    style: { head: ['cyan'] },
-  });
-
-  const sortedUsernames = Object.keys(accounts).sort();
-
-  for (const username of sortedUsernames) {
-    const account = accounts[username];
-    const isActive = username === activeUsername;
-    const limits = `${account.limits.requestsPerDay} req/day`;
-    const status = isActive ? '● active' : '○ inactive';
-
-    table.push([username, account.email, limits, status]);
-  }
-
-  return table.toString();
-}
-
-export function formatAccountTableJson(
-  accounts: Record<string, AccountInfo>,
-  activeUsername: string | null
-): object {
-  const sortedUsernames = Object.keys(accounts).sort();
-  const result = sortedUsernames.map((username) => ({
-    username,
-    email: accounts[username].email,
-    name: accounts[username].name,
-    limits: accounts[username].limits,
-    active: username === activeUsername,
-    created: accounts[username].created,
-    lastUsed: accounts[username].lastUsed,
-  }));
-
-  return { accounts: result };
-}
-
-export function formatLimits(limits: { requestsPerDay: number; tokensPerDay: number }): string {
-  const reqStr = `${limits.requestsPerDay} requests/day`;
-  const tokenStr = limits.tokensPerDay >= 1000000
-    ? `${(limits.tokensPerDay / 1000000).toFixed(0)}M tokens/day`
-    : `${limits.tokensPerDay.toLocaleString()} tokens/day`;
-  return `${reqStr}, ${tokenStr}`;
-}

package/src/utils/validation.ts

@@ -1,27 +0,0 @@
-export function validateUsername(username: string): { valid: boolean; error?: string } {
-  if (!username || username.length < 3) {
-    return { valid: false, error: 'Username must be at least 3 characters' };
-  }
-
-  if (username.length > 30) {
-    return { valid: false, error: 'Username must be at most 30 characters' };
-  }
-
-  if (!/^[a-zA-Z0-9]/.test(username)) {
-    return { valid: false, error: 'Username must start with a letter or number' };
-  }
-
-  if (!/[a-zA-Z0-9]$/.test(username)) {
-    return { valid: false, error: 'Username must end with a letter or number' };
-  }
-
-  if (!/^[a-zA-Z0-9-]+$/.test(username)) {
-    return { valid: false, error: 'Username can only contain letters, numbers, and hyphens' };
-  }
-
-  if (username.includes('--')) {
-    return { valid: false, error: 'Username cannot contain consecutive hyphens' };
-  }
-
-  return { valid: true };
-}

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "Node16",
-    "moduleResolution": "Node16",
-    "lib": ["ES2022"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}