@omniradiology/omnirad 0.1.3

package/app/api/compliance/export/patient/[id]/route.ts

@@ -0,0 +1,108 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db, sqlite } from "@/db";
+import { patients, reports, patientPrivacyControls } from "@/db/schema";
+import { eq } from "drizzle-orm";
+import { requireUser, requirePermission, handleAuthError } from "@/lib/security/authz";
+import { safeError } from "@/lib/security/phi-redaction";
+import { auditSuccess, auditEventFromContext } from "@/lib/security/audit";
+import { randomUUID } from "crypto";
+
+// POST /api/compliance/export/patient/[id] — GDPR Article 20: Data Portability
+export async function POST(
+    request: NextRequest,
+    { params }: { params: Promise<{ id: string }> }
+) {
+    try {
+        const ctx = await requireUser(request);
+        requirePermission(ctx, "compliance.manage");
+
+        const { id } = await params;
+
+        // Get patient data
+        const patient = db.select().from(patients).where(eq(patients.id, id)).limit(1).all();
+        if (patient.length === 0) {
+            return NextResponse.json({ error: "Patient not found" }, { status: 404 });
+        }
+
+        // Get all reports for this patient
+        const patientReports = db.select({
+            id: reports.id,
+            modality: reports.modality,
+            urgency: reports.urgency,
+            reportStatus: reports.reportStatus,
+            reportData: reports.reportData,
+            createdAt: reports.createdAt,
+        }).from(reports).where(eq(reports.patientId, id)).all();
+
+        const parsedReports = patientReports.map(r => {
+            let reportData: any = {};
+            try { reportData = JSON.parse(r.reportData); } catch {}
+            // Exclude image_data from exports to keep size manageable
+            delete reportData.image_data;
+            delete reportData.images_data;
+            return {
+                id: r.id,
+                modality: r.modality,
+                urgency: r.urgency,
+                reportStatus: r.reportStatus,
+                reportData,
+                createdAt: r.createdAt,
+            };
+        });
+
+        // Get privacy controls
+        const privacyCtrl = sqlite.prepare(
+            "SELECT * FROM patient_privacy_controls WHERE patient_id = ?"
+        ).get(id) as any;
+
+        // Build export package
+        const exportData = {
+            exportVersion: "1.0",
+            exportedAt: new Date().toISOString(),
+            exportedBy: ctx.fullName,
+            patient: {
+                id: patient[0].id,
+                name: patient[0].patientName,
+                idNumber: patient[0].patientIdNumber,
+                dateOfBirth: patient[0].dob,
+                age: patient[0].age,
+                gender: patient[0].gender,
+                contactInfo: patient[0].contactInfo,
+                notes: patient[0].notes,
+                createdAt: patient[0].createdAt,
+            },
+            reports: parsedReports,
+            privacyControls: privacyCtrl ? {
+                restriction: privacyCtrl.restriction,
+                consentStatus: privacyCtrl.consent_status,
+            } : null,
+            _meta: {
+                format: "OmniRad GDPR Export",
+                recordCount: parsedReports.length,
+            },
+        };
+
+        // Update last exported timestamp
+        if (privacyCtrl) {
+            sqlite.prepare(
+                "UPDATE patient_privacy_controls SET last_exported_at = ?, last_exported_by = ?, updated_at = ? WHERE patient_id = ?"
+            ).run(new Date().toISOString(), ctx.userId, new Date().toISOString(), id);
+        } else {
+            sqlite.prepare(
+                "INSERT INTO patient_privacy_controls (id, patient_id, last_exported_at, last_exported_by, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)"
+            ).run(randomUUID(), id, new Date().toISOString(), ctx.userId, new Date().toISOString(), new Date().toISOString());
+        }
+
+        await auditSuccess(auditEventFromContext(ctx, "patient.export", "patient", {
+            resourceId: id,
+            patientId: id,
+            metadata: { format: "json", count: parsedReports.length },
+        }));
+
+        return NextResponse.json(exportData);
+    } catch (error) {
+        if ((error as any)?.statusCode) return handleAuthError(error);
+        safeError("Error exporting patient data:", error);
+        return NextResponse.json({ error: "Failed to export patient data" }, { status: 500 });
+    }
+}

package/app/api/compliance/restrict/patient/[id]/route.ts

@@ -0,0 +1,59 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db, sqlite } from "@/db";
+import { patients } from "@/db/schema";
+import { eq } from "drizzle-orm";
+import { requireUser, requirePermission, handleAuthError } from "@/lib/security/authz";
+import { safeError } from "@/lib/security/phi-redaction";
+import { auditSuccess, auditEventFromContext } from "@/lib/security/audit";
+import { randomUUID } from "crypto";
+
+// POST /api/compliance/restrict/patient/[id] — GDPR Article 18: Right to Restriction
+export async function POST(
+    request: NextRequest,
+    { params }: { params: Promise<{ id: string }> }
+) {
+    try {
+        const ctx = await requireUser(request);
+        requirePermission(ctx, "compliance.manage");
+
+        const { id } = await params;
+        const body = await request.json();
+        const { restriction, reason } = body; // restriction: "restricted" | "none"
+
+        // Validate patient exists
+        const patient = await db.select().from(patients).where(eq(patients.id, id)).limit(1);
+        if (patient.length === 0) {
+            return NextResponse.json({ error: "Patient not found" }, { status: 404 });
+        }
+
+        const now = new Date().toISOString();
+        const existing = sqlite.prepare(
+            "SELECT id FROM patient_privacy_controls WHERE patient_id = ?"
+        ).get(id) as any;
+
+        if (existing) {
+            sqlite.prepare(`
+                UPDATE patient_privacy_controls 
+                SET restriction = ?, restricted_by = ?, restricted_at = ?, restriction_reason = ?, updated_at = ?
+                WHERE patient_id = ?
+            `).run(restriction || "restricted", ctx.userId, now, reason || null, now, id);
+        } else {
+            sqlite.prepare(`
+                INSERT INTO patient_privacy_controls (id, patient_id, restriction, restricted_by, restricted_at, restriction_reason, created_at, updated_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            `).run(randomUUID(), id, restriction || "restricted", ctx.userId, now, reason || null, now, now);
+        }
+
+        await auditSuccess(auditEventFromContext(ctx, "patient.restrict", "patient", {
+            resourceId: id,
+            patientId: id,
+            metadata: { restriction: restriction || "restricted" },
+        }));
+
+        return NextResponse.json({ success: true });
+    } catch (error) {
+        if ((error as any)?.statusCode) return handleAuthError(error);
+        safeError("Error restricting patient:", error);
+        return NextResponse.json({ error: "Failed to restrict patient" }, { status: 500 });
+    }
+}

package/app/api/compliance/settings/route.ts

@@ -0,0 +1,93 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/db";
+import { complianceSettings } from "@/db/schema";
+import { eq } from "drizzle-orm";
+import { requireUser, requirePermission, handleAuthError } from "@/lib/security/authz";
+import { safeError } from "@/lib/security/phi-redaction";
+import { auditSuccess, auditEventFromContext } from "@/lib/security/audit";
+
+// GET /api/compliance/settings — Get compliance settings
+export async function GET(request: NextRequest) {
+    try {
+        const ctx = await requireUser(request);
+        requirePermission(ctx, "compliance.manage");
+
+        const row = db.select().from(complianceSettings).where(eq(complianceSettings.id, 1)).get();
+
+        if (!row) {
+            // Return defaults
+            return NextResponse.json({
+                dataRetentionDays: 2555,
+                auditRetentionDays: 2555,
+                sessionTimeoutMinutes: 15,
+                idleTimeoutMinutes: 30,
+                enableGdprExport: true,
+                enableGdprAnonymize: true,
+                enableGdprRestriction: true,
+                legalBasis: "legitimate_interest",
+                privacyPolicyUrl: "",
+                dpoContactEmail: "",
+            });
+        }
+
+        return NextResponse.json({
+            dataRetentionDays: row.dataRetentionDays ?? 2555,
+            auditRetentionDays: row.auditRetentionDays ?? 2555,
+            sessionTimeoutMinutes: row.sessionTimeoutMinutes ?? 15,
+            idleTimeoutMinutes: row.idleTimeoutMinutes ?? 30,
+            enableGdprExport: !!(row.enableGdprExport ?? 1),
+            enableGdprAnonymize: !!(row.enableGdprAnonymize ?? 1),
+            enableGdprRestriction: !!(row.enableGdprRestriction ?? 1),
+            legalBasis: row.legalBasis || "legitimate_interest",
+            privacyPolicyUrl: row.privacyPolicyUrl || "",
+            dpoContactEmail: row.dpoContactEmail || "",
+        });
+    } catch (error) {
+        if ((error as any)?.statusCode) return handleAuthError(error);
+        safeError("Error fetching compliance settings:", error);
+        return NextResponse.json({ error: "Failed to fetch compliance settings" }, { status: 500 });
+    }
+}
+
+// PUT /api/compliance/settings — Update compliance settings
+export async function PUT(request: NextRequest) {
+    try {
+        const ctx = await requireUser(request);
+        requirePermission(ctx, "compliance.manage");
+
+        const data = await request.json();
+        const now = new Date().toISOString();
+
+        const exists = db.select().from(complianceSettings).where(eq(complianceSettings.id, 1)).get();
+
+        const values = {
+            dataRetentionDays: data.dataRetentionDays ?? 2555,
+            auditRetentionDays: data.auditRetentionDays ?? 2555,
+            sessionTimeoutMinutes: data.sessionTimeoutMinutes ?? 15,
+            idleTimeoutMinutes: data.idleTimeoutMinutes ?? 30,
+            enableGdprExport: !!data.enableGdprExport,
+            enableGdprAnonymize: !!data.enableGdprAnonymize,
+            enableGdprRestriction: !!data.enableGdprRestriction,
+            legalBasis: data.legalBasis || "legitimate_interest",
+            privacyPolicyUrl: data.privacyPolicyUrl || null,
+            dpoContactEmail: data.dpoContactEmail || null,
+            updatedAt: now,
+        };
+
+        if (exists) {
+            db.update(complianceSettings).set(values).where(eq(complianceSettings.id, 1)).run();
+        } else {
+            db.insert(complianceSettings).values({ id: 1, ...values }).run();
+        }
+
+        await auditSuccess(auditEventFromContext(ctx, "compliance.settings.update", "config", {
+            metadata: { method: "PUT", route: "/api/compliance/settings" },
+        }));
+
+        return NextResponse.json({ success: true });
+    } catch (error) {
+        if ((error as any)?.statusCode) return handleAuthError(error);
+        safeError("Error updating compliance settings:", error);
+        return NextResponse.json({ error: "Failed to update compliance settings" }, { status: 500 });
+    }
+}

package/app/api/copilot/annotate/route.ts

@@ -0,0 +1,94 @@
+import { NextRequest, NextResponse } from "next/server";
+import { requireUser, requirePermission, handleAuthError } from "@/lib/security/authz";
+import { safeError } from "@/lib/security/phi-redaction";
+import { auditSuccess, auditEventFromContext } from "@/lib/security/audit";
+
+// POST /api/copilot/annotate — proxy to Python backend for structured annotation
+export async function POST(req: NextRequest) {
+    try {
+        const ctx = await requireUser(req);
+        requirePermission(ctx, "copilot.use");
+
+        const body = await req.json();
+        const {
+            message,
+            session_id,
+            patient_id,
+            report_id,
+            study_uid,
+            series_uid,
+            current_slice,
+            total_slices,
+            modality,
+            report_text,
+            viewport_image,
+        } = body;
+
+        if (!message) {
+            return NextResponse.json({ error: "Message is required" }, { status: 400 });
+        }
+
+        await auditSuccess(auditEventFromContext(ctx, "segmentation.request", "ai", {
+            patientId: patient_id || undefined,
+            metadata: { modality: modality || undefined },
+        }));
+
+        // Proxy to Python backend
+        const pythonUrl = "http://localhost:8001/copilot/annotate";
+        const pythonResponse = await fetch(pythonUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                message,
+                session_id: session_id || null,
+                patient_id: patient_id || null,
+                report_id: report_id || null,
+                study_uid: study_uid || null,
+                series_uid: series_uid || null,
+                current_slice: current_slice ?? null,
+                total_slices: total_slices ?? null,
+                modality: modality || null,
+                report_text: report_text || null,
+                viewport_image: viewport_image || null,
+            }),
+        });
+
+        if (!pythonResponse.ok) {
+            safeError("Copilot annotate backend error", { status: pythonResponse.status });
+            return NextResponse.json(
+                {
+                    reply: "⚠️ Could not reach the AI Copilot service for annotation.",
+                    viewer_actions: [],
+                    findings_summary: [],
+                },
+                { status: 200 }
+            );
+        }
+
+        const result = await pythonResponse.json();
+
+        return NextResponse.json({
+            reply: result.reply || "",
+            viewer_actions: result.viewer_actions || [],
+            findings_summary: result.findings_summary || [],
+            references: result.references || [],
+        });
+    } catch (error: any) {
+        if ((error as any)?.statusCode) return handleAuthError(error);
+
+        if (error?.cause?.code === "ECONNREFUSED" || error?.message?.includes("ECONNREFUSED")) {
+            return NextResponse.json({
+                reply: "⚠️ The AI Copilot backend is not running.",
+                viewer_actions: [],
+                findings_summary: [],
+            });
+        }
+
+        safeError("Copilot annotate error:", error);
+        return NextResponse.json({
+            reply: "⚠️ An unexpected error occurred.",
+            viewer_actions: [],
+            findings_summary: [],
+        });
+    }
+}

package/app/api/copilot/chat/route.ts

@@ -0,0 +1,238 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db, sqlite } from "@/db";
+import { requireUser, requirePermission, handleAuthError } from "@/lib/security/authz";
+import { safeError } from "@/lib/security/phi-redaction";
+import { auditSuccess, auditEventFromContext } from "@/lib/security/audit";
+
+// POST /api/copilot/chat — proxy to Python backend + save messages
+// Supports SSE streaming when 'x-stream: true' header is present
+export async function POST(req: NextRequest) {
+    try {
+        const ctx = await requireUser(req);
+        requirePermission(ctx, "copilot.use");
+
+        const body = await req.json();
+        const { message, patientContext, chatHistory, sessionId, study_context } = body;
+        const wantsStream = body.stream === true;
+
+        if (!message) {
+            return NextResponse.json({ error: "Message is required" }, { status: 400 });
+        }
+
+        const activeSessionId = sessionId || `session_${Date.now()}`;
+
+        // Save user message to SQLite
+        try {
+            const insertStmt = sqlite.prepare(
+                "INSERT INTO chat_messages (session_id, role, content, patient_id, created_at) VALUES (?, 'user', ?, ?, ?)"
+            );
+            insertStmt.run(
+                activeSessionId,
+                message,
+                patientContext?.patientId || null,
+                new Date().toISOString()
+            );
+        } catch (dbErr) {
+            safeError("Error saving user message:", dbErr);
+        }
+
+        // Audit the copilot message (without storing content)
+        await auditSuccess(auditEventFromContext(ctx, "copilot.message", "ai", {
+            patientId: patientContext?.patientId || undefined,
+            metadata: { purpose: "copilot" },
+        }));
+
+        // Sanitize incoming history
+        const sanitizedHistory = (chatHistory || []).map((msg: any) => ({
+            role: msg.role,
+            content: typeof msg.content === "string" 
+                ? msg.content 
+                : Array.isArray(msg.content)
+                    ? msg.content.map((c: any) => c.text || JSON.stringify(c)).join("\n")
+                    : JSON.stringify(msg.content)
+        }));
+
+        const requestBody = JSON.stringify({
+            message,
+            chat_history: sanitizedHistory,
+            patient_context: patientContext || {},
+            session_id: activeSessionId,
+            study_context: study_context || null,
+        });
+
+        // ─── SSE Streaming Mode ─────────────────────────────────────────
+        if (wantsStream) {
+            const pythonUrl = "http://localhost:8001/copilot/chat/stream";
+            let pythonResponse: Response;
+            
+            try {
+                pythonResponse = await fetch(pythonUrl, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: requestBody,
+                });
+            } catch (fetchErr: any) {
+                if (fetchErr?.cause?.code === 'ECONNREFUSED' || fetchErr?.message?.includes('ECONNREFUSED')) {
+                    return NextResponse.json({
+                        message: "⚠️ The AI Copilot backend is not running. Please start the Python service.",
+                        viewerActions: [],
+                        references: [],
+                    });
+                }
+                throw fetchErr;
+            }
+
+            if (!pythonResponse.ok || !pythonResponse.body) {
+                safeError("Python SSE backend error", { status: pythonResponse.status });
+                return NextResponse.json({
+                    message: "⚠️ Could not reach the AI Copilot streaming service.",
+                    viewerActions: [],
+                    references: [],
+                    sessionId: activeSessionId,
+                }, { status: 200 });
+            }
+
+            // Create a TransformStream to intercept the 'complete' event for DB saving
+            const reader = pythonResponse.body.getReader();
+            const decoder = new TextDecoder();
+            let sseBuffer = "";
+            
+            const stream = new ReadableStream({
+                async start(controller) {
+                    try {
+                        while (true) {
+                            const { done, value } = await reader.read();
+                            if (done) break;
+                            
+                            sseBuffer += decoder.decode(value, { stream: true });
+                            const segments = sseBuffer.split("\n\n");
+                            sseBuffer = segments.pop() || "";
+
+                            for (const segment of segments) {
+                                const line = segment.trim();
+                                if (!line.startsWith("data: ")) {
+                                    // Forward non-data lines as-is
+                                    controller.enqueue(new TextEncoder().encode(segment + "\n\n"));
+                                    continue;
+                                }
+
+                                try {
+                                    const data = JSON.parse(line.slice(6));
+                                    
+                                    if (data.type === "complete") {
+                                        // Enrich with sessionId and forward
+                                        const enriched = { ...data, sessionId: activeSessionId };
+                                        controller.enqueue(new TextEncoder().encode(
+                                            `data: ${JSON.stringify(enriched)}\n\n`
+                                        ));
+
+                                        // Save assistant message to SQLite
+                                        try {
+                                            const insertStmt = sqlite.prepare(
+                                                "INSERT INTO chat_messages (session_id, role, content, viewer_actions, references_data, patient_id, created_at) VALUES (?, 'assistant', ?, ?, ?, ?, ?)"
+                                            );
+                                            insertStmt.run(
+                                                activeSessionId,
+                                                data.message || "",
+                                                JSON.stringify(data.viewer_actions || []),
+                                                JSON.stringify(data.references || []),
+                                                patientContext?.patientId || null,
+                                                new Date().toISOString()
+                                            );
+                                        } catch (dbErr) {
+                                            safeError("Error saving streamed assistant message:", dbErr);
+                                        }
+                                    } else {
+                                        // Forward status/error events as-is
+                                        controller.enqueue(new TextEncoder().encode(segment + "\n\n"));
+                                    }
+                                } catch {
+                                    // Not valid JSON, forward as-is
+                                    controller.enqueue(new TextEncoder().encode(segment + "\n\n"));
+                                }
+                            }
+                        }
+                    } catch (err) {
+                        safeError("SSE stream error:", err);
+                    } finally {
+                        controller.close();
+                    }
+                },
+            });
+
+            return new Response(stream, {
+                headers: {
+                    "Content-Type": "text/event-stream",
+                    "Cache-Control": "no-cache",
+                    "Connection": "keep-alive",
+                    "X-Accel-Buffering": "no",
+                },
+            });
+        }
+
+        // ─── Non-Streaming Mode (original behavior) ─────────────────────
+        const pythonUrl = "http://localhost:8001/copilot/chat";
+        const pythonResponse = await fetch(pythonUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: requestBody,
+        });
+
+        if (!pythonResponse.ok) {
+            safeError("Python backend error", { status: pythonResponse.status });
+            return NextResponse.json(
+                {
+                    message: "⚠️ Could not reach the AI Copilot service. Make sure the Python backend is running (`npm run dev`).",
+                    viewer_actions: [],
+                    references: [],
+                    sessionId: activeSessionId,
+                },
+                { status: 200 }
+            );
+        }
+
+        const result = await pythonResponse.json();
+
+        // Save assistant message to SQLite
+        try {
+            const insertStmt = sqlite.prepare(
+                "INSERT INTO chat_messages (session_id, role, content, viewer_actions, references_data, patient_id, created_at) VALUES (?, 'assistant', ?, ?, ?, ?, ?)"
+            );
+            insertStmt.run(
+                activeSessionId,
+                result.message || "",
+                JSON.stringify(result.viewer_actions || []),
+                JSON.stringify(result.references || []),
+                patientContext?.patientId || null,
+                new Date().toISOString()
+            );
+        } catch (dbErr) {
+            safeError("Error saving assistant message:", dbErr);
+        }
+
+        return NextResponse.json({
+            message: result.message,
+            viewerActions: result.viewer_actions || [],
+            references: result.references || [],
+            sessionId: activeSessionId,
+        });
+    } catch (error: any) {
+        if ((error as any)?.statusCode) return handleAuthError(error);
+
+        // Check if it's a connection error
+        if (error?.cause?.code === 'ECONNREFUSED' || error?.message?.includes('ECONNREFUSED')) {
+            return NextResponse.json({
+                message: "⚠️ The AI Copilot backend is not running. Please start the Python service with `npm run dev` (it runs both Next.js and the AI service).",
+                viewerActions: [],
+                references: [],
+            });
+        }
+
+        safeError("Copilot chat error:", error);
+        return NextResponse.json({
+            message: "⚠️ An unexpected error occurred. Please try again.",
+            viewerActions: [],
+            references: [],
+        });
+    }
+}