@weavetab/plugin-realtime 0.0.0-stage → 0.3.0

package/dist/canvas.js

@@ -0,0 +1,179 @@
+import { run } from "./page.js";
+// recorder hooks CanvasRenderingContext2D.prototype and window.requestAnimationFrame.
+// draws are only kept while a rAF callback is running, that is what defines a frame.
+const SPY = `(() => {
+  if (window.__wt_cv) return 1;
+  const cv = window.__wt_cv = { frames: [], n: 0, cur: null, orig: {}, canvases: [], bg: 0, raf: window.requestAnimationFrame };
+  const P = CanvasRenderingContext2D.prototype;
+
+  const rec = (ctx, kind, key, x, y, w, h) => {
+    const m = ctx.getTransform();
+    const x1 = m.a * x + m.c * y + m.e, y1 = m.b * x + m.d * y + m.f;
+    const x2 = m.a * (x + w) + m.c * (y + h) + m.e, y2 = m.b * (x + w) + m.d * (y + h) + m.f;
+    let ci = cv.canvases.indexOf(ctx.canvas);
+    if (ci < 0) ci = cv.canvases.push(ctx.canvas) - 1;
+    const ww = Math.abs(x2 - x1), hh = Math.abs(y2 - y1);
+    cv.cur.push({ sig: kind + '|' + Math.round(ww) + 'x' + Math.round(hh) + '|' + key,
+      x: Math.min(x1, x2), y: Math.min(y1, y2), w: ww, h: hh, c: ci });
+  };
+  const styleKey = (s) => typeof s === 'string' ? s : 'grad';
+  const imgKey = (im) => {
+    const s = im.currentSrc || im.src;
+    return s ? s.split('?')[0].split('/').pop() : (im.id || im.tagName || 'bmp');
+  };
+  const wrap = (name, fn) => {
+    const o = P[name];
+    cv.orig[name] = o;
+    P[name] = function () {
+      const r = o.apply(this, arguments);
+      // the spy must never break the game's own draw call
+      try { if (cv.cur && this.canvas.isConnected && cv.cur.length < 2000) fn(this, arguments); } catch (e) {}
+      return r;
+    };
+  };
+
+  wrap('fillRect', (c, a) => rec(c, 'rect', styleKey(c.fillStyle), a[0], a[1], a[2], a[3]));
+  wrap('strokeRect', (c, a) => rec(c, 'frame', styleKey(c.strokeStyle), a[0], a[1], a[2], a[3]));
+  wrap('drawImage', (c, a) => {
+    const im = a[0], n = a.length;
+    if (n >= 9) rec(c, 'img', imgKey(im) + '@' + a[1] + ',' + a[2], a[5], a[6], a[7], a[8]);
+    else if (n >= 5) rec(c, 'img', imgKey(im), a[1], a[2], a[3], a[4]);
+    else rec(c, 'img', imgKey(im), a[1], a[2], im.naturalWidth || im.videoWidth || im.width || 0, im.naturalHeight || im.videoHeight || im.height || 0);
+  });
+  const text = (c, a) => {
+    const m = c.measureText(a[0]);
+    rec(c, 'text', String(a[0]).slice(0, 24), a[1], a[2] - m.actualBoundingBoxAscent, m.width, m.actualBoundingBoxAscent + m.actualBoundingBoxDescent);
+  };
+  wrap('fillText', text);
+  wrap('strokeText', text);
+  wrap('beginPath', (c) => { c.__wtp = []; });
+  wrap('arc', (c, a) => {
+    if (Math.abs(a[4] - a[3]) >= 6.2) (c.__wtp || (c.__wtp = [])).push([a[0], a[1], a[2]]);
+  });
+  const commit = (style) => (c) => {
+    for (const p of (c.__wtp || [])) rec(c, 'arc', styleKey(c[style]), p[0] - p[2], p[1] - p[2], p[2] * 2, p[2] * 2);
+    c.__wtp = [];
+  };
+  wrap('fill', commit('fillStyle'));
+  wrap('stroke', commit('strokeStyle'));
+
+  window.requestAnimationFrame = function (cb) {
+    return cv.raf.call(window, function (ts) {
+      cv.cur = [];
+      try { return cb(ts); } finally {
+        cv.frames.push({ t: ts, d: cv.cur });
+        if (cv.frames.length > 16) cv.frames.shift();
+        cv.cur = null;
+        cv.n++;
+      }
+    });
+  };
+
+  const matchSig = (pattern, s) => {
+    if (!pattern) return false;
+    if (pattern === '*' || pattern === true) return true;
+    if (Array.isArray(pattern)) return pattern.some((p) => matchSig(p, s));
+    if (typeof pattern !== 'string') return false;
+    if (pattern.indexOf('*') < 0) return s === pattern;
+    const parts = pattern.split('*');
+    if (!s.startsWith(parts[0])) return false;
+    if (!s.endsWith(parts[parts.length - 1])) return false;
+    let idx = 0;
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      if (!part) continue;
+      const found = s.indexOf(part, idx);
+      if (found < 0) return false;
+      idx = found + part.length;
+    }
+    return true;
+  };
+
+  cv.track = (sig, depth) => {
+    const fr = cv.frames;
+    if (!fr.length) return [];
+    const last = fr[fr.length - 1].d.filter((d) => matchSig(sig, d.sig));
+    if (last.length > 200) return last.map((d) => Object.assign({ vx: 0, vy: 0 }, d));
+    const prevs = fr.slice(Math.max(0, fr.length - 1 - (depth || 2)), -1).reverse().map((f) => f.d.filter((d) => matchSig(sig, d.sig)));
+    return last.map((d) => {
+      let cur = d, steps = 0;
+      for (const p of prevs) {
+        let best = null, bd = 1e9;
+        for (const q of p) {
+          const dd = (q.x - cur.x) * (q.x - cur.x) + (q.y - cur.y) * (q.y - cur.y);
+          if (dd < bd) { bd = dd; best = q; }
+        }
+        if (!best || bd > 40000) break;
+        cur = best; steps++;
+      }
+      return Object.assign({}, d, { vx: steps ? (d.x - cur.x) / steps : 0, vy: steps ? (d.y - cur.y) / steps : 0 });
+    });
+  };
+  return 0;
+})()`;
+const WAIT = (frames) => `new Promise((res) => {
+  const cv = window.__wt_cv, start = cv.n, t0 = performance.now();
+  const tick = () => (cv.n - start >= ${frames} || performance.now() - t0 > 3000) ? res(cv.n - start) : setTimeout(tick, 8);
+  tick();
+})`;
+const REPORT = `(() => {
+  const cv = window.__wt_cv;
+  const fr = cv.frames, last = fr[fr.length - 1];
+  const r1 = (v) => Math.round(v * 10) / 10;
+  const dt = fr.length > 1 ? fr[fr.length - 1].t - fr[0].t : 0;
+  const cans = [];
+  const info = (i) => {
+    let o = cans.find((c) => c.i === i);
+    if (!o) {
+      const el = cv.canvases[i], r = el.getBoundingClientRect();
+      o = { i, id: el.id || null, w: el.width, h: el.height, left: r.left, top: r.top, sx: r.width / el.width, sy: r.height / el.height };
+      cans.push(o);
+    }
+    return o;
+  };
+  const sigs = {};
+  for (const d of last.d) (sigs[d.sig] || (sigs[d.sig] = [])).push(d);
+  const ents = [], groups = [];
+  let bg = 0;
+  for (const sig of Object.keys(sigs).slice(0, 200)) {
+    const inst = sigs[sig];
+    const kind = sig.split('|')[0];
+    const tr = cv.track(sig, 5);
+    if (inst.length > 6) {
+      groups.push({ sig, count: inst.length, moving: tr.filter((t) => t.vx || t.vy).length });
+      continue;
+    }
+    for (const t of tr) {
+      const cn = info(t.c);
+      if ((kind === 'rect') && t.w >= cn.w * 0.9 && t.h >= cn.h * 0.9) { bg++; continue; }
+      ents.push({ sig, canvas: t.c, x: r1(t.x), y: r1(t.y), w: r1(t.w), h: r1(t.h), vx: r1(t.vx), vy: r1(t.vy) });
+    }
+  }
+  ents.sort((a, b) => (Math.abs(b.vx) + Math.abs(b.vy)) - (Math.abs(a.vx) + Math.abs(a.vy)));
+  return { frames: fr.length, fps: dt ? Math.round((fr.length - 1) * 1000 / dt) : null, canvases: cans,
+    entities: ents.slice(0, 40), groups: groups.slice(0, 20), background_fills: bg, truncated: ents.length > 40 };
+})()`;
+const OFF = `(() => {
+  const cv = window.__wt_cv;
+  if (!cv) return 0;
+  const P = CanvasRenderingContext2D.prototype;
+  for (const k of Object.keys(cv.orig)) P[k] = cv.orig[k];
+  window.requestAnimationFrame = cv.raf;
+  delete window.__wt_cv;
+  return 1;
+})()`;
+export async function canvasTool(sess, a) {
+    if (a.action === "detach")
+        return { detached: Boolean(await run(sess, OFF)) };
+    const fresh = (await run(sess, SPY)) === 0;
+    if (a.action === "attach")
+        return { attached: true, already: !fresh };
+    const want = Math.min(Math.max(a.frames ?? 6, 2), 15);
+    const got = await run(sess, WAIT(want), true);
+    if (!got)
+        throw new Error("no frames seen: tab hidden, or the game does not use requestAnimationFrame");
+    return run(sess, REPORT);
+}
+export function canvasSnap(sess) {
+    return run(sess, `window.__wt_cv && window.__wt_cv.frames.length ? ${REPORT} : null`);
+}

package/dist/causal.d.ts

@@ -0,0 +1 @@
+export declare function tagMap(sess: any, res: any, winMs: number): Promise<any>;

package/dist/causal.js

@@ -0,0 +1,72 @@
+import { run } from "./page.js";
+const LINE = /^(\s*)\[w:(\d+)\]/;
+function probeIds(ids, winMs) {
+    return `((ids, win) => {
+    const rt = window.__wt_rt;
+    if (!rt) return [];
+    const now = performance.now();
+    const clk = rt.click && now - rt.click.t < 15000 ? rt.click : null;
+    const out = [];
+    for (const id of ids) {
+      const el = document.querySelector('[data-wt-id="' + id + '"]');
+      if (!el) continue;
+      let b;
+      for (let n = el; n && b === undefined; n = n.parentElement) b = rt.born.get(n);
+      if (b === undefined || now - b > win) continue;
+      let dist = null;
+      if (clk) {
+        const r = el.getBoundingClientRect();
+        dist = Math.round(Math.hypot(r.left + r.width / 2 - clk.x, r.top + r.height / 2 - clk.y));
+      }
+      out.push([id, Math.round(now - b), dist]);
+    }
+    return out;
+  })(${JSON.stringify(ids)}, ${winMs})`;
+}
+async function tagText(sess, text, winMs) {
+    const lines = text.split("\n");
+    const ids = new Set();
+    for (const ln of lines) {
+        const m = LINE.exec(ln);
+        if (m)
+            ids.add(m[2]);
+    }
+    if (!ids.size)
+        return text;
+    const hits = await run(sess, probeIds([...ids], winMs));
+    if (!hits.length)
+        return text;
+    const byId = new Map(hits.map((h) => [h[0], h]));
+    return lines
+        .map((ln) => {
+        const m = LINE.exec(ln);
+        const h = m && byId.get(m[2]);
+        if (!h)
+            return ln;
+        return `${ln} {new ${h[1]}ms${h[2] == null ? "" : `, ${h[2]}px from click`}}`;
+    })
+        .join("\n");
+}
+// returns undefined when nothing changed so the pipeline keeps the original result
+export async function tagMap(sess, res, winMs) {
+    if (typeof res === "string") {
+        const t = await tagText(sess, res, winMs);
+        return t === res ? undefined : t;
+    }
+    if (!Array.isArray(res?.content))
+        return;
+    let touched = false;
+    const content = [];
+    for (const blk of res.content) {
+        if (blk?.type === "text" && typeof blk.text === "string") {
+            const t = await tagText(sess, blk.text, winMs);
+            if (t !== blk.text)
+                touched = true;
+            content.push({ ...blk, text: t });
+        }
+        else {
+            content.push(blk);
+        }
+    }
+    return touched ? { ...res, content } : undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export declare const realtimePlugin: import("@weavetab/sdk").WeavetabPluginDefinition;
+export default realtimePlugin;
+export declare const plugin: import("@weavetab/sdk").WeavetabPluginDefinition;

package/dist/index.js

@@ -0,0 +1,242 @@
+import { definePlugin, defineTool, defineCommand, definePrompt, defineResource, z, } from "@weavetab/sdk";
+import { sessOf, arm } from "./page.js";
+import { tagMap } from "./causal.js";
+import { canvasTool } from "./canvas.js";
+import { reflexTool, statusTool } from "./reflex.js";
+import { autopilotTool } from "./autopilot.js";
+import { readFeed } from "./surface.js";
+const statusCommand = defineCommand({
+    name: "status",
+    description: "Read the in-page realtime probe state, canvas frame counter, and active 60Hz reflex rules.",
+    usage: "weavetab plugin use realtime status [--wait_ms <ms>]",
+    requiresSession: true,
+    schema: {
+        wait_ms: z.number().optional().describe("Block up to wait_ms until active reflexes finish"),
+    },
+    handler: async (args, ctx) => {
+        const sess = sessOf(ctx);
+        return await statusTool(sess, Number(args.wait_ms || 0));
+    },
+});
+const reflexClearCommand = defineCommand({
+    name: "reflex-clear",
+    description: "Clear all active 60Hz reflex rules on the active browser tab via CLI.",
+    usage: "weavetab plugin use realtime reflex-clear",
+    requiresSession: true,
+    handler: async (_args, ctx) => {
+        const sess = sessOf(ctx);
+        return await reflexTool(sess, { action: "clear" });
+    },
+});
+const autopilotCommand = defineCommand({
+    name: "autopilot",
+    description: "Run bounded in-page autopilot toward a goal directly via CLI.",
+    usage: "weavetab plugin use realtime autopilot --goal <text> [--max_steps <n>]",
+    requiresSession: true,
+    schema: {
+        goal: z.string().describe("Natural language click goal"),
+        max_steps: z.number().optional().describe("Maximum click steps (default 5)"),
+        stop_when_text: z.string().optional().describe("Stop when this text appears"),
+    },
+    handler: async (args, ctx) => {
+        const sess = sessOf(ctx);
+        return await autopilotTool(sess, {
+            goal: args.goal,
+            max_steps: args.max_steps ?? 5,
+            stop_when_text: args.stop_when_text,
+        });
+    },
+});
+export const realtimePlugin = definePlugin({
+    name: "@weavetab/plugin-realtime",
+    version: "0.3.0",
+    description: "Causal age/proximity tags for browser_map, 60Hz in-page reflex rules, canvas entity sampling and a bounded click loop.",
+    agentsMd: "AGENTS.md",
+    defaultConfig: {
+        causalWindowMs: 4000,
+    },
+    permissions: {
+        cdp: {
+            evaluate: true,
+            input: true,
+            reason: "Installs the in-page MutationObserver, hooks Canvas2D/rAF, and dispatches click/key events.",
+        },
+        tools: {
+            add: true,
+            reason: "Registers realtime_canvas, realtime_reflex, realtime_autopilot, and realtime_status.",
+        },
+        commands: {
+            add: true,
+            reason: "Registers status and reflex-clear CLI commands.",
+        },
+        prompts: {
+            add: true,
+            reason: "Registers the /realtime_watch prompt utility.",
+        },
+        resources: {
+            add: true,
+            reason: "Registers the @realtime_feed resource utility.",
+        },
+        hooks: {
+            onBeforeAction: true,
+            onAfterAction: true,
+            reason: "Arms the in-page mutation probe before actions and tags newly added nodes in browser_map output.",
+        },
+        network: {
+            domains: ["127.0.0.1", "localhost"],
+            reason: "Allows realtime_autopilot to query an optional local OpenAI-compatible model endpoint.",
+        },
+    },
+    commands: [statusCommand, reflexClearCommand, autopilotCommand],
+    async onLoad(ctx) {
+        const winMs = typeof ctx.config?.causalWindowMs === "number" ? ctx.config.causalWindowMs : 4000;
+        ctx.cli?.registerCommand?.(statusCommand);
+        ctx.cli?.registerCommand?.(reflexClearCommand);
+        ctx.cli?.registerCommand?.(autopilotCommand);
+        ctx.mcp.registerTool(defineTool({
+            name: "realtime_canvas",
+            description: "Records Canvas2D draw calls across requestAnimationFrame ticks and returns moving/static entities with bounding boxes and px/frame velocity.",
+            requiresSession: true,
+            schema: {
+                action: z.enum(["sample", "attach", "detach"]).optional().describe("sample (default), attach, or detach"),
+                frames: z.number().optional().describe("Frames to sample (2-15, default 6)"),
+            },
+            handler: async (args, rawCtx) => {
+                const out = await canvasTool(sessOf(rawCtx), {
+                    action: args.action || "sample",
+                    frames: args.frames,
+                });
+                return { content: [{ type: "text", text: JSON.stringify(out, null, 2) }] };
+            },
+        }));
+        ctx.mcp.registerTool(defineTool({
+            name: "realtime_reflex",
+            description: "Registers, removes, lists, or clears in-page 60Hz requestAnimationFrame rules that click or press keys on DOM or Canvas2D triggers without an LLM round-trip.",
+            requiresSession: true,
+            schema: {
+                action: z.enum(["add", "remove", "list", "clear"]).describe("Operation to perform"),
+                id: z.string().optional().describe("Rule identifier"),
+                when: z
+                    .object({
+                    selector: z.string().optional(),
+                    text: z.string().optional(),
+                    only_new: z.boolean().optional(),
+                    enabled: z.boolean().optional(),
+                    canvas: z
+                        .object({
+                        names: z.record(z.string(), z.union([z.string(), z.array(z.string())])),
+                        js: z.string(),
+                    })
+                        .optional(),
+                })
+                    .optional(),
+                do: z
+                    .object({
+                    type: z.enum(["click", "click_xy", "key", "js"]),
+                    x: z.number().optional(),
+                    y: z.number().optional(),
+                    key: z.string().optional(),
+                    hold_ms: z.number().optional(),
+                    code: z.string().optional(),
+                })
+                    .optional(),
+                cooldown_ms: z.number().optional(),
+                max_hits: z.number().optional(),
+                ttl_ms: z.number().optional(),
+                stop_selector: z.string().optional(),
+            },
+            handler: async (args, rawCtx) => {
+                const out = await reflexTool(sessOf(rawCtx), args);
+                return { content: [{ type: "text", text: JSON.stringify(out, null, 2) }] };
+            },
+        }));
+        ctx.mcp.registerTool(defineTool({
+            name: "realtime_autopilot",
+            description: "Runs a bounded in-page click loop toward a short goal ('accept cookies', 'continue') with causal age/dialog scoring and optional local model pick.",
+            requiresSession: true,
+            schema: {
+                goal: z.string().describe("Short natural-language click goal"),
+                max_steps: z.number().optional(),
+                stop_when_selector: z.string().optional(),
+                stop_when_text: z.string().optional(),
+                stop_when_url: z.string().optional(),
+                avoid_labels: z.string().optional(),
+                model_url: z.string().optional(),
+                model: z.string().optional(),
+                model_timeout_ms: z.number().optional(),
+            },
+            handler: async (args, rawCtx) => {
+                const out = await autopilotTool(sessOf(rawCtx), args);
+                return { content: [{ type: "text", text: JSON.stringify(out, null, 2) }] };
+            },
+        }));
+        ctx.mcp.registerTool(defineTool({
+            name: "realtime_status",
+            description: "Returns the live state of the in-page probe, Canvas2D spy, and active 60Hz reflex rules. Optionally waits until reflexes complete.",
+            requiresSession: true,
+            schema: {
+                wait_ms: z.number().optional().describe("Wait up to wait_ms (max 30000) for active reflexes to finish"),
+            },
+            handler: async (args, rawCtx) => {
+                const out = await statusTool(sessOf(rawCtx), args.wait_ms ?? 0);
+                return { content: [{ type: "text", text: JSON.stringify(out, null, 2) }] };
+            },
+        }));
+        ctx.mcp.registerPrompt(definePrompt({
+            name: "realtime_watch",
+            description: "Snapshot live DOM mutations, active reflexes, and Canvas2D entities, then guide the agent to wire a 60Hz reflex rule.",
+            arguments: {
+                goal: z.string().describe("What the reflex should watch for and do"),
+                mode: z.enum(["auto", "dom", "canvas"]).optional().describe("Trigger mode (default: auto)"),
+            },
+            handler: async (args, rawCtx) => {
+                const feed = await readFeed(sessOf(rawCtx), winMs);
+                return [
+                    `Goal: ${args.goal}`,
+                    `Mode: ${args.mode || "auto"}`,
+                    `Live feed: ${JSON.stringify(feed)}`,
+                    `Use realtime_canvas, realtime_reflex, and realtime_status to arm and verify the rule.`,
+                ].join("\n");
+            },
+        }));
+        ctx.mcp.registerResource(defineResource({
+            name: "realtime_canvas_feed",
+            uri: "realtime://canvas",
+            description: "Live snapshot of Canvas2D draw counts, rAF frame rate, and active moving entity bounding boxes.",
+            mimeType: "application/json",
+            read: async (_uri, _vars, rawCtx) => {
+                const sess = sessOf(rawCtx);
+                const canvasData = await canvasTool(sess, { action: "sample", frames: 3 });
+                return JSON.stringify(canvasData, null, 2);
+            },
+        }));
+        ctx.mcp.registerResource(defineResource({
+            name: "realtime_feed",
+            uri: "realtime://feed",
+            description: "Live snapshot of newly mutated DOM elements (with click distance), active 60Hz reflex rules, and tracked Canvas2D entities.",
+            mimeType: "application/json",
+            read: async (_uri, _vars, rawCtx) => {
+                const feed = await readFeed(sessOf(rawCtx), winMs);
+                return JSON.stringify(feed, null, 2);
+            },
+        }));
+        ctx.logger?.info("@weavetab/plugin-realtime loaded");
+    },
+    async onBeforeAction(_action, _args, rawCtx) {
+        const sess = sessOf(rawCtx);
+        if (sess?.Runtime) {
+            await arm(sess).catch(() => { });
+        }
+    },
+    async onAfterAction(action, result, rawCtx) {
+        if (action !== "browser_map")
+            return;
+        const sess = sessOf(rawCtx);
+        if (!sess?.Runtime)
+            return;
+        const winMs = typeof rawCtx?.config?.causalWindowMs === "number" ? rawCtx.config.causalWindowMs : 4000;
+        return await tagMap(sess, result, winMs).catch(() => undefined);
+    },
+});
+export default realtimePlugin;
+export const plugin = realtimePlugin;

package/dist/page.d.ts

@@ -0,0 +1,3 @@
+export declare function sessOf(ctx: any): any;
+export declare function run(sess: any, expression: string, awaitPromise?: boolean): Promise<any>;
+export declare function arm(sess: any): Promise<any>;

package/dist/page.js

@@ -0,0 +1,33 @@
+// page-side probe shared by every tool in here. one per document, survives until navigation.
+const PROBE = `(() => {
+  if (window.__wt_rt) return 1;
+  const rt = window.__wt_rt = { born: new WeakMap(), click: null, lastMut: 0 };
+  new MutationObserver(recs => {
+    const now = performance.now();
+    for (const r of recs) {
+      if (r.type === 'childList') {
+        for (const n of r.addedNodes) if (n.nodeType === 1 && !rt.born.has(n)) rt.born.set(n, now);
+      }
+    }
+    rt.lastMut = now;
+  }).observe(document.documentElement, {
+    childList: true, subtree: true, characterData: true, attributes: true,
+    attributeFilter: ['class', 'hidden', 'aria-expanded', 'aria-hidden', 'open', 'disabled']
+  });
+  addEventListener('pointerdown', e => { rt.click = { x: e.clientX, y: e.clientY, t: performance.now() }; }, true);
+  return 0;
+})()`;
+export function sessOf(ctx) {
+    return ctx?.tab?.session || ctx?.session || ctx;
+}
+export async function run(sess, expression, awaitPromise = false) {
+    const out = await sess.Runtime.evaluate({ expression, returnByValue: true, awaitPromise });
+    if (out.exceptionDetails) {
+        const ex = out.exceptionDetails;
+        throw new Error(ex.exception?.description?.split("\n")[0] || ex.text || "page eval failed");
+    }
+    return out.result?.value;
+}
+export function arm(sess) {
+    return run(sess, PROBE);
+}

package/dist/reflex.d.ts

@@ -0,0 +1,29 @@
+type Rule = {
+    action: "add" | "remove" | "list" | "clear";
+    id?: string;
+    when?: {
+        selector?: string;
+        text?: string;
+        only_new?: boolean;
+        enabled?: boolean;
+        canvas?: {
+            names: Record<string, string | string[]>;
+            js: string;
+        };
+    };
+    do?: {
+        type: "click" | "click_xy" | "key" | "js";
+        x?: number;
+        y?: number;
+        key?: string;
+        hold_ms?: number;
+        code?: string;
+    };
+    cooldown_ms?: number;
+    max_hits?: number;
+    ttl_ms?: number;
+    stop_selector?: string;
+};
+export declare function reflexTool(sess: any, a: Rule): Promise<any>;
+export declare function statusTool(sess: any, waitMs?: number): Promise<any>;
+export {};