showrun-cli 0.1.0__py3-none-any.whl

showrun/shell.py

@@ -0,0 +1,238 @@
+"""A persistent shell session driven through a pty.
+
+All steps run in the same shell process, so `cd`, `export`, functions and
+aliases carry over between steps.  Completion of each command is detected by
+a random sentinel printed together with the command's exit status.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import secrets
+import shlex
+import shutil
+import tempfile
+import time
+from dataclasses import dataclass
+from typing import Callable, Dict, Optional
+
+import pexpect
+
+
+@dataclass
+class Result:
+    exit_code: int
+    output: str
+    duration: float
+    timed_out: bool = False
+    interrupted: bool = False
+
+
+class ShellError(Exception):
+    pass
+
+
+def _kill_tree(pid: int) -> None:
+    """Terminate *pid* and its descendants (background groups run in a subshell)."""
+    import subprocess
+
+    try:
+        kids = subprocess.run(["pgrep", "-P", str(pid)], capture_output=True, text=True).stdout.split()
+    except FileNotFoundError:
+        kids = []
+    for kid in kids:
+        _kill_tree(int(kid))
+    try:
+        os.kill(pid, 15)
+    except (ProcessLookupError, PermissionError):
+        pass
+
+
+class Shell:
+    def __init__(
+        self,
+        shell: str = "bash",
+        cwd: Optional[str] = None,
+        env: Optional[Dict[str, str]] = None,
+        size: Optional[tuple] = None,
+    ):
+        self.token = secrets.token_hex(6)
+        self._marker_prefix = "__SR_" + self.token
+        full_env = dict(os.environ)
+        full_env.update(env or {})
+        full_env.setdefault("TERM", "xterm-256color")
+        # A pager (git log, man, systemctl) would wait for keys the audience never sends.
+        # The demo's own settings.env can still choose a pager.
+        for var in ("PAGER", "GIT_PAGER", "SYSTEMD_PAGER"):
+            if var not in (env or {}):
+                full_env[var] = "cat"
+        # Keep users' rc files out of the way; demos should be reproducible.
+        full_env["PS1"] = ""
+        full_env["PS2"] = ""
+        full_env.pop("PROMPT_COMMAND", None)
+
+        args = ["--norc", "--noprofile"] if os.path.basename(shell) == "bash" else []
+        if os.path.basename(shell) == "zsh":
+            args = ["-f"]
+        cols, rows = size or shutil.get_terminal_size((100, 30))
+        try:
+            self.child = pexpect.spawn(
+                shell, args, cwd=cwd, env=full_env, encoding="utf-8",
+                codec_errors="replace", dimensions=(rows, cols), echo=False,
+            )
+        except pexpect.ExceptionPexpect as e:
+            raise ShellError(f"could not start shell '{shell}': {e}") from e
+
+        self._raw("stty -echo 2>/dev/null; PS1=''; PS2=''; unset PROMPT_COMMAND; set +m 2>/dev/null; bind 'set enable-bracketed-paste off' 2>/dev/null")
+        self.run("true")  # sync: swallow any startup noise
+        self.background: list = []  # (pid, logfile, command)
+
+    # -- low level -----------------------------------------------------
+    def _raw(self, line: str) -> None:
+        self.child.sendline(line)
+
+    def resize(self, cols: int, rows: int) -> None:
+        self.child.setwinsize(rows, cols)
+
+    @property
+    def alive(self) -> bool:
+        return self.child.isalive()
+
+    # -- running -------------------------------------------------------
+    def run(
+        self,
+        command: str,
+        on_output: Optional[Callable[[str], None]] = None,
+        timeout: Optional[float] = None,
+    ) -> Result:
+        """Run *command* to completion, streaming output to *on_output*."""
+        if not self.alive:
+            raise ShellError("shell has exited")
+        # The status line is sent on its own line so multi-line commands work.
+        # Each run gets its own marker id, so a stale marker can never end a later run.
+        self._seq = getattr(self, "_seq", 0) + 1
+        seq = self._seq
+        marker_re = re.compile(r"\r?\n?__SR_" + self.token + "_" + str(seq) + r"_(\d+)__\r?\n")
+        marker_cmd = f"printf '\\n__SR_{self.token}_{seq}_%d__\\n' \"$?\"\n"
+        self.child.send(command.rstrip("\n") + "\n")
+        self.child.send(marker_cmd)
+
+        def interrupt() -> None:
+            # Ctrl-C makes the tty discard typed-ahead input, including our
+            # marker line, so send it again afterwards.
+            self.child.sendintr()
+            time.sleep(0.1)
+            self.child.send(marker_cmd)
+
+        start = time.monotonic()
+        buf = ""
+        emitted = []
+        hold = len(self._marker_prefix) + 16  # >= full marker length
+        timed_out = interrupted = False
+
+        def emit(text: str) -> None:
+            if text:
+                emitted.append(text)
+                if on_output:
+                    on_output(text)
+
+        while True:
+            try:
+                chunk = self.child.read_nonblocking(4096, timeout=0.05)
+                buf += chunk
+            except pexpect.TIMEOUT:
+                pass
+            except pexpect.EOF:
+                emit(buf)
+                raise ShellError("shell exited while running a command (did the step run `exit`?)")
+            except KeyboardInterrupt:
+                interrupt()
+                interrupted = True
+                continue
+
+            m = marker_re.search(buf)
+            if m:
+                emit(buf[: m.start()])
+                rest = buf[m.end():]
+                if rest.strip():
+                    emit(rest)
+                code = int(m.group(1))
+                break
+            # Emit everything except a tail that might hold a partial marker.
+            safe = len(buf) - hold
+            if safe > 0:
+                emit(buf[:safe])
+                buf = buf[safe:]
+
+            if timeout and not timed_out and time.monotonic() - start > timeout:
+                timed_out = True
+                interrupt()
+
+        return Result(code, "".join(emitted), time.monotonic() - start, timed_out, interrupted)
+
+    def start_background(self, command: str) -> tuple:
+        """Start *command* in the background inside the session; returns (pid, logfile)."""
+        log = os.path.join(tempfile.gettempdir(), f"showrun-{self.token}-bg{len(self.background)}.log")
+        # A subshell keeps bash from printing job-control noise like "[1] 1234".
+        out = self.capture(f"( {{ {command.rstrip().rstrip(';')}\n}} > {shlex.quote(log)} 2>&1 & echo $! )")
+        try:
+            pid = int(out.strip().splitlines()[-1])
+        except (ValueError, IndexError):
+            raise ShellError(f"could not start background command: {out}")
+        self.background.append((pid, log, command))
+        return pid, log
+
+    def stop_background(self) -> None:
+        for pid, _, _ in self.background:
+            _kill_tree(pid)
+        self.background.clear()
+
+    def wait_for(self, command: str, timeout: float = 30, interval: float = 0.5) -> bool:
+        """Poll *command* (silently) until it exits 0, or give up after *timeout* seconds."""
+        deadline = time.monotonic() + timeout
+        while True:
+            if self.run(f"{{ {command}\n}} >/dev/null 2>&1", timeout=max(1.0, min(10, timeout))).exit_code == 0:
+                return True
+            if time.monotonic() > deadline:
+                return False
+            time.sleep(interval)
+
+    def capture(self, command: str, timeout: float = 10) -> str:
+        out = self.run(command, timeout=timeout).output
+        return re.sub(r"\x1b\[[0-9;?]*[ -/]*[@-~]|\r", "", out).strip()
+
+    def cwd(self) -> str:
+        path = self.capture("pwd")
+        home = os.path.expanduser("~")
+        if home != "/" and (path == home or path.startswith(home + "/")):
+            path = "~" + path[len(home):]
+        return path
+
+    # -- live interaction -----------------------------------------------
+    def interact(self, prompt: str = "(live) \\w $ ", escape: str = "\x1d") -> None:
+        """Hand the session to the user until they press the escape key (Ctrl-])."""
+        self.run(f"stty echo 2>/dev/null; PS1='{prompt}'")
+        try:
+            self.child.interact(escape_character=escape)
+        finally:
+            self.child.sendcontrol("c")  # discard any half-typed line
+            time.sleep(0.05)
+            self._raw("stty -echo 2>/dev/null; PS1=''")
+            self.run("true")
+
+    def close(self) -> None:
+        self.stop_background()
+        if self.alive:
+            try:
+                self._raw("exit")
+                self.child.expect(pexpect.EOF, timeout=2)
+            except Exception:
+                pass
+            self.child.close(force=True)
+
+    def __enter__(self) -> "Shell":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.close()

showrun/starter.yaml

@@ -0,0 +1,65 @@
+# showrun demo — press Enter to advance, ? for all keys.
+title: showrun tour
+
+settings:
+  prompt: "[bold green]anand@demo[/] [bold blue]{cwd}[/] [bold]$[/] "
+  typing_speed: 0.035     # seconds per character
+  jitter: 0.5             # human-ish timing
+  typo_rate: 0.015        # the occasional fat-fingered key, corrected live
+
+vars:
+  port: 8765              # override: showrun play demo.yaml -v port=9000
+  workdir: /tmp/showrun-tour
+
+setup:                    # runs silently before the first step
+  - rm -rf {{workdir}} && mkdir -p {{workdir}}
+
+cleanup:                  # always runs, even if you quit with q
+  - rm -rf {{workdir}}
+
+steps:
+  - title: Getting set up
+    say: Every step shares one shell, so cd and export stick.
+    run: cd {{workdir}}
+    notes: Mention that this is a real shell, not a recording.
+
+  - run: export GREETING="hello from showrun"     # shorthand also works: - echo hi
+    hidden: true
+
+  - run: echo "$GREETING"
+    expect_output: hello
+
+  - run: |
+      cat > app.txt <<'EOF'
+      status: ok
+      version: 1.4.2
+      warning: cache is cold
+      EOF
+    type: false            # appears instantly, no typing
+
+  - run: cat app.txt
+    highlight: ["warning.*"]   # draw the audience's eye
+    notes: Point at the highlighted warning line.
+
+  - title: Services
+    run: python3 -m http.server {{port}} --bind 127.0.0.1
+    background: true
+    wait_for: curl -sf http://127.0.0.1:{{port}}/ -o /dev/null
+
+  - run: curl -s http://127.0.0.1:{{port}}/ | grep -m1 -o 'app.txt'
+    expect_output: app.txt
+
+  - title: Safety nets
+    say: Slow or flaky? Show canned output instead of running it.
+    run: kubectl rollout status deploy/web
+    execute: false
+    output: |
+      Waiting for deployment "web" rollout to finish: 2 of 3 updated replicas are available...
+      deployment "web" successfully rolled out
+    highlight: successfully
+
+  - run: ls /does-not-exist
+    expect_exit: any        # failures you meant to show
+
+  - say: That's the tour. Try `showrun record my-demo.yaml` to capture your own.
+    pause: true

showrun_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,247 @@
+Metadata-Version: 2.5
+Name: showrun-cli
+Version: 0.1.0
+Summary: Scripted, keypress-driven terminal demos: record once, present with Enter, replay offline.
+Project-URL: Homepage, https://showrun.clues.apps.clue2.app
+Project-URL: Repository, https://github.com/honnuanand/showrun
+Project-URL: Issues, https://github.com/honnuanand/showrun/issues
+Project-URL: Documentation, https://github.com/honnuanand/showrun/tree/main/docs
+Author-email: Anand Rao <anand@clue2solve.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: asciinema,cli,demo,demo-magic,live-coding,mcp,presentation,terminal
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Documentation
+Classifier: Topic :: Terminals
+Requires-Python: >=3.9
+Requires-Dist: pexpect>=4.8
+Requires-Dist: pydantic>=2
+Requires-Dist: pyyaml>=6
+Requires-Dist: rich>=13
+Requires-Dist: typer>=0.9
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.2; (python_version >= '3.10') and extra == 'mcp'
+Description-Content-Type: text/markdown
+
+# showrun
+
+[![CI](https://github.com/honnuanand/showrun/actions/workflows/ci.yml/badge.svg)](https://github.com/honnuanand/showrun/actions/workflows/ci.yml)
+[![Publish](https://github.com/honnuanand/showrun/actions/workflows/publish.yml/badge.svg)](https://github.com/honnuanand/showrun/actions/workflows/publish.yml)
+[![PyPI](https://img.shields.io/pypi/v/showrun-cli)](https://pypi.org/p/showrun-cli)
+[![Python](https://img.shields.io/pypi/pyversions/showrun-cli)](https://pypi.org/p/showrun-cli)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](https://github.com/honnuanand/showrun/blob/main/LICENSE)
+
+Scripted, keypress-driven terminal demos. You write (or **record**) the demo once, then
+present it by just hitting **Enter**: commands are typed out like a human would, run in a
+real shell, and stream live output. Hidden setup, canned output, presenter notes, rehearsal,
+offline playback and recordings are built in.
+
+It's made for anyone who shows a command line to other people: conference talks, team demos,
+and especially **how-tos for CLI tools**. Write the steps once, rehearse them in CI, present
+them live, and publish the same file as a replay and a Markdown runbook.
+
+**Website and live replays: [showrun.clues.apps.clue2.app](https://showrun.clues.apps.clue2.app)**
+
+![showrun presenting a short git how-to](https://raw.githubusercontent.com/honnuanand/showrun/main/docs/media/git-undo.gif)
+
+```bash
+pip install showrun-cli     # the command is `showrun`
+showrun init demo.yaml      # starter demo that shows off every feature
+showrun check demo.yaml     # rehearse unattended
+showrun play demo.yaml      # present it
+```
+
+## Sample replays
+
+Each of these is a YAML file in this repo, rendered with `showrun render`. The `.cast` files
+play in [asciinema-player](https://github.com/asciinema/asciinema-player) or with
+`showrun replay docs/casts/<name>.cast`.
+
+| Demo | Replay |
+|---|---|
+| **How-to: undo your last git commit** ([`docs/demos/git-undo.yaml`](https://github.com/honnuanand/showrun/blob/main/docs/demos/git-undo.yaml)): narration, highlights, a real git repo set up silently | [GIF](https://raw.githubusercontent.com/honnuanand/showrun/main/docs/media/git-undo.gif) · [cast](https://github.com/honnuanand/showrun/blob/main/docs/casts/git-undo.cast) |
+| **The feature tour** ([`examples/tour.yaml`](https://github.com/honnuanand/showrun/blob/main/examples/tour.yaml)): shared shell state, hidden steps, a background server with `wait_for`, canned output | ![tour](https://raw.githubusercontent.com/honnuanand/showrun/main/docs/media/tour.gif) |
+| **showrun rehearsing itself** ([`docs/demos/showrun-cli.yaml`](https://github.com/honnuanand/showrun/blob/main/docs/demos/showrun-cli.yaml)): `validate`, `check` and `export` | ![showrun cli](https://raw.githubusercontent.com/honnuanand/showrun/main/docs/media/showrun-cli.gif) |
+| **Offline playback** ([`examples/recorded.yaml`](https://github.com/honnuanand/showrun/blob/main/examples/recorded.yaml) with `--offline`): recorded output, nothing executed | ![offline](https://raw.githubusercontent.com/honnuanand/showrun/main/docs/media/offline.gif) |
+
+The full guide, with every option and workflow, is in [docs/](https://github.com/honnuanand/showrun/blob/main/docs/README.md).
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `showrun play demo.yaml` | Present. `--offline` replays recorded output, `--fallback` runs live but swaps in the recording if a step fails, `--auto 3` advances by itself, `--start 7`, `--speed 2`, `--cast talk.cast`, `-v port=9000` |
+| `showrun record demo.yaml` | Do the demo once in a shell; every command and its output becomes a step |
+| `showrun check demo.yaml` | Rehearsal: runs every step, checks exit codes and expected output, flags slow steps. Exit code 1 on failure, so it works in CI |
+| `showrun notes demo.yaml` | Presenter view for a second terminal: current step, talking points, what's next, timer |
+| `showrun render demo.yaml -o demo.cast` | Present unattended and save an asciinema cast, no terminal needed (`--offline`, `--delay 1.5`, `--width`, `--height`). Good for docs and CI |
+| `showrun replay talk.cast` | Play back a recording (`--speed 2 --max-idle 1`). Casts also work with asciinema / asciinema-player |
+| `showrun export demo.yaml -f md` | Markdown runbook (`-f sh` for a plain bash script) |
+| `showrun validate demo.yaml` | Parse and list steps |
+| `showrun mcp` | MCP server for AI agents (see below) |
+
+## Keys while presenting
+
+| Key | Action |
+|---|---|
+| Enter / Space / → | run the typed command, or continue |
+| any key while typing | finish typing instantly |
+| `s` | skip this step |
+| `b` / ← | back one step |
+| `r` | retype the command |
+| `g` + number + Enter | jump to step N |
+| `l` | list all steps |
+| `i` | live shell in the same session (Ctrl-] returns to the demo) |
+| `?` | help |
+| `q` / Ctrl-C | quit (cleanup still runs) |
+
+## Recording
+
+```
+showrun record kafka-demo.yaml
+● rec ~/work $ #title Producing events
+● rec ~/work $ #say Let's start the broker first
+● rec ~/work $ #bg docker compose up kafka
+● rec ~/work $ #wait nc -z localhost 9092
+● rec ~/work $ kcat -b localhost:9092 -L
+● rec ~/work $ #note mention partitions here
+● rec ~/work $ ./produce.sh 100
+● rec ~/work $ #done
+```
+
+Directives: `#say`, `#title`, `#note` (attach to the next command), `#hide cmd`, `#bg cmd`,
+`#wait cmd`, `#fake` (turn the last step into canned output), `#pause`, `#undo`, `#list`,
+`#done`. The file is saved after every step, so nothing is lost if something crashes.
+
+Each recorded step keeps its output in `recorded_output`, which gives you three ways to
+present:
+
+- `showrun play demo.yaml` runs everything live.
+- `showrun play demo.yaml --offline` shows the recordings and runs nothing that has one
+  (background services and `wait_for` are skipped). It's for bad wifi or no cluster.
+- `showrun play demo.yaml --fallback` runs live, but if a step fails, times out or misses
+  `expect_output`, it says so and shows the recorded run instead.
+
+## Demo file reference
+
+```yaml
+title: My demo
+settings:
+  prompt: "[bold green]me@demo[/] [blue]{cwd}[/] $ "   # Rich markup; {cwd} is live
+  typing_speed: 0.04      # s per char
+  jitter: 0.5             # timing randomness
+  typo_rate: 0.01         # occasional fake typo, corrected on screen
+  wait_before_typing: false
+  theme: monokai          # syntax highlighting theme
+  timeout: 60             # default per-step timeout
+  shell: bash             # or zsh
+  cwd: ./project          # relative to the YAML file
+  env: {KUBECONFIG: ./kc}
+vars:                     # {{name}}; override with -v name=x or SHOWRUN_VAR_NAME
+  ns: demo
+setup:   [kubectl create ns {{ns}}]     # silent, before step 1
+cleanup: [kubectl delete ns {{ns}}]     # always runs
+steps:
+  - kubectl get pods -n {{ns}}          # plain string = run it
+  - run: export TOKEN=$(./get-token)
+    hidden: true                        # runs silently
+  - title: Deploying                    # section rule
+    say: Now we roll out v2             # narration shown as a comment
+    notes: Stress zero downtime         # presenter view only
+    run: kubectl apply -f v2.yaml
+    highlight: ["configured", "created"]  # regexes highlighted in output
+    expect_output: configured           # checked by `check`, warned live
+    expect_exit: 0                      # or "any"
+    timeout: 30
+  - run: ./server --port 8080
+    background: true
+    wait_for: curl -sf localhost:8080/health
+    wait_timeout: 30
+  - run: terraform apply                # too slow to run on stage?
+    execute: false
+    output: "Apply complete! Resources: 3 added"
+  - run: cat big.json
+    type: false                         # appears instantly
+    speed: 0.01                         # per-step typing speed
+    typos: false
+    clear: true                         # clear screen first
+  - pause: true                         # wait for Enter
+```
+
+## How it works
+
+- **One persistent shell** (`pexpect` on a pty) runs every step, so `cd`, `export` and
+  functions carry over. A unique marker after each command gives the exit code and tells
+  showrun when the command has finished, without guessing at prompts.
+- **Rich** draws the prompt, the syntax-highlighted typing, highlights and the notes view.
+- **Recordings** are plain asciinema v2 files with a marker at each step, written by
+  showrun itself, so asciinema doesn't need to be installed.
+- **Background jobs** run inside the session, and their process trees are killed at the end.
+
+## Limits
+
+Full-screen apps (vim, top, k9s) don't stream well inside a step. Use `i` to drop into the
+live shell for those. Commands that read from stdin need their input piped in.
+
+## Use it from AI agents (MCP)
+
+`showrun mcp` runs a [Model Context Protocol](https://modelcontextprotocol.io) server over
+stdio, so an agent such as Claude Code, Claude Desktop or Cursor can write, rehearse and
+render demos for you.
+
+```bash
+pip install 'showrun-cli[mcp]'                 # needs Python 3.10+
+claude mcp add showrun -- showrun mcp          # Claude Code
+```
+
+There's also a hosted, read-only server at `https://showrun.clues.apps.clue2.app/mcp`. It can explain the format, validate
+and export demos, and never runs commands. Use it when you don't want to install anything:
+
+```bash
+claude mcp add --transport http showrun https://showrun.clues.apps.clue2.app/mcp
+```
+
+For other clients, add the local server to the client's MCP config:
+
+```json
+{ "mcpServers": { "showrun": { "command": "showrun", "args": ["mcp"] } } }
+```
+
+| Tool | What it does |
+|---|---|
+| `demo_format`, `starter_demo` | The YAML format reference and a starter file to edit |
+| `validate_demo` | Parse a demo (file or inline YAML) and list its steps |
+| `write_demo` | Validate and save a demo; won't overwrite unless asked |
+| `check_demo` | Rehearse: **runs** every command and reports failures |
+| `export_demo` | Markdown runbook or bash script |
+| `render_demo` | Present unattended into a `.cast` (**runs** commands unless `offline`) |
+| `read_cast` | A `.cast` as plain text with step markers, so the agent can see the result |
+
+The server also publishes the one-page guide as the resource `showrun://guide`. Ask your
+agent something like *"write a showrun demo that shows how to use `jq` to filter JSON,
+check it, and render it"*. `check_demo` and `render_demo` run shell commands on your
+machine, so leave your client's tool approval on.
+
+## Credits
+
+showrun is inspired by [demo-magic](https://github.com/paxtonhare/demo-magic) by Paxton
+Hare, the little bash script that types your commands for you while you talk. I've used
+demo-magic for my own talks and demos for more than a decade, and showrun is my attempt at
+the same idea with rehearsal, recording, offline playback and presenter notes built in.
+Thank you, Paxton.
+
+## Development
+
+```bash
+pip install -e '.[dev]' && pytest
+```

showrun_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+showrun/__init__.py,sha256=LvoOF17ZQSvNnFVJX4f2V_KEpmmNwuGvyEI_1Y0J9b8,184
+showrun/cast.py,sha256=3ZGKfCq1jtCMvjshnhtJvxYck6pCcC8nOdJMfNzlS8g,2830
+showrun/check.py,sha256=47d1_Schqn_Hx3dA1EUHSA7AHo6vMpxsRh5h_J0WeoU,3814
+showrun/cli.py,sha256=21oc1aNHKMXtTRSsDk-rAnEHPgamKNZIe8E8ceZyQh0,8931
+showrun/export.py,sha256=zBQkbJqROpp1XYAJglqbrHguWvOFBh4rUdGYNxeuYXQ,2006
+showrun/keys.py,sha256=z8SHKg_--BwabGbGaLXGYQgDhK4B6SPmgut1hhZu5NU,4020
+showrun/mcp_server.py,sha256=jof91ajo6XfEfVWgADm57JrdjFu3Ci-7sgh2MYoaX8w,8828
+showrun/model.py,sha256=9IzLAsToGCNtkPi9iUCkXwaTTBXi45vmb5HdOU09dAU,7741
+showrun/notes.py,sha256=cyPQvFKkIJHLtL4V1wWIcpCBx52xWpRCf7tS_V8mRQ0,3607
+showrun/player.py,sha256=rU67IMO9vd0OY7WrELv5rzYcBhpuQGaIGqZNpfUGHS4,17557
+showrun/record.py,sha256=aNNc2ZJaGWY-AMUKuvF9mHroa5v1sMBDhbxlsOROUhM,6770
+showrun/render.py,sha256=ghWNZE0Klge-wxJA5kC6f5_aw0mHCiDbGeQI4WvwQuk,1626
+showrun/shell.py,sha256=2zYK25204Il1r3ar-OrTxn7vroYMJyiRq7Kscf5ZgNw,8613
+showrun/starter.yaml,sha256=JrmTwDyOJ6mh8ChA2Bu0IHclg7sWnoaH9ASlosMuszs,2062
+showrun_cli-0.1.0.dist-info/METADATA,sha256=rpIaz6s3FpPYYHPZa-CVrVnQ-cwdmc_Xa-77olI7DjM,12320
+showrun_cli-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+showrun_cli-0.1.0.dist-info/entry_points.txt,sha256=mwf9MCaDGAqNnDJmF8hTp5olapHQzoYDEISrKdL0NPc,44
+showrun_cli-0.1.0.dist-info/licenses/LICENSE,sha256=_sMEFpXIlvRW0vJhpbJ5Xpi0LQOp7YTKz_4_LCUpOm0,1066
+showrun_cli-0.1.0.dist-info/RECORD,,

showrun_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

showrun_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+showrun = showrun.cli:app

showrun_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Anand Rao
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.