janction-render 0.1.0__tar.gz → 0.2.0__tar.gz

janction_render-0.2.0/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: janction-render
+Version: 0.2.0
+Summary: Cloud GPU render farm for Blender, for AI agents: MCP server (remote + stdio) and CLI. Render Blender without a GPU from Claude, ChatGPT, Claude Code, Codex, Cursor.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31
+Requires-Dist: mcp>=1.10
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.10; extra == "mcp"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+# JANCTION Render
+
+A cloud GPU render farm for Blender, built for AI agents. Render Blender scenes on JANCTION GPUs from **Claude, ChatGPT,
+Claude Code, Codex, Cursor or any MCP client**: an MCP server (remote and stdio) plus a CLI. Use it to render Blender
+without a GPU, or when rendering locally is slow.
+
+- Input: a `.blend` file, or a **bpy Python script that builds the scene** (no local Blender needed).
+- `scene_info` reads the scene without rendering (cameras, frame range, missing files).
+- `render_preview` returns 1-4 low-cost frames tiled in one image within seconds, so the agent can look, fix, and repeat.
+- `render_estimate` says how long a render will take ("about 3 minutes") and whether it fits today's free quota.
+- `render_final` renders the frames on GPUs and joins them into an MP4; `render_status` reports the remaining time.
+- Free beta: no charges. Each key gets 10 GPU-minutes per day; a final render is up to 240 frames at 1080p.
+  Paid plans (per GPU second, prepaid credit) will be announced on the service page before they start.
+- Inputs and results are deleted 24 hours after last use and are never used for training.
+
+## Status
+
+Free beta. Service page: `https://render.janction.jp` (`/v1/health`, `/llms.txt`). Blender 5.0, Cycles on GPU.
+
+## Connect (remote MCP, nothing to install)
+
+MCP server URL: **`https://render.janction.jp/mcp`** (Streamable HTTP). Auth is OAuth 2.1 with dynamic client
+registration: pressing "Connect" opens a page that creates a free API key (or takes one you already have). A raw API key
+also works as `Authorization: Bearer jr_...`.
+
+| client | how |
+|---|---|
+| Claude.ai (web, desktop, mobile) | Settings → Connectors → Add custom connector → paste the URL → Connect |
+| ChatGPT | Settings → Connectors → Advanced → Developer mode → Create → paste the URL (OAuth) |
+| Claude Code | `claude mcp add --transport http janction-render https://render.janction.jp/mcp`, then `/mcp` to authenticate |
+| Cursor, Windsurf, other MCP clients | Streamable HTTP at the URL above (OAuth, or a Bearer API key header) |
+
+Remote tools take `scene_script` (bpy code as text), `scene_url` (an https link to a `.blend` or `.py`) or `scene_id`;
+results come back as an inline image plus download links that need no key and work for about 24 hours.
+
+Claude Code plugin (the remote connector plus a skill with the workflow):
+
+```
+/plugin marketplace add KJdayo/janction-render
+/plugin install janction-render@janction-render
+```
+
+## Install (stdio MCP, sends local files)
+
+The package is on PyPI as `janction-render`.
+
+```
+# Claude Code (uvx runs it without a global install)
+claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- uvx --from janction-render janction-render-mcp
+
+# or with pip / pipx
+pip install janction-render
+claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- janction-render-mcp
+```
+
+Codex: add to `~/.codex/config.toml`
+
+```toml
+[mcp_servers.janction-render]
+command = "uvx"
+args = ["--from", "janction-render", "janction-render-mcp"]
+env = { JANCTION_RENDER_SERVER = "https://render.janction.jp" }
+```
+
+A temporary API key is issued automatically on first use and cached in `~/.janction-render.json`; set
+`JANCTION_RENDER_API_KEY` to pin one (quota and, later, credit belong to the key). The same key can be used from the
+remote connector: paste it on the connect page.
+
+Then, in Claude Code:
+
+> Build a small street scene in Blender with a camera fly-through and render a preview with janction-render.
+
+## Tools
+
+| tool | what |
+|---|---|
+| `scene_info(scene_script | scene_url | scene_path | scene_id)` | cameras, frame range, fps, resolution, objects, lights, missing files. No render. |
+| `render_preview(..., frames="1-24")` | up to 4 frames (720p budget) tiled with frame labels; returns the image inline |
+| `render_estimate(scene_id, frame_start, frame_end, width, height, samples)` | GPU seconds, queue wait, "about N minutes", fits today's free quota? No GPU time used |
+| `render_final(scene_id, frame_start, frame_end, width, height, samples, fps, output)` | PNG or MP4; returns job_id + estimate |
+| `render_status(job_id)` | progress and ETA (`eta.human`); `render_download(job_id)` files or links; `render_cancel(job_id)` |
+| `billing()` | free-beta quota (used today, daily limit, reset time); later balance and top-up link |
+| `render_info()` | workers online, queue and expected wait |
+
+CLI: `janction-render inspect|preview|render|status|download|cancel|jobs|balance|topup|info`.
+
+## Writing a scene script
+
+```python
+import bpy, math
+for ob in list(bpy.data.objects):
+    bpy.data.objects.remove(ob, do_unlink=True)
+scene = bpy.context.scene
+scene.frame_start, scene.frame_end = 1, 24
+bpy.ops.mesh.primitive_monkey_add(location=(0, 0, 1))
+cam = bpy.data.objects.new("Camera", bpy.data.cameras.new("Camera"))
+scene.collection.objects.link(cam); scene.camera = cam
+cam.location = (6, -6, 4); cam.rotation_euler = (math.radians(60), 0, math.radians(45))
+sun = bpy.data.objects.new("Sun", bpy.data.lights.new("Sun", "SUN"))
+scene.collection.objects.link(sun)
+```
+
+The service sets engine (Cycles), resolution, samples and denoising; your script sets the scene, camera and frame range.
+Scripts run in an isolated container with no network. See `samples/cube_scene.py`.
+
+## HTTP API
+
+```
+POST /v1/keys                                   -> {api_key}         (header X-API-Key afterwards)
+POST /v1/files  multipart "file" (.blend|.py)   -> {scene_id}
+POST /v1/estimate {kind, frames|frame_start/frame_end, width, height, samples, scene_id?} -> seconds, wall_seconds, human, quota
+POST /v1/jobs   {scene_id, kind: info|preview|final, frames|frame_start/frame_end, width, height, samples, camera, fps, output}
+GET  /v1/jobs/{id}      status, progress, eta, artifacts[], cost, warnings, info    DELETE /v1/jobs/{id}  cancel
+GET  /v1/jobs/{id}/artifacts/{name}             PNG / MP4
+POST /mcp                                       remote MCP (Streamable HTTP; Bearer api key or OAuth)
+GET  /.well-known/oauth-protected-resource/mcp  OAuth discovery
+POST /v1/billing/checkout {amount_yen} -> {checkout_url}   POST /v1/billing/sync   GET /v1/ledger   GET /v1/me
+GET  /llms.txt  /terms  /privacy  /legal  /security
+```
+
+During the free beta a `429 quota_exceeded` response carries `resets_at`; a `400 beta_limit` means the job is too big
+(split it). Once paid plans start, a `402 payment_required` response carries `checkout_url`.
+
+## Self-hosting
+
+The server (FastAPI + SQLite, with the remote MCP endpoint) and the worker (Blender in disposable Docker containers,
+`--network none --cap-drop ALL`) live in the internal repository and are not part of this package yet. This repository
+holds the client side: stdio MCP server, CLI, HTTP client, samples and the Claude Code plugin.
+
+## MCP registry
+
+This server is listed in the official MCP registry as `io.github.KJdayo/janction-render` (remote: `https://render.janction.jp/mcp`).
+
+mcp-name: io.github.KJdayo/janction-render
+
+## License
+
+MIT (see LICENSE). Operated by JasmyLab Inc.

janction_render-0.2.0/README.md

@@ -0,0 +1,138 @@
+# JANCTION Render
+
+A cloud GPU render farm for Blender, built for AI agents. Render Blender scenes on JANCTION GPUs from **Claude, ChatGPT,
+Claude Code, Codex, Cursor or any MCP client**: an MCP server (remote and stdio) plus a CLI. Use it to render Blender
+without a GPU, or when rendering locally is slow.
+
+- Input: a `.blend` file, or a **bpy Python script that builds the scene** (no local Blender needed).
+- `scene_info` reads the scene without rendering (cameras, frame range, missing files).
+- `render_preview` returns 1-4 low-cost frames tiled in one image within seconds, so the agent can look, fix, and repeat.
+- `render_estimate` says how long a render will take ("about 3 minutes") and whether it fits today's free quota.
+- `render_final` renders the frames on GPUs and joins them into an MP4; `render_status` reports the remaining time.
+- Free beta: no charges. Each key gets 10 GPU-minutes per day; a final render is up to 240 frames at 1080p.
+  Paid plans (per GPU second, prepaid credit) will be announced on the service page before they start.
+- Inputs and results are deleted 24 hours after last use and are never used for training.
+
+## Status
+
+Free beta. Service page: `https://render.janction.jp` (`/v1/health`, `/llms.txt`). Blender 5.0, Cycles on GPU.
+
+## Connect (remote MCP, nothing to install)
+
+MCP server URL: **`https://render.janction.jp/mcp`** (Streamable HTTP). Auth is OAuth 2.1 with dynamic client
+registration: pressing "Connect" opens a page that creates a free API key (or takes one you already have). A raw API key
+also works as `Authorization: Bearer jr_...`.
+
+| client | how |
+|---|---|
+| Claude.ai (web, desktop, mobile) | Settings → Connectors → Add custom connector → paste the URL → Connect |
+| ChatGPT | Settings → Connectors → Advanced → Developer mode → Create → paste the URL (OAuth) |
+| Claude Code | `claude mcp add --transport http janction-render https://render.janction.jp/mcp`, then `/mcp` to authenticate |
+| Cursor, Windsurf, other MCP clients | Streamable HTTP at the URL above (OAuth, or a Bearer API key header) |
+
+Remote tools take `scene_script` (bpy code as text), `scene_url` (an https link to a `.blend` or `.py`) or `scene_id`;
+results come back as an inline image plus download links that need no key and work for about 24 hours.
+
+Claude Code plugin (the remote connector plus a skill with the workflow):
+
+```
+/plugin marketplace add KJdayo/janction-render
+/plugin install janction-render@janction-render
+```
+
+## Install (stdio MCP, sends local files)
+
+The package is on PyPI as `janction-render`.
+
+```
+# Claude Code (uvx runs it without a global install)
+claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- uvx --from janction-render janction-render-mcp
+
+# or with pip / pipx
+pip install janction-render
+claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- janction-render-mcp
+```
+
+Codex: add to `~/.codex/config.toml`
+
+```toml
+[mcp_servers.janction-render]
+command = "uvx"
+args = ["--from", "janction-render", "janction-render-mcp"]
+env = { JANCTION_RENDER_SERVER = "https://render.janction.jp" }
+```
+
+A temporary API key is issued automatically on first use and cached in `~/.janction-render.json`; set
+`JANCTION_RENDER_API_KEY` to pin one (quota and, later, credit belong to the key). The same key can be used from the
+remote connector: paste it on the connect page.
+
+Then, in Claude Code:
+
+> Build a small street scene in Blender with a camera fly-through and render a preview with janction-render.
+
+## Tools
+
+| tool | what |
+|---|---|
+| `scene_info(scene_script | scene_url | scene_path | scene_id)` | cameras, frame range, fps, resolution, objects, lights, missing files. No render. |
+| `render_preview(..., frames="1-24")` | up to 4 frames (720p budget) tiled with frame labels; returns the image inline |
+| `render_estimate(scene_id, frame_start, frame_end, width, height, samples)` | GPU seconds, queue wait, "about N minutes", fits today's free quota? No GPU time used |
+| `render_final(scene_id, frame_start, frame_end, width, height, samples, fps, output)` | PNG or MP4; returns job_id + estimate |
+| `render_status(job_id)` | progress and ETA (`eta.human`); `render_download(job_id)` files or links; `render_cancel(job_id)` |
+| `billing()` | free-beta quota (used today, daily limit, reset time); later balance and top-up link |
+| `render_info()` | workers online, queue and expected wait |
+
+CLI: `janction-render inspect|preview|render|status|download|cancel|jobs|balance|topup|info`.
+
+## Writing a scene script
+
+```python
+import bpy, math
+for ob in list(bpy.data.objects):
+    bpy.data.objects.remove(ob, do_unlink=True)
+scene = bpy.context.scene
+scene.frame_start, scene.frame_end = 1, 24
+bpy.ops.mesh.primitive_monkey_add(location=(0, 0, 1))
+cam = bpy.data.objects.new("Camera", bpy.data.cameras.new("Camera"))
+scene.collection.objects.link(cam); scene.camera = cam
+cam.location = (6, -6, 4); cam.rotation_euler = (math.radians(60), 0, math.radians(45))
+sun = bpy.data.objects.new("Sun", bpy.data.lights.new("Sun", "SUN"))
+scene.collection.objects.link(sun)
+```
+
+The service sets engine (Cycles), resolution, samples and denoising; your script sets the scene, camera and frame range.
+Scripts run in an isolated container with no network. See `samples/cube_scene.py`.
+
+## HTTP API
+
+```
+POST /v1/keys                                   -> {api_key}         (header X-API-Key afterwards)
+POST /v1/files  multipart "file" (.blend|.py)   -> {scene_id}
+POST /v1/estimate {kind, frames|frame_start/frame_end, width, height, samples, scene_id?} -> seconds, wall_seconds, human, quota
+POST /v1/jobs   {scene_id, kind: info|preview|final, frames|frame_start/frame_end, width, height, samples, camera, fps, output}
+GET  /v1/jobs/{id}      status, progress, eta, artifacts[], cost, warnings, info    DELETE /v1/jobs/{id}  cancel
+GET  /v1/jobs/{id}/artifacts/{name}             PNG / MP4
+POST /mcp                                       remote MCP (Streamable HTTP; Bearer api key or OAuth)
+GET  /.well-known/oauth-protected-resource/mcp  OAuth discovery
+POST /v1/billing/checkout {amount_yen} -> {checkout_url}   POST /v1/billing/sync   GET /v1/ledger   GET /v1/me
+GET  /llms.txt  /terms  /privacy  /legal  /security
+```
+
+During the free beta a `429 quota_exceeded` response carries `resets_at`; a `400 beta_limit` means the job is too big
+(split it). Once paid plans start, a `402 payment_required` response carries `checkout_url`.
+
+## Self-hosting
+
+The server (FastAPI + SQLite, with the remote MCP endpoint) and the worker (Blender in disposable Docker containers,
+`--network none --cap-drop ALL`) live in the internal repository and are not part of this package yet. This repository
+holds the client side: stdio MCP server, CLI, HTTP client, samples and the Claude Code plugin.
+
+## MCP registry
+
+This server is listed in the official MCP registry as `io.github.KJdayo/janction-render` (remote: `https://render.janction.jp/mcp`).
+
+mcp-name: io.github.KJdayo/janction-render
+
+## License
+
+MIT (see LICENSE). Operated by JasmyLab Inc.

{janction_render-0.1.0 → janction_render-0.2.0}/janction_render/__init__.py

@@ -1,3 +1,3 @@
 """JANCTION Render — ターミナルの AI エージェントから GPU で 3DCG を描く。"""
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"

janction_render-0.2.0/janction_render/brief.py

@@ -0,0 +1,55 @@
+"""仕事の状態を、エージェントが読みやすい短い形にする。stdio の MCP（mcp_server.py）とリモート MCP（server/mcp_remote.py）で共通。"""
+from __future__ import annotations
+
+from typing import Any
+
+
+def eta_brief(e: dict[str, Any] | None) -> dict[str, Any] | None:
+    """受付の eta（作業時間の見積もり）から、伝える価値のある項目だけ。"""
+    if not e:
+        return None
+    keep = ("human", "remaining_seconds", "queue_wait_seconds", "remaining_gpu_seconds", "elapsed_seconds",
+            "running_for_seconds", "took_seconds", "workers_online", "basis")
+    return {k: e[k] for k in keep if e.get(k) is not None}
+
+
+def estimate_brief(e: dict[str, Any] | None) -> dict[str, Any] | None:
+    if not e:
+        return None
+    keep = ("human", "seconds", "wall_seconds", "queue_wait_seconds", "per_frame_seconds", "frames", "chunks",
+            "workers_online", "basis", "basis_note", "note", "quota", "cost")
+    return {k: e[k] for k in keep if e.get(k) is not None}
+
+
+def brief(j: dict[str, Any]) -> dict[str, Any]:
+    p = j["progress"]
+    out: dict[str, Any] = {
+        "job_id": j["job_id"],
+        "kind": j["kind"],
+        "status": j["status"],
+        "scene_id": j["scene_id"],
+        "frames": j["frames"] if j.get("frames") else f"{j['frame_start']}-{j['frame_end']}",
+        "progress": f"{p['frames_done']}/{p['frames_total']} frames, {p['chunks_done']}/{p['chunks_total']} chunks",
+        "queue_ahead": p["queue_ahead"],
+        "gpu_seconds": j["gpu_seconds"],
+        "device": j["device"],
+        "expires_at": j["expires_at"],
+    }
+    if j.get("eta"):
+        out["eta"] = eta_brief(j["eta"])
+    if j.get("estimate"):
+        out["estimate"] = estimate_brief(j["estimate"])
+    if j.get("error"):
+        out["error"] = j["error"]
+    if j.get("log_tail"):
+        out["log_tail"] = j["log_tail"][-1500:]
+    if j.get("warnings"):
+        out["warnings"] = j["warnings"]
+    if j.get("output"):
+        out["output"] = j["output"]["name"]
+    if j.get("cost"):
+        c = j["cost"]
+        out["cost"] = ("free" if c["free"] else
+                       (f"{c['charged_yen']} yen charged" if c["settled"] else f"up to {c['reserved_yen']} yen reserved"))
+    out["artifacts"] = [a["name"] for a in j["artifacts"]][:50]
+    return out

{janction_render-0.1.0 → janction_render-0.2.0}/janction_render/client.py

@@ -185,6 +185,13 @@ class Client:
         body.update({k: v for k, v in params.items() if v is not None})
         return self._req("POST", "/v1/jobs", json=body)
 
+    def estimate(self, scene_id: Optional[str] = None, **params: Any) -> dict[str, Any]:
+        """入れずに見積もりだけ（GPU 秒・列の待ち・壁時計の目安・無料枠に収まるか）。"""
+        body: dict[str, Any] = {k: v for k, v in params.items() if v is not None}
+        if scene_id:
+            body["scene_id"] = scene_id
+        return self._req("POST", "/v1/estimate", json=body)
+
     def job(self, job_id: str) -> dict[str, Any]:
         return self._req("GET", f"/v1/jobs/{job_id}")
 

{janction_render-0.1.0 → janction_render-0.2.0}/janction_render/mcp_server.py

@@ -26,6 +26,7 @@ try:
 except ImportError:  # mcp 1.x
     from mcp.server.fastmcp import FastMCP as MCPServer, Image  # type: ignore
 
+from janction_render.brief import brief as _brief, estimate_brief
 from janction_render.client import Client, ClientError, parse_frames
 
 PREVIEW_WAIT_S = 240.0
@@ -34,12 +35,13 @@ INFO_WAIT_S = 150.0
 mcp = MCPServer(
     name="janction-render",
     instructions=(
-        "Render Blender scenes on JANCTION GPUs from the terminal. Use it when the user is "
-        "building 3DCG with Blender (a .blend file or a bpy Python script) and has no GPU or "
-        "rendering locally is slow. Flow: scene_info (cameras, frame range, missing files; no "
-        "render) -> render_preview (1-4 fast frames in one image; look at it, fix the scene, "
-        "repeat) -> ask the user 'is this OK?' -> render_final (frames or MP4) -> render_status / "
-        "render_download. Inputs and results are deleted 24 hours after last use."
+        "Render Blender scenes on JANCTION GPUs (a cloud render farm for AI agents) from the terminal. Use it when the "
+        "user is building 3DCG with Blender (a .blend file or a bpy Python script) and has no GPU or rendering locally "
+        "is slow. Flow: scene_info (cameras, frame range, missing files; no render) -> render_preview (1-4 fast frames "
+        "in one image; look at it, fix the scene, repeat) -> ask the user 'is this OK?' -> render_estimate (tell the "
+        "user how long it takes and whether it fits today's free quota) -> render_final (frames or MP4) -> "
+        "render_status / render_download. Always tell the user the time estimate (estimate.human / eta.human). "
+        "Blender 5.0 with Cycles on GPU. Inputs and results are deleted 24 hours after last use."
     ),
 )
 
@@ -72,36 +74,6 @@ def _quota_block(exc: ClientError) -> Optional[dict[str, Any]]:
                     "lower resolution or samples) may still fit"}
 
 
-def _brief(j: dict[str, Any]) -> dict[str, Any]:
-    p = j["progress"]
-    out = {
-        "job_id": j["job_id"],
-        "kind": j["kind"],
-        "status": j["status"],
-        "scene_id": j["scene_id"],
-        "frames": j["frames"] if j.get("frames") else f"{j['frame_start']}-{j['frame_end']}",
-        "progress": f"{p['frames_done']}/{p['frames_total']} frames, {p['chunks_done']}/{p['chunks_total']} chunks",
-        "queue_ahead": p["queue_ahead"],
-        "gpu_seconds": j["gpu_seconds"],
-        "device": j["device"],
-        "expires_at": j["expires_at"],
-    }
-    if j.get("error"):
-        out["error"] = j["error"]
-    if j.get("log_tail"):
-        out["log_tail"] = j["log_tail"][-1500:]
-    if j.get("warnings"):
-        out["warnings"] = j["warnings"]
-    if j.get("output"):
-        out["output"] = j["output"]["name"]
-    if j.get("cost"):
-        c = j["cost"]
-        out["cost"] = ("free" if c["free"] else
-                       (f"{c['charged_yen']} yen charged" if c["settled"] else f"up to {c['reserved_yen']} yen reserved"))
-    out["artifacts"] = [a["name"] for a in j["artifacts"]][:50]
-    return out
-
-
 def _payment_block(exc: ClientError) -> Optional[dict[str, Any]]:
     """残高不足（402）なら、決済ページのリンクと次の手順を返す。"""
     p = exc.payment()
@@ -218,6 +190,37 @@ def render_preview(
     return result
 
 
+@mcp.tool()
+def render_estimate(scene_id: str = "", kind: str = "final", frame_start: int = 1, frame_end: int = 1,
+                    frames: str = "", width: int = 1920, height: int = 1080, samples: int = 128) -> str:
+    """Estimate how long a render will take BEFORE starting it (no GPU time used): GPU seconds, queue wait,
+    wall-clock time as a human-readable string ('about 3 minutes'), and whether it fits today's free quota and
+    the size limits. kind is 'final' (frame_start..frame_end at width x height, samples) or 'preview' (frames
+    like '1-24'). Pass scene_id when you have one: the estimate then uses this scene's own measured render
+    times. Tell the user the result before calling render_final."""
+    c = _client()
+    try:
+        params: dict[str, Any] = {"kind": kind, "width": width, "height": height, "samples": samples}
+        if kind == "preview":
+            params["frames"] = parse_frames(frames)
+        else:
+            params.update({"frame_start": frame_start, "frame_end": frame_end})
+        est = c.estimate(scene_id or None, **params)
+    except (ClientError, ValueError) as exc:
+        return _j({"ok": False, "error": str(exc)})
+    out = estimate_brief(est) or {}
+    out["kind"] = kind
+    q = est.get("quota") or {}
+    if q and not q.get("fits_today", True):
+        out["next"] = ("this does not fit today's remaining free GPU time; propose fewer frames, lower resolution or "
+                       "samples, or wait until resets_at")
+    elif q and q.get("fits_size") is False:
+        out["next"] = f"too big for the free beta (max {q.get('max_frames_per_job')} frames and 1920x1080 per job); split it"
+    else:
+        out["next"] = "tell the user the estimate and ask before calling render_final"
+    return _j(out)
+
+
 @mcp.tool()
 def render_final(
     scene_path: str = "",
@@ -253,20 +256,26 @@ def render_final(
     except (ValueError, FileNotFoundError) as exc:
         return _j({"ok": False, "error": str(exc)})
     brief = _brief(j)
-    brief["estimate"] = j.get("estimate")
-    brief["next"] = "render_status(job_id) until status is done, then render_download(job_id)"
+    est = j.get("estimate") or {}
+    brief["next"] = (f"tell the user it will take {est.get('human', 'a few minutes')}; then render_status(job_id) "
+                     "until status is done, then render_download(job_id)")
     return _j(brief)
 
 
 @mcp.tool()
 def render_status(job_id: str) -> str:
     """Check a JANCTION render job: status (queued/running/done/failed/canceled), frames done,
-    how many chunks are queued ahead, artifacts ready, Blender warnings, and the error plus log
-    tail if it failed. Use render_download once status is done."""
+    how many chunks are queued ahead, the ETA (eta.human = remaining time including queue wait),
+    artifacts ready, Blender warnings, and the error plus log tail if it failed. Use render_download
+    once status is done."""
     try:
-        return _j(_brief(_client().job(job_id)))
+        j = _client().job(job_id)
     except ClientError as exc:
         return _j({"ok": False, "error": str(exc)})
+    b = _brief(j)
+    if j["status"] in ("queued", "running"):
+        b["next"] = f"tell the user: {((j.get('eta') or {}).get('human') or 'still working')}; check again in a while"
+    return _j(b)
 
 
 @mcp.tool()
@@ -346,7 +355,8 @@ def render_info() -> str:
     except (ClientError, Exception) as exc:  # noqa: BLE001
         return _j({"ok": False, "server": c.server, "error": str(exc)})
     return _j({"ok": True, "server": c.server, "workers": health["workers"], "queue": health["queue"],
-               "key": me, "downloads_go_to": str(_out_root())})
+               "key": me, "downloads_go_to": str(_out_root()),
+               "remote_mcp": f"{c.server}/mcp (Streamable HTTP; for Claude.ai, ChatGPT, Cursor: add this URL as a connector)"})
 
 
 def main() -> None:

janction_render-0.2.0/janction_render.egg-info/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: janction-render
+Version: 0.2.0
+Summary: Cloud GPU render farm for Blender, for AI agents: MCP server (remote + stdio) and CLI. Render Blender without a GPU from Claude, ChatGPT, Claude Code, Codex, Cursor.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31
+Requires-Dist: mcp>=1.10
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.10; extra == "mcp"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+# JANCTION Render
+
+A cloud GPU render farm for Blender, built for AI agents. Render Blender scenes on JANCTION GPUs from **Claude, ChatGPT,
+Claude Code, Codex, Cursor or any MCP client**: an MCP server (remote and stdio) plus a CLI. Use it to render Blender
+without a GPU, or when rendering locally is slow.
+
+- Input: a `.blend` file, or a **bpy Python script that builds the scene** (no local Blender needed).
+- `scene_info` reads the scene without rendering (cameras, frame range, missing files).
+- `render_preview` returns 1-4 low-cost frames tiled in one image within seconds, so the agent can look, fix, and repeat.
+- `render_estimate` says how long a render will take ("about 3 minutes") and whether it fits today's free quota.
+- `render_final` renders the frames on GPUs and joins them into an MP4; `render_status` reports the remaining time.
+- Free beta: no charges. Each key gets 10 GPU-minutes per day; a final render is up to 240 frames at 1080p.
+  Paid plans (per GPU second, prepaid credit) will be announced on the service page before they start.
+- Inputs and results are deleted 24 hours after last use and are never used for training.
+
+## Status
+
+Free beta. Service page: `https://render.janction.jp` (`/v1/health`, `/llms.txt`). Blender 5.0, Cycles on GPU.
+
+## Connect (remote MCP, nothing to install)
+
+MCP server URL: **`https://render.janction.jp/mcp`** (Streamable HTTP). Auth is OAuth 2.1 with dynamic client
+registration: pressing "Connect" opens a page that creates a free API key (or takes one you already have). A raw API key
+also works as `Authorization: Bearer jr_...`.
+
+| client | how |
+|---|---|
+| Claude.ai (web, desktop, mobile) | Settings → Connectors → Add custom connector → paste the URL → Connect |
+| ChatGPT | Settings → Connectors → Advanced → Developer mode → Create → paste the URL (OAuth) |
+| Claude Code | `claude mcp add --transport http janction-render https://render.janction.jp/mcp`, then `/mcp` to authenticate |
+| Cursor, Windsurf, other MCP clients | Streamable HTTP at the URL above (OAuth, or a Bearer API key header) |
+
+Remote tools take `scene_script` (bpy code as text), `scene_url` (an https link to a `.blend` or `.py`) or `scene_id`;
+results come back as an inline image plus download links that need no key and work for about 24 hours.
+
+Claude Code plugin (the remote connector plus a skill with the workflow):
+
+```
+/plugin marketplace add KJdayo/janction-render
+/plugin install janction-render@janction-render
+```
+
+## Install (stdio MCP, sends local files)
+
+The package is on PyPI as `janction-render`.
+
+```
+# Claude Code (uvx runs it without a global install)
+claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- uvx --from janction-render janction-render-mcp
+
+# or with pip / pipx
+pip install janction-render
+claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- janction-render-mcp
+```
+
+Codex: add to `~/.codex/config.toml`
+
+```toml
+[mcp_servers.janction-render]
+command = "uvx"
+args = ["--from", "janction-render", "janction-render-mcp"]
+env = { JANCTION_RENDER_SERVER = "https://render.janction.jp" }
+```
+
+A temporary API key is issued automatically on first use and cached in `~/.janction-render.json`; set
+`JANCTION_RENDER_API_KEY` to pin one (quota and, later, credit belong to the key). The same key can be used from the
+remote connector: paste it on the connect page.
+
+Then, in Claude Code:
+
+> Build a small street scene in Blender with a camera fly-through and render a preview with janction-render.
+
+## Tools
+
+| tool | what |
+|---|---|
+| `scene_info(scene_script | scene_url | scene_path | scene_id)` | cameras, frame range, fps, resolution, objects, lights, missing files. No render. |
+| `render_preview(..., frames="1-24")` | up to 4 frames (720p budget) tiled with frame labels; returns the image inline |
+| `render_estimate(scene_id, frame_start, frame_end, width, height, samples)` | GPU seconds, queue wait, "about N minutes", fits today's free quota? No GPU time used |
+| `render_final(scene_id, frame_start, frame_end, width, height, samples, fps, output)` | PNG or MP4; returns job_id + estimate |
+| `render_status(job_id)` | progress and ETA (`eta.human`); `render_download(job_id)` files or links; `render_cancel(job_id)` |
+| `billing()` | free-beta quota (used today, daily limit, reset time); later balance and top-up link |
+| `render_info()` | workers online, queue and expected wait |
+
+CLI: `janction-render inspect|preview|render|status|download|cancel|jobs|balance|topup|info`.
+
+## Writing a scene script
+
+```python
+import bpy, math
+for ob in list(bpy.data.objects):
+    bpy.data.objects.remove(ob, do_unlink=True)
+scene = bpy.context.scene
+scene.frame_start, scene.frame_end = 1, 24
+bpy.ops.mesh.primitive_monkey_add(location=(0, 0, 1))
+cam = bpy.data.objects.new("Camera", bpy.data.cameras.new("Camera"))
+scene.collection.objects.link(cam); scene.camera = cam
+cam.location = (6, -6, 4); cam.rotation_euler = (math.radians(60), 0, math.radians(45))
+sun = bpy.data.objects.new("Sun", bpy.data.lights.new("Sun", "SUN"))
+scene.collection.objects.link(sun)
+```
+
+The service sets engine (Cycles), resolution, samples and denoising; your script sets the scene, camera and frame range.
+Scripts run in an isolated container with no network. See `samples/cube_scene.py`.
+
+## HTTP API
+
+```
+POST /v1/keys                                   -> {api_key}         (header X-API-Key afterwards)
+POST /v1/files  multipart "file" (.blend|.py)   -> {scene_id}
+POST /v1/estimate {kind, frames|frame_start/frame_end, width, height, samples, scene_id?} -> seconds, wall_seconds, human, quota
+POST /v1/jobs   {scene_id, kind: info|preview|final, frames|frame_start/frame_end, width, height, samples, camera, fps, output}
+GET  /v1/jobs/{id}      status, progress, eta, artifacts[], cost, warnings, info    DELETE /v1/jobs/{id}  cancel
+GET  /v1/jobs/{id}/artifacts/{name}             PNG / MP4
+POST /mcp                                       remote MCP (Streamable HTTP; Bearer api key or OAuth)
+GET  /.well-known/oauth-protected-resource/mcp  OAuth discovery
+POST /v1/billing/checkout {amount_yen} -> {checkout_url}   POST /v1/billing/sync   GET /v1/ledger   GET /v1/me
+GET  /llms.txt  /terms  /privacy  /legal  /security
+```
+
+During the free beta a `429 quota_exceeded` response carries `resets_at`; a `400 beta_limit` means the job is too big
+(split it). Once paid plans start, a `402 payment_required` response carries `checkout_url`.
+
+## Self-hosting
+
+The server (FastAPI + SQLite, with the remote MCP endpoint) and the worker (Blender in disposable Docker containers,
+`--network none --cap-drop ALL`) live in the internal repository and are not part of this package yet. This repository
+holds the client side: stdio MCP server, CLI, HTTP client, samples and the Claude Code plugin.
+
+## MCP registry
+
+This server is listed in the official MCP registry as `io.github.KJdayo/janction-render` (remote: `https://render.janction.jp/mcp`).
+
+mcp-name: io.github.KJdayo/janction-render
+
+## License
+
+MIT (see LICENSE). Operated by JasmyLab Inc.

{janction_render-0.1.0 → janction_render-0.2.0}/janction_render.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.md
 pyproject.toml
 janction_render/__init__.py
+janction_render/brief.py
 janction_render/cli.py
 janction_render/client.py
 janction_render/mcp_server.py

{janction_render-0.1.0 → janction_render-0.2.0}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "janction-render"
-version = "0.1.0"
-description = "Render Blender scenes on JANCTION GPUs straight from terminal AI agents (Claude Code, Codex): MCP server + CLI"
+version = "0.2.0"
+description = "Cloud GPU render farm for Blender, for AI agents: MCP server (remote + stdio) and CLI. Render Blender without a GPU from Claude, ChatGPT, Claude Code, Codex, Cursor."
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = ["requests>=2.31", "mcp>=1.10"]

janction_render-0.1.0/PKG-INFO

@@ -1,118 +0,0 @@
-Metadata-Version: 2.4
-Name: janction-render
-Version: 0.1.0
-Summary: Render Blender scenes on JANCTION GPUs straight from terminal AI agents (Claude Code, Codex): MCP server + CLI
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: requests>=2.31
-Requires-Dist: mcp>=1.10
-Provides-Extra: mcp
-Requires-Dist: mcp>=1.10; extra == "mcp"
-Provides-Extra: dev
-Requires-Dist: pytest>=8; extra == "dev"
-Dynamic: license-file
-
-# JANCTION Render
-
-Render Blender scenes on JANCTION GPUs straight from a terminal AI agent (Claude Code, Codex, or any MCP client).
-Use it when you are building 3DCG with Blender and have no GPU, or rendering locally is slow.
-
-- Input: a `.blend` file, or a **bpy Python script that builds the scene** (no local Blender needed).
-- `scene_info` reads the scene without rendering (cameras, frame range, missing files).
-- `render_preview` returns 1-4 low-cost frames tiled in one image within seconds, so the agent can look, fix, and repeat.
-- `render_final` renders the frames on GPUs and joins them into an MP4.
-- Free beta: no charges. Each key gets 10 GPU-minutes per day; a final render is up to 240 frames at 1080p.
-  Paid plans (per GPU second, prepaid credit) will be announced on the service page before they start.
-- Inputs and results are deleted 24 hours after last use and are never used for training.
-
-## Status
-
-Free beta. The public endpoint is `https://render.janction.jp` (opening; check `/v1/health`). Until it answers, you can
-self-host the server and worker from the internal package (see Self-hosting) or wait for the announcement in `/llms.txt`.
-
-## Install
-
-Until the package is on PyPI, install straight from this repository:
-
-```
-# Claude Code
-claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- uvx --from git+https://github.com/KJdayo/janction-render janction-render-mcp
-
-# or with pipx
-pipx install git+https://github.com/KJdayo/janction-render
-claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- janction-render-mcp
-```
-
-Codex: add to `~/.codex/config.toml`
-
-```toml
-[mcp_servers.janction-render]
-command = "uvx"
-args = ["--from", "git+https://github.com/KJdayo/janction-render", "janction-render-mcp"]
-env = { JANCTION_RENDER_SERVER = "https://render.janction.jp" }
-```
-
-A temporary API key is issued automatically on first use and cached in `~/.janction-render.json`; set
-`JANCTION_RENDER_API_KEY` to pin one (quota and, later, credit belong to the key).
-
-Then, in Claude Code:
-
-> Build a small street scene in Blender with a camera fly-through and render a preview with janction-render.
-
-## Tools
-
-| tool | what |
-|---|---|
-| `scene_info(scene_path | scene_script | scene_id)` | cameras, frame range, fps, resolution, objects, lights, missing files. No render. |
-| `render_preview(..., frames="1-24")` | up to 4 frames (720p budget) tiled with frame labels; returns the image inline |
-| `render_final(scene_id, frame_start, frame_end, width, height, samples, fps, output)` | PNG or MP4; returns job_id + estimate |
-| `render_status(job_id)` / `render_download(job_id)` / `render_cancel(job_id)` | progress, files, cancel |
-| `billing(topup_yen=0)` | free-beta quota (used today, daily limit, reset time); later balance and top-up link |
-| `render_info()` | server, workers online, queue |
-
-CLI: `janction-render inspect|preview|render|status|download|cancel|jobs|balance|topup|info`.
-
-## Writing a scene script
-
-```python
-import bpy, math
-for ob in list(bpy.data.objects):
-    bpy.data.objects.remove(ob, do_unlink=True)
-scene = bpy.context.scene
-scene.frame_start, scene.frame_end = 1, 24
-bpy.ops.mesh.primitive_monkey_add(location=(0, 0, 1))
-cam = bpy.data.objects.new("Camera", bpy.data.cameras.new("Camera"))
-scene.collection.objects.link(cam); scene.camera = cam
-cam.location = (6, -6, 4); cam.rotation_euler = (math.radians(60), 0, math.radians(45))
-sun = bpy.data.objects.new("Sun", bpy.data.lights.new("Sun", "SUN"))
-scene.collection.objects.link(sun)
-```
-
-The service sets engine (Cycles), resolution, samples and denoising; your script sets the scene, camera and frame range.
-Scripts run in an isolated container with no network. See `samples/cube_scene.py`.
-
-## HTTP API
-
-```
-POST /v1/keys                                   -> {api_key}         (header X-API-Key afterwards)
-POST /v1/files  multipart "file" (.blend|.py)   -> {scene_id}
-POST /v1/jobs   {scene_id, kind: info|preview|final, frames|frame_start/frame_end, width, height, samples, camera, fps, output}
-GET  /v1/jobs/{id}      status, progress, artifacts[], cost, warnings, info      DELETE /v1/jobs/{id}  cancel
-GET  /v1/jobs/{id}/artifacts/{name}             PNG / MP4
-POST /v1/billing/checkout {amount_yen} -> {checkout_url}   POST /v1/billing/sync   GET /v1/ledger   GET /v1/me
-GET  /llms.txt  /terms  /privacy  /tokushoho
-```
-
-During the free beta a `429 quota_exceeded` response carries `resets_at`; a `400 beta_limit` means the job is too big
-(split it). Once paid plans start, a `402 payment_required` response carries `checkout_url`.
-
-## Self-hosting
-
-The server (FastAPI + SQLite) and the worker (Blender in disposable Docker containers, `--network none --cap-drop ALL`)
-live in the internal repository and are not part of this package yet. This repository holds the client side: MCP server, CLI,
-HTTP client and samples.
-
-## License
-
-MIT (see LICENSE). Operated by JasmyLab Inc.

janction_render-0.1.0/README.md

@@ -1,103 +0,0 @@
-# JANCTION Render
-
-Render Blender scenes on JANCTION GPUs straight from a terminal AI agent (Claude Code, Codex, or any MCP client).
-Use it when you are building 3DCG with Blender and have no GPU, or rendering locally is slow.
-
-- Input: a `.blend` file, or a **bpy Python script that builds the scene** (no local Blender needed).
-- `scene_info` reads the scene without rendering (cameras, frame range, missing files).
-- `render_preview` returns 1-4 low-cost frames tiled in one image within seconds, so the agent can look, fix, and repeat.
-- `render_final` renders the frames on GPUs and joins them into an MP4.
-- Free beta: no charges. Each key gets 10 GPU-minutes per day; a final render is up to 240 frames at 1080p.
-  Paid plans (per GPU second, prepaid credit) will be announced on the service page before they start.
-- Inputs and results are deleted 24 hours after last use and are never used for training.
-
-## Status
-
-Free beta. The public endpoint is `https://render.janction.jp` (opening; check `/v1/health`). Until it answers, you can
-self-host the server and worker from the internal package (see Self-hosting) or wait for the announcement in `/llms.txt`.
-
-## Install
-
-Until the package is on PyPI, install straight from this repository:
-
-```
-# Claude Code
-claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- uvx --from git+https://github.com/KJdayo/janction-render janction-render-mcp
-
-# or with pipx
-pipx install git+https://github.com/KJdayo/janction-render
-claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- janction-render-mcp
-```
-
-Codex: add to `~/.codex/config.toml`
-
-```toml
-[mcp_servers.janction-render]
-command = "uvx"
-args = ["--from", "git+https://github.com/KJdayo/janction-render", "janction-render-mcp"]
-env = { JANCTION_RENDER_SERVER = "https://render.janction.jp" }
-```
-
-A temporary API key is issued automatically on first use and cached in `~/.janction-render.json`; set
-`JANCTION_RENDER_API_KEY` to pin one (quota and, later, credit belong to the key).
-
-Then, in Claude Code:
-
-> Build a small street scene in Blender with a camera fly-through and render a preview with janction-render.
-
-## Tools
-
-| tool | what |
-|---|---|
-| `scene_info(scene_path | scene_script | scene_id)` | cameras, frame range, fps, resolution, objects, lights, missing files. No render. |
-| `render_preview(..., frames="1-24")` | up to 4 frames (720p budget) tiled with frame labels; returns the image inline |
-| `render_final(scene_id, frame_start, frame_end, width, height, samples, fps, output)` | PNG or MP4; returns job_id + estimate |
-| `render_status(job_id)` / `render_download(job_id)` / `render_cancel(job_id)` | progress, files, cancel |
-| `billing(topup_yen=0)` | free-beta quota (used today, daily limit, reset time); later balance and top-up link |
-| `render_info()` | server, workers online, queue |
-
-CLI: `janction-render inspect|preview|render|status|download|cancel|jobs|balance|topup|info`.
-
-## Writing a scene script
-
-```python
-import bpy, math
-for ob in list(bpy.data.objects):
-    bpy.data.objects.remove(ob, do_unlink=True)
-scene = bpy.context.scene
-scene.frame_start, scene.frame_end = 1, 24
-bpy.ops.mesh.primitive_monkey_add(location=(0, 0, 1))
-cam = bpy.data.objects.new("Camera", bpy.data.cameras.new("Camera"))
-scene.collection.objects.link(cam); scene.camera = cam
-cam.location = (6, -6, 4); cam.rotation_euler = (math.radians(60), 0, math.radians(45))
-sun = bpy.data.objects.new("Sun", bpy.data.lights.new("Sun", "SUN"))
-scene.collection.objects.link(sun)
-```
-
-The service sets engine (Cycles), resolution, samples and denoising; your script sets the scene, camera and frame range.
-Scripts run in an isolated container with no network. See `samples/cube_scene.py`.
-
-## HTTP API
-
-```
-POST /v1/keys                                   -> {api_key}         (header X-API-Key afterwards)
-POST /v1/files  multipart "file" (.blend|.py)   -> {scene_id}
-POST /v1/jobs   {scene_id, kind: info|preview|final, frames|frame_start/frame_end, width, height, samples, camera, fps, output}
-GET  /v1/jobs/{id}      status, progress, artifacts[], cost, warnings, info      DELETE /v1/jobs/{id}  cancel
-GET  /v1/jobs/{id}/artifacts/{name}             PNG / MP4
-POST /v1/billing/checkout {amount_yen} -> {checkout_url}   POST /v1/billing/sync   GET /v1/ledger   GET /v1/me
-GET  /llms.txt  /terms  /privacy  /tokushoho
-```
-
-During the free beta a `429 quota_exceeded` response carries `resets_at`; a `400 beta_limit` means the job is too big
-(split it). Once paid plans start, a `402 payment_required` response carries `checkout_url`.
-
-## Self-hosting
-
-The server (FastAPI + SQLite) and the worker (Blender in disposable Docker containers, `--network none --cap-drop ALL`)
-live in the internal repository and are not part of this package yet. This repository holds the client side: MCP server, CLI,
-HTTP client and samples.
-
-## License
-
-MIT (see LICENSE). Operated by JasmyLab Inc.

janction_render-0.1.0/janction_render.egg-info/PKG-INFO

@@ -1,118 +0,0 @@
-Metadata-Version: 2.4
-Name: janction-render
-Version: 0.1.0
-Summary: Render Blender scenes on JANCTION GPUs straight from terminal AI agents (Claude Code, Codex): MCP server + CLI
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: requests>=2.31
-Requires-Dist: mcp>=1.10
-Provides-Extra: mcp
-Requires-Dist: mcp>=1.10; extra == "mcp"
-Provides-Extra: dev
-Requires-Dist: pytest>=8; extra == "dev"
-Dynamic: license-file
-
-# JANCTION Render
-
-Render Blender scenes on JANCTION GPUs straight from a terminal AI agent (Claude Code, Codex, or any MCP client).
-Use it when you are building 3DCG with Blender and have no GPU, or rendering locally is slow.
-
-- Input: a `.blend` file, or a **bpy Python script that builds the scene** (no local Blender needed).
-- `scene_info` reads the scene without rendering (cameras, frame range, missing files).
-- `render_preview` returns 1-4 low-cost frames tiled in one image within seconds, so the agent can look, fix, and repeat.
-- `render_final` renders the frames on GPUs and joins them into an MP4.
-- Free beta: no charges. Each key gets 10 GPU-minutes per day; a final render is up to 240 frames at 1080p.
-  Paid plans (per GPU second, prepaid credit) will be announced on the service page before they start.
-- Inputs and results are deleted 24 hours after last use and are never used for training.
-
-## Status
-
-Free beta. The public endpoint is `https://render.janction.jp` (opening; check `/v1/health`). Until it answers, you can
-self-host the server and worker from the internal package (see Self-hosting) or wait for the announcement in `/llms.txt`.
-
-## Install
-
-Until the package is on PyPI, install straight from this repository:
-
-```
-# Claude Code
-claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- uvx --from git+https://github.com/KJdayo/janction-render janction-render-mcp
-
-# or with pipx
-pipx install git+https://github.com/KJdayo/janction-render
-claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- janction-render-mcp
-```
-
-Codex: add to `~/.codex/config.toml`
-
-```toml
-[mcp_servers.janction-render]
-command = "uvx"
-args = ["--from", "git+https://github.com/KJdayo/janction-render", "janction-render-mcp"]
-env = { JANCTION_RENDER_SERVER = "https://render.janction.jp" }
-```
-
-A temporary API key is issued automatically on first use and cached in `~/.janction-render.json`; set
-`JANCTION_RENDER_API_KEY` to pin one (quota and, later, credit belong to the key).
-
-Then, in Claude Code:
-
-> Build a small street scene in Blender with a camera fly-through and render a preview with janction-render.
-
-## Tools
-
-| tool | what |
-|---|---|
-| `scene_info(scene_path | scene_script | scene_id)` | cameras, frame range, fps, resolution, objects, lights, missing files. No render. |
-| `render_preview(..., frames="1-24")` | up to 4 frames (720p budget) tiled with frame labels; returns the image inline |
-| `render_final(scene_id, frame_start, frame_end, width, height, samples, fps, output)` | PNG or MP4; returns job_id + estimate |
-| `render_status(job_id)` / `render_download(job_id)` / `render_cancel(job_id)` | progress, files, cancel |
-| `billing(topup_yen=0)` | free-beta quota (used today, daily limit, reset time); later balance and top-up link |
-| `render_info()` | server, workers online, queue |
-
-CLI: `janction-render inspect|preview|render|status|download|cancel|jobs|balance|topup|info`.
-
-## Writing a scene script
-
-```python
-import bpy, math
-for ob in list(bpy.data.objects):
-    bpy.data.objects.remove(ob, do_unlink=True)
-scene = bpy.context.scene
-scene.frame_start, scene.frame_end = 1, 24
-bpy.ops.mesh.primitive_monkey_add(location=(0, 0, 1))
-cam = bpy.data.objects.new("Camera", bpy.data.cameras.new("Camera"))
-scene.collection.objects.link(cam); scene.camera = cam
-cam.location = (6, -6, 4); cam.rotation_euler = (math.radians(60), 0, math.radians(45))
-sun = bpy.data.objects.new("Sun", bpy.data.lights.new("Sun", "SUN"))
-scene.collection.objects.link(sun)
-```
-
-The service sets engine (Cycles), resolution, samples and denoising; your script sets the scene, camera and frame range.
-Scripts run in an isolated container with no network. See `samples/cube_scene.py`.
-
-## HTTP API
-
-```
-POST /v1/keys                                   -> {api_key}         (header X-API-Key afterwards)
-POST /v1/files  multipart "file" (.blend|.py)   -> {scene_id}
-POST /v1/jobs   {scene_id, kind: info|preview|final, frames|frame_start/frame_end, width, height, samples, camera, fps, output}
-GET  /v1/jobs/{id}      status, progress, artifacts[], cost, warnings, info      DELETE /v1/jobs/{id}  cancel
-GET  /v1/jobs/{id}/artifacts/{name}             PNG / MP4
-POST /v1/billing/checkout {amount_yen} -> {checkout_url}   POST /v1/billing/sync   GET /v1/ledger   GET /v1/me
-GET  /llms.txt  /terms  /privacy  /tokushoho
-```
-
-During the free beta a `429 quota_exceeded` response carries `resets_at`; a `400 beta_limit` means the job is too big
-(split it). Once paid plans start, a `402 payment_required` response carries `checkout_url`.
-
-## Self-hosting
-
-The server (FastAPI + SQLite) and the worker (Blender in disposable Docker containers, `--network none --cap-drop ALL`)
-live in the internal repository and are not part of this package yet. This repository holds the client side: MCP server, CLI,
-HTTP client and samples.
-
-## License
-
-MIT (see LICENSE). Operated by JasmyLab Inc.