@roj-ai/sdk 0.1.36 → 0.2.2

package/src/plugins/uploads/preprocessors/zip-preprocessor.ts

@@ -8,18 +8,30 @@
  */
 
 import { extname } from 'node:path'
+import { ArchiveBudget, inspectZipArchive } from '~/lib/archive/index.js'
 import { mapWithConcurrency } from '~/lib/utils/concurrency.js'
 import type { Result } from '~/lib/utils/result.js'
 import { Err, Ok } from '~/lib/utils/result.js'
 import type { ProcessRunner } from '~/platform/process.js'
 import type { Logger } from '../../../lib/logger/logger.js'
-import type { Preprocessor, PreprocessorContext, PreprocessorRegistry, PreprocessorResult } from '../preprocessor.js'
+import {
+	getPreprocessingSignal,
+	preprocessingAbortError,
+	type Preprocessor,
+	type PreprocessorContext,
+	type PreprocessorRegistry,
+	type PreprocessorResult,
+} from '../preprocessor.js'
 
 const MAX_DEPTH = 3
-const MAX_FILES = 500
-const MAX_TOTAL_SIZE = 100 * 1024 * 1024 // 100MB
 const ZIP_FILE_CONCURRENCY = 10
 
+interface ProcessedArchiveEntry {
+	manifestEntry: string
+	derivedPaths: string[]
+	nestedArchiveError?: Error
+}
+
 const MIME_MAP: Record<string, string> = {
 	'.pdf': 'application/pdf',
 	'.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
@@ -49,7 +61,7 @@ function getMimeType(filename: string): string | null {
 }
 
 function makeExec(processRunner: ProcessRunner) {
-	return (cmd: string, args: string[]) => processRunner.execFile(cmd, args, { timeout: 60_000, maxBuffer: 50 * 1024 * 1024 })
+	return (cmd: string, args: string[], signal?: AbortSignal) => processRunner.execFile(cmd, args, { timeout: 60_000, maxBuffer: 50 * 1024 * 1024, signal })
 }
 
 function formatSize(bytes: number): string {
@@ -72,7 +84,7 @@ export class ZipPreprocessor implements Preprocessor {
 	private readonly registry: PreprocessorRegistry
 	private readonly logger: Logger
 	private readonly processRunner: ProcessRunner
-	private readonly exec: (cmd: string, args: string[]) => Promise<{ stdout: string; stderr: string }>
+	private readonly exec: (cmd: string, args: string[], signal?: AbortSignal) => Promise<{ stdout: string; stderr: string }>
 	private readonly depth: number
 
 	constructor(config: ZipPreprocessorConfig) {
@@ -88,66 +100,69 @@ export class ZipPreprocessor implements Preprocessor {
 		_mimeType: string,
 		ctx: PreprocessorContext,
 	): Promise<Result<PreprocessorResult, Error>> {
+		const signal = getPreprocessingSignal(ctx)
+		if (signal.aborted) return Err(preprocessingAbortError(signal))
 		if (this.depth >= MAX_DEPTH) {
 			return Err(new Error(`ZIP nesting depth limit reached (max ${MAX_DEPTH})`))
 		}
+		const archiveBudget = ctx.archiveBudget ?? new ArchiveBudget()
+		const inspection = await inspectZipArchive(this.processRunner, filePath, {
+			signal,
+			limits: archiveBudget.limits,
+		})
+		if (!inspection.ok) {
+			if (signal.aborted) return Err(preprocessingAbortError(signal))
+			return Err(
+				new Error(`ZIP inspection failed: ${inspection.error.message}`, {
+					cause: inspection.error,
+				}),
+			)
+		}
+		if (signal.aborted) return Err(preprocessingAbortError(signal))
+		const budgetResult = archiveBudget.consume(inspection.value)
+		if (!budgetResult.ok) return Err(budgetResult.error)
 
 		// Extract to disk via unzip
 		const extractStore = ctx.files.scoped('extracted')
-		const extractDirResult = extractStore.realPath('')
+		const extractDirResult = await extractStore.containedPath('')
 		if (!extractDirResult.ok) {
 			return Err(new Error('Failed to resolve extraction directory'))
 		}
+		if (signal.aborted) return Err(preprocessingAbortError(signal))
 
 		try {
-			await this.exec('unzip', ['-o', '-q', filePath, '-d', extractDirResult.value])
+			await this.exec('unzip', ['-o', '-q', filePath, '-d', extractDirResult.value], signal)
 		} catch (error) {
+			if (signal.aborted) return Err(preprocessingAbortError(signal))
 			const message = error instanceof Error ? error.message : String(error)
 			if (message.includes('ENOENT')) {
 				return Err(new Error('unzip not found'))
 			}
-			// unzip returns exit code 1 for warnings (e.g. skipped dirs) — still usable
-			if (!message.includes('exit code 1')) {
-				return Err(new Error(`unzip failed: ${message}`))
-			}
+			return Err(new Error(`unzip failed: ${message}`))
 		}
+		if (signal.aborted) return Err(preprocessingAbortError(signal))
 
 		// List extracted files
 		const listResult = await extractStore.list('', { maxDepth: 10 })
 		if (!listResult.ok) {
 			return Err(new Error('Failed to list extracted files'))
 		}
+		if (signal.aborted) return Err(preprocessingAbortError(signal))
 
 		const files = listResult.value
 			.filter(e => e.type === 'file')
 			.sort((a, b) => a.name.localeCompare(b.name))
 
-		// Pick eligible files first (limits depend on cumulative iteration order, so this stays sequential)
-		const eligible: typeof files = []
-		let totalSize = 0
-		let truncationNotice: string | null = null
+		const fileCount = files.length
 
-		for (const file of files) {
-			if (eligible.length >= MAX_FILES) {
-				truncationNotice = `... (truncated, ${files.length - eligible.length} more files)`
-				break
-			}
-			const fileSize = file.size ?? 0
-			if (totalSize + fileSize > MAX_TOTAL_SIZE) {
-				truncationNotice = '... (total size limit reached)'
-				break
-			}
-			totalSize += fileSize
-			eligible.push(file)
-		}
-
-		const fileCount = eligible.length
-
-		// Process eligible files in parallel with bounded concurrency
-		const processed = await mapWithConcurrency(eligible, ZIP_FILE_CONCURRENCY, async (file) => {
+		// Process files in parallel with bounded concurrency
+		const processed = await mapWithConcurrency(files, ZIP_FILE_CONCURRENCY, async (file): Promise<ProcessedArchiveEntry> => {
 			const collectedPaths: string[] = []
+			if (signal.aborted) {
+				return { manifestEntry: '', derivedPaths: collectedPaths }
+			}
 
-			const fileRealPath = extractStore.realPath(file.name)
+			const fileRealPath = await extractStore.containedPath(file.name)
 			if (!fileRealPath.ok) {
 				return {
 					manifestEntry: `- ${file.name} (path resolution failed)`,
@@ -175,7 +190,9 @@ export class ZipPreprocessor implements Preprocessor {
 
 				if (preprocessor) {
 					const subResult = await preprocessor.process(fileRealPath.value, mime, {
+						...ctx,
 						files: ctx.files.scoped(`extracted/${file.name}-content`),
+						archiveBudget,
 					})
 					if (subResult.ok) {
 						if (subResult.value.derivedPaths) {
@@ -191,6 +208,13 @@ export class ZipPreprocessor implements Preprocessor {
 						}
 					} else {
 						this.logger.warn('Sub-preprocessor failed', { file: file.name, error: subResult.error.message })
+						if (mime === 'application/zip') {
+							return {
+								manifestEntry: `- ${file.name} (nested ZIP rejected)`,
+								derivedPaths: collectedPaths,
+								nestedArchiveError: subResult.error,
+							}
+						}
 					}
 				}
 			}
@@ -200,6 +224,9 @@ export class ZipPreprocessor implements Preprocessor {
 				derivedPaths: collectedPaths,
 			}
 		})
+		if (signal.aborted) return Err(preprocessingAbortError(signal))
+		const nestedArchiveError = processed.find(item => item.nestedArchiveError)?.nestedArchiveError
+		if (nestedArchiveError) return Err(nestedArchiveError)
 
 		const derivedPaths: string[] = []
 		const manifest: string[] = []
@@ -207,18 +234,20 @@ export class ZipPreprocessor implements Preprocessor {
 			derivedPaths.push(...item.derivedPaths)
 			manifest.push(item.manifestEntry)
 		}
-		if (truncationNotice) manifest.push(truncationNotice)
-
 		const fullManifest = `## ZIP Contents (${fileCount} files)\n\n${manifest.join('\n')}`
 
 		// Write full manifest to disk
-		await ctx.files.write('content.txt', fullManifest)
+		if (signal.aborted) return Err(preprocessingAbortError(signal))
+		const manifestWrite = await ctx.files.write('content.txt', fullManifest)
+		if (!manifestWrite.ok) {
+			return Err(new Error(`Failed to write ZIP manifest: ${manifestWrite.error}`))
+		}
 		derivedPaths.push('content.txt')
 
 		this.logger.debug('ZIP processed', {
 			filePath,
 			filesExtracted: fileCount,
-			totalSize,
+			totalSize: inspection.value.totalUncompressedSize,
 			depth: this.depth,
 		})
 

package/src/plugins/uploads/schema.ts

@@ -9,21 +9,46 @@
 
 import { uuidv7 } from 'uuidv7'
 import z from 'zod/v4'
+import { type DomainError, ValidationErrors } from '~/core/errors.js'
+import { Err, Ok, type Result } from '~/lib/utils/result.js'
 import type { SessionId } from '../../core/sessions/schema.js'
 
 // ============================================================================
 // UploadId - Branded type
 // ============================================================================
 
-/** UploadId schema - validates any string and brands as UploadId. */
-export const uploadIdSchema = z.string().brand('UploadId')
+/**
+ * Characters an upload id may contain.
+ *
+ * Twin of `SESSION_ID_PATTERN`: the id is interpolated straight into filesystem
+ * paths (`sessions/<sessionId>/uploads/<uploadId>`) and into the basePath handed to
+ * the agent, and FileStore containment is lexical and rooted at the data dir, so a
+ * `..` segment reaches a sibling session rather than escaping outright. Generated
+ * ids are UUIDv7, which fits.
+ */
+export const UPLOAD_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/
+
+/** True when the value is safe to interpolate into a path. */
+export const isValidUploadId = (id: string): boolean => UPLOAD_ID_PATTERN.test(id)
+
+/** UploadId schema - validates the id shape and brands as UploadId. */
+export const uploadIdSchema = z.string().regex(UPLOAD_ID_PATTERN, 'Invalid upload id').brand('UploadId')
 
 /** Branded UploadId type */
 export type UploadId = z.infer<typeof uploadIdSchema>
 
-/** Constructor for UploadId */
+/**
+ * Unchecked brand — only for ids already known to match `UPLOAD_ID_PATTERN`.
+ *
+ * It does not validate, so it must never see untrusted input. Use `parseUploadId`
+ * at a boundary that is not a method input, and `uploadIdSchema` at one that is.
+ */
 export const UploadId = (id: string): UploadId => id as UploadId
 
+/** Checked UploadId constructor — the form to use on untrusted input. */
+export const parseUploadId = (value: string): Result<UploadId, DomainError> =>
+	isValidUploadId(value) ? Ok(UploadId(value)) : Err(ValidationErrors.invalid('Invalid upload id'))
+
 /** Generate a new UploadId (UUIDv7) */
 export const generateUploadId = (): UploadId => UploadId(uuidv7())
 
@@ -87,6 +112,8 @@ export interface UploadMetadata {
 	createdAt: number
 	completedAt?: number
 	error?: string
+	/** Set only after the terminal event is durable. */
+	terminalEventPersisted?: boolean
 	/** Set when the upload is attached to a message via sendMessage */
 	usedInMessageId?: string
 }

package/src/plugins/uploads/state.ts

@@ -18,11 +18,15 @@ export const uploadEvents = createEventsFactory({
 			agentId: z4.string(),
 			uploadIds: z4.array(uploadIdSchema),
 		}),
+		attachment_deletion_completed: z4.object({
+			uploadId: uploadIdSchema,
+		}),
 	},
 })
 
 export type AttachmentUploadedEvent = (typeof uploadEvents)['Events']['attachment_uploaded']
 export type AttachmentsConsumedEvent = (typeof uploadEvents)['Events']['attachments_consumed']
+export type AttachmentDeletionCompletedEvent = (typeof uploadEvents)['Events']['attachment_deletion_completed']
 
 /** A pending upload tracked in session state */
 export interface PendingUpload {
@@ -39,4 +43,12 @@ export interface PendingUpload {
 export interface UploadsState {
 	/** Uploads that have been uploaded but not yet consumed by an agent */
 	pending: PendingUpload[]
+	/**
+	 * Small terminal projection for uploads still visible to the user.
+	 *
+	 * Reconciliation against on-disk metadata keys off this plus
+	 * `UploadMetadata.terminalEventPersisted`; it is idempotent, so no separate
+	 * "awaiting materialization" projection is needed.
+	 */
+	terminal: Record<string, 'ready' | 'failed'>
 }