@sxl-studio/bridge 1.7.1 → 1.7.3

package/dist/bridge-live-validation.js

@@ -0,0 +1,1141 @@
+import { getBridgePackageVersion } from "./bridge-version.js";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { generateCodeConnectTemplate } from "./codeconnect-template.js";
+import { runMcpRuntimeProbe } from "./mcp-runtime-probe.js";
+import { registerDataTools } from "./tools/data.js";
+function normalizeBaseUrl(baseUrl) {
+    return baseUrl.replace(/\/+$/, "");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function addFinding(findings, finding) {
+    findings.push(finding);
+}
+function statusFromFindings(findings) {
+    if (findings.some((finding) => finding.severity === "error"))
+        return "fail";
+    if (findings.some((finding) => finding.severity === "warning"))
+        return "warn";
+    return "pass";
+}
+async function fetchJson(options) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs);
+    try {
+        const headers = {};
+        if (options.authToken)
+            headers.Authorization = `Bearer ${options.authToken}`;
+        if (options.body !== undefined)
+            headers["Content-Type"] = "application/json";
+        const response = await options.fetchImpl(`${options.baseUrl}${options.endpoint}`, {
+            method: options.method ?? "GET",
+            headers,
+            body: options.body === undefined ? undefined : JSON.stringify(options.body),
+            signal: controller.signal,
+        });
+        const text = await response.text();
+        let body = null;
+        if (text.trim().length > 0) {
+            try {
+                body = JSON.parse(text);
+            }
+            catch {
+                body = text;
+            }
+        }
+        return { status: response.status, body };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function asEnvelope(body) {
+    return isRecord(body) ? body : {};
+}
+function decodeCommandError(error) {
+    if (!error)
+        return "Command failed.";
+    try {
+        const parsed = JSON.parse(error);
+        if (isRecord(parsed) && typeof parsed["message"] === "string") {
+            return parsed["message"];
+        }
+    }
+    catch {
+        // Plain command errors are already human-readable.
+    }
+    return error;
+}
+async function validateHttpEndpoint(options) {
+    const startedAt = Date.now();
+    const response = await fetchJson(options);
+    const durationMs = Date.now() - startedAt;
+    if (response.status === 401) {
+        addFinding(options.findings, {
+            severity: "error",
+            code: "LIVE_UNAUTHORIZED",
+            message: "Bridge requires Authorization. Pass --auth-token or set BRIDGE_AUTH_TOKEN.",
+            step: options.name,
+        });
+        return { name: options.name, kind: "http", ok: false, status: "fail", durationMs };
+    }
+    if (response.status < 200 || response.status >= 300) {
+        addFinding(options.findings, {
+            severity: "error",
+            code: "LIVE_HTTP_FAILED",
+            message: `GET ${options.endpoint} returned HTTP ${response.status}.`,
+            step: options.name,
+        });
+        return { name: options.name, kind: "http", ok: false, status: "fail", durationMs };
+    }
+    const validation = options.validate(response.body);
+    if (!validation.ok) {
+        addFinding(options.findings, {
+            severity: "error",
+            code: validation.error ? "LIVE_HTTP_STATUS_FAILED" : "LIVE_HTTP_SHAPE_INVALID",
+            message: validation.error ?? `GET ${options.endpoint} did not return the expected shape.`,
+            step: options.name,
+        });
+        return {
+            name: options.name,
+            kind: "http",
+            ok: false,
+            status: "fail",
+            durationMs,
+            details: validation.details,
+        };
+    }
+    if (validation.warning) {
+        addFinding(options.findings, {
+            severity: "warning",
+            code: "LIVE_HTTP_WARNING",
+            message: validation.warning,
+            step: options.name,
+        });
+    }
+    return {
+        name: options.name,
+        kind: "http",
+        ok: true,
+        status: validation.warning ? "warn" : "pass",
+        durationMs,
+        details: validation.details,
+    };
+}
+async function validateMcpStreamableHttp(options) {
+    const startedAt = Date.now();
+    const result = await runMcpRuntimeProbe(options);
+    for (const warning of result.warnings) {
+        addFinding(options.findings, {
+            severity: "warning",
+            code: warning.code,
+            message: warning.message,
+            step: "runtime.mcpStreamableHttp",
+        });
+    }
+    if (!result.ok) {
+        addFinding(options.findings, {
+            severity: "error",
+            code: result.error?.code ?? "MCP_STREAMABLE_HTTP_FAILED",
+            message: result.error?.message ?? "MCP /mcp probe failed.",
+            step: "runtime.mcpStreamableHttp",
+        });
+    }
+    return {
+        name: "runtime.mcpStreamableHttp",
+        kind: "mcp",
+        ok: result.ok,
+        status: result.ok ? result.warnings.length > 0 ? "warn" : "pass" : "fail",
+        durationMs: Date.now() - startedAt,
+        details: result.details,
+    };
+}
+async function runCommand(options) {
+    const startedAt = Date.now();
+    const response = await fetchJson({
+        ...options,
+        endpoint: "/api/command",
+        method: "POST",
+        body: {
+            commandType: options.commandType,
+            payload: options.payload ?? {},
+        },
+    });
+    const durationMs = Date.now() - startedAt;
+    if (response.status === 401) {
+        addFinding(options.findings, {
+            severity: "error",
+            code: "LIVE_UNAUTHORIZED",
+            message: "Bridge requires Authorization. Pass --auth-token or set BRIDGE_AUTH_TOKEN.",
+            step: options.commandType,
+        });
+        return {
+            step: { name: options.commandType, kind: "command", commandType: options.commandType, ok: false, status: "fail", durationMs },
+            result: null,
+        };
+    }
+    if (response.status === 503) {
+        addFinding(options.findings, {
+            severity: "error",
+            code: "LIVE_PLUGIN_NOT_CONNECTED",
+            message: "No plugin is connected to Bridge.",
+            step: options.commandType,
+        });
+        return {
+            step: { name: options.commandType, kind: "command", commandType: options.commandType, ok: false, status: "fail", durationMs },
+            result: null,
+        };
+    }
+    if (response.status < 200 || response.status >= 300) {
+        addFinding(options.findings, {
+            severity: "error",
+            code: "LIVE_COMMAND_HTTP_FAILED",
+            message: `POST /api/command ${options.commandType} returned HTTP ${response.status}.`,
+            step: options.commandType,
+        });
+        return {
+            step: { name: options.commandType, kind: "command", commandType: options.commandType, ok: false, status: "fail", durationMs },
+            result: null,
+        };
+    }
+    const envelope = asEnvelope(response.body);
+    if (envelope.status !== "completed") {
+        addFinding(options.findings, {
+            severity: "error",
+            code: "LIVE_COMMAND_FAILED",
+            message: `${options.commandType} failed: ${decodeCommandError(envelope.error)}`,
+            step: options.commandType,
+        });
+        return {
+            step: {
+                name: options.commandType,
+                kind: "command",
+                commandType: options.commandType,
+                ok: false,
+                status: "fail",
+                durationMs: typeof envelope.durationMs === "number" ? envelope.durationMs : durationMs,
+                details: { commandStatus: envelope.status ?? null },
+            },
+            result: envelope.result ?? null,
+        };
+    }
+    const validation = options.validate?.(envelope.result);
+    if (validation && !validation.ok) {
+        addFinding(options.findings, {
+            severity: "error",
+            code: "LIVE_COMMAND_RESULT_INVALID",
+            message: `${options.commandType} returned an unexpected result shape.`,
+            step: options.commandType,
+        });
+    }
+    else if (validation?.warning) {
+        addFinding(options.findings, {
+            severity: "warning",
+            code: "LIVE_COMMAND_WARNING",
+            message: validation.warning,
+            step: options.commandType,
+        });
+    }
+    return {
+        step: {
+            name: options.commandType,
+            kind: "command",
+            commandType: options.commandType,
+            ok: validation ? validation.ok : true,
+            status: validation && !validation.ok ? "fail" : validation?.warning ? "warn" : "pass",
+            durationMs: typeof envelope.durationMs === "number" ? envelope.durationMs : durationMs,
+            details: validation?.details,
+        },
+        result: envelope.result ?? null,
+    };
+}
+async function runLocalStep(options) {
+    const startedAt = Date.now();
+    try {
+        const validation = await options.run();
+        if (!validation.ok) {
+            addFinding(options.findings, {
+                severity: "error",
+                code: "LIVE_LOCAL_CHECK_FAILED",
+                message: `${options.name} returned an unexpected result shape.`,
+                step: options.name,
+            });
+        }
+        else if (validation.warning) {
+            addFinding(options.findings, {
+                severity: "warning",
+                code: "LIVE_LOCAL_CHECK_WARNING",
+                message: validation.warning,
+                step: options.name,
+            });
+        }
+        return {
+            name: options.name,
+            kind: "local",
+            ok: validation.ok,
+            status: validation.ok ? validation.warning ? "warn" : "pass" : "fail",
+            durationMs: Date.now() - startedAt,
+            details: validation.details,
+        };
+    }
+    catch (error) {
+        addFinding(options.findings, {
+            severity: "error",
+            code: "LIVE_LOCAL_CHECK_ERROR",
+            message: `${options.name} failed: ${error instanceof Error ? error.message : String(error)}`,
+            step: options.name,
+        });
+        return {
+            name: options.name,
+            kind: "local",
+            ok: false,
+            status: "fail",
+            durationMs: Date.now() - startedAt,
+        };
+    }
+}
+function smokeScreenSpec(dryRun = true) {
+    return {
+        name: `SXL Bridge Live Validation ${new Date().toISOString().slice(0, 19)}`,
+        dryRun,
+        layout: { mode: "VERTICAL", itemSpacing: 8, padding: 16, width: 320 },
+        items: [
+            {
+                kind: "text",
+                name: "Validation Title",
+                value: "SXL Bridge live validation",
+                fontSize: 16,
+            },
+            { kind: "spacer", size: 8 },
+        ],
+    };
+}
+function smokeVariableSpec() {
+    const suffix = new Date().toISOString().slice(0, 10);
+    return {
+        collections: [
+            {
+                collectionName: `SXL Bridge Live Validation/${suffix}`,
+                modes: [{ key: "default", name: "Default" }],
+                variables: [
+                    {
+                        name: "color/live-validation",
+                        type: "COLOR",
+                        valuesByMode: {
+                            default: { value: "#3366ff" },
+                        },
+                    },
+                ],
+            },
+        ],
+        dryRun: true,
+    };
+}
+function smokeStyleSpec() {
+    const suffix = new Date().toISOString().slice(0, 10);
+    return {
+        paintStyles: [
+            {
+                name: `SXL Bridge Live Validation/${suffix}/Paint`,
+                paints: [{ type: "SOLID", color: "#3366ff" }],
+            },
+        ],
+        dryRun: true,
+    };
+}
+function smokeVariableCoverageSuggestion() {
+    return {
+        nodeId: "SXL_BRIDGE_DRY_RUN_NODE",
+        property: "fills[0].color",
+        variableId: "SXL_BRIDGE_DRY_RUN_VARIABLE",
+        variableName: "SXL Bridge Dry Run Variable",
+    };
+}
+function smokeStyleCoverageSuggestion() {
+    return {
+        nodeId: "SXL_BRIDGE_DRY_RUN_NODE",
+        property: "fillStyleId · fills[0]",
+        styleId: "SXL_BRIDGE_DRY_RUN_STYLE",
+        styleName: "SXL Bridge Dry Run Style",
+    };
+}
+function toolsCatalogueValidation(requiredTools) {
+    return (body) => {
+        if (!isRecord(body) || !Array.isArray(body["tools"]))
+            return { ok: false };
+        const tools = body["tools"].filter(isRecord);
+        const names = new Set(tools.map((tool) => typeof tool["name"] === "string" ? tool["name"] : ""));
+        const missing = requiredTools.filter((name) => !names.has(name));
+        const dryRunTemplate = tools.find((tool) => tool["name"] === "generate_code_connect_template");
+        return {
+            ok: missing.length === 0,
+            details: {
+                toolCount: tools.length,
+                missing,
+                hasCodeConnectContext: names.has("get_context_for_code_connect"),
+                hasCodeConnectTemplate: names.has("generate_code_connect_template"),
+                templateDryRunSupported: isRecord(dryRunTemplate) ? dryRunTemplate["dryRunSupported"] === true : false,
+            },
+        };
+    };
+}
+function statusEnvelopeValidation(options) {
+    return (body) => {
+        const shapeOk = isRecord(body) &&
+            typeof body["ok"] === "boolean" &&
+            typeof body["status"] === "string" &&
+            Array.isArray(body[options.requiredArray]) &&
+            isRecord(body["summary"]);
+        const details = isRecord(body) && isRecord(body["summary"]) ? body["summary"] : undefined;
+        if (!shapeOk) {
+            return { ok: false, details };
+        }
+        const summaryCount = details?.[options.summaryCountKey];
+        const countOk = typeof summaryCount === "number" ? summaryCount > 0 : true;
+        if (!countOk) {
+            return {
+                ok: false,
+                details,
+                error: `GET ${options.endpoint} returned an empty ${options.summaryCountKey} summary.`,
+            };
+        }
+        if (body["status"] === "fail" || body["ok"] !== true) {
+            return {
+                ok: false,
+                details,
+                error: `GET ${options.endpoint} reported status=${String(body["status"])}.`,
+            };
+        }
+        return {
+            ok: true,
+            details,
+            warning: body["status"] === "warn" ? `GET ${options.endpoint} reported warnings.` : undefined,
+        };
+    };
+}
+function okObject(result) {
+    return { ok: isRecord(result) };
+}
+function operatorRunbookValidation(body) {
+    const workflows = isRecord(body) && Array.isArray(body["workflows"]) ? body["workflows"] : [];
+    const workflowIds = new Set(workflows
+        .filter(isRecord)
+        .map((workflow) => typeof workflow["id"] === "string" ? workflow["id"] : "")
+        .filter(Boolean));
+    const ok = isRecord(body) &&
+        body["id"] === "sxl-operator-runbook" &&
+        Array.isArray(body["startHere"]) &&
+        Array.isArray(body["globalSafetyRules"]) &&
+        workflowIds.has("draw-or-update-screen") &&
+        workflowIds.has("official-figma-mcp-companion");
+    return {
+        ok,
+        details: { workflowCount: workflows.length },
+        error: ok ? undefined : "GET /api/operator-runbook did not return the expected SXL operator runbook.",
+    };
+}
+function pluginStatusValidation(result) {
+    if (!isRecord(result))
+        return { ok: false };
+    return {
+        ok: typeof result["writesAllowed"] === "boolean" && typeof result["sessionActive"] === "boolean",
+        details: {
+            editorType: typeof result["editorType"] === "string" ? result["editorType"] : null,
+            writesAllowed: result["writesAllowed"] === true,
+            sessionActive: result["sessionActive"] === true,
+        },
+    };
+}
+function listValidation(key) {
+    return (result) => {
+        if (!isRecord(result))
+            return { ok: false };
+        const value = result[key];
+        return {
+            ok: Array.isArray(value),
+            details: { count: Array.isArray(value) ? value.length : null },
+        };
+    };
+}
+function findComponentsValidation(result) {
+    if (!isRecord(result))
+        return { ok: false };
+    const components = Array.isArray(result["components"]) ? result["components"] : [];
+    const summary = isRecord(result["summary"]) ? result["summary"] : {};
+    return {
+        ok: result["ok"] === true && Array.isArray(result["components"]) && isRecord(result["summary"]),
+        details: {
+            returned: summary["returned"] ?? components.length,
+            totalLocal: summary["totalLocal"] ?? null,
+            hasMore: summary["hasMore"] ?? null,
+        },
+    };
+}
+function buildDryRunValidation(result) {
+    if (!isRecord(result))
+        return { ok: false };
+    const summary = isRecord(result["summary"]) ? result["summary"] : {};
+    const errors = Array.isArray(summary["errors"]) ? summary["errors"] : [];
+    return {
+        ok: result["ok"] === true && result["dryRun"] === true && errors.length === 0,
+        details: {
+            dryRun: result["dryRun"] === true,
+            errors: errors.length,
+            totalItems: summary["totalItems"] ?? null,
+        },
+    };
+}
+function auditSummaryValidation(result) {
+    if (!isRecord(result))
+        return { ok: false };
+    return {
+        ok: result["ok"] === true && typeof result["scannedNodes"] === "number",
+        details: {
+            scannedNodes: result["scannedNodes"] ?? null,
+            totalUsages: result["totalUsages"] ?? null,
+        },
+    };
+}
+function coverageSummaryValidation(result) {
+    if (!isRecord(result))
+        return { ok: false };
+    return {
+        ok: typeof result["scannedNodes"] === "number" &&
+            typeof result["missing"] === "number" &&
+            isRecord(result["byProperty"]) &&
+            isRecord(result["byPage"]),
+        details: {
+            scope: typeof result["scope"] === "string" ? result["scope"] : null,
+            scannedNodes: result["scannedNodes"] ?? null,
+            missing: result["missing"] ?? null,
+            withSuggestion: result["withSuggestion"] ?? null,
+            truncated: result["truncated"] === true,
+        },
+    };
+}
+function coveragePageValidation(result) {
+    if (!isRecord(result))
+        return { ok: false };
+    const missingItems = Array.isArray(result["missingItems"]) ? result["missingItems"] : [];
+    return {
+        ok: typeof result["scannedNodes"] === "number" &&
+            typeof result["missing"] === "number" &&
+            Array.isArray(result["missingItems"]),
+        details: {
+            scannedNodes: result["scannedNodes"] ?? null,
+            missing: result["missing"] ?? null,
+            returned: missingItems.length,
+            cursor: typeof result["cursor"] === "string" ? result["cursor"] : null,
+        },
+    };
+}
+function dryRunApplyPreviewValidation(result) {
+    if (!isRecord(result))
+        return { ok: false };
+    const preview = Array.isArray(result["preview"]) ? result["preview"] : [];
+    const errors = Array.isArray(result["errors"]) ? result["errors"] : [];
+    return {
+        ok: result["ok"] === true && result["dryRun"] === true && preview.length > 0 && errors.length === 0,
+        details: {
+            dryRun: result["dryRun"] === true,
+            preview: preview.length,
+            skipped: Array.isArray(result["skipped"]) ? result["skipped"].length : null,
+            errors: errors.length,
+        },
+    };
+}
+function importVariableSpecDryRunValidation(result) {
+    if (!isRecord(result))
+        return { ok: false };
+    const totals = isRecord(result["totals"]) ? result["totals"] : {};
+    return {
+        ok: result["ok"] === true &&
+            result["dryRun"] === true &&
+            Array.isArray(result["collections"]) &&
+            typeof totals["variablesCreated"] === "number",
+        details: {
+            dryRun: result["dryRun"] === true,
+            collections: Array.isArray(result["collections"]) ? result["collections"].length : null,
+            variablesCreated: totals["variablesCreated"] ?? null,
+            errors: totals["errors"] ?? null,
+        },
+    };
+}
+function importStyleSpecDryRunValidation(result) {
+    if (!isRecord(result))
+        return { ok: false };
+    const totals = isRecord(result["totals"]) ? result["totals"] : {};
+    return {
+        ok: result["ok"] === true &&
+            result["dryRun"] === true &&
+            Array.isArray(result["paintStyles"]) &&
+            typeof totals["paintsCreated"] === "number",
+        details: {
+            dryRun: result["dryRun"] === true,
+            paintStyles: Array.isArray(result["paintStyles"]) ? result["paintStyles"].length : null,
+            paintsCreated: totals["paintsCreated"] ?? null,
+            errors: totals["errors"] ?? null,
+        },
+    };
+}
+function dedupeDryRunValidation(result) {
+    if (!isRecord(result))
+        return { ok: false };
+    return {
+        ok: result["ok"] === true && result["dryRun"] === true && Array.isArray(result["groups"]),
+        details: {
+            dryRun: result["dryRun"] === true,
+            groups: Array.isArray(result["groups"]) ? result["groups"].length : null,
+            mergedCount: result["mergedCount"] ?? null,
+            errors: Array.isArray(result["errors"]) ? result["errors"].length : null,
+        },
+    };
+}
+function listCompositionsValidation(result) {
+    if (!isRecord(result))
+        return { ok: false };
+    return {
+        ok: typeof result["count"] === "number" && Array.isArray(result["compositions"]),
+        details: {
+            count: result["count"] ?? null,
+            returned: Array.isArray(result["compositions"]) ? result["compositions"].length : null,
+        },
+    };
+}
+function bulkCompositionDryRunValidation(result) {
+    if (!isRecord(result))
+        return { ok: false };
+    const summary = isRecord(result["summary"]) ? result["summary"] : {};
+    const items = Array.isArray(result["items"]) ? result["items"] : [];
+    return {
+        ok: typeof result["ok"] === "boolean" && result["dryRun"] === true && isRecord(result["summary"]) && Array.isArray(result["items"]),
+        details: {
+            ok: result["ok"] === true,
+            dryRun: result["dryRun"] === true,
+            total: summary["total"] ?? null,
+            processed: summary["processed"] ?? null,
+            failed: summary["failed"] ?? null,
+            items: items.length,
+        },
+    };
+}
+function compositionDriftValidation(result) {
+    if (!isRecord(result))
+        return { ok: false };
+    const summary = isRecord(result["summary"]) ? result["summary"] : {};
+    return {
+        ok: result["ok"] === true && isRecord(result["summary"]) && Array.isArray(result["findings"]),
+        details: {
+            totalCompositions: summary["totalCompositions"] ?? null,
+            linked: summary["linked"] ?? null,
+            unlinked: summary["unlinked"] ?? null,
+            drift: summary["drift"] ?? null,
+            missing: summary["missing"] ?? null,
+            findings: Array.isArray(result["findings"]) ? result["findings"].length : null,
+        },
+    };
+}
+function unusedVariablesValidation(result) {
+    if (!isRecord(result))
+        return { ok: false };
+    return {
+        ok: typeof result["count"] === "number" && typeof result["scannedNodes"] === "number" && Array.isArray(result["variables"]),
+        details: {
+            count: result["count"] ?? null,
+            scannedNodes: result["scannedNodes"] ?? null,
+            returned: Array.isArray(result["variables"]) ? result["variables"].length : null,
+        },
+    };
+}
+function unusedStylesValidation(result) {
+    if (!isRecord(result))
+        return { ok: false };
+    return {
+        ok: typeof result["count"] === "number" && typeof result["scannedNodes"] === "number" && Array.isArray(result["styles"]),
+        details: {
+            count: result["count"] ?? null,
+            scannedNodes: result["scannedNodes"] ?? null,
+            returned: Array.isArray(result["styles"]) ? result["styles"].length : null,
+        },
+    };
+}
+function componentUsagePageValidation(result) {
+    if (!isRecord(result))
+        return { ok: false };
+    const usages = Array.isArray(result["usages"]) ? result["usages"] : [];
+    return {
+        ok: result["ok"] === true && typeof result["scannedNodes"] === "number" && Array.isArray(result["usages"]),
+        details: {
+            scannedNodes: result["scannedNodes"] ?? null,
+            totalUsages: result["totalUsages"] ?? null,
+            returned: usages.length,
+            cursor: typeof result["cursor"] === "string" ? result["cursor"] : null,
+        },
+    };
+}
+function componentPropSummaryValidation(result) {
+    if (!isRecord(result))
+        return { ok: false };
+    return {
+        ok: result["ok"] === true &&
+            typeof result["scannedNodes"] === "number" &&
+            isRecord(result["byProperty"]) &&
+            isRecord(result["byValue"]),
+        details: {
+            scannedNodes: result["scannedNodes"] ?? null,
+            totalUsages: result["totalUsages"] ?? null,
+            propertyCount: isRecord(result["byProperty"]) ? Object.keys(result["byProperty"]).length : null,
+            valueCount: isRecord(result["byValue"]) ? Object.keys(result["byValue"]).length : null,
+        },
+    };
+}
+function docFlowDryRunValidation(result) {
+    if (!isRecord(result))
+        return { ok: false };
+    const pages = Array.isArray(result["pages"]) ? result["pages"] : [];
+    return {
+        ok: result["ok"] === true && result["dryRun"] === true && typeof result["pageCount"] === "number",
+        details: {
+            dryRun: result["dryRun"] === true,
+            pageCount: result["pageCount"] ?? null,
+            returnedPages: pages.length,
+            flowName: typeof result["flowName"] === "string" ? result["flowName"] : null,
+        },
+    };
+}
+function readWritesAllowed(result) {
+    if (!isRecord(result))
+        return null;
+    return typeof result["writesAllowed"] === "boolean" ? result["writesAllowed"] : null;
+}
+async function codeConnectTemplateDryRunValidation() {
+    const root = mkdtempSync(path.join(tmpdir(), "sxl-bridge-live-codeconnect-"));
+    try {
+        const filePath = path.join(root, "src/components/LiveValidationButton.tsx");
+        mkdirSync(path.dirname(filePath), { recursive: true });
+        writeFileSync(filePath, "export function LiveValidationButton() { return <button />; }", "utf8");
+        const result = generateCodeConnectTemplate({
+            rootDir: root,
+            componentNames: ["LiveValidationButton"],
+            repositoryUrl: "https://example.invalid/sxl-live-validation",
+            writeFile: false,
+        });
+        return {
+            ok: result.ok === true &&
+                result.dryRun === true &&
+                result.write.requested === false &&
+                result.write.written === false &&
+                result.template.fileName === "LiveValidationButton.figma.ts" &&
+                result.template.content.includes("figma.code`<LiveValidationButton />`"),
+            details: {
+                dryRun: result.dryRun,
+                written: result.write.written,
+                fileName: result.template.fileName,
+                bytes: result.template.bytes,
+            },
+        };
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+}
+function readLocalToolJson(response) {
+    if (!isRecord(response))
+        return {};
+    const content = response["content"];
+    if (!Array.isArray(content) || !isRecord(content[0]) || typeof content[0]["text"] !== "string")
+        return {};
+    try {
+        const parsed = JSON.parse(content[0]["text"]);
+        return isRecord(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+async function databasePayloadDryRunValidation() {
+    const tools = new Map();
+    const server = {
+        tool: (name, _description, _schema, handler) => {
+            tools.set(name, { handler });
+        },
+    };
+    const calls = [];
+    const queue = {
+        execute: async (commandType, payload = {}) => {
+            calls.push({ commandType, payload });
+            if (commandType === "list_datasets") {
+                return { commandId: "cmd-datasets", status: "completed", result: { ok: true, datasets: [{ id: "ds_live", name: "Live Dataset" }] } };
+            }
+            if (commandType === "get_dataset") {
+                return {
+                    commandId: "cmd-dataset",
+                    status: "completed",
+                    result: { ok: true, dataset: { id: "ds_live", name: "Live Dataset", data: [{ label: "A" }] } },
+                };
+            }
+            if (commandType === "list_assets") {
+                return { commandId: "cmd-assets", status: "completed", result: { ok: true, assets: [{ id: "asset_live", name: "Live Asset" }] } };
+            }
+            if (commandType === "get_asset") {
+                return {
+                    commandId: "cmd-asset",
+                    status: "completed",
+                    result: { ok: true, asset: { id: "asset_live", name: "Live Asset" }, content: "data:image/png;base64,AAA" },
+                };
+            }
+            if (commandType === "list_mappings") {
+                return { commandId: "cmd-mappings", status: "completed", result: { ok: true, mappings: [{ id: "map_live", name: "Live Mapping" }] } };
+            }
+            if (commandType === "get_mapping") {
+                return {
+                    commandId: "cmd-mapping",
+                    status: "completed",
+                    result: { ok: true, mapping: { id: "map_live", name: "Live Mapping", fields: [] } },
+                };
+            }
+            return { commandId: `cmd-${commandType}`, status: "failed", error: `Unexpected command ${commandType}` };
+        },
+    };
+    registerDataTools(server, queue);
+    const exportTool = tools.get("export_database_payload");
+    const importTool = tools.get("import_database_payload");
+    if (!exportTool || !importTool) {
+        return { ok: false, details: { hasExportTool: Boolean(exportTool), hasImportTool: Boolean(importTool) } };
+    }
+    const exportBody = readLocalToolJson(await exportTool.handler({
+        includeAssetContent: true,
+        bridgeResponseMode: "full",
+    }));
+    const importBody = readLocalToolJson(await importTool.handler({
+        payload: exportBody,
+        bridgeResponseMode: "full",
+    }));
+    const writeCalls = calls.filter(({ commandType }) => /^save_|^delete_/.test(commandType));
+    return {
+        ok: exportBody["ok"] === true &&
+            exportBody["kind"] === "sxl-database-payload" &&
+            importBody["ok"] === true &&
+            importBody["dryRun"] === true &&
+            importBody["willCallPlugin"] === false &&
+            writeCalls.length === 0,
+        details: {
+            exportedKind: exportBody["kind"] ?? null,
+            exportCounts: isRecord(exportBody["counts"]) ? exportBody["counts"] : null,
+            importDryRun: importBody["dryRun"] === true,
+            importWillCallPlugin: importBody["willCallPlugin"] ?? null,
+            writeCalls: writeCalls.length,
+        },
+    };
+}
+export async function runBridgeLiveValidation(options = {}) {
+    const findings = [];
+    const steps = [];
+    const baseUrl = normalizeBaseUrl(options.baseUrl ?? `http://127.0.0.1:${process.env["BRIDGE_PORT"] || "37830"}`);
+    const suite = options.suite ?? "baseline";
+    const writeCanary = options.writeCanary === true;
+    const cleanup = options.cleanup === true;
+    if (cleanup && !writeCanary) {
+        addFinding(findings, {
+            severity: "error",
+            code: "LIVE_CLEANUP_REQUIRES_WRITE_CANARY",
+            message: "Live validation cleanup can only run with --write-canary because it deletes the frame created by the canary step.",
+            step: "writeCanary.cleanup",
+        });
+        const status = statusFromFindings(findings);
+        return {
+            ok: false,
+            status,
+            version: 1,
+            bridgeVersion: getBridgePackageVersion(),
+            generatedAt: new Date().toISOString(),
+            baseUrl,
+            suite,
+            writeCanary,
+            cleanup,
+            steps,
+            findings,
+        };
+    }
+    const shared = {
+        baseUrl,
+        authToken: options.authToken ?? process.env["BRIDGE_AUTH_TOKEN"],
+        timeoutMs: options.timeoutMs ?? 30_000,
+        fetchImpl: options.fetchImpl ?? fetch,
+        findings,
+    };
+    steps.push(await validateHttpEndpoint({
+        ...shared,
+        endpoint: "/api/status",
+        name: "runtime.status",
+        validate: (body) => {
+            const statusBody = isRecord(body) ? body : {};
+            const session = isRecord(statusBody["session"]) ? statusBody["session"] : {};
+            const ports = isRecord(statusBody["ports"]) ? statusBody["ports"] : {};
+            const connected = session["connected"] === true;
+            return {
+                ok: isRecord(body),
+                details: {
+                    pluginConnected: connected,
+                    authEnabled: statusBody["authEnabled"] === true,
+                    bridgePort: typeof ports["http"] === "number" ? ports["http"] : null,
+                    runtimeHealth: isRecord(statusBody["runtime"]) && typeof statusBody["runtime"]["health"] === "string"
+                        ? statusBody["runtime"]["health"]
+                        : null,
+                    telemetryEvents: isRecord(statusBody["telemetry"]) && typeof statusBody["telemetry"]["eventsBuffered"] === "number"
+                        ? statusBody["telemetry"]["eventsBuffered"]
+                        : null,
+                },
+                warning: connected ? undefined : "Bridge is running, but no Remote Connect plugin session is connected.",
+            };
+        },
+    }));
+    steps.push(await validateMcpStreamableHttp(shared));
+    steps.push(await validateHttpEndpoint({
+        ...shared,
+        endpoint: "/api/ultimate-readiness",
+        name: "runtime.ultimateReadiness",
+        validate: statusEnvelopeValidation({
+            endpoint: "/api/ultimate-readiness",
+            requiredArray: "requirements",
+            summaryCountKey: "requirementCount",
+        }),
+    }));
+    steps.push(await validateHttpEndpoint({
+        ...shared,
+        endpoint: "/api/performance-profile",
+        name: "runtime.performanceProfile",
+        validate: statusEnvelopeValidation({
+            endpoint: "/api/performance-profile",
+            requiredArray: "tools",
+            summaryCountKey: "toolCount",
+        }),
+    }));
+    steps.push(await validateHttpEndpoint({
+        ...shared,
+        endpoint: "/api/operator-runbook",
+        name: "runtime.operatorRunbook",
+        validate: operatorRunbookValidation,
+    }));
+    steps.push(await validateHttpEndpoint({
+        ...shared,
+        endpoint: "/api/tools",
+        name: "runtime.toolsCatalogue",
+        validate: toolsCatalogueValidation([
+            "get_operator_runbook",
+            "get_context_for_code_connect",
+            "generate_code_connect_template",
+            "get_code_connect_suggestions",
+            "codeconnect_get_registry",
+            "codeconnect_get_global_settings",
+            "get_libraries",
+            "search_design_system",
+            "get_design_context",
+            "get_metadata",
+            "get_screenshot",
+            "get_variable_defs",
+            "upload_assets",
+            "import_variable_spec",
+            "import_style_spec",
+            "audit_variable_coverage",
+            "apply_coverage_suggestions",
+            "audit_style_coverage",
+            "apply_style_coverage_suggestions",
+            "list_compositions",
+            "bulk_generate_compositions",
+            "audit_composition_drift",
+        ]),
+    }));
+    const statusStep = steps.find((step) => step.name === "runtime.status");
+    if (!statusStep?.ok || statusStep.details?.["pluginConnected"] !== true) {
+        if (statusStep?.details?.["pluginConnected"] !== true) {
+            const authEnabled = statusStep?.details?.["authEnabled"] === true;
+            const bridgePort = typeof statusStep?.details?.["bridgePort"] === "number"
+                ? statusStep.details["bridgePort"]
+                : null;
+            const guidance = [
+                "Bridge is reachable, but no SXL Studio Remote Connect plugin session is connected.",
+                bridgePort !== null
+                    ? `Set the plugin Remote Connect port to ${bridgePort} if Bridge is not using the default port.`
+                    : null,
+                authEnabled
+                    ? "Bridge auth is enabled; verify the plugin Remote Connect overlay token matches BRIDGE_AUTH_TOKEN."
+                    : null,
+            ].filter(Boolean).join(" ");
+            addFinding(findings, {
+                severity: "error",
+                code: "LIVE_PLUGIN_NOT_CONNECTED",
+                message: guidance,
+                step: "runtime.status",
+            });
+        }
+        const status = statusFromFindings(findings);
+        return {
+            ok: false,
+            status,
+            version: 1,
+            bridgeVersion: getBridgePackageVersion(),
+            generatedAt: new Date().toISOString(),
+            baseUrl,
+            suite,
+            writeCanary,
+            cleanup,
+            steps,
+            findings,
+        };
+    }
+    const baselineCommands = [
+        { commandType: "get_plugin_status", validate: pluginStatusValidation },
+        { commandType: "get_selection_summary", validate: okObject },
+        { commandType: "list_token_files", validate: listValidation("files") },
+        { commandType: "get_tokens_config", validate: okObject },
+        { commandType: "get_variables", payload: { limit: 20 }, validate: okObject },
+        { commandType: "get_local_styles", validate: okObject },
+        { commandType: "find_components", payload: { includeProperties: true, includeRemoteInstances: false, limit: 5 }, validate: findComponentsValidation },
+        { commandType: "build_mockup", payload: smokeScreenSpec(), validate: buildDryRunValidation },
+    ];
+    const allOnlyCommands = [
+        { commandType: "codeconnect_get_registry", validate: okObject },
+        { commandType: "codeconnect_get_global_settings", validate: okObject },
+        { commandType: "codeconnect_get_selection_status", validate: okObject },
+        { commandType: "get_selection_variable_defs", payload: { scope: "selection", maxNodes: 5, maxDefinitions: 20 }, validate: okObject },
+        { commandType: "inspect_enabled_libraries", validate: okObject },
+        { commandType: "search_enabled_library_assets", payload: { query: "button", includeVariables: false }, validate: okObject },
+        { commandType: "list_datasets", validate: listValidation("datasets") },
+        { commandType: "list_assets", validate: listValidation("assets") },
+        { commandType: "list_mappings", validate: listValidation("mappings") },
+        { commandType: "import_variable_spec", payload: { spec: smokeVariableSpec() }, validate: importVariableSpecDryRunValidation },
+        { commandType: "dedupe_variables", payload: { strategy: "byName", apply: false }, validate: dedupeDryRunValidation },
+        { commandType: "import_style_spec", payload: { spec: smokeStyleSpec() }, validate: importStyleSpecDryRunValidation },
+        { commandType: "dedupe_styles", payload: { strategy: "byName", styleType: "ALL", apply: false }, validate: dedupeDryRunValidation },
+        { commandType: "audit_variable_coverage", payload: { scope: "page", suggest: true }, validate: coverageSummaryValidation },
+        { commandType: "find_variable_coverage_misses", payload: { scope: "page", suggest: true, limit: 5 }, validate: coveragePageValidation },
+        { commandType: "apply_coverage_suggestions", payload: { suggestions: [smokeVariableCoverageSuggestion()], dryRun: true }, validate: dryRunApplyPreviewValidation },
+        { commandType: "audit_style_coverage", payload: { scope: "page" }, validate: coverageSummaryValidation },
+        { commandType: "find_style_coverage_misses", payload: { scope: "page", limit: 5 }, validate: coveragePageValidation },
+        { commandType: "apply_style_coverage_suggestions", payload: { suggestions: [smokeStyleCoverageSuggestion()], dryRun: true }, validate: dryRunApplyPreviewValidation },
+        { commandType: "find_unused_variables", validate: unusedVariablesValidation },
+        { commandType: "find_unused_styles", validate: unusedStylesValidation },
+        { commandType: "list_compositions", validate: listCompositionsValidation },
+        { commandType: "bulk_generate_compositions", payload: { operation: "auto", dryRun: true }, validate: bulkCompositionDryRunValidation },
+        { commandType: "audit_composition_drift", validate: compositionDriftValidation },
+        { commandType: "analyze_component_usage", payload: { scope: "page" }, validate: auditSummaryValidation },
+        { commandType: "find_component_usages", payload: { scope: "page", limit: 5 }, validate: componentUsagePageValidation },
+        { commandType: "analyze_component_prop_usage", payload: { scope: "page" }, validate: componentPropSummaryValidation },
+        { commandType: "find_component_prop_usages", payload: { scope: "page", limit: 5 }, validate: componentUsagePageValidation },
+        {
+            commandType: "build_doc_flow",
+            payload: {
+                title: "SXL Bridge Doc Builder Live Validation",
+                dryRun: true,
+                pages: [
+                    {
+                        title: "Overview",
+                        description: "Non-destructive Remote Connect Doc Builder dry-run.",
+                    },
+                ],
+            },
+            validate: docFlowDryRunValidation,
+        },
+    ];
+    let writesAllowed = null;
+    for (const command of suite === "all" ? [...baselineCommands, ...allOnlyCommands] : baselineCommands) {
+        const step = await runCommand({ ...shared, ...command });
+        if (command.commandType === "get_plugin_status") {
+            writesAllowed = readWritesAllowed(step.result);
+        }
+        steps.push(step.step);
+    }
+    if (suite === "all") {
+        steps.push(await runLocalStep({
+            name: "generate_code_connect_template:dryRun",
+            findings,
+            run: codeConnectTemplateDryRunValidation,
+        }));
+        steps.push(await runLocalStep({
+            name: "database_payload:dryRun",
+            findings,
+            run: databasePayloadDryRunValidation,
+        }));
+    }
+    if (writeCanary) {
+        if (writesAllowed !== true) {
+            addFinding(findings, {
+                severity: "error",
+                code: "LIVE_WRITE_CANARY_NOT_WRITABLE",
+                message: "Live validation --write-canary requires writesAllowed=true. Run in Figma Design mode with edit access.",
+                step: "get_plugin_status",
+            });
+        }
+        else {
+            const apply = await runCommand({
+                ...shared,
+                commandType: "build_mockup",
+                payload: smokeScreenSpec(false),
+            });
+            let rootNodeId = null;
+            if (!isRecord(apply.result) || typeof apply.result["rootNodeId"] !== "string") {
+                addFinding(findings, {
+                    severity: "error",
+                    code: "LIVE_WRITE_CANARY_RESULT_INVALID",
+                    message: "build_mockup write canary did not return a rootNodeId.",
+                    step: "writeCanary.build_mockup",
+                });
+                apply.step.ok = false;
+                apply.step.status = "fail";
+            }
+            else {
+                rootNodeId = apply.result["rootNodeId"];
+                apply.step.details = { rootNodeId };
+            }
+            steps.push({ ...apply.step, name: "writeCanary.build_mockup" });
+            if (cleanup && rootNodeId) {
+                const cleanupStep = await runCommand({
+                    ...shared,
+                    commandType: "delete_node",
+                    payload: {
+                        nodeId: rootNodeId,
+                        confirmDestructive: true,
+                        destructiveReason: "cleanup SXL Bridge live validation write canary",
+                    },
+                });
+                if (!isRecord(cleanupStep.result) || cleanupStep.result["ok"] !== true) {
+                    addFinding(findings, {
+                        severity: "error",
+                        code: "LIVE_WRITE_CANARY_CLEANUP_FAILED",
+                        message: "delete_node cleanup did not return { ok: true }.",
+                        step: "writeCanary.delete_node",
+                    });
+                    cleanupStep.step.ok = false;
+                    cleanupStep.step.status = "fail";
+                }
+                else {
+                    cleanupStep.step.details = {
+                        rootNodeId,
+                        deleted: cleanupStep.result["deleted"] === true,
+                        name: typeof cleanupStep.result["name"] === "string" ? cleanupStep.result["name"] : null,
+                    };
+                }
+                steps.push({ ...cleanupStep.step, name: "writeCanary.delete_node" });
+            }
+        }
+    }
+    const status = statusFromFindings(findings);
+    return {
+        ok: status !== "fail",
+        status,
+        version: 1,
+        bridgeVersion: getBridgePackageVersion(),
+        generatedAt: new Date().toISOString(),
+        baseUrl,
+        suite,
+        writeCanary,
+        cleanup,
+        steps,
+        findings,
+    };
+}
+//# sourceMappingURL=bridge-live-validation.js.map