@lovelybunch/api 1.0.55 → 1.0.57

package/dist/routes/api/v1/api-keys/route.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const apiKeys: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default apiKeys;

package/dist/routes/api/v1/api-keys/route.js

@@ -0,0 +1,120 @@
+import { Hono } from 'hono';
+import { getAuthManager } from '../../../../lib/auth/auth-manager.js';
+import { requireAuth } from '../../../../middleware/auth.js';
+const apiKeys = new Hono();
+/**
+ * GET /api/v1/api-keys
+ * List all API keys
+ */
+apiKeys.get('/', async (c) => {
+    try {
+        const session = requireAuth(c);
+        // If auth is disabled (session is null), return empty list
+        if (!session) {
+            return c.json({
+                success: true,
+                data: {
+                    apiKeys: [],
+                },
+            });
+        }
+        const authManager = getAuthManager();
+        const keys = await authManager.listApiKeys();
+        // Return keys without actual key values
+        return c.json({
+            success: true,
+            data: {
+                apiKeys: keys.map((k) => ({
+                    id: k.id,
+                    name: k.name,
+                    keyPreview: k.keyPreview,
+                    createdBy: k.createdBy,
+                    createdAt: k.createdAt,
+                    expiresAt: k.expiresAt,
+                    lastUsedAt: k.lastUsedAt,
+                    scopes: k.scopes,
+                })),
+            },
+        });
+    }
+    catch (error) {
+        console.error('List API keys error:', error);
+        return c.json({ success: false, error: error.message || 'Failed to list API keys' }, error.message === 'Authentication required' ? 401 : 500);
+    }
+});
+/**
+ * POST /api/v1/api-keys
+ * Create a new API key
+ */
+apiKeys.post('/', async (c) => {
+    try {
+        const session = requireAuth(c);
+        if (!session) {
+            return c.json({ success: false, error: 'Authentication is required to create API keys' }, 401);
+        }
+        const authManager = getAuthManager();
+        const body = await c.req.json();
+        const { name, expiresIn, scopes } = body;
+        if (!name) {
+            return c.json({ success: false, error: 'Name is required' }, 400);
+        }
+        if (!scopes || scopes.length === 0) {
+            return c.json({ success: false, error: 'At least one scope is required' }, 400);
+        }
+        // Create API key
+        const { apiKey, rawKey } = await authManager.createApiKey(name, session.userId, scopes, expiresIn);
+        return c.json({
+            success: true,
+            data: {
+                apiKey: {
+                    id: apiKey.id,
+                    name: apiKey.name,
+                    keyPreview: apiKey.keyPreview,
+                    createdBy: apiKey.createdBy,
+                    createdAt: apiKey.createdAt,
+                    expiresAt: apiKey.expiresAt,
+                    scopes: apiKey.scopes,
+                },
+                key: rawKey, // Only returned once!
+            },
+            message: 'API key created successfully. Save this key securely - it will not be shown again.',
+        });
+    }
+    catch (error) {
+        console.error('Create API key error:', error);
+        return c.json({ success: false, error: error.message || 'Failed to create API key' }, error.message === 'Authentication required' ? 401 : 500);
+    }
+});
+/**
+ * DELETE /api/v1/api-keys/:id
+ * Delete an API key
+ */
+apiKeys.delete('/:id', async (c) => {
+    try {
+        const session = requireAuth(c);
+        if (!session) {
+            return c.json({ success: false, error: 'Authentication is required to delete API keys' }, 401);
+        }
+        const apiKeyId = c.req.param('id');
+        const authManager = getAuthManager();
+        const keys = await authManager.listApiKeys();
+        const key = keys.find((k) => k.id === apiKeyId);
+        if (!key) {
+            return c.json({ success: false, error: 'API key not found' }, 404);
+        }
+        // Check if user is admin or the creator of the key
+        if (session.role !== 'admin' && key.createdBy !== session.userId) {
+            return c.json({ success: false, error: 'Not authorized to delete this API key' }, 403);
+        }
+        await authManager.deleteApiKey(apiKeyId);
+        return c.json({
+            success: true,
+            message: 'API key deleted successfully',
+        });
+    }
+    catch (error) {
+        console.error('Delete API key error:', error);
+        return c.json({ success: false, error: error.message || 'Failed to delete API key' }, error.message === 'Authentication required' ? 401 : 500);
+    }
+});
+export default apiKeys;

package/dist/routes/api/v1/auth/index.d.ts

@@ -0,0 +1 @@
+export { default } from './route.js';

package/dist/routes/api/v1/auth/index.js

@@ -0,0 +1 @@
+export { default } from './route.js';

package/dist/routes/api/v1/auth/route.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const auth: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default auth;

package/dist/routes/api/v1/auth/route.js

@@ -0,0 +1,230 @@
+import { Hono } from 'hono';
+import { setCookie, deleteCookie } from 'hono/cookie';
+import { getAuthManager } from '../../../../lib/auth/auth-manager.js';
+import { getSession } from '../../../../middleware/auth.js';
+const auth = new Hono();
+/**
+ * POST /api/v1/auth/login
+ * Login with email and password
+ */
+auth.post('/login', async (c) => {
+    try {
+        const authManager = getAuthManager();
+        const body = await c.req.json();
+        const { email, password } = body;
+        if (!email || !password) {
+            return c.json({ success: false, error: 'Email and password are required' }, 400);
+        }
+        // Verify credentials
+        const user = await authManager.verifyCredentials(email, password);
+        if (!user) {
+            return c.json({ success: false, error: 'Invalid email or password' }, 401);
+        }
+        // Generate token
+        const token = await authManager.generateToken(user);
+        // Get session config
+        const config = await authManager.loadAuthConfig();
+        // Set cookie
+        setCookie(c, config.session.cookieName, token, {
+            httpOnly: true,
+            secure: config.session.secure || false,
+            sameSite: 'Lax',
+            maxAge: authManager['parseExpiry'](config.session.expiresIn),
+            path: '/',
+        });
+        return c.json({
+            success: true,
+            data: {
+                user: {
+                    id: user.id,
+                    email: user.email,
+                    name: user.name,
+                    role: user.role,
+                },
+                token, // Also return token for programmatic use
+            },
+        });
+    }
+    catch (error) {
+        console.error('Login error:', error);
+        return c.json({ success: false, error: 'Login failed' }, 500);
+    }
+});
+/**
+ * POST /api/v1/auth/register
+ * Register a new user (must be whitelisted)
+ */
+auth.post('/register', async (c) => {
+    try {
+        const authManager = getAuthManager();
+        const body = await c.req.json();
+        const { email, password, name } = body;
+        if (!email || !password || !name) {
+            return c.json({ success: false, error: 'Email, password, and name are required' }, 400);
+        }
+        // Validate password strength
+        if (password.length < 8) {
+            return c.json({ success: false, error: 'Password must be at least 8 characters' }, 400);
+        }
+        // Check if email is whitelisted
+        const isWhitelisted = await authManager.isEmailWhitelisted(email);
+        if (!isWhitelisted) {
+            return c.json({ success: false, error: 'Email not authorized for registration' }, 403);
+        }
+        // Register user
+        const user = await authManager.registerUser(email, password, name);
+        // Generate token
+        const token = await authManager.generateToken(user);
+        // Get session config
+        const config = await authManager.loadAuthConfig();
+        // Set cookie
+        setCookie(c, config.session.cookieName, token, {
+            httpOnly: true,
+            secure: config.session.secure || false,
+            sameSite: 'Lax',
+            maxAge: authManager['parseExpiry'](config.session.expiresIn),
+            path: '/',
+        });
+        return c.json({
+            success: true,
+            data: {
+                user: {
+                    id: user.id,
+                    email: user.email,
+                    name: user.name,
+                    role: user.role,
+                },
+                token,
+            },
+        });
+    }
+    catch (error) {
+        console.error('Registration error:', error);
+        return c.json({ success: false, error: error.message || 'Registration failed' }, 400);
+    }
+});
+/**
+ * POST /api/v1/auth/logout
+ * Logout and clear session
+ */
+auth.post('/logout', async (c) => {
+    try {
+        const authManager = getAuthManager();
+        const config = await authManager.loadAuthConfig();
+        // Clear cookie
+        deleteCookie(c, config.session.cookieName, {
+            path: '/',
+        });
+        return c.json({
+            success: true,
+            message: 'Logged out successfully',
+        });
+    }
+    catch (error) {
+        console.error('Logout error:', error);
+        return c.json({ success: false, error: 'Logout failed' }, 500);
+    }
+});
+/**
+ * GET /api/v1/auth/me
+ * Get current user info
+ */
+auth.get('/me', async (c) => {
+    try {
+        const session = getSession(c);
+        if (!session) {
+            return c.json({ success: false, error: 'Not authenticated' }, 401);
+        }
+        const authManager = getAuthManager();
+        const user = await authManager.findUserById(session.userId);
+        if (!user) {
+            return c.json({ success: false, error: 'User not found' }, 404);
+        }
+        return c.json({
+            success: true,
+            data: {
+                user: {
+                    id: user.id,
+                    email: user.email,
+                    name: user.name,
+                    role: user.role,
+                    lastLoginAt: user.lastLoginAt,
+                },
+            },
+        });
+    }
+    catch (error) {
+        console.error('Get user error:', error);
+        return c.json({ success: false, error: 'Failed to get user info' }, 500);
+    }
+});
+/**
+ * POST /api/v1/auth/change-password
+ * Change current user's password
+ */
+auth.post('/change-password', async (c) => {
+    try {
+        const session = getSession(c);
+        if (!session) {
+            return c.json({ success: false, error: 'Not authenticated' }, 401);
+        }
+        const authManager = getAuthManager();
+        const body = await c.req.json();
+        const { currentPassword, newPassword } = body;
+        if (!currentPassword || !newPassword) {
+            return c.json({ success: false, error: 'Current and new password are required' }, 400);
+        }
+        // Validate new password strength
+        if (newPassword.length < 8) {
+            return c.json({ success: false, error: 'New password must be at least 8 characters' }, 400);
+        }
+        await authManager.changePassword(session.userId, currentPassword, newPassword);
+        return c.json({
+            success: true,
+            message: 'Password changed successfully',
+        });
+    }
+    catch (error) {
+        console.error('Change password error:', error);
+        return c.json({ success: false, error: error.message || 'Failed to change password' }, 400);
+    }
+});
+/**
+ * GET /api/v1/auth/status
+ * Check if auth is enabled
+ */
+auth.get('/status', async (c) => {
+    try {
+        const authManager = getAuthManager();
+        const authEnabled = await authManager.isAuthEnabled();
+        let config = null;
+        if (authEnabled) {
+            const authConfig = await authManager.loadAuthConfig();
+            config = {
+                allowRegistration: authConfig.allowRegistration,
+                providers: {
+                    local: authConfig.providers.local.enabled,
+                    google: authConfig.providers.oauth.google?.enabled || false,
+                    github: authConfig.providers.oauth.github?.enabled || false,
+                },
+            };
+        }
+        return c.json({
+            success: true,
+            data: {
+                enabled: authEnabled,
+                config,
+            },
+        });
+    }
+    catch (error) {
+        console.error('Auth status error:', error);
+        return c.json({
+            success: true,
+            data: {
+                enabled: false,
+            },
+        });
+    }
+});
+export default auth;

package/dist/routes/api/v1/auth-settings/index.d.ts

@@ -0,0 +1 @@
+export { default } from './route.js';

package/dist/routes/api/v1/auth-settings/index.js

@@ -0,0 +1 @@
+export { default } from './route.js';

package/dist/routes/api/v1/auth-settings/route.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const authSettings: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default authSettings;

package/dist/routes/api/v1/auth-settings/route.js

@@ -0,0 +1,249 @@
+import { Hono } from 'hono';
+import { getAuthManager } from '../../../../lib/auth/auth-manager.js';
+import { requireAdmin } from '../../../../middleware/auth.js';
+const authSettings = new Hono();
+/**
+ * GET /api/v1/auth-settings
+ * Get auth configuration (admin only)
+ */
+authSettings.get('/', async (c) => {
+    try {
+        requireAdmin(c);
+        const authManager = getAuthManager();
+        const config = await authManager.loadAuthConfig();
+        // Return config without sensitive data (passwords, secrets, API keys)
+        return c.json({
+            success: true,
+            data: {
+                enabled: config.enabled,
+                allowRegistration: config.allowRegistration,
+                providers: {
+                    local: {
+                        enabled: config.providers.local.enabled,
+                        users: config.providers.local.users.map((u) => ({
+                            id: u.id,
+                            email: u.email,
+                            name: u.name,
+                            role: u.role,
+                            registered: u.registered,
+                            createdAt: u.createdAt,
+                            updatedAt: u.updatedAt,
+                            lastLoginAt: u.lastLoginAt,
+                        })),
+                    },
+                    oauth: {
+                        google: config.providers.oauth.google
+                            ? {
+                                enabled: config.providers.oauth.google.enabled,
+                                clientId: config.providers.oauth.google.clientId
+                                    ? '***'
+                                    : undefined,
+                                hasClientSecret: !!config.providers.oauth.google.clientSecret,
+                                callbackUrl: config.providers.oauth.google.callbackUrl,
+                            }
+                            : undefined,
+                        github: config.providers.oauth.github
+                            ? {
+                                enabled: config.providers.oauth.github.enabled,
+                                clientId: config.providers.oauth.github.clientId
+                                    ? '***'
+                                    : undefined,
+                                hasClientSecret: !!config.providers.oauth.github.clientSecret,
+                                callbackUrl: config.providers.oauth.github.callbackUrl,
+                            }
+                            : undefined,
+                    },
+                },
+                session: {
+                    expiresIn: config.session.expiresIn,
+                    cookieName: config.session.cookieName,
+                    secure: config.session.secure,
+                },
+            },
+        });
+    }
+    catch (error) {
+        console.error('Get auth settings error:', error);
+        return c.json({ success: false, error: error.message || 'Failed to get auth settings' }, error.message === 'Admin access required' ? 403 : 500);
+    }
+});
+/**
+ * PUT /api/v1/auth-settings
+ * Update auth configuration (admin only)
+ */
+authSettings.put('/', async (c) => {
+    try {
+        requireAdmin(c);
+        const authManager = getAuthManager();
+        const config = await authManager.loadAuthConfig();
+        const body = await c.req.json();
+        // Update allowed fields
+        if (typeof body.enabled === 'boolean') {
+            config.enabled = body.enabled;
+        }
+        if (typeof body.allowRegistration === 'boolean') {
+            config.allowRegistration = body.allowRegistration;
+        }
+        if (body.session) {
+            if (body.session.expiresIn) {
+                config.session.expiresIn = body.session.expiresIn;
+            }
+            if (typeof body.session.secure === 'boolean') {
+                config.session.secure = body.session.secure;
+            }
+        }
+        await authManager.saveAuthConfig(config);
+        return c.json({
+            success: true,
+            message: 'Auth settings updated successfully',
+        });
+    }
+    catch (error) {
+        console.error('Update auth settings error:', error);
+        return c.json({ success: false, error: error.message || 'Failed to update auth settings' }, error.message === 'Admin access required' ? 403 : 500);
+    }
+});
+/**
+ * POST /api/v1/auth-settings/users
+ * Add a new whitelisted user (admin only)
+ */
+authSettings.post('/users', async (c) => {
+    try {
+        requireAdmin(c);
+        const authManager = getAuthManager();
+        const body = await c.req.json();
+        const { email, name, role = 'viewer' } = body;
+        if (!email || !name) {
+            return c.json({ success: false, error: 'Email and name are required' }, 400);
+        }
+        const user = await authManager.addWhitelistedUser(email, name, role);
+        return c.json({
+            success: true,
+            data: {
+                user: {
+                    id: user.id,
+                    email: user.email,
+                    name: user.name,
+                    role: user.role,
+                    registered: user.registered,
+                },
+            },
+        });
+    }
+    catch (error) {
+        console.error('Add user error:', error);
+        return c.json({ success: false, error: error.message || 'Failed to add user' }, error.message === 'Admin access required' ? 403 : 400);
+    }
+});
+/**
+ * PUT /api/v1/auth-settings/users/:id
+ * Update a user (admin only)
+ */
+authSettings.put('/users/:id', async (c) => {
+    try {
+        requireAdmin(c);
+        const authManager = getAuthManager();
+        const userId = c.req.param('id');
+        const body = await c.req.json();
+        const user = await authManager.findUserById(userId);
+        if (!user) {
+            return c.json({ success: false, error: 'User not found' }, 404);
+        }
+        // Update role if provided
+        if (body.role) {
+            await authManager.updateUserRole(userId, body.role);
+        }
+        // Update name if provided
+        if (body.name) {
+            const config = await authManager.loadAuthConfig();
+            const userIndex = config.providers.local.users.findIndex((u) => u.id === userId);
+            if (userIndex !== -1) {
+                config.providers.local.users[userIndex].name = body.name;
+                config.providers.local.users[userIndex].updatedAt = new Date();
+                await authManager.saveAuthConfig(config);
+            }
+        }
+        return c.json({
+            success: true,
+            message: 'User updated successfully',
+        });
+    }
+    catch (error) {
+        console.error('Update user error:', error);
+        return c.json({ success: false, error: error.message || 'Failed to update user' }, error.message === 'Admin access required' ? 403 : 500);
+    }
+});
+/**
+ * POST /api/v1/auth-settings/users/:id/reset-password
+ * Admin reset user password (admin only)
+ */
+authSettings.post('/users/:id/reset-password', async (c) => {
+    try {
+        requireAdmin(c);
+        const authManager = getAuthManager();
+        const userId = c.req.param('id');
+        const body = await c.req.json();
+        if (!body.newPassword) {
+            return c.json({ success: false, error: 'New password is required' }, 400);
+        }
+        if (body.newPassword.length < 8) {
+            return c.json({ success: false, error: 'Password must be at least 8 characters' }, 400);
+        }
+        await authManager.adminResetPassword(userId, body.newPassword);
+        return c.json({
+            success: true,
+            message: 'Password reset successfully',
+        });
+    }
+    catch (error) {
+        console.error('Reset password error:', error);
+        return c.json({ success: false, error: error.message || 'Failed to reset password' }, error.message === 'Admin access required' ? 403 : 400);
+    }
+});
+/**
+ * DELETE /api/v1/auth-settings/users/:id
+ * Remove a user (admin only)
+ */
+authSettings.delete('/users/:id', async (c) => {
+    try {
+        requireAdmin(c);
+        const authManager = getAuthManager();
+        const userId = c.req.param('id');
+        await authManager.removeUser(userId);
+        return c.json({
+            success: true,
+            message: 'User removed successfully',
+        });
+    }
+    catch (error) {
+        console.error('Remove user error:', error);
+        return c.json({ success: false, error: error.message || 'Failed to remove user' }, error.message === 'Admin access required' ? 403 : 400);
+    }
+});
+/**
+ * PUT /api/v1/auth-settings/oauth/:provider
+ * Configure OAuth provider (admin only)
+ */
+authSettings.put('/oauth/:provider', async (c) => {
+    try {
+        requireAdmin(c);
+        const authManager = getAuthManager();
+        const provider = c.req.param('provider');
+        const body = await c.req.json();
+        const config = await authManager.loadAuthConfig();
+        if (!config.providers.oauth) {
+            config.providers.oauth = {};
+        }
+        config.providers.oauth[provider] = body;
+        await authManager.saveAuthConfig(config);
+        return c.json({
+            success: true,
+            message: `${provider} OAuth configuration updated successfully`,
+        });
+    }
+    catch (error) {
+        console.error('Update OAuth config error:', error);
+        return c.json({ success: false, error: error.message || 'Failed to update OAuth configuration' }, error.message === 'Admin access required' ? 403 : 500);
+    }
+});
+export default authSettings;

package/dist/routes/api/v1/context/knowledge/[filename]/route.js

@@ -94,7 +94,7 @@ app.put('/:filename', async (c) => {
         const updatedMetadata = {
             ...currentData,
             ...body.metadata,
-            updated: new Date().toISOString().split('T')[0],
+            updated: new Date().toISOString(),
             // Ensure these are arrays
             tags: body.metadata?.tags !== undefined ? body.metadata.tags : (currentData.tags || []),
             sources: body.metadata?.sources !== undefined ? body.metadata.sources : (currentData.sources || [])

package/dist/routes/api/v1/context/knowledge/route.js

@@ -53,7 +53,7 @@ app.get('/', async (c) => {
                 filename: file,
                 metadata: {
                     ...data,
-                    updated: data.updated || new Date().toISOString().split('T')[0],
+                    updated: data.updated || new Date().toISOString(),
                     tags: data.tags || [],
                     sources: data.sources || []
                 },
@@ -101,7 +101,7 @@ app.post('/', async (c) => {
         const now = new Date();
         const frontmatter = {
             version: '1.0',
-            updated: now.toISOString().split('T')[0],
+            updated: now.toISOString(),
             type: 'knowledge',
             category: body.metadata?.category || 'general',
             tags: body.metadata?.tags || [],

package/dist/server-with-static.js

@@ -21,6 +21,9 @@ app.use('/api/*', cors({
 }));
 // Handle trailing slashes consistently for API routes
 app.use('/api/*', trimTrailingSlash());
+// Import and apply authentication middleware
+import { authMiddleware } from './middleware/auth.js';
+app.use('/api/*', authMiddleware);
 // Create WebSocket support
 const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app });
 // WebSocket route for terminal sessions
@@ -75,6 +78,9 @@ app.get('/ws/terminal-preview/:sessionId', upgradeWebSocket((c) => ({
     },
 })));
 // Import and register API routes
+import auth from './routes/api/v1/auth/index.js';
+import authSettings from './routes/api/v1/auth-settings/index.js';
+import apiKeys from './routes/api/v1/api-keys/index.js';
 import proposals from './routes/api/v1/proposals/index.js';
 import terminalSessions from './routes/api/v1/terminal/sessions/index.js';
 import terminalCreate from './routes/api/v1/terminal/[proposalId]/create/index.js';
@@ -95,6 +101,9 @@ import git from './routes/api/v1/git/index.js';
 import mcp from './routes/api/v1/mcp/index.js';
 // Register API routes FIRST
 console.log('🔗 Registering API routes...');
+app.route('/api/v1/auth', auth);
+app.route('/api/v1/auth-settings', authSettings);
+app.route('/api/v1/api-keys', apiKeys);
 app.route('/api/v1/proposals', proposals);
 app.route('/api/v1/terminal/sessions', terminalSessions);
 app.route('/api/v1/terminal/:proposalId/create', terminalCreate);