verybot 0.1.3

package/dist/gateway/methods/scheduler.js

@@ -0,0 +1,129 @@
+import { broadcast, onClientClose } from "../broadcast.js";
+const VALID_STATUSES = new Set(["active", "paused", "completed", "failed"]);
+/** Validate that `teamId` belongs to a real team. */
+function validateTeamId(agent, teamId) {
+    if (!teamId)
+        throw new Error("Missing teamId");
+    const teams = agent.getTeams();
+    if (!teams.some((t) => t.id === teamId)) {
+        throw new Error(`Unknown team: "${teamId}"`);
+    }
+}
+export function schedulerMethods(getAgent, getScheduleStore, getConnectedChannels, ctx) {
+    return {
+        /** Connect a WS client to a team's scheduler. Returns session history + connection key. */
+        "scheduler.connect": async (params) => {
+            const { teamId } = params;
+            validateTeamId(getAgent(), teamId);
+            const connectedChannels = getConnectedChannels();
+            // Register this WS as a connected channel — send fn broadcasts via WS events
+            const connectionKey = connectedChannels.connect(teamId, {
+                channelType: "gateway",
+                channelId: `ws:${teamId}`,
+                send: async (text) => {
+                    broadcast("schedulerMessage", { teamId, role: "assistant", content: text });
+                },
+            });
+            // Auto-disconnect when the WS closes (prevents stale entries)
+            if (ctx?.ws) {
+                onClientClose(ctx.ws, () => {
+                    connectedChannels.disconnect(teamId, connectionKey);
+                });
+            }
+            // Return existing session history
+            const session = getAgent().getSchedulerSession(teamId);
+            const messages = session?.getMessages() ?? [];
+            return { connectionKey, messages };
+        },
+        /** Disconnect a WS client from a team's scheduler. */
+        "scheduler.disconnect": async (params) => {
+            const { teamId, connectionKey } = params;
+            if (!teamId || !connectionKey)
+                throw new Error("Missing teamId or connectionKey");
+            getConnectedChannels().disconnect(teamId, connectionKey);
+            return { status: "ok" };
+        },
+        /** Send a message to the team's scheduler session. */
+        "scheduler.send": async (params) => {
+            const { teamId, message } = params;
+            if (!message)
+                throw new Error("Missing message");
+            validateTeamId(getAgent(), teamId);
+            // Broadcast user message to OTHER clients (sender already has it via optimistic UI)
+            const excludeWs = ctx?.ws;
+            broadcast("schedulerMessage", { teamId, role: "user", content: message, senderInfo: "Web UI" }, excludeWs);
+            const reply = await getAgent().handleSchedulerMessage(teamId, message, "Web UI");
+            // Broadcast reply to OTHER clients (sender gets it via RPC response)
+            broadcast("schedulerMessage", { teamId, role: "assistant", content: reply }, excludeWs);
+            return { status: "ok", reply };
+        },
+        /** Get scheduler session history for a team. */
+        "scheduler.history": async (params) => {
+            const { teamId } = params;
+            validateTeamId(getAgent(), teamId);
+            const session = getAgent().getSchedulerSession(teamId);
+            return { messages: session?.getMessages() ?? [] };
+        },
+        /** List schedules for a team. */
+        "scheduler.list": async (params) => {
+            const { teamId, status } = params;
+            validateTeamId(getAgent(), teamId);
+            if (status && !VALID_STATUSES.has(status)) {
+                throw new Error(`Invalid status: "${status}". Must be one of: active, paused, completed, failed`);
+            }
+            const store = getScheduleStore();
+            const schedules = store.listByTeam(teamId, status);
+            return { schedules };
+        },
+        // --- Direct schedule CRUD (bypasses LLM) ---
+        /** Pause an active schedule. */
+        "scheduler.pause": async (params) => {
+            const { teamId, scheduleId } = params;
+            if (!scheduleId)
+                throw new Error("Missing scheduleId");
+            validateTeamId(getAgent(), teamId);
+            const store = getScheduleStore();
+            const schedule = store.getById(scheduleId);
+            if (!schedule || schedule.teamId !== teamId) {
+                throw new Error(`Schedule "${scheduleId}" not found for this team`);
+            }
+            if (schedule.status !== "active") {
+                throw new Error(`Schedule is not active (status: ${schedule.status})`);
+            }
+            store.update(scheduleId, { status: "paused" });
+            return { status: "ok" };
+        },
+        /** Resume a paused schedule. */
+        "scheduler.resume": async (params) => {
+            const { teamId, scheduleId } = params;
+            if (!scheduleId)
+                throw new Error("Missing scheduleId");
+            validateTeamId(getAgent(), teamId);
+            const store = getScheduleStore();
+            const schedule = store.getById(scheduleId);
+            if (!schedule || schedule.teamId !== teamId) {
+                throw new Error(`Schedule "${scheduleId}" not found for this team`);
+            }
+            if (schedule.status !== "paused") {
+                throw new Error(`Schedule is not paused (status: ${schedule.status})`);
+            }
+            const nextRun = store.computeNextRun(schedule);
+            store.update(scheduleId, { status: "active", nextRun });
+            return { status: "ok" };
+        },
+        /** Delete a schedule. */
+        "scheduler.delete": async (params) => {
+            const { teamId, scheduleId } = params;
+            if (!scheduleId)
+                throw new Error("Missing scheduleId");
+            validateTeamId(getAgent(), teamId);
+            const store = getScheduleStore();
+            const schedule = store.getById(scheduleId);
+            if (!schedule || schedule.teamId !== teamId) {
+                throw new Error(`Schedule "${scheduleId}" not found for this team`);
+            }
+            store.delete(scheduleId);
+            return { status: "ok" };
+        },
+    };
+}

package/dist/gateway/methods/sessions.d.ts

@@ -0,0 +1,26 @@
+import type { Agent } from "../../brain/agent.js";
+export declare function sessionMethods(getAgent: () => Agent): {
+    "sessions.list": () => Promise<{
+        sessions: import("../../brain/session-store.js").SessionIndexEntry[];
+        ts: number;
+    }>;
+    "sessions.get": (params: {
+        sessionKey: string;
+    }) => Promise<{
+        messages: {
+            role: "system" | "user" | "assistant" | "tool";
+            content: string;
+        }[];
+    }>;
+    "sessions.rename": (params: {
+        sessionKey: string;
+        title: string;
+    }) => Promise<{
+        status: string;
+    }>;
+    "sessions.clear": (params: {
+        sessionKey: string;
+    }) => Promise<{
+        status: string;
+    }>;
+};

package/dist/gateway/methods/sessions.js

@@ -0,0 +1,54 @@
+import { logger } from "../../logger.js";
+export function sessionMethods(getAgent) {
+    return {
+        "sessions.list": async () => {
+            const agent = getAgent();
+            const sessions = agent.getStore().list();
+            // Enrich sessions with team name + color from the team store
+            const teams = agent.getTeams();
+            const teamById = new Map(teams.map((t) => [t.id, t]));
+            const enriched = sessions.map((s) => {
+                const team = s.teamId ? teamById.get(s.teamId) : undefined;
+                if (!team)
+                    return s;
+                return {
+                    ...s,
+                    ...(team.name && { teamName: team.name }),
+                    ...(team.color && { teamColor: team.color }),
+                };
+            });
+            return { sessions: enriched, ts: Date.now() };
+        },
+        "sessions.get": async (params) => {
+            if (!params?.sessionKey || typeof params.sessionKey !== "string") {
+                throw new Error("sessionKey is required and must be a string");
+            }
+            const session = await getAgent().getStore().load(params.sessionKey);
+            if (!session)
+                return { messages: [] };
+            const messages = session.getMessages().map((m) => ({
+                role: m.role,
+                content: typeof m.content === "string" ? m.content : JSON.stringify(m.content),
+            }));
+            return { messages };
+        },
+        "sessions.rename": async (params) => {
+            if (!params?.sessionKey || typeof params.sessionKey !== "string") {
+                throw new Error("sessionKey is required and must be a string");
+            }
+            if (!params?.title || typeof params.title !== "string") {
+                throw new Error("title is required and must be a string");
+            }
+            const ok = getAgent().getStore().rename(params.sessionKey, params.title);
+            if (!ok)
+                return { status: "not_found" };
+            logger.info(`[${params.sessionKey}] Session renamed to: ${params.title}`);
+            return { status: "ok" };
+        },
+        "sessions.clear": async (params) => {
+            logger.info(`[${params.sessionKey}] Session clear requested`);
+            await getAgent().clearSession(params.sessionKey);
+            return { status: "ok" };
+        },
+    };
+}

package/dist/gateway/methods/skills.d.ts

@@ -0,0 +1,35 @@
+import type { SkillManager } from "../../skills/loader.js";
+export declare function skillMethods(getSkillManager: () => SkillManager): {
+    /** List all skills (without content). */
+    "skills.list": () => Promise<{
+        skills: {
+            name: string;
+            description: string;
+            icon: string | undefined;
+            tools: string[];
+        }[];
+    }>;
+    /** Get a single skill by name (includes content). */
+    "skills.get": (params: unknown) => Promise<{
+        skill: {
+            name: string;
+            description: string;
+            icon: string | undefined;
+            tools: string[];
+            content: string;
+        };
+    }>;
+    /** Create or update a skill on disk. Supports rename via `originalName`. */
+    "skills.save": (params: unknown) => Promise<{
+        status: string;
+    }>;
+    /** Delete a skill directory from disk. */
+    "skills.delete": (params: unknown) => Promise<{
+        status: string;
+    }>;
+    /** Import skills from ~/.claude/ (plugins cache + user skills). */
+    "skills.importClaude": () => Promise<{
+        imported: string[];
+        skipped: string[];
+    }>;
+};

package/dist/gateway/methods/skills.js

@@ -0,0 +1,202 @@
+import { mkdir, writeFile, rm, readdir, stat, cp } from "fs/promises";
+import { basename, resolve, join } from "path";
+import { homedir } from "os";
+import { SKILLS_DIR } from "../../paths.js";
+import { emit } from "../../events.js";
+import { logger } from "../../logger.js";
+/* ------------------------------------------------------------------ */
+/*  Validation helpers                                                 */
+/* ------------------------------------------------------------------ */
+/** Alphanumeric, hyphens, underscores, max 64 chars. */
+const VALID_SKILL_NAME = /^[a-zA-Z0-9][a-zA-Z0-9 _-]{0,63}$/;
+/** Resolve a safe skill directory path, rejecting traversal attempts. */
+function safeSkillDir(name) {
+    const sanitized = basename(name.trim());
+    if (!sanitized || sanitized === "." || sanitized === "..") {
+        throw new Error("Invalid skill name");
+    }
+    if (!VALID_SKILL_NAME.test(sanitized)) {
+        throw new Error("Skill name must be alphanumeric (hyphens/underscores allowed, max 64 chars)");
+    }
+    const target = resolve(SKILLS_DIR, sanitized);
+    const parent = resolve(SKILLS_DIR);
+    if (!target.startsWith(`${parent}/`)) {
+        throw new Error("Invalid skill name");
+    }
+    return target;
+}
+/** Escape a string for safe YAML value output. */
+function yamlEscape(val) {
+    if (/[:\n\r#"'\[\]{}|>&*!%@`]/.test(val) || val.trim() !== val) {
+        return `"${val.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`;
+    }
+    return val;
+}
+/** Build YAML frontmatter string from skill metadata. */
+function buildFrontmatter(p) {
+    const lines = ["---"];
+    lines.push(`name: ${yamlEscape(p.name)}`);
+    lines.push(`description: ${yamlEscape(p.description)}`);
+    if (p.icon)
+        lines.push(`icon: ${yamlEscape(p.icon)}`);
+    if (p.tools.length > 0)
+        lines.push(`tools: [${p.tools.map(yamlEscape).join(", ")}]`);
+    lines.push("---");
+    return lines.join("\n");
+}
+/* ------------------------------------------------------------------ */
+/*  RPC methods                                                        */
+/* ------------------------------------------------------------------ */
+export function skillMethods(getSkillManager) {
+    return {
+        /** List all skills (without content). */
+        "skills.list": async () => {
+            const entries = getSkillManager().entries;
+            return {
+                skills: entries.map((e) => ({
+                    name: e.name,
+                    description: e.description,
+                    icon: e.icon,
+                    tools: e.tools,
+                })),
+            };
+        },
+        /** Get a single skill by name (includes content). */
+        "skills.get": async (params) => {
+            const { name } = (params ?? {});
+            if (!name || typeof name !== "string")
+                throw new Error("name is required");
+            const entry = getSkillManager().entries.find((e) => e.name === name);
+            if (!entry)
+                throw new Error(`Skill not found: ${name}`);
+            return {
+                skill: {
+                    name: entry.name,
+                    description: entry.description,
+                    icon: entry.icon,
+                    tools: entry.tools,
+                    content: entry.content,
+                },
+            };
+        },
+        /** Create or update a skill on disk. Supports rename via `originalName`. */
+        "skills.save": async (params) => {
+            const p = (params ?? {});
+            if (!p.name || typeof p.name !== "string")
+                throw new Error("name is required");
+            if (!p.content || typeof p.content !== "string")
+                throw new Error("content is required");
+            const name = p.name.trim();
+            if (name.length === 0)
+                throw new Error("name cannot be empty");
+            const skillDir = safeSkillDir(name);
+            // Check uniqueness (case-insensitive, matching scanner dedup logic)
+            const originalName = typeof p.originalName === "string" ? p.originalName.trim() : "";
+            const isRename = originalName && originalName !== name;
+            const isCreate = !originalName;
+            if (isCreate || isRename) {
+                const conflict = getSkillManager().entries.find((e) => e.name.toLowerCase() === name.toLowerCase());
+                if (conflict)
+                    throw new Error(`A skill named "${conflict.name}" already exists`);
+            }
+            // If renamed, delete the old skill directory first
+            if (isRename) {
+                const oldDir = safeSkillDir(originalName);
+                await rm(oldDir, { recursive: true, force: true });
+            }
+            const description = typeof p.description === "string" ? p.description.replace(/[\r\n]/g, " ") : "";
+            const icon = typeof p.icon === "string" && p.icon.length > 0 ? p.icon : undefined;
+            const tools = Array.isArray(p.tools) ? p.tools.filter((t) => typeof t === "string") : [];
+            const frontmatter = buildFrontmatter({ name, description, icon, tools });
+            const fileContent = `${frontmatter}\n${p.content}`;
+            await mkdir(skillDir, { recursive: true });
+            await writeFile(`${skillDir}/SKILL.md`, fileContent, "utf-8");
+            // Rescan so in-memory entries are consistent before broadcasting
+            await getSkillManager().scan();
+            emit("skillChange", { action: "saved", name });
+            return { status: "ok" };
+        },
+        /** Delete a skill directory from disk. */
+        "skills.delete": async (params) => {
+            const { name } = (params ?? {});
+            if (!name || typeof name !== "string")
+                throw new Error("name is required");
+            const skillDir = safeSkillDir(name);
+            await rm(skillDir, { recursive: true, force: true });
+            // Rescan so in-memory entries are consistent before broadcasting
+            await getSkillManager().scan();
+            emit("skillChange", { action: "deleted", name });
+            return { status: "ok" };
+        },
+        /** Import skills from ~/.claude/ (plugins cache + user skills). */
+        "skills.importClaude": async () => {
+            const claudeDir = join(homedir(), ".claude");
+            const found = await findSkillFiles(claudeDir);
+            if (found.length === 0)
+                return { imported: [], skipped: [] };
+            const existing = new Set(getSkillManager().entries.map((e) => e.name.toLowerCase()));
+            const imported = [];
+            const skipped = [];
+            for (const skillDir of found) {
+                const name = basename(skillDir);
+                if (existing.has(name.toLowerCase())) {
+                    skipped.push(name);
+                    continue;
+                }
+                try {
+                    const destDir = resolve(SKILLS_DIR, name);
+                    await cp(skillDir, destDir, { recursive: true });
+                    imported.push(name);
+                    existing.add(name.toLowerCase());
+                }
+                catch (err) {
+                    logger.warn(`Failed to import Claude skill "${name}": ${err instanceof Error ? err.message : err}`);
+                    skipped.push(name);
+                }
+            }
+            if (imported.length > 0) {
+                await getSkillManager().scan();
+                emit("skillChange", { action: "saved", name: imported.join(", ") });
+            }
+            return { imported, skipped };
+        },
+    };
+}
+/**
+ * Recursively find directories containing SKILL.md under a root path.
+ * Returns the parent directories (skill dirs to copy).
+ */
+async function findSkillFiles(root) {
+    const results = [];
+    async function walk(dir, depth) {
+        const MAX_DEPTH = 8;
+        if (depth > MAX_DEPTH)
+            return;
+        let entries;
+        try {
+            entries = await readdir(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry === "node_modules" || entry.startsWith("."))
+                continue;
+            const full = join(dir, entry);
+            const s = await stat(full).catch(() => null);
+            if (!s?.isDirectory())
+                continue;
+            // Check if this directory has a SKILL.md
+            const skillStat = await stat(join(full, "SKILL.md")).catch(() => null);
+            if (skillStat?.isFile()) {
+                results.push(full);
+            }
+            else {
+                // No SKILL.md here, recurse deeper
+                await walk(full, depth + 1);
+            }
+        }
+    }
+    await walk(root, 0);
+    return results;
+}

package/dist/gateway/methods/system.d.ts

@@ -0,0 +1,12 @@
+import { type LogEntry } from "../../logger.js";
+import type { RpcContext } from "../rpc.js";
+export declare function systemMethods(restart: () => Promise<void>, ctx?: RpcContext): {
+    /** Hot-restart all backend components. WebSocket connections stay alive. */
+    "system.restart": () => Promise<{
+        status: string;
+    }>;
+    /** Return buffered log history and subscribe the caller to real-time log events. */
+    "system.logs.subscribe": () => Promise<{
+        logs: LogEntry[];
+    }>;
+};

package/dist/gateway/methods/system.js

@@ -0,0 +1,39 @@
+import { emit } from "../../events.js";
+import { onClientClose } from "../broadcast.js";
+import { logger, getLogBuffer, addLogSubscriber } from "../../logger.js";
+export function systemMethods(restart, ctx) {
+    return {
+        /** Hot-restart all backend components. WebSocket connections stay alive. */
+        "system.restart": async () => {
+            logger.info("Hot restart requested via RPC");
+            emit("system", { action: "restarting" });
+            // Run restart in background so the RPC response is sent first
+            setTimeout(async () => {
+                try {
+                    await restart();
+                    emit("system", { action: "restarted" });
+                    logger.info("Hot restart complete");
+                }
+                catch (err) {
+                    logger.error(`Hot restart failed: ${err}`);
+                    emit("system", { action: "restart_failed", error: String(err) });
+                }
+            }, 0);
+            return { status: "restarting" };
+        },
+        /** Return buffered log history and subscribe the caller to real-time log events. */
+        "system.logs.subscribe": async () => {
+            const ws = ctx?.ws;
+            if (ws) {
+                const send = (entry) => {
+                    if (ws.readyState === ws.OPEN) {
+                        ws.send(JSON.stringify({ type: "event", event: "log", payload: entry }));
+                    }
+                };
+                const unsub = addLogSubscriber(send);
+                onClientClose(ws, unsub);
+            }
+            return { logs: getLogBuffer() };
+        },
+    };
+}

package/dist/gateway/methods/tasks.d.ts

@@ -0,0 +1,21 @@
+import type { TaskStore } from "../../tasks/store.js";
+export declare function taskMethods(taskStore: TaskStore): {
+    "tasks.list": (params: unknown) => Promise<{
+        tasks: import("../../tasks/types.js").Task[];
+    }>;
+    "tasks.create": (params: unknown) => Promise<{
+        task: import("../../tasks/types.js").Task;
+    }>;
+    "tasks.update": (params: unknown) => Promise<{
+        task: import("../../tasks/types.js").Task;
+    }>;
+    "tasks.delete": (params: unknown) => Promise<{
+        status: string;
+    }>;
+    "tasks.reorder": (params: unknown) => Promise<{
+        status: string;
+    }>;
+    "tasks.archiveDone": (params: unknown) => Promise<{
+        archived: number;
+    }>;
+};

package/dist/gateway/methods/tasks.js

@@ -0,0 +1,46 @@
+import { emit } from "../../events.js";
+import { CreateTaskSchema, UpdateTaskSchema, ListTasksSchema, ReorderTasksSchema } from "../../tasks/types.js";
+export function taskMethods(taskStore) {
+    return {
+        "tasks.list": async (params) => {
+            const filter = ListTasksSchema.parse(params ?? {});
+            return { tasks: taskStore.list(filter) };
+        },
+        "tasks.create": async (params) => {
+            const input = CreateTaskSchema.parse(params);
+            const task = taskStore.create(input);
+            emit("taskChange", { action: "created", task });
+            return { task };
+        },
+        "tasks.update": async (params) => {
+            const { id, ...updates } = UpdateTaskSchema.parse(params);
+            const task = taskStore.update(id, updates);
+            if (!task)
+                throw new Error(`Task not found: ${id}`);
+            emit("taskChange", { action: "updated", task });
+            return { task };
+        },
+        "tasks.delete": async (params) => {
+            const { id } = params ?? {};
+            if (!id)
+                throw new Error("Missing task id");
+            const deleted = taskStore.delete(id);
+            if (!deleted)
+                throw new Error(`Task not found: ${id}`);
+            emit("taskChange", { action: "deleted", id });
+            return { status: "ok" };
+        },
+        "tasks.reorder": async (params) => {
+            const { status, orderedIds } = ReorderTasksSchema.parse(params);
+            taskStore.reorder(status, orderedIds);
+            emit("taskChange", { action: "reordered", status });
+            return { status: "ok" };
+        },
+        "tasks.archiveDone": async (params) => {
+            const { teamId } = params ?? {};
+            const count = taskStore.archiveDone(teamId);
+            emit("taskChange", { action: "archived", count });
+            return { archived: count };
+        },
+    };
+}

package/dist/gateway/methods/teams.d.ts

@@ -0,0 +1,70 @@
+import type { TeamStore } from "../../teams/store.js";
+import type { TeamConfig } from "../../config/agent-config.js";
+import type { MemoryStore } from "../../memory/store.js";
+import type { EmbeddingProvider } from "../../memory/embedding.js";
+export declare function teamMethods(teamStore: TeamStore, memoryStore?: MemoryStore | null, embeddingProvider?: EmbeddingProvider | null): {
+    /** List all teams with their agents. */
+    "teams.list": () => Promise<{
+        teams: {
+            agents: import("../../teams/types.js").AgentRow[];
+            id: string;
+            name: string;
+            color: string;
+            workspace: string;
+            createdAt: number;
+            updatedAt: number;
+        }[];
+    }>;
+    /** Return teams in the TeamConfig[] format used by the UI. */
+    "teams.configs": () => Promise<{
+        teams: TeamConfig[];
+    }>;
+    /**
+     * Save a single team (create or update) including its agents.
+     * Accepts a full TeamConfig; handles agent diff internally.
+     */
+    "teams.save": (params: unknown) => Promise<{
+        teams: TeamConfig[];
+    }>;
+    /** Create a new team. */
+    "teams.create": (params: unknown) => Promise<{
+        team: import("../../teams/types.js").Team;
+    }>;
+    /** Update a team (rename / recolor / workspace / variables). */
+    "teams.update": (params: unknown) => Promise<{
+        team: import("../../teams/types.js").Team;
+    }>;
+    /** Delete a team and all its agents. */
+    "teams.delete": (params: unknown) => Promise<{
+        teams: TeamConfig[];
+    }>;
+    /** Add an agent to a team. */
+    "teams.createAgent": (params: unknown) => Promise<{
+        agent: import("../../teams/types.js").AgentRow;
+    }>;
+    /** Update an agent's configuration. */
+    "teams.updateAgent": (params: unknown) => Promise<{
+        agent: import("../../teams/types.js").AgentRow;
+    }>;
+    /** Remove an agent from a team. */
+    "teams.deleteAgent": (params: unknown) => Promise<{
+        status: string;
+    }>;
+    /** List memories for a team (paginated). */
+    "teams.memories.list": (params: unknown) => Promise<{
+        entries: import("../../memory/types.js").MemoryEntry[];
+        total: number;
+    }>;
+    /** Search memories scoped to a team (returns global + team). */
+    "teams.memories.search": (params: unknown) => Promise<{
+        facts: string[];
+    }>;
+    /** Manually add a memory for a team. */
+    "teams.memories.add": (params: unknown) => Promise<{
+        saved: boolean;
+    }>;
+    /** Delete a single memory by ID (team-scoped for authorization). */
+    "teams.memories.delete": (params: unknown) => Promise<{
+        status: string;
+    }>;
+};