verybot 0.1.8

package/dist/brain/session-store.d.ts

@@ -0,0 +1,50 @@
+import { Session } from "./session.js";
+export interface SessionIndexEntry {
+    key: string;
+    file: string;
+    messageCount: number;
+    updatedAt: number;
+    /** Human-readable title — auto-set from first user message, editable via rename. */
+    title?: string;
+    /** Team UUID (stable reference, survives renames). */
+    teamId?: string;
+    /** Team name snapshot at save time (denormalized for fast display). */
+    teamName?: string;
+    /** Channel type: "gateway", "worker", "scheduler", "telegram", etc. */
+    channelType?: string;
+    /** Worker agent ID (stable reference for worker sessions). */
+    agentId?: string;
+    /** Worker agent name snapshot at save time (denormalized for display). */
+    agentName?: string;
+}
+export declare class SessionStore {
+    private dataDir;
+    private indexPath;
+    private index;
+    constructor(dataDir: string);
+    /** Save session to JSONL. Three modes: compaction marker, full rewrite, or append. */
+    save(session: Session): Promise<void>;
+    /** Load a session from its JSONL file. Respects compaction markers. */
+    load(sessionKey: string): Promise<Session | null>;
+    /** List all session keys with metadata. */
+    list(): SessionIndexEntry[];
+    /** Rename a session (update its title in the index). */
+    rename(sessionKey: string, title: string): boolean;
+    /**
+     * Update session metadata (team name, agent info). Only writes to disk if something changed.
+     * Note: teamName and agentName are denormalized snapshots — they may become stale if
+     * the team or agent is renamed after the session was last active.
+     */
+    updateMetadata(sessionKey: string, meta: {
+        teamId?: string;
+        teamName?: string;
+        channelType?: string;
+        agentId?: string;
+        agentName?: string;
+    }): void;
+    /** Clear a session — deletes the JSONL file and removes the index entry. */
+    clear(sessionKey: string): Promise<void>;
+    private getOrCreateEntry;
+    private loadIndex;
+    private saveIndex;
+}

package/dist/brain/session-store.js

@@ -0,0 +1,207 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Session } from "./session.js";
+import { parseSessionKey } from "./session-key.js";
+const MAX_TITLE_LEN = 30;
+function isCompaction(entry) {
+    return "type" in entry && entry.type === "compaction";
+}
+export class SessionStore {
+    dataDir;
+    indexPath;
+    index;
+    constructor(dataDir) {
+        this.dataDir = dataDir;
+        this.indexPath = path.join(dataDir, "index.json");
+        // Ensure directory exists
+        fs.mkdirSync(dataDir, { recursive: true });
+        // Load existing index
+        this.index = this.loadIndex();
+    }
+    /** Save session to JSONL. Three modes: compaction marker, full rewrite, or append. */
+    async save(session) {
+        const entry = this.getOrCreateEntry(session.key);
+        const filePath = path.join(this.dataDir, entry.file);
+        if (session.pendingCompaction) {
+            // Compaction: append marker + re-append kept messages (append-only, preserves history)
+            const marker = {
+                type: "compaction",
+                ts: Date.now(),
+                summary: session.pendingCompaction.summary,
+            };
+            const kept = session.getCompactionMessages();
+            const lines = JSON.stringify(marker) +
+                "\n" +
+                kept.map((msg) => JSON.stringify({ ts: Date.now(), message: msg })).join("\n") +
+                "\n";
+            fs.appendFileSync(filePath, lines, "utf-8");
+        }
+        else if (session.needsFullRewrite) {
+            // Emergency truncate: overwrite entire file
+            const all = session.getMessages();
+            const lines = all.map((msg) => JSON.stringify({ ts: Date.now(), message: msg })).join("\n") + "\n";
+            fs.writeFileSync(filePath, lines, "utf-8");
+        }
+        else {
+            // Normal: append only new messages
+            const newMessages = session.getNewMessages();
+            if (newMessages.length === 0)
+                return;
+            const lines = newMessages.map((msg) => JSON.stringify({ ts: Date.now(), message: msg })).join("\n") + "\n";
+            fs.appendFileSync(filePath, lines, "utf-8");
+        }
+        session.markPersisted();
+        // Update index
+        entry.messageCount = session.messageCount;
+        entry.updatedAt = Date.now();
+        // Auto-set title from first user message (once)
+        if (!entry.title) {
+            const firstUserMsg = session
+                .getMessages()
+                .find((m) => m.role === "user" && typeof m.content === "string" && m.content.trim());
+            if (firstUserMsg && typeof firstUserMsg.content === "string") {
+                const raw = firstUserMsg.content.trim().split("\n")[0];
+                entry.title = raw.length > MAX_TITLE_LEN ? raw.slice(0, MAX_TITLE_LEN - 1) + "\u2026" : raw;
+            }
+        }
+        this.saveIndex();
+    }
+    /** Load a session from its JSONL file. Respects compaction markers. */
+    async load(sessionKey) {
+        const entry = this.index.get(sessionKey);
+        if (!entry)
+            return null;
+        const filePath = path.join(this.dataDir, entry.file);
+        if (!fs.existsSync(filePath))
+            return null;
+        const content = fs.readFileSync(filePath, "utf-8");
+        const entries = [];
+        for (const line of content.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                entries.push(JSON.parse(line));
+            }
+            catch {
+                // skip malformed lines
+            }
+        }
+        // Find the last compaction marker
+        let lastCompactionIdx = -1;
+        for (let i = entries.length - 1; i >= 0; i--) {
+            if (isCompaction(entries[i])) {
+                lastCompactionIdx = i;
+                break;
+            }
+        }
+        const messages = [];
+        if (lastCompactionIdx >= 0) {
+            // Compacted: summary message + all message entries after the marker
+            const marker = entries[lastCompactionIdx];
+            messages.push({
+                role: "user",
+                content: `[Prior conversation summary]\n${marker.summary}`,
+            });
+            for (let i = lastCompactionIdx + 1; i < entries.length; i++) {
+                const e = entries[i];
+                if (!isCompaction(e)) {
+                    messages.push(e.message);
+                }
+            }
+        }
+        else {
+            // No compaction: load all messages
+            for (const e of entries) {
+                if (!isCompaction(e)) {
+                    messages.push(e.message);
+                }
+            }
+        }
+        return new Session(sessionKey, messages);
+    }
+    /** List all session keys with metadata. */
+    list() {
+        return [...this.index.values()].sort((a, b) => b.updatedAt - a.updatedAt);
+    }
+    /** Rename a session (update its title in the index). */
+    rename(sessionKey, title) {
+        if (typeof title !== "string")
+            return false;
+        const entry = this.index.get(sessionKey);
+        if (!entry)
+            return false;
+        // Strip control characters and trim
+        const sanitized = title.replace(/[\x00-\x1F\x7F-\x9F]/g, "").trim();
+        if (sanitized.length === 0)
+            return false;
+        entry.title = sanitized.length > MAX_TITLE_LEN ? sanitized.slice(0, MAX_TITLE_LEN - 1) + "\u2026" : sanitized;
+        this.saveIndex();
+        return true;
+    }
+    /**
+     * Update session metadata (team name, agent info). Only writes to disk if something changed.
+     * Note: teamName and agentName are denormalized snapshots — they may become stale if
+     * the team or agent is renamed after the session was last active.
+     */
+    updateMetadata(sessionKey, meta) {
+        const entry = this.index.get(sessionKey);
+        if (!entry)
+            return;
+        const FIELDS = ["teamId", "teamName", "channelType", "agentId", "agentName"];
+        let changed = false;
+        for (const field of FIELDS) {
+            if (meta[field] !== undefined && entry[field] !== meta[field]) {
+                entry[field] = meta[field];
+                changed = true;
+            }
+        }
+        if (changed)
+            this.saveIndex();
+    }
+    /** Clear a session — deletes the JSONL file and removes the index entry. */
+    async clear(sessionKey) {
+        const entry = this.index.get(sessionKey);
+        if (!entry)
+            return;
+        const filePath = path.join(this.dataDir, entry.file);
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+        }
+        this.index.delete(sessionKey);
+        this.saveIndex();
+    }
+    // --- internal ---
+    getOrCreateEntry(key) {
+        let entry = this.index.get(key);
+        if (!entry) {
+            const safeKey = key.replace(/[^a-zA-Z0-9_-]/g, "_");
+            const parsed = parseSessionKey(key);
+            entry = {
+                key,
+                file: `${safeKey}.jsonl`,
+                messageCount: 0,
+                updatedAt: Date.now(),
+                teamId: parsed.teamId,
+                channelType: parsed.channelType,
+            };
+            this.index.set(key, entry);
+        }
+        return entry;
+    }
+    loadIndex() {
+        if (!fs.existsSync(this.indexPath)) {
+            return new Map();
+        }
+        try {
+            const raw = JSON.parse(fs.readFileSync(this.indexPath, "utf-8"));
+            return new Map(Object.entries(raw));
+        }
+        catch {
+            return new Map();
+        }
+    }
+    saveIndex() {
+        const obj = Object.fromEntries(this.index);
+        fs.writeFileSync(this.indexPath, JSON.stringify(obj, null, 2), "utf-8");
+    }
+}

package/dist/brain/session.d.ts

@@ -0,0 +1,32 @@
+import type { LanguageModel, ModelMessage } from "ai";
+export interface PendingCompaction {
+    summary: string;
+}
+export declare class Session {
+    readonly key: string;
+    private messages;
+    private persistedCount;
+    private _pendingCompaction;
+    private _needsFullRewrite;
+    constructor(key: string, messages?: ModelMessage[]);
+    append(msg: ModelMessage): void;
+    getMessages(): ModelMessage[];
+    /** Returns only messages not yet written to disk (normal append path). */
+    getNewMessages(): ModelMessage[];
+    /** After compaction: returns kept + new messages (everything except the summary at index 0). */
+    getCompactionMessages(): ModelMessage[];
+    /** Mark all current messages as persisted. */
+    markPersisted(): void;
+    /** Pending compaction info for the store to persist as a marker. */
+    get pendingCompaction(): PendingCompaction | null;
+    /** True when the file must be fully overwritten (emergency truncate). */
+    get needsFullRewrite(): boolean;
+    /** LLM-based compaction — summarizes old messages when tokens exceed context budget. */
+    compact(model: LanguageModel, contextWindow: number, systemPrompt: string): Promise<boolean>;
+    /** Replace the internal messages array (e.g. after programmatic compaction). Marks full rewrite. */
+    replaceMessages(messages: ModelMessage[]): void;
+    /** Emergency truncation — drop oldest messages, keeping last N. */
+    truncate(keep: number): void;
+    get messageCount(): number;
+    get updatedAt(): number;
+}

package/dist/brain/session.js

@@ -0,0 +1,75 @@
+import { compactMessages } from "./compaction.js";
+export class Session {
+    key;
+    messages = [];
+    persistedCount = 0; // how many messages are already on disk
+    _pendingCompaction = null;
+    _needsFullRewrite = false;
+    constructor(key, messages = []) {
+        this.key = key;
+        this.messages = messages;
+        this.persistedCount = messages.length;
+    }
+    append(msg) {
+        this.messages.push(msg);
+    }
+    getMessages() {
+        return [...this.messages];
+    }
+    /** Returns only messages not yet written to disk (normal append path). */
+    getNewMessages() {
+        return this.messages.slice(this.persistedCount);
+    }
+    /** After compaction: returns kept + new messages (everything except the summary at index 0). */
+    getCompactionMessages() {
+        return this.messages.slice(1);
+    }
+    /** Mark all current messages as persisted. */
+    markPersisted() {
+        this.persistedCount = this.messages.length;
+        this._pendingCompaction = null;
+        this._needsFullRewrite = false;
+    }
+    /** Pending compaction info for the store to persist as a marker. */
+    get pendingCompaction() {
+        return this._pendingCompaction;
+    }
+    /** True when the file must be fully overwritten (emergency truncate). */
+    get needsFullRewrite() {
+        return this._needsFullRewrite;
+    }
+    /** LLM-based compaction — summarizes old messages when tokens exceed context budget. */
+    async compact(model, contextWindow, systemPrompt) {
+        const result = await compactMessages(model, this.messages, contextWindow, systemPrompt);
+        if (result.compacted) {
+            this.messages = result.messages;
+            if (result.summary) {
+                // LLM summarization succeeded — persist as append-only compaction marker
+                this._pendingCompaction = { summary: result.summary };
+            }
+            else {
+                // Fallback truncation (no summary) — needs full file rewrite
+                this._needsFullRewrite = true;
+            }
+        }
+        return result.compacted;
+    }
+    /** Replace the internal messages array (e.g. after programmatic compaction). Marks full rewrite. */
+    replaceMessages(messages) {
+        this.messages = messages;
+        this._needsFullRewrite = true;
+    }
+    /** Emergency truncation — drop oldest messages, keeping last N. */
+    truncate(keep) {
+        if (this.messages.length > keep) {
+            this.messages = this.messages.slice(-keep);
+            this._needsFullRewrite = true;
+        }
+    }
+    get messageCount() {
+        return this.messages.length;
+    }
+    get updatedAt() {
+        return Date.now();
+    }
+}

package/dist/brain/task-subscriber.d.ts

@@ -0,0 +1,56 @@
+import type { ToolSet } from "ai";
+import type { Config } from "../config.js";
+import type { TaskStore } from "../tasks/store.js";
+import type { TeamStore } from "../teams/store.js";
+import type { MemoryStore } from "../memory/store.js";
+import type { EmbeddingProvider } from "../memory/embedding.js";
+import type { SkillManager } from "../skills/loader.js";
+import type { BrowserConfig } from "../computer/browser/manager.js";
+import { SessionStore } from "./session-store.js";
+export interface SubscriberDeps {
+    taskStore: TaskStore;
+    teamStore: TeamStore;
+    sessionStore: SessionStore;
+    memoryStore: MemoryStore | null;
+    embeddingProvider: EmbeddingProvider | null;
+    memoryMaxResults: number;
+    config: Config;
+    baseTools: ToolSet;
+    skillManager: SkillManager;
+    browserConfig: BrowserConfig | null;
+    sandboxEnabled: boolean;
+}
+/**
+ * Pull-based task execution: workers subscribe to task statuses
+ * and self-select tasks from the board. Runs a single poll timer
+ * and an efficient cross-table query per tick.
+ */
+export declare class TaskSubscriberManager {
+    private deps;
+    private timer;
+    /** agentId → Set<taskId> of currently running tasks */
+    private activeRuns;
+    private polling;
+    constructor(deps: SubscriberDeps);
+    start(): void;
+    stop(): void;
+    private poll;
+    /** Release claims that have been held longer than STALE_CLAIM_TIMEOUT_MS. */
+    private cleanupStaleClaims;
+    /** Emit `taskChange.updated` with the latest task snapshot if it still exists. */
+    private emitTaskUpdated;
+    /**
+     * Find a claimable task and atomically claim it via the store.
+     * Uses TeamStore.findClaimableTasks() for cross-table query,
+     * then TaskStore.claimTask() for atomic claim.
+     */
+    private findAndClaim;
+    /**
+     * Run full LLM loop for a claimed task.
+     * Follows same pattern as delegate.ts runWorker().
+     */
+    private runWorker;
+    /** Filter base tools by agent allowlist (empty = inherit all). */
+    private filterTools;
+    private filterToolSetByAllowlist;
+}