@lotagate/cli 0.1.22 → 0.1.24

package/dist/infrastructure/sessions/file-session-store.js

@@ -1,525 +0,0 @@
-import crypto from 'node:crypto';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { CliError } from '../../domain/errors/cli-error.js';
-import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
-import { isRecord, isSessionEvent, isSessionMetadata, isTranscriptEntry } from '../../domain/session/session-schema.js';
-import { isGoalEventType, isPersistedGoalEventData } from '../../domain/orchestration/goal.js';
-import { isAlreadyExists, isFileNotFound } from '../filesystem/fs-errors.js';
-import { acquireAdvisoryFileLock, atomicWriteFile, releaseAdvisoryFileLock } from '../filesystem/atomic-file-store.js';
-import { isSafeProjectKey, resolveProjectSessionPaths, resolveProjectSessionPathsForKey } from './project-session-paths.js';
-import { appendJournalRecord, appendJournalRecords, eventRecord, journalEvents, journalTranscript, latestMetadata, metadataRecord, readJournal, repairJournal, transcriptRecord } from './session-journal.js';
-import { indexProjectSession, readProjectSessionIndex, readSessionLocator, removeIndexedSession } from './session-index.js';
-import { RESOURCE_LIMITS } from '../../domain/runtime/resource-limits.js';
-import { readJsonFileBounded } from '../filesystem/bounded-json-reader.js';
-const SESSION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-const ATTACHMENT_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
-const SESSION_LOCK_STALE_MS = 5 * 60 * 1000;
-export class FileSessionStore {
-    paths;
-    constructor(paths) {
-        this.paths = paths;
-    }
-    async create(input) {
-        const now = new Date().toISOString();
-        const metadata = { ...input, id: crypto.randomUUID(), createdAt: now, updatedAt: now };
-        const sessionPaths = resolveProjectSessionPaths(this.paths, metadata.cwd, metadata.id);
-        await fs.mkdir(sessionPaths.attachmentsDirectory, { recursive: true });
-        await appendJournalRecord(sessionPaths.journalFile, metadataRecord(metadata));
-        await indexProjectSession(this.paths, metadata, sessionPaths.projectKey);
-        return metadata;
-    }
-    async get(sessionId) {
-        const sessionPaths = await this.locate(sessionId);
-        if (sessionPaths === undefined)
-            return undefined;
-        try {
-            const metadata = latestMetadata(await readJournal(sessionPaths.journalFile));
-            if (metadata === undefined)
-                throw new Error('Session metadata is missing.');
-            return metadata;
-        }
-        catch (error) {
-            throw this.corrupt(sessionId, error);
-        }
-    }
-    async list(projectFingerprint) {
-        const sessions = [];
-        for (const projectKey of await this.projectKeys()) {
-            const projectPaths = resolveProjectSessionPathsForKey(this.paths, projectKey, '00000000-0000-4000-8000-000000000000');
-            const index = await this.readOrRebuildIndex(projectPaths.projectIndexFile, projectKey);
-            for (const metadata of Object.values(index))
-                if (projectFingerprint === undefined || metadata.projectFingerprint === projectFingerprint)
-                    sessions.push(metadata);
-        }
-        return sessions.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
-    }
-    async updateStatus(sessionId, status) {
-        return this.withLock(sessionId, async () => {
-            const metadata = await this.require(sessionId);
-            const updated = { ...metadata, status, updatedAt: new Date().toISOString() };
-            const sessionPaths = await this.requirePaths(sessionId);
-            await appendJournalRecord(sessionPaths.journalFile, metadataRecord(updated));
-            await indexProjectSession(this.paths, updated, sessionPaths.projectKey);
-            return updated;
-        });
-    }
-    async rename(sessionId, name) {
-        const normalized = name.trim().replace(/\s+/gu, ' ');
-        if (normalized.length === 0 || normalized.length > 120 || /[\r\n]/u.test(normalized) || normalized.includes('\0')) {
-            throw new CliError(CLI_ERROR_CODES.INVALID_ARGUMENT, 'Session name is invalid.', { category: 'session', userMessage: 'Session name must be between 1 and 120 printable characters.' });
-        }
-        return this.withLock(sessionId, async () => {
-            const metadata = await this.require(sessionId);
-            const updated = { ...metadata, name: normalized, updatedAt: new Date().toISOString() };
-            const sessionPaths = await this.requirePaths(sessionId);
-            await appendJournalRecord(sessionPaths.journalFile, metadataRecord(updated));
-            await indexProjectSession(this.paths, updated, sessionPaths.projectKey);
-            return updated;
-        });
-    }
-    async appendEvent(event, options = {}) {
-        const records = [{ kind: 'event', event }];
-        if (options.locked === true)
-            await this.appendJournalLocked(event.sessionId, records);
-        else
-            await this.appendJournal(event.sessionId, records);
-    }
-    async appendTranscript(sessionId, entry) {
-        await this.appendJournal(sessionId, [{ kind: 'transcript', entry }]);
-    }
-    async appendJournal(sessionId, records) {
-        if (records.length === 0)
-            return;
-        await this.withLock(sessionId, () => this.appendJournalLocked(sessionId, records));
-    }
-    async readEvents(sessionId) {
-        const sessionPaths = await this.requirePaths(sessionId);
-        await this.require(sessionId);
-        return journalEvents(await readJournal(sessionPaths.journalFile));
-    }
-    async readTranscript(sessionId) {
-        const sessionPaths = await this.requirePaths(sessionId);
-        await this.require(sessionId);
-        return journalTranscript(await readJournal(sessionPaths.journalFile));
-    }
-    async readHistory(sessionId) {
-        return this.withLock(sessionId, async () => {
-            const sessionPaths = await this.requirePaths(sessionId);
-            await this.require(sessionId);
-            const records = await readJournal(sessionPaths.journalFile);
-            return { events: journalEvents(records), transcript: journalTranscript(records) };
-        });
-    }
-    async delete(sessionId) {
-        const metadata = await this.get(sessionId);
-        if (metadata === undefined)
-            return false;
-        await this.withLock(sessionId, async () => {
-            const sessionPaths = await this.requirePaths(sessionId);
-            await fs.rm(sessionPaths.journalFile, { force: true });
-            await fs.rm(sessionPaths.sessionDirectory, { recursive: true, force: true });
-            await removeIndexedSession(this.paths, metadata, sessionPaths.projectKey);
-        });
-        return true;
-    }
-    async fork(sessionId, overrides = {}) {
-        const snapshot = await this.readSnapshot(sessionId);
-        const source = snapshot.metadata;
-        const forked = await this.create({ projectFingerprint: source.projectFingerprint, cwd: source.cwd, model: overrides.model ?? source.model, profile: overrides.profile ?? source.profile, status: 'active' });
-        try {
-            await this.withLock(forked.id, async () => {
-                const sessionPaths = await this.requirePaths(forked.id);
-                for (const event of snapshot.events) {
-                    const data = pauseForkedGoalEvent(event.data);
-                    await appendJournalRecord(sessionPaths.journalFile, eventRecord({ ...event, sessionId: forked.id, ...(data === undefined ? {} : { data }) }));
-                }
-                for (const entry of snapshot.transcript)
-                    await appendJournalRecord(sessionPaths.journalFile, transcriptRecord(entry));
-                for (const [attachmentId, item] of snapshot.attachments) {
-                    if (item.attachment !== undefined)
-                        await this.persistAttachment(forked.id, { ...item.attachment, id: attachmentId }, item.bytes);
-                }
-            });
-            return forked;
-        }
-        catch (error) {
-            try {
-                await this.delete(forked.id);
-            }
-            catch (cleanupError) {
-                throw new AggregateError([error, cleanupError], 'Session fork failed and cleanup was incomplete.');
-            }
-            throw error;
-        }
-    }
-    async compact(sessionId, summary, options = {}) {
-        const normalized = summary.trim();
-        if (normalized.length === 0)
-            throw new CliError(CLI_ERROR_CODES.SESSION_CORRUPTED, 'Compaction summary cannot be empty.', { category: 'session', userMessage: 'Compaction summary cannot be empty.' });
-        const timestamp = new Date().toISOString();
-        await this.appendJournal(sessionId, [
-            { kind: 'transcript', entry: { type: 'system', timestamp, content: `[Compacted context]\n${normalized}`, ...(options.turnId === undefined ? {} : { turnId: options.turnId }) } },
-            { kind: 'event', event: { type: 'context.compacted', timestamp, sessionId, ...(options.turnId === undefined ? {} : { turnId: options.turnId }), data: { summary: normalized } } },
-        ]);
-    }
-    async export(sessionId) {
-        const snapshot = await this.readSnapshot(sessionId);
-        const attachments = [];
-        for (const entry of snapshot.transcript)
-            for (const attachmentId of entry.attachmentIds ?? []) {
-                if (attachments.some((item) => item.attachment.id === attachmentId))
-                    continue;
-                const item = snapshot.attachments.get(attachmentId);
-                if (item === undefined)
-                    continue;
-                const attachment = item.attachment ?? { id: attachmentId, name: attachmentId, mimeType: 'application/octet-stream', sizeBytes: item.bytes.byteLength, source: 'file' };
-                attachments.push({ attachment, dataBase64: Buffer.from(item.bytes).toString('base64') });
-            }
-        return { metadata: snapshot.metadata, events: snapshot.events, transcript: snapshot.transcript, attachments };
-    }
-    async import(bundle, projectFingerprint, cwd) {
-        validateBundle(bundle);
-        const metadata = await this.create({ projectFingerprint, cwd, model: bundle.metadata.model, profile: bundle.metadata.profile, status: 'active' });
-        try {
-            for (const event of bundle.events) {
-                const data = pauseImportedGoalEvent(event.data);
-                await this.appendEvent({ ...event, sessionId: metadata.id, ...(data === undefined ? {} : { data }) });
-            }
-            for (const entry of bundle.transcript)
-                await this.appendTranscript(metadata.id, entry);
-            for (const item of bundle.attachments)
-                await this.saveAttachment(metadata.id, item.attachment, Buffer.from(item.dataBase64, 'base64'));
-            return metadata;
-        }
-        catch (error) {
-            try {
-                await this.delete(metadata.id);
-            }
-            catch (cleanupError) {
-                throw new AggregateError([error, cleanupError], 'Session import failed and cleanup was incomplete.');
-            }
-            throw error;
-        }
-    }
-    async saveAttachment(sessionId, attachment, bytes) {
-        if (!ATTACHMENT_ID_PATTERN.test(attachment.id))
-            throw new CliError(CLI_ERROR_CODES.ATTACHMENT_INVALID_IMAGE, 'Attachment id is invalid.', { category: 'attachment', userMessage: 'Attachment name is invalid.' });
-        if (attachment.sizeBytes < 0 || attachment.sizeBytes > RESOURCE_LIMITS.maxAttachmentBytes)
-            throw new CliError(CLI_ERROR_CODES.ATTACHMENT_TOO_LARGE, 'Attachment exceeds the allowed size.', { category: 'attachment', userMessage: 'Attachment exceeds the allowed size.' });
-        if (bytes.byteLength !== attachment.sizeBytes)
-            throw new CliError(CLI_ERROR_CODES.ATTACHMENT_INVALID_IMAGE, 'Attachment size does not match metadata.', { category: 'attachment', userMessage: 'Attachment size does not match its metadata.' });
-        return this.withLock(sessionId, () => this.persistAttachment(sessionId, attachment, bytes));
-    }
-    async persistAttachment(sessionId, attachment, bytes) {
-        const sessionPaths = await this.requirePaths(sessionId);
-        await this.require(sessionId);
-        await fs.mkdir(sessionPaths.attachmentsDirectory, { recursive: true });
-        const filePath = path.join(sessionPaths.attachmentsDirectory, `${attachment.id}.bin`);
-        await fs.writeFile(filePath, bytes, { flag: 'wx', mode: 0o600 }).catch(async (error) => { if (!isAlreadyExists(error))
-            throw error; await fs.writeFile(filePath, bytes, { mode: 0o600 }); });
-        await atomicWriteFile(path.join(sessionPaths.attachmentsDirectory, `${attachment.id}.json`), `${JSON.stringify(attachment, null, 2)}\n`);
-        return { ...attachment, storagePath: path.posix.join('attachments', `${attachment.id}.bin`) };
-    }
-    async readAttachment(sessionId, attachmentId) {
-        const sessionPaths = await this.requirePaths(sessionId);
-        await this.require(sessionId);
-        if (!ATTACHMENT_ID_PATTERN.test(attachmentId))
-            return undefined;
-        const filePath = path.join(sessionPaths.attachmentsDirectory, `${attachmentId}.bin`);
-        try {
-            const stat = await fs.stat(filePath);
-            if (stat.size > RESOURCE_LIMITS.maxAttachmentBytes) {
-                throw new CliError(CLI_ERROR_CODES.ATTACHMENT_TOO_LARGE, 'Stored attachment exceeds the allowed size.', { category: 'attachment', userMessage: 'Stored attachment exceeds the allowed size.' });
-            }
-            return await fs.readFile(filePath);
-        }
-        catch (error) {
-            if (isFileNotFound(error))
-                return undefined;
-            throw error;
-        }
-    }
-    async recoverStaleLock(sessionId) {
-        const sessionPaths = await this.locate(sessionId);
-        if (sessionPaths === undefined)
-            return false;
-        let stat;
-        try {
-            stat = await fs.stat(sessionPaths.lockFile);
-        }
-        catch (error) {
-            if (isFileNotFound(error))
-                return false;
-            throw error;
-        }
-        if (Date.now() - stat.mtimeMs < SESSION_LOCK_STALE_MS)
-            return false;
-        let lock = {};
-        try {
-            lock = await readJsonFileBounded(sessionPaths.lockFile, 4 * 1024);
-        }
-        catch { /* stale malformed lock is recoverable after age threshold */ }
-        if (typeof lock.pid === 'number' && isProcessAlive(lock.pid))
-            return false;
-        await fs.rm(sessionPaths.lockFile, { force: true });
-        return true;
-    }
-    async repair(sessionId) {
-        const sessionPaths = await this.requirePaths(sessionId);
-        const removed = await this.withLock(sessionId, () => repairJournal(sessionPaths.journalFile));
-        return { eventsRemoved: removed, transcriptRemoved: 0 };
-    }
-    async withLock(sessionId, action) {
-        const sessionPaths = await this.requirePaths(sessionId);
-        await fs.mkdir(sessionPaths.sessionDirectory, { recursive: true });
-        let handle;
-        try {
-            handle = await acquireAdvisoryFileLock(sessionPaths.lockFile);
-        }
-        catch (error) {
-            if (isAlreadyExists(error) && await this.recoverStaleLock(sessionId))
-                return this.withLock(sessionId, action);
-            if (isAlreadyExists(error))
-                throw new CliError(CLI_ERROR_CODES.SESSION_LOCKED, `Session is locked: ${sessionId}`, { category: 'session', userMessage: 'The session is being used by another process. Try again later.', retryable: true });
-            throw error;
-        }
-        try {
-            return await action();
-        }
-        finally {
-            await releaseAdvisoryFileLock(handle, sessionPaths.lockFile);
-        }
-    }
-    async require(sessionId) {
-        const metadata = await this.get(sessionId);
-        if (metadata === undefined)
-            throw new CliError(CLI_ERROR_CODES.SESSION_NOT_FOUND, `Session not found: ${sessionId}`, { category: 'session', userMessage: `Session not found: ${sessionId}.` });
-        return metadata;
-    }
-    async requirePaths(sessionId) {
-        const sessionPaths = await this.locate(sessionId);
-        if (sessionPaths === undefined)
-            throw new CliError(CLI_ERROR_CODES.SESSION_NOT_FOUND, `Session not found: ${sessionId}`, { category: 'session', userMessage: `Session not found: ${sessionId}.` });
-        return sessionPaths;
-    }
-    async locate(sessionId) {
-        if (!SESSION_ID_PATTERN.test(sessionId))
-            return undefined;
-        const locator = await readSessionLocator(this.paths);
-        const projectKey = locator.sessions[sessionId];
-        if (typeof projectKey === 'string' && isSafeProjectKey(projectKey)) {
-            const located = resolveProjectSessionPathsForKey(this.paths, projectKey, sessionId);
-            if (await fileExists(located.journalFile))
-                return located;
-        }
-        return this.locateByScan(sessionId);
-    }
-    async locateByScan(sessionId) {
-        for (const projectKey of await this.projectKeys()) {
-            const candidate = resolveProjectSessionPathsForKey(this.paths, projectKey, sessionId);
-            if (await fileExists(candidate.journalFile))
-                return candidate;
-        }
-        return undefined;
-    }
-    async projectKeys() {
-        try {
-            return (await fs.readdir(this.paths.projectsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory() && isSafeProjectKey(entry.name)).map((entry) => entry.name);
-        }
-        catch (error) {
-            if (isFileNotFound(error))
-                return [];
-            throw error;
-        }
-    }
-    async readOrRebuildIndex(filePath, projectKey) {
-        try {
-            const sessions = (await readProjectSessionIndex(filePath, projectKey)).sessions;
-            if (await this.indexMatchesJournals(projectKey, sessions))
-                return sessions;
-            return this.rebuildProjectIndex(projectKey);
-        }
-        catch {
-            return this.rebuildProjectIndex(projectKey);
-        }
-    }
-    async indexMatchesJournals(projectKey, sessions) {
-        const journalIds = await this.projectJournalIds(projectKey);
-        const indexedIds = Object.keys(sessions);
-        return journalIds.length === indexedIds.length && journalIds.every((id) => sessions[id] !== undefined);
-    }
-    async projectJournalIds(projectKey) {
-        const directory = path.join(this.paths.projectsDir, projectKey);
-        try {
-            return (await fs.readdir(directory, { withFileTypes: true }))
-                .filter((entry) => entry.isFile() && entry.name.endsWith('.jsonl'))
-                .map((entry) => entry.name.slice(0, -'.jsonl'.length))
-                .filter((id) => SESSION_ID_PATTERN.test(id));
-        }
-        catch (error) {
-            if (isFileNotFound(error))
-                return [];
-            throw error;
-        }
-    }
-    async projectHasJournals(projectKey) {
-        const directory = path.join(this.paths.projectsDir, projectKey);
-        try {
-            return (await fs.readdir(directory, { withFileTypes: true })).some((entry) => entry.isFile() && entry.name.endsWith('.jsonl'));
-        }
-        catch (error) {
-            if (isFileNotFound(error))
-                return false;
-            throw error;
-        }
-    }
-    async rebuildProjectIndex(projectKey) {
-        const sessions = {};
-        const projectDirectory = path.join(this.paths.projectsDir, projectKey);
-        for (const entry of await fs.readdir(projectDirectory, { withFileTypes: true })) {
-            if (!entry.isFile() || !entry.name.endsWith('.jsonl'))
-                continue;
-            try {
-                const metadata = latestMetadata(await readJournal(path.join(projectDirectory, entry.name)));
-                if (metadata !== undefined)
-                    sessions[metadata.id] = metadata;
-            }
-            catch { /* A corrupted session remains inspectable through session show/repair. */ }
-        }
-        const indexFile = path.join(projectDirectory, 'index.json');
-        await fs.mkdir(projectDirectory, { recursive: true });
-        await atomicWriteFile(indexFile, `${JSON.stringify({ projectKey, sessions }, null, 2)}\n`);
-        for (const metadata of Object.values(sessions))
-            await indexProjectSession(this.paths, metadata, projectKey);
-        return sessions;
-    }
-    async readSnapshot(sessionId) {
-        return this.withLock(sessionId, async () => {
-            const metadata = await this.require(sessionId);
-            const sessionPaths = await this.requirePaths(sessionId);
-            const records = await readJournal(sessionPaths.journalFile);
-            const events = journalEvents(records);
-            const transcript = journalTranscript(records);
-            const attachments = new Map();
-            for (const entry of transcript)
-                for (const attachmentId of entry.attachmentIds ?? []) {
-                    if (attachments.has(attachmentId))
-                        continue;
-                    const bytes = await this.readAttachment(sessionId, attachmentId);
-                    if (bytes !== undefined)
-                        attachments.set(attachmentId, { bytes, attachment: await this.readAttachmentMetadata(sessionPaths, attachmentId) });
-                }
-            return { metadata, events, transcript, attachments };
-        });
-    }
-    async appendJournalLocked(sessionId, records) {
-        const sessionPaths = await this.requirePaths(sessionId);
-        await this.require(sessionId);
-        const journalRecords = records.map((record) => {
-            if (record.kind === 'event' && record.event.sessionId !== sessionId) {
-                throw new CliError(CLI_ERROR_CODES.SESSION_CORRUPTED, 'Cannot append an event to a different session.', {
-                    category: 'session', userMessage: 'Session event data is invalid.',
-                });
-            }
-            return record.kind === 'event' ? eventRecord(record.event) : transcriptRecord(record.entry);
-        });
-        await appendJournalRecords(sessionPaths.journalFile, journalRecords);
-    }
-    async readAttachmentMetadata(sessionPaths, attachmentId) {
-        try {
-            return parseAttachment(await readJsonFileBounded(path.join(sessionPaths.attachmentsDirectory, `${attachmentId}.json`), RESOURCE_LIMITS.configFileBytes));
-        }
-        catch (error) {
-            if (isFileNotFound(error))
-                return undefined;
-            throw error;
-        }
-    }
-    corrupt(sessionId, cause) { return new CliError(CLI_ERROR_CODES.SESSION_CORRUPTED, `Session metadata is corrupted: ${sessionId}`, { category: 'session', userMessage: 'Session is corrupted and its metadata cannot be read.', cause }); }
-}
-function pauseForkedGoalEvent(data) {
-    return pauseGoalEventData(data);
-}
-function pauseImportedGoalEvent(data) {
-    return pauseGoalEventData(data);
-}
-function pauseGoalEventData(data) {
-    if (data === undefined || typeof data['goal'] !== 'object' || data['goal'] === null)
-        return data;
-    const goal = data['goal'];
-    if (goal['status'] !== 'active')
-        return data;
-    return { ...data, goal: { ...goal, status: 'paused', updatedAt: new Date().toISOString() }, reason: 'Explicit resume is required after fork or import.' };
-}
-async function fileExists(filePath) { try {
-    await fs.access(filePath);
-    return true;
-}
-catch (error) {
-    if (isFileNotFound(error))
-        return false;
-    throw error;
-} }
-function isProcessAlive(pid) { if (pid === process.pid)
-    return true; try {
-    process.kill(pid, 0);
-    return true;
-}
-catch {
-    return false;
-} }
-function validateBundle(bundle) {
-    if (!isSessionMetadata(bundle.metadata) || !Array.isArray(bundle.events) || !Array.isArray(bundle.transcript) || !Array.isArray(bundle.attachments))
-        throw invalidBundle('Session export file is invalid.');
-    if (bundle.events.length > RESOURCE_LIMITS.sessionEvents || bundle.transcript.length > RESOURCE_LIMITS.sessionTranscriptEntries || bundle.attachments.length > RESOURCE_LIMITS.sessionAttachments)
-        throw invalidBundle('Session export exceeds the supported entry limits.');
-    for (const event of bundle.events) {
-        if (!isSessionEvent(event))
-            throw invalidBundle('Session export contains an invalid event.');
-        if (isGoalEventType(event.type) && !isPersistedGoalEventData(event.data))
-            throw invalidBundle('Session export contains an invalid goal event.');
-        if (byteLength(event.type) > 256 || byteLength(event.timestamp) > 128 || byteLength(event.sessionId) > 128)
-            throw invalidBundle('Session event metadata is too large.');
-    }
-    const attachmentIds = new Set();
-    let totalAttachmentBytes = 0;
-    for (const entry of bundle.transcript) {
-        if (!isTranscriptEntry(entry) || byteLength(entry.content) > RESOURCE_LIMITS.sessionTextBytes)
-            throw invalidBundle('Session export contains an invalid transcript entry.');
-        if (entry.attachmentIds !== undefined && (!Array.isArray(entry.attachmentIds) || entry.attachmentIds.some((id) => typeof id !== 'string' || !ATTACHMENT_ID_PATTERN.test(id))))
-            throw invalidBundle('Session transcript contains invalid attachment references.');
-    }
-    for (const item of bundle.attachments) {
-        if (!isSessionAttachment(item))
-            throw invalidBundle('Session export contains an invalid attachment.');
-        const attachment = item.attachment;
-        if (typeof attachment.id !== 'string' || !ATTACHMENT_ID_PATTERN.test(attachment.id) || attachmentIds.has(attachment.id) || typeof attachment.name !== 'string' || typeof attachment.mimeType !== 'string' || typeof attachment.sizeBytes !== 'number' || !Number.isSafeInteger(attachment.sizeBytes) || attachment.sizeBytes < 0 || attachment.sizeBytes > RESOURCE_LIMITS.maxAttachmentBytes || (attachment.source !== 'clipboard' && attachment.source !== 'file'))
-            throw invalidBundle('Session export contains invalid attachment metadata.');
-        const bytes = Buffer.from(item.dataBase64, 'base64');
-        if (bytes.toString('base64') !== item.dataBase64 || bytes.byteLength !== attachment.sizeBytes)
-            throw invalidBundle('Session export contains an invalid attachment payload.');
-        totalAttachmentBytes += bytes.byteLength;
-        if (totalAttachmentBytes > RESOURCE_LIMITS.sessionAttachmentTotalBytes)
-            throw invalidBundle('Session export exceeds the total attachment limit.');
-        attachmentIds.add(attachment.id);
-    }
-}
-function isSessionAttachment(value) {
-    if (!isRecord(value) || !isRecord(value['attachment']) || typeof value['dataBase64'] !== 'string')
-        return false;
-    const attachment = value['attachment'];
-    return typeof attachment['id'] === 'string' && typeof attachment['name'] === 'string' && typeof attachment['mimeType'] === 'string'
-        && typeof attachment['sizeBytes'] === 'number' && Number.isSafeInteger(attachment['sizeBytes'])
-        && (attachment['source'] === 'clipboard' || attachment['source'] === 'file');
-}
-function byteLength(value) { return Buffer.byteLength(value, 'utf8'); }
-function invalidBundle(message) { return new CliError(CLI_ERROR_CODES.SESSION_CORRUPTED, message, { category: 'session', userMessage: message }); }
-function parseAttachment(value) {
-    if (typeof value !== 'object' || value === null)
-        throw new Error('Invalid attachment metadata.');
-    const record = value;
-    if (typeof record['id'] !== 'string' || typeof record['name'] !== 'string' || typeof record['mimeType'] !== 'string' || typeof record['sizeBytes'] !== 'number' || (record['source'] !== 'clipboard' && record['source'] !== 'file'))
-        throw new Error('Invalid attachment metadata.');
-    return value;
-}

package/dist/infrastructure/sessions/project-session-paths.d.ts

@@ -1,17 +0,0 @@
-import type { PlatformPaths } from '../platform/platform-paths.js';
-import { type HostPlatformContext } from '../platform/host-platform.js';
-export interface ProjectSessionPaths {
-    projectKey: string;
-    projectDirectory: string;
-    projectIndexFile: string;
-    sessionId: string;
-    journalFile: string;
-    sessionDirectory: string;
-    attachmentsDirectory: string;
-    subagentsDirectory: string;
-    lockFile: string;
-}
-export declare function isSafeProjectKey(value: string): boolean;
-export declare function createProjectKey(cwd: string, platform?: HostPlatformContext): string;
-export declare function resolveProjectSessionPaths(paths: PlatformPaths, cwd: string, sessionId: string): ProjectSessionPaths;
-export declare function resolveProjectSessionPathsForKey(paths: PlatformPaths, projectKey: string, sessionId: string): ProjectSessionPaths;

package/dist/infrastructure/sessions/project-session-paths.js

@@ -1,41 +0,0 @@
-import crypto from 'node:crypto';
-import path from 'node:path';
-import { detectHostPlatform } from '../platform/host-platform.js';
-export function isSafeProjectKey(value) {
-    return /^[A-Za-z0-9._-]+--[0-9a-f]{12}$/u.test(value);
-}
-export function createProjectKey(cwd, platform = detectHostPlatform()) {
-    const canonical = path.resolve(cwd);
-    const comparisonValue = platform.isWindows ? canonical.toLowerCase() : canonical;
-    const hash = crypto.createHash('sha256').update(comparisonValue, 'utf8').digest('hex').slice(0, 12);
-    const display = canonical
-        .replaceAll('\\', '-')
-        .replaceAll('/', '-')
-        .replaceAll(':', '-')
-        .replace(/[^A-Za-z0-9._-]+/gu, '-')
-        .replace(/-+/gu, '-')
-        .replace(/^-|-$/gu, '')
-        .slice(0, 120);
-    return `${display || 'project'}--${hash}`;
-}
-export function resolveProjectSessionPaths(paths, cwd, sessionId) {
-    const projectKey = createProjectKey(cwd, paths.platform);
-    return resolveProjectSessionPathsForKey(paths, projectKey, sessionId);
-}
-export function resolveProjectSessionPathsForKey(paths, projectKey, sessionId) {
-    if (!isSafeProjectKey(projectKey))
-        throw new Error('Invalid project session key.');
-    const projectDirectory = path.join(paths.projectsDir, projectKey);
-    const sessionDirectory = path.join(projectDirectory, sessionId);
-    return {
-        projectKey,
-        projectDirectory,
-        projectIndexFile: path.join(projectDirectory, 'index.json'),
-        sessionId,
-        journalFile: path.join(projectDirectory, `${sessionId}.jsonl`),
-        sessionDirectory,
-        attachmentsDirectory: path.join(sessionDirectory, 'attachments'),
-        subagentsDirectory: path.join(sessionDirectory, 'subagents'),
-        lockFile: path.join(sessionDirectory, 'lock'),
-    };
-}

package/dist/infrastructure/sessions/session-index.d.ts

@@ -1,16 +0,0 @@
-import type { SessionMetadata } from '../../domain/session/session.js';
-import type { PlatformPaths } from '../platform/platform-paths.js';
-interface ProjectSessionIndex {
-    projectKey: string;
-    sessions: Record<string, SessionMetadata>;
-}
-interface SessionLocatorIndex {
-    sessions: Record<string, string>;
-}
-export declare function readProjectSessionIndex(filePath: string, projectKey: string): Promise<ProjectSessionIndex>;
-export declare function writeProjectSessionIndex(filePath: string, projectKey: string, sessions: Readonly<Record<string, SessionMetadata>>): Promise<void>;
-export declare function readSessionLocator(paths: PlatformPaths): Promise<SessionLocatorIndex>;
-export declare function writeSessionLocator(paths: PlatformPaths, sessions: Readonly<Record<string, string>>): Promise<void>;
-export declare function indexProjectSession(paths: PlatformPaths, metadata: SessionMetadata, projectKey: string): Promise<void>;
-export declare function removeIndexedSession(paths: PlatformPaths, metadata: SessionMetadata, projectKey: string): Promise<void>;
-export {};