@flowdot.ai/daemon 1.0.0

package/dist/goals/TaskQueue.js

@@ -0,0 +1,331 @@
+import { EventEmitter } from 'node:events';
+function getPriorityWeight(priority) {
+    switch (priority) {
+        case 'high': return 10;
+        case 'medium': return 5;
+        case 'low': return 1;
+        default: return 5;
+    }
+}
+import { GoalError } from './errors.js';
+const DEFAULT_MAX_TASKS_PER_DAY = 20;
+const DEFAULT_QUIET_HOURS = {
+    start: 22,
+    end: 6,
+};
+const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+export class TaskQueueError extends GoalError {
+    constructor(message, cause) {
+        super('TASK_EXECUTION_ERROR', message, cause ? { cause } : {});
+    }
+}
+export class QuotaExceededError extends GoalError {
+    constructor(executed, max) {
+        super('TASK_QUOTA_EXCEEDED', `Daily task quota exceeded (${executed}/${max})`);
+    }
+}
+export class TaskQueue extends EventEmitter {
+    maxTasksPerDay;
+    quietHours;
+    enforceQuietHours;
+    typeWeights;
+    logger;
+    tasks;
+    executedToday = 0;
+    lastResetDate = '';
+    quietHoursTimer = null;
+    constructor(options = {}) {
+        super();
+        this.maxTasksPerDay = options.maxTasksPerDay ?? DEFAULT_MAX_TASKS_PER_DAY;
+        this.quietHours = options.quietHours ?? DEFAULT_QUIET_HOURS;
+        this.enforceQuietHours = options.enforceQuietHours ?? true;
+        this.logger = options.logger ?? noopLogger;
+        this.typeWeights = new Map([
+            ['research', 1.0],
+            ['draft', 1.2],
+            ['code', 1.5],
+            ['execute', 2.0],
+            ['recipe', 1.8],
+            ['loop', 1.0],
+            ['notify', 0.5],
+        ]);
+        if (options.typeWeights) {
+            for (const [type, weight] of Object.entries(options.typeWeights)) {
+                this.typeWeights.set(type, weight);
+            }
+        }
+        this.tasks = new Map();
+        this.resetDailyCounterIfNeeded();
+    }
+    addTask(task, goalHash) {
+        if (!this.tasks.has(goalHash)) {
+            this.tasks.set(goalHash, new Map());
+        }
+        const goalTasks = this.tasks.get(goalHash);
+        goalTasks.set(task.id, task);
+        this.logger.debug('TASK_QUEUE', 'Task added', {
+            taskId: task.id,
+            goalHash,
+            type: task.taskType,
+            priority: task.priority,
+        });
+        this.emit('taskAdded', task, goalHash);
+    }
+    addTasks(tasks, goalHash) {
+        for (const task of tasks) {
+            this.addTask(task, goalHash);
+        }
+    }
+    removeTask(taskId, goalHash, reason = 'removed') {
+        const goalTasks = this.tasks.get(goalHash);
+        if (!goalTasks) {
+            return false;
+        }
+        const removed = goalTasks.delete(taskId);
+        if (removed) {
+            this.logger.debug('TASK_QUEUE', 'Task removed', {
+                taskId,
+                goalHash,
+                reason,
+            });
+            this.emit('taskRemoved', taskId, goalHash, reason);
+            if (goalTasks.size === 0) {
+                this.tasks.delete(goalHash);
+            }
+        }
+        return removed;
+    }
+    getNextTask(options = {}) {
+        this.resetDailyCounterIfNeeded();
+        this.pruneExpiredTasks();
+        if (this.executedToday >= this.maxTasksPerDay) {
+            this.logger.debug('TASK_QUEUE', 'Quota reached, no tasks available');
+            return null;
+        }
+        const readyTasks = this.getReadyTasks(options);
+        if (readyTasks.length === 0) {
+            return null;
+        }
+        return readyTasks[0];
+    }
+    getTasks(options = {}) {
+        this.pruneExpiredTasks();
+        const result = [];
+        for (const [goalHash, goalTasks] of this.tasks) {
+            if (options.goalHash && goalHash !== options.goalHash) {
+                continue;
+            }
+            for (const task of goalTasks.values()) {
+                if (options.type && task.taskType !== options.type) {
+                    continue;
+                }
+                if (options.status && task.status !== options.status) {
+                    continue;
+                }
+                const queued = this.createQueuedTask(task, goalHash);
+                if (options.readyOnly && !queued.isReady) {
+                    continue;
+                }
+                result.push(queued);
+            }
+        }
+        result.sort((a, b) => b.priorityScore - a.priorityScore);
+        if (options.limit && options.limit > 0) {
+            return result.slice(0, options.limit);
+        }
+        return result;
+    }
+    getReadyTasks(options = {}) {
+        return this.getTasks({ ...options, readyOnly: true });
+    }
+    markTaskStarted(taskId, goalHash) {
+        this.resetDailyCounterIfNeeded();
+        this.executedToday++;
+        this.logger.debug('TASK_QUEUE', 'Task started', {
+            taskId,
+            goalHash,
+            executedToday: this.executedToday,
+        });
+        if (this.executedToday >= this.maxTasksPerDay) {
+            this.emit('quotaReached', this.executedToday);
+        }
+    }
+    clearGoal(goalHash) {
+        const goalTasks = this.tasks.get(goalHash);
+        if (!goalTasks) {
+            return 0;
+        }
+        const count = goalTasks.size;
+        this.tasks.delete(goalHash);
+        this.logger.info('TASK_QUEUE', 'Goal cleared', { goalHash, count });
+        this.emit('queueCleared', goalHash);
+        return count;
+    }
+    clearAll() {
+        let total = 0;
+        for (const goalTasks of this.tasks.values()) {
+            total += goalTasks.size;
+        }
+        this.tasks.clear();
+        this.logger.info('TASK_QUEUE', 'Queue cleared', { count: total });
+        this.emit('queueCleared');
+        return total;
+    }
+    getStats() {
+        this.resetDailyCounterIfNeeded();
+        let totalPending = 0;
+        let readyCount = 0;
+        let scheduledCount = 0;
+        let expiredCount = 0;
+        const byGoal = new Map();
+        const byType = new Map();
+        const now = new Date();
+        for (const [goalHash, goalTasks] of this.tasks) {
+            byGoal.set(goalHash, goalTasks.size);
+            for (const task of goalTasks.values()) {
+                totalPending++;
+                byType.set(task.taskType, (byType.get(task.taskType) ?? 0) + 1);
+                if (task.expiresAt && new Date(task.expiresAt) < now) {
+                    expiredCount++;
+                }
+                else if (task.scheduledFor && new Date(task.scheduledFor) > now) {
+                    scheduledCount++;
+                }
+                else {
+                    readyCount++;
+                }
+            }
+        }
+        return {
+            totalPending,
+            readyCount,
+            scheduledCount,
+            expiredCount,
+            executedToday: this.executedToday,
+            remainingQuota: Math.max(0, this.maxTasksPerDay - this.executedToday),
+            inQuietHours: this.isInQuietHours(),
+            byGoal,
+            byType,
+        };
+    }
+    isInQuietHours() {
+        if (!this.enforceQuietHours) {
+            return false;
+        }
+        const now = new Date();
+        const hour = now.getHours();
+        if (this.quietHours.start > this.quietHours.end) {
+            return hour >= this.quietHours.start || hour < this.quietHours.end;
+        }
+        else {
+            return hour >= this.quietHours.start && hour < this.quietHours.end;
+        }
+    }
+    hasQuota() {
+        this.resetDailyCounterIfNeeded();
+        return this.executedToday < this.maxTasksPerDay;
+    }
+    stop() {
+        if (this.quietHoursTimer) {
+            clearTimeout(this.quietHoursTimer);
+            this.quietHoursTimer = null;
+        }
+    }
+    createQueuedTask(task, goalHash) {
+        const now = new Date();
+        const priorityScore = this.calculatePriorityScore(task);
+        let isReady = true;
+        let notReadyReason;
+        if (task.expiresAt && new Date(task.expiresAt) < now) {
+            isReady = false;
+            notReadyReason = 'Task has expired';
+        }
+        if (task.scheduledFor && new Date(task.scheduledFor) > now) {
+            isReady = false;
+            notReadyReason = `Scheduled for ${task.scheduledFor}`;
+        }
+        if (this.isInQuietHours()) {
+            isReady = false;
+            notReadyReason = 'Currently in quiet hours';
+        }
+        if (this.executedToday >= this.maxTasksPerDay) {
+            isReady = false;
+            notReadyReason = 'Daily quota reached';
+        }
+        if (task.status !== 'pending' && task.status !== 'awaiting_approval') {
+            isReady = false;
+            notReadyReason = `Task status is ${task.status}`;
+        }
+        return {
+            task,
+            goalHash,
+            queuedAt: new Date(task.createdAt),
+            priorityScore,
+            isReady,
+            notReadyReason,
+        };
+    }
+    calculatePriorityScore(task) {
+        let score = getPriorityWeight(task.priority);
+        const typeWeight = this.typeWeights.get(task.taskType) ?? 1.0;
+        score *= typeWeight;
+        if (task.expiresAt) {
+            const now = new Date();
+            const expires = new Date(task.expiresAt);
+            const hoursUntilExpiry = (expires.getTime() - now.getTime()) / (1000 * 60 * 60);
+            if (hoursUntilExpiry > 0 && hoursUntilExpiry < 24) {
+                score *= 1.5;
+            }
+            else if (hoursUntilExpiry > 0 && hoursUntilExpiry < 4) {
+                score *= 2.0;
+            }
+        }
+        const ageHours = (Date.now() - new Date(task.createdAt).getTime()) / (1000 * 60 * 60);
+        if (ageHours > 24) {
+            score *= 1.1;
+        }
+        return score;
+    }
+    pruneExpiredTasks() {
+        const now = new Date();
+        for (const [goalHash, goalTasks] of this.tasks) {
+            const expired = [];
+            for (const task of goalTasks.values()) {
+                if (task.expiresAt && new Date(task.expiresAt) < now) {
+                    expired.push(task.id);
+                }
+            }
+            for (const taskId of expired) {
+                const task = goalTasks.get(taskId);
+                goalTasks.delete(taskId);
+                if (task) {
+                    this.logger.info('TASK_QUEUE', 'Task expired', {
+                        taskId,
+                        goalHash,
+                        title: task.title,
+                    });
+                    this.emit('taskExpired', task, goalHash);
+                }
+            }
+            if (goalTasks.size === 0) {
+                this.tasks.delete(goalHash);
+            }
+        }
+    }
+    resetDailyCounterIfNeeded() {
+        const today = new Date().toISOString().split('T')[0];
+        if (this.lastResetDate !== today) {
+            this.executedToday = 0;
+            this.lastResetDate = today;
+            this.logger.debug('TASK_QUEUE', 'Daily counter reset', { date: today });
+        }
+    }
+}
+export function createTaskQueue(options = {}) {
+    return new TaskQueue(options);
+}

package/dist/goals/TaskSanitizer.d.ts

@@ -0,0 +1,61 @@
+import type { CreateTaskInput, Logger } from './types.js';
+import { GoalError } from './errors.js';
+export interface SanitizationResult {
+    readonly isValid: boolean;
+    readonly sanitizedInput: CreateTaskInput | null;
+    readonly warnings: string[];
+    readonly blocked: boolean;
+    readonly blockReason?: string;
+    readonly securityIssues: SecurityIssue[];
+    readonly modifications: string[];
+}
+export interface SecurityIssue {
+    readonly type: SecurityIssueType;
+    readonly severity: 'low' | 'medium' | 'high' | 'critical';
+    readonly description: string;
+    readonly location?: string;
+    readonly matchedPattern?: string;
+}
+export type SecurityIssueType = 'prompt_injection' | 'command_injection' | 'path_traversal' | 'sensitive_path' | 'dangerous_command' | 'control_character' | 'excessive_length' | 'suspicious_pattern' | 'encoding_attack';
+export interface TaskSanitizerOptions {
+    readonly allowedPaths?: string[];
+    readonly deniedPaths?: string[];
+    readonly allowedCommands?: string[];
+    readonly deniedCommands?: string[];
+    readonly maxTitleLength?: number;
+    readonly maxDescriptionLength?: number;
+    readonly strictMode?: boolean;
+    readonly customBlockedPatterns?: RegExp[];
+    readonly logger?: Logger;
+}
+export interface PathValidationResult {
+    isValid: boolean;
+    normalizedPath: string;
+    issues: SecurityIssue[];
+}
+export declare class TaskSanitizationError extends GoalError {
+    readonly issues: SecurityIssue[];
+    constructor(message: string, issues: SecurityIssue[]);
+}
+export declare class TaskSanitizer {
+    private readonly allowedPaths;
+    private readonly deniedPaths;
+    private readonly allowedCommands;
+    private readonly deniedCommands;
+    private readonly maxTitleLength;
+    private readonly maxDescriptionLength;
+    private readonly strictMode;
+    private readonly customBlockedPatterns;
+    private readonly logger;
+    constructor(options?: TaskSanitizerOptions);
+    sanitize(input: CreateTaskInput): SanitizationResult;
+    validatePath(path: string): PathValidationResult;
+    validateCommand(command: string): SecurityIssue[];
+    private checkPromptInjection;
+    private checkDangerousCommands;
+    private checkCustomPatterns;
+    private sanitizeText;
+    private matchesGlob;
+}
+export declare function createTaskSanitizer(options?: TaskSanitizerOptions): TaskSanitizer;
+export declare function createSecureTaskSanitizer(logger?: Logger): TaskSanitizer;