janction-render 0.1.0__py3-none-any.whl

janction_render/__init__.py

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

janction_render/cli.py

@@ -0,0 +1,264 @@
+"""コマンド。MCP と同じ機能を同じ受付で（要件 F-01）。
+
+    janction-render preview scene.py                      # 試し描き 1 コマ → PNG
+    janction-render render scene.blend --frames 1-240     # 仕上げ → MP4（1 コマなら PNG）
+    janction-render status JOB
+    janction-render download JOB --out DIR [--wait 600]
+    janction-render cancel JOB
+    janction-render jobs
+    janction-render info
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+from .client import Client, ClientError, parse_frames
+
+
+def _j(obj: Any) -> str:
+    return json.dumps(obj, ensure_ascii=False, indent=2)
+
+
+def _size(s: str) -> tuple[int, int]:
+    try:
+        w, h = s.lower().split("x")
+        return int(w), int(h)
+    except ValueError:
+        raise argparse.ArgumentTypeError("size must look like 1920x1080")
+
+
+def _frames(s: str) -> tuple[int, int]:
+    try:
+        if "-" in s:
+            a, b = s.split("-", 1)
+            return int(a), int(b)
+        return int(s), int(s)
+    except ValueError:
+        raise argparse.ArgumentTypeError("frames must look like 1-240 or 12")
+
+
+def _progress(j: dict[str, Any]) -> None:
+    p = j["progress"]
+    print(f"  {j['status']}: {p['frames_done']}/{p['frames_total']} frames"
+          + (f", {p['queue_ahead']} chunks ahead" if p["queue_ahead"] else ""), file=sys.stderr)
+
+
+def _scene(c: Client, args: argparse.Namespace) -> str:
+    if args.scene_id:
+        return args.scene_id
+    if not args.scene:
+        raise SystemExit("give a scene file (.blend or .py) or --scene-id")
+    up = c.upload(args.scene)
+    print(f"uploaded {up['name']} -> scene_id {up['scene_id']}", file=sys.stderr)
+    return up["scene_id"]
+
+
+def cmd_inspect(c: Client, args: argparse.Namespace) -> int:
+    sid = _scene(c, args)
+    j = c.submit(sid, kind="info")
+    if j["status"] != "done":
+        print(f"job {j['job_id']} queued (reads the scene, no render)", file=sys.stderr)
+        j = c.wait(j["job_id"], timeout=args.timeout, on_progress=_progress)
+    if j["status"] != "done":
+        print(_j({k: j.get(k) for k in ("job_id", "status", "error", "log_tail")}))
+        return 1
+    info = dict(j.get("info") or {})
+    info["scene_id"] = sid
+    if j.get("warnings"):
+        info["blender_warnings"] = j["warnings"]
+    print(_j(info))
+    return 0
+
+
+def cmd_preview(c: Client, args: argparse.Namespace) -> int:
+    sid = _scene(c, args)
+    w, h = args.size
+    frames = parse_frames(args.frames, default=args.frame)
+    j = c.submit(sid, kind="preview", frames=frames, camera=args.camera, width=w, height=h,
+                 samples=args.samples)
+    print(f"job {j['job_id']} queued: frames {frames} (estimate ~{j['estimate']['seconds']}s)", file=sys.stderr)
+    j = c.wait(j["job_id"], timeout=args.timeout, on_progress=_progress)
+    if j["status"] != "done":
+        print(_j({k: j.get(k) for k in ("job_id", "status", "error", "log_tail", "warnings")}))
+        return 1
+    out = Path(args.out) if args.out else Path("render_out") / j["job_id"]
+    paths = c.download(j["job_id"], out)
+    print(_j({"job_id": j["job_id"], "scene_id": sid, "frames": frames, "files": [str(p) for p in paths],
+              "warnings": j.get("warnings") or [], "gpu_seconds": j["gpu_seconds"], "device": j["device"],
+              "expires_at": j["expires_at"]}))
+    return 0
+
+
+def cmd_render(c: Client, args: argparse.Namespace) -> int:
+    sid = _scene(c, args)
+    w, h = args.size
+    fs, fe = args.frames
+    j = c.submit(sid, kind="final", frame_start=fs, frame_end=fe, width=w, height=h,
+                 samples=args.samples, fps=args.fps, output=args.output, camera=args.camera)
+    print(f"job {j['job_id']} queued: {fe - fs + 1} frames in {j['progress']['chunks_total']} chunks, "
+          f"estimate ~{j['estimate']['seconds']}s", file=sys.stderr)
+    if not args.wait:
+        print(_j({"job_id": j["job_id"], "scene_id": sid, "estimate": j["estimate"]}))
+        return 0
+    j = c.wait(j["job_id"], timeout=args.timeout, on_progress=_progress)
+    if j["status"] != "done":
+        print(_j({k: j.get(k) for k in ("job_id", "status", "error", "log_tail")}))
+        return 1
+    out = Path(args.out) if args.out else Path("render_out") / j["job_id"]
+    paths = c.download(j["job_id"], out)
+    print(_j({"job_id": j["job_id"], "scene_id": sid, "files": [str(p) for p in paths],
+              "warnings": j.get("warnings") or [], "gpu_seconds": j["gpu_seconds"], "device": j["device"],
+              "expires_at": j["expires_at"]}))
+    return 0
+
+
+def cmd_status(c: Client, args: argparse.Namespace) -> int:
+    print(_j(c.job(args.job)))
+    return 0
+
+
+def cmd_download(c: Client, args: argparse.Namespace) -> int:
+    j = c.wait(args.job, timeout=args.wait, on_progress=_progress) if args.wait else c.job(args.job)
+    out = Path(args.out) if args.out else Path("render_out") / args.job
+    paths = c.download(args.job, out)
+    print(_j({"job_id": args.job, "status": j["status"], "files": [str(p) for p in paths]}))
+    return 0 if j["status"] == "done" else 1
+
+
+def cmd_cancel(c: Client, args: argparse.Namespace) -> int:
+    j = c.cancel(args.job)
+    print(_j({"job_id": j["job_id"], "status": j["status"]}))
+    return 0
+
+
+def cmd_jobs(c: Client, args: argparse.Namespace) -> int:
+    rows = c.jobs(args.limit)
+    for j in rows:
+        p = j["progress"]
+        print(f"{j['job_id']}  {j['kind']:<7} {j['status']:<9} {j['frame_start']}-{j['frame_end']}  "
+              f"{p['frames_done']}/{p['frames_total']}  gpu {j['gpu_seconds']}s")
+    return 0
+
+
+def cmd_info(c: Client, args: argparse.Namespace) -> int:
+    print(_j({"server": c.server, "health": c.health(), "me": c.me()}))
+    return 0
+
+
+def cmd_balance(c: Client, args: argparse.Namespace) -> int:
+    me = c.me()
+    synced = c.billing_sync() if me["billing"]["enabled"] else {}
+    me = c.me()
+    print(_j({"balance_yen": me["balance_yen"], "free_previews_left": me["free_previews_left"],
+              "billing": me["billing"], "just_credited": synced.get("credited", []),
+              "ledger": c.ledger(args.limit)["entries"]}))
+    return 0
+
+
+def cmd_topup(c: Client, args: argparse.Namespace) -> int:
+    co = c.checkout(args.yen)
+    print(f"open this page in a browser and pay: {co['checkout_url']}", file=sys.stderr)
+    print(_j(co))
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="janction-render",
+                                description="Render Blender scenes on JANCTION GPUs from the terminal.")
+    p.add_argument("--server", default=None, help="server URL (default: JANCTION_RENDER_SERVER or http://127.0.0.1:8340)")
+    p.add_argument("--key", default=None, help="API key (default: JANCTION_RENDER_API_KEY or an auto-issued temporary key)")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    s = sub.add_parser("inspect", help="read the scene without rendering (cameras, frame range, missing files)")
+    s.add_argument("scene", nargs="?", help=".blend file or bpy Python script")
+    s.add_argument("--scene-id", default=None, help="reuse an uploaded scene")
+    s.add_argument("--timeout", type=float, default=180)
+    s.set_defaults(fn=cmd_inspect)
+
+    s = sub.add_parser("preview", help="render 1-4 preview frames (fast, up to 720p; several frames are tiled)")
+    s.add_argument("scene", nargs="?", help=".blend file or bpy Python script")
+    s.add_argument("--scene-id", default=None, help="reuse an uploaded scene")
+    s.add_argument("--frame", type=int, default=1)
+    s.add_argument("--frames", default="", help="e.g. 1,8,16,24 or 1-24 (4 evenly spaced) -> one tiled image")
+    s.add_argument("--camera", default=None)
+    s.add_argument("--size", type=_size, default=(1280, 720))
+    s.add_argument("--samples", type=int, default=16)
+    s.add_argument("--out", default=None)
+    s.add_argument("--timeout", type=float, default=300)
+    s.set_defaults(fn=cmd_preview)
+
+    s = sub.add_parser("render", help="render final frames (MP4 or PNG)")
+    s.add_argument("scene", nargs="?")
+    s.add_argument("--scene-id", default=None)
+    s.add_argument("--frames", type=_frames, required=True, help="e.g. 1-240 or 12")
+    s.add_argument("--size", type=_size, default=(1920, 1080))
+    s.add_argument("--samples", type=int, default=128)
+    s.add_argument("--fps", type=int, default=24)
+    s.add_argument("--output", choices=["auto", "png", "mp4"], default="auto")
+    s.add_argument("--camera", default=None)
+    s.add_argument("--out", default=None)
+    s.add_argument("--wait", action="store_true", help="wait until done and download")
+    s.add_argument("--timeout", type=float, default=7200)
+    s.set_defaults(fn=cmd_render)
+
+    s = sub.add_parser("status")
+    s.add_argument("job")
+    s.set_defaults(fn=cmd_status)
+
+    s = sub.add_parser("download")
+    s.add_argument("job")
+    s.add_argument("--out", default=None)
+    s.add_argument("--wait", type=float, default=0, help="seconds to wait for the job first")
+    s.set_defaults(fn=cmd_download)
+
+    s = sub.add_parser("cancel")
+    s.add_argument("job")
+    s.set_defaults(fn=cmd_cancel)
+
+    s = sub.add_parser("jobs")
+    s.add_argument("--limit", type=int, default=20)
+    s.set_defaults(fn=cmd_jobs)
+
+    s = sub.add_parser("info")
+    s.set_defaults(fn=cmd_info)
+
+    s = sub.add_parser("balance", help="credit balance, price, and recent ledger (also confirms payments)")
+    s.add_argument("--limit", type=int, default=20)
+    s.set_defaults(fn=cmd_balance)
+
+    s = sub.add_parser("topup", help="get a Stripe checkout link to add credit")
+    s.add_argument("--yen", type=int, default=None, help="amount (default: the minimum)")
+    s.set_defaults(fn=cmd_topup)
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    c = Client(server=args.server, api_key=args.key, client="cli")
+    try:
+        return int(args.fn(c, args))
+    except ClientError as exc:
+        if exc.status == 429 and exc.error == "quota_exceeded":
+            print(f"quota: {exc.detail}", file=sys.stderr)
+            print(_j({k: exc.extra.get(k) for k in ("scope", "gpu_seconds_used_today", "gpu_seconds_per_day", "resets_at")}))
+            return 4
+        pay = exc.payment()
+        if pay:
+            print(f"payment required: {exc.detail}", file=sys.stderr)
+            print(f"open this page in a browser and pay, then run the command again: {pay['checkout_url']}",
+                  file=sys.stderr)
+            print(_j(pay))
+            return 3
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+    except (FileNotFoundError, ValueError) as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

janction_render/client.py

@@ -0,0 +1,249 @@
+"""受付を呼ぶ側の共通部分。MCP とコマンドの両方がこれを使う（要件 F-01）。
+
+環境変数:
+    JANCTION_RENDER_SERVER   受付の URL（既定 http://127.0.0.1:8340）
+    JANCTION_RENDER_API_KEY  API キー。無ければ受付に一時キーをもらい ~/.janction-render.json に覚える
+"""
+from __future__ import annotations
+
+import json
+import os
+import time
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+import requests
+
+DEFAULT_SERVER = "http://127.0.0.1:8340"
+CACHE = Path.home() / ".janction-render.json"
+
+
+def parse_frames(spec: str, default: int = 1, count: int = 4) -> list[int]:
+    """試し描きのコマの指定を配列にする。
+
+    '1,8,16,24' → そのまま／'1-24' → 両端を含む count コマを等間隔で／'12' → [12]／'' → [default]
+    """
+    s = (spec or "").strip()
+    if not s:
+        return [int(default)]
+    if "," in s:
+        vals = [int(x) for x in s.split(",") if x.strip()]
+    elif "-" in s:
+        a, b = s.split("-", 1)
+        a, b = int(a), int(b)
+        if b < a:
+            raise ValueError("frames: end must be >= start")
+        n = min(count, b - a + 1)
+        vals = [a + round(i * (b - a) / (n - 1)) for i in range(n)] if n > 1 else [a]
+    else:
+        vals = [int(s)]
+    out: list[int] = []
+    for v in vals:
+        if v < 0:
+            raise ValueError("frames must be >= 0")
+        if v not in out:
+            out.append(v)
+    return out
+
+
+class ClientError(RuntimeError):
+    def __init__(self, status: int, error: str, detail: str, extra: Optional[dict[str, Any]] = None):
+        super().__init__(f"{error}: {detail}" if detail else error)
+        self.status = status
+        self.error = error
+        self.detail = detail
+        self.extra = extra or {}   # 402 のときは checkout_url / needed_yen / balance_yen など
+
+    def payment(self) -> Optional[dict[str, Any]]:
+        """残高不足（402）なら、決済ページのリンクなどをまとめて返す。"""
+        if self.status != 402:
+            return None
+        out = {"payment_required": True, "detail": self.detail,
+               **{k: self.extra.get(k) for k in ("needed_yen", "balance_yen", "topup_yen", "checkout_url",
+                                                 "session_id", "yen_per_gpu_second", "how")}}
+        if self.extra.get("accepts"):
+            # x402（USDC）でも払える受付。対応しているエージェントは accepts から X-PAYMENT を組む
+            out["x402"] = {"x402Version": self.extra.get("x402Version"), "accepts": self.extra["accepts"],
+                           "how": self.extra.get("how_x402")}
+        return out
+
+
+class Client:
+    def __init__(self, server: Optional[str] = None, api_key: Optional[str] = None, client: str = "") -> None:
+        from . import __version__
+
+        self.server = (server or os.environ.get("JANCTION_RENDER_SERVER") or DEFAULT_SERVER).rstrip("/")
+        self._key = (api_key or os.environ.get("JANCTION_RENDER_API_KEY") or "").strip() or None
+        self.s = requests.Session()
+        # 受付に名乗る（どの入口から来たかを数える。個人を特定するものは入れない）
+        self.s.headers["X-Client"] = f"{client or 'api'} {__version__}"
+
+    # ---- 鍵 ----------------------------------------------------------------
+
+    def key(self) -> str:
+        if self._key:
+            return self._key
+        cache = self._read_cache()
+        cached = cache.get(self.server)
+        if cached:
+            self._key = cached
+            return cached
+        r = self.s.post(f"{self.server}/v1/keys", json={"label": self.s.headers.get("X-Client", "auto")}, timeout=15)
+        self._raise(r)
+        self._key = r.json()["api_key"]
+        cache[self.server] = self._key
+        self._write_cache(cache)
+        return self._key
+
+    def forget_key(self) -> None:
+        cache = self._read_cache()
+        cache.pop(self.server, None)
+        self._write_cache(cache)
+        self._key = None
+
+    @staticmethod
+    def _read_cache() -> dict[str, str]:
+        try:
+            data = json.loads(CACHE.read_text(encoding="utf-8"))
+            return data if isinstance(data, dict) else {}
+        except (OSError, ValueError):
+            return {}
+
+    @staticmethod
+    def _write_cache(cache: dict[str, str]) -> None:
+        try:
+            CACHE.write_text(json.dumps(cache, indent=1), encoding="utf-8")
+            try:
+                os.chmod(CACHE, 0o600)
+            except OSError:
+                pass
+        except OSError:
+            pass
+
+    # ---- 共通 --------------------------------------------------------------
+
+    @staticmethod
+    def _raise(r: requests.Response) -> None:
+        if r.status_code < 400:
+            return
+        try:
+            body = r.json()
+        except ValueError:
+            raise ClientError(r.status_code, f"http_{r.status_code}", r.text[:300])
+        raise ClientError(r.status_code, str(body.get("error", r.status_code)), str(body.get("detail", "")),
+                          extra=body if isinstance(body, dict) else None)
+
+    def _headers(self) -> dict[str, str]:
+        return {"X-API-Key": self.key()}
+
+    def _req(self, method: str, path: str, timeout: float = 30.0, **kw: Any) -> Any:
+        r = self.s.request(method, f"{self.server}{path}", headers=self._headers(), timeout=timeout, **kw)
+        if r.status_code == 401 and not os.environ.get("JANCTION_RENDER_API_KEY"):
+            # 覚えていた一時キーが受付側で消えた（受付の作り直しなど）。1 回だけ取り直す。
+            self.forget_key()
+            r = self.s.request(method, f"{self.server}{path}", headers=self._headers(), timeout=timeout, **kw)
+        self._raise(r)
+        return r.json()
+
+    # ---- 機能 --------------------------------------------------------------
+
+    def health(self) -> dict[str, Any]:
+        r = self.s.get(f"{self.server}/v1/health", timeout=10)
+        self._raise(r)
+        return r.json()
+
+    def me(self) -> dict[str, Any]:
+        return self._req("GET", "/v1/me")
+
+    def upload(self, path: str | Path) -> dict[str, Any]:
+        p = Path(path)
+        if not p.is_file():
+            raise FileNotFoundError(f"{p} is not a file")
+        if p.suffix.lower() not in (".blend", ".py"):
+            raise ValueError("scene must be a .blend file or a Blender Python script (.py)")
+        with p.open("rb") as fh:
+            r = self.s.post(f"{self.server}/v1/files", headers=self._headers(),
+                            files={"file": (p.name, fh, "application/octet-stream")}, timeout=1800)
+        self._raise(r)
+        return r.json()
+
+    def upload_text(self, name: str, text: str) -> dict[str, Any]:
+        """文字列で受け取った bpy スクリプトを、そのままシーンとして送る（ファイルを作らなくてよい）。"""
+        import tempfile
+
+        if not name.lower().endswith(".py"):
+            name = "scene.py"
+        if not text.strip():
+            raise ValueError("the script is empty")
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / Path(name).name
+            p.write_text(text, encoding="utf-8")
+            return self.upload(p)
+
+    def submit(self, scene_id: str, **params: Any) -> dict[str, Any]:
+        body = {"scene_id": scene_id}
+        body.update({k: v for k, v in params.items() if v is not None})
+        return self._req("POST", "/v1/jobs", json=body)
+
+    def job(self, job_id: str) -> dict[str, Any]:
+        return self._req("GET", f"/v1/jobs/{job_id}")
+
+    def jobs(self, limit: int = 20) -> list[dict[str, Any]]:
+        return self._req("GET", f"/v1/jobs?limit={int(limit)}")["jobs"]
+
+    def cancel(self, job_id: str) -> dict[str, Any]:
+        return self._req("DELETE", f"/v1/jobs/{job_id}")
+
+    # ---- 決済 --------------------------------------------------------------
+
+    def checkout(self, amount_yen: Optional[int] = None) -> dict[str, Any]:
+        """クレジットをチャージする決済ページのリンクを作る。"""
+        body = {"amount_yen": int(amount_yen)} if amount_yen else {}
+        return self._req("POST", "/v1/billing/checkout", json=body)
+
+    def billing_sync(self) -> dict[str, Any]:
+        """払い終わった決済を確かめて残高に足す（戻り先のページを開かなかったときの保険）。"""
+        return self._req("POST", "/v1/billing/sync", timeout=60)
+
+    def ledger(self, limit: int = 50) -> dict[str, Any]:
+        return self._req("GET", f"/v1/ledger?limit={int(limit)}")
+
+    def wait(self, job_id: str, timeout: float, interval: float = 2.0,
+             on_progress: Optional[Callable[[dict[str, Any]], None]] = None) -> dict[str, Any]:
+        """done / failed / canceled になるまで待つ。上限を過ぎたらそのときの状態を返す。"""
+        deadline = time.monotonic() + timeout
+        last_key = None
+        while True:
+            j = self.job(job_id)
+            key = (j["status"], j["progress"]["frames_done"])
+            if on_progress and key != last_key:
+                on_progress(j)
+                last_key = key
+            if j["status"] in ("done", "failed", "canceled") or time.monotonic() > deadline:
+                return j
+            time.sleep(interval)
+
+    def download(self, job_id: str, out_dir: str | Path, only: Optional[list[str]] = None) -> list[Path]:
+        """成果物を out_dir に落とす。only を渡せばその名前だけ。"""
+        j = self.job(job_id)
+        out = Path(out_dir)
+        out.mkdir(parents=True, exist_ok=True)
+        paths: list[Path] = []
+        from urllib.parse import urlsplit
+
+        for a in j["artifacts"]:
+            if only and a["name"] not in only:
+                continue
+            # 受付が返す URL は公開 URL の土台で組まれている。自分がつないだ先（SSH トンネルなど）でも
+            # 落とせるように、パスだけを取り出して自分の server に付け直す
+            parts = urlsplit(a["url"])
+            path = parts.path + (f"?{parts.query}" if parts.query else "")
+            url = f"{self.server}{path}" if parts.path.startswith("/v1/") else a["url"]
+            with self.s.get(url, headers=self._headers(), stream=True, timeout=600) as r:
+                self._raise(r)
+                dest = out / a["name"]
+                with dest.open("wb") as fh:
+                    for chunk in r.iter_content(1024 * 1024):
+                        fh.write(chunk)
+            paths.append(dest)
+        return paths

janction_render/mcp_server.py

@@ -0,0 +1,358 @@
+"""JANCTION Render の MCP サーバー（Claude Code・Codex などから使う）。
+
+登録:
+    claude mcp add janction-render -- python /path/to/janction_render/mcp_server.py
+    （または pip install 後: claude mcp add janction-render -- janction-render-mcp）
+
+環境変数:
+    JANCTION_RENDER_SERVER   受付の URL（既定 http://127.0.0.1:8340）
+    JANCTION_RENDER_API_KEY  API キー（無ければ一時キーを自動で取る）
+    JANCTION_RENDER_OUT      落とし先の親フォルダ（既定 ~/janction-render）
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+if __package__ in (None, ""):
+    # ファイルとして直接起動されたとき（claude mcp add ... server.py）
+    sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+try:
+    from mcp.server.mcpserver import Image, MCPServer
+except ImportError:  # mcp 1.x
+    from mcp.server.fastmcp import FastMCP as MCPServer, Image  # type: ignore
+
+from janction_render.client import Client, ClientError, parse_frames
+
+PREVIEW_WAIT_S = 240.0
+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."
+    ),
+)
+
+
+def _log(msg: str) -> None:
+    print(f"[janction-render] {msg}", file=sys.stderr, flush=True)
+
+
+def _client() -> Client:
+    return Client(client="mcp")
+
+
+def _out_root() -> Path:
+    return Path(os.environ.get("JANCTION_RENDER_OUT") or (Path.home() / "janction-render"))
+
+
+def _j(obj: Any) -> str:
+    return json.dumps(obj, ensure_ascii=False, indent=2)
+
+
+def _quota_block(exc: ClientError) -> Optional[dict[str, Any]]:
+    """無料ベータの 1 日の上限に当たった（429 quota_exceeded）ときの返事。"""
+    if exc.status != 429 or exc.error != "quota_exceeded":
+        return None
+    x = exc.extra
+    return {"quota_exceeded": True, "detail": exc.detail, "scope": x.get("scope"),
+            "gpu_seconds_used_today": x.get("gpu_seconds_used_today"), "gpu_seconds_per_day": x.get("gpu_seconds_per_day"),
+            "resets_at": x.get("resets_at"),
+            "next": "tell the user today's free GPU time is used up and when it resets; a smaller job (fewer frames, "
+                    "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()
+    if p is None:
+        return None
+    p["next"] = ("show checkout_url to the user and ask them to pay in a browser (Stripe; the rest stays as credit); "
+                 "after they paid, call billing() to confirm the balance, then submit the same job again")
+    return p
+
+
+def _resolve_scene(c: Client, scene_path: str, scene_id: str, scene_script: str = "") -> str:
+    if scene_id:
+        return scene_id
+    if scene_script.strip():
+        up = c.upload_text("scene.py", scene_script)
+        _log(f"uploaded inline script -> {up['scene_id']} ({up['size']} bytes)")
+        return up["scene_id"]
+    if not scene_path:
+        raise ValueError("pass scene_path (a .blend or a bpy .py script), scene_script (bpy code as text), "
+                         "or scene_id from a previous call")
+    up = c.upload(scene_path)
+    _log(f"uploaded {up['name']} -> {up['scene_id']} ({up['size']} bytes)")
+    return up["scene_id"]
+
+
+@mcp.tool()
+def scene_info(scene_path: str = "", scene_id: str = "", scene_script: str = "") -> str:
+    """Read a Blender scene WITHOUT rendering: cameras (and which is active), frame range and fps,
+    resolution, engine, objects by type, lights, materials, whether it is animated, and any linked
+    files that are missing (textures etc. that would render pink). Takes a few seconds, no GPU.
+
+    Give the scene as scene_path (.blend or .py file), scene_script (bpy Python code as text, no
+    file needed), or scene_id from a previous call. Call this first for a .blend you did not write
+    yourself, or after writing a bpy script to check what it produced. Use the camera names and
+    frame range in render_preview / render_final. Returns scene_id to reuse in the next calls.
+    """
+    c = _client()
+    try:
+        sid = _resolve_scene(c, scene_path, scene_id, scene_script)
+        j = c.submit(sid, kind="info")
+        if j["status"] != "done":
+            j = c.wait(j["job_id"], timeout=INFO_WAIT_S)
+    except (ClientError, ValueError, FileNotFoundError) as exc:
+        return _j({"ok": False, "error": str(exc)})
+    if j["status"] != "done":
+        b = _brief(j)
+        b["hint"] = "still queued (a GPU worker may be busy); call scene_info again in a moment" \
+            if j["status"] in ("queued", "running") else "fix the scene and try again"
+        return _j(b)
+    info = dict(j.get("info") or {})
+    info["scene_id"] = j["scene_id"]
+    if info.get("engine") and info["engine"] != "CYCLES":
+        info["engine_note"] = "JANCTION renders with CYCLES; the scene's engine setting is not used"
+    if j.get("warnings"):
+        info["blender_warnings"] = j["warnings"]
+    if info.get("missing_files"):
+        info["note"] = "missing_files will render pink/black; pack them into the .blend (File > External Data > Pack) or fix the paths"
+    return _j(info)
+
+
+@mcp.tool(structured_output=False)
+def render_preview(
+    scene_path: str = "",
+    scene_id: str = "",
+    scene_script: str = "",
+    frames: str = "",
+    camera: str = "",
+    width: int = 1280,
+    height: int = 720,
+    samples: int = 16,
+    out_dir: str = "",
+) -> list[Any]:
+    """Render a fast, cheap preview of a Blender scene on a JANCTION GPU and show the image.
+
+    Use this when the user is making 3DCG with Blender and wants to see how it looks, but has no
+    GPU or local rendering is slow. Give the scene as scene_path (a .blend file OR a bpy Python
+    script), scene_script (bpy code as text; no file and no local Blender needed), or scene_id
+    from a previous call. frames: '' = frame 1;
+    '12' = one frame; '1,8,16,24' or '1-24' = up to 4 frames tiled in ONE image (2x2, each tile
+    labeled with its frame number) so you can judge camera motion and animation. Same GPU cost as
+    one 720p frame. Quality is deliberately low (up to 1280x720, few samples, denoised).
+    Look at the returned image, fix the scene, preview again; when it looks right, ask the user and
+    call render_final. Returns scene_id (reuse it without re-uploading), job_id, saved PNG paths,
+    Blender warnings (e.g. missing textures), GPU seconds, and the expiry time (24h after last use).
+    """
+    c = _client()
+    try:
+        frame_list = parse_frames(frames)
+        sid = _resolve_scene(c, scene_path, scene_id, scene_script)
+        j = c.submit(sid, kind="preview", frames=frame_list, camera=camera or None,
+                     width=width, height=height, samples=samples)
+        _log(f"preview job {j['job_id']} submitted frames={frame_list}")
+        j = c.wait(j["job_id"], timeout=PREVIEW_WAIT_S)
+    except ClientError as exc:
+        block = _payment_block(exc) or _quota_block(exc)
+        return [_j(block if block else {"ok": False, "error": str(exc)})]
+    except (ValueError, FileNotFoundError) as exc:
+        return [_j({"ok": False, "error": str(exc)})]
+    brief = _brief(j)
+    if j["status"] != "done":
+        brief["hint"] = ("still running: call render_status(job_id) and then render_download"
+                         if j["status"] in ("queued", "running")
+                         else "fix the scene and try again")
+        return [_j(brief)]
+    out = Path(out_dir) if out_dir else _out_root() / j["job_id"]
+    paths = c.download(j["job_id"], out)
+    show = next((p for p in paths if p.name == "sheet.png"), None) or next((p for p in paths if p.suffix == ".png"), None)
+    brief["files"] = [str(p) for p in paths]
+    brief["next"] = ("look at the image; if the scene needs changes, edit it and call render_preview again; "
+                     "if it looks right, ask the user before calling render_final")
+    result: list[Any] = [_j(brief)]
+    if show is not None:
+        result.append(Image(data=show.read_bytes(), format="png"))
+    return result
+
+
+@mcp.tool()
+def render_final(
+    scene_path: str = "",
+    scene_id: str = "",
+    scene_script: str = "",
+    frame_start: int = 1,
+    frame_end: int = 1,
+    width: int = 1920,
+    height: int = 1080,
+    samples: int = 128,
+    fps: int = 24,
+    output: str = "auto",
+    camera: str = "",
+) -> str:
+    """Render the final frames (or a video) of a Blender scene on JANCTION GPUs.
+
+    Call this after the user approved a preview. Pass scene_id from render_preview (or scene_path /
+    scene_script to upload a new .blend / bpy script). frame_start..frame_end are inclusive; several frames are
+    split across GPUs and joined into output.mp4 (output='mp4', fps), a single frame gives a PNG
+    (output='png'; 'auto' picks). Returns job_id and a time estimate right away; the render runs
+    in the background: poll with render_status, then fetch with render_download. Inputs and
+    results are deleted 24 hours after last use, so download them.
+    """
+    c = _client()
+    try:
+        sid = _resolve_scene(c, scene_path, scene_id, scene_script)
+        j = c.submit(sid, kind="final", frame_start=frame_start, frame_end=frame_end,
+                     width=width, height=height, samples=samples, fps=fps, output=output,
+                     camera=camera or None)
+    except ClientError as exc:
+        block = _payment_block(exc) or _quota_block(exc)
+        return _j(block if block else {"ok": False, "error": str(exc)})
+    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)"
+    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."""
+    try:
+        return _j(_brief(_client().job(job_id)))
+    except ClientError as exc:
+        return _j({"ok": False, "error": str(exc)})
+
+
+@mcp.tool()
+def render_download(job_id: str, out_dir: str = "", wait_seconds: int = 0) -> str:
+    """Download a JANCTION render job's files (PNG frames, sheet.png and/or output.mp4) to out_dir
+    (default ~/janction-render/<job_id>). wait_seconds > 0 first waits up to that long for the job
+    to finish. Returns the local file paths."""
+    c = _client()
+    try:
+        j = c.wait(job_id, timeout=float(wait_seconds)) if wait_seconds > 0 else c.job(job_id)
+        if j["status"] != "done" and not j["artifacts"]:
+            b = _brief(j)
+            b["hint"] = "nothing to download yet"
+            return _j(b)
+        out = Path(out_dir) if out_dir else _out_root() / job_id
+        paths = c.download(job_id, out)
+    except ClientError as exc:
+        return _j({"ok": False, "error": str(exc)})
+    b = _brief(j)
+    b["files"] = [str(p) for p in paths]
+    if j["status"] != "done":
+        b["hint"] = "job is not finished; these are the frames ready so far"
+    return _j(b)
+
+
+@mcp.tool()
+def render_cancel(job_id: str) -> str:
+    """Cancel a queued or running JANCTION render job. GPU time after the cancel is not used."""
+    try:
+        return _j(_brief(_client().cancel(job_id)))
+    except ClientError as exc:
+        return _j({"ok": False, "error": str(exc)})
+
+
+@mcp.tool()
+def billing(topup_yen: int = 0) -> str:
+    """Check the account's quota or credit. During the free beta it returns today's GPU-time usage,
+    the daily quota and when it resets (no charges). Once paid plans start: with topup_yen = 0 it
+    confirms any payment the user just made and returns the balance (yen), the price per GPU second
+    and free previews left; with topup_yen > 0 (minimum 500) it returns a Stripe checkout URL to show
+    to the user. Renders are charged by GPU seconds and only for frames that actually rendered."""
+    c = _client()
+    try:
+        if topup_yen > 0:
+            co = c.checkout(topup_yen)
+            return _j({"checkout_url": co["checkout_url"], "amount_yen": co["amount_yen"],
+                       "next": "the user pays at checkout_url in a browser; then call billing() to confirm"})
+        me = c.me()
+        synced: dict[str, Any] = {}
+        if me["billing"]["enabled"]:
+            synced = c.billing_sync()
+            me = c.me()
+        if me.get("quota"):
+            q = me["quota"]
+            return _j({"mode": "free_beta", "note": "no charges during the free beta; daily GPU-time quota per key",
+                       "gpu_seconds_used_today": q["gpu_seconds_used_today"], "gpu_seconds_per_day": q["gpu_seconds_per_day"],
+                       "resets_at": q["resets_at"], "max_frames_per_job": q["max_frames_per_job"],
+                       "max_pixels": q["max_pixels"]})
+        return _j({"balance_yen": me["balance_yen"], "free_previews_left": me["free_previews_left"],
+                   "yen_per_gpu_second": me["billing"]["yen_per_gpu_second"],
+                   "min_topup_yen": me["billing"]["min_topup_yen"], "billing_enabled": me["billing"]["enabled"],
+                   "just_credited": synced.get("credited", []),
+                   "pending_checkout_url": me["billing"]["pending_checkout_url"],
+                   "charged_yen_total": me["charged_yen_total"]})
+    except ClientError as exc:
+        return _j({"ok": False, "error": str(exc)})
+
+
+@mcp.tool()
+def render_info() -> str:
+    """Show the JANCTION Render connection: server URL, whether GPU workers are online, queue
+    length, and this key's usage. Call this if renders seem stuck or before the first render."""
+    c = _client()
+    try:
+        health = c.health()
+        me = c.me()
+    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())})
+
+
+def main() -> None:
+    _log(f"stdio, server={Client().server}")
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

janction_render-0.1.0.dist-info/METADATA

@@ -0,0 +1,118 @@
+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.dist-info/RECORD

@@ -0,0 +1,10 @@
+janction_render/__init__.py,sha256=N4SQoQqiiHbuExcbHjmi7L4yV2niuyv7MQacbN7-_ys,122
+janction_render/cli.py,sha256=sCeuRQozqZMzDvjVscsUeF0gItaa3oBo7877I5AakZU,10810
+janction_render/client.py,sha256=jrK2oLqfJnrLK33CP2I53ThCgVSXjSbBEElTsIDtcSQ,10631
+janction_render/mcp_server.py,sha256=mW87tMVAALOi8zywoBTVluvuyic0ZO4kUhqYicYQHkQ,16108
+janction_render-0.1.0.dist-info/licenses/LICENSE,sha256=CA2hQaY4n7sg6CJ3w976wCrsw0ZpYiFgQI9xUTnmNZs,1106
+janction_render-0.1.0.dist-info/METADATA,sha256=JrqYYUepxZc1wT6ARPNeNcedrpDRBelM-hnqtZmdBsc,5429
+janction_render-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+janction_render-0.1.0.dist-info/entry_points.txt,sha256=wFzcUIGRcRe7pvLb0D2UkRYLZSkSxC5FvUMn1xS_Q9Y,115
+janction_render-0.1.0.dist-info/top_level.txt,sha256=y2LPa34ZfAuOVZzTJHbqRC0daOQ9X4p6iCao60MW940,16
+janction_render-0.1.0.dist-info/RECORD,,

janction_render-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

janction_render-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+janction-render = janction_render.cli:main
+janction-render-mcp = janction_render.mcp_server:main

janction_render-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 JasmyLab Inc. (ジャスミーラボ株式会社)
+
+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.

janction_render-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+janction_render