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.

21.9 KB
Raw Blame
import { describe, expect, it, vi } from 'vitest';
import * as fs from 'node:fs';
import * as path from 'node:path';
import * as vm from 'node:vm';

type Listener = (event: any) => any;

function fakeClassList() {
  const values = new Set<string>();
  return {
    add: (...names: string[]) => names.forEach((name) => values.add(name)),
    remove: (...names: string[]) => names.forEach((name) => values.delete(name)),
    contains: (name: string) => values.has(name),
    toggle: (name: string, force?: boolean) => {
      const shouldAdd = force == null ? !values.has(name) : force;
      if (shouldAdd) values.add(name);
      else values.delete(name);
      return shouldAdd;
    },
  };
}

function loadProjectDetailScript() {
  const source = fs.readFileSync(
    path.join(__dirname, '../../src/renderer/modules/project-detail.js'),
    'utf8',
  );
  const context: any = {
    AbortController,
    ArrayBuffer,
    Blob,
    clearTimeout,
    performance,
    setTimeout,
    Uint8Array,
    btoa: (value: string) => Buffer.from(value, 'binary').toString('base64'),
    // Uploads encode through the shared renderer helper (utils.js).
    // eslint-disable-next-line @typescript-eslint/no-var-requires
    _arrayBufferToBase64: require('../../src/renderer/modules/utils.js')._arrayBufferToBase64,
    createLogger: () => ({ error: vi.fn(), info: vi.fn(), warn: vi.fn() }),
    escapeHtml: (value: unknown) => String(value ?? ''),
    t: (key: string, vars?: Record<string, unknown>) => `${key}:${JSON.stringify(vars || {})}`,
    window: {
      addEventListener: vi.fn(),
      orkas: { invoke: vi.fn() },
    },
    document: {
      readyState: 'loading',
      addEventListener: vi.fn(),
      getElementById: vi.fn(() => null),
      querySelector: vi.fn(() => null),
      querySelectorAll: vi.fn(() => []),
    },
  };
  vm.createContext(context);
  vm.runInContext(source, context, { filename: 'project-detail.js' });
  vm.runInContext("_projectDetailPid = 'project-1'", context);
  return context;
}

function makeRow(kind: 'dir' | 'file', rel: string) {
  const rowListeners: Record<string, Listener> = {};
  const nodeListeners: Record<string, Listener> = {};
  const node = {
    addEventListener: (name: string, listener: Listener) => { nodeListeners[name] = listener; },
    classList: fakeClassList(),
  };
  const row = {
    addEventListener: (name: string, listener: Listener) => { rowListeners[name] = listener; },
    classList: fakeClassList(),
    dataset: kind === 'dir'
      ? { type: 'dir', projectDir: rel }
      : { type: 'file', projectFile: rel, projectFileKind: 'text' },
    querySelector: () => node,
  };
  return { kind, node, nodeListeners, rel, row, rowListeners };
}

function makeTree(rows: ReturnType<typeof makeRow>[] = []) {
  const rootListeners: Record<string, Listener> = {};
  const root = {
    addEventListener: (name: string, listener: Listener) => { rootListeners[name] = listener; },
    classList: fakeClassList(),
    contains: () => false,
    dataset: {} as Record<string, string>,
    innerHTML: '',
    querySelectorAll: (selector: string) => {
      if (selector === '.project-dir-row[data-project-dir]') {
        return rows.filter((entry) => entry.kind === 'dir').map((entry) => entry.row);
      }
      if (selector === '.project-file-row[data-project-file]') {
        return rows.filter((entry) => entry.kind === 'file').map((entry) => entry.row);
      }
      if (selector === '.ctx-tree-wrap[data-type]') return rows.map((entry) => entry.row);
      if (selector === '.skill-tree-node.is-drag-over') {
        return rows.map((entry) => entry.node)
          .filter((node) => node.classList.contains('is-drag-over'));
      }
      return [];
    },
  };
  return { root, rootListeners };
}

function makeDropSurface() {
  const listeners: Record<string, Listener> = {};
  const surface = {
    addEventListener: (name: string, listener: Listener) => { listeners[name] = listener; },
    classList: fakeClassList(),
    contains: () => false,
    dataset: {} as Record<string, string>,
  };
  return { listeners, surface };
}

function dropEvent(dataTransfer: any, closestRow: any = null) {
  return {
    dataTransfer,
    preventDefault: vi.fn(),
    stopPropagation: vi.fn(),
    target: {
      closest: (selector: string) => selector === '.ctx-tree-wrap' ? closestRow : null,
    },
  };
}

describe('Project Library external file drag-and-drop', () => {
  it.each(['project', 'account'])('stops later upload dialogs after %s changes while the first message is open', async scope => {
    const context = loadProjectDetailScript();
    context.currentUserId = 'first';
    context.window.orkas.invoke = vi.fn(async () => ({ ok: false }));
    context.loadProjectDetail = vi.fn(async () => {});
    let release!: () => void, shown!: () => void;
    const waiting = new Promise<void>(resolve => { shown = resolve; });
    context.uiAlert = vi.fn(() => { shown(); return new Promise<void>(resolve => { release = resolve; }); });
    const files = [
      { name: 'unsupported.zip', size: 1 }, { name: '.hidden.md', size: 1 },
      { name: 'failed.md', size: 1, arrayBuffer: async () => new ArrayBuffer(1) },
    ];
    const uploading = context._uploadProjectFiles(files, '', 'drop');
    await waiting;
    expect(context.uiAlert.mock.calls[0][0]).toContain('contexts.upload_rejected');
    if (scope === 'account') context.currentUserId = 'second';
    else vm.runInContext("_projectDetailPid = 'project-2'", context);
    release(); await uploading;
    expect(context.uiAlert).toHaveBeenCalledOnce();
    expect(context.loadProjectDetail).not.toHaveBeenCalled();
    expect(context.window.orkas.invoke).toHaveBeenCalledOnce();
  });

  it.each([
    ['drop', 'project', 'success'], ['drop', 'project', 'failure'], ['drop', 'project', 'rejection'],
    ['drop', 'account', 'success'], ['drop', 'account', 'failure'], ['drop', 'account', 'rejection'],
    ['native', 'project', 'success'], ['native', 'project', 'failure'], ['native', 'project', 'rejection'], ['native', 'project', 'cancelled'],
    ['native', 'account', 'success'], ['native', 'account', 'failure'], ['native', 'account', 'rejection'], ['native', 'account', 'cancelled'],
  ])('isolates late %s upload %s/%s from the current view and account', async (method, scope, outcome) => {
    const context = loadProjectDetailScript();
    context.currentUserId = 'first';
    context.uiAlert = vi.fn(async () => {});
    context.loadProjectDetail = vi.fn(async () => {});
    context._setProjectFilesStatus = vi.fn();
    vm.runInContext(`_projectDetailResolvedPid = 'project-1'; _projectDetailMeta = {
      project: { project_id: 'project-1' } };`, context);
    let release!: () => void, started!: () => void;
    const waiting = new Promise<void>(resolve => { started = resolve; });
    const response = new Promise((resolve, reject) => {
      release = () => outcome === 'rejection' ? reject(new Error('synthetic upload failure'))
        : resolve(outcome === 'cancelled' ? { ok: true, cancelled: true, files: [] }
          : { ok: outcome === 'success', files: [{ ok: outcome === 'success', name: 'old.md' }] });
    });
    context.window.orkas.invoke = vi.fn((channel: string) => {
      expect(channel).toBe(method === 'native' ? 'projects.files.pickAndUpload' : 'projects.files.upload');
      started(); return response;
    });
    const file = { name: 'old.md', size: 1, arrayBuffer: async () => new ArrayBuffer(1) };
    const uploading = method === 'native' ? context._uploadProjectFilesNative('')
      : context._uploadProjectFiles([file], '', 'drop');
    await waiting;
    context._setProjectFilesStatus.mockClear();
    if (scope === 'account') context.currentUserId = 'second';
    else vm.runInContext(`_projectDetailPid = 'project-2'; _projectDetailResolvedPid = 'project-2';
      _projectDetailMeta = { project: { project_id: 'project-2' } };`, context);
    release(); await uploading;
    expect(context._setProjectFilesStatus).not.toHaveBeenCalled();
    expect(context.uiAlert).not.toHaveBeenCalled();
    expect(context.loadProjectDetail).not.toHaveBeenCalled();
    expect(context.window.orkas.invoke).toHaveBeenCalledExactlyOnceWith(
      method === 'native' ? 'projects.files.pickAndUpload' : 'projects.files.upload',
      method === 'native' ? { projectId: 'project-1', targetDir: '' }
        : { projectId: 'project-1', name: 'old.md', data: 'AA==' },
    );
  });

  it.each(['buffer', 'native-import'])('stops before fallback IPC when account changes during %s preparation', async phase => {
    const context = loadProjectDetailScript();
    context.currentUserId = 'first';
    context.uiAlert = vi.fn(async () => {});
    context.loadProjectDetail = vi.fn(async () => {});
    let release!: (value: unknown) => void, started!: () => void;
    const waiting = new Promise<void>(resolve => { started = resolve; });
    const response = new Promise(resolve => { release = resolve; });
    const file = { name: 'old.md', size: 1, arrayBuffer: vi.fn(async () => {
      if (phase === 'buffer') { started(); return response; } return new ArrayBuffer(1);
    }) };
    if (phase === 'native-import') context.window.orkas.importLocalFiles = vi.fn(() => { started(); return response; });
    const uploading = context._uploadProjectFiles([file], '', 'drop');
    await waiting;
    context.currentUserId = 'second';
    release(phase === 'buffer' ? new ArrayBuffer(1) : {});
    await uploading;
    expect(context.window.orkas.invoke).not.toHaveBeenCalled();
    expect(context.uiAlert).not.toHaveBeenCalled();
    expect(context.loadProjectDetail).not.toHaveBeenCalled();
  });

  it('does not dispatch more files from an old account after the initial upload workers settle', async () => {
    const context = loadProjectDetailScript();
    context.currentUserId = 'first';
    context.loadProjectDetail = vi.fn(async () => {});
    let release!: (value: unknown) => void;
    const response = new Promise(resolve => { release = resolve; });
    context.window.orkas.importLocalFiles = vi.fn(() => response);
    const files = Array.from({ length: 7 }, (_, i) => ({ name: `old-${i}.md`, size: 1 }));
    const uploading = context._uploadProjectFiles(files, '', 'drop');
    await vi.waitFor(() => expect(context.window.orkas.importLocalFiles).toHaveBeenCalledTimes(3));
    context.currentUserId = 'second';
    release({ ok: true, files: [{ ok: true }] });
    await uploading;
    expect(context.window.orkas.importLocalFiles).toHaveBeenCalledTimes(3);
    expect(context.window.orkas.invoke).not.toHaveBeenCalled();
    expect(context.loadProjectDetail).not.toHaveBeenCalled();
  });


  it('uploads operating-system files into the hovered folder with copy semantics', async () => {
    const context = loadProjectDetailScript();
    const folder = makeRow('dir', 'Research/Notes');
    const tree = makeTree([folder]);
    const file = { name: 'brief.md', size: 12, arrayBuffer: vi.fn() };
    const dataTransfer = { types: ['Files'], files: [file], getData: () => '' };
    context.document.getElementById = (id: string) => id === 'project-files-list' ? tree.root : null;
    context._uploadProjectFiles = vi.fn(async () => undefined);

    context._bindProjectFileRows();
    const hover = dropEvent(dataTransfer);
    folder.nodeListeners.dragover(hover);
    expect(hover.preventDefault).toHaveBeenCalledOnce();
    expect(hover.stopPropagation).toHaveBeenCalledOnce();
    expect(dataTransfer.dropEffect).toBe('copy');
    expect(folder.node.classList.contains('is-drag-over')).toBe(true);

    const drop = dropEvent(dataTransfer);
    await folder.nodeListeners.drop(drop);
    expect(context._uploadProjectFiles).toHaveBeenCalledWith([file], 'Research/Notes', 'drop');
    expect(drop.preventDefault).toHaveBeenCalledOnce();
    expect(drop.stopPropagation).toHaveBeenCalledOnce();
    expect(folder.node.classList.contains('is-drag-over')).toBe(false);
  });

  it('keeps internal project Library drags on the move path', async () => {
    const context = loadProjectDetailScript();
    const folder = makeRow('dir', 'Archive');
    const tree = makeTree([folder]);
    const dataTransfer = {
      types: ['application/x-project-library-path'],
      files: [],
      getData: () => 'draft.md',
    };
    context.document.getElementById = (id: string) => id === 'project-files-list' ? tree.root : null;
    context._handleProjectLibraryMove = vi.fn(async () => undefined);
    context._uploadProjectFiles = vi.fn(async () => undefined);

    context._bindProjectFileRows();
    const hover = dropEvent(dataTransfer);
    folder.nodeListeners.dragover(hover);
    expect(dataTransfer.dropEffect).toBe('move');

    await folder.nodeListeners.drop(dropEvent(dataTransfer));
    expect(context._handleProjectLibraryMove).toHaveBeenCalledWith('draft.md', 'Archive');
    expect(context._uploadProjectFiles).not.toHaveBeenCalled();
  });

  it('accepts external files at the root when the project Library is empty', async () => {
    const context = loadProjectDetailScript();
    const tree = makeTree();
    const file = { name: 'root.txt', size: 4, arrayBuffer: vi.fn() };
    const dataTransfer = { types: ['Files'], files: [file], getData: () => '' };
    context.document.getElementById = (id: string) => id === 'project-files-list' ? tree.root : null;
    context._uploadProjectFiles = vi.fn(async () => undefined);

    context._renderProjectFiles([]);
    context._bindProjectFileRows();
    expect(tree.rootListeners.drop).toBeTypeOf('function');

    const hover = dropEvent(dataTransfer);
    tree.rootListeners.dragover(hover);
    expect(hover.preventDefault).toHaveBeenCalledOnce();
    expect(dataTransfer.dropEffect).toBe('copy');
    expect(tree.root.classList.contains('is-root-drag-over')).toBe(true);

    await tree.rootListeners.drop(dropEvent(dataTransfer));
    expect(context._uploadProjectFiles).toHaveBeenCalledWith([file], '', 'drop');
    expect(tree.root.classList.contains('is-root-drag-over')).toBe(false);
  });

  it('drops over an existing nested file into that file parent folder', async () => {
    const context = loadProjectDetailScript();
    const folder = makeRow('dir', 'Research');
    const existing = makeRow('file', 'Research/existing.md');
    const tree = makeTree([folder, existing]);
    const file = { name: 'new.md', size: 4, arrayBuffer: vi.fn() };
    const dataTransfer = { types: ['Files'], files: [file], getData: () => '' };
    context.document.getElementById = (id: string) => id === 'project-files-list' ? tree.root : null;
    context._uploadProjectFiles = vi.fn(async () => undefined);

    context._bindProjectFileRows();
    const hover = dropEvent(dataTransfer, existing.row);
    tree.rootListeners.dragover(hover);
    expect(hover.preventDefault).toHaveBeenCalledOnce();
    expect(folder.node.classList.contains('is-drag-over')).toBe(true);

    await tree.rootListeners.drop(dropEvent(dataTransfer, existing.row));
    expect(context._uploadProjectFiles).toHaveBeenCalledWith([file], 'Research', 'drop');
  });

  it('uploads beside the open nested file when dropped onto the project file viewer', async () => {
    const context = loadProjectDetailScript();
    const viewer = makeDropSurface();
    const file = { name: 'new-reference.pdf', size: 40, arrayBuffer: vi.fn() };
    const dataTransfer = { types: ['Files'], files: [file], getData: () => '' };
    context._uploadProjectFiles = vi.fn(async () => undefined);
    context._bindProjectLibraryDetailDrop(
      viewer.surface,
      () => context._projectLibraryParentDir('Research/Notes/current.md'),
    );

    const hover = dropEvent(dataTransfer);
    viewer.listeners.dragover(hover);
    expect(hover.preventDefault).toHaveBeenCalledOnce();
    expect(hover.stopPropagation).toHaveBeenCalledOnce();
    expect(dataTransfer.dropEffect).toBe('copy');
    expect(viewer.surface.classList.contains('is-external-drag-over')).toBe(true);

    const drop = dropEvent(dataTransfer);
    await viewer.listeners.drop(drop);
    expect(context._uploadProjectFiles).toHaveBeenCalledWith([file], 'Research/Notes', 'drop');
    expect(viewer.surface.classList.contains('is-external-drag-over')).toBe(false);
  });

  it.each(['demo.mp4', 'inventory.XLS'])('rejects hidden and unsupported drops while uploading %s', async name => {
    const context = loadProjectDetailScript();
    const hidden = { name: '.secret.md', size: 2, arrayBuffer: vi.fn() };
    const unsupported = { name: 'archive.zip', size: 3, arrayBuffer: vi.fn() };
    const video = {
      name,
      size: 4,
      arrayBuffer: vi.fn(async () => new ArrayBuffer(4)),
    };
    context.window.orkas.invoke = vi.fn(async () => ({ ok: true }));
    context.loadProjectDetail = vi.fn(async () => undefined);
    context.uiAlert = vi.fn(async () => undefined);

    await context._uploadProjectFiles([hidden, unsupported, video], 'References', 'drop');

    expect(hidden.arrayBuffer).not.toHaveBeenCalled();
    expect(unsupported.arrayBuffer).not.toHaveBeenCalled();
    expect(video.arrayBuffer).toHaveBeenCalledOnce();
    expect(context.window.orkas.invoke).toHaveBeenCalledOnce();
    expect(context.window.orkas.invoke).toHaveBeenCalledWith('projects.files.upload', expect.objectContaining({
      projectId: 'project-1',
      name: `References/${name}`,
    }));
    expect(context.loadProjectDetail).toHaveBeenCalledWith('project-1');
    expect(context.uiAlert).toHaveBeenCalledTimes(2);
    expect(context.uiAlert.mock.calls[0][0]).toContain('contexts.upload_rejected');
    expect(context.uiAlert.mock.calls[0][0]).toContain('archive.zip');
    expect(context.uiAlert.mock.calls[1][0]).toContain('contexts.upload_hidden_rejected');
    expect(context.uiAlert.mock.calls[1][0]).toContain('.secret.md');
  });

  it('caps external upload work at three concurrent files', async () => {
    const context = loadProjectDetailScript();
    let active = 0;
    let maxActive = 0;
    const files = Array.from({ length: 7 }, (_, index) => ({
      name: `doc-${index}.md`,
      arrayBuffer: vi.fn(async () => {
        active += 1;
        maxActive = Math.max(maxActive, active);
        await new Promise((resolve) => setTimeout(resolve, 5));
        active -= 1;
        return new ArrayBuffer(1);
      }),
    }));
    context.window.orkas.invoke = vi.fn(async () => ({ ok: true }));
    context.loadProjectDetail = vi.fn(async () => undefined);

    await context._uploadProjectFiles(files, '', 'drop');

    expect(maxActive).toBe(3);
    expect(context.window.orkas.invoke).toHaveBeenCalledTimes(7);
  });

  it('keeps rejection alerts when the post-upload refresh fails', async () => {
    const context = loadProjectDetailScript();
    const file = { name: 'ok.md', arrayBuffer: vi.fn(async () => new ArrayBuffer(1)) };
    const rejected = { name: 'bad.zip', arrayBuffer: vi.fn() };
    context.window.orkas.invoke = vi.fn(async () => ({ ok: true }));
    context.loadProjectDetail = vi.fn(async () => { throw new Error('refresh failed'); });
    context.uiAlert = vi.fn(async () => undefined);
    context._projectLogFailure = vi.fn();

    await expect(context._uploadProjectFiles([file, rejected], '', 'drop')).resolves.toBeUndefined();
    expect(context._projectLogFailure).toHaveBeenCalledWith('project_file_upload', expect.objectContaining({
      error_code: 'files_rejected',
      error_type: 'validation',
    }));
    expect(context.uiAlert).toHaveBeenCalledWith(expect.stringContaining('bad.zip'));
  });
});


describe('Project detail Library transfer drafts', () => {
  it.each([true, false])('resolves the save choice %s before opening transfer', async (save) => {
    const context = loadProjectDetailScript();
    vm.runInContext(fs.readFileSync(path.join(__dirname, '../../src/renderer/modules/library-transfer.js'), 'utf8'), context);
    context.window.LibraryTransfer = { ...context.window.LibraryTransfer, open: vi.fn(async () => ({})) };
    context.uiConfirm = vi.fn(async () => save);
    context.uiAlert = vi.fn();
    context.__controller = { isDirty: () => true, save: vi.fn(async () => true) };
    vm.runInContext(`
      _projectLibraryActiveName = 'draft.md';
      _projectLibraryMveController = __controller;
      _projectLibraryDrafts.set('draft.md', { content: 'Edited', dirty: true });
    `, context);
    await context._openProjectLibraryTransfer(['draft.md'], 'menu');
    expect(context.uiConfirm).toHaveBeenCalledOnce();
    expect(context.__controller.save).toHaveBeenCalledTimes(save ? 1 : 0);
    expect(context.window.LibraryTransfer.open).toHaveBeenCalledOnce();
    expect(context.window.LibraryTransfer.open.mock.calls[0][0].source).toEqual({ scope: 'project', projectId: 'project-1' });
  });

  it('saves hidden project folder drafts through their own editor before transfer', async () => {
    const context = loadProjectDetailScript();
    vm.runInContext(fs.readFileSync(path.join(__dirname, '../../src/renderer/modules/library-transfer.js'), 'utf8'), context);
    context.window.LibraryTransfer = { ...context.window.LibraryTransfer, open: vi.fn(async () => ({})) };
    context.uiConfirm = vi.fn(async () => true);
    context.uiAlert = vi.fn();
    context.window.orkas.invoke.mockResolvedValue({ ok: true, content: 'Original' });
    context._prepProjectLibraryViewer = () => ({ bodyEl: {}, actionsEl: {} });
    const written: any[] = [];
    context.mountMdViewEdit = ({ source, initialDraft, callbacks }: any) => ({
      isDirty: () => true,
      save: async () => { written.push({ ...source, content: initialDraft.content }); callbacks.onDraftChange(null); return true; },
    });
    vm.runInContext(`
      _projectLibraryDrafts.set('notes/one.md', { content: 'First edit', dirty: true });
      _projectLibraryDrafts.set('notes/two.md', { content: 'Second edit', dirty: true });
      _projectLibraryDrafts.set('unrelated.md', { content: 'Keep this draft', dirty: true });
    `, context);
    await context._openProjectLibraryTransfer(['notes'], 'batch');
    expect(written).toEqual([
      { kind: 'project-file', projectId: 'project-1', name: 'notes/one.md', content: 'First edit' },
      { kind: 'project-file', projectId: 'project-1', name: 'notes/two.md', content: 'Second edit' },
    ]);
    expect(context.window.LibraryTransfer.open).toHaveBeenCalledOnce();
    expect(vm.runInContext('Array.from(_projectLibraryDrafts.keys())', context)).toEqual(['unrelated.md']);
  });

});