atoo-studio 0.0.1 → 0.0.2

package/dist/src/handlers/databases.js

@@ -0,0 +1,327 @@
+import { Router } from 'express';
+import { spawn } from 'child_process';
+import { connectionManager } from '../database/connection-manager.js';
+import { discoverLocalFiles } from '../database/discovery/local-files.js';
+import { discoverContainerDatabases, parseComposeFile } from '../database/discovery/container.js';
+import { discoverFromEnvFiles } from '../database/discovery/env-parser.js';
+import { scanLocalPorts } from '../database/discovery/port-scan.js';
+import { db } from '../state/db.js';
+import { obfuscate, deobfuscate } from '../services/obfuscation.js';
+/** Obfuscate sensitive fields before persisting */
+function obfuscateParams(params) {
+    const p = { ...params };
+    if (p.password)
+        p.password = obfuscate(p.password);
+    if (p.connection_string)
+        p.connection_string = obfuscate(p.connection_string);
+    return p;
+}
+/** Deobfuscate sensitive fields after loading from DB */
+function deobfuscateParams(params) {
+    const p = { ...params };
+    if (p.password)
+        try {
+            p.password = deobfuscate(p.password);
+        }
+        catch { }
+    if (p.connection_string)
+        try {
+            p.connection_string = deobfuscate(p.connection_string);
+        }
+        catch { }
+    return p;
+}
+export const databasesRouter = Router();
+// --- Discovery ---
+let discoveryCache = null;
+const DISCOVERY_CACHE_TTL = 15_000;
+/** Invalidate discovery cache so next request re-scans */
+function invalidateDiscoveryCache() {
+    discoveryCache = null;
+}
+// --- Container event hooks ---
+// Watch for docker/podman container start/stop to auto-invalidate discovery cache.
+function startContainerWatcher() {
+    for (const runtime of ['docker', 'podman']) {
+        try {
+            const child = spawn(runtime, ['events', '--filter', 'type=container', '--filter', 'event=start', '--filter', 'event=stop', '--filter', 'event=die', '--format', '{{.Status}}'], {
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            child.stdout?.on('data', () => {
+                // Any container start/stop/die event invalidates cache
+                invalidateDiscoveryCache();
+            });
+            child.on('error', () => { }); // runtime not installed, ignore
+            child.unref(); // Don't prevent process exit
+        }
+        catch { }
+    }
+}
+// Start watching container events in background
+startContainerWatcher();
+async function runDiscovery(projectDir) {
+    const now = Date.now();
+    if (discoveryCache && now - discoveryCache.time < DISCOVERY_CACHE_TTL) {
+        return discoveryCache.result;
+    }
+    const [localFiles, containerDbs, composeDbs, envDbs] = await Promise.all([
+        Promise.resolve(projectDir ? discoverLocalFiles(projectDir) : []),
+        discoverContainerDatabases(),
+        Promise.resolve(projectDir ? parseComposeFile(projectDir) : []),
+        Promise.resolve(projectDir ? discoverFromEnvFiles(projectDir) : []),
+    ]);
+    // Deduplicate compose vs running containers
+    const seen = new Set(containerDbs.map(d => `${d.db_type}:${d.params.port}`));
+    const uniqueCompose = composeDbs.filter(d => !seen.has(`${d.db_type}:${d.params.port}`));
+    // Deduplicate env discoveries vs already-found
+    for (const d of [...containerDbs, ...uniqueCompose])
+        seen.add(`${d.db_type}:${d.params.port}`);
+    const uniqueEnv = envDbs.filter(d => !d.params.port || !seen.has(`${d.db_type}:${d.params.port}`));
+    // Collect ports already found to exclude from port scanning
+    const knownPorts = new Set();
+    for (const d of [...localFiles, ...containerDbs, ...uniqueCompose, ...uniqueEnv]) {
+        if (d.params.port)
+            knownPorts.add(d.params.port);
+    }
+    // Port scan as fallback
+    const portResults = await scanLocalPorts(knownPorts);
+    const result = [...localFiles, ...containerDbs, ...uniqueCompose, ...uniqueEnv, ...portResults];
+    discoveryCache = { result, time: now };
+    return result;
+}
+databasesRouter.get('/api/databases/discover', async (req, res) => {
+    try {
+        const projectDir = req.query.project_dir;
+        const discovered = await runDiscovery(projectDir);
+        const savedConnections = db.getSavedDbConnections().map(c => ({
+            ...c,
+            params: deobfuscateParams(c.params),
+        }));
+        // Strip passwords from the response — frontend doesn't need them for display
+        const safeSaved = savedConnections.map(c => ({
+            id: c.id, name: c.name, db_type: c.db_type,
+            params: { ...c.params, password: c.params.password ? '••••' : undefined, connection_string: undefined },
+        }));
+        res.json({
+            discovered,
+            connections: connectionManager.getActiveConnections(),
+            saved: safeSaved,
+        });
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+// --- Connection management ---
+databasesRouter.post('/api/databases/connect', async (req, res) => {
+    try {
+        const { db_type, connection, name, save } = req.body;
+        if (!db_type)
+            return res.status(400).json({ error: 'db_type is required' });
+        if (!connection)
+            return res.status(400).json({ error: 'connection params are required' });
+        const connectionId = await connectionManager.connect(db_type, connection, name);
+        // Save to persistent storage if requested or always for manual connections
+        if (save !== false) {
+            const connName = name || `${db_type}@${connection.host || connection.filename || 'localhost'}`;
+            db.saveDbConnection(connectionId, connName, db_type, obfuscateParams(connection));
+        }
+        db.touchDbConnection(connectionId);
+        res.json({ connection_id: connectionId });
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+databasesRouter.post('/api/databases/disconnect', async (req, res) => {
+    try {
+        const { connection_id } = req.body;
+        if (!connection_id)
+            return res.status(400).json({ error: 'connection_id is required' });
+        await connectionManager.disconnect(connection_id);
+        res.json({ ok: true });
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+// Reconnect a saved connection
+databasesRouter.post('/api/databases/reconnect', async (req, res) => {
+    try {
+        const { saved_id } = req.body;
+        if (!saved_id)
+            return res.status(400).json({ error: 'saved_id is required' });
+        const saved = db.getSavedDbConnections().find(c => c.id === saved_id);
+        if (!saved)
+            return res.status(404).json({ error: 'Saved connection not found' });
+        const connectionId = await connectionManager.connect(saved.db_type, deobfuscateParams(saved.params), saved.name);
+        db.touchDbConnection(saved_id);
+        res.json({ connection_id: connectionId });
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+// Delete a saved connection
+databasesRouter.delete('/api/databases/saved/:id', async (req, res) => {
+    try {
+        db.deleteDbConnection(req.params.id);
+        res.json({ ok: true });
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+databasesRouter.get('/api/databases/connections', (_req, res) => {
+    res.json(connectionManager.getActiveConnections());
+});
+// --- Query & Schema ---
+databasesRouter.post('/api/databases/query', async (req, res) => {
+    try {
+        const { connection_id, query, limit, timeout_ms } = req.body;
+        if (!connection_id)
+            return res.status(400).json({ error: 'connection_id is required' });
+        if (!query)
+            return res.status(400).json({ error: 'query is required' });
+        const result = await connectionManager.query(connection_id, query, limit || 100, timeout_ms);
+        res.json(result);
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+// Update a single cell value (for inline editing)
+databasesRouter.post('/api/databases/update-cell', async (req, res) => {
+    try {
+        const { connection_id, table, primary_key, column, value } = req.body;
+        if (!connection_id)
+            return res.status(400).json({ error: 'connection_id is required' });
+        if (!table)
+            return res.status(400).json({ error: 'table is required' });
+        if (!primary_key || typeof primary_key !== 'object')
+            return res.status(400).json({ error: 'primary_key object is required (e.g. {"id": 1})' });
+        if (!column)
+            return res.status(400).json({ error: 'column is required' });
+        // Build WHERE clause from primary key
+        const pkEntries = Object.entries(primary_key);
+        if (pkEntries.length === 0)
+            return res.status(400).json({ error: 'primary_key must have at least one field' });
+        const whereClause = pkEntries.map(([k], i) => `"${k}" = $${i + 2}`).join(' AND ');
+        const sql = `UPDATE "${table}" SET "${column}" = $1 WHERE ${whereClause}`;
+        const params = [value, ...pkEntries.map(([, v]) => v)];
+        // Use raw query with parameterized values — for now use a simple approach
+        // since our driver interface only supports string queries
+        const escapedValue = value === null ? 'NULL' : typeof value === 'number' ? String(value) : `'${String(value).replace(/'/g, "''")}'`;
+        const escapedWhere = pkEntries.map(([k, v]) => {
+            const ev = v === null ? 'IS NULL' : typeof v === 'number' ? `= ${v}` : `= '${String(v).replace(/'/g, "''")}'`;
+            return `"${k}" ${ev}`;
+        }).join(' AND ');
+        const rawSql = `UPDATE "${table}" SET "${column}" = ${escapedValue} WHERE ${escapedWhere}`;
+        const result = await connectionManager.query(connection_id, rawSql, 1);
+        res.json({ ok: true, affected: result.row_count });
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+databasesRouter.get('/api/databases/:connectionId/tables', async (req, res) => {
+    try {
+        const tables = await connectionManager.getTables(req.params.connectionId);
+        res.json(tables);
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+databasesRouter.get('/api/databases/:connectionId/tables/:table', async (req, res) => {
+    try {
+        const schema = await connectionManager.describeTable(req.params.connectionId, req.params.table);
+        res.json(schema);
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+databasesRouter.get('/api/databases/:connectionId/databases', async (req, res) => {
+    try {
+        const databases = await connectionManager.getDatabases(req.params.connectionId);
+        res.json(databases);
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+// --- MCP endpoint (called by MCP server process) ---
+// NOTE: This is exported separately and registered in server.ts BEFORE the auth
+// middleware, alongside other /api/mcp/* routes. It must NOT be on databasesRouter
+// because that router is mounted after requireAuth.
+export async function handleMcpConnectDatabase(req, res) {
+    try {
+        const { action, db_type, connection, query, table, connection_id, options } = req.body;
+        const limit = options?.limit || 100;
+        const timeoutMs = options?.timeout_ms || 30000;
+        const readonly = options?.readonly !== false; // default true
+        switch (action) {
+            case 'connect': {
+                if (!db_type)
+                    return res.status(400).json({ error: 'db_type is required for connect' });
+                const id = await connectionManager.connect(db_type, connection || {}, undefined, readonly);
+                const tables = await connectionManager.getTables(id);
+                res.json({ connection_id: id, tables, message: `Connected to ${db_type} (${readonly ? 'read-only' : 'read-write'}). ${tables.length} tables found.` });
+                break;
+            }
+            case 'disconnect': {
+                if (!connection_id)
+                    return res.status(400).json({ error: 'connection_id is required' });
+                await connectionManager.disconnect(connection_id);
+                res.json({ message: 'Disconnected' });
+                break;
+            }
+            case 'query': {
+                if (!connection_id)
+                    return res.status(400).json({ error: 'connection_id is required' });
+                if (!query)
+                    return res.status(400).json({ error: 'query is required' });
+                const result = await connectionManager.query(connection_id, query, limit, timeoutMs);
+                res.json(result);
+                break;
+            }
+            case 'tables': {
+                if (!connection_id)
+                    return res.status(400).json({ error: 'connection_id is required' });
+                const tables = await connectionManager.getTables(connection_id);
+                res.json({ tables });
+                break;
+            }
+            case 'describe': {
+                if (!connection_id)
+                    return res.status(400).json({ error: 'connection_id is required' });
+                if (!table)
+                    return res.status(400).json({ error: 'table is required' });
+                const schema = await connectionManager.describeTable(connection_id, table);
+                res.json(schema);
+                break;
+            }
+            case 'schema': {
+                if (!connection_id)
+                    return res.status(400).json({ error: 'connection_id is required' });
+                const allTables = await connectionManager.getTables(connection_id);
+                const schemas = [];
+                for (const t of allTables.slice(0, 50)) {
+                    try {
+                        const s = await connectionManager.describeTable(connection_id, t.name);
+                        schemas.push(s);
+                    }
+                    catch { }
+                }
+                res.json({ tables: allTables, schemas });
+                break;
+            }
+            default:
+                res.status(400).json({ error: `Unknown action: ${action}` });
+        }
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+}

package/dist/src/handlers/environments.d.ts

@@ -0,0 +1,3 @@
+export declare const environmentsRouter: import("express-serve-static-core").Router;
+export declare let broadcastSettingsChange: (scope: string, key: string, settings: any, excludeWs?: any) => void;
+export declare function setBroadcastSettingsChange(fn: typeof broadcastSettingsChange): void;

package/dist/src/handlers/environments.js

@@ -0,0 +1,286 @@
+import { Router } from 'express';
+import fs from 'fs';
+import fsp from 'fs/promises';
+import path from 'path';
+import { db } from '../state/db.js';
+import * as gitOps from '../services/git-ops.js';
+import { watchProject } from '../services/project-watcher.js';
+import { isAuthEnabled } from '../auth/middleware.js';
+export const environmentsRouter = Router();
+// Broadcast function — set by server.ts when /ws/settings is initialized
+export let broadcastSettingsChange = () => { };
+export function setBroadcastSettingsChange(fn) {
+    broadcastSettingsChange = fn;
+}
+// ═══════════════════════════════════════════════════
+// ENVIRONMENT ENDPOINTS
+// ═══════════════════════════════════════════════════
+// List environments (filtered by user when auth is enabled)
+environmentsRouter.get('/api/environments', (req, res) => {
+    if (isAuthEnabled() && req.user) {
+        const envs = db.listEnvironmentsForUser(req.user.id);
+        return res.json(envs);
+    }
+    const envs = db.listEnvironments();
+    res.json(envs);
+});
+// Create environment
+environmentsRouter.post('/api/environments', (req, res) => {
+    const { name } = req.body;
+    if (!name)
+        return res.status(400).json({ error: 'name is required' });
+    if (isAuthEnabled() && req.user) {
+        const env = db.createEnvironmentWithOwner(name, req.user.id);
+        return res.json(env);
+    }
+    const env = db.createEnvironment(name);
+    res.json(env);
+});
+// Delete environment (owner only when auth is enabled)
+environmentsRouter.delete('/api/environments/:id', (req, res) => {
+    if (isAuthEnabled() && req.user) {
+        const owner = db.getEnvironmentOwner(req.params.id);
+        if (owner !== req.user.id) {
+            return res.status(403).json({ error: 'Only the environment owner can delete it' });
+        }
+    }
+    const deleted = db.deleteEnvironment(req.params.id);
+    if (!deleted)
+        return res.status(404).json({ error: 'Environment not found' });
+    res.json({ success: true });
+});
+// ═══════════════════════════════════════════════════
+// ENVIRONMENT SHARING
+// ═══════════════════════════════════════════════════
+// List shares for an environment
+environmentsRouter.get('/api/environments/:id/shares', (req, res) => {
+    if (isAuthEnabled() && req.user) {
+        if (!db.canAccessEnvironment(req.user.id, req.params.id)) {
+            return res.status(403).json({ error: 'Access denied' });
+        }
+    }
+    const shares = db.listEnvironmentShares(req.params.id);
+    res.json(shares);
+});
+// Share environment with a user (owner only)
+environmentsRouter.post('/api/environments/:id/shares', (req, res) => {
+    const { user_id } = req.body;
+    if (!user_id)
+        return res.status(400).json({ error: 'user_id is required' });
+    if (isAuthEnabled() && req.user) {
+        const owner = db.getEnvironmentOwner(req.params.id);
+        if (owner !== req.user.id) {
+            return res.status(403).json({ error: 'Only the environment owner can share it' });
+        }
+    }
+    const targetUser = db.getUser(user_id);
+    if (!targetUser)
+        return res.status(404).json({ error: 'User not found' });
+    db.shareEnvironment(req.params.id, user_id, req.user?.id || 'system');
+    res.json({ ok: true });
+});
+// Revoke share
+environmentsRouter.delete('/api/environments/:id/shares/:userId', (req, res) => {
+    if (isAuthEnabled() && req.user) {
+        const owner = db.getEnvironmentOwner(req.params.id);
+        if (owner !== req.user.id) {
+            return res.status(403).json({ error: 'Only the environment owner can manage shares' });
+        }
+    }
+    const deleted = db.unshareEnvironment(req.params.id, req.params.userId);
+    if (!deleted)
+        return res.status(404).json({ error: 'Share not found' });
+    res.json({ ok: true });
+});
+// ═══════════════════════════════════════════════════
+// PROJECTS IN ENVIRONMENT
+// ═══════════════════════════════════════════════════
+// Get projects in an environment (with live isGit + pe_id)
+environmentsRouter.get('/api/environments/:id/projects', async (req, res) => {
+    if (isAuthEnabled() && req.user && !db.canAccessEnvironment(req.user.id, req.params.id)) {
+        return res.status(403).json({ error: 'Access denied' });
+    }
+    const env = db.getEnvironment(req.params.id);
+    if (!env)
+        return res.status(404).json({ error: 'Environment not found' });
+    const projects = db.getProjectsForEnvironment(req.params.id);
+    const withGit = await Promise.all(projects.map(async (p) => {
+        if (p.ssh_connection_id) {
+            // Remote project — skip local fs checks and watching
+            return { ...p, isGit: false };
+        }
+        let isGit = false;
+        try {
+            await fsp.access(path.join(p.path, '.git'));
+            isGit = true;
+        }
+        catch { }
+        return { ...p, isGit };
+    }));
+    res.json(withGit);
+});
+// Create project + link to environment
+environmentsRouter.post('/api/environments/:id/projects', async (req, res) => {
+    if (isAuthEnabled() && req.user && !db.canAccessEnvironment(req.user.id, req.params.id)) {
+        return res.status(403).json({ error: 'Access denied' });
+    }
+    const env = db.getEnvironment(req.params.id);
+    if (!env)
+        return res.status(404).json({ error: 'Environment not found' });
+    const { name, path: projectPath, initGit, remoteUrl, ssh_connection_id, remote_path } = req.body;
+    if (!name || !projectPath) {
+        return res.status(400).json({ error: 'name and path are required' });
+    }
+    try {
+        if (ssh_connection_id) {
+            // Remote project — skip local fs checks
+            const { sshManager } = await import('../services/ssh-manager.js');
+            const remoteGit = await import('../services/remote-git-ops.js');
+            if (initGit && remoteUrl) {
+                try {
+                    await remoteGit.gitClone(ssh_connection_id, remoteUrl, projectPath);
+                }
+                catch { }
+            }
+            else {
+                // Ensure remote directory exists
+                try {
+                    await sshManager.exec(ssh_connection_id, `mkdir -p '${projectPath.replace(/'/g, "'\\''")}'`);
+                }
+                catch { }
+                if (initGit) {
+                    try {
+                        await remoteGit.gitInit(ssh_connection_id, projectPath);
+                    }
+                    catch { }
+                }
+            }
+            const project = db.createProject(name, projectPath, {
+                sshConnectionId: ssh_connection_id,
+                remotePath: remote_path || projectPath,
+            });
+            const peId = db.linkProject(project.id, req.params.id);
+            let isGit = false;
+            try {
+                await sshManager.exec(ssh_connection_id, `test -d '${projectPath.replace(/'/g, "'\\''")}'/.git`);
+                isGit = true;
+            }
+            catch { }
+            res.json({ ...project, pe_id: peId, isGit });
+        }
+        else {
+            // Local project
+            const resolved = path.resolve(projectPath);
+            if (initGit && remoteUrl && !fs.existsSync(path.join(resolved, '.git'))) {
+                // Clone into target directory (git clone creates it if needed)
+                await gitOps.gitClone(remoteUrl, resolved);
+            }
+            else {
+                if (!fs.existsSync(resolved)) {
+                    fs.mkdirSync(resolved, { recursive: true });
+                }
+                if (initGit && !fs.existsSync(path.join(resolved, '.git'))) {
+                    await gitOps.gitInit(resolved);
+                }
+            }
+            const project = db.createProject(name, projectPath);
+            const peId = db.linkProject(project.id, req.params.id);
+            let isGit = false;
+            try {
+                isGit = fs.existsSync(path.join(resolved, '.git'));
+            }
+            catch { }
+            // Start watching the new project
+            watchProject(project.id, resolved);
+            res.json({ ...project, pe_id: peId, isGit });
+        }
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+// Connect an existing project from another environment
+environmentsRouter.post('/api/environments/:id/connect-project', (req, res) => {
+    const env = db.getEnvironment(req.params.id);
+    if (!env)
+        return res.status(404).json({ error: 'Environment not found' });
+    const { project_id } = req.body;
+    if (!project_id)
+        return res.status(400).json({ error: 'project_id is required' });
+    const project = db.getProject(project_id);
+    if (!project)
+        return res.status(404).json({ error: 'Project not found' });
+    const peId = db.linkProject(project_id, req.params.id);
+    res.json({ success: true, pe_id: peId });
+});
+// Unlink project from environment by PE ID
+environmentsRouter.delete('/api/project-links/:peId', (req, res) => {
+    const pe = db.getProjectEnvironment(req.params.peId);
+    if (!pe)
+        return res.status(404).json({ error: 'Link not found' });
+    const deleteProject = req.query.deleteProject === 'true';
+    const deleteFiles = req.query.deleteFiles === 'true';
+    db.unlinkProject(req.params.peId);
+    // Check remaining links
+    const remainingEnvs = db.getEnvironmentsForProject(pe.project_id);
+    if (remainingEnvs.length === 0 && deleteProject) {
+        // Delete working directory if requested
+        if (deleteFiles) {
+            const project = db.getProject(pe.project_id);
+            if (project && !project.ssh_connection_id) {
+                try {
+                    fs.rmSync(project.path, { recursive: true, force: true });
+                }
+                catch { }
+            }
+        }
+        db.deleteProject(pe.project_id);
+    }
+    res.json({ success: true, remainingLinks: remainingEnvs.length });
+});
+// Resolve a project-environment link (for URL-based routing)
+environmentsRouter.get('/api/project-links/:peId', (req, res) => {
+    const pe = db.getProjectEnvironment(req.params.peId);
+    if (!pe)
+        return res.status(404).json({ error: 'Project link not found' });
+    const project = db.getProject(pe.project_id);
+    const environment = db.getEnvironment(pe.environment_id);
+    res.json({ ...pe, project, environment });
+});
+// ═══════════════════════════════════════════════════
+// ENVIRONMENT SETTINGS
+// ═══════════════════════════════════════════════════
+environmentsRouter.get('/api/environments/:id/settings', (req, res) => {
+    const settings = db.getEnvironmentSettings(req.params.id);
+    if (!settings)
+        return res.status(404).json({ error: 'Environment not found' });
+    res.json(settings);
+});
+environmentsRouter.put('/api/environments/:id/settings', (req, res) => {
+    db.updateEnvironmentSettings(req.params.id, req.body);
+    const settings = db.getEnvironmentSettings(req.params.id);
+    broadcastSettingsChange('environment', req.params.id, settings, req._settingsWs);
+    res.json(settings);
+});
+// ═══════════════════════════════════════════════════
+// PROJECT SETTINGS (by project-environment link ID)
+// ═══════════════════════════════════════════════════
+environmentsRouter.get('/api/project-links/:peId/settings', (req, res) => {
+    const settings = db.getProjectSettings(req.params.peId);
+    res.json(settings);
+});
+environmentsRouter.put('/api/project-links/:peId/settings', (req, res) => {
+    try {
+        db.updateProjectSettings(req.params.peId, req.body);
+    }
+    catch (e) {
+        if (e.code === 'SQLITE_CONSTRAINT_FOREIGNKEY') {
+            res.status(404).json({ error: 'Project link not found' });
+            return;
+        }
+        throw e;
+    }
+    const settings = db.getProjectSettings(req.params.peId);
+    broadcastSettingsChange('project', req.params.peId, settings, req._settingsWs);
+    res.json(settings);
+});

package/dist/src/handlers/github.d.ts

@@ -0,0 +1 @@
+export declare const githubRouter: import("express-serve-static-core").Router;