@gajae-code/coding-agent 0.5.1 → 0.5.3

package/src/session/session-manager.ts

@@ -40,6 +40,7 @@ import {
 	isBlobRef,
 	isImageDataUrl,
 	MemoryBlobStore,
+	ResidentBlobMissingError,
 	resolveImageData,
 	resolveImageDataUrl,
 	resolveResidentImageDataSync,
@@ -888,8 +889,27 @@ async function resolvePersistedBlobRefs(value: unknown, blobStore: BlobStore, ke
 	);
 }
 
+/**
+ * Run async tasks with bounded concurrency so an image-heavy resume never materializes
+ * every blob's base64 simultaneously (F8: avoids the transient OOM spike of an unbounded
+ * Promise.all over all historical images).
+ */
+const BLOB_RESOLVE_CONCURRENCY = 8;
+async function runWithConcurrency(tasks: Array<() => Promise<void>>, limit: number): Promise<void> {
+	let next = 0;
+	const worker = async (): Promise<void> => {
+		while (next < tasks.length) {
+			const index = next;
+			next += 1;
+			await tasks[index]!();
+		}
+	};
+	const workerCount = Math.max(1, Math.min(limit, tasks.length));
+	await Promise.all(Array.from({ length: workerCount }, () => worker()));
+}
+
 async function resolveBlobRefsInEntries(entries: FileEntry[], blobStore: BlobStore): Promise<void> {
-	const promises: Promise<void>[] = [];
+	const tasks: Array<() => Promise<void>> = [];
 
 	for (const entry of entries) {
 		if (entry.type === "session") continue;
@@ -901,22 +921,19 @@ async function resolveBlobRefsInEntries(entries: FileEntry[], blobStore: BlobSto
 			contentArray = entry.content;
 		}
 
-		if (contentArray) {
-			for (const block of contentArray) {
-				if (isImageBlock(block) && isBlobRef(block.data)) {
-					promises.push(
-						resolveImageData(blobStore, block.data).then(resolved => {
-							block.data = resolved;
-						}),
-					);
+		tasks.push(async () => {
+			if (contentArray) {
+				for (const block of contentArray) {
+					if (isImageBlock(block) && isBlobRef(block.data)) {
+						block.data = await resolveImageData(blobStore, block.data);
+					}
 				}
 			}
-		}
-
-		promises.push(resolvePersistedBlobRefs(entry, blobStore));
+			await resolvePersistedBlobRefs(entry, blobStore);
+		});
 	}
 
-	await Promise.all(promises);
+	await runWithConcurrency(tasks, BLOB_RESOLVE_CONCURRENCY);
 }
 
 /**
@@ -1201,6 +1218,12 @@ interface ResidentBlobStores {
 	sessionFile?: string;
 }
 
+type ResidentBlobMissingPolicy = "throw" | "placeholder";
+
+function residentBlobMissingPlaceholder(error: ResidentBlobMissingError): string {
+	return `[Session resident ${error.kind} blob missing: sha256:${error.hash}; original content unavailable]`;
+}
+
 function externalizeResidentValueSync(obj: unknown, stores: ResidentBlobStores, key?: string): unknown {
 	if (obj === null || obj === undefined) return obj;
 	if (typeof obj === "string") {
@@ -1256,6 +1279,7 @@ function materializeResidentValueSync(
 	stores: ResidentBlobStores,
 	key?: string,
 	cache = new Map<string, string>(),
+	missingPolicy: ResidentBlobMissingPolicy = "throw",
 ): unknown {
 	if (obj === null || obj === undefined) return obj;
 	if (typeof obj === "string") return obj;
@@ -1263,19 +1287,28 @@ function materializeResidentValueSync(
 		const cacheKey = `${obj.kind}:${obj.ref}`;
 		const cached = cache.get(cacheKey);
 		if (cached !== undefined) return cached;
-		const resolved =
-			obj.kind === "imageUrl"
-				? resolveResidentImageDataUrlSync(stores.imageStore, obj.ref, stores)
-				: obj.kind === "imageData"
-					? resolveResidentImageDataSync(stores.imageStore, obj.ref, stores)
-					: resolveTextBlobSync(stores.textStore, obj.ref, stores);
+		let resolved: string;
+		try {
+			resolved =
+				obj.kind === "imageUrl"
+					? resolveResidentImageDataUrlSync(stores.imageStore, obj.ref, stores)
+					: obj.kind === "imageData"
+						? resolveResidentImageDataSync(stores.imageStore, obj.ref, stores)
+						: resolveTextBlobSync(stores.textStore, obj.ref, stores);
+		} catch (err) {
+			if (missingPolicy === "placeholder" && err instanceof ResidentBlobMissingError) {
+				resolved = residentBlobMissingPlaceholder(err);
+			} else {
+				throw err;
+			}
+		}
 		cache.set(cacheKey, resolved);
 		return resolved;
 	}
 	if (Array.isArray(obj)) {
 		let changed = false;
 		const result = obj.map(item => {
-			const newItem = materializeResidentValueSync(item, stores, key, cache);
+			const newItem = materializeResidentValueSync(item, stores, key, cache, missingPolicy);
 			if (newItem !== item) changed = true;
 			return newItem;
 		});
@@ -1284,7 +1317,7 @@ function materializeResidentValueSync(
 	if (typeof obj === "object") {
 		let changed = false;
 		const entries = Object.entries(obj).map(([childKey, value]) => {
-			const newValue = materializeResidentValueSync(value, stores, childKey, cache);
+			const newValue = materializeResidentValueSync(value, stores, childKey, cache, missingPolicy);
 			if (newValue !== value) changed = true;
 			return [childKey, newValue] as const;
 		});
@@ -1297,8 +1330,9 @@ function materializeResidentEntrySync<T extends FileEntry | SessionEntry>(
 	entry: T,
 	stores: ResidentBlobStores,
 	cache: Map<string, string>,
+	missingPolicy: ResidentBlobMissingPolicy = "throw",
 ): T {
-	return materializeResidentValueSync(entry, stores, undefined, cache) as T;
+	return materializeResidentValueSync(entry, stores, undefined, cache, missingPolicy) as T;
 }
 
 function materializeResidentEntriesSync<T extends FileEntry | SessionEntry>(
@@ -1308,6 +1342,37 @@ function materializeResidentEntriesSync<T extends FileEntry | SessionEntry>(
 	const cache = new Map<string, string>();
 	return entries.map(entry => materializeResidentEntrySync(entry, stores, cache));
 }
+
+function materializeResidentEntryForPersistenceSync<T extends FileEntry | SessionEntry>(
+	entry: T,
+	stores: ResidentBlobStores,
+	cache: Map<string, string>,
+): T {
+	return materializeResidentEntrySync(entry, stores, cache, "placeholder");
+}
+
+function materializeResidentEntriesForPersistenceSync<T extends FileEntry | SessionEntry>(
+	entries: T[],
+	stores: ResidentBlobStores,
+): T[] {
+	const cache = new Map<string, string>();
+	return entries.map(entry => materializeResidentEntryForPersistenceSync(entry, stores, cache));
+}
+
+export function residentBlobSentinelForTests(kind: ResidentBlobKind, ref: string): ResidentBlobSentinel {
+	return residentBlobSentinel(kind, ref);
+}
+
+export function materializeResidentEntriesForPersistenceForTests<T>(
+	entries: T[],
+	textStore: BlobStore,
+	imageStore: BlobStore = textStore,
+): T[] {
+	return materializeResidentEntriesForPersistenceSync(entries as Array<T & FileEntry>, {
+		textStore,
+		imageStore,
+	}) as T[];
+}
 function cloneJsonSemantic<T>(value: T): T {
 	if (value === null || value === undefined || typeof value !== "object") return value;
 	if (Array.isArray(value)) return value.map(item => cloneJsonSemantic(item)) as T;
@@ -2109,7 +2174,7 @@ export class SessionManager {
 	#labelRevision = 0;
 	#replayMetadataRevision = 0;
 	#materializedEntriesRevision = -1;
-	#materializedEntriesCache: WeakRef<SessionEntry[]> | undefined;
+	#materializedEntriesCache: SessionEntry[] | undefined;
 	#sessionContextCache: WeakRef<SessionContext> | undefined;
 	#sessionContextEntryRevision = -1;
 	#sessionContextLeafRevision = -1;
@@ -2817,7 +2882,7 @@ export class SessionManager {
 		await this.#queuePersistTask(async () => {
 			await this.#closePersistWriterInternal();
 			const entries = await Promise.all(
-				materializeResidentEntriesSync(this.#fileEntries, this.#residentBlobStores()).map(entry =>
+				materializeResidentEntriesForPersistenceSync(this.#fileEntries, this.#residentBlobStores()).map(entry =>
 					prepareEntryForPersistence(entry, this.#blobStore),
 				),
 			);
@@ -2831,8 +2896,8 @@ export class SessionManager {
 	#rewriteFileSync(): void {
 		if (!this.persist || !this.#sessionFile) return;
 		this.#closePersistWriterInternalSync();
-		const entries = materializeResidentEntriesSync(this.#fileEntries, this.#residentBlobStores()).map(entry =>
-			prepareEntryForPersistenceSync(entry, this.#blobStore),
+		const entries = materializeResidentEntriesForPersistenceSync(this.#fileEntries, this.#residentBlobStores()).map(
+			entry => prepareEntryForPersistenceSync(entry, this.#blobStore),
 		);
 		this.#writeEntriesAtomicallySync(entries);
 		this.#needsFullRewriteOnNextPersist = false;
@@ -3139,7 +3204,11 @@ export class SessionManager {
 				this.#rewriteFile().catch(() => {});
 				return;
 			}
-			const materializedEntry = materializeResidentEntrySync(entry, this.#residentBlobStores(), new Map());
+			const materializedEntry = materializeResidentEntryForPersistenceSync(
+				entry,
+				this.#residentBlobStores(),
+				new Map(),
+			);
 			const persistedEntry = prepareEntryForPersistenceSync(materializedEntry, this.#blobStore);
 			writer.writeSync(persistedEntry);
 		} catch (err) {
@@ -3608,15 +3677,14 @@ export class SessionManager {
 	 * change the leaf pointer. Entries cannot be modified or deleted.
 	 */
 	#getMaterializedEntriesInternal(): SessionEntry[] {
-		if (this.#materializedEntriesRevision === this.#entryRevision) {
-			const cached = this.#materializedEntriesCache?.deref();
-			if (cached) return cached;
+		if (this.#materializedEntriesRevision === this.#entryRevision && this.#materializedEntriesCache) {
+			return this.#materializedEntriesCache;
 		}
 		const resolvedTextBlobCache = new Map<string, string>();
 		const materializedEntries = this.#fileEntries
 			.filter((e): e is SessionEntry => e.type !== "session")
 			.map(entry => materializeResidentEntrySync(entry, this.#residentBlobStores(), resolvedTextBlobCache));
-		this.#materializedEntriesCache = new WeakRef(materializedEntries);
+		this.#materializedEntriesCache = materializedEntries;
 		this.#materializedEntriesRevision = this.#entryRevision;
 		return materializedEntries;
 	}

package/src/session/streaming-output.ts

@@ -15,6 +15,7 @@ function sanitizeOutputChunk(rawChunk: string): string {
 export const DEFAULT_MAX_LINES = 3000;
 export const DEFAULT_MAX_BYTES = 50 * 1024; // 50KB
 export const DEFAULT_MAX_COLUMN = 1024; // Max chars per grep match line
+export const DEFAULT_ARTIFACT_MAX_BYTES = 10 * 1024 * 1024; // 10MB
 
 const NL = "\n";
 
@@ -41,6 +42,8 @@ export interface OutputSummary {
 	columnTruncatedLines?: number;
 	/** Artifact ID for internal URL access (artifact://<id>) when truncated */
 	artifactId?: string;
+	/** Bytes omitted from artifact storage after the artifact hard cap was reached. */
+	artifactTruncatedBytes?: number;
 }
 
 export interface OutputSinkOptions {
@@ -61,6 +64,8 @@ export interface OutputSinkOptions {
 	 * writes still respect the budget. Default 0 = no per-line cap.
 	 */
 	maxColumns?: number;
+	/** Hard cap for artifact writes/pending replay. Default DEFAULT_ARTIFACT_MAX_BYTES. */
+	artifactMaxBytes?: number;
 	onChunk?: (chunk: string) => void;
 	/** Minimum ms between onChunk calls. 0 = every chunk (default). */
 	chunkThrottleMs?: number;
@@ -668,6 +673,9 @@ export class OutputSink {
 	#sawData = false;
 	#truncated = false;
 	#lastChunkTime = 0;
+	#artifactBytes = 0;
+	#artifactTruncatedBytes = 0;
+	#artifactTruncationNoticeWritten = false;
 
 	// Per-line column cap streaming state (persists across `push` calls so a
 	// long line split across chunks still trips the same trigger).
@@ -697,6 +705,7 @@ export class OutputSink {
 	readonly #onRawChunk?: (chunk: string) => void;
 	readonly #chunkThrottleMs: number;
 	readonly #maxColumns: number;
+	readonly #artifactMaxBytes: number;
 
 	constructor(options?: OutputSinkOptions) {
 		const {
@@ -708,6 +717,7 @@ export class OutputSink {
 			onChunk,
 			chunkThrottleMs = 0,
 			onRawChunk,
+			artifactMaxBytes = DEFAULT_ARTIFACT_MAX_BYTES,
 		} = options ?? {};
 		this.#artifactPath = artifactPath;
 		this.#artifactId = artifactId;
@@ -717,6 +727,7 @@ export class OutputSink {
 		this.#onChunk = onChunk;
 		this.#onRawChunk = onRawChunk;
 		this.#chunkThrottleMs = chunkThrottleMs;
+		this.#artifactMaxBytes = Math.max(0, artifactMaxBytes);
 	}
 
 	#headText(): string {
@@ -907,6 +918,40 @@ export class OutputSink {
 		}
 	}
 
+	#artifactTruncationNotice(droppedBytes: number): string {
+		return `\n[artifact truncated after ${this.#artifactBytes} bytes; omitted at least ${droppedBytes} bytes]\n`;
+	}
+
+	#capArtifactChunk(chunk: string, bytes: number): { chunk: string; bytes: number } | null {
+		if (bytes === 0) return null;
+		if (this.#artifactMaxBytes <= 0 || this.#artifactBytes >= this.#artifactMaxBytes) {
+			this.#artifactTruncatedBytes += bytes;
+			return null;
+		}
+		const room = this.#artifactMaxBytes - this.#artifactBytes;
+		if (bytes <= room) {
+			return { chunk, bytes };
+		}
+		const kept = truncateHeadBytes(chunk, room);
+		this.#artifactTruncatedBytes += bytes - kept.bytes;
+		return kept.bytes > 0 ? { chunk: kept.text, bytes: kept.bytes } : null;
+	}
+
+	#writeArtifactTruncationNotice(): void {
+		if (this.#artifactTruncatedBytes <= 0 || this.#artifactTruncationNoticeWritten) return;
+		const notice = this.#artifactTruncationNotice(this.#artifactTruncatedBytes);
+		try {
+			if (this.#fileReady && this.#file) {
+				this.#file.sink.write(notice);
+			} else {
+				this.#queuePendingFileWrite(notice, Buffer.byteLength(notice, "utf-8"));
+			}
+			this.#artifactTruncationNoticeWritten = true;
+		} catch {
+			/* ignore */
+		}
+	}
+
 	#queuePendingFileWrite(chunk: string, bytes = Buffer.byteLength(chunk, "utf-8")): void {
 		if (!this.#pendingFileWrites) this.#pendingFileWrites = [chunk];
 		else this.#pendingFileWrites.push(chunk);
@@ -915,14 +960,17 @@ export class OutputSink {
 	}
 
 	#enqueueFileWrite(chunk: string, bytes: number): void {
+		const capped = this.#capArtifactChunk(chunk, bytes);
+		if (!capped) return;
+		this.#artifactBytes += capped.bytes;
 		if (!this.#fileReady || !this.#file) {
-			this.#queuePendingFileWrite(chunk, bytes);
+			this.#queuePendingFileWrite(capped.chunk, capped.bytes);
 			if (this.#willOverflow(bytes) || this.#pendingFileWriteBytes > this.#spillThreshold) this.#createFileSink();
 			return;
 		}
 
 		try {
-			this.#file.sink.write(chunk);
+			this.#file.sink.write(capped.chunk);
 		} catch {
 			try {
 				void this.#file.sink.end();
@@ -931,7 +979,7 @@ export class OutputSink {
 			}
 			this.#file = undefined;
 			this.#fileReady = false;
-			this.#queuePendingFileWrite(chunk, bytes);
+			this.#queuePendingFileWrite(capped.chunk, capped.bytes);
 			this.#createFileSink();
 		}
 	}
@@ -1019,6 +1067,8 @@ export class OutputSink {
 		const totalLines = this.#sawData ? this.#totalLines + 1 : 0;
 
 		let artifactId: string | undefined;
+		if (this.#artifactTruncatedBytes > 0) this.#createFileSink();
+		this.#writeArtifactTruncationNotice();
 		if (this.#file) {
 			artifactId = this.#file.artifactId;
 			await this.#file.sink.end();
@@ -1095,6 +1145,7 @@ export class OutputSink {
 			elidedLines,
 			columnDroppedBytes: this.#columnDroppedBytes > 0 ? this.#columnDroppedBytes : undefined,
 			columnTruncatedLines: this.#columnTruncatedLines > 0 ? this.#columnTruncatedLines : undefined,
+			artifactTruncatedBytes: this.#artifactTruncatedBytes > 0 ? this.#artifactTruncatedBytes : undefined,
 			artifactId,
 		};
 	}