profclaw 0.0.1-beta.1

package/dist/routes/search.js

@@ -0,0 +1,189 @@
+import { Hono } from 'hono';
+import { getStorage } from '../storage/index.js';
+import { getEmbeddingService } from '../ai/embedding-service.js';
+import { getSummary, searchSummaries } from '../summaries/index.js';
+import { getTask, getTasks } from '../queue/index.js';
+import { logger } from '../utils/logger.js';
+const search = new Hono();
+const validSearchTypes = new Set(['task', 'summary', 'all']);
+/**
+ * Unified semantic search endpoint
+ *
+ * Searches across tasks and summaries using vector embeddings.
+ * Falls back to text search if embeddings are not available.
+ *
+ * Query params:
+ * - q: Search query (required)
+ * - type: 'task' | 'summary' | 'all' (default: 'all')
+ * - limit: Max results (default: 10)
+ * - threshold: Minimum similarity score 0-1 (default: 0.5)
+ */
+search.get('/semantic', async (c) => {
+    const query = c.req.query('q');
+    const type = (c.req.query('type') || 'all');
+    const limit = parseInt(c.req.query('limit') || '10');
+    const threshold = parseFloat(c.req.query('threshold') || '0.5');
+    if (!query) {
+        return c.json({ error: 'Query parameter "q" is required' }, 400);
+    }
+    if (!validSearchTypes.has(type)) {
+        return c.json({ error: 'Invalid search type' }, 400);
+    }
+    const storage = getStorage();
+    const results = {
+        tasks: [],
+        summaries: [],
+        totalResults: 0,
+    };
+    try {
+        // Check if semantic search is supported
+        if (!storage.searchSimilar) {
+            // Fall back to text search
+            logger.info('[Search] Semantic search not supported, falling back to text search');
+            if (type === 'all' || type === 'summary') {
+                const summaryResults = await searchSummaries(query, limit);
+                results.summaries = summaryResults.map((s) => ({
+                    summary: s,
+                    score: 1.0, // Text search doesn't provide scores
+                }));
+            }
+            if (type === 'all' || type === 'task') {
+                const allTasks = await getTasks();
+                const taskResults = allTasks.filter((t) => {
+                    const searchText = `${t.title} ${t.description || ''} ${t.prompt}`.toLowerCase();
+                    return searchText.includes(query.toLowerCase());
+                }).slice(0, limit);
+                results.tasks = taskResults.map((t) => ({
+                    task: t,
+                    score: 1.0,
+                }));
+            }
+            results.totalResults = results.tasks.length + results.summaries.length;
+            return c.json({
+                query,
+                type,
+                method: 'text',
+                ...results,
+            });
+        }
+        // Generate embedding for query
+        const embeddingService = getEmbeddingService();
+        const queryEmbedding = await embeddingService.generateEmbedding(query);
+        // Search summaries
+        if (type === 'all' || type === 'summary') {
+            const summaryMatches = await storage.searchSimilar('summary', queryEmbedding, limit);
+            for (const match of summaryMatches) {
+                if (match.distance >= threshold) {
+                    const summary = await getSummary(match.entityId);
+                    if (summary) {
+                        results.summaries.push({
+                            summary,
+                            score: match.distance,
+                        });
+                    }
+                }
+            }
+        }
+        // Search tasks
+        if (type === 'all' || type === 'task') {
+            const taskMatches = await storage.searchSimilar('task', queryEmbedding, limit);
+            for (const match of taskMatches) {
+                if (match.distance >= threshold) {
+                    const task = await getTask(match.entityId);
+                    if (task) {
+                        results.tasks.push({
+                            task,
+                            score: match.distance,
+                        });
+                    }
+                }
+            }
+        }
+        // Sort by score
+        results.tasks.sort((a, b) => b.score - a.score);
+        results.summaries.sort((a, b) => b.score - a.score);
+        results.totalResults = results.tasks.length + results.summaries.length;
+        return c.json({
+            query,
+            type,
+            method: 'semantic',
+            threshold,
+            ...results,
+        });
+    }
+    catch (error) {
+        logger.error('[Search] Semantic search failed:', error);
+        return c.json({
+            error: 'Search failed',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        }, 500);
+    }
+});
+/**
+ * Full-text search across all entities
+ */
+search.get('/text', async (c) => {
+    const query = c.req.query('q');
+    const type = (c.req.query('type') || 'all');
+    const limit = parseInt(c.req.query('limit') || '20');
+    if (!query) {
+        return c.json({ error: 'Query parameter "q" is required' }, 400);
+    }
+    if (!validSearchTypes.has(type)) {
+        return c.json({ error: 'Invalid search type' }, 400);
+    }
+    const results = {
+        tasks: [],
+        summaries: [],
+        totalResults: 0,
+    };
+    try {
+        const queryLower = query.toLowerCase();
+        if (type === 'all' || type === 'summary') {
+            results.summaries = await searchSummaries(query, limit);
+        }
+        if (type === 'all' || type === 'task') {
+            const allTasks = await getTasks();
+            results.tasks = allTasks.filter((t) => {
+                const searchText = `${t.title} ${t.description || ''} ${t.prompt}`.toLowerCase();
+                return searchText.includes(queryLower);
+            }).slice(0, limit);
+        }
+        results.totalResults = results.tasks.length + results.summaries.length;
+        return c.json({
+            query,
+            type,
+            ...results,
+        });
+    }
+    catch (error) {
+        logger.error('[Search] Text search failed:', error);
+        return c.json({
+            error: 'Search failed',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        }, 500);
+    }
+});
+/**
+ * Get search capabilities
+ */
+search.get('/capabilities', async (c) => {
+    const storage = getStorage();
+    const hasSemanticSearch = !!storage.searchSimilar;
+    let embeddingProvider = 'none';
+    try {
+        const service = getEmbeddingService();
+        embeddingProvider = service.provider || 'unknown';
+    }
+    catch {
+        // No embedding service available
+    }
+    return c.json({
+        textSearch: true,
+        semanticSearch: hasSemanticSearch,
+        embeddingProvider,
+        supportedTypes: ['task', 'summary', 'all'],
+    });
+});
+export { search as searchRoutes };
+//# sourceMappingURL=search.js.map

package/dist/routes/security.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Security API Routes
+ *
+ * Manages security policies, DM pairing, channel allowlists,
+ * exec policies, plugin permissions, and risk analysis.
+ */
+import { Hono } from 'hono';
+declare const security: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default security;
+//# sourceMappingURL=security.d.ts.map

package/dist/routes/security.js

@@ -0,0 +1,189 @@
+/**
+ * Security API Routes
+ *
+ * Manages security policies, DM pairing, channel allowlists,
+ * exec policies, plugin permissions, and risk analysis.
+ */
+import { Hono } from 'hono';
+import { getSecurityManager } from '../chat/execution/security.js';
+const security = new Hono();
+// Security Policy
+security.get('/policy', (c) => {
+    const manager = getSecurityManager();
+    return c.json({ success: true, data: manager.getPolicy() });
+});
+security.patch('/policy', async (c) => {
+    const body = await c.req.json();
+    const manager = getSecurityManager();
+    manager.updatePolicy(body);
+    return c.json({ success: true, data: manager.getPolicy() });
+});
+// DM Pairing
+security.post('/pairing/generate', async (c) => {
+    const { senderId, channelProvider } = await c.req.json();
+    if (!senderId || !channelProvider) {
+        return c.json({ success: false, error: 'senderId and channelProvider required' }, 400);
+    }
+    const manager = getSecurityManager();
+    const session = manager.generatePairingCode(senderId, channelProvider);
+    return c.json({ success: true, data: { code: session.code, expiresAt: session.expiresAt, verified: session.verified } });
+});
+security.post('/pairing/verify', async (c) => {
+    const { senderId, channelProvider, code } = await c.req.json();
+    if (!senderId || !channelProvider || !code) {
+        return c.json({ success: false, error: 'senderId, channelProvider, and code required' }, 400);
+    }
+    const manager = getSecurityManager();
+    const verified = manager.verifyPairingCode(senderId, channelProvider, code);
+    return c.json({ success: true, data: { verified } });
+});
+security.get('/pairing/trusted/:senderId', (c) => {
+    const senderId = c.req.param('senderId');
+    const manager = getSecurityManager();
+    return c.json({ success: true, data: { trusted: manager.isDMSenderTrusted(senderId) } });
+});
+// Channel Allowlist
+security.get('/channels', (c) => {
+    const manager = getSecurityManager();
+    return c.json({ success: true, data: manager.getChannelAllowlist() });
+});
+security.post('/channels', async (c) => {
+    const entry = await c.req.json();
+    if (!entry.channelId || !entry.provider) {
+        return c.json({ success: false, error: 'channelId and provider required' }, 400);
+    }
+    entry.addedAt = entry.addedAt ?? new Date().toISOString();
+    entry.enabled = entry.enabled ?? true;
+    const manager = getSecurityManager();
+    manager.addChannelToAllowlist(entry);
+    return c.json({ success: true, data: entry });
+});
+security.delete('/channels/:provider/:channelId', (c) => {
+    const provider = c.req.param('provider');
+    const channelId = c.req.param('channelId');
+    const manager = getSecurityManager();
+    const removed = manager.removeChannelFromAllowlist(channelId, provider);
+    return c.json({ success: true, data: { removed } });
+});
+// Exec Approval Policies
+security.get('/exec-policies', (c) => {
+    const manager = getSecurityManager();
+    return c.json({ success: true, data: manager.getExecPolicies() });
+});
+security.post('/exec-policies', async (c) => {
+    const policy = await c.req.json();
+    if (!policy.id || !policy.name || !policy.action) {
+        return c.json({ success: false, error: 'id, name, and action required' }, 400);
+    }
+    policy.priority = policy.priority ?? 0;
+    policy.enabled = policy.enabled ?? true;
+    const manager = getSecurityManager();
+    manager.addExecPolicy(policy);
+    return c.json({ success: true, data: policy });
+});
+security.delete('/exec-policies/:id', (c) => {
+    const id = c.req.param('id');
+    const manager = getSecurityManager();
+    const removed = manager.removeExecPolicy(id);
+    return c.json({ success: true, data: { removed } });
+});
+// Plugin Allowlist
+security.get('/plugins', (c) => {
+    const manager = getSecurityManager();
+    return c.json({ success: true, data: manager.getPluginAllowlist() });
+});
+security.post('/plugins', async (c) => {
+    const entry = await c.req.json();
+    if (!entry.pluginId || !entry.name) {
+        return c.json({ success: false, error: 'pluginId and name required' }, 400);
+    }
+    entry.addedAt = entry.addedAt ?? new Date().toISOString();
+    entry.permissions = entry.permissions ?? [];
+    entry.trusted = entry.trusted ?? false;
+    const manager = getSecurityManager();
+    manager.addPluginToAllowlist(entry);
+    return c.json({ success: true, data: entry });
+});
+security.delete('/plugins/:pluginId', (c) => {
+    const pluginId = c.req.param('pluginId');
+    const manager = getSecurityManager();
+    const removed = manager.removePluginFromAllowlist(pluginId);
+    return c.json({ success: true, data: { removed } });
+});
+// Channel Policies (retry/timeout)
+security.get('/channel-policies', (c) => {
+    const manager = getSecurityManager();
+    return c.json({ success: true, data: manager.getChannelPolicies() });
+});
+security.post('/channel-policies', async (c) => {
+    const policy = await c.req.json();
+    if (!policy.channelId || !policy.provider) {
+        return c.json({ success: false, error: 'channelId and provider required' }, 400);
+    }
+    policy.retryAttempts = policy.retryAttempts ?? 3;
+    policy.retryDelayMs = policy.retryDelayMs ?? 1000;
+    policy.timeoutMs = policy.timeoutMs ?? 300_000;
+    const manager = getSecurityManager();
+    manager.setChannelPolicy(policy);
+    return c.json({ success: true, data: policy });
+});
+security.delete('/channel-policies/:provider/:channelId', (c) => {
+    const provider = c.req.param('provider');
+    const channelId = c.req.param('channelId');
+    const manager = getSecurityManager();
+    const removed = manager.removeChannelPolicy(channelId, provider);
+    return c.json({ success: true, data: { removed } });
+});
+// Risk Analysis
+security.post('/analyze-risk', async (c) => {
+    const { toolName, params } = await c.req.json();
+    if (!toolName) {
+        return c.json({ success: false, error: 'toolName required' }, 400);
+    }
+    // Build a minimal tool definition for analysis
+    const { getToolRegistry } = await import('../chat/execution/registry.js');
+    const registry = getToolRegistry();
+    const tool = registry.get(toolName);
+    if (!tool) {
+        return c.json({ success: false, error: `Tool not found: ${toolName}` }, 404);
+    }
+    const manager = getSecurityManager();
+    const analysis = manager.analyzeRisk(tool, params ?? {});
+    return c.json({ success: true, data: analysis });
+});
+// Approval Management
+security.get('/approvals', (c) => {
+    const conversationId = c.req.query('conversationId');
+    const manager = getSecurityManager();
+    return c.json({ success: true, data: manager.getPendingApprovals(conversationId) });
+});
+security.post('/approvals/:id/respond', async (c) => {
+    const requestId = c.req.param('id');
+    const { decision, userId } = await c.req.json();
+    if (!decision || !['allow-once', 'allow-always', 'deny'].includes(decision)) {
+        return c.json({ success: false, error: 'Valid decision required: allow-once, allow-always, deny' }, 400);
+    }
+    const manager = getSecurityManager();
+    const handled = manager.handleApprovalResponse({ requestId, decision, userId });
+    return c.json({ success: true, data: { handled } });
+});
+// Audit / Status
+security.get('/status', (c) => {
+    const manager = getSecurityManager();
+    const policy = manager.getPolicy();
+    return c.json({
+        success: true,
+        data: {
+            mode: policy.mode,
+            allowlistEntries: policy.allowlist?.length ?? 0,
+            channelAllowlistEntries: policy.channelAllowlist?.length ?? 0,
+            execPolicies: policy.execPolicies?.length ?? 0,
+            pluginAllowlistEntries: policy.pluginAllowlist?.length ?? 0,
+            channelPolicies: policy.channelPolicies?.length ?? 0,
+            dmPairingEnabled: policy.dmPairing?.enabled ?? false,
+            pendingApprovals: manager.getPendingApprovals().length,
+        },
+    });
+});
+export default security;
+//# sourceMappingURL=security.js.map

package/dist/routes/settings.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from 'hono';
+declare const settings: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export { settings as settingsRoutes };
+//# sourceMappingURL=settings.d.ts.map

package/dist/routes/settings.js

@@ -0,0 +1,119 @@
+import { Hono } from 'hono';
+import { getSettings, updateSettings, resetSettings, UpdateSettingsSchema, getPluginHealth, togglePlugin, } from '../settings/index.js';
+const settings = new Hono();
+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),
+        };
+    }
+}
+// Get current settings (secrets masked)
+settings.get('/', async (c) => {
+    try {
+        const currentSettings = await getSettings();
+        return c.json({ settings: currentSettings });
+    }
+    catch (error) {
+        console.error('[API] Error fetching settings:', error);
+        return c.json({
+            error: 'Failed to fetch settings',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        }, 500);
+    }
+});
+// Update settings (partial update)
+settings.patch('/', async (c) => {
+    try {
+        const parsedBody = await parseJsonBody(c);
+        if (!parsedBody.ok) {
+            return parsedBody.response;
+        }
+        const parsed = UpdateSettingsSchema.safeParse(parsedBody.body);
+        if (!parsed.success) {
+            return c.json({
+                error: 'Validation failed',
+                details: parsed.error.flatten(),
+            }, 400);
+        }
+        const updated = await updateSettings(parsed.data);
+        return c.json({
+            message: 'Settings updated',
+            settings: updated,
+        });
+    }
+    catch (error) {
+        console.error('[API] Error updating settings:', error);
+        return c.json({
+            error: 'Failed to update settings',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        }, 500);
+    }
+});
+// Reset settings to defaults
+settings.post('/reset', async (c) => {
+    try {
+        const resetResult = await resetSettings();
+        return c.json({
+            message: 'Settings reset to defaults',
+            settings: resetResult,
+        });
+    }
+    catch (error) {
+        console.error('[API] Error resetting settings:', error);
+        return c.json({
+            error: 'Failed to reset settings',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        }, 500);
+    }
+});
+// Get plugin health status
+settings.get('/plugins/health', async (c) => {
+    try {
+        const health = await getPluginHealth();
+        return c.json({ plugins: health });
+    }
+    catch (error) {
+        console.error('[API] Error checking plugin health:', error);
+        return c.json({
+            error: 'Failed to check plugin health',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        }, 500);
+    }
+});
+// Toggle plugin enabled/disabled
+settings.post('/plugins/:id/toggle', async (c) => {
+    try {
+        const id = c.req.param('id');
+        const parsedBody = await parseJsonBody(c);
+        if (!parsedBody.ok) {
+            return parsedBody.response;
+        }
+        const enabled = Boolean(parsedBody.body.enabled);
+        const result = await togglePlugin(id, enabled);
+        return c.json({
+            message: `Plugin ${id} ${enabled ? 'enabled' : 'disabled'}`,
+            settings: result,
+        });
+    }
+    catch (error) {
+        console.error('[API] Error toggling plugin:', error);
+        return c.json({
+            error: 'Failed to toggle plugin',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        }, error instanceof Error && error.message.includes('Unknown') ? 404 : 500);
+    }
+});
+export { settings as settingsRoutes };
+//# sourceMappingURL=settings.js.map

package/dist/routes/setup.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Setup Routes
+ *
+ * Public routes for initial app setup and configuration status.
+ * These routes are accessible without authentication to allow
+ * first-time setup and configuration checks.
+ */
+import { Hono } from 'hono';
+declare const setup: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export { setup as setupRoutes };
+//# sourceMappingURL=setup.d.ts.map