synthos 0.7.2 → 0.9.0

package/src/service/useApiRoutes.ts

@@ -1,17 +1,21 @@
 import path from "path";
-import { listPages, loadPageMetadata, PageMetadata, savePageMetadata, REQUIRED_PAGES, deletePage, copyPage, loadPageState, savePageState, PAGE_VERSION } from "../pages";
-import { checkIfExists, copyFile, deleteFile, loadFile } from "../files";
+import fs from "fs/promises";
+import AdmZip from "adm-zip";
+import { listPages, loadPageMetadata, PageMetadata, savePageMetadata, deletePage, copyPage, loadPageState, savePageState, clearVersions, PAGE_VERSION } from "../pages";
+import { checkIfExists, copyFile, copyFolderRecursive, deleteFile, ensureFolderExists, findFileInFolders, listFolders, loadFile } from "../files";
 import {getModelEntry, loadSettings, saveSettings, ServicesConfig } from "../settings";
 import { Application } from 'express';
+import express from 'express';
 import { SynthOSConfig } from "../init";
 import { createCompletePrompt, PROVIDERS } from "./createCompletePrompt";
 import { generateDefaultImage, generateImage } from "./generateImage";
-import { chainOfThought } from "agentm-core";
+import { chainOfThought } from "../models";
 import { requiresSettings } from "./requiresSettings";
 import { executeScript } from "../scripts";
-import { listThemes, loadTheme, loadThemeInfo } from "../themes";
+import { listThemes, loadTheme, loadThemeInfo, loadThemeVersion } from "../themes";
 import { migratePage } from "../migrations";
 import { loadPageWithFallback } from "./usePageRoutes";
+import { Customizer } from "../customizer";
 
 // ---------------------------------------------------------------------------
 // Service registry
@@ -45,18 +49,108 @@ const SERVICE_REGISTRY: ServiceDefinition[] = [
     }
 ];
 
-export function useApiRoutes(config: SynthOSConfig, app: Application): void {
+export function useApiRoutes(config: SynthOSConfig, app: Application, customizer?: Customizer): void {
     // List pages
     app.get('/api/pages', async (req, res) => {
-        const pages = await listPages(config.pagesFolder, config.requiredPagesFolder);
+        const pages = await listPages(config.pagesFolder, config.requiredPagesFolders);
         res.json(pages);
     });
 
+    // Import a page from a zip file
+    app.post('/api/pages/import', express.raw({ type: 'application/zip', limit: '50mb' }), async (req, res) => {
+        try {
+            const zipBuffer = req.body as Buffer;
+            if (!zipBuffer || zipBuffer.length === 0) {
+                res.status(400).json({ error: 'Empty request body' });
+                return;
+            }
+
+            let zip: AdmZip;
+            try {
+                zip = new AdmZip(zipBuffer);
+            } catch {
+                res.status(400).json({ error: 'Invalid zip file' });
+                return;
+            }
+
+            const entries = zip.getEntries();
+            if (entries.length === 0) {
+                res.status(400).json({ error: 'Zip file is empty' });
+                return;
+            }
+
+            // Determine top-level folder name and validate structure
+            const firstEntry = entries[0].entryName;
+            const topFolder = firstEntry.split('/')[0];
+            const hasPageHtml = entries.some(e => e.entryName === `${topFolder}/page.html`);
+            if (!hasPageHtml) {
+                res.status(400).json({ error: 'Zip must contain a <folder>/page.html entry' });
+                return;
+            }
+
+            // Sanitize page name from folder name
+            let pageName = topFolder.toLowerCase().replace(/[^a-z0-9_-]/g, '');
+            if (!pageName) {
+                res.status(400).json({ error: 'Could not derive a valid page name from zip contents' });
+                return;
+            }
+
+            // Auto-append _1, _2, etc. on name conflicts
+            let finalName = pageName;
+            let suffix = 0;
+            while (await checkIfExists(path.join(config.pagesFolder, 'pages', finalName))) {
+                suffix++;
+                finalName = `${pageName}_${suffix}`;
+            }
+
+            const targetDir = path.join(config.pagesFolder, 'pages', finalName);
+            await ensureFolderExists(targetDir);
+
+            // Extract entries with path traversal protection
+            for (const entry of entries) {
+                if (entry.isDirectory) continue;
+
+                // Strip the top-level folder prefix to get relative path
+                const relativePath = entry.entryName.substring(topFolder.length + 1);
+                if (!relativePath) continue;
+
+                const resolvedPath = path.resolve(targetDir, relativePath);
+                if (!resolvedPath.startsWith(path.resolve(targetDir))) {
+                    // Path traversal — skip this entry
+                    continue;
+                }
+
+                await ensureFolderExists(path.dirname(resolvedPath));
+                await fs.writeFile(resolvedPath, entry.getData());
+            }
+
+            // Update metadata: set createdDate and lastModified to now
+            const now = new Date().toISOString();
+            const existingMeta = await loadPageMetadata(config.pagesFolder, finalName);
+            const metadata: PageMetadata = {
+                title: existingMeta?.title ?? '',
+                categories: existingMeta?.categories ?? [],
+                pinned: existingMeta?.pinned ?? false,
+                showInAll: existingMeta?.showInAll ?? true,
+                createdDate: now,
+                lastModified: now,
+                pageVersion: existingMeta?.pageVersion ?? PAGE_VERSION,
+                mode: existingMeta?.mode ?? 'unlocked',
+            };
+            await savePageMetadata(config.pagesFolder, finalName, metadata);
+
+            res.status(201).json({ name: finalName, title: metadata.title });
+        } catch (err: unknown) {
+            console.error(err);
+            res.status(500).json({ error: (err as Error).message });
+        }
+    });
+
     // Get page metadata
     app.get('/api/pages/:name', async (req, res) => {
         try {
             const { name } = req.params;
-            const metadata = await loadPageMetadata(config.pagesFolder, name, config.requiredPagesFolder);
+            const metadata = await loadPageMetadata(config.pagesFolder, name, config.requiredPagesFolders);
             if (metadata) {
                 res.json(metadata);
             } else {
@@ -107,7 +201,7 @@ export function useApiRoutes(config: SynthOSConfig, app: Application): void {
             }
 
             // Load existing metadata (or defaults)
-            const existing = await loadPageMetadata(config.pagesFolder, name, config.requiredPagesFolder);
+            const existing = await loadPageMetadata(config.pagesFolder, name, config.requiredPagesFolders);
             const metadata: PageMetadata = {
                 title: existing?.title ?? '',
                 categories: existing?.categories ?? [],
@@ -133,7 +227,11 @@ export function useApiRoutes(config: SynthOSConfig, app: Application): void {
             if (metadata.mode !== 'locked') {
                 const userPagePath = path.join(config.pagesFolder, 'pages', name, 'page.html');
                 if (!(await checkIfExists(userPagePath))) {
-                    const html = await loadPageState(config.requiredPagesFolder, name, false);
+                    let html: string | undefined;
+                    for (const folder of config.requiredPagesFolders) {
+                        html = await loadPageState(folder, name);
+                        if (html) break;
+                    }
                     if (html) {
                         await savePageState(config.pagesFolder, name, html);
                     }
@@ -159,7 +257,7 @@ export function useApiRoutes(config: SynthOSConfig, app: Application): void {
             }
 
             // Load existing metadata (user override → fallback .json → defaults)
-            let metadata = await loadPageMetadata(config.pagesFolder, name, config.requiredPagesFolder);
+            let metadata = await loadPageMetadata(config.pagesFolder, name, config.requiredPagesFolders);
             if (!metadata) {
                 metadata = {
                     title: '',
@@ -188,7 +286,7 @@ export function useApiRoutes(config: SynthOSConfig, app: Application): void {
             const { name } = req.params;
 
             // Cannot delete required pages
-            if (REQUIRED_PAGES.includes(name)) {
+            if (config.requiredPages.includes(name)) {
                 res.status(400).json({ error: `Cannot delete required page "${name}"` });
                 return;
             }
@@ -210,11 +308,56 @@ export function useApiRoutes(config: SynthOSConfig, app: Application): void {
         }
     });
 
+    // Discover what a page contains (tables + files)
+    app.get('/api/pages/:name/contents', async (req, res) => {
+        try {
+            const { name } = req.params;
+
+            // Resolve page folder: user pages first, then required pages
+            let pageFolder: string | undefined;
+            const userFolder = path.join(config.pagesFolder, 'pages', name);
+            if (await checkIfExists(path.join(userFolder, 'page.html'))) {
+                pageFolder = userFolder;
+            } else {
+                for (const folder of config.requiredPagesFolders) {
+                    const candidate = path.join(folder, name);
+                    if (await checkIfExists(path.join(candidate, 'page.html'))) {
+                        pageFolder = candidate;
+                        break;
+                    }
+                }
+            }
+
+            if (!pageFolder) {
+                res.status(404).json({ error: `Page "${name}" not found` });
+                return;
+            }
+
+            // List subdirectories, filtering out non-table entries
+            const EXCLUDED = new Set(['files']);
+            const subdirs = await listFolders(pageFolder);
+            const tables = subdirs.filter(d => !EXCLUDED.has(d));
+
+            // Check if files/ exists and has entries
+            const filesDir = path.join(pageFolder, 'files');
+            let hasFiles = false;
+            if (await checkIfExists(filesDir)) {
+                const entries = await fs.readdir(filesDir);
+                hasFiles = entries.length > 0;
+            }
+
+            res.json({ tables, hasFiles });
+        } catch (err: unknown) {
+            console.error(err);
+            res.status(500).json({ error: (err as Error).message });
+        }
+    });
+
     // Copy a page to a new name
     app.post('/api/pages/:name/copy', async (req, res) => {
         try {
             const sourceName = req.params.name;
-            const { name: targetName, title, categories } = req.body;
+            const { name: targetName, title, categories, copyTables, copyFiles } = req.body;
 
             // Validate target name
             if (!targetName || typeof targetName !== 'string') {
@@ -236,10 +379,14 @@ export function useApiRoutes(config: SynthOSConfig, app: Application): void {
             // Check source exists (user pages → required pages)
             const sourceFolderPath = path.join(config.pagesFolder, 'pages', sourceName, 'page.html');
             const sourceFlatPath = path.join(config.pagesFolder, `${sourceName}.html`);
-            const sourceRequiredPath = path.join(config.requiredPagesFolder, `${sourceName}.html`);
+            let sourceRequiredPath: string | undefined;
+            for (const folder of config.requiredPagesFolders) {
+                const candidate = path.join(folder, sourceName, 'page.html');
+                if (await checkIfExists(candidate)) { sourceRequiredPath = candidate; break; }
+            }
             const sourceExists = await checkIfExists(sourceFolderPath)
                 || await checkIfExists(sourceFlatPath)
-                || await checkIfExists(sourceRequiredPath);
+                || !!sourceRequiredPath;
             if (!sourceExists) {
                 res.status(404).json({ error: `Source page "${sourceName}" not found` });
                 return;
@@ -259,7 +406,11 @@ export function useApiRoutes(config: SynthOSConfig, app: Application): void {
                 targetName,
                 typeof title === 'string' ? title : '',
                 Array.isArray(categories) ? categories : [],
-                config.requiredPagesFolder
+                config.requiredPagesFolders,
+                {
+                    copyTables: copyTables === true,
+                    copyFiles: copyFiles !== false, // default true
+                }
             );
 
             // Return the new page metadata
@@ -286,9 +437,6 @@ export function useApiRoutes(config: SynthOSConfig, app: Application): void {
             if (Array.isArray(settings.models)) {
                 for (const entry of settings.models) {
                     if (entry.configuration) {
-                        if (typeof entry.configuration.maxTokens === 'string') {
-                            entry.configuration.maxTokens = parseInt(entry.configuration.maxTokens);
-                        }
                     }
                     if (typeof entry.logCompletions === 'string') {
                         entry.logCompletions = entry.logCompletions === 'true';
@@ -326,9 +474,8 @@ export function useApiRoutes(config: SynthOSConfig, app: Application): void {
     app.post('/api/generate/completion', async (req, res) => {
         await requiresSettings(res, config.pagesFolder, async (settings) => {
             const { prompt, temperature } = req.body;
-            const maxTokens = getModelEntry(settings, 'chat').configuration.maxTokens;
             const completePrompt = await createCompletePrompt(config.pagesFolder, 'chat', req.body.model);
-            const response = await chainOfThought({ question: prompt, temperature, maxTokens, completePrompt });
+            const response = await chainOfThought({ question: prompt, temperature, completePrompt });
             if (response.completed) {
                 res.json(response.value ?? {});
             } else {
@@ -339,31 +486,42 @@ export function useApiRoutes(config: SynthOSConfig, app: Application): void {
     });
 
     // Brainstorm endpoint
+    if (!customizer || customizer.isEnabled('brainstorm'))
     app.post('/api/brainstorm', async (req, res) => {
         await requiresSettings(res, config.pagesFolder, async (settings) => {
             const { context, messages } = req.body;
-            const maxTokens = getModelEntry(settings, 'chat').configuration.maxTokens;
             const completePrompt = await createCompletePrompt(config.pagesFolder, 'chat');
 
+            const productName = customizer?.productName ?? 'SynthOS';
             const system: { role: 'system'; content: string } = {
                 role: 'system',
-                content: `You are a creative brainstorming assistant for SynthOS, a tool that builds web pages through conversation. The user is brainstorming — exploring ideas before building. Be concise, creative, and collaborative. Suggest concrete approaches when you can.
+                content: `You are a creative brainstorming assistant for ${productName}, a tool that builds pages through conversation.
+${productName} is like a WIKI for vibe coding. Each page has a chat panel and a viewer panel. They are vibe coding what's displayed in that viewer panel. They can then save that as a page.
+The user is brainstorming — exploring ideas before building. Be concise, creative, and collaborative.
+They may say that they want to build an app or page that does XYZ but they're talking about what they expect to see in the viewer panel.
+The goal is to help them generate a prompt for the builder that captures their vision, along with suggestions for next steps.
+Suggest concrete approaches when you can, not complex visions for some ellaborate app.
+Just help expand their thoughts into a great next prompt.
+
+<CONTEXT>
+${context}
+
+<INSTRUCTIONS>
+Look at the <CHAT_HISTORY> and if it's empty it's the start of a new idea. Simply greet them and ask them what they're thinking of building. Suggestions could be help me decide, etc.
+If you see a conversation between ${productName} and the User. Asses what they're building and ask them what they'd like help with. Maybe offer a few good next steps.
+
+${productName} exposes table storage and chat completion api's that every page can use. If the user wants to store something or use AI, your prompt should suggest using table storage or make llm calls.
 
 You MUST return your response as a JSON object with exactly these fields:
 {
   "response": "Your conversational reply — explanations, options, suggestions. Markdown OK.",
-  "prompt": "A clean, actionable instruction ready to paste into SynthOS chat to build what was discussed. Update this each exchange to reflect the latest brainstorm state.",
+  "prompt": "A clean, actionable instruction ready to paste into ${productName} chat to build what was discussed. Update this each exchange to reflect the latest brainstorm state.",
   "suggestions": ["Short clickable option A", "Short clickable option B", "Short clickable option C"]
 }
 
 suggestions — 2-4 short phrases the user can click to continue the conversation. These are next-step options: directions to explore, questions to answer, or choices to make. Keep each under 60 characters. Always provide suggestions.
 
-Return ONLY the JSON object. No markdown fences.
-
-<CONTEXT>
-${context}
-</CONTEXT>`
-            };
+Return ONLY the JSON object.`};
 
             // Format multi-turn conversation into a single prompt
             const formatted = (messages as { role: string; content: string }[]).map(m =>
@@ -372,7 +530,7 @@ ${context}
 
             const prompt: { role: 'user'; content: string } = { role: 'user', content: formatted };
 
-            const result = await completePrompt({ prompt, system, maxTokens, jsonMode: true });
+            const result = await completePrompt({ prompt, system, jsonMode: true });
             if (result.completed) {
                 let response = result.value || '';
                 let brainstormPrompt = '';
@@ -397,6 +555,7 @@ ${context}
     });
 
     // Define a route for running configured scripts
+    if (!customizer || customizer.isEnabled('scripts'))
     app.post('/api/scripts/:id', async (req, res) => {
         await requiresSettings(res, config.pagesFolder, async (settings) => {
             const { id } = req.params;
@@ -425,7 +584,13 @@ ${context}
                 res.status(404).send(`// Theme info for "${themeName}" not found`);
                 return;
             }
-            const js = `window.themeInfo=${JSON.stringify(info)};document.documentElement.classList.add(window.themeInfo.mode+"-mode");`;
+            const themeVersion = await loadThemeVersion(themeName, config);
+            const payload = { ...info, name: themeName, version: themeVersion };
+            let js = `window.themeInfo=${JSON.stringify(payload)};document.documentElement.classList.add(window.themeInfo.mode+"-mode");`;
+            if (themeVersion >= 3) {
+                js += `document.documentElement.classList.add(${JSON.stringify(themeName)});`;
+            }
+            js += `document.documentElement.setAttribute("data-toolbar",${JSON.stringify(settings.toolbarPosition || 'left')});`;
             res.set('Content-Type', 'application/javascript');
             res.send(js);
         } catch (err: unknown) {
@@ -442,21 +607,18 @@ ${context}
                 res.status(400).send('// Missing page query parameter');
                 return;
             }
-            const metadata = await loadPageMetadata(config.pagesFolder, page, config.requiredPagesFolder);
+            const metadata = await loadPageMetadata(config.pagesFolder, page, config.requiredPagesFolders);
             const mode = metadata?.mode ?? 'unlocked';
             const title = metadata?.title ?? '';
             const categories = metadata?.categories ?? [];
-            const info = JSON.stringify({ name: page, mode, latestPageVersion: PAGE_VERSION, title, categories });
+            const isRequiredPage = config.requiredPages.includes(page);
+            const productName = customizer?.productName ?? 'SynthOS';
+            const info = JSON.stringify({ name: page, mode, latestPageVersion: PAGE_VERSION, title, categories, isRequiredPage, productName });
             const js = [
                 `window.pageInfo=${info};`,
                 `if(window.pageInfo.mode==="locked"){`,
                 `document.addEventListener("DOMContentLoaded",function(){`,
                 `var f=document.getElementById("chatForm");if(f)f.style.display="none";`,
-                `var s=document.getElementById("saveLink");if(s)s.textContent="Copy";`,
-                `var r=document.getElementById("resetLink");if(r){`,
-                `var c=r.cloneNode(true);c.textContent="Reload";`,
-                `c.addEventListener("click",function(e){e.preventDefault();window.location.href=window.location.pathname;});`,
-                `r.parentNode.replaceChild(c,r);}`,
                 `});`,
                 `}`,
             ].join('');
@@ -506,8 +668,8 @@ ${context}
                 res.status(400).send('// Invalid version parameter');
                 return;
             }
-            const scriptPath = path.join(config.pageScriptsFolder, `page-v${v}.js`);
-            if (!(await checkIfExists(scriptPath))) {
+            const scriptPath = await findFileInFolders(config.staticFilesFolders, `page.v${v}.js`);
+            if (!scriptPath) {
                 res.status(404).send(`// page-v${v}.js not found`);
                 return;
             }
@@ -529,8 +691,8 @@ ${context}
                 res.status(400).send('// Invalid version parameter');
                 return;
             }
-            const scriptPath = path.join(config.pageScriptsFolder, `helpers-v${v}.js`);
-            if (!(await checkIfExists(scriptPath))) {
+            const scriptPath = await findFileInFolders(config.staticFilesFolders, `helpers.v${v}.js`);
+            if (!scriptPath) {
                 res.status(404).send(`// helpers-v${v}.js not found`);
                 return;
             }
@@ -609,6 +771,7 @@ ${context}
     // Web Search (Brave Search API)
     // -----------------------------------------------------------------------
 
+    if (!customizer || customizer.isEnabled('search'))
     app.post('/api/search/web', async (req, res) => {
         try {
             const { query, count, country, freshness } = req.body;
@@ -663,7 +826,7 @@ ${context}
             const { name } = req.params;
 
             // Load current metadata
-            const metadata = await loadPageMetadata(config.pagesFolder, name, config.requiredPagesFolder);
+            const metadata = await loadPageMetadata(config.pagesFolder, name, config.requiredPagesFolders);
             if (!metadata) {
                 res.status(404).json({ error: `Page "${name}" not found` });
                 return;
@@ -689,14 +852,25 @@ ${context}
             // Save upgraded HTML to v2 folder structure
             await savePageState(config.pagesFolder, name, migratedHtml);
 
-            // Move legacy flat file to .migrated folder instead of deleting
+            // Backup original page to .migrated/ before overwriting
+            const migratedFolder = path.join(config.pagesFolder, '.migrated');
+
+            // Handle legacy flat file (<localFolder>/pagename.html)
             const flatPath = path.join(config.pagesFolder, `${name}.html`);
             if (await checkIfExists(flatPath)) {
-                const migratedFolder = path.join(config.pagesFolder, '.migrated');
                 await copyFile(flatPath, migratedFolder);
                 await deleteFile(flatPath);
             }
 
+            // Handle folder-based page (<localFolder>/pages/name/)
+            const folderPath = path.join(config.pagesFolder, 'pages', name);
+            if (await checkIfExists(folderPath)) {
+                await copyFolderRecursive(folderPath, path.join(migratedFolder, name));
+            }
+
+            // Clear stale version files (undo snapshots from the old page version)
+            await clearVersions(config.pagesFolder, name);
+
             // Update metadata
             metadata.pageVersion = PAGE_VERSION;
             metadata.lastModified = new Date().toISOString();
@@ -708,4 +882,94 @@ ${context}
             res.status(500).json({ error: (err as Error).message });
         }
     });
+
+    // Export a page as a zip file
+    app.get('/api/pages/:name/export', async (req, res) => {
+        try {
+            const { name } = req.params;
+
+            // Try user pages folder first, then required pages
+            const userPageDir = path.join(config.pagesFolder, 'pages', name);
+            let requiredPageDir: string | undefined;
+            for (const folder of config.requiredPagesFolders) {
+                if (await checkIfExists(path.join(folder, name, 'page.html'))) {
+                    requiredPageDir = path.join(folder, name);
+                    break;
+                }
+            }
+            let sourceDir: string | null = null;
+
+            if (await checkIfExists(path.join(userPageDir, 'page.html'))) {
+                sourceDir = userPageDir;
+            } else if (requiredPageDir) {
+                // For required pages, create a temp-like zip with just the HTML
+                const zip = new AdmZip();
+                const html = await loadFile(path.join(requiredPageDir, 'page.html'));
+                zip.addFile(`${name}/page.html`, Buffer.from(html, 'utf-8'));
+
+                // Include page.json if it exists
+                const metaPath = path.join(requiredPageDir, 'page.json');
+                if (await checkIfExists(metaPath)) {
+                    const meta = await loadFile(metaPath);
+                    zip.addFile(`${name}/page.json`, Buffer.from(meta, 'utf-8'));
+                }
+
+                const zipBuffer = zip.toBuffer();
+                res.set('Content-Type', 'application/zip');
+                res.set('Content-Disposition', `attachment; filename="${name}.zip"`);
+                res.send(zipBuffer);
+                return;
+            } else {
+                res.status(404).json({ error: `Page "${name}" not found` });
+                return;
+            }
+
+            // Zip the entire page folder
+            const zip = new AdmZip();
+            zip.addLocalFolder(sourceDir, name);
+            const zipBuffer = zip.toBuffer();
+
+            res.set('Content-Type', 'application/zip');
+            res.set('Content-Disposition', `attachment; filename="${name}.zip"`);
+            res.send(zipBuffer);
+        } catch (err: unknown) {
+            console.error(err);
+            res.status(500).json({ error: (err as Error).message });
+        }
+    });
+
+    // Ask a question about a page (with full page HTML context)
+    app.post('/api/pages/:name/ask', async (req, res) => {
+        await requiresSettings(res, config.pagesFolder, async (settings) => {
+            const { name } = req.params;
+            const { question } = req.body;
+            if (typeof question !== 'string' || !question.trim()) {
+                res.status(400).json({ error: 'question is required' });
+                return;
+            }
+
+            // Load the page HTML
+            const html = await loadPageWithFallback(name, config, false);
+            if (!html) {
+                res.status(404).json({ error: `Page "${name}" not found` });
+                return;
+            }
+
+            // Create completion (uses 'chat' model, not 'builder')
+            const complete = await createCompletePrompt(config.pagesFolder, 'chat', req.body.model);
+
+            const system = {
+                role: 'system' as const,
+                content: `You are a helpful assistant. The user will ask questions about a web page. Answer based on the page content provided.\n\n<PAGE_HTML>\n${html}`
+            };
+            const prompt = { role: 'user' as const, content: question };
+
+            const result = await complete({ system, prompt });
+            if (result.completed) {
+                res.json({ answer: result.value });
+            } else {
+                res.status(500).json({ error: result.error?.message || 'Completion failed' });
+            }
+        });
+    });
 }

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,
@@ -21,7 +21,7 @@ export function useConnectorRoutes(config: SynthOSConfig, app: Application): voi
             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;
@@ -35,9 +35,11 @@ export function useConnectorRoutes(config: SynthOSConfig, app: Application): voi
                         id: def.id,
                         name: def.name,
                         category: def.category,
+                        description: def.description,
                         configured: isOAuth
                             ? !!oauthCfg && oauthCfg.enabled && !!oauthCfg.accessToken
-                            : !!cfg && cfg.enabled && !!cfg.apiKey
+                            : !!cfg && cfg.enabled && !!cfg.apiKey,
+                        enabled: !!cfg?.enabled
                     };
                 });
 
@@ -52,7 +54,7 @@ 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;
@@ -86,7 +88,7 @@ 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;
@@ -162,7 +164,7 @@ 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;
@@ -212,7 +214,7 @@ 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;
@@ -324,7 +326,7 @@ 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;
@@ -352,11 +354,20 @@ export function useConnectorRoutes(config: SynthOSConfig, app: Application): voi
             }
 
             // Build URL — join baseUrl path with request path to avoid
-            // absolute paths (e.g. "/me/accounts") replacing the base path
+            // absolute paths (e.g. "/me/accounts") replacing the base path.
+            // Split path from inline query string first — assigning a '?' to
+            // URL.pathname encodes it as %3F, which breaks upstream APIs.
+            const [reqPath, reqQS] = request.path.split('?');
             const base = new URL(def.baseUrl);
-            const joinedPath = base.pathname.replace(/\/+$/, '') + '/' + request.path.replace(/^\/+/, '');
+            const joinedPath = base.pathname.replace(/\/+$/, '') + '/' + reqPath.replace(/^\/+/, '');
             base.pathname = joinedPath;
             const url = base;
+            if (reqQS) {
+                const inline = new URLSearchParams(reqQS);
+                for (const [key, value] of inline.entries()) {
+                    url.searchParams.set(key, value);
+                }
+            }
             if (request.query) {
                 for (const [key, value] of Object.entries(request.query)) {
                     url.searchParams.set(key, value);