@hotmeshio/long-tail 0.1.0

package/build/system/mcp-servers/playwright-cli/schemas.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitFormSchema = exports.extractContentSchema = exports.captureAuthenticatedPagesSchema = exports.capturePageSchema = exports.loginAndCaptureSchema = void 0;
+const zod_1 = require("zod");
+exports.loginAndCaptureSchema = zod_1.z.object({
+    url: zod_1.z.string().describe('Login page URL'),
+    username_selector: zod_1.z.string().describe('CSS selector for username input (e.g. #username)'),
+    password_selector: zod_1.z.string().describe('CSS selector for password input (e.g. #password)'),
+    username: zod_1.z.string().describe('Username value'),
+    password: zod_1.z.string().describe('Password value'),
+    submit_selector: zod_1.z.string().describe('CSS selector for submit button (e.g. button[type="submit"])'),
+    wait_after_login: zod_1.z.string().optional()
+        .describe('CSS selector or URL substring to wait for after login. For SPAs, use a URL pattern like "/dashboard" to wait until the URL changes.'),
+    screenshot_path: zod_1.z.string().optional()
+        .describe('Path to save a post-login screenshot'),
+    full_page: zod_1.z.boolean().optional().describe('Full-page screenshot (default: false)'),
+    timeout: zod_1.z.number().optional().describe('Max wait time in ms (default: 30000)'),
+});
+exports.capturePageSchema = zod_1.z.object({
+    url: zod_1.z.string().describe('URL to navigate to and capture'),
+    screenshot_path: zod_1.z.string().optional()
+        .describe('File path to save the screenshot PNG. If omitted, auto-derived from the URL path (e.g., /admin/users → screenshots/admin-users.png).'),
+    page_id: zod_1.z.string().optional().describe('Reuse an existing page to preserve session (e.g., from login_and_capture)'),
+    full_page: zod_1.z.boolean().optional().describe('Capture full scrollable page (default: true)'),
+    wait_for_selector: zod_1.z.string().optional()
+        .describe('CSS selector to wait for before capturing (ensures content is loaded)'),
+    wait_ms: zod_1.z.number().optional()
+        .describe('Fixed delay in ms after page load before capturing (default: 2000). Use when no specific selector to wait for.'),
+    wait_until: zod_1.z.enum(['load', 'domcontentloaded', 'networkidle']).optional()
+        .describe('Navigation wait strategy (default: load)'),
+    timeout: zod_1.z.number().optional().describe('Max navigation timeout in ms (default: 30000)'),
+});
+exports.captureAuthenticatedPagesSchema = zod_1.z.object({
+    login: zod_1.z.object({
+        url: zod_1.z.string(),
+        username_selector: zod_1.z.string(),
+        password_selector: zod_1.z.string(),
+        username: zod_1.z.string(),
+        password: zod_1.z.string(),
+        submit_selector: zod_1.z.string(),
+        wait_after_login: zod_1.z.string().optional(),
+        timeout: zod_1.z.number().optional(),
+    }).describe('Login parameters — same shape as login_and_capture'),
+    pages: zod_1.z.array(zod_1.z.object({
+        url: zod_1.z.string().describe('URL to navigate to'),
+        screenshot_path: zod_1.z.string().describe('Path to save screenshot'),
+        wait_for_selector: zod_1.z.string().optional(),
+        wait_ms: zod_1.z.number().optional(),
+        full_page: zod_1.z.boolean().optional(),
+    })).describe('Pages to capture after login — session is shared across all'),
+});
+exports.extractContentSchema = zod_1.z.object({
+    url: zod_1.z.string().optional().describe('URL to navigate to. Omit to extract from an existing page (requires page_id).'),
+    page_id: zod_1.z.string().optional().describe('Reuse an existing page (e.g., from login_and_capture). Skips navigation if url is also omitted.'),
+    selector: zod_1.z.string().optional().describe('CSS selector to extract text from'),
+    script: zod_1.z.string().optional().describe('Custom JavaScript to evaluate and return data'),
+    extract_links: zod_1.z.boolean().optional().describe('Also extract all links from the page'),
+    extract_metadata: zod_1.z.boolean().optional().describe('Also extract meta title, description, and OG tags'),
+    wait_for_selector: zod_1.z.string().optional().describe('Wait for this selector before extracting'),
+    wait_ms: zod_1.z.number().optional().describe('Fixed delay before extraction (default: 1000)'),
+    timeout: zod_1.z.number().optional(),
+});
+exports.submitFormSchema = zod_1.z.object({
+    url: zod_1.z.string().describe('Form page URL'),
+    fields: zod_1.z.array(zod_1.z.object({
+        selector: zod_1.z.string().describe('CSS selector for the input'),
+        value: zod_1.z.string().describe('Value to fill'),
+    })).describe('Fields to fill before submitting'),
+    submit_selector: zod_1.z.string().describe('CSS selector for the submit button'),
+    wait_after_submit: zod_1.z.string().optional()
+        .describe('CSS selector or URL pattern to wait for after submit'),
+    screenshot_path: zod_1.z.string().optional().describe('Path to save post-submit screenshot'),
+    full_page: zod_1.z.boolean().optional(),
+    timeout: zod_1.z.number().optional(),
+});

package/build/system/mcp-servers/playwright-cli/tools-auth.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerAuthTools(srv: McpServer): void;

package/build/system/mcp-servers/playwright-cli/tools-auth.js

@@ -0,0 +1,183 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAuthTools = registerAuthTools;
+const path = __importStar(require("path"));
+const logger_1 = require("../../../services/logger");
+const playwright_1 = require("../playwright");
+const schemas_1 = require("./schemas");
+const helpers_1 = require("./helpers");
+function registerAuthTools(srv) {
+    // login_and_capture
+    srv.registerTool('login_and_capture', {
+        title: 'Login & Capture',
+        description: 'Log into a website and optionally capture a screenshot of the authenticated page. ' +
+            'Handles navigation, credential entry, form submission, and post-login waiting in one call. ' +
+            'Returns a page handle for use with other tools. ' +
+            'PREFERRED over separate navigate/fill/click calls for login flows. ' +
+            'Common selectors: #username / #password / button[type="submit"]. ' +
+            'If unsure about selectors, use extract_content first to discover the page structure.',
+        inputSchema: schemas_1.loginAndCaptureSchema,
+    }, async (args) => {
+        try {
+            const b = await (0, playwright_1.ensureBrowser)();
+            const page = await b.newPage();
+            const pageId = (0, playwright_1.allocatePageId)();
+            playwright_1.pages.set(pageId, page);
+            const timeout = args.timeout ?? 30_000;
+            // Navigate to login page
+            await page.goto(args.url, { waitUntil: 'load', timeout });
+            // Fill credentials and submit
+            await page.fill(args.username_selector, args.username, { timeout });
+            await page.fill(args.password_selector, args.password, { timeout });
+            await page.click(args.submit_selector, { timeout });
+            // Wait for post-login indicator
+            if (args.wait_after_login) {
+                const indicator = args.wait_after_login;
+                if (indicator.startsWith('/') || indicator.startsWith('http')) {
+                    // URL pattern — wait until URL contains this string
+                    await page.waitForFunction((pattern) => window.location.href.includes(pattern), indicator.startsWith('http') ? indicator : indicator, { timeout });
+                    // Extra settle time for SPA data loading
+                    await page.waitForTimeout(2000);
+                }
+                else {
+                    // CSS selector
+                    await page.waitForSelector(indicator, { timeout });
+                }
+            }
+            else {
+                // Default: wait for URL to change from login page
+                const loginUrl = args.url;
+                await page.waitForFunction((url) => !window.location.href.includes(url), loginUrl.replace(/https?:\/\/[^/]+/, ''), { timeout });
+                await page.waitForTimeout(2000);
+            }
+            // Optional screenshot — handle directory-only paths gracefully
+            let screenshot;
+            if (args.screenshot_path) {
+                let screenshotPath = args.screenshot_path;
+                if (!path.extname(screenshotPath)) {
+                    screenshotPath = screenshotPath.replace(/\/$/, '') + '/home.png';
+                }
+                screenshot = await (0, helpers_1.saveScreenshot)(page, screenshotPath, args.full_page ?? true);
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            page_id: pageId,
+                            url: page.url(),
+                            title: await page.title(),
+                            logged_in: true,
+                            screenshot,
+                            _handle: (0, playwright_1.buildHandle)(pageId),
+                        }),
+                    }],
+            };
+        }
+        catch (err) {
+            logger_1.loggerRegistry.error(`[lt-mcp:playwright-cli] login_and_capture error: ${err.message}`);
+            return (0, helpers_1.errorResult)(err.message, err.name === 'TimeoutError' ? 'TIMEOUT' : 'LOGIN_FAILED');
+        }
+    });
+    // capture_authenticated_pages
+    srv.registerTool('capture_authenticated_pages', {
+        title: 'Capture Authenticated Pages',
+        description: 'Log in once, then navigate to multiple URLs capturing a screenshot of each. ' +
+            'Reuses the same browser page so the authenticated session persists across all captures. ' +
+            'PREFERRED for "login then screenshot all pages" tasks — handles the entire flow in one call.',
+        inputSchema: schemas_1.captureAuthenticatedPagesSchema,
+    }, async (args) => {
+        try {
+            const login = args.login;
+            const b = await (0, playwright_1.ensureBrowser)();
+            const page = await b.newPage();
+            const pageId = (0, playwright_1.allocatePageId)();
+            playwright_1.pages.set(pageId, page);
+            const timeout = login.timeout ?? 30_000;
+            // Login sequence
+            await page.goto(login.url, { waitUntil: 'load', timeout });
+            await page.fill(login.username_selector, login.username, { timeout });
+            await page.fill(login.password_selector, login.password, { timeout });
+            await page.click(login.submit_selector, { timeout });
+            if (login.wait_after_login) {
+                const indicator = login.wait_after_login;
+                if (indicator.startsWith('/') || indicator.startsWith('http')) {
+                    await page.waitForFunction((pattern) => window.location.href.includes(pattern), indicator, { timeout });
+                    await page.waitForTimeout(2000);
+                }
+                else {
+                    await page.waitForSelector(indicator, { timeout });
+                }
+            }
+            else {
+                const loginPath = login.url.replace(/https?:\/\/[^/]+/, '');
+                await page.waitForFunction((path) => !window.location.href.includes(path), loginPath, { timeout });
+                await page.waitForTimeout(2000);
+            }
+            // Capture each page (same browser page = same session)
+            const captures = [];
+            for (const target of args.pages) {
+                await page.goto(target.url, { waitUntil: 'load', timeout: 30_000 });
+                if (target.wait_for_selector) {
+                    await page.waitForSelector(target.wait_for_selector, { timeout: 10_000 });
+                }
+                else {
+                    await page.waitForTimeout(target.wait_ms ?? 3000);
+                }
+                const shot = await (0, helpers_1.saveScreenshot)(page, target.screenshot_path, target.full_page ?? true);
+                captures.push({
+                    url: page.url(),
+                    title: await page.title(),
+                    ...shot,
+                });
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            page_id: pageId,
+                            login_url: login.url,
+                            captures,
+                            total: captures.length,
+                            _handle: (0, playwright_1.buildHandle)(pageId),
+                        }),
+                    }],
+            };
+        }
+        catch (err) {
+            return (0, helpers_1.errorResult)(err.message, err.name === 'TimeoutError' ? 'TIMEOUT' : 'CAPTURE_FAILED');
+        }
+    });
+}

package/build/system/mcp-servers/playwright-cli/tools-capture.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerCaptureTools(srv: McpServer): void;

package/build/system/mcp-servers/playwright-cli/tools-capture.js

@@ -0,0 +1,267 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCaptureTools = registerCaptureTools;
+const path = __importStar(require("path"));
+const logger_1 = require("../../../services/logger");
+const playwright_1 = require("../playwright");
+const schemas_1 = require("./schemas");
+const helpers_1 = require("./helpers");
+function registerCaptureTools(srv) {
+    // capture_page
+    srv.registerTool('capture_page', {
+        title: 'Capture Page',
+        description: 'Navigate to a URL and capture a screenshot in one call. ' +
+            'Optionally waits for a CSS selector or a fixed delay to ensure content is loaded. ' +
+            'Pass page_id from a prior login_and_capture to reuse the authenticated session.',
+        inputSchema: schemas_1.capturePageSchema,
+    }, async (args) => {
+        try {
+            let page;
+            let pageId;
+            if (args.page_id && playwright_1.pages.has(args.page_id)) {
+                const existingPage = playwright_1.pages.get(args.page_id);
+                try {
+                    await existingPage.evaluate('1');
+                    page = existingPage;
+                    pageId = args.page_id;
+                }
+                catch {
+                    playwright_1.pages.delete(args.page_id);
+                    const b = await (0, playwright_1.ensureBrowser)();
+                    page = await b.newPage();
+                    pageId = (0, playwright_1.allocatePageId)();
+                    playwright_1.pages.set(pageId, page);
+                }
+            }
+            else {
+                const b = await (0, playwright_1.ensureBrowser)();
+                page = await b.newPage();
+                pageId = (0, playwright_1.allocatePageId)();
+                playwright_1.pages.set(pageId, page);
+            }
+            await page.goto(args.url, {
+                waitUntil: args.wait_until || 'load',
+                timeout: args.timeout ?? 30_000,
+            });
+            if (args.wait_for_selector) {
+                await page.waitForSelector(args.wait_for_selector, { timeout: args.timeout ?? 10_000 });
+            }
+            else {
+                await page.waitForTimeout(args.wait_ms ?? 2000);
+            }
+            // Auto-derive screenshot path from URL if not provided
+            const screenshotPath = args.screenshot_path || (() => {
+                try {
+                    const urlPath = new URL(args.url).pathname;
+                    const slug = urlPath === '/' ? 'home' : urlPath.replace(/^\/+|\/+$/g, '').replace(/\//g, '-');
+                    return `screenshots/${slug || 'page'}.png`;
+                }
+                catch {
+                    return `screenshots/capture-${Date.now()}.png`;
+                }
+            })();
+            const screenshot = await (0, helpers_1.saveScreenshot)(page, screenshotPath, args.full_page ?? true);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            page_id: pageId,
+                            url: page.url(),
+                            title: await page.title(),
+                            ...screenshot,
+                            _handle: (0, playwright_1.buildHandle)(pageId),
+                        }),
+                    }],
+            };
+        }
+        catch (err) {
+            return (0, helpers_1.errorResult)(err.message, err.name === 'TimeoutError' ? 'TIMEOUT' : 'CAPTURE_FAILED');
+        }
+    });
+    // extract_content
+    srv.registerTool('extract_content', {
+        title: 'Extract Content',
+        description: 'Navigate to a URL and extract structured content. ' +
+            'Extracts page title and text by default. Optionally extracts links, metadata, ' +
+            'text from a specific CSS selector, or runs custom JavaScript.',
+        inputSchema: schemas_1.extractContentSchema,
+    }, async (args) => {
+        try {
+            let page;
+            let pageId;
+            if (args.page_id && playwright_1.pages.has(args.page_id)) {
+                // Reuse existing page (e.g., from login_and_capture)
+                const existingPage = playwright_1.pages.get(args.page_id);
+                // Verify page is still usable (not closed)
+                try {
+                    await existingPage.evaluate('1');
+                    page = existingPage;
+                    pageId = args.page_id;
+                    if (args.url) {
+                        await page.goto(args.url, { waitUntil: 'load', timeout: args.timeout ?? 30_000 });
+                    }
+                }
+                catch {
+                    // Page is stale/closed — clean it up and fall through to create new page
+                    playwright_1.pages.delete(args.page_id);
+                    logger_1.loggerRegistry.info(`[lt-mcp:playwright-cli] extract_content: page_id ${args.page_id} is stale, creating fresh page`);
+                    if (!args.url) {
+                        return (0, helpers_1.errorResult)('page_id is stale and no url provided as fallback', 'STALE_PAGE');
+                    }
+                    const b = await (0, playwright_1.ensureBrowser)();
+                    page = await b.newPage();
+                    pageId = (0, playwright_1.allocatePageId)();
+                    playwright_1.pages.set(pageId, page);
+                    await page.goto(args.url, { waitUntil: 'load', timeout: args.timeout ?? 30_000 });
+                }
+            }
+            else {
+                if (!args.url) {
+                    return (0, helpers_1.errorResult)('Either url or a valid page_id is required', 'MISSING_PARAMS');
+                }
+                const b = await (0, playwright_1.ensureBrowser)();
+                page = await b.newPage();
+                pageId = (0, playwright_1.allocatePageId)();
+                playwright_1.pages.set(pageId, page);
+                await page.goto(args.url, { waitUntil: 'load', timeout: args.timeout ?? 30_000 });
+            }
+            if (args.wait_for_selector) {
+                await page.waitForSelector(args.wait_for_selector, { timeout: args.timeout ?? 10_000 });
+            }
+            else {
+                await page.waitForTimeout(args.wait_ms ?? 1000);
+            }
+            const result = {
+                url: page.url(),
+                title: await page.title(),
+            };
+            // Extract text from selector
+            if (args.selector) {
+                result.content = await page.$$eval(args.selector, (els) => els.map((el) => el.innerText).join('\n'));
+            }
+            else {
+                result.content = await page.evaluate(() => document.body.innerText.slice(0, 5000));
+            }
+            // Custom script
+            if (args.script) {
+                result.script_result = await page.evaluate(args.script);
+            }
+            // Links
+            if (args.extract_links) {
+                result.links = await page.$$eval('a[href]', (els) => els.map((a) => ({ text: a.textContent?.trim(), href: a.href }))
+                    .filter((l) => l.href && !l.href.startsWith('javascript:')));
+            }
+            // Metadata
+            if (args.extract_metadata) {
+                result.metadata = await page.evaluate(() => ({
+                    title: document.title,
+                    description: document.querySelector('meta[name="description"]')?.getAttribute('content'),
+                    og_title: document.querySelector('meta[property="og:title"]')?.getAttribute('content'),
+                    og_description: document.querySelector('meta[property="og:description"]')?.getAttribute('content'),
+                    og_image: document.querySelector('meta[property="og:image"]')?.getAttribute('content'),
+                }));
+            }
+            result.page_id = pageId;
+            result._handle = (0, playwright_1.buildHandle)(pageId);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result) }],
+            };
+        }
+        catch (err) {
+            return (0, helpers_1.errorResult)(err.message, err.name === 'TimeoutError' ? 'TIMEOUT' : 'EXTRACT_FAILED');
+        }
+    });
+    // submit_form
+    srv.registerTool('submit_form', {
+        title: 'Submit Form',
+        description: 'Navigate to a form page, fill multiple fields, submit, and capture the result. ' +
+            'Handles navigation, field filling, form submission, and post-submit waiting in one call.',
+        inputSchema: schemas_1.submitFormSchema,
+    }, async (args) => {
+        try {
+            const b = await (0, playwright_1.ensureBrowser)();
+            const page = await b.newPage();
+            const pageId = (0, playwright_1.allocatePageId)();
+            playwright_1.pages.set(pageId, page);
+            const timeout = args.timeout ?? 30_000;
+            await page.goto(args.url, { waitUntil: 'load', timeout });
+            // Fill all fields
+            for (const field of args.fields) {
+                await page.fill(field.selector, field.value, { timeout });
+            }
+            // Submit
+            await page.click(args.submit_selector, { timeout });
+            // Wait for result
+            if (args.wait_after_submit) {
+                const indicator = args.wait_after_submit;
+                if (indicator.startsWith('/') || indicator.startsWith('http')) {
+                    await page.waitForFunction((pattern) => window.location.href.includes(pattern), indicator, { timeout });
+                }
+                else {
+                    await page.waitForSelector(indicator, { timeout });
+                }
+            }
+            else {
+                await page.waitForTimeout(2000);
+            }
+            // Optional screenshot — handle directory-only paths gracefully
+            let screenshot;
+            if (args.screenshot_path) {
+                let screenshotPath = args.screenshot_path;
+                if (!path.extname(screenshotPath)) {
+                    screenshotPath = screenshotPath.replace(/\/$/, '') + '/result.png';
+                }
+                screenshot = await (0, helpers_1.saveScreenshot)(page, screenshotPath, args.full_page ?? true);
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            page_id: pageId,
+                            result_url: page.url(),
+                            result_title: await page.title(),
+                            screenshot,
+                            _handle: (0, playwright_1.buildHandle)(pageId),
+                        }),
+                    }],
+            };
+        }
+        catch (err) {
+            logger_1.loggerRegistry.error(`[lt-mcp:playwright-cli] submit_form error: ${err.message}`);
+            return (0, helpers_1.errorResult)(err.message, err.name === 'TimeoutError' ? 'TIMEOUT' : 'SUBMIT_FAILED');
+        }
+    });
+}

package/build/system/mcp-servers/prompts.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Build the translation system prompt for the given target language.
+ */
+export declare function TRANSLATE_SYSTEM_PROMPT(targetLanguage: string): string;

package/build/system/mcp-servers/prompts.js

@@ -0,0 +1,10 @@
+"use strict";
+// ── Document Vision prompts ─────────────────────────────────────────────────
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRANSLATE_SYSTEM_PROMPT = TRANSLATE_SYSTEM_PROMPT;
+/**
+ * Build the translation system prompt for the given target language.
+ */
+function TRANSLATE_SYSTEM_PROMPT(targetLanguage) {
+    return `You are a translation assistant. Translate the user's text to ${targetLanguage}. Return ONLY a JSON object: {"translated_content": "...", "source_language": "detected ISO code"}. No markdown, no explanation.`;
+}

package/build/system/mcp-servers/workflow-compiler.d.ts

@@ -0,0 +1,15 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Create the Workflow Compiler MCP server.
+ *
+ * Provides tools for converting MCP tool call sequences into
+ * deterministic HotMesh YAML workflows:
+ * - convert_execution_to_yaml — analyze execution and generate YAML
+ * - deploy_yaml_workflow — deploy and optionally activate
+ * - list_yaml_workflows — list stored YAML workflows
+ */
+export declare function createWorkflowCompilerServer(options?: {
+    name?: string;
+}): Promise<McpServer>;
+export declare function getWorkflowCompilerServer(): McpServer | null;
+export declare function stopWorkflowCompilerServer(): Promise<void>;