@realtimex/folio 0.1.2

package/api/src/routes/accounts.ts

@@ -0,0 +1,142 @@
+import { Router } from "express";
+import axios from "axios";
+import { asyncHandler } from "../middleware/errorHandler.js";
+import { optionalAuth } from "../middleware/auth.js";
+
+const router = Router();
+
+router.use(optionalAuth);
+
+// GET /api/accounts
+router.get(
+    "/",
+    asyncHandler(async (req, res) => {
+        if (!req.user || !req.supabase) {
+            res.status(401).json({ error: "Authentication required" });
+            return;
+        }
+
+        const { data, error } = await req.supabase
+            .from("integrations")
+            .select("id, provider, is_enabled, created_at, updated_at")
+            .eq("user_id", req.user.id);
+
+        if (error) {
+            res.status(500).json({ error: error.message });
+            return;
+        }
+
+        // Map to expected frontend format
+        const accounts = data?.map(integration => ({
+            id: integration.id,
+            email_address: integration.provider, // Just for UI display
+            provider: integration.provider,
+            is_connected: integration.is_enabled,
+            sync_enabled: integration.is_enabled,
+            created_at: integration.created_at,
+            updated_at: integration.updated_at
+        })) || [];
+
+        res.json({ accounts });
+    })
+);
+
+// POST /api/accounts/google-drive/auth-url
+router.post(
+    "/google-drive/auth-url",
+    asyncHandler(async (req, res) => {
+        const { clientId } = req.body;
+        if (!clientId) {
+            res.status(400).json({ error: "Missing clientId" });
+            return;
+        }
+
+        const redirectUri = "urn:ietf:wg:oauth:2.0:oob"; // Desktop/local app flow
+
+        // We request drive (full access) to allow downloading and uploading (moving) files
+        const params = new URLSearchParams({
+            client_id: clientId,
+            redirect_uri: redirectUri,
+            response_type: "code",
+            scope: "https://www.googleapis.com/auth/drive",
+            access_type: "offline",
+            prompt: "consent",
+        });
+
+        const authUrl = `https://accounts.google.com/o/oauth2/v2/auth?${params.toString()}`;
+        res.json({ authUrl });
+    })
+);
+
+// POST /api/accounts/google-drive/connect
+router.post(
+    "/google-drive/connect",
+    asyncHandler(async (req, res) => {
+        if (!req.supabase || !req.user) {
+            res.status(401).json({ error: "Authentication required" });
+            return;
+        }
+
+        const { authCode, clientId, clientSecret } = req.body;
+        if (!authCode || !clientId || !clientSecret) {
+            res.status(400).json({ error: "Missing authCode, clientId, or clientSecret" });
+            return;
+        }
+
+        try {
+            // Exchange code for tokens
+            const tokenResponse = await axios.post("https://oauth2.googleapis.com/token", null, {
+                params: {
+                    client_id: clientId,
+                    client_secret: clientSecret,
+                    code: authCode,
+                    grant_type: "authorization_code",
+                    redirect_uri: "urn:ietf:wg:oauth:2.0:oob",
+                },
+            });
+
+            const { access_token, refresh_token, expires_in } = tokenResponse.data;
+
+            const credentials = {
+                access_token,
+                refresh_token,
+                expires_at: Date.now() + expires_in * 1000,
+                client_id: clientId,
+                client_secret: clientSecret
+            };
+
+            // Save to integrations
+            const { data: integration, error } = await req.supabase
+                .from("integrations")
+                .upsert(
+                    {
+                        user_id: req.user.id,
+                        provider: "google_drive",
+                        credentials,
+                        is_enabled: true
+                    },
+                    { onConflict: "user_id,provider" }
+                )
+                .select()
+                .single();
+
+            if (error) {
+                throw new Error(`Database error: ${error.message}`);
+            }
+
+            res.json({ success: true, account: integration });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        } catch (error: any) {
+            const errorMessage = error.response?.data?.error_description
+                || error.response?.data?.error
+                || error.message
+                || "Failed to connect Google Drive";
+
+            res.status(500).json({
+                error: errorMessage
+            });
+        }
+    })
+);
+
+export default router;

package/api/src/routes/baseline-config.ts

@@ -0,0 +1,124 @@
+import { Router } from "express";
+import { asyncHandler } from "../middleware/errorHandler.js";
+import { optionalAuth } from "../middleware/auth.js";
+import { BaselineConfigService, DEFAULT_BASELINE_FIELDS } from "../services/BaselineConfigService.js";
+import { PolicyEngine } from "../services/PolicyEngine.js";
+
+const router = Router();
+router.use(optionalAuth);
+
+// GET /api/baseline-config
+// Returns the active config. If none exists, returns the built-in defaults
+// with id: null so the UI can distinguish "never saved" from "saved and active".
+router.get(
+    "/",
+    asyncHandler(async (req, res) => {
+        if (!req.supabase || !req.user) {
+            res.status(401).json({ success: false, error: "Authentication required" });
+            return;
+        }
+        const config = await BaselineConfigService.getActive(req.supabase, req.user.id);
+        res.json({
+            success: true,
+            config,
+            defaults: DEFAULT_BASELINE_FIELDS,
+        });
+    })
+);
+
+// GET /api/baseline-config/history
+// Returns all saved versions for the user, newest first.
+router.get(
+    "/history",
+    asyncHandler(async (req, res) => {
+        if (!req.supabase || !req.user) {
+            res.status(401).json({ success: false, error: "Authentication required" });
+            return;
+        }
+        const history = await BaselineConfigService.list(req.supabase, req.user.id);
+        res.json({ success: true, history });
+    })
+);
+
+// POST /api/baseline-config
+// Save a new version. Body: { context?, fields[], activate? }
+// Always creates a new row — never mutates an existing version.
+router.post(
+    "/",
+    asyncHandler(async (req, res) => {
+        if (!req.supabase || !req.user) {
+            res.status(401).json({ success: false, error: "Authentication required" });
+            return;
+        }
+        const { context, fields, activate = true } = req.body;
+        if (!Array.isArray(fields) || fields.length === 0) {
+            res.status(400).json({ success: false, error: "fields array is required and must not be empty" });
+            return;
+        }
+        const config = await BaselineConfigService.save(
+            req.supabase,
+            req.user.id,
+            { context, fields },
+            activate
+        );
+        res.status(201).json({ success: true, config });
+    })
+);
+
+// POST /api/baseline-config/:id/activate
+// Activate a previously saved version.
+router.post(
+    "/:id/activate",
+    asyncHandler(async (req, res) => {
+        if (!req.supabase || !req.user) {
+            res.status(401).json({ success: false, error: "Authentication required" });
+            return;
+        }
+        const ok = await BaselineConfigService.activate(
+            req.supabase,
+            req.user.id,
+            req.params.id as string
+        );
+        if (!ok) {
+            res.status(404).json({ success: false, error: "Config version not found" });
+            return;
+        }
+        res.json({ success: true });
+    })
+);
+
+// POST /api/baseline-config/suggest
+// Body: { description, provider?, model? }
+// Returns a draft { context, fields[] } for the user to review before saving.
+router.post(
+    "/suggest",
+    asyncHandler(async (req, res) => {
+        if (!req.supabase || !req.user) {
+            res.status(401).json({ success: false, error: "Authentication required" });
+            return;
+        }
+        const { description, provider, model } = req.body;
+        if (!description || typeof description !== "string") {
+            res.status(400).json({ success: false, error: "description is required" });
+            return;
+        }
+
+        // Pass current active fields so the LLM avoids duplicating them
+        const activeConfig = await BaselineConfigService.getActive(req.supabase, req.user.id);
+        const currentFields = activeConfig?.fields ?? DEFAULT_BASELINE_FIELDS;
+
+        const result = await PolicyEngine.suggestBaseline(description, currentFields, {
+            provider,
+            model,
+            userId: req.user.id,
+            supabase: req.supabase,
+        });
+        if (!result.suggestion) {
+            res.status(503).json({ success: false, error: result.error ?? "Suggestion failed. SDK may be unavailable." });
+            return;
+        }
+        res.json({ success: true, suggestion: result.suggestion });
+    })
+);
+
+export default router;

package/api/src/routes/chat.ts

@@ -0,0 +1,154 @@
+import { Router } from "express";
+import { asyncHandler } from "../middleware/errorHandler.js";
+import { optionalAuth } from "../middleware/auth.js";
+import { ChatService } from "../services/ChatService.js";
+
+const router = Router();
+
+interface PostMessageBody {
+    sessionId?: string;
+    content?: string;
+}
+
+// All chat routes require authentication
+router.use(optionalAuth);
+
+// GET /api/chat/sessions
+router.get(
+    "/sessions",
+    asyncHandler(async (req, res) => {
+        if (!req.supabase || !req.user) {
+            res.status(401).json({ success: false, error: "Authentication required" });
+            return;
+        }
+
+        const { data: sessions, error } = await req.supabase
+            .from("chat_sessions")
+            .select("*")
+            .eq("user_id", req.user.id)
+            .order("updated_at", { ascending: false });
+
+        if (error) {
+            res.status(500).json({ success: false, error: error.message });
+            return;
+        }
+
+        res.json({ success: true, sessions });
+    })
+);
+
+// POST /api/chat/sessions
+router.post(
+    "/sessions",
+    asyncHandler(async (req, res) => {
+        if (!req.supabase || !req.user) {
+            res.status(401).json({ success: false, error: "Authentication required" });
+            return;
+        }
+
+        const { data: session, error } = await req.supabase
+            .from("chat_sessions")
+            .insert({ user_id: req.user.id, title: "New Conversation" })
+            .select("*")
+            .single();
+
+        if (error) {
+            res.status(500).json({ success: false, error: error.message });
+            return;
+        }
+
+        res.status(201).json({ success: true, session });
+    })
+);
+
+// GET /api/chat/sessions/:id/messages
+router.get(
+    "/sessions/:id/messages",
+    asyncHandler(async (req, res) => {
+        if (!req.supabase || !req.user) {
+            res.status(401).json({ success: false, error: "Authentication required" });
+            return;
+        }
+
+        // Verify session belongs to user
+        const { data: sessionData } = await req.supabase
+            .from("chat_sessions")
+            .select("id")
+            .eq("id", req.params["id"] as string)
+            .eq("user_id", req.user.id)
+            .maybeSingle();
+
+        if (!sessionData) {
+            res.status(404).json({ success: false, error: "Session not found" });
+            return;
+        }
+
+        const { data: messages, error } = await req.supabase
+            .from("chat_messages")
+            .select("*")
+            .eq("session_id", req.params["id"] as string)
+            .eq("user_id", req.user.id)
+            .order("created_at", { ascending: true });
+
+        if (error) {
+            res.status(500).json({ success: false, error: error.message });
+            return;
+        }
+
+        res.json({ success: true, messages });
+    })
+);
+
+// POST /api/chat/message
+router.post(
+    "/message",
+    asyncHandler(async (req, res) => {
+        if (!req.supabase || !req.user) {
+            res.status(401).json({ success: false, error: "Authentication required" });
+            return;
+        }
+
+        const { sessionId, content } = (req.body ?? {}) as PostMessageBody;
+        const normalizedSessionId = typeof sessionId === "string" ? sessionId : "";
+        const trimmedContent = typeof content === "string" ? content.trim() : "";
+        if (!normalizedSessionId || !trimmedContent) {
+            res.status(400).json({ success: false, error: "Missing sessionId or content" });
+            return;
+        }
+
+        // Verify session belongs to user
+        const { data: sessionData } = await req.supabase
+            .from("chat_sessions")
+            .select("id")
+            .eq("id", normalizedSessionId)
+            .eq("user_id", req.user.id)
+            .maybeSingle();
+
+        if (!sessionData) {
+            res.status(404).json({ success: false, error: "Session not found" });
+            return;
+        }
+
+        // Dynamically name session if it's the first message
+        const { count } = await req.supabase
+            .from("chat_messages")
+            .select("*", { count: 'exact', head: true })
+            .eq("session_id", normalizedSessionId)
+            .eq("user_id", req.user.id);
+
+        if (count === 0 && trimmedContent.length > 3) {
+            const title = trimmedContent.substring(0, 30) + (trimmedContent.length > 30 ? "..." : "");
+            await req.supabase.from("chat_sessions").update({ title }).eq("id", normalizedSessionId);
+        }
+
+        try {
+            const aiMessage = await ChatService.handleMessage(normalizedSessionId, req.user.id, trimmedContent, req.supabase);
+            res.json({ success: true, message: aiMessage });
+        } catch (error) {
+            const message = error instanceof Error ? error.message : "Failed to process message";
+            res.status(500).json({ success: false, error: message });
+        }
+    })
+);
+
+export default router;

package/api/src/routes/health.ts

@@ -0,0 +1,61 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { createClient } from "@supabase/supabase-js";
+import { Router } from "express";
+
+import { config } from "../config/index.js";
+import { SDKService } from "../services/SDKService.js";
+import { getServerSupabase, getSupabaseConfigFromHeaders } from "../services/supabase.js";
+
+const router = Router();
+
+let version = "0.0.0";
+try {
+  const pkgPath = join(config.packageRoot, "package.json");
+  version = JSON.parse(readFileSync(pkgPath, "utf8")).version;
+} catch {
+  // fallback stays at default
+}
+
+router.get("/", async (req, res) => {
+  let supabase = getServerSupabase();
+
+  if (!supabase) {
+    const headerConfig = getSupabaseConfigFromHeaders(req.headers as Record<string, unknown>);
+    if (headerConfig) {
+      supabase = createClient(headerConfig.url, headerConfig.anonKey, {
+        auth: {
+          autoRefreshToken: false,
+          persistSession: false
+        }
+      });
+    }
+  }
+
+  let databaseStatus = "not_configured";
+
+  if (supabase) {
+    try {
+      const { error } = await supabase.from("user_settings").select("id").limit(1);
+      databaseStatus = error ? "error" : "connected";
+    } catch {
+      databaseStatus = "error";
+    }
+  }
+
+  const sdkAvailable = await SDKService.isAvailable();
+
+  res.json({
+    status: "healthy",
+    timestamp: new Date().toISOString(),
+    version,
+    environment: config.nodeEnv,
+    services: {
+      database: databaseStatus,
+      realtimeXSdk: sdkAvailable ? "available" : "unavailable"
+    }
+  });
+});
+
+export default router;

package/api/src/routes/index.ts

@@ -0,0 +1,35 @@
+import { Router } from "express";
+
+import healthRoutes from "./health.js";
+import migrateRoutes from "./migrate.js";
+import processingRoutes from "./processing.js";
+import setupRoutes from "./setup.js";
+import ttsRoutes from "./tts.js";
+import sdkRoutes from "./sdk.js";
+import policiesRoutes from "./policies.js";
+import ingestionsRoutes from "./ingestions.js";
+import baselineConfigRoutes from "./baseline-config.js";
+import accountsRoutes from "./accounts.js";
+import settingsRoutes from "./settings.js";
+import rulesRoutes from "./rules.js";
+import chatRoutes from "./chat.js";
+import statsRoutes from "./stats.js";
+
+const router = Router();
+
+router.use("/health", healthRoutes);
+router.use("/migrate", migrateRoutes);
+router.use("/setup", setupRoutes);
+router.use("/processing", processingRoutes);
+router.use("/tts", ttsRoutes);
+router.use("/sdk", sdkRoutes);
+router.use("/policies", policiesRoutes);
+router.use("/ingestions", ingestionsRoutes);
+router.use("/baseline-config", baselineConfigRoutes);
+router.use("/accounts", accountsRoutes);
+router.use("/settings", settingsRoutes);
+router.use("/rules", rulesRoutes);
+router.use("/chat", chatRoutes);
+router.use("/stats", statsRoutes);
+
+export default router;