@axhub/genie 0.2.7 → 0.2.8

package/server/acp-runtime/session-store.test.js

@@ -1,89 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'fs/promises';
-import os from 'os';
-import path from 'path';
-import test from 'node:test';
-import { pathToFileURL } from 'node:url';
-
-async function loadSessionStore(sessionRoot) {
-  process.env.AXHUB_GENIE_ACP_SESSION_ROOT = sessionRoot;
-  const moduleUrl = `${pathToFileURL(path.resolve('server/acp-runtime/session-store.js')).href}?root=${encodeURIComponent(sessionRoot)}&ts=${Date.now()}`;
-  return import(moduleUrl);
-}
-
-async function createTempSessionRoot() {
-  return fs.mkdtemp(path.join(os.tmpdir(), 'axhub-genie-acp-sessions-'));
-}
-
-test('session-store persists and lists ACP sessions', async () => {
-  const sessionRoot = await createTempSessionRoot();
-
-  try {
-    const sessionStore = await loadSessionStore(sessionRoot);
-
-    await sessionStore.writeAcpSessionRecord({
-      provider: 'claude',
-      sessionId: 'session-a',
-      projectPath: '/tmp/project-a',
-      model: 'claude-sonnet-4',
-      title: 'Session A',
-      lastActivity: '2026-03-30T10:00:00.000Z',
-      lastPromptAt: '2026-03-30T10:00:00.000Z'
-    });
-
-    const record = await sessionStore.readAcpSessionRecord('claude', 'session-a');
-    assert.equal(record.provider, 'claude');
-    assert.equal(record.sessionId, 'session-a');
-    assert.equal(record.projectPath, '/tmp/project-a');
-
-    const sessions = await sessionStore.listAcpSessions({
-      provider: 'claude',
-      projectPath: '/tmp/project-a'
-    });
-
-    assert.equal(sessions.length, 1);
-    assert.equal(sessions[0].id, 'session-a');
-    assert.equal(sessions[0].model, 'claude-sonnet-4');
-    assert.equal(sessions[0].source, 'acp');
-  } finally {
-    delete process.env.AXHUB_GENIE_ACP_SESSION_ROOT;
-    await fs.rm(sessionRoot, { recursive: true, force: true });
-  }
-});
-
-test('session-store GC removes only stale closed session records by default', async () => {
-  const sessionRoot = await createTempSessionRoot();
-
-  try {
-    const sessionStore = await loadSessionStore(sessionRoot);
-
-    await sessionStore.writeAcpSessionRecord({
-      provider: 'codex',
-      sessionId: 'closed-session',
-      projectPath: '/tmp/project-b',
-      lastActivity: '2025-01-01T00:00:00.000Z',
-      closedAt: '2025-01-01T00:00:00.000Z',
-      isClosed: true
-    });
-
-    await sessionStore.writeAcpSessionRecord({
-      provider: 'codex',
-      sessionId: 'open-session',
-      projectPath: '/tmp/project-b',
-      lastActivity: '2025-01-01T00:00:00.000Z',
-      isClosed: false
-    });
-
-    const gcResult = await sessionStore.gcOldAcpSessions({
-      provider: 'codex',
-      maxAgeDays: 30
-    });
-
-    assert.equal(gcResult.removed, 1);
-    assert.equal(await sessionStore.readAcpSessionRecord('codex', 'closed-session'), null);
-    assert.ok(await sessionStore.readAcpSessionRecord('codex', 'open-session'));
-  } finally {
-    delete process.env.AXHUB_GENIE_ACP_SESSION_ROOT;
-    await fs.rm(sessionRoot, { recursive: true, force: true });
-  }
-});

package/server/cli.test.js

@@ -1,76 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import {
-  buildEditorRequest,
-  deriveExternalAgentWebSocketUrl,
-  normalizeApiBaseUrl,
-  parseArgs,
-} from './cli.js';
-
-test('parseArgs collects nested editor positionals and options', () => {
-  const parsed = parseArgs([
-    'editor',
-    'nodes',
-    'list',
-    '--channel',
-    'project-a',
-    '--target-client-id',
-    'figma-123',
-    '--status',
-    'pending-dispatch,dirty',
-    '--limit',
-    '25',
-  ]);
-
-  assert.deepEqual(parsed.positionals, ['editor', 'nodes', 'list']);
-  assert.equal(parsed.options.channel, 'project-a');
-  assert.equal(parsed.options.targetClientId, 'figma-123');
-  assert.equal(parsed.options.status, 'pending-dispatch,dirty');
-  assert.equal(parsed.options.limit, '25');
-});
-
-test('parseArgs accepts default working directory aliases', () => {
-  const parsed = parseArgs([
-    'start',
-    '--cwd',
-    './workspace',
-  ]);
-
-  assert.deepEqual(parsed.positionals, ['start']);
-  assert.equal(parsed.options.defaultProjectPath, './workspace');
-});
-
-test('buildEditorRequest creates clients list request without target client', () => {
-  const request = buildEditorRequest(['editor', 'clients', 'list'], {
-    channel: 'project-a',
-  });
-
-  assert.equal(request.message.type, 'integration.editor.clients.list');
-  assert.equal(request.message.payload.channel, 'project-a');
-  assert.equal(request.targetClientId, null);
-});
-
-test('buildEditorRequest creates screenshot request with resolved download path', () => {
-  const request = buildEditorRequest(['editor', 'node', 'screenshot'], {
-    channel: 'project-a',
-    targetClientId: 'figma-123',
-    elementKey: 'hero-card',
-    outputDir: '.',
-  });
-
-  assert.equal(request.message.type, 'integration.editor.node.screenshot.get');
-  assert.equal(request.message.payload.channel, 'project-a');
-  assert.equal(request.message.payload.targetClientId, 'figma-123');
-  assert.equal(request.message.payload.elementKey, 'hero-card');
-  assert.ok(request.message.payload.downloadPath.endsWith('/AI-Web-UI'));
-});
-
-test('normalizeApiBaseUrl trims trailing slashes', () => {
-  assert.equal(normalizeApiBaseUrl('http://localhost:32123/api///'), 'http://localhost:32123/api');
-});
-
-test('deriveExternalAgentWebSocketUrl switches to ws and preserves apiKey', () => {
-  const url = deriveExternalAgentWebSocketUrl('http://localhost:32123/api', 'ck_test');
-  assert.equal(url, 'ws://localhost:32123/api/agent/ws?apiKey=ck_test');
-});

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

@@ -1,53 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import path from 'path';
-
-import { normalizeExternalAgentRunRequest } from './service.js';
-
-const DEFAULT_WORKDIR_ENV = 'AXHUB_GENIE_DEFAULT_PROJECT_PATH';
-const originalDefaultWorkdir = process.env[DEFAULT_WORKDIR_ENV];
-
-test.afterEach(() => {
-  if (originalDefaultWorkdir === undefined) {
-    delete process.env[DEFAULT_WORKDIR_ENV];
-    return;
-  }
-
-  process.env[DEFAULT_WORKDIR_ENV] = originalDefaultWorkdir;
-});
-
-test('normalizeExternalAgentRunRequest falls back to configured default project path', () => {
-  process.env[DEFAULT_WORKDIR_ENV] = '/tmp/axhub-default-project';
-
-  const normalized = normalizeExternalAgentRunRequest({
-    provider: 'codex',
-    message: 'Inspect the repository',
-    stream: false
-  });
-
-  assert.equal(normalized.projectPath, path.resolve('/tmp/axhub-default-project'));
-});
-
-test('normalizeExternalAgentRunRequest falls back to process cwd when no project path is provided', () => {
-  delete process.env[DEFAULT_WORKDIR_ENV];
-
-  const normalized = normalizeExternalAgentRunRequest({
-    provider: 'codex',
-    message: 'Inspect the repository',
-    stream: false
-  });
-
-  assert.equal(normalized.projectPath, process.cwd());
-});
-
-test('normalizeExternalAgentRunRequest rejects deprecated GitHub parameters', () => {
-  assert.throws(() => {
-    normalizeExternalAgentRunRequest({
-      provider: 'codex',
-      message: 'Inspect the repository',
-      githubUrl: 'https://github.com/example/repo'
-    });
-  }, {
-    message: /Unsupported parameters: githubUrl/
-  });
-});

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

@@ -1,289 +0,0 @@
-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();
-  }
-});