@striae-org/striae 3.0.4

package/app/types/audit.ts

@@ -0,0 +1,301 @@
+// Audit trail types for comprehensive forensic accountability framework
+// Tracks all user actions and system events throughout the application
+
+export type AuditAction = 
+  // Case Management Actions
+  | 'case-create' | 'case-rename' | 'case-delete'
+  // Confirmation Workflow Actions  
+  | 'case-export' | 'case-import' | 'confirmation-create' | 'confirmation-export' | 'confirmation-import'
+  // File Operations
+  | 'file-upload' | 'file-delete' | 'file-access'
+  // Annotation Operations
+  | 'annotation-create' | 'annotation-edit' | 'annotation-delete'
+  // User & Session Management
+  | 'user-login' | 'user-logout' | 'user-profile-update' | 'user-password-reset' | 'user-account-delete'
+  // NEW: User Registration & Authentication
+  | 'user-registration' | 'email-verification' | 'mfa-enrollment' | 'mfa-authentication'
+  // Document Generation
+  | 'pdf-generate'
+  // Security & Monitoring
+  | 'security-violation'
+  // Legacy actions (for backward compatibility)
+  | 'import' | 'export' | 'confirm' | 'validate';
+
+export type AuditResult = 'success' | 'failure' | 'warning' | 'blocked' | 'pending';
+
+export type AuditFileType = 
+  | 'case-package' | 'confirmation-data' | 'image-file' | 'pdf-document' 
+  | 'json-data' | 'csv-export' | 'log-file' | 'unknown';
+
+/**
+ * Core audit entry structure for all validation events
+ * Based on the specification in confirmations-guide.md
+ */
+export interface ValidationAuditEntry {
+  timestamp: string;
+  userId: string;
+  userEmail: string;
+  action: AuditAction;
+  result: AuditResult;
+  details: AuditDetails;
+}
+
+/**
+ * Detailed information for each audit entry
+ * Contains action-specific data and metadata
+ */
+export interface AuditDetails {
+  // Core identification
+  fileName?: string;
+  fileType?: AuditFileType;
+  caseNumber?: string;
+  confirmationId?: string;
+  
+  // Validation & Security
+  hashValid?: boolean;
+  validationErrors: string[];
+  securityChecks?: SecurityCheckResults;
+  
+  // Context & Workflow
+  originalExaminerUid?: string;
+  reviewingExaminerUid?: string;
+  workflowPhase?: WorkflowPhase;
+  
+  // Performance & Metrics
+  performanceMetrics?: PerformanceMetrics;
+  
+  // Case Management Details
+  caseDetails?: CaseAuditDetails;
+  
+  // File Operation Details
+  fileDetails?: FileAuditDetails;
+  
+  // Annotation Details
+  annotationDetails?: AnnotationAuditDetails;
+  
+  // User Session Details
+  sessionDetails?: SessionAuditDetails;
+  
+  // Security Incident Details
+  securityDetails?: SecurityAuditDetails;
+  
+  // User Profile & Authentication Details
+  userProfileDetails?: UserProfileAuditDetails;
+}
+
+/**
+ * Workflow phases for tracking different types of forensic activities
+ */
+export type WorkflowPhase = 
+  | 'casework'             // All case, notes, image, and pdf related actions
+  | 'case-export'          // Only case exporting
+  | 'case-import'          // Only case importing  
+  | 'confirmation'         // Only confirmation-related activity
+  | 'user-management';     // User login, logout, profile management, account activities
+
+/**
+ * Security validation results
+ */
+export interface SecurityCheckResults {
+  selfConfirmationPrevented: boolean;
+  fileIntegrityValid: boolean;
+  exporterUidValidated?: boolean;
+  manifestSignaturePresent?: boolean;
+  manifestSignatureValid?: boolean;
+  manifestSignatureKeyId?: string;
+}
+
+/**
+ * Performance and operational metrics
+ */
+export interface PerformanceMetrics {
+  processingTimeMs: number;
+  fileSizeBytes: number;
+  validationStepsCompleted?: number;
+  validationStepsFailed?: number;
+}
+
+/**
+ * Complete audit trail for a case or workflow
+ */
+export interface AuditTrail {
+  caseNumber: string;
+  workflowId: string; // Unique identifier linking related audit entries
+  entries: ValidationAuditEntry[];
+  summary: AuditSummary;
+}
+
+/**
+ * Summary of audit trail for reporting and compliance
+ */
+export interface AuditSummary {
+  totalEvents: number;
+  successfulEvents: number;
+  failedEvents: number;
+  warningEvents: number;
+  workflowPhases: WorkflowPhase[];
+  participatingUsers: string[]; // User IDs
+  startTimestamp: string;
+  endTimestamp: string;
+  complianceStatus: 'compliant' | 'non-compliant' | 'pending';
+  securityIncidents: number;
+}
+
+/**
+ * Audit entry creation parameters
+ */
+export interface CreateAuditEntryParams {
+  userId: string;
+  userEmail: string;
+  action: AuditAction;
+  result: AuditResult;
+  fileName?: string;
+  fileType?: AuditFileType;
+  hashValid?: boolean;
+  validationErrors?: string[];
+  caseNumber?: string;
+  confirmationId?: string;
+  workflowPhase?: WorkflowPhase;
+  securityChecks?: SecurityCheckResults;
+  performanceMetrics?: PerformanceMetrics;
+  originalExaminerUid?: string;
+  reviewingExaminerUid?: string;
+  // Extended detail fields
+  caseDetails?: CaseAuditDetails;
+  fileDetails?: FileAuditDetails;
+  annotationDetails?: AnnotationAuditDetails;
+  sessionDetails?: SessionAuditDetails;
+  securityDetails?: SecurityAuditDetails;
+  userProfileDetails?: UserProfileAuditDetails;
+}
+
+/**
+ * Query parameters for retrieving audit entries
+ */
+export interface AuditQueryParams {
+  caseNumber?: string;
+  workflowId?: string;
+  userId?: string;
+  action?: AuditAction;
+  result?: AuditResult;
+  workflowPhase?: WorkflowPhase;
+  startDate?: string;
+  endDate?: string;
+  limit?: number;
+  offset?: number;
+}
+
+// =============================================================================
+// SPECIALIZED AUDIT DETAIL INTERFACES
+// =============================================================================
+
+/**
+ * Case management specific audit details
+ */
+export interface CaseAuditDetails {
+  oldCaseName?: string;
+  newCaseName?: string;
+  totalFiles?: number;
+  totalAnnotations?: number;
+  createdDate?: string;
+  lastModified?: string;
+  deleteReason?: string;
+  backupCreated?: boolean;
+}
+
+/**
+ * File operation specific audit details
+ */
+export interface FileAuditDetails {
+  fileId?: string;
+  originalFileName?: string;
+  fileSize: number;
+  mimeType?: string;
+  uploadMethod?: 'drag-drop' | 'file-picker' | 'api' | 'import';
+  processingTime?: number;
+  thumbnailGenerated?: boolean;
+  deleteReason?: string;
+  sourceLocation?: string;
+}
+
+/**
+ * Annotation operation specific audit details
+ */
+export interface AnnotationAuditDetails {
+  annotationId?: string;
+  annotationType?: 'measurement' | 'identification' | 'comparison' | 'note' | 'region';
+  annotationData?: any; // The actual annotation data structure
+  canvasPosition?: { x: number; y: number };
+  annotationSize?: { width: number; height: number };
+  previousValue?: any; // For edit operations
+  tool?: string; // Which tool was used to create/edit
+}
+
+/**
+ * User session specific audit details
+ */
+export interface SessionAuditDetails {
+  sessionId?: string;
+  userAgent?: string;
+  sessionDuration?: number;
+  loginMethod?: 'firebase' | 'sso' | 'api-key' | 'manual';
+  logoutReason?: 'user-initiated' | 'timeout' | 'security' | 'error';
+}
+
+/**
+ * Security incident specific audit details
+ */
+export interface SecurityAuditDetails {
+  incidentType?: 'unauthorized-access' | 'data-breach' | 'malware' | 'injection' | 'brute-force' | 'privilege-escalation';
+  severity?: 'low' | 'medium' | 'high' | 'critical';
+  targetResource?: string;
+  blockedBySystem?: boolean;
+  investigationId?: string;
+  reportedToAuthorities?: boolean;
+  mitigationSteps?: string[];
+  // MFA specific fields
+  mfaMethod?: 'sms' | 'totp' | 'hardware-key';
+  phoneNumber?: string; // Masked phone number for privacy
+  enrollmentAttempts?: number;
+  enrollmentDate?: string;
+  mandatoryEnrollment?: boolean;
+  backupCodesGenerated?: boolean;
+  verificationAttempts?: number;
+  authenticationDate?: string;
+  loginFlowStep?: 'first-factor' | 'second-factor';
+}
+
+/**
+ * User profile and authentication specific audit details
+ */
+export interface UserProfileAuditDetails {
+  profileField?: 'displayName' | 'email' | 'organization' | 'role' | 'preferences' | 'avatar';
+  oldValue?: string;
+  newValue?: string;
+  resetMethod?: 'email' | 'sms' | 'security-questions' | 'admin-reset';
+  resetToken?: string; // Partial token for tracking (last 4 chars)
+  verificationMethod?: 'email-link' | 'sms-code' | 'totp' | 'backup-codes' | 'admin-verification';
+  verificationAttempts?: number;
+  passwordComplexityMet?: boolean;
+  previousPasswordReused?: boolean;
+  // Account deletion specific fields
+  deletionReason?: 'user-requested' | 'admin-initiated' | 'policy-violation' | 'inactive-account';
+  dataRetentionPeriod?: number; // Days before permanent deletion
+  confirmationMethod?: 'uid-email' | 'password' | 'admin-override';
+  casesCount?: number; // Number of cases deleted with account
+  filesCount?: number; // Number of files deleted with account
+  // NEW: User registration specific fields
+  registrationMethod?: 'email-password' | 'sso' | 'admin-created' | 'api';
+  firstName?: string;
+  lastName?: string;
+  company?: string;
+  emailVerificationRequired?: boolean;
+  mfaEnrollmentRequired?: boolean;
+  // NEW: Email verification specific fields
+  verificationDate?: string;
+  emailVerified?: boolean;
+  emailNotificationSent?: boolean;
+  // NEW: Retroactive verification fields
+  retroactiveVerification?: boolean;
+  retroactiveReason?: string;
+}

package/app/types/case.ts

@@ -0,0 +1,90 @@
+import { FileData } from './file';
+import { AnnotationData, ConfirmationData } from './annotations';
+
+// Case-related types and interfaces
+
+export type CaseActionType = 'loaded' | 'created' | 'deleted' | null;
+
+export interface CaseData {
+  createdAt: string;
+  caseNumber: string;
+  files: FileData[];
+}
+
+export interface ReadOnlyCaseData extends CaseData {
+  isReadOnly?: boolean;
+}
+
+export interface CasesToDelete {
+  casesToDelete: string[];
+}
+
+export interface CaseExportData {
+  metadata: {
+    caseNumber: string;
+    caseCreatedDate: string;
+    exportDate: string;
+    exportedBy: string | null;
+    exportedByUid: string;
+    exportedByName: string;
+    exportedByCompany: string;
+    striaeExportSchemaVersion: string;
+    totalFiles: number;
+  };
+  files: Array<{
+    fileData: FileData;
+    annotations?: AnnotationData;
+    hasAnnotations: boolean;
+  }>;
+  summary?: {
+    filesWithAnnotations: number;
+    filesWithoutAnnotations: number;
+    totalBoxAnnotations: number;
+    filesWithConfirmations?: number;
+    filesWithConfirmationsRequested?: number;
+    lastModified?: string;
+    earliestAnnotationDate?: string;
+    latestAnnotationDate?: string;
+    exportError?: string;
+  };
+}
+
+export interface AllCasesExportData {
+  metadata: {
+    exportDate: string;
+    exportedBy: string | null;
+    exportedByUid: string;
+    exportedByName: string;
+    exportedByCompany: string;
+    striaeExportSchemaVersion: string;
+    totalCases: number;
+    totalFiles: number;
+    totalAnnotations: number;
+    totalConfirmations: number;
+    totalConfirmationsRequested: number;
+  };
+  cases: CaseExportData[];
+  summary?: {
+    casesWithFiles: number;
+    casesWithAnnotations: number;
+    casesWithoutFiles: number;
+    lastModified?: string;
+    earliestAnnotationDate?: string;
+    latestAnnotationDate?: string;
+  };
+}
+
+// Confirmation-related case types
+export interface CaseConfirmations {
+  [originalImageId: string]: ConfirmationData[];
+}
+
+export interface CaseDataWithConfirmations {
+  createdAt: string;
+  caseNumber: string;
+  files: any[];
+  isReadOnly?: boolean;
+  importedAt?: string;
+  originalImageIds?: { [originalId: string]: string };
+  confirmations?: CaseConfirmations;
+}

package/app/types/export.ts

@@ -0,0 +1,8 @@
+// Export-related types and interfaces
+
+export interface ExportOptions {
+  format?: 'json' | 'csv';
+  includeMetadata?: boolean;
+  includeUserInfo?: boolean;
+  protectForensicData?: boolean; // Enable read-only protection
+}

package/app/types/file.ts

@@ -0,0 +1,30 @@
+// File-related types and interfaces
+
+export interface FileData {
+  id: string;
+  originalFilename: string;
+  uploadedAt: string;
+}
+
+export interface FileUploadResponse {
+  success: boolean;
+  result: {
+    id: string;
+    filename: string;
+    uploaded: string;
+    requireSignedURLs: boolean;
+    variants: string[];
+  };
+  errors: Array<{
+    code: number;
+    message: string;
+  }>;
+  messages: string[];
+}
+
+export interface ImageUploadResponse {
+  success: boolean;
+  result: FileUploadResponse['result'];
+  errors: FileUploadResponse['errors'];
+  messages: FileUploadResponse['messages'];
+}

package/app/types/import.ts

@@ -0,0 +1,107 @@
+// Import-related types and interfaces
+
+export interface ImportOptions {
+  overwriteExisting?: boolean;
+  validateIntegrity?: boolean;
+  preserveTimestamps?: boolean;
+}
+
+export interface ImportResult {
+  success: boolean;
+  caseNumber: string;
+  isReadOnly: boolean;
+  filesImported: number;
+  annotationsImported: number;
+  errors?: string[];
+  warnings?: string[];
+}
+
+export interface ReadOnlyCaseMetadata {
+  caseNumber: string;
+  importedAt: string;
+  originalExportDate: string;
+  originalExportedBy: string;
+  sourceHash?: string;
+  sourceManifestVersion?: string;
+  sourceSignatureKeyId?: string;
+  sourceSignatureValid?: boolean;
+  isReadOnly: true;
+}
+
+export interface ConfirmationImportResult {
+  success: boolean;
+  caseNumber: string;
+  confirmationsImported: number;
+  imagesUpdated: number;
+  errors?: string[];
+  warnings?: string[];
+}
+
+export interface R2ObjectMetadata {
+  lastModified: string;
+  size: number;
+  etag: string;
+}
+
+export interface ConfirmationImportData {
+  metadata: {
+    caseNumber: string;
+    exportDate: string;
+    exportedBy: string;
+    exportedByUid: string;
+    exportedByName: string;
+    exportedByCompany: string;
+    totalConfirmations: number;
+    version: string;
+    hash: string;
+    signatureVersion?: string;
+    signature?: {
+      algorithm: string;
+      keyId: string;
+      signedAt: string;
+      value: string;
+    };
+    originalExportCreatedAt?: string;
+  };
+  confirmations: {
+    [originalImageId: string]: Array<{
+      fullName: string;
+      badgeId: string;
+      timestamp: string;
+      confirmationId: string;
+      confirmedBy: string;
+      confirmedByEmail: string;
+      confirmedByCompany: string;
+      confirmedAt: string;
+    }>;
+  };
+}
+
+export interface CaseImportPreview {
+  caseNumber: string;
+  exportedBy: string | null;
+  exportedByName: string | null;
+  exportedByCompany: string | null;
+  exportDate: string;
+  totalFiles: number;
+  caseCreatedDate?: string;
+  hashValid?: boolean;
+  hashError?: string;
+  expectedHash?: string;
+  actualHash?: string;
+  hasAnnotations: boolean;
+  validationSummary: string;
+  errors?: string[];
+  // Enhanced validation details
+  validationDetails?: {
+    hasForensicManifest: boolean;
+    dataValid?: boolean;
+    imageValidation?: { [filename: string]: boolean };
+    manifestValid?: boolean;
+    signatureValid?: boolean;
+    signatureKeyId?: string;
+    signatureError?: string;
+    validationSummary?: string;
+    integrityErrors?: string[];
+  };
+}

package/app/types/index.ts

@@ -0,0 +1,24 @@
+// Barrel export for all application types
+// This allows importing multiple types from a single location
+// Example: import { UserData, FileData, AnnotationData } from '~/types';
+
+// Annotation types
+export * from './annotations';
+
+// User types
+export * from './user';
+
+// File types  
+export * from './file';
+
+// Case types
+export * from './case';
+
+// Import types
+export * from './import';
+
+// Export types
+export * from './export';
+
+// Audit types
+export * from './audit';

package/app/types/user.ts

@@ -0,0 +1,38 @@
+// User-related types and interfaces
+
+import { ReadOnlyCaseMetadata } from './import';
+
+export interface UserData {
+  uid: string;
+  email: string | null;
+  firstName: string;
+  lastName: string;
+  company: string;
+  permitted: boolean;
+  cases: Array<{
+    caseNumber: string;
+    createdAt: string;
+  }>;
+  readOnlyCases?: Array<{
+    caseNumber: string;
+    importedAt: string;
+    originalExportDate: string;
+    originalExportedBy: string;
+    sourceHash?: string;
+    sourceManifestVersion?: string;
+    sourceSignatureKeyId?: string;
+    sourceSignatureValid?: boolean;
+    isReadOnly: true;
+  }>;
+  createdAt: string;
+  updatedAt?: string;
+}
+
+export interface ExtendedUserData extends UserData {
+  readOnlyCases?: ReadOnlyCaseMetadata[];
+}
+
+export interface UserLimits {
+  maxCases: number;
+  maxFilesPerCase: number;
+}