verybot 0.1.8

package/README.md

@@ -0,0 +1,167 @@
+# VeryBot - Assistant for Your Work
+
+<p align="center">
+  <strong>One assistant for your work across chat, tasks, teams, playbooks, and channels.</strong>
+</p>
+
+<p align="center">
+  <a href="https://opensource.org/license/mit"><img src="https://img.shields.io/badge/License-MIT-blue.svg?style=for-the-badge" alt="MIT License"></a>
+  <a href="https://github.com/charlie0077/verybot"><img src="https://img.shields.io/github/stars/charlie0077/verybot?style=for-the-badge" alt="GitHub stars"></a>
+</p>
+
+VeryBot is a self-hosted AI assistant platform for real work.  
+It helps individuals, teams, and developers run work from one place: chat with your assistant, organize tasks, manage teams, save playbooks, automate recurring jobs, and connect external channels like Telegram, Discord, Slack, and WhatsApp.
+
+[Quick Start (User)](#quick-start-user) · [Quick Start (Developer)](#quick-start-developer) · [Let LLM Set Up Your Flow Example](#let-llm-set-up-your-flow-example) · [Playbooks](#playbooks) · [Docs](#docs)
+
+## Why VeryBot
+
+- Reduce context-switching: one assistant across chat, tasks, teams, and channels.
+- Turn talk into execution: convert conversations into structured tasks you can track and ship.
+- Move faster with less micromanagement: set goals once and let the assistant create/follow up on work.
+- Replace repetitive reminders with scheduled automation.
+- Stay in control anywhere: use the same Control UI from desktop or mobile when reachable.
+- Reuse what works: save proven workflows as playbooks and run them again.
+- Keep your data ownership: self-host with local-first runtime data under `~/.verybot`.
+- Extend only when needed: add tools, skills, and MCP integrations without changing core workflow.
+
+## Who It Is For
+
+- Solo operators: personal work copilot with task and reminder automation.
+- Small teams: shared team context, team-specific workflows, and worker agents.
+- Developers: self-hosted runtime with tools, APIs, and extensibility.
+
+## Quick Start (User)
+
+Requirements:
+
+- Node.js `>=22`
+- npm
+
+Install and run (npm, fastest):
+
+```bash
+npm install -g verybot
+verybot
+```
+
+Upgrade later:
+
+```bash
+npm install -g verybot@latest
+```
+
+Open the Control UI:
+
+- `http://localhost:28789`
+
+If the UI asks for a gateway token, you can:
+
+- Copy it from the terminal output where you started `verybot` (`GATEWAY_TOKEN: ...`)
+- Or run:
+
+```bash
+verybot config get GATEWAY_TOKEN
+```
+
+First setup in **Settings -> Agent**:
+
+1. Choose a model provider.
+2. If you picked an API-key provider, add your API key.
+3. If you use Codex CLI or Claude CLI and it already works on this machine, no API key setup is needed.
+4. Save and send a chat prompt like: `Set up a team and starter tasks for launch planning.`
+
+Need to access it from LAN or internet?
+
+### LAN access
+
+From installed CLI runtime (bind gateway/UI on all interfaces):
+
+```bash
+verybot --host 0.0.0.0 --port 28789
+```
+
+Then open:
+
+- `http://<your-lan-ip>:28789`
+
+### Internet access (recommended setup)
+
+1. Run VeryBot on the server:
+
+```bash
+verybot --host 127.0.0.1 --port 28789
+```
+
+2. Put a reverse proxy with TLS in front (example: Caddy):
+
+```caddy
+verybot.example.com {
+  reverse_proxy 127.0.0.1:28789
+}
+```
+
+3. Point your domain DNS to that server and open only ports `80/443` in firewall/security groups.
+4. Keep `GATEWAY_TOKEN` private and rotate it if leaked.
+
+## Quick Start (Developer)
+
+Clone and run from source:
+
+```bash
+git clone https://github.com/charlie0077/verybot.git
+cd verybot
+npm install
+npm run dev
+```
+
+Useful commands:
+
+| Command | Purpose |
+| --- | --- |
+| `npm run dev` | Backend + UI dev servers |
+| `npm run dev:backend` | Backend only (`tsx watch`) |
+| `npm run dev:lan` | Expose UI on LAN (`0.0.0.0:10000`) |
+| `npm run build` | Build backend + UI to `dist/` |
+| `npm start` | Run production build |
+| `npm test` | Run test suite |
+
+## Let LLM Set Up Your Flow Example
+
+In **Chat**, you can ask the LLM to set up your workflow instead of doing everything manually.
+
+Example prompts:
+
+- `Create a team called Growth Ops for launch planning.`
+- `For Growth Ops, set up task statuses: backlog, todo, in_progress, blocked, done.`
+- `Create tasks for launch planning and place them in backlog.`
+- `Set up a recurring Monday reminder to review launch risks.`
+- `Create a playbook called Launch Checklist with clear handoff steps.`
+
+Then review and refine in **Teams**, **Tasks**, **Scheduler**, and **Playbooks**.
+
+## Playbooks
+
+Use **Playbooks** to store reusable workflows (SOPs, checklists, scripts) your assistant can follow.
+
+Common playbooks:
+
+- New customer onboarding
+- Weekly team planning
+- Incident triage
+- Release readiness checklist
+
+## Channels (Optional)
+
+Connect external channels in **Settings** -> **Channels**.
+
+| Channel | Required keys |
+| --- | --- |
+| Telegram | `TELEGRAM_BOT_TOKEN` |
+| Discord | `DISCORD_BOT_TOKEN` |
+| Slack | `SLACK_BOT_TOKEN`, `SLACK_APP_TOKEN` |
+| WhatsApp | `WHATSAPP_PHONE_ID` |
+
+## License
+
+MIT

package/dist/aliases/store.d.ts

@@ -0,0 +1,21 @@
+import type { CommandAlias } from "./types.js";
+/** Max allowed alias length (including leading "/"). */
+export declare const MAX_ALIAS_LENGTH = 64;
+/** Max allowed alias expansion length. */
+export declare const MAX_ALIAS_EXPANSION_LENGTH = 2000;
+/** Global file-backed command alias storage. */
+export declare class CommandAliasStore {
+    private readonly filePath;
+    private aliases;
+    private lastMtime;
+    private constructor();
+    static create(filePath: string): Promise<CommandAliasStore>;
+    list(): CommandAlias[];
+    upsert(rawAlias: string, rawExpansion: string): CommandAlias;
+    delete(rawAlias: string): boolean;
+    close(): void;
+    private loadFromFile;
+    private saveToFile;
+    private fileMtime;
+    private reloadIfChanged;
+}

package/dist/aliases/store.js

@@ -0,0 +1,148 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "fs";
+import { randomUUID } from "crypto";
+import { dirname, join } from "path";
+import { logger } from "../logger.js";
+/** Max allowed alias length (including leading "/"). */
+export const MAX_ALIAS_LENGTH = 64;
+/** Max allowed alias expansion length. */
+export const MAX_ALIAS_EXPANSION_LENGTH = 2_000;
+/** Slash command alias format: "/name" without whitespace. */
+const ALIAS_RE = /^\/\S+$/;
+function normalizeAlias(rawAlias) {
+    const trimmed = rawAlias.trim().toLowerCase();
+    if (!trimmed)
+        return "";
+    return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+function validateAlias(rawAlias) {
+    const alias = normalizeAlias(rawAlias);
+    if (!alias)
+        throw new Error("alias is required");
+    if (alias.length > MAX_ALIAS_LENGTH) {
+        throw new Error(`alias exceeds maximum length of ${MAX_ALIAS_LENGTH}`);
+    }
+    if (!ALIAS_RE.test(alias)) {
+        throw new Error("alias must be a single token with no spaces");
+    }
+    return alias;
+}
+function validateExpansion(expansion) {
+    const trimmed = expansion.trim();
+    if (!trimmed)
+        throw new Error("expansion is required");
+    if (trimmed.length > MAX_ALIAS_EXPANSION_LENGTH) {
+        throw new Error(`expansion exceeds maximum length of ${MAX_ALIAS_EXPANSION_LENGTH}`);
+    }
+    return trimmed;
+}
+function sortByAlias(a, b) {
+    return a.alias.localeCompare(b.alias);
+}
+/** Global file-backed command alias storage. */
+export class CommandAliasStore {
+    filePath;
+    aliases = new Map();
+    lastMtime = null;
+    constructor(filePath) {
+        this.filePath = filePath;
+        this.aliases = this.loadFromFile();
+        this.lastMtime = this.fileMtime();
+    }
+    static async create(filePath) {
+        mkdirSync(dirname(filePath), { recursive: true });
+        return new CommandAliasStore(filePath);
+    }
+    list() {
+        this.reloadIfChanged();
+        return [...this.aliases.values()]
+            .sort(sortByAlias)
+            .map((row) => ({ ...row }));
+    }
+    upsert(rawAlias, rawExpansion) {
+        this.reloadIfChanged();
+        const alias = validateAlias(rawAlias);
+        const expansion = validateExpansion(rawExpansion);
+        const existing = this.aliases.get(alias);
+        const now = Date.now();
+        const nextAlias = {
+            alias,
+            expansion,
+            createdAt: existing?.createdAt ?? now,
+            updatedAt: now,
+        };
+        this.aliases.set(alias, nextAlias);
+        this.saveToFile();
+        return { ...nextAlias };
+    }
+    delete(rawAlias) {
+        this.reloadIfChanged();
+        const alias = validateAlias(rawAlias);
+        const existed = this.aliases.delete(alias);
+        if (existed)
+            this.saveToFile();
+        return existed;
+    }
+    close() {
+        // no-op: file-backed store
+        logger.info("Command alias store closed");
+    }
+    loadFromFile() {
+        if (!existsSync(this.filePath))
+            return new Map();
+        try {
+            const raw = readFileSync(this.filePath, "utf-8");
+            const parsed = JSON.parse(raw);
+            const rows = Array.isArray(parsed.aliases) ? parsed.aliases : [];
+            const map = new Map();
+            for (const row of rows) {
+                if (!row || typeof row !== "object")
+                    continue;
+                if (typeof row.alias !== "string" || typeof row.expansion !== "string")
+                    continue;
+                try {
+                    const alias = validateAlias(row.alias);
+                    const expansion = validateExpansion(row.expansion);
+                    const createdAt = Number.isFinite(row.createdAt) ? Number(row.createdAt) : Date.now();
+                    const updatedAt = Number.isFinite(row.updatedAt) ? Number(row.updatedAt) : createdAt;
+                    map.set(alias, { alias, expansion, createdAt, updatedAt });
+                }
+                catch {
+                    // Skip malformed alias rows.
+                }
+            }
+            return map;
+        }
+        catch (err) {
+            logger.warn(`Failed to read command alias file: ${err instanceof Error ? err.message : err}`);
+            return new Map();
+        }
+    }
+    saveToFile() {
+        const payload = {
+            aliases: [...this.aliases.values()]
+                .sort(sortByAlias)
+                .map((row) => ({ ...row })),
+        };
+        const dir = dirname(this.filePath);
+        mkdirSync(dir, { recursive: true });
+        const tmpPath = join(dir, `.command-aliases.${randomUUID()}.tmp`);
+        writeFileSync(tmpPath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
+        renameSync(tmpPath, this.filePath);
+        this.lastMtime = this.fileMtime();
+    }
+    fileMtime() {
+        try {
+            return statSync(this.filePath).mtimeMs;
+        }
+        catch {
+            return null;
+        }
+    }
+    reloadIfChanged() {
+        const mtime = this.fileMtime();
+        if (mtime === this.lastMtime)
+            return;
+        this.aliases = this.loadFromFile();
+        this.lastMtime = mtime;
+    }
+}

package/dist/aliases/types.d.ts

@@ -0,0 +1,6 @@
+export interface CommandAlias {
+    alias: string;
+    expansion: string;
+    createdAt: number;
+    updatedAt: number;
+}

package/dist/aliases/types.js

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

package/dist/brain/agent-registry.d.ts

@@ -0,0 +1,96 @@
+import type { LanguageModel, ToolSet } from "ai";
+import type { AgentConfig, TeamConfig, TaskStatusConfig } from "../config/agent-config.js";
+import type { Config } from "../config.js";
+import type { MemoryStore } from "../memory/store.js";
+import type { EmbeddingProvider } from "../memory/embedding.js";
+import type { ModelDef } from "../config/model-catalog.js";
+import type { CodexReasoningEffort } from "../config/model-spec.js";
+export interface WorkerDeps {
+    memoryStore: MemoryStore | null;
+    embeddingProvider: EmbeddingProvider | null;
+    baseTools: ToolSet;
+    config: Config;
+}
+export interface ResolvedAgent {
+    agentConfig: AgentConfig;
+    model: LanguageModel;
+    modelDef: ModelDef;
+    tools: ToolSet;
+}
+export interface ResolvedAgentById {
+    role: "orchestrator" | "worker";
+    resolved: ResolvedAgent;
+}
+/**
+ * Holds agent configs for a single team.
+ * The first config is the orchestrator, rest are workers.
+ * `canDelegate` is auto-derived from team membership.
+ */
+export declare class AgentRegistry {
+    private deps;
+    private orchestratorConfig;
+    /** Workers keyed by name (human-readable, unique within team). */
+    private workersByName;
+    private workerNames;
+    constructor(orchestrator: AgentConfig, workers: AgentConfig[], deps: WorkerDeps);
+    getOrchestrator(): AgentConfig;
+    /** Resolve the orchestrator into a model + def, ready for per-session override. */
+    resolveOrchestrator(): ResolvedAgent;
+    getWorker(name: string): AgentConfig | undefined;
+    /** Return the list of worker names that the orchestrator can delegate to. */
+    delegatableWorkers(): string[];
+    /** Build an id→name map for all agents (orchestrator + workers). */
+    buildIdToNameMap(): Map<string, string>;
+    /** Resolve a worker by name into a model + filtered tool set, ready for runLoop(). */
+    resolveWorker(name: string): ResolvedAgent | null;
+    /** Resolve any team agent by stable ID (orchestrator or worker). */
+    resolveAgentById(agentId: string): ResolvedAgentById | null;
+    private resolveConfig;
+}
+export interface TeamAgentInfo {
+    id: string;
+    name: string;
+    subscriptions: string[];
+    concurrency: number;
+}
+/** Info returned by TeamRegistry.listTeams() for UI display. */
+export interface TeamInfo {
+    id: string;
+    name: string;
+    color: string;
+    orchestratorId: string;
+    orchestratorIdentity: string;
+    orchestratorModel: string;
+    workerCount: number;
+    /** Worker agents with subscription info for the task board UI. */
+    workers?: TeamAgentInfo[];
+    /** Custom task statuses (undefined = defaults). */
+    statuses?: TaskStatusConfig[];
+}
+/**
+ * Wraps per-team AgentRegistry instances.
+ * Provides team resolution and isolation boundaries.
+ */
+export declare class TeamRegistry {
+    private teams;
+    constructor(teams: TeamConfig[], deps: WorkerDeps);
+    /** Find which team owns an orchestrator ID. */
+    resolveTeam(orchestratorId: string): {
+        teamId: string;
+        registry: AgentRegistry;
+    } | null;
+    /** Get registry for a specific team by teamId. */
+    getTeamRegistry(teamId: string): AgentRegistry | null;
+    /** Get raw team config for a specific team by teamId. */
+    getTeamConfig(teamId: string): TeamConfig | null;
+    /** All teams for UI picker. */
+    listTeams(): TeamInfo[];
+    /** True if any team has workers. */
+    hasWorkers(): boolean;
+}
+/** Parse "provider:modelId" string. */
+export declare function parseModel(raw: string): {
+    provider: string;
+    modelId: string;
+    codexReasoningEffort?: CodexReasoningEffort;
+};

package/dist/brain/agent-registry.js

@@ -0,0 +1,141 @@
+import { parseModelSpec } from "../config/model-spec.js";
+import { getModel } from "./providers.js";
+import { resolveModelDef } from "../config/model-catalog.js";
+/**
+ * Holds agent configs for a single team.
+ * The first config is the orchestrator, rest are workers.
+ * `canDelegate` is auto-derived from team membership.
+ */
+export class AgentRegistry {
+    deps;
+    orchestratorConfig;
+    /** Workers keyed by name (human-readable, unique within team). */
+    workersByName;
+    workerNames;
+    constructor(orchestrator, workers, deps) {
+        this.deps = deps;
+        this.orchestratorConfig = orchestrator;
+        this.workersByName = new Map(workers.map((w) => [w.name, w]));
+        this.workerNames = workers.map((w) => w.name);
+    }
+    getOrchestrator() {
+        return this.orchestratorConfig;
+    }
+    /** Resolve the orchestrator into a model + def, ready for per-session override. */
+    resolveOrchestrator() {
+        return this.resolveConfig(this.orchestratorConfig);
+    }
+    getWorker(name) {
+        return this.workersByName.get(name);
+    }
+    /** Return the list of worker names that the orchestrator can delegate to. */
+    delegatableWorkers() {
+        return this.workerNames;
+    }
+    /** Build an id→name map for all agents (orchestrator + workers). */
+    buildIdToNameMap() {
+        const map = new Map();
+        map.set(this.orchestratorConfig.id, this.orchestratorConfig.name);
+        for (const w of this.workersByName.values()) {
+            map.set(w.id, w.name);
+        }
+        return map;
+    }
+    /** Resolve a worker by name into a model + filtered tool set, ready for runLoop(). */
+    resolveWorker(name) {
+        const cfg = this.workersByName.get(name);
+        return cfg ? this.resolveConfig(cfg) : null;
+    }
+    /** Resolve any team agent by stable ID (orchestrator or worker). */
+    resolveAgentById(agentId) {
+        if (this.orchestratorConfig.id === agentId) {
+            return { role: "orchestrator", resolved: this.resolveOrchestrator() };
+        }
+        for (const worker of this.workersByName.values()) {
+            if (worker.id === agentId) {
+                return { role: "worker", resolved: this.resolveConfig(worker) };
+            }
+        }
+        return null;
+    }
+    resolveConfig(cfg) {
+        const { provider, modelId, codexReasoningEffort } = parseModel(cfg.model);
+        const model = getModel(provider, modelId, { codexReasoningEffort });
+        const modelDef = resolveModelDef(modelId, cfg.contextWindow);
+        const tools = filterTools(this.deps.baseTools, cfg.tools);
+        return { agentConfig: cfg, model, modelDef, tools };
+    }
+}
+/**
+ * Wraps per-team AgentRegistry instances.
+ * Provides team resolution and isolation boundaries.
+ */
+export class TeamRegistry {
+    teams;
+    constructor(teams, deps) {
+        this.teams = new Map(teams.map((t) => [
+            t.id,
+            {
+                config: t,
+                registry: new AgentRegistry(t.orchestrator, t.workers, deps),
+            },
+        ]));
+    }
+    /** Find which team owns an orchestrator ID. */
+    resolveTeam(orchestratorId) {
+        for (const [teamId, { config, registry }] of this.teams) {
+            if (config.orchestrator.id === orchestratorId) {
+                return { teamId, registry };
+            }
+        }
+        return null;
+    }
+    /** Get registry for a specific team by teamId. */
+    getTeamRegistry(teamId) {
+        return this.teams.get(teamId)?.registry ?? null;
+    }
+    /** Get raw team config for a specific team by teamId. */
+    getTeamConfig(teamId) {
+        return this.teams.get(teamId)?.config ?? null;
+    }
+    /** All teams for UI picker. */
+    listTeams() {
+        return [...this.teams.values()].map(({ config }) => ({
+            id: config.id,
+            name: config.name ?? config.id,
+            color: config.color ?? "",
+            orchestratorId: config.orchestrator.id,
+            orchestratorIdentity: config.orchestrator.identity,
+            orchestratorModel: parseModel(config.orchestrator.model).modelId,
+            workerCount: config.workers.length,
+        }));
+    }
+    /** True if any team has workers. */
+    hasWorkers() {
+        for (const { config } of this.teams.values()) {
+            if (config.workers.length > 0)
+                return true;
+        }
+        return false;
+    }
+}
+/** Parse "provider:modelId" string. */
+export function parseModel(raw) {
+    const parsed = parseModelSpec(raw);
+    return {
+        provider: parsed.provider,
+        modelId: parsed.modelId,
+        codexReasoningEffort: parsed.codexReasoningEffort,
+    };
+}
+/** Return only the tools whose names are in the allowlist, or all if allowlist is empty. */
+function filterTools(base, allowlist) {
+    if (allowlist.length === 0)
+        return { ...base };
+    const filtered = {};
+    for (const name of allowlist) {
+        if (name in base)
+            filtered[name] = base[name];
+    }
+    return filtered;
+}