@axhub/genie 0.1.8 → 0.2.0

package/server/external-agent/ws.test.js

@@ -0,0 +1,289 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import os from 'node:os';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+
+import { handleExternalAgentWebSocketConnection } from './ws.js';
+
+class FakeWebSocket extends EventEmitter {
+  constructor() {
+    super();
+    this.readyState = 1;
+    this.sent = [];
+  }
+
+  send(payload) {
+    this.sent.push(JSON.parse(String(payload)));
+  }
+
+  close() {
+    this.readyState = 3;
+    this.emit('close');
+  }
+
+  lastMessage() {
+    return this.sent[this.sent.length - 1] || null;
+  }
+}
+
+function attachSocket(socket) {
+  handleExternalAgentWebSocketConnection(socket, { user: null });
+  return socket;
+}
+
+function sendMessage(socket, payload) {
+  socket.emit('message', JSON.stringify(payload));
+}
+
+async function flushAsyncWork() {
+  await new Promise((resolve) => setImmediate(resolve));
+}
+
+async function createTempDir(prefix) {
+  return fs.mkdtemp(path.join(os.tmpdir(), `${prefix}-`));
+}
+
+async function waitFor(check, { timeoutMs = 1000, intervalMs = 10 } = {}) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    const result = check();
+    if (result) {
+      return result;
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+  throw new Error('Timed out waiting for async WebSocket message');
+}
+
+const TEST_PNG_DATA_URL =
+  'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO7Z0bUAAAAASUVORK5CYII=';
+
+test('integration.editor.clients.list returns connected frontend clients', async () => {
+  const frontend = attachSocket(new FakeWebSocket());
+  const external = attachSocket(new FakeWebSocket());
+
+  try {
+    sendMessage(frontend, {
+      type: 'integration.connect',
+      requestId: 'conn_frontend',
+      payload: {
+        role: 'frontend-page',
+        channel: 'project-a',
+        clientId: 'figma-123',
+        pageUrl: 'http://localhost:5173/session/1',
+        sessionId: 'session-1',
+        capabilities: ['editor.snapshot'],
+      },
+    });
+
+    sendMessage(external, {
+      type: 'integration.editor.clients.list',
+      requestId: 'editor_clients',
+      payload: {
+        channel: 'project-a',
+      },
+    });
+
+    const message = external.lastMessage();
+    assert.equal(message.type, 'integration.editor.clients.result');
+    assert.equal(message.requestId, 'editor_clients');
+    assert.equal(message.payload.total, 1);
+    assert.equal(message.payload.items[0].clientId, 'figma-123');
+    assert.deepEqual(message.payload.items[0].capabilities, ['editor.snapshot']);
+  } finally {
+    external.close();
+    frontend.close();
+  }
+});
+
+test('integration.editor.node.screenshot.result materializes frontend data URL on the server', async () => {
+  const frontend = attachSocket(new FakeWebSocket());
+  const external = attachSocket(new FakeWebSocket());
+  const outputDir = await createTempDir('axhub-genie-shot');
+
+  try {
+    sendMessage(frontend, {
+      type: 'integration.connect',
+      requestId: 'conn_frontend',
+      payload: {
+        role: 'frontend-page',
+        channel: 'project-a',
+        clientId: 'figma-123',
+        capabilities: ['editor.node.screenshot'],
+      },
+    });
+
+    sendMessage(external, {
+      type: 'integration.editor.node.screenshot.get',
+      requestId: 'editor_shot',
+      payload: {
+        channel: 'project-a',
+        targetClientId: 'figma-123',
+        elementKey: 'hero-card',
+        downloadPath: outputDir,
+      },
+    });
+
+    const forwardedRequest = frontend.lastMessage();
+    assert.equal(forwardedRequest.type, 'integration.editor.node.screenshot.get');
+    assert.equal(forwardedRequest.payload.downloadPath, outputDir);
+
+    sendMessage(frontend, {
+      type: 'integration.ack',
+      requestId: 'editor_shot',
+      payload: {
+        accepted: true,
+      },
+    });
+
+    sendMessage(frontend, {
+      type: 'integration.editor.node.screenshot.result',
+      requestId: 'editor_shot',
+      payload: {
+        width: 1440,
+        height: 640,
+        image: {
+          name: 'hero-card.png',
+          data: TEST_PNG_DATA_URL,
+        },
+      },
+    });
+
+    await flushAsyncWork();
+
+    const message = await waitFor(() => {
+      const last = external.lastMessage();
+      return last?.type === 'integration.editor.node.screenshot.result' ? last : null;
+    });
+    assert.equal(message.type, 'integration.editor.node.screenshot.result');
+    assert.equal(message.requestId, 'editor_shot');
+    assert.equal(message.payload.elementKey, 'hero-card');
+    assert.equal(message.payload.mimeType, 'image/png');
+    assert.equal(message.payload.width, 1440);
+    assert.equal(message.payload.height, 640);
+    assert.ok(path.isAbsolute(message.payload.absolutePath));
+    assert.ok(message.payload.absolutePath.startsWith(outputDir));
+
+    const stat = await fs.stat(message.payload.absolutePath);
+    assert.equal(stat.size, message.payload.size);
+  } finally {
+    external.close();
+    frontend.close();
+    await fs.rm(outputDir, { recursive: true, force: true });
+  }
+});
+
+test('integration.editor.context-images.result materializes frontend data URLs on the server', async () => {
+  const frontend = attachSocket(new FakeWebSocket());
+  const external = attachSocket(new FakeWebSocket());
+  const outputDir = await createTempDir('axhub-genie-context');
+
+  try {
+    sendMessage(frontend, {
+      type: 'integration.connect',
+      requestId: 'conn_frontend',
+      payload: {
+        role: 'frontend-page',
+        channel: 'project-a',
+        clientId: 'figma-123',
+        capabilities: ['editor.context-images'],
+      },
+    });
+
+    sendMessage(external, {
+      type: 'integration.editor.context-images.get',
+      requestId: 'editor_context_images',
+      payload: {
+        channel: 'project-a',
+        targetClientId: 'figma-123',
+        downloadPath: outputDir,
+      },
+    });
+
+    const forwardedRequest = frontend.lastMessage();
+    assert.equal(forwardedRequest.type, 'integration.editor.context-images.get');
+    assert.equal(forwardedRequest.payload.downloadPath, outputDir);
+
+    sendMessage(frontend, {
+      type: 'integration.editor.context-images.result',
+      requestId: 'editor_context_images',
+      payload: {
+        items: [
+          {
+            id: 'img_001',
+            name: 'clipboard-image-1.png',
+            createdAt: 1742547600000,
+            source: 'prompt-context',
+            data: TEST_PNG_DATA_URL,
+          },
+          {
+            id: 'img_002',
+            name: 'clipboard-image-2.png',
+            createdAt: 1742547600001,
+            source: 'prompt-context',
+            data: TEST_PNG_DATA_URL,
+          },
+        ],
+      },
+    });
+
+    await flushAsyncWork();
+
+    const message = await waitFor(() => {
+      const last = external.lastMessage();
+      return last?.type === 'integration.editor.context-images.result' ? last : null;
+    });
+    assert.equal(message.type, 'integration.editor.context-images.result');
+    assert.equal(message.requestId, 'editor_context_images');
+    assert.equal(message.payload.items.length, 2);
+
+    for (const item of message.payload.items) {
+      assert.equal(item.mimeType, 'image/png');
+      assert.ok(path.isAbsolute(item.absolutePath));
+      assert.ok(item.absolutePath.startsWith(outputDir));
+      const stat = await fs.stat(item.absolutePath);
+      assert.equal(stat.size, item.size);
+    }
+  } finally {
+    external.close();
+    frontend.close();
+    await fs.rm(outputDir, { recursive: true, force: true });
+  }
+});
+
+test('integration.editor.snapshot.get returns unsupported capability error when frontend lacks capability', async () => {
+  const frontend = attachSocket(new FakeWebSocket());
+  const external = attachSocket(new FakeWebSocket());
+
+  try {
+    sendMessage(frontend, {
+      type: 'integration.connect',
+      requestId: 'conn_frontend',
+      payload: {
+        role: 'frontend-page',
+        channel: 'project-a',
+        clientId: 'figma-123',
+        capabilities: ['context.update'],
+      },
+    });
+
+    sendMessage(external, {
+      type: 'integration.editor.snapshot.get',
+      requestId: 'editor_snapshot',
+      payload: {
+        channel: 'project-a',
+        targetClientId: 'figma-123',
+      },
+    });
+
+    const message = external.lastMessage();
+    assert.equal(message.type, 'integration.error');
+    assert.equal(message.requestId, 'editor_snapshot');
+    assert.equal(message.payload.code, 'UNSUPPORTED_FRONTEND_CAPABILITY');
+  } finally {
+    external.close();
+    frontend.close();
+  }
+});

package/server/gemini-cli.js

@@ -1,5 +1,6 @@
 import { spawn } from 'child_process';
 import crossSpawn from 'cross-spawn';
+import { resolveWorkingDirectory } from './utils/defaultWorkingDirectory.js';
 
 const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
 
@@ -101,11 +102,68 @@ function emitTextChunks(ws, sessionId, chunks) {
   });
 }
 
+function formatGeminiProcessError(code, stderrOutput) {
+  const normalizedStderr = String(stderrOutput || '').trim();
+  if (normalizedStderr) {
+    const apiMessageMatch =
+      normalizedStderr.match(/"message":"([^"]+)"/) ||
+      normalizedStderr.match(/message:\s*"([^"]+)"/i) ||
+      normalizedStderr.match(/ApiError:\s*\{.*?"message":"([^"]+)"/i) ||
+      normalizedStderr.match(/Error when talking to Gemini API[\s\S]*?message":"([^"]+)"/i);
+
+    if (apiMessageMatch?.[1]) {
+      return apiMessageMatch[1];
+    }
+
+    const firstMeaningfulLine = normalizedStderr
+      .split('\n')
+      .map((line) => line.trim())
+      .find((line) => line && !line.startsWith('at '));
+
+    if (firstMeaningfulLine) {
+      return firstMeaningfulLine;
+    }
+
+    return normalizedStderr;
+  }
+
+  return `Gemini CLI exited with code ${code}`;
+}
+
+function extractGeminiEventError(event) {
+  if (!event || typeof event !== 'object') {
+    return null;
+  }
+
+  const candidates = [
+    event?.error?.message,
+    event?.error?.details,
+    event?.result?.error?.message,
+    event?.result?.error,
+    event?.data?.error?.message,
+    event?.data?.error,
+    event?.message
+  ];
+
+  for (const candidate of candidates) {
+    const normalized = String(candidate || '').trim();
+    if (normalized) {
+      return normalized;
+    }
+  }
+
+  return null;
+}
+
 async function queryGemini(command, options = {}, ws) {
   return new Promise((resolve, reject) => {
     const { sessionId, cwd, projectPath, resume, model, permissionMode } = options;
     let capturedSessionId = sessionId;
     let sentSessionCreated = false;
+    let stderrBuffer = '';
+    let fatalErrorSent = false;
+    let sawSuccessfulTerminalEvent = false;
+    let sawErroredTerminalEvent = false;
 
     const args = ['-y', '@google/gemini-cli'];
 
@@ -126,7 +184,7 @@ async function queryGemini(command, options = {}, ws) {
       args.push('--yolo');
     }
 
-    const workingDir = cwd || projectPath || process.cwd();
+    const workingDir = resolveWorkingDirectory({ cwd, projectPath });
 
     const geminiProcess = spawnFunction('npx', args, {
       cwd: workingDir,
@@ -142,6 +200,19 @@ async function queryGemini(command, options = {}, ws) {
     activeGeminiProcesses.set(processRegistryKey, geminiProcess);
 
     const finalizeSessionId = () => capturedSessionId || sessionId || null;
+    const emitFatalError = (errorMessage) => {
+      if (fatalErrorSent || !errorMessage) {
+        return;
+      }
+
+      fatalErrorSent = true;
+      ws.send({
+        type: 'claude-error',
+        error: errorMessage,
+        provider: 'gemini',
+        sessionId: finalizeSessionId()
+      });
+    };
 
     const handleJsonEvent = (event) => {
       const incomingSessionId = event?.session_id || event?.sessionId || event?.data?.session_id || event?.data?.sessionId;
@@ -169,6 +240,15 @@ async function queryGemini(command, options = {}, ws) {
 
       const type = event?.type || event?.event || event?.kind;
       if (type === 'result' || type === 'done' || type === 'complete') {
+        const eventStatus = String(event?.status || event?.result?.status || '').trim().toLowerCase();
+        const eventError = extractGeminiEventError(event);
+        if (eventStatus === 'error' || eventError) {
+          sawErroredTerminalEvent = true;
+          emitFatalError(eventError || 'Gemini CLI request failed');
+          return;
+        }
+
+        sawSuccessfulTerminalEvent = true;
         ws.send({
           type: 'claude-response',
           data: { type: 'content_block_stop' },
@@ -204,11 +284,13 @@ async function queryGemini(command, options = {}, ws) {
     });
 
     geminiProcess.stderr.on('data', (data) => {
-      ws.send({
-        type: 'claude-error',
-        error: data.toString(),
-        sessionId: finalizeSessionId()
-      });
+      const chunk = data.toString();
+      stderrBuffer += chunk;
+
+      const normalizedChunk = chunk.trim();
+      if (normalizedChunk) {
+        console.warn('Gemini CLI stderr:', normalizedChunk);
+      }
     });
 
     geminiProcess.on('close', (code) => {
@@ -223,29 +305,35 @@ async function queryGemini(command, options = {}, ws) {
 
       activeGeminiProcesses.delete(processRegistryKey);
 
-      ws.send({
-        type: 'claude-complete',
-        sessionId: finalizeSessionId(),
-        provider: 'gemini',
-        exitCode: code,
-        isNewSession: !sessionId && !!command
-      });
+      if (code === 0 && !sawErroredTerminalEvent) {
+        if (!sawSuccessfulTerminalEvent) {
+          ws.send({
+            type: 'claude-response',
+            data: { type: 'content_block_stop' },
+            provider: 'gemini',
+            sessionId: finalizeSessionId()
+          });
+        }
 
-      if (code === 0) {
+        ws.send({
+          type: 'claude-complete',
+          sessionId: finalizeSessionId(),
+          provider: 'gemini',
+          exitCode: code,
+          isNewSession: !sessionId && !!command
+        });
         resolve();
       } else {
-        reject(new Error(`Gemini CLI exited with code ${code}`));
+        const errorMessage = formatGeminiProcessError(code, stderrBuffer);
+        emitFatalError(errorMessage);
+        reject(new Error(errorMessage));
       }
     });
 
     geminiProcess.on('error', (error) => {
       activeGeminiProcesses.delete(processRegistryKey);
 
-      ws.send({
-        type: 'claude-error',
-        error: error.message,
-        sessionId: finalizeSessionId()
-      });
+      emitFatalError(error.message);
 
       reject(error);
     });