@minicor/mcp-server 2.0.2 → 2.0.4

package/dist/lds-client.js

@@ -1,5 +1,5 @@
 /**
- * Stateless HTTP client for the Laminar Desktop Service (LDS).
+ * Stateless HTTP client for the Minicor Desktop Service (MDS).
  *
  * Every method receives the base URL (Cloudflare Tunnel) and optional auth
  * credentials so the caller (tool handler) can pull them from session state.
@@ -19,7 +19,7 @@ async function request(url, init) {
     const res = await fetch(url, init);
     if (!res.ok) {
         const body = await res.text().catch(() => "");
-        throw new Error(`LDS ${init?.method ?? "GET"} ${url} returned ${res.status}: ${body}`);
+        throw new Error(`MDS ${init?.method ?? "GET"} ${url} returned ${res.status}: ${body}`);
     }
     return res.json();
 }

package/dist/prompts/build-nerve-rpa.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDeps } from "../types.js";
+export declare function register({ server }: ToolDeps): void;
+//# sourceMappingURL=build-nerve-rpa.d.ts.map

package/dist/prompts/build-nerve-rpa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-nerve-rpa.d.ts","sourceRoot":"","sources":["../../src/prompts/build-nerve-rpa.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,wBAAgB,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,QAAQ,QAsJ5C"}

package/dist/prompts/build-nerve-rpa.js

@@ -0,0 +1,148 @@
+import { z } from "zod";
+export function register({ server }) {
+    server.prompt("build-nerve-rpa-workflow", "Build an RPA workflow using NERVE's atomic operations: annotated screenshots, element clicking/typing, CDP browser control, OCR, and self-healing. Optimized for NERVE (not legacy LDS).", {
+        workspaceId: z.string().describe("Laminar workspace ID"),
+        task: z.string().describe("What to automate"),
+        appName: z.string().describe("Target application name"),
+        workflowId: z.string().optional().describe("Existing workflow ID to add steps to"),
+    }, async ({ workspaceId, task, appName, workflowId }) => ({
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `You are building an RPA workflow using NERVE on the Laminar platform. NERVE gives you direct atomic control over the Windows desktop — you do NOT need to write Python scripts for simple interactions.
+
+## Task
+${task}
+
+## Target Application
+${appName}
+
+## Workspace
+ID: ${workspaceId}${workflowId ? `\nExisting workflow ID: ${workflowId}` : "\nCreate a new workflow for this automation."}
+
+## How NERVE Works
+
+NERVE runs on the VM and exposes the full OS via HTTP APIs. When you call \`vm_connect\`, check the \`capabilities\` array in the response to see what's available.
+
+Key capabilities:
+- \`annotated_screenshots\` — X-Ray Vision: screenshot with numbered element overlays
+- \`ui_tree_cache\` — Persistent accessibility tree
+- \`atomic_input\` — Click/type/invoke by element ID
+- \`script_execution\` — Run Python scripts
+- \`cdp\` — Chrome DevTools Protocol for browser control
+- \`ocr\` / \`template_matching\` — For Citrix/pixel-based apps
+- \`self_healing\` — Pause on error + intervention
+
+## Step 1: Connect and Survey
+
+1. \`vm_connect\` — connect to the VM
+2. Check \`capabilities\` in the response
+3. \`vm_annotated_screenshot\` — see the desktop with numbered elements
+4. \`vm_system_info\` — get OS, RAM, CPU info
+5. \`vm_processes\` — see what's running
+
+## Step 2: Understand the UI
+
+Use the annotated screenshot to understand the screen. Each interactive element has a number:
+\`\`\`
+[1] Username field (Edit)
+[2] Password field (Edit)  
+[3] OK button (Button)
+[4] Cancel button (Button)
+\`\`\`
+
+For deeper inspection:
+- \`vm_inspect_ui\` mode \`element_tree\` — full accessibility tree
+- \`vm_inspect_ui\` mode \`element_at_point\` — inspect specific coordinates
+
+## Step 3: Interact with Atomic Operations
+
+**DO NOT write Python scripts for simple click/type operations.** Use atomic tools:
+
+- \`vm_click_element\` {element_id: 3} — click element #3 from annotated screenshot
+- \`vm_type_into_element\` {element_id: 1, text: "admin"} — type into element #1
+- \`vm_set_value\` {element_id: 2, value: "password"} — set value directly
+- \`vm_invoke_element\` {element_id: 3} — invoke button via accessibility pattern
+- \`vm_shell\` {command: "Start-Process notepad"} — run commands
+
+After each action, take another \`vm_annotated_screenshot\` to verify it worked.
+
+## Step 4: For Web Apps — Use CDP
+
+If the target is a browser or Electron app:
+
+1. \`cdp_connect\` — connect to Chrome/Edge DevTools
+2. \`cdp_dom\` — get the full DOM tree
+3. \`cdp_query\` {selector: "#username"} — find elements by CSS
+4. \`cdp_click\` {selector: "#login-btn"} — click via DOM
+5. \`cdp_type\` {selector: "#email", text: "user@example.com"} — type via DOM
+6. \`cdp_js\` — execute arbitrary JavaScript
+7. \`cdp_network\` — see API calls the app makes
+
+CDP is MORE RELIABLE than screen-based automation for web apps.
+
+## Step 5: For Citrix / Legacy Apps — Use OCR + Template Matching
+
+When there's no accessibility tree (Citrix, RDP, custom-rendered apps):
+
+1. \`vm_ocr\` {x, y, width, height} — read text from a screen region
+2. \`vm_template_match\` {template_b64: "..."} — find a visual element
+3. \`vm_wait_for_text\` {text: "Login", region: {...}} — wait for text to appear
+4. \`vm_wait_for_change\` {region: {...}} — wait for visual change (replaces sleep)
+5. \`vm_region_ocr\` {regions: [...]} — batch OCR multiple fields
+6. Click by coordinates from template match results
+
+## Step 6: Build Production Scripts
+
+Once you understand the UI and have tested atomic operations, consolidate into Python scripts for production:
+
+1. Write a Python script that performs the full sequence
+2. Test with \`debug_rpa_step\` — returns before/after screenshots + timeline
+3. Save with \`create_rpa_flow\` — wraps Python in Laminar workflow format
+
+## Step 7: Self-Healing Pattern
+
+For robust automations, enable self-healing:
+
+1. Execute with \`on_error: "pause"\` — script pauses at failure instead of crashing
+2. \`vm_failure_context\` — get screenshot, UI tree, error details at failure point
+3. \`vm_annotated_screenshot\` — see current screen state
+4. Fix with atomic operations (\`vm_click_element\`, etc.)
+5. Resume execution
+
+## Step 8: End-to-End Validation
+
+1. \`execute_workflow\` to run the full sequence
+2. \`vm_annotated_screenshot\` to verify final state
+3. \`vm_execution_timeline\` to review frame-by-frame what happened
+4. \`diagnose_execution\` if anything fails
+
+## Data Extraction Priority
+
+When you need to READ data from the screen:
+
+1. **Accessibility tree** — \`vm_inspect_ui\` with \`element_tree\` (most reliable)
+2. **Focused element** — Tab through fields, read via \`vm_inspect_ui\` \`focused_element\`
+3. **Clipboard** — Click field, Ctrl+A, Ctrl+C, then \`vm_read_clipboard\`
+4. **OCR** — \`vm_ocr\` on a specific region
+5. **CDP extraction** — \`cdp_js\` to read DOM values (for web apps)
+6. **Region screenshot** — \`vm_screenshot\` of a specific area (last resort)
+
+## Key Rules
+
+- **Annotated screenshots FIRST** — always start by seeing the screen with element IDs
+- **Atomic ops for exploration** — use click/type tools to test, scripts for production
+- **Verify after every action** — take another annotated screenshot
+- **Never hardcode coordinates** — use element IDs or accessibility patterns
+- **Use wait_for_text/wait_for_change** — never use time.sleep() for synchronization
+- **Use \`create_rpa_flow\`** to save steps — never construct JS wrappers manually
+- **Use \`{{config.variables}}\`** for secrets — never hardcode credentials
+`,
+                },
+            },
+        ],
+    }));
+}
+//# sourceMappingURL=build-nerve-rpa.js.map

package/dist/prompts/build-nerve-rpa.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-nerve-rpa.js","sourceRoot":"","sources":["../../src/prompts/build-nerve-rpa.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,MAAM,UAAU,QAAQ,CAAC,EAAE,MAAM,EAAY;IAC3C,MAAM,CAAC,MAAM,CACX,0BAA0B,EAC1B,0LAA0L,EAC1L;QACE,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,sBAAsB,CAAC;QACxD,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,kBAAkB,CAAC;QAC7C,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,yBAAyB,CAAC;QACvD,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,sCAAsC,CAAC;KACnF,EACD,KAAK,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,CAAC;QACrD,QAAQ,EAAE;YACR;gBACE,IAAI,EAAE,MAAe;gBACrB,OAAO,EAAE;oBACP,IAAI,EAAE,MAAe;oBACrB,IAAI,EAAE;;;EAGhB,IAAI;;;EAGJ,OAAO;;;MAGH,WAAW,GAAG,UAAU,CAAC,CAAC,CAAC,2BAA2B,UAAU,EAAE,CAAC,CAAC,CAAC,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuHxH;iBACU;aACF;SACF;KACF,CAAC,CACH,CAAC;AACJ,CAAC"}

package/dist/prompts/build-rpa.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-rpa.d.ts","sourceRoot":"","sources":["../../src/prompts/build-rpa.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,wBAAgB,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,QAAQ,QAgL5C"}
+{"version":3,"file":"build-rpa.d.ts","sourceRoot":"","sources":["../../src/prompts/build-rpa.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,wBAAgB,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,QAAQ,QAmT5C"}

package/dist/prompts/build-rpa.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 export function register({ server }) {
-    server.prompt("build-rpa-workflow", "Iteratively build an RPA workflow on a VM using the Laminar Desktop Service. Guides you through connecting to the VM, researching the target app's UI framework, taking screenshots, inspecting UI elements, writing and testing RPA scripts, and saving each working step as a Laminar workflow flow.", {
-        workspaceId: z.string().describe("Laminar workspace ID"),
+    server.prompt("build-rpa-workflow", "Iteratively build an RPA workflow on a VM using the Minicor Desktop Service. Guides you through connecting to the VM, researching the target app's UI framework, taking screenshots, inspecting UI elements, writing and testing RPA scripts, and saving each working step as a Minicor workflow flow.", {
+        workspaceId: z.string().describe("Minicor workspace ID"),
         task: z
             .string()
             .describe("Description of what to automate (e.g. 'Log into Centricity, navigate to Documents, download the latest report')"),
@@ -18,7 +18,7 @@ export function register({ server }) {
                 role: "user",
                 content: {
                     type: "text",
-                    text: `You are building an RPA workflow on the Laminar platform. Your goal is to iteratively create automation steps that run on a VM via the Laminar Desktop Service (LDS).
+                    text: `You are building an RPA workflow on the Minicor platform. Your goal is to iteratively create automation steps that run on a VM via the Minicor Desktop Service (MDS).
 
 ## Task
 ${task}
@@ -38,26 +38,112 @@ ID: ${workspaceId}${workflowId ? `\nExisting workflow ID: ${workflowId} (add ste
 3. Only then → save via \`create_rpa_flow\`
 
 ### Rule 2 — USE \`create_rpa_flow\` TO SAVE (NOT \`create_flow\`)
-When saving an RPA step, call **\`create_rpa_flow\`** — it automatically wraps your Python script in the correct Laminar JS format. You only pass the Python script; the tool handles the \`lam.httpRequest\` / \`lam.rpa\` wrapper.
+When saving an RPA step, call **\`create_rpa_flow\`** — it automatically wraps your Python script in the correct Minicor JS format. You only pass the Python script; the tool handles the \`lam.httpRequest\` / \`lam.rpa\` wrapper.
 
 **NEVER** call \`create_flow\` with raw Python for an RPA step. **NEVER** try to construct the JS wrapper yourself.
 
 ### Rule 3 — COMBINE ui_inspect + screenshots + clipboard
 Screenshots alone are unreliable for reading data (resolution issues, misreads). ALWAYS combine multiple methods. See the Data Extraction Strategy section below.
 
-## Procedure
+## Strategy Selection (BEFORE writing any automation)
 
-### 1. Connect to the VM
-If no VM is connected, ask for the **Cloudflare Tunnel URL** and call \`vm_connect\`.
+### For Web/Browser Targets:
+- Use **CDP via Python websocket** for page manipulation (fastest, most reliable for anti-bot sites)
+- The MDS provides an isolated Chrome instance per execution via \`/execute/browser\`
+- Multiple browser automations run **in parallel** on the same VM — each gets its own Chrome
+- Scripts always use \`127.0.0.1:9222\` — the MDS transparently routes to the correct Chrome instance
+- Use CDP \`Page.captureScreenshot\` for screenshots within the browser tab
+- Check if the site has usable internal APIs (inspect network traffic via CDP \`fetch\` interception)
+- If clean APIs exist and are stable → consider direct \`requests\`/\`httpx\` instead of UI automation
+- If anti-bot protection exists (Cloudflare, reCAPTCHA) → CDP through the VM browser avoids detection
 
-### 2. Research the Target Application
-Based on "${appName}", pick the UI automation framework:
+### For Desktop Targets:
 - **.NET / WPF / WinForms** → \`uiautomation\` (default) or \`pywinauto\`
 - **Java / Swing** → \`jab\` (Java Access Bridge)
-- **Electron / web-based desktop** → \`pywinauto\` or pyautogui
+- **Electron / web-based desktop** → \`pywinauto\` or \`pyautogui\`
 - **Legacy Win32** → \`uiautomation\`
+- Start with \`uiautomation\` if unsure.
+- Desktop scripts use \`/execute\` and run **one at a time** per VM (the physical screen is shared)
+
+### Mixed Browser + Desktop (IMPORTANT)
+Some browser automations need to interact with the physical screen — for example:
+- Clicking OS-level alerts or confirmation dialogs
+- File upload/download dialogs (native file picker)
+- Browser notifications or permission prompts
+- CAPTCHA solving that requires clicking outside the browser
+
+**These automations CANNOT use \`/execute/browser\`** because they need the screen, which is shared.
+Use \`/execute\` instead and treat them like desktop automations — they run one at a time per VM.
+
+When building a workflow, determine which category it falls into:
+- **Pure CDP** (all interaction via \`Runtime.evaluate\`, \`Page.navigate\`, etc.) → \`/execute/browser\` — parallel-safe
+- **Needs screen interaction** (any \`pyautogui\`, OS dialogs, file pickers) → \`/execute\` — one at a time
+
+## Browser Automation via CDP (Python WebSocket)
+
+Your Python scripts connect to Chrome via the Chrome DevTools Protocol. The MDS handles Chrome lifecycle and port routing transparently — scripts always use port 9222.
+
+**Dispatch:** Use \`dispatchPattern: "browser"\` when saving with \`create_rpa_flow\`. This routes to \`/execute/browser\` which provides an isolated Chrome instance.
+
+### How CDP Works:
+1. Discover tabs: \`GET http://127.0.0.1:9222/json\`
+2. Connect via WebSocket to the target tab's \`webSocketDebuggerUrl\`
+3. Use \`Runtime.evaluate\` to execute JavaScript in the page context
+4. Use CDP \`Page.captureScreenshot\` for screenshots
+
+### CDP Starter Template:
+\`\`\`python
+import json, websocket, time
+from urllib.request import urlopen
+
+tabs = json.loads(urlopen('http://127.0.0.1:9222/json').read())
+page_tab = [t for t in tabs if t.get('type') == 'page'][0]
+ws = websocket.create_connection(page_tab['webSocketDebuggerUrl'])
+cmd_id = 0
+
+def cdp_eval(ws, js):
+    global cmd_id; cmd_id += 1
+    ws.send(json.dumps({'id': cmd_id, 'method': 'Runtime.evaluate', 'params': {'expression': js}}))
+    while True:
+        msg = json.loads(ws.recv())
+        if msg.get('id') == cmd_id: return msg
+
+# Navigate
+cdp_eval(ws, 'window.location.href="https://example.com"')
+time.sleep(8)
+
+# Fill input using React-safe setter (ALWAYS use this for React/Angular/Vue apps)
+cdp_eval(ws, 'var s=Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype,"value").set;var inp=document.querySelector("input[type=email]");if(inp){s.call(inp,"user@example.com");inp.dispatchEvent(new Event("input",{bubbles:true}));inp.dispatchEvent(new Event("change",{bubbles:true}))}')
+
+# Click button by text content (more resilient than CSS selectors)
+cdp_eval(ws, 'document.querySelectorAll("button").forEach(function(b){if(b.textContent.trim()==="Submit"){b.click()}})')
+
+ws.close()
+\`\`\`
+
+### Key CDP Patterns:
+- **React-safe value setter**: Always use \`Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, "value").set\` — direct \`.value=\` assignment does NOT trigger React/Angular change detection
+- **Button clicks by text**: Use \`querySelectorAll("button").forEach()\` + \`textContent.trim()\` matching — more resilient than IDs or classes that change
+- **Credentials**: Use \`\\\${username}\` / \`\\\${password}\` interpolated from JS wrapper variables sourced from \`{{config.xxx}}\` — NEVER hardcode
+- **Waits**: \`time.sleep()\` between navigations (8-15s for page loads, 1-3s for UI actions)
+- **Verification**: Use CDP \`Page.captureScreenshot\` for per-tab screenshots
+- **Dropdown handling**: Click to open, then use \`querySelectorAll\` to find options by text and click
+- **Tab management**: If multiple tabs open, filter \`/json\` response by URL or title
+
+### Parallel Execution Notes:
+- \`/execute/browser\` runs your script with its own Chrome instance — multiple workflows can run at the same time on one VM
+- \`/execute\` runs your script without Chrome — for desktop automation or mixed browser+desktop scripts
+- The MDS transparently rewrites \`127.0.0.1:9222\` in your script to the correct Chrome port — you never need to handle ports
+- Recordings from \`/execute/browser\` capture only the browser tab (CDP screencast), not the full desktop
+- Recordings from \`/execute\` capture the full desktop (MSS screen recording)
+
+## Procedure
 
-Start with \`uiautomation\` if unsure.
+### 1. Connect to the VM
+If no VM is connected, ask for the **Cloudflare Tunnel URL** and call \`vm_connect\`.
+
+### 2. Research the Target Application
+Based on "${appName}", determine if it's a **web/browser** target or a **desktop** target using the Strategy Selection above.
 
 ### 3. Initial Survey (ALWAYS do this first)
 Before writing any automation:
@@ -90,17 +176,58 @@ Before writing any automation:
 **e. SAVE — Call \`create_rpa_flow\` (only after c + d pass)**
 - Pass the validated Python script, step name, description, flowId, and executionOrder
 - The tool handles all JS wrapping automatically
-- Default dispatch: \`cloudflare_tunnel\` (uses \`lam.httpRequest\`)
+- For browser/CDP automations: set \`dispatchPattern: "browser"\` — routes to \`/execute/browser\` (parallel-safe)
+- For desktop automations: use default \`dispatchPattern: "cloudflare_tunnel"\` — routes to \`/execute\`
+- For mixed browser+desktop: use default \`dispatchPattern: "cloudflare_tunnel"\` — runs one at a time
+
+### 5. Data Passing Between Steps (CRITICAL)
+
+Workflow input is available as \`data.input\` in the **JS wrapper**, NOT in Python directly. Dynamic values must be interpolated in the JS layer, then embedded into the Python template literal.
+
+**CORRECT — JS-layer interpolation (how the existing SOAP workflow does it):**
+\`\`\`javascript
+(data) => {
+  const mrn = data?.input?.mrn || "DEFAULT";
+  const pythonScript = \\\`
+    mrn = "\${mrn}"
+    # ... rest of Python script uses mrn variable
+  \\\`;
+  return { "lam.httpRequest": { ... body: { script: pythonScript } } };
+}
+\`\`\`
+
+**WRONG — Python template vars (will show literal text, not resolved):**
+\`\`\`python
+mrn = "{{input.mrn}}"   # WRONG — this is not a config variable
+mrn = data.input.mrn     # WRONG — data object doesn't exist in Python
+\`\`\`
+
+\`create_rpa_flow\` generates the JS wrapper automatically, but if the script needs dynamic input from \`data.input\` or \`data.step_N\`, you must construct the JS wrapper yourself or update the flow after creation to add JS-layer const declarations that interpolate values into the Python template literal.
+
+**Config variables** like \`{{config.username}}\` ARE resolved by the workflow engine and work in both JS and Python layers. Use these for credentials and environment URLs.
+
+**Previous step outputs** are at \`data.step_N.response\` (for HTTP/RPA steps) or \`data.step_N.data\` (for GENERAL_FUNCTION steps).
+
+### 6. Test Through Minicor (REQUIRED — vm_execute_script is NOT enough)
+
+\`vm_execute_script\` is for **prototyping only**. Scripts that pass on the VM may FAIL when run through Minicor because:
+- \`{{config.xxx}}\` variables only resolve in the workflow engine
+- \`data.input\` interpolation only works through the JS wrapper
+- Step-to-step data flow (\`data.step_N\`) only works in the real executor
+
+**After saving ALL steps, you MUST test through Minicor:**
+
+a. \`execute_workflow\` with **real input data** and a **configurationId** pointing to the correct config store
+b. If a step fails → \`diagnose_execution\` to identify the issue
+c. Use \`test_workflow_step\` to re-run individual failing steps through Minicor (NOT \`vm_execute_script\`)
+d. Fix with \`update_flow\`, then re-test through \`execute_workflow\` again
+e. Iterate until the **full workflow passes end-to-end** through \`execute_workflow\`
 
-### 5. End-to-End Validation
-After all steps are built:
-- \`execute_workflow\` to run the full sequence
-- \`vm_screenshot\` to verify final state
-- \`diagnose_execution\` if anything fails
+**Do NOT declare a workflow complete until it passes \`execute_workflow\` with real inputs.**
 
-### 6. Iterate with the User
-- Present completed workflow summary
-- Make adjustments, re-validate changed steps
+### 7. Iterate with the User
+- Present completed workflow summary with execution results from Minicor
+- Make adjustments, re-validate changed steps through \`execute_workflow\`
 
 ## Data Extraction Strategy
 
@@ -146,15 +273,19 @@ When you need to READ data from the screen (not just click/type), follow this pr
 ## Debugging Tools
 
 - **\`debug_rpa_step\`** — runs a script with before/after screenshots and full diagnostics (stdout, stderr, exit code). Use during development.
-- **\`vm_reset_state\`** — Smart Launch: close dialogs, reset app to known state. Use before testing.
+- **\`vm_reset_state\`** — Manage windows: focus an app, minimize all, close dialogs, or close an app. Use before testing.
 - **\`vm_read_clipboard\`** — read clipboard after a copy operation.
-- **\`vm_screenshot_region\`** — crop/zoom a region for better text reading.
+- **\`vm_screenshot_region\`** — crop/zoom a specific screen region for better text reading or verifying specific UI elements.
 - **\`batch_test_rpa\`** — run the workflow with multiple test inputs.
+- **Video Recordings** — Minicor records MP4 videos of each RPA step execution. Use \`get_full_execution\` to see recording references (\`recording.blobName\`). These can be viewed in the Minicor platform for visual debugging.
 
 ## Important Rules
 - **VALIDATE BEFORE SAVING** — no exceptions unless user explicitly opts out
+- **TEST THROUGH MINICOR** — \`vm_execute_script\` is for prototyping. Always run \`execute_workflow\` with real inputs before declaring done.
 - **Use \`create_rpa_flow\`** — never construct JS wrappers manually
 - **Use \`{{config.variables}}\` for secrets** — never hardcode credentials
+- **Last step = workflow output** — The workflow returns whatever the FINAL step produces. If you need structured data returned (JSON, extracted records), the last step must output it. Don't put meaningful data in step N and cleanup in step N+1. Combine cleanup + data return in the last step, or add a GENERAL_FUNCTION step after RPA that formats the final result.
+- **Study existing workflows first** — Before building, check if similar workflows exist in the workspace via \`get_workflow_overview\`. Reuse proven patterns for JS wrapper data passing, coordinate discovery, and framework selection. Existing workflows are battle-tested — copy their interpolation patterns.
 - **Combine extraction methods** — accessibility tree + clipboard + screenshots
 - **Start simple** — get basic automation working before adding sophistication
 - **Add waits** — use \`time.sleep()\` or element-wait patterns between actions

package/dist/prompts/build-rpa.js.map

@@ -1 +1 @@
-{"version":3,"file":"build-rpa.js","sourceRoot":"","sources":["../../src/prompts/build-rpa.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,MAAM,UAAU,QAAQ,CAAC,EAAE,MAAM,EAAY;IAC3C,MAAM,CAAC,MAAM,CACX,oBAAoB,EACpB,wSAAwS,EACxS;QACE,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,sBAAsB,CAAC;QACxD,IAAI,EAAE,CAAC;aACJ,MAAM,EAAE;aACR,QAAQ,CACP,iHAAiH,CAClH;QACH,OAAO,EAAE,CAAC;aACP,MAAM,EAAE;aACR,QAAQ,CACP,uFAAuF,CACxF;QACH,UAAU,EAAE,CAAC;aACV,MAAM,EAAE;aACR,QAAQ,EAAE;aACV,QAAQ,CACP,sEAAsE,CACvE;KACJ,EACD,KAAK,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,CAAC;QACrD,QAAQ,EAAE;YACR;gBACE,IAAI,EAAE,MAAe;gBACrB,OAAO,EAAE;oBACP,IAAI,EAAE,MAAe;oBACrB,IAAI,EAAE;;;EAGhB,IAAI;;;EAGJ,OAAO;;;MAGH,WAAW,GAAG,UAAU,CAAC,CAAC,CAAC,2BAA2B,UAAU,+BAA+B,CAAC,CAAC,CAAC,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;YAwB1I,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDA4GsC;iBAC9C;aACF;SACF;KACF,CAAC,CACH,CAAC;AACJ,CAAC"}
+{"version":3,"file":"build-rpa.js","sourceRoot":"","sources":["../../src/prompts/build-rpa.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,MAAM,UAAU,QAAQ,CAAC,EAAE,MAAM,EAAY;IAC3C,MAAM,CAAC,MAAM,CACX,oBAAoB,EACpB,wSAAwS,EACxS;QACE,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,sBAAsB,CAAC;QACxD,IAAI,EAAE,CAAC;aACJ,MAAM,EAAE;aACR,QAAQ,CACP,iHAAiH,CAClH;QACH,OAAO,EAAE,CAAC;aACP,MAAM,EAAE;aACR,QAAQ,CACP,uFAAuF,CACxF;QACH,UAAU,EAAE,CAAC;aACV,MAAM,EAAE;aACR,QAAQ,EAAE;aACV,QAAQ,CACP,sEAAsE,CACvE;KACJ,EACD,KAAK,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,CAAC;QACrD,QAAQ,EAAE;YACR;gBACE,IAAI,EAAE,MAAe;gBACrB,OAAO,EAAE;oBACP,IAAI,EAAE,MAAe;oBACrB,IAAI,EAAE;;;EAGhB,IAAI;;;EAGJ,OAAO;;;MAGH,WAAW,GAAG,UAAU,CAAC,CAAC,CAAC,2BAA2B,UAAU,+BAA+B,CAAC,CAAC,CAAC,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAoH1I,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDAmJsC;iBAC9C;aACF;SACF;KACF,CAAC,CACH,CAAC;AACJ,CAAC"}

package/dist/prompts/debug-execution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"debug-execution.d.ts","sourceRoot":"","sources":["../../src/prompts/debug-execution.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAG5C,wBAAgB,QAAQ,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,QAAQ,QAoDpD"}
+{"version":3,"file":"debug-execution.d.ts","sourceRoot":"","sources":["../../src/prompts/debug-execution.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAG5C,wBAAgB,QAAQ,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,QAAQ,QAyEpD"}

package/dist/prompts/debug-execution.js

@@ -40,7 +40,28 @@ ${json(flowsData)}
 ## Execution Details:
 ${json(executionData)}
 
-Analyze the execution, identify failures, explain root causes, and suggest specific code fixes for the failing steps. Use the Laminar workflow specification (available via the laminar-workflow-guide prompt) for correct syntax.`,
+Analyze the execution, identify failures, explain root causes, and suggest specific code fixes for the failing steps. Use the Minicor workflow specification (available via the minicor-workflow-guide prompt) for correct syntax.
+
+## Debugging Strategy
+
+### 1. Analyze the execution data above
+- Identify which steps failed and their error messages
+- Check the transformation (input) data for each failed step
+- Look at preceding successful steps for context
+
+### 2. Check for video recordings
+- RPA step executions include \`recording.blobName\` in their response data (e.g. \`rpa_1_step-name.mp4\`)
+- These MP4 recordings can be viewed in the Minicor platform for visual debugging
+
+### 3. If a VM is connected — reproduce on the live VM
+- Use \`replay_execution_step\` with the failed flow run ID to re-run the exact script with before/after screenshots
+- Use \`vm_screenshot\` + \`vm_inspect_ui\` to compare expected vs actual VM state
+- Use \`debug_rpa_step\` with a modified script to test fixes
+
+### 4. Fix and redeploy
+- After identifying the fix, use \`debug_rpa_step\` to validate the corrected script
+- Use \`update_flow\` to deploy the fixed step code
+- Use \`execute_workflow\` to verify the full workflow works end-to-end`,
                     },
                 },
             ],

package/dist/prompts/debug-execution.js.map

@@ -1 +1 @@
-{"version":3,"file":"debug-execution.js","sourceRoot":"","sources":["../../src/prompts/debug-execution.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAErC,MAAM,UAAU,QAAQ,CAAC,EAAE,MAAM,EAAE,MAAM,EAAY;IACnD,MAAM,CAAC,MAAM,CACX,0BAA0B,EAC1B,uDAAuD,EACvD;QACE,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,sBAAsB,CAAC;QACvD,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,qBAAqB,CAAC;KACxD,EACD,KAAK,EAAE,EAAE,UAAU,EAAE,WAAW,EAAE,EAAE,EAAE;QACpC,MAAM,GAAG,GAAG,QAAQ,CAAC,UAAU,CAAC,CAAC;QACjC,MAAM,GAAG,GAAG,QAAQ,CAAC,WAAW,CAAC,CAAC;QAClC,IAAI,aAAkB,CAAC;QACvB,IAAI,SAAc,CAAC;QAEnB,IAAI,CAAC;YACH,aAAa,GAAG,MAAM,MAAM,EAAE,CAAC,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;YACtD,SAAS,GAAG,MAAM,MAAM,EAAE,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QACnD,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,OAAO;gBACL,QAAQ,EAAE;oBACR;wBACE,IAAI,EAAE,MAAe;wBACrB,OAAO,EAAE;4BACP,IAAI,EAAE,MAAe;4BACrB,IAAI,EAAE,mCAAmC,CAAC,CAAC,OAAO,EAAE;yBACrD;qBACF;iBACF;aACF,CAAC;QACJ,CAAC;QAED,OAAO;YACL,QAAQ,EAAE;gBACR;oBACE,IAAI,EAAE,MAAe;oBACrB,OAAO,EAAE;wBACP,IAAI,EAAE,MAAe;wBACrB,IAAI,EAAE;;;EAGlB,IAAI,CAAC,SAAS,CAAC;;;EAGf,IAAI,CAAC,aAAa,CAAC;;mOAE8M;qBACtN;iBACF;aACF;SACF,CAAC;IACJ,CAAC,CACF,CAAC;AACJ,CAAC"}
+{"version":3,"file":"debug-execution.js","sourceRoot":"","sources":["../../src/prompts/debug-execution.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAErC,MAAM,UAAU,QAAQ,CAAC,EAAE,MAAM,EAAE,MAAM,EAAY;IACnD,MAAM,CAAC,MAAM,CACX,0BAA0B,EAC1B,uDAAuD,EACvD;QACE,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,sBAAsB,CAAC;QACvD,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,qBAAqB,CAAC;KACxD,EACD,KAAK,EAAE,EAAE,UAAU,EAAE,WAAW,EAAE,EAAE,EAAE;QACpC,MAAM,GAAG,GAAG,QAAQ,CAAC,UAAU,CAAC,CAAC;QACjC,MAAM,GAAG,GAAG,QAAQ,CAAC,WAAW,CAAC,CAAC;QAClC,IAAI,aAAkB,CAAC;QACvB,IAAI,SAAc,CAAC;QAEnB,IAAI,CAAC;YACH,aAAa,GAAG,MAAM,MAAM,EAAE,CAAC,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;YACtD,SAAS,GAAG,MAAM,MAAM,EAAE,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QACnD,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,OAAO;gBACL,QAAQ,EAAE;oBACR;wBACE,IAAI,EAAE,MAAe;wBACrB,OAAO,EAAE;4BACP,IAAI,EAAE,MAAe;4BACrB,IAAI,EAAE,mCAAmC,CAAC,CAAC,OAAO,EAAE;yBACrD;qBACF;iBACF;aACF,CAAC;QACJ,CAAC;QAED,OAAO;YACL,QAAQ,EAAE;gBACR;oBACE,IAAI,EAAE,MAAe;oBACrB,OAAO,EAAE;wBACP,IAAI,EAAE,MAAe;wBACrB,IAAI,EAAE;;;EAGlB,IAAI,CAAC,SAAS,CAAC;;;EAGf,IAAI,CAAC,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;wEAuBmD;qBAC3D;iBACF;aACF;SACF,CAAC;IACJ,CAAC,CACF,CAAC;AACJ,CAAC"}

package/dist/prompts/workflow-guide.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workflow-guide.d.ts","sourceRoot":"","sources":["../../src/prompts/workflow-guide.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,wBAAgB,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,QAAQ,QAkL5C"}
+{"version":3,"file":"workflow-guide.d.ts","sourceRoot":"","sources":["../../src/prompts/workflow-guide.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,wBAAgB,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,QAAQ,QAuK5C"}

package/dist/prompts/workflow-guide.js

@@ -1,13 +1,13 @@
 export function register({ server }) {
-    server.prompt("laminar-workflow-guide", "Comprehensive guide for creating and editing Laminar workflows — step types, data access patterns, available libraries, and best practices", {}, async () => ({
+    server.prompt("minicor-workflow-guide", "Comprehensive guide for creating and editing Minicor workflows — step types, data access patterns, available libraries, and best practices", {}, async () => ({
         messages: [
             {
                 role: "user",
                 content: {
                     type: "text",
-                    text: `Please use this Laminar platform specification when creating or editing workflows:
+                    text: `Please use this Minicor platform specification when creating or editing workflows:
 
-# Laminar Workflow Specification
+# Minicor Workflow Specification
 
 ## Step Structure
 Every step is a JSON object with these fields:
@@ -70,17 +70,6 @@ def transform(data):
 
 Multiple requests: use \`"lam.httpRequests"\` (plural) with an array.
 
-### SHELL_SCRIPT
-\`\`\`json
-{
-  "lam.shell": {
-    "script": "Bash script as string",
-    "environment": {},
-    "timeout": 300,
-    "binaryDataIds": []
-  }
-}
-\`\`\`
 
 ### RPA (Desktop Automation)
 **IMPORTANT: Use the \`create_rpa_flow\` tool to save RPA steps.** It accepts your validated Python script and automatically wraps it in the correct JS format. You do NOT need to construct the wrapper yourself.

package/dist/prompts/workflow-guide.js.map

@@ -1 +1 @@
-{"version":3,"file":"workflow-guide.js","sourceRoot":"","sources":["../../src/prompts/workflow-guide.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,QAAQ,CAAC,EAAE,MAAM,EAAY;IAC3C,MAAM,CAAC,MAAM,CACX,wBAAwB,EACxB,4IAA4I,EAC5I,EAAE,EACF,KAAK,IAAI,EAAE,CAAC,CAAC;QACX,QAAQ,EAAE;YACR;gBACE,IAAI,EAAE,MAAe;gBACrB,OAAO,EAAE;oBACP,IAAI,EAAE,MAAe;oBACrB,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gGAiK8E;iBACrF;aACF;SACF;KACF,CAAC,CACH,CAAC;AACJ,CAAC"}
+{"version":3,"file":"workflow-guide.js","sourceRoot":"","sources":["../../src/prompts/workflow-guide.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,QAAQ,CAAC,EAAE,MAAM,EAAY;IAC3C,MAAM,CAAC,MAAM,CACX,wBAAwB,EACxB,4IAA4I,EAC5I,EAAE,EACF,KAAK,IAAI,EAAE,CAAC,CAAC;QACX,QAAQ,EAAE;YACR;gBACE,IAAI,EAAE,MAAe;gBACrB,OAAO,EAAE;oBACP,IAAI,EAAE,MAAe;oBACrB,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gGAsJ8E;iBACrF;aACF;SACF;KACF,CAAC,CACH,CAAC;AACJ,CAAC"}