Skip to content

armgit / Orkas

Public Imported from GitHub
0

Orkas is an open-source (MIT), local-first AI team for your desktop: a Commander turns your goal into to-dos and coordinates 16 built-in specialist agents plus Claude Code, Codex, OpenCode, OpenClaw and Hermes, with projects, scheduled automations and connectors. Free app for macOS & Windows; built-in models or your own keys.

16.3 KB
Raw Blame
import { readFileSync } from 'node:fs';
import { resolve } from 'node:path';
import vm from 'node:vm';
import { describe, expect, it, vi } from 'vitest';
import { LOCALES } from '../../src/main/i18n';

class FakeElement {
  value = '';
  hidden = false;
  disabled = false;
  textContent = '';
  className = '';
  innerHTML = '';
  dataset: Record<string, string> = {};
  style: Record<string, string> = {};
  children: FakeElement[] = [];
  private readonly attributes = new Map<string, string>();
  private readonly listeners = new Map<string, Array<(event?: any) => unknown>>();

  setAttribute(name: string, value: string) { this.attributes.set(name, value); }
  getAttribute(name: string) { return this.attributes.get(name) || null; }
  removeAttribute(name: string) { this.attributes.delete(name); }
  appendChild(child: FakeElement) { this.children.push(child); return child; }
  querySelector() { return null; }
  focus() { this.setAttribute('data-focused', 'true'); }

  addEventListener(type: string, handler: (event?: any) => unknown) {
    const handlers = this.listeners.get(type) || [];
    handlers.push(handler);
    this.listeners.set(type, handlers);
  }

  async dispatch(type: string, event: Record<string, unknown> = {}) {
    for (const handler of this.listeners.get(type) || []) {
      await handler({ currentTarget: this, target: this, preventDefault: vi.fn(), ...event });
    }
  }

  click() { return this.dispatch('click'); }
}

function loadQuickSetupHarness(language = 'en') {
  const source = readFileSync(resolve(__dirname, '../../src/renderer/modules/settings.js'), 'utf8');
  const html = readFileSync(resolve(__dirname, '../../src/renderer/index.html'), 'utf8');
  const elements = new Map<string, FakeElement>();
  for (const id of [
    'settings-orkas-api-create-key',
    'settings-orkas-api-key-input',
    'settings-orkas-api-configure',
    'settings-orkas-api-status',
    'settings-orkas-api-saved',
    'settings-orkas-api-key-masked',
    'settings-orkas-api-edit',
    'settings-orkas-api-delete',
    'settings-orkas-api-editor',
    'settings-orkas-api-cancel',
    'settings-entries',
    'settings-search-entries',
    'settings-image-entries',
    'settings-video-entries',
    'settings-tts-entries',
  ]) elements.set(id, new FakeElement());

  const invoke = vi.fn(async (channel: string) => {
    if (channel === 'orkasApi.getStatus') return {
      ok: true,
      configured: false,
      keyMasked: '',
      name: '',
      connectorAccess: false,
    };
    if (channel === 'orkasApi.save') return {
      ok: true,
      configured: true,
      keyMasked: 'orka…-key',
      name: 'Desktop key',
      connectorAccess: true,
    };
    if (channel === 'orkasApi.remove') return { ok: true, removed: true };
    return { ok: true };
  });
  const refreshModelGuard = vi.fn(async () => true);
  const context: any = {
    console,
    createLogger: () => ({ info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() }),
    escapeHtml: (value: unknown) => String(value ?? ''),
    t: (key: string) => key,
    getLang: () => language,
    document: {
      getElementById: (id: string) => elements.get(id) || null,
      createElement: () => new FakeElement(),
      querySelectorAll: () => [],
      addEventListener: vi.fn(),
      removeEventListener: vi.fn(),
    },
    window: {
      addEventListener: vi.fn(),
      orkas: { invoke },
    },
    setTimeout,
    clearTimeout,
    setInterval,
    clearInterval,
    URL,
    refreshModelGuard,
    uiConfirm: vi.fn(async () => true),
  };
  vm.createContext(context);
  vm.runInContext(source, context, { filename: 'settings.js' });
  vm.runInContext(`
    window.__orkasApiRefreshes = 0;
    _settingsRefreshAllCredentialSections = async () => { window.__orkasApiRefreshes += 1; };
    _settingsBindOrkasApiOnce();
  `, context);
  return { context, elements, html, source, invoke, refreshModelGuard };
}

describe('Orkas public API quick setup', () => {
  it('uses the approved maximum saving in every locale and the initial settings paint', () => {
    const html = readFileSync(resolve(__dirname, '../../src/renderer/index.html'), 'utf8');
    for (const { code } of LOCALES) {
      const catalog = JSON.parse(readFileSync(
        resolve(__dirname, `../../src/renderer/locales/${code}.json`), 'utf8',
      ));
      for (const key of ['price_comparison.maximum', 'new_chat.model_picker.recommended_with_savings']) {
        expect(catalog[key], `${code}: ${key}`).toContain('50');
        expect(catalog[key], `${code}: ${key}`).not.toContain('60');
      }
      if (code === 'en') {
        expect(html).toContain(`data-i18n="price_comparison.maximum">${catalog['price_comparison.maximum']}</span>`);
        expect(catalog['price_comparison.maximum']).toBe('Model costs up to 50% less than provider API pricing');
      }
      if (code === 'zh') expect(catalog['price_comparison.maximum']).toBe('模型费用较厂商 API 最高省 50%');
    }
  });

  it('uses concise configure copy in every supported locale', () => {
    const html = readFileSync(resolve(__dirname, '../../src/renderer/index.html'), 'utf8');
    expect(html).toContain('data-i18n="settings.orkas_api.configure">Configure</button>');

    const expected = { en: 'Configure', zh: '配置', ja: '設定', pt: 'Configurar' };
    for (const [locale, copy] of Object.entries(expected)) {
      const catalog = JSON.parse(readFileSync(
        resolve(__dirname, `../../src/renderer/locales/${locale}.json`),
        'utf8',
      ));
      expect(catalog['settings.orkas_api.configure']).toBe(copy);
      expect(catalog).not.toHaveProperty('settings.orkas_api.configure_all');
    }
  });

  it('uses the standard settings card background and border', () => {
    const css = readFileSync(resolve(__dirname, '../../src/renderer/style.css'), 'utf8');
    expect(css).toMatch(/\.settings-group\s*{[^}]*background:\s*var\(--surface\);[^}]*border:\s*1px solid var\(--border\);/s);
    expect(css).not.toContain('.settings-orkas-api-group::before');
    expect(css).not.toMatch(/\.settings-orkas-api-group\s*{[^}]*(?:linear-gradient|border-color)/s);
  });

  it('lays out saved credentials and editing actions without exposing the raw key', () => {
    const css = readFileSync(resolve(__dirname, '../../src/renderer/style.css'), 'utf8');
    expect(css).toMatch(/\.settings-orkas-api-group\s*{[^}]*display:\s*grid;[^}]*grid-template-columns:\s*minmax\(0,\s*1fr\)\s+max-content;/s);
    expect(css).toMatch(/\.settings-orkas-api-head\s*{[^}]*display:\s*contents;/s);
    expect(css).toContain('.settings-orkas-api-saved');
    expect(css).toContain('.settings-orkas-api-key-summary code');
    expect(css).toContain('.settings-orkas-api-actions');
  });

  it('uses the complete Orkas service labels in pickers and configured rows', () => {
    const { context, elements, source } = loadQuickSetupHarness();
    expect(source).not.toContain("label: 'Orkas API'");
    expect(vm.runInContext("_SEARCH_PROVIDER_OPTIONS.find((p) => p.id === 'orkas-api').label", context))
      .toBe('Orkas · Search');
    expect(vm.runInContext("_IMAGE_PROVIDER_OPTIONS.find((p) => p.id === 'orkas-api').label", context))
      .toBe('Orkas · Image');
    expect(vm.runInContext("_VIDEO_AUTH_PROVIDER_OPTIONS.find((p) => p.id === 'orkas-api').label", context))
      .toBe('Orkas · Video');
    expect(vm.runInContext("_ttsProviderLabel('orkas-api')", context)).toBe('Orkas · Voice');

    vm.runInContext(`
      _settingsAttachReorderDnd = () => {};
      _settingsState.searchProfiles = [{ id: 's1', provider: 'orkas-api', label: 'Orkas', apiKeyMasked: 'sk-…1' }];
      _settingsState.imageProfiles = [
        { id: 'i1', provider: 'orkas-api', model: 'orkas-image', label: 'Orkas', apiKeyMasked: 'sk-…1' },
        { id: 'i2', provider: 'openai', model: 'gpt-image-2', label: 'Personal', apiKeyMasked: 'sk-…2' }
      ];
      _settingsState.videoProfiles = [{ id: 'v1', provider: 'orkas-api', model: 'orkas-video', label: 'Orkas', apiKeyMasked: 'sk-…1' }];
      _settingsState.ttsProfiles = [{ id: 't1', provider: 'orkas-api', model: 'orkas-tts-1', label: 'Orkas', apiKeyMasked: 'sk-…1' }];
      _settingsRenderSearchEntries();
      _settingsRenderImageEntries();
      _settingsRenderVideoEntries();
      _settingsRenderTtsEntries();
    `, context);

    const configuredLabel = (id: string) => elements.get(id)!
      .children[0]!.children[1]!.children[0]!.innerHTML;
    expect(configuredLabel('settings-search-entries')).toContain('>Orkas · Search</span>');
    expect(configuredLabel('settings-image-entries')).toContain('>Orkas · Image</span>');
    expect(configuredLabel('settings-video-entries')).toContain('>Orkas · Video</span>');
    expect(configuredLabel('settings-tts-entries')).toContain('>Orkas · Voice</span>');
    const mediaDetails = (id: string, index = 0) => elements.get(id)!.children[index]!.children[1]!.children
      .filter(child => child.className.includes('entry-media-model')).map(child => child.textContent);
    expect(mediaDetails('settings-image-entries')).toEqual(['Seedream 5.0 Flash']);
    expect(mediaDetails('settings-video-entries')).toEqual(['Seedance 2.0/2.5']);
    expect(mediaDetails('settings-image-entries', 1)).toEqual([]);
    expect(mediaDetails('settings-search-entries')).toEqual([]);
    expect(mediaDetails('settings-tts-entries')).toEqual([]);
    expect(source).toContain('settings.orkas_api.recommended');
    expect(source).toContain('settings.orkas_api.includes');
  });

  it('renders both configured official model rows in Settings', () => {
    const { context, elements } = loadQuickSetupHarness();
    const zh = JSON.parse(readFileSync(resolve(__dirname, '../../src/renderer/locales/zh.json'), 'utf8'));
    context.t = (key: string, values?: { models?: string }) => String(zh[key] || key)
      .replace('{models}', values?.models || '');
    vm.runInContext(`
      _settingsAttachReorderDnd = () => {};
      _settingsState.entries = [
        {
          entryId: 'orkas-standard', provider: 'orkas-api', providerLabel: 'Orkas',
          model: 'orkas-llm-1.5', modelName: 'Orkas-1.5', modelEditable: false,
          modelAvailable: true, official: true, recommended: true,
          includedModels: ['DeepSeek V4.1 Flash', 'GPT-6 Luna', 'Claude-Sonnet-5', 'Gemini-3.8 Flash'],
          profileType: 'api_key', profileAvailable: true, profileLabel: 'Orkas'
        },
        {
          entryId: 'orkas-pro', provider: 'orkas-api', providerLabel: 'Orkas',
          model: 'orkas-llm-1.5-pro', modelName: 'Orkas-1.5 Pro', modelEditable: false,
          modelAvailable: true, official: true,
          includedModels: ['GPT-6.1 Sol', 'Claude Opus 5.5', 'Kimi K3'],
          profileType: 'api_key', profileAvailable: true, profileLabel: 'Orkas'
        }
      ];
      _settingsRenderEntries();
    `, context);

    const rows = elements.get('settings-entries')!.children;
    expect(rows).toHaveLength(2);
    expect(rows[0]!.children[1]!.children[0]!.innerHTML).toContain('Orkas-1.5');
    expect(rows[0]!.children[1]!.children[0]!.innerHTML).toContain('推荐 · 较厂商 API 最高省 50%');
    expect(rows[1]!.children[1]!.children[0]!.innerHTML).toContain('Orkas-1.5 Pro');
    expect(rows[1]!.children[1]!.children[0]!.innerHTML).not.toContain('50%');
    expect(rows[0]!.children[1]!.children[1]!.children[1]!.textContent)
      .toContain('DeepSeek V4.1 Flash · GPT-6 Luna · Claude-Sonnet-5 · Gemini-3.8 Flash');
    expect(rows[1]!.children[1]!.children[1]!.children[1]!.textContent)
      .toContain('GPT-6.1 Sol · Claude Opus 5.5 · Kimi K3');
  });

  it('saves the shared credential without a success label from the real card click binding', async () => {
    const { context, elements, html, source, invoke, refreshModelGuard } = loadQuickSetupHarness();
    for (const id of [
      'settings-orkas-api-group',
      'settings-orkas-api-key-input',
      'settings-orkas-api-configure',
      'settings-orkas-api-edit',
      'settings-orkas-api-delete',
    ]) expect(html).toContain(`id="${id}"`);
    expect(source).toContain('orkasApi.remove');
    expect(source).not.toContain('/v1/capabilities');

    elements.get('settings-orkas-api-key-input')!.value = '  public-orkas-key  ';
    await elements.get('settings-orkas-api-create-key')!.click();
    await elements.get('settings-orkas-api-configure')!.click();

    expect(invoke).toHaveBeenCalledWith('auth.openExternal', {
      url: 'https://orkas.ai/views/account/account.html?lang=en#api-keys',
    });
    expect(invoke).toHaveBeenCalledWith('orkasApi.save', {
      apiKey: 'public-orkas-key',
    });
    expect(elements.get('settings-orkas-api-key-input')!.value).toBe('');
    expect(vm.runInContext('window.__orkasApiRefreshes', context)).toBe(1);
    expect(refreshModelGuard).toHaveBeenCalledOnce();
    const status = elements.get('settings-orkas-api-status')!;
    expect(status.textContent).toBe('');
    expect(status.getAttribute('data-i18n')).toBeNull();
    context.t = (key: string) => `translated:${key}`;
    vm.runInContext('_settingsRenderOrkasApiCard()', context);
    expect(status.textContent).toBe('');
  });

  it('keeps the masked credential visible and supports edit and delete', async () => {
    const { context, elements, invoke } = loadQuickSetupHarness();
    vm.runInContext(`
      _settingsState.orkasApiCredential = {
        configured: true,
        keyMasked: 'orka…1234',
        name: 'Desktop key',
        connectorAccess: true,
      };
      _settingsRenderOrkasApiCard();
    `, context);

    expect(elements.get('settings-orkas-api-saved')!.hidden).toBe(false);
    expect(elements.get('settings-orkas-api-editor')!.hidden).toBe(true);
    expect(elements.get('settings-orkas-api-key-masked')!.textContent).toBe('orka…1234');

    await elements.get('settings-orkas-api-edit')!.click();
    expect(elements.get('settings-orkas-api-editor')!.hidden).toBe(false);
    expect(elements.get('settings-orkas-api-key-input')!.getAttribute('data-focused')).toBe('true');

    await elements.get('settings-orkas-api-delete')!.click();
    expect(invoke).toHaveBeenCalledWith('orkasApi.remove');
    const status = elements.get('settings-orkas-api-status')!;
    expect(status.textContent).toBe('');
    expect(status.getAttribute('data-i18n')).toBeNull();
    context.t = (key: string) => `translated:${key}`;
    vm.runInContext('_settingsRenderOrkasApiCard()', context);
    expect(status.textContent).toBe('');
  });

  it.each(['zh', 'en', 'ja', 'pt'])('carries the %s desktop language to the API-key page', async (language) => {
    const { elements, invoke } = loadQuickSetupHarness(language);

    await elements.get('settings-orkas-api-create-key')!.click();

    expect(invoke).toHaveBeenCalledWith('auth.openExternal', {
      url: `https://orkas.ai/views/account/account.html?lang=${language}#api-keys`,
    });
  });

  it('preserves existing query parameters and fragments while localizing Orkas Web URLs', () => {
    const { context } = loadQuickSetupHarness('ja');

    expect(vm.runInContext(
      "_settingsLocalizedOrkasWebUrl('https://orkas.ai/views/account/account.html?source=settings#api-keys')",
      context,
    )).toBe('https://orkas.ai/views/account/account.html?source=settings&lang=ja#api-keys');
    expect(vm.runInContext(
      "_settingsLocalizedOrkasWebUrl('https://example.com/account?source=settings#api-keys')",
      context,
    )).toBe('https://example.com/account?source=settings#api-keys');
  });

  it('keeps setup errors bound to an i18n key after language changes', async () => {
    const { context, elements } = loadQuickSetupHarness();
    await elements.get('settings-orkas-api-configure')!.click();

    const status = elements.get('settings-orkas-api-status')!;
    expect(status.getAttribute('data-i18n')).toBe('settings.orkas_api.key_required');
    context.t = (key: string) => `translated:${key}`;
    vm.runInContext('_settingsRenderOrkasApiCard()', context);
    expect(status.textContent).toBe('translated:settings.orkas_api.key_required');
  });

  it('supports Enter to configure and blocks an empty key before IPC', async () => {
    const { elements, invoke } = loadQuickSetupHarness();
    const keyInput = elements.get('settings-orkas-api-key-input')!;
    await keyInput.dispatch('keydown', { key: 'Enter', isComposing: false });
    expect(invoke).not.toHaveBeenCalledWith('orkasApi.save', expect.anything());

    keyInput.value = 'enter-key';
    await keyInput.dispatch('keydown', { key: 'Enter', isComposing: false });
    expect(invoke).toHaveBeenCalledWith('orkasApi.save', { apiKey: 'enter-key' });
  });
});