@@ -11,7 +11,7 @@ git-sim works anywhere you use Git. The `git-sim` command line tool does the wor
 | Vim 8.1 and newer | the same commands as Neovim | [integrations/vim](../integrations/vim) |
 | Emacs 27.1 and newer | `git-sim-simulate`, `git-sim-preflight`, and `git-sim-live`, with Magit's branch or commit at point as the default | [integrations/emacs](../integrations/emacs) |
 | nano, and editors without plugins | `git live` in a second terminal pane, and nano's execute prompt (`^T`) to drop a pre-flight report into your file | [shell.md](shell.md) |
-| Jupyter | `%gitsim rebase main` shows the graph right under the cell | below |
+| Jupyter | `%gitsim rebase main` shows the graph right under the cell, and `%gitsim live` shows the live graph there | below |
 | GitHub CLI | `gh sim pr 42` shows what merging a pull request would do | [integrations/gh-sim](../integrations/gh-sim) |
 | GitHub Actions | a comment on each pull request with the pre-flight report, and the graph attached to the run | [integrations/github-action](../integrations/github-action) |
 | Blogs and docs | `git-sim-embed.js` wraps any git-sim graph in the interactive viewer | [embed.md](embed.md) |
@@ -34,6 +34,12 @@ Then, in a notebook:
 %gitsim rebase main
 %gitsim --height 700 -C ../other-repo merge feature
 %gitsim preflight reset --hard HEAD~1
+%gitsim live
+%gitsim live stop
 ```
 
 The command runs in the notebook's working directory (or the `-C` path), the same as it would in a terminal. The graph shows up in a frame under the cell that grows to fit it, up to 1200 pixels. To pick the height yourself, put `--height` and a number of pixels before the Git command. `preflight` prints the report as text. git-sim never changes your repo.
+
+`%gitsim live` runs `git-sim live` in the background and shows the live page under the cell, 760 pixels tall unless you set `--height`. It updates as the repo changes, whether you run Git in the notebook or in a terminal, and you can add live mode options after it, like `%gitsim live --no-zones`. Running it again shows the same session. `%gitsim live stop` stops it, and so does restarting the kernel.
+
+Live mode only works when Jupyter runs on your own machine, because the page comes from a small server on the kernel's `127.0.0.1`. In Colab, JupyterHub, or Binder, run `git-sim live` on the machine with the repo instead.
@@ -4,19 +4,27 @@
     %gitsim --height 700 merge feature  a fixed height (it fits the graph otherwise)
     %gitsim preflight reset --hard HEAD~1
                                         the pre-flight report, as text
+    %gitsim live                        the live graph, updating as the repo changes
+    %gitsim live stop                   stops it (so does restarting the kernel)
 
 The command runs in the notebook's working directory (or ``-C path``) exactly
 as it would in a terminal, with the browser kept closed, and the page git-sim
 writes is shown in an iframe so its scripts and styles stay out of the
-notebook's own. Nothing in the repository is changed.
+notebook's own. Live mode runs git-sim live in the background and frames the
+page its local server serves, so it needs Jupyter on your own machine.
+Nothing in the repository is changed.
 """
 
+import atexit
 import html
 import os
+import queue
+import re
 import shlex
 import subprocess
 import sys
-from typing import List, Optional, Tuple
+import threading
+from typing import Dict, List, Optional, Tuple
 
 DEFAULT_HEIGHT = 560
 
@@ -95,6 +103,129 @@ def run(words: List[str], repo: Optional[str] = None) -> subprocess.CompletedPro
     )
 
 
+LIVE_HEIGHT = 760
+LIVE_URL = re.compile(r"http://127\.0\.0\.1:\d+/#k=[\w-]+")
+
+# The git-sim live servers this kernel started: repository folder -> (process, url)
+_live: Dict[str, Tuple[subprocess.Popen, str]] = {}
+
+
+def remote_kernel() -> bool:
+    """Whether the notebook is likely open in a browser on another machine
+    (Colab, JupyterHub, Binder), which can't reach this machine's 127.0.0.1."""
+    return "google.colab" in sys.modules or any(
+        name in os.environ
+        for name in ("COLAB_RELEASE_TAG", "JUPYTERHUB_API_URL", "BINDER_SERVICE_HOST")
+    )
+
+
+def live_frame(url: str, height: int = LIVE_HEIGHT) -> str:
+    return (
+        f'<div><iframe src="{html.escape(url, quote=True)}" '
+        f'style="width:100%;height:{int(height)}px;border:0;border-radius:10px" '
+        'title="git-sim live"></iframe></div>'
+    )
+
+
+def live_start(extra: List[str], repo: Optional[str]) -> Tuple[Optional[str], str]:
+    """Start git-sim live for the repository in the background, or reuse the
+    one already running there. Returns the page's URL, or None and what went
+    wrong."""
+    where = os.path.abspath(repo or ".")
+    running = _live.get(where)
+    if running and running[0].poll() is None:
+        return running[1], ""
+    cmd = [sys.executable, "-m", "git_sim", "--open-in", "local", "live"]
+    cmd += ["--allow-local-frames", *extra]
+    proc = subprocess.Popen(
+        cmd,
+        cwd=where,
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.PIPE,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        env=dict(os.environ, git_sim_auto_open="false"),
+    )
+    # It prints the URL once the first drawing is done. The rest of what it
+    # prints is read and dropped so the pipe never fills up.
+    found: "queue.Queue[str]" = queue.Queue()
+    said: List[str] = []
+
+    def read():
+        for text in proc.stderr:
+            match = LIVE_URL.search(text)
+            if match:
+                found.put(match.group(0))
+            elif found.empty():
+                said.append(text)
+        found.put("")
+
+    threading.Thread(target=read, daemon=True).start()
+    try:
+        url = found.get(timeout=60)
+    except queue.Empty:
+        url = ""
+    if not url:
+        proc.kill()
+        return None, "".join(said).strip() or "git-sim live did not start in 60 seconds"
+    _live[where] = (proc, url)
+    return url, ""
+
+
+def live_stop() -> List[str]:
+    """Stop every git-sim live this kernel started. Returns their folders."""
+    stopped = []
+    for where, (proc, _) in list(_live.items()):
+        if proc.poll() is None:
+            proc.terminate()
+            stopped.append(where)
+        del _live[where]
+    return stopped
+
+
+atexit.register(live_stop)
+
+
+def show_live(rest: List[str], height: Optional[int], repo: Optional[str]) -> None:
+    from IPython.display import HTML, Markdown, display
+
+    if rest[:1] == ["stop"]:
+        stopped = live_stop()
+        display(
+            Markdown(
+                "Stopped git-sim live for " + ", ".join(f"`{s}`" for s in stopped) + "."
+                if stopped
+                else "git-sim live isn't running."
+            )
+        )
+        return
+    if remote_kernel():
+        display(
+            Markdown(
+                "Live mode needs Jupyter running on your own machine, because the page "
+                "comes from a server on the kernel's `127.0.0.1`, which your browser "
+                "can't reach from here. Run `git-sim live` on the machine with the repo instead."
+            )
+        )
+        return
+    url, error = live_start(rest, repo)
+    if not url:
+        display(
+            HTML(
+                f"<pre style='color:#b91c1c;font:13px/1.45 monospace'>git-sim live could not start\n{html.escape(error)}</pre>"
+            )
+        )
+        return
+    display(HTML(live_frame(url, height or LIVE_HEIGHT)))
+    display(
+        Markdown(
+            "Watching the repo in the background. `%gitsim live stop` stops it, and so does restarting the kernel."
+        )
+    )
+
+
 def gitsim(line: str):
     """The %gitsim line magic."""
     from IPython.display import HTML, Markdown, display
@@ -103,10 +234,13 @@ def gitsim(line: str):
     if not words:
         display(
             Markdown(
-                "`%gitsim <git command>`, e.g. `%gitsim rebase main`, or `%gitsim preflight reset --hard HEAD~1`."
+                "`%gitsim <git command>`, e.g. `%gitsim rebase main`, `%gitsim preflight reset --hard HEAD~1`, or `%gitsim live`."
             )
         )
         return
+    if words[0] == "live":
+        show_live(words[1:], height, repo)
+        return
     result = run(words, repo)
     if words[0] == "preflight":
         text = (result.stdout or "") + (result.stderr or "")
 
@@ -971,7 +971,10 @@ def _send(self, body: bytes, content_type: str, status: int = 200) -> None:
         self.send_header("Content-Type", content_type)
         self.send_header("Content-Length", str(len(body)))
         self.send_header("Cache-Control", "no-store")
-        self.send_header("X-Frame-Options", "DENY")
+        if self.server.local_frames:
+            self.send_header("Content-Security-Policy", LOCAL_FRAME_ANCESTORS)
+        else:
+            self.send_header("X-Frame-Options", "DENY")
         self._cors()
         self.end_headers()
         self.wfile.write(body)
@@ -1093,9 +1096,10 @@ class LiveServer(http.server.ThreadingHTTPServer):
     # git-sim live finds it busy (and picks another) rather than sharing it.
     allow_reuse_address = os.name != "nt"
 
-    def __init__(self, address, session: LiveSession):
+    def __init__(self, address, session: LiveSession, local_frames: bool = False):
         super().__init__(address, LiveHandler)
         self.session = session
+        self.local_frames = local_frames
 
     def server_bind(self):
         if os.name == "nt" and hasattr(socket, "SO_EXCLUSIVEADDRUSE"):
@@ -1105,8 +1109,17 @@ def server_bind(self):
 
 SERVER_FILE = "server.json"
 
+# With --allow-local-frames (the Jupyter magic): only pages served from this
+# machine may put the live page in a frame. Without it, nothing may.
+LOCAL_FRAME_ANCESTORS = (
+    "frame-ancestors http://localhost:* http://127.0.0.1:* "
+    "https://localhost:* https://127.0.0.1:*"
+)
+
 
-def _serve(session: "LiveSession", port: int, sessions_dir: str) -> LiveServer:
+def _serve(
+    session: "LiveSession", port: int, sessions_dir: str, local_frames: bool = False
+) -> LiveServer:
     """The live server, on the port and with the key this repository's last
     one had (kept in <sessions dir>/server.json), so a page still open from
     before git-sim live was restarted reconnects by itself. With --port, that
@@ -1121,12 +1134,14 @@ def _serve(session: "LiveSession", port: int, sessions_dir: str) -> LiveServer:
     server = None
     if saved.get("port") and saved.get("key") and (not port or port == saved["port"]):
         try:
-            server = LiveServer(("127.0.0.1", int(saved["port"])), session)
+            server = LiveServer(
+                ("127.0.0.1", int(saved["port"])), session, local_frames
+            )
             session.key = saved["key"]
         except (OSError, ValueError):
             server = None
     if server is None:
-        server = LiveServer(("127.0.0.1", port), session)
+        server = LiveServer(("127.0.0.1", port), session, local_frames)
     try:
         os.makedirs(sessions_dir, exist_ok=True)
         with open(os.path.join(sessions_dir, SERVER_FILE), "w", encoding="utf-8") as f:
@@ -1276,6 +1291,12 @@ def live(
         POLL_SECONDS, "--interval", help="Seconds between checks of the repository."
     ),
     repo: str = typer.Option(".", "--repo", "-C", help="The repository to watch."),
+    local_frames: bool = typer.Option(
+        False,
+        "--allow-local-frames",
+        hidden=True,
+        help="Let pages on this machine frame the live page (the Jupyter magic uses it).",
+    ),
 ):
     """Follow the repository as it changes: an animated graph that plays every
     commit, branch, checkout, reset, rebase or staged file as it happens, in
@@ -1386,7 +1407,7 @@ def emit(snap: Snapshot) -> None:
     # Browser mode: draw the current state, serve, watch.
     _say(f"git-sim live: drawing {root} ...")
     session.start()
-    server = _serve(session, port, _sessions_dir(root))
+    server = _serve(session, port, _sessions_dir(root), local_frames)
     base = f"http://127.0.0.1:{server.server_address[1]}"
     local_url = f"{base}/#k={session.key}"
     watcher = threading.Thread(
 
@@ -1,5 +1,9 @@
 """The Jupyter magic's pieces that need no notebook."""
 
+import subprocess
+import urllib.request
+
+from git_sim import jupyter
 from git_sim.jupyter import DEFAULT_HEIGHT, embed_page, parse_line
 
 
@@ -33,3 +37,21 @@ def test_with_no_height_the_frame_fits_the_graph():
     assert f"height:{DEFAULT_HEIGHT}px" in frame and '" onload="' in frame
     assert "getElementById(&#x27;scene&#x27;)" in frame
 
+
+def test_live_starts_once_per_repo_and_serves_a_frameable_page(tmp_path):
+    def git(*args):
+        subprocess.run(["git", *args], cwd=tmp_path, check=True, capture_output=True)
+
+    git("init", "-q")
+    git("-c", "user.name=t", "-c", "user.email=t@t", "commit", "-q", "--allow-empty", "-m", "a")
+    try:
+        url, error = jupyter.live_start(["--no-zones"], str(tmp_path))
+        assert url and not error and jupyter.LIVE_URL.fullmatch(url)
+        # a second cell reuses the running server
+        assert jupyter.live_start([], str(tmp_path)) == (url, "")
+        with urllib.request.urlopen(url.split("#")[0]) as r:
+            assert "frame-ancestors" in r.headers["Content-Security-Policy"]
+        assert f'src="{url}"' in jupyter.live_frame(url)
+    finally:
+        assert jupyter.live_stop() == [str(tmp_path)]
+    assert jupyter.live_stop() == []
@@ -663,6 +663,36 @@ def test_the_local_server_requires_the_key_and_answers_the_site(repo, tmp_path):
             urllib.request.urlopen(base + "/info")
         with urllib.request.urlopen(base + f"/info?k={session.key}") as r:
             assert json.loads(r.read()) == {"repo": "repo", "where": session.where}
+        # no page may frame it
+        with urllib.request.urlopen(base + "/") as r:
+            assert r.headers["X-Frame-Options"] == "DENY"
+            assert r.headers.get("Content-Security-Policy") is None
+    finally:
+        session.stop.set()
+        server.shutdown()
+        server.server_close()
+
+
+def test_the_jupyter_magics_server_lets_only_local_pages_frame_it(repo, tmp_path):
+    import urllib.request
+
+    from git_sim.live import LiveServer
+
+    session = LiveSession(str(repo), str(tmp_path / "out"), zones=False, poll=0.1)
+    session.start()
+    server = LiveServer(("127.0.0.1", 0), session, local_frames=True)
+    thread = __import__("threading").Thread(
+        target=server.serve_forever, kwargs={"poll_interval": 0.1}, daemon=True
+    )
+    thread.start()
+    try:
+        with urllib.request.urlopen(
+            f"http://127.0.0.1:{server.server_address[1]}/"
+        ) as r:
+            assert r.headers.get("X-Frame-Options") is None
+            policy = r.headers["Content-Security-Policy"]
+            assert policy.startswith("frame-ancestors ") and "http://localhost:*" in policy
+            assert "initialcommit" not in policy
     finally:
         session.stop.set()
         server.shutdown()