neuron-inspector 0.8.1 → 1.1.0

package/dist/monitor.js

@@ -1,53 +1,46 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import * as os from "node:os";
 import YAML from "yaml";
-const NEURON_DIR = path.join(os.homedir(), ".neuron");
-const MONITORS_FILE = path.join(NEURON_DIR, "monitors.yaml");
-const ALERTS_FILE = path.join(NEURON_DIR, "monitor-alerts.yaml");
+import { NEURON_DIR, ensureNeuronDir } from "./paths.js";
 const MAX_ALERTS = 100;
 const activeIntervals = new Map();
-function ensureNeuronDir() {
-    if (!fs.existsSync(NEURON_DIR)) {
-        fs.mkdirSync(NEURON_DIR, { recursive: true });
-    }
-}
 function monitorsPath() {
-    return MONITORS_FILE;
+    return path.join(NEURON_DIR, "monitors.yaml");
 }
 function alertsPath() {
-    return ALERTS_FILE;
+    return path.join(NEURON_DIR, "monitor-alerts.yaml");
 }
-function loadMonitors() {
+export function loadMonitors() {
     ensureNeuronDir();
-    if (!fs.existsSync(MONITORS_FILE)) {
+    if (!fs.existsSync(monitorsPath())) {
         return [];
     }
-    const content = fs.readFileSync(MONITORS_FILE, "utf-8");
+    const content = fs.readFileSync(monitorsPath(), "utf-8");
     const store = YAML.parse(content);
     return store?.monitors || [];
 }
-function saveMonitors(monitors) {
+export function saveMonitors(monitors) {
     ensureNeuronDir();
     const store = { monitors };
-    fs.writeFileSync(MONITORS_FILE, YAML.stringify(store), "utf-8");
+    fs.writeFileSync(monitorsPath(), YAML.stringify(store), "utf-8");
 }
 function loadAlerts() {
     ensureNeuronDir();
-    if (!fs.existsSync(ALERTS_FILE)) {
+    if (!fs.existsSync(alertsPath())) {
         return [];
     }
-    const content = fs.readFileSync(ALERTS_FILE, "utf-8");
+    const content = fs.readFileSync(alertsPath(), "utf-8");
     const store = YAML.parse(content);
-    return store?.alerts || [];
+    const alerts = store?.alerts || [];
+    return alerts.length > MAX_ALERTS ? alerts.slice(-MAX_ALERTS) : alerts;
 }
 function saveAlerts(alerts) {
     ensureNeuronDir();
     const trimmed = alerts.slice(-MAX_ALERTS);
     const store = { alerts: trimmed };
-    fs.writeFileSync(ALERTS_FILE, YAML.stringify(store), "utf-8");
+    fs.writeFileSync(alertsPath(), YAML.stringify(store), "utf-8");
 }
-function addAlert(alert) {
+export function addAlert(alert) {
     const alerts = loadAlerts();
     alerts.push(alert);
     saveAlerts(alerts);
@@ -55,23 +48,187 @@ function addAlert(alert) {
 function generateId() {
     return `mon_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
 }
-async function checkMonitor(monitor, checkFn) {
+export async function executeMonitorActions(actions, ctx, tabId, triggerData, monitorUrl) {
+    const results = [];
+    // Browser actions need a tab — open one if not provided
+    const browserActions = new Set(["click", "type", "navigate", "scroll", "screenshot", "extract", "evaluate"]);
+    let resolvedTabId = tabId;
+    for (const action of actions) {
+        const start = Date.now();
+        try {
+            // Lazy-open a tab for the first browser action that needs one
+            if (browserActions.has(action.type) && resolvedTabId === undefined) {
+                const url = monitorUrl || triggerData.url;
+                if (!url)
+                    throw new Error("No URL available to open a tab for browser action");
+                const tab = (await ctx.pending.call(ctx.ws, "openTab", { url }, 30_000));
+                resolvedTabId = tab?.tabId;
+                if (!resolvedTabId)
+                    throw new Error("Failed to open tab for monitor action");
+                await new Promise((r) => setTimeout(r, 3000));
+            }
+            let result;
+            switch (action.type) {
+                case "click": {
+                    const args = { tabId: resolvedTabId };
+                    if (action.config.selector)
+                        args.selectors = [action.config.selector];
+                    if (action.config.text)
+                        args.texts = [action.config.text];
+                    result = await ctx.pending.call(ctx.ws, "clickElement", args, 15_000);
+                    break;
+                }
+                case "type": {
+                    const args = {
+                        tabId: resolvedTabId,
+                        selectors: [action.config.selector],
+                        value: action.config.value,
+                    };
+                    result = await ctx.pending.call(ctx.ws, "typeText", args, 15_000);
+                    break;
+                }
+                case "navigate": {
+                    result = await ctx.pending.call(ctx.ws, "navigateTo", { tabId: resolvedTabId, url: action.config.url }, 30_000);
+                    // Wait for load
+                    await new Promise((r) => setTimeout(r, 2000));
+                    break;
+                }
+                case "scroll": {
+                    const args = {
+                        tabId: resolvedTabId,
+                        deltaY: action.config.pixels || 600,
+                        smooth: true,
+                    };
+                    result = await ctx.pending.call(ctx.ws, "scrollPage", args, 10_000);
+                    break;
+                }
+                case "evaluate": {
+                    result = await ctx.pending.call(ctx.ws, "evaluateJS", {
+                        tabId: resolvedTabId,
+                        expression: action.config.expression,
+                    }, 15_000);
+                    break;
+                }
+                case "screenshot": {
+                    result = await ctx.pending.call(ctx.ws, "takeScreenshot", { tabId: resolvedTabId }, 15_000);
+                    break;
+                }
+                case "extract": {
+                    const args = { tabId: resolvedTabId };
+                    if (action.config.selector)
+                        args.selector = action.config.selector;
+                    result = await ctx.pending.call(ctx.ws, "extractData", args, 15_000);
+                    break;
+                }
+                case "webhook": {
+                    const url = action.config.url;
+                    const method = action.config.method || "POST";
+                    const customBody = action.config.body;
+                    const customHeaders = action.config.headers;
+                    const headers = {
+                        "Content-Type": "application/json",
+                        ...customHeaders,
+                    };
+                    const body = customBody || JSON.stringify(triggerData);
+                    const res = await fetch(url, { method, headers, body });
+                    result = { status: res.status, statusText: res.statusText };
+                    break;
+                }
+                default:
+                    throw new Error(`Unknown action type: ${action.type}`);
+            }
+            results.push({
+                action_id: action.id,
+                type: action.type,
+                status: "success",
+                duration_ms: Date.now() - start,
+                result,
+            });
+        }
+        catch (err) {
+            results.push({
+                action_id: action.id,
+                type: action.type,
+                status: "failed",
+                duration_ms: Date.now() - start,
+                error: err.message,
+            });
+            if (action.on_error !== "continue") {
+                break; // stop chain
+            }
+        }
+    }
+    return results;
+}
+async function checkMonitor(monitor, checkFn, ctx) {
     try {
-        const result = await checkFn(monitor.url, monitor.condition.selector);
         const { condition } = monitor;
+        // ── Buffer-based conditions (no tab needed) ──────────────
+        if (condition.type === "request_match") {
+            if (!ctx)
+                throw new Error("request_match requires bridge context");
+            const filters = {
+                sinceMs: monitor.last_check_at ? new Date(monitor.last_check_at).getTime() : Date.now() - monitor.check_interval_minutes * 60_000,
+                limit: 200,
+            };
+            if (condition.urlPattern)
+                filters.urlPattern = condition.urlPattern;
+            if (condition.method)
+                filters.method = condition.method;
+            if (condition.statusMin != null)
+                filters.statusMin = condition.statusMin;
+            if (condition.statusMax != null)
+                filters.statusMax = condition.statusMax;
+            const result = await ctx.pending.call(ctx.ws, "getRecentRequests", filters, 15_000);
+            const requests = Array.isArray(result) ? result : result.requests || [];
+            if (requests.length > 0) {
+                return {
+                    triggered: true,
+                    details: `${requests.length} request(s) matched (${condition.urlPattern || "all"}${condition.statusMin ? ` status>=${condition.statusMin}` : ""}${condition.statusMax ? ` status<=${condition.statusMax}` : ""})`,
+                    currentValue: JSON.stringify(requests.slice(0, 5)),
+                };
+            }
+            return { triggered: false };
+        }
+        if (condition.type === "console_match") {
+            if (!ctx)
+                throw new Error("console_match requires bridge context");
+            const filters = {
+                sinceMs: monitor.last_check_at ? new Date(monitor.last_check_at).getTime() : Date.now() - monitor.check_interval_minutes * 60_000,
+                limit: 200,
+            };
+            if (condition.search)
+                filters.search = condition.search;
+            if (condition.levels?.length)
+                filters.levels = condition.levels;
+            const result = await ctx.pending.call(ctx.ws, "getRecentLogs", filters, 15_000);
+            const logs = Array.isArray(result) ? result : result.logs || [];
+            if (logs.length > 0) {
+                return {
+                    triggered: true,
+                    details: `${logs.length} console message(s) matched (${condition.search || "all"}${condition.levels?.length ? ` levels=${condition.levels.join(",")}` : ""})`,
+                    currentValue: JSON.stringify(logs.slice(0, 5)),
+                };
+            }
+            return { triggered: false };
+        }
+        // ── Page-based conditions (open tab, extract) ────────────
+        const result = await checkFn(monitor.url, monitor.condition.selector);
+        const tabId = result.tabId;
         switch (condition.type) {
             case "content_change": {
                 if (!condition.baseline) {
-                    return { triggered: false, currentValue: result.text };
+                    return { triggered: false, currentValue: result.text, tabId };
                 }
                 if (result.text !== condition.baseline) {
                     return {
                         triggered: true,
                         details: "Content changed",
                         currentValue: result.text,
+                        tabId,
                     };
                 }
-                return { triggered: false };
+                return { triggered: false, tabId };
             }
             case "text_appears": {
                 if (!condition.text) {
@@ -82,25 +239,27 @@ async function checkMonitor(monitor, checkFn) {
                         triggered: true,
                         details: `Text "${condition.text}" appeared on page`,
                         currentValue: result.text,
+                        tabId,
                     };
                 }
-                return { triggered: false };
+                return { triggered: false, tabId };
             }
             case "text_disappears": {
                 if (!condition.text) {
                     throw new Error("text_disappears condition requires 'text' parameter");
                 }
                 if (!condition.baseline) {
-                    return { triggered: false, currentValue: result.text };
+                    return { triggered: false, currentValue: result.text, tabId };
                 }
                 if (condition.baseline.includes(condition.text) && !result.text.includes(condition.text)) {
                     return {
                         triggered: true,
                         details: `Text "${condition.text}" disappeared from page`,
                         currentValue: result.text,
+                        tabId,
                     };
                 }
-                return { triggered: false };
+                return { triggered: false, tabId };
             }
             case "price_below": {
                 if (condition.threshold === undefined) {
@@ -114,14 +273,15 @@ async function checkMonitor(monitor, checkFn) {
                             triggered: true,
                             details: `Price ${price} is below threshold ${condition.threshold}`,
                             currentValue: price.toString(),
+                            tabId,
                         };
                     }
                 }
-                return { triggered: false };
+                return { triggered: false, tabId };
             }
             case "new_items": {
                 if (!condition.baseline) {
-                    return { triggered: false, currentValue: JSON.stringify(result.items || []) };
+                    return { triggered: false, currentValue: JSON.stringify(result.items || []), tabId };
                 }
                 const baselineItems = JSON.parse(condition.baseline);
                 const currentItems = result.items || [];
@@ -130,25 +290,27 @@ async function checkMonitor(monitor, checkFn) {
                         triggered: true,
                         details: `New items detected: ${currentItems.length - baselineItems.length} added`,
                         currentValue: JSON.stringify(currentItems),
+                        tabId,
                     };
                 }
-                return { triggered: false };
+                return { triggered: false, tabId };
             }
             case "selector_change": {
                 if (!condition.selector) {
                     throw new Error("selector_change condition requires 'selector' parameter");
                 }
                 if (!condition.baseline) {
-                    return { triggered: false, currentValue: result.text };
+                    return { triggered: false, currentValue: result.text, tabId };
                 }
                 if (result.text !== condition.baseline) {
                     return {
                         triggered: true,
                         details: "Selector content changed",
                         currentValue: result.text,
+                        tabId,
                     };
                 }
-                return { triggered: false };
+                return { triggered: false, tabId };
             }
             default:
                 throw new Error(`Unknown condition type: ${condition.type}`);
@@ -159,8 +321,8 @@ async function checkMonitor(monitor, checkFn) {
         return { triggered: false };
     }
 }
-async function runMonitorCheck(monitor, checkFn) {
-    const checkResult = await checkMonitor(monitor, checkFn);
+async function runMonitorCheck(monitor, checkFn, actionFn, closeTabFn, ctx) {
+    const checkResult = await checkMonitor(monitor, checkFn, ctx);
     const monitors = loadMonitors();
     const monitorIndex = monitors.findIndex((m) => m.id === monitor.id);
     if (monitorIndex === -1)
@@ -182,6 +344,29 @@ async function runMonitorCheck(monitor, checkFn) {
             previous_value: monitor.condition.baseline,
             current_value: checkResult.currentValue,
         };
+        // Execute actions if defined — tabId may be undefined for buffer-based conditions
+        if (monitor.actions?.length && actionFn) {
+            try {
+                const actionResults = await actionFn(monitor.actions, checkResult.tabId, {
+                    monitor_name: monitor.name,
+                    monitor_id: monitor.id,
+                    url: monitor.url,
+                    condition_type: monitor.condition.type,
+                    triggered_at: alert.triggered_at,
+                    details: alert.details,
+                    previous_value: alert.previous_value,
+                    current_value: alert.current_value,
+                });
+                alert.action_results = actionResults;
+                const failed = actionResults.filter((r) => r.status === "failed");
+                if (failed.length > 0) {
+                    console.error(`[MONITOR ACTIONS] ${monitor.name}: ${failed.length}/${actionResults.length} action(s) failed`);
+                }
+            }
+            catch (err) {
+                console.error(`[MONITOR ACTIONS] ${monitor.name}: action execution error:`, err);
+            }
+        }
         addAlert(alert);
         console.error(`[MONITOR ALERT] ${monitor.name}: ${alert.details}`);
         if (checkResult.currentValue) {
@@ -192,8 +377,15 @@ async function runMonitorCheck(monitor, checkFn) {
         monitors[monitorIndex].last_result = "no_change";
     }
     saveMonitors(monitors);
+    // Close the tab after actions are done (if the check opened one)
+    if (checkResult.tabId && closeTabFn) {
+        try {
+            await closeTabFn(checkResult.tabId);
+        }
+        catch { /* ok */ }
+    }
 }
-export function startMonitor(checkFn) {
+export function startMonitor(checkFn, actionFn, closeTabFn, getCtx) {
     for (const interval of activeIntervals.values()) {
         clearInterval(interval);
     }
@@ -210,12 +402,12 @@ export function startMonitor(checkFn) {
         const delay = (i + 1) * STAGGER_MS;
         const timeout = setTimeout(() => {
             // First check after the staggered delay
-            runMonitorCheck(monitor, checkFn).catch((err) => {
+            runMonitorCheck(monitor, checkFn, actionFn, closeTabFn, getCtx?.()).catch((err) => {
                 console.error(`Error running monitor ${monitor.id}:`, err);
             });
             // Then schedule the repeating interval
             const interval = setInterval(() => {
-                runMonitorCheck(monitor, checkFn).catch((err) => {
+                runMonitorCheck(monitor, checkFn, actionFn, closeTabFn, getCtx?.()).catch((err) => {
                     console.error(`Error running monitor ${monitor.id}:`, err);
                 });
             }, intervalMs);
@@ -229,7 +421,7 @@ export function startMonitor(checkFn) {
         console.error(`[monitor] Scheduled ${enabled.length} monitor(s), staggered over ${(enabled.length * STAGGER_MS / 1000)}s`);
     }
 }
-export async function handleMonitorTool(name, args, checkFn) {
+export async function handleMonitorTool(name, args, checkFn, actionFn, closeTabFn, getCtx) {
     switch (name) {
         case "neuron_monitor_create": {
             const url = args.url;
@@ -237,15 +429,21 @@ export async function handleMonitorTool(name, args, checkFn) {
             const checkIntervalMinutes = args.check_interval_minutes || 60;
             const condition = args.condition;
             const enabled = args.enabled !== undefined ? args.enabled : true;
-            if (!url || !monitorName || !condition) {
-                throw new Error("Missing required parameters: url, name, condition");
+            const actions = args.actions;
+            if (!monitorName || !condition) {
+                throw new Error("Missing required parameters: name, condition");
+            }
+            const isBufferBased = condition.type === "request_match" || condition.type === "console_match";
+            if (!isBufferBased && !url) {
+                throw new Error("URL is required for page-based conditions");
             }
             const monitor = {
                 id: generateId(),
-                url,
+                url: url || "",
                 name: monitorName,
                 check_interval_minutes: checkIntervalMinutes,
                 condition,
+                actions,
                 enabled,
                 created_at: new Date().toISOString(),
                 alert_count: 0,
@@ -256,15 +454,17 @@ export async function handleMonitorTool(name, args, checkFn) {
             if (enabled && checkFn) {
                 const intervalMs = checkIntervalMinutes * 60 * 1000;
                 const interval = setInterval(() => {
-                    runMonitorCheck(monitor, checkFn).catch((err) => {
+                    runMonitorCheck(monitor, checkFn, actionFn, closeTabFn, getCtx?.()).catch((err) => {
                         console.error(`Error running monitor ${monitor.id}:`, err);
                     });
                 }, intervalMs);
                 activeIntervals.set(monitor.id, interval);
             }
+            const bridgePort = parseInt(process.env.NEURON_BRIDGE_PORT ?? "7377", 10);
             return {
                 success: true,
                 monitor_id: monitor.id,
+                webhook_url: `http://127.0.0.1:${bridgePort}/hooks/${monitor.id}`,
                 message: `Monitor "${monitorName}" created successfully`,
             };
         }
@@ -329,7 +529,7 @@ export async function handleMonitorTool(name, args, checkFn) {
                 if (!monitor) {
                     throw new Error(`Monitor ${monitorId} not found`);
                 }
-                await runMonitorCheck(monitor, checkFn);
+                await runMonitorCheck(monitor, checkFn, actionFn, closeTabFn, getCtx?.());
                 const updated = loadMonitors().find((m) => m.id === monitorId);
                 return {
                     monitor_id: monitorId,
@@ -342,7 +542,7 @@ export async function handleMonitorTool(name, args, checkFn) {
                 const results = [];
                 for (const monitor of monitors) {
                     if (monitor.enabled) {
-                        await runMonitorCheck(monitor, checkFn);
+                        await runMonitorCheck(monitor, checkFn, actionFn, closeTabFn, getCtx?.());
                         const updated = loadMonitors().find((m) => m.id === monitor.id);
                         results.push({
                             monitor_id: monitor.id,
@@ -390,6 +590,9 @@ export async function handleMonitorTool(name, args, checkFn) {
                 const newCond = args.condition;
                 monitor.condition = { ...monitor.condition, ...newCond };
             }
+            if (args.actions !== undefined) {
+                monitor.actions = args.actions;
+            }
             saveMonitors(monitors);
             // Restart interval if interval or enabled changed
             const existingInterval = activeIntervals.get(monitorId);
@@ -401,7 +604,7 @@ export async function handleMonitorTool(name, args, checkFn) {
                 const intervalMs = monitor.check_interval_minutes * 60 * 1000;
                 const m = monitor;
                 const interval = setInterval(() => {
-                    runMonitorCheck(m, checkFn).catch((err) => {
+                    runMonitorCheck(m, checkFn, actionFn, closeTabFn, getCtx?.()).catch((err) => {
                         console.error(`Error running monitor ${m.id}:`, err);
                     });
                 }, intervalMs);
@@ -417,6 +620,7 @@ export async function handleMonitorTool(name, args, checkFn) {
                     enabled: monitor.enabled,
                     check_interval_minutes: monitor.check_interval_minutes,
                     condition: monitor.condition,
+                    actions: monitor.actions,
                 },
             };
         }
@@ -443,7 +647,7 @@ export async function handleMonitorTool(name, args, checkFn) {
                 const intervalMs = monitors[idx].check_interval_minutes * 60 * 1000;
                 const m = monitors[idx];
                 const interval = setInterval(() => {
-                    runMonitorCheck(m, checkFn).catch((err) => {
+                    runMonitorCheck(m, checkFn, actionFn, closeTabFn, getCtx?.()).catch((err) => {
                         console.error(`Error running monitor ${m.id}:`, err);
                     });
                 }, intervalMs);
@@ -461,13 +665,13 @@ export async function handleMonitorTool(name, args, checkFn) {
 export const MONITOR_TOOLS = [
     {
         name: "neuron_monitor_create",
-        description: "Create a persistent page monitor that watches a URL for changes and alerts when conditions are met (price drops, new job postings, content changes). Monitors run in the background at specified intervals.",
+        description: "Create a persistent monitor that watches a URL for changes, matches HTTP traffic patterns, or watches console messages. Monitors run in the background at specified intervals. Page-based conditions (content_change, text_appears, etc.) require a URL. Buffer-based conditions (request_match, console_match) query the extension's ring buffers directly without opening a tab.",
         inputSchema: {
             type: "object",
             properties: {
                 url: {
                     type: "string",
-                    description: "The URL to monitor",
+                    description: "The URL to monitor. Required for page-based conditions, optional for request_match/console_match",
                 },
                 name: {
                     type: "string",
@@ -475,7 +679,7 @@ export const MONITOR_TOOLS = [
                 },
                 check_interval_minutes: {
                     type: "number",
-                    description: "How often to check the page (in minutes). Default: 60",
+                    description: "How often to check (in minutes). Default: 60",
                     default: 60,
                 },
                 condition: {
@@ -491,8 +695,10 @@ export const MONITOR_TOOLS = [
                                 "price_below",
                                 "new_items",
                                 "selector_change",
+                                "request_match",
+                                "console_match",
                             ],
-                            description: "Type of condition: content_change (any change), text_appears, text_disappears, price_below (numeric comparison), new_items (list growth), selector_change (specific element change)",
+                            description: "Type of condition: content_change (any change), text_appears, text_disappears, price_below (numeric comparison), new_items (list growth), selector_change (specific element change), request_match (HTTP requests in ring buffers), console_match (console messages in ring buffers)",
                         },
                         selector: {
                             type: "string",
@@ -506,6 +712,31 @@ export const MONITOR_TOOLS = [
                             type: "number",
                             description: "Numeric threshold for price_below condition",
                         },
+                        urlPattern: {
+                            type: "string",
+                            description: "URL substring to match for request_match condition",
+                        },
+                        method: {
+                            type: "string",
+                            description: "HTTP method filter for request_match (e.g. GET, POST)",
+                        },
+                        statusMin: {
+                            type: "number",
+                            description: "Minimum HTTP status code for request_match (e.g. 400)",
+                        },
+                        statusMax: {
+                            type: "number",
+                            description: "Maximum HTTP status code for request_match (e.g. 599)",
+                        },
+                        search: {
+                            type: "string",
+                            description: "Substring to search in console messages for console_match",
+                        },
+                        levels: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Console log levels to match for console_match (e.g. [\"error\", \"warn\"])",
+                        },
                     },
                     required: ["type"],
                 },
@@ -514,8 +745,34 @@ export const MONITOR_TOOLS = [
                     description: "Whether the monitor is active. Default: true",
                     default: true,
                 },
+                actions: {
+                    type: "array",
+                    description: "Actions to execute when the condition triggers. Each action runs in sequence; chain stops on first failure unless on_error is 'continue'.",
+                    items: {
+                        type: "object",
+                        properties: {
+                            id: { type: "string", description: "Unique action ID" },
+                            type: {
+                                type: "string",
+                                enum: ["click", "type", "navigate", "scroll", "evaluate", "screenshot", "extract", "webhook"],
+                                description: "Action type to execute",
+                            },
+                            config: {
+                                type: "object",
+                                description: "Action-specific configuration. click: {selector, text}. type: {selector, value}. navigate: {url}. scroll: {pixels}. evaluate: {expression}. screenshot: {}. extract: {selector}. webhook: {url, method}.",
+                            },
+                            on_error: {
+                                type: "string",
+                                enum: ["stop", "continue"],
+                                description: "What to do if this action fails. Default: stop",
+                            },
+                            label: { type: "string", description: "Human-readable label for this action" },
+                        },
+                        required: ["id", "type", "config"],
+                    },
+                },
             },
-            required: ["url", "name", "condition"],
+            required: ["name", "condition"],
         },
     },
     {
@@ -613,17 +870,38 @@ export const MONITOR_TOOLS = [
                     properties: {
                         type: {
                             type: "string",
-                            enum: ["content_change", "text_appears", "text_disappears", "price_below", "new_items", "selector_change"],
+                            enum: ["content_change", "text_appears", "text_disappears", "price_below", "new_items", "selector_change", "request_match", "console_match"],
                         },
                         selector: { type: "string" },
                         text: { type: "string" },
                         threshold: { type: "number" },
+                        urlPattern: { type: "string" },
+                        method: { type: "string" },
+                        statusMin: { type: "number" },
+                        statusMax: { type: "number" },
+                        search: { type: "string" },
+                        levels: { type: "array", items: { type: "string" } },
                     },
                 },
                 enabled: {
                     type: "boolean",
                     description: "Whether the monitor is active",
                 },
+                actions: {
+                    type: "array",
+                    description: "Replace the monitor's action chain. Same schema as neuron_monitor_create.",
+                    items: {
+                        type: "object",
+                        properties: {
+                            id: { type: "string" },
+                            type: { type: "string", enum: ["click", "type", "navigate", "scroll", "evaluate", "screenshot", "extract", "webhook"] },
+                            config: { type: "object" },
+                            on_error: { type: "string", enum: ["stop", "continue"] },
+                            label: { type: "string" },
+                        },
+                        required: ["id", "type", "config"],
+                    },
+                },
             },
             required: ["monitor_id"],
         },