🧪 [testing improvement] Add tests for JulesClient constructor

packages/cli/test/client.test.ts

@@ -0,0 +1,23 @@
+import { JulesClient } from '../src/client';
+import assert from 'node:assert';
+import { test } from 'node:test';
+
+test('JulesClient constructor uses provided API key', () => {
+  const apiKey = 'test-api-key';
+  const client = new JulesClient(apiKey);
+  assert.strictEqual((client as any).apiKey, apiKey);
+});
+
+test('JulesClient constructor uses API key from environment if not provided', (t) => {
+  const originalEnvKey = process.env.JULES_API_KEY;
+  // We use direct mutation here because process.env is a special object
+  // and node:test mocks are not yet compatible with it for simple property replacement.
+  // Using t.after ensures the environment is restored regardless of test outcome.
+  process.env.JULES_API_KEY = 'env-api-key';
+  t.after(() => {
+    process.env.JULES_API_KEY = originalEnvKey;
+  });
+
+  const client = new JulesClient();
+  assert.strictEqual((client as any).apiKey, 'env-api-key');
+});

temp_verify/src/auth.ts

@@ -0,0 +1,29 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+export function getApiKey(): string {
+  // 1. Check environment variable
+  const envKey = process.env.JULES_API_KEY;
+  if (envKey) {
+    return envKey;
+  }
+
+  // 2. Check config file: ~/.config/jules/config.json
+  const configPath = path.join(os.homedir(), '.config', 'jules', 'config.json');
+  try {
+    if (fs.existsSync(configPath)) {
+      const configContent = fs.readFileSync(configPath, 'utf8');
+      const config = JSON.parse(configContent);
+      if (config.apiKey) {
+        return config.apiKey;
+      }
+    }
+  } catch (error) {
+    console.error('Warning: could not read config file:', configPath);
+  }
+
+  // 3. Neither found, exit with error message
+  console.error('No API key found. Set JULES_API_KEY or run: jules_cli setup');
+  process.exit(1);
+}

temp_verify/src/client.ts

@@ -0,0 +1,114 @@
+import { getApiKey } from './auth.ts';
+
+const BASE_URL = 'https://jules.googleapis.com/v1alpha';
+
+export class JulesClient {
+  private apiKey: string;
+
+  constructor(apiKey?: string) {
+    this.apiKey = apiKey || getApiKey();
+  }
+
+  private getHeaders(): Record<string, string> {
+    return {
+      'x-goog-api-key': this.apiKey,
+      'Content-Type': 'application/json',
+    };
+  }
+
+  static async validateKey(apiKey: string): Promise<boolean> {
+    const response = await fetch(`${BASE_URL}/sessions`, {
+      method: 'GET',
+      headers: {
+        'x-goog-api-key': apiKey,
+        'Content-Type': 'application/json',
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to validate key: ${response.status} ${response.statusText}`);
+    }
+
+    return true;
+  }
+
+  async getSessions(): Promise<any> {
+    const response = await fetch(`${BASE_URL}/sessions`, {
+      method: 'GET',
+      headers: this.getHeaders(),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch sessions: ${response.status} ${response.statusText}`);
+    }
+
+    return response.json();
+  }
+
+  async getSession(id: string): Promise<any> {
+    const response = await fetch(`${BASE_URL}/sessions/${id}`, {
+      method: 'GET',
+      headers: this.getHeaders(),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch session: ${response.status} ${response.statusText}`);
+    }
+
+    return response.json();
+  }
+
+  async createSession(options: any): Promise<any> {
+    const response = await fetch(`${BASE_URL}/sessions`, {
+      method: 'POST',
+      headers: this.getHeaders(),
+      body: JSON.stringify(options),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to create session: ${response.status} ${response.statusText}`);
+    }
+
+    return response.json();
+  }
+
+  async approvePlan(id: string): Promise<any> {
+    const response = await fetch(`${BASE_URL}/sessions/${id}:approvePlan`, {
+      method: 'POST',
+      headers: this.getHeaders(),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to approve plan: ${response.status} ${response.statusText}`);
+    }
+
+    return response.json();
+  }
+
+  async sendMessage(id: string, message: string): Promise<any> {
+    const response = await fetch(`${BASE_URL}/sessions/${id}:sendMessage`, {
+      method: 'POST',
+      headers: this.getHeaders(),
+      body: JSON.stringify({ prompt: message }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to send message: ${response.status} ${response.statusText}`);
+    }
+
+    return response.json();
+  }
+
+  async getActivities(id: string): Promise<any> {
+    const response = await fetch(`${BASE_URL}/sessions/${id}/activities`, {
+      method: 'GET',
+      headers: this.getHeaders(),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch activities: ${response.status} ${response.statusText}`);
+    }
+
+    return response.json();
+  }
+}

temp_verify/test/client.test.ts

@@ -0,0 +1,18 @@
+import { JulesClient } from '../src/client.ts';
+import assert from 'node:assert';
+import { test } from 'node:test';
+import * as auth from '../src/auth.ts';
+
+test('JulesClient constructor uses provided API key', () => {
+  const apiKey = 'test-api-key';
+  const client = new JulesClient(apiKey);
+  assert.strictEqual((client as any).apiKey, apiKey);
+});
+
+test('JulesClient constructor uses API key from auth if not provided', (t) => {
+  // Use node:test mock.method to mock the getApiKey function from the auth module
+  t.mock.method(auth, 'getApiKey', () => 'mock-api-key');
+
+  const client = new JulesClient();
+  assert.strictEqual((client as any).apiKey, 'mock-api-key');
+});