@namzu/sdk 14.0.6 → 15.0.0

package/src/session/migration/__tests__/filesystem.test.ts

@@ -1,270 +0,0 @@
-import { chmod, mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-import { IS_WINDOWS } from '../../../test-support/paths.js'
-import { UNKNOWN_TENANT_ID } from '../../../types/ids/index.js'
-import { FilesystemMigrationError } from '../errors.js'
-import {
-	DefaultFilesystemMigrator,
-	type FilesystemMigrationEvent,
-	type FilesystemMigrationSink,
-	LEGACY_DEFAULT_PROJECT_PREFIX,
-	LEGACY_DEFAULT_SESSION_ID,
-	MARKER_REL_PATH,
-	MIGRATION_VERSION,
-} from '../filesystem.js'
-import { acquireMigrationLock, writeMarker } from '../marker.js'
-
-function collectingSink(): {
-	events: FilesystemMigrationEvent[]
-	sink: FilesystemMigrationSink
-} {
-	const events: FilesystemMigrationEvent[] = []
-	return {
-		events,
-		sink: {
-			emit(ev) {
-				events.push(ev)
-			},
-		},
-	}
-}
-
-async function seedLegacyThread(root: string, thread: string, runs: string[]): Promise<void> {
-	for (const run of runs) {
-		const dir = join(root, 'threads', thread, 'runs', run)
-		await mkdir(dir, { recursive: true })
-		await writeFile(join(dir, 'run.json'), JSON.stringify({ id: run }), 'utf-8')
-	}
-}
-
-async function pathExists(p: string): Promise<boolean> {
-	try {
-		await stat(p)
-		return true
-	} catch {
-		return false
-	}
-}
-
-describe('DefaultFilesystemMigrator.migrate', () => {
-	let root: string
-
-	beforeEach(async () => {
-		root = await mkdtemp(join(tmpdir(), 'namzu-fsmig-'))
-	})
-
-	afterEach(async () => {
-		// chmod first in case a test left 000 perms on a directory.
-		await chmod(root, 0o755).catch(() => undefined)
-		await rm(root, { recursive: true, force: true })
-	})
-
-	it('cold boot with a single legacy thread: migrates, emits event, writes marker', async () => {
-		await seedLegacyThread(root, 'thd_abc', ['run_xyz'])
-
-		const { events, sink } = collectingSink()
-		const migrator = new DefaultFilesystemMigrator(sink)
-
-		const result = await migrator.migrate(root)
-
-		expect(result.kind).toBe('migrated')
-		expect(result.migratedThreads).toEqual([
-			{ legacyThreadId: 'thd_abc', newProjectId: `${LEGACY_DEFAULT_PROJECT_PREFIX}abc` },
-		])
-
-		// New layout exists.
-		const newRunDir = join(
-			root,
-			'projects',
-			`${LEGACY_DEFAULT_PROJECT_PREFIX}abc`,
-			'sessions',
-			LEGACY_DEFAULT_SESSION_ID,
-			'runs',
-			'run_xyz',
-		)
-		expect(await pathExists(newRunDir)).toBe(true)
-		expect(await pathExists(join(newRunDir, 'run.json'))).toBe(true)
-
-		// Legacy path moved (runs/ sub-tree renamed).
-		expect(await pathExists(join(root, 'threads', 'thd_abc', 'runs'))).toBe(false)
-
-		// Marker landed.
-		const markerRaw = await readFile(join(root, MARKER_REL_PATH), 'utf-8')
-		const markerParsed = JSON.parse(markerRaw)
-		expect(markerParsed.version).toBe(MIGRATION_VERSION)
-		expect(markerParsed.migratedThreads).toHaveLength(1)
-
-		// Event emitted with accurate result.
-		expect(events).toHaveLength(1)
-		expect(events[0]?.type).toBe('filesystem.migrated')
-		expect(events[0]?.result.kind).toBe('migrated')
-	})
-
-	it('warm boot with an existing marker short-circuits to already_migrated', async () => {
-		await writeMarker(join(root, MARKER_REL_PATH), {
-			version: MIGRATION_VERSION,
-			at: new Date(),
-			migratedThreads: [],
-		})
-		await seedLegacyThread(root, 'thd_stillhere', ['run_ignored'])
-
-		const { events, sink } = collectingSink()
-		const migrator = new DefaultFilesystemMigrator(sink)
-
-		const result = await migrator.migrate(root)
-
-		expect(result.kind).toBe('already_migrated')
-		expect(events).toHaveLength(0)
-		// No migration happened — legacy path untouched.
-		expect(await pathExists(join(root, 'threads', 'thd_stillhere', 'runs', 'run_ignored'))).toBe(
-			true,
-		)
-	})
-
-	it('cold boot with neither legacy nor marker writes a marker and returns noop_no_legacy', async () => {
-		const { events, sink } = collectingSink()
-		const migrator = new DefaultFilesystemMigrator(sink)
-
-		const result = await migrator.migrate(root)
-
-		expect(result.kind).toBe('noop_no_legacy')
-		expect(events).toHaveLength(0)
-		expect(await pathExists(join(root, MARKER_REL_PATH))).toBe(true)
-	})
-
-	it('cooperates with a concurrent migrator: main marker lands → already_migrated', async () => {
-		await seedLegacyThread(root, 'thd_abc', ['run_1'])
-
-		// Pre-seed the tmp lock to simulate another boot mid-migration.
-		await acquireMigrationLock(join(root, '.migration', 'v0.2.0.tmp'))
-
-		// Now write the main marker as the "winner" would. The loser must
-		// see this on the re-check after waiting and return already_migrated.
-		await writeMarker(join(root, MARKER_REL_PATH), {
-			version: MIGRATION_VERSION,
-			at: new Date(),
-			migratedThreads: [
-				{ legacyThreadId: 'thd_abc', newProjectId: `${LEGACY_DEFAULT_PROJECT_PREFIX}abc` },
-			],
-		})
-
-		// Because readMarker is checked FIRST (before lock contention), this
-		// actually returns already_migrated on step 1. That is the correct
-		// semantics: the main marker is the single source of truth.
-		const migrator = new DefaultFilesystemMigrator()
-		const result = await migrator.migrate(root)
-		expect(result.kind).toBe('already_migrated')
-	})
-
-	it('migrates multiple legacy threads in one pass with marker listing all', async () => {
-		await seedLegacyThread(root, 'thd_a', ['run_a1', 'run_a2'])
-		await seedLegacyThread(root, 'thd_b', ['run_b1'])
-		await seedLegacyThread(root, 'thd_c', ['run_c1'])
-
-		const migrator = new DefaultFilesystemMigrator()
-		const result = await migrator.migrate(root)
-
-		expect(result.kind).toBe('migrated')
-		expect(result.migratedThreads).toHaveLength(3)
-		const ids = result.migratedThreads.map((m) => m.legacyThreadId).sort()
-		expect(ids).toEqual(['thd_a', 'thd_b', 'thd_c'])
-
-		// Marker content mirrors result.
-		const markerRaw = await readFile(join(root, MARKER_REL_PATH), 'utf-8')
-		const markerParsed = JSON.parse(markerRaw)
-		expect(markerParsed.migratedThreads).toHaveLength(3)
-	})
-
-	it('synthesized project.json has _legacy: true and tenantId: UNKNOWN_TENANT_ID', async () => {
-		await seedLegacyThread(root, 'thd_tenantcheck', ['run_0'])
-		const migrator = new DefaultFilesystemMigrator()
-		await migrator.migrate(root)
-
-		const projectJsonPath = join(
-			root,
-			'projects',
-			`${LEGACY_DEFAULT_PROJECT_PREFIX}tenantcheck`,
-			'project.json',
-		)
-		const parsed = JSON.parse(await readFile(projectJsonPath, 'utf-8'))
-		expect(parsed._legacy).toBe(true)
-		expect(parsed.tenantId).toBe(UNKNOWN_TENANT_ID)
-		expect(parsed.id).toBe(`${LEGACY_DEFAULT_PROJECT_PREFIX}tenantcheck`)
-		expect(parsed.config).toMatchObject({
-			maxDelegationDepth: 4,
-			maxDelegationWidth: 8,
-			maxInterventionDepth: 10,
-		})
-	})
-
-	it('synthesized session.json is idle and flagged _legacy', async () => {
-		await seedLegacyThread(root, 'thd_sescheck', ['run_0'])
-		const migrator = new DefaultFilesystemMigrator()
-		await migrator.migrate(root)
-
-		const sessionJsonPath = join(
-			root,
-			'projects',
-			`${LEGACY_DEFAULT_PROJECT_PREFIX}sescheck`,
-			'sessions',
-			LEGACY_DEFAULT_SESSION_ID,
-			'session.json',
-		)
-		const parsed = JSON.parse(await readFile(sessionJsonPath, 'utf-8'))
-		expect(parsed.id).toBe(LEGACY_DEFAULT_SESSION_ID)
-		expect(parsed.status).toBe('idle')
-		expect(parsed.tenantId).toBe(UNKNOWN_TENANT_ID)
-		expect(parsed._legacy).toBe(true)
-	})
-
-	it('idempotent: two successive migrate() calls produce the same end-state', async () => {
-		await seedLegacyThread(root, 'thd_idem', ['run_1'])
-
-		const migrator = new DefaultFilesystemMigrator()
-		const first = await migrator.migrate(root)
-		const second = await migrator.migrate(root)
-
-		expect(first.kind).toBe('migrated')
-		expect(second.kind).toBe('already_migrated')
-		expect(second.migratedThreads).toHaveLength(0)
-		// End state still valid.
-		const newRunDir = join(
-			root,
-			'projects',
-			`${LEGACY_DEFAULT_PROJECT_PREFIX}idem`,
-			'sessions',
-			LEGACY_DEFAULT_SESSION_ID,
-			'runs',
-			'run_1',
-		)
-		expect(await pathExists(newRunDir)).toBe(true)
-	})
-
-	// chmod 0o555 does not prevent directory writes on Windows, so the
-	// failure this asserts cannot be induced there. Skip rather than leave
-	// the suite permanently red for Windows contributors.
-	it.skipIf(IS_WINDOWS)(
-		'error path: unwritable marker directory surfaces FilesystemMigrationError',
-		async () => {
-			// Make the rootDir read-only so write_marker fails on the noop branch
-			// (simplest repro — no legacy threads needed).
-			await chmod(root, 0o555)
-
-			const migrator = new DefaultFilesystemMigrator()
-			try {
-				await migrator.migrate(root)
-				expect.fail('expected migrate() to throw')
-			} catch (err) {
-				expect(err).toBeInstanceOf(FilesystemMigrationError)
-				const details = (err as FilesystemMigrationError).details
-				expect(details.op).toBe('write_marker')
-				expect(details.path).toContain('v0.2.0')
-			} finally {
-				// restore perms so afterEach can clean up
-				await chmod(root, 0o755).catch(() => undefined)
-			}
-		},
-	)
-})

package/src/session/migration/__tests__/id-prefix.test.ts

@@ -1,101 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest'
-import type { ProjectId } from '../../../types/session/ids.js'
-import {
-	NOOP_MIGRATION_WARNING_SINK,
-	StalePrefixError,
-	__resetSeenLegacyForTests,
-	acceptLegacyThreadId,
-	rejectLegacyPrefix,
-} from '../id-prefix.js'
-import type { MigrationWarning, MigrationWarningSink } from '../id-prefix.js'
-
-function collectingSink(): { emitted: MigrationWarning[]; sink: MigrationWarningSink } {
-	const emitted: MigrationWarning[] = []
-	return {
-		emitted,
-		sink: {
-			emit(w) {
-				emitted.push(w)
-			},
-		},
-	}
-}
-
-describe('acceptLegacyThreadId', () => {
-	beforeEach(() => {
-		__resetSeenLegacyForTests()
-	})
-
-	it('coerces thd_* to prj_* and emits a warning on first encounter', () => {
-		const { emitted, sink } = collectingSink()
-		const result = acceptLegacyThreadId('thd_abc', sink)
-		expect(result).toBe('prj_abc' as ProjectId)
-		expect(emitted).toHaveLength(1)
-		expect(emitted[0]?.kind).toBe('id_prefix_legacy_read')
-		expect(emitted[0]?.legacyId).toBe('thd_abc')
-		expect(emitted[0]?.normalizedId).toBe('prj_abc')
-		expect(emitted[0]?.emittedOncePerProcess).toBe(true)
-		expect(emitted[0]?.at).toBeInstanceOf(Date)
-	})
-
-	it('does NOT re-emit a warning for the same legacy id on a second call', () => {
-		const { emitted, sink } = collectingSink()
-		acceptLegacyThreadId('thd_abc', sink)
-		acceptLegacyThreadId('thd_abc', sink)
-		acceptLegacyThreadId('thd_abc', sink)
-		expect(emitted).toHaveLength(1)
-	})
-
-	it('emits distinct warnings for distinct legacy ids', () => {
-		const { emitted, sink } = collectingSink()
-		acceptLegacyThreadId('thd_abc', sink)
-		acceptLegacyThreadId('thd_xyz', sink)
-		expect(emitted).toHaveLength(2)
-		expect(emitted.map((w) => w.legacyId).sort()).toEqual(['thd_abc', 'thd_xyz'])
-	})
-
-	it('returns prj_* ids unchanged and emits no warning', () => {
-		const { emitted, sink } = collectingSink()
-		const result = acceptLegacyThreadId('prj_keepme', sink)
-		expect(result).toBe('prj_keepme' as ProjectId)
-		expect(emitted).toHaveLength(0)
-	})
-
-	it('rejects unknown prefixes with StalePrefixError', () => {
-		const { sink } = collectingSink()
-		expect(() => acceptLegacyThreadId('xyz_nope', sink)).toThrowError(StalePrefixError)
-	})
-
-	it('StalePrefixError carries structured details for unknown prefixes', () => {
-		const { sink } = collectingSink()
-		try {
-			acceptLegacyThreadId('xyz_nope', sink)
-			expect.fail('expected throw')
-		} catch (err) {
-			expect(err).toBeInstanceOf(StalePrefixError)
-			expect((err as StalePrefixError).details.rawId).toBe('xyz_nope')
-			expect((err as StalePrefixError).details.kind).toBe('unknown_prefix')
-		}
-	})
-
-	it('NOOP_MIGRATION_WARNING_SINK swallows warnings without error', () => {
-		expect(() => acceptLegacyThreadId('thd_noop', NOOP_MIGRATION_WARNING_SINK)).not.toThrow()
-	})
-})
-
-describe('rejectLegacyPrefix', () => {
-	it('throws StalePrefixError for thd_* input', () => {
-		expect(() => rejectLegacyPrefix('thd_abc')).toThrowError(StalePrefixError)
-	})
-
-	it('accepts prj_* input without throwing', () => {
-		expect(() => rejectLegacyPrefix('prj_abc')).not.toThrow()
-	})
-
-	it('accepts non-thread prefixes without throwing (writer guard is scoped)', () => {
-		// The guard is specifically for thd_* re-emission; unrelated prefixes
-		// are a concern for their own parse functions.
-		expect(() => rejectLegacyPrefix('ses_abc')).not.toThrow()
-		expect(() => rejectLegacyPrefix('run_abc')).not.toThrow()
-	})
-})

package/src/session/migration/__tests__/marker.test.ts

@@ -1,84 +0,0 @@
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-import type { ProjectId } from '../../../types/session/ids.js'
-import { acquireMigrationLock, readMarker, releaseMigrationLock, writeMarker } from '../marker.js'
-
-describe('migration marker I/O', () => {
-	let root: string
-
-	beforeEach(async () => {
-		root = await mkdtemp(join(tmpdir(), 'namzu-marker-'))
-	})
-
-	afterEach(async () => {
-		await rm(root, { recursive: true, force: true })
-	})
-
-	it('readMarker returns null when the file is missing', async () => {
-		const result = await readMarker(join(root, 'missing.json'))
-		expect(result).toBeNull()
-	})
-
-	it('readMarker parses a valid JSON marker', async () => {
-		const path = join(root, 'v0.2.0')
-		const at = new Date('2026-04-17T00:00:00.000Z')
-		await writeMarker(path, {
-			version: '0.2.0',
-			at,
-			migratedThreads: [{ legacyThreadId: 'thd_abc', newProjectId: 'prj_legacy_abc' as ProjectId }],
-		})
-		const result = await readMarker(path)
-		expect(result).not.toBeNull()
-		expect(result?.version).toBe('0.2.0')
-		expect(result?.at.toISOString()).toBe('2026-04-17T00:00:00.000Z')
-		expect(result?.migratedThreads).toEqual([
-			{ legacyThreadId: 'thd_abc', newProjectId: 'prj_legacy_abc' },
-		])
-	})
-
-	it('readMarker returns null on corrupt JSON (retry-safe)', async () => {
-		const path = join(root, 'corrupt.json')
-		await writeFile(path, '{ not valid json', 'utf-8')
-		const result = await readMarker(path)
-		expect(result).toBeNull()
-	})
-
-	it('writeMarker atomically writes via tmp-rename (no partial content)', async () => {
-		const path = join(root, 'v0.2.0')
-		await writeMarker(path, {
-			version: '0.2.0',
-			at: new Date(),
-			migratedThreads: [],
-		})
-		const content = await readFile(path, 'utf-8')
-		const parsed = JSON.parse(content)
-		expect(parsed.version).toBe('0.2.0')
-	})
-
-	it('acquireMigrationLock succeeds on first call and throws EEXIST on the second', async () => {
-		const lockPath = join(root, 'v0.2.0.tmp')
-		await acquireMigrationLock(lockPath)
-		let caught: NodeJS.ErrnoException | null = null
-		try {
-			await acquireMigrationLock(lockPath)
-		} catch (err) {
-			caught = err as NodeJS.ErrnoException
-		}
-		expect(caught).not.toBeNull()
-		expect(caught?.code).toBe('EEXIST')
-	})
-
-	it('releaseMigrationLock tolerates a missing file (idempotent)', async () => {
-		const lockPath = join(root, 'never-existed.tmp')
-		await expect(releaseMigrationLock(lockPath)).resolves.toBeUndefined()
-	})
-
-	it('releaseMigrationLock clears the lock so re-acquire succeeds', async () => {
-		const lockPath = join(root, 'v0.2.0.tmp')
-		await acquireMigrationLock(lockPath)
-		await releaseMigrationLock(lockPath)
-		await expect(acquireMigrationLock(lockPath)).resolves.toBeUndefined()
-	})
-})