gemix 0.0.1

package/src/auth/oauth.ts

@@ -0,0 +1,231 @@
+import { OAuth2Client } from 'google-auth-library';
+import * as http from 'node:http';
+import * as url from 'node:url';
+import * as net from 'node:net';
+import * as crypto from 'node:crypto';
+import open from 'open';
+import type { TokenData } from '../storage/accounts.js';
+
+// OAuth Client ID (same as Gemini CLI - public for installed apps)
+const OAUTH_CLIENT_ID =
+  '681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.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',
+];
+
+const HTTP_REDIRECT = 301;
+const SIGN_IN_SUCCESS_URL =
+  'https://developers.google.com/gemini-code-assist/auth_success_gemini';
+const SIGN_IN_FAILURE_URL =
+  'https://developers.google.com/gemini-code-assist/auth_failure_gemini';
+
+export interface OAuthResult {
+  tokens: TokenData;
+  email: string;
+  name: string;
+  picture?: string;
+}
+
+function getAvailablePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.listen(0, () => {
+      const address = server.address();
+      const port = address && typeof address === 'object' ? address.port : 0;
+      server.close(() => resolve(port));
+    });
+    server.on('error', reject);
+  });
+}
+
+export async function authenticateWithGoogle(): Promise<OAuthResult> {
+  const client = new OAuth2Client({
+    clientId: OAUTH_CLIENT_ID,
+    clientSecret: OAUTH_CLIENT_SECRET,
+  });
+
+  const port = await getAvailablePort();
+  const redirectUri = `http://127.0.0.1:${port}/oauth2callback`;
+  const state = crypto.randomBytes(32).toString('hex');
+
+  const authUrl = client.generateAuthUrl({
+    redirect_uri: redirectUri,
+    access_type: 'offline',
+    scope: OAUTH_SCOPE,
+    prompt: 'consent',
+    state,
+  });
+
+  const loginCompletePromise = new Promise<{
+    code: string;
+  }>((resolve, reject) => {
+    const server = http.createServer(async (req, res) => {
+      try {
+        if (!req.url || req.url.indexOf('/oauth2callback') === -1) {
+          res.writeHead(HTTP_REDIRECT, { Location: SIGN_IN_FAILURE_URL });
+          res.end();
+          reject(new Error('Unexpected request: ' + req.url));
+          return;
+        }
+
+        const qs = new url.URL(req.url, `http://127.0.0.1:${port}`).searchParams;
+
+        if (qs.get('error')) {
+          res.writeHead(HTTP_REDIRECT, { Location: SIGN_IN_FAILURE_URL });
+          res.end();
+          reject(new Error(`Google OAuth error: ${qs.get('error')}. ${qs.get('error_description') || ''}`));
+          return;
+        }
+
+        if (qs.get('state') !== state) {
+          res.writeHead(200, { 'Content-Type': 'text/html' });
+          res.end('<h1>State mismatch. Possible CSRF attack.</h1>');
+          reject(new Error('State mismatch. Possible CSRF attack.'));
+          return;
+        }
+
+        if (qs.get('code')) {
+          res.writeHead(HTTP_REDIRECT, { Location: SIGN_IN_SUCCESS_URL });
+          res.end();
+          resolve({ code: qs.get('code')! });
+        } else {
+          res.writeHead(HTTP_REDIRECT, { Location: SIGN_IN_FAILURE_URL });
+          res.end();
+          reject(new Error('No authorization code received.'));
+        }
+      } catch (e) {
+        res.writeHead(HTTP_REDIRECT, { Location: SIGN_IN_FAILURE_URL });
+        res.end();
+        reject(e instanceof Error ? e : new Error(String(e)));
+      } finally {
+        server.close();
+      }
+    });
+
+    server.listen(port, '127.0.0.1', () => {});
+    server.on('error', reject);
+  });
+
+  console.log('\nOpening browser for Google authentication...\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 authTimeout = 5 * 60 * 1000;
+  let timeoutId: NodeJS.Timeout | undefined;
+
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new Error('Authentication timed out after 5 minutes.'));
+    }, authTimeout);
+  });
+
+  const cancellationPromise = new Promise<never>((_, reject) => {
+    process.on('SIGINT', () => {
+      reject(new Error('Authentication cancelled by user.'));
+    });
+  });
+
+  try {
+    const { code } = await Promise.race([
+      loginCompletePromise,
+      timeoutPromise,
+      cancellationPromise,
+    ]);
+
+    if (timeoutId) clearTimeout(timeoutId);
+
+    const { tokens } = await client.getToken({
+      code,
+      redirect_uri: redirectUri,
+    });
+
+    client.setCredentials(tokens);
+
+    const userInfo = await fetchUserInfo(client);
+
+    return {
+      tokens: {
+        access_token: tokens.access_token || '',
+        refresh_token: tokens.refresh_token || '',
+        id_token: tokens.id_token || '',
+        scope: tokens.scope || OAUTH_SCOPE.join(' '),
+        token_type: tokens.token_type || 'Bearer',
+        expiry_date: tokens.expiry_date || Date.now(),
+      },
+      email: userInfo.email,
+      name: userInfo.name,
+      picture: userInfo.picture,
+    };
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId);
+  }
+}
+
+async function fetchUserInfo(client: OAuth2Client): Promise<{
+  email: string;
+  name: string;
+  picture?: string;
+}> {
+  const { token } = await client.getAccessToken();
+  if (!token) throw new Error('No access token available');
+
+  const response = await fetch('https://www.googleapis.com/oauth2/v2/userinfo', {
+    headers: { Authorization: `Bearer ${token}` },
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch user info: ${response.status} ${response.statusText}`);
+  }
+
+  const userInfo = (await response.json()) as {
+    email: string;
+    name: string;
+    picture?: string;
+  };
+
+  return {
+    email: userInfo.email,
+    name: userInfo.name,
+    picture: userInfo.picture,
+  };
+}
+
+export async function refreshTokens(tokens: TokenData): Promise<TokenData | null> {
+  try {
+    const client = new OAuth2Client({
+      clientId: OAUTH_CLIENT_ID,
+      clientSecret: OAUTH_CLIENT_SECRET,
+    });
+
+    client.setCredentials({
+      access_token: tokens.access_token,
+      refresh_token: tokens.refresh_token,
+    });
+
+    const { token: newAccessToken } = await client.getAccessToken();
+    if (!newAccessToken) return null;
+
+    const credentials = client.credentials;
+    return {
+      access_token: newAccessToken,
+      refresh_token: credentials.refresh_token || tokens.refresh_token,
+      id_token: credentials.id_token || tokens.id_token || '',
+      scope: tokens.scope,
+      token_type: tokens.token_type,
+      expiry_date: credentials.expiry_date || Date.now() + 3600 * 1000,
+    };
+  } catch {
+    return null;
+  }
+}

package/src/commands/current.ts

@@ -0,0 +1,18 @@
+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 "gemx list" to see available accounts.');
+    console.log('Use "gemx 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

@@ -0,0 +1,20 @@
+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 "gemx 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

@@ -0,0 +1,53 @@
+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 'gemx 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

@@ -0,0 +1,37 @@
+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 "gemx 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

@@ -0,0 +1,25 @@
+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 "gemx 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

@@ -0,0 +1,59 @@
+#!/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('gemx')
+  .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();