synthos 0.8.0 → 0.10.0

package/src/service/useConnectorRoutes.ts

@@ -2,7 +2,7 @@ import { Application } from 'express';
 import { SynthOSConfig } from '../init';
 import { loadSettings, saveSettings } from '../settings';
 import {
-    CONNECTOR_REGISTRY,
+    getConnectorRegistry,
     ConnectorSummary,
     ConnectorDetail,
     ConnectorCallRequest,
@@ -15,13 +15,13 @@ export function useConnectorRoutes(config: SynthOSConfig, app: Application): voi
     // Also handles POST /api/connectors — Proxy call (see below)
     app.get('/api/connectors', async (req, res) => {
         try {
-            const settings = await loadSettings(config.pagesFolder);
+            const settings = await loadSettings(config);
             const connectors = settings.connectors ?? {};
 
             const categoryFilter = req.query.category as string | undefined;
             const idFilter = req.query.id as string | undefined;
 
-            const list: ConnectorSummary[] = CONNECTOR_REGISTRY
+            const list: ConnectorSummary[] = getConnectorRegistry(config.serviceConnectorsFolders)
                 .filter(def => {
                     if (categoryFilter && def.category !== categoryFilter) return false;
                     if (idFilter && def.id !== idFilter) return false;
@@ -54,13 +54,13 @@ export function useConnectorRoutes(config: SynthOSConfig, app: Application): voi
     app.get('/api/connectors/:id', async (req, res) => {
         try {
             const { id } = req.params;
-            const def = CONNECTOR_REGISTRY.find(d => d.id === id);
+            const def = getConnectorRegistry(config.serviceConnectorsFolders).find(d => d.id === id);
             if (!def) {
                 res.status(404).json({ error: `Connector "${id}" not found` });
                 return;
             }
 
-            const settings = await loadSettings(config.pagesFolder);
+            const settings = await loadSettings(config);
             const cfg = (settings.connectors ?? {})[id];
             const isOAuth = def.authStrategy === 'oauth2';
             const oauthCfg = cfg as ConnectorOAuthConfig | undefined;
@@ -88,13 +88,13 @@ export function useConnectorRoutes(config: SynthOSConfig, app: Application): voi
     app.post('/api/connectors/:id', async (req, res) => {
         try {
             const { id } = req.params;
-            const def = CONNECTOR_REGISTRY.find(d => d.id === id);
+            const def = getConnectorRegistry(config.serviceConnectorsFolders).find(d => d.id === id);
             if (!def) {
                 res.status(404).json({ error: `Connector "${id}" not found` });
                 return;
             }
 
-            const settings = await loadSettings(config.pagesFolder);
+            const settings = await loadSettings(config);
             const existing = settings.connectors ?? {};
 
             if (def.authStrategy === 'oauth2') {
@@ -121,7 +121,7 @@ export function useConnectorRoutes(config: SynthOSConfig, app: Application): voi
                 }
 
                 const updated = { ...existing, [id]: entry };
-                await saveSettings(config.pagesFolder, { connectors: updated });
+                await saveSettings(config, { connectors: updated });
             } else {
                 const { apiKey, enabled } = req.body;
                 const resolvedKey = (typeof apiKey === 'string' && apiKey.length > 0)
@@ -132,7 +132,7 @@ export function useConnectorRoutes(config: SynthOSConfig, app: Application): voi
                     ...existing,
                     [id]: { apiKey: resolvedKey, enabled: !!enabled }
                 };
-                await saveSettings(config.pagesFolder, { connectors: updated });
+                await saveSettings(config, { connectors: updated });
             }
 
             res.json({ saved: true });
@@ -146,13 +146,13 @@ export function useConnectorRoutes(config: SynthOSConfig, app: Application): voi
     app.delete('/api/connectors/:id', async (req, res) => {
         try {
             const { id } = req.params;
-            const settings = await loadSettings(config.pagesFolder);
+            const settings = await loadSettings(config);
             const existing = settings.connectors ?? {};
 
             const updated = { ...existing };
             delete updated[id];
 
-            await saveSettings(config.pagesFolder, { connectors: updated });
+            await saveSettings(config, { connectors: updated });
             res.json({ deleted: true });
         } catch (err: unknown) {
             console.error(err);
@@ -164,13 +164,13 @@ export function useConnectorRoutes(config: SynthOSConfig, app: Application): voi
     app.get('/api/connectors/:id/authorize', async (req, res) => {
         try {
             const { id } = req.params;
-            const def = CONNECTOR_REGISTRY.find(d => d.id === id);
+            const def = getConnectorRegistry(config.serviceConnectorsFolders).find(d => d.id === id);
             if (!def || def.authStrategy !== 'oauth2') {
                 res.status(400).json({ error: `Connector "${id}" is not an OAuth2 connector` });
                 return;
             }
 
-            const settings = await loadSettings(config.pagesFolder);
+            const settings = await loadSettings(config);
             const cfg = (settings.connectors ?? {})[id] as ConnectorOAuthConfig | undefined;
             if (!cfg?.clientId || !cfg?.clientSecret) {
                 res.status(400).json({ error: 'Client ID and Client Secret must be saved before authorizing' });
@@ -214,13 +214,13 @@ export function useConnectorRoutes(config: SynthOSConfig, app: Application): voi
             const state = JSON.parse(stateRaw) as { connector: string };
             const connectorId = state.connector;
 
-            const def = CONNECTOR_REGISTRY.find(d => d.id === connectorId);
+            const def = getConnectorRegistry(config.serviceConnectorsFolders).find(d => d.id === connectorId);
             if (!def || def.authStrategy !== 'oauth2') {
                 res.status(400).json({ error: `Unknown OAuth2 connector: ${connectorId}` });
                 return;
             }
 
-            const settings = await loadSettings(config.pagesFolder);
+            const settings = await loadSettings(config);
             const cfg = (settings.connectors ?? {})[connectorId] as ConnectorOAuthConfig | undefined;
             if (!cfg?.clientId || !cfg?.clientSecret) {
                 res.status(400).json({ error: 'Client credentials not found' });
@@ -307,7 +307,7 @@ export function useConnectorRoutes(config: SynthOSConfig, app: Application): voi
                     enabled: true
                 }
             };
-            await saveSettings(config.pagesFolder, { connectors: updated });
+            await saveSettings(config, { connectors: updated });
 
             res.redirect(`/settings?tab=connectors&connected=${encodeURIComponent(connectorId)}`);
         } catch (err: unknown) {
@@ -326,13 +326,13 @@ export function useConnectorRoutes(config: SynthOSConfig, app: Application): voi
                 return;
             }
 
-            const def = CONNECTOR_REGISTRY.find(d => d.id === request.connector);
+            const def = getConnectorRegistry(config.serviceConnectorsFolders).find(d => d.id === request.connector);
             if (!def) {
                 res.status(404).json({ error: `Connector "${request.connector}" not found` });
                 return;
             }
 
-            const settings = await loadSettings(config.pagesFolder);
+            const settings = await loadSettings(config);
             const cfg = (settings.connectors ?? {})[request.connector];
 
             if (def.authStrategy === 'oauth2') {

package/src/service/useDataRoutes.ts

@@ -1,6 +1,5 @@
 import { Application, Response } from 'express';
 import { SynthOSConfig } from "../init";
-import { checkIfExists, deleteFile, ensureFolderExists, listFiles, loadFile, saveFile } from "../files";
 import path from "path";
 import { v4 } from "uuid";
 import { clearCachedScripts } from '../scripts';
@@ -17,19 +16,20 @@ export function useDataRoutes(config: SynthOSConfig, app: Application): void {
 // ---------------------------------------------------------------------------
 
 async function handleList(config: SynthOSConfig, page: string, table: string, query: Record<string, any>, res: Response): Promise<void> {
+    const sp = config.storageProvider;
     const folder = tableFolder(config, page, table);
-    if (!(await checkIfExists(folder))) {
+    if (!(await sp.checkIfExists(folder))) {
         res.status(404).json({ error: 'table_not_found', page, table });
         return;
     }
 
-    const ids = (await listFiles(folder)).filter(f => f.endsWith('.json')).map(f => f.replace('.json', ''));
+    const ids = (await sp.listFiles(folder)).filter(f => f.endsWith('.json')).map(f => f.replace('.json', ''));
 
     const rows: Record<string, any>[] = [];
     for (const id of ids) {
         const file = recordFile(folder, id);
         try {
-            const row = JSON.parse(await loadFile(file));
+            const row = JSON.parse(await sp.loadFile(file));
             row.id = id;
             rows.push(row);
         } catch (err: unknown) {
@@ -49,15 +49,16 @@ async function handleList(config: SynthOSConfig, page: string, table: string, qu
 }
 
 async function handleGet(config: SynthOSConfig, page: string, table: string, id: string, res: Response): Promise<void> {
+    const sp = config.storageProvider;
     const folder = tableFolder(config, page, table);
-    if (!(await checkIfExists(folder))) {
+    if (!(await sp.checkIfExists(folder))) {
         res.status(404).json({ error: 'table_not_found', page, table });
         return;
     }
 
     const file = recordFile(folder, id);
     try {
-        const row = JSON.parse(await loadFile(file));
+        const row = JSON.parse(await sp.loadFile(file));
         row.id = id;
         res.json(row);
     } catch (err: unknown) {
@@ -66,13 +67,14 @@ async function handleGet(config: SynthOSConfig, page: string, table: string, id:
 }
 
 async function handleUpsert(config: SynthOSConfig, page: string, table: string, body: any, res: Response): Promise<void> {
+    const sp = config.storageProvider;
     const id = body.id ?? v4();
     const folder = tableFolder(config, page, table);
     const file = recordFile(folder, id);
     try {
         const row = { ...body, id };
-        await ensureFolderExists(folder);
-        await saveFile(file, JSON.stringify(row, null, 4));
+        await sp.ensureFolderExists(folder);
+        await sp.saveFile(file, JSON.stringify(row, null, 4));
         if (table === 'scripts') {
             clearCachedScripts();
         }
@@ -84,11 +86,12 @@ async function handleUpsert(config: SynthOSConfig, page: string, table: string,
 }
 
 async function handleDelete(config: SynthOSConfig, page: string, table: string, id: string, res: Response): Promise<void> {
+    const sp = config.storageProvider;
     const folder = tableFolder(config, page, table);
     const file = recordFile(folder, id);
     try {
-        if (await checkIfExists(file)) {
-            await deleteFile(file);
+        if (await sp.checkIfExists(file)) {
+            await sp.deleteFile(file);
             if (table === 'scripts') {
                 clearCachedScripts();
             }

package/src/service/useFileRoutes.ts

@@ -0,0 +1,128 @@
+import { Application } from 'express';
+import express from 'express';
+import path from 'path';
+import { SynthOSConfig } from '../init';
+
+export function useFileRoutes(config: SynthOSConfig, app: Application): void {
+    const sp = config.storageProvider;
+
+    // List files in a page's files/ folder
+    app.get('/api/files/:page', async (req, res) => {
+        try {
+            const folder = filesFolder(config, req.params.page);
+            if (!(await sp.checkIfExists(folder))) {
+                res.json({ files: [] });
+                return;
+            }
+
+            const entries = await sp.listFiles(folder);
+            const files: { name: string; size: number }[] = [];
+            for (const entry of entries) {
+                const stat = await sp.stat(path.join(folder, entry));
+                if (stat.isFile) {
+                    files.push({ name: entry, size: stat.size });
+                }
+            }
+            res.json({ files });
+        } catch (err: unknown) {
+            console.error(err);
+            res.status(500).json({ error: (err as Error).message });
+        }
+    });
+
+    // Download/serve a specific file
+    app.get('/api/files/:page/:filename', async (req, res) => {
+        try {
+            const filePath = safeFilePath(config, req.params.page, req.params.filename);
+            if (!filePath) {
+                res.status(400).json({ error: 'Invalid filename' });
+                return;
+            }
+
+            if (!(await sp.checkIfExists(filePath))) {
+                res.status(404).json({ error: 'File not found' });
+                return;
+            }
+
+            res.type(path.extname(req.params.filename));
+            sp.createReadStream(filePath).pipe(res);
+        } catch (err: unknown) {
+            console.error(err);
+            res.status(500).json({ error: (err as Error).message });
+        }
+    });
+
+    // Upload a file (raw body + x-filename header)
+    app.post('/api/files/:page', express.raw({ type: '*/*', limit: '50mb' }), async (req, res) => {
+        try {
+            const filename = req.headers['x-filename'] as string | undefined;
+            if (!filename || filename.trim().length === 0) {
+                res.status(400).json({ error: 'x-filename header is required' });
+                return;
+            }
+
+            const filePath = safeFilePath(config, req.params.page, filename);
+            if (!filePath) {
+                res.status(400).json({ error: 'Invalid filename' });
+                return;
+            }
+
+            const folder = filesFolder(config, req.params.page);
+            await sp.ensureFolderExists(folder);
+            await sp.saveBuffer(filePath, req.body as Buffer);
+
+            const stat = await sp.stat(filePath);
+            res.status(201).json({ name: filename, size: stat.size });
+        } catch (err: unknown) {
+            console.error(err);
+            res.status(500).json({ error: (err as Error).message });
+        }
+    });
+
+    // Delete a file
+    app.delete('/api/files/:page/:filename', async (req, res) => {
+        try {
+            const filePath = safeFilePath(config, req.params.page, req.params.filename);
+            if (!filePath) {
+                res.status(400).json({ error: 'Invalid filename' });
+                return;
+            }
+
+            if (!(await sp.checkIfExists(filePath))) {
+                res.status(404).json({ error: 'File not found' });
+                return;
+            }
+
+            await sp.deleteFile(filePath);
+            res.json({ deleted: true });
+        } catch (err: unknown) {
+            console.error(err);
+            res.status(500).json({ error: (err as Error).message });
+        }
+    });
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function filesFolder(config: SynthOSConfig, page: string): string {
+    return path.join(config.pagesFolder, 'pages', page, 'files');
+}
+
+/**
+ * Resolve a filename inside the page's files/ folder with path-traversal protection.
+ * Returns the absolute path if safe, or null if the filename is invalid.
+ */
+function safeFilePath(config: SynthOSConfig, page: string, filename: string): string | null {
+    // Reject obviously bad filenames
+    if (!filename || filename.includes('..') || filename.includes('/') || filename.includes('\\')) {
+        return null;
+    }
+    const folder = filesFolder(config, page);
+    const resolved = path.resolve(folder, filename);
+    if (!resolved.startsWith(path.resolve(folder))) {
+        return null;
+    }
+    return resolved;
+}