streamtex 0.7.76__tar.gz → 0.7.78__tar.gz

{streamtex-0.7.76/streamtex.egg-info → streamtex-0.7.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamtex
-Version: 0.7.76
+Version: 0.7.78
 Summary: AI-powered content framework for Streamlit — create presentations, courses, and web-books with Claude or Cursor, no coding required.
 Author-email: Nicolas Guelfi <nicolas.guelfi@laposte.net>
 License-Expression: BUSL-1.1

{streamtex-0.7.76 → streamtex-0.7.78}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "streamtex"
-version = "0.7.76"
+version = "0.7.78"
 description = "AI-powered content framework for Streamlit — create presentations, courses, and web-books with Claude or Cursor, no coding required."
 readme = "README.md"
 requires-python = ">=3.11"

{streamtex-0.7.76 → streamtex-0.7.78}/streamtex/cli/release_cmd.py

@@ -46,21 +46,22 @@ def _html_env(items) -> dict[str, str]:
     return env
 
 
-def _skew(cfg, t, allow_skew: bool) -> str:
-    """Why the exporting streamtex is not the live image's, refused unless --allow-skew (rel version=a)."""
-    skew = build.library_skew(cfg)
+def _skew(cfg, t, allow_skew: bool) -> tuple[str, str]:
+    """Why the exporting streamtex is not the live image's, refused unless --allow-skew (rel version=a);
+    with the exporting version when the gap is one of version only — a rebuild of the image at that
+    version ends it (#150) — else ``""``."""
+    info = build.library_info(cfg)
+    skew = build.library_skew(cfg, info)
     running = ops.image_version(t)
     wanted = (cfg.lock_dir / "stx-version").read_text(encoding="utf-8").strip()
     if not skew and running and running != wanted:
-        how = ("stx release rebuild" if "live" in coolify.repo_faces(t.cfg)
-               else "stx release setup --show live, paste, redeploy")
         skew = (f"the live application runs streamtex {running}, {cfg.dir}/stx-version says {wanted} — "
-                f"rebuild it ({how})")
+                "rebuild it (stx release rebuild)")
     if skew and not allow_skew:
         raise ReleaseError(f"{skew} — publish with the image's streamtex, or pass --allow-skew for a trial")
     if skew:
         click.echo(f"  ⚠ {skew} (--allow-skew: the sites are marked in status)")
-    return skew
+    return skew, ("" if not skew or build.copy_skew(info) else info["version"])
 
 
 @release.command("publish")
@@ -85,7 +86,7 @@ def publish_cmd(sites, groups, all_, target, allow_skew, html_env):
     env = _html_env(html_env)
     release_name = build.require_committed(cfg.root)
     build.require_lock(cfg)
-    skew = _skew(cfg, t, allow_skew)
+    skew, skew_version = _skew(cfg, t, allow_skew)
     run_checks(cfg, chosen)
     data = _passwords(cfg)
     faces = {s.site: pw.for_site(data, s) for s in chosen}     # every password checked before any copy
@@ -93,7 +94,8 @@ def publish_cmd(sites, groups, all_, target, allow_skew, html_env):
     pool = pw.RecordPool(ops.server_records(t))                # one record per password, on every site
     for s in chosen:
         ops.publish_site(t, cfg, state, s, release_name, faces[s.site], click.echo, env, skew,
-                         levels[s.site], pool)
+                         levels[s.site], pool, skew_version=skew_version)
+    ops.check_foreign_links(t, cfg, state, click.echo)        # after all: a site published may stop one (#155)
 
 
 @release.command("status")
@@ -111,7 +113,7 @@ def status_cmd(target):
     wanted = wanted_path.read_text(encoding="utf-8").strip() if wanted_path.exists() else "?"
     gap = "" if running == wanted else "  ← GAP"
     click.echo(f"target {t.name} · HEAD {head} · live image streamtex {running} (stx-version {wanted}){gap}\n")
-    rows = ops.status_rows(t, cfg, state, data)
+    rows = ops.status_rows(t, cfg, state, data, running)
     w = max([28] + [len(r[0]) + 2 for r in rows])
     click.echo(f"{'site':<{w}}{'published':<14}{'served (html)':<19}{'live':<8}{'html':<11}date")
     for name, rel, html, live, access, date, flag in rows:
@@ -296,7 +298,8 @@ def media_report_cmd(site, show, html_env):
     """What SITE's live face would serve with `[release] media_per_site = true` (#142), on this machine.
 
     Exports SITE's HTML from the commit, as publish does, then sorts its static folder: the files the
-    export shows and those media_keep names are kept, the others would no longer be served. Nothing is
+    export shows or links to under app/static/ and those media_keep names are kept, the others would no
+    longer be served. Nothing is
     sent: the server is not read nor changed."""
     import tempfile
     from pathlib import Path
@@ -316,9 +319,10 @@ def media_report_cmd(site, show, html_env):
         raise ReleaseError(f"{site}: {s.doc_dir}/static is not a folder — the live face serves no media")
     kept, dropped = sorted(mp.kept), mp.dropped
     by_export = sum(1 for why in mp.kept.values() if why == "export")
+    by_link = sum(1 for why in mp.kept.values() if why == "export link")
     click.echo(f"{site} — static folder {mp.static} ({len(mp.files)} files, {md.human(mp.size(mp.files))})")
     click.echo(f"  kept: {len(kept)} file(s), {md.human(mp.size(kept))} — {by_export} shown by the HTML "
-               f"export, {len(kept) - by_export} named by media_keep")
+               f"export, {by_link} linked by it, {len(kept) - by_export - by_link} named by media_keep")
     click.echo(f"  no longer served: {len(dropped)} file(s), {md.human(mp.size(dropped))}")
     if mp.unmatched:
         click.echo(f"  {mp.unmatched} export file(s) match no static file (inlined or generated: nothing to keep)")
@@ -327,6 +331,13 @@ def media_report_cmd(site, show, html_env):
                    f"needs them ({len(mp.named)}):")
         for p in mp.named:
             click.echo(f"      {p}")
+    if mp.foreign:
+        n = sum(len(v) for v in mp.foreign.values())
+        click.echo(f"  links to other sites' files: {n} — served by those sites, not this one; publish "
+                   "checks that each still serves its file:")
+        for other, rels in mp.foreign.items():
+            for p in rels:
+                click.echo(f"      {other}: /app/static/{p}")
     if show:
         click.echo(f"{'Kept' if show == 'kept' else 'No longer served'}:")
         for p in (kept if show == "kept" else dropped):
@@ -352,11 +363,27 @@ def lock_cmd():
 @release.command("rebuild")
 @_target
 @click.option("--face", type=click.Choice(["static", "live"]), default="live", show_default=True)
-def rebuild_cmd(target, face):
-    """Rebuild an application built from the repository (after lock, commit, push) and wait for it."""
+@click.option("--dry-run", "dry_run", is_flag=True,
+              help="Dockerfile kept in Coolify: show the difference, write nothing, rebuild nothing.")
+@click.option("--restore", is_flag=True,
+              help="Dockerfile kept in Coolify: put back the last one kept on the server, then rebuild.")
+def rebuild_cmd(target, face, dry_run, restore):
+    """Rebuild an application after `stx release lock`, and wait for it.
+
+    Built from the repository: from the Dockerfile committed and pushed. Built from a Dockerfile kept in
+    Coolify: today's is written in Coolify's database over ssh (the API cannot), the one in place kept
+    on the server first (#149)."""
     cfg, _state, t = _ctx(target)
-    coolify.rebuild(cfg, t.cfg, face, click.echo)
-    if face == "live":
+    if face in coolify.repo_faces(t.cfg):
+        if dry_run or restore:
+            raise ReleaseError("--dry-run and --restore are for an application built from a Dockerfile kept "
+                               "in Coolify; this one is built from the repository")
+        coolify.rebuild(cfg, t.cfg, face, click.echo)
+    elif not coolify.rebuild_pasted(cfg, t, face, click.echo, dry_run, restore):
+        return
+    if face == "live" and restore:
+        click.echo(f"  live application on streamtex {ops.image_version(t) or '?'}")
+    elif face == "live":
         running = ops.image_version(t)
         wanted = (cfg.lock_dir / "stx-version").read_text(encoding="utf-8").strip()
         if running != wanted:

{streamtex-0.7.76 → streamtex-0.7.78}/streamtex/deploy/stx_auth.py

@@ -107,7 +107,7 @@ from pathlib import Path
 from urllib.parse import parse_qs, urlsplit
 
 #: The library release this file ships with, and its interface number (#135).
-STX_VERSION = "0.7.76"
+STX_VERSION = "0.7.78"
 AUTH_INTERFACE = 3
 
 DEFAULT_ROOT = "/var/lib/stx-auth"

{streamtex-0.7.76 → streamtex-0.7.78}/streamtex/release/build.py

@@ -119,17 +119,28 @@ def require_lock(cfg: ReleaseConfig) -> None:
             f"{have_ver.strip() or '?'} in the image): `stx release lock`, commit, then rebuild the live application")
 
 
-def library_skew(cfg: ReleaseConfig) -> str:
-    """Why the exporting streamtex is not the image's, or ``""`` (rel version=a)."""
-    info = json.loads(_project_python(cfg, (
+def library_info(cfg: ReleaseConfig) -> dict:
+    """The streamtex that exports here: its ``version``, and its ``direct_url`` when installed from a folder."""
+    return json.loads(_project_python(cfg, (
         "import json, importlib.metadata as m, streamtex\n"
         "d = m.distribution('streamtex')\n"
         "u = d.read_text('direct_url.json')\n"
         "print(json.dumps({'version': streamtex.__version__, 'direct_url': json.loads(u) if u else None}))")))
+
+
+def library_skew(cfg: ReleaseConfig, info: dict | None = None) -> str:
+    """Why the exporting streamtex is not the image's, or ``""`` (rel version=a)."""
+    info = info if info is not None else library_info(cfg)
     want = (cfg.lock_dir / "stx-version").read_text(encoding="utf-8").strip() \
         if (cfg.lock_dir / "stx-version").exists() else ""
     if want and info["version"] != want:
         return f"streamtex {info['version']} exports here, the live image runs {want}"
+    return copy_skew(info)
+
+
+def copy_skew(info: dict) -> str:
+    """Why an editable streamtex holds code that its version's release has not, or ``""``: such a gap
+    never ends with a rebuild of the image, unlike a gap of version only (#150)."""
     url = info.get("direct_url") or {}
     if url.get("dir_info", {}).get("editable"):
         path = url.get("url", "").removeprefix("file://")

{streamtex-0.7.76 → streamtex-0.7.78}/streamtex/release/coolify.py

@@ -5,11 +5,16 @@
 (no repository). ``stx-version`` and ``requirements.txt`` come from the project's lock folder.
 
 What the API cannot do (4.0.0-beta.468) is printed as manual steps, then checked where possible:
-mounting the host folder (Persistent Storage → Directory Mount ``<root>/<face>`` → ``/srv/<face>``), and
-replacing the Dockerfile of an existing application (Configuration → Dockerfile, Save, Redeploy).
+mounting the host folder (Persistent Storage → Directory Mount ``<root>/<face>`` → ``/srv/<face>``).
 The Coolify token is read from the target's env file (``coolify_env``), never printed.
 
-A public repository removes the paste: with ``"repo": "owner/name"`` in the target, the faces of
+The API also refuses to replace the Dockerfile of an existing application. ``stx release rebuild``
+writes it where Coolify's interface does, the column ``applications.dockerfile`` of Coolify's database,
+over ssh (#149): the difference shown first, the previous Dockerfile kept on the server
+(``<root>/dockerfiles/``, put back by ``rebuild --restore``), the written one read back, then the
+application rebuilt. A Coolify whose database changed stops it with a clear message.
+
+A public repository needs no database: with ``"repo": "owner/name"`` in the target, the faces of
 ``repo_faces`` (default ``["live"]``) are built by Coolify from ``<dir>/Dockerfile.<face>``, written by
 ``stx release lock`` and committed. A new streamtex is then ``lock``, commit, push, ``stx release
 rebuild``. An application created from a pasted Dockerfile cannot be switched (the API cannot clear it):
@@ -19,6 +24,8 @@ rebuild``. An application created from a pasted Dockerfile cannot be switched (t
 from __future__ import annotations
 
 import base64
+import datetime as dt
+import difflib
 import json
 import re
 import shlex
@@ -204,8 +211,8 @@ def setup(cfg: ReleaseConfig, tcfg: dict, echo) -> dict:
             elif not _inline(app):
                 echo(f"  {name}: built from {app.get('git_repository')} ({app.get('dockerfile_location')})")
             else:
-                echo(f"  TO DO in Coolify ({name}): Configuration → Dockerfile, paste the output of "
-                     f"`stx release setup --show {face}`, Save, Redeploy (the API cannot change it)")
+                echo(f"  {name}: built from a Dockerfile kept in Coolify — `stx release rebuild --face {face}` "
+                     "writes today's and rebuilds")
         _health(co, uuid)
         echo(f"  TO DO in Coolify ({name}): Persistent Storage → Directory Mount "
              f"{tcfg['root']}/{face} → /srv/{face}, then Redeploy")
@@ -317,8 +324,8 @@ def deploy(co: Coolify, uuid: str, echo, restart: bool = False) -> None:
 
 def rebuild(cfg: ReleaseConfig, tcfg: dict, face: str, echo) -> None:
     if face not in repo_faces(tcfg):
-        raise ReleaseError(f"the {face} application is built from a pasted Dockerfile — paste "
-                           f"`stx release setup --show {face}` in Coolify (Configuration → Dockerfile), Save, Redeploy")
+        raise ReleaseError(f"the {face} application is built from a Dockerfile pasted in Coolify — "
+                           "rebuild_pasted writes it there")
     require_pushed_dockerfile(cfg, tcfg, face)
     co = Coolify(cfg.root, tcfg["coolify_env"])
     uuid = tcfg[f"{face}_uuid"]
@@ -370,3 +377,107 @@ def migrate(cfg: ReleaseConfig, tcfg: dict, face: str, mounted, echo) -> bool:
     echo(f"  {name + INLINE_SUFFIX}: stopped (kept for a rollback; delete it in Coolify when sure)")
     del tcfg[old_key]
     return True
+
+
+# -- built from a pasted Dockerfile: written in Coolify's database (#149) -----------------------------
+
+_PSQL = "docker exec -i {db} psql -U coolify -d coolify -v ON_ERROR_STOP=1 -qtA"
+_TAG = "$stx_dockerfile$"                 # dollar quoting: the Dockerfile goes in unchanged
+BACKUPS = "dockerfiles"                   # under the target's root, beside static/ and live/: never served
+
+
+def _psql(t, sql: str) -> str:
+    db = t.cfg.get("coolify_db", "coolify-db")
+    r = t.sh(_PSQL.format(db=shlex.quote(db)), check=False, input=sql)
+    if r.returncode:
+        raise ReleaseError(f"Coolify's database ({db}) refused the request — if Coolify changed, paste "
+                           f"`stx release setup --show <face>` in Coolify instead: {(r.stderr or r.stdout)[-400:]}")
+    return r.stdout
+
+
+def _uuid(tcfg: dict, face: str) -> str:
+    uuid = tcfg.get(f"{face}_uuid", "")
+    if not re.fullmatch(r"[A-Za-z0-9-]+", uuid):
+        raise ReleaseError(f"no valid {face}_uuid in the target — run `stx release setup --apply` first")
+    return uuid
+
+
+def read_pasted(t, uuid: str) -> str:
+    """The Dockerfile Coolify keeps for the application (base64: the text comes back unchanged)."""
+    out = _psql(t, "SELECT 'stx:' || coalesce(encode(convert_to(dockerfile, 'UTF8'), 'base64'), '') "
+                   f"FROM applications WHERE uuid = '{uuid}';\n")
+    if not out.lstrip().startswith("stx:"):
+        raise ReleaseError(f"no application {uuid} in Coolify's database")
+    return base64.b64decode("".join(out.strip().removeprefix("stx:").split())).decode("utf-8")
+
+
+def write_pasted(t, uuid: str, text: str) -> None:
+    """Write *text* as the application's Dockerfile, then read it back: it must be *text* exactly."""
+    if _TAG in text:
+        raise ReleaseError(f"the Dockerfile holds {_TAG}")
+    out = _psql(t, f"UPDATE applications SET dockerfile = {_TAG}{text}{_TAG}, updated_at = now() "
+                   f"WHERE uuid = '{uuid}' RETURNING length(dockerfile);\n")
+    if not out.strip():
+        raise ReleaseError(f"no application {uuid} in Coolify's database: nothing written")
+    if read_pasted(t, uuid) != text:
+        raise ReleaseError(f"the Dockerfile read back from Coolify ({out.strip()} characters) is not the one "
+                           f"written ({len(text)}) — check it in Coolify (Configuration → Dockerfile)")
+
+
+def _diff(old: str, new: str, echo, limit: int = 60) -> None:
+    lines = list(difflib.unified_diff(old.splitlines(), new.splitlines(), "in Coolify", "to write", n=0,
+                                      lineterm=""))
+    plus = sum(1 for x in lines if x.startswith("+") and not x.startswith("+++"))
+    minus = sum(1 for x in lines if x.startswith("-") and not x.startswith("---"))
+    echo(f"  difference: {plus} line(s) added, {minus} removed")
+    for x in lines[2:limit + 2]:
+        echo(f"    {x}")
+    if len(lines) > limit + 2:
+        echo(f"    … ({len(lines) - limit - 2} more line(s))")
+
+
+def _backups(t, face: str) -> list[str]:
+    folder = t.path(BACKUPS)
+    r = t.sh(f"ls -1 {shlex.quote(folder)} 2>/dev/null || true", check=False)
+    return sorted(x for x in r.stdout.split() if x.startswith(f"Dockerfile.{face}."))
+
+
+def rebuild_pasted(cfg: ReleaseConfig, t, face: str, echo, dry_run: bool = False, restore: bool = False) -> bool:
+    """Rebuild a face built from a Dockerfile pasted in Coolify (#149): write today's Dockerfile — or,
+    with *restore*, the last one kept — in Coolify's database, the one in place kept first under
+    ``<root>/dockerfiles/``, then rebuild and wait. *dry_run* shows the difference and writes nothing.
+    Returns True when the application was rebuilt."""
+    if t.kind != "ssh":
+        raise ReleaseError(f"target {t.name} is local: its containers are built by `stx release local up`")
+    uuid, name = _uuid(t.cfg, face), t.cfg[f"{face}_app"]
+    co = Coolify(cfg.root, t.cfg["coolify_env"])
+    if not _inline(co.call("GET", f"/applications/{uuid}")):
+        raise ReleaseError(f"{name} is built from a repository — `stx release rebuild` builds it from there")
+    current = read_pasted(t, uuid)
+    if restore:
+        kept = _backups(t, face)
+        if not kept:
+            raise ReleaseError(f"no Dockerfile kept for {face} under {t.path(BACKUPS)}")
+        source = t.path(BACKUPS, kept[-1])
+        wanted = t.sh(f"cat {shlex.quote(source)}").stdout
+        echo(f"  {name}: back to {source}")
+    else:
+        wanted = compose_dockerfile(cfg, face)
+        echo(f"  {name}: the Dockerfile of today's lock ({len(wanted)} characters)")
+    if current == wanted:
+        echo("  difference: none — Coolify already has it")
+    else:
+        _diff(current, wanted, echo)
+    if dry_run:
+        echo("  dry run: nothing written, nothing rebuilt")
+        return False
+    if current != wanted:
+        stamp = dt.datetime.now().strftime("%Y%m%d-%H%M%S-%f")     # never the name of another one
+        backup = t.path(BACKUPS, f"Dockerfile.{face}.{stamp}")
+        t.write(backup, current)
+        echo(f"  the Dockerfile in place kept: {backup} (`stx release rebuild --face {face} --restore` puts it back)")
+        write_pasted(t, uuid, wanted)
+        echo(f"  written in Coolify and read back ({len(wanted)} characters)")
+    echo(f"  {name}: rebuilding")
+    deploy(co, uuid, echo)
+    return True

{streamtex-0.7.76 → streamtex-0.7.78}/streamtex/release/media.py

@@ -7,9 +7,16 @@ document. With ``[release] media_per_site = true``, each release of the code hol
 
 * the files its HTML export shows: each file of the export's ``data/`` folders, found again in the
   static folder by its content (size, then SHA-256) — the export copies a served file unchanged;
+* the files its HTML export links to under ``app/static/`` — a download offered by a link, at the
+  site's address or another's (``href='https://<site>…/app/static/downloads/x.zip'``): the export
+  leaves such a link as it is, and the live face must serve its file;
 * the files ``media_keep`` names (``[release]`` and the site's table): glob patterns relative to the
   static folder, as in ``/app/static/<path>``; ``*`` also crosses ``/``.
 
+A link to another site's file (``https://<other site>…/app/static/x.zip``) is served by that site, and
+only while that site keeps the file: ``foreign`` lists such links, publish records them and checks,
+after each publication, that the other site still serves each file (#155).
+
 The code itself is unchanged: a block that reads a file of the static folder still finds it. A site
 without an HTML face keeps serving its whole static folder. ``stx release media-report SITE`` shows
 the plan without changing anything.
@@ -24,6 +31,7 @@ from collections import defaultdict
 from dataclasses import dataclass, field
 from fnmatch import fnmatchcase
 from pathlib import Path
+from urllib.parse import unquote
 
 from .config import ReleaseConfig, Site
 
@@ -31,6 +39,10 @@ SERVED = ".stx-served"
 
 #: A path under the static folder named in a site's own files: ``static/…`` or ``app/static/…``.
 _NAMED_RE = re.compile(r"""(?:app/)?static/([\w.~/-]+)""")
+#: A link of the export to a served file, absolute or not: the path after ``app/static/``.
+_LINKED_RE = re.compile(r"""app/static/([^"'\s()<>?#\\]+)""")
+#: The same link with its address: the host, whose first label names the site that serves it.
+_HOSTED_RE = re.compile(r"""https?://([A-Za-z0-9.-]+)(?::\d+)?/app/static/([^"'\s()<>?#\\]+)""")
 _TEXT = {".py", ".md", ".html", ".css", ".js", ".toml", ".json", ".txt", ".yaml", ".yml"}
 
 
@@ -40,9 +52,12 @@ class MediaPlan:
 
     static: Path | None                       # the site's static folder, resolved (None: it has none)
     files: dict[str, int] = field(default_factory=dict)       # every file of it → its size
-    kept: dict[str, str] = field(default_factory=dict)        # served → why: "export" or the pattern
+    kept: dict[str, str] = field(default_factory=dict)        # served → why: "export", "export link",
+                                                              # or the media_keep pattern
     unmatched: int = 0                        # export files found in no static file (inlined, generated)
     named: list[str] = field(default_factory=list)            # named in the site's files, not kept
+    foreign: dict[str, list[str]] = field(default_factory=dict)  # another site of the project → the
+                                                              # files the export links to on it (#155)
 
     @property
     def dropped(self) -> list[str]:
@@ -77,7 +92,20 @@ def keep_patterns(cfg: ReleaseConfig, site: Site) -> tuple[str, ...]:
     return (*cfg.media_keep, *site.media_keep)
 
 
-def plan(cfg: ReleaseConfig, site: Site, code: Path, html: Path) -> MediaPlan:
+def _rel(match: str) -> str:
+    return unquote(match.replace("&amp;", "&")).rstrip("/")
+
+
+def site_of_host(cfg: ReleaseConfig, host: str, suffix: str = "") -> str:
+    """The project's site an address names (its first label, without a provisional *suffix*), or ``""``."""
+    label = host.split(".", 1)[0].lower()
+    for name in (label, label.removesuffix(suffix) if suffix else label):
+        if name in cfg.by_name:
+            return name
+    return ""
+
+
+def plan(cfg: ReleaseConfig, site: Site, code: Path, html: Path, suffix: str = "") -> MediaPlan:
     """The files the live face of *site* serves, from its snapshot *code* and its HTML export *html*,
     both on this machine; the snapshot's media folder is linked to the project's while it is read."""
     linked = None
@@ -88,13 +116,13 @@ def plan(cfg: ReleaseConfig, site: Site, code: Path, html: Path) -> MediaPlan:
         linked.parent.mkdir(parents=True, exist_ok=True)
         linked.symlink_to(cfg.root / cfg.media)
     try:
-        return _plan(cfg, site, code, html)
+        return _plan(cfg, site, code, html, suffix)
     finally:
         if linked is not None:
             linked.unlink()
 
 
-def _plan(cfg: ReleaseConfig, site: Site, code: Path, html: Path) -> MediaPlan:
+def _plan(cfg: ReleaseConfig, site: Site, code: Path, html: Path, suffix: str) -> MediaPlan:
     folder = code / site.doc_dir / "static"
     if not folder.is_dir():
         return MediaPlan(static=None)
@@ -117,6 +145,19 @@ def _plan(cfg: ReleaseConfig, site: Site, code: Path, html: Path) -> MediaPlan:
                     mp.kept.setdefault(rel, "export")
                     found = True
         mp.unmatched += not found
+    foreign: dict[str, set[str]] = defaultdict(set)
+    for f in sorted(html.rglob("*")):
+        if f.is_file() and f.suffix in (".html", ".css", ".js"):
+            text = f.read_text(encoding="utf-8", errors="replace")
+            for m in _LINKED_RE.findall(text):
+                rel = _rel(m)
+                if rel in mp.files:
+                    mp.kept.setdefault(rel, "export link")
+            for host, m in _HOSTED_RE.findall(text):
+                other = site_of_host(cfg, host, suffix)
+                if other and other != site.site:
+                    foreign[other].add(_rel(m))
+    mp.foreign = {k: sorted(v) for k, v in sorted(foreign.items())}
     for pat in keep_patterns(cfg, site):
         for rel in mp.files:
             if fnmatchcase(rel, pat):

{streamtex-0.7.76 → streamtex-0.7.78}/streamtex/release/ops.py

@@ -280,7 +280,7 @@ def _levels_line(levels: dict, default: int | None) -> str:
 
 def publish_site(t: Target, cfg: ReleaseConfig, state: dict, site: Site, release: str, faces: dict,
                  echo: Echo, html_env: dict[str, str] | None = None, skew: str = "",
-                 levels: dict | None = None, pool: pw.RecordPool | None = None) -> None:
+                 levels: dict | None = None, pool: pw.RecordPool | None = None, skew_version: str = "") -> None:
     echo(f"\n▶ {site.site} @ {release} ({t.name})")
     entries = sites_of(state, t.name)
     v = entries.setdefault(site.site, {})
@@ -293,6 +293,7 @@ def publish_site(t: Target, cfg: ReleaseConfig, state: dict, site: Site, release
     if "live" in site.faces and not v.get("port"):
         v["port"] = max([cfg.port_base - 1] + [s.get("port") or 0 for s in entries.values()]) + 1
     names: dict[int, str] = {}
+    foreign: dict[str, list[str]] = {}
     with tempfile.TemporaryDirectory(prefix="stx-release-") as w:
         work = Path(w)
         code = build.snapshot(cfg, site, work)
@@ -306,8 +307,9 @@ def publish_site(t: Target, cfg: ReleaseConfig, state: dict, site: Site, release
             if html is None:
                 echo(f"  ! media per site: {site.site} has no HTML face — its live face serves its whole "
                      "static folder")
-            elif (mp := md.plan(cfg, site, code, html)).static is not None:
+            elif (mp := md.plan(cfg, site, code, html, t.suffix)).static is not None:
                 md.build_served(code, site, mp.kept)
+                foreign = mp.foreign
                 echo(f"  ✓ media per site: {len(mp.kept)} of {len(mp.files)} file(s) served "
                      f"({md.human(mp.size(mp.kept))})")
                 if mp.named:
@@ -363,10 +365,11 @@ def publish_site(t: Target, cfg: ReleaseConfig, state: dict, site: Site, release
              cuts={str(n): name for n, name in names.items()}, up_to_slide_previous=v.get("up_to_slide"))
     for old in ("html_release", "html_previous"):
         v.pop(old, None)
-    if skew:
-        v["skew"] = skew
+    record_skew(v, skew, skew_version)
+    if foreign:
+        v["foreign_links"] = foreign
     else:
-        v.pop("skew", None)
+        v.pop("foreign_links", None)
     save_state(cfg.root, state)
     echo(f"  ✓ {site.site}: html {release}, live {'ok' if 'live' in site.faces else '-'}"
          + (f" — port {v['port']}" if v.get("port") else "")
@@ -377,6 +380,64 @@ def publish_site(t: Target, cfg: ReleaseConfig, state: dict, site: Site, release
         echo(f"  ⌫ {len(removed)} old release(s) removed: {', '.join(removed)}")
 
 
+def foreign_gaps(t: Target, cfg: ReleaseConfig, state: dict) -> tuple[int, list[tuple[str, str, str]]]:
+    """Every link of a site's export to another site's ``/app/static/`` file, recorded at publish, checked
+    in the live container as its router serves it: (how many, those the other site does not serve) —
+    (site, other site, file) (#155)."""
+    links = [(a, b, rel) for a, v in sorted(sites_of(state, t.name).items())
+             for b, rels in sorted((v.get("foreign_links") or {}).items()) for rel in rels]
+    gaps, ask = [], {}
+    for a, b, rel in links:
+        other = cfg.by_name.get(b)
+        if other is None or "live" not in other.faces:
+            gaps.append((a, b, rel))
+        else:
+            ask.setdefault(f"{LIVE_ROOT}/sites/{b}/static/{rel}", []).append((a, b, rel))
+    if ask:
+        script = ("for p in " + " ".join(shlex.quote(x) for x in ask)
+                  + "; do [ -f \"$p\" ] || printf '%s\\n' \"$p\"; done")
+        r = t.dexec("live", "sh -c " + shlex.quote(script), check=False)
+        if r.returncode:
+            raise ReleaseError(f"{t.name}: the links to other sites' files could not be checked: "
+                               f"{(r.stderr or r.stdout)[-300:]}")
+        for missing in r.stdout.splitlines():
+            gaps += ask.get(missing, [])
+    return len(links), sorted(gaps)
+
+
+def check_foreign_links(t: Target, cfg: ReleaseConfig, state: dict, echo: Echo) -> None:
+    n, gaps = foreign_gaps(t, cfg, state)
+    if not n:
+        return
+    if not gaps:
+        echo(f"✓ links to other sites' files: {n}, all served by those sites")
+        return
+    echo(f"! links to other sites' files: {len(gaps)} of {n} not served by the site their address names "
+         "(a visitor gets 404) — that site must show or link to the file, or name it in its media_keep:")
+    for a, b, rel in gaps:
+        echo(f"    {a} → {b}: /app/static/{rel}")
+
+
+def record_skew(v: dict, skew: str, version: str = "") -> None:
+    """A site published with --allow-skew is marked; with *version*, the exporting streamtex, when the
+    gap was one of version only: the mark is then resolved once the live image runs it (#150)."""
+    v.pop("skew", None)
+    v.pop("skew_version", None)
+    if skew:
+        v["skew"] = skew
+        if version:
+            v["skew_version"] = version
+
+
+def skew_flag(v: dict, running: str) -> str:
+    """The mark status shows: kept, never erased, but said resolved when the image caught up (#150)."""
+    if not v.get("skew"):
+        return ""
+    if v.get("skew_version") and v["skew_version"] == running:
+        return f"  (skew, resolved: the live image runs {running})"
+    return "  (skew)"
+
+
 def _slides(v: dict) -> str:
     return "all slides" if v.get("up_to_slide") is None else f"slides 1 to {v['up_to_slide']}"
 
@@ -524,7 +585,7 @@ def image_version(t: Target) -> str:
     return r.stdout.strip() if r.returncode == 0 else ""
 
 
-def status_rows(t: Target, cfg: ReleaseConfig, state: dict, data: dict | None) -> list[tuple]:
+def status_rows(t: Target, cfg: ReleaseConfig, state: dict, data: dict | None, running: str = "") -> list[tuple]:
     rows = []
     for name, v in sorted(sites_of(state, t.name).items()):
         site = cfg.by_name.get(name)
@@ -550,8 +611,7 @@ def status_rows(t: Target, cfg: ReleaseConfig, state: dict, data: dict | None) -
             flag = f"  ← GAP ({'; '.join(problems)})" if problems else ""
         else:
             flag = "" if html == v.get("release") else "  ← GAP"
-        if v.get("skew"):
-            flag += "  (skew)"
+        flag += skew_flag(v, running)
         if levels and "html" in site.faces and any(lvl != "all" for lvl in levels.values()):
             flag += f"  ({_levels_line(levels, v.get('up_to_slide'))})"
         access = "-" if "html" not in site.faces else ("open" if v.get("html_open") else "protected")

{streamtex-0.7.76 → streamtex-0.7.78}/streamtex/release/state.py

@@ -28,11 +28,13 @@ from . import ReleaseError
 
 STATE_FILE = ".stx-release.json"
 #: What a site entry keeps (the prototype's training/kind are replaced by the site list of stx.toml).
-SITE_KEYS = ("port", "release", "previous", "date", "asleep", "html_open", "skew",
+SITE_KEYS = ("port", "release", "previous", "date", "asleep", "html_open", "skew", "skew_version",
              # the HTML face's own release under a slide limit (#146, as the prototype's bascule2/n1)
              "html_release", "html_previous", "up_to_slide", "up_to_slide_previous", "last", "html_date",
              # each slide number's cut of the release, now and before (#148)
-             "cuts", "cuts_previous")
+             "cuts", "cuts_previous",
+             # the links of its export to other sites' /app/static/ files, checked after a publish (#155)
+             "foreign_links")
 
 
 def state_path(root: Path) -> Path:

{streamtex-0.7.76 → streamtex-0.7.78}/streamtex/release/target.py

@@ -72,9 +72,9 @@ class Target:
                 "-o", "ControlMaster=auto", "-o", f"ControlPath={CONTROL_PATH}", "-o", "ControlPersist=120",
                 self.cfg["host"]]
 
-    def sh(self, cmd: str, check: bool = True) -> subprocess.CompletedProcess:
+    def sh(self, cmd: str, check: bool = True, input: str | None = None) -> subprocess.CompletedProcess:
         argv = ["sh", "-c", cmd] if self.kind == "local" else [*self.ssh_argv(), cmd]
-        r = subprocess.run(argv, text=True, capture_output=True)
+        r = subprocess.run(argv, input=input, text=True, capture_output=True)
         if check and r.returncode:
             raise ReleaseError(f"{self.name}: `{cmd[:120]}` failed: {(r.stderr or r.stdout)[-600:]}")
         return r

{streamtex-0.7.76 → streamtex-0.7.78/streamtex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamtex
-Version: 0.7.76
+Version: 0.7.78
 Summary: AI-powered content framework for Streamlit — create presentations, courses, and web-books with Claude or Cursor, no coding required.
 Author-email: Nicolas Guelfi <nicolas.guelfi@laposte.net>
 License-Expression: BUSL-1.1