databricks-tellr-app 0.4.2.dev13__tar.gz → 0.4.2.dev14__tar.gz

{databricks_tellr_app-0.4.2.dev13 → databricks_tellr_app-0.4.2.dev14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: databricks-tellr-app
-Version: 0.4.2.dev13
+Version: 0.4.2.dev14
 Summary: Tellr application package for Databricks Apps
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{databricks_tellr_app-0.4.2.dev13 → databricks_tellr_app-0.4.2.dev14}/databricks_tellr_app.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: databricks-tellr-app
-Version: 0.4.2.dev13
+Version: 0.4.2.dev14
 Summary: Tellr application package for Databricks Apps
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{databricks_tellr_app-0.4.2.dev13 → databricks_tellr_app-0.4.2.dev14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "databricks-tellr-app"
-version = "0.4.2.dev13"
+version = "0.4.2.dev14"
 description = "Tellr application package for Databricks Apps"
 readme = "README.md"
 requires-python = ">=3.10"

{databricks_tellr_app-0.4.2.dev13 → databricks_tellr_app-0.4.2.dev14}/src/api/routes/export.py

@@ -102,8 +102,22 @@ def build_slide_html(slide: dict, slide_deck: dict) -> str:
         }
     )
     
+    # NO `crossorigin` — deliberately, and it must stay that way (WM-02).
+    #
+    # `crossorigin="anonymous"` turns these into CORS requests. cdn.tailwindcss.com
+    # answers with a 302 and no CORS headers, so the request failed with
+    # net::ERR_FAILED and Tailwind's Preflight never landed — measured consequence
+    # on a DS-OFF deck: h3 rendered 22px/600 in the exported file against
+    # 16px/400 on screen, up to 38.25 px of per-component drift and a heading
+    # losing a line to re-wrap. The frontend surfaces emit the same tag WITHOUT the
+    # attribute (see buildSlideDocument in frontend/src/services/slideDocument.ts)
+    # and it loads, so dropping it is parity with what the user actually saw.
+    #
+    # Safe to drop on its own because there is NO `integrity` attribute here: with
+    # SRI present, removing `crossorigin` would block the script outright and turn
+    # a 38 px drift into no styling at all.
     scripts_html = "\n".join([
-        f'    <script src="{src}" crossorigin="anonymous"></script>'
+        f'    <script src="{src}"></script>'
         for src in external_scripts
     ])
 
@@ -148,6 +162,27 @@ def build_slide_html(slide: dict, slide_deck: dict) -> str:
       font-family: 'Inter', 'Segoe UI', system-ui, -apple-system, sans-serif;
     }}
     {deck_css}
+    /* After deck CSS: the fixed-frame document owns its OWN box (WM-01).
+       The html/body rule above is emitted BEFORE the deck, so a deck-authored
+       `body {{ padding: 48px 0; gap: 48px }}` — real generator output — used to win
+       on order and translate the WHOLE slide down: `.slide` measured at y=48, and
+       the .pptx carried that offset on every positioned component (dy 46-48 px)
+       including the background rectangle, whose bottom then sat at 768 inside a
+       720 frame. So: a 48 px unpainted band at the top of every exported slide and
+       48 px of content pushed past the clip.
+       Restated HERE, after the deck, exactly as the frontend preview surfaces
+       already do it (SLIDE_PREVIEW_RESET_STYLE is appended after the deck CSS in
+       buildSlideDocument), so the export agrees with what the user saw on screen.
+       Deliberately NOT added to the shared SLIDE_ROOT_RESET_STYLE: that constant is
+       also injected into the standalone MULTI-slide export, whose scrolling layout
+       depends on `body {{ padding: 40px 20px }}`.
+       No `!important`, matching the frontend rule: it wins by ORDER at equal
+       specificity, so both surfaces treat a deck's `!important` body padding the
+       same way and cannot drift apart. */
+    html, body {{
+      margin: 0;
+      padding: 0;
+    }}
     /* After deck CSS: flatten the slide root (outer margin / radius / shadow) —
        inside this fixed 1280x720 overflow:hidden document a root margin
        shifts content past the clip and truncates the export's bottom edge

{databricks_tellr_app-0.4.2.dev13 → databricks_tellr_app-0.4.2.dev14}/src/api/routes/settings/design_systems.py

@@ -25,6 +25,7 @@ import re
 import unicodedata
 from collections import OrderedDict
 from typing import Any, List, Optional, cast
+from urllib.parse import unquote
 
 from fastapi import APIRouter, Depends, File, Form, HTTPException, Response, UploadFile, status
 from pydantic import BaseModel, Field
@@ -833,6 +834,60 @@ def set_default_design_system(ds_id: int, db: Session = Depends(get_db)):
         )
 
 
+# SDR-4437 HIGH-3: workspace-global library writes are admin-only. REMOVING the
+# org default is the same org-wide state change as setting it, so it carries the
+# same gate — authorship must not buy it.
+@router.post(
+    "/{ds_id}/clear-default", response_model=DesignSystemDetail,
+    dependencies=[Depends(require_admin)],
+)
+def clear_default_design_system(ds_id: int, db: Session = Depends(get_db)):
+    """Remove the org-wide default, returning the library to "no default".
+
+    The lifecycle used to be ASYMMETRIC: ``set-default`` could promote a system and
+    switch between systems, but nothing could withdraw the flag — so returning to
+    no-default meant DELETING the design system or promoting a different one, and
+    the legacy slide-style fallback was unreachable in practice. Generation then
+    resolves no design system (``get_default_design_system_id`` returns None) and
+    new sessions take the legacy path.
+
+    Idempotent: clearing a system that is not the default succeeds and changes
+    nothing, so a double-click cannot produce an error to interpret.
+
+    Deliberately asymmetric with ``set-default``, which refuses an INACTIVE row:
+    promoting a tombstone into org-wide state is wrong, but REMOVING org-wide state
+    is always the safe direction and must never be blocked — refusing it would
+    strand the flag with no way to withdraw it.
+
+    Clearing correctly UNFREEZES rename/delete for the row's author: the freeze in
+    :func:`_require_creator_or_admin` is a function of the LOADED row's
+    ``is_default``, so it lifts when the flag does. That grants a non-admin nothing
+    new, because this route is itself admin-only.
+    """
+    try:
+        ds = db.query(DesignSystem).filter(DesignSystem.id == ds_id).first()
+        if not ds:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Design system {ds_id} not found",
+            )
+        if ds.is_default:
+            ds.is_default = False
+            db.commit()
+            db.refresh(ds)
+            logger.info(f"Cleared default design system: {ds.name} (id={ds.id})")
+        return _detail(ds)
+    except HTTPException:
+        raise
+    except Exception as e:
+        db.rollback()
+        logger.error(f"Error clearing default design system {ds_id}: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to clear default design system",
+        )
+
+
 def _template_thumbnail_url(ds_id: int, template_id: int) -> str:
     return f"/api/settings/design-systems/{ds_id}/templates/{template_id}/thumbnail"
 
@@ -1180,6 +1235,35 @@ _TEXT_SOURCE_MIMES = frozenset(
 # pass — only ever seen in double-encoding smuggling attempts, so reject outright.
 _ENCODED_TRAVERSAL_RE = re.compile(r"%(2e|2f|5c)", re.IGNORECASE)
 
+# How many decode passes a value may need before it stops changing. A value still
+# mutating after this many is pathological, never a real bundle path, and is
+# refused rather than normalized (see :func:`_validated_file_path`).
+_MAX_DECODE_PASSES = 4
+
+
+def _has_canonical_shape(value: str) -> bool:
+    """True when ``value`` has the shape of a canonical bundle-relative path.
+
+    The SHAPE half of :func:`_validated_file_path`, factored out so the exact same
+    rules can be re-applied to each decoded form of a request path — one source of
+    truth, rather than a second, weaker copy of the checks.
+    """
+    if not value or "\\" in value:
+        return False
+    # NUL / C0 control characters never appear in a legitimate stored path, and
+    # NUL in particular must be rejected BEFORE the DB lookup: psycopg2 refuses
+    # NUL in a bound parameter (ValueError), which would surface as a 500
+    # instead of the uniform opaque 404 (SQLite masks this as a no-match 404).
+    if any(ord(ch) < 0x20 for ch in value):
+        return False
+    if _ENCODED_TRAVERSAL_RE.search(value):
+        return False
+    if value.startswith("/") or re.match(r"^[A-Za-z]:", value):
+        return False
+    if any(segment in ("", ".", "..") for segment in value.split("/")):
+        return False
+    return True
+
 
 def _validated_file_path(raw: str) -> Optional[str]:
     """Return ``raw`` when it is a canonical bundle-relative path, else ``None``.
@@ -1190,22 +1274,32 @@ def _validated_file_path(raw: str) -> Optional[str]:
     backslashes, absolute/drive paths, empty/``.``/``..`` segments, and lingering
     percent-encoded traversal bytes all fail. Lookups are DB-exact within one
     design system (no filesystem involved), so this is defence-in-depth.
+
+    MULTIPLY-ENCODED forms are refused too. ``_ENCODED_TRAVERSAL_RE`` matches a
+    lingering ``%2e``/``%2f``/``%5c``, but in ``%252e`` the traversal is hidden
+    behind its own encoded ``%``, so ONE pass of that check cannot see it. The
+    value is therefore decoded repeatedly and every intermediate form must satisfy
+    the same shape rules; a value that keeps decoding into a traversal is refused
+    at any depth.
+
+    The refusal keys on TRAVERSAL, never on the ``%`` character: a literal ``%``
+    is legitimate in a brand's own filename, and an escape that decodes to
+    something harmless (``%41`` -> ``A``) stays accepted. Rejecting ``%`` outright
+    would turn a brand's real file into a 404 — the same class of brand-hostile
+    limit the uncapped-text columns exist to avoid.
     """
-    if not raw or "\\" in raw:
-        return None
-    # NUL / C0 control characters never appear in a legitimate stored path, and
-    # NUL in particular must be rejected BEFORE the DB lookup: psycopg2 refuses
-    # NUL in a bound parameter (ValueError), which would surface as a 500
-    # instead of the uniform opaque 404 (SQLite masks this as a no-match 404).
-    if any(ord(ch) < 0x20 for ch in raw):
-        return None
-    if _ENCODED_TRAVERSAL_RE.search(raw):
-        return None
-    if raw.startswith("/") or re.match(r"^[A-Za-z]:", raw):
-        return None
-    if any(segment in ("", ".", "..") for segment in raw.split("/")):
+    if not _has_canonical_shape(raw):
         return None
-    return raw
+    candidate = raw
+    for _ in range(_MAX_DECODE_PASSES):
+        decoded = unquote(candidate)
+        if decoded == candidate:
+            return raw
+        if not _has_canonical_shape(decoded):
+            return None
+        candidate = decoded
+    # Still changing after _MAX_DECODE_PASSES: refuse rather than keep unwrapping.
+    return None
 
 
 def _is_text_source(path: str, mime: str) -> bool:

{databricks_tellr_app-0.4.2.dev13 → databricks_tellr_app-0.4.2.dev14}/src/services/agent_factory.py

@@ -312,6 +312,44 @@ def _get_prompt_content(
     }
 
 
+def _design_system_is_active(design_system_id: int) -> bool:
+    """True when that design system exists and is ACTIVE.
+
+    The tool gate below needs the same verdict the prompt branch reaches at
+    :func:`_get_prompt_content` (``.filter_by(id=…, is_active=True)``, else
+    *"Design system not found, using default"*), so both halves of a generation
+    request agree about whether a design system is in play.
+
+    NOT the same question as ``chat_service.resolve_active_design_system_id``,
+    despite the name: that resolves the ``{{ds-asset:ID}}`` scope for a deck
+    RESPONSE and deliberately still resolves a soft-deleted system's bytes, so
+    already-generated decks keep their fonts and images (the D7 retention
+    contract). This is the AUTHORING question — may new content be made against
+    this brand — and a tombstone answers no.
+
+    Fails CLOSED. A lookup error degrades exactly the way the prompt branch does
+    (no brand material) rather than advertising a tool whose own lookup would fail
+    in the same breath.
+    """
+    try:
+        from src.core.database import get_db_session
+        from src.database.models import DesignSystem
+
+        with get_db_session() as db:
+            return (
+                db.query(DesignSystem.id)
+                .filter_by(id=design_system_id, is_active=True)
+                .first()
+                is not None
+            )
+    except Exception as e:
+        logger.error(
+            f"Failed to resolve design_system_id for tool registration: {e}",
+            extra={"design_system_id": design_system_id},
+        )
+        return False
+
+
 def _build_tools(
     config: AgentConfig,
     session_data: dict[str, Any],
@@ -351,12 +389,21 @@ def _build_tools(
     )
     tools.append(image_search_tool)
 
-    # Brand-asset search tool — ONLY when a design system is selected (state
-    # guard). Bound to the design_system_id via closure so it surfaces only that
-    # system's assets; the compiled style's ASSET CONTRACT tells the model to call
-    # it. Gated on design_system_id alone — a pinned template_id (Phase 4) shapes
-    # prompt assembly only and never changes tool registration.
-    if config.design_system_id is not None:
+    # Brand-asset search tool — ONLY when a selected design system is ACTIVE.
+    # Bound to the design_system_id via closure so it surfaces only that system's
+    # assets; the compiled style's ASSET CONTRACT tells the model to call it. A
+    # pinned template_id (Phase 4) shapes prompt assembly only and never changes
+    # tool registration.
+    #
+    # The is_active half matters because a session keeps its pin after the design
+    # system is soft-deleted: on the id alone, generation got a fully working brand
+    # tool for a TOMBSTONE (measured: "Found 2 brand asset(s)" with embeddable
+    # handles) while the prompt branch, which does filter is_active, supplied no
+    # brand at all — so new content was authored against a deleted brand with none
+    # of its instructions. Both halves now answer the same question.
+    if config.design_system_id is not None and _design_system_is_active(
+        config.design_system_id
+    ):
         tools.append(build_ds_asset_tool(config.design_system_id))
 
     genie_index = 0

{databricks_tellr_app-0.4.2.dev13 → databricks_tellr_app-0.4.2.dev14}/src/services/converter_jail/jail.py

@@ -43,6 +43,13 @@ class JailResult:
     returncode: int
     timed_out: bool
     stderr_tail: str = ""
+    #: Per-slide outcomes reported by the trusted runner, in the order received:
+    #: True when the slide's generated code produced its slide, False when the
+    #: deterministic placeholder fallback was used. EMPTY when the runner reported
+    #: nothing (a runner with no result channel, or one that died before emitting) —
+    #: callers must treat empty as "unknown", never as "all failed", so an absent
+    #: channel cannot manufacture a failure.
+    slide_results: tuple = ()
 
 
 @dataclass
@@ -177,8 +184,14 @@ def _spawn(
 
         assert proc.stdout is not None
 
+        slide_results: List[bool] = []
+
         def _drain_stdout():
             for line in proc.stdout:
+                result = protocol.decode_slide_result(line)
+                if result is not None:
+                    slide_results.append(result[1])
+                    continue
                 decoded = protocol.decode_progress(line)
                 if decoded and progress_cb:
                     try:
@@ -207,6 +220,7 @@ def _spawn(
             returncode=proc.returncode if proc.returncode is not None else -1,
             timed_out=timed_out,
             stderr_tail="".join(stderr_lines[-40:]),
+            slide_results=tuple(slide_results),
         )
     finally:
         shutil.rmtree(env["HOME"], ignore_errors=True)

{databricks_tellr_app-0.4.2.dev13 → databricks_tellr_app-0.4.2.dev14}/src/services/converter_jail/pptx_runner.py

@@ -106,14 +106,22 @@ def run(job_dir: str, output_path: str, emit: Optional[Callable[[str], None]] =
         sdir = Path(job_dir) / entry["dir"]
         assets_dir = str(sdir / protocol.ASSETS_DIR)
 
+        # Report whether this slide got REAL content or the deterministic
+        # placeholder. Both fallback branches below are invisible in the saved
+        # file — it is a valid .pptx either way — so the host cannot otherwise
+        # tell an all-placeholder deck from a good one.
+        rendered = True
         if not entry.get("has_code"):
             _add_fallback(prs, i, f"Slide {i}")
+            rendered = False
         else:
             html_str = (sdir / protocol.HTML_NAME).read_text(encoding="utf-8")
             code = (sdir / protocol.CODE_NAME).read_text(encoding="utf-8")
             if not _exec_snippet(code, prs, html_str, assets_dir):
                 _add_fallback(prs, i, "Slide Content")
+                rendered = False
 
+        emit(protocol.encode_slide_result(entry["index"], rendered))
         emit(protocol.encode_progress(i, total, f"Building slide {i}/{total}…"))
 
     prs.save(output_path)

{databricks_tellr_app-0.4.2.dev13 → databricks_tellr_app-0.4.2.dev14}/src/services/converter_jail/protocol.py

@@ -23,6 +23,39 @@ HTML_NAME = "html.txt"
 ASSETS_DIR = "assets"
 
 
+# Sentinel prefix for the trusted per-slide RESULT channel. Same trust property as
+# PROGRESS_PREFIX and for the same reason: only the trusted runner emits it, and
+# generated code's stdout is redirected to stderr before any snippet executes, so a
+# snippet cannot forge a result for itself. The host needs this because whether a
+# slide produced REAL content is only known after validation and execution — a
+# non-empty snippet can still be rejected by the import allowlist or raise when it
+# runs, and both outcomes fall back to a placeholder slide. Without a report, an
+# all-placeholder deck is indistinguishable from a good one.
+RESULT_PREFIX = "@@TELLR_JAIL_SLIDE_RESULT@@ "
+
+
+def encode_slide_result(index: int, rendered: bool) -> str:
+    """Encode one per-slide outcome as a single stdout line (with newline).
+
+    ``rendered`` is True only when the slide's own generated code ran and produced
+    its slide; False whenever the deterministic placeholder fallback was used.
+    """
+    payload = json.dumps({"index": index, "rendered": bool(rendered)})
+    return f"{RESULT_PREFIX}{payload}\n"
+
+
+def decode_slide_result(line: str):
+    """Decode a stdout line into ``(index, rendered)``, or None when the line is
+    not a slide-result line / is malformed."""
+    if not line.startswith(RESULT_PREFIX):
+        return None
+    try:
+        data = json.loads(line[len(RESULT_PREFIX):].strip())
+        return int(data["index"]), bool(data["rendered"])
+    except (ValueError, KeyError, TypeError):
+        return None
+
+
 def encode_progress(current: int, total: int, message: str) -> str:
     """Encode one progress event as a single stdout line (with newline)."""
     payload = json.dumps({"current": current, "total": total, "message": message})