profclaw 0.0.1-beta.1

package/dist/routes/voice.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Voice Routes
+ *
+ * API endpoints for speech-to-text and text-to-speech.
+ */
+import { Hono } from 'hono';
+export declare const voiceRoutes: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+//# sourceMappingURL=voice.d.ts.map

package/dist/routes/voice.js

@@ -0,0 +1,127 @@
+/**
+ * Voice Routes
+ *
+ * API endpoints for speech-to-text and text-to-speech.
+ */
+import { Hono } from 'hono';
+import { getVoiceService } from '../voice/index.js';
+export const voiceRoutes = new Hono();
+/**
+ * GET /api/voice/status - Get voice service status
+ */
+voiceRoutes.get('/status', async (c) => {
+    const voice = await getVoiceService();
+    const sttProvider = voice.getSTTProvider();
+    const ttsProvider = voice.getTTSProvider();
+    return c.json({
+        available: voice.isSTTAvailable() || voice.isTTSAvailable(),
+        stt: {
+            provider: sttProvider,
+            model: sttProvider === 'whisper' ? 'whisper-1' : undefined,
+            languages: sttProvider ? ['en', 'es', 'fr', 'de', 'ja', 'zh', 'ko', 'pt', 'ru', 'it'] : [],
+        },
+        tts: {
+            provider: ttsProvider,
+        },
+    });
+});
+/**
+ * POST /api/voice/transcribe - Transcribe audio to text
+ * Accepts: multipart/form-data with 'audio' file field
+ * or application/json with { audio: base64string, format: 'wav'|'mp3'|'webm' }
+ */
+voiceRoutes.post('/transcribe', async (c) => {
+    const voice = await getVoiceService();
+    if (!voice.isSTTAvailable()) {
+        return c.json({ error: 'STT not configured. Set OPENAI_API_KEY for Whisper.' }, 503);
+    }
+    const contentType = c.req.header('content-type') || '';
+    let audioBuffer;
+    let format = 'webm';
+    if (contentType.includes('multipart/form-data')) {
+        const formData = await c.req.formData();
+        const file = formData.get('audio');
+        if (!file || !(file instanceof File)) {
+            return c.json({ error: 'No audio file provided' }, 400);
+        }
+        audioBuffer = Buffer.from(await file.arrayBuffer());
+        format = file.name?.split('.').pop() || 'webm';
+    }
+    else {
+        const body = await c.req.json();
+        if (!body.audio) {
+            return c.json({ error: 'No audio data provided' }, 400);
+        }
+        audioBuffer = Buffer.from(body.audio, 'base64');
+        format = body.format || 'webm';
+    }
+    try {
+        const result = await voice.transcribe(audioBuffer, { format });
+        return c.json({
+            text: result.text,
+            language: result.language,
+            duration: result.duration_ms,
+        });
+    }
+    catch (error) {
+        return c.json({ error: error instanceof Error ? error.message : 'Transcription failed' }, 500);
+    }
+});
+/**
+ * POST /api/voice/synthesize - Convert text to speech
+ * Returns audio as binary stream or base64
+ */
+voiceRoutes.post('/synthesize', async (c) => {
+    const voice = await getVoiceService();
+    if (!voice.isTTSAvailable()) {
+        return c.json({ error: 'TTS not configured. Set OPENAI_API_KEY or ELEVENLABS_API_KEY.' }, 503);
+    }
+    const body = await c.req.json();
+    if (!body.text) {
+        return c.json({ error: 'text is required' }, 400);
+    }
+    try {
+        const result = await voice.synthesize(body.text, {
+            voice: body.voice,
+            format: body.format || 'mp3',
+        });
+        const audioBuffer = result.audio;
+        if (body.returnBase64) {
+            return c.json({
+                audio: audioBuffer.toString('base64'),
+                format: result.format,
+                size: audioBuffer.length,
+            });
+        }
+        // Return as binary audio
+        const mimeMap = {
+            mp3: 'audio/mpeg',
+            wav: 'audio/wav',
+            opus: 'audio/opus',
+            aac: 'audio/aac',
+        };
+        c.header('Content-Type', mimeMap[result.format] || 'audio/mpeg');
+        c.header('Content-Length', String(audioBuffer.length));
+        return c.body(new Uint8Array(audioBuffer));
+    }
+    catch (error) {
+        return c.json({ error: error instanceof Error ? error.message : 'Synthesis failed' }, 500);
+    }
+});
+/**
+ * GET /api/voice/voices - List available TTS voices
+ */
+voiceRoutes.get('/voices', async (c) => {
+    const voice = await getVoiceService();
+    if (!voice.isTTSAvailable()) {
+        return c.json({ error: 'TTS not configured' }, 503);
+    }
+    try {
+        const voices = await voice.listVoices();
+        return c.json({ voices });
+    }
+    catch (error) {
+        return c.json({ error: error instanceof Error ? error.message : 'Failed to list voices' }, 500);
+    }
+});
+//# sourceMappingURL=voice.js.map

package/dist/routes/webchat.d.ts

@@ -0,0 +1,11 @@
+/**
+ * WebChat Routes
+ *
+ * POST /api/chat/webchat          -- Send a message (creates session if needed)
+ * GET  /api/chat/webchat/stream   -- SSE stream for a session
+ * POST /api/chat/webchat/session  -- Create a new session
+ * DELETE /api/chat/webchat/session/:id -- End a session
+ */
+import { Hono } from 'hono';
+export declare const webchatRoutes: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+//# sourceMappingURL=webchat.d.ts.map

package/dist/routes/webchat.js

@@ -0,0 +1,173 @@
+/**
+ * WebChat Routes
+ *
+ * POST /api/chat/webchat          -- Send a message (creates session if needed)
+ * GET  /api/chat/webchat/stream   -- SSE stream for a session
+ * POST /api/chat/webchat/session  -- Create a new session
+ * DELETE /api/chat/webchat/session/:id -- End a session
+ */
+import { Hono } from 'hono';
+import { createSession, getSession, attachSSE, sendToSession, removeSession, getSessionCount, getSessionCountByIp, } from '../chat/providers/webchat/index.js';
+import { getChatRegistry } from '../chat/providers/registry.js';
+import { logger } from '../utils/logger.js';
+export const webchatRoutes = new Hono();
+const MAX_SESSIONS_PER_IP = parseInt(process.env.WEBCHAT_MAX_SESSIONS_PER_IP || '5', 10);
+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),
+        };
+    }
+}
+/**
+ * Create a new WebChat session.
+ */
+webchatRoutes.post('/session', async (c) => {
+    const ip = c.req.header('x-forwarded-for') || c.req.header('x-real-ip') || 'unknown';
+    // Rate limit by IP
+    if (getSessionCountByIp(ip) >= MAX_SESSIONS_PER_IP) {
+        return c.json({ error: 'Too many sessions from this IP' }, 429);
+    }
+    const body = await c.req.json().catch(() => ({}));
+    const sessionId = createSession({
+        userId: body.userId,
+        userName: body.userName,
+        ip,
+    });
+    return c.json({ sessionId, activeSessions: getSessionCount() });
+});
+/**
+ * SSE stream for receiving messages.
+ */
+webchatRoutes.get('/stream', (c) => {
+    const sessionId = c.req.query('sessionId');
+    if (!sessionId) {
+        return c.json({ error: 'sessionId query parameter required' }, 400);
+    }
+    const session = getSession(sessionId);
+    if (!session) {
+        return c.json({ error: 'Session not found' }, 404);
+    }
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        start(controller) {
+            attachSSE(sessionId, controller);
+            // Send connected event
+            const connectMsg = `event: connected\ndata: ${JSON.stringify({
+                sessionId,
+                userId: session.userId,
+                userName: session.userName,
+                timestamp: new Date().toISOString(),
+            })}\n\n`;
+            controller.enqueue(encoder.encode(connectMsg));
+            // Heartbeat
+            const heartbeat = setInterval(() => {
+                try {
+                    const ping = `event: ping\ndata: ${JSON.stringify({ timestamp: new Date().toISOString() })}\n\n`;
+                    controller.enqueue(encoder.encode(ping));
+                }
+                catch {
+                    clearInterval(heartbeat);
+                }
+            }, 15000);
+            c.req.raw.signal.addEventListener('abort', () => {
+                clearInterval(heartbeat);
+                try {
+                    controller.close();
+                }
+                catch { /* ok */ }
+            });
+        },
+        cancel() {
+            // Cleanup handled by abort handler
+        },
+    });
+    return new Response(stream, {
+        headers: {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'X-Accel-Buffering': 'no',
+        },
+    });
+});
+/**
+ * Send a message from the user.
+ * The chat engine processes it and streams the response via SSE.
+ */
+webchatRoutes.post('/', async (c) => {
+    const parsed = await parseJsonBody(c);
+    if (!parsed.ok) {
+        return parsed.response;
+    }
+    const sessionId = typeof parsed.body.sessionId === 'string' ? parsed.body.sessionId : undefined;
+    const text = typeof parsed.body.text === 'string' ? parsed.body.text : undefined;
+    if (!sessionId || !text) {
+        return c.json({ error: 'sessionId and text are required' }, 400);
+    }
+    const session = getSession(sessionId);
+    if (!session) {
+        return c.json({ error: 'Session not found' }, 404);
+    }
+    // Acknowledge receipt
+    sendToSession(sessionId, 'message:received', {
+        text,
+        timestamp: new Date().toISOString(),
+        from: 'user',
+    });
+    // Parse the incoming message through the webchat provider
+    const registry = getChatRegistry();
+    const provider = registry.get('webchat');
+    if (!provider) {
+        return c.json({ error: 'WebChat provider not registered' }, 500);
+    }
+    const message = provider.inbound.parseMessage({ sessionId, text });
+    if (!message) {
+        return c.json({ error: 'Failed to parse message' }, 400);
+    }
+    // Emit to the chat engine for processing (async -- response goes via SSE)
+    try {
+        await registry.emit({
+            type: 'message',
+            provider: 'webchat',
+            accountId: 'default',
+            timestamp: new Date(),
+            payload: message,
+        });
+    }
+    catch (error) {
+        logger.error('[WebChat] Failed to emit message to chat engine:', error);
+        return c.json({ error: 'Failed to process message' }, 500);
+    }
+    return c.json({ success: true, messageId: message.id });
+});
+/**
+ * End a session.
+ */
+webchatRoutes.delete('/session/:id', (c) => {
+    const sessionId = c.req.param('id');
+    removeSession(sessionId);
+    return c.json({ success: true });
+});
+/**
+ * Get WebChat status.
+ */
+webchatRoutes.get('/status', (c) => {
+    return c.json({
+        activeSessions: getSessionCount(),
+        provider: 'webchat',
+        healthy: true,
+    });
+});
+//# sourceMappingURL=webchat.js.map

package/dist/routes/webhook-dedup.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Lightweight in-memory deduplication for inbound webhooks/interactions.
+ *
+ * This protects against provider retries causing duplicate command or message
+ * handling within a short time window.
+ */
+export declare function isDuplicateWebhookEvent(scope: string, eventId: string | number, ttlMs?: number): boolean;
+export declare function getWebhookDedupValue<T>(scope: string, eventId: string | number): T | undefined;
+export declare function setWebhookDedupValue(scope: string, eventId: string | number, value: unknown, ttlMs?: number): void;
+export declare function clearWebhookDedupCache(): void;
+//# sourceMappingURL=webhook-dedup.d.ts.map

package/dist/routes/webhook-dedup.js

@@ -0,0 +1,49 @@
+/**
+ * Lightweight in-memory deduplication for inbound webhooks/interactions.
+ *
+ * This protects against provider retries causing duplicate command or message
+ * handling within a short time window.
+ */
+const seenWebhookEvents = new Map();
+function getWebhookKey(scope, eventId) {
+    return `${scope}:${String(eventId)}`;
+}
+function pruneExpired(now) {
+    for (const [key, entry] of seenWebhookEvents) {
+        if (entry.expiresAt <= now) {
+            seenWebhookEvents.delete(key);
+        }
+    }
+}
+export function isDuplicateWebhookEvent(scope, eventId, ttlMs = 5 * 60_000) {
+    const now = Date.now();
+    pruneExpired(now);
+    const key = getWebhookKey(scope, eventId);
+    const entry = seenWebhookEvents.get(key);
+    if (entry && entry.expiresAt > now) {
+        return true;
+    }
+    seenWebhookEvents.set(key, { expiresAt: now + ttlMs });
+    return false;
+}
+export function getWebhookDedupValue(scope, eventId) {
+    const now = Date.now();
+    pruneExpired(now);
+    const entry = seenWebhookEvents.get(getWebhookKey(scope, eventId));
+    if (!entry || entry.expiresAt <= now) {
+        return undefined;
+    }
+    return entry.value;
+}
+export function setWebhookDedupValue(scope, eventId, value, ttlMs = 5 * 60_000) {
+    const now = Date.now();
+    pruneExpired(now);
+    seenWebhookEvents.set(getWebhookKey(scope, eventId), {
+        expiresAt: now + ttlMs,
+        value,
+    });
+}
+export function clearWebhookDedupCache() {
+    seenWebhookEvents.clear();
+}
+//# sourceMappingURL=webhook-dedup.js.map

package/dist/routes/webhooks.d.ts

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

package/dist/routes/webhooks.js

@@ -0,0 +1,71 @@
+import { Hono } from 'hono';
+import { handleGitHubWebhook } from '../integrations/github.js';
+import { handleJiraWebhook } from '../integrations/jira.js';
+import { handleLinearWebhook } from '../integrations/linear.js';
+import { addTask } from '../queue/index.js';
+const webhooks = new Hono();
+// GitHub webhook
+webhooks.post('/github', async (c) => {
+    try {
+        const taskInput = await handleGitHubWebhook(c);
+        if (!taskInput) {
+            return c.json({ message: 'Webhook received, no task created' });
+        }
+        const task = await addTask(taskInput);
+        return c.json({
+            message: 'Task created from GitHub webhook',
+            task,
+        });
+    }
+    catch (error) {
+        console.error('[Webhook] GitHub error:', error);
+        return c.json({
+            error: 'Webhook processing failed',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        }, error instanceof Error && error.message.includes('signature') ? 401 : 500);
+    }
+});
+// Jira webhook
+webhooks.post('/jira', async (c) => {
+    try {
+        const taskInput = await handleJiraWebhook(c);
+        if (!taskInput) {
+            return c.json({ message: 'Webhook received, no task created' });
+        }
+        const task = await addTask(taskInput);
+        return c.json({
+            message: 'Task created from Jira webhook',
+            task,
+        });
+    }
+    catch (error) {
+        console.error('[Webhook] Jira error:', error);
+        return c.json({
+            error: 'Webhook processing failed',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        }, error instanceof Error && error.message.includes('token') ? 401 : 500);
+    }
+});
+// Linear webhook
+webhooks.post('/linear', async (c) => {
+    try {
+        const taskInput = await handleLinearWebhook(c);
+        if (!taskInput) {
+            return c.json({ message: 'Webhook received, no task created' });
+        }
+        const task = await addTask(taskInput);
+        return c.json({
+            message: 'Task created from Linear webhook',
+            task,
+        });
+    }
+    catch (error) {
+        console.error('[Webhook] Linear error:', error);
+        return c.json({
+            error: 'Webhook processing failed',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        }, error instanceof Error && error.message.includes('signature') ? 401 : 500);
+    }
+});
+export { webhooks as webhooksRoutes };
+//# sourceMappingURL=webhooks.js.map

package/dist/routes/whatsapp.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WhatsApp Business Cloud API Routes
+ *
+ * Handles:
+ * - Webhook verification (GET challenge)
+ * - Webhook updates (messages, status updates)
+ * - Health checks
+ * - Security: HMAC-SHA256 signature verification, phone allowlist
+ */
+import { Hono } from 'hono';
+export { formatToolResult } from '../chat/format/index.js';
+declare const whatsapp: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export { whatsapp as whatsappRoutes };
+//# sourceMappingURL=whatsapp.d.ts.map