@decaf-ts/integrations 0.4.0 → 0.4.1-0

package/lib/esm/plugins/superset/templates.js

@@ -0,0 +1,840 @@
+/**
+ * @module integrations/plugins/superset/templates
+ * @summary Patch and build script templates for the Superset embed plugin.
+ * @description Holds all patch scripts (Python + Bash) and build scripts as
+ * string templates. These are materialized onto disk by the installer. Decaf
+ * does not generate new Superset source — it patches existing internal files
+ * (`superset-frontend/src/embedded/index.tsx` and
+ * `superset-embedded-sdk/src/index.ts`) following the reference implementation
+ * from DECAF-40 §9.
+ *
+ * The patch adds a `switchDashboard` method to Superset's existing Switchboard
+ * channel, replacing only `DashboardPage` while keeping the iframe element,
+ * document, contentWindow, React runtime, and message channel alive.
+ */
+import { SUPERSET_PLUGIN_ID, SUPERSET_PLUGIN_VERSION } from "./manifest.js";
+const APPLY_PATCH_PY = `#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+
+FRONTEND_FILE = Path("superset-frontend/src/embedded/index.tsx")
+SDK_FILE = Path("superset-embedded-sdk/src/index.ts")
+
+
+class PatchError(RuntimeError):
+    pass
+
+
+def replace_once(
+    content: str,
+    old: str,
+    new: str,
+    description: str,
+) -> str:
+    count = content.count(old)
+
+    if count != 1:
+        raise PatchError(
+            f"{description}: expected exactly one occurrence, found {count}"
+        )
+
+    return content.replace(old, new, 1)
+
+
+def replace_regex_once(
+    content: str,
+    pattern: re.Pattern[str],
+    replacement: str,
+    description: str,
+) -> str:
+    updated, count = pattern.subn(replacement, content, count=1)
+
+    if count != 1:
+        raise PatchError(
+            f"{description}: expected exactly one match, found {count}"
+        )
+
+    return updated
+
+
+def patch_react_import(content: str) -> str:
+    react_import_pattern = re.compile(
+        r"import\\s*\\{\\s*([^}]+)\\s*\\}\\s*from\\s*'react';"
+    )
+
+    match = react_import_pattern.search(content)
+
+    if not match:
+        raise PatchError("Could not locate the named React import")
+
+    imports = [
+        value.strip()
+        for value in match.group(1).replace("\\n", " ").split(",")
+        if value.strip()
+    ]
+
+    required_imports = ["lazy", "Suspense", "useEffect", "useState"]
+
+    for required_import in required_imports:
+        if required_import not in imports:
+            imports.append(required_import)
+
+    replacement = (
+        "import {\\n  "
+        + ",\\n  ".join(imports)
+        + ",\\n} from 'react';"
+    )
+
+    return (
+        content[: match.start()]
+        + replacement
+        + content[match.end() :]
+    )
+
+
+def locate_embedded_component(
+    content: str,
+) -> tuple[re.Match[str], str]:
+    names = [
+        "EmbeddedLazyDashboardPage",
+        "EmbededLazyDashboardPage",
+    ]
+
+    for name in names:
+        pattern = re.compile(
+            rf"const {name} = \\(\\) => \\{{.*?\\n\\}};\\n"
+            rf"(?=const EmbeddedRoute)",
+            re.DOTALL,
+        )
+
+        match = pattern.search(content)
+
+        if match:
+            return match, name
+
+    raise PatchError(
+        "Could not find EmbeddedLazyDashboardPage before EmbeddedRoute"
+    )
+
+
+def patch_frontend(frontend_path: Path) -> None:
+    content = frontend_path.read_text(encoding="utf-8")
+
+    if "SUPERSET_SWITCHABLE_EMBED_PATCH" in content:
+        print(f"Already patched: {frontend_path}")
+        return
+
+    content = patch_react_import(content)
+
+    component_match, component_name = locate_embedded_component(
+        content
+    )
+
+    replacement_component = \`// SUPERSET_SWITCHABLE_EMBED_PATCH
+//
+// Allows the existing embedded Superset document to replace DashboardPage
+// without navigating or recreating the iframe.
+//
+// Security:
+// - This method is exposed only through Superset's existing Switchboard
+//   MessageChannel.
+// - The host application must obtain a guest token for the target dashboard.
+// - Superset's normal Allowed Domains validation remains in effect.
+
+interface SwitchDashboardPayload {
+  dashboardId: string;
+  guestToken: string;
+}
+
+interface SwitchDashboardResult {
+  dashboardId: string;
+  accepted: true;
+}
+
+type DashboardSwitchHandler = (
+  payload: SwitchDashboardPayload,
+) => Promise<SwitchDashboardResult>;
+
+let dashboardSwitchHandler: DashboardSwitchHandler | undefined;
+
+const \${component_name} = () => {
+  const uiConfig = useUiConfig();
+
+  const [dashboardId, setDashboardId] = useState<string | null>(
+    bootstrapData.embedded!.dashboard_id,
+  );
+
+  useEffect(() => {
+    dashboardSwitchHandler = async ({
+      dashboardId: requestedDashboardId,
+      guestToken,
+    }: SwitchDashboardPayload) => {
+      const nextDashboardId = requestedDashboardId.trim();
+
+      if (!nextDashboardId) {
+        throw new Error(
+          'dashboardId must be a non-empty string',
+        );
+      }
+
+      if (
+        typeof guestToken !== 'string' ||
+        guestToken.trim().length === 0
+      ) {
+        throw new Error(
+          'guestToken must be a non-empty string',
+        );
+      }
+
+      setDashboardId(null);
+
+      displayedUnauthorizedToast = false;
+
+      setupGuestClient(guestToken);
+
+      await new Promise<void>(resolve => {
+        window.requestAnimationFrame(() => resolve());
+      });
+
+      setDashboardId(nextDashboardId);
+
+      return {
+        dashboardId: nextDashboardId,
+        accepted: true,
+      };
+    };
+
+    return () => {
+      dashboardSwitchHandler = undefined;
+    };
+  }, []);
+
+  useEffect(() => {
+    if (!uiConfig?.emitDataMasks) {
+      return undefined;
+    }
+
+    let previousDataMask = store.getState().dataMask;
+
+    return store.subscribe(() => {
+      const currentDataMask = store.getState().dataMask;
+
+      if (previousDataMask !== currentDataMask) {
+        Switchboard.emit('observeDataMask', {
+          ...currentDataMask,
+          ...getDataMaskChangeTrigger(
+            currentDataMask,
+            previousDataMask,
+          ),
+        });
+
+        previousDataMask = currentDataMask;
+      }
+    });
+  }, [uiConfig?.emitDataMasks]);
+
+  if (!dashboardId) {
+    return <Loading />;
+  }
+
+  return (
+    <LazyDashboardPage
+      key={dashboardId}
+      idOrSlug={dashboardId}
+    />
+  );
+};
+\`
+
+    content = (
+        content[: component_match.start()]
+        + replacement_component
+        + content[component_match.end() :]
+    )
+
+    switchboard_anchor_candidates = [
+        (
+            "    Switchboard.defineMethod("
+            "'getScrollSize', embeddedApi.getScrollSize);"
+        ),
+        (
+            "    Switchboard.defineMethod(\\n"
+            "      'getScrollSize',\\n"
+            "      embeddedApi.getScrollSize,\\n"
+            "    );"
+        ),
+    ]
+
+    switchboard_method = """    Switchboard.defineMethod(
+      'switchDashboard',
+      async (
+        payload: SwitchDashboardPayload,
+      ): Promise<SwitchDashboardResult> => {
+        if (!dashboardSwitchHandler) {
+          throw new Error(
+            'The embedded dashboard is not ready to switch',
+          );
+        }
+
+        return dashboardSwitchHandler(payload);
+      },
+    );
+
+"""
+
+    anchor_found = False
+
+    for anchor in switchboard_anchor_candidates:
+        if content.count(anchor) == 1:
+            content = content.replace(
+                anchor,
+                switchboard_method + anchor,
+                1,
+            )
+            anchor_found = True
+            break
+
+    if not anchor_found:
+        raise PatchError(
+            "Could not locate the getScrollSize Switchboard method"
+        )
+
+    frontend_path.write_text(content, encoding="utf-8")
+    print(f"Patched: {frontend_path}")
+
+
+def patch_guest_token_fetch_type(content: str) -> str:
+    candidates = [
+        "export type GuestTokenFetchFn = () => Promise<string>;",
+        (
+            "export type GuestTokenFetchFn = "
+            "() => Promise<string>;"
+        ),
+    ]
+
+    replacement = """// SUPERSET_SWITCHABLE_EMBED_SDK_PATCH
+//
+// dashboardId is undefined for the initial dashboard bootstrap.
+// After a successful dashboard switch, token refreshes receive the active
+// dashboard UUID.
+export type GuestTokenFetchFn = (
+  dashboardId?: string,
+) => Promise<string>;"""
+
+    for candidate in candidates:
+        if content.count(candidate) == 1:
+            return content.replace(
+                candidate,
+                replacement,
+                1,
+            )
+
+    raise PatchError("Could not locate GuestTokenFetchFn")
+
+
+def patch_embedded_dashboard_type(content: str) -> str:
+    type_pattern = re.compile(
+        r"(export\\s+(?:interface|type)\\s+EmbeddedDashboard"
+        r".*?\\{)(.*?)(\\n\\};)",
+        re.DOTALL,
+    )
+
+    match = type_pattern.search(content)
+
+    if not match:
+        raise PatchError(
+            "Could not locate the EmbeddedDashboard public type"
+        )
+
+    body = match.group(2)
+
+    if "switchDashboard:" in body:
+        return content
+
+    method = """
+  /**
+   * Replaces DashboardPage in the existing iframe document.
+   *
+   * The value must be the target dashboard UUID/id accepted by
+   * DashboardPage, not the embedded-configuration UUID used in the
+   * initial /embedded/:uuid URL.
+   */
+  switchDashboard: (
+    dashboardId: string,
+  ) => Promise<{
+    dashboardId: string;
+    accepted: true;
+  }>;
+"""
+
+    updated_type = (
+        match.group(1)
+        + body.rstrip()
+        + "\\n"
+        + method.rstrip()
+        + match.group(3)
+    )
+
+    return (
+        content[: match.start()]
+        + updated_type
+        + content[match.end() :]
+    )
+
+
+def patch_initial_guest_token_fetch(content: str) -> str:
+    candidates = [
+        "fetchGuestToken(),",
+        "await fetchGuestToken(),",
+    ]
+
+    for candidate in candidates:
+        if content.count(candidate) >= 1:
+            return content.replace(
+                candidate,
+                candidate.replace(
+                    "fetchGuestToken()",
+                    "fetchGuestToken(undefined)",
+                ),
+                1,
+            )
+
+    raise PatchError(
+        "Could not locate the initial fetchGuestToken call"
+    )
+
+
+def patch_guest_token_refresh(content: str) -> str:
+    patterns = [
+        re.compile(
+            r"async function refreshGuestToken\\(\\) \\{\\s*"
+            r"const newGuestToken = await fetchGuestToken\\(\\);\\s*"
+            r"ourPort\\.emit\\("
+            r"'guestToken',\\s*\\{\\s*guestToken:\\s*newGuestToken\\s*\\}"
+            r"\\);\\s*"
+            r"setTimeout\\("
+            r"refreshGuestToken,\\s*"
+            r"getGuestTokenRefreshTiming\\(newGuestToken\\)"
+            r"\\);\\s*"
+            r"\\}",
+            re.DOTALL,
+        ),
+        re.compile(
+            r"const refreshGuestToken = async \\(\\) => \\{\\s*"
+            r"const newGuestToken = await fetchGuestToken\\(\\);\\s*"
+            r"ourPort\\.emit\\("
+            r"'guestToken',\\s*\\{\\s*guestToken:\\s*newGuestToken\\s*\\}"
+            r"\\);\\s*"
+            r"setTimeout\\("
+            r"refreshGuestToken,\\s*"
+            r"getGuestTokenRefreshTiming\\(newGuestToken\\)"
+            r"\\);\\s*"
+            r"\\};",
+            re.DOTALL,
+        ),
+    ]
+
+    replacement = """let activeDashboardId: string | undefined;
+
+  async function refreshGuestToken() {
+    const newGuestToken = await fetchGuestToken(
+      activeDashboardId,
+    );
+
+    ourPort.emit('guestToken', {
+      guestToken: newGuestToken,
+    });
+
+    setTimeout(
+      refreshGuestToken,
+      getGuestTokenRefreshTiming(newGuestToken),
+    );
+  }"""
+
+    for pattern in patterns:
+        updated, count = pattern.subn(
+            replacement,
+            content,
+            count=1,
+        )
+
+        if count == 1:
+            return updated
+
+    raise PatchError(
+        "Could not locate the guest-token refresh function"
+    )
+
+
+def patch_sdk_functions(content: str) -> str:
+    anchor_candidates = [
+        (
+            "  const getScrollSize = () => "
+            "ourPort.get<Size>('getScrollSize');"
+        ),
+        (
+            "  const getScrollSize = () =>\\n"
+            "    ourPort.get<Size>('getScrollSize');"
+        ),
+    ]
+
+    switch_function = """  const switchDashboard = async (
+    dashboardId: string,
+  ): Promise<{
+    dashboardId: string;
+    accepted: true;
+  }> => {
+    const normalizedDashboardId = dashboardId.trim();
+
+    if (!normalizedDashboardId) {
+      throw new Error(
+        'dashboardId must be a non-empty string',
+      );
+    }
+
+    const guestToken = await fetchGuestToken(
+      normalizedDashboardId,
+    );
+
+    const result = await ourPort.get<{
+      dashboardId: string;
+      accepted: true;
+    }>('switchDashboard', {
+      dashboardId: normalizedDashboardId,
+      guestToken,
+    });
+
+    activeDashboardId = normalizedDashboardId;
+
+    return result;
+  };
+
+"""
+
+    for anchor in anchor_candidates:
+        if content.count(anchor) == 1:
+            return content.replace(
+                anchor,
+                switch_function + anchor,
+                1,
+            )
+
+    raise PatchError(
+        "Could not locate the SDK getScrollSize function"
+    )
+
+
+def patch_sdk_return_object(content: str) -> str:
+    candidates = [
+        "    setThemeMode,\\n  };",
+        "    setThemeMode,\\n    unmount,\\n  };",
+        "    unmount,\\n    setThemeMode,\\n  };",
+    ]
+
+    for candidate in candidates:
+        if content.count(candidate) == 1:
+            lines = candidate.splitlines()
+
+            closing = lines.pop()
+            body = "\\n".join(lines)
+
+            return content.replace(
+                candidate,
+                body
+                + "\\n"
+                + "    switchDashboard,\\n"
+                + closing,
+                1,
+            )
+
+    raise PatchError(
+        "Could not locate the EmbeddedDashboard return object"
+    )
+
+
+def patch_sdk(sdk_path: Path) -> None:
+    content = sdk_path.read_text(encoding="utf-8")
+
+    if "SUPERSET_SWITCHABLE_EMBED_SDK_PATCH" in content:
+        print(f"Already patched: {sdk_path}")
+        return
+
+    content = patch_guest_token_fetch_type(content)
+    content = patch_embedded_dashboard_type(content)
+    content = patch_initial_guest_token_fetch(content)
+    content = patch_guest_token_refresh(content)
+    content = patch_sdk_functions(content)
+    content = patch_sdk_return_object(content)
+
+    sdk_path.write_text(content, encoding="utf-8")
+    print(f"Patched: {sdk_path}")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Apply the switchable-dashboard patch to a "
+            "Superset 6.1.x source checkout."
+        )
+    )
+
+    parser.add_argument(
+        "superset_root",
+        type=Path,
+        help="Path to the Apache Superset source checkout",
+    )
+
+    args = parser.parse_args()
+    root = args.superset_root.resolve()
+
+    frontend_path = root / FRONTEND_FILE
+    sdk_path = root / SDK_FILE
+
+    missing = [
+        path
+        for path in [frontend_path, sdk_path]
+        if not path.exists()
+    ]
+
+    if missing:
+        print(
+            "The target does not appear to be a compatible "
+            "Superset source checkout.",
+            file=sys.stderr,
+        )
+
+        for missing_path in missing:
+            print(f"Missing: {missing_path}", file=sys.stderr)
+
+        return 2
+
+    try:
+        patch_frontend(frontend_path)
+        patch_sdk(sdk_path)
+    except PatchError as error:
+        print(f"Patch failed: {error}", file=sys.stderr)
+        return 1
+
+    print("Patch completed successfully.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+`;
+const VERIFY_PATCH_SH = `#!/usr/bin/env bash
+
+set -euo pipefail
+
+SUPERSET_ROOT=\${1:?Usage: verify_patch.sh /path/to/superset}
+
+FRONTEND_FILE="$SUPERSET_ROOT/superset-frontend/src/embedded/index.tsx"
+SDK_FILE="$SUPERSET_ROOT/superset-embedded-sdk/src/index.ts"
+
+test -f "$FRONTEND_FILE"
+test -f "$SDK_FILE"
+
+grep -q \\
+  "SUPERSET_SWITCHABLE_EMBED_PATCH" \\
+  "$FRONTEND_FILE"
+
+grep -q \\
+  "'switchDashboard'" \\
+  "$FRONTEND_FILE"
+
+grep -q \\
+  "dashboardSwitchHandler" \\
+  "$FRONTEND_FILE"
+
+grep -q \\
+  "SUPERSET_SWITCHABLE_EMBED_SDK_PATCH" \\
+  "$SDK_FILE"
+
+grep -q \\
+  "switchDashboard:" \\
+  "$SDK_FILE"
+
+grep -q \\
+  "activeDashboardId" \\
+  "$SDK_FILE"
+
+grep -q \\
+  "fetchGuestToken(" \\
+  "$SDK_FILE"
+
+echo "The switchable-dashboard patch is present."
+`;
+const BUILD_SDK_SH = `#!/usr/bin/env bash
+
+set -euo pipefail
+
+SUPERSET_ROOT=\${1:?Usage: build-sdk.sh /path/to/superset}
+
+SDK_ROOT="$SUPERSET_ROOT/superset-embedded-sdk"
+
+if [ ! -f "$SDK_ROOT/package.json" ]; then
+  echo "Missing SDK package: $SDK_ROOT" >&2
+  exit 1
+fi
+
+cd "$SDK_ROOT"
+
+npm ci
+
+npm run build
+
+echo
+echo "Embedded SDK build completed."
+echo "Output directory:"
+find . \\
+  -maxdepth 2 \\
+  -type d \\
+  \\( -name dist -o -name lib \\) \\
+  -print
+`;
+const BUILD_FRONTEND_SH = `#!/usr/bin/env bash
+
+set -euo pipefail
+
+SUPERSET_ROOT=\${1:?Usage: build-superset-frontend.sh /path/to/superset}
+
+FRONTEND_ROOT="$SUPERSET_ROOT/superset-frontend"
+
+if [ ! -f "$FRONTEND_ROOT/package.json" ]; then
+  echo "Missing Superset frontend: $FRONTEND_ROOT" >&2
+  exit 1
+fi
+
+cd "$FRONTEND_ROOT"
+
+npm ci
+
+npm run build
+
+echo "Superset frontend build completed."
+`;
+const PATCH_AND_BUILD_SH = `#!/usr/bin/env bash
+
+set -euo pipefail
+
+SUPERSET_ROOT=\${1:?Usage: patch-and-build.sh /path/to/superset}
+
+SCRIPT_DIR=$(
+  cd "$(dirname "\${BASH_SOURCE[0]}")"
+  pwd
+)
+
+PROJECT_ROOT=$(
+  cd "$SCRIPT_DIR/.."
+  pwd
+)
+
+python3 \\
+  "$PROJECT_ROOT/patches/apply_superset_6_1_patch.py" \\
+  "$SUPERSET_ROOT"
+
+"$PROJECT_ROOT/patches/verify_patch.sh" \\
+  "$SUPERSET_ROOT"
+
+"$SCRIPT_DIR/build-sdk.sh" \\
+  "$SUPERSET_ROOT"
+
+"$SCRIPT_DIR/build-superset-frontend.sh" \\
+  "$SUPERSET_ROOT"
+
+echo
+echo "Patch and frontend builds completed."
+`;
+const BUILD_DOCKER_SH = `#!/usr/bin/env bash
+
+set -euo pipefail
+
+SUPERSET_ROOT=\${1:?Usage: build-docker-image.sh /path/to/superset [image-tag]}
+IMAGE_TAG=\${2:-local/superset-switchable:6.1.0}
+
+SCRIPT_DIR=$(
+  cd "$(dirname "\${BASH_SOURCE[0]}")"
+  pwd
+)
+
+PROJECT_ROOT=$(
+  cd "$SCRIPT_DIR/.."
+  pwd
+)
+
+python3 \\
+  "$PROJECT_ROOT/patches/apply_superset_6_1_patch.py" \\
+  "$SUPERSET_ROOT"
+
+"$PROJECT_ROOT/patches/verify_patch.sh" \\
+  "$SUPERSET_ROOT"
+
+cd "$SUPERSET_ROOT"
+
+docker build \\
+  --target lean \\
+  --tag "$IMAGE_TAG" \\
+  .
+
+echo "Built Docker image: $IMAGE_TAG"
+`;
+const README = `# ${SUPERSET_PLUGIN_ID}
+
+Multi-tenant, org-agnostic Superset dashboard embed plugin (patch-and-build strategy).
+
+This is not a generated plugin like the Kibana variant. Instead, Decaf holds
+patch scripts that modify Superset's internal embedded frontend and embedded
+SDK source files to add a \`switchDashboard\` method. The existing iframe
+element, document, contentWindow, React runtime, and Switchboard MessageChannel
+are preserved across dashboard switches.
+
+## What it patches
+
+- \`superset-frontend/src/embedded/index.tsx\` — adds \`switchDashboard\` to the
+  Switchboard channel; replaces only \`DashboardPage\`.
+- \`superset-embedded-sdk/src/index.ts\` — adds
+  \`embeddedDashboard.switchDashboard(dashboardId)\`; requests a guest token for
+  the selected dashboard; refreshes future guest tokens for the active dashboard.
+
+## Build
+
+\`\`\`bash
+# Apply patch + verify + build SDK + build frontend
+build/patch-and-build.sh /path/to/superset
+
+# Or build a Docker image
+build/build-docker-image.sh /path/to/superset registry.example.com/superset-switchable:6.1.0
+\`\`\`
+
+The patched SDK must be packed and installed into the Angular application:
+
+\`\`\`bash
+cd /path/to/superset/superset-embedded-sdk
+npm ci && npm run build && npm pack
+cd /path/to/angular-app
+npm install /path/to/superset/superset-embedded-sdk/superset-ui-embedded-sdk-*.tgz
+\`\`\`
+
+Version: ${SUPERSET_PLUGIN_VERSION}
+`;
+/**
+ * Returns the full set of patch and build script files.
+ */
+export function supersetPatchFiles() {
+    return [
+        { path: "patches/apply_superset_6_1_patch.py", content: APPLY_PATCH_PY, executable: true },
+        { path: "patches/verify_patch.sh", content: VERIFY_PATCH_SH, executable: true },
+        { path: "build/build-sdk.sh", content: BUILD_SDK_SH, executable: true },
+        { path: "build/build-superset-frontend.sh", content: BUILD_FRONTEND_SH, executable: true },
+        { path: "build/patch-and-build.sh", content: PATCH_AND_BUILD_SH, executable: true },
+        { path: "build/build-docker-image.sh", content: BUILD_DOCKER_SH, executable: true },
+        { path: "README.md", content: README },
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"templates.js","sourceRoot":"","sources":["../../../../src/plugins/superset/templates.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,sBAAmB;AAWzE,MAAM,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsmBtB,CAAC;AAEF,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCvB,CAAC;AAEF,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BpB,CAAC;AAEF,MAAM,iBAAiB,GAAG;;;;;;;;;;;;;;;;;;;;CAoBzB,CAAC;AAEF,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+B1B,CAAC;AAEF,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCvB,CAAC;AAEF,MAAM,MAAM,GAAG,KAAK,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAqC3B,uBAAuB;CACjC,CAAC;AAEF;;GAEG;AACH,MAAM,UAAU,kBAAkB;IAChC,OAAO;QACL,EAAE,IAAI,EAAE,qCAAqC,EAAE,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE;QAC1F,EAAE,IAAI,EAAE,yBAAyB,EAAE,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,IAAI,EAAE;QAC/E,EAAE,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,IAAI,EAAE;QACvE,EAAE,IAAI,EAAE,kCAAkC,EAAE,OAAO,EAAE,iBAAiB,EAAE,UAAU,EAAE,IAAI,EAAE;QAC1F,EAAE,IAAI,EAAE,0BAA0B,EAAE,OAAO,EAAE,kBAAkB,EAAE,UAAU,EAAE,IAAI,EAAE;QACnF,EAAE,IAAI,EAAE,6BAA6B,EAAE,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,IAAI,EAAE;QACnF,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE;KACvC,CAAC;AACJ,CAAC","sourcesContent":["/**\n * @module integrations/plugins/superset/templates\n * @summary Patch and build script templates for the Superset embed plugin.\n * @description Holds all patch scripts (Python + Bash) and build scripts as\n * string templates. These are materialized onto disk by the installer. Decaf\n * does not generate new Superset source — it patches existing internal files\n * (`superset-frontend/src/embedded/index.tsx` and\n * `superset-embedded-sdk/src/index.ts`) following the reference implementation\n * from DECAF-40 §9.\n *\n * The patch adds a `switchDashboard` method to Superset's existing Switchboard\n * channel, replacing only `DashboardPage` while keeping the iframe element,\n * document, contentWindow, React runtime, and message channel alive.\n */\nimport { SUPERSET_PLUGIN_ID, SUPERSET_PLUGIN_VERSION } from \"./manifest\";\n\nexport interface SupersetPatchFile {\n  /** Relative path within the target directory. */\n  path: string;\n  /** File contents. */\n  content: string;\n  /** Whether to mark the file executable on POSIX. */\n  executable?: boolean;\n}\n\nconst APPLY_PATCH_PY = `#!/usr/bin/env python3\n\nfrom __future__ import annotations\n\nimport argparse\nimport re\nimport sys\nfrom pathlib import Path\n\n\nFRONTEND_FILE = Path(\"superset-frontend/src/embedded/index.tsx\")\nSDK_FILE = Path(\"superset-embedded-sdk/src/index.ts\")\n\n\nclass PatchError(RuntimeError):\n    pass\n\n\ndef replace_once(\n    content: str,\n    old: str,\n    new: str,\n    description: str,\n) -> str:\n    count = content.count(old)\n\n    if count != 1:\n        raise PatchError(\n            f\"{description}: expected exactly one occurrence, found {count}\"\n        )\n\n    return content.replace(old, new, 1)\n\n\ndef replace_regex_once(\n    content: str,\n    pattern: re.Pattern[str],\n    replacement: str,\n    description: str,\n) -> str:\n    updated, count = pattern.subn(replacement, content, count=1)\n\n    if count != 1:\n        raise PatchError(\n            f\"{description}: expected exactly one match, found {count}\"\n        )\n\n    return updated\n\n\ndef patch_react_import(content: str) -> str:\n    react_import_pattern = re.compile(\n        r\"import\\\\s*\\\\{\\\\s*([^}]+)\\\\s*\\\\}\\\\s*from\\\\s*'react';\"\n    )\n\n    match = react_import_pattern.search(content)\n\n    if not match:\n        raise PatchError(\"Could not locate the named React import\")\n\n    imports = [\n        value.strip()\n        for value in match.group(1).replace(\"\\\\n\", \" \").split(\",\")\n        if value.strip()\n    ]\n\n    required_imports = [\"lazy\", \"Suspense\", \"useEffect\", \"useState\"]\n\n    for required_import in required_imports:\n        if required_import not in imports:\n            imports.append(required_import)\n\n    replacement = (\n        \"import {\\\\n  \"\n        + \",\\\\n  \".join(imports)\n        + \",\\\\n} from 'react';\"\n    )\n\n    return (\n        content[: match.start()]\n        + replacement\n        + content[match.end() :]\n    )\n\n\ndef locate_embedded_component(\n    content: str,\n) -> tuple[re.Match[str], str]:\n    names = [\n        \"EmbeddedLazyDashboardPage\",\n        \"EmbededLazyDashboardPage\",\n    ]\n\n    for name in names:\n        pattern = re.compile(\n            rf\"const {name} = \\\\(\\\\) => \\\\{{.*?\\\\n\\\\}};\\\\n\"\n            rf\"(?=const EmbeddedRoute)\",\n            re.DOTALL,\n        )\n\n        match = pattern.search(content)\n\n        if match:\n            return match, name\n\n    raise PatchError(\n        \"Could not find EmbeddedLazyDashboardPage before EmbeddedRoute\"\n    )\n\n\ndef patch_frontend(frontend_path: Path) -> None:\n    content = frontend_path.read_text(encoding=\"utf-8\")\n\n    if \"SUPERSET_SWITCHABLE_EMBED_PATCH\" in content:\n        print(f\"Already patched: {frontend_path}\")\n        return\n\n    content = patch_react_import(content)\n\n    component_match, component_name = locate_embedded_component(\n        content\n    )\n\n    replacement_component = \\`// SUPERSET_SWITCHABLE_EMBED_PATCH\n//\n// Allows the existing embedded Superset document to replace DashboardPage\n// without navigating or recreating the iframe.\n//\n// Security:\n// - This method is exposed only through Superset's existing Switchboard\n//   MessageChannel.\n// - The host application must obtain a guest token for the target dashboard.\n// - Superset's normal Allowed Domains validation remains in effect.\n\ninterface SwitchDashboardPayload {\n  dashboardId: string;\n  guestToken: string;\n}\n\ninterface SwitchDashboardResult {\n  dashboardId: string;\n  accepted: true;\n}\n\ntype DashboardSwitchHandler = (\n  payload: SwitchDashboardPayload,\n) => Promise<SwitchDashboardResult>;\n\nlet dashboardSwitchHandler: DashboardSwitchHandler | undefined;\n\nconst \\${component_name} = () => {\n  const uiConfig = useUiConfig();\n\n  const [dashboardId, setDashboardId] = useState<string | null>(\n    bootstrapData.embedded!.dashboard_id,\n  );\n\n  useEffect(() => {\n    dashboardSwitchHandler = async ({\n      dashboardId: requestedDashboardId,\n      guestToken,\n    }: SwitchDashboardPayload) => {\n      const nextDashboardId = requestedDashboardId.trim();\n\n      if (!nextDashboardId) {\n        throw new Error(\n          'dashboardId must be a non-empty string',\n        );\n      }\n\n      if (\n        typeof guestToken !== 'string' ||\n        guestToken.trim().length === 0\n      ) {\n        throw new Error(\n          'guestToken must be a non-empty string',\n        );\n      }\n\n      setDashboardId(null);\n\n      displayedUnauthorizedToast = false;\n\n      setupGuestClient(guestToken);\n\n      await new Promise<void>(resolve => {\n        window.requestAnimationFrame(() => resolve());\n      });\n\n      setDashboardId(nextDashboardId);\n\n      return {\n        dashboardId: nextDashboardId,\n        accepted: true,\n      };\n    };\n\n    return () => {\n      dashboardSwitchHandler = undefined;\n    };\n  }, []);\n\n  useEffect(() => {\n    if (!uiConfig?.emitDataMasks) {\n      return undefined;\n    }\n\n    let previousDataMask = store.getState().dataMask;\n\n    return store.subscribe(() => {\n      const currentDataMask = store.getState().dataMask;\n\n      if (previousDataMask !== currentDataMask) {\n        Switchboard.emit('observeDataMask', {\n          ...currentDataMask,\n          ...getDataMaskChangeTrigger(\n            currentDataMask,\n            previousDataMask,\n          ),\n        });\n\n        previousDataMask = currentDataMask;\n      }\n    });\n  }, [uiConfig?.emitDataMasks]);\n\n  if (!dashboardId) {\n    return <Loading />;\n  }\n\n  return (\n    <LazyDashboardPage\n      key={dashboardId}\n      idOrSlug={dashboardId}\n    />\n  );\n};\n\\`\n\n    content = (\n        content[: component_match.start()]\n        + replacement_component\n        + content[component_match.end() :]\n    )\n\n    switchboard_anchor_candidates = [\n        (\n            \"    Switchboard.defineMethod(\"\n            \"'getScrollSize', embeddedApi.getScrollSize);\"\n        ),\n        (\n            \"    Switchboard.defineMethod(\\\\n\"\n            \"      'getScrollSize',\\\\n\"\n            \"      embeddedApi.getScrollSize,\\\\n\"\n            \"    );\"\n        ),\n    ]\n\n    switchboard_method = \"\"\"    Switchboard.defineMethod(\n      'switchDashboard',\n      async (\n        payload: SwitchDashboardPayload,\n      ): Promise<SwitchDashboardResult> => {\n        if (!dashboardSwitchHandler) {\n          throw new Error(\n            'The embedded dashboard is not ready to switch',\n          );\n        }\n\n        return dashboardSwitchHandler(payload);\n      },\n    );\n\n\"\"\"\n\n    anchor_found = False\n\n    for anchor in switchboard_anchor_candidates:\n        if content.count(anchor) == 1:\n            content = content.replace(\n                anchor,\n                switchboard_method + anchor,\n                1,\n            )\n            anchor_found = True\n            break\n\n    if not anchor_found:\n        raise PatchError(\n            \"Could not locate the getScrollSize Switchboard method\"\n        )\n\n    frontend_path.write_text(content, encoding=\"utf-8\")\n    print(f\"Patched: {frontend_path}\")\n\n\ndef patch_guest_token_fetch_type(content: str) -> str:\n    candidates = [\n        \"export type GuestTokenFetchFn = () => Promise<string>;\",\n        (\n            \"export type GuestTokenFetchFn = \"\n            \"() => Promise<string>;\"\n        ),\n    ]\n\n    replacement = \"\"\"// SUPERSET_SWITCHABLE_EMBED_SDK_PATCH\n//\n// dashboardId is undefined for the initial dashboard bootstrap.\n// After a successful dashboard switch, token refreshes receive the active\n// dashboard UUID.\nexport type GuestTokenFetchFn = (\n  dashboardId?: string,\n) => Promise<string>;\"\"\"\n\n    for candidate in candidates:\n        if content.count(candidate) == 1:\n            return content.replace(\n                candidate,\n                replacement,\n                1,\n            )\n\n    raise PatchError(\"Could not locate GuestTokenFetchFn\")\n\n\ndef patch_embedded_dashboard_type(content: str) -> str:\n    type_pattern = re.compile(\n        r\"(export\\\\s+(?:interface|type)\\\\s+EmbeddedDashboard\"\n        r\".*?\\\\{)(.*?)(\\\\n\\\\};)\",\n        re.DOTALL,\n    )\n\n    match = type_pattern.search(content)\n\n    if not match:\n        raise PatchError(\n            \"Could not locate the EmbeddedDashboard public type\"\n        )\n\n    body = match.group(2)\n\n    if \"switchDashboard:\" in body:\n        return content\n\n    method = \"\"\"\n  /**\n   * Replaces DashboardPage in the existing iframe document.\n   *\n   * The value must be the target dashboard UUID/id accepted by\n   * DashboardPage, not the embedded-configuration UUID used in the\n   * initial /embedded/:uuid URL.\n   */\n  switchDashboard: (\n    dashboardId: string,\n  ) => Promise<{\n    dashboardId: string;\n    accepted: true;\n  }>;\n\"\"\"\n\n    updated_type = (\n        match.group(1)\n        + body.rstrip()\n        + \"\\\\n\"\n        + method.rstrip()\n        + match.group(3)\n    )\n\n    return (\n        content[: match.start()]\n        + updated_type\n        + content[match.end() :]\n    )\n\n\ndef patch_initial_guest_token_fetch(content: str) -> str:\n    candidates = [\n        \"fetchGuestToken(),\",\n        \"await fetchGuestToken(),\",\n    ]\n\n    for candidate in candidates:\n        if content.count(candidate) >= 1:\n            return content.replace(\n                candidate,\n                candidate.replace(\n                    \"fetchGuestToken()\",\n                    \"fetchGuestToken(undefined)\",\n                ),\n                1,\n            )\n\n    raise PatchError(\n        \"Could not locate the initial fetchGuestToken call\"\n    )\n\n\ndef patch_guest_token_refresh(content: str) -> str:\n    patterns = [\n        re.compile(\n            r\"async function refreshGuestToken\\\\(\\\\) \\\\{\\\\s*\"\n            r\"const newGuestToken = await fetchGuestToken\\\\(\\\\);\\\\s*\"\n            r\"ourPort\\\\.emit\\\\(\"\n            r\"'guestToken',\\\\s*\\\\{\\\\s*guestToken:\\\\s*newGuestToken\\\\s*\\\\}\"\n            r\"\\\\);\\\\s*\"\n            r\"setTimeout\\\\(\"\n            r\"refreshGuestToken,\\\\s*\"\n            r\"getGuestTokenRefreshTiming\\\\(newGuestToken\\\\)\"\n            r\"\\\\);\\\\s*\"\n            r\"\\\\}\",\n            re.DOTALL,\n        ),\n        re.compile(\n            r\"const refreshGuestToken = async \\\\(\\\\) => \\\\{\\\\s*\"\n            r\"const newGuestToken = await fetchGuestToken\\\\(\\\\);\\\\s*\"\n            r\"ourPort\\\\.emit\\\\(\"\n            r\"'guestToken',\\\\s*\\\\{\\\\s*guestToken:\\\\s*newGuestToken\\\\s*\\\\}\"\n            r\"\\\\);\\\\s*\"\n            r\"setTimeout\\\\(\"\n            r\"refreshGuestToken,\\\\s*\"\n            r\"getGuestTokenRefreshTiming\\\\(newGuestToken\\\\)\"\n            r\"\\\\);\\\\s*\"\n            r\"\\\\};\",\n            re.DOTALL,\n        ),\n    ]\n\n    replacement = \"\"\"let activeDashboardId: string | undefined;\n\n  async function refreshGuestToken() {\n    const newGuestToken = await fetchGuestToken(\n      activeDashboardId,\n    );\n\n    ourPort.emit('guestToken', {\n      guestToken: newGuestToken,\n    });\n\n    setTimeout(\n      refreshGuestToken,\n      getGuestTokenRefreshTiming(newGuestToken),\n    );\n  }\"\"\"\n\n    for pattern in patterns:\n        updated, count = pattern.subn(\n            replacement,\n            content,\n            count=1,\n        )\n\n        if count == 1:\n            return updated\n\n    raise PatchError(\n        \"Could not locate the guest-token refresh function\"\n    )\n\n\ndef patch_sdk_functions(content: str) -> str:\n    anchor_candidates = [\n        (\n            \"  const getScrollSize = () => \"\n            \"ourPort.get<Size>('getScrollSize');\"\n        ),\n        (\n            \"  const getScrollSize = () =>\\\\n\"\n            \"    ourPort.get<Size>('getScrollSize');\"\n        ),\n    ]\n\n    switch_function = \"\"\"  const switchDashboard = async (\n    dashboardId: string,\n  ): Promise<{\n    dashboardId: string;\n    accepted: true;\n  }> => {\n    const normalizedDashboardId = dashboardId.trim();\n\n    if (!normalizedDashboardId) {\n      throw new Error(\n        'dashboardId must be a non-empty string',\n      );\n    }\n\n    const guestToken = await fetchGuestToken(\n      normalizedDashboardId,\n    );\n\n    const result = await ourPort.get<{\n      dashboardId: string;\n      accepted: true;\n    }>('switchDashboard', {\n      dashboardId: normalizedDashboardId,\n      guestToken,\n    });\n\n    activeDashboardId = normalizedDashboardId;\n\n    return result;\n  };\n\n\"\"\"\n\n    for anchor in anchor_candidates:\n        if content.count(anchor) == 1:\n            return content.replace(\n                anchor,\n                switch_function + anchor,\n                1,\n            )\n\n    raise PatchError(\n        \"Could not locate the SDK getScrollSize function\"\n    )\n\n\ndef patch_sdk_return_object(content: str) -> str:\n    candidates = [\n        \"    setThemeMode,\\\\n  };\",\n        \"    setThemeMode,\\\\n    unmount,\\\\n  };\",\n        \"    unmount,\\\\n    setThemeMode,\\\\n  };\",\n    ]\n\n    for candidate in candidates:\n        if content.count(candidate) == 1:\n            lines = candidate.splitlines()\n\n            closing = lines.pop()\n            body = \"\\\\n\".join(lines)\n\n            return content.replace(\n                candidate,\n                body\n                + \"\\\\n\"\n                + \"    switchDashboard,\\\\n\"\n                + closing,\n                1,\n            )\n\n    raise PatchError(\n        \"Could not locate the EmbeddedDashboard return object\"\n    )\n\n\ndef patch_sdk(sdk_path: Path) -> None:\n    content = sdk_path.read_text(encoding=\"utf-8\")\n\n    if \"SUPERSET_SWITCHABLE_EMBED_SDK_PATCH\" in content:\n        print(f\"Already patched: {sdk_path}\")\n        return\n\n    content = patch_guest_token_fetch_type(content)\n    content = patch_embedded_dashboard_type(content)\n    content = patch_initial_guest_token_fetch(content)\n    content = patch_guest_token_refresh(content)\n    content = patch_sdk_functions(content)\n    content = patch_sdk_return_object(content)\n\n    sdk_path.write_text(content, encoding=\"utf-8\")\n    print(f\"Patched: {sdk_path}\")\n\n\ndef main() -> int:\n    parser = argparse.ArgumentParser(\n        description=(\n            \"Apply the switchable-dashboard patch to a \"\n            \"Superset 6.1.x source checkout.\"\n        )\n    )\n\n    parser.add_argument(\n        \"superset_root\",\n        type=Path,\n        help=\"Path to the Apache Superset source checkout\",\n    )\n\n    args = parser.parse_args()\n    root = args.superset_root.resolve()\n\n    frontend_path = root / FRONTEND_FILE\n    sdk_path = root / SDK_FILE\n\n    missing = [\n        path\n        for path in [frontend_path, sdk_path]\n        if not path.exists()\n    ]\n\n    if missing:\n        print(\n            \"The target does not appear to be a compatible \"\n            \"Superset source checkout.\",\n            file=sys.stderr,\n        )\n\n        for missing_path in missing:\n            print(f\"Missing: {missing_path}\", file=sys.stderr)\n\n        return 2\n\n    try:\n        patch_frontend(frontend_path)\n        patch_sdk(sdk_path)\n    except PatchError as error:\n        print(f\"Patch failed: {error}\", file=sys.stderr)\n        return 1\n\n    print(\"Patch completed successfully.\")\n    return 0\n\n\nif __name__ == \"__main__\":\n    raise SystemExit(main())\n`;\n\nconst VERIFY_PATCH_SH = `#!/usr/bin/env bash\n\nset -euo pipefail\n\nSUPERSET_ROOT=\\${1:?Usage: verify_patch.sh /path/to/superset}\n\nFRONTEND_FILE=\"$SUPERSET_ROOT/superset-frontend/src/embedded/index.tsx\"\nSDK_FILE=\"$SUPERSET_ROOT/superset-embedded-sdk/src/index.ts\"\n\ntest -f \"$FRONTEND_FILE\"\ntest -f \"$SDK_FILE\"\n\ngrep -q \\\\\n  \"SUPERSET_SWITCHABLE_EMBED_PATCH\" \\\\\n  \"$FRONTEND_FILE\"\n\ngrep -q \\\\\n  \"'switchDashboard'\" \\\\\n  \"$FRONTEND_FILE\"\n\ngrep -q \\\\\n  \"dashboardSwitchHandler\" \\\\\n  \"$FRONTEND_FILE\"\n\ngrep -q \\\\\n  \"SUPERSET_SWITCHABLE_EMBED_SDK_PATCH\" \\\\\n  \"$SDK_FILE\"\n\ngrep -q \\\\\n  \"switchDashboard:\" \\\\\n  \"$SDK_FILE\"\n\ngrep -q \\\\\n  \"activeDashboardId\" \\\\\n  \"$SDK_FILE\"\n\ngrep -q \\\\\n  \"fetchGuestToken(\" \\\\\n  \"$SDK_FILE\"\n\necho \"The switchable-dashboard patch is present.\"\n`;\n\nconst BUILD_SDK_SH = `#!/usr/bin/env bash\n\nset -euo pipefail\n\nSUPERSET_ROOT=\\${1:?Usage: build-sdk.sh /path/to/superset}\n\nSDK_ROOT=\"$SUPERSET_ROOT/superset-embedded-sdk\"\n\nif [ ! -f \"$SDK_ROOT/package.json\" ]; then\n  echo \"Missing SDK package: $SDK_ROOT\" >&2\n  exit 1\nfi\n\ncd \"$SDK_ROOT\"\n\nnpm ci\n\nnpm run build\n\necho\necho \"Embedded SDK build completed.\"\necho \"Output directory:\"\nfind . \\\\\n  -maxdepth 2 \\\\\n  -type d \\\\\n  \\\\( -name dist -o -name lib \\\\) \\\\\n  -print\n`;\n\nconst BUILD_FRONTEND_SH = `#!/usr/bin/env bash\n\nset -euo pipefail\n\nSUPERSET_ROOT=\\${1:?Usage: build-superset-frontend.sh /path/to/superset}\n\nFRONTEND_ROOT=\"$SUPERSET_ROOT/superset-frontend\"\n\nif [ ! -f \"$FRONTEND_ROOT/package.json\" ]; then\n  echo \"Missing Superset frontend: $FRONTEND_ROOT\" >&2\n  exit 1\nfi\n\ncd \"$FRONTEND_ROOT\"\n\nnpm ci\n\nnpm run build\n\necho \"Superset frontend build completed.\"\n`;\n\nconst PATCH_AND_BUILD_SH = `#!/usr/bin/env bash\n\nset -euo pipefail\n\nSUPERSET_ROOT=\\${1:?Usage: patch-and-build.sh /path/to/superset}\n\nSCRIPT_DIR=$(\n  cd \"$(dirname \"\\${BASH_SOURCE[0]}\")\"\n  pwd\n)\n\nPROJECT_ROOT=$(\n  cd \"$SCRIPT_DIR/..\"\n  pwd\n)\n\npython3 \\\\\n  \"$PROJECT_ROOT/patches/apply_superset_6_1_patch.py\" \\\\\n  \"$SUPERSET_ROOT\"\n\n\"$PROJECT_ROOT/patches/verify_patch.sh\" \\\\\n  \"$SUPERSET_ROOT\"\n\n\"$SCRIPT_DIR/build-sdk.sh\" \\\\\n  \"$SUPERSET_ROOT\"\n\n\"$SCRIPT_DIR/build-superset-frontend.sh\" \\\\\n  \"$SUPERSET_ROOT\"\n\necho\necho \"Patch and frontend builds completed.\"\n`;\n\nconst BUILD_DOCKER_SH = `#!/usr/bin/env bash\n\nset -euo pipefail\n\nSUPERSET_ROOT=\\${1:?Usage: build-docker-image.sh /path/to/superset [image-tag]}\nIMAGE_TAG=\\${2:-local/superset-switchable:6.1.0}\n\nSCRIPT_DIR=$(\n  cd \"$(dirname \"\\${BASH_SOURCE[0]}\")\"\n  pwd\n)\n\nPROJECT_ROOT=$(\n  cd \"$SCRIPT_DIR/..\"\n  pwd\n)\n\npython3 \\\\\n  \"$PROJECT_ROOT/patches/apply_superset_6_1_patch.py\" \\\\\n  \"$SUPERSET_ROOT\"\n\n\"$PROJECT_ROOT/patches/verify_patch.sh\" \\\\\n  \"$SUPERSET_ROOT\"\n\ncd \"$SUPERSET_ROOT\"\n\ndocker build \\\\\n  --target lean \\\\\n  --tag \"$IMAGE_TAG\" \\\\\n  .\n\necho \"Built Docker image: $IMAGE_TAG\"\n`;\n\nconst README = `# ${SUPERSET_PLUGIN_ID}\n\nMulti-tenant, org-agnostic Superset dashboard embed plugin (patch-and-build strategy).\n\nThis is not a generated plugin like the Kibana variant. Instead, Decaf holds\npatch scripts that modify Superset's internal embedded frontend and embedded\nSDK source files to add a \\`switchDashboard\\` method. The existing iframe\nelement, document, contentWindow, React runtime, and Switchboard MessageChannel\nare preserved across dashboard switches.\n\n## What it patches\n\n- \\`superset-frontend/src/embedded/index.tsx\\` — adds \\`switchDashboard\\` to the\n  Switchboard channel; replaces only \\`DashboardPage\\`.\n- \\`superset-embedded-sdk/src/index.ts\\` — adds\n  \\`embeddedDashboard.switchDashboard(dashboardId)\\`; requests a guest token for\n  the selected dashboard; refreshes future guest tokens for the active dashboard.\n\n## Build\n\n\\`\\`\\`bash\n# Apply patch + verify + build SDK + build frontend\nbuild/patch-and-build.sh /path/to/superset\n\n# Or build a Docker image\nbuild/build-docker-image.sh /path/to/superset registry.example.com/superset-switchable:6.1.0\n\\`\\`\\`\n\nThe patched SDK must be packed and installed into the Angular application:\n\n\\`\\`\\`bash\ncd /path/to/superset/superset-embedded-sdk\nnpm ci && npm run build && npm pack\ncd /path/to/angular-app\nnpm install /path/to/superset/superset-embedded-sdk/superset-ui-embedded-sdk-*.tgz\n\\`\\`\\`\n\nVersion: ${SUPERSET_PLUGIN_VERSION}\n`;\n\n/**\n * Returns the full set of patch and build script files.\n */\nexport function supersetPatchFiles(): SupersetPatchFile[] {\n  return [\n    { path: \"patches/apply_superset_6_1_patch.py\", content: APPLY_PATCH_PY, executable: true },\n    { path: \"patches/verify_patch.sh\", content: VERIFY_PATCH_SH, executable: true },\n    { path: \"build/build-sdk.sh\", content: BUILD_SDK_SH, executable: true },\n    { path: \"build/build-superset-frontend.sh\", content: BUILD_FRONTEND_SH, executable: true },\n    { path: \"build/patch-and-build.sh\", content: PATCH_AND_BUILD_SH, executable: true },\n    { path: \"build/build-docker-image.sh\", content: BUILD_DOCKER_SH, executable: true },\n    { path: \"README.md\", content: README },\n  ];\n}\n"]}