verybot 0.1.8

package/dist/prompt-templates/store.js

@@ -0,0 +1,224 @@
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+import { randomUUID } from "crypto";
+import Database from "better-sqlite3";
+import { logger } from "../logger.js";
+/** Max allowed length for template names. */
+export const MAX_TEMPLATE_NAME_LENGTH = 128;
+/** Max allowed length for template content. */
+export const MAX_TEMPLATE_CONTENT_LENGTH = 50_000;
+const VALID_ROLES = new Set(["orchestrator", "worker"]);
+const FORK_NAME_SUFFIX = "Copy";
+const FIRST_FORK_DUPLICATE_INDEX = 2;
+/**
+ * SQLite-backed persistence for prompt templates.
+ * Shares the same DB file as TeamStore, TaskStore, etc.
+ */
+export class PromptTemplateStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    static async create(dbPath) {
+        mkdirSync(dirname(dbPath), { recursive: true });
+        const db = new Database(dbPath);
+        db.pragma("journal_mode = WAL");
+        const store = new PromptTemplateStore(db);
+        store.createSchema();
+        return store;
+    }
+    createSchema() {
+        this.db.pragma("foreign_keys = ON");
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS prompt_templates (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL UNIQUE,
+        description TEXT NOT NULL DEFAULT '',
+        role TEXT NOT NULL,
+        content TEXT NOT NULL DEFAULT '',
+        builtin INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+    `);
+    }
+    createPromptTemplate(input) {
+        validateName(input.name);
+        validateContent(input.content);
+        validateRole(input.role);
+        const now = Date.now();
+        const id = input.id ?? randomUUID();
+        try {
+            this.db.prepare(`INSERT INTO prompt_templates (id, name, description, role, content, builtin, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, 0, ?, ?)`).run(id, input.name, input.description ?? "", input.role, input.content, now, now);
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
+                throw new Error(`A template named "${input.name}" already exists`);
+            }
+            throw err;
+        }
+        return {
+            id, name: input.name, description: input.description ?? "",
+            role: input.role, content: input.content, builtin: false,
+            createdAt: now, updatedAt: now,
+        };
+    }
+    forkPromptTemplate(sourceId, input = {}) {
+        const source = this.getPromptTemplateById(sourceId);
+        if (!source)
+            return null;
+        const name = input.name === undefined
+            ? buildForkName(source.name, this.listPromptTemplateNames())
+            : input.name.trim();
+        return this.createPromptTemplate({
+            name,
+            description: input.description ?? source.description,
+            role: source.role,
+            content: source.content,
+        });
+    }
+    updatePromptTemplate(id, input) {
+        const existing = this.getPromptTemplateById(id);
+        if (!existing)
+            return null;
+        if (existing.builtin)
+            throw new Error("Cannot modify a built-in template");
+        if (input.name !== undefined)
+            validateName(input.name);
+        if (input.content !== undefined)
+            validateContent(input.content);
+        if (input.role !== undefined)
+            validateRole(input.role);
+        const now = Date.now();
+        const updated = {
+            ...existing,
+            ...(input.name !== undefined && { name: input.name }),
+            ...(input.description !== undefined && { description: input.description }),
+            ...(input.role !== undefined && { role: input.role }),
+            ...(input.content !== undefined && { content: input.content }),
+            updatedAt: now,
+        };
+        try {
+            this.db.prepare(`UPDATE prompt_templates SET name = ?, description = ?, role = ?, content = ?, updated_at = ? WHERE id = ?`).run(updated.name, updated.description, updated.role, updated.content, now, id);
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
+                throw new Error(`A template named "${input.name}" already exists`);
+            }
+            throw err;
+        }
+        return updated;
+    }
+    deletePromptTemplate(id) {
+        const existing = this.getPromptTemplateById(id);
+        if (existing?.builtin)
+            throw new Error("Cannot delete a built-in template");
+        const info = this.db.prepare("DELETE FROM prompt_templates WHERE id = ?").run(id);
+        return info.changes > 0;
+    }
+    getPromptTemplateById(id) {
+        const row = this.db.prepare("SELECT * FROM prompt_templates WHERE id = ?").get(id);
+        return row ? toPromptTemplate(row) : null;
+    }
+    listPromptTemplates() {
+        const rows = this.db.prepare("SELECT * FROM prompt_templates ORDER BY builtin DESC, created_at ASC").all();
+        return rows.map(toPromptTemplate);
+    }
+    listPromptTemplateNames() {
+        const rows = this.db.prepare("SELECT name FROM prompt_templates").all();
+        return rows.map((row) => row.name);
+    }
+    /**
+     * Upsert built-in templates by id on boot.
+     * Only updates name/description/role/content for existing builtins.
+     */
+    seedBuiltins(templates) {
+        const upsert = this.db.prepare(`
+      INSERT INTO prompt_templates (id, name, description, role, content, builtin, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, 1, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        name = excluded.name,
+        description = excluded.description,
+        role = excluded.role,
+        content = excluded.content,
+        builtin = 1,
+        updated_at = excluded.updated_at
+    `);
+        const now = Date.now();
+        const keepIds = templates.map((t) => t.id);
+        const runAll = this.db.transaction(() => {
+            for (const t of templates) {
+                upsert.run(t.id, t.name, t.description, t.role, t.content, now, now);
+            }
+            if (keepIds.length === 0) {
+                this.db.prepare(`DELETE FROM prompt_templates WHERE builtin = 1`).run();
+            }
+            else {
+                this.db.prepare(`DELETE FROM prompt_templates WHERE builtin = 1 AND id NOT IN (${keepIds.map(() => "?").join(",")})`).run(...keepIds);
+            }
+        });
+        runAll();
+        logger.info(`Seeded ${templates.length} built-in prompt templates`);
+    }
+    close() {
+        this.db.close();
+        logger.info("Prompt template store closed");
+    }
+}
+function toPromptTemplate(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        description: row.description ?? "",
+        role: row.role,
+        content: row.content ?? "",
+        builtin: row.builtin === 1,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function validateName(name) {
+    if (typeof name !== "string" || name.trim().length === 0) {
+        throw new Error("Template name is required");
+    }
+    if (name.length > MAX_TEMPLATE_NAME_LENGTH) {
+        throw new Error(`Template name exceeds maximum length of ${MAX_TEMPLATE_NAME_LENGTH}`);
+    }
+}
+function validateContent(content) {
+    if (typeof content !== "string") {
+        throw new Error("Template content must be a string");
+    }
+    if (content.length > MAX_TEMPLATE_CONTENT_LENGTH) {
+        throw new Error(`Template content exceeds maximum length of ${MAX_TEMPLATE_CONTENT_LENGTH}`);
+    }
+}
+function validateRole(role) {
+    if (!VALID_ROLES.has(role)) {
+        throw new Error("role must be 'orchestrator' or 'worker'");
+    }
+}
+function buildForkName(sourceName, existingNames) {
+    const trimmedSourceName = sourceName.trim();
+    const firstForkName = `${trimmedSourceName} (${FORK_NAME_SUFFIX})`;
+    const existing = new Set(existingNames);
+    if (!existing.has(firstForkName))
+        return firstForkName;
+    const escapedName = escapeRegex(trimmedSourceName);
+    const forkPattern = new RegExp(`^${escapedName} \\(${FORK_NAME_SUFFIX}(?: (\\d+))?\\)$`);
+    let nextIndex = FIRST_FORK_DUPLICATE_INDEX;
+    for (const candidateName of existing) {
+        const match = candidateName.match(forkPattern);
+        if (!match)
+            continue;
+        const usedIndex = match[1] ? Number(match[1]) : 1;
+        if (!Number.isFinite(usedIndex))
+            continue;
+        nextIndex = Math.max(nextIndex, usedIndex + 1);
+    }
+    return `${trimmedSourceName} (${FORK_NAME_SUFFIX} ${nextIndex})`;
+}
+function escapeRegex(input) {
+    return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/prompt-templates/types.d.ts

@@ -0,0 +1,10 @@
+export interface PromptTemplate {
+    id: string;
+    name: string;
+    description: string;
+    role: "orchestrator" | "worker";
+    content: string;
+    builtin: boolean;
+    createdAt: number;
+    updatedAt: number;
+}

package/dist/prompt-templates/types.js

@@ -0,0 +1 @@
+export {};

package/dist/scheduler/connected-channels.d.ts

@@ -0,0 +1,24 @@
+export interface ConnectedChannel {
+    channelType: string;
+    channelId: string;
+    send: (text: string) => Promise<void>;
+}
+/**
+ * In-memory registry tracking which channels are connected to which team's scheduler.
+ * Multiple channels (web UI, Telegram, etc.) can connect simultaneously.
+ */
+export declare class ConnectedChannelRegistry {
+    /** Map<teamId, Map<connectionKey, ConnectedChannel>> */
+    private channels;
+    /** Register a channel connection. Returns a unique connection key for later disconnect. */
+    connect(teamId: string, channel: ConnectedChannel): string;
+    /** Unregister a channel connection. */
+    disconnect(teamId: string, key: string): void;
+    /** Get all connected channels for a team. */
+    getAll(teamId: string): ConnectedChannel[];
+    /**
+     * Broadcast a message to all connected channels for a team.
+     * `excludeKey` skips a specific connection (e.g., the sender that already has the reply).
+     */
+    broadcastToTeam(teamId: string, text: string, excludeKey?: string): Promise<void>;
+}

package/dist/scheduler/connected-channels.js

@@ -0,0 +1,57 @@
+import { randomUUID } from "crypto";
+import { logger } from "../logger.js";
+/**
+ * In-memory registry tracking which channels are connected to which team's scheduler.
+ * Multiple channels (web UI, Telegram, etc.) can connect simultaneously.
+ */
+export class ConnectedChannelRegistry {
+    /** Map<teamId, Map<connectionKey, ConnectedChannel>> */
+    channels = new Map();
+    /** Register a channel connection. Returns a unique connection key for later disconnect. */
+    connect(teamId, channel) {
+        const key = randomUUID();
+        let teamMap = this.channels.get(teamId);
+        if (!teamMap) {
+            teamMap = new Map();
+            this.channels.set(teamId, teamMap);
+        }
+        teamMap.set(key, channel);
+        logger.info(`[scheduler] Channel connected: ${channel.channelType}:${channel.channelId} → team ${teamId} (key: ${key.slice(0, 8)})`);
+        return key;
+    }
+    /** Unregister a channel connection. */
+    disconnect(teamId, key) {
+        const teamMap = this.channels.get(teamId);
+        if (!teamMap)
+            return;
+        teamMap.delete(key);
+        if (teamMap.size === 0)
+            this.channels.delete(teamId);
+        logger.info(`[scheduler] Channel disconnected: team ${teamId} (key: ${key.slice(0, 8)})`);
+    }
+    /** Get all connected channels for a team. */
+    getAll(teamId) {
+        const teamMap = this.channels.get(teamId);
+        if (!teamMap)
+            return [];
+        return [...teamMap.values()];
+    }
+    /**
+     * Broadcast a message to all connected channels for a team.
+     * `excludeKey` skips a specific connection (e.g., the sender that already has the reply).
+     */
+    async broadcastToTeam(teamId, text, excludeKey) {
+        const teamMap = this.channels.get(teamId);
+        if (!teamMap)
+            return;
+        const sends = [];
+        for (const [key, channel] of teamMap) {
+            if (key === excludeKey)
+                continue;
+            sends.push(channel.send(text).catch((err) => {
+                logger.warn(`[scheduler] Broadcast to ${channel.channelType}:${channel.channelId} failed: ${err instanceof Error ? err.message : err}`);
+            }));
+        }
+        await Promise.all(sends);
+    }
+}

package/dist/scheduler/scheduler.d.ts

@@ -0,0 +1,22 @@
+import type { ScheduleStore } from "./store.js";
+import type { Agent } from "../brain/agent.js";
+import type { ConnectedChannelRegistry } from "./connected-channels.js";
+export declare class Scheduler {
+    private store;
+    private agent;
+    private connectedChannels;
+    private tickMs;
+    private timer;
+    private running;
+    constructor(store: ScheduleStore, agent: Agent, connectedChannels: ConnectedChannelRegistry, tickMs?: number);
+    start(): void;
+    stop(): void;
+    /**
+     * On startup: fire missed one-shots, skip missed recurring.
+     */
+    private catchUp;
+    private tick;
+    private executeTask;
+    private advanceSchedule;
+    private handleError;
+}

package/dist/scheduler/scheduler.js

@@ -0,0 +1,132 @@
+import { logger } from "../logger.js";
+const TICK_INTERVAL_MS = 5_000;
+const MAX_RETRY_COUNT = 1;
+/** Prefix that LLM uses to signal "not worth notifying". */
+const SKIP_SIGNAL = "[SKIP]";
+export class Scheduler {
+    store;
+    agent;
+    connectedChannels;
+    tickMs;
+    timer = null;
+    running = false;
+    constructor(store, agent, connectedChannels, tickMs = TICK_INTERVAL_MS) {
+        this.store = store;
+        this.agent = agent;
+        this.connectedChannels = connectedChannels;
+        this.tickMs = tickMs;
+    }
+    start() {
+        // Catch up missed tasks on startup
+        this.catchUp().catch((err) => {
+            logger.error(`Scheduler catch-up failed: ${err instanceof Error ? err.message : err}`);
+        });
+        this.timer = setInterval(() => {
+            this.tick().catch((err) => {
+                logger.error(`Scheduler tick failed: ${err instanceof Error ? err.message : err}`);
+            });
+        }, this.tickMs);
+        logger.info(`Scheduler started (tick every ${this.tickMs}ms)`);
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        logger.info("Scheduler stopped");
+    }
+    /**
+     * On startup: fire missed one-shots, skip missed recurring.
+     */
+    async catchUp() {
+        const now = new Date();
+        const due = this.store.getDueSchedules(now);
+        if (due.length === 0)
+            return;
+        const oneShots = due.filter((s) => s.type === "one_shot");
+        const recurring = due.filter((s) => s.type === "recurring");
+        // Skip missed recurring — advance to next future run
+        for (const schedule of recurring) {
+            const nextRun = this.store.computeNextRun(schedule);
+            this.store.markCompleted(schedule.id, nextRun);
+            logger.info(`[scheduler] Skipped missed recurring "${schedule.prompt.slice(0, 40)}..." → next: ${nextRun}`);
+        }
+        // Fire missed one-shots
+        if (oneShots.length > 0) {
+            logger.info(`[scheduler] Catching up ${oneShots.length} missed one-shot task(s)`);
+            await Promise.allSettled(oneShots.map((s) => this.executeTask(s)));
+        }
+    }
+    async tick() {
+        if (this.running)
+            return; // prevent overlapping ticks
+        this.running = true;
+        try {
+            const due = this.store.getDueSchedules(new Date());
+            if (due.length === 0)
+                return;
+            logger.info(`[scheduler] ${due.length} task(s) due`);
+            await Promise.allSettled(due.map((s) => this.executeTask(s)));
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    async executeTask(schedule) {
+        const taskLabel = `"${schedule.prompt.slice(0, 50)}..." (${schedule.id})`;
+        logger.info(`[scheduler] Executing task ${taskLabel}`);
+        try {
+            const reply = await this.agent.runScheduledTask({
+                prompt: schedule.prompt,
+                teamId: schedule.teamId,
+                integrations: schedule.integrations.split(",").filter(Boolean),
+            });
+            // Check for [SKIP] signal on conditional tasks
+            if (schedule.conditional && reply.trimStart().startsWith(SKIP_SIGNAL)) {
+                logger.info(`[scheduler] Task ${taskLabel} skipped by LLM`);
+                this.advanceSchedule(schedule);
+                return;
+            }
+            // Broadcast to all connected channels for this team
+            await this.connectedChannels.broadcastToTeam(schedule.teamId, reply);
+            logger.info(`[scheduler] Task ${taskLabel} broadcast to team ${schedule.teamId}`);
+            // Reset fail count and advance
+            this.advanceSchedule(schedule);
+        }
+        catch (err) {
+            await this.handleError(schedule, err);
+        }
+    }
+    advanceSchedule(schedule) {
+        const nextRun = schedule.type === "recurring" ? this.store.computeNextRun(schedule) : null;
+        this.store.markCompleted(schedule.id, nextRun);
+        if (nextRun) {
+            logger.info(`[scheduler] Next run for ${schedule.id}: ${nextRun}`);
+        }
+    }
+    async handleError(schedule, err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const taskLabel = `"${schedule.prompt.slice(0, 50)}..." (${schedule.id})`;
+        // Re-read to get current fail count
+        const current = this.store.getById(schedule.id);
+        const failCount = (current?.failCount ?? schedule.failCount) + 1;
+        if (failCount <= MAX_RETRY_COUNT) {
+            // Retry: increment fail count, leave next_run unchanged (fires on next tick)
+            logger.warn(`[scheduler] Task ${taskLabel} failed (attempt ${failCount}), will retry: ${msg}`);
+            this.store.update(schedule.id, { failCount });
+            return;
+        }
+        // Max retries exceeded — advance the schedule and notify user
+        logger.error(`[scheduler] Task ${taskLabel} failed after ${failCount} attempts: ${msg}`);
+        const nextRun = schedule.type === "recurring" ? this.store.computeNextRun(schedule) : null;
+        this.store.markFailed(schedule.id, nextRun);
+        // Best-effort notification to connected channels
+        try {
+            const notification = `Scheduled task failed: "${schedule.prompt.slice(0, 80)}..."\nError: ${msg}`;
+            await this.connectedChannels.broadcastToTeam(schedule.teamId, notification);
+        }
+        catch {
+            logger.warn(`[scheduler] Could not notify about failed task ${schedule.id}`);
+        }
+    }
+}

package/dist/scheduler/store.d.ts

@@ -0,0 +1,27 @@
+import type { Schedule, ScheduleStatus } from "./types.js";
+export declare class ScheduleStore {
+    private db;
+    private constructor();
+    /** Async factory — mirrors MemoryStore.create pattern. */
+    static create(dbPath: string): Promise<ScheduleStore>;
+    private createSchema;
+    create(schedule: Schedule): void;
+    getById(id: string): Schedule | null;
+    listByTeam(teamId: string, status?: ScheduleStatus): Schedule[];
+    /** Get all schedules that are due (next_run <= now and status = 'active'). */
+    getDueSchedules(now: Date): Schedule[];
+    /** Get all schedules with a specific status. */
+    getByStatus(status: ScheduleStatus): Schedule[];
+    /** Update specific fields on a schedule. */
+    update(id: string, fields: Partial<Pick<Schedule, "status" | "nextRun" | "lastRun" | "failCount">>): void;
+    delete(id: string): boolean;
+    /** Mark a schedule as completed for this run and advance to the next. */
+    markCompleted(id: string, nextRun: string | null): void;
+    /** Increment fail count and optionally advance the schedule. */
+    markFailed(id: string, nextRun: string | null): void;
+    /** Compute the next run time for a recurring schedule using croner. */
+    computeNextRun(schedule: Schedule): string | null;
+    setTimezone(teamId: string, timezone: string): void;
+    getTimezone(teamId: string): string | null;
+    close(): void;
+}