pilotlynx 0.1.2 → 0.2.0

package/dist/lib/relay/queue.d.ts

@@ -0,0 +1,18 @@
+export declare class AgentPool {
+    private maxConcurrent;
+    private maxQueueDepth;
+    private maxMemoryMB;
+    private projectQueues;
+    private globalSemaphore;
+    private idleTimers;
+    constructor(maxConcurrent: number, maxQueueDepth: number, maxMemoryMB: number);
+    enqueue<T>(project: string, fn: () => Promise<T>): Promise<{
+        result: Promise<T>;
+        position: number;
+    }>;
+    getQueueDepth(project: string): number;
+    getActiveCount(): number;
+    shutdown(): Promise<void>;
+    private getOrCreateQueue;
+    private resetIdleTimer;
+}

package/dist/lib/relay/queue.js

@@ -0,0 +1,85 @@
+import PQueue from 'p-queue';
+const IDLE_TIMEOUT_MS = 30 * 60_000; // 30 minutes
+export class AgentPool {
+    maxConcurrent;
+    maxQueueDepth;
+    maxMemoryMB;
+    projectQueues = new Map();
+    globalSemaphore;
+    idleTimers = new Map();
+    constructor(maxConcurrent, maxQueueDepth, maxMemoryMB) {
+        this.maxConcurrent = maxConcurrent;
+        this.maxQueueDepth = maxQueueDepth;
+        this.maxMemoryMB = maxMemoryMB;
+        this.globalSemaphore = new PQueue({ concurrency: maxConcurrent });
+    }
+    async enqueue(project, fn) {
+        // Check memory pressure
+        const rss = process.memoryUsage().rss;
+        if (rss > this.maxMemoryMB * 1024 * 1024) {
+            throw new Error(`Memory pressure: RSS ${Math.round(rss / 1024 / 1024)}MB exceeds limit ${this.maxMemoryMB}MB`);
+        }
+        const queue = this.getOrCreateQueue(project);
+        // Check queue depth
+        const depth = queue.size + queue.pending;
+        if (depth >= this.maxQueueDepth) {
+            throw new Error(`Queue full for project "${project}": ${depth}/${this.maxQueueDepth}`);
+        }
+        const position = depth;
+        // Reset idle timer for this project
+        this.resetIdleTimer(project);
+        const result = queue.add(async () => {
+            // Wait for a global semaphore slot before running
+            return this.globalSemaphore.add(() => fn());
+        });
+        return { result, position };
+    }
+    getQueueDepth(project) {
+        const queue = this.projectQueues.get(project);
+        if (!queue)
+            return 0;
+        return queue.size + queue.pending;
+    }
+    getActiveCount() {
+        return this.globalSemaphore.pending;
+    }
+    async shutdown() {
+        // Clear all idle timers
+        for (const timer of this.idleTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.idleTimers.clear();
+        // Clear all project queues
+        for (const queue of this.projectQueues.values()) {
+            queue.clear();
+        }
+        this.projectQueues.clear();
+        // Wait for in-flight work to complete
+        await this.globalSemaphore.onIdle();
+        this.globalSemaphore.clear();
+    }
+    getOrCreateQueue(project) {
+        let queue = this.projectQueues.get(project);
+        if (!queue) {
+            queue = new PQueue({ concurrency: 1 });
+            this.projectQueues.set(project, queue);
+        }
+        return queue;
+    }
+    resetIdleTimer(project) {
+        const existing = this.idleTimers.get(project);
+        if (existing)
+            clearTimeout(existing);
+        const timer = setTimeout(() => {
+            const queue = this.projectQueues.get(project);
+            if (queue && queue.size === 0 && queue.pending === 0) {
+                this.projectQueues.delete(project);
+                this.idleTimers.delete(project);
+            }
+        }, IDLE_TIMEOUT_MS);
+        // Don't hold the process open for idle timers
+        timer.unref();
+        this.idleTimers.set(project, timer);
+    }
+}
+//# sourceMappingURL=queue.js.map

package/dist/lib/relay/queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.js","sourceRoot":"","sources":["../../../src/lib/relay/queue.ts"],"names":[],"mappings":"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"}

package/dist/lib/relay/router.d.ts

@@ -1,2 +1,25 @@
-import type { ChannelAdapter, InboundMessage } from './channel.js';
-export declare function createRouter(adapter: ChannelAdapter): (msg: InboundMessage) => Promise<void>;
+import type Database from 'better-sqlite3';
+import type { ChatPlatform, ChatMessage } from './platform.js';
+import type { RelayConfig } from './types.js';
+import { AgentPool } from './queue.js';
+export declare class RelayRouter {
+    private db;
+    private pool;
+    private config;
+    private activeAbortControllers;
+    private startedAt;
+    constructor(db: Database.Database, pool: AgentPool, config: RelayConfig);
+    /**
+     * Main message handler — called by platform adapters on incoming messages.
+     */
+    routeMessage(platform: ChatPlatform, msg: ChatMessage): Promise<void>;
+    /**
+     * Reaction handler — called by platform adapters on reactions.
+     */
+    routeReaction(platform: ChatPlatform, channelId: string, messageId: string, userId: string, emoji: string): Promise<void>;
+    /**
+     * Slash command handler — called by platform adapters.
+     */
+    routeCommand(platform: ChatPlatform, channelId: string, userId: string, command: string, args: string): Promise<string>;
+    private executeAndPost;
+}

package/dist/lib/relay/router.js

@@ -1,191 +1,282 @@
-import { listProjects } from '../project.js';
-import { getRecentLogs } from '../observation.js';
-import { executeRun } from '../command-ops/run-ops.js';
-import { acquireRunLock } from './locks.js';
-import { loadRelayConfig } from './config.js';
-import { appendConversation, getRecentConversation } from './history.js';
-import { runRelayChatAgent } from './chat.js';
-function getChatConfig(config, chatId) {
-    return config.routing.chats[chatId] ?? null;
-}
-function isUserAllowed(config, userId) {
-    if (config.routing.allowedUsers.length === 0)
+// ── Relay Router ──
+// Central dispatch: routes platform messages to the right handler.
+// Wires together: bindings, context, queue, executor, poster, admin, feedback.
+import { randomUUID } from 'node:crypto';
+import { lookupBinding } from './bindings.js';
+import { cacheMessage, writePendingMessage, markPendingDone, recordRelayRun, updateRelayRun } from './db.js';
+import { assembleContext } from './context.js';
+import { executeRelayRun } from './executor.js';
+import { formatResponse, addCostFooter } from './poster.js';
+import { parseCommand, handleAdminCommand } from './admin.js';
+import { classifyReaction, handleFeedback, appendRelayFeedback, saveFeedbackToMemory, isReactionRateLimited } from './feedback.js';
+import { sendWebhookNotification } from './notify.js';
+// ── Rate Limiting ──
+const userMessageTimestamps = new Map();
+function isUserRateLimited(userId, maxPerHour) {
+    const now = Date.now();
+    const cutoff = now - 3_600_000;
+    let timestamps = userMessageTimestamps.get(userId);
+    if (!timestamps) {
+        timestamps = [];
+        userMessageTimestamps.set(userId, timestamps);
+    }
+    const recent = timestamps.filter((t) => t > cutoff);
+    userMessageTimestamps.set(userId, recent);
+    if (recent.length >= maxPerHour)
         return true;
-    return config.routing.allowedUsers.includes(userId);
-}
-function formatLogsSummary(project) {
-    const logs = getRecentLogs(project, 7);
-    if (logs.length === 0)
-        return `No recent logs for "${project}".`;
-    const lines = logs.slice(-10).map(r => {
-        const icon = r.success ? '\u2705' : '\u274c';
-        const time = new Date(r.startedAt).toISOString().slice(0, 16).replace('T', ' ');
-        return `${icon} ${time} ${r.workflow} ($${r.costUsd.toFixed(4)})`;
-    });
-    return `Recent runs for *${project}* (last 7 days):\n${lines.join('\n')}`;
+    recent.push(now);
+    return false;
 }
-const HELP_TEXT = `*PilotLynx Relay*
-
-Commands:
-/run <project> <workflow> — Execute a workflow
-/status [project] — Show recent run logs
-/projects — List registered projects
-/help — Show this message
-
-Or just type normally to chat with the project agent.`;
-export function createRouter(adapter) {
-    return async (msg) => {
-        const config = loadRelayConfig();
-        if (!config || !config.enabled)
+// ── Router ──
+export class RelayRouter {
+    db;
+    pool;
+    config;
+    activeAbortControllers = new Map(); // conversationId → controller
+    startedAt = new Date();
+    constructor(db, pool, config) {
+        this.db = db;
+        this.pool = pool;
+        this.config = config;
+    }
+    /**
+     * Main message handler — called by platform adapters on incoming messages.
+     */
+    async routeMessage(platform, msg) {
+        // Ignore bot messages
+        if (msg.isBot)
             return;
-        // User allowlist check
-        if (!isUserAllowed(config, msg.userId)) {
-            await adapter.send(msg.chatId, 'Unauthorized. Your user ID is not in the allowedUsers list.');
+        // Cache the incoming message
+        cacheMessage(this.db, msg);
+        // Check for admin commands first
+        const parsed = parseCommand(msg.text);
+        if (parsed) {
+            const response = await handleAdminCommand({
+                db: this.db,
+                platform: platform.name,
+                channelId: msg.channelId,
+                userId: msg.userId,
+                config: this.config,
+                getQueueDepth: (p) => this.pool.getQueueDepth(p),
+                getActiveCount: () => this.pool.getActiveCount(),
+                startedAt: this.startedAt,
+            }, parsed.command, parsed.args);
+            // Handle special commands
+            if (parsed.command === 'cancel') {
+                const controller = this.activeAbortControllers.get(msg.conversationId);
+                if (controller) {
+                    controller.abort();
+                    this.activeAbortControllers.delete(msg.conversationId);
+                }
+            }
+            await platform.sendMessage(msg.channelId, response, msg.conversationId);
             return;
         }
-        const chatConfig = getChatConfig(config, msg.chatId);
-        // Unmapped chat: send setup instructions
-        if (!chatConfig) {
-            const rawId = msg.chatId.startsWith('telegram:') ? msg.chatId.slice('telegram:'.length) : msg.chatId;
-            await adapter.send(msg.chatId, `Your chat ID is \`${rawId}\`.\n\n` +
-                `Run this to connect:\n` +
-                `\`pilotlynx relay add-chat ${rawId} --project <name>\``);
+        // Look up channel binding
+        const project = lookupBinding(this.db, platform.name, msg.channelId);
+        if (!project) {
+            await platform.sendMessage(msg.channelId, 'This channel is not bound to a project. An admin can use `bind <project>` to set one up.', msg.conversationId);
             return;
         }
-        const text = msg.text.trim();
-        // Command routing
-        if (text.startsWith('/')) {
-            await handleCommand(msg, text, chatConfig, config, adapter);
+        // Rate limit
+        if (isUserRateLimited(msg.userId, this.config.limits.userRatePerHour)) {
+            await platform.sendMessage(msg.channelId, 'You\'re sending messages too quickly. Please slow down.', msg.conversationId);
+            return;
         }
-        else if (chatConfig.allowChat) {
-            await handleChat(msg, text, chatConfig, adapter);
+        // Write pending message for crash recovery
+        const pendingId = randomUUID();
+        writePendingMessage(this.db, {
+            id: pendingId,
+            platform: platform.name,
+            channelId: msg.channelId,
+            conversationId: msg.conversationId,
+            userId: msg.userId,
+            userName: msg.userName,
+            text: msg.text,
+            receivedAt: new Date().toISOString(),
+            status: 'pending',
+        });
+        // Enqueue the agent run
+        try {
+            const { result: runPromise, position } = await this.pool.enqueue(project, async () => {
+                return this.executeAndPost(platform, msg, project, pendingId);
+            });
+            // If queued (not immediate), notify the user
+            if (position > 0) {
+                await platform.sendMessage(msg.channelId, `Your request is queued (position ${position}). I'll respond shortly.`, msg.conversationId);
+            }
+            // Don't await the run promise — it executes in the background via the queue
+            runPromise.catch((err) => {
+                console.error(`[relay] Run failed for ${project}:`, err);
+            });
         }
-        else {
-            await adapter.send(msg.chatId, 'Chat is disabled for this channel. Use /help for commands.');
+        catch (err) {
+            // Queue full or memory pressure
+            markPendingDone(this.db, pendingId);
+            const errMsg = err instanceof Error ? err.message : String(err);
+            await platform.sendMessage(msg.channelId, `Cannot process request: ${errMsg}`, msg.conversationId);
         }
-    };
-}
-async function handleCommand(msg, text, chatConfig, config, adapter) {
-    try {
-        const parts = text.split(/\s+/);
-        const cmd = parts[0].toLowerCase();
-        if (cmd === '/help') {
-            await adapter.send(msg.chatId, HELP_TEXT);
+    }
+    /**
+     * Reaction handler — called by platform adapters on reactions.
+     */
+    async routeReaction(platform, channelId, messageId, userId, emoji) {
+        // Rate limit reactions
+        if (isReactionRateLimited(userId, this.config.limits.reactionRatePerHour))
             return;
-        }
-        if (cmd === '/projects') {
-            const projects = listProjects();
-            if (projects.length === 0) {
-                await adapter.send(msg.chatId, 'No projects registered.');
-            }
-            else {
-                await adapter.send(msg.chatId, `*Registered projects:*\n${projects.map(p => `• ${p}`).join('\n')}`);
+        // Check for cancellation reaction (stop_sign on a "Working on it..." message)
+        if (emoji === 'stop_sign' || emoji === 'octagonal_sign') {
+            // Find conversation for this message and abort
+            for (const [convId, controller] of this.activeAbortControllers) {
+                controller.abort();
+                this.activeAbortControllers.delete(convId);
+                await platform.sendMessage(channelId, 'Run cancelled.', convId);
+                break;
             }
             return;
         }
-        if (cmd === '/status') {
-            const project = parts[1] ?? chatConfig.project ?? config.routing.defaultProject;
-            if (!project) {
-                await adapter.send(msg.chatId, 'Usage: /status <project>\nNo default project configured.');
-                return;
-            }
-            await adapter.send(msg.chatId, formatLogsSummary(project));
+        const feedbackType = classifyReaction(emoji);
+        if (!feedbackType)
             return;
-        }
-        if (cmd === '/run') {
-            if (!chatConfig.allowRun) {
-                await adapter.send(msg.chatId, 'Run commands are disabled for this chat.');
-                return;
-            }
-            let resolvedProject;
-            let resolvedWorkflow;
-            if (parts.length === 3) {
-                resolvedProject = parts[1];
-                resolvedWorkflow = parts[2];
-            }
-            else if (parts.length === 2 && chatConfig.project) {
-                resolvedProject = chatConfig.project;
-                resolvedWorkflow = parts[1];
-            }
-            else {
-                await adapter.send(msg.chatId, 'Usage: /run <project> <workflow>');
-                return;
-            }
-            // Acquire run lock
-            const release = await acquireRunLock(resolvedProject);
-            if (!release) {
-                await adapter.send(msg.chatId, `\u23f3 Project "${resolvedProject}" is busy. Try again shortly.`);
-                return;
-            }
-            let typingInterval;
-            try {
-                await adapter.sendTyping(msg.chatId);
-                typingInterval = setInterval(() => {
-                    adapter.sendTyping(msg.chatId).catch(() => { });
-                }, 4000);
-                const result = await executeRun(resolvedProject, resolvedWorkflow);
-                if (result.success) {
-                    const duration = result.durationMs ? `${Math.round(result.durationMs / 1000)}s` : '?';
-                    await adapter.send(msg.chatId, `\u2705 *${resolvedProject}/${resolvedWorkflow}* completed\n` +
-                        `Duration: ${duration} | Cost: $${result.costUsd?.toFixed(4) ?? '?'}\n` +
-                        `${result.record?.summary?.slice(0, 500) ?? ''}`);
-                }
-                else {
-                    await adapter.send(msg.chatId, `\u274c *${resolvedProject}/${resolvedWorkflow}* failed\n${result.error?.slice(0, 500) ?? 'Unknown error'}`);
-                }
-            }
-            finally {
-                clearInterval(typingInterval);
-                await release();
-            }
+        const project = lookupBinding(this.db, platform.name, channelId);
+        if (!project)
             return;
+        const signal = {
+            type: feedbackType,
+            platform: platform.name,
+            conversationId: messageId, // approximate — reactions target a message
+            messageId,
+            userId,
+            userName: userId, // resolved by platform adapter if available
+            timestamp: new Date().toISOString(),
+        };
+        // Try to get agent output summary from the most recent run for this project
+        const lastRun = this.db.prepare(`SELECT id, status FROM relay_runs
+       WHERE project = ? AND platform = ? AND channel_id = ?
+       ORDER BY started_at DESC LIMIT 1`).get(project, platform.name, channelId);
+        const outputSummary = lastRun?.status === 'completed' ? `(run ${lastRun.id})` : undefined;
+        const entry = handleFeedback(signal, project, outputSummary);
+        appendRelayFeedback(entry);
+        // Save starred/saved responses to project memory/ dir
+        if (feedbackType === 'save') {
+            saveFeedbackToMemory(project, entry, outputSummary);
+        }
+        if (feedbackType === 'negative') {
+            await platform.sendMessage(channelId, 'Got it — what went wrong? Reply in this thread and I\'ll note the feedback.', messageId);
         }
-        await adapter.send(msg.chatId, `Unknown command: ${cmd}\nUse /help for available commands.`);
-    }
-    catch (err) {
-        await adapter.send(msg.chatId, `Command error: ${err instanceof Error ? err.message : String(err)}`);
-    }
-}
-async function handleChat(msg, text, chatConfig, adapter) {
-    const project = chatConfig.project;
-    if (!project) {
-        await adapter.send(msg.chatId, 'No project assigned to this chat. Use /help for commands.');
-        return;
     }
-    // Log user message
-    await appendConversation(msg.chatId, {
-        role: 'user',
-        content: text,
-        timestamp: new Date().toISOString(),
-    });
-    // Acquire lock for read-only agent too (prevents concurrent agent sessions)
-    const release = await acquireRunLock(project);
-    if (!release) {
-        await adapter.send(msg.chatId, '\u23f3 Project is busy processing another request. Try again shortly.');
-        return;
+    /**
+     * Slash command handler — called by platform adapters.
+     */
+    async routeCommand(platform, channelId, userId, command, args) {
+        return handleAdminCommand({
+            db: this.db,
+            platform: platform.name,
+            channelId,
+            userId,
+            config: this.config,
+            getQueueDepth: (p) => this.pool.getQueueDepth(p),
+            getActiveCount: () => this.pool.getActiveCount(),
+            startedAt: this.startedAt,
+        }, command, args);
     }
-    let typingInterval;
-    try {
-        await adapter.sendTyping(msg.chatId);
-        typingInterval = setInterval(() => {
-            adapter.sendTyping(msg.chatId).catch(() => { });
-        }, 4000);
-        const history = getRecentConversation(msg.chatId);
-        const reply = await runRelayChatAgent(project, text, history);
-        // Log assistant reply
-        await appendConversation(msg.chatId, {
-            role: 'assistant',
-            content: reply,
-            timestamp: new Date().toISOString(),
+    // ── Internal ──
+    async executeAndPost(platform, msg, project, pendingId) {
+        const runId = randomUUID();
+        const abortController = new AbortController();
+        this.activeAbortControllers.set(msg.conversationId, abortController);
+        // Record the run start
+        recordRelayRun(this.db, {
+            id: runId,
+            platform: platform.name,
+            channelId: msg.channelId,
+            conversationId: msg.conversationId,
+            project,
+            userId: msg.userId,
+            startedAt: new Date().toISOString(),
+            status: 'running',
+            costUsd: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            durationMs: 0,
         });
-        await adapter.send(msg.chatId, reply);
-    }
-    catch (err) {
-        await adapter.send(msg.chatId, `Error: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    finally {
-        clearInterval(typingInterval);
-        await release();
+        // Start streaming indicator
+        const stream = await platform.startStream(msg.channelId, msg.conversationId);
+        try {
+            // Assemble context
+            const { prompt, isStale } = await assembleContext(this.db, platform, msg.channelId, msg.conversationId, msg.text, msg.userName, project, this.config.context);
+            if (isStale) {
+                await platform.sendMessage(msg.channelId, `_Thread inactive for ${this.config.context.staleThreadDays}+ days. Starting fresh context._`, msg.conversationId);
+            }
+            // Execute agent run
+            const request = {
+                platform: platform.name,
+                channelId: msg.channelId,
+                conversationId: msg.conversationId,
+                userId: msg.userId,
+                userName: msg.userName,
+                project,
+                prompt,
+                abortSignal: abortController.signal,
+                onText: (text) => {
+                    stream.append(text).catch(() => { });
+                },
+            };
+            const result = await executeRelayRun(request);
+            // Stop streaming and post final response
+            await stream.stop();
+            // Format and split response
+            const maxLen = platform.capabilities.maxMessageLength;
+            const parts = formatResponse(result.text, maxLen);
+            for (const part of parts) {
+                await platform.sendMessage(msg.channelId, part, msg.conversationId);
+            }
+            // Git diff summary
+            if (result.gitDiffStat) {
+                await platform.sendMessage(msg.channelId, `\`\`\`\n${result.gitDiffStat}\n\`\`\``, msg.conversationId);
+            }
+            // Cost footer
+            const footer = addCostFooter(result);
+            await platform.sendMessage(msg.channelId, footer, msg.conversationId);
+            // Update run record
+            const completedAt = new Date().toISOString();
+            updateRelayRun(this.db, runId, {
+                completedAt,
+                status: result.success ? 'completed' : 'failed',
+                costUsd: result.costUsd,
+                inputTokens: result.inputTokens,
+                outputTokens: result.outputTokens,
+                durationMs: result.durationMs,
+                model: result.model,
+            });
+            // Emit relay webhook event
+            sendWebhookNotification({
+                event: result.success ? 'relay_run_complete' : 'relay_run_failed',
+                timestamp: completedAt,
+                project,
+                workflow: 'relay',
+                success: result.success,
+                summary: result.text.slice(0, 200),
+                costUsd: result.costUsd,
+                durationMs: result.durationMs,
+                model: result.model,
+                platform: platform.name,
+                channelId: msg.channelId,
+            }).catch(() => { });
+        }
+        catch (err) {
+            await stream.stop();
+            const errMsg = err instanceof Error ? err.message : String(err);
+            await platform.sendMessage(msg.channelId, `Error: ${errMsg}`, msg.conversationId);
+            updateRelayRun(this.db, runId, {
+                completedAt: new Date().toISOString(),
+                status: 'failed',
+            });
+        }
+        finally {
+            this.activeAbortControllers.delete(msg.conversationId);
+            markPendingDone(this.db, pendingId);
+        }
     }
 }
 //# sourceMappingURL=router.js.map