synthos 0.1.0

package/src/service/useDataRoutes.ts

@@ -0,0 +1,97 @@
+import { Application } 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';
+
+export function useDataRoutes(config: SynthOSConfig, app: Application): void {
+    // Retrieve all rows from a table
+    app.get('/api/data/:table', async (req, res) => {
+        // Get list of row ids
+        const { table } = req.params;
+        const folder = await tableFolder(config, table);
+        const ids = (await listFiles(folder)).filter(f => f.endsWith('.json')).map(f => f.replace('.json', ''));
+        
+        // Enumerate all rows
+        const rows: Record<string, any>[] = [];
+        for (const id of ids) {
+            const file = recordFile(folder, id);
+            try {
+                const row = JSON.parse(await loadFile(file));
+                row.id = id;
+                rows.push(row);
+            } catch (err: unknown) {
+                console.error(err);
+            }
+        }
+        
+        // Return rows
+        res.json(rows);
+    });
+
+    // Retrieve a single row from a table
+    app.get('/api/data/:table/:id', async (req, res) => {
+        const { table, id } = req.params;
+        const folder = await tableFolder(config, table);
+        const file = recordFile(folder, id);
+        try {
+            const row = JSON.parse(await loadFile(file));
+            row.id = id;
+            res.json(row);
+        } catch (err: unknown) {
+            res.json({});
+        }
+    });
+
+    // Upsert a single row into a table
+    app.post('/api/data/:table', async (req, res) => {
+        const { table } = req.params;
+        const id = req.body.id ?? v4();
+        const folder = await tableFolder(config, table);
+        const file = recordFile(folder, id);
+        try {
+            const row = { ...req.body, id };
+            await ensureFolderExists(folder);
+            await saveFile(file, JSON.stringify(row, null, 4));
+            if (table === 'scripts') {
+                clearCachedScripts();
+            }
+            res.json(row);
+        } catch (err: unknown) {
+            console.error(err);
+            res.status(500).send((err as Error).message);
+        }
+    });
+
+    // Delete a single row from a table
+    app.delete('/api/data/:table/:id', async (req, res) => {
+        const { table, id } = req.params;
+        const folder = await tableFolder(config, table);
+        const file = recordFile(folder, id);
+        try {
+            if (await checkIfExists(file)) {
+                await deleteFile(file);
+
+                // Clear cached scripts
+                if (table === 'scripts') {
+                    clearCachedScripts();
+                }
+            }
+            res.json({ success: true });
+        } catch (err: unknown) {
+            console.error(err);
+            res.status(500).send((err as Error).message);
+        }
+    });
+}
+
+async function tableFolder(config: SynthOSConfig, table: string): Promise<string> {
+    const folder = path.join(config.pagesFolder, table);
+    await ensureFolderExists(folder);
+    return folder;
+}
+
+function recordFile(folder: string, id: string): string {
+    return path.join(folder, `${id}.json`);
+}

package/src/service/usePageRoutes.ts

@@ -0,0 +1,147 @@
+import { loadPageState, normalizePageName, savePageState, updatePageState } from "../pages";
+import { hasConfiguredSettings, loadSettings } from "../settings";
+import { Application } from 'express';
+import { transformPage, transformPageAsObject } from "./transformPage";
+import { SynthOSConfig } from "../init";
+import { createCompletePrompt } from "./createCompletePrompt";
+import { completePrompt } from "agentm-core";
+
+const HOME_PAGE_ROUTE = '/home';
+const PAGE_NOT_FOUND = 'Page not found';
+
+export function usePageRoutes(config: SynthOSConfig, app: Application): void {
+    // Redirect / to /home page
+    app.get('/', (req, res) => res.redirect(HOME_PAGE_ROUTE));
+    
+    // Page retrieval
+    app.get('/:page', async (req, res) => {
+        // Redirect if settings not configured
+        const { page } = req.params;
+        const isConfigured = await hasConfiguredSettings(config.pagesFolder);
+        if (!isConfigured && page !== 'settings') {
+            res.redirect('/settings');
+            return;
+        }
+
+        // Ensure page exists
+        const pageState = await loadPageWithFallback(page, config, false);
+        if (!pageState) {
+            res.status(404).send(PAGE_NOT_FOUND);
+            return;
+        }
+
+        res.send(pageState);
+    });
+
+    // Page reset
+    app.get('/:page/reset', async (req, res) => {
+        // Redirect if settings not configured
+        const { page } = req.params;
+        const isConfigured = await hasConfiguredSettings(config.pagesFolder);
+        if (!isConfigured) {
+            res.redirect('/settings');
+            return;
+        }
+
+        // Ensure page exists
+        const pageState = await loadPageWithFallback(page, config, true);
+        if (!pageState) {
+            res.status(404).send(PAGE_NOT_FOUND);
+            return;
+        }
+
+        res.redirect(`/${page}`);
+    });
+
+    // Page save
+    app.get('/:page/save', async (req, res) => {
+        // Redirect if settings not configured
+        const { page } = req.params;
+        const isConfigured = await hasConfiguredSettings(config.pagesFolder);
+        if (!isConfigured) {
+            res.redirect('/settings');
+            return;
+        }
+
+        // Normalize and validate save-as parameter
+        const saveAs = normalizePageName(req.query['name'] as string);
+        if (!saveAs) {
+            res.status(400).send('Invalid or missing name parameter');
+            return;
+        }
+
+        // Load page state
+        const pageState = await loadPageWithFallback(page, config, false);
+        if (!pageState) {
+            res.status(404).send(PAGE_NOT_FOUND);
+            return;
+        }
+
+        // Save as new page and redirect to saved page
+        await savePageState(config.pagesFolder, saveAs, pageState);
+        res.redirect(`/${saveAs}`);
+    });
+
+    // Page transformation
+    app.post('/:page', async (req, res) => {
+        try {
+            // Ensure settings configured
+            const { page } = req.params;
+            const isConfigured = await hasConfiguredSettings(config.pagesFolder);
+            if (!isConfigured) {
+                res.status(400).send('Settings not configured');
+                return;
+            }
+
+            // Ensure page exists
+            const pageState = await loadPageWithFallback(page, config, false);
+            if (!pageState) {
+                res.status(404).send(PAGE_NOT_FOUND);
+                return;
+            }
+
+            // Get required and optional parameters
+            const { message } = req.body; // Extract the message from the request body
+            if (typeof message !== 'string') {
+                res.status(400).send('Invalid or missing message parameter');
+                return;
+            }
+
+            // Create model instance
+            const innerCompletePrompt = await createCompletePrompt(config.pagesFolder, req.body.model);
+            const completePrompt: completePrompt = (args) => {
+                // console.log(`SYSTEM:\n${args.system!.content}`);
+                // console.log(`PROMPT:\n${args.prompt!.content}`);
+                return innerCompletePrompt(args);
+            }
+
+
+            // Transform and cache updated page 
+            const pagesFolder = config.pagesFolder;
+            const { maxTokens, instructions, model } = await loadSettings(config.pagesFolder);
+            const result = model.startsWith('gpt-') ? 
+                await transformPageAsObject({ pagesFolder, pageState, message, maxTokens, instructions, completePrompt }) :
+                await transformPage({ pagesFolder, pageState, message, maxTokens, instructions, completePrompt });
+            if (result.completed) {
+                updatePageState(page, result.value!);
+                res.send(result.value!);
+            } else {
+                throw result.error;
+            }
+        } catch (err: unknown) {
+            console.error(err);
+            res.status(500).send((err as Error).message);
+        }
+    });
+}
+
+export async function loadPageWithFallback(page: string, config: SynthOSConfig, reset: boolean): Promise<string|undefined> {
+    // Try primary pages folder first
+    const pageState = await loadPageState(config.pagesFolder, page, reset);
+    if (pageState) {
+        return pageState;
+    }
+
+    // Try fallback pages folder second
+    return loadPageState(config.requiredPagesFolder, page, reset);
+}

package/src/settings.ts

@@ -0,0 +1,60 @@
+import {checkIfExists, loadFile, saveFile} from './files';
+import path from 'path';
+
+let _settings: Partial<Settings>|undefined;
+
+export interface Settings {
+    serviceApiKey: string;
+    model: string;
+    maxTokens: number;
+    imageQuality: 'standard' | 'hd';
+    instructions?: string;
+    logCompletions?: boolean;
+}
+
+export const DefaultSettings: Settings = {
+    serviceApiKey: '',
+    model: '',
+    maxTokens: 8000,
+    imageQuality: 'standard',
+    instructions: '',
+    logCompletions: false
+};
+
+export async function hasConfiguredSettings(folder: string): Promise<boolean> {
+    const settings = await loadSettings(folder);
+    if (typeof settings.serviceApiKey !== 'string' || settings.serviceApiKey.length == 0) {
+        return false;
+    }
+    if (typeof settings.model !== 'string' || settings.model.length == 0) {
+        return false;
+    }
+    if (typeof settings.maxTokens !== 'number' || settings.maxTokens <= 0) {
+        return false;
+    }
+
+    return true;    
+}
+
+export async function loadSettings(folder: string): Promise<Settings> {
+    if (_settings == undefined) {
+        // Check for file to exist
+        const filename = path.join(folder, 'settings.json');
+        if (await checkIfExists(filename)) {
+            try {
+                // Load and parse file
+                _settings = JSON.parse(await loadFile(filename));
+            } catch {
+                // Invalid JSON
+            }
+        }
+    }
+
+    // Return settings from file
+    return {...DefaultSettings, ..._settings};
+}
+
+export async function saveSettings(folder: string, settings: Partial<Settings>): Promise<void> {
+    _settings = {..._settings, ...settings};
+    await saveFile(path.join(folder, 'settings.json'), JSON.stringify(_settings, null, 4));
+}

package/src/synthos-cli.ts

@@ -0,0 +1,38 @@
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { server } from "./service";
+import { createConfig, init } from "./init";
+
+const dynamicImport = new Function('specifier', `return import(specifier)`);
+
+export async function run() {
+    await yargs(hideBin(process.argv))
+        .scriptName('synthos')
+        .command('start', `Starts the SynthOS server.`, (yargs) => {
+            return yargs
+                .option('port', {
+                    describe: `The port number to use.`,
+                    type: 'number',
+                    default: 4242
+                })
+                .option('pages', {
+                    describe: `Include default pages when initializing a new .synthos folder.`,
+                    type: 'boolean',
+                    default: true
+                })
+                .demandOption([]);
+        }, async (args) => {
+            const config = createConfig();
+            await init(config, args.pages);
+            await server(config).listen(args.port, async () => {
+                console.log(`SynthOS server is running on http://localhost:${args.port}`);
+                
+                // Open using default browser
+                const open = await dynamicImport('open');
+                open.default(`http://localhost:${args.port}`);
+            });
+        })
+        .help()
+        .demandCommand()
+        .parseAsync();
+}