@critical-path/core 0.36.0 → 0.37.0

package/src/storage/firebase-storage.ts

@@ -1,209 +0,0 @@
-import type {
-  FileStorageAdapter,
-  UploadFileInput,
-  UploadFileResult,
-  PresignedUrlOptions,
-  PresignedUploadResult
-} from '../types/index.js';
-import { buildStorageKey, contentDispositionFor, normalizeUploadData } from './file-storage.js';
-
-export interface FirebaseStorageBucketInterface {
-  name?: string;
-  file(path: string): {
-    save(
-      data: Uint8Array | Buffer | string,
-      options?: { metadata?: { contentType?: string; [key: string]: any }; resumable?: boolean }
-    ): Promise<void>;
-    delete(options?: any): Promise<any>;
-    getSignedUrl?(config: { action: 'read' | 'write'; expires: string | number | Date; contentType?: string }): Promise<[string]>;
-    publicUrl?(): string;
-  };
-}
-
-export class InMemoryFirebaseStorageMock implements FirebaseStorageBucketInterface {
-  name: string;
-  private files = new Map<string, { data: Uint8Array; contentType: string; token?: string }>();
-
-  constructor(name: string = 'mock-firebase-bucket') {
-    this.name = name;
-  }
-
-  file(path: string) {
-    const files = this.files;
-    const bucketName = this.name;
-    return {
-      async save(data: Uint8Array | Buffer | string, options?: any) {
-        let bytes: Uint8Array;
-        if (typeof data === 'string') {
-          bytes = new TextEncoder().encode(data);
-        } else if (data instanceof Uint8Array) {
-          bytes = data;
-        } else if (typeof Buffer !== 'undefined' && Buffer.isBuffer(data)) {
-          bytes = new Uint8Array(data);
-        } else {
-          bytes = new Uint8Array();
-        }
-        files.set(path, {
-          data: bytes,
-          contentType: options?.metadata?.contentType || 'application/octet-stream',
-          token: options?.metadata?.metadata?.firebaseStorageDownloadTokens
-        });
-      },
-      async delete() {
-        files.delete(path);
-      },
-      async download(): Promise<[Uint8Array]> {
-        const file = files.get(path);
-        if (!file) throw new Error(`File not found: ${path}`);
-        return [file.data];
-      },
-      async getMetadata(): Promise<[any]> {
-        const file = files.get(path);
-        return [{
-          contentType: file?.contentType,
-          metadata: {
-            firebaseStorageDownloadTokens: file?.token
-          }
-        }];
-      },
-      async getSignedUrl(config: any): Promise<[string]> {
-        const file = files.get(path);
-        const token = file?.token || 'mock-signed-token';
-        return [`https://firebasestorage.googleapis.com/v0/b/${encodeURIComponent(bucketName)}/o/${encodeURIComponent(path)}?alt=media&token=${token}`];
-      },
-      publicUrl() {
-        return `https://firebasestorage.googleapis.com/v0/b/${encodeURIComponent(bucketName)}/o/${encodeURIComponent(path)}?alt=media`;
-      }
-    };
-  }
-}
-
-export interface FirebaseStorageConfig {
-  bucket?: FirebaseStorageBucketInterface;
-  bucketName?: string;
-  publicUrlBase?: string;
-}
-
-export class FirebaseStorageAdapter implements FileStorageAdapter {
-  private bucket: FirebaseStorageBucketInterface;
-  private bucketName: string;
-  private publicUrlBase?: string;
-
-  constructor(config: FirebaseStorageConfig = {}) {
-    if (!config.bucket) {
-      // Never fall back to an in-memory mock silently: files would vanish on restart.
-      throw new Error('FirebaseStorageAdapter requires a "bucket" (e.g. getStorage().bucket()). Use InMemoryFirebaseStorageMock in tests.');
-    }
-    this.bucket = config.bucket;
-    this.bucketName = config.bucketName || this.bucket.name || 'default-bucket';
-    if (this.bucket && config.bucketName && this.bucket.name !== config.bucketName) {
-      this.bucket.name = config.bucketName;
-    }
-    this.publicUrlBase = config.publicUrlBase?.replace(/\/+$/, '');
-  }
-
-  private getPublicUrl(storageKey: string, token?: string): string {
-    if (this.publicUrlBase) {
-      return `${this.publicUrlBase}/${encodeURIComponent(storageKey).replace(/%2F/g, '/')}`;
-    }
-    const tokenParam = token ? `&token=${encodeURIComponent(token)}` : '';
-    return `https://firebasestorage.googleapis.com/v0/b/${encodeURIComponent(this.bucketName)}/o/${encodeURIComponent(storageKey)}?alt=media${tokenParam}`;
-  }
-
-  async upload(input: UploadFileInput): Promise<UploadFileResult> {
-    const storageKey = buildStorageKey(input.pathPrefix, input.filename);
-
-    const bodyData = normalizeUploadData(input.data, input.encoding, input.mimeType);
-    const mimeType = input.mimeType || 'application/octet-stream';
-    const sizeBytes = bodyData.byteLength;
-    const downloadToken =
-      typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
-        ? crypto.randomUUID()
-        : Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
-
-    const fileRef = this.bucket.file(storageKey);
-    await fileRef.save(bodyData, {
-      metadata: {
-        contentType: mimeType,
-        ...(contentDispositionFor(mimeType, input.filename) ? { contentDisposition: contentDispositionFor(mimeType, input.filename) } : {}),
-        metadata: {
-          firebaseStorageDownloadTokens: downloadToken
-        }
-      },
-      resumable: false
-    });
-
-    const url = this.getPublicUrl(storageKey, downloadToken);
-
-    return {
-      storageKey,
-      url,
-      sizeBytes,
-      mimeType
-    };
-  }
-
-  async delete(storageKey: string): Promise<boolean> {
-    try {
-      const fileRef = this.bucket.file(storageKey);
-      await fileRef.delete();
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  async download(storageKey: string): Promise<Buffer | Uint8Array> {
-    const fileRef = this.bucket.file(storageKey);
-    if (typeof (fileRef as any).download === 'function') {
-      const [buf] = await (fileRef as any).download();
-      return buf;
-    }
-    const url = await this.getDownloadUrl(storageKey);
-    const res = await fetch(url);
-    if (!res.ok) {
-      throw new Error(`Failed to download file from "${url}": ${res.statusText}`);
-    }
-    const arrayBuffer = await res.arrayBuffer();
-    return new Uint8Array(arrayBuffer);
-  }
-
-  async getDownloadUrl(storageKey: string): Promise<string> {
-    const fileRef = this.bucket.file(storageKey);
-    if (typeof (fileRef as any).getMetadata === 'function') {
-      try {
-        const [meta] = await (fileRef as any).getMetadata();
-        const token = meta?.metadata?.firebaseStorageDownloadTokens;
-        return this.getPublicUrl(storageKey, token);
-      } catch {
-        // Fallback to public URL without token
-      }
-    }
-    return this.getPublicUrl(storageKey);
-  }
-
-  async getPresignedUploadUrl(options: PresignedUrlOptions): Promise<PresignedUploadResult> {
-    const storageKey = options.storageKey;
-    const fileRef = this.bucket.file(storageKey);
-
-    if (typeof fileRef.getSignedUrl === 'function') {
-      const expiresInMs = (options.expiresInSeconds || 900) * 1000;
-      const expires = Date.now() + expiresInMs;
-      const [url] = await fileRef.getSignedUrl({
-        action: 'write',
-        expires,
-        contentType: options.contentType
-      });
-
-      return {
-        uploadUrl: url,
-        storageKey,
-        method: 'PUT',
-        headers: options.contentType ? { 'Content-Type': options.contentType } : {}
-      };
-    }
-
-    // A public URL is not an upload credential; refuse rather than hand out a URL that cannot work.
-    throw new Error('FirebaseStorageAdapter cannot presign uploads: the bucket does not support getSignedUrl.');
-  }
-}

package/src/storage/index.ts

@@ -1,3 +0,0 @@
-export * from './file-storage.js';
-export * from './s3.js';
-export * from './firebase-storage.js';

package/src/storage/s3.ts

@@ -1,151 +0,0 @@
-import type {
-  FileStorageAdapter,
-  UploadFileInput,
-  UploadFileResult,
-  PresignedUrlOptions,
-  PresignedUploadResult
-} from '../types/index.js';
-import { buildStorageKey, contentDispositionFor, normalizeUploadData } from './file-storage.js';
-
-/** The subset of the AWS SDK v3 `S3Client` the adapter uses. */
-export interface S3ClientLike {
-  send(command: unknown): Promise<unknown>;
-}
-
-type CommandClass = new (input: Record<string, unknown>) => unknown;
-
-/**
- * Command classes from `@aws-sdk/client-s3`, passed in so `@critical-path/core` has no AWS
- * dependency: `{ PutObjectCommand, DeleteObjectCommand, GetObjectCommand }`.
- */
-export interface S3Commands {
-  PutObjectCommand: CommandClass;
-  DeleteObjectCommand: CommandClass;
-  /** Needed for signed download URLs (private buckets). */
-  GetObjectCommand?: CommandClass;
-}
-
-export interface S3StorageConfig {
-  bucket: string;
-  region?: string;
-  /** Custom endpoint for S3-compatible services (MinIO, R2, LocalStack). */
-  endpoint?: string;
-  /** Base URL for public object links (e.g. a CDN). */
-  publicUrlBase?: string;
-  forcePathStyle?: boolean;
-  /** An AWS SDK v3 `S3Client` (or compatible). Required for uploads and deletes. */
-  client?: S3ClientLike;
-  commands?: S3Commands;
-  /**
-   * Signs a command into a URL, typically
-   * `(command, { expiresIn }) => getSignedUrl(client, command, { expiresIn })` from
-   * `@aws-sdk/s3-request-presigner`. Required for presigned uploads and signed downloads.
-   */
-  presign?: (command: unknown, options: { expiresIn: number }) => Promise<string>;
-  /**
-   * Serve downloads through signed URLs instead of public object URLs (for private buckets).
-   * Requires `presign` and `commands.GetObjectCommand`. Default `false`.
-   */
-  signedDownloads?: boolean;
-  /** Lifetime of signed download URLs in seconds. Default 3600. */
-  downloadUrlExpiresIn?: number;
-}
-
-/**
- * Stores attachments in Amazon S3 (or an S3-compatible service) using the AWS SDK v3 client
- * you provide. Errors from S3 propagate; nothing is reported as stored unless S3 accepted it.
- */
-export class S3StorageAdapter implements FileStorageAdapter {
-  private readonly bucket: string;
-  private readonly endpoint: string;
-  private readonly publicUrlBase?: string;
-  private readonly forcePathStyle: boolean;
-  private readonly config: S3StorageConfig;
-
-  constructor(config: S3StorageConfig) {
-    if (!config.bucket) {
-      throw new Error('S3StorageAdapter requires a "bucket" name in its config.');
-    }
-    if (config.client && !config.commands) {
-      throw new Error('S3StorageAdapter needs "commands" ({ PutObjectCommand, DeleteObjectCommand }) from @aws-sdk/client-s3 when a client is given.');
-    }
-    if (config.signedDownloads && (!config.presign || !config.commands?.GetObjectCommand)) {
-      throw new Error('S3StorageAdapter signedDownloads requires "presign" and "commands.GetObjectCommand".');
-    }
-    this.config = config;
-    this.bucket = config.bucket;
-    const region = config.region || 'us-east-1';
-    this.endpoint = (config.endpoint || `https://s3.${region}.amazonaws.com`).replace(/\/+$/, '');
-    this.publicUrlBase = config.publicUrlBase?.replace(/\/+$/, '');
-    this.forcePathStyle =
-      config.forcePathStyle ?? (this.endpoint.includes('localhost') || this.endpoint.includes('127.0.0.1'));
-  }
-
-  private requireClient(operation: string): { client: S3ClientLike; commands: S3Commands } {
-    if (!this.config.client || !this.config.commands) {
-      throw new Error(`S3StorageAdapter cannot ${operation}: configure "client" and "commands".`);
-    }
-    return { client: this.config.client, commands: this.config.commands };
-  }
-
-  private getObjectUrl(storageKey: string): string {
-    const path = encodeURIComponent(storageKey).replace(/%2F/g, '/');
-    if (this.publicUrlBase) return `${this.publicUrlBase}/${path}`;
-    if (this.forcePathStyle) return `${this.endpoint}/${this.bucket}/${path}`;
-    return `${this.endpoint.replace('://', `://${this.bucket}.`)}/${path}`;
-  }
-
-  async upload(input: UploadFileInput): Promise<UploadFileResult> {
-    const { client, commands } = this.requireClient('upload');
-    const storageKey = buildStorageKey(input.pathPrefix, input.filename);
-    const body = normalizeUploadData(input.data, input.encoding, input.mimeType);
-    const mimeType = input.mimeType || 'application/octet-stream';
-    const disposition = contentDispositionFor(mimeType, input.filename);
-
-    await client.send(
-      new commands.PutObjectCommand({
-        Bucket: this.bucket,
-        Key: storageKey,
-        Body: body,
-        ContentType: mimeType,
-        ...(disposition ? { ContentDisposition: disposition } : {})
-      })
-    );
-
-    return { storageKey, url: await this.getDownloadUrl(storageKey), sizeBytes: body.byteLength, mimeType };
-  }
-
-  /** Deletes an object. S3 deletes are idempotent, so a missing object still returns `true`. */
-  async delete(storageKey: string): Promise<boolean> {
-    const { client, commands } = this.requireClient('delete');
-    await client.send(new commands.DeleteObjectCommand({ Bucket: this.bucket, Key: storageKey }));
-    return true;
-  }
-
-  async getDownloadUrl(storageKey: string): Promise<string> {
-    if (this.config.signedDownloads) {
-      const command = new this.config.commands!.GetObjectCommand!({ Bucket: this.bucket, Key: storageKey });
-      return this.config.presign!(command, { expiresIn: this.config.downloadUrlExpiresIn ?? 3600 });
-    }
-    return this.getObjectUrl(storageKey);
-  }
-
-  async getPresignedUploadUrl(options: PresignedUrlOptions): Promise<PresignedUploadResult> {
-    if (!this.config.presign || !this.config.commands) {
-      throw new Error('S3StorageAdapter cannot presign uploads: configure "presign" and "commands".');
-    }
-    const command = new this.config.commands.PutObjectCommand({
-      Bucket: this.bucket,
-      Key: options.storageKey,
-      ...(options.contentType ? { ContentType: options.contentType } : {})
-    });
-    const uploadUrl = await this.config.presign(command, { expiresIn: options.expiresInSeconds ?? 900 });
-    return {
-      uploadUrl,
-      storageKey: options.storageKey,
-      method: 'PUT',
-      // The signature covers Content-Type, so the uploader must send exactly this header.
-      headers: options.contentType ? { 'Content-Type': options.contentType } : {}
-    };
-  }
-}

package/src/storage/storage.test.ts

@@ -1,274 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  InMemoryFileStore,
-  S3StorageAdapter,
-  FirebaseStorageAdapter,
-  InMemoryFirebaseStorageMock,
-  CriticalPathEngine
-} from '../index.js';
-
-describe('Storage Adapters', () => {
-  describe('InMemoryFileStore', () => {
-    it('uploads, downloads, and deletes files in memory', async () => {
-      const store = new InMemoryFileStore({ publicUrlBase: 'https://cdn.example.com/files' });
-
-      const uploadResult = await store.upload({
-        filename: 'diagram.png',
-        data: 'file-contents-here',
-        mimeType: 'image/png',
-        pathPrefix: 'attachments/task-1'
-      });
-
-      expect(uploadResult.storageKey).toContain('attachments/task-1/');
-      expect(uploadResult.storageKey).toContain('diagram.png');
-      expect(uploadResult.mimeType).toBe('image/png');
-      expect(uploadResult.url).toContain('https://cdn.example.com/files/');
-      expect(uploadResult.sizeBytes).toBeGreaterThan(0);
-
-      const downloadUrl = await store.getDownloadUrl(uploadResult.storageKey);
-      expect(downloadUrl).toBe(uploadResult.url);
-
-      const presigned = await store.getPresignedUploadUrl({
-        storageKey: 'presigned-key.png',
-        contentType: 'image/png'
-      });
-      expect(presigned.uploadUrl).toContain('presigned-key.png');
-      expect(presigned.method).toBe('PUT');
-
-      const deleted = await store.delete(uploadResult.storageKey);
-      expect(deleted).toBe(true);
-      await expect(store.getDownloadUrl(uploadResult.storageKey)).rejects.toThrow();
-    });
-  });
-
-  describe('S3StorageAdapter', () => {
-    // Stand-ins for @aws-sdk/client-s3 command classes: they just record their input
-    class PutObjectCommand { constructor(public input: Record<string, unknown>) {} }
-    class DeleteObjectCommand { constructor(public input: Record<string, unknown>) {} }
-    class GetObjectCommand { constructor(public input: Record<string, unknown>) {} }
-    const commands = { PutObjectCommand, DeleteObjectCommand, GetObjectCommand };
-
-    function setup(send: (command: any) => Promise<unknown> = async () => ({})) {
-      const sent: any[] = [];
-      const presigned: Array<{ command: any; expiresIn: number }> = [];
-      const adapter = new S3StorageAdapter({
-        bucket: 'my-project-bucket',
-        region: 'eu-west-1',
-        client: { send: async (command) => { sent.push(command); return send(command); } },
-        commands,
-        presign: async (command, { expiresIn }) => {
-          presigned.push({ command, expiresIn });
-          return `https://signed.example/${(command as any).input.Key}?X-Amz-Expires=${expiresIn}`;
-        }
-      });
-      return { adapter, sent, presigned };
-    }
-
-    it('uploads with a real command object and returns the object URL', async () => {
-      const { adapter, sent } = setup();
-      const res = await adapter.upload({ filename: 'spec.pdf', data: new Uint8Array([1, 2, 3, 4]), mimeType: 'application/pdf', pathPrefix: 'docs' });
-
-      expect(res.storageKey).toMatch(/^docs\/\d+_[0-9a-f]{12}_spec\.pdf$/);
-      expect(res.sizeBytes).toBe(4);
-      expect(res.url).toBe(`https://my-project-bucket.s3.eu-west-1.amazonaws.com/${res.storageKey}`);
-      expect(sent[0]).toBeInstanceOf(PutObjectCommand);
-      expect(sent[0].input).toMatchObject({ Bucket: 'my-project-bucket', Key: res.storageKey, ContentType: 'application/pdf' });
-      expect(sent[0].input.ContentDisposition).toBeUndefined();
-
-      expect(await adapter.delete(res.storageKey)).toBe(true);
-      expect(sent[1]).toBeInstanceOf(DeleteObjectCommand);
-    });
-
-    it('forces active content to download', async () => {
-      const { adapter, sent } = setup();
-      await adapter.upload({ filename: 'x.svg', data: '<svg/>', mimeType: 'image/svg+xml', encoding: 'utf-8' });
-      expect(sent[0].input.ContentDisposition).toBe('attachment; filename="x.svg"');
-    });
-
-    it('propagates S3 errors instead of reporting success', async () => {
-      const { adapter } = setup(async () => {
-        throw new Error('AccessDenied');
-      });
-      await expect(adapter.upload({ filename: 'a.txt', data: 'x' })).rejects.toThrow('AccessDenied');
-      await expect(adapter.delete('a.txt')).rejects.toThrow('AccessDenied');
-    });
-
-    it('refuses to upload or presign without the AWS pieces', async () => {
-      const bare = new S3StorageAdapter({ bucket: 'b' });
-      await expect(bare.upload({ filename: 'a.txt', data: 'x' })).rejects.toThrow(/configure "client"/);
-      await expect(bare.getPresignedUploadUrl({ storageKey: 'k' })).rejects.toThrow(/presign/);
-      expect(() => new S3StorageAdapter({ bucket: 'b', client: { send: async () => ({}) } })).toThrow(/commands/);
-    });
-
-    it('presigns uploads through the provided signer, covering the content type', async () => {
-      const { adapter, presigned } = setup();
-      const result = await adapter.getPresignedUploadUrl({ storageKey: 'projects/p1/file.zip', contentType: 'application/zip', expiresInSeconds: 60 });
-
-      expect(result.uploadUrl).toBe('https://signed.example/projects/p1/file.zip?X-Amz-Expires=60');
-      expect(result.headers).toEqual({ 'Content-Type': 'application/zip' });
-      expect(presigned[0].command).toBeInstanceOf(PutObjectCommand);
-      expect(presigned[0].command.input).toMatchObject({ Key: 'projects/p1/file.zip', ContentType: 'application/zip' });
-    });
-
-    it('serves signed download URLs for private buckets', async () => {
-      const presign = async (command: any, { expiresIn }: { expiresIn: number }) => `https://signed.example/get/${command.input.Key}?e=${expiresIn}`;
-      const adapter = new S3StorageAdapter({ bucket: 'b', client: { send: async () => ({}) }, commands, presign, signedDownloads: true });
-      expect(await adapter.getDownloadUrl('k')).toBe('https://signed.example/get/k?e=3600');
-    });
-
-    it('rejects path prefixes that escape their directory', async () => {
-      const { adapter } = setup();
-      for (const pathPrefix of ['../other', 'projects/../../x', '/abs', 'a//b', 'bad prefix']) {
-        await expect(adapter.upload({ filename: 'a.txt', data: 'x', pathPrefix })).rejects.toThrow(/Invalid storage path prefix/);
-      }
-    });
-  });
-
-  describe('FirebaseStorageAdapter & InMemoryFirebaseStorageMock', () => {
-    it('works with InMemoryFirebaseStorageMock', async () => {
-      const mockStorage = new InMemoryFirebaseStorageMock();
-      const adapter = new FirebaseStorageAdapter({
-        bucket: mockStorage,
-        bucketName: 'my-app.appspot.com'
-      });
-      expect(() => new FirebaseStorageAdapter()).toThrow(/requires a "bucket"/);
-
-      const uploadResult = await adapter.upload({
-        filename: 'architecture.png',
-        data: 'png-data-mock',
-        mimeType: 'image/png',
-        pathPrefix: 'projects/p1'
-      });
-
-      expect(uploadResult.storageKey).toContain('projects/p1/');
-      expect(uploadResult.url).toContain('https://firebasestorage.googleapis.com/v0/b/my-app.appspot.com/o/');
-
-      const downloadUrl = await adapter.getDownloadUrl(uploadResult.storageKey);
-      expect(downloadUrl).toBe(uploadResult.url);
-
-      const deleted = await adapter.delete(uploadResult.storageKey);
-      expect(deleted).toBe(true);
-    });
-  });
-
-  describe('CriticalPathEngine with File Storage', () => {
-    it('creates attachments with direct upload & handles file deletion on attachment removal', async () => {
-      const fileStore = new InMemoryFileStore();
-      const engine = new CriticalPathEngine({ fileStorage: fileStore });
-
-      const project = await engine.createProject({ key: 'ATT', name: 'Attachment Project' });
-      const task = await engine.createTask({ projectId: project.id, title: 'Upload test task', status: 'todo' });
-
-      // Upload file directly through engine (which also creates attachment)
-      const attachment = await engine.uploadAttachmentFile({
-        filename: 'screenshot.png',
-        data: 'image-binary-bytes',
-        mimeType: 'image/png',
-        taskId: task.id,
-        projectId: project.id,
-        uploaderId: 'user_1',
-        uploaderType: 'user'
-      });
-
-      expect(attachment.id).toBeDefined();
-      expect(attachment.filename).toBe('screenshot.png');
-      expect(attachment.storageKey).toBeDefined();
-
-      const taskAttachments = await engine.getAttachments({ taskId: task.id });
-      expect(taskAttachments.length).toBe(1);
-      expect(taskAttachments[0].id).toBe(attachment.id);
-
-      // Deleting attachment should also delete file from fileStorage
-      const deleted = await engine.deleteAttachment(attachment.id);
-      expect(deleted).toBe(true);
-
-      const remainingAttachments = await engine.getAttachments({ taskId: task.id });
-      expect(remainingAttachments.length).toBe(0);
-    });
-
-    it('decodes base64 strings and data URIs into binary Uint8Array data', async () => {
-      const fileStore = new InMemoryFileStore();
-      const rawText = 'Hello Critical Path Storage';
-      const base64Text = Buffer.from(rawText).toString('base64');
-
-      const resBase64 = await fileStore.upload({
-        filename: 'test.png',
-        data: base64Text,
-        mimeType: 'image/png',
-        encoding: 'base64'
-      });
-
-      const stored = fileStore.getFile(resBase64.storageKey);
-      expect(stored).toBeDefined();
-      expect(stored?.sizeBytes).toBe(Buffer.from(rawText).length);
-      expect(new TextDecoder().decode(stored?.data)).toBe(rawText);
-
-      // Data URI
-      const dataUri = `data:image/png;base64,${base64Text}`;
-      const resDataUri = await fileStore.upload({
-        filename: 'datauri.png',
-        data: dataUri,
-        mimeType: 'image/png'
-      });
-      const storedUri = fileStore.getFile(resDataUri.storageKey);
-      expect(storedUri).toBeDefined();
-      expect(storedUri?.sizeBytes).toBe(Buffer.from(rawText).length);
-      expect(new TextDecoder().decode(storedUri?.data)).toBe(rawText);
-    });
-
-    it('downloads file bytes and reads text content from attachments via engine', async () => {
-      const mockStorage = new InMemoryFirebaseStorageMock();
-      const storageAdapter = new FirebaseStorageAdapter({ bucket: mockStorage, bucketName: 'test-bucket' });
-      const engine = new CriticalPathEngine({ fileStorage: storageAdapter });
-
-      const project = await engine.createProject({ name: 'Attachment Reading Test' });
-      const task = await engine.createTask({ projectId: project.id, title: 'Document Task' });
-
-      const planMarkdown = '# Project Roadmap\n\nPhase 1: Research\nPhase 2: Execution';
-      const attachment = await engine.uploadAttachmentFile({
-        filename: 'Roadmap.md',
-        data: planMarkdown,
-        mimeType: 'text/markdown',
-        taskId: task.id,
-        projectId: project.id,
-        uploaderId: 'agent_planner',
-        uploaderType: 'agent',
-        artifactType: 'plan'
-      });
-
-      expect(attachment.id).toBeDefined();
-      expect(attachment.artifactType).toBe('plan');
-
-      // Test download method on adapter
-      const downloadedBytes = await storageAdapter.download(attachment.storageKey!);
-      expect(new TextDecoder().decode(downloadedBytes)).toBe(planMarkdown);
-
-      // Test engine readAttachmentText
-      const readText = await engine.readAttachmentText(attachment.id);
-      expect(readText).toBe(planMarkdown);
-
-      // Test filtering by artifactType
-      const planAttachments = await engine.getAttachments({ taskId: task.id, artifactType: 'plan' });
-      expect(planAttachments.length).toBe(1);
-      expect(planAttachments[0].id).toBe(attachment.id);
-
-      const reviewAttachments = await engine.getAttachments({ taskId: task.id, artifactType: 'review' });
-      expect(reviewAttachments.length).toBe(0);
-    });
-  });
-
-  it('stores uploads made through an actor view under the project prefix', async () => {
-    const engine = new CriticalPathEngine({ fileStorage: new InMemoryFileStore() });
-    const project = await engine.createProject({ name: 'Uploads' });
-    const task = await engine.createTask({ projectId: project.id, title: 'T' });
-
-    const attachment = await engine.withActor({ userId: 'u1' }).uploadAttachmentFile({ taskId: task.id, filename: 'notes.txt', data: 'hi', encoding: 'utf-8' });
-    expect(attachment.storageKey?.startsWith(`projects/${project.id}/`)).toBe(true);
-    expect(attachment.uploaderId).toBe('u1');
-
-    await expect(
-      engine.withActor({ userId: 'u1' }).uploadAttachmentFile({ filename: 'orphan.txt', data: 'x' })
-    ).rejects.toThrow(/must reference a project/);
-  });
-});
-

package/src/storage/upload-limits.test.ts

@@ -1,41 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { CriticalPathEngine, InMemoryFileStore, ValidationError } from '../index.js';
-
-async function setup() {
-  const engine = new CriticalPathEngine({
-    fileStorage: new InMemoryFileStore(),
-    uploads: { maxBytes: 10, allowedMimeTypes: ['image/*', 'application/pdf'] }
-  });
-  const project = await engine.createProject({ name: 'Limits' });
-  return { engine, project };
-}
-
-describe('upload limits', () => {
-  it('enforces the decoded size of direct uploads', async () => {
-    const { engine, project } = await setup();
-    await expect(
-      engine.uploadAttachmentFile({ projectId: project.id, filename: 'ok.png', mimeType: 'image/png', data: new Uint8Array(10), uploaderId: 'u' })
-    ).resolves.toMatchObject({ sizeBytes: 10 });
-    // 16 base64 characters decode to 12 bytes
-    await expect(
-      engine.uploadAttachmentFile({ projectId: project.id, filename: 'big.png', mimeType: 'image/png', data: 'AAAAAAAAAAAAAAAA', encoding: 'base64', uploaderId: 'u' })
-    ).rejects.toThrow(/maximum is 10 bytes/);
-  });
-
-  it('allows MIME types by exact match or wildcard', async () => {
-    const { engine, project } = await setup();
-    const upload = (mimeType: string) =>
-      engine.uploadAttachmentFile({ projectId: project.id, filename: 'f', mimeType, data: new Uint8Array(1), uploaderId: 'u' });
-    await expect(upload('image/webp')).resolves.toBeDefined();
-    await expect(upload('application/pdf; charset=binary')).resolves.toBeDefined();
-    await expect(upload('text/html')).rejects.toThrow(ValidationError);
-  });
-
-  it('applies to presigned uploads and registered attachments', async () => {
-    const { engine, project } = await setup();
-    await expect(engine.getPresignedAttachmentUploadUrl({ projectId: project.id, filename: 'x.html', contentType: 'text/html' })).rejects.toThrow(/not allowed/);
-    await expect(
-      engine.createAttachment({ projectId: project.id, filename: 'x', url: 'https://e.com/x', mimeType: 'image/png', sizeBytes: 11, uploaderId: 'u' })
-    ).rejects.toThrow(/maximum/);
-  });
-});