gemini-coder 0.1.1 → 0.1.3

package/README.md

@@ -24,7 +24,25 @@ npm start
 
 ## Authentication
 
-This tool expects a local `gemini.json` service account file in the project root when run from source. Do not publish that file with the package.
+Server-backed auth is supported. Run the Gemini Coder server on a trusted machine that has access to Google credentials, then point client machines at it with `GEMINI_CODER_SERVER_URL`.
+
+Server example:
+
+```bash
+export GEMINI_CODER_SERVER_TOKEN=your-shared-secret
+export GOOGLE_APPLICATION_CREDENTIALS=/path/to/gemini.json
+npm run serve
+```
+
+Client example:
+
+```bash
+export GEMINI_CODER_SERVER_URL=http://your-server:8787
+export GEMINI_CODER_SERVER_TOKEN=your-shared-secret
+gemini-coder chat
+```
+
+For local source runs, the CLI still supports a `gemini.json` file in the workspace root as a fallback.
 
 ## Notes
 

package/dist/cli.js

@@ -10,15 +10,15 @@ const sessionManager = new SessionManager();
 program
     .name('gemini')
     .description('Gemini Coder Pro CLI - Advanced AI Coding Agent')
-    .version('0.1.1');
+    .version('0.1.3');
 program
     .command('chat', { isDefault: true })
     .description('Start an interactive chat session')
     .option('-p, --prompt <query>', 'Start with an initial prompt')
     .option('-c, --continue', 'Continue the most recent session')
-    .option('-m, --model <name>', 'Specify the model to use', 'gemini-3.1-pro-preview')
+    .option('-m, --model <name>', 'Specify the model to use', 'gemini-3.5-flash')
     .action(async (options) => {
-    printBootScreen('Gemini Coder Pro', 'v0.1.1');
+    printBootScreen('Gemini Coder Pro', 'v0.1.3');
     let session;
     if (options.continue) {
         session = await sessionManager.getLatestSession();

package/dist/core/ai.js

@@ -1,33 +1,12 @@
-import { GoogleGenAI } from '@google/genai';
-import fs from 'fs';
-import path from 'path';
+import { createGoogleClient } from './auth.js';
+import { createRemoteClient } from './remote-client.js';
 import { fileURLToPath } from 'url';
-function findProjectRoot(startPath) {
-    let currentPath = startPath;
-    while (currentPath !== path.parse(currentPath).root) {
-        if (fs.existsSync(path.join(currentPath, 'package.json'))) {
-            return currentPath;
-        }
-        currentPath = path.dirname(currentPath);
-    }
-    throw new Error('Could not find project root containing package.json');
-}
+import path from 'path';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const projectRoot = findProjectRoot(__dirname);
-const credentialsPath = path.join(projectRoot, 'gemini.json');
-if (!fs.existsSync(credentialsPath)) {
-    console.error(`Error: gemini.json not found at expected path: ${credentialsPath}`);
-    process.exit(1);
-}
-const config = JSON.parse(fs.readFileSync(credentialsPath, 'utf8'));
-const location = config.location ?? process.env.GOOGLE_CLOUD_LOCATION ?? 'global';
-export const client = new GoogleGenAI({
-    project: config.project_id,
-    location,
-    vertexai: true,
-    googleAuthOptions: {
-        keyFile: credentialsPath,
-        scopes: ['https://www.googleapis.com/auth/cloud-platform'],
-    }
-});
+const projectRoot = path.resolve(__dirname, '..', '..');
+const serverUrl = process.env.GEMINI_CODER_SERVER_URL;
+const serverToken = process.env.GEMINI_CODER_SERVER_TOKEN;
+export const client = serverUrl
+    ? createRemoteClient(serverUrl, serverToken)
+    : createGoogleClient(projectRoot);

package/dist/core/auth.js

@@ -0,0 +1,78 @@
+import { GoogleGenAI } from '@google/genai';
+import fs from 'fs';
+import path from 'path';
+function findFileUpward(startPath, fileName) {
+    let currentPath = startPath;
+    while (currentPath !== path.parse(currentPath).root) {
+        const candidatePath = path.join(currentPath, fileName);
+        if (fs.existsSync(candidatePath)) {
+            return candidatePath;
+        }
+        currentPath = path.dirname(currentPath);
+    }
+    return null;
+}
+function loadCredentialsFromFile(filePath) {
+    try {
+        const config = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        return {
+            project: config.project_id,
+            location: config.location,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+export function resolveAuthConfig(baseDir) {
+    const envCredentialsPath = process.env.GOOGLE_APPLICATION_CREDENTIALS;
+    const envProject = process.env.GOOGLE_CLOUD_PROJECT ?? process.env.GCLOUD_PROJECT ?? process.env.GOOGLE_PROJECT_ID;
+    const envLocation = process.env.GOOGLE_CLOUD_LOCATION;
+    if (envCredentialsPath && fs.existsSync(envCredentialsPath)) {
+        const fromEnvFile = loadCredentialsFromFile(envCredentialsPath);
+        const project = envProject ?? fromEnvFile.project;
+        if (!project) {
+            throw new Error('GOOGLE_APPLICATION_CREDENTIALS is set, but the file does not contain project_id and no Google Cloud project env var was provided.');
+        }
+        return {
+            project,
+            location: envLocation ?? fromEnvFile.location ?? 'global',
+            keyFile: envCredentialsPath,
+        };
+    }
+    const localCredentialsPath = findFileUpward(baseDir, 'gemini.json');
+    if (localCredentialsPath) {
+        const fromLocalFile = loadCredentialsFromFile(localCredentialsPath);
+        const project = envProject ?? fromLocalFile.project;
+        if (!project) {
+            throw new Error(`Found ${localCredentialsPath}, but it does not contain project_id and no Google Cloud project env var was provided.`);
+        }
+        return {
+            project,
+            location: envLocation ?? fromLocalFile.location ?? 'global',
+            keyFile: localCredentialsPath,
+        };
+    }
+    if (envProject) {
+        return {
+            project: envProject,
+            location: envLocation ?? 'global',
+        };
+    }
+    throw new Error('No auth source found. Set GOOGLE_APPLICATION_CREDENTIALS, or place gemini.json in the workspace/server root, or configure GOOGLE_CLOUD_PROJECT for ADC.');
+}
+export function createGoogleClient(baseDir) {
+    const auth = resolveAuthConfig(baseDir);
+    const googleAuthOptions = auth.keyFile
+        ? {
+            keyFile: auth.keyFile,
+            scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+        }
+        : undefined;
+    return new GoogleGenAI({
+        project: auth.project,
+        location: auth.location,
+        vertexai: true,
+        ...(googleAuthOptions ? { googleAuthOptions } : {}),
+    });
+}

package/dist/core/orchestrator.js

@@ -110,7 +110,7 @@ export class Orchestrator {
     mode = OrchestratorMode.NORMAL;
     model;
     appliedEdits = [];
-    constructor(session, sessionManager, model = 'gemini-3.1-pro-preview') {
+    constructor(session, sessionManager, model = 'gemini-3.5-flash') {
         this.session = session;
         this.sessionManager = sessionManager;
         this.model = model;
@@ -174,7 +174,19 @@ export class Orchestrator {
     }
     async chat() {
         while (true) {
-            const userInput = await rl.question(getPromptText(this.mode));
+            let userInput = '';
+            try {
+                userInput = await rl.question(getPromptText(this.mode));
+            }
+            catch (error) {
+                if (error?.code === 'ABORT_ERR' ||
+                    error?.name === 'AbortError' ||
+                    error?.code === 'ERR_USE_AFTER_CLOSE') {
+                    console.log(chalk.yellow('\nSession interrupted. Exiting...'));
+                    break;
+                }
+                throw error;
+            }
             if (userInput.trim() === '')
                 continue;
             if (userInput.toLowerCase() === 'exit')
@@ -189,6 +201,7 @@ export class Orchestrator {
             this.session.updatedAt = new Date().toISOString();
             await this.sessionManager.saveSession(this.session);
         }
+        rl.close();
     }
     async handleSlashCommand(command) {
         const [cmd, ...args] = command.slice(1).split(' ');
@@ -260,12 +273,21 @@ export class Orchestrator {
                     contents,
                     config: {
                         tools: [{ functionDeclarations }],
+                        maxOutputTokens: 8192,
                     }
                 }));
             }
             catch (err) {
                 spinner.fail(chalk.red('API Error'));
-                console.error(chalk.red(`\n[API Error]: ${err.message || err}`));
+                const message = String(err?.message || err);
+                const isOauthDnsIssue = message.includes('oauth2.googleapis.com') ||
+                    message.includes('ENOTFOUND') ||
+                    message.includes('EAI_AGAIN') ||
+                    message.includes('ECONNRESET');
+                console.error(chalk.red(`\n[API Error]: ${message}`));
+                if (isOauthDnsIssue) {
+                    console.error(chalk.yellow('\n[Hint]: The CLI could not reach oauth2.googleapis.com to exchange the service-account token. Check network access, DNS, firewall, or proxy settings on this machine, then retry.'));
+                }
                 return;
             }
             let responseParts = [];
@@ -283,7 +305,7 @@ export class Orchestrator {
                 if (parts.length > 0) {
                     responseParts.push(...parts);
                     const textParts = parts
-                        .map(part => ('text' in part ? part.text : undefined))
+                        .map((part) => ('text' in part ? part.text : undefined))
                         .filter((text) => typeof text === 'string' && text.length > 0)
                         .join('');
                     if (textParts) {

package/dist/core/remote-client.js

@@ -0,0 +1,49 @@
+async function* readNdjsonStream(response) {
+    if (!response.body) {
+        return;
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        let lineBreakIndex = buffer.indexOf('\n');
+        while (lineBreakIndex !== -1) {
+            const line = buffer.slice(0, lineBreakIndex).trim();
+            buffer = buffer.slice(lineBreakIndex + 1);
+            if (line.length > 0) {
+                yield JSON.parse(line);
+            }
+            lineBreakIndex = buffer.indexOf('\n');
+        }
+    }
+    const remaining = buffer.trim();
+    if (remaining.length > 0) {
+        yield JSON.parse(remaining);
+    }
+}
+export function createRemoteClient(serverUrl, token) {
+    const normalizedServerUrl = serverUrl.replace(/\/+$/, '');
+    return {
+        models: {
+            generateContentStream: async (request) => {
+                const response = await fetch(`${normalizedServerUrl}/v1/generateContentStream`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        ...(token ? { Authorization: `Bearer ${token}` } : {}),
+                    },
+                    body: JSON.stringify(request),
+                });
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    throw new Error(`Remote auth server error (${response.status}): ${errorText}`);
+                }
+                return readNdjsonStream(response);
+            },
+        },
+    };
+}

package/dist/server.js

@@ -0,0 +1,60 @@
+import { createServer } from 'http';
+import { URL } from 'url';
+import { createGoogleClient } from './core/auth.js';
+const serverPort = Number(process.env.GEMINI_CODER_SERVER_PORT ?? 8787);
+const serverHost = process.env.GEMINI_CODER_SERVER_HOST ?? '127.0.0.1';
+const requiredToken = process.env.GEMINI_CODER_SERVER_TOKEN?.trim();
+const serverRoot = process.cwd();
+const aiClient = createGoogleClient(serverRoot);
+function sendJson(response, statusCode, payload) {
+    response.statusCode = statusCode;
+    response.setHeader('Content-Type', 'application/json; charset=utf-8');
+    response.end(JSON.stringify(payload));
+}
+function readRequestBody(request) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        request.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+        request.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        request.on('error', reject);
+    });
+}
+const server = createServer(async (request, response) => {
+    try {
+        const requestUrl = new URL(request.url ?? '/', `http://${request.headers.host ?? `${serverHost}:${serverPort}`}`);
+        if (requestUrl.pathname === '/health') {
+            sendJson(response, 200, { ok: true });
+            return;
+        }
+        if (requestUrl.pathname !== '/v1/generateContentStream' || request.method !== 'POST') {
+            sendJson(response, 404, { error: 'Not found' });
+            return;
+        }
+        if (requiredToken) {
+            const authHeader = request.headers.authorization ?? '';
+            if (authHeader !== `Bearer ${requiredToken}`) {
+                sendJson(response, 401, { error: 'Unauthorized' });
+                return;
+            }
+        }
+        const rawBody = await readRequestBody(request);
+        const payload = JSON.parse(rawBody || '{}');
+        response.statusCode = 200;
+        response.setHeader('Content-Type', 'application/x-ndjson; charset=utf-8');
+        response.setHeader('Cache-Control', 'no-cache');
+        response.setHeader('Connection', 'keep-alive');
+        const stream = await aiClient.models.generateContentStream(payload);
+        for await (const chunk of stream) {
+            response.write(`${JSON.stringify(chunk)}\n`);
+        }
+        response.end();
+    }
+    catch (error) {
+        sendJson(response, 500, {
+            error: error?.message || String(error),
+        });
+    }
+});
+server.listen(serverPort, serverHost, () => {
+    console.log(`Gemini Coder server listening on http://${serverHost}:${serverPort}`);
+});

package/dist/ui/terminal.js

@@ -10,6 +10,28 @@ export const QUICK_ACTIONS = [
 function getBoxWidth() {
     return Math.max(60, Math.min(process.stdout.columns || 80, 96));
 }
+function wrapContent(content, maxWidth) {
+    const rawLines = content.split(/\r?\n/);
+    const wrapped = [];
+    for (const rawLine of rawLines) {
+        const line = rawLine.replace(/\t/g, '  ');
+        if (line.length === 0) {
+            wrapped.push('');
+            continue;
+        }
+        let remaining = line;
+        while (remaining.length > maxWidth) {
+            let breakAt = remaining.lastIndexOf(' ', maxWidth);
+            if (breakAt <= 0) {
+                breakAt = maxWidth;
+            }
+            wrapped.push(remaining.slice(0, breakAt).trimEnd());
+            remaining = remaining.slice(breakAt).trimStart();
+        }
+        wrapped.push(remaining);
+    }
+    return wrapped;
+}
 function boxLine(content, width) {
     const innerWidth = width - 2;
     const text = content.length > innerWidth ? content.slice(0, innerWidth) : content;
@@ -24,8 +46,12 @@ export function printBox(title, lines, accent = 'blue') {
     const left = '─'.repeat(Math.floor(titlePad / 2));
     const right = '─'.repeat(titlePad - left.length);
     console.log(borderColor(`┌${left}${titleText}${right}┐`));
+    const contentWidth = width - 3;
     for (const line of lines) {
-        console.log(borderColor(boxLine(` ${line}`, width)));
+        const wrappedLines = wrapContent(line, Math.max(1, contentWidth));
+        for (const wrappedLine of wrappedLines) {
+            console.log(borderColor(boxLine(` ${wrappedLine}`, width)));
+        }
     }
     console.log(borderColor(`└${'─'.repeat(width - 2)}┘`));
 }
@@ -45,8 +71,11 @@ export function getPromptText(mode) {
     return chalk.bold(`${promptColor('>')} `);
 }
 export function printAssistantResponse(text) {
-    const lines = text.split(/\r?\n/);
-    printBox('Gemini', lines.length > 0 ? lines : [''], 'blue');
+    const width = Math.max(40, Math.min(process.stdout.columns || 80, 80));
+    const line = '─'.repeat(width - 11);
+    console.log(chalk.blue.bold(`\n┌── Gemini ${line}`));
+    console.log(text);
+    console.log(chalk.blue.bold(`└──${'─'.repeat(width - 3)}`));
 }
 export function printModeChange(mode) {
     const label = mode === OrchestratorMode.PLAN ? chalk.magenta('Plan mode') : chalk.green('Normal mode');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gemini-coder",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "main": "dist/cli.js",
   "bin": {
@@ -13,7 +13,9 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "dev": "tsx src/cli.ts chat",
+    "dev:server": "tsx src/server.ts",
     "start": "node dist/cli.js chat",
+    "serve": "node dist/server.js",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {