Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
test(mcp-host): pin the GFS store kill tests from the adversarial review
Alfredo Lopez0ce07ef23572
diff --git a/mcp-host/package-lock.json b/mcp-host/package-lock.jsonindex 602049fe8..82d43ce64 100644--- a/mcp-host/package-lock.json+++ b/mcp-host/package-lock.json@@ -1,12 +1,12 @@{"name": "clerum-mcp-host",- "version": "0.1.532",+ "version": "0.1.533","lockfileVersion": 3,"requires": true,"packages": {"": {"name": "clerum-mcp-host",- "version": "0.1.532",+ "version": "0.1.533","license": "SEE LICENSE IN LICENSE","dependencies": {"@anthropic-ai/sdk": "^0.32.0",diff --git a/mcp-host/package.json b/mcp-host/package.jsonindex c4893bae3..0926ea7cf 100644--- a/mcp-host/package.json+++ b/mcp-host/package.json@@ -1,6 +1,6 @@{"name": "clerum-mcp-host",- "version": "0.1.532",+ "version": "0.1.533","description": "MCP Host - reads Host CRD and provides LLM access via OpenAI/Claude","main": "dist/main.js","engines": {diff --git a/mcp-host/src/internalTools/gfsDownloadMetrics.test.ts b/mcp-host/src/internalTools/gfsDownloadMetrics.test.tsindex c6ccb539b..001661a73 100644--- a/mcp-host/src/internalTools/gfsDownloadMetrics.test.ts+++ b/mcp-host/src/internalTools/gfsDownloadMetrics.test.ts@@ -10,21 +10,18 @@ import {recordGfsShellOutputLimit,} from './gfsDownloadMetrics'-async function counterValue(name: string): Promise<number> {+/** Sum of the samples of `name` whose labels include every `labels` pair. */+async function counterValue(name: string, labels: Record<string, string> = {}): Promise<number> {const metric = register.getSingleMetric(name)if (metric === undefined) throw new Error(`metric ${name} is not registered`)const { values } = await metric.get()- return values.reduce((sum, sample) => sum + sample.value, 0)+ return values+ .filter(sample => Object.entries(labels).every(([key, value]) => sample.labels[key] === value))+ .reduce((sum, sample) => sum + sample.value, 0)}async function expiryValue(outcome: string): Promise<number> {- const metric = register.getSingleMetric('clerum_gfs_download_expiry_total')- if (metric === undefined)- throw new Error('metric clerum_gfs_download_expiry_total is not registered')- const { values } = await metric.get()- return values- .filter(sample => sample.labels.outcome === outcome)- .reduce((sum, sample) => sum + sample.value, 0)+ return counterValue('clerum_gfs_download_expiry_total', { outcome })}describe('GFS download metrics', () => {@@ -40,14 +37,30 @@ describe('GFS download metrics', () => {})it('records admission, transfer, active count, and shell-limit outcomes', async () => {+ const series = [+ ['clerum_gfs_download_admissions_total', { outcome: 'workspace_attempt' }],+ ['clerum_gfs_download_transfers_total', { outcome: 'success' }],+ ['clerum_gfs_shell_output_limits_total', { outcome: 'output_limit_exceeded' }],+ ['clerum_gfs_download_quota_total', { scope: 'caller', reason: 'storage_bytes' }],+ ['clerum_gfs_download_expiry_total', { outcome: 'remove_failed' }],+ ] as const+ const before = await Promise.all(series.map(([name, labels]) => counterValue(name, labels)))+ const active = await counterValue('clerum_gfs_download_active')+recordGfsDownloadAdmission('workspace_attempt')enterGfsDownloadTransfer()+ expect(await counterValue('clerum_gfs_download_active')).toBe(active + 1)recordGfsDownloadTransfer('success', 0.25)exitGfsDownloadTransfer()recordGfsShellOutputLimit('output_limit_exceeded')recordGfsDownloadQuota('caller', 'storage_bytes')recordGfsDownloadExpiry('remove_failed')+ // Each call moved its own series by exactly one.+ for (const [index, [name, labels]] of series.entries())+ expect(await counterValue(name, labels)).toBe(before[index]! + 1)+ expect(await counterValue('clerum_gfs_download_active')).toBe(active)+const scraped = await register.metrics()expect(scraped).toContain('clerum_gfs_download_admissions_total{outcome="workspace_attempt"}')expect(scraped).toContain('clerum_gfs_download_transfers_total{outcome="success"}')diff --git a/mcp-host/src/internalTools/gfsDownloadStore.test.ts b/mcp-host/src/internalTools/gfsDownloadStore.test.tsindex 6603312af..6c1ea78b3 100644--- a/mcp-host/src/internalTools/gfsDownloadStore.test.ts+++ b/mcp-host/src/internalTools/gfsDownloadStore.test.ts@@ -985,3 +985,149 @@ describe('GFS download store: pins, lifecycle and errors', () => {await expect(openStore(real)).resolves.toBeInstanceOf(GfsDownloadStore)})})++// Kill tests for mutations the adversarial review of PR #1028 found surviving+// (S08, S10, S11, S12, S13, S22, S24), adapted from its verified repros.+describe('GFS download store: adversarial review kill tests', () => {+ it('ADV-S08: an infeasible eviction plan deletes nothing even when some copies are evictable', async () => {+ const { limited } = await limitedStore(HOST_30_CALLER_15)+ const loose = await completedCopy(limited, callerRoot, CALLER, 70, 5)+ tick()+ await completedCopy(limited, callerRoot, CALLER, 71, 8, { owner: 'task-1' })+ const denied = await quotaCount('caller', 'storage_bytes')+ await expect(startTransfer(limited, callerRoot, CALLER, 72, 10)).rejects.toMatchObject({+ code: 'caller_quota_exceeded',+ })+ // Witness: the admission reached the quota decision.+ expect(await quotaCount('caller', 'storage_bytes')).toBe(denied + 1)+ // The unpinned copy could not make room on its own, so it must survive.+ expect(await exists(downloadDirectory(callerRoot, loose.receipt.id))).toBe(true)+ // Witness: once the pin is released the same admission evicts and succeeds.+ await limited.releaseReceiptOwner('task-1', CALLER)+ await expect(startTransfer(limited, callerRoot, CALLER, 72, 10)).resolves.toBeDefined()+ })++ it('ADV-S11: publish refuses a digest that does not match the partial bytes', async () => {+ const { transfer } = await startTransfer(store, callerRoot, CALLER, 73, 8)+ hashBoundary.mockClear()+ await expect(+ store.publish(transfer.id, CALLER, digest(Buffer.alloc(8, 0xee)))+ ).rejects.toMatchObject({ code: 'storage_write_failed' })+ // Witness: publication hashed the partial file.+ expect(hashBoundary).toHaveBeenCalled()+ const directory = downloadDirectory(callerRoot, transfer.id)+ expect(await exists(path.join(directory, 'source'))).toBe(false)+ expect(await exists(path.join(directory, 'meta.json'))).toBe(false)+ await store.fail(transfer.id, CALLER)+ expect(await exists(directory)).toBe(false)+ })++ it('ADV-S13: publish refuses a partial file larger than the admitted size', async () => {+ const transfer = await store.createTransfer({+ callerIdentity: CALLER,+ callerWorkspacePath: callerRoot,+ source: sourceFor(74),+ sizeBytes: 5,+ expiresAt: future(),+ })+ const bigger = Buffer.alloc(9, 4)+ await nativeFs.writeFile(path.join(callerRoot, transfer.partialPath), bigger)+ await expect(store.publish(transfer.id, CALLER, digest(bigger))).rejects.toMatchObject({+ code: 'download_missing',+ })+ // Witness: the oversized partial is the one that was offered.+ expect((await nativeFs.stat(path.join(callerRoot, transfer.partialPath))).size).toBe(9)+ expect(await exists(path.join(downloadDirectory(callerRoot, transfer.id), 'source'))).toBe(+ false+ )+ })++ it('ADV-S24: publish refuses a transfer whose expiry passed during the download', async () => {+ const bytes = Buffer.alloc(6, 7)+ const transfer = await store.createTransfer({+ callerIdentity: CALLER,+ callerWorkspacePath: callerRoot,+ source: sourceFor(75),+ sizeBytes: 6,+ expiresAt: future(1_000),+ })+ await nativeFs.writeFile(path.join(callerRoot, transfer.partialPath), bytes)+ vi.setSystemTime(Date.now() + 1_000)+ await expect(store.publish(transfer.id, CALLER, digest(bytes))).rejects.toMatchObject({+ code: 'download_expired',+ })+ // Witness: the transfer is still active, so fail() is accepted and cleans it up.+ await expect(store.fail(transfer.id, CALLER)).resolves.toBeUndefined()+ expect(await exists(downloadDirectory(callerRoot, transfer.id))).toBe(false)+ })++ it('ADV-S22: a caller root that is an alias of another caller directory is refused', async () => {+ const otherRoot = await callerDirectory(hostRoot, 'caller-b')+ const alias = path.join(hostRoot, 'users', 'alias')+ await nativeFs.symlink(otherRoot, alias)+ await expect(+ store.createTransfer({+ callerIdentity: 'alias',+ callerWorkspacePath: alias,+ source: sourceFor(76),+ sizeBytes: 3,+ expiresAt: future(),+ })+ ).rejects.toMatchObject({ code: 'workspace_unavailable' })+ expect(await exists(path.join(otherRoot, '.gfs-downloads'))).toBe(false)+ // Witness: the real directory is accepted.+ await expect(+ store.createTransfer({+ callerIdentity: 'caller-b',+ callerWorkspacePath: otherRoot,+ source: sourceFor(76),+ sizeBytes: 3,+ expiresAt: future(),+ })+ ).resolves.toMatchObject({ sizeBytes: 3 })+ })++ it('ADV-S10: a source.partial swapped after meta.json is renamed is not published', async () => {+ const { transfer, bytes } = await startTransfer(store, callerRoot, CALLER, 77, 8)+ const partial = path.join(callerRoot, transfer.partialPath)+ let swapped = false+ renameBoundary.mockImplementation(async (from: string, to: string) => {+ await nativeFs.rename(from, to)+ if (to.endsWith(path.sep + 'meta.json') && !swapped) {+ swapped = true+ await nativeFs.writeFile(partial + '.swap', Buffer.alloc(8, 0x55), { mode: 0o600 })+ await nativeFs.rename(partial + '.swap', partial)+ }+ })+ await expect(store.publish(transfer.id, CALLER, digest(bytes))).rejects.toMatchObject({+ code: 'storage_write_failed',+ })+ // Witness: the swap happened inside the publication.+ expect(swapped).toBe(true)+ await expect(store.readManagedFile(transfer.path, CALLER)).rejects.toMatchObject({+ code: 'download_missing',+ })+ })++ it('ADV-S12: a source.partial swapped after hashing is refused before meta.json is written', async () => {+ const { transfer, bytes } = await startTransfer(store, callerRoot, CALLER, 78, 8)+ let swapped = false+ lstatBoundary.mockImplementation(async (target: string, options?: unknown) => {+ // The store addresses the partial through the real path of the Host root.+ const partial = target+ if (target.endsWith(path.sep + 'source.partial') && options === undefined && !swapped) {+ swapped = true+ await nativeFs.writeFile(partial + '.swap', Buffer.alloc(8, 0x66), { mode: 0o600 })+ await nativeFs.rename(partial + '.swap', partial)+ }+ return nativeFs.lstat(target, options as never)+ })+ await expect(store.publish(transfer.id, CALLER, digest(bytes))).rejects.toMatchObject({+ code: 'download_missing',+ })+ expect(swapped).toBe(true)+ expect(await exists(path.join(downloadDirectory(callerRoot, transfer.id), 'meta.json'))).toBe(+ false+ )+ })+})diff --git a/mcp-host/src/internalTools/gfsDownloadStoreBoundaries.test.ts b/mcp-host/src/internalTools/gfsDownloadStoreBoundaries.test.tsindex 6db11e0a8..5e3d5ec30 100644--- a/mcp-host/src/internalTools/gfsDownloadStoreBoundaries.test.ts+++ b/mcp-host/src/internalTools/gfsDownloadStoreBoundaries.test.ts@@ -6,7 +6,6 @@* value that is refused, on a real temporary directory.*/import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'-import * as crypto from 'node:crypto'import { randomUUID } from 'node:crypto'import * as syncFs from 'node:fs'import * as fs from 'node:fs/promises'diff --git a/mcp-host/src/internalTools/gfsDownloadStoreRestart.test.ts b/mcp-host/src/internalTools/gfsDownloadStoreRestart.test.tsindex d226af9a5..cf1b9cbba 100644--- a/mcp-host/src/internalTools/gfsDownloadStoreRestart.test.ts+++ b/mcp-host/src/internalTools/gfsDownloadStoreRestart.test.ts@@ -361,3 +361,55 @@ describe('GFS download store restart', () => {expect(await second.debugInventory()).toMatchObject({ bytes: 128, files: 2 })})})++describe('GFS download store restart: retirement edge cases', () => {+ it('S14: only `.gfs-download-store.retired-<uuid>` names are removed', async () => {+ const foreign = path.join(hostRoot, `${RETIRED_PREFIX}foo`)+ const retired = path.join(hostRoot, `${RETIRED_PREFIX}00000000-0000-4000-8000-000000000001`)+ for (const directory of [foreign, retired]) {+ await fs.mkdir(directory, { mode: 0o700 })+ await fs.writeFile(path.join(directory, 'copy'), 'bytes', { mode: 0o600 })+ }++ await open()++ // Witness: a uuid-named retired tree is removed by the same sweep.+ expect(exists(retired)).toBe(false)+ expect(exists(path.join(foreign, 'copy'))).toBe(true)+ })++ it.each([+ ['a file', 'file'],+ ['a symlink', 'symlink'],+ ] as const)(+ 'S15: a `.gfs-download-store` that is %s is retired without following it',+ async (_label, kind) => {+ const legacy = path.join(hostRoot, '.gfs-download-store')+ const outside = await fs.mkdtemp(path.join(tmpdir(), 'gfs-store-legacy-target-'))+ const target = path.join(outside, 'target')+ try {+ await fs.writeFile(target, 'outside bytes', { mode: 0o600 })+ if (kind === 'file') await fs.writeFile(legacy, 'legacy bytes', { mode: 0o600 })+ else await fs.symlink(target, legacy)+ const warn = vi.spyOn(logger, 'warn')+ const retiredBefore = await expiryCount('retired_legacy_store')++ const store = await open()++ expect(store.isAvailable()).toBe(true)+ expect(retirementWarnings(warn)).toEqual([+ expect.objectContaining({ files: kind === 'file' ? 1 : 0 }),+ ])+ expect(await expiryCount('retired_legacy_store')).toBe(retiredBefore + 1)+ expect(exists(legacy)).toBe(false)+ expect((await hostRootEntries()).filter(name => name.startsWith(RETIRED_PREFIX))).toEqual(+ []+ )+ // The symlink's target is never followed.+ await expect(fs.readFile(target, 'utf8')).resolves.toBe('outside bytes')+ } finally {+ await fs.rm(outside, { recursive: true, force: true })+ }+ }+ )+})diff --git a/mcp-host/src/internalTools/gfsStorePrivateFiles.test.ts b/mcp-host/src/internalTools/gfsStorePrivateFiles.test.tsnew file mode 100644index 000000000..061f06eeb--- /dev/null+++ b/mcp-host/src/internalTools/gfsStorePrivateFiles.test.ts@@ -0,0 +1,83 @@+/**+ * The private-object opener of the GFS download store: it never follows a+ * symlink, and it refuses an opened inode whose name moved to another inode+ * before the check finished.+ */+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'+import * as syncFs from 'node:fs'+import type * as fs from 'node:fs/promises'+import { tmpdir } from 'node:os'+import * as path from 'node:path'+import {+ PrivateStoreNameMovedError,+ PrivateStoreUntrustedError,+ openPrivateStoreObject,+} from './gfsStorePrivateFiles'++const { beforeLstat } = vi.hoisted(() => ({+ beforeLstat: { hook: undefined as ((target: string) => void) | undefined },+}))+// Pass-through lstat; a test can act on the name right before the opener's+// name check, the window an atomic rename over the name would use.+vi.mock('node:fs/promises', async original => {+ const actual = await original<typeof fs>()+ return {+ ...actual,+ lstat: ((target: syncFs.PathLike, ...rest: never[]) => {+ beforeLstat.hook?.(String(target))+ return (actual.lstat as (...args: unknown[]) => Promise<unknown>)(target, ...rest)+ }) as typeof actual.lstat,+ }+})++let root: string++beforeEach(() => {+ beforeLstat.hook = undefined+ root = syncFs.mkdtempSync(path.join(tmpdir(), 'gfs-private-files-'))+})++afterEach(() => {+ beforeLstat.hook = undefined+ syncFs.rmSync(root, { recursive: true, force: true })+})++function privateFile(name: string, content: string): string {+ const target = path.join(root, name)+ syncFs.writeFileSync(target, content, { mode: 0o600 })+ return target+}++describe('openPrivateStoreObject', () => {+ it('S02: refuses a symlink at the open itself, with ELOOP', async () => {+ const target = privateFile('target', 'private bytes')+ const link = path.join(root, 'link')+ syncFs.symlinkSync(target, link)+ // Witness: the private file it points at is opened.+ const handle = await openPrivateStoreObject(target, 'file')+ await handle.close()++ await expect(openPrivateStoreObject(link, 'file')).rejects.toMatchObject({ code: 'ELOOP' })+ })++ it('S03: refuses an opened inode whose name moved to another inode', async () => {+ const target = privateFile('source', 'published bytes')+ const replacement = privateFile('replacement', 'other bytes')+ let swapped = false+ beforeLstat.hook = name => {+ if (name !== target || swapped) return+ swapped = true+ syncFs.renameSync(replacement, target)+ }++ const refusal = await openPrivateStoreObject(target, 'file').catch(error => error)++ expect(swapped).toBe(true)+ expect(refusal).toBeInstanceOf(PrivateStoreNameMovedError)+ expect(refusal).toBeInstanceOf(PrivateStoreUntrustedError)+ // Witness: without the swap the same name opens.+ beforeLstat.hook = undefined+ const handle = await openPrivateStoreObject(target, 'file')+ await handle.close()+ })+})diff --git a/scripts/ci/pinned-vitest-cases/mcp-host.json b/scripts/ci/pinned-vitest-cases/mcp-host.jsonindex cef64ec25..ef3dd2d64 100644--- a/scripts/ci/pinned-vitest-cases/mcp-host.json+++ b/scripts/ci/pinned-vitest-cases/mcp-host.json@@ -606,5 +606,153 @@{"suite": "gfsDownloadStoreBoundaries.test.ts","fullName": "GFS download store boundaries: path swapped between check and use K2b: a caller directory swapped between the meta.json rename and the source rename publishes nothing"+ },+ {+ "suite": "gfsDownloadStore.test.ts",+ "fullName": "GFS download store: adversarial review kill tests ADV-S08: an infeasible eviction plan deletes nothing even when some copies are evictable"+ },+ {+ "suite": "gfsDownloadStore.test.ts",+ "fullName": "GFS download store: adversarial review kill tests ADV-S11: publish refuses a digest that does not match the partial bytes"+ },+ {+ "suite": "gfsDownloadStore.test.ts",+ "fullName": "GFS download store: adversarial review kill tests ADV-S13: publish refuses a partial file larger than the admitted size"+ },+ {+ "suite": "gfsDownloadStore.test.ts",+ "fullName": "GFS download store: adversarial review kill tests ADV-S24: publish refuses a transfer whose expiry passed during the download"+ },+ {+ "suite": "gfsDownloadStore.test.ts",+ "fullName": "GFS download store: adversarial review kill tests ADV-S22: a caller root that is an alias of another caller directory is refused"+ },+ {+ "suite": "gfsDownloadStore.test.ts",+ "fullName": "GFS download store: adversarial review kill tests ADV-S10: a source.partial swapped after meta.json is renamed is not published"+ },+ {+ "suite": "gfsDownloadStore.test.ts",+ "fullName": "GFS download store: adversarial review kill tests ADV-S12: a source.partial swapped after hashing is refused before meta.json is written"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: caller identity (ADV-1) two channels with the same sender never see each other’s copy"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: caller identity (ADV-1) refuses an identity that is not the caller root’s key"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: caller root shape (F9) refuses the Host root as a caller root"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: caller root shape (F9) refuses the users directory as a caller root"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: caller root shape (F9) refuses a directory inside a caller root as a caller root"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: caller root shape (F9) refuses a directory outside users as a caller root"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: transient I/O is not corruption (F1/ADV-3) reuse that cannot open a pinned copy keeps it for the task that holds it"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: transient I/O is not corruption (F1/ADV-3) reuse still removes a copy whose bytes no longer match its receipt"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: transient I/O is not corruption (F1/ADV-3) a sweep that cannot lstat a published copy keeps it and counts sweep_failed"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: transient I/O is not corruption (F1/ADV-3) a startup sweep that cannot open meta.json keeps the copy for the next start"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: transient I/O is not corruption (F1/ADV-3) an admission that cannot verify .gfs-downloads fails and keeps every copy"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: transient I/O is not corruption (F1/ADV-3) readManagedFile logs a non-ENOENT failure of the owner’s copy and still answers download_missing"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: transient I/O is not corruption (F1/ADV-3) readManagedFilePrefix logs a non-ENOENT failure of the owner’s copy and still answers download_missing"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: trash, eviction and undo (ADV-2/F2/F3/F8) a replaced .gfs-downloads stranded by a failed rm is protected and swept"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: trash, eviction and undo (ADV-2/F2/F3/F8) an eviction whose removal fails keeps the copy published and charged"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: trash, eviction and undo (ADV-2/F2/F3/F8) a refused removal whose undo also fails reports the refusal, not the undo"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: trash, eviction and undo (ADV-2/F2/F3/F8) a removal of a directory that never existed is not counted as removed"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: expiry, close, recency and removal proof S17: createTransfer refuses an expiry at or before its creation instant"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: expiry, close, recency and removal proof S18: close() does not wait for pinned copies, only for active transfers"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: expiry, close, recency and removal proof S28: a managed read refreshes recency, so the unread copy is evicted first"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: expiry, close, recency and removal proof S31: a removal is proven by ENOENT, not by rm returning"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: expiry, close, recency and removal proof S01: a descriptor with the published inode number on another device is not served"+ },+ {+ "suite": "gfsDownloadStoreAdversarial.test.ts",+ "fullName": "GFS download store adversarial round: expiry, close, recency and removal proof S09: publication syncs the download directory after the source rename"+ },+ {+ "suite": "gfsDownloadStoreRestart.test.ts",+ "fullName": "GFS download store restart: retirement edge cases S14: only `.gfs-download-store.retired-<uuid>` names are removed"+ },+ {+ "suite": "gfsDownloadStoreRestart.test.ts",+ "fullName": "GFS download store restart: retirement edge cases S15: a `.gfs-download-store` that is a file is retired without following it"+ },+ {+ "suite": "gfsDownloadStoreRestart.test.ts",+ "fullName": "GFS download store restart: retirement edge cases S15: a `.gfs-download-store` that is a symlink is retired without following it"+ },+ {+ "suite": "gfsStorePrivateFiles.test.ts",+ "fullName": "openPrivateStoreObject S02: refuses a symlink at the open itself, with ELOOP"+ },+ {+ "suite": "gfsStorePrivateFiles.test.ts",+ "fullName": "openPrivateStoreObject S03: refuses an opened inode whose name moved to another inode"+ },+ {+ "suite": "gfsExecutionCapability.test.ts",+ "fullName": "gfsStoreCallerIdentity keys the store by the channel-namespaced caller-root key, never the raw sender"+ },+ {+ "suite": "gfsExecutionCapability.test.ts",+ "fullName": "gfsStoreCallerIdentity gives a task without a source message the system key of its caller root"}]