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.
JavaScript agent-collaborationagent-harnessagent-orchestrationagent-teamagent-workflowai-assistantai-automationai-employeeai-productivityai-teamai-workflowautonomous-agentsclaude-code-guiclaude-coworkdesktop-agentlocal-firstmulti-agentmulti-agent-systemself-evolving-agentstask-automation
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']);
});
});