profclaw 0.0.1-beta.1

package/dist/routes/notifications.js

@@ -0,0 +1,154 @@
+/**
+ * In-App Notifications API
+ *
+ * CRUD for user notifications with read/unread state.
+ */
+import { Hono } from 'hono';
+import { zValidator } from '@hono/zod-validator';
+import { z } from 'zod';
+import { randomUUID } from 'node:crypto';
+import { getClient } from '../storage/index.js';
+import { logger } from '../utils/logger.js';
+const notificationsRoutes = new Hono();
+// === List Notifications ===
+notificationsRoutes.get('/', async (c) => {
+    const limit = parseInt(c.req.query('limit') || '50');
+    const unreadOnly = c.req.query('unread') === 'true';
+    try {
+        const client = getClient();
+        const whereClause = unreadOnly ? 'WHERE read = 0' : '';
+        const result = await client.execute({
+            sql: `SELECT * FROM notifications ${whereClause} ORDER BY created_at DESC LIMIT ?`,
+            args: [limit],
+        });
+        const countResult = await client.execute({
+            sql: `SELECT COUNT(*) as total FROM notifications WHERE read = 0`,
+            args: [],
+        });
+        const notifications = result.rows.map((row) => ({
+            id: row.id,
+            userId: row.user_id,
+            title: row.title,
+            description: row.description,
+            type: row.type,
+            category: row.category,
+            entityType: row.entity_type,
+            entityId: row.entity_id,
+            read: Boolean(row.read),
+            createdAt: row.created_at,
+        }));
+        return c.json({
+            notifications,
+            total: notifications.length,
+            unreadCount: Number(countResult.rows[0]?.total ?? 0),
+        });
+    }
+    catch (error) {
+        logger.error('[Notifications] List error:', error instanceof Error ? error : undefined);
+        return c.json({ error: 'Failed to list notifications' }, 500);
+    }
+});
+// === Create Notification ===
+notificationsRoutes.post('/', zValidator('json', z.object({
+    title: z.string(),
+    description: z.string().optional(),
+    type: z.enum(['success', 'error', 'info', 'warning']).default('info'),
+    category: z.enum(['system', 'task', 'ticket', 'agent', 'chat', 'cron']).default('system'),
+    entityType: z.string().optional(),
+    entityId: z.string().optional(),
+    userId: z.string().optional(),
+})), async (c) => {
+    const body = c.req.valid('json');
+    try {
+        const id = randomUUID();
+        const client = getClient();
+        await client.execute({
+            sql: `INSERT INTO notifications (id, user_id, title, description, type, category, entity_type, entity_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+            args: [
+                id,
+                body.userId ?? null,
+                body.title,
+                body.description ?? null,
+                body.type,
+                body.category,
+                body.entityType ?? null,
+                body.entityId ?? null,
+            ],
+        });
+        return c.json({
+            id,
+            title: body.title,
+            type: body.type,
+            category: body.category,
+            read: false,
+        }, 201);
+    }
+    catch (error) {
+        logger.error('[Notifications] Create error:', error instanceof Error ? error : undefined);
+        return c.json({ error: 'Failed to create notification' }, 500);
+    }
+});
+// === Mark as Read ===
+notificationsRoutes.patch('/:id/read', async (c) => {
+    const id = c.req.param('id');
+    try {
+        const client = getClient();
+        await client.execute({
+            sql: `UPDATE notifications SET read = 1 WHERE id = ?`,
+            args: [id],
+        });
+        return c.json({ success: true });
+    }
+    catch (error) {
+        logger.error('[Notifications] Mark read error:', error instanceof Error ? error : undefined);
+        return c.json({ error: 'Failed to mark as read' }, 500);
+    }
+});
+// === Mark All as Read ===
+notificationsRoutes.post('/mark-all-read', async (c) => {
+    try {
+        const client = getClient();
+        await client.execute({
+            sql: `UPDATE notifications SET read = 1 WHERE read = 0`,
+            args: [],
+        });
+        return c.json({ success: true });
+    }
+    catch (error) {
+        logger.error('[Notifications] Mark all read error:', error instanceof Error ? error : undefined);
+        return c.json({ error: 'Failed to mark all as read' }, 500);
+    }
+});
+// === Delete Notification ===
+notificationsRoutes.delete('/:id', async (c) => {
+    const id = c.req.param('id');
+    try {
+        const client = getClient();
+        await client.execute({
+            sql: `DELETE FROM notifications WHERE id = ?`,
+            args: [id],
+        });
+        return c.json({ success: true });
+    }
+    catch (error) {
+        logger.error('[Notifications] Delete error:', error instanceof Error ? error : undefined);
+        return c.json({ error: 'Failed to delete notification' }, 500);
+    }
+});
+// === Get Unread Count ===
+notificationsRoutes.get('/unread-count', async (c) => {
+    try {
+        const client = getClient();
+        const result = await client.execute({
+            sql: `SELECT COUNT(*) as count FROM notifications WHERE read = 0`,
+            args: [],
+        });
+        return c.json({ count: Number(result.rows[0]?.count ?? 0) });
+    }
+    catch (error) {
+        logger.error('[Notifications] Count error:', error instanceof Error ? error : undefined);
+        return c.json({ error: 'Failed to get count' }, 500);
+    }
+});
+export { notificationsRoutes };
+//# sourceMappingURL=notifications.js.map

package/dist/routes/oobe.d.ts

@@ -0,0 +1,10 @@
+/**
+ * OOBE (Out-of-Box Experience) Routes
+ *
+ * Public routes for the first-time setup wizard.
+ * Creates a local-mode user without requiring email/password.
+ */
+import { Hono } from 'hono';
+declare const oobe: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export { oobe as oobeRoutes };
+//# sourceMappingURL=oobe.d.ts.map

package/dist/routes/oobe.js

@@ -0,0 +1,405 @@
+/**
+ * OOBE (Out-of-Box Experience) Routes
+ *
+ * Public routes for the first-time setup wizard.
+ * Creates a local-mode user without requiring email/password.
+ */
+import { Hono } from 'hono';
+import { randomUUID } from 'crypto';
+import { eq } from 'drizzle-orm';
+import { z } from 'zod';
+import { getDb } from '../storage/index.js';
+import { users, userPreferences } from '../storage/schema.js';
+import { getSettingsRaw, updateSettings } from '../settings/index.js';
+import { createSession } from '../auth/auth-service.js';
+import { setCookie } from 'hono/cookie';
+import { hashPassword, validatePasswordStrength } from '../auth/password.js';
+import { invalidateLocalAdminCache } from '../auth/middleware.js';
+const oobe = new Hono();
+const COOKIE_OPTIONS = {
+    httpOnly: true,
+    secure: process.env.NODE_ENV === 'production',
+    sameSite: 'lax',
+    maxAge: 30 * 24 * 60 * 60, // 30 days
+    path: '/',
+};
+// SCHEMAS
+const PROVIDER_ENUM = z.enum([
+    'anthropic', 'openai', 'google', 'azure', 'ollama', 'openrouter',
+    'groq', 'xai', 'mistral', 'cohere', 'perplexity', 'deepseek',
+    'together', 'cerebras', 'fireworks', 'copilot',
+]);
+const setupSchema = z.object({
+    name: z.string().min(1).max(100).trim(),
+    avatarUrl: z.string().url().max(500).optional(),
+    aiProvider: z.object({
+        provider: PROVIDER_ENUM,
+        apiKey: z.string().optional(),
+        ollamaBaseUrl: z.string().optional(),
+    }).optional(),
+});
+const enableMultiUserSchema = z.object({
+    email: z.string().email().max(255),
+    password: z.string().min(8).max(128),
+});
+const validateAiSchema = z.object({
+    provider: PROVIDER_ENUM,
+    apiKey: z.string().optional(),
+    ollamaBaseUrl: z.string().optional(),
+});
+async function parseJsonBody(c) {
+    try {
+        const body = await c.req.json();
+        if (!body || typeof body !== 'object' || Array.isArray(body)) {
+            return {
+                ok: false,
+                response: c.json({ error: 'Request body must be a JSON object' }, 400),
+            };
+        }
+        return { ok: true, body: body };
+    }
+    catch {
+        return {
+            ok: false,
+            response: c.json({ error: 'Invalid JSON body' }, 400),
+        };
+    }
+}
+// ROUTES
+/**
+ * GET /api/oobe/status
+ * Check if OOBE setup is needed
+ */
+oobe.get('/status', async (c) => {
+    try {
+        const db = getDb();
+        const settings = await getSettingsRaw();
+        let hasAdmin = false;
+        if (db) {
+            const adminUsers = await db
+                .select({ id: users.id })
+                .from(users)
+                .where(eq(users.role, 'admin'))
+                .limit(1);
+            hasAdmin = adminUsers.length > 0;
+        }
+        return c.json({
+            needsSetup: !hasAdmin,
+            authMode: settings.system.authMode,
+            hasAccessKey: Boolean(settings.system.accessKeyHash),
+        });
+    }
+    catch (error) {
+        console.error('[OOBE] Status check error:', error);
+        return c.json({ needsSetup: true, authMode: 'local' });
+    }
+});
+/**
+ * POST /api/oobe/setup
+ * Create local user and configure AI provider
+ */
+oobe.post('/setup', async (c) => {
+    try {
+        const db = getDb();
+        if (!db) {
+            return c.json({ error: 'Database not initialized' }, 500);
+        }
+        // Check if admin already exists
+        const existingAdmins = await db
+            .select({ id: users.id })
+            .from(users)
+            .where(eq(users.role, 'admin'))
+            .limit(1);
+        if (existingAdmins.length > 0) {
+            return c.json({ error: 'Setup already completed' }, 403);
+        }
+        const parsedBody = await parseJsonBody(c);
+        if (!parsedBody.ok) {
+            return parsedBody.response;
+        }
+        const parsed = setupSchema.safeParse(parsedBody.body);
+        if (!parsed.success) {
+            const firstError = parsed.error.errors[0]?.message || 'Invalid input';
+            return c.json({ error: firstError }, 400);
+        }
+        const { name, avatarUrl, aiProvider: aiConfig } = parsed.data;
+        // Create local admin user with synthetic email
+        const userId = randomUUID();
+        const now = new Date();
+        await db.insert(users).values({
+            id: userId,
+            email: 'owner@profclaw.local',
+            name,
+            avatarUrl: avatarUrl ?? null,
+            role: 'admin',
+            status: 'active',
+            onboardingCompleted: true,
+            createdAt: now,
+            updatedAt: now,
+        });
+        // Create default preferences
+        await db.insert(userPreferences).values({
+            id: randomUUID(),
+            userId,
+            updatedAt: now,
+        });
+        // Configure AI provider if provided
+        if (aiConfig) {
+            const aiSettings = {
+                defaultProvider: aiConfig.provider,
+            };
+            if (aiConfig.provider === 'anthropic' && aiConfig.apiKey) {
+                aiSettings.anthropicKey = aiConfig.apiKey;
+            }
+            else if (aiConfig.provider === 'openai' && aiConfig.apiKey) {
+                aiSettings.openaiKey = aiConfig.apiKey;
+            }
+            else if (aiConfig.provider === 'ollama') {
+                aiSettings.ollamaBaseUrl = aiConfig.ollamaBaseUrl || 'http://localhost:11434';
+            }
+            else if (aiConfig.apiKey) {
+                aiSettings.providerKeys = { [aiConfig.provider]: aiConfig.apiKey };
+            }
+            await updateSettings({ aiProvider: aiSettings });
+        }
+        // Set auth mode to local
+        const settings = await getSettingsRaw();
+        await updateSettings({
+            system: { ...settings.system, authMode: 'local' },
+        });
+        // Create session (for cookie-based auth fallback)
+        const session = await createSession(userId);
+        setCookie(c, 'profclaw_session', session.token, COOKIE_OPTIONS);
+        // Invalidate cached admin in middleware
+        invalidateLocalAdminCache();
+        console.log(`[OOBE] Local admin created: ${name}`);
+        return c.json({
+            success: true,
+            user: {
+                id: userId,
+                email: 'owner@profclaw.local',
+                name,
+                role: 'admin',
+            },
+        });
+    }
+    catch (error) {
+        console.error('[OOBE] Setup error:', error);
+        return c.json({
+            error: 'Setup failed',
+            details: error instanceof Error ? error.message : 'Unknown',
+        }, 500);
+    }
+});
+/**
+ * POST /api/oobe/validate-ai
+ * Test an AI provider key with a small request
+ */
+oobe.post('/validate-ai', async (c) => {
+    try {
+        const parsedBody = await parseJsonBody(c);
+        if (!parsedBody.ok) {
+            return parsedBody.response;
+        }
+        const parsed = validateAiSchema.safeParse(parsedBody.body);
+        if (!parsed.success) {
+            return c.json({ valid: false, error: 'Invalid input' }, 400);
+        }
+        const { provider, apiKey, ollamaBaseUrl } = parsed.data;
+        if (provider === 'ollama') {
+            // Test Ollama connection
+            const baseUrl = ollamaBaseUrl || 'http://localhost:11434';
+            try {
+                const response = await fetch(`${baseUrl}/api/tags`, {
+                    signal: AbortSignal.timeout(5000),
+                });
+                if (!response.ok) {
+                    return c.json({ valid: false, error: `Ollama returned HTTP ${response.status}` });
+                }
+                const data = await response.json();
+                return c.json({
+                    valid: true,
+                    message: `Connected to Ollama (${Array.isArray(data.models) ? data.models.length : 0} models available)`,
+                });
+            }
+            catch {
+                return c.json({ valid: false, error: 'Cannot connect to Ollama. Is it running?' });
+            }
+        }
+        // Test OpenAI or Anthropic key
+        if (!apiKey) {
+            return c.json({ valid: false, error: 'API key is required' }, 400);
+        }
+        if (provider === 'anthropic') {
+            try {
+                const response = await fetch('https://api.anthropic.com/v1/messages', {
+                    method: 'POST',
+                    headers: {
+                        'x-api-key': apiKey,
+                        'anthropic-version': '2023-06-01',
+                        'content-type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        model: 'claude-haiku-4-5-20251001',
+                        max_tokens: 1,
+                        messages: [{ role: 'user', content: 'hi' }],
+                    }),
+                    signal: AbortSignal.timeout(10000),
+                });
+                if (response.ok || response.status === 200) {
+                    return c.json({ valid: true, message: 'Anthropic API key is valid' });
+                }
+                const error = await response.json();
+                return c.json({
+                    valid: false,
+                    error: error?.error?.message || `HTTP ${response.status}`,
+                });
+            }
+            catch (err) {
+                return c.json({
+                    valid: false,
+                    error: err instanceof Error ? err.message : 'Connection failed',
+                });
+            }
+        }
+        if (provider === 'openai') {
+            try {
+                const response = await fetch('https://api.openai.com/v1/models', {
+                    headers: { Authorization: `Bearer ${apiKey}` },
+                    signal: AbortSignal.timeout(10000),
+                });
+                if (response.ok) {
+                    return c.json({ valid: true, message: 'OpenAI API key is valid' });
+                }
+                const error = await response.json();
+                return c.json({
+                    valid: false,
+                    error: error?.error?.message || `HTTP ${response.status}`,
+                });
+            }
+            catch (err) {
+                return c.json({
+                    valid: false,
+                    error: err instanceof Error ? err.message : 'Connection failed',
+                });
+            }
+        }
+        // OpenAI-compatible providers
+        const COMPATIBLE_URLS = {
+            groq: 'https://api.groq.com/openai/v1/models',
+            xai: 'https://api.x.ai/v1/models',
+            deepseek: 'https://api.deepseek.com/v1/models',
+            together: 'https://api.together.xyz/v1/models',
+            fireworks: 'https://api.fireworks.ai/inference/v1/models',
+            mistral: 'https://api.mistral.ai/v1/models',
+            openrouter: 'https://openrouter.ai/api/v1/models',
+            cerebras: 'https://api.cerebras.ai/v1/models',
+        };
+        const compatibleUrl = COMPATIBLE_URLS[provider];
+        if (compatibleUrl && apiKey) {
+            try {
+                const response = await fetch(compatibleUrl, {
+                    headers: { Authorization: `Bearer ${apiKey}` },
+                    signal: AbortSignal.timeout(10000),
+                });
+                if (response.ok) {
+                    return c.json({ valid: true, message: `${provider} API key is valid` });
+                }
+                const errBody = await response.json();
+                return c.json({
+                    valid: false,
+                    error: errBody?.error?.message || `HTTP ${response.status}`,
+                });
+            }
+            catch (err) {
+                return c.json({
+                    valid: false,
+                    error: err instanceof Error ? err.message : 'Connection failed',
+                });
+            }
+        }
+        // Other providers - accept key without live validation
+        if (apiKey && apiKey.length > 0) {
+            return c.json({ valid: true, message: `API key accepted for ${provider}` });
+        }
+        return c.json({ valid: false, error: 'API key is required' }, 400);
+    }
+    catch (error) {
+        console.error('[OOBE] AI validation error:', error);
+        return c.json({ valid: false, error: 'Validation failed' }, 500);
+    }
+});
+/**
+ * POST /api/oobe/enable-multiuser
+ * Set email + password on the owner account and switch to multi-user auth mode
+ */
+oobe.post('/enable-multiuser', async (c) => {
+    try {
+        const db = getDb();
+        if (!db) {
+            return c.json({ error: 'Database not initialized' }, 500);
+        }
+        const parsedBody = await parseJsonBody(c);
+        if (!parsedBody.ok) {
+            return parsedBody.response;
+        }
+        const parsed = enableMultiUserSchema.safeParse(parsedBody.body);
+        if (!parsed.success) {
+            const firstError = parsed.error.errors[0]?.message || 'Invalid input';
+            return c.json({ error: firstError }, 400);
+        }
+        const { email, password } = parsed.data;
+        // Validate password strength
+        const passwordError = validatePasswordStrength(password);
+        if (passwordError) {
+            return c.json({ error: passwordError }, 400);
+        }
+        // Find the admin user (owner)
+        const admins = await db
+            .select()
+            .from(users)
+            .where(eq(users.role, 'admin'))
+            .limit(1);
+        if (admins.length === 0) {
+            return c.json({ error: 'No admin user found' }, 404);
+        }
+        const admin = admins[0];
+        // Check if email is already taken by another user
+        const existingEmail = await db
+            .select({ id: users.id })
+            .from(users)
+            .where(eq(users.email, email.toLowerCase()))
+            .limit(1);
+        if (existingEmail.length > 0 && existingEmail[0].id !== admin.id) {
+            return c.json({ error: 'Email already in use' }, 400);
+        }
+        // Update admin with real email and password
+        const passwordHash = hashPassword(password);
+        await db
+            .update(users)
+            .set({
+            email: email.toLowerCase(),
+            passwordHash,
+            updatedAt: new Date(),
+        })
+            .where(eq(users.id, admin.id));
+        // Switch auth mode to multi
+        const settings = await getSettingsRaw();
+        await updateSettings({
+            system: { ...settings.system, authMode: 'multi' },
+        });
+        // Invalidate cached admin
+        invalidateLocalAdminCache();
+        console.log(`[OOBE] Multi-user mode enabled for: ${email}`);
+        return c.json({
+            success: true,
+            message: 'Multi-user authentication enabled',
+        });
+    }
+    catch (error) {
+        console.error('[OOBE] Enable multi-user error:', error);
+        return c.json({ error: 'Failed to enable multi-user mode' }, 500);
+    }
+});
+export { oobe as oobeRoutes };
+//# sourceMappingURL=oobe.js.map

package/dist/routes/openapi.d.ts

@@ -0,0 +1,9 @@
+/**
+ * OpenAPI Documentation Route
+ *
+ * Serves the OpenAPI spec as JSON and provides a Swagger UI page.
+ */
+import { Hono } from 'hono';
+declare const openApiRoutes: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export { openApiRoutes };
+//# sourceMappingURL=openapi.d.ts.map