godot-daedalus_backend 1.0.0

package/src/session/session-store.ts

@@ -0,0 +1,669 @@
+import { createReadStream } from "node:fs";
+import { access, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { getDefaultArchivedSessionsDir, getDefaultSessionsDir } from "../app-paths.js";
+import type { ChatMessage } from "../protocol/types.js";
+
+const SESSIONS_DIR: string = getDefaultSessionsDir();
+const ARCHIVED_SESSIONS_DIR: string = getDefaultArchivedSessionsDir();
+const SESSION_ID_PATTERN: RegExp = /^session-[a-zA-Z0-9_-]+$/;
+
+let ensureSessionsDirPromise: Promise<void> | null = null;
+let ensureArchivedSessionsDirPromise: Promise<void> | null = null;
+
+export type SessionMetadata = {
+	id: string;
+	title: string;
+	workspaceId?: string | undefined;
+	activeSkillId?: string | undefined;
+	provider?: string | undefined;
+	model?: string | undefined;
+	archivedAt?: string | undefined;
+	createdAt: string;
+	updatedAt: string;
+};
+
+export type StoredMessage = ChatMessage & {
+	createdAt: string;
+};
+
+export type StoredSessionEvent = {
+	id: string;
+	requestId: string;
+	event: string;
+	data: unknown;
+	createdAt: string;
+};
+
+export type StoredSession = {
+	metadata: SessionMetadata;
+	messages: StoredMessage[];
+	events: StoredSessionEvent[];
+};
+
+export type StoredSessionTimelinePage = {
+	metadata: SessionMetadata;
+	messages: StoredMessage[];
+	events: StoredSessionEvent[];
+	messageCount: number;
+	eventCount: number;
+	messagesOffset: number;
+	hasMoreBefore: boolean;
+	latestWorkflowSnapshot: unknown | null;
+};
+
+export type SessionSummary = {
+	content: string;
+	messageCount: number;
+	tokenEstimate: number;
+	generatedAt: string;
+};
+
+function assertSafeSessionId(sessionId: string): string {
+	if (!SESSION_ID_PATTERN.test(sessionId)) {
+		throw new Error(`Invalid session id: ${sessionId}`);
+	}
+
+	return sessionId;
+}
+
+function getSessionDir(sessionId: string): string {
+	return join(SESSIONS_DIR, assertSafeSessionId(sessionId));
+}
+
+function getArchivedSessionDir(sessionId: string): string {
+	return join(ARCHIVED_SESSIONS_DIR, assertSafeSessionId(sessionId));
+}
+
+async function ensureSessionsDir(): Promise<void> {
+	if (!ensureSessionsDirPromise) {
+		ensureSessionsDirPromise = (async (): Promise<void> => {
+			await mkdir(SESSIONS_DIR, { recursive: true });
+		})();
+	}
+
+	await ensureSessionsDirPromise;
+}
+
+async function ensureArchivedSessionsDir(): Promise<void> {
+	if (!ensureArchivedSessionsDirPromise) {
+		ensureArchivedSessionsDirPromise = (async (): Promise<void> => {
+			await mkdir(ARCHIVED_SESSIONS_DIR, { recursive: true });
+		})();
+	}
+
+	await ensureArchivedSessionsDirPromise;
+}
+
+async function createSessionDir(sessionId: string): Promise<string> {
+	await ensureSessionsDir();
+	const dir: string = getSessionDir(sessionId);
+	await mkdir(dir, { recursive: true });
+	return dir;
+}
+
+function metaPath(sessionId: string): string {
+	return join(getSessionDir(sessionId), "metadata.json");
+}
+
+function archivedMetaPath(sessionId: string): string {
+	return join(getArchivedSessionDir(sessionId), "metadata.json");
+}
+
+function messagesPath(sessionId: string): string {
+	return join(getSessionDir(sessionId), "messages.jsonl");
+}
+
+function eventsPath(sessionId: string): string {
+	return join(getSessionDir(sessionId), "events.jsonl");
+}
+
+export async function createSession(title: string, workspaceId?: string, skillId?: string): Promise<SessionMetadata> {
+	const timestamp: string = new Date().toISOString();
+	const dateStr: string = timestamp.slice(0, 10).replace(/-/g, "");
+	const id: string = `session-${dateStr}-${Date.now().toString(36)}`;
+
+	const metadata: SessionMetadata = {
+		id,
+		title,
+		workspaceId,
+		activeSkillId: skillId,
+		createdAt: timestamp,
+		updatedAt: timestamp
+	};
+
+	const dir: string = await createSessionDir(id);
+	await writeFile(join(dir, "metadata.json"), JSON.stringify(metadata, null, 2), "utf8");
+	await writeFile(join(dir, "messages.jsonl"), "", "utf8");
+	await writeFile(join(dir, "events.jsonl"), "", "utf8");
+
+	return metadata;
+}
+
+function parseJsonLines<T>(rawLines: string): T[] {
+	const items: T[] = [];
+
+	for (const line of rawLines.split("\n")) {
+		const trimmed: string = line.trim();
+		if (trimmed.length === 0) {
+			continue;
+		}
+
+		try {
+			items.push(JSON.parse(trimmed) as T);
+		} catch {
+			// Skip corrupted lines
+		}
+	}
+
+	return items;
+}
+
+function parseJsonLine<T>(line: string): T | null {
+	const trimmed: string = line.trim();
+	if (trimmed.length === 0) {
+		return null;
+	}
+
+	try {
+		return JSON.parse(trimmed) as T;
+	} catch {
+		return null;
+	}
+}
+
+async function readSessionMetadata(sessionId: string): Promise<SessionMetadata> {
+	await ensureSessionsDir();
+	const metaFile: string = metaPath(sessionId);
+
+	try {
+		const raw: string = await readFile(metaFile, "utf8");
+		return JSON.parse(raw) as SessionMetadata;
+	} catch {
+		throw new Error(`Session not found: ${sessionId}`);
+	}
+}
+
+async function readArchivedSessionMetadata(sessionId: string): Promise<SessionMetadata> {
+	await ensureArchivedSessionsDir();
+	const metaFile: string = archivedMetaPath(sessionId);
+
+	try {
+		const raw: string = await readFile(metaFile, "utf8");
+		return JSON.parse(raw) as SessionMetadata;
+	} catch {
+		throw new Error(`Archived session not found: ${sessionId}`);
+	}
+}
+
+async function pathExists(path: string): Promise<boolean> {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function listSessionMetadataFromDir(rootDir: string): Promise<SessionMetadata[]> {
+	const entries: string[] = await readdir(rootDir, { withFileTypes: true })
+		.then((items) => items.filter((d) => d.isDirectory()).map((d) => d.name));
+
+	const sessions: SessionMetadata[] = [];
+
+	for (const entry of entries) {
+		try {
+			const raw: string = await readFile(join(rootDir, entry, "metadata.json"), "utf8");
+			sessions.push(JSON.parse(raw) as SessionMetadata);
+		} catch {
+			// Skip invalid sessions
+		}
+	}
+
+	sessions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+	return sessions;
+}
+
+async function readRecentJsonLines<T>(filePath: string, limit: number): Promise<{ items: T[]; offset: number; total: number }> {
+	const items: T[] = [];
+	let total: number = 0;
+
+	try {
+		const rl = createInterface({
+			input: createReadStream(filePath, { encoding: "utf8" }),
+			crlfDelay: Infinity
+		});
+
+		for await (const line of rl) {
+			const item: T | null = parseJsonLine<T>(line);
+			if (item === null) {
+				continue;
+			}
+
+			total += 1;
+			items.push(item);
+			if (items.length > limit) {
+				items.shift();
+			}
+		}
+	} catch {
+		return { items: [], offset: 0, total: 0 };
+	}
+
+	return {
+		items,
+		offset: Math.max(0, total - items.length),
+		total
+	};
+}
+
+async function readJsonLineRange<T>(filePath: string, offset: number, limit: number): Promise<{ items: T[]; total: number }> {
+	const items: T[] = [];
+	let total: number = 0;
+	const startOffset: number = Math.max(0, offset);
+	const endOffset: number = Math.max(startOffset, startOffset + limit);
+
+	try {
+		const rl = createInterface({
+			input: createReadStream(filePath, { encoding: "utf8" }),
+			crlfDelay: Infinity
+		});
+
+		for await (const line of rl) {
+			const item: T | null = parseJsonLine<T>(line);
+			if (item === null) {
+				continue;
+			}
+
+			if (total >= startOffset && total < endOffset) {
+				items.push(item);
+			}
+			total += 1;
+		}
+	} catch {
+		return { items: [], total: 0 };
+	}
+
+	return { items, total };
+}
+
+function collectRequestIds(messages: StoredMessage[]): Set<string> {
+	const requestIds: Set<string> = new Set();
+
+	for (const message of messages) {
+		if (message.requestId !== undefined && message.requestId.length > 0) {
+			requestIds.add(message.requestId);
+		}
+	}
+
+	return requestIds;
+}
+
+async function readSessionEventsForRequestIds(sessionId: string, requestIds: Set<string>): Promise<{
+	events: StoredSessionEvent[];
+	eventCount: number;
+	latestWorkflowSnapshot: unknown | null;
+}> {
+	const events: StoredSessionEvent[] = [];
+	let eventCount: number = 0;
+	let latestWorkflowSnapshot: unknown | null = null;
+
+	try {
+		const rl = createInterface({
+			input: createReadStream(eventsPath(sessionId), { encoding: "utf8" }),
+			crlfDelay: Infinity
+		});
+
+		for await (const line of rl) {
+			const event: StoredSessionEvent | null = parseJsonLine<StoredSessionEvent>(line);
+			if (event === null) {
+				continue;
+			}
+
+			eventCount += 1;
+			if (event.event === "workflow.todo.updated") {
+				latestWorkflowSnapshot = event.data;
+			}
+			if (requestIds.has(event.requestId)) {
+				events.push(event);
+			}
+		}
+	} catch {
+		return { events: [], eventCount: 0, latestWorkflowSnapshot: null };
+	}
+
+	events.sort((left: StoredSessionEvent, right: StoredSessionEvent): number => left.createdAt.localeCompare(right.createdAt));
+	return { events, eventCount, latestWorkflowSnapshot };
+}
+
+export async function openSession(sessionId: string): Promise<StoredSession> {
+	const metadata: SessionMetadata = await readSessionMetadata(sessionId);
+	const msgFile: string = messagesPath(sessionId);
+
+	let messages: StoredMessage[] = [];
+
+	try {
+		const rawLines: string = await readFile(msgFile, "utf8");
+		messages = parseJsonLines<StoredMessage>(rawLines);
+	} catch {
+		// No messages yet
+	}
+
+	let events: StoredSessionEvent[] = [];
+
+	try {
+		const rawLines: string = await readFile(eventsPath(sessionId), "utf8");
+		events = parseJsonLines<StoredSessionEvent>(rawLines);
+	} catch {
+		// No timeline events yet
+	}
+
+	return { metadata, messages, events };
+}
+
+export async function openSessionRecentTimeline(sessionId: string, limit: number): Promise<StoredSessionTimelinePage> {
+	const metadata: SessionMetadata = await readSessionMetadata(sessionId);
+	const messagePage = await readRecentJsonLines<StoredMessage>(messagesPath(sessionId), limit);
+	const eventPage = await readSessionEventsForRequestIds(sessionId, collectRequestIds(messagePage.items));
+
+	return {
+		metadata,
+		messages: messagePage.items,
+		events: eventPage.events,
+		messageCount: messagePage.total,
+		eventCount: eventPage.eventCount,
+		messagesOffset: messagePage.offset,
+		hasMoreBefore: messagePage.offset > 0,
+		latestWorkflowSnapshot: eventPage.latestWorkflowSnapshot
+	};
+}
+
+export async function openSessionTimelinePage(sessionId: string, beforeOffset: number, limit: number): Promise<StoredSessionTimelinePage> {
+	const metadata: SessionMetadata = await readSessionMetadata(sessionId);
+	const endOffset: number = Math.max(0, beforeOffset);
+	const messagesOffset: number = Math.max(0, endOffset - limit);
+	const messagePage = await readJsonLineRange<StoredMessage>(messagesPath(sessionId), messagesOffset, endOffset - messagesOffset);
+	const eventPage = await readSessionEventsForRequestIds(sessionId, collectRequestIds(messagePage.items));
+
+	return {
+		metadata,
+		messages: messagePage.items,
+		events: eventPage.events,
+		messageCount: messagePage.total,
+		eventCount: eventPage.eventCount,
+		messagesOffset,
+		hasMoreBefore: messagesOffset > 0,
+		latestWorkflowSnapshot: eventPage.latestWorkflowSnapshot
+	};
+}
+
+export async function saveSession(sessionId: string, messages: ChatMessage[], metadata?: Partial<SessionMetadata>): Promise<void> {
+	const metaFile: string = metaPath(sessionId);
+	const msgFile: string = messagesPath(sessionId);
+
+	const existing: StoredSession = await openSession(sessionId);
+	const updated: SessionMetadata = {
+		...existing.metadata,
+		...(metadata ?? {}),
+		updatedAt: new Date().toISOString()
+	};
+	await writeFile(metaFile, JSON.stringify(updated, null, 2), "utf8");
+
+	const timestamp: string = new Date().toISOString();
+	const lines: string[] = [];
+
+	for (const message of messages) {
+		lines.push(JSON.stringify({ ...message, createdAt: message.createdAt ?? timestamp }) + "\n");
+	}
+
+	await writeFile(msgFile, lines.join(""), "utf8");
+}
+
+export async function rewindSessionFromRequest(sessionId: string, requestId: string): Promise<StoredMessage[]> {
+	const stored: StoredSession = await openSession(sessionId);
+	const startIndex: number = stored.messages.findIndex((message: StoredMessage): boolean => message.requestId === requestId);
+	if (startIndex < 0) {
+		return stored.messages;
+	}
+
+	const keptMessages: StoredMessage[] = stored.messages.slice(0, startIndex);
+	const removedRequestIds: Set<string> = new Set(
+		stored.messages
+			.slice(startIndex)
+			.map((message: StoredMessage): string | undefined => message.requestId)
+			.filter((value: string | undefined): value is string => value !== undefined && value.length > 0)
+	);
+	const keptEvents: StoredSessionEvent[] = stored.events.filter((event: StoredSessionEvent): boolean => !removedRequestIds.has(event.requestId));
+	const updatedMetadata: SessionMetadata = {
+		...stored.metadata,
+		updatedAt: new Date().toISOString()
+	};
+
+	await writeFile(metaPath(sessionId), JSON.stringify(updatedMetadata, null, 2), "utf8");
+	await writeFile(
+		messagesPath(sessionId),
+		keptMessages.map((message: StoredMessage): string => JSON.stringify(message) + "\n").join(""),
+		"utf8"
+	);
+	await writeFile(
+		eventsPath(sessionId),
+		keptEvents.map((event: StoredSessionEvent): string => JSON.stringify(event) + "\n").join(""),
+		"utf8"
+	);
+
+	return keptMessages;
+}
+
+export async function appendMessage(sessionId: string, message: ChatMessage): Promise<void> {
+	await ensureSessionsDir();
+	const msgFile: string = messagesPath(sessionId);
+	const line: string = JSON.stringify({ ...message, createdAt: message.createdAt ?? new Date().toISOString() }) + "\n";
+	await writeFile(msgFile, line, { encoding: "utf8", flag: "a" });
+}
+
+export async function appendSessionEvent(sessionId: string, requestId: string, event: string, data: unknown): Promise<void> {
+	await ensureSessionsDir();
+	const eventFile: string = eventsPath(sessionId);
+	const timestamp: string = new Date().toISOString();
+	const record: StoredSessionEvent = {
+		id: `event-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+		requestId,
+		event,
+		data,
+		createdAt: timestamp
+	};
+	const line: string = JSON.stringify(record) + "\n";
+	await writeFile(eventFile, line, { encoding: "utf8", flag: "a" });
+}
+
+export async function clearSessionEvents(sessionId: string): Promise<void> {
+	await ensureSessionsDir();
+	await writeFile(eventsPath(sessionId), "", "utf8");
+}
+
+export async function listSessions(): Promise<SessionMetadata[]> {
+	await ensureSessionsDir();
+	return listSessionMetadataFromDir(SESSIONS_DIR);
+}
+
+export async function listArchivedSessions(): Promise<SessionMetadata[]> {
+	await ensureArchivedSessionsDir();
+	return listSessionMetadataFromDir(ARCHIVED_SESSIONS_DIR);
+}
+
+export async function archiveSession(sessionId: string): Promise<SessionMetadata> {
+	const safeSessionId: string = assertSafeSessionId(sessionId);
+	await ensureSessionsDir();
+	await ensureArchivedSessionsDir();
+
+	const sourceDir: string = getSessionDir(safeSessionId);
+	const targetDir: string = getArchivedSessionDir(safeSessionId);
+	if (await pathExists(targetDir)) {
+		throw new Error(`Archived session already exists: ${safeSessionId}`);
+	}
+
+	const existingMetadata: SessionMetadata = await readSessionMetadata(safeSessionId);
+	const archivedAt: string = new Date().toISOString();
+	const metadata: SessionMetadata = {
+		...existingMetadata,
+		archivedAt,
+		updatedAt: archivedAt
+	};
+	await rename(sourceDir, targetDir);
+	await writeFile(join(targetDir, "metadata.json"), JSON.stringify(metadata, null, 2), "utf8");
+	return metadata;
+}
+
+export async function restoreArchivedSession(sessionId: string): Promise<SessionMetadata> {
+	const safeSessionId: string = assertSafeSessionId(sessionId);
+	await ensureSessionsDir();
+	await ensureArchivedSessionsDir();
+
+	const sourceDir: string = getArchivedSessionDir(safeSessionId);
+	const targetDir: string = getSessionDir(safeSessionId);
+	if (await pathExists(targetDir)) {
+		throw new Error(`Session already exists: ${safeSessionId}`);
+	}
+
+	const archivedMetadata: SessionMetadata = await readArchivedSessionMetadata(safeSessionId);
+	const metadata: SessionMetadata = {
+		...archivedMetadata,
+		archivedAt: undefined,
+		updatedAt: new Date().toISOString()
+	};
+	await rename(sourceDir, targetDir);
+	await writeFile(join(targetDir, "metadata.json"), JSON.stringify(metadata, null, 2), "utf8");
+	return metadata;
+}
+
+export async function deleteSession(sessionId: string): Promise<void> {
+	const safeSessionId: string = assertSafeSessionId(sessionId);
+	await ensureSessionsDir();
+	const dir: string = getSessionDir(safeSessionId);
+	if (!await pathExists(dir)) {
+		throw new Error(`Session not found: ${safeSessionId}`);
+	}
+
+	await rm(dir, { recursive: true });
+}
+
+export async function deleteArchivedSession(sessionId: string): Promise<void> {
+	const safeSessionId: string = assertSafeSessionId(sessionId);
+	await ensureArchivedSessionsDir();
+	const dir: string = getArchivedSessionDir(safeSessionId);
+	if (!await pathExists(dir)) {
+		throw new Error(`Archived session not found: ${safeSessionId}`);
+	}
+
+	await rm(dir, { recursive: true });
+}
+
+export async function renameSession(sessionId: string, newTitle: string): Promise<SessionMetadata> {
+	const stored: StoredSession = await openSession(sessionId);
+	const updated: SessionMetadata = {
+		...stored.metadata,
+		title: newTitle,
+		updatedAt: new Date().toISOString()
+	};
+
+	const metaFile: string = metaPath(sessionId);
+	await writeFile(metaFile, JSON.stringify(updated, null, 2), "utf8");
+
+	return updated;
+}
+
+export async function sessionExists(sessionId: string): Promise<boolean> {
+	await ensureSessionsDir();
+	try {
+		await access(getSessionDir(sessionId));
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function summaryPath(sessionId: string): string {
+	return join(getSessionDir(sessionId), "summary.md");
+}
+
+function parseSummaryFrontmatter(raw: string): SessionSummary {
+	if (!raw.startsWith("---\n")) {
+		return {
+			content: raw.trim(),
+			messageCount: 0,
+			tokenEstimate: 0,
+			generatedAt: ""
+		};
+	}
+
+	const endIndex: number = raw.indexOf("\n---\n", 4);
+	if (endIndex === -1) {
+		return {
+			content: raw.trim(),
+			messageCount: 0,
+			tokenEstimate: 0,
+			generatedAt: ""
+		};
+	}
+
+	const header: string = raw.slice(4, endIndex);
+	const content: string = raw.slice(endIndex + 5).trim();
+	const metadata: Record<string, string> = {};
+
+	for (const line of header.split("\n")) {
+		const colonIndex: number = line.indexOf(":");
+		if (colonIndex === -1) {
+			continue;
+		}
+
+		const key: string = line.slice(0, colonIndex).trim();
+		const value: string = line.slice(colonIndex + 1).trim();
+		metadata[key] = value;
+	}
+
+	return {
+		content,
+		messageCount: Number.parseInt(metadata.messageCount ?? "0", 10),
+		tokenEstimate: Number.parseInt(metadata.tokenEstimate ?? "0", 10),
+		generatedAt: metadata.generatedAt ?? ""
+	};
+}
+
+function formatSummaryMarkdown(summary: SessionSummary): string {
+	return [
+		"---",
+		`messageCount: ${summary.messageCount}`,
+		`tokenEstimate: ${summary.tokenEstimate}`,
+		`generatedAt: ${summary.generatedAt}`,
+		"---",
+		"",
+		summary.content.trim(),
+		""
+	].join("\n");
+}
+
+export async function readSummary(sessionId: string): Promise<SessionSummary | null> {
+	try {
+		const filePath: string = summaryPath(sessionId);
+		const raw: string = await readFile(filePath, "utf8");
+		return parseSummaryFrontmatter(raw);
+	} catch {
+		return null;
+	}
+}
+
+export async function writeSummary(sessionId: string, summary: SessionSummary): Promise<void> {
+	await ensureSessionsDir();
+	const filePath: string = summaryPath(sessionId);
+	await writeFile(filePath, formatSummaryMarkdown(summary), "utf8");
+}
+
+export async function deleteSummary(sessionId: string): Promise<void> {
+	try {
+		const filePath: string = summaryPath(sessionId);
+		await rm(filePath, { force: true });
+	} catch {
+		// Already gone
+	}
+}