liveface-mcp 0.1.0__tar.gz

liveface_mcp-0.1.0/.gitignore

@@ -0,0 +1,4 @@
+.venv/
+liveface_mcp/web/*.js
+*.egg-info/
+e2e/out/

liveface_mcp-0.1.0/LICENSE

@@ -0,0 +1,30 @@
+Liveface MCP Server Licence
+
+Copyright (c) 2026 Liveface (https://liveface.io). All rights reserved.
+
+This package, liveface-mcp, including its code, pages and documentation
+(the "Software"), is licensed, not sold.
+
+1. Use. You may install the Software and run it, unmodified, with AI agent
+   applications to use avatars from a Liveface account, for as long as your
+   use of Liveface follows Liveface's terms of service.
+
+2. Distribution. You may not copy, publish, sell, sublicense or distribute
+   the Software or a modified copy of it, on its own or as part of another
+   library, tool or service; point others to its published package instead.
+
+3. Restrictions. You may not modify the Software, use it or any part of it
+   with a service other than Liveface, or remove this notice from it.
+
+4. Ownership. Liveface keeps all rights in the Software not expressly
+   granted here.
+
+5. Termination. This licence ends automatically if you break its terms or
+   your Liveface account is closed; then you must stop using the Software.
+
+6. No warranty. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+   KIND, EXPRESS OR IMPLIED, INCLUDING THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+   LIVEFACE 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 OF OR OTHER DEALINGS IN IT.

liveface_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.5
+Name: liveface-mcp
+Version: 0.1.0
+Summary: Speak as a Liveface avatar from Claude Code, Claude Desktop or Codex
+Project-URL: Homepage, https://liveface.io
+Author: Liveface
+License: Liveface MCP Server Licence
+        
+        Copyright (c) 2026 Liveface (https://liveface.io). All rights reserved.
+        
+        This package, liveface-mcp, including its code, pages and documentation
+        (the "Software"), is licensed, not sold.
+        
+        1. Use. You may install the Software and run it, unmodified, with AI agent
+           applications to use avatars from a Liveface account, for as long as your
+           use of Liveface follows Liveface's terms of service.
+        
+        2. Distribution. You may not copy, publish, sell, sublicense or distribute
+           the Software or a modified copy of it, on its own or as part of another
+           library, tool or service; point others to its published package instead.
+        
+        3. Restrictions. You may not modify the Software, use it or any part of it
+           with a service other than Liveface, or remove this notice from it.
+        
+        4. Ownership. Liveface keeps all rights in the Software not expressly
+           granted here.
+        
+        5. Termination. This licence ends automatically if you break its terms or
+           your Liveface account is closed; then you must stop using the Software.
+        
+        6. No warranty. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+           KIND, EXPRESS OR IMPLIED, INCLUDING THE WARRANTIES OF MERCHANTABILITY,
+           FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+           LIVEFACE 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 OF OR OTHER DEALINGS IN IT.
+License-File: LICENSE
+Keywords: avatar,claude,codex,liveface,mcp,talking-avatar
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Video
+Requires-Python: >=3.10
+Requires-Dist: mcp<3,>=2
+Description-Content-Type: text/markdown
+
+# liveface-mcp: Liveface for AI agents
+
+An MCP server for Claude Code, Claude Desktop and Codex. Inside the chat, the
+**studio** lets you choose an avatar and a voice, write a line and get a video
+of the avatar saying it, or make a new avatar from a photo, once you have
+connected your [Liveface](https://liveface.io) account. Without an account,
+shared avatars still speak in a browser window.
+
+## Install
+
+With [uv](https://docs.astral.sh/uv/) nothing needs installing first. In
+Claude Code:
+
+```sh
+claude mcp add liveface -- uvx liveface-mcp
+```
+
+or in the MCP config of Claude Desktop or Codex:
+
+```json
+{
+  "mcpServers": {
+    "liveface": {
+      "command": "uvx",
+      "args": ["liveface-mcp"],
+      "env": { "LIVEFACE_CLIENT_NAME": "Claude Desktop" }
+    }
+  }
+}
+```
+
+Or install it with `pipx install liveface-mcp` (or `pip install liveface-mcp`)
+and use the `liveface-mcp` command. Python 3.10 or later.
+
+## Connecting your account
+
+Ask for the studio and press **Connect your account** (or, in a terminal,
+ask the agent to `connect_account`). A page of the dashboard opens with a code;
+sign in as usual, check the code is the one the app shows, and press
+**Approve**. That is the device sign-in of `docs/connected-apps.md`: the app
+never sees your password, gets a session limited to avatars, their creation
+and speech (never members, keys, deleting, or settings), keeps it in
+`~/.liveface/mcp-credentials.json` (readable by you only), and is cut off at
+once when you disconnect it in the dashboard's Settings, under Connected apps.
+
+## Configuration
+
+| Variable | Meaning |
+|---|---|
+| `LIVEFACE_BASE` | The site. Default `https://liveface.io`. |
+| `LIVEFACE_CLIENT_NAME` | How this app names itself when asking to connect. |
+| `LIVEFACE_CREDENTIALS` | Where the session is kept. Default `~/.liveface/mcp-credentials.json`. |
+| `LIVEFACE_AVATARS` | Shared avatars, no account needed: `name=token` pairs (a share link's token). |
+
+## The studio (an MCP app)
+
+`avatar_studio()` returns a page the host draws inside the chat
+(`ui://liveface/studio.html`, `text/html;profile=mcp-app`):
+
+- **Library.** Your avatars as cards (and the shared ones), a voice (every
+  server voice, grouped by provider), the line (`[happy]`, `[sad]`... tags
+  change the face), **Create video**: the page runs the avatar engine, has the
+  avatar say it and records picture and voice into an MP4 (WebM where the
+  browser writes nothing else) to play or download. A browser voice cannot be
+  recorded, so an avatar on one is said in a server voice, and the page says
+  which.
+- **New avatar.** A person (woman, man) or an animal, the photo, the style
+  (the dashboard's own pictures), the pose, the image service, the voice
+  (one that suits the person), a name, and the agreements in the dashboard's
+  own words. The wizard's steps run on this server (`creation.py`), with
+  progress; the new avatar is then chosen in the library. When its face's
+  points cannot be found (the dashboard has the person place them by hand),
+  the picture is made once more, then **Finish in the dashboard** opens the
+  wizard where the avatar is waiting.
+- The page holds no account token: it asks this server through the host, and
+  the server calls the site. Its CSP lets it reach the site only.
+- It needs a host that draws MCP apps. Elsewhere the tools still answer in
+  text, and `speak` opens its browser window.
+
+## Tools
+
+The model's: `avatar_studio`, `connect_account`, `account_status`,
+`disconnect_account`, `list_avatars`, `speak(text, avatar)`, `stop`.
+The page's own (hidden from the model): `studio_*`.
+
+## Licence
+
+Proprietary: free to use with your own Liveface account. See the `LICENSE`
+file in the package.

liveface_mcp-0.1.0/PYPI.md

@@ -0,0 +1,89 @@
+# liveface-mcp: Liveface for AI agents
+
+An MCP server for Claude Code, Claude Desktop and Codex. Inside the chat, the
+**studio** lets you choose an avatar and a voice, write a line and get a video
+of the avatar saying it, or make a new avatar from a photo, once you have
+connected your [Liveface](https://liveface.io) account. Without an account,
+shared avatars still speak in a browser window.
+
+## Install
+
+With [uv](https://docs.astral.sh/uv/) nothing needs installing first. In
+Claude Code:
+
+```sh
+claude mcp add liveface -- uvx liveface-mcp
+```
+
+or in the MCP config of Claude Desktop or Codex:
+
+```json
+{
+  "mcpServers": {
+    "liveface": {
+      "command": "uvx",
+      "args": ["liveface-mcp"],
+      "env": { "LIVEFACE_CLIENT_NAME": "Claude Desktop" }
+    }
+  }
+}
+```
+
+Or install it with `pipx install liveface-mcp` (or `pip install liveface-mcp`)
+and use the `liveface-mcp` command. Python 3.10 or later.
+
+## Connecting your account
+
+Ask for the studio and press **Connect your account** (or, in a terminal,
+ask the agent to `connect_account`). A page of the dashboard opens with a code;
+sign in as usual, check the code is the one the app shows, and press
+**Approve**. That is the device sign-in of `docs/connected-apps.md`: the app
+never sees your password, gets a session limited to avatars, their creation
+and speech (never members, keys, deleting, or settings), keeps it in
+`~/.liveface/mcp-credentials.json` (readable by you only), and is cut off at
+once when you disconnect it in the dashboard's Settings, under Connected apps.
+
+## Configuration
+
+| Variable | Meaning |
+|---|---|
+| `LIVEFACE_BASE` | The site. Default `https://liveface.io`. |
+| `LIVEFACE_CLIENT_NAME` | How this app names itself when asking to connect. |
+| `LIVEFACE_CREDENTIALS` | Where the session is kept. Default `~/.liveface/mcp-credentials.json`. |
+| `LIVEFACE_AVATARS` | Shared avatars, no account needed: `name=token` pairs (a share link's token). |
+
+## The studio (an MCP app)
+
+`avatar_studio()` returns a page the host draws inside the chat
+(`ui://liveface/studio.html`, `text/html;profile=mcp-app`):
+
+- **Library.** Your avatars as cards (and the shared ones), a voice (every
+  server voice, grouped by provider), the line (`[happy]`, `[sad]`... tags
+  change the face), **Create video**: the page runs the avatar engine, has the
+  avatar say it and records picture and voice into an MP4 (WebM where the
+  browser writes nothing else) to play or download. A browser voice cannot be
+  recorded, so an avatar on one is said in a server voice, and the page says
+  which.
+- **New avatar.** A person (woman, man) or an animal, the photo, the style
+  (the dashboard's own pictures), the pose, the image service, the voice
+  (one that suits the person), a name, and the agreements in the dashboard's
+  own words. The wizard's steps run on this server (`creation.py`), with
+  progress; the new avatar is then chosen in the library. When its face's
+  points cannot be found (the dashboard has the person place them by hand),
+  the picture is made once more, then **Finish in the dashboard** opens the
+  wizard where the avatar is waiting.
+- The page holds no account token: it asks this server through the host, and
+  the server calls the site. Its CSP lets it reach the site only.
+- It needs a host that draws MCP apps. Elsewhere the tools still answer in
+  text, and `speak` opens its browser window.
+
+## Tools
+
+The model's: `avatar_studio`, `connect_account`, `account_status`,
+`disconnect_account`, `list_avatars`, `speak(text, avatar)`, `stop`.
+The page's own (hidden from the model): `studio_*`.
+
+## Licence
+
+Proprietary: free to use with your own Liveface account. See the `LICENSE`
+file in the package.

liveface_mcp-0.1.0/README.md

@@ -0,0 +1,114 @@
+# Liveface for AI agents
+
+An MCP server for Claude Code, Claude Desktop and Codex. Inside the chat, the
+**studio** lets you choose an avatar and a voice, write a line and get a video
+of the avatar saying it, or make a new avatar from a photo, once you have
+connected your Liveface account. Without an account, shared avatars still
+speak in a browser window.
+
+## Install
+
+From PyPI, for anyone: see [PYPI.md](PYPI.md) (`uvx liveface-mcp`), the page
+PyPI shows. From this repository, to work on it:
+
+## Setup
+
+```sh
+npm ci --prefix ../embed && npm ci --prefix ../frontend   # the build imports both
+./build.sh                                                 # type-checks and bundles the two pages
+uv venv .venv && VIRTUAL_ENV=.venv uv pip install -e .
+```
+
+Register it. In Claude Code:
+
+```sh
+claude mcp add liveface -- /abs/path/to/mcp/.venv/bin/liveface-mcp
+```
+
+or in the MCP config of Claude Desktop or Codex:
+
+```json
+{
+  "mcpServers": {
+    "liveface": {
+      "command": "/abs/path/to/mcp/.venv/bin/liveface-mcp",
+      "env": { "LIVEFACE_CLIENT_NAME": "Claude Desktop" }
+    }
+  }
+}
+```
+
+## Connecting your account
+
+Ask for the studio and press **Connect your account** (or, in a terminal,
+ask the agent to `connect_account`). A page of the dashboard opens with a code;
+sign in as usual, check the code is the one the app shows, and press
+**Approve**. That is the device sign-in of `docs/connected-apps.md`: the app
+never sees your password, gets a session limited to avatars, their creation
+and speech (never members, keys, deleting, or settings), keeps it in
+`~/.liveface/mcp-credentials.json` (readable by you only), and is cut off at
+once when you disconnect it in the dashboard's Settings, under Connected apps.
+
+## Configuration
+
+| Variable | Meaning |
+|---|---|
+| `LIVEFACE_BASE` | The site. Default `https://liveface.io`. |
+| `LIVEFACE_CLIENT_NAME` | How this app names itself when asking to connect. |
+| `LIVEFACE_CREDENTIALS` | Where the session is kept. Default `~/.liveface/mcp-credentials.json`. |
+| `LIVEFACE_AVATARS` | Shared avatars, no account needed: `name=token` pairs (a share link's token). |
+
+## The studio (an MCP app)
+
+`avatar_studio()` returns a page the host draws inside the chat
+(`ui://liveface/studio.html`, `text/html;profile=mcp-app`):
+
+- **Library.** Your avatars as cards (and the shared ones), a voice (every
+  server voice, grouped by provider), the line (`[happy]`, `[sad]`... tags
+  change the face), **Create video**: the page runs the avatar engine, has the
+  avatar say it and records picture and voice into an MP4 (WebM where the
+  browser writes nothing else) to play or download. A browser voice cannot be
+  recorded, so an avatar on one is said in a server voice, and the page says
+  which.
+- **New avatar.** A person (woman, man) or an animal, the photo, the style
+  (the dashboard's own pictures), the pose, the image service, the voice
+  (one that suits the person), a name, and the agreements in the dashboard's
+  own words. The wizard's steps run on this server (`creation.py`), with
+  progress; the new avatar is then chosen in the library. When its face's
+  points cannot be found (the dashboard has the person place them by hand),
+  the picture is made once more, then **Finish in the dashboard** opens the
+  wizard where the avatar is waiting.
+- The page holds no account token: it asks this server through the host, and
+  the server calls the site. Its CSP lets it reach the site only.
+- It needs a host that draws MCP apps. Elsewhere the tools still answer in
+  text, and `speak` opens its browser window.
+
+## Tools
+
+The model's: `avatar_studio`, `connect_account`, `account_status`,
+`disconnect_account`, `list_avatars`, `speak(text, avatar)`, `stop`.
+The page's own (hidden from the model): `studio_*`.
+
+## Layout
+
+```
+liveface_mcp/
+  server.py        wires the tools to the shared Services
+  services.py      config, account, APIs, window, runs
+  config.py        the environment
+  transport.py     JSON and multipart over the standard library; ApiError
+  account.py       the device sign-in, the session on disk, refreshing it
+  client.py        the account's API, and the public share API
+  creation.py      the wizard's steps, in the background, with progress
+  window.py        the browser window for `speak`
+  tools/           speak, account, studio
+  web/             window.html + window.entry.ts; studio.html + studio/ (the page's modules)
+tests/             unittest, over a fake site (fakes.py); no network
+e2e/               the studio end to end in a real Chrome (README there)
+```
+
+## Tests
+
+```sh
+python -m unittest discover -s tests -t .
+```

liveface_mcp-0.1.0/build.sh

@@ -0,0 +1,16 @@
+#!/bin/sh
+# Builds the two pages this server serves: the avatar window (`speak`) and
+# the studio (an MCP app). Run from anywhere; needs the repo's embed and
+# frontend deps installed (npm ci in embed/ and frontend/), because the
+# engine (embed/src) and the consent wording (frontend/src/i18n) are imported
+# at build time.
+set -eu
+here=$(cd "$(dirname "$0")" && pwd)
+web="$here/liveface_mcp/web"
+cd "$here/../embed"
+# Type-check the pages first (mcp/tsconfig.json), with the repo's TypeScript.
+npx tsc -p "$here/tsconfig.json"
+npx esbuild "$web/window.entry.ts" --bundle --format=iife --minify --target=es2020 --outfile="$web/window.js"
+npx esbuild "$web/studio/main.ts" --bundle --format=iife --minify --target=es2020 \
+  --tsconfig="$here/../frontend/tsconfig.json" --loader:.webp=dataurl --outfile="$web/studio.js"
+echo "built $web/window.js and $web/studio.js"

liveface_mcp-0.1.0/e2e/README.md

@@ -0,0 +1,29 @@
+# The studio, end to end
+
+A real Chrome drives the studio inside a mock MCP host (`harness.py`: the
+real MCP server in-process, the page in a sandboxed iframe under the CSP its
+resource declares, `/api/*` proxied to the backend as production's proxy
+does), and the dashboard's `/connect` page:
+
+1. the studio opens, not connected; **Connect your account** shows a code and
+   asks the host to open the dashboard;
+2. the dashboard: sign in (it comes back to `/connect?code=`), check, Approve;
+3. the studio connects and lists the account's avatars;
+4. a video with the first one (its sound and length checked);
+5. a new avatar from a photo: a man, 3D realistic, arms crossed;
+6. a video with it.
+
+It spends real image calls (step 5). Run it against a scratch copy of a local
+database, never production:
+
+```sh
+# a backend of this checkout on :7003 (RIG_MODEL_PATH, KOKORO_*, a Gemini key in its database,
+#   APP_BASE_URL=http://localhost:5183, PUBLIC_BASE_URL=http://localhost:9099/api),
+# its dashboard on :5183 proxying /api to :7003, then:
+cd mcp
+E2E_BACKEND=http://localhost:7003 LIVEFACE_BASE=http://localhost:9099 \
+  LIVEFACE_CREDENTIALS=/tmp/e2e-creds.json python e2e/harness.py &
+E2E_USER=... E2E_PASSWORD=... node e2e/studio.e2e.mjs /path/to/photo.jpg   # skip-create: steps 1-4
+```
+
+Screenshots and the videos land in `e2e/out/` (ignored).

liveface_mcp-0.1.0/e2e/harness.py

@@ -0,0 +1,130 @@
+"""A mock MCP host for the studio, end to end: the real MCP server in this
+process (its tools called as a host calls them), the studio page in a
+sandboxed iframe under the CSP its resource declares, and /api/* proxied to
+the backend the way production's proxy lays it out.
+
+    E2E_BACKEND=http://localhost:7003 LIVEFACE_BASE=http://localhost:9099 python e2e/harness.py
+
+(run from mcp/, so `liveface_mcp` is this checkout's; e2e/README.md)
+"""
+
+import asyncio
+import json
+import os
+import threading
+import urllib.error
+import urllib.request
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+from liveface_mcp import config, server
+from liveface_mcp.services import Services
+from liveface_mcp.tools import studio
+
+BACKEND = os.environ.get("E2E_BACKEND", "http://localhost:7003")
+PORT = int(os.environ.get("E2E_PORT", "9099"))
+
+services = Services.of(config.load())
+mcp = server.build(services)
+loop = asyncio.new_event_loop()
+threading.Thread(target=loop.run_forever, daemon=True).start()
+
+
+def run(coro):
+    return asyncio.run_coroutine_threadsafe(coro, loop).result(timeout=300)
+
+
+def csp() -> str:
+    [resource] = [r for r in run(mcp.list_resources()) if str(r.uri) == studio.URI]
+    declared = resource.meta["ui"]["csp"]
+    connect = " ".join(declared["connectDomains"])
+    resources = " ".join(declared["resourceDomains"])
+    # blob: in connect-src is the TEST's only (it reads the video back); the page does not need it.
+    return (
+        "default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; "
+        f"img-src data: blob: {resources}; media-src data: blob: {resources}; connect-src {connect} blob:"
+    )
+
+
+HOST = """<!doctype html><title>mock host</title>
+<iframe id="app" sandbox="allow-scripts allow-downloads" src="/studio.html" style="width:560px;height:1000px;border:1px solid #888"></iframe>
+<script>
+const frame = document.getElementById("app");
+window.__log = []; window.__opened = [];
+addEventListener("message", async (e) => {
+  if (e.source !== frame.contentWindow) return;
+  const m = e.data; window.__log.push(m.method || "response");
+  const reply = (result) => frame.contentWindow.postMessage({ jsonrpc: "2.0", id: m.id, result }, "*");
+  if (m.method === "ui/initialize") reply({ protocolVersion: "2026-01-26", hostInfo: { name: "mock", version: "1" }, hostCapabilities: {}, hostContext: {} });
+  else if (m.method === "ui/notifications/initialized") {
+    const opened = await (await fetch("/tool", { method: "POST", body: JSON.stringify({ name: "avatar_studio", arguments: {} }) })).json();
+    frame.contentWindow.postMessage({ jsonrpc: "2.0", method: "ui/notifications/tool-result", params: opened }, "*");
+  } else if (m.method === "tools/call") {
+    reply(await (await fetch("/tool", { method: "POST", body: JSON.stringify(m.params) })).json());
+  } else if (m.method === "ui/open-link") { window.__opened.push(m.params.url); reply({}); }
+});
+</script>"""
+
+
+class Handler(BaseHTTPRequestHandler):
+    def log_message(self, format, *args):
+        pass
+
+    def _send(self, status, body: bytes, content_type: str, extra=None):
+        self.send_response(status)
+        self.send_header("Content-Type", content_type)
+        for key, value in (extra or {}).items():
+            self.send_header(key, value)
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def _proxy(self):
+        length = int(self.headers.get("Content-Length") or 0)
+        body = self.rfile.read(length) if length else None
+        headers = {k: v for k, v in self.headers.items() if k.lower() not in ("host", "connection", "content-length")}
+        req = urllib.request.Request(BACKEND + self.path[4:], data=body, headers=headers, method=self.command)
+        try:
+            with urllib.request.urlopen(req, timeout=300) as response:
+                status, data, rheaders = response.status, response.read(), response.headers
+        except urllib.error.HTTPError as error:
+            status, data, rheaders = error.code, error.read(), error.headers
+        skip = ("transfer-encoding", "content-length", "connection", "content-encoding")
+        self.send_response(status)
+        for key, value in rheaders.items():
+            if key.lower() not in skip:
+                self.send_header(key, value)
+        self.send_header("Content-Length", str(len(data)))
+        self.end_headers()
+        self.wfile.write(data)
+
+    def do_GET(self):
+        if self.path.startswith("/api/"):
+            return self._proxy()
+        if self.path == "/studio.html":
+            html = run(mcp.read_resource(studio.URI))[0].content
+            return self._send(200, html.encode(), "text/html", {"Content-Security-Policy": csp()})
+        return self._send(200, HOST.encode(), "text/html")
+
+    def do_OPTIONS(self):
+        return self._proxy()
+
+    def do_PATCH(self):
+        return self._proxy()
+
+    def do_DELETE(self):
+        return self._proxy()
+
+    def do_POST(self):
+        if self.path.startswith("/api/"):
+            return self._proxy()
+        if self.path == "/tool":
+            call = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
+            result = run(mcp.call_tool(call["name"], call.get("arguments") or {}))
+            dumped = result.model_dump(mode="json", by_alias=True, exclude_none=True)
+            return self._send(200, json.dumps(dumped).encode(), "application/json")
+        self._send(404, b"", "text/plain")
+
+
+if __name__ == "__main__":
+    print(f"mock host on http://localhost:{PORT}", flush=True)
+    ThreadingHTTPServer(("127.0.0.1", PORT), Handler).serve_forever()