htmlship 0.1.4__tar.gz → 0.2.0__tar.gz

htmlship-0.2.0/LICENSE

@@ -0,0 +1,29 @@
+MIT License
+
+Copyright (c) 2026 HTMLShip
+
+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.
+
+---
+
+The MIT license above applies to the source code in this repository.
+
+It does NOT cover the "HTMLShip" name or the brand assets in `web/assets/`
+(logo, favicons, and any derived artwork). Those are reserved — see
+`web/assets/LICENSE` for details.

{htmlship-0.1.4 → htmlship-0.2.0}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: htmlship
-Version: 0.1.4
+Version: 0.2.0
 Summary: Host and share HTML pages from LLMs and coding agents in one line.
 Project-URL: Homepage, https://htmlship.com
 Project-URL: Repository, https://github.com/htmlship/htmlship
 Author: HTMLShip
 License: MIT
+License-File: LICENSE
 Keywords: agent,hosting,html,llm,mcp,paste
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -58,6 +59,9 @@ HTMLShip has four surfaces:
 npx htmlship publish report.html
 npx htmlship publish report.html --password "demo-pass"
 
+# Build a frontend project (React/Vite/etc.) and ship the compiled app
+npx htmlship deploy ./my-app
+
 # Python
 pip install htmlship
 ```
@@ -128,7 +132,36 @@ npx htmlship publish report.html --password "demo-pass"
 npx htmlship list-mine
 ```
 
-The CLI stores owner keys in `~/.htmlship/keys.json` so `update`, `delete`, and `list-mine` can work with pages you created locally. Set `HTMLSHIP_KEYS_DIR` to use another key-store directory, and set `HTMLSHIP_API_URL` to point the CLI at a local or staging API.
+The CLI stores owner keys in `~/.htmlship/keys.json` so `update`, `delete`, and `list-mine` can work with pages you created locally. When a page's key isn't saved there and `--owner-key` isn't passed, `update` and `delete` prompt for it interactively — `delete` asks for the key right after the `[y/N]` confirmation — so the public slug alone is never enough to mutate a page. Set `HTMLSHIP_KEYS_DIR` to use another key-store directory, and set `HTMLSHIP_API_URL` to point the CLI at a local or staging API.
+
+## Deploy built apps
+
+`deploy` builds a modern frontend project (React, Vite, Svelte, etc.) and publishes the **compiled** app as a single self-contained page — no separate asset hosting required.
+
+```bash
+htmlship deploy ./my-app            # detect build script, build, inline, publish
+htmlship deploy --dry-run           # build + inline, but don't publish (inspect first)
+htmlship deploy --build-cmd "vite build" --out dist
+npx htmlship deploy ./my-app        # same, no install
+```
+
+How it works:
+
+1. **The build runs locally, on your machine — never on the server.** `deploy` detects your package manager (npm/pnpm/yarn/bun) and runs the `build` script (falling back to `build:prod`, or `--build-cmd` to override). This is what keeps the service from ever executing untrusted build steps.
+2. The build output (`dist/` or `build/`, or `--out`) is **inlined into one HTML file**: scripts and stylesheets are embedded, and referenced images/icons/fonts become data URIs. The result must be ≤ 10 MB.
+3. It's published with `sandbox_mode: "relaxed"` so the app's JavaScript can run (see [Rendering](#rendering)).
+
+The same flow is available programmatically (Python library) and via the `deploy_project` MCP tool:
+
+```python
+import htmlship
+
+# Library: build ./my-app locally and publish the compiled app
+page = htmlship.HTMLShipClient().deploy("./my-app", expires_in=1440)
+print(page.url)
+```
+
+**Relaxed-mode limits (by design):** a deployed app runs in an isolated, opaque origin and **cannot** make network requests (`connect-src 'none'`), read cookies, access other pages, or use `eval`. It's intended for self-contained client-side apps and demos — not for apps that call external APIs at runtime.
 
 ## API
 
@@ -162,12 +195,14 @@ Notes:
 - `html` is stored and served verbatim. Scripts are blocked by the view CSP, not by sanitizing the body.
 - Payloads are limited to 10 MiB by default.
 - `expires_in` is in **minutes** and must be between 1 and 10080 (7 days). Requests above the cap are rejected with `422`.
-- `sandbox_mode` accepts `strict` or `relaxed`; the current view headers use the strict CSP.
+- `sandbox_mode` accepts `strict` (default) or `relaxed`. `strict` blocks all scripts; `relaxed` lets the page's own inline scripts run inside an isolated, opaque origin (used by `deploy` for compiled apps). See [Rendering](#rendering).
 - Password-protected views set a signed, HTTP-only session cookie after the correct password is submitted.
 
+There is no server-side build endpoint, by design: builds always run on the client (see [Deploy built apps](#deploy-built-apps)). The API only ever receives already-inlined HTML, so deploying via the API is simply a `POST /api/v1/pages` with `"sandbox_mode": "relaxed"`.
+
 ## Rendering
 
-Rendered HTML is served from `view.htmlship.com/{slug}` with strict security headers:
+Rendered HTML is served from `view.htmlship.com/{slug}`. **Strict** pages (the default) get a CSP that blocks all scripts:
 
 - `Content-Security-Policy: default-src 'none'`
 - images from `data:` and `https:`
@@ -177,6 +212,8 @@ Rendered HTML is served from `view.htmlship.com/{slug}` with strict security hea
 - `Referrer-Policy: no-referrer`
 - restrictive `Permissions-Policy`
 
+**Relaxed** pages (`sandbox_mode: "relaxed"`, used by `deploy`) let the page's own inline scripts run but isolate them with `Content-Security-Policy: sandbox allow-scripts` — deliberately *without* `allow-same-origin`. That forces an opaque origin, so a deployed app cannot read cookies, touch `localStorage`, or fetch other pages same-origin. `connect-src 'none'` additionally blocks network egress. The body is still served verbatim; isolation is enforced entirely by response headers, with no change to the single-file storage model.
+
 The app routes by `Host` header:
 
 - `htmlship.com` serves the landing page
@@ -191,9 +228,10 @@ curl "http://localhost:8000/<slug>?_host=view.htmlship.com"
 
 ## MCP Server
 
-HTMLShip ships a stdio MCP server with three tools:
+HTMLShip ships a stdio MCP server with four tools:
 
 - `publish_html` (accepts optional `password`)
+- `deploy_project` — build a local frontend project and publish the compiled app (runs the build on the machine hosting the MCP server)
 - `fetch_html`
 - `update_html`
 
@@ -319,3 +357,9 @@ scripts/             Deploy and smoke-test scripts
 ```
 
 The npm package mirrors the Python CLI surface and reads/writes the same `~/.htmlship/keys.json` file format, so users can mix and match. The Node MCP server lives at `htmlship mcp` (subcommand) rather than a separate `htmlship-mcp` bin.
+
+## License
+
+Source code in this repository is licensed under the MIT License — see [`LICENSE`](./LICENSE).
+
+The "HTMLShip" name and the brand assets in `web/assets/` (logo, favicons) are not covered by MIT and are reserved — see [`web/assets/LICENSE`](./web/assets/LICENSE). If you fork to run your own instance, please replace those files with your own branding.

{htmlship-0.1.4 → htmlship-0.2.0}/README.md

@@ -14,6 +14,9 @@ HTMLShip has four surfaces:
 npx htmlship publish report.html
 npx htmlship publish report.html --password "demo-pass"
 
+# Build a frontend project (React/Vite/etc.) and ship the compiled app
+npx htmlship deploy ./my-app
+
 # Python
 pip install htmlship
 ```
@@ -84,7 +87,36 @@ npx htmlship publish report.html --password "demo-pass"
 npx htmlship list-mine
 ```
 
-The CLI stores owner keys in `~/.htmlship/keys.json` so `update`, `delete`, and `list-mine` can work with pages you created locally. Set `HTMLSHIP_KEYS_DIR` to use another key-store directory, and set `HTMLSHIP_API_URL` to point the CLI at a local or staging API.
+The CLI stores owner keys in `~/.htmlship/keys.json` so `update`, `delete`, and `list-mine` can work with pages you created locally. When a page's key isn't saved there and `--owner-key` isn't passed, `update` and `delete` prompt for it interactively — `delete` asks for the key right after the `[y/N]` confirmation — so the public slug alone is never enough to mutate a page. Set `HTMLSHIP_KEYS_DIR` to use another key-store directory, and set `HTMLSHIP_API_URL` to point the CLI at a local or staging API.
+
+## Deploy built apps
+
+`deploy` builds a modern frontend project (React, Vite, Svelte, etc.) and publishes the **compiled** app as a single self-contained page — no separate asset hosting required.
+
+```bash
+htmlship deploy ./my-app            # detect build script, build, inline, publish
+htmlship deploy --dry-run           # build + inline, but don't publish (inspect first)
+htmlship deploy --build-cmd "vite build" --out dist
+npx htmlship deploy ./my-app        # same, no install
+```
+
+How it works:
+
+1. **The build runs locally, on your machine — never on the server.** `deploy` detects your package manager (npm/pnpm/yarn/bun) and runs the `build` script (falling back to `build:prod`, or `--build-cmd` to override). This is what keeps the service from ever executing untrusted build steps.
+2. The build output (`dist/` or `build/`, or `--out`) is **inlined into one HTML file**: scripts and stylesheets are embedded, and referenced images/icons/fonts become data URIs. The result must be ≤ 10 MB.
+3. It's published with `sandbox_mode: "relaxed"` so the app's JavaScript can run (see [Rendering](#rendering)).
+
+The same flow is available programmatically (Python library) and via the `deploy_project` MCP tool:
+
+```python
+import htmlship
+
+# Library: build ./my-app locally and publish the compiled app
+page = htmlship.HTMLShipClient().deploy("./my-app", expires_in=1440)
+print(page.url)
+```
+
+**Relaxed-mode limits (by design):** a deployed app runs in an isolated, opaque origin and **cannot** make network requests (`connect-src 'none'`), read cookies, access other pages, or use `eval`. It's intended for self-contained client-side apps and demos — not for apps that call external APIs at runtime.
 
 ## API
 
@@ -118,12 +150,14 @@ Notes:
 - `html` is stored and served verbatim. Scripts are blocked by the view CSP, not by sanitizing the body.
 - Payloads are limited to 10 MiB by default.
 - `expires_in` is in **minutes** and must be between 1 and 10080 (7 days). Requests above the cap are rejected with `422`.
-- `sandbox_mode` accepts `strict` or `relaxed`; the current view headers use the strict CSP.
+- `sandbox_mode` accepts `strict` (default) or `relaxed`. `strict` blocks all scripts; `relaxed` lets the page's own inline scripts run inside an isolated, opaque origin (used by `deploy` for compiled apps). See [Rendering](#rendering).
 - Password-protected views set a signed, HTTP-only session cookie after the correct password is submitted.
 
+There is no server-side build endpoint, by design: builds always run on the client (see [Deploy built apps](#deploy-built-apps)). The API only ever receives already-inlined HTML, so deploying via the API is simply a `POST /api/v1/pages` with `"sandbox_mode": "relaxed"`.
+
 ## Rendering
 
-Rendered HTML is served from `view.htmlship.com/{slug}` with strict security headers:
+Rendered HTML is served from `view.htmlship.com/{slug}`. **Strict** pages (the default) get a CSP that blocks all scripts:
 
 - `Content-Security-Policy: default-src 'none'`
 - images from `data:` and `https:`
@@ -133,6 +167,8 @@ Rendered HTML is served from `view.htmlship.com/{slug}` with strict security hea
 - `Referrer-Policy: no-referrer`
 - restrictive `Permissions-Policy`
 
+**Relaxed** pages (`sandbox_mode: "relaxed"`, used by `deploy`) let the page's own inline scripts run but isolate them with `Content-Security-Policy: sandbox allow-scripts` — deliberately *without* `allow-same-origin`. That forces an opaque origin, so a deployed app cannot read cookies, touch `localStorage`, or fetch other pages same-origin. `connect-src 'none'` additionally blocks network egress. The body is still served verbatim; isolation is enforced entirely by response headers, with no change to the single-file storage model.
+
 The app routes by `Host` header:
 
 - `htmlship.com` serves the landing page
@@ -147,9 +183,10 @@ curl "http://localhost:8000/<slug>?_host=view.htmlship.com"
 
 ## MCP Server
 
-HTMLShip ships a stdio MCP server with three tools:
+HTMLShip ships a stdio MCP server with four tools:
 
 - `publish_html` (accepts optional `password`)
+- `deploy_project` — build a local frontend project and publish the compiled app (runs the build on the machine hosting the MCP server)
 - `fetch_html`
 - `update_html`
 
@@ -275,3 +312,9 @@ scripts/             Deploy and smoke-test scripts
 ```
 
 The npm package mirrors the Python CLI surface and reads/writes the same `~/.htmlship/keys.json` file format, so users can mix and match. The Node MCP server lives at `htmlship mcp` (subcommand) rather than a separate `htmlship-mcp` bin.
+
+## License
+
+Source code in this repository is licensed under the MIT License — see [`LICENSE`](./LICENSE).
+
+The "HTMLShip" name and the brand assets in `web/assets/` (logo, favicons) are not covered by MIT and are reserved — see [`web/assets/LICENSE`](./web/assets/LICENSE). If you fork to run your own instance, please replace those files with your own branding.

{htmlship-0.1.4 → htmlship-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "htmlship"
-version = "0.1.4"
+version = "0.2.0"
 description = "Host and share HTML pages from LLMs and coding agents in one line."
 readme = "README.md"
 requires-python = ">=3.12"

htmlship-0.2.0/src/htmlship/_version.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

htmlship-0.2.0/src/htmlship/build.py

@@ -0,0 +1,325 @@
+"""Client-side build + single-file inliner for ``htmlship deploy``.
+
+Mirrors the TypeScript implementation in ``npm/src/build.ts``: detect a frontend
+project, run its build *locally* (never on the server), and inline the output
+into one self-contained HTML document suitable for publishing as a relaxed
+(sandboxed-script) page.
+"""
+from __future__ import annotations
+
+import base64
+import json
+import re
+import subprocess
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from pathlib import Path
+from urllib.parse import unquote
+
+from .exceptions import HTMLShipError
+
+# Order matters: the first lockfile found wins.
+_LOCKFILES: list[tuple[str, str]] = [
+    ("pnpm-lock.yaml", "pnpm"),
+    ("yarn.lock", "yarn"),
+    ("bun.lockb", "bun"),
+    ("bun.lock", "bun"),
+    ("package-lock.json", "npm"),
+]
+
+DEFAULT_BUILD_TIMEOUT = 5 * 60
+MAX_PAYLOAD_BYTES = 10 * 1024 * 1024
+
+LogFn = Callable[[str], None]
+
+
+def _noop(_msg: str) -> None:  # pragma: no cover - trivial
+    return None
+
+
+@dataclass
+class Project:
+    dir: Path
+    build_script: str  # empty when build_cmd overrides it
+    package_manager: str
+
+
+def detect_package_manager(directory: Path) -> str:
+    for fname, pm in _LOCKFILES:
+        if (directory / fname).exists():
+            return pm
+    return "npm"
+
+
+def detect_project(directory: Path, build_cmd_override: str | None = None) -> Project:
+    pkg_path = directory / "package.json"
+    if not pkg_path.exists():
+        raise HTMLShipError(f"no package.json found in {directory}")
+    try:
+        pkg = json.loads(pkg_path.read_text(encoding="utf-8"))
+    except Exception as exc:
+        raise HTMLShipError(f"failed to read package.json: {exc}") from exc
+
+    scripts = pkg.get("scripts") or {} if isinstance(pkg, dict) else {}
+    pm = detect_package_manager(directory)
+    if build_cmd_override:
+        return Project(dir=directory, build_script="", package_manager=pm)
+
+    if scripts.get("build"):
+        build_script = "build"
+    elif scripts.get("build:prod"):
+        build_script = "build:prod"
+    else:
+        raise HTMLShipError(
+            'no "build" or "build:prod" script in package.json (use build_cmd to specify one)'
+        )
+    return Project(dir=directory, build_script=build_script, package_manager=pm)
+
+
+def build_command(pm: str, script: str) -> str:
+    # npm/pnpm/bun use `run <script>`; yarn runs the script directly.
+    return f"yarn {script}" if pm == "yarn" else f"{pm} run {script}"
+
+
+def install_command(pm: str) -> str:
+    return f"{pm} install"
+
+
+def run_build(
+    project: Project,
+    *,
+    install: bool = False,
+    build_cmd: str | None = None,
+    timeout: int = DEFAULT_BUILD_TIMEOUT,
+    log: LogFn = _noop,
+) -> None:
+    if install:
+        _exec(install_command(project.package_manager), project.dir, timeout, log)
+    cmd = build_cmd or build_command(project.package_manager, project.build_script)
+    _exec(cmd, project.dir, timeout, log)
+
+
+def _exec(command: str, cwd: Path, timeout: int, log: LogFn) -> None:
+    log(f"$ {command}")
+    # shell=True keeps this cross-platform and lets build_cmd accept a normal
+    # command line. The command is either a fixed package-manager invocation or
+    # the user's own explicit override — never remote/untrusted input — and runs
+    # only on the user's machine, by design.
+    try:
+        result = subprocess.run(command, cwd=str(cwd), shell=True, timeout=timeout, check=False)  # noqa: S602
+    except FileNotFoundError as exc:
+        raise HTMLShipError(f"build failed: `{command}` — command not found") from exc
+    except subprocess.TimeoutExpired as exc:
+        raise HTMLShipError(f"build timed out after {timeout}s: `{command}`") from exc
+    if result.returncode != 0:
+        raise HTMLShipError(f"build exited with code {result.returncode}: `{command}`")
+
+
+def resolve_output_dir(directory: Path, override: str | None = None) -> Path:
+    candidates = [override] if override else ["dist", "build"]
+    for c in candidates:
+        assert c is not None
+        p = Path(c) if Path(c).is_absolute() else directory / c
+        if p.is_dir():
+            return p
+    if override:
+        raise HTMLShipError(f"build output dir not found: {override}")
+    raise HTMLShipError("no build output found (looked for dist/ and build/; use out to specify)")
+
+
+# --- single-file inliner ----------------------------------------------------
+
+_MIME = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".webp": "image/webp",
+    ".avif": "image/avif",
+    ".ico": "image/x-icon",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".ttf": "font/ttf",
+    ".otf": "font/otf",
+    ".css": "text/css",
+    ".js": "text/javascript",
+    ".mjs": "text/javascript",
+    ".json": "application/json",
+}
+
+
+@dataclass
+class InlineResult:
+    html: str
+    bytes: int
+    warnings: list[str] = field(default_factory=list)
+
+
+def _mime_for(p: Path) -> str:
+    return _MIME.get(p.suffix.lower(), "application/octet-stream")
+
+
+def _is_local_ref(ref: str) -> bool:
+    return bool(ref) and (
+        re.match(r"^(https?:)?//", ref, re.I) is None
+        and not ref.startswith(("data:", "#", "mailto:", "blob:"))
+    )
+
+
+def _attr(tag: str, name: str) -> str | None:
+    m = re.search(rf"\b{name}\s*=\s*(\"([^\"]*)\"|'([^']*)'|([^\s>]+))", tag, re.I)
+    if not m:
+        return None
+    return m.group(2) or m.group(3) or m.group(4)
+
+
+def _resolve_local(root: Path, base_dir: Path, ref: str) -> Path | None:
+    clean = ref.split("#")[0].split("?")[0]
+    if not clean:
+        return None
+    base = base_dir
+    if clean.startswith("/"):
+        base = root
+        clean = clean.lstrip("/")
+    try:
+        abs_ = (base / unquote(clean)).resolve()
+    except Exception:
+        return None
+    root_resolved = root.resolve()
+    if abs_ == root_resolved:
+        return None
+    try:
+        abs_.relative_to(root_resolved)
+    except ValueError:
+        return None  # escapes the output root — path-traversal guard
+    if not abs_.is_file():
+        return None
+    return abs_
+
+
+def _data_uri(file: Path) -> str:
+    encoded = base64.b64encode(file.read_bytes()).decode("ascii")
+    return f"data:{_mime_for(file)};base64,{encoded}"
+
+
+def _inline_css_urls(root: Path, css_dir: Path, css: str, warnings: list[str]) -> str:
+    def repl(m: re.Match[str]) -> str:
+        ref = m.group(2)
+        if not _is_local_ref(ref):
+            return m.group(0)
+        file = _resolve_local(root, css_dir, ref)
+        if not file:
+            warnings.append(f"unresolved css asset: {ref}")
+            return m.group(0)
+        return f"url({_data_uri(file)})"
+
+    return re.sub(r"url\(\s*(['\"]?)([^'\")]+)\1\s*\)", repl, css, flags=re.I)
+
+
+def inline_html(root: Path, html_file: Path) -> InlineResult:
+    """Inline an entry HTML file and its local assets into one document.
+
+    Scripts and stylesheets are inlined, referenced images/icons/fonts become
+    data URIs, and now-redundant preload links are dropped. External (http/https)
+    references are left untouched; unresolvable local references are left in place
+    and reported as warnings rather than failing the build.
+    """
+    if not html_file.exists():
+        raise HTMLShipError(f"entry HTML not found: {html_file}")
+    html_dir = html_file.parent
+    warnings: list[str] = []
+    html = html_file.read_text(encoding="utf-8")
+
+    def local_file(ref: str) -> Path | None:
+        if not _is_local_ref(ref):
+            return None
+        f = _resolve_local(root, html_dir, ref)
+        if not f:
+            warnings.append(f"unresolved asset: {ref}")
+            return None
+        return f
+
+    def link_repl(m: re.Match[str]) -> str:
+        tag = m.group(0)
+        rel = (_attr(tag, "rel") or "").lower()
+        href = _attr(tag, "href")
+        if not href:
+            return tag
+        if rel == "stylesheet":
+            f = local_file(href)
+            if not f:
+                return tag
+            css = _inline_css_urls(root, f.parent, f.read_text(encoding="utf-8"), warnings)
+            return f"<style>{css}</style>"
+        if rel in ("modulepreload", "preload", "prefetch"):
+            return "" if _is_local_ref(href) else tag
+        if rel in ("icon", "shortcut icon", "apple-touch-icon"):
+            f = local_file(href)
+            return tag.replace(href, _data_uri(f)) if f else tag
+        return tag
+
+    html = re.sub(r"<link\b[^>]*>", link_repl, html, flags=re.I)
+
+    def script_repl(m: re.Match[str]) -> str:
+        tag = m.group(0)
+        attrs = m.group(1)
+        src = _attr(tag, "src")
+        if not src:
+            return tag
+        f = local_file(src)
+        if not f:
+            return tag
+        js = re.sub(r"</script", lambda _m: "<\\/script", f.read_text(encoding="utf-8"), flags=re.I)
+        type_attr = ' type="module"' if re.search(r'\btype\s*=\s*["\']module["\']', attrs, re.I) else ""
+        return f"<script{type_attr}>{js}</script>"
+
+    html = re.sub(r"<script\b([^>]*)>\s*</script>", script_repl, html, flags=re.I)
+
+    def img_repl(m: re.Match[str]) -> str:
+        tag = m.group(0)
+        src = _attr(tag, "src")
+        if not src or not _is_local_ref(src):
+            return tag
+        f = local_file(src)
+        return tag.replace(src, _data_uri(f)) if f else tag
+
+    html = re.sub(r"<img\b[^>]*>", img_repl, html, flags=re.I)
+
+    return InlineResult(html=html, bytes=len(html.encode("utf-8")), warnings=warnings)
+
+
+def format_bytes(n: int) -> str:
+    if n < 1024:
+        return f"{n} B"
+    if n < 1024 * 1024:
+        return f"{n / 1024:.1f} KB"
+    return f"{n / (1024 * 1024):.2f} MB"
+
+
+def build_and_inline(
+    directory: Path,
+    *,
+    build_cmd: str | None = None,
+    out: str | None = None,
+    entry: str | None = None,
+    install: bool = False,
+    timeout: int = DEFAULT_BUILD_TIMEOUT,
+    log: LogFn = _noop,
+) -> InlineResult:
+    """Detect, build locally, and inline a project into one self-contained document."""
+    project = detect_project(directory, build_cmd)
+    log(f"project:   {directory}")
+    log(f"pkg mgr:   {project.package_manager}")
+    log(f"build:     {build_cmd or build_command(project.package_manager, project.build_script)}")
+
+    run_build(project, install=install, build_cmd=build_cmd, timeout=timeout, log=log)
+
+    out_dir = resolve_output_dir(directory, out)
+    entry_file = out_dir / (entry or "index.html")
+    result = inline_html(out_dir, entry_file)
+    log(f"output:    {out_dir}")
+    log(f"inlined:   {format_bytes(result.bytes)} single HTML")
+    for w in result.warnings:
+        log(f"warning:   {w}")
+    return result

{htmlship-0.1.4 → htmlship-0.2.0}/src/htmlship/cli.py

@@ -60,6 +60,14 @@ def _lookup_owner_key(slug: str) -> str | None:
     return _load_keys().get(slug, {}).get("owner_key")
 
 
+def _prompt_owner_key(slug: str) -> str:
+    """Ask for the owner key when it isn't saved locally or passed via --owner-key."""
+    key = click.prompt(f"owner_key for '{slug}'").strip()
+    if not key:
+        raise click.ClickException("owner_key is required")
+    return key
+
+
 # --- helpers ------------------------------------------------------------------
 
 
@@ -168,6 +176,107 @@ def publish(
         click.echo("(URL copied to clipboard)", err=True)
 
 
+@main.command()
+@click.argument("dir", required=False, default=".")
+@click.option("--build-cmd", default=None, help="Override the build command (default: detected from package.json).")
+@click.option("--out", default=None, help="Build output dir (default: auto-detect dist/ or build/).")
+@click.option("--entry", default=None, help="Entry HTML within the output dir (default: index.html).")
+@click.option("--install", is_flag=True, help="Run dependency install before building.")
+@click.option("--dry-run", is_flag=True, help="Build and inline, but report a summary instead of publishing.")
+@click.option("--title", default=None, help="Optional title.")
+@click.option("--password", default=None, help="Password-protect the page.")
+@click.option(
+    "--expires-in",
+    type=int,
+    default=None,
+    help="Minutes until expiry (1–10080, i.e. up to 7 days).",
+)
+@click.option("--no-clipboard", is_flag=True, help="Don't copy URL to clipboard.")
+@click.option("--quiet", "-q", is_flag=True, help="Print only the URL.")
+@click.pass_context
+def deploy(
+    ctx: click.Context,
+    dir: str,
+    build_cmd: str | None,
+    out: str | None,
+    entry: str | None,
+    install: bool,
+    dry_run: bool,
+    title: str | None,
+    password: str | None,
+    expires_in: int | None,
+    no_clipboard: bool,
+    quiet: bool,
+) -> None:
+    """Build a frontend project and publish the compiled app as one self-contained page.
+
+    Runs the project's build script locally, inlines the output into a single
+    HTML file, and publishes it with relaxed sandboxing so its JavaScript runs
+    in an isolated origin.
+
+    Examples:
+
+      htmlship deploy ./my-app
+      htmlship deploy --build-cmd "vite build" --out dist
+    """
+    from pathlib import Path
+
+    from .build import MAX_PAYLOAD_BYTES, build_and_inline, format_bytes
+
+    project_dir = Path(dir).resolve()
+    log = (lambda _m: None) if quiet else (lambda m: click.echo(m, err=True))
+
+    try:
+        result = build_and_inline(
+            project_dir,
+            build_cmd=build_cmd,
+            out=out,
+            entry=entry,
+            install=install,
+            log=log,
+        )
+    except HTMLShipError as exc:
+        raise click.ClickException(str(exc)) from exc
+
+    if result.bytes > MAX_PAYLOAD_BYTES:
+        raise click.ClickException(
+            f"inlined page is {format_bytes(result.bytes)}, exceeds the 10 MB limit"
+        )
+
+    if dry_run:
+        log("dry-run:   built and inlined OK; not published")
+        return
+
+    client = _make_client(ctx.obj["api_url"])
+    try:
+        page = client.publish(
+            result.html,
+            title=title,
+            password=password,
+            expires_in=expires_in,
+            sandbox_mode="relaxed",
+        )
+    except HTMLShipError as exc:
+        raise click.ClickException(str(exc)) from exc
+    finally:
+        client.close()
+
+    _remember(page.slug, page.owner_key or "", page.url, title)
+
+    if quiet:
+        click.echo(page.url)
+        return
+
+    click.echo(page.url)
+    click.echo(f"slug:      {page.slug}", err=True)
+    click.echo(f"owner_key: {page.owner_key}  (saved to {KEYS_FILE})", err=True)
+    click.echo("sandbox:   relaxed (scripts run in an isolated origin)", err=True)
+    if page.expires_at:
+        click.echo(f"expires:   {page.expires_at.isoformat()}", err=True)
+    if not no_clipboard and _try_clipboard(page.url):
+        click.echo("(URL copied to clipboard)", err=True)
+
+
 @main.command()
 @click.argument("slug")
 @click.pass_context
@@ -205,7 +314,7 @@ def get(ctx: click.Context, slug: str) -> None:
 @click.argument("source", required=False)
 @click.option("--file", "-f", "file_", type=click.Path(exists=True, dir_okay=False))
 @click.option("--title", default=None, help="Optional new title.")
-@click.option("--owner-key", default=None, help="Owner key (defaults to local store).")
+@click.option("--owner-key", default=None, help="Owner key (defaults to local store, else prompted).")
 @click.pass_context
 def update(
     ctx: click.Context,
@@ -217,11 +326,7 @@ def update(
 ) -> None:
     """Replace HTML for an existing page."""
     html = _read_html(source, file_)
-    key = owner_key or _lookup_owner_key(slug)
-    if not key:
-        raise click.ClickException(
-            f"no owner key for '{slug}' in {KEYS_FILE}; pass --owner-key explicitly"
-        )
+    key = owner_key or _lookup_owner_key(slug) or _prompt_owner_key(slug)
     client = _make_client(ctx.obj["api_url"])
     try:
         page = client.update(slug, html, owner_key=key, title=title)
@@ -235,18 +340,16 @@ def update(
 
 @main.command()
 @click.argument("slug")
-@click.option("--owner-key", default=None, help="Owner key (defaults to local store).")
+@click.option("--owner-key", default=None, help="Owner key (defaults to local store, else prompted).")
 @click.option("--yes", "-y", is_flag=True, help="Skip confirmation.")
 @click.pass_context
 def delete(ctx: click.Context, slug: str, owner_key: str | None, yes: bool) -> None:
     """Soft-delete a page."""
     key = owner_key or _lookup_owner_key(slug)
-    if not key:
-        raise click.ClickException(
-            f"no owner key for '{slug}' in {KEYS_FILE}; pass --owner-key explicitly"
-        )
     if not yes:
         click.confirm(f"Delete page '{slug}'?", abort=True)
+    if not key:
+        key = _prompt_owner_key(slug)
     client = _make_client(ctx.obj["api_url"])
     try:
         client.delete(slug, owner_key=key)

{htmlship-0.1.4 → htmlship-0.2.0}/src/htmlship/client.py

@@ -90,6 +90,48 @@ class HTMLShipClient:
             _client=self,
         )
 
+    def deploy(
+        self,
+        project_dir: str | Any,
+        *,
+        build_cmd: str | None = None,
+        out: str | None = None,
+        entry: str | None = None,
+        install: bool = False,
+        title: str | None = None,
+        password: str | None = None,
+        expires_in: int | None = None,
+    ) -> Page:
+        """Build a local frontend project and publish it as one self-contained page.
+
+        Detects the project, runs its build *locally* (never on the server),
+        inlines the output into a single HTML document, and publishes it as a
+        relaxed (sandboxed-script) page so its JavaScript runs in an isolated
+        origin. Returns a Page with owner_key set.
+        """
+        from pathlib import Path
+
+        from .build import MAX_PAYLOAD_BYTES, build_and_inline
+
+        result = build_and_inline(
+            Path(project_dir),
+            build_cmd=build_cmd,
+            out=out,
+            entry=entry,
+            install=install,
+        )
+        if result.bytes > MAX_PAYLOAD_BYTES:
+            raise HTMLShipError(
+                f"inlined page is {result.bytes} bytes, exceeds the 10 MB limit"
+            )
+        return self.publish(
+            result.html,
+            title=title,
+            password=password,
+            expires_in=expires_in,
+            sandbox_mode="relaxed",
+        )
+
     def get(self, slug: str) -> Page:
         """Fetch metadata for a page. owner_key is None on the returned object."""
         r = self._http.get(f"/api/v1/pages/{slug}")

htmlship-0.2.0/src/htmlship_mcp/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

{htmlship-0.1.4 → htmlship-0.2.0}/src/htmlship_mcp/server.py

@@ -1,8 +1,9 @@
 """HTMLShip MCP server.
 
-Exposes three tools — publish_html, fetch_html, update_html — that wrap the
-public Python library. All HTTP traffic goes through the library and the
-real API; this server adds no business logic of its own.
+Exposes four tools — publish_html, deploy_project, fetch_html, update_html —
+that wrap the public Python library. All HTTP traffic goes through the library
+and the real API; this server adds no business logic of its own. ``deploy_project``
+additionally runs a project's build script locally before publishing.
 
 Configure the API endpoint via the HTMLSHIP_API_URL environment variable.
 """
@@ -65,6 +66,58 @@ def publish_html(
     }
 
 
+@mcp.tool()
+def deploy_project(
+    dir: str,
+    build_cmd: str | None = None,
+    out: str | None = None,
+    install: bool = False,
+    title: str | None = None,
+    password: str | None = None,
+    expires_in: int | None = None,
+) -> dict[str, Any]:
+    """Build a local frontend project and publish the compiled app as one page.
+
+    Runs the project's build script ON THIS MACHINE (npm/pnpm/yarn/bun,
+    auto-detected), inlines the output (dist/ or build/) into a single HTML
+    file, and publishes it with relaxed sandboxing so its JavaScript runs in an
+    isolated origin (no cookies, no same-origin fetch, no network egress).
+
+    Args:
+        dir: Path to the project directory (must contain package.json).
+        build_cmd: Override the build command (default: detected build/build:prod script).
+        out: Build output directory (default: auto-detect dist/ or build/).
+        install: Run dependency install before building.
+        title: Optional human-readable title.
+        password: Optional password required before viewing the page.
+        expires_in: Optional TTL in minutes (1–10080, i.e. up to 7 days).
+
+    Returns:
+        A dict with keys: url, slug, owner_key, expires_at.
+        IMPORTANT: owner_key is the only credential to update or delete the
+        page later. Save it.
+    """
+    with _client() as c:
+        try:
+            page = c.deploy(
+                dir,
+                build_cmd=build_cmd,
+                out=out,
+                install=install,
+                title=title,
+                password=password,
+                expires_in=expires_in,
+            )
+        except HTMLShipError as exc:
+            raise RuntimeError(f"htmlship deploy failed: {exc}") from exc
+    return {
+        "url": page.url,
+        "slug": page.slug,
+        "owner_key": page.owner_key,
+        "expires_at": page.expires_at.isoformat() if page.expires_at else None,
+    }
+
+
 @mcp.tool()
 def fetch_html(slug: str) -> dict[str, Any]:
     """Fetch a page's metadata.

htmlship-0.2.0/src/htmlship_server/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

{htmlship-0.1.4 → htmlship-0.2.0}/src/htmlship_server/main.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from contextlib import asynccontextmanager
 from pathlib import Path
 
-from fastapi import FastAPI
+from fastapi import FastAPI, Request
 from fastapi.responses import FileResponse, HTMLResponse, Response
 from starlette.staticfiles import StaticFiles
 
@@ -53,11 +53,30 @@ def create_app() -> FastAPI:
         async def landing_js() -> Response:
             return FileResponse(web_dir / "demo.js", media_type="application/javascript")
 
+        @app.get("/favicon.ico", include_in_schema=False)
+        async def landing_favicon() -> Response:
+            return FileResponse(web_dir / "assets" / "favicon.ico", media_type="image/x-icon")
+
         @app.get("/llms.txt", include_in_schema=False)
         @app.get("/llm.txt", include_in_schema=False)
         async def landing_llms() -> Response:
             return FileResponse(web_dir / "llms.txt", media_type="text/plain")
 
+        @app.get("/robots.txt", include_in_schema=False)
+        async def robots(request: Request) -> Response:
+            # User-generated pages live on the view subdomain and shouldn't be
+            # indexed (they expire and can be deleted); serve a disallow-all there
+            # and the welcoming policy on the landing/api hosts.
+            if request.scope.get("htmlship_host_kind") == "view":
+                return Response("User-agent: *\nDisallow: /\n", media_type="text/plain")
+            return FileResponse(web_dir / "robots.txt", media_type="text/plain")
+
+        @app.get("/sitemap.xml", include_in_schema=False)
+        async def sitemap() -> Response:
+            # Public marketing site only; the view host 404s this (handled by the
+            # host-routing middleware), keeping ephemeral pages out of sitemaps.
+            return FileResponse(web_dir / "sitemap.xml", media_type="application/xml")
+
     # The view router last so that /{slug} doesn't shadow the landing routes above.
     app.include_router(view.router)
 

{htmlship-0.1.4 → htmlship-0.2.0}/src/htmlship_server/middleware.py

@@ -11,7 +11,10 @@ API_HOST_PREFIX = "api."
 SLUG_CHARS = frozenset("0123456789abcdefghijklmnopqrstuvwxyz")
 
 # Paths always allowed on every host kind.
-ALWAYS_ALLOWED_PATHS = frozenset({"/health", "/version", "/api/openapi.json", "/api/docs"})
+# /robots.txt is served on every host (the view host returns a disallow-all body).
+ALWAYS_ALLOWED_PATHS = frozenset(
+    {"/health", "/version", "/api/openapi.json", "/api/docs", "/robots.txt"}
+)
 
 # Path prefixes allowed on every host kind (e.g., FastAPI internals).
 ALWAYS_ALLOWED_PREFIXES = ("/docs/", "/api/openapi", "/api/docs")

{htmlship-0.1.4 → htmlship-0.2.0}/src/htmlship_server/routers/view.py

@@ -25,15 +25,47 @@ STRICT_CSP = (
     "frame-ancestors *"
 )
 
-SECURITY_HEADERS = {
-    "Content-Security-Policy": STRICT_CSP,
-    "X-Content-Type-Options": "nosniff",
-    "Referrer-Policy": "no-referrer",
-    "Permissions-Policy": (
-        "accelerometer=(), camera=(), geolocation=(), microphone=(), payment=()"
-    ),
-    "Cache-Control": "public, max-age=3600",
-}
+# Relaxed mode: for self-contained built apps (e.g. a compiled React bundle
+# inlined into one HTML file) the page's own inline scripts must run.
+#
+# `sandbox allow-scripts` (deliberately WITHOUT allow-same-origin) forces the
+# document into an opaque origin: scripts run, but they cannot read cookies or
+# localStorage, and cannot make same-origin requests to other slugs — which is
+# what otherwise defeats password protection on neighbouring pages. Achieving
+# this with a header (rather than an iframe wrapper or a separate raw endpoint)
+# keeps the body served verbatim and avoids a directly-reachable bypass URL.
+#
+# `connect-src 'none'` blocks network exfiltration as defense-in-depth; only
+# the page's own inline script/style and https/data assets are permitted.
+RELAXED_CSP = (
+    "sandbox allow-scripts; "
+    "default-src 'none'; "
+    "script-src 'unsafe-inline'; "
+    "style-src 'unsafe-inline' https:; "
+    "img-src data: https:; "
+    "font-src https: data:; "
+    "media-src https:; "
+    "connect-src 'none'; "
+    "form-action 'none'; "
+    "base-uri 'none'; "
+    "frame-ancestors *"
+)
+
+
+def _security_headers(csp: str) -> dict[str, str]:
+    return {
+        "Content-Security-Policy": csp,
+        "X-Content-Type-Options": "nosniff",
+        "Referrer-Policy": "no-referrer",
+        "Permissions-Policy": (
+            "accelerometer=(), camera=(), geolocation=(), microphone=(), payment=()"
+        ),
+        "Cache-Control": "public, max-age=3600",
+    }
+
+
+SECURITY_HEADERS = _security_headers(STRICT_CSP)
+RELAXED_SECURITY_HEADERS = _security_headers(RELAXED_CSP)
 
 
 PASSWORD_FORM_TEMPLATE = """<!doctype html>
@@ -123,7 +155,12 @@ async def _load_active_view(session: AsyncSession, slug: str) -> Page:
 async def _serve_html(page: Page) -> HTMLResponse:
     store = get_blob_store()
     data = await store.get(page.blob_key)
-    return HTMLResponse(data, headers=SECURITY_HEADERS)
+    headers = (
+        RELAXED_SECURITY_HEADERS
+        if page.sandbox_mode == "relaxed"
+        else SECURITY_HEADERS
+    )
+    return HTMLResponse(data, headers=headers)
 
 
 async def _bump_view_count(session: AsyncSession, page_id) -> None:

htmlship-0.1.4/src/htmlship/_version.py

@@ -1 +0,0 @@
-__version__ = "0.1.4"

htmlship-0.1.4/src/htmlship_mcp/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.1.4"

htmlship-0.1.4/src/htmlship_server/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.1.4"