@morlay/session-rdb 0.0.19 → 0.0.21-alpha.0

package/dist/import.d.mts

@@ -1,19 +1,19 @@
-import { r as SessionPersistenceRdb } from "./index-CCcK9tia.mjs";
+import { u as SessionPersistenceRdb } from "./backend-DpdtxYpz.mjs";
 import { SessionStorageMetadata } from "@deepseek-ai/dsh-session-persistence";
 import { Session, SessionEvent, SessionId } from "@deepseek-ai/dsh-session";
 import { Context } from "@deepseek-ai/cordis";
 //#region src/import.d.ts
-/** 当前世代产物的文件名（读入侧接受任意 canonical 世代名，见 parseImportZip）。 */
 declare const SESSION_LOG_ARTIFACT_FILENAME = "session.jsonl";
 declare const SESSION_IMPORT_PATH = "/api/session.import";
 declare function parseJsonlArtifact(content: string): SessionStorageMetadata & {
   events: SessionEvent[];
 };
-declare function parseImportZip(zip: Uint8Array): SessionStorageMetadata & {
+declare function parseImportZip(zip: Uint8Array): Promise<SessionStorageMetadata & {
   events: SessionEvent[];
-};
+}>;
 declare function persistImport(persistence: SessionPersistenceRdb, branch: {
   rewind(id: SessionId, toBoundary: number): Promise<unknown>;
+  resetLiveDerivedState?(session: Session): void;
 } | undefined, imported: SessionStorageMetadata & {
   events: SessionEvent[];
 }, targetId?: SessionId, sessions?: {

package/dist/import.mjs

@@ -1,2 +1,215 @@
-import { a as persistImport, i as parseJsonlArtifact, n as SESSION_LOG_ARTIFACT_FILENAME, o as registerSessionImport, r as parseImportZip, t as SESSION_IMPORT_PATH } from "./import-Bc2QQa5G.mjs";
+import { i as replaceLiveSessionLog } from "./branch-5JzX9rUq.mjs";
+import { randomUUID } from "node:crypto";
+import { SESSION_FORMAT_VERSION, SessionLogOffset } from "@deepseek-ai/dsh-session";
+import { parseSessionFormatLogFilename } from "@deepseek-ai/dsh-session-format";
+import { sessionFormatCatalog } from "@deepseek-ai/dsh-session-format-catalog";
+import { balanceRewindPrefix } from "@morlay/session-branch";
+import { unzip } from "fflate";
+//#region src/import.ts
+const SESSION_LOG_ARTIFACT_FILENAME = "session.jsonl";
+const SESSION_IMPORT_PATH = "/api/session.import";
+const MAX_IMPORT_ZIP_BYTES = 67108864;
+function parseJsonlArtifact(content) {
+	const lines = content.split("\n");
+	if (lines.length === 0 || lines[0] === "") throw new Error("imported session log is empty");
+	let header;
+	try {
+		header = JSON.parse(lines[0]);
+	} catch {
+		throw new Error("imported session log has an unparsable header line");
+	}
+	let restore;
+	try {
+		restore = sessionFormatCatalog.createRestore(header, {
+			recovery: "strict",
+			validation: "transformed"
+		});
+	} catch (error) {
+		throw new Error(`imported session log has an invalid header line: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	for (let i = 1; i < lines.length; i++) {
+		const line = lines[i];
+		if (line === void 0 || line === "") continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(line);
+		} catch {
+			throw new Error(`imported session log has an unparsable event line at ${i}`);
+		}
+		try {
+			restore.decodeRow(parsed);
+		} catch (error) {
+			throw new Error(`imported session log has an invalid event line at ${i}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	let artifact;
+	try {
+		artifact = restore.finish();
+	} catch (error) {
+		throw new Error(`imported session log is incomplete: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const meta = artifact.header;
+	const events = artifact.events;
+	for (let i = 0; i < events.length; i++) if (events[i].seq !== i) throw new Error(`imported session log seq gap at ${i} (got ${events[i].seq}); import requires a dense log`);
+	const inheritedEventCount = Math.min(artifact.inheritedEventCount, events.length);
+	return {
+		meta: {
+			version: SESSION_FORMAT_VERSION,
+			id: meta.id,
+			createdAt: meta.createdAt,
+			...meta.cwd === void 0 ? {} : { cwd: meta.cwd },
+			...meta.parentSession === void 0 ? {} : { parentSession: meta.parentSession },
+			isSeeded: meta.isSeeded,
+			...meta.origin === void 0 ? {} : { origin: meta.origin },
+			...meta.delegationDepth === void 0 ? {} : { delegationDepth: meta.delegationDepth },
+			...meta.agentPreset === void 0 ? {} : { agentPreset: meta.agentPreset }
+		},
+		inheritedEventCount: SessionLogOffset(inheritedEventCount),
+		events
+	};
+}
+/**
+* fflate 的 `unzip` 是回调式异步 API（node 侧内部走 worker_threads，浏览器侧走 Web Worker），
+* 这里桥成 Promise。它与 `unzipSync` 的差异只在同步/异步：非法 zip 走的是同一段校验代码，
+* 拒绝的错误对象与同步版一致，因此上层文案无需区分。
+*/
+function unzipAsync(data) {
+	return new Promise((resolve, reject) => {
+		unzip(data, (error, entries) => {
+			if (error === null) resolve(entries);
+			else reject(error);
+		});
+	});
+}
+async function parseImportZip(zip) {
+	let entries;
+	try {
+		entries = await unzipAsync(zip);
+	} catch {
+		throw new Error("imported zip is not a valid ZIP archive");
+	}
+	const artifact = Object.entries(entries).find(([name]) => parseSessionFormatLogFilename(name) !== void 0);
+	if (artifact === void 0) throw new Error(`imported zip has no session log artifact (expected ${SESSION_LOG_ARTIFACT_FILENAME} or a canonical session.vN.jsonl)`);
+	return parseJsonlArtifact(new TextDecoder().decode(artifact[1]));
+}
+async function stopAgentLoop(ctx, sessionId) {
+	const agent = ctx.get("agents")?.get(sessionId);
+	if (agent === void 0) return;
+	agent.cancel?.({ kind: "user" }, { keepInbox: true });
+	await agent.whenIdle();
+}
+async function persistImport(persistence, branch, imported, targetId, sessions, stopLoop) {
+	const id = targetId ?? `session-${randomUUID()}`;
+	const events = balanceRewindPrefix(imported.events, { keepOpenTail: true });
+	if (targetId !== void 0) {
+		if (branch === void 0) throw new Error("sessionBranch service is unavailable");
+		if (stopLoop !== void 0) await stopLoop(targetId);
+		await branch.rewind(targetId, -1);
+		const liveHandle = persistence.tracker.writerOf(targetId);
+		if (liveHandle !== void 0) {
+			if (events.length > 0) await liveHandle.append(events);
+		} else {
+			const handle = await persistence.open(targetId, "write");
+			try {
+				if (events.length > 0) await handle.append(events);
+			} finally {
+				await handle.close();
+			}
+		}
+	} else {
+		const handle = await persistence.create({
+			...imported.meta,
+			id
+		}, { inheritedEventCount: SessionLogOffset(Math.min(imported.inheritedEventCount, events.length)) });
+		if (events.length > 0) await handle.append(events);
+		await handle.close();
+	}
+	if (targetId !== void 0) {
+		const live = sessions?.get(targetId);
+		if (live !== void 0) {
+			replaceLiveSessionLog(live, events);
+			branch?.resetLiveDerivedState?.(live);
+		}
+	}
+	return id;
+}
+function registerSessionImport(ctx, persistence) {
+	ctx.inject(["webServer", "connection"], (webCtx) => {
+		const webServer = webCtx.webServer;
+		const connection = webCtx.get("connection");
+		return webCtx.effect(() => webServer.register({
+			kind: "exact",
+			path: SESSION_IMPORT_PATH,
+			handler: async (req, res) => {
+				const rejection = connection.requestRejection(req);
+				if (rejection !== void 0) {
+					res.writeHead(rejection);
+					res.end(rejection === 401 ? "unauthorized" : "forbidden");
+					return;
+				}
+				const chunks = [];
+				for await (const chunk of req) chunks.push(chunk);
+				const body = Buffer.concat(chunks);
+				let envelope;
+				try {
+					envelope = JSON.parse(body.toString("utf8"));
+				} catch {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "request body is not JSON" }));
+					return;
+				}
+				if (typeof envelope.zip !== "string" || envelope.zip === "") {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "missing zip field" }));
+					return;
+				}
+				if (envelope.sessionId !== void 0 && (typeof envelope.sessionId !== "string" || envelope.sessionId === "")) {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "sessionId must be a non-empty string" }));
+					return;
+				}
+				let zip;
+				try {
+					zip = Buffer.from(envelope.zip, "base64");
+				} catch {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "zip field is not valid base64" }));
+					return;
+				}
+				if (zip.byteLength > MAX_IMPORT_ZIP_BYTES) {
+					res.writeHead(413, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "imported zip exceeds the size limit" }));
+					return;
+				}
+				let imported;
+				try {
+					imported = await parseImportZip(zip);
+				} catch (error) {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: error instanceof Error ? error.message : "imported zip is invalid" }));
+					return;
+				}
+				const targetId = typeof envelope.sessionId === "string" ? envelope.sessionId : void 0;
+				const branch = webCtx.get("sessionBranch");
+				try {
+					const sessions = webCtx.get("sessions");
+					const id = await persistImport(persistence, branch, imported, targetId, sessions, (sessionId) => stopAgentLoop(webCtx, sessionId));
+					res.writeHead(200, { "content-type": "application/json" });
+					res.end(JSON.stringify({ sessionId: id }));
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					if (targetId !== void 0 && /not found/i.test(message)) {
+						res.writeHead(404, { "content-type": "application/json" });
+						res.end(JSON.stringify({ error: `session "${targetId}" not found` }));
+						return;
+					}
+					res.writeHead(500, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: error instanceof Error ? error.message : "import failed" }));
+					return;
+				}
+			}
+		}), `session-rdb: ${SESSION_IMPORT_PATH} route`);
+	});
+}
+//#endregion
 export { SESSION_IMPORT_PATH, SESSION_LOG_ARTIFACT_FILENAME, parseImportZip, parseJsonlArtifact, persistImport, registerSessionImport };

package/dist/index.d.mts

@@ -1,3 +1,2 @@
-import { o as SCHEMA_VERSION } from "./schema-DPcuEh_a.mjs";
-import { a as SessionBranchRdb, i as SessionPersistenceRdbInternals, n as ProjectionCacheOptions, o as SessionBranchRdbProvider, r as SessionPersistenceRdb, s as locateTurnEnd, t as Config } from "./index-CCcK9tia.mjs";
-export { Config, ProjectionCacheOptions, SCHEMA_VERSION, SessionBranchRdb, SessionBranchRdbProvider, SessionPersistenceRdb, SessionPersistenceRdb as default, SessionPersistenceRdbInternals, locateTurnEnd };
+import { c as SessionDeletionError, d as SessionPersistenceRdbInternals, f as SessionBranchRdb, l as SessionDeletionErrorCode, m as locateTurnEnd, o as Config, p as SessionBranchRdbProvider, s as ProjectionCacheOptions, u as SessionPersistenceRdb, x as SCHEMA_VERSION } from "./backend-DpdtxYpz.mjs";
+export { Config, ProjectionCacheOptions, SCHEMA_VERSION, SessionBranchRdb, SessionBranchRdbProvider, SessionDeletionError, SessionDeletionErrorCode, SessionPersistenceRdb, SessionPersistenceRdb as default, SessionPersistenceRdbInternals, locateTurnEnd };