profclaw 0.0.1-beta.1

package/dist/routes/integrations.js

@@ -0,0 +1,200 @@
+/**
+ * Integrations Route
+ *
+ * Manage external service integrations (web search, etc.)
+ * Provides config management and availability checks.
+ */
+import { Hono } from 'hono';
+import { z } from 'zod';
+import { getSettingsRaw, updateSettings } from '../settings/index.js';
+// Stub for web search availability check until settings supports it
+async function checkWebSearchAvailable() {
+    return { available: false, reason: 'Web search not configured in settings' };
+}
+import { setWebSearchConfig, checkWebSearchAvailable as toolCheckAvailable } from '../chat/execution/tools/web-search.js';
+import { WebSearchConfigSchema, getDefaultWebSearchConfig } from '../integrations/web-search.js';
+import { logger } from '../utils/logger.js';
+const integrations = new Hono();
+// Web Search Integration
+/**
+ * GET /api/integrations/web-search
+ * Get web search configuration and status
+ */
+integrations.get('/web-search', async (c) => {
+    try {
+        const settings = await getSettingsRaw();
+        const webSearch = settings.webSearch || getDefaultWebSearchConfig();
+        const availability = await checkWebSearchAvailable();
+        // Mask API keys for display
+        const masked = {
+            enabled: webSearch.enabled,
+            provider: webSearch.provider,
+            brave: webSearch.brave ? { apiKey: maskApiKey(webSearch.brave.apiKey) } : undefined,
+            serper: webSearch.serper ? { apiKey: maskApiKey(webSearch.serper.apiKey) } : undefined,
+            searxng: webSearch.searxng ? {
+                baseUrl: webSearch.searxng.baseUrl,
+                apiKey: maskApiKey(webSearch.searxng.apiKey),
+            } : undefined,
+            tavily: webSearch.tavily ? { apiKey: maskApiKey(webSearch.tavily.apiKey) } : undefined,
+        };
+        return c.json({
+            config: masked,
+            status: {
+                available: availability.available,
+                provider: availability.provider,
+                reason: availability.reason,
+            },
+            // List available providers for UI
+            providers: [
+                { id: 'brave', name: 'Brave Search', description: 'Fast, privacy-focused search', configFields: ['apiKey'] },
+                { id: 'serper', name: 'Serper (Google)', description: 'Google Search results via API', configFields: ['apiKey'] },
+                { id: 'searxng', name: 'SearXNG', description: 'Self-hosted metasearch engine', configFields: ['baseUrl', 'apiKey'] },
+                { id: 'tavily', name: 'Tavily', description: 'AI-optimized search API', configFields: ['apiKey'] },
+            ],
+        });
+    }
+    catch (error) {
+        logger.error('[Integrations] Error fetching web search config:', { error });
+        return c.json({
+            error: 'Failed to fetch web search configuration',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        }, 500);
+    }
+});
+/**
+ * PATCH /api/integrations/web-search
+ * Update web search configuration
+ */
+integrations.patch('/web-search', async (c) => {
+    try {
+        const body = await c.req.json();
+        // Validate partial update
+        const UpdateSchema = z.object({
+            enabled: z.boolean().optional(),
+            provider: z.enum(['brave', 'serper', 'searxng', 'tavily']).optional(),
+            brave: z.object({
+                apiKey: z.string().optional(),
+            }).optional(),
+            serper: z.object({
+                apiKey: z.string().optional(),
+            }).optional(),
+            searxng: z.object({
+                baseUrl: z.string().url().optional(),
+                apiKey: z.string().optional(),
+            }).optional(),
+            tavily: z.object({
+                apiKey: z.string().optional(),
+            }).optional(),
+        });
+        const parsed = UpdateSchema.safeParse(body);
+        if (!parsed.success) {
+            return c.json({
+                error: 'Validation failed',
+                details: parsed.error.flatten(),
+            }, 400);
+        }
+        // Get current settings and merge
+        const current = await getSettingsRaw();
+        const currentWebSearch = current.webSearch || getDefaultWebSearchConfig();
+        // Don't overwrite existing API keys with masked values
+        const updatedWebSearch = {
+            enabled: parsed.data.enabled ?? currentWebSearch.enabled,
+            provider: parsed.data.provider ?? currentWebSearch.provider,
+            brave: mergeProviderConfig(currentWebSearch.brave, parsed.data.brave),
+            serper: mergeProviderConfig(currentWebSearch.serper, parsed.data.serper),
+            searxng: mergeProviderConfigWithUrl(currentWebSearch.searxng, parsed.data.searxng),
+            tavily: mergeProviderConfig(currentWebSearch.tavily, parsed.data.tavily),
+        };
+        // Update settings
+        // TODO: Add webSearch to main settings schema
+        await updateSettings({ integrations: {} }); // Stub - webSearch not in settings yet
+        // Reload the web search tool config
+        const fullConfig = WebSearchConfigSchema.parse(updatedWebSearch);
+        setWebSearchConfig(fullConfig);
+        // Check new availability
+        const availability = toolCheckAvailable();
+        logger.info(`[Integrations] Web search config updated, provider: ${updatedWebSearch.provider}, enabled: ${updatedWebSearch.enabled}`);
+        return c.json({
+            message: 'Web search configuration updated',
+            status: {
+                available: availability.available,
+                provider: availability.provider,
+                reason: availability.reason,
+            },
+        });
+    }
+    catch (error) {
+        logger.error('[Integrations] Error updating web search config:', { error });
+        return c.json({
+            error: 'Failed to update web search configuration',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        }, 500);
+    }
+});
+/**
+ * POST /api/integrations/web-search/test
+ * Test web search configuration
+ */
+integrations.post('/web-search/test', async (c) => {
+    try {
+        const { webSearch } = await import('../integrations/web-search.js');
+        const settings = await getSettingsRaw();
+        const config = settings.webSearch || getDefaultWebSearchConfig();
+        if (!config.enabled) {
+            return c.json({
+                success: false,
+                error: 'Web search is disabled',
+            }, 400);
+        }
+        // Parse the full config
+        const fullConfig = WebSearchConfigSchema.parse(config);
+        // Run a test search
+        const result = await webSearch('test query', fullConfig, { count: 1 });
+        return c.json({
+            success: true,
+            provider: result.provider,
+            resultCount: result.results.length,
+            sample: result.results[0] ? {
+                title: result.results[0].title,
+                url: result.results[0].url,
+            } : null,
+        });
+    }
+    catch (error) {
+        logger.error('[Integrations] Web search test failed:', { error });
+        return c.json({
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        }, 500);
+    }
+});
+// Helpers
+function maskApiKey(key) {
+    if (!key)
+        return undefined;
+    if (key.length < 8)
+        return '••••••••';
+    return key.slice(0, 4) + '••••' + key.slice(-4);
+}
+function mergeProviderConfig(current, update) {
+    if (!update)
+        return current;
+    // Don't overwrite with masked values
+    const newKey = update.apiKey && !update.apiKey.includes('••••')
+        ? update.apiKey
+        : current?.apiKey;
+    return { apiKey: newKey };
+}
+function mergeProviderConfigWithUrl(current, update) {
+    if (!update)
+        return current;
+    const newKey = update.apiKey && !update.apiKey.includes('••••')
+        ? update.apiKey
+        : current?.apiKey;
+    return {
+        baseUrl: update.baseUrl ?? current?.baseUrl,
+        apiKey: newKey,
+    };
+}
+export { integrations as integrationsRoutes };
+//# sourceMappingURL=integrations.js.map

package/dist/routes/labels.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Labels API Routes
+ *
+ * CRUD operations for labels with project scoping.
+ */
+import { Hono } from 'hono';
+export declare const labelsRoutes: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+//# sourceMappingURL=labels.d.ts.map

package/dist/routes/labels.js

@@ -0,0 +1,240 @@
+/**
+ * Labels API Routes
+ *
+ * CRUD operations for labels with project scoping.
+ */
+import { Hono } from 'hono';
+import { z } from 'zod';
+import { createLabel, getLabel, listLabels, updateLabel, deleteLabel, getTicketLabels, addLabelToTicket, removeLabelFromTicket, setTicketLabels, } from '../labels/index.js';
+export const labelsRoutes = new Hono();
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : undefined;
+}
+const createLabelBodySchema = z.object({
+    name: z.string().min(1),
+    description: z.string().optional(),
+    color: z.string().optional(),
+    parentId: z.string().optional(),
+});
+const updateLabelBodySchema = z.object({
+    name: z.string().optional(),
+    description: z.string().optional(),
+    color: z.string().optional(),
+    parentId: z.string().nullable().optional(),
+    sortOrder: z.number().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),
+        };
+    }
+}
+// PROJECT LABELS
+/**
+ * GET /api/projects/:projectId/labels
+ * List all labels for a project
+ */
+labelsRoutes.get('/projects/:projectId/labels', async (c) => {
+    try {
+        const projectId = c.req.param('projectId');
+        const labelsList = await listLabels(projectId);
+        return c.json({
+            labels: labelsList,
+            count: labelsList.length,
+        });
+    }
+    catch (error) {
+        console.error('[Labels] List error:', error);
+        return c.json({ error: error instanceof Error ? error.message : 'Failed to list labels' }, 500);
+    }
+});
+/**
+ * POST /api/projects/:projectId/labels
+ * Create a new label for a project
+ */
+labelsRoutes.post('/projects/:projectId/labels', async (c) => {
+    try {
+        const projectId = c.req.param('projectId');
+        const parsed = await parseJsonBody(c);
+        if (!parsed.ok) {
+            return parsed.response;
+        }
+        const bodyParse = createLabelBodySchema.safeParse(parsed.body);
+        if (!bodyParse.success) {
+            return c.json({ error: 'name is required' }, 400);
+        }
+        const body = bodyParse.data;
+        const label = await createLabel({
+            projectId,
+            name: body.name,
+            description: body.description,
+            color: body.color,
+            parentId: body.parentId,
+        });
+        return c.json(label, 201);
+    }
+    catch (error) {
+        console.error('[Labels] Create error:', error);
+        if (getErrorMessage(error)?.includes('UNIQUE constraint')) {
+            return c.json({ error: 'A label with this name already exists' }, 409);
+        }
+        return c.json({ error: getErrorMessage(error) ?? 'Failed to create label' }, 500);
+    }
+});
+/**
+ * GET /api/labels/:id
+ * Get a single label by ID
+ */
+labelsRoutes.get('/labels/:id', async (c) => {
+    try {
+        const id = c.req.param('id');
+        const label = await getLabel(id);
+        if (!label) {
+            return c.json({ error: 'Label not found' }, 404);
+        }
+        return c.json(label);
+    }
+    catch (error) {
+        console.error('[Labels] Get error:', error);
+        return c.json({ error: error instanceof Error ? error.message : 'Failed to get label' }, 500);
+    }
+});
+/**
+ * PATCH /api/labels/:id
+ * Update a label
+ */
+labelsRoutes.patch('/labels/:id', async (c) => {
+    try {
+        const id = c.req.param('id');
+        const parsed = await parseJsonBody(c);
+        if (!parsed.ok) {
+            return parsed.response;
+        }
+        const bodyParse = updateLabelBodySchema.safeParse(parsed.body);
+        if (!bodyParse.success) {
+            return c.json({ error: 'Invalid label update' }, 400);
+        }
+        const body = bodyParse.data;
+        const label = await updateLabel(id, {
+            name: body.name,
+            description: body.description,
+            color: body.color,
+            parentId: body.parentId,
+            sortOrder: body.sortOrder,
+        });
+        return c.json(label);
+    }
+    catch (error) {
+        console.error('[Labels] Update error:', error);
+        if (getErrorMessage(error)?.includes('not found')) {
+            return c.json({ error: 'Label not found' }, 404);
+        }
+        return c.json({ error: getErrorMessage(error) ?? 'Failed to update label' }, 500);
+    }
+});
+/**
+ * DELETE /api/labels/:id
+ * Delete a label
+ */
+labelsRoutes.delete('/labels/:id', async (c) => {
+    try {
+        const id = c.req.param('id');
+        await deleteLabel(id);
+        return c.json({ success: true });
+    }
+    catch (error) {
+        console.error('[Labels] Delete error:', error);
+        return c.json({ error: error instanceof Error ? error.message : 'Failed to delete label' }, 500);
+    }
+});
+// TICKET LABELS
+/**
+ * GET /api/tickets/:ticketId/labels
+ * Get all labels for a ticket
+ */
+labelsRoutes.get('/tickets/:ticketId/labels', async (c) => {
+    try {
+        const ticketId = c.req.param('ticketId');
+        const labelsList = await getTicketLabels(ticketId);
+        return c.json({
+            labels: labelsList,
+            count: labelsList.length,
+        });
+    }
+    catch (error) {
+        console.error('[Labels] Get ticket labels error:', error);
+        return c.json({ error: error instanceof Error ? error.message : 'Failed to get ticket labels' }, 500);
+    }
+});
+/**
+ * PUT /api/tickets/:ticketId/labels
+ * Set all labels for a ticket (replaces existing)
+ */
+labelsRoutes.put('/tickets/:ticketId/labels', async (c) => {
+    try {
+        const ticketId = c.req.param('ticketId');
+        const parsed = await parseJsonBody(c);
+        if (!parsed.ok) {
+            return parsed.response;
+        }
+        const body = parsed.body;
+        if (!Array.isArray(body.labelIds)) {
+            return c.json({ error: 'labelIds must be an array' }, 400);
+        }
+        await setTicketLabels(ticketId, body.labelIds);
+        const labels = await getTicketLabels(ticketId);
+        return c.json({
+            labels,
+            count: labels.length,
+        });
+    }
+    catch (error) {
+        console.error('[Labels] Set ticket labels error:', error);
+        return c.json({ error: error instanceof Error ? error.message : 'Failed to set ticket labels' }, 500);
+    }
+});
+/**
+ * POST /api/tickets/:ticketId/labels/:labelId
+ * Add a label to a ticket
+ */
+labelsRoutes.post('/tickets/:ticketId/labels/:labelId', async (c) => {
+    try {
+        const ticketId = c.req.param('ticketId');
+        const labelId = c.req.param('labelId');
+        await addLabelToTicket(ticketId, labelId);
+        return c.json({ success: true });
+    }
+    catch (error) {
+        console.error('[Labels] Add label to ticket error:', error);
+        return c.json({ error: error instanceof Error ? error.message : 'Failed to add label' }, 500);
+    }
+});
+/**
+ * DELETE /api/tickets/:ticketId/labels/:labelId
+ * Remove a label from a ticket
+ */
+labelsRoutes.delete('/tickets/:ticketId/labels/:labelId', async (c) => {
+    try {
+        const ticketId = c.req.param('ticketId');
+        const labelId = c.req.param('labelId');
+        await removeLabelFromTicket(ticketId, labelId);
+        return c.json({ success: true });
+    }
+    catch (error) {
+        console.error('[Labels] Remove label from ticket error:', error);
+        return c.json({ error: error instanceof Error ? error.message : 'Failed to remove label' }, 500);
+    }
+});
+//# sourceMappingURL=labels.js.map

package/dist/routes/mcp.d.ts

@@ -0,0 +1,14 @@
+/**
+ * MCP Routes
+ *
+ * API endpoints for managing MCP server connections and tool discovery.
+ *
+ * Endpoints:
+ *   GET  /api/mcp/status           - MCP server/client status
+ *   GET  /api/mcp/tools            - List tools from connected MCP servers
+ *   POST /api/mcp/servers/:name/connect    - Connect to an MCP server
+ *   POST /api/mcp/servers/:name/disconnect - Disconnect from an MCP server
+ */
+import { Hono } from 'hono';
+export declare const mcpRoutes: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+//# sourceMappingURL=mcp.d.ts.map

package/dist/routes/mcp.js

@@ -0,0 +1,125 @@
+/**
+ * MCP Routes
+ *
+ * API endpoints for managing MCP server connections and tool discovery.
+ *
+ * Endpoints:
+ *   GET  /api/mcp/status           - MCP server/client status
+ *   GET  /api/mcp/tools            - List tools from connected MCP servers
+ *   POST /api/mcp/servers/:name/connect    - Connect to an MCP server
+ *   POST /api/mcp/servers/:name/disconnect - Disconnect from an MCP server
+ */
+import { Hono } from 'hono';
+import { logger } from '../utils/logger.js';
+export const mcpRoutes = new Hono();
+let runtimePromise = null;
+async function getMcpRuntime() {
+    if (!runtimePromise) {
+        runtimePromise = Promise.all([
+            import('../mcp/client.js'),
+            import('../mcp/tool-adapter.js'),
+        ]).then(([clientModule, adapterModule]) => ({
+            mcpClientManager: clientModule.mcpClientManager,
+            adaptToolsToMCP: adapterModule.adaptToolsToMCP,
+        }));
+    }
+    return runtimePromise;
+}
+// GET /status - MCP server/client status
+mcpRoutes.get('/status', async (c) => {
+    try {
+        const { mcpClientManager, adaptToolsToMCP } = await getMcpRuntime();
+        const connectedServers = mcpClientManager.getStatus();
+        const adaptedTools = adaptToolsToMCP();
+        return c.json({
+            server: {
+                enabled: true,
+                toolsExposed: adaptedTools.length,
+            },
+            clients: connectedServers,
+            connectedCount: connectedServers.filter((s) => s.connected).length,
+            totalServers: connectedServers.length,
+        });
+    }
+    catch (error) {
+        logger.error('[MCP Routes] Status error:', error instanceof Error ? error : undefined);
+        return c.json({ error: 'Failed to get MCP status' }, 500);
+    }
+});
+// GET /tools - List tools from all connected MCP servers + adapted profClaw tools
+mcpRoutes.get('/tools', async (c) => {
+    try {
+        const { mcpClientManager, adaptToolsToMCP } = await getMcpRuntime();
+        // Get tools from connected external MCP servers
+        const externalTools = mcpClientManager.listTools().map((t) => ({
+            name: t.name,
+            server: t.serverName,
+            description: t.description,
+            source: 'external',
+        }));
+        // Get profClaw tools adapted to MCP format
+        const internalTools = adaptToolsToMCP().map((t) => ({
+            name: t.schema.name,
+            server: 'profclaw',
+            description: t.schema.description,
+            source: 'internal',
+        }));
+        return c.json({
+            tools: [...internalTools, ...externalTools],
+            totalInternal: internalTools.length,
+            totalExternal: externalTools.length,
+        });
+    }
+    catch (error) {
+        logger.error('[MCP Routes] Tools listing error:', error instanceof Error ? error : undefined);
+        return c.json({ error: 'Failed to list MCP tools' }, 500);
+    }
+});
+// POST /servers/:name/connect - Connect to a configured MCP server
+mcpRoutes.post('/servers/:name/connect', async (c) => {
+    const { name } = c.req.param();
+    try {
+        const { mcpClientManager } = await getMcpRuntime();
+        // Read MCP server configs from settings
+        // For now, accept the config in the request body
+        const body = await c.req.json().catch(() => ({}));
+        const config = {
+            name,
+            command: body.command,
+            args: body.args,
+            env: body.env,
+            url: body.url,
+        };
+        if (!config.command && !config.url) {
+            return c.json({ error: 'Must provide either command (for stdio) or url (for SSE)' }, 400);
+        }
+        await mcpClientManager.connect(config);
+        return c.json({
+            connected: true,
+            name,
+            tools: mcpClientManager.listTools()
+                .filter((t) => t.serverName === name)
+                .length,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Connection failed';
+        logger.error(`[MCP Routes] Connect error for ${name}:`, error instanceof Error ? error : undefined);
+        return c.json({ error: message }, 500);
+    }
+});
+// POST /servers/:name/disconnect - Disconnect from an MCP server
+mcpRoutes.post('/servers/:name/disconnect', async (c) => {
+    const { name } = c.req.param();
+    try {
+        const { mcpClientManager } = await getMcpRuntime();
+        await mcpClientManager.disconnect(name);
+        return c.json({ disconnected: true, name });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Disconnect failed';
+        logger.error(`[MCP Routes] Disconnect error for ${name}:`, error instanceof Error ? error : undefined);
+        return c.json({ error: message }, 500);
+    }
+});
+//# sourceMappingURL=mcp.js.map

package/dist/routes/memory.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Memory Routes
+ *
+ * API endpoints for memory system management.
+ * Provides search, browse, sync, and delete capabilities.
+ */
+import { Hono } from 'hono';
+declare const memory: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export { memory as memoryRoutes };
+//# sourceMappingURL=memory.d.ts.map