import { spawn } from 'node:child_process' import { createHash } from 'node:crypto' import { once } from 'node:events' import { chmod, link, mkdir, mkdtemp, readFile, readdir, rename, rm, stat, symlink, truncate, writeFile } from 'node:fs/promises' import { tmpdir } from 'node:os' import { dirname, join } from 'node:path' import { afterEach, describe, expect, it, vi } from 'vitest' import { IdentityInvalidError, IdentityStore, prepareDefaultIdentityDirectory, resetDefaultIdentityRoles, serverStorageDirectory } from '../src/identity-store.js' import { ServerCredentialStore } from '../src/server-credentials.js' vi.mock('node:fs/promises', async importOriginal => { const actual = await importOriginal() return { ...actual, rename: vi.fn(actual.rename) } }) const directories: string[] = [] async function mockMoveFailure(source: string, target: string, code: string, createTarget = false): Promise { const actual = await vi.importActual('node:fs/promises') let pending = true vi.mocked(rename).mockImplementation(async (from, to) => { if (pending && from === source && to === target) { pending = false if (createTarget) await mkdir(target) throw Object.assign(createTarget ? new IdentityInvalidError('destination appeared') : new Error('move unavailable'), { code }) } return actual.rename(from, to) }) } afterEach(async () => { await Promise.all(directories.splice(0).map(directory => rm(directory, { recursive: true, force: true }))) }) describe('IdentityStore', () => { it('moves all Server roles without changing identities, trust or credential bytes, and serializes repeated migration', async () => { const home = await temporaryDirectory() const env = { DSH_HOME: home } const source = join(home, 'remote') const target = join(home, 'ds-harness-remote') const records: Array<{ directory: string; identity: Awaited>; peers: unknown; files: Map }> = [] for (const origin of ['https://first.example.com', 'https://second.example.com']) { for (const role of ['host', 'client'] as const) { const directory = serverStorageDirectory(source, origin, role) const store = new IdentityStore({ directory }) const identity = await store.loadOrCreate('Host') await store.trustPeer({ deviceId: identity.deviceId, name: 'Peer', platform: 'linux', publicKey: identity.publicKey }) await new ServerCredentialStore(directory).save({ serverUrl: origin, deviceId: identity.deviceId, authorizationMethod: 'owned_device', accessToken: 'fixture-access-token', accessTokenExpiresAt: 1, refreshToken: 'fixture-refresh-token', refreshTokenExpiresAt: 2 }) const files = new Map() for (const file of await readdir(directory)) files.set(file, await readFile(join(directory, file))) records.push({ directory, identity, peers: store.listTrustedPeers(), files }) } } await expect(stat(target)).rejects.toMatchObject({ code: 'ENOENT' }) expect(await Promise.all(Array.from({ length: 3 }, () => prepareDefaultIdentityDirectory({ env })))).toEqual([target, target, target]) await expect(stat(source)).rejects.toMatchObject({ code: 'ENOENT' }) for (const record of records) { const directory = record.directory.replace(source, target) for (const [file, bytes] of record.files) expect(await readFile(join(directory, file))).toEqual(bytes) const store = new IdentityStore({ directory }) expect(await store.loadOrCreate('Host')).toEqual(record.identity) expect(store.listTrustedPeers()).toEqual(record.peers) if (process.platform !== 'win32') expect((await stat(join(directory, 'device.key'))).mode & 0o777).toBe(0o600) } expect(new IdentityStore({ env }).directory).toBe(target) expect(await prepareDefaultIdentityDirectory({ env })).toBe(target) }) it('migrates interrupted peer writes for flat, host and client storage and cleans only known temporaries', async () => { const dead = await deadPid() for (const role of ['flat', 'host', 'client'] as const) { const home = await temporaryDirectory() const source = join(home, 'remote') const directory = role === 'flat' ? source : serverStorageDirectory(source, 'https://example.com', role) const store = new IdentityStore({ directory }) const identity = await store.loadOrCreate('Host') await store.trustPeer({ deviceId: identity.deviceId, name: 'Peer', platform: 'linux', publicKey: identity.publicKey }) const peers = await readFile(join(directory, 'trusted-peers.json')) const temps = [ `trusted-peers.json.${dead}.01a1b6d8-e8b5-7000-8000-000000000001.tmp`, `server-credentials.json.${dead}.01a1b6d8-e8b5-7000-8000-000000000002.tmp`, `device.json.${dead}.01a1b6d8-e8b5-7000-8000-000000000003.tmp`, `device.key.${dead}.01a1b6d8-e8b5-7000-8000-000000000004.tmp`, `host-pairing.json.${dead}.01a1b6d8-e8b5-7000-8000-000000000005.tmp`, `pairing-host-only.json.${dead}.01a1b6d8-e8b5-7000-8000-000000000006.tmp`, ] for (const temp of temps) { await writeFile(join(directory, temp), '{partial', { mode: 0o600 }) } const target = await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }) const moved = directory.replace(source, target) for (const temp of temps) { expect(await readFile(join(moved, temp), 'utf8')).toBe('{partial') } const reopened = new IdentityStore({ directory: moved }) expect(await reopened.loadOrCreate('Host')).toEqual(identity) expect(await readFile(join(moved, 'trusted-peers.json'))).toEqual(peers) const remaining = await readdir(moved) for (const temp of temps) { expect(remaining).not.toContain(temp) } } }) it('preserves in-flight credential and peer temporary files owned by a live process until rename completes', async () => { const directory = await temporaryDirectory() const store = new IdentityStore({ directory }) const identity = await store.loadOrCreate('Host') const inFlightCredTemp = `server-credentials.json.${process.pid}.01a1b6d8-e8b5-7000-8000-000000000002.tmp` const inFlightPeerTemp = `trusted-peers.json.${process.pid}.01a1b6d8-e8b5-7000-8000-000000000001.tmp` const dead = await deadPid() const staleCredTemp = `server-credentials.json.${dead}.01a1b6d8-e8b5-7000-8000-000000000003.tmp` await writeFile(join(directory, inFlightCredTemp), '{"schemaVersion":1}\n', { mode: 0o600 }) await writeFile(join(directory, inFlightPeerTemp), '{"schemaVersion":1,"peers":[]}\n', { mode: 0o600 }) await writeFile(join(directory, staleCredTemp), '{partial', { mode: 0o600 }) // Concurrent loadOrCreate runs removeStaleTemporaries; live PID temps must survive so rename succeeds. expect(await new IdentityStore({ directory }).loadOrCreate('Host')).toEqual(identity) const afterLoad = await readdir(directory) expect(afterLoad).toContain(inFlightCredTemp) expect(afterLoad).toContain(inFlightPeerTemp) expect(afterLoad).not.toContain(staleCredTemp) await rename(join(directory, inFlightPeerTemp), join(directory, 'trusted-peers.json')) await rename(join(directory, inFlightCredTemp), join(directory, 'server-credentials.json')) // Migration must also refuse to move legacy storage while a live process has an unrenamed temp file. const home = await temporaryDirectory() const source = join(home, 'remote') const hostIdentity = await new IdentityStore({ directory: source }).loadOrCreate('Host') const liveMigrationTemp = join(source, inFlightCredTemp) const validCredPayload = JSON.stringify({ schemaVersion: 1, serverUrl: 'https://dsh.r2049.cn', deviceId: hostIdentity.deviceId, authorizationMethod: 'account', account: 'host@example.com', accessToken: 'fixture-access-token', accessTokenExpiresAt: 1, refreshToken: 'fixture-refresh-token', refreshTokenExpiresAt: 2, }) await writeFile(liveMigrationTemp, `${validCredPayload}\n`, { mode: 0o600 }) await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })).rejects.toMatchObject({ code: 'IDENTITY_LOCKED', }) await rename(liveMigrationTemp, join(source, 'server-credentials.json')) await chmod(join(source, 'server-credentials.json'), 0o600) expect(await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })).toBe(join(home, 'ds-harness-remote')) }) it('reclaims exited-owner identity and interrupted real-hash takeover locks during migration and runtime load while preserving live lock and concurrent takeover protection', async () => { const [deadOwner, deadContender, deadSecondContender] = await deadPids() expect(new Set([deadOwner, deadContender, deadSecondContender]).size).toBe(3) const lockRecord = `${deadOwner}\n` const takeoverRecord = `${deadContender}\n` const realTakeover = `device.lock.takeover-${createHash('sha256').update(lockRecord).digest('hex').slice(0, 16)}` const secondTakeover = `device.lock.takeover-${createHash('sha256').update(`${realTakeover}\n${takeoverRecord}`).digest('hex').slice(0, 16)}` const serverUrl = 'https://example.com' for (const role of ['flat', 'host', 'client'] as const) { const home = await temporaryDirectory() const source = join(home, 'remote') const directory = role === 'flat' ? source : serverStorageDirectory(source, serverUrl, role) const store = new IdentityStore({ directory, role: role === 'flat' ? undefined : role }) const identity = await store.loadOrCreate('Host') await store.trustPeer({ deviceId: identity.deviceId, name: 'Peer', platform: 'linux', publicKey: identity.publicKey }) const credentials = await new ServerCredentialStore(directory).save({ serverUrl, deviceId: identity.deviceId, authorizationMethod: 'owned_device', accessToken: 'fixture-access-token', accessTokenExpiresAt: 1, refreshToken: 'fixture-refresh-token', refreshTokenExpiresAt: 2, }) const deviceJsonBytes = await readFile(join(directory, 'device.json')) const deviceKeyBytes = await readFile(join(directory, 'device.key')) const peersBytes = await readFile(join(directory, 'trusted-peers.json')) const credentialBytes = await readFile(join(directory, 'server-credentials.json')) await writeFile(join(directory, 'device.lock'), lockRecord, { mode: 0o600 }) await writeFile(join(directory, realTakeover), takeoverRecord, { mode: 0o600 }) await writeFile(join(directory, secondTakeover), `${deadSecondContender}\n`, { mode: 0o600 }) const target = await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }) expect(target).toBe(join(home, 'ds-harness-remote')) const moved = directory.replace(source, target) expect(await readdir(moved)).not.toContain('device.lock') expect(await readdir(moved)).not.toContain(realTakeover) expect(await readdir(moved)).not.toContain(secondTakeover) expect(await readFile(join(moved, 'device.json'))).toEqual(deviceJsonBytes) expect(await readFile(join(moved, 'device.key'))).toEqual(deviceKeyBytes) expect(await readFile(join(moved, 'trusted-peers.json'))).toEqual(peersBytes) expect(await readFile(join(moved, 'server-credentials.json'))).toEqual(credentialBytes) // Also verify direct runtime withIdentityLock recovery when device.lock and chained real-hash takeover files remain. await writeFile(join(moved, 'device.lock'), lockRecord, { mode: 0o600 }) await writeFile(join(moved, realTakeover), takeoverRecord, { mode: 0o600 }) await writeFile(join(moved, secondTakeover), `${deadSecondContender}\n`, { mode: 0o600 }) const reopened = new IdentityStore({ directory: moved, role: role === 'flat' ? undefined : role }) expect(await reopened.loadOrCreate('Host')).toEqual(identity) expect(reopened.listTrustedPeers()).toEqual(store.listTrustedPeers()) expect(await new ServerCredentialStore(moved).load(serverUrl, identity.deviceId)).toEqual(credentials) expect(await readdir(moved)).not.toContain('device.lock') expect(await readdir(moved)).not.toContain(realTakeover) expect(await readdir(moved)).not.toContain(secondTakeover) expect(await readFile(join(moved, 'device.json'))).toEqual(deviceJsonBytes) expect(await readFile(join(moved, 'device.key'))).toEqual(deviceKeyBytes) expect(await readFile(join(moved, 'trusted-peers.json'))).toEqual(peersBytes) expect(await readFile(join(moved, 'server-credentials.json'))).toEqual(credentialBytes) } // Live lock owner or live concurrent takeover contender must reject with IDENTITY_LOCKED without altering any file. for (const liveScenario of ['live-lock-with-dead-takeover', 'dead-lock-with-live-takeover'] as const) { const home = await temporaryDirectory() const source = join(home, 'remote') const hostDir = serverStorageDirectory(source, serverUrl, 'host') const store = new IdentityStore({ directory: hostDir, role: 'host' }) const identity = await store.loadOrCreate('Host') await store.trustPeer({ deviceId: identity.deviceId, name: 'Peer', platform: 'linux', publicKey: identity.publicKey }) await new ServerCredentialStore(hostDir).save({ serverUrl, deviceId: identity.deviceId, authorizationMethod: 'owned_device', accessToken: 'fixture-access-token', accessTokenExpiresAt: 1, refreshToken: 'fixture-refresh-token', refreshTokenExpiresAt: 2, }) const activeLockRecord = liveScenario === 'live-lock-with-dead-takeover' ? `${process.pid}\n` : lockRecord const activeTakeoverName = `device.lock.takeover-${createHash('sha256').update(activeLockRecord).digest('hex').slice(0, 16)}` const activeTakeoverRecord = liveScenario === 'live-lock-with-dead-takeover' ? `${deadContender}\n` : `${process.pid}\n` await writeFile(join(hostDir, 'device.lock'), activeLockRecord, { mode: 0o600 }) await writeFile(join(hostDir, activeTakeoverName), activeTakeoverRecord, { mode: 0o600 }) const beforeEntries = (await readdir(hostDir)).sort() const beforeBytes = new Map(await Promise.all( beforeEntries.map(async name => [name, await readFile(join(hostDir, name))] as const), )) await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }), liveScenario).rejects.toMatchObject({ code: 'IDENTITY_LOCKED', }) expect((await readdir(hostDir)).sort(), liveScenario).toEqual(beforeEntries) for (const [name, bytes] of beforeBytes) { expect(await readFile(join(hostDir, name)), `${liveScenario}:${name}`).toEqual(bytes) } await expect(stat(join(home, 'ds-harness-remote'))).rejects.toMatchObject({ code: 'ENOENT' }) } }) it('migrates valid host storage alongside an empty client directory, rotated client credential or uncredentialed broken flat root', async () => { const serverUrl = 'https://dsh.r2049.cn' for (const scenario of [ 'empty-client', 'rotated-client-credential', 'broken-flat-root', 'corrupt-flat-json', 'invalid-flat-schema', 'corrupt-flat-key', ] as const) { const home = await temporaryDirectory() const source = join(home, 'remote') const hostDir = serverStorageDirectory(source, serverUrl, 'host') const clientDir = serverStorageDirectory(source, serverUrl, 'client') const hostIdentity = await new IdentityStore({ directory: hostDir, role: 'host' }).loadOrCreate('Host') await new ServerCredentialStore(hostDir).save({ serverUrl, deviceId: hostIdentity.deviceId, authorizationMethod: 'account', account: 'host@example.com', accessToken: 'fixture-access-token', accessTokenExpiresAt: 1, refreshToken: 'fixture-refresh-token', refreshTokenExpiresAt: 2, }) const hostCredentialBytes = await readFile(join(hostDir, 'server-credentials.json')) if (scenario === 'empty-client') { await mkdir(clientDir, { recursive: true }) } if (scenario === 'rotated-client-credential') { const oldClient = await new IdentityStore({ directory: await temporaryDirectory() }).loadOrCreate('Old Client') await new IdentityStore({ directory: clientDir, role: 'client' }).loadOrCreate('Client') await new ServerCredentialStore(clientDir).save({ serverUrl, deviceId: oldClient.deviceId, authorizationMethod: 'account', account: 'host@example.com', accessToken: 'stale-client-access-token', accessTokenExpiresAt: 1, refreshToken: 'stale-client-refresh-token', refreshTokenExpiresAt: 2, }) } if (scenario === 'broken-flat-root') { const other = await new IdentityStore({ directory: await temporaryDirectory() }).loadOrCreate('Other') await new IdentityStore({ directory: source }).loadOrCreate('Flat') await writeFile(join(source, 'device.key'), `${other.privateKey}\n`, { mode: 0o600 }) } if (scenario === 'corrupt-flat-json') { await new IdentityStore({ directory: source }).loadOrCreate('Flat') await writeFile(join(source, 'device.json'), '{corrupt-json', { mode: 0o600 }) } if (scenario === 'invalid-flat-schema') { await new IdentityStore({ directory: source }).loadOrCreate('Flat') await writeFile(join(source, 'device.json'), '{"schemaVersion":99}', { mode: 0o600 }) } if (scenario === 'corrupt-flat-key') { await new IdentityStore({ directory: source }).loadOrCreate('Flat') await writeFile(join(source, 'device.key'), 'not-a-32-byte-private-key\n', { mode: 0o600 }) } const target = await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }) expect(target, scenario).toBe(join(home, 'ds-harness-remote')) const movedHostDir = serverStorageDirectory(target, serverUrl, 'host') expect(await new IdentityStore({ directory: movedHostDir, role: 'host' }).loadOrCreate('Host'), scenario).toEqual(hostIdentity) expect(await readFile(join(movedHostDir, 'server-credentials.json')), scenario).toEqual(hostCredentialBytes) if (scenario.includes('flat')) { const healedFlat = await new IdentityStore({ directory: target }).loadOrCreate('Flat') expect(healedFlat.publicKey, scenario).toBeDefined() expect(await new IdentityStore({ directory: movedHostDir, role: 'host' }).loadOrCreate('Host'), scenario).toEqual(hostIdentity) } } // Broken flat root without a verified scoped identity must still be rejected. const unverifiedHome = await temporaryDirectory() const unverifiedSource = join(unverifiedHome, 'remote') const unverifiedClientDir = serverStorageDirectory(unverifiedSource, serverUrl, 'client') const other = await new IdentityStore({ directory: await temporaryDirectory() }).loadOrCreate('Other') await new IdentityStore({ directory: unverifiedSource }).loadOrCreate('Flat') await writeFile(join(unverifiedSource, 'device.key'), `${other.privateKey}\n`, { mode: 0o600 }) await mkdir(unverifiedClientDir, { recursive: true }) await writeFile(join(unverifiedClientDir, 'device.json'), '{corrupt-client-json', { mode: 0o600 }) await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: unverifiedHome } })).rejects.toMatchObject({ code: 'IDENTITY_INVALID', }) await expect(new IdentityStore({ directory: unverifiedSource }).loadOrCreate('Flat')).rejects.toThrow(IdentityInvalidError) // Flat root credential with mismatched deviceId must still be rejected even when a valid scoped host exists. const mismatchHome = await temporaryDirectory() const mismatchSource = join(mismatchHome, 'remote') const mismatchHostDir = serverStorageDirectory(mismatchSource, serverUrl, 'host') const validHost = await new IdentityStore({ directory: mismatchHostDir, role: 'host' }).loadOrCreate('Host') await new IdentityStore({ directory: mismatchSource }).loadOrCreate('Flat') await new ServerCredentialStore(mismatchSource).save({ serverUrl, deviceId: validHost.deviceId, authorizationMethod: 'account', account: 'host@example.com', accessToken: 'fixture-access-token', accessTokenExpiresAt: 1, refreshToken: 'fixture-refresh-token', refreshTokenExpiresAt: 2, }) await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: mismatchHome } })).rejects.toMatchObject({ code: 'IDENTITY_INVALID', }) // Symlinked device.json in scoped host must not authorize flat root self-heal. const symlinkScopedRoot = await temporaryDirectory() const externalDir = await temporaryDirectory() const externalIdentity = await new IdentityStore({ directory: externalDir }).loadOrCreate('External') const symlinkHostDir = serverStorageDirectory(symlinkScopedRoot, serverUrl, 'host') await mkdir(symlinkHostDir, { recursive: true }) await writeFile(join(symlinkHostDir, 'device.key'), `${externalIdentity.privateKey}\n`, { mode: 0o600 }) await symlink(join(externalDir, 'device.json'), join(symlinkHostDir, 'device.json')) await new IdentityStore({ directory: symlinkScopedRoot }).loadOrCreate('Flat') const brokenFlatKey = `${other.privateKey}\n` await writeFile(join(symlinkScopedRoot, 'device.key'), brokenFlatKey, { mode: 0o600 }) await expect(new IdentityStore({ directory: symlinkScopedRoot }).loadOrCreate('Flat')).rejects.toThrow(IdentityInvalidError) expect(await readFile(join(symlinkScopedRoot, 'device.key'), 'utf8')).toBe(brokenFlatKey) }) it('rejects unknown or malformed peer temporary names without deleting them', async () => { for (const name of ['foreign.json.1.01a1b6d8-e8b5-7000-8000-000000000001.tmp', 'trusted-peers.json.other.tmp']) { const home = await temporaryDirectory() const source = join(home, 'remote') await new IdentityStore({ directory: source }).loadOrCreate('Host') await writeFile(join(source, name), 'keep') await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })).rejects.toMatchObject({ code: 'STORAGE_CONFLICT' }) await new IdentityStore({ directory: source }).loadOrCreate('Host') expect(await readFile(join(source, name), 'utf8')).toBe('keep') } }) it('refuses conflicting roots, lock records and symlinks without modifying either storage tree', async () => { for (const scenario of ['conflict', 'destination-race', 'identity-lock', 'refresh-lock', 'symlink']) { const home = await temporaryDirectory() const source = join(home, 'remote') const target = join(home, 'ds-harness-remote') const original = await new IdentityStore({ directory: source }).loadOrCreate('Host') if (scenario === 'conflict') await mkdir(target) if (scenario === 'destination-race') await mockMoveFailure(source, target, 'EEXIST', true) if (scenario === 'identity-lock') await writeFile(join(source, 'device.lock'), String(process.pid)) if (scenario === 'refresh-lock') await mkdir(join(source, 'server-credentials.json.refresh-lock')) if (scenario === 'symlink') await symlink(join(source, 'device.key'), join(source, 'linked')) await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }), scenario).rejects.toBeInstanceOf(IdentityInvalidError) expect((await readFile(join(source, 'device.key'), 'utf8')).trim()).toBe(original.privateKey) if (!['conflict', 'destination-race'].includes(scenario)) await expect(stat(target)).rejects.toMatchObject({ code: 'ENOENT' }) } const directory = await temporaryDirectory() expect(await prepareDefaultIdentityDirectory({ directory })).toBe(directory) }) it('moves an idle refresh queue marker and rejects an active queue holder', async () => { const home = await temporaryDirectory() const source = join(home, 'remote') await new IdentityStore({ directory: source }).loadOrCreate('Host') await new ServerCredentialStore(source).withRefreshLock(async () => undefined) const marker = join(source, 'server-credentials.json.refresh-lock') expect(await readFile(marker, 'utf8')).toBe('DSH_REFRESH_LOCK_V2\n') const holder = `${marker}.holder-${process.pid}-00000000-0000-7000-8000-000000000000` await writeFile(holder, `${process.pid}-00000000-0000-7000-8000-000000000000 1\n`) await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })).rejects.toMatchObject({ code: 'IDENTITY_LOCKED' }) await rm(holder) expect(await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })).toBe(join(home, 'ds-harness-remote')) expect(await readFile(join(home, 'ds-harness-remote', 'server-credentials.json.refresh-lock'), 'utf8')) .toBe('DSH_REFRESH_LOCK_V2\n') }) it.skipIf(process.platform !== 'linux')('moves storage after cleaning a dead holder and accepts a queue temp file', async () => { const home = await temporaryDirectory() const source = join(home, 'remote') await new IdentityStore({ directory: source }).loadOrCreate('Host') const lock = join(source, 'server-credentials.json.refresh-lock') await writeFile(lock, 'DSH_REFRESH_LOCK_V2\n') const owner = spawn(process.execPath, ['-e', 'setInterval(() => {}, 1000)'], { stdio: 'ignore' }) const pid = owner.pid! owner.kill('SIGKILL') await once(owner, 'exit') const id = `${pid}-00000000-0000-7000-8000-000000000001` await writeFile(`${lock}.holder-${id}`, `${id} 1\n`) const temporary = `${lock}.holder-${id}.${pid}.00000000-0000-7000-8000-000000000002.tmp` await writeFile(temporary, 'partial') const target = await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }) expect(target).toBe(join(home, 'ds-harness-remote')) expect(await readdir(target)).not.toContain(`server-credentials.json.refresh-lock.holder-${id}`) expect(await readFile(join(target, temporary.slice(source.length + 1)), 'utf8')).toBe('partial') }) it.skipIf(process.platform !== 'linux')('removes verified hardlink remnants from an interrupted refresh lock publication', async () => { const home = await temporaryDirectory() const source = join(home, 'remote') await new IdentityStore({ directory: source }).loadOrCreate('Host') const dead = await deadPid() const marker = join(source, 'server-credentials.json.refresh-lock') await writeFile(marker, 'DSH_REFRESH_LOCK_V2\n', { mode: 0o600 }) const markerTemp = `${marker}.${dead}.00000000-0000-7000-8000-000000000001.tmp` await link(marker, markerTemp) const id = `${dead}-00000000-0000-7000-8000-000000000002` const holder = `${marker}.holder-${id}` await writeFile(holder, `${id} 1\n`, { mode: 0o600 }) const holderTemp = `${holder}.${dead}.00000000-0000-7000-8000-000000000003.tmp` await link(holder, holderTemp) expect((await stat(marker)).nlink).toBe(2) expect((await stat(holder)).nlink).toBe(2) const target = await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }) expect(target).toBe(join(home, 'ds-harness-remote')) expect(await readdir(target)).not.toContain(markerTemp.slice(source.length + 1)) expect(await readdir(target)).not.toContain(holderTemp.slice(source.length + 1)) expect(await readdir(target)).not.toContain(holder.slice(source.length + 1)) expect((await stat(join(target, 'server-credentials.json.refresh-lock'))).nlink).toBe(1) }) it.skipIf(process.platform !== 'linux')('rejects a queue temp that does not link to its matching published file', async () => { const home = await temporaryDirectory() const source = join(home, 'remote') await new IdentityStore({ directory: source }).loadOrCreate('Host') const dead = await deadPid() const marker = join(source, 'server-credentials.json.refresh-lock') await writeFile(marker, 'DSH_REFRESH_LOCK_V2\n', { mode: 0o600 }) await link(marker, join(home, 'foreign-link')) const markerTemp = `${marker}.${dead}.00000000-0000-7000-8000-000000000004.tmp` await writeFile(markerTemp, 'DSH_REFRESH_LOCK_V2\n', { mode: 0o600 }) await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })).rejects.toMatchObject({ code: 'STORAGE_CONFLICT' }) expect((await stat(marker)).nlink).toBe(2) expect(await readFile(markerTemp, 'utf8')).toBe('DSH_REFRESH_LOCK_V2\n') }) it('waits for an active refresh before it moves the storage directory', async () => { const home = await temporaryDirectory() const source = join(home, 'remote') await new IdentityStore({ directory: source }).loadOrCreate('Host') let entered!: () => void let release!: () => void const started = new Promise(resolve => { entered = resolve }) const finish = new Promise(resolve => { release = resolve }) const refresh = new ServerCredentialStore(source).withRefreshLock(async () => { entered() await finish }) await started const moving = prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }) await new Promise(resolve => setTimeout(resolve, 100)) await expect(stat(join(home, 'ds-harness-remote'))).rejects.toMatchObject({ code: 'ENOENT' }) release() await refresh expect(await moving).toBe(join(home, 'ds-harness-remote')) }) it('holds the migration gate while a default identity reset clears credentials', async () => { const home = await temporaryDirectory() const target = join(home, 'ds-harness-remote') await new IdentityStore({ directory: target }).loadOrCreate('Host') let enteredClear!: () => void let releaseClear!: () => void const clearing = new Promise(resolve => { enteredClear = resolve }) const finishClear = new Promise(resolve => { releaseClear = resolve }) const originalClear = ServerCredentialStore.prototype.clear const clear = vi.spyOn(ServerCredentialStore.prototype, 'clear') clear.mockImplementation(async function (this: ServerCredentialStore) { enteredClear() await finishClear return originalClear.call(this) }) try { const reset = resetDefaultIdentityRoles(['host'], undefined, 'New Host', { env: { DSH_HOME: home } }) await clearing let enteredRefresh = false const refresh = new ServerCredentialStore(target).withRefreshLock(async () => { enteredRefresh = true }) await new Promise(resolve => setTimeout(resolve, 100)) expect(enteredRefresh).toBe(false) releaseClear() expect(await reset).toBe(target) await refresh expect(enteredRefresh).toBe(true) } finally { releaseClear() clear.mockRestore() } }) it('keeps using verified legacy identities, trust and authorization when the directory move fails', async () => { for (const code of ['EACCES', 'EPERM', 'EBUSY', 'EXDEV', 'EROFS', 'ENOSPC', 'EDQUOT']) { const home = await temporaryDirectory() const source = join(home, 'remote') const env = { DSH_HOME: home } const store = new IdentityStore({ directory: source }) const original = await store.loadOrCreate('Host') await store.trustPeer({ deviceId: original.deviceId, name: 'Peer', platform: 'linux', publicKey: original.publicKey }) const credentials = await new ServerCredentialStore(source).save({ serverUrl: 'https://first.example.com', deviceId: original.deviceId, authorizationMethod: 'owned_device', accessToken: 'fixture-access-token', accessTokenExpiresAt: 1, refreshToken: 'fixture-refresh-token', refreshTokenExpiresAt: 2 }) const bytes = await readFile(join(source, 'server-credentials.json')) await mockMoveFailure(source, join(home, 'ds-harness-remote'), code) expect(await prepareDefaultIdentityDirectory({ env }), code).toBe(source) // A subsequent default-store load must adopt the fallback, without retrying // the move or creating a replacement identity at the canonical path. const fallback = new IdentityStore({ env }) expect(await fallback.loadOrCreate('Host'), code).toEqual(original) expect(fallback.directory).toBe(source) expect(fallback.listTrustedPeers()).toEqual(store.listTrustedPeers()) expect(await new ServerCredentialStore(fallback.directory).load(credentials.serverUrl, original.deviceId)).toEqual(credentials) expect(await readFile(join(source, 'server-credentials.json'))).toEqual(bytes) await expect(stat(join(home, 'ds-harness-remote'))).rejects.toMatchObject({ code: 'ENOENT' }) } }) it('refuses to replace missing or changed storage after a persisted legacy fallback and preserves 64-bit NTFS inode precision', async () => { for (const scenario of ['missing', 'replaced', 'float-pin', 'high-bit-ino']) { const home = await temporaryDirectory() const source = join(home, 'remote') const original = await new IdentityStore({ directory: source }).loadOrCreate('Host') await mockMoveFailure(source, join(home, 'ds-harness-remote'), 'EACCES') await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }) const pinPath = join(home, '.ds-harness-remote-migration', 'legacy-root.json') if (scenario === 'float-pin') { await writeFile(pinPath, JSON.stringify({ schemaVersion: 1, dev: 1.5, ino: 2.5 }), { mode: 0o600 }) await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }), scenario).rejects.toBeInstanceOf(IdentityInvalidError) continue } if (scenario === 'high-bit-ino') { const pinned = JSON.parse(await readFile(pinPath, 'utf8')) as { dev: number | string; ino: number | string } const lowBitChanged = (BigInt(pinned.ino) ^ 1n).toString() await writeFile(pinPath, JSON.stringify({ schemaVersion: 1, dev: String(pinned.dev), ino: lowBitChanged }), { mode: 0o600 }) await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }), scenario).rejects.toThrow('changed after fallback') continue } const backup = join(home, 'preserved') await rename(source, backup) if (scenario === 'replaced') await new IdentityStore({ directory: source }).loadOrCreate('Other Host') await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }), scenario).rejects.toBeInstanceOf(IdentityInvalidError) expect((await readFile(join(backup, 'device.key'), 'utf8')).trim()).toBe(original.privateKey) await expect(stat(join(home, 'ds-harness-remote'))).rejects.toMatchObject({ code: 'ENOENT' }) } }) it('leaves foreign, mixed and inconsistent legacy contents untouched instead of claiming ownership', async () => { for (const scenario of ['foreign', 'empty', 'mixed', 'wrong-key', 'bad-peers', 'wrong-device', 'wrong-scope', 'unknown-role']) { const home = await temporaryDirectory() const source = join(home, 'remote') await mkdir(source) const env = { DSH_HOME: home } if (scenario === 'foreign') await writeFile(join(source, 'settings.json'), '{"owner":"other-plugin"}') if (!['foreign', 'empty'].includes(scenario)) { const origin = 'https://first.example.com' const directory = scenario === 'wrong-scope' ? join(source, 'servers', '0'.repeat(24), 'host') : scenario === 'unknown-role' ? join(source, 'servers', '0'.repeat(24), 'other') : serverStorageDirectory(source, origin, 'host') const identity = await new IdentityStore({ directory }).loadOrCreate('Host') if (scenario === 'mixed') await writeFile(join(directory, 'foreign.txt'), 'leave-this-alone') if (scenario === 'wrong-key') await writeFile(join(directory, 'device.key'), 'invalid-private-key') if (scenario === 'bad-peers') await writeFile(join(directory, 'trusted-peers.json'), '{"schemaVersion":1,"peers":[{}]}') if (scenario === 'wrong-device' || scenario === 'wrong-scope') { await new ServerCredentialStore(directory).save({ serverUrl: origin, deviceId: scenario === 'wrong-device' ? 'another-device' : identity.deviceId, authorizationMethod: 'owned_device', accessToken: 'fixture-access-token', accessTokenExpiresAt: 1, refreshToken: 'fixture-refresh-token', refreshTokenExpiresAt: 2 }) } } const snapshot = async (directory: string): Promise => { const values: Record = {} for (const entry of await readdir(directory, { withFileTypes: true })) { values[entry.name] = entry.isDirectory() ? await snapshot(join(directory, entry.name)) : await readFile(join(directory, entry.name)) } return values } const before = await snapshot(source) await expect(prepareDefaultIdentityDirectory({ env }), scenario).rejects.toThrow('ownership could not be verified') expect(await snapshot(source), scenario).toEqual(before) await expect(stat(join(home, 'ds-harness-remote'))).rejects.toMatchObject({ code: 'ENOENT' }) } }) it('creates and reloads one stable device identity', async () => { const directory = await temporaryDirectory() const first = await new IdentityStore({ directory }).loadOrCreate('Workstation') const second = await new IdentityStore({ directory }).loadOrCreate('Renamed workstation') expect(second).toMatchObject({ deviceId: first.deviceId, publicKey: first.publicKey, privateKey: first.privateKey, name: 'Renamed workstation' }) expect(first.deviceId).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/) if (process.platform !== 'win32') { expect((await stat(join(directory, 'device.key'))).mode & 0o777).toBe(0o600) } }) it('persists trusted peers without private material', async () => { const hostDirectory = await temporaryDirectory() const clientDirectory = await temporaryDirectory() const hostStore = new IdentityStore({ directory: hostDirectory }) await hostStore.loadOrCreate('Host') const client = await new IdentityStore({ directory: clientDirectory }).loadOrCreate('Client') await hostStore.trustPeer({ deviceId: client.deviceId, name: client.name, platform: 'linux', publicKey: client.publicKey }) const stored = await readFile(join(hostDirectory, 'trusted-peers.json'), 'utf8') expect(stored).toContain(client.publicKey) expect(stored).not.toContain(client.privateKey) expect(hostStore.isTrusted(client.deviceId, client.publicKey)).toBe(true) }) it('reloads all trusted peers after discovering more than 256 hosts', async () => { const directory = await temporaryDirectory() const store = new IdentityStore({ directory }) const identity = await store.loadOrCreate('Client') for (let index = 0; index < 301; index++) { await store.trustPeer({ deviceId: `host-${index}`, name: `Host ${index}`, platform: 'linux', publicKey: identity.publicKey }) } const restarted = new IdentityStore({ directory }) await expect(restarted.loadOrCreate('Client')).resolves.toMatchObject({ deviceId: identity.deviceId }) expect(restarted.listTrustedPeers()).toEqual(store.listTrustedPeers()) const file = join(directory, 'trusted-peers.json') const records = JSON.parse(await readFile(file, 'utf8')) records.peers[300].fingerprint = 'invalid' await writeFile(file, JSON.stringify(records), { mode: 0o600 }) await expect(new IdentityStore({ directory }).loadOrCreate('Client')).rejects.toThrow(/invalid fingerprint/) }) it('fails closed for incomplete or overly permissive identity files', async () => { const incomplete = await temporaryDirectory() await writeFile(join(incomplete, 'device.json'), '{}') await expect(new IdentityStore({ directory: incomplete }).loadOrCreate('Host')).rejects.toBeInstanceOf(IdentityInvalidError) if (process.platform !== 'win32') { const permissive = await temporaryDirectory() await new IdentityStore({ directory: permissive }).loadOrCreate('Host') await chmod(join(permissive, 'device.key'), 0o644) await expect(new IdentityStore({ directory: permissive }).loadOrCreate('Host')).rejects.toThrow(/0600/) } }) it('isolates Host and Client identities by normalized Server origin', async () => { const root = await temporaryDirectory() const firstHost = serverStorageDirectory(root, 'https://one.example.com', 'host') const firstClient = serverStorageDirectory(root, 'https://one.example.com', 'client') const secondHost = serverStorageDirectory(root, 'https://two.example.com', 'host') expect(firstHost).not.toBe(firstClient) expect(firstHost).not.toBe(secondHost) expect(serverStorageDirectory(root, 'https://one.example.com/', 'host')).toBe(firstHost) }) it('serializes concurrent first-time creation onto one key pair', async () => { const directory = await temporaryDirectory() // Two Stores over one directory model the real incident: a Desktop restart // overlapping the previous Host process, both reaching the "create" branch. const stores = Array.from({ length: 6 }, () => new IdentityStore({ directory })) const created = await Promise.all(stores.map(store => store.loadOrCreate('Workstation'))) const [first] = created for (const identity of created) { expect(identity).toMatchObject({ deviceId: first!.deviceId, publicKey: first!.publicKey, privateKey: first!.privateKey }) } // The pair left on disk must still be self-consistent. const reloaded = await new IdentityStore({ directory }).loadOrCreate('Workstation') expect(reloaded.publicKey).toBe(first!.publicKey) expect(reloaded.privateKey).toBe(first!.privateKey) }) it('reports a mismatched key pair instead of silently minting a new identity', async () => { const directory = await temporaryDirectory() const original = await new IdentityStore({ directory }).loadOrCreate('Workstation') // Reproduce the incident's residue: overwrite the private key with an // unrelated one so the public key in device.json no longer matches. const other = await new IdentityStore({ directory: await temporaryDirectory() }).loadOrCreate('Other') await writeFile(join(directory, 'device.key'), `${other.privateKey}\n`) // Repair stays an explicit operator action: a silent rebuild would drop the // pinned peer trust and re-register the device without the user knowing. await expect(new IdentityStore({ directory }).loadOrCreate('Workstation')) .rejects.toThrow(/public and private keys do not match/) // The original record is left intact so the operator can still back it up. expect(JSON.parse(await readFile(join(directory, 'device.json'), 'utf8')).publicKey).toBe(original.publicKey) }) it('keeps recovery material when the stored pair does not verify', async () => { const directory = await temporaryDirectory() const original = await new IdentityStore({ directory }).loadOrCreate('Workstation') const other = await new IdentityStore({ directory: await temporaryDirectory() }).loadOrCreate('Other') const residue = join(directory, 'device.key.57692.01a1a04a-7ced-7ffe-b382-e5a2e689f6ad.tmp') await writeFile(residue, `${original.privateKey}\n`) await writeFile(join(directory, 'device.key'), `${other.privateKey}\n`) await expect(new IdentityStore({ directory }).loadOrCreate('Workstation')) .rejects.toThrow(/public and private keys do not match/) // That temp is the only private key still matching device.json (#276), so a // failed verification must not delete it the way a successful one does. await expect(readFile(residue, 'utf8')).resolves.toContain(original.privateKey) }) it('resets onto a fresh identity without leaving lock artifacts behind', async () => { const directory = await temporaryDirectory() const first = await new IdentityStore({ directory }).loadOrCreate('Workstation') const second = await new IdentityStore({ directory }).reset('Workstation') expect(second.deviceId).not.toBe(first.deviceId) expect((await readdir(directory)).sort()).toEqual(['device.json', 'device.key', 'trusted-peers.json']) await expect(new IdentityStore({ directory }).loadOrCreate('Workstation')).resolves.toMatchObject({ deviceId: second.deviceId, publicKey: second.publicKey, }) }) it('clears temporary files left behind by an interrupted write', async () => { const directory = await temporaryDirectory() await new IdentityStore({ directory }).loadOrCreate('Workstation') const residue = join(directory, 'device.key.57692.01a1a04a-7ced-7ffe-b382-e5a2e689f6ad.tmp') await writeFile(residue, 'stale\n') await new IdentityStore({ directory }).loadOrCreate('Workstation') const remaining = (await readdir(directory)).filter(name => name.endsWith('.tmp')) expect(remaining).toEqual([]) }) it('self-heals uncredentialed unpeered corrupt or incomplete client identities including across legacy migration', async () => { const first = await new IdentityStore({ directory: await temporaryDirectory() }).loadOrCreate('Client 1') const second = await new IdentityStore({ directory: await temporaryDirectory() }).loadOrCreate('Client 2') for (const scenario of ['mismatched', 'device-only', 'key-only', 'legacy-upgrade', 'legacy-client-only'] as const) { if (scenario === 'legacy-client-only') { const home = await temporaryDirectory() const legacyRoot = join(home, 'remote') const serverUrl = 'https://dsh.r2049.cn' const legacyClientDir = serverStorageDirectory(legacyRoot, serverUrl, 'client') await mkdir(legacyClientDir, { recursive: true }) await writeFile(join(legacyClientDir, 'device.json'), JSON.stringify({ schemaVersion: 1, deviceId: first.deviceId, name: 'Client', publicKey: first.publicKey, }), { mode: 0o600 }) await writeFile(join(legacyClientDir, 'device.key'), `${second.privateKey}\n`, { mode: 0o600 }) const migratedRoot = await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }) expect(migratedRoot).toBe(join(home, 'ds-harness-remote')) const migratedClientDir = serverStorageDirectory(migratedRoot, serverUrl, 'client') const healedClient = await new IdentityStore({ directory: migratedClientDir, role: 'client' }).loadOrCreate('Client') expect(healedClient.deviceId).not.toBe(first.deviceId) expect(await new IdentityStore({ directory: migratedClientDir, role: 'client' }).loadOrCreate('Client')).toEqual(healedClient) continue } if (scenario === 'legacy-upgrade') { const home = await temporaryDirectory() const legacyRoot = join(home, 'remote') const serverUrl = 'https://dsh.r2049.cn' const legacyHostDir = serverStorageDirectory(legacyRoot, serverUrl, 'host') const legacyClientDir = serverStorageDirectory(legacyRoot, serverUrl, 'client') const hostIdentity = await new IdentityStore({ directory: legacyHostDir, role: 'host' }).loadOrCreate('Host') await new ServerCredentialStore(legacyHostDir).save({ serverUrl, deviceId: hostIdentity.deviceId, authorizationMethod: 'account', account: 'host@example.com', accessToken: 'fixture-access-token', accessTokenExpiresAt: 1, refreshToken: 'fixture-refresh-token', refreshTokenExpiresAt: 2, }) const hostCredentialBytes = await readFile(join(legacyHostDir, 'server-credentials.json')) await mkdir(legacyClientDir, { recursive: true }) await writeFile(join(legacyClientDir, 'device.json'), JSON.stringify({ schemaVersion: 1, deviceId: first.deviceId, name: 'Client', publicKey: first.publicKey, }), { mode: 0o600 }) await writeFile(join(legacyClientDir, 'device.key'), `${second.privateKey}\n`, { mode: 0o600 }) const migratedRoot = await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }) expect(migratedRoot).toBe(join(home, 'ds-harness-remote')) const migratedHostDir = serverStorageDirectory(migratedRoot, serverUrl, 'host') const migratedClientDir = serverStorageDirectory(migratedRoot, serverUrl, 'client') expect(await new IdentityStore({ directory: migratedHostDir, role: 'host' }).loadOrCreate('Host')).toEqual(hostIdentity) expect(await readFile(join(migratedHostDir, 'server-credentials.json'))).toEqual(hostCredentialBytes) const healedClient = await new IdentityStore({ directory: migratedClientDir, role: 'client' }).loadOrCreate('Client') expect(healedClient.deviceId).not.toBe(first.deviceId) expect(await new IdentityStore({ directory: migratedClientDir, role: 'client' }).loadOrCreate('Client')).toEqual(healedClient) continue } const directory = await temporaryDirectory() if (scenario !== 'key-only') { await writeFile(join(directory, 'device.json'), JSON.stringify({ schemaVersion: 1, deviceId: first.deviceId, name: 'Client', publicKey: first.publicKey, })) } if (scenario !== 'device-only') { await writeFile(join(directory, 'device.key'), `${second.privateKey}\n`) } const healed = await new IdentityStore({ directory, role: 'client' }).loadOrCreate('Client') expect(healed.publicKey, scenario).toBeDefined() expect(healed.privateKey, scenario).toBeDefined() const reloaded = await new IdentityStore({ directory, role: 'client' }).loadOrCreate('Client') expect(reloaded, scenario).toEqual(healed) } }) it('refuses to auto-heal when credentials, trusted peers, unreadable peer records, or host role exist without altering stored bytes', async () => { const first = await new IdentityStore({ directory: await temporaryDirectory() }).loadOrCreate('Device 1') const second = await new IdentityStore({ directory: await temporaryDirectory() }).loadOrCreate('Device 2') for (const scenario of ['credentials', 'trusted-peers', 'corrupt-peers', 'unknown-file', 'unexpected-servers-dir', 'host-role'] as const) { const directory = await temporaryDirectory() await writeFile(join(directory, 'device.json'), JSON.stringify({ schemaVersion: 1, deviceId: first.deviceId, name: 'Device', publicKey: first.publicKey, }), { mode: 0o600 }) await writeFile(join(directory, 'device.key'), `${second.privateKey}\n`, { mode: 0o600 }) if (scenario === 'credentials') { await new ServerCredentialStore(directory).save({ serverUrl: 'https://dsh.r2049.cn', deviceId: first.deviceId, authorizationMethod: 'owned_device', accessToken: 'token-access-12345', accessTokenExpiresAt: Date.now() + 60000, refreshToken: 'token-refresh-12345', refreshTokenExpiresAt: Date.now() + 600000, }) } if (scenario === 'trusted-peers') { await writeFile(join(directory, 'trusted-peers.json'), JSON.stringify({ schemaVersion: 1, peers: [{ deviceId: 'peer-device-id', name: 'Peer', platform: 'linux', publicKey: first.publicKey, fingerprint: first.fingerprint, trustedAt: Date.now(), }], })) } if (scenario === 'corrupt-peers') { await writeFile(join(directory, 'trusted-peers.json'), '{corrupt-peers-json') } if (scenario === 'unknown-file') { await writeFile(join(directory, 'foreign.bak'), 'keep-me') } if (scenario === 'unexpected-servers-dir') { await mkdir(join(directory, 'servers'), { recursive: true }) } const beforeEntries = (await readdir(directory)).sort() const beforeBytes = new Map(await Promise.all( beforeEntries .filter(name => name !== 'servers') .map(async name => [name, await readFile(join(directory, name))] as const), )) const role = scenario === 'host-role' ? 'host' : 'client' await expect(new IdentityStore({ directory, role }).loadOrCreate('Device'), scenario) .rejects.toThrow(IdentityInvalidError) const afterEntries = (await readdir(directory)).sort() expect(afterEntries, scenario).toEqual(beforeEntries) for (const [name, bytes] of beforeBytes) { expect(await readFile(join(directory, name)), `${scenario}:${name}`).toEqual(bytes) } } }) it.each(['.DS_Store', 'desktop.ini', 'Thumbs.db', 'DESKTOP.INI', 'THUMBS.DB'])( 'keeps plain OS metadata %s at every level and migrates identities unchanged', async name => { const home = await temporaryDirectory() const source = join(home, 'remote') const host = serverStorageDirectory(source, 'https://example.com', 'host') const client = serverStorageDirectory(source, 'https://example.com', 'client') const first = await new IdentityStore({ directory: host }).loadOrCreate('Host') const second = await new IdentityStore({ directory: client, role: 'client' }).loadOrCreate('Client') const levels = [source, join(source, 'servers'), dirname(host), host, client] for (const level of levels) await writeFile(join(level, name), 'metadata') const target = await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }) expect(target).toBe(join(home, 'ds-harness-remote')) for (const level of levels) { expect(await readFile(join(level.replace(source, target), name), 'utf8')).toBe('metadata') } expect(await new IdentityStore({ directory: host.replace(source, target) }).loadOrCreate('Host')).toEqual(first) expect(await new IdentityStore({ directory: client.replace(source, target), role: 'client' }).loadOrCreate('Client')).toEqual(second) }, ) it('keeps plain OS metadata compatible with a flat legacy identity and client self-heal', async () => { for (const role of ['flat', 'client'] as const) { const home = await temporaryDirectory() const source = join(home, 'remote') const directory = role === 'flat' ? source : serverStorageDirectory(source, 'https://example.com', role) await new IdentityStore({ directory, role: role === 'flat' ? 'host' : role }).loadOrCreate('Device') await writeFile(join(directory, '.DS_Store'), 'metadata') if (role === 'client') await rm(join(directory, 'device.key')) const target = await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }) await expect(new IdentityStore({ directory: directory.replace(source, target), role: role === 'flat' ? 'host' : role }).loadOrCreate('Device')) .resolves.toHaveProperty('deviceId') } }) it.each(['.DS_Store', 'desktop.ini', 'Thumbs.db'])( 'client self-heal only tolerates plain metadata %s and keeps stored bytes otherwise', async name => { for (const kind of ['file', 'directory', 'hardlink', 'oversized'] as const) { const directory = await temporaryDirectory() await new IdentityStore({ directory, role: 'client' }).loadOrCreate('Client') const original = await readFile(join(directory, 'device.json')) await rm(join(directory, 'device.key')) const artifact = join(directory, name) if (kind === 'directory') await mkdir(artifact) else if (kind === 'hardlink') await link(join(directory, 'device.json'), artifact) else { await writeFile(artifact, 'metadata') if (kind === 'oversized') await truncate(artifact, 16 * 1024 * 1024 + 1) } const loaded = new IdentityStore({ directory, role: 'client' }).loadOrCreate('Client') if (kind === 'file') await expect(loaded).resolves.toHaveProperty('deviceId') else { await expect(loaded).rejects.toMatchObject({ code: 'IDENTITY_INVALID' }) expect(await readFile(join(directory, 'device.json'))).toEqual(original) } } }, ) it('still rejects metadata names used by directories, links, oversized files and unknown content', async () => { for (const level of ['root', 'servers', 'scope', 'role'] as const) { for (const kind of ['directory', 'symlink', 'hardlink', 'oversized', 'unknown', 'appledouble'] as const) { const home = await temporaryDirectory() const source = join(home, 'remote') const host = serverStorageDirectory(source, 'https://example.com', 'host') await new IdentityStore({ directory: host }).loadOrCreate('Host') const directory = { root: source, servers: join(source, 'servers'), scope: dirname(host), role: host }[level] const artifact = join(directory, kind === 'unknown' ? 'foreign.txt' : kind === 'appledouble' ? '._foreign' : '.DS_Store') if (kind === 'directory') await mkdir(artifact) else if (kind === 'symlink') await symlink(home, artifact, process.platform === 'win32' ? 'junction' : 'dir') else if (kind === 'hardlink') await link(join(host, 'device.json'), artifact) else { await writeFile(artifact, 'keep') if (kind === 'oversized') await truncate(artifact, 16 * 1024 * 1024 + 1) } await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }), `${level}:${kind}`) .rejects.toMatchObject({ code: 'STORAGE_CONFLICT' }) await expect(stat(source)).resolves.toBeDefined() } } }) it.each([ 'server-credentials.json.bak', 'server-credentials.json.bak-1793870140999', 'server-credentials.json.old', 'server-credentials.json.orig', 'server-credentials.json~', 'server-credentials.json.swp', ])('preserves known credential backups during migration: %s', async name => { const home = await temporaryDirectory() const source = join(home, 'remote') const directory = serverStorageDirectory(source, 'https://example.com', 'host') const identity = await new IdentityStore({ directory }).loadOrCreate('Host') await writeFile(join(directory, name), 'backup-bytes') const target = await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }) const migrated = directory.replace(source, target) expect(await readFile(join(migrated, name), 'utf8')).toBe('backup-bytes') expect(await new IdentityStore({ directory: migrated }).loadOrCreate('Host')).toEqual(identity) }) it('rejects unsafe known backup artifacts during migration', async () => { for (const kind of ['directory', 'symlink', 'hardlink', 'oversized'] as const) { const home = await temporaryDirectory() const source = join(home, 'remote') const directory = serverStorageDirectory(source, 'https://example.com', 'host') await new IdentityStore({ directory }).loadOrCreate('Host') const artifact = join(directory, 'server-credentials.json.bak') if (kind === 'directory') await mkdir(artifact) else if (kind === 'symlink') await symlink(home, artifact, process.platform === 'win32' ? 'junction' : 'dir') else if (kind === 'hardlink') await link(join(directory, 'device.json'), artifact) else { await writeFile(artifact, 'oversized') await truncate(artifact, 16 * 1024 * 1024 + 1) } await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }), kind) .rejects.toMatchObject({ code: 'STORAGE_CONFLICT' }) await expect(stat(source)).resolves.toBeDefined() } }) it('allows known backups while healing an unpaired client identity', async () => { const directory = await temporaryDirectory() const store = new IdentityStore({ directory, role: 'client' }) const original = await store.loadOrCreate('Client') await rm(join(directory, 'device.key')) await writeFile(join(directory, 'device.json.bak-1793870140999'), 'backup-bytes') const healed = await new IdentityStore({ directory, role: 'client' }).loadOrCreate('Client') expect(healed.deviceId).not.toBe(original.deviceId) expect(await readFile(join(directory, 'device.json.bak-1793870140999'), 'utf8')).toBe('backup-bytes') }) }) async function temporaryDirectory(): Promise { const directory = await mkdtemp(join(tmpdir(), 'dsh-remote-plugin-')) directories.push(directory) return directory } let cachedDeadPids: Promise<[number, number, number]> | undefined async function deadPids(): Promise<[number, number, number]> { cachedDeadPids ??= (async () => { const first = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 50)'], { stdio: 'ignore' }) const second = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 50)'], { stdio: 'ignore' }) const third = spawn(process.execPath, ['-e', ''], { stdio: 'ignore' }) await Promise.all([ new Promise(resolve => first.once('exit', () => resolve())), new Promise(resolve => second.once('exit', () => resolve())), new Promise(resolve => third.once('exit', () => resolve())), ]) return [first.pid!, second.pid!, third.pid!] })() return cachedDeadPids } async function deadPid(): Promise { const [first] = await deadPids() return first }