gemix 0.0.2 → 0.1.0

package/src/auth/oauth.ts

@@ -1,194 +0,0 @@
-import * as crypto from 'node:crypto';
-import * as readline from 'node:readline';
-import open from 'open';
-import type { TokenData } from '../storage/accounts.js';
-
-const OAUTH_CLIENT_ID =
-  '1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com';
-
-const OAUTH_CLIENT_SECRET = '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';
-
-const OAUTH_SCOPE = [
-  'openid',
-  'https://www.googleapis.com/auth/cloud-platform',
-  'https://www.googleapis.com/auth/userinfo.email',
-  'https://www.googleapis.com/auth/userinfo.profile',
-  'https://www.googleapis.com/auth/cclog',
-  'https://www.googleapis.com/auth/experimentsandconfigs',
-];
-
-const REDIRECT_URI = 'https://antigravity.google/oauth-callback';
-
-function generateCodeVerifier(): string {
-  return crypto.randomBytes(32).toString('base64url');
-}
-
-function generateCodeChallenge(verifier: string): string {
-  return crypto.createHash('sha256').update(verifier).digest('base64url');
-}
-
-export interface OAuthResult {
-  tokens: TokenData;
-  email: string;
-  name: string;
-  picture?: string;
-}
-
-export async function authenticateWithGoogle(): Promise<OAuthResult> {
-  const state = crypto.randomBytes(32).toString('hex');
-  const codeVerifier = generateCodeVerifier();
-  const codeChallenge = generateCodeChallenge(codeVerifier);
-
-  const authParams = new URLSearchParams({
-    client_id: OAUTH_CLIENT_ID,
-    response_type: 'code',
-    redirect_uri: REDIRECT_URI,
-    scope: OAUTH_SCOPE.join(' '),
-    access_type: 'offline',
-    prompt: 'consent',
-    state,
-    code_challenge: codeChallenge,
-    code_challenge_method: 'S256',
-  });
-
-  const authUrl = `https://accounts.google.com/o/oauth2/auth?${authParams.toString()}`;
-
-  console.log('\nOpening browser for Google authentication...\n');
-  console.log('After signing in, copy the authorization code from the redirect page.\n');
-  console.log(`If the browser doesn't open, visit:\n${authUrl}\n`);
-
-  const childProcess = await open(authUrl);
-  childProcess.on('error', (error) => {
-    console.error(`Failed to open browser: ${error.message}`);
-    console.log(`Please visit:\n${authUrl}\n`);
-  });
-
-  const code = await promptForAuthCode();
-
-  const startTime = Date.now();
-  const tokenResponse = await fetch('https://oauth2.googleapis.com/token', {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
-    },
-    body: new URLSearchParams({
-      client_id: OAUTH_CLIENT_ID,
-      client_secret: OAUTH_CLIENT_SECRET,
-      code,
-      grant_type: 'authorization_code',
-      redirect_uri: REDIRECT_URI,
-      code_verifier: codeVerifier,
-    }),
-  });
-
-  if (!tokenResponse.ok) {
-    const errorText = await tokenResponse.text();
-    throw new Error(`Token exchange failed: ${tokenResponse.status} ${errorText}`);
-  }
-
-  const tokenPayload = (await tokenResponse.json()) as {
-    access_token: string;
-    refresh_token: string;
-    expires_in: number;
-    token_type: string;
-    scope: string;
-  };
-
-  const userInfoResponse = await fetch('https://www.googleapis.com/oauth2/v2/userinfo', {
-    headers: { Authorization: `Bearer ${tokenPayload.access_token}` },
-  });
-
-  if (!userInfoResponse.ok) {
-    throw new Error(`Failed to fetch user info: ${userInfoResponse.status} ${userInfoResponse.statusText}`);
-  }
-
-  const userInfo = (await userInfoResponse.json()) as {
-    email: string;
-    name: string;
-    picture?: string;
-  };
-
-  return {
-    tokens: {
-      access_token: tokenPayload.access_token,
-      refresh_token: tokenPayload.refresh_token,
-      id_token: '',
-      scope: tokenPayload.scope || OAUTH_SCOPE.join(' '),
-      token_type: tokenPayload.token_type || 'Bearer',
-      expiry_date: startTime + tokenPayload.expires_in * 1000,
-    },
-    email: userInfo.email,
-    name: userInfo.name,
-    picture: userInfo.picture,
-  };
-}
-
-function promptForAuthCode(): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
-
-    const authTimeout = 5 * 60 * 1000;
-    const timeoutId = setTimeout(() => {
-      rl.close();
-      reject(new Error('Authentication timed out after 5 minutes.'));
-    }, authTimeout);
-
-    const onSigint = () => {
-      clearTimeout(timeoutId);
-      rl.close();
-      reject(new Error('Authentication cancelled by user.'));
-    };
-    process.on('SIGINT', onSigint);
-
-    rl.question('Paste the authorization code: ', (answer) => {
-      clearTimeout(timeoutId);
-      process.removeListener('SIGINT', onSigint);
-      rl.close();
-      const code = answer.trim();
-      if (!code) {
-        reject(new Error('No authorization code provided.'));
-      } else {
-        resolve(code);
-      }
-    });
-  });
-}
-
-export async function refreshTokens(tokens: TokenData): Promise<TokenData | null> {
-  try {
-    const tokenResponse = await fetch('https://oauth2.googleapis.com/token', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
-      },
-      body: new URLSearchParams({
-        client_id: OAUTH_CLIENT_ID,
-        client_secret: OAUTH_CLIENT_SECRET,
-        refresh_token: tokens.refresh_token,
-        grant_type: 'refresh_token',
-      }),
-    });
-
-    if (!tokenResponse.ok) return null;
-
-    const tokenPayload = (await tokenResponse.json()) as {
-      access_token: string;
-      expires_in: number;
-      token_type: string;
-    };
-
-    return {
-      access_token: tokenPayload.access_token,
-      refresh_token: tokens.refresh_token,
-      id_token: tokens.id_token || '',
-      scope: tokens.scope,
-      token_type: tokenPayload.token_type || 'Bearer',
-      expiry_date: Date.now() + tokenPayload.expires_in * 1000,
-    };
-  } catch {
-    return null;
-  }
-}

package/src/commands/current.ts

@@ -1,18 +0,0 @@
-import { loadAccounts, getActiveUsername } from '../storage/accounts.js';
-import { formatLimits } from '../utils/table.js';
-
-export async function currentCommand(): Promise<void> {
-  const activeUsername = await getActiveUsername();
-  const accounts = await loadAccounts();
-
-  if (!activeUsername || !accounts.accounts[activeUsername]) {
-    console.log('No active account.');
-    console.log('Use "gemix list" to see available accounts.');
-    console.log('Use "gemix use <username>" to switch accounts.');
-    return;
-  }
-
-  const account = accounts.accounts[activeUsername];
-  console.log(`Active account: ${activeUsername} (${account.email})`);
-  console.log(`Limits: ${formatLimits(account.limits)}`);
-}

package/src/commands/list.ts

@@ -1,20 +0,0 @@
-import { loadAccounts } from '../storage/accounts.js';
-import { formatAccountTable, formatAccountTableJson } from '../utils/table.js';
-
-export async function listCommand(json: boolean = false): Promise<void> {
-  const accounts = await loadAccounts();
-  const activeUsername = accounts.active;
-
-  if (Object.keys(accounts.accounts).length === 0) {
-    console.log('No accounts registered.');
-    console.log('Run "gemix register <username>" to add an account.');
-    return;
-  }
-
-  if (json) {
-    const result = formatAccountTableJson(accounts.accounts, activeUsername);
-    console.log(JSON.stringify(result, null, 2));
-  } else {
-    console.log(formatAccountTable(accounts.accounts, activeUsername));
-  }
-}

package/src/commands/register.ts

@@ -1,53 +0,0 @@
-import { authenticateWithGoogle } from '../auth/oauth.js';
-import { addAccount, loadAccounts } from '../storage/accounts.js';
-import { validateUsername } from '../utils/validation.js';
-import { formatLimits } from '../utils/table.js';
-
-export async function registerCommand(username: string): Promise<void> {
-  const validation = validateUsername(username);
-  if (!validation.valid) {
-    console.error(`Error: ${validation.error}`);
-    process.exit(1);
-  }
-
-  const accounts = await loadAccounts();
-  if (accounts.accounts[username]) {
-    console.error(`Error: Account '${username}' already exists.`);
-    console.error(`Use 'gemix remove ${username}' to remove it first.`);
-    process.exit(1);
-  }
-
-  try {
-    console.log(`Registering account '${username}'...`);
-    const result = await authenticateWithGoogle();
-
-    await addAccount(
-      username,
-      result.email,
-      result.name,
-      result.picture,
-      result.tokens
-    );
-
-    const isFirstAccount = Object.keys(accounts.accounts).length === 0;
-
-    console.log('');
-    console.log(`✓ Registered ${username} (${result.email})`);
-    if (result.picture) {
-      console.log(`  ${result.picture}`);
-    }
-    console.log(`  Limits: ${formatLimits({ requestsPerDay: 500, tokensPerDay: 1000000 })}`);
-
-    if (isFirstAccount) {
-      console.log('  Set as active account');
-    }
-    console.log('');
-  } catch (error) {
-    if (error instanceof Error && error.message.includes('cancelled')) {
-      console.log('Registration cancelled.');
-    } else {
-      console.error('Registration failed:', error instanceof Error ? error.message : error);
-    }
-    process.exit(1);
-  }
-}

package/src/commands/remove.ts

@@ -1,37 +0,0 @@
-import * as readline from 'node:readline';
-import { removeAccount, loadAccounts } from '../storage/accounts.js';
-
-export async function removeCommand(username: string, yes: boolean = false): Promise<void> {
-  const accounts = await loadAccounts();
-
-  if (!accounts.accounts[username]) {
-    console.error(`Error: Account '${username}' not found.`);
-    console.error('Use "gemix list" to see available accounts.');
-    process.exit(1);
-  }
-
-  if (!yes) {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
-
-    const answer = await new Promise<string>((resolve) => {
-      rl.question(`Remove account '${username}'? (y/N) `, resolve);
-    });
-    rl.close();
-
-    if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
-      console.log('Removal cancelled.');
-      return;
-    }
-  }
-
-  const success = await removeAccount(username);
-  if (!success) {
-    console.error('Error: Failed to remove account.');
-    process.exit(1);
-  }
-
-  console.log(`✓ Removed account '${username}'`);
-}

package/src/commands/use.ts

@@ -1,25 +0,0 @@
-import { switchAccount, loadAccounts } from '../storage/accounts.js';
-
-export async function useCommand(username: string): Promise<void> {
-  const accounts = await loadAccounts();
-
-  if (!accounts.accounts[username]) {
-    console.error(`Error: Account '${username}' not found.`);
-    console.error('Use "gemix list" to see available accounts.');
-    process.exit(1);
-  }
-
-  try {
-    const success = await switchAccount(username);
-    if (!success) {
-      console.error('Error: Failed to switch account.');
-      process.exit(1);
-    }
-
-    const account = accounts.accounts[username];
-    console.log(`✓ Switched to ${username} (${account.email})`);
-  } catch (error) {
-    console.error('Error:', error instanceof Error ? error.message : error);
-    process.exit(1);
-  }
-}

package/src/index.ts

@@ -1,59 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from 'commander';
-import { registerCommand } from './commands/register.js';
-import { listCommand } from './commands/list.js';
-import { useCommand } from './commands/use.js';
-import { currentCommand } from './commands/current.js';
-import { removeCommand } from './commands/remove.js';
-
-const program = new Command();
-
-program
-  .name('gemix')
-  .description('Gemini multi-account CLI - manage multiple Google accounts')
-  .version('1.0.0');
-
-program
-  .command('register')
-  .description('Register a new Google account')
-  .argument('<username>', 'Unique username for this account')
-  .action(async (username: string) => {
-    await registerCommand(username);
-  });
-
-program
-  .command('list')
-  .alias('ls')
-  .description('List all registered accounts')
-  .option('-j, --json', 'Output in JSON format')
-  .action(async (options: { json?: boolean }) => {
-    await listCommand(options.json);
-  });
-
-program
-  .command('use')
-  .description('Switch to a different account')
-  .argument('<username>', 'Username of the account to switch to')
-  .action(async (username: string) => {
-    await useCommand(username);
-  });
-
-program
-  .command('current')
-  .description('Show the currently active account')
-  .action(async () => {
-    await currentCommand();
-  });
-
-program
-  .command('remove')
-  .alias('rm')
-  .description('Remove a registered account')
-  .argument('<username>', 'Username of the account to remove')
-  .option('-y, --yes', 'Skip confirmation')
-  .action(async (username: string, options: { yes?: boolean }) => {
-    await removeCommand(username, options.yes);
-  });
-
-program.parse();

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);
-}