@minicor/mcp-server 2.0.0

package/dist/paths.js

@@ -0,0 +1,46 @@
+/**
+ * Shared path resolution for token and config storage.
+ *
+ * New installs write to ~/.minicor/. Existing ~/.laminar/ installs
+ * keep working via fallback reads. Once a user re-auths, tokens
+ * silently migrate to ~/.minicor/.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const MINICOR_DIR = path.join(os.homedir(), ".minicor");
+const LEGACY_DIR = path.join(os.homedir(), ".laminar");
+export { MINICOR_DIR };
+export function getTokenPath() {
+    const minicorPath = path.join(MINICOR_DIR, "tokens.json");
+    if (fs.existsSync(minicorPath))
+        return minicorPath;
+    const legacyPath = path.join(LEGACY_DIR, "tokens.json");
+    if (fs.existsSync(legacyPath))
+        return legacyPath;
+    return minicorPath;
+}
+export function getWriteTokenPath() {
+    return path.join(MINICOR_DIR, "tokens.json");
+}
+export function getConfigPath() {
+    const minicorPath = path.join(MINICOR_DIR, "config.json");
+    if (fs.existsSync(minicorPath))
+        return minicorPath;
+    const legacyPath = path.join(LEGACY_DIR, "config.json");
+    if (fs.existsSync(legacyPath))
+        return legacyPath;
+    return minicorPath;
+}
+export function getWriteConfigPath() {
+    return path.join(MINICOR_DIR, "config.json");
+}
+export function regionToApiBase(region) {
+    return region === "ca"
+        ? "https://ca.api.laminar.run"
+        : "https://api.laminar.run";
+}
+export function apiBaseToRegion(apiBase) {
+    return apiBase.includes("ca.api") ? "ca" : "us";
+}
+//# sourceMappingURL=paths.js.map

package/dist/paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.js","sourceRoot":"","sources":["../src/paths.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,MAAM,SAAS,CAAC;AACzB,OAAO,EAAE,MAAM,SAAS,CAAC;AACzB,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,EAAE,UAAU,CAAC,CAAC;AACxD,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,EAAE,UAAU,CAAC,CAAC;AAEvD,OAAO,EAAE,WAAW,EAAE,CAAC;AAEvB,MAAM,UAAU,YAAY;IAC1B,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;IAC1D,IAAI,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;QAAE,OAAO,WAAW,CAAC;IACnD,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,aAAa,CAAC,CAAC;IACxD,IAAI,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC;QAAE,OAAO,UAAU,CAAC;IACjD,OAAO,WAAW,CAAC;AACrB,CAAC;AAED,MAAM,UAAU,iBAAiB;IAC/B,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;AAC/C,CAAC;AAED,MAAM,UAAU,aAAa;IAC3B,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;IAC1D,IAAI,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;QAAE,OAAO,WAAW,CAAC;IACnD,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,aAAa,CAAC,CAAC;IACxD,IAAI,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC;QAAE,OAAO,UAAU,CAAC;IACjD,OAAO,WAAW,CAAC;AACrB,CAAC;AAED,MAAM,UAAU,kBAAkB;IAChC,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;AAC/C,CAAC;AAID,MAAM,UAAU,eAAe,CAAC,MAAc;IAC5C,OAAO,MAAM,KAAK,IAAI;QACpB,CAAC,CAAC,4BAA4B;QAC9B,CAAC,CAAC,yBAAyB,CAAC;AAChC,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,OAAe;IAC7C,OAAO,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;AAClD,CAAC"}

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

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

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

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

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

@@ -0,0 +1,90 @@
+import { z } from "zod";
+export function register({ server }) {
+    server.prompt("build-browser-rpa-workflow", "Iteratively build a browser-based RPA workflow using the Laminar Browser RPA service. Guides you through creating a browser session, performing actions, extracting data, and saving each step as a Laminar workflow flow.", {
+        workspaceId: z.string().describe("Laminar workspace ID"),
+        task: z
+            .string()
+            .describe("Description of what to automate (e.g. 'Log into athenaHealth, navigate to patient chart, extract insurance info')"),
+        targetUrl: z
+            .string()
+            .describe("Starting URL for the web application"),
+        workflowId: z
+            .string()
+            .optional()
+            .describe("Existing workflow ID to add steps to (omit to create a new workflow)"),
+    }, async ({ workspaceId, task, targetUrl, workflowId }) => ({
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `You are building a browser-based RPA workflow on the Laminar platform. Your goal is to automate web application interactions using the Browser RPA session API.
+
+## Task
+${task}
+
+## Target URL
+${targetUrl}
+
+## Workspace
+ID: ${workspaceId}${workflowId ? `\nExisting workflow ID: ${workflowId} (add steps to this workflow)` : "\nCreate a new workflow for this automation."}
+
+## How Browser RPA Works
+
+The Browser RPA service provides a session-based API:
+1. **Create Session** — starts a browser instance, returns a sessionId
+2. **Act** — sends natural-language actions (e.g. "click the login button", "type hello@example.com in the email field")
+3. **Extract** — extracts data from the current page via natural-language instructions
+4. **Screenshot** — captures the current browser state
+5. **Close Session** — cleans up
+
+## Procedure
+
+### 1. Connect to Browser RPA Service
+Call \`browser_connect\` with the service base URL and bearer token. Ask the user if not known.
+
+### 2. Create a Browser Session
+Call \`browser_create_session\` to get a sessionId.
+
+### 3. Iterative Build Loop — For EACH step:
+
+**a. ACT — Perform the browser action**
+- Call \`browser_act\` with a natural-language description of what to do
+- Be specific: "navigate to ${targetUrl}", "click the Submit button", "type 'john@example.com' into the email input field"
+
+**b. VERIFY — Confirm the action worked**
+- Call \`browser_screenshot\` to see the current state
+- If the action didn't produce the expected result, retry with a more specific instruction
+
+**c. EXTRACT — Get data if needed**
+- Call \`browser_extract\` with instructions like "extract the patient name and date of birth"
+- This returns structured data from the page
+
+**d. SAVE — Persist as a workflow step**
+- Call \`create_browser_rpa_flow\` with the action type and payload
+- For the first step, use actionType "create_session"
+- For navigation/interaction steps, use actionType "act"
+- For data extraction steps, use actionType "extract"
+- For cleanup, use actionType "close_session"
+
+### 4. End-to-End Validation
+- Run the full workflow via \`execute_workflow\`
+- Verify the final state
+
+### 5. Iterate with the User
+- Present the completed workflow
+- Make adjustments as needed
+
+## Important Rules
+- **Always verify actions with screenshots** before saving
+- **Use \`create_browser_rpa_flow\`** to save steps — it generates the correct \`lam.httpRequest\` wrapper
+- **Use \`{{config.variables}}\`** for credentials (bearerToken, baseUrl, etc.)
+- **Be specific in actions** — natural language should be unambiguous
+- **Handle 2FA/MFA** — if login requires verification codes, use waitForInput patterns
+- **One action per step** — keep steps focused and debuggable`,
+                },
+            },
+        ],
+    }));
+}
+//# sourceMappingURL=build-browser-rpa.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"build-browser-rpa.js","sourceRoot":"","sources":["../../src/prompts/build-browser-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,4BAA4B,EAC5B,4NAA4N,EAC5N;QACE,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,sBAAsB,CAAC;QACxD,IAAI,EAAE,CAAC;aACJ,MAAM,EAAE;aACR,QAAQ,CACP,mHAAmH,CACpH;QACH,SAAS,EAAE,CAAC;aACT,MAAM,EAAE;aACR,QAAQ,CAAC,sCAAsC,CAAC;QACnD,UAAU,EAAE,CAAC;aACV,MAAM,EAAE;aACR,QAAQ,EAAE;aACV,QAAQ,CAAC,sEAAsE,CAAC;KACpF,EACD,KAAK,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,CAAC;QACvD,QAAQ,EAAE;YACR;gBACE,IAAI,EAAE,MAAe;gBACrB,OAAO,EAAE;oBACP,IAAI,EAAE,MAAe;oBACrB,IAAI,EAAE;;;EAGhB,IAAI;;;EAGJ,SAAS;;;MAGL,WAAW,GAAG,UAAU,CAAC,CAAC,CAAC,2BAA2B,UAAU,+BAA+B,CAAC,CAAC,CAAC,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;8BAuBxH,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DA+BuB;iBACnD;aACF;SACF;KACF,CAAC,CACH,CAAC;AACJ,CAAC"}

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

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

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

@@ -0,0 +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"}

package/dist/prompts/build-rpa.js

@@ -0,0 +1,168 @@
+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"),
+        task: z
+            .string()
+            .describe("Description of what to automate (e.g. 'Log into Centricity, navigate to Documents, download the latest report')"),
+        appName: z
+            .string()
+            .describe("Name of the application to automate (e.g. 'Centricity', 'SAP GUI', 'Epic Hyperspace')"),
+        workflowId: z
+            .string()
+            .optional()
+            .describe("Existing workflow ID to add steps to (omit to create a new workflow)"),
+    }, async ({ workspaceId, task, appName, workflowId }) => ({
+        messages: [
+            {
+                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).
+
+## Task
+${task}
+
+## Target Application
+${appName}
+
+## Workspace
+ID: ${workspaceId}${workflowId ? `\nExisting workflow ID: ${workflowId} (add steps to this workflow)` : "\nCreate a new workflow for this automation."}
+
+## CRITICAL RULES
+
+### Rule 1 — MANDATORY VALIDATION
+**NEVER save a step without first validating it on the VM.** Every RPA script MUST pass this sequence:
+1. \`vm_execute_script\` — run on the VM
+2. \`vm_screenshot\` — visually confirm it worked
+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.
+
+**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
+
+### 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}", pick the UI automation framework:
+- **.NET / WPF / WinForms** → \`uiautomation\` (default) or \`pywinauto\`
+- **Java / Swing** → \`jab\` (Java Access Bridge)
+- **Electron / web-based desktop** → \`pywinauto\` or pyautogui
+- **Legacy Win32** → \`uiautomation\`
+
+Start with \`uiautomation\` if unsure.
+
+### 3. Initial Survey (ALWAYS do this first)
+Before writing any automation:
+1. \`vm_screenshot\` — see the desktop state
+2. \`vm_inspect_ui\` mode \`screen_info\` — get resolution
+3. \`vm_inspect_ui\` mode \`window_list\` — list windows
+4. Verify the target app is running
+
+### 4. Iterative Build Loop — For EACH step:
+
+**a. OBSERVE — Understand the current state (REQUIRED)**
+- \`vm_screenshot\` to see the screen
+- \`vm_inspect_ui\` with \`element_tree\` to map UI elements
+- \`vm_inspect_ui\` with \`element_at_point\` for specific elements
+
+**b. WRITE — Create the Python RPA script**
+- Use the appropriate framework (pyautogui for mouse/keyboard, uiautomation/pywinauto for element-based)
+- Include error handling and waits
+- Explain what it does before executing
+
+**c. VALIDATE — Test on the VM (REQUIRED)**
+- \`vm_execute_script\` — run the script
+- Or use \`debug_rpa_step\` for full before/after screenshots + diagnostics
+- Fix and re-run if errors occur
+
+**d. VERIFY — Confirm visually (REQUIRED)**
+- \`vm_screenshot\` immediately after
+- If result is wrong, go back to (b)
+
+**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\`)
+
+### 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
+
+### 6. Iterate with the User
+- Present completed workflow summary
+- Make adjustments, re-validate changed steps
+
+## Data Extraction Strategy
+
+When you need to READ data from the screen (not just click/type), follow this priority order. **Do NOT rely solely on screenshots for data reading.**
+
+### Priority 1: Accessibility Tree (most reliable)
+- \`vm_inspect_ui\` with \`element_tree\` on the target window
+- If the tree exposes text values, this is the most reliable method
+- Use \`element_at_point\` for specific fields
+- Use \`focused_element\` to read the current field
+
+### Priority 2: Open Accessible Dialogs
+- Many apps expose more data when you open edit/detail dialogs
+- Double-click on a row or click "Edit" to open a modal — the modal often has better accessibility support
+- Then use \`element_tree\` on the modal
+
+### Priority 3: Clipboard Extraction
+- Use \`vm_execute_script\` to click a field, then Ctrl+A, Ctrl+C
+- Call \`vm_read_clipboard\` to get the copied text
+- Works for individual fields, text areas, and some grid cells
+
+### Priority 4: Keyboard Navigation
+- Tab through fields, reading each via \`vm_inspect_ui\` \`focused_element\`
+- Useful when the accessibility tree returns element structure but not values
+
+### Priority 5: Zoomed Screenshot
+- Use \`vm_screenshot_region\` to crop a specific area for better resolution
+- Only for small text that can't be accessed any other way
+
+### Priority 6: Alternative Application Paths
+- Think creatively! Look for:
+  - Reports or Print menus that export data
+  - List/Search views with better accessibility
+  - CLI tools or command-line interfaces the app provides
+  - Export to CSV/clipboard options
+  - Alternative windows/dialogs that show the same data more accessibly
+- Use \`vm_execute_script\` to run Python code that queries the app's data directly if a CLI or API exists
+
+### Priority 7: Full Screenshot (VERIFICATION ONLY)
+- Full desktop screenshots are for **verifying actions worked**, NOT for reading data
+- If you must use a screenshot to read data, acknowledge it's unreliable and suggest a better approach to the user
+
+## 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_read_clipboard\`** — read clipboard after a copy operation.
+- **\`vm_screenshot_region\`** — crop/zoom a region for better text reading.
+- **\`batch_test_rpa\`** — run the workflow with multiple test inputs.
+
+## Important Rules
+- **VALIDATE BEFORE SAVING** — no exceptions unless user explicitly opts out
+- **Use \`create_rpa_flow\`** — never construct JS wrappers manually
+- **Use \`{{config.variables}}\` for secrets** — never hardcode credentials
+- **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
+- **Handle errors** — try/except with meaningful messages
+- **Keep scripts focused** — one logical action per step`,
+                },
+            },
+        ],
+    }));
+}
+//# sourceMappingURL=build-rpa.js.map

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

@@ -0,0 +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"}

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

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

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

@@ -0,0 +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"}

package/dist/prompts/debug-execution.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { json } from "../helpers.js";
+export function register({ server, client }) {
+    server.prompt("debug-workflow-execution", "Analyze a failed workflow execution and suggest fixes", {
+        workflowId: z.string().describe("Workflow ID to debug"),
+        executionId: z.string().describe("Failed execution ID"),
+    }, async ({ workflowId, executionId }) => {
+        const wId = parseInt(workflowId);
+        const eId = parseInt(executionId);
+        let executionData;
+        let flowsData;
+        try {
+            executionData = await client().getExecution(wId, eId);
+            flowsData = await client().getWorkflowFlows(wId);
+        }
+        catch (e) {
+            return {
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: `Failed to fetch execution data: ${e.message}`,
+                        },
+                    },
+                ],
+            };
+        }
+        return {
+            messages: [
+                {
+                    role: "user",
+                    content: {
+                        type: "text",
+                        text: `Please debug this Laminar workflow execution.
+
+## Workflow Flows (Steps):
+${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.`,
+                    },
+                },
+            ],
+        };
+    });
+}
+//# sourceMappingURL=debug-execution.js.map

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

@@ -0,0 +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"}

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

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

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

@@ -0,0 +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"}

package/dist/prompts/workflow-guide.js

@@ -0,0 +1,175 @@
+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 () => ({
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `Please use this Laminar platform specification when creating or editing workflows:
+
+# Laminar Workflow Specification
+
+## Step Structure
+Every step is a JSON object with these fields:
+- \`name\`: (string) Descriptive name
+- \`description\`: (string) Detailed explanation
+- \`program\`: (string) Code to execute (JS or Python)
+- \`executionOrder\`: (integer) Position in workflow (starts at 1)
+- \`flowType\`: (string) "HTTP_REQUEST", "GENERAL_FUNCTION", "SHELL_SCRIPT", "RPA"
+- \`language\`: (string) "js" or "py" (NOTE: RPA flows must ALWAYS use "js")
+
+## Program Signatures
+**Python (py):**
+\`\`\`python
+def transform(data):
+    # Your logic here
+    return {}
+\`\`\`
+
+**JavaScript (js):**
+\`\`\`javascript
+(data) => {
+    // Your code here
+    return {};
+}
+\`\`\`
+
+## Return Values by flowType
+
+### HTTP_REQUEST
+\`\`\`json
+{
+  "lam.httpRequest": {
+    "method": "GET|POST|PUT|DELETE|PATCH",
+    "url": "String",
+    "headers": "Object (optional)",
+    "pathParams": "Object (optional)",
+    "queryParams": "Object (optional)",
+    "body": "Object (optional)",
+    "authentication": {
+      "type": "basic|bearer|oauth2|apikey",
+      "token": "{{config.token}}"
+    },
+    "retry": { "maxAttempts": "Number" },
+    "pagination": {
+      "next": { "queryParams": {}, "headers": {}, "body": {} },
+      "stopCondition": "JS function receiving ctx",
+      "maxPages": 10
+    },
+    "loopUntil": {
+      "condition": "(ctx) => ctx.response.status === 'completed'",
+      "maxAttempts": 20,
+      "strategy": "exponential",
+      "initialDelay": "2s",
+      "maxDelay": "60s",
+      "multiplier": 2
+    }
+  }
+}
+\`\`\`
+
+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.
+
+RPA flows internally use \`language: "js"\` with the Python embedded in a JS arrow function. Two dispatch patterns exist:
+- **\`lam.httpRequest\`** (Cloudflare Tunnel — default) — sends the script to the VM via HTTP
+- **\`lam.rpa\`** (channelId) — sends via pub/sub channel
+
+The \`create_rpa_flow\` tool handles both patterns via the \`dispatchPattern\` parameter (default: \`cloudflare_tunnel\`).
+
+**NEVER** save raw Python as the program for an RPA flow. **NEVER** manually construct the JS wrapper — use \`create_rpa_flow\`.
+
+### Configuration Updates
+\`\`\`json
+{
+  "lam.updateConfig": {
+    "configurationId": "my-config",
+    "properties": [{ "key": "k", "value": "v" }],
+    "createIfNotExists": true,
+    "configurationName": "Auto-generated Config"
+  }
+}
+\`\`\`
+
+### Redis Key-Value Store
+\`\`\`json
+{
+  "lam.kvStore": {
+    "operation": "set|get|delete|exists|list|increment|decrement|transaction",
+    "key": "user:session:token",
+    "value": {},
+    "ttl": 3600,
+    "redisUrl": "{{config.redisUrl}}"
+  }
+}
+\`\`\`
+
+### Cron Job Management
+\`\`\`json
+{
+  "lam.cron": {
+    "operation": "create|update|delete",
+    "name": "Daily Report",
+    "schedule": "0 0 9 * * *",
+    "url": "https://api.laminar.run/workflow/execute/external/{id}?api_key=key",
+    "body": {}
+  }
+}
+\`\`\`
+
+### Custom Response (lam.response)
+\`\`\`json
+{
+  "lam.response": {
+    "statusCode": 200,
+    "message": "Success",
+    "data": {},
+    "error": { "code": "ERROR_CODE", "message": "Error description" }
+  }
+}
+\`\`\`
+Note: Workflow exits immediately when lam.response is encountered.
+
+## Data Access Patterns
+- \`data.input\`: Original workflow input
+- \`data.step_N.response\`: HTTP request output from step N
+- \`data.step_N.data\`: General function output from step N
+- \`data.step_N.stdout\`: Shell output from step N
+- \`data.step_N.stderr\`: Shell error from step N
+- \`data.step_N.cronJobId\`: Cron job ID from step N
+- \`data.step_N.response["lam.kvStore.value"]\`: KV store value
+- \`data.step_N.response["lam.binaryDataId"]\`: File download reference
+
+## Available Libraries
+- **Python:** json, datetime, math, statistics, collections, itertools, functools, re, copy, decimal, csv, io, dataclasses, typing, enum
+- **JavaScript:** lodash (as _), date-fns (format, parseISO)
+
+## Security
+Use \`{{config.variableName}}\` for sensitive values (API keys, tokens, passwords). These reference configuration store properties.
+
+## Best Practices
+1. **Minimize steps** — combine operations when logical, fewer steps = faster execution
+2. **Don't JSON.stringify request bodies** — pass objects directly
+3. **File downloads** auto-create \`lam.binaryDataId\` — don't process as text
+4. **Use {{config.variables}}** for sensitive data, not hardcoded values
+5. **Access errors** via \`data.step_N.response.error\` and \`data.step_N.response.statusCode\``,
+                },
+            },
+        ],
+    }));
+}
+//# sourceMappingURL=workflow-guide.js.map

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

@@ -0,0 +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"}

package/dist/services.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Optional service clients: Elasticsearch + CRON.
+ * Only instantiated when configured — otherwise tools degrade gracefully.
+ */
+import type { ElasticsearchConfig, CronConfig } from "./config.js";
+export interface ESSearchParams {
+    workspaceId: string;
+    workflowId?: string;
+    workflowIds?: string[];
+    query?: string;
+    startDate?: string;
+    endDate?: string;
+    status?: string;
+    includeGlobalObject?: boolean;
+    rawQuery?: string;
+    fuzzy?: boolean;
+    size?: number;
+    from?: number;
+}
+export declare class ElasticsearchService {
+    private endpoint;
+    private apiKey;
+    private indexName;
+    constructor(config: ElasticsearchConfig);
+    private esRequest;
+    search(params: ESSearchParams): Promise<{
+        warning?: string | undefined;
+        hits: any;
+        total: any;
+        took: any;
+    }>;
+    private formatResults;
+}
+export declare class CronService {
+    private apiBase;
+    private apiKey;
+    constructor(config: CronConfig);
+    private request;
+    listJobs(workflowId?: string): Promise<any[]>;
+    getJob(jobId: string): Promise<any>;
+    createJob(job: {
+        name: string;
+        schedule: string;
+        url: string;
+        body?: Record<string, any>;
+        enabled?: boolean;
+        max_runs?: number | null;
+        is_temporary?: boolean;
+    }): Promise<any>;
+    updateJob(jobId: string, updates: {
+        name?: string;
+        schedule?: string;
+        url?: string;
+        body?: Record<string, any>;
+        enabled?: boolean;
+    }): Promise<any>;
+    toggleJob(jobId: string): Promise<any>;
+    deleteJob(jobId: string): Promise<void>;
+    triggerJob(jobId: string): Promise<void>;
+}
+//# sourceMappingURL=services.d.ts.map

package/dist/services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../src/services.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAOnE,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAS;gBAEd,MAAM,EAAE,mBAAmB;YAMzB,SAAS;IAmBjB,MAAM,CAAC,MAAM,EAAE,cAAc;;;;;;IAmJnC,OAAO,CAAC,aAAa;CAyBtB;AAID,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAS;gBAEX,MAAM,EAAE,UAAU;YAKhB,OAAO;IA+Bf,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM;IAY5B,MAAM,CAAC,KAAK,EAAE,MAAM;IAKpB,SAAS,CAAC,GAAG,EAAE;QACnB,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,GAAG,EAAE,MAAM,CAAC;QACZ,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC3B,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACzB,YAAY,CAAC,EAAE,OAAO,CAAC;KACxB;IASK,SAAS,CACb,KAAK,EAAE,MAAM,EACb,OAAO,EAAE;QACP,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC3B,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB;IAUG,SAAS,CAAC,KAAK,EAAE,MAAM;IAKvB,SAAS,CAAC,KAAK,EAAE,MAAM;IAIvB,UAAU,CAAC,KAAK,EAAE,MAAM;CAG/B"}