verybot 0.1.3

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;
+}

package/dist/scheduler/store.js

@@ -0,0 +1,205 @@
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+import Database from "better-sqlite3";
+import { Cron } from "croner";
+import { logger } from "../logger.js";
+/** Map a DB row to a Schedule object. */
+function rowToSchedule(row) {
+    return {
+        id: row.id,
+        teamId: row.team_id,
+        prompt: row.prompt,
+        type: row.type,
+        cron: row.cron,
+        runAt: row.run_at,
+        timezone: row.timezone,
+        integrations: row.integrations,
+        conditional: row.conditional === 1,
+        status: row.status,
+        nextRun: row.next_run,
+        lastRun: row.last_run,
+        failCount: row.fail_count,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+export class ScheduleStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /** Async factory — mirrors MemoryStore.create pattern. */
+    static async create(dbPath) {
+        mkdirSync(dirname(dbPath), { recursive: true });
+        const db = new Database(dbPath);
+        db.pragma("journal_mode = WAL");
+        const store = new ScheduleStore(db);
+        store.createSchema();
+        return store;
+    }
+    createSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS schedules (
+        id TEXT PRIMARY KEY,
+        team_id TEXT NOT NULL,
+        prompt TEXT NOT NULL,
+        type TEXT NOT NULL,
+        cron TEXT,
+        run_at TEXT,
+        timezone TEXT NOT NULL DEFAULT 'UTC',
+        integrations TEXT NOT NULL DEFAULT '',
+        conditional INTEGER NOT NULL DEFAULT 0,
+        status TEXT NOT NULL DEFAULT 'active',
+        next_run TEXT,
+        last_run TEXT,
+        fail_count INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_schedules_next_run ON schedules(next_run);
+      CREATE INDEX IF NOT EXISTS idx_schedules_status ON schedules(status);
+      CREATE INDEX IF NOT EXISTS idx_schedules_team ON schedules(team_id);
+
+      CREATE TABLE IF NOT EXISTS scheduler_settings (
+        team_id TEXT PRIMARY KEY,
+        timezone TEXT NOT NULL DEFAULT 'UTC'
+      );
+    `);
+    }
+    // --- CRUD ---
+    create(schedule) {
+        this.db
+            .prepare(`INSERT INTO schedules (
+          id, team_id, prompt, type, cron, run_at, timezone,
+          integrations, conditional,
+          status, next_run, last_run, fail_count, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(schedule.id, schedule.teamId, schedule.prompt, schedule.type, schedule.cron, schedule.runAt, schedule.timezone, schedule.integrations, schedule.conditional ? 1 : 0, schedule.status, schedule.nextRun, schedule.lastRun, schedule.failCount, schedule.createdAt, schedule.updatedAt);
+    }
+    getById(id) {
+        const row = this.db
+            .prepare("SELECT * FROM schedules WHERE id = ?")
+            .get(id);
+        return row ? rowToSchedule(row) : null;
+    }
+    listByTeam(teamId, status) {
+        if (status) {
+            const rows = this.db
+                .prepare("SELECT * FROM schedules WHERE team_id = ? AND status = ? ORDER BY created_at DESC")
+                .all(teamId, status);
+            return rows.map(rowToSchedule);
+        }
+        const rows = this.db
+            .prepare("SELECT * FROM schedules WHERE team_id = ? ORDER BY created_at DESC")
+            .all(teamId);
+        return rows.map(rowToSchedule);
+    }
+    /** Get all schedules that are due (next_run <= now and status = 'active'). */
+    getDueSchedules(now) {
+        const rows = this.db
+            .prepare("SELECT * FROM schedules WHERE status = 'active' AND next_run IS NOT NULL AND next_run <= ?")
+            .all(now.toISOString());
+        return rows.map(rowToSchedule);
+    }
+    /** Get all schedules with a specific status. */
+    getByStatus(status) {
+        const rows = this.db
+            .prepare("SELECT * FROM schedules WHERE status = ?")
+            .all(status);
+        return rows.map(rowToSchedule);
+    }
+    /** Update specific fields on a schedule. */
+    update(id, fields) {
+        const sets = [];
+        const values = [];
+        if (fields.status !== undefined) {
+            sets.push("status = ?");
+            values.push(fields.status);
+        }
+        if (fields.nextRun !== undefined) {
+            sets.push("next_run = ?");
+            values.push(fields.nextRun);
+        }
+        if (fields.lastRun !== undefined) {
+            sets.push("last_run = ?");
+            values.push(fields.lastRun);
+        }
+        if (fields.failCount !== undefined) {
+            sets.push("fail_count = ?");
+            values.push(fields.failCount);
+        }
+        if (sets.length === 0)
+            return;
+        sets.push("updated_at = ?");
+        values.push(new Date().toISOString());
+        values.push(id);
+        this.db.prepare(`UPDATE schedules SET ${sets.join(", ")} WHERE id = ?`).run(...values);
+    }
+    delete(id) {
+        const info = this.db.prepare("DELETE FROM schedules WHERE id = ?").run(id);
+        return info.changes > 0;
+    }
+    /** Mark a schedule as completed for this run and advance to the next. */
+    markCompleted(id, nextRun) {
+        const now = new Date().toISOString();
+        if (nextRun) {
+            // Recurring — advance to next run
+            this.db
+                .prepare("UPDATE schedules SET last_run = ?, next_run = ?, fail_count = 0, updated_at = ? WHERE id = ?")
+                .run(now, nextRun, now, id);
+        }
+        else {
+            // One-shot — mark completed
+            this.db
+                .prepare("UPDATE schedules SET last_run = ?, next_run = NULL, status = 'completed', fail_count = 0, updated_at = ? WHERE id = ?")
+                .run(now, now, id);
+        }
+    }
+    /** Increment fail count and optionally advance the schedule. */
+    markFailed(id, nextRun) {
+        const now = new Date().toISOString();
+        if (nextRun) {
+            // Recurring — advance despite failure
+            this.db
+                .prepare("UPDATE schedules SET last_run = ?, next_run = ?, fail_count = fail_count + 1, updated_at = ? WHERE id = ?")
+                .run(now, nextRun, now, id);
+        }
+        else {
+            // One-shot — mark failed
+            this.db
+                .prepare("UPDATE schedules SET last_run = ?, next_run = NULL, status = 'failed', fail_count = fail_count + 1, updated_at = ? WHERE id = ?")
+                .run(now, now, id);
+        }
+    }
+    // --- Next run computation ---
+    /** Compute the next run time for a recurring schedule using croner. */
+    computeNextRun(schedule) {
+        if (schedule.type !== "recurring" || !schedule.cron)
+            return null;
+        try {
+            const job = new Cron(schedule.cron, { timezone: schedule.timezone });
+            const next = job.nextRun();
+            return next ? next.toISOString() : null;
+        }
+        catch (err) {
+            logger.warn(`Failed to compute next run for schedule ${schedule.id}: ${err instanceof Error ? err.message : err}`);
+            return null;
+        }
+    }
+    // --- Team Settings ---
+    setTimezone(teamId, timezone) {
+        this.db
+            .prepare("INSERT INTO scheduler_settings (team_id, timezone) VALUES (?, ?) ON CONFLICT(team_id) DO UPDATE SET timezone = ?")
+            .run(teamId, timezone, timezone);
+    }
+    getTimezone(teamId) {
+        const row = this.db
+            .prepare("SELECT timezone FROM scheduler_settings WHERE team_id = ?")
+            .get(teamId);
+        return row?.timezone ?? null;
+    }
+    close() {
+        this.db.close();
+        logger.info("Schedule store closed");
+    }
+}

package/dist/scheduler/types.d.ts

@@ -0,0 +1,29 @@
+export type ScheduleType = "one_shot" | "recurring";
+export type ScheduleStatus = "active" | "paused" | "completed" | "failed";
+export interface Schedule {
+    id: string;
+    /** Team that owns this schedule */
+    teamId: string;
+    /** The user's instruction / prompt for the LLM */
+    prompt: string;
+    type: ScheduleType;
+    /** Cron expression (recurring only) */
+    cron: string | null;
+    /** ISO timestamp (one-shot only) */
+    runAt: string | null;
+    /** IANA timezone, e.g. "America/New_York" */
+    timezone: string;
+    /** Comma-separated integration names to enable for this task */
+    integrations: string;
+    /** Whether the LLM can skip delivery with [SKIP] */
+    conditional: boolean;
+    status: ScheduleStatus;
+    /** ISO timestamp of next scheduled run */
+    nextRun: string | null;
+    /** ISO timestamp of last completed run */
+    lastRun: string | null;
+    /** Number of consecutive failures */
+    failCount: number;
+    createdAt: string;
+    updatedAt: string;
+}

package/dist/scheduler/types.js

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

package/dist/security/command-validator.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Command validation for bash tool security.
+ *
+ * Blocks dangerous shell syntax (quote-aware) and checks executables
+ * against safe-bin and allowlist rules.
+ */
+/** Default read-only commands that always pass in allowlist mode. */
+export declare const DEFAULT_SAFE_BINS: Set<string>;
+interface ValidationResult {
+    ok: boolean;
+    reason?: string;
+}
+/**
+ * Check for dangerous shell syntax (quote-aware).
+ *
+ * Blocks backticks, command substitution `$(...)`, redirects `> <`,
+ * and subshells `( )` when they appear outside of quotes.
+ */
+export declare function validateCommand(command: string): ValidationResult;
+/** Check if ALL segments of a command match the allowlist. */
+export declare function isAllowed(command: string, safeBins: Set<string>, allowlist: string[]): boolean;
+export {};