verybot 0.1.8

package/dist/gateway/methods/playbooks.js

@@ -0,0 +1,488 @@
+import { mkdir, readdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { emit } from "../../events.js";
+import { PLAYBOOK_DIR, PLAYBOOKS_DIR } from "../../paths.js";
+const INDEX_FILENAME = "index.yaml";
+const README_FILENAME = "README.md";
+const SCRIPTS_DIRNAME = "scripts";
+const DEFAULT_README = "# New Playbook\n\n## When to use\n- TODO\n\n## Steps\n- TODO\n";
+const PLAYBOOK_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9 _-]{0,63}$/;
+function normalizeScriptPath(rawPath) {
+    if (typeof rawPath !== "string")
+        return null;
+    const normalized = rawPath.trim().replace(/\\/g, "/");
+    if (!normalized)
+        return null;
+    if (normalized.startsWith("/"))
+        return null;
+    const segments = normalized.split("/").filter(Boolean);
+    if (segments.length === 0)
+        return null;
+    if (segments.some((segment) => segment === "." || segment === ".."))
+        return null;
+    return segments.join("/");
+}
+function normalizeScriptCodeFiles(value) {
+    if (!Array.isArray(value))
+        return [];
+    const files = [];
+    const seenPaths = new Set();
+    for (const item of value) {
+        if (!item || typeof item !== "object")
+            continue;
+        const candidate = item;
+        const path = normalizeScriptPath(candidate.path);
+        if (!path || seenPaths.has(path))
+            continue;
+        const content = typeof candidate.content === "string" ? candidate.content : "";
+        files.push({ path, content });
+        seenPaths.add(path);
+    }
+    return files;
+}
+function getIndexPath() {
+    return join(PLAYBOOK_DIR, INDEX_FILENAME);
+}
+function sanitizePlaybookName(rawName) {
+    if (typeof rawName !== "string")
+        throw new Error("playbook name is required");
+    const trimmed = rawName.trim();
+    const sanitized = basename(trimmed);
+    if (!sanitized || sanitized === "." || sanitized === "..") {
+        throw new Error("Invalid playbook name");
+    }
+    if (!PLAYBOOK_NAME_PATTERN.test(sanitized)) {
+        throw new Error("Playbook name must be alphanumeric (spaces/hyphens/underscores allowed, max 64 chars)");
+    }
+    return sanitized;
+}
+function resolvePlaybookDir(name) {
+    const target = resolve(PLAYBOOKS_DIR, name);
+    const parent = resolve(PLAYBOOKS_DIR);
+    if (!target.startsWith(`${parent}/`)) {
+        throw new Error("Invalid playbook path");
+    }
+    return target;
+}
+function isNonEmptyArray(value) {
+    return Array.isArray(value) && value.length > 0;
+}
+function normalizeStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    const result = [];
+    const seen = new Set();
+    for (const item of value) {
+        if (typeof item !== "string")
+            continue;
+        const trimmed = item.trim();
+        if (!trimmed)
+            continue;
+        const key = trimmed.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(trimmed);
+    }
+    return result;
+}
+function parseYamlScalar(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return "";
+    if (trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length >= 2) {
+        return trimmed
+            .slice(1, -1)
+            .replace(/\\n/g, "\n")
+            .replace(/\\"/g, '"')
+            .replace(/\\\\/g, "\\");
+    }
+    if (trimmed.startsWith("'") && trimmed.endsWith("'") && trimmed.length >= 2) {
+        return trimmed.slice(1, -1).replace(/''/g, "'");
+    }
+    return trimmed;
+}
+function parseInlineYamlList(value) {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("[") || !trimmed.endsWith("]"))
+        return [];
+    const body = trimmed.slice(1, -1).trim();
+    if (!body)
+        return [];
+    return body
+        .split(",")
+        .map((item) => parseYamlScalar(item))
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function lineIndent(line) {
+    return line.length - line.trimStart().length;
+}
+function parseYamlBlockList(lines, startIndex, parentIndent) {
+    const values = [];
+    let idx = startIndex;
+    while (idx < lines.length) {
+        const line = lines[idx];
+        if (!line.trim()) {
+            idx++;
+            continue;
+        }
+        const indent = lineIndent(line);
+        if (indent <= parentIndent)
+            break;
+        const itemMatch = line.match(/^\s*-\s*(.*)$/);
+        if (!itemMatch)
+            break;
+        const parsed = parseYamlScalar(itemMatch[1]);
+        if (parsed)
+            values.push(parsed);
+        idx++;
+    }
+    return { values, nextIndex: idx };
+}
+function parseIndexYaml(raw) {
+    const lines = raw.replace(/\r\n/g, "\n").split("\n");
+    const entries = [];
+    let idx = 0;
+    while (idx < lines.length) {
+        const line = lines[idx];
+        const nameMatch = line.match(/^\s*-\s*name:\s*(.*)$/);
+        if (!nameMatch) {
+            idx++;
+            continue;
+        }
+        const name = parseYamlScalar(nameMatch[1]);
+        const entry = {
+            name,
+            description: "",
+            triggers: [],
+            tags: [],
+        };
+        idx++;
+        while (idx < lines.length) {
+            const current = lines[idx];
+            if (/^\s*-\s*name:\s*/.test(current))
+                break;
+            const descriptionMatch = current.match(/^\s*description:\s*(.*)$/);
+            if (descriptionMatch) {
+                entry.description = parseYamlScalar(descriptionMatch[1]);
+                idx++;
+                continue;
+            }
+            const triggersMatch = current.match(/^\s*triggers:\s*(.*)$/);
+            if (triggersMatch) {
+                const inline = triggersMatch[1].trim();
+                if (inline) {
+                    entry.triggers = parseInlineYamlList(inline);
+                    idx++;
+                    continue;
+                }
+                const parsed = parseYamlBlockList(lines, idx + 1, lineIndent(current));
+                entry.triggers = parsed.values;
+                idx = parsed.nextIndex;
+                continue;
+            }
+            const tagsMatch = current.match(/^\s*tags:\s*(.*)$/);
+            if (tagsMatch) {
+                const inline = tagsMatch[1].trim();
+                if (inline) {
+                    entry.tags = parseInlineYamlList(inline);
+                    idx++;
+                    continue;
+                }
+                const parsed = parseYamlBlockList(lines, idx + 1, lineIndent(current));
+                entry.tags = parsed.values;
+                idx = parsed.nextIndex;
+                continue;
+            }
+            idx++;
+        }
+        if (entry.name) {
+            entries.push({
+                name: entry.name,
+                description: entry.description,
+                triggers: normalizeStringArray(entry.triggers),
+                tags: normalizeStringArray(entry.tags),
+            });
+        }
+    }
+    return entries;
+}
+function yamlEscape(value) {
+    if (/[:\n\r#"'\[\]{}|>&*!%@`]/.test(value) || value.trim() !== value) {
+        return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`;
+    }
+    return value;
+}
+function serializeIndexYaml(entries) {
+    if (entries.length === 0)
+        return "playbooks: []\n";
+    const lines = ["playbooks:"];
+    for (const entry of entries) {
+        lines.push(`  - name: ${yamlEscape(entry.name)}`);
+        lines.push(`    description: ${yamlEscape(entry.description)}`);
+        if (isNonEmptyArray(entry.triggers)) {
+            lines.push("    triggers:");
+            for (const trigger of entry.triggers) {
+                lines.push(`      - ${yamlEscape(trigger)}`);
+            }
+        }
+        else {
+            lines.push("    triggers: []");
+        }
+        if (isNonEmptyArray(entry.tags)) {
+            lines.push("    tags:");
+            for (const tag of entry.tags) {
+                lines.push(`      - ${yamlEscape(tag)}`);
+            }
+        }
+        else {
+            lines.push("    tags: []");
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+async function exists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readIndexEntries() {
+    const indexPath = getIndexPath();
+    const raw = await readFile(indexPath, "utf-8").catch(() => "");
+    if (!raw.trim())
+        return [];
+    return parseIndexYaml(raw);
+}
+async function writeIndexEntries(entries) {
+    await mkdir(PLAYBOOK_DIR, { recursive: true });
+    const indexPath = getIndexPath();
+    await writeFile(indexPath, serializeIndexYaml(entries), "utf-8");
+}
+async function listFilesRecursive(root) {
+    const files = [];
+    async function walk(current) {
+        const entries = await readdir(current, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            const abs = join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(abs);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            const relPath = relative(root, abs).replace(/\\/g, "/");
+            files.push(relPath);
+        }
+    }
+    if (await exists(root)) {
+        await walk(root);
+    }
+    return files.sort((a, b) => a.localeCompare(b));
+}
+async function readDiskPlaybook(name) {
+    const dir = resolvePlaybookDir(name);
+    if (!(await exists(dir)))
+        return null;
+    const readmePath = join(dir, README_FILENAME);
+    const scriptsDir = join(dir, SCRIPTS_DIRNAME);
+    const readmeExists = await exists(readmePath);
+    const readme = readmeExists ? await readFile(readmePath, "utf-8") : "";
+    const scriptFiles = await listFilesRecursive(scriptsDir);
+    const scriptCodeFiles = await Promise.all(scriptFiles.map(async (path) => {
+        const content = await readFile(join(scriptsDir, path), "utf-8").catch(() => "");
+        return { path, content };
+    }));
+    return { readmeExists, readme, scriptFiles, scriptCodeFiles };
+}
+function findIndexEntry(entries, name) {
+    return entries.find((entry) => entry.name === name);
+}
+function normalizeIndexEntry(params) {
+    return {
+        name: params.name,
+        description: typeof params.description === "string" ? params.description.trim() : "",
+        triggers: normalizeStringArray(params.triggers),
+        tags: normalizeStringArray(params.tags),
+    };
+}
+async function listDiskPlaybookNames() {
+    const entries = await readdir(PLAYBOOKS_DIR, { withFileTypes: true }).catch(() => []);
+    return entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort((a, b) => a.localeCompare(b));
+}
+export function playbookMethods() {
+    return {
+        "playbooks.list": async () => {
+            const indexEntries = await readIndexEntries();
+            const indexMap = new Map(indexEntries.map((entry) => [entry.name, entry]));
+            const diskNames = await listDiskPlaybookNames();
+            const names = new Set([...indexMap.keys(), ...diskNames]);
+            const sortedNames = Array.from(names).sort((a, b) => a.localeCompare(b));
+            const playbooks = await Promise.all(sortedNames.map(async (name) => {
+                const indexEntry = indexMap.get(name);
+                const diskEntry = await readDiskPlaybook(name);
+                return {
+                    name,
+                    description: indexEntry?.description ?? "",
+                    triggers: indexEntry?.triggers ?? [],
+                    tags: indexEntry?.tags ?? [],
+                    inIndex: Boolean(indexEntry),
+                    onDisk: Boolean(diskEntry),
+                    readmeExists: diskEntry?.readmeExists ?? false,
+                    scriptCount: diskEntry?.scriptFiles.length ?? 0,
+                };
+            }));
+            return { playbooks };
+        },
+        "playbooks.get": async (params) => {
+            const payload = (params ?? {});
+            const name = sanitizePlaybookName(payload.name);
+            const indexEntries = await readIndexEntries();
+            const indexEntry = findIndexEntry(indexEntries, name);
+            const diskEntry = await readDiskPlaybook(name);
+            if (!indexEntry && !diskEntry) {
+                throw new Error(`Playbook not found: ${name}`);
+            }
+            return {
+                playbook: {
+                    name,
+                    description: indexEntry?.description ?? "",
+                    triggers: indexEntry?.triggers ?? [],
+                    tags: indexEntry?.tags ?? [],
+                    inIndex: Boolean(indexEntry),
+                    onDisk: Boolean(diskEntry),
+                    readmeExists: diskEntry?.readmeExists ?? false,
+                    readme: diskEntry?.readme ?? "",
+                    scriptFiles: diskEntry?.scriptFiles ?? [],
+                    scriptCodeFiles: diskEntry?.scriptCodeFiles ?? [],
+                },
+            };
+        },
+        "playbooks.create": async (params) => {
+            const payload = (params ?? {});
+            const name = sanitizePlaybookName(payload.name);
+            const readme = typeof payload.readme === "string" ? payload.readme : DEFAULT_README;
+            const indexEntries = await readIndexEntries();
+            if (findIndexEntry(indexEntries, name)) {
+                throw new Error(`Playbook already exists in index: ${name}`);
+            }
+            const playbookDir = resolvePlaybookDir(name);
+            if (await exists(playbookDir)) {
+                throw new Error(`Playbook directory already exists: ${name}`);
+            }
+            const normalized = normalizeIndexEntry({
+                name,
+                description: payload.description,
+                triggers: payload.triggers,
+                tags: payload.tags,
+            });
+            const nextEntries = [...indexEntries, normalized].sort((a, b) => a.name.localeCompare(b.name));
+            await mkdir(playbookDir, { recursive: true });
+            await mkdir(join(playbookDir, SCRIPTS_DIRNAME), { recursive: true });
+            await writeFile(join(playbookDir, README_FILENAME), readme, "utf-8");
+            await writeIndexEntries(nextEntries);
+            emit("playbookChange", { action: "created", name });
+            return { status: "ok" };
+        },
+        "playbooks.update": async (params) => {
+            const payload = (params ?? {});
+            const name = sanitizePlaybookName(payload.name);
+            const hasReadme = typeof payload.readme === "string";
+            const readme = hasReadme ? payload.readme : null;
+            const scriptCodeFiles = normalizeScriptCodeFiles(payload.scriptCodeFiles);
+            const indexEntries = await readIndexEntries();
+            const normalized = normalizeIndexEntry({
+                name,
+                description: payload.description,
+                triggers: payload.triggers,
+                tags: payload.tags,
+            });
+            const existingIndex = findIndexEntry(indexEntries, name);
+            const nextEntries = existingIndex
+                ? indexEntries.map((entry) => (entry.name === name ? normalized : entry))
+                : [...indexEntries, normalized].sort((a, b) => a.name.localeCompare(b.name));
+            const playbookDir = resolvePlaybookDir(name);
+            await mkdir(playbookDir, { recursive: true });
+            const scriptsDir = join(playbookDir, SCRIPTS_DIRNAME);
+            await mkdir(scriptsDir, { recursive: true });
+            const readmePath = join(playbookDir, README_FILENAME);
+            if (readme !== null) {
+                await writeFile(readmePath, readme, "utf-8");
+            }
+            else if (!(await exists(readmePath))) {
+                await writeFile(readmePath, DEFAULT_README, "utf-8");
+            }
+            for (const scriptFile of scriptCodeFiles) {
+                const targetScriptPath = resolve(scriptsDir, scriptFile.path);
+                if (!targetScriptPath.startsWith(`${resolve(scriptsDir)}/`)) {
+                    throw new Error(`Invalid script path: ${scriptFile.path}`);
+                }
+                await mkdir(dirname(targetScriptPath), { recursive: true });
+                await writeFile(targetScriptPath, scriptFile.content, "utf-8");
+            }
+            await writeIndexEntries(nextEntries);
+            emit("playbookChange", { action: "updated", name });
+            return { status: "ok" };
+        },
+        "playbooks.rename": async (params) => {
+            const payload = (params ?? {});
+            const name = sanitizePlaybookName(payload.name);
+            const newName = sanitizePlaybookName(payload.newName);
+            if (name === newName)
+                return { status: "ok" };
+            const indexEntries = await readIndexEntries();
+            const oldEntry = findIndexEntry(indexEntries, name);
+            const newEntry = findIndexEntry(indexEntries, newName);
+            if (newEntry)
+                throw new Error(`Playbook already exists: ${newName}`);
+            const oldDir = resolvePlaybookDir(name);
+            const newDir = resolvePlaybookDir(newName);
+            const oldDirExists = await exists(oldDir);
+            const newDirExists = await exists(newDir);
+            if (!oldEntry && !oldDirExists) {
+                throw new Error(`Playbook not found: ${name}`);
+            }
+            if (newDirExists) {
+                throw new Error(`Playbook directory already exists: ${newName}`);
+            }
+            if (oldDirExists) {
+                await mkdir(PLAYBOOKS_DIR, { recursive: true });
+                await rename(oldDir, newDir);
+            }
+            const nextEntries = oldEntry
+                ? indexEntries
+                    .map((entry) => (entry.name === name ? { ...entry, name: newName } : entry))
+                    .sort((a, b) => a.name.localeCompare(b.name))
+                : [...indexEntries, { name: newName, description: "", triggers: [], tags: [] }]
+                    .sort((a, b) => a.name.localeCompare(b.name));
+            await writeIndexEntries(nextEntries);
+            emit("playbookChange", { action: "renamed", name, newName });
+            return { status: "ok" };
+        },
+        "playbooks.delete": async (params) => {
+            const payload = (params ?? {});
+            const name = sanitizePlaybookName(payload.name);
+            const indexEntries = await readIndexEntries();
+            const nextEntries = indexEntries.filter((entry) => entry.name !== name);
+            const hadIndexEntry = nextEntries.length !== indexEntries.length;
+            const playbookDir = resolvePlaybookDir(name);
+            const hadDirectory = await exists(playbookDir);
+            if (!hadIndexEntry && !hadDirectory) {
+                throw new Error(`Playbook not found: ${name}`);
+            }
+            if (hadDirectory) {
+                await rm(playbookDir, { recursive: true, force: true });
+            }
+            await writeIndexEntries(nextEntries);
+            emit("playbookChange", { action: "deleted", name });
+            return { status: "ok" };
+        },
+    };
+}

package/dist/gateway/methods/prompt-templates.d.ts

@@ -0,0 +1,27 @@
+import type { PromptTemplateStore } from "../../prompt-templates/store.js";
+export declare function promptTemplateMethods(promptTemplateStore: PromptTemplateStore): {
+    /** List all prompt templates. */
+    "promptTemplates.list": () => Promise<{
+        promptTemplates: import("../../prompt-templates/types.js").PromptTemplate[];
+    }>;
+    /** Get a single prompt template by id. */
+    "promptTemplates.get": (params: unknown) => Promise<{
+        promptTemplate: import("../../prompt-templates/types.js").PromptTemplate;
+    }>;
+    /** Create a new prompt template. */
+    "promptTemplates.create": (params: unknown) => Promise<{
+        promptTemplate: import("../../prompt-templates/types.js").PromptTemplate;
+    }>;
+    /** Fork an existing template into a user-editable copy. */
+    "promptTemplates.fork": (params: unknown) => Promise<{
+        promptTemplate: import("../../prompt-templates/types.js").PromptTemplate;
+    }>;
+    /** Update an existing prompt template (rejects builtins). */
+    "promptTemplates.update": (params: unknown) => Promise<{
+        promptTemplate: import("../../prompt-templates/types.js").PromptTemplate;
+    }>;
+    /** Delete a prompt template (rejects builtins). */
+    "promptTemplates.delete": (params: unknown) => Promise<{
+        status: string;
+    }>;
+};

package/dist/gateway/methods/prompt-templates.js

@@ -0,0 +1,106 @@
+import { emit } from "../../events.js";
+import { MAX_TEMPLATE_NAME_LENGTH, MAX_TEMPLATE_CONTENT_LENGTH } from "../../prompt-templates/store.js";
+const VALID_ROLES = new Set(["orchestrator", "worker"]);
+export function promptTemplateMethods(promptTemplateStore) {
+    return {
+        /** List all prompt templates. */
+        "promptTemplates.list": async () => {
+            return { promptTemplates: promptTemplateStore.listPromptTemplates() };
+        },
+        /** Get a single prompt template by id. */
+        "promptTemplates.get": async (params) => {
+            const { id } = (params ?? {});
+            if (!id || typeof id !== "string")
+                throw new Error("id is required");
+            const promptTemplate = promptTemplateStore.getPromptTemplateById(id);
+            if (!promptTemplate)
+                throw new Error(`Template not found: ${id}`);
+            return { promptTemplate };
+        },
+        /** Create a new prompt template. */
+        "promptTemplates.create": async (params) => {
+            const p = (params ?? {});
+            const name = p.name;
+            const role = p.role;
+            const content = p.content;
+            if (!name || typeof name !== "string")
+                throw new Error("name is required");
+            if (name.trim().length === 0)
+                throw new Error("name cannot be empty");
+            if (name.length > MAX_TEMPLATE_NAME_LENGTH)
+                throw new Error(`name exceeds maximum length of ${MAX_TEMPLATE_NAME_LENGTH}`);
+            if (!role || !VALID_ROLES.has(role))
+                throw new Error("role must be 'orchestrator' or 'worker'");
+            if (typeof content !== "string")
+                throw new Error("content is required");
+            if (content.length > MAX_TEMPLATE_CONTENT_LENGTH)
+                throw new Error(`content exceeds maximum length of ${MAX_TEMPLATE_CONTENT_LENGTH}`);
+            const promptTemplate = promptTemplateStore.createPromptTemplate({
+                name: name.trim(),
+                description: typeof p.description === "string" ? p.description : "",
+                role: role,
+                content,
+            });
+            emit("promptTemplateChange", { action: "created", promptTemplate });
+            return { promptTemplate };
+        },
+        /** Fork an existing template into a user-editable copy. */
+        "promptTemplates.fork": async (params) => {
+            const p = (params ?? {});
+            const id = p.id;
+            if (!id || typeof id !== "string")
+                throw new Error("id is required");
+            if (p.name !== undefined && (typeof p.name !== "string" || p.name.trim().length === 0)) {
+                throw new Error("name cannot be empty");
+            }
+            if (typeof p.name === "string" && p.name.length > MAX_TEMPLATE_NAME_LENGTH) {
+                throw new Error(`name exceeds maximum length of ${MAX_TEMPLATE_NAME_LENGTH}`);
+            }
+            if (p.description !== undefined && typeof p.description !== "string") {
+                throw new Error("description must be a string");
+            }
+            const promptTemplate = promptTemplateStore.forkPromptTemplate(id, {
+                name: typeof p.name === "string" ? p.name.trim() : undefined,
+                description: typeof p.description === "string" ? p.description : undefined,
+            });
+            if (!promptTemplate)
+                throw new Error(`Template not found: ${id}`);
+            emit("promptTemplateChange", { action: "created", promptTemplate });
+            return { promptTemplate };
+        },
+        /** Update an existing prompt template (rejects builtins). */
+        "promptTemplates.update": async (params) => {
+            const p = (params ?? {});
+            const id = p.id;
+            if (!id || typeof id !== "string")
+                throw new Error("id is required");
+            if (p.name !== undefined && (typeof p.name !== "string" || p.name.trim().length === 0)) {
+                throw new Error("name cannot be empty");
+            }
+            if (p.role !== undefined && !VALID_ROLES.has(p.role)) {
+                throw new Error("role must be 'orchestrator' or 'worker'");
+            }
+            const promptTemplate = promptTemplateStore.updatePromptTemplate(id, {
+                name: typeof p.name === "string" ? p.name.trim() : undefined,
+                description: typeof p.description === "string" ? p.description : undefined,
+                role: VALID_ROLES.has(p.role) ? p.role : undefined,
+                content: typeof p.content === "string" ? p.content : undefined,
+            });
+            if (!promptTemplate)
+                throw new Error(`Template not found: ${id}`);
+            emit("promptTemplateChange", { action: "updated", promptTemplate });
+            return { promptTemplate };
+        },
+        /** Delete a prompt template (rejects builtins). */
+        "promptTemplates.delete": async (params) => {
+            const { id } = (params ?? {});
+            if (!id || typeof id !== "string")
+                throw new Error("id is required");
+            const deleted = promptTemplateStore.deletePromptTemplate(id);
+            if (!deleted)
+                throw new Error(`Template not found: ${id}`);
+            emit("promptTemplateChange", { action: "deleted", id });
+            return { status: "ok" };
+        },
+    };
+}

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

@@ -0,0 +1,62 @@
+import type { Agent } from "../../brain/agent.js";
+import type { ScheduleStore } from "../../scheduler/store.js";
+import type { ConnectedChannelRegistry } from "../../scheduler/connected-channels.js";
+import type { RpcContext } from "../rpc.js";
+export declare function schedulerMethods(getAgent: () => Agent, getScheduleStore: () => ScheduleStore, getConnectedChannels: () => ConnectedChannelRegistry, ctx?: RpcContext): {
+    /** Connect a WS client to a team's scheduler. Returns session history + connection key. */
+    "scheduler.connect": (params: {
+        teamId: string;
+    }) => Promise<{
+        connectionKey: string;
+        messages: import("ai").ModelMessage[];
+    }>;
+    /** Disconnect a WS client from a team's scheduler. */
+    "scheduler.disconnect": (params: {
+        teamId: string;
+        connectionKey: string;
+    }) => Promise<{
+        status: string;
+    }>;
+    /** Send a message to the team's scheduler session. */
+    "scheduler.send": (params: {
+        teamId: string;
+        message: string;
+    }) => Promise<{
+        status: string;
+        reply: string;
+    }>;
+    /** Get scheduler session history for a team. */
+    "scheduler.history": (params: {
+        teamId: string;
+    }) => Promise<{
+        messages: import("ai").ModelMessage[];
+    }>;
+    /** List schedules for a team. */
+    "scheduler.list": (params: {
+        teamId: string;
+        status?: string;
+    }) => Promise<{
+        schedules: import("../../scheduler/types.js").Schedule[];
+    }>;
+    /** Pause an active schedule. */
+    "scheduler.pause": (params: {
+        teamId: string;
+        scheduleId: string;
+    }) => Promise<{
+        status: string;
+    }>;
+    /** Resume a paused schedule. */
+    "scheduler.resume": (params: {
+        teamId: string;
+        scheduleId: string;
+    }) => Promise<{
+        status: string;
+    }>;
+    /** Delete a schedule. */
+    "scheduler.delete": (params: {
+        teamId: string;
+        scheduleId: string;
+    }) => Promise<{
+        status: string;
+    }>;
+};