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.

fix(library): guard move deletion at the filesystem boundary

BlueSkyID66668eec1ae8330
diff --git a/src/main/features/contexts.ts b/src/main/features/contexts.ts
index 9781080e..a1397bfc 100644
--- a/src/main/features/contexts.ts
+++ b/src/main/features/contexts.ts
@@ -684,7 +684,9 @@ export async function importContextFileFromPath(
}
/** User-facing delete — files or dirs (recursive), refuses to touch the root index. */
-export function deleteContextTarget(relpath: string, userId: string = getActiveUserId()): Result {
+export function deleteContextTarget(
+ relpath: string, userId: string = getActiveUserId(), beforeDelete?: () => boolean,
+): Result {
let p: string;
try { p = resolvePath(relpath, { mustExist: true, userId }); }
catch (err) { return { ok: false, error: (err as Error).message }; }
@@ -695,6 +697,7 @@ export function deleteContextTarget(relpath: string, userId: string = getActiveU
const droppedRels = _collectRelsUnder(p, relpath);
try {
const st = fs.statSync(p);
+ if (beforeDelete && !beforeDelete()) return { ok: false, error: 'source_changed' };
if (st.isDirectory()) fs.rmSync(p, { recursive: true, force: true });
else fs.unlinkSync(p);
} catch (err) { return { ok: false, error: (err as Error).message }; }
diff --git a/src/main/features/library_transfer.ts b/src/main/features/library_transfer.ts
index dbd28e43..1b8b285d 100644
--- a/src/main/features/library_transfer.ts
+++ b/src/main/features/library_transfer.ts
@@ -9,8 +9,8 @@
* skipped source delete rolls the destination back best-effort.
*/
-import * as fs from 'node:fs';
import * as path from 'node:path';
+import { captureLocalEntryRevision, localEntryRevisionMatches } from '../util/file-import';
import * as contexts from './contexts';
import * as projectFiles from './project_files';
@@ -115,30 +115,6 @@ async function resolveSourceAbs(userId: string, ref: LibraryRef, rel: string): P
return { ok: true, absPath: resolved.absPath };
}
-/**
- * Fingerprint of a file or folder tree (path, size and mtime of every entry),
- * or null when it cannot be read. Two fingerprints differ when the source was
- * edited, added to or removed from between them.
- */
-function fingerprintEntry(absPath: string): string | null {
- const rows: string[] = [];
- const walk = (abs: string, rel: string): void => {
- const stat = fs.statSync(abs);
- if (stat.isDirectory()) {
- rows.push(`${rel}/`);
- for (const name of fs.readdirSync(abs).sort()) walk(path.join(abs, name), `${rel}/${name}`);
- return;
- }
- rows.push(`${rel}:${stat.size}:${stat.mtimeMs}`);
- };
- try {
- walk(absPath, '');
- } catch {
- return null;
- }
- return rows.join('\n');
-}
-
async function copyInto(
userId: string,
destination: LibraryRef,
@@ -160,9 +136,11 @@ async function copyInto(
return { ok: true, fileCount: copied.fileCount, bytes: copied.bytes };
}
-async function deleteFrom(userId: string, ref: LibraryRef, rel: string): Promise<{ ok: boolean; error?: string }> {
- if (ref.scope === 'global') return contexts.deleteContextTarget(rel, userId);
- return projectFiles.deleteProjectEntry(userId, ref.projectId!, rel);
+async function deleteFrom(
+ userId: string, ref: LibraryRef, rel: string, beforeDelete?: () => boolean,
+): Promise<{ ok: boolean; error?: string }> {
+ if (ref.scope === 'global') return contexts.deleteContextTarget(rel, userId, beforeDelete);
+ return projectFiles.deleteProjectEntry(userId, ref.projectId!, rel, beforeDelete);
}
async function moveWithin(
@@ -244,7 +222,15 @@ export async function transferLibraryEntries(
results.push({ ...resultBase, ok: false, error: 'account_changed' });
continue;
}
- const sourceBefore = mode === 'move' ? fingerprintEntry(resolved.absPath) : null;
+ const sourceBefore = mode === 'move' ? await captureLocalEntryRevision(resolved.absPath) : undefined;
+ if (mode === 'move' && !sourceBefore) {
+ results.push({ ...resultBase, ok: false, error: 'transfer_failed' });
+ continue;
+ }
+ if (!isActiveAccount(userId)) {
+ results.push({ ...resultBase, ok: false, error: 'account_changed' });
+ continue;
+ }
const copied = await copyInto(userId, destination, resolved.absPath, targetRel);
if (copied.ok === false) {
results.push({ ...resultBase, ok: false, error: normalizeError(copied.error) });
@@ -266,17 +252,18 @@ export async function transferLibraryEntries(
continue;
}
let removed: { ok: boolean; error?: string };
- if (fingerprintEntry(resolved.absPath) !== sourceBefore) {
- // Edited while it was being copied: deleting now would lose those edits.
- removed = { ok: false, error: 'source_changed' };
- } else {
- try {
- removed = await deleteFrom(userId, source, sourceRel);
- } catch {
- removed = { ok: false, error: 'source_delete_failed' };
- }
+ try {
+ removed = await deleteFrom(userId, source, sourceRel, () => localEntryRevisionMatches(sourceBefore));
+ } catch {
+ removed = { ok: false, error: 'source_delete_failed' };
}
if (!removed.ok) {
+ // A native directory removal may fail after deleting some children.
+ // Keep the completed copy when the original revision is no longer intact.
+ if (removed.error !== 'source_changed' && !localEntryRevisionMatches(sourceBefore)) {
+ results.push({ ...resultBase, ok: false, error: 'rollback_failed' });
+ continue;
+ }
let rollback: { ok: boolean; error?: string };
try {
rollback = await deleteFrom(userId, destination, targetRel);
diff --git a/src/main/features/project_files.ts b/src/main/features/project_files.ts
index 311e70b6..35db4449 100644
--- a/src/main/features/project_files.ts
+++ b/src/main/features/project_files.ts
@@ -559,7 +559,9 @@ export async function deleteProjectFile(userId: string, projectId: string, name:
return { ok: true };
}
-export async function deleteProjectEntry(userId: string, projectId: string, name: string): Promise<Result> {
+export async function deleteProjectEntry(
+ userId: string, projectId: string, name: string, beforeDelete?: () => boolean,
+): Promise<Result> {
let safeName: string;
let pid: string;
try {
@@ -579,6 +581,7 @@ export async function deleteProjectEntry(userId: string, projectId: string, name
const files = await filesUnderEntry(abs, root);
try {
+ if (beforeDelete && !beforeDelete()) return { ok: false, error: 'source_changed' };
if (st.isDirectory()) fs.rmSync(abs, { recursive: true, force: false });
else fs.unlinkSync(abs);
} catch (err) { return { ok: false, error: (err as Error).message }; }
diff --git a/src/main/util/file-import.ts b/src/main/util/file-import.ts
index c834b69c..f24f4e18 100644
--- a/src/main/util/file-import.ts
+++ b/src/main/util/file-import.ts
@@ -150,6 +150,55 @@ export function copyLocalEntryExclusiveSync(source: string, target: string, dire
}
}
+export interface LocalEntryRevision {
+ root: string;
+ entries: Array<{ relative: string; stamp: string }>;
+}
+
+const MAX_REVISION_ENTRIES = 10_000;
+const MAX_REVISION_PATH_BYTES = 1024 * 1024;
+
+function revisionStamp(stat: fs.BigIntStats): string | undefined {
+ if (!stat.isFile() && !stat.isDirectory()) return undefined;
+ return [stat.isDirectory() ? 'dir' : 'file', stat.dev, stat.ino, stat.size, stat.mtimeNs, stat.ctimeNs].join(':');
+}
+
+/** Capture bounded metadata without following symlinks or blocking Main for a
+ * full directory scan. An unavailable revision must never authorize deletion. */
+export async function captureLocalEntryRevision(root: string): Promise<LocalEntryRevision | undefined> {
+ const entries: LocalEntryRevision['entries'] = [];
+ const deadline = performance.now() + 5000;
+ let pathBytes = 0;
+ async function visit(absolute: string, relative: string, depth: number): Promise<void> {
+ pathBytes += Buffer.byteLength(relative);
+ if (depth > 64 || entries.length >= MAX_REVISION_ENTRIES
+ || pathBytes > MAX_REVISION_PATH_BYTES || performance.now() > deadline) throw new Error('revision budget exceeded');
+ const stat = await fsp.lstat(absolute, { bigint: true });
+ const stamp = revisionStamp(stat);
+ if (!stamp) throw new Error('unsupported revision source');
+ entries.push({ relative, stamp });
+ if (stat.isDirectory()) {
+ const directory = await fsp.opendir(absolute);
+ for await (const child of directory) {
+ await visit(path.join(absolute, child.name), relative ? path.join(relative, child.name) : child.name, depth + 1);
+ }
+ }
+ }
+ try { await visit(root, '', 0); return { root, entries }; }
+ catch { return undefined; }
+}
+
+/** Run immediately before the synchronous removal, after all awaited work.
+ * Directory stamps detect added/removed children without another tree walk. */
+export function localEntryRevisionMatches(revision: LocalEntryRevision | undefined): boolean {
+ if (!revision?.entries.length || revision.entries.length > MAX_REVISION_ENTRIES) return false;
+ const deadline = performance.now() + 100;
+ try {
+ return revision.entries.every(({ relative, stamp }) => performance.now() <= deadline
+ && revisionStamp(fs.lstatSync(path.join(revision.root, relative), { bigint: true })) === stamp);
+ } catch { return false; }
+}
+
export async function isUtf8File(absPath: string): Promise<boolean> {
const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
const stream = fs.createReadStream(absPath);
diff --git a/test/main/features/library_transfer.test.ts b/test/main/features/library_transfer.test.ts
index b0874bc3..a127d423 100644
--- a/test/main/features/library_transfer.test.ts
+++ b/test/main/features/library_transfer.test.ts
@@ -1,6 +1,10 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
const state = vi.hoisted(() => ({
+ root: '',
calls: [] as Array<{ op: string; args: unknown[] }>,
failDelete: '' as string,
throwDelete: '' as string,
@@ -18,7 +22,7 @@ vi.mock('../../../src/main/features/users', () => ({
}));
vi.mock('../../../src/main/features/contexts', () => ({
- resolveContextEntryAbsPath: (rel: string, userId = state.activeUserId) => `/${userId}/global/${rel}`,
+ resolveContextEntryAbsPath: (rel: string, userId = state.activeUserId) => `${state.root}/${userId}/global/${rel}`,
copyContextEntryFromPath: (source: string, target: string, userId = state.activeUserId) => {
state.calls.push({ op: 'copy-global', args: [userId, source, target] });
if (target.includes('conflict')) return { ok: false, error: 'target_exists' };
@@ -43,7 +47,7 @@ vi.mock('../../../src/main/features/project_files', () => ({
}
return {
ok: true,
- absPath: `/projects/${pid}/${rel}`,
+ absPath: `${state.root}/projects/${pid}/${rel}`,
type: rel.includes('.') ? 'file' : 'dir',
};
},
@@ -68,6 +72,12 @@ vi.mock('../../../src/main/features/project_files', () => ({
}));
beforeEach(() => {
+ state.root = fs.mkdtempSync(path.join(os.tmpdir(), 'orkas-transfer-unit-'));
+ for (const relative of ['u1/global/note.md', 'projects/p1/note.md', 'projects/p1/folder/child.md']) {
+ const absolute = path.join(state.root, relative);
+ fs.mkdirSync(path.dirname(absolute), { recursive: true });
+ fs.writeFileSync(absolute, 'Source fixture');
+ }
state.calls.length = 0;
state.failDelete = '';
state.throwDelete = '';
@@ -81,6 +91,10 @@ beforeEach(() => {
vi.resetModules();
});
+afterEach(() => {
+ fs.rmSync(state.root, { recursive: true, force: true });
+});
+
async function transfer(request: any) {
const mod = await import('../../../src/main/features/library_transfer');
return mod.transferLibraryEntries('u1', request);
@@ -98,7 +112,7 @@ describe('library_transfer', () => {
expect(result).toMatchObject({ ok: true, succeeded: 1, failed: 0 });
expect(state.calls).toContainEqual({
op: 'copy-global',
- args: ['u1', '/projects/p1/notes/report.md', 'imports/report.md'],
+ args: ['u1', `${state.root}/projects/p1/notes/report.md`, 'imports/report.md'],
});
});
@@ -135,7 +149,7 @@ describe('library_transfer', () => {
});
expect(result).toMatchObject({ ok: true, succeeded: 1, failed: 0 });
- expect(state.calls).toEqual([{ op: 'copy-global', args: ['u1', '/u1/global/note.md', 'archive/note.md'] }]);
+ expect(state.calls).toEqual([{ op: 'copy-global', args: ['u1', `${state.root}/u1/global/note.md`, 'archive/note.md'] }]);
});
it('reports unsupported destinations per item while allowing the rest of a batch', async () => {
@@ -166,7 +180,7 @@ describe('library_transfer', () => {
failed: 1,
results: [{ source: 'conflict.md', ok: false, error: 'target_exists' }],
});
- expect(state.calls).toEqual([{ op: 'copy-global', args: ['u1', '/projects/p1/conflict.md', 'conflict.md'] }]);
+ expect(state.calls).toEqual([{ op: 'copy-global', args: ['u1', `${state.root}/projects/p1/conflict.md`, 'conflict.md'] }]);
});
it('deduplicates children when their selected parent is transferred', async () => {
diff --git a/test/main/features/library_transfer_integration.test.ts b/test/main/features/library_transfer_integration.test.ts
index bba60d81..e4bfca1c 100644
--- a/test/main/features/library_transfer_integration.test.ts
+++ b/test/main/features/library_transfer_integration.test.ts
@@ -2,9 +2,12 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import * as fs from 'node:fs';
import * as os from 'node:os';
import * as path from 'node:path';
+import { syncBuiltinESMExports } from 'node:module';
import { drainMainRuntimeForTest } from '../../helpers/drain-main-runtime';
+const hooks = vi.hoisted(() => ({ beforeProjectAccess: null as null | (() => void) }));
+
vi.mock('../../../src/main/logger', () => ({
createLogger: () => ({
debug: vi.fn(),
@@ -15,7 +18,7 @@ vi.mock('../../../src/main/logger', () => ({
}));
vi.mock('../../../src/main/features/projects', () => ({
- projectExists: async () => true,
+ projectExists: async () => { hooks.beforeProjectAccess?.(); return true; },
getProject: async () => ({ project_id: 'p1' }),
}));
@@ -50,6 +53,7 @@ function seed(target: string, content: string): void {
}
beforeEach(async () => {
+ hooks.beforeProjectAccess = null;
root = fs.mkdtempSync(path.join(os.tmpdir(), 'orkas-library-transfer-'));
previousWorkspace = process.env.ORKAS_WORKSPACE_ROOT;
process.env.ORKAS_WORKSPACE_ROOT = root;
@@ -59,12 +63,169 @@ beforeEach(async () => {
});
afterEach(async () => {
+ vi.restoreAllMocks();
+ syncBuiltinESMExports();
await drainMainRuntimeForTest();
if (previousWorkspace === undefined) delete process.env.ORKAS_WORKSPACE_ROOT;
else process.env.ORKAS_WORKSPACE_ROOT = previousWorkspace;
fs.rmSync(root, { recursive: true, force: true });
});
+it.each(['file', 'folder'] as const)('preserves a %s edited during awaited project source deletion', async (kind) => {
+ const entry = kind === 'file' ? 'latest.md' : 'folder';
+ const relative = kind === 'file' ? entry : `${entry}/latest.md`;
+ seed(projectPath(relative), 'Copied revision');
+ const transfer = await import('../../../src/main/features/library_transfer');
+ let edited = false;
+ hooks.beforeProjectAccess = () => {
+ if (!edited && fs.existsSync(globalPath(entry))) {
+ edited = true;
+ seed(projectPath(relative), 'Saved during deletion preparation');
+ }
+ };
+
+ const result = await transfer.transferLibraryEntries('u1', {
+ mode: 'move', source: { scope: 'project', projectId: 'p1' }, paths: [entry], destination: { scope: 'global' },
+ });
+
+ expect(edited).toBe(true);
+ expect(fs.existsSync(projectPath(relative))).toBe(true);
+ expect(fs.readFileSync(projectPath(relative), 'utf8')).toBe('Saved during deletion preparation');
+ expect(fs.existsSync(globalPath(entry))).toBe(false);
+ expect(result).toMatchObject({ ok: true, succeeded: 0, failed: 1, results: [{ error: 'source_delete_failed' }] });
+});
+
+it('fails closed when source metadata cannot establish a revision', async () => {
+ const source = globalPath('unreadable.md');
+ seed(source, 'Source must survive');
+ const transfer = await import('../../../src/main/features/library_transfer');
+ const nodeFs = (await import('node:fs')).default;
+ const promises = (await import('node:fs/promises')).default;
+ const stat = nodeFs.statSync;
+ const lstat = promises.lstat;
+ let syncFailures = 0;
+ vi.spyOn(nodeFs, 'statSync').mockImplementation(((filename: any, ...args: any[]) => {
+ if (String(filename) === source && syncFailures++ < 2) {
+ throw Object.assign(new Error('Injected metadata read failure'), { code: 'EIO' });
+ }
+ return (stat as any)(filename, ...args);
+ }) as any);
+ vi.spyOn(promises, 'lstat').mockImplementation(((filename: any, ...args: any[]) => {
+ if (String(filename) === source) {
+ return Promise.reject(Object.assign(new Error('Injected revision read failure'), { code: 'EIO' }));
+ }
+ return (lstat as any)(filename, ...args);
+ }) as any);
+ syncBuiltinESMExports();
+
+ const result = await transfer.transferLibraryEntries('u1', {
+ mode: 'move', source: { scope: 'global' }, paths: ['unreadable.md'], destination: { scope: 'project', projectId: 'p1' },
+ });
+
+ expect(fs.existsSync(source)).toBe(true);
+ expect(fs.readFileSync(source, 'utf8')).toBe('Source must survive');
+ expect(fs.existsSync(projectPath('unreadable.md'))).toBe(false);
+ expect(result).toMatchObject({ ok: true, succeeded: 0, failed: 1 });
+});
+
+it('rejects a nested symlink without scanning the directory it points to', async () => {
+ const outside = path.join(root, 'outside');
+ seed(path.join(outside, 'unrelated.md'), 'Outside document');
+ fs.mkdirSync(projectPath('folder'), { recursive: true });
+ const linked = projectPath('folder/linked');
+ fs.symlinkSync(outside, linked, process.platform === 'win32' ? 'junction' : 'dir');
+ const transfer = await import('../../../src/main/features/library_transfer');
+ const nodeFs = (await import('node:fs')).default;
+ const promises = (await import('node:fs/promises')).default;
+ const readdir = nodeFs.readdirSync;
+ const opendir = promises.opendir;
+ let traversedLink = false;
+ const observe = (filename: unknown) => {
+ const value = String(filename);
+ if (value === linked || value.startsWith(`${linked}${path.sep}`)) traversedLink = true;
+ };
+ vi.spyOn(nodeFs, 'readdirSync').mockImplementation(((filename: any, ...args: any[]) => {
+ observe(filename); return (readdir as any)(filename, ...args);
+ }) as any);
+ vi.spyOn(promises, 'opendir').mockImplementation(((filename: any, ...args: any[]) => {
+ observe(filename); return (opendir as any)(filename, ...args);
+ }) as any);
+ syncBuiltinESMExports();
+
+ const result = await transfer.transferLibraryEntries('u1', {
+ mode: 'move', source: { scope: 'project', projectId: 'p1' }, paths: ['folder'], destination: { scope: 'global' },
+ });
+
+ expect(traversedLink).toBe(false);
+ expect(result).toMatchObject({ ok: true, succeeded: 0, failed: 1 });
+ expect(fs.existsSync(projectPath('folder'))).toBe(true);
+ expect(fs.readFileSync(path.join(outside, 'unrelated.md'), 'utf8')).toBe('Outside document');
+ expect(fs.existsSync(globalPath('folder'))).toBe(false);
+});
+
+it('preserves a replacement source even when its size and mtime match the copied file', async () => {
+ const source = globalPath('same.md');
+ seed(source, 'old');
+ const timestamp = new Date('2026-01-01T00:00:00Z');
+ fs.utimesSync(source, timestamp, timestamp);
+ const transfer = await import('../../../src/main/features/library_transfer');
+ const nodeFs = (await import('node:fs')).default;
+ const copy = nodeFs.copyFileSync;
+ let edited = false;
+ vi.spyOn(nodeFs, 'copyFileSync').mockImplementation(((from: any, to: any, mode: any) => {
+ copy(from, to, mode);
+ if (String(from) === source && !edited) {
+ edited = true;
+ fs.writeFileSync(`${source}.replacement`, 'new');
+ fs.renameSync(`${source}.replacement`, source);
+ fs.utimesSync(source, timestamp, timestamp);
+ }
+ }) as any);
+ syncBuiltinESMExports();
+
+ const result = await transfer.transferLibraryEntries('u1', {
+ mode: 'move', source: { scope: 'global' }, paths: ['same.md'], destination: { scope: 'project', projectId: 'p1' },
+ });
+
+ expect(edited).toBe(true);
+ expect(fs.existsSync(source)).toBe(true);
+ expect(fs.readFileSync(source, 'utf8')).toBe('new');
+ expect(fs.existsSync(projectPath('same.md'))).toBe(false);
+ expect(result).toMatchObject({ ok: true, succeeded: 0, failed: 1 });
+});
+
+it.each(['global', 'project'] as const)('retains the complete copy after a %s source is partially deleted', async (scope) => {
+ const source = scope === 'global' ? globalPath : projectPath;
+ const destination = scope === 'global' ? projectPath : globalPath;
+ seed(source('folder/first.md'), 'First original');
+ seed(source('folder/second.md'), 'Second original');
+ const transfer = await import('../../../src/main/features/library_transfer');
+ const nodeFs = (await import('node:fs')).default;
+ const remove = nodeFs.rmSync;
+ let interrupted = false;
+ vi.spyOn(nodeFs, 'rmSync').mockImplementation(((target: any, ...args: any[]) => {
+ if (String(target) === source('folder') && !interrupted) {
+ interrupted = true;
+ fs.unlinkSync(source('folder/first.md'));
+ throw Object.assign(new Error('Injected partial deletion'), { code: 'EACCES' });
+ }
+ return (remove as any)(target, ...args);
+ }) as any);
+ syncBuiltinESMExports();
+
+ const result = await transfer.transferLibraryEntries('u1', {
+ mode: 'move', paths: ['folder'],
+ source: scope === 'global' ? { scope: 'global' } : { scope: 'project', projectId: 'p1' },
+ destination: scope === 'global' ? { scope: 'project', projectId: 'p1' } : { scope: 'global' },
+ });
+
+ expect(interrupted).toBe(true);
+ expect(fs.existsSync(destination('folder/first.md'))).toBe(true);
+ expect(fs.readFileSync(destination('folder/first.md'), 'utf8')).toBe('First original');
+ expect(fs.readFileSync(destination('folder/second.md'), 'utf8')).toBe('Second original');
+ expect(result).toMatchObject({ ok: true, succeeded: 0, failed: 1, results: [{ error: 'rollback_failed' }] });
+});
+
describe('library_transfer filesystem lifecycle', () => {
it('moves bytes from the global Library to one project destination', async () => {
seed(globalPath('inbox/plan.md'), '# durable transfer\n');
diff --git a/test/main/features/library_transfer_source_changed.test.ts b/test/main/features/library_transfer_source_changed.test.ts
index bfd3f3e2..1cfe0f00 100644
--- a/test/main/features/library_transfer_source_changed.test.ts
+++ b/test/main/features/library_transfer_source_changed.test.ts
@@ -20,7 +20,8 @@ vi.mock('../../../src/main/features/contexts', () => ({
state.calls.push({ op: 'copy-global', args: [source, target] });
return { ok: true, path: target, fileCount: 1, bytes: 10 };
},
- deleteContextTarget: (rel: string) => {
+ deleteContextTarget: (rel: string, _uid: string, beforeDelete?: () => boolean) => {
+ if (beforeDelete && !beforeDelete()) return { ok: false, error: 'source_changed' };
state.calls.push({ op: 'delete-global', args: [rel] });
return { ok: true };
},
@@ -34,7 +35,8 @@ vi.mock('../../../src/main/features/project_files', () => ({
state.duringCopy?.();
return { ok: true, name: target, fileCount: 1, bytes: 10 };
},
- deleteProjectEntry: async (_uid: string, pid: string, rel: string) => {
+ deleteProjectEntry: async (_uid: string, pid: string, rel: string, beforeDelete?: () => boolean) => {
+ if (beforeDelete && !beforeDelete()) return { ok: false, error: 'source_changed' };
state.calls.push({ op: 'delete-project', args: [pid, rel] });
return { ok: true };
},
diff --git a/test/main/util/file-import.test.ts b/test/main/util/file-import.test.ts
index 117306cf..2c1629bb 100644
--- a/test/main/util/file-import.test.ts
+++ b/test/main/util/file-import.test.ts
@@ -9,6 +9,8 @@ import {
assertLocalImportTarget,
copyLocalFileAtomic,
copyLocalEntryExclusiveSync,
+ captureLocalEntryRevision,
+ localEntryRevisionMatches,
inspectLocalImportSource,
withLocalImportLock,
} from '../../../src/main/util/file-import';
@@ -19,6 +21,67 @@ beforeEach(() => {
root = fs.mkdtempSync(path.join(os.tmpdir(), 'orkas-file-import-'));
});
+describe('Library move revisions', () => {
+ it('accepts unchanged descendants and rejects added and removed children', async () => {
+ fs.writeFileSync(path.join(root, 'first.md'), 'First document');
+ const before = await captureLocalEntryRevision(root);
+ expect(localEntryRevisionMatches(before)).toBe(true);
+
+ fs.writeFileSync(path.join(root, 'second.md'), 'Second document');
+ expect(localEntryRevisionMatches(before)).toBe(false);
+ const afterAddition = await captureLocalEntryRevision(root);
+ fs.unlinkSync(path.join(root, 'second.md'));
+ expect(localEntryRevisionMatches(afterAddition)).toBe(false);
+ });
+
+ it('rejects missing and unreadable revision evidence', async () => {
+ const file = path.join(root, 'source.md');
+ fs.writeFileSync(file, 'Source document');
+ const revision = await captureLocalEntryRevision(file);
+ const nodeFs = (await import('node:fs')).default;
+ const { syncBuiltinESMExports } = await import('node:module');
+ const lstat = nodeFs.lstatSync;
+ const spy = vi.spyOn(nodeFs, 'lstatSync').mockImplementation(((filename: any, ...args: any[]) => {
+ if (String(filename) === file) throw Object.assign(new Error('Injected metadata read failure'), { code: 'EIO' });
+ return (lstat as any)(filename, ...args);
+ }) as any);
+ syncBuiltinESMExports();
+ try { expect(localEntryRevisionMatches(revision)).toBe(false); }
+ finally { spy.mockRestore(); syncBuiltinESMExports(); }
+ expect(localEntryRevisionMatches(undefined)).toBe(false);
+ expect(await captureLocalEntryRevision(path.join(root, 'missing.md'))).toBeUndefined();
+ });
+
+ it('accepts depth 64 and refuses a deeper source', async () => {
+ let directory = root;
+ for (let depth = 1; depth <= 64; depth++) {
+ directory = path.join(directory, 'd'); fs.mkdirSync(directory);
+ }
+ const revision = await captureLocalEntryRevision(root);
+ expect(revision).toBeDefined();
+ fs.mkdirSync(path.join(directory, 'too-deep'));
+ expect(await captureLocalEntryRevision(root)).toBeUndefined();
+ });
+
+ it('refuses deletion when the synchronous verification budget expires', async () => {
+ fs.writeFileSync(path.join(root, 'source.md'), 'Source document');
+ const revision = await captureLocalEntryRevision(root);
+ const clock = vi.spyOn(performance, 'now').mockReturnValueOnce(0).mockReturnValue(101);
+ let matches: boolean;
+ try { matches = localEntryRevisionMatches(revision); }
+ finally { clock.mockRestore(); }
+ expect(matches).toBe(false);
+ });
+
+ it('refuses a snapshot after the collection budget expires', async () => {
+ const clock = vi.spyOn(performance, 'now').mockReturnValueOnce(0).mockReturnValue(5001);
+ let revision: Awaited<ReturnType<typeof captureLocalEntryRevision>>;
+ try { revision = await captureLocalEntryRevision(root); }
+ finally { clock.mockRestore(); }
+ expect(revision).toBeUndefined();
+ });
+});
+
afterEach(() => {
fs.rmSync(root, { recursive: true, force: true });
});