openbot 0.2.12 → 0.2.13

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/dist/agents/agent-creator.js

@@ -1,74 +0,0 @@
-import path from "node:path";
-import { llmPlugin } from "../plugins/llm/index.js";
-import { fileSystemToolDefinitions, fileSystemPlugin } from "../plugins/file-system/index.js";
-import { DEFAULT_BASE_DIR, resolvePath } from "../config.js";
-export const agentCreatorAgent = (options) => (builder) => {
-    const { model } = options;
-    const baseDir = resolvePath(DEFAULT_BASE_DIR);
-    const agentsDir = path.join(baseDir, "agents");
-    builder
-        .use(fileSystemPlugin({ baseDir }))
-        .use(llmPlugin({
-        model,
-        system: `You are the OpenBot Agent Creator. Your job is to help users create AND update custom OpenBot agents via natural language.
-
-Configuration storage:
-1. The Default Agent (the main orchestrator, usually named "OpenBot") is defined in: ${baseDir}/AGENT.md.
-2. Custom Agents live in their own subdirectories: ${agentsDir}/<agent-name>/AGENT.md.
-
-The AGENT.md file uses Markdown with a YAML frontmatter block at the top.
-
-Frontmatter fields (required):
----
-name: <slug-name>
-description: <short description>
-plugins:
-  - shell
-  - file-system
-  - name: approval
-    config:
-      rules: []
----
-
-Optional fields:
-- model: <provider/model-id>
-- subscribe: [<event-type>, ...]
-
-The Markdown body below the frontmatter contains the agent's persona and detailed behavioral instructions.
-
-Official plugin catalog (prefer these):
-- shell: execute shell commands
-- file-system: read/write/list/delete files
-- approval: require user approval before risky actions
-- browser-tools: web automation
-- search: search/retrieval tools
-
-Tool Usage:
-1. Use \`listFiles\` to explore existing agents in ${agentsDir}.
-2. Use \`readFile\` to inspect an existing agent's AGENT.md before updating it.
-3. Use \`writeFile\` to create or update an agent's AGENT.md.
-
-Rules:
-1. Do not write files until user explicitly approves the proposed changes.
-2. For updates, ALWAYS read the current AGENT.md first using \`readFile\`, then propose changes.
-3. For the Default Agent, ALWAYS use ${baseDir}/AGENT.md.
-4. For Custom Agents, ALWAYS use ${agentsDir}/<name>/AGENT.md.
-5. If you're unsure which agent to update, use \`listFiles\` on ${agentsDir} to see available agents.
-6. Prefer official plugins.
-7. Keep frontmatter minimal; include only meaningful fields.
-8. If required info is missing, ask focused follow-up questions.
-9. After writing, confirm that the correct AGENT.md was updated.
-10. The server hot-reloads ~/.openbot changes.
-11. ALWAYS use the consolidated AGENT.md format. Do NOT create agent.yaml files anymore.
-
-Workflow:
-1. Determine whether this is create or update, and if it's for the Default Agent or a Custom Agent.
-2. If it's an update, use \`readFile\` to get the current configuration.
-3. If the agent name is ambiguous, use \`listFiles\` to find the correct one.
-4. Collect missing requirements from the user.
-5. Show a proposed AGENT.md content (frontmatter + instructions) and request explicit approval.
-6. On approval, write the appropriate AGENT.md using \`writeFile\`.
-7. Return a short completion summary.`,
-        toolDefinitions: fileSystemToolDefinitions, // Give it access to write files
-    }));
-};

package/dist/agents/browser-agent.js

@@ -1,31 +0,0 @@
-import { llmPlugin } from "../plugins/llm/index.js";
-import { browserPlugin, browserToolDefinitions, } from "../plugins/browser/index.js";
-const DEFAULT_SYSTEM_PROMPT = `You are a Browser Agent.
-Your job is to help the user browse the web, extract information, and perform actions.
-
-Tools:
-- browser_act: Give a natural language instruction to interact with the page (e.g. "click the login button").
-- browser_observe: See what actions are available on the current page.
-- browser_extract: Pull structured data from the page.
-- browser_state_update: Get a fresh screenshot and URL.
-
-Always describe what you see and what you are doing.`;
-/**
- * High-level Browser Agent plugin for Melony.
- * Composes the low-level browserPlugin with an llmPlugin.
- */
-export const browserAgent = (options) => (builder) => {
-    const { model, systemPrompt = DEFAULT_SYSTEM_PROMPT } = options;
-    builder
-        .use(browserPlugin({ ...options, model }))
-        .use(llmPlugin({
-        model,
-        system: systemPrompt,
-        toolDefinitions: browserToolDefinitions,
-        promptInputType: "agent:browser:input",
-        actionResultInputType: "agent:browser:result",
-        completionEventType: "agent:browser:output",
-    }));
-    // NOTE: Bridge-back to the manager is handled generically by open-bot.ts.
-    // No per-agent boilerplate needed.
-};

package/dist/agents/os-agent.js

@@ -1,32 +0,0 @@
-import { llmPlugin } from "../plugins/llm/index.js";
-import { shellPlugin, shellToolDefinitions } from "../plugins/shell/index.js";
-import { fileSystemPlugin, fileSystemToolDefinitions } from "../plugins/file-system/index.js";
-import approvalPlugin from "../plugins/approval/index.js";
-const DEFAULT_SYSTEM_PROMPT = `You are an OS Agent with access to the shell and file system.
-Your job is to help the user with file operations and command execution.
-You can read, write, list, and delete files, as well as execute shell commands.
-Always be careful with destructive operations.
-When you are done with the task, summarize what you did.`;
-export const osAgent = (options) => (builder) => {
-    const { model, cwd = process.cwd(), systemPrompt = DEFAULT_SYSTEM_PROMPT } = options;
-    builder
-        .use(shellPlugin({ cwd }))
-        .use(fileSystemPlugin({ baseDir: "/" }))
-        .use(approvalPlugin({
-        rules: [
-            { action: "action:executeCommand", message: "The agent wants to execute a terminal command. Please review carefully." },
-            // { action: "action:writeFile", message: "The agent wants to write to a file." },
-            { action: "action:deleteFile", message: "The agent wants to delete a file." },
-        ],
-    }))
-        .use(llmPlugin({
-        model,
-        system: systemPrompt,
-        toolDefinitions: {
-            ...shellToolDefinitions,
-            ...fileSystemToolDefinitions
-        },
-    }));
-    // NOTE: Bridge-back to the manager is handled generically by open-bot.ts.
-    // No per-agent boilerplate needed.
-};

package/dist/agents/planner-agent.js

@@ -1,32 +0,0 @@
-import { llmPlugin } from "../plugins/llm/index.js";
-const PLANNER_SYSTEM_PROMPT = `You are a planning specialist agent.
-
-Your job:
-- Convert a user intent into a short, executable plan.
-- Keep plans practical and concise.
-- Prefer 2-5 steps.
-- Each step should specify the best agent to execute it when relevant.
-
-Available agent naming convention:
-- Use exact agent names when assigning (e.g. os, browser, topic, planner-agent, etc.).
-
-Output format:
-- Return strict JSON only.
-- Shape:
-{
-  "goal": "...",
-  "steps": [
-    { "id": "step_1", "agent": "agent-name-or-manager", "task": "..." }
-  ]
-}
-
-Rules:
-- If no specialist agent is needed for a step, set "agent" to "manager".
-- Do not include markdown fences.
-- Do not include explanatory prose outside JSON.`;
-export const plannerAgent = (options) => (builder) => {
-    builder.use(llmPlugin({
-        model: options.model,
-        system: PLANNER_SYSTEM_PROMPT,
-    }));
-};

package/dist/agents/topic-agent.js

@@ -1,46 +0,0 @@
-import { generateText } from "ai";
-function getTitleSourceMessages(state, event) {
-    if (Array.isArray(state.messages) && state.messages.length >= 2) {
-        return state.messages;
-    }
-    const agentName = event.meta?.agentName;
-    if (!agentName)
-        return [];
-    const agentMessages = state.agentStates?.[agentName]?.messages;
-    if (Array.isArray(agentMessages) && agentMessages.length >= 2) {
-        return agentMessages;
-    }
-    return [];
-}
-export const topicAgent = (options) => (builder) => {
-    builder.on("agent:output", async function* (event, { state }) {
-        // Only title if it doesn't have one and there's history
-        if (state.title) {
-            return;
-        }
-        const messagesForTitle = getTitleSourceMessages(state, event);
-        // Don't title if there are too few messages
-        if (messagesForTitle.length < 2) {
-            return;
-        }
-        try {
-            const { text } = await generateText({
-                model: options.model,
-                system: "You are a Topic Agent. Create a very concise (3-5 words) title for the conversation based on the user's intent. Do not use quotes or special characters.",
-                prompt: `Analyze these messages and provide a title: ${JSON.stringify(messagesForTitle.slice(0, 6))}`,
-            });
-            const newTitle = text.replace(/["']/g, "").trim();
-            if (newTitle) {
-                state.title = newTitle;
-                // Notify the client to refresh the sessions list in the sidebar
-                yield {
-                    type: "client:invalidate",
-                    data: { tags: ["sessions"] }
-                };
-            }
-        }
-        catch (error) {
-            console.error("[topic-agent] Failed to generate title:", error);
-        }
-    });
-};

package/dist/architecture/execution-engine.js

@@ -1,151 +0,0 @@
-const DEFAULT_POLICY = {
-    maxRetries: 1,
-    stepTimeoutMs: 45000,
-};
-function nowIso() {
-    return new Date().toISOString();
-}
-function toError(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function updateTrace(state, patch) {
-    const next = {
-        traceId: patch.traceId ?? state.execution?.traceId ?? `trace_${Date.now()}`,
-        state: patch.state ?? state.execution?.state ?? "RECEIVED",
-        intent: patch.intent ?? state.execution?.intent,
-        plan: patch.plan ?? state.execution?.plan,
-        currentStepId: patch.currentStepId ?? state.execution?.currentStepId,
-        error: patch.error ?? state.execution?.error,
-        updatedAt: nowIso(),
-    };
-    state.execution = next;
-    return next;
-}
-function toExecutionEvent(trace) {
-    return {
-        type: "execution:state",
-        data: {
-            traceId: trace.traceId,
-            state: trace.state,
-            currentStepId: trace.currentStepId,
-            error: trace.error,
-            intentType: trace.intent?.type,
-            planSteps: trace.plan?.steps.length,
-        },
-    };
-}
-function withTimeout(promise, timeoutMs) {
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-            reject(new Error(`Step timed out after ${timeoutMs}ms`));
-        }, timeoutMs);
-        promise
-            .then((value) => {
-            clearTimeout(timer);
-            resolve(value);
-        })
-            .catch((error) => {
-            clearTimeout(timer);
-            reject(error);
-        });
-    });
-}
-function hasPendingApprovals(state) {
-    const agentStates = state.agentStates || {};
-    return Object.values(agentStates).some((agentState) => !!agentState.pendingApprovals &&
-        Object.keys(agentState.pendingApprovals).length > 0);
-}
-async function* executeStep(step, input, policy) {
-    let lastError;
-    for (let attempt = 0; attempt <= policy.maxRetries; attempt++) {
-        try {
-            const stream = step.kind === "delegate"
-                ? input.callbacks.runAgent(step.agent ?? "", step.task ?? "", step.attachments, input.state, input.runId)
-                : input.callbacks.runManager(step.content ?? "", step.attachments, input.state, input.runId);
-            while (true) {
-                const nextItem = await withTimeout(stream.next(), policy.stepTimeoutMs);
-                if (nextItem.done)
-                    break;
-                const event = nextItem.value;
-                if (input.state.execution?.state === "WAITING_APPROVAL") {
-                    const trace = updateTrace(input.state, {
-                        state: "EXECUTING",
-                        currentStepId: step.id,
-                    });
-                    yield toExecutionEvent(trace);
-                }
-                yield event;
-            }
-            return;
-        }
-        catch (error) {
-            lastError = error;
-            if (attempt < policy.maxRetries) {
-                const trace = updateTrace(input.state, {
-                    state: "EXECUTING",
-                    currentStepId: step.id,
-                    error: `Retry ${attempt + 1}/${policy.maxRetries}: ${toError(error)}`,
-                });
-                yield toExecutionEvent(trace);
-                continue;
-            }
-        }
-    }
-    throw lastError instanceof Error ? lastError : new Error(toError(lastError));
-}
-/**
- * Stateful execution engine for plan steps.
- * The engine is the commit point for executing actions from a plan.
- */
-export async function* executePlan(input) {
-    const policy = {
-        ...DEFAULT_POLICY,
-        ...(input.policy ?? {}),
-    };
-    let trace = updateTrace(input.state, {
-        traceId: input.traceId,
-        state: "EXECUTING",
-        plan: input.plan,
-        error: undefined,
-    });
-    yield toExecutionEvent(trace);
-    try {
-        for (const step of input.plan.steps) {
-            trace = updateTrace(input.state, {
-                state: "EXECUTING",
-                currentStepId: step.id,
-                error: undefined,
-            });
-            yield toExecutionEvent(trace);
-            yield* executeStep(step, input, policy);
-            if (hasPendingApprovals(input.state)) {
-                trace = updateTrace(input.state, {
-                    state: "WAITING_APPROVAL",
-                    currentStepId: step.id,
-                });
-                yield toExecutionEvent(trace);
-                return;
-            }
-        }
-        trace = updateTrace(input.state, {
-            state: "COMPLETED",
-            currentStepId: undefined,
-            error: undefined,
-        });
-        yield toExecutionEvent(trace);
-    }
-    catch (error) {
-        trace = updateTrace(input.state, {
-            state: "FAILED",
-            error: toError(error),
-        });
-        yield toExecutionEvent(trace);
-        throw error;
-    }
-}
-export function setExecutionState(state, patch) {
-    return updateTrace(state, patch);
-}
-export function executionStateEvent(trace) {
-    return toExecutionEvent(trace);
-}

package/dist/architecture/intent-classifier.js

@@ -1,26 +0,0 @@
-/**
- * Classifies user input into a routing intent.
- * Starts with deterministic rules; can later be upgraded to hybrid LLM+rules.
- */
-export function classifyIntent(input) {
-    const raw = input.content.trim();
-    if (!raw) {
-        return { type: "chat", confidence: 0.8 };
-    }
-    if (raw.startsWith("/") || raw.startsWith("@")) {
-        const firstSpace = raw.indexOf(" ");
-        const prefix = firstSpace === -1 ? raw.slice(1) : raw.slice(1, firstSpace);
-        if (input.knownAgents.has(prefix)) {
-            return {
-                type: "agent_direct",
-                confidence: 0.99,
-                targetAgent: prefix,
-            };
-        }
-    }
-    const looksLikeTask = /\b(create|build|write|fix|update|implement|run|execute|open|edit|delete|list)\b/i.test(raw);
-    if (looksLikeTask) {
-        return { type: "task", confidence: 0.75 };
-    }
-    return { type: "chat", confidence: 0.7 };
-}

package/dist/architecture/planner.js

@@ -1,106 +0,0 @@
-import { generateObject } from "ai";
-import { z } from "zod";
-function createStepId(index) {
-    return `step_${index + 1}`;
-}
-/**
- * Strategic planner that emits explicit executable steps.
- * Initial version is deterministic to keep behavior predictable.
- */
-const PlanStepSchema = z.object({
-    id: z.string(),
-    kind: z.enum(["delegate", "manager"]),
-    successCriteria: z.string(),
-    agent: z.string().optional(),
-    task: z.string().optional(),
-    content: z.string().optional(),
-});
-const PlanSchema = z.object({
-    goal: z.string(),
-    stopCondition: z.string(),
-    steps: z.array(PlanStepSchema).min(1).max(4),
-});
-function sanitizePlan(raw, input) {
-    const steps = raw.steps.map((step, index) => {
-        const normalized = {
-            id: step.id?.trim() ? step.id : createStepId(index),
-            kind: step.kind,
-            successCriteria: step.successCriteria?.trim() || "Step completed successfully.",
-        };
-        if (step.kind === "delegate") {
-            const chosenAgent = step.agent && input.knownAgents.includes(step.agent)
-                ? step.agent
-                : input.knownAgents[0];
-            normalized.agent = chosenAgent;
-            normalized.task = step.task?.trim() || input.content.trim();
-        }
-        else {
-            normalized.content = step.content?.trim() || input.content.trim();
-        }
-        return normalized;
-    });
-    if (steps[0]) {
-        steps[0].attachments = input.attachments;
-    }
-    return {
-        goal: raw.goal?.trim() || input.content || "Handle user request",
-        stopCondition: raw.stopCondition?.trim() || "All plan steps completed successfully.",
-        steps,
-    };
-}
-function buildDeterministicPlan(input) {
-    const steps = [];
-    const content = input.content.trim();
-    const attachments = input.attachments;
-    if (input.intent.type === "agent_direct" && input.intent.targetAgent) {
-        const firstSpace = content.indexOf(" ");
-        const delegatedTask = firstSpace === -1 ? "" : content.slice(firstSpace + 1).trim();
-        steps.push({
-            id: createStepId(0),
-            kind: "delegate",
-            agent: input.intent.targetAgent,
-            task: delegatedTask,
-            attachments,
-            successCriteria: "Agent returns an output event.",
-        });
-    }
-    else {
-        steps.push({
-            id: createStepId(0),
-            kind: "manager",
-            content,
-            attachments,
-            successCriteria: "Manager emits a completion message.",
-        });
-    }
-    return {
-        goal: content || "Handle user request",
-        steps,
-        stopCondition: "All plan steps completed successfully.",
-    };
-}
-export async function createPlan(input, options = {}) {
-    if (input.intent.type === "agent_direct") {
-        return buildDeterministicPlan(input);
-    }
-    if (!options.model) {
-        return buildDeterministicPlan(input);
-    }
-    try {
-        const { object } = await generateObject({
-            model: options.model,
-            schema: PlanSchema,
-            system: `You are a strategic planner for an AI orchestration system.
-Output compact, executable plans.
-Available agents: ${input.knownAgents.join(", ") || "none"}.
-Use "delegate" only when an agent is clearly needed; otherwise use "manager".`,
-            prompt: `Intent: ${JSON.stringify(input.intent)}
-User request: ${input.content}
-Return a plan with 1-4 steps.`,
-        });
-        return sanitizePlan(object, input);
-    }
-    catch {
-        return buildDeterministicPlan(input);
-    }
-}

package/dist/automation-worker.js

@@ -1,121 +0,0 @@
-function minuteKey(date) {
-    return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}T${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
-}
-function parseNumber(value) {
-    if (!/^\d+$/.test(value))
-        return null;
-    return Number(value);
-}
-function matchToken(value, token, min, max) {
-    const [base, stepRaw] = token.split("/");
-    const step = stepRaw ? parseNumber(stepRaw) : null;
-    if (stepRaw && (!step || step <= 0))
-        return false;
-    const checkStep = (start) => {
-        if (!step)
-            return true;
-        return (value - start) % step === 0;
-    };
-    if (base === "*") {
-        return checkStep(min);
-    }
-    if (base.includes("-")) {
-        const [startRaw, endRaw] = base.split("-");
-        const start = parseNumber(startRaw);
-        const end = parseNumber(endRaw);
-        if (start === null || end === null || start < min || end > max || start > end)
-            return false;
-        if (value < start || value > end)
-            return false;
-        return checkStep(start);
-    }
-    const exact = parseNumber(base);
-    if (exact === null || exact < min || exact > max)
-        return false;
-    if (value !== exact)
-        return false;
-    return checkStep(exact);
-}
-function matchField(value, field, min, max) {
-    const tokens = field.split(",").map((t) => t.trim()).filter(Boolean);
-    if (tokens.length === 0)
-        return false;
-    return tokens.some((token) => matchToken(value, token, min, max));
-}
-export function isCronDue(cron, date) {
-    const fields = cron.trim().split(/\s+/);
-    if (fields.length !== 5)
-        return false;
-    const [minuteField, hourField, domField, monthField, dowField] = fields;
-    const minute = date.getMinutes();
-    const hour = date.getHours();
-    const dayOfMonth = date.getDate();
-    const month = date.getMonth() + 1;
-    const dayOfWeek = date.getDay();
-    const minuteMatch = matchField(minute, minuteField, 0, 59);
-    const hourMatch = matchField(hour, hourField, 0, 23);
-    const monthMatch = matchField(month, monthField, 1, 12);
-    const domMatch = matchField(dayOfMonth, domField, 1, 31);
-    const dowMatch = matchField(dayOfWeek, dowField, 0, 7) || (dayOfWeek === 0 && matchField(7, dowField, 0, 7));
-    const domWildcard = domField.trim() === "*";
-    const dowWildcard = dowField.trim() === "*";
-    const dayMatch = domWildcard && dowWildcard
-        ? true
-        : domWildcard
-            ? dowMatch
-            : dowWildcard
-                ? domMatch
-                : domMatch || dowMatch;
-    return minuteMatch && hourMatch && monthMatch && dayMatch;
-}
-export function startAutomationWorker(options) {
-    const { listAutomations, runAutomation, pollIntervalMs = 60000, logger = console, } = options;
-    const inFlightByAutomation = new Set();
-    const seenMinuteByAutomation = new Map();
-    let polling = false;
-    const tick = async () => {
-        if (polling)
-            return;
-        polling = true;
-        try {
-            const now = new Date();
-            const currentMinute = minuteKey(now);
-            const automations = await listAutomations();
-            for (const automation of automations) {
-                if (!automation.enabled)
-                    continue;
-                if (inFlightByAutomation.has(automation.id))
-                    continue;
-                if (seenMinuteByAutomation.get(automation.id) === currentMinute)
-                    continue;
-                const due = isCronDue(automation.cron, now);
-                if (!due)
-                    continue;
-                seenMinuteByAutomation.set(automation.id, currentMinute);
-                inFlightByAutomation.add(automation.id);
-                void runAutomation(automation, new Date(now))
-                    .catch((err) => {
-                    logger.error(`[automations] Failed run for "${automation.name}" (${automation.id}):`, err);
-                })
-                    .finally(() => {
-                    inFlightByAutomation.delete(automation.id);
-                });
-            }
-        }
-        catch (err) {
-            logger.error("[automations] Worker tick failed:", err);
-        }
-        finally {
-            polling = false;
-        }
-    };
-    const interval = setInterval(() => {
-        void tick();
-    }, pollIntervalMs);
-    logger.info(`[automations] Worker started (poll interval ${pollIntervalMs}ms)`);
-    void tick();
-    return () => {
-        clearInterval(interval);
-        logger.info("[automations] Worker stopped");
-    };
-}