verybot 0.1.3

package/dist/tools/teams.js

@@ -0,0 +1,180 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { emit } from "../events.js";
+/**
+ * Creates AI-facing tools for team and worker management.
+ * Only available to the default team orchestrator.
+ */
+export function createTeamManagementTools(teamStore) {
+    const teamList = tool({
+        description: "List all teams and their agents (orchestrators + workers).",
+        inputSchema: z.object({}),
+        execute: async () => {
+            try {
+                const teams = teamStore.listTeams();
+                if (teams.length === 0)
+                    return "No teams found.";
+                const lines = teams.map((team) => {
+                    const agents = teamStore.listAgentsByTeam(team.id);
+                    const agentLines = agents
+                        .map((a) => `  - ${a.name} (${a.role}, model: ${a.model}, id: ${a.id})`)
+                        .join("\n");
+                    const colorStr = team.color ? `, color: ${team.color}` : "";
+                    return `**${team.name}** (id: ${team.id}${colorStr})\n${agentLines || "  (no agents)"}`;
+                });
+                return lines.join("\n\n");
+            }
+            catch (err) {
+                return `Failed to list teams: ${err instanceof Error ? err.message : err}`;
+            }
+        },
+    });
+    const teamCreate = tool({
+        description: "Create a new team. Configure its orchestrator via the UI, then add workers via worker_create.",
+        inputSchema: z.object({
+            name: z.string().describe("Team name (must be unique)"),
+            color: z.string().optional().describe("Optional hex color (e.g. #ef4444)"),
+        }),
+        execute: async ({ name, color }) => {
+            try {
+                const team = teamStore.createTeam({ name, color });
+                emit("teamChange", { action: "created", team });
+                return `Team created: "${team.name}" (id: ${team.id})`;
+            }
+            catch (err) {
+                return `Failed to create team: ${err instanceof Error ? err.message : err}`;
+            }
+        },
+    });
+    const teamUpdate = tool({
+        description: "Update an existing team's name or color.",
+        inputSchema: z.object({
+            id: z.string().describe("Team ID to update"),
+            name: z.string().optional().describe("New team name"),
+            color: z.string().optional().describe("New hex color (e.g. #ef4444)"),
+        }),
+        execute: async ({ id, name, color }) => {
+            try {
+                const team = teamStore.updateTeam(id, { name, color });
+                if (!team)
+                    return `Team not found: ${id}`;
+                emit("teamChange", { action: "updated", team });
+                return `Team updated: "${team.name}" (id: ${team.id})`;
+            }
+            catch (err) {
+                return `Failed to update team: ${err instanceof Error ? err.message : err}`;
+            }
+        },
+    });
+    const teamDelete = tool({
+        description: "Delete a team and all its agents. This cannot be undone.",
+        inputSchema: z.object({
+            id: z.string().describe("Team ID to delete"),
+        }),
+        execute: async ({ id }) => {
+            try {
+                const deleted = teamStore.deleteTeam(id);
+                if (!deleted)
+                    return `Team not found: ${id}`;
+                emit("teamChange", { action: "deleted", id });
+                return `Team deleted: ${id}`;
+            }
+            catch (err) {
+                return `Failed to delete team: ${err instanceof Error ? err.message : err}`;
+            }
+        },
+    });
+    const workerCreate = tool({
+        description: "Add a worker agent to a team. Workers can be delegated tasks by the orchestrator.",
+        inputSchema: z.object({
+            teamId: z.string().describe("Team ID to add the worker to"),
+            name: z.string().describe("Worker name (unique within the team)"),
+            model: z.string().describe("Model string (e.g. 'anthropic:claude-sonnet-4-20250514')"),
+            identity: z.string().optional().describe("System prompt / identity for the worker"),
+            tools: z.array(z.string()).optional().describe("List of tool names to enable"),
+            maxSteps: z.number().optional().describe("Max inference steps per run"),
+            timeout: z.number().optional().describe("Timeout in seconds for delegated tasks"),
+        }),
+        execute: async ({ teamId, name, model, identity, tools, maxSteps, timeout }) => {
+            try {
+                const agent = teamStore.createAgent(teamId, {
+                    name,
+                    role: "worker",
+                    model,
+                    identity,
+                    tools,
+                    maxSteps,
+                    timeout,
+                });
+                emit("teamChange", { action: "agentCreated", agent });
+                return `Worker created: "${agent.name}" (id: ${agent.id}) in team ${teamId}`;
+            }
+            catch (err) {
+                return `Failed to create worker: ${err instanceof Error ? err.message : err}`;
+            }
+        },
+    });
+    const workerUpdate = tool({
+        description: "Update a worker's configuration (name, model, identity, tools, etc.).",
+        inputSchema: z.object({
+            id: z.string().describe("Agent ID to update"),
+            name: z.string().optional().describe("New worker name"),
+            model: z.string().optional().describe("New model string"),
+            identity: z.string().optional().describe("New system prompt / identity"),
+            tools: z.array(z.string()).optional().describe("New list of tool names"),
+            maxSteps: z.number().optional().describe("New max inference steps"),
+            timeout: z.number().optional().describe("New timeout in seconds"),
+        }),
+        execute: async ({ id, name, model, identity, tools, maxSteps, timeout }) => {
+            try {
+                const existing = teamStore.getAgentById(id);
+                if (!existing)
+                    return `Agent not found: ${id}`;
+                if (existing.role === "orchestrator") {
+                    return "Cannot modify an orchestrator via worker_update. Use the UI to update orchestrators.";
+                }
+                const agent = teamStore.updateAgent(id, { name, model, identity, tools, maxSteps, timeout });
+                if (!agent)
+                    return `Agent not found: ${id}`;
+                emit("teamChange", { action: "agentUpdated", agent });
+                return `Worker updated: "${agent.name}" (id: ${agent.id})`;
+            }
+            catch (err) {
+                return `Failed to update worker: ${err instanceof Error ? err.message : err}`;
+            }
+        },
+    });
+    const workerDelete = tool({
+        description: "Remove a worker from a team. This cannot be undone.",
+        inputSchema: z.object({
+            id: z.string().describe("Agent ID to delete"),
+        }),
+        execute: async ({ id }) => {
+            try {
+                const existing = teamStore.getAgentById(id);
+                if (!existing)
+                    return `Agent not found: ${id}`;
+                if (existing.role === "orchestrator") {
+                    return "Cannot delete an orchestrator via worker_delete. Use the UI to manage orchestrators.";
+                }
+                const deleted = teamStore.deleteAgent(id);
+                if (!deleted)
+                    return `Agent not found: ${id}`;
+                emit("teamChange", { action: "agentDeleted", id });
+                return `Worker deleted: ${id}`;
+            }
+            catch (err) {
+                return `Failed to delete worker: ${err instanceof Error ? err.message : err}`;
+            }
+        },
+    });
+    return {
+        team_list: teamList,
+        team_create: teamCreate,
+        team_update: teamUpdate,
+        team_delete: teamDelete,
+        worker_create: workerCreate,
+        worker_update: workerUpdate,
+        worker_delete: workerDelete,
+    };
+}

package/dist/tools/web-fetch.d.ts

@@ -0,0 +1,3 @@
+export declare const webFetchTool: import("ai").Tool<{
+    url: string;
+}, string>;

package/dist/tools/web-fetch.js

@@ -0,0 +1,22 @@
+import { tool } from "ai";
+import { z } from "zod";
+// TODO: phase 5 — improve with HTML→markdown conversion
+export const webFetchTool = tool({
+    description: "Fetch a URL and return its text content",
+    inputSchema: z.object({
+        url: z.string().url().describe("The URL to fetch"),
+    }),
+    execute: async ({ url }) => {
+        try {
+            const res = await fetch(url, {
+                headers: { "User-Agent": "mini-agent/0.1" },
+                signal: AbortSignal.timeout(15_000),
+            });
+            const text = await res.text();
+            return text.slice(0, 20_000); // cap size
+        }
+        catch (err) {
+            return `Error fetching ${url}: ${err.message}`;
+        }
+    },
+});

package/dist/tts/edge.d.ts

@@ -0,0 +1,10 @@
+/** Detect dominant language from text content. */
+export declare function detectLanguage(text: string): string;
+/** Pick the right voice for the text language. */
+export declare function resolveVoice(text: string, explicitVoice?: string): string;
+/**
+ * Synthesize text to an mp3 file using Microsoft Edge TTS.
+ * Free, no API key required — uses the same neural voices as Edge browser.
+ * Returns the path to the generated mp3 file (caller must clean up).
+ */
+export declare function synthesize(text: string, voice?: string): Promise<string>;

package/dist/tts/edge.js

@@ -0,0 +1,60 @@
+import { EdgeTTS } from "node-edge-tts";
+import { join } from "path";
+import { tmpdir } from "os";
+import { randomBytes } from "crypto";
+import { logger } from "../logger.js";
+const OUTPUT_FORMAT = "audio-24khz-96kbitrate-mono-mp3";
+const MAX_TEXT_LENGTH = 2_000;
+const SYNTHESIS_TIMEOUT = 300_000;
+/** Default voices per detected language. */
+const VOICE_MAP = {
+    zh: "zh-CN-XiaoxiaoNeural",
+    ja: "ja-JP-NanamiNeural",
+    ko: "ko-KR-SunHiNeural",
+    en: "en-US-AriaNeural",
+};
+const FALLBACK_VOICE = "en-US-AriaNeural";
+// CJK Unicode ranges for language detection
+const CJK_RE = /[\u4e00-\u9fff\u3400-\u4dbf]/;
+const JAPANESE_RE = /[\u3040-\u309f\u30a0-\u30ff]/;
+const KOREAN_RE = /[\uac00-\ud7af\u1100-\u11ff]/;
+/** Detect dominant language from text content. */
+export function detectLanguage(text) {
+    // Sample first 200 chars for speed
+    const sample = text.slice(0, 200);
+    if (JAPANESE_RE.test(sample))
+        return "ja";
+    if (KOREAN_RE.test(sample))
+        return "ko";
+    if (CJK_RE.test(sample))
+        return "zh";
+    return "en";
+}
+/** Pick the right voice for the text language. */
+export function resolveVoice(text, explicitVoice) {
+    if (explicitVoice)
+        return explicitVoice;
+    const lang = detectLanguage(text);
+    return VOICE_MAP[lang] ?? FALLBACK_VOICE;
+}
+/**
+ * Synthesize text to an mp3 file using Microsoft Edge TTS.
+ * Free, no API key required — uses the same neural voices as Edge browser.
+ * Returns the path to the generated mp3 file (caller must clean up).
+ */
+export async function synthesize(text, voice) {
+    const trimmed = text.length > MAX_TEXT_LENGTH
+        ? text.slice(0, MAX_TEXT_LENGTH)
+        : text;
+    const resolvedVoice = resolveVoice(trimmed, voice);
+    const outPath = join(tmpdir(), `edge-tts-${randomBytes(6).toString("hex")}.mp3`);
+    const tts = new EdgeTTS({
+        voice: resolvedVoice,
+        lang: resolvedVoice.split("-").slice(0, 2).join("-"),
+        outputFormat: OUTPUT_FORMAT,
+        timeout: SYNTHESIS_TIMEOUT,
+    });
+    await tts.ttsPromise(trimmed, outPath);
+    logger.info(`TTS synthesized ${trimmed.length} chars with voice=${resolvedVoice}`);
+    return outPath;
+}

package/dist/tts/speak.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Start playing an mp3 file in the background (non-blocking).
+ * Returns immediately — use stopAudio/pauseAudio to control playback.
+ * Cleans up the temp file when playback ends.
+ */
+export declare function playAudio(filePath: string): void;
+/** Pause current playback (SIGSTOP). */
+export declare function pauseAudio(): string;
+/** Resume paused playback (SIGCONT). */
+export declare function resumeAudio(): string;
+/** Stop current playback immediately. */
+export declare function stopAudio(): string;

package/dist/tts/speak.js

@@ -0,0 +1,81 @@
+import { spawn } from "child_process";
+import { unlink } from "fs/promises";
+import { logger } from "../logger.js";
+const PLAYBACK_TIMEOUT = 300_000;
+let activeChild = null;
+let activeFile = null;
+let paused = false;
+/**
+ * Start playing an mp3 file in the background (non-blocking).
+ * Returns immediately — use stopAudio/pauseAudio to control playback.
+ * Cleans up the temp file when playback ends.
+ */
+export function playAudio(filePath) {
+    // Stop any existing playback first
+    stopAudio();
+    activeFile = filePath;
+    paused = false;
+    const cmd = process.platform === "darwin" ? "afplay" : "ffplay";
+    const args = process.platform === "darwin"
+        ? [filePath]
+        : ["-nodisp", "-autoexit", filePath];
+    const child = spawn(cmd, args, { stdio: "ignore" });
+    activeChild = child;
+    const timer = setTimeout(() => {
+        child.kill();
+        logger.warn("TTS playback timed out");
+    }, PLAYBACK_TIMEOUT);
+    const cleanup = () => {
+        clearTimeout(timer);
+        activeChild = null;
+        activeFile = null;
+        paused = false;
+        unlink(filePath).catch(() => { });
+    };
+    child.on("close", (code) => {
+        cleanup();
+        if (code === 0 || code === null) {
+            logger.info("TTS playback finished");
+        }
+        else {
+            logger.warn(`TTS player exited with code ${code}`);
+        }
+    });
+    child.on("error", (err) => {
+        cleanup();
+        logger.error(`TTS player error: ${err.message}`);
+    });
+}
+/** Pause current playback (SIGSTOP). */
+export function pauseAudio() {
+    if (!activeChild)
+        return "Nothing is playing.";
+    if (paused)
+        return "Already paused.";
+    activeChild.kill("SIGSTOP");
+    paused = true;
+    logger.info("TTS playback paused");
+    return "Playback paused.";
+}
+/** Resume paused playback (SIGCONT). */
+export function resumeAudio() {
+    if (!activeChild)
+        return "Nothing is playing.";
+    if (!paused)
+        return "Already playing.";
+    activeChild.kill("SIGCONT");
+    paused = false;
+    logger.info("TTS playback resumed");
+    return "Playback resumed.";
+}
+/** Stop current playback immediately. */
+export function stopAudio() {
+    if (!activeChild)
+        return "Nothing is playing.";
+    // Resume first if paused, then kill — avoids zombie stopped process
+    if (paused)
+        activeChild.kill("SIGCONT");
+    activeChild.kill();
+    logger.info("TTS playback stopped");
+    return "Playback stopped.";
+}

package/dist/tts/transcribe.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Transcribe an audio buffer to text using OpenAI's gpt-4o-mini-transcribe.
+ * Accepts ogg/opus (Telegram voice), mp3, wav, m4a, webm, etc.
+ */
+export declare function transcribe(audioBuffer: Buffer, filename?: string): Promise<string>;

package/dist/tts/transcribe.js

@@ -0,0 +1,40 @@
+import OpenAI from "openai";
+import { logger } from "../logger.js";
+const TRANSCRIBE_MODEL = "gpt-4o-mini-transcribe";
+let client = null;
+function getClient() {
+    if (!client) {
+        client = new OpenAI();
+    }
+    return client;
+}
+/**
+ * Transcribe an audio buffer to text using OpenAI's gpt-4o-mini-transcribe.
+ * Accepts ogg/opus (Telegram voice), mp3, wav, m4a, webm, etc.
+ */
+export async function transcribe(audioBuffer, filename = "voice.ogg") {
+    // Telegram sends .oga (Opus in Ogg) — normalize to .ogg which OpenAI accepts
+    const normalizedName = filename.replace(/\.oga$/, ".ogg");
+    const file = new File([new Uint8Array(audioBuffer)], normalizedName, {
+        type: mimeFromFilename(normalizedName),
+    });
+    const result = await getClient().audio.transcriptions.create({
+        model: TRANSCRIBE_MODEL,
+        file,
+    });
+    logger.info(`Transcribed ${audioBuffer.length} bytes → ${result.text.length} chars`);
+    return result.text;
+}
+function mimeFromFilename(name) {
+    if (name.endsWith(".ogg") || name.endsWith(".oga"))
+        return "audio/ogg";
+    if (name.endsWith(".mp3"))
+        return "audio/mpeg";
+    if (name.endsWith(".wav"))
+        return "audio/wav";
+    if (name.endsWith(".m4a"))
+        return "audio/mp4";
+    if (name.endsWith(".webm"))
+        return "audio/webm";
+    return "audio/ogg";
+}

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Split a long message into chunks that fit within a character limit.
+ * Splits on newline boundaries when possible, hard-splits otherwise.
+ */
+export declare function splitMessage(text: string, maxLength: number): string[];

package/dist/utils.js

@@ -0,0 +1,22 @@
+/**
+ * Split a long message into chunks that fit within a character limit.
+ * Splits on newline boundaries when possible, hard-splits otherwise.
+ */
+export function splitMessage(text, maxLength) {
+    if (text.length <= maxLength)
+        return [text];
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+        if (remaining.length <= maxLength) {
+            chunks.push(remaining);
+            break;
+        }
+        let splitAt = remaining.lastIndexOf("\n", maxLength);
+        if (splitAt <= 0)
+            splitAt = maxLength;
+        chunks.push(remaining.slice(0, splitAt));
+        remaining = remaining.slice(splitAt).replace(/^\n/, "");
+    }
+    return chunks;
+}

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "verybot",
+  "version": "0.1.3",
+  "description": "Multi-channel AI agent framework with Telegram, Discord, Slack, and WhatsApp support",
+  "type": "module",
+  "license": "MIT",
+  "author": "charlie",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/charlie0077/verybot"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "telegram",
+    "discord",
+    "slack",
+    "whatsapp",
+    "llm",
+    "chatbot",
+    "mcp"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "bin": {
+    "verybot": "./verybot.js"
+  },
+  "files": [
+    "dist/",
+    "verybot.js"
+  ],
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "rm -rf dist && tsc && find dist -name '*.test.js' -o -name '*.test.d.ts' | xargs rm -f && cd ui && vite build --outDir ../dist/control-ui",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "bun run build && bun run test",
+    "publish:patch": "npm version patch && npm publish --access public",
+    "publish:minor": "npm version minor && npm publish --access public",
+    "publish:major": "npm version major && npm publish --access public"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.38",
+    "@ai-sdk/deepseek": "^2.0.18",
+    "@ai-sdk/elevenlabs": "^2.0.18",
+    "@ai-sdk/google": "^3.0.22",
+    "@ai-sdk/groq": "^3.0.22",
+    "@ai-sdk/mistral": "^3.0.19",
+    "@ai-sdk/openai": "^3.0.26",
+    "@ai-sdk/openai-compatible": "^2.0.28",
+    "@ai-sdk/togetherai": "^2.0.31",
+    "@ai-sdk/xai": "^3.0.50",
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@slack/bolt": "^4.6.0",
+    "@whiskeysockets/baileys": "^7.0.0-rc.9",
+    "ai": "^6.0.75",
+    "ai-sdk-provider-claude-code": "^3.4.0",
+    "ai-sdk-provider-codex-cli": "^1.0.5",
+    "better-sqlite3": "^12.6.2",
+    "chokidar": "^5.0.0",
+    "croner": "^10.0.1",
+    "discord.js": "^14.25.1",
+    "grammy": "^1.39.3",
+    "markdown-it": "^14.1.1",
+    "node-edge-tts": "^1.2.10",
+    "node-llama-cpp": "^3.15.1",
+    "octokit": "^5.0.5",
+    "openai": "^6.18.0",
+    "playwright": "^1.58.2",
+    "qrcode": "^1.5.4",
+    "sharp": "^0.34.5",
+    "sqlite-vec": "^0.1.7-alpha.2",
+    "twitter-api-v2": "^1.29.0",
+    "winston": "^3.19.0",
+    "ws": "^8.19.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/markdown-it": "^14.1.2",
+    "@types/node": "^25.2.1",
+    "@types/qrcode": "^1.5.6",
+    "@types/ws": "^8.18.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
+}

package/verybot.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./dist/index.js";