confyui 0.1.0__py3-none-any.whl

confyui/__init__.py

@@ -0,0 +1,10 @@
+"""KπX sovereign local image generation & editing daemon over ComfyUI."""
+
+# Note: per sovereign standard, package version is defined exclusively in
+# pyproject.toml to eliminate desynchronization risks. Do NOT add __version__ here.
+
+from confyui.client import ComfyClient
+from confyui.config import Config
+from confyui.server import ServerManager
+
+__all__ = ["ComfyClient", "Config", "ServerManager"]

confyui/cli.py

@@ -0,0 +1,203 @@
+"""confyui CLI — Typer-based interface to the sovereign ComfyUI daemon.
+
+Provides `generate` (txt2img), `edit` (img2img), `inpaint`, `status`, `stop`, and `models`.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from confyui.client import ComfyClient
+from confyui.config import Config
+from confyui.server import ServerManager
+
+app = typer.Typer(
+    name="confyui",
+    help="KπX sovereign local image generation & editing daemon over ComfyUI (XPU-first).",
+    no_args_is_help=True,
+)
+console = Console()
+
+
+@app.command()
+def generate(
+    prompt: str = typer.Argument(..., help="Text prompt to generate"),
+    negative: str = typer.Option("", "--negative", "-n", help="Negative prompt"),
+    width: int = typer.Option(512, "--width", "-w", help="Image width in pixels"),
+    height: int = typer.Option(512, "--height", "-h", help="Image height in pixels"),
+    steps: int = typer.Option(20, "--steps", "-s", help="Sampling steps"),
+    cfg: float = typer.Option(7.0, "--cfg", help="Classifier-free guidance scale"),
+    seed: int | None = typer.Option(None, "--seed", help="Random seed for reproducibility"),
+    sampler: str = typer.Option("euler", "--sampler", help="Sampler name (euler, dpmpp_2m, etc.)"),
+    scheduler: str = typer.Option("normal", "--scheduler", help="Scheduler name (normal, karras, etc.)"),
+    model: str | None = typer.Option(None, "--model", "-m", help="Checkpoint filename"),
+    out: Path | None = typer.Option(None, "--out", "-o", help="Destination path for output image"),
+    timeout: float = typer.Option(300.0, "--timeout", help="Max seconds to wait"),
+) -> None:
+    """Generate an image from text (txt2img)."""
+    client = ComfyClient()
+    with console.status("[bold green]Generating image..."):
+        dest = client.generate(
+            prompt=prompt,
+            negative_prompt=negative,
+            width=width,
+            height=height,
+            steps=steps,
+            cfg=cfg,
+            seed=seed,
+            sampler_name=sampler,
+            scheduler=scheduler,
+            model=model,
+            out=out,
+            timeout=timeout,
+        )
+    console.print(f"[bold green]✓[/bold green] Saved: [cyan]{dest}[/cyan] ({dest.stat().st_size:,} bytes)")
+
+
+@app.command()
+def edit(
+    source: Path = typer.Argument(..., help="Path to source image to modify"),
+    prompt: str = typer.Argument(..., help="Text prompt describing the desired modification"),
+    negative: str = typer.Option("", "--negative", "-n", help="Negative prompt"),
+    denoise: float = typer.Option(
+        0.55, "--denoise", "-d", help="Denoising strength (0.0 = untouched, 1.0 = full rewrite)"
+    ),
+    steps: int = typer.Option(20, "--steps", "-s", help="Sampling steps"),
+    cfg: float = typer.Option(7.0, "--cfg", help="Classifier-free guidance scale"),
+    seed: int | None = typer.Option(None, "--seed", help="Random seed for reproducibility"),
+    sampler: str = typer.Option("euler", "--sampler", help="Sampler name"),
+    scheduler: str = typer.Option("normal", "--scheduler", help="Scheduler name"),
+    model: str | None = typer.Option(None, "--model", "-m", help="Checkpoint filename"),
+    out: Path | None = typer.Option(None, "--out", "-o", help="Destination path"),
+    timeout: float = typer.Option(300.0, "--timeout", help="Max seconds to wait"),
+) -> None:
+    """Edit an existing image with a text prompt (img2img)."""
+    client = ComfyClient()
+    with console.status(f"[bold green]Editing {source.name} (denoise={denoise})..."):
+        dest = client.edit(
+            source=source,
+            prompt=prompt,
+            negative_prompt=negative,
+            denoise=denoise,
+            steps=steps,
+            cfg=cfg,
+            seed=seed,
+            sampler_name=sampler,
+            scheduler=scheduler,
+            model=model,
+            out=out,
+            timeout=timeout,
+        )
+    console.print(f"[bold green]✓[/bold green] Saved: [cyan]{dest}[/cyan] ({dest.stat().st_size:,} bytes)")
+
+
+@app.command()
+def inpaint(
+    source: Path = typer.Argument(..., help="Path to source image"),
+    mask: Path = typer.Argument(..., help="Path to binary mask (white = regenerate, black = preserve)"),
+    prompt: str = typer.Argument(..., help="Text prompt for the masked region"),
+    negative: str = typer.Option("", "--negative", "-n", help="Negative prompt"),
+    denoise: float = typer.Option(1.0, "--denoise", "-d", help="Denoising strength for masked region"),
+    steps: int = typer.Option(25, "--steps", "-s", help="Sampling steps"),
+    cfg: float = typer.Option(7.0, "--cfg", help="Classifier-free guidance scale"),
+    seed: int | None = typer.Option(None, "--seed", help="Random seed"),
+    sampler: str = typer.Option("euler", "--sampler", help="Sampler name"),
+    scheduler: str = typer.Option("normal", "--scheduler", help="Scheduler name"),
+    model: str | None = typer.Option(None, "--model", "-m", help="Inpainting checkpoint filename"),
+    out: Path | None = typer.Option(None, "--out", "-o", help="Destination path"),
+    timeout: float = typer.Option(300.0, "--timeout", help="Max seconds to wait"),
+) -> None:
+    """Inpaint a region defined by a mask."""
+    client = ComfyClient()
+    with console.status(f"[bold green]Inpainting {source.name}..."):
+        dest = client.inpaint(
+            source=source,
+            mask=mask,
+            prompt=prompt,
+            negative_prompt=negative,
+            denoise=denoise,
+            steps=steps,
+            cfg=cfg,
+            seed=seed,
+            sampler_name=sampler,
+            scheduler=scheduler,
+            model=model,
+            out=out,
+            timeout=timeout,
+        )
+    console.print(f"[bold green]✓[/bold green] Saved: [cyan]{dest}[/cyan] ({dest.stat().st_size:,} bytes)")
+
+
+@app.command()
+def status() -> None:
+    """Show the status of the ComfyUI background daemon."""
+    mgr = ServerManager()
+    st = mgr.status()
+
+    table = Table(title="confyui Daemon Status")
+    table.add_column("Property", style="bold cyan")
+    table.add_column("Value")
+
+    table.add_row("HTTP Server", "[green]UP[/green]" if st["http_up"] else "[red]DOWN[/red]")
+    table.add_row("Supervisor Process", "[green]ALIVE[/green]" if st["running"] else "[dim]STOPPED[/dim]")
+    table.add_row("PID", str(st["pid"]) if st["pid"] else "—")
+    table.add_row("Base URL", st["base_url"])
+    table.add_row("Idle Timeout", f"{st['idle_timeout_sec']}s")
+
+    rem = st["idle_remaining_sec"]
+    if rem is not None:
+        table.add_row("Idle Remaining", f"{rem}s before auto-shutdown")
+    else:
+        table.add_row("Idle Remaining", "—")
+
+    table.add_row("ComfyUI Dir", st["comfyui_dir"])
+    table.add_row("Log File", st["log_file"])
+
+    console.print(table)
+
+
+@app.command()
+def stop() -> None:
+    """Stop the running ComfyUI daemon and free RAM/VRAM immediately."""
+    mgr = ServerManager()
+    if mgr.stop():
+        console.print("[bold yellow]✓[/bold yellow] ComfyUI daemon stopped.")
+    else:
+        console.print("[dim]ComfyUI daemon is not running.[/dim]")
+
+
+@app.command()
+def models() -> None:
+    """List available checkpoint models in ComfyUI."""
+    client = ComfyClient()
+    ckpts = client.list_checkpoints()
+    if not ckpts:
+        console.print("[yellow]No checkpoints found in ComfyUI checkpoints directory.[/yellow]")
+        return
+
+    table = Table(title="Available Checkpoints")
+    table.add_column("#", style="dim")
+    table.add_column("Model Checkpoint", style="cyan")
+
+    cfg = Config.from_env()
+    for idx, c in enumerate(ckpts, 1):
+        suffix = ""
+        if c == cfg.default_ckpt:
+            suffix = " [bold green](default)[/bold green]"
+        elif c == cfg.default_inpaint_ckpt:
+            suffix = " [bold blue](default inpaint)[/bold blue]"
+        table.add_row(str(idx), c + suffix)
+
+    console.print(table)
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

confyui/client.py

@@ -0,0 +1,248 @@
+"""HTTP client for ComfyUI.
+
+Submits workflows to the REST API, polls execution history, and fetches output images.
+"""
+
+from __future__ import annotations
+
+import shutil
+import time
+import uuid
+from pathlib import Path
+from typing import Any
+
+import httpx
+from PIL import Image
+
+from confyui.config import Config
+from confyui.server import ServerManager
+from confyui.workflows import (
+    build_img2img_workflow,
+    build_inpaint_workflow,
+    build_txt2img_workflow,
+)
+
+
+class ComfyClient:
+    """High-level client for the ComfyUI API."""
+
+    def __init__(self, config: Config | None = None) -> None:
+        self.cfg = config or Config.from_env()
+        self.manager = ServerManager(self.cfg)
+
+    def _client(self, timeout: float = 30.0) -> httpx.Client:
+        return httpx.Client(base_url=self.cfg.base_url, timeout=timeout)
+
+    def list_checkpoints(self) -> list[str]:
+        """List checkpoint files available in ComfyUI."""
+        self.manager.ensure_running()
+        with self._client() as c:
+            r = c.get("/object_info/CheckpointLoaderSimple")
+            r.raise_for_status()
+            data = r.json()
+            try:
+                ckpts = data["CheckpointLoaderSimple"]["input"]["required"]["ckpt_name"][0]
+                return list(ckpts)
+            except (KeyError, IndexError):
+                return []
+
+    def submit_and_wait(
+        self,
+        workflow: dict[str, Any],
+        poll_interval: float = 1.0,
+        timeout: float = 300.0,
+    ) -> list[tuple[str, str]]:
+        """Submit a workflow, wait for completion, and return [(filename, subfolder), ...]."""
+        self.manager.ensure_running()
+        with self._client() as c:
+            # 1. POST prompt
+            r = c.post("/prompt", json={"prompt": workflow})
+            r.raise_for_status()
+            data = r.json()
+            prompt_id = data.get("prompt_id")
+            if not prompt_id:
+                raise RuntimeError(f"ComfyUI did not return a prompt_id: {data}")
+
+            # 2. Poll history
+            start = time.time()
+            deadline = start + timeout
+            while time.time() < deadline:
+                self.manager.touch_activity()
+                hr = c.get(f"/history/{prompt_id}")
+                if hr.status_code == 200:
+                    hdata = hr.json()
+                    if prompt_id in hdata:
+                        entry = hdata[prompt_id]
+                        outputs = entry.get("outputs", {})
+                        # Find SaveImage node outputs (class SaveImage)
+                        images: list[tuple[str, str]] = []
+                        for node_out in outputs.values():
+                            for img in node_out.get("images", []):
+                                fn = img.get("filename")
+                                sub = img.get("subfolder", "")
+                                if fn:
+                                    images.append((fn, sub))
+                        if images:
+                            return images
+                time.sleep(poll_interval)
+
+        raise TimeoutError(f"Workflow {prompt_id} did not finish within {timeout}s.")
+
+    def fetch_image(
+        self,
+        filename: str,
+        subfolder: str = "",
+        dest: Path | None = None,
+    ) -> Path:
+        """Download a generated image from ComfyUI /view."""
+        self.manager.touch_activity()
+        with self._client(timeout=60.0) as c:
+            params = {"filename": filename, "type": "output"}
+            if subfolder:
+                params["subfolder"] = subfolder
+            r = c.get("/view", params=params)
+            r.raise_for_status()
+
+            if dest is None:
+                dest = Path.cwd() / filename
+            dest = Path(dest).expanduser().resolve()
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            dest.write_bytes(r.content)
+            return dest
+
+    def _stage_image(self, source: Path, target_name: str, resize_to: tuple[int, int] | None = None) -> str:
+        """Copy a local image into ComfyUI's input/ directory, optionally pre-resizing."""
+        self.cfg.input_dir.mkdir(parents=True, exist_ok=True)
+        dest = self.cfg.input_dir / target_name
+
+        if resize_to is not None:
+            im = Image.open(source).convert("RGB")
+            im = im.resize(resize_to, Image.Resampling.LANCZOS)
+            im.save(dest)
+        else:
+            shutil.copyfile(source, dest)
+        return target_name
+
+    def generate(
+        self,
+        prompt: str,
+        negative_prompt: str = "",
+        width: int = 512,
+        height: int = 512,
+        steps: int = 20,
+        cfg: float = 7.0,
+        seed: int | None = None,
+        sampler_name: str = "euler",
+        scheduler: str = "normal",
+        model: str | None = None,
+        out: Path | None = None,
+        timeout: float = 300.0,
+    ) -> Path:
+        """txt2img one-shot."""
+        ckpt = model or self.cfg.default_ckpt
+        wf = build_txt2img_workflow(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            width=width,
+            height=height,
+            steps=steps,
+            cfg=cfg,
+            seed=seed,
+            sampler_name=sampler_name,
+            scheduler=scheduler,
+            ckpt_name=ckpt,
+        )
+        images = self.submit_and_wait(wf, timeout=timeout)
+        fn, sub = images[0]
+        return self.fetch_image(fn, sub, dest=out)
+
+    def edit(
+        self,
+        source: Path,
+        prompt: str,
+        negative_prompt: str = "",
+        denoise: float = 0.55,
+        steps: int = 20,
+        cfg: float = 7.0,
+        seed: int | None = None,
+        sampler_name: str = "euler",
+        scheduler: str = "normal",
+        model: str | None = None,
+        out: Path | None = None,
+        resize_to: tuple[int, int] | None = (512, 512),
+        timeout: float = 300.0,
+    ) -> Path:
+        """img2img one-shot."""
+        source = Path(source).expanduser().resolve()
+        if not source.is_file():
+            raise FileNotFoundError(f"Source image not found: {source}")
+
+        uid = uuid.uuid4().hex[:8]
+        staged_name = f"edit_in_{uid}.png"
+        self._stage_image(source, staged_name, resize_to=resize_to)
+
+        ckpt = model or self.cfg.default_ckpt
+        wf = build_img2img_workflow(
+            image_name=staged_name,
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            steps=steps,
+            cfg=cfg,
+            seed=seed,
+            sampler_name=sampler_name,
+            scheduler=scheduler,
+            denoise=denoise,
+            ckpt_name=ckpt,
+        )
+        images = self.submit_and_wait(wf, timeout=timeout)
+        fn, sub = images[0]
+        return self.fetch_image(fn, sub, dest=out)
+
+    def inpaint(
+        self,
+        source: Path,
+        mask: Path,
+        prompt: str,
+        negative_prompt: str = "",
+        denoise: float = 1.0,
+        steps: int = 25,
+        cfg: float = 7.0,
+        seed: int | None = None,
+        sampler_name: str = "euler",
+        scheduler: str = "normal",
+        model: str | None = None,
+        out: Path | None = None,
+        resize_to: tuple[int, int] | None = (512, 512),
+        timeout: float = 300.0,
+    ) -> Path:
+        """Inpainting one-shot."""
+        source = Path(source).expanduser().resolve()
+        mask = Path(mask).expanduser().resolve()
+        if not source.is_file():
+            raise FileNotFoundError(f"Source image not found: {source}")
+        if not mask.is_file():
+            raise FileNotFoundError(f"Mask image not found: {mask}")
+
+        uid = uuid.uuid4().hex[:8]
+        staged_src = f"inpaint_src_{uid}.png"
+        staged_mask = f"inpaint_mask_{uid}.png"
+        self._stage_image(source, staged_src, resize_to=resize_to)
+        self._stage_image(mask, staged_mask, resize_to=resize_to)
+
+        ckpt = model or self.cfg.default_inpaint_ckpt
+        wf = build_inpaint_workflow(
+            image_name=staged_src,
+            mask_name=staged_mask,
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            steps=steps,
+            cfg=cfg,
+            seed=seed,
+            sampler_name=sampler_name,
+            scheduler=scheduler,
+            denoise=denoise,
+            ckpt_name=ckpt,
+        )
+        images = self.submit_and_wait(wf, timeout=timeout)
+        fn, sub = images[0]
+        return self.fetch_image(fn, sub, dest=out)

confyui/config.py

@@ -0,0 +1,103 @@
+"""Central configuration for confyui.
+
+Every value is overridable through environment variables; defaults expand
+$HOME at runtime so no absolute path is ever hardcoded.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+
+def _env_path(name: str, default: Path) -> Path:
+    val = os.environ.get(name)
+    if val:
+        return Path(val).expanduser()
+    return default
+
+
+def _env_int(name: str, default: int) -> int:
+    val = os.environ.get(name)
+    if val:
+        try:
+            return int(val)
+        except ValueError:
+            return default
+    return default
+
+
+@dataclass(frozen=True)
+class Config:
+    """Runtime configuration for the confyui daemon and CLI."""
+
+    comfyui_dir: Path
+    python_bin: Path
+    host: str
+    port: int
+    idle_timeout: int
+    spawn_timeout: int
+    default_ckpt: str
+    default_inpaint_ckpt: str
+    state_dir: Path
+
+    @property
+    def base_url(self) -> str:
+        return f"http://{self.host}:{self.port}"
+
+    @property
+    def pid_file(self) -> Path:
+        return self.state_dir / "comfyui.pid"
+
+    @property
+    def log_file(self) -> Path:
+        return self.state_dir / "comfyui.log"
+
+    @property
+    def input_dir(self) -> Path:
+        return self.comfyui_dir / "input"
+
+    @property
+    def output_dir(self) -> Path:
+        return self.comfyui_dir / "output"
+
+    @property
+    def checkpoints_dir(self) -> Path:
+        return self.comfyui_dir / "models" / "checkpoints"
+
+    @classmethod
+    def from_env(cls) -> Config:
+        home = Path.home()
+        # Default ComfyUI runtime checkout (overridable via CONFYUI_DIR)
+        comfyui_dir = _env_path(
+            "CONFYUI_DIR",
+            home / ".local" / "share" / "confyui" / "ComfyUI",
+        )
+        # Default Python is the one inside the ComfyUI venv if it exists,
+        # otherwise falls back to current python environment.
+        default_py = comfyui_dir / ".venv" / "bin" / "python"
+        python_bin = _env_path("CONFYUI_PYTHON", default_py)
+
+        state_dir = _env_path(
+            "CONFYUI_STATE_DIR",
+            home / ".cache" / "confyui",
+        )
+
+        return cls(
+            comfyui_dir=comfyui_dir,
+            python_bin=python_bin,
+            host=os.environ.get("CONFYUI_HOST", "127.0.0.1"),
+            port=_env_int("CONFYUI_PORT", 8188),
+            idle_timeout=_env_int("CONFYUI_IDLE_TIMEOUT", 1800),
+            spawn_timeout=_env_int("CONFYUI_SPAWN_TIMEOUT", 90),
+            default_ckpt=os.environ.get(
+                "CONFYUI_DEFAULT_CKPT",
+                "Realistic_Vision_V5.1.safetensors",
+            ),
+            default_inpaint_ckpt=os.environ.get(
+                "CONFYUI_INPAINT_CKPT",
+                "Realistic_Vision_V5.1_fp16-no-ema-inpainting.safetensors",
+            ),
+            state_dir=state_dir,
+        )

confyui/server.py

@@ -0,0 +1,264 @@
+"""ComfyUI process lifecycle manager (daemon lazy start + idle watchdog).
+
+Pattern:
+- First generation/edit call checks if ComfyUI is up on `http://{host}:{port}`.
+- If not running, spawns a detached supervisor process in the background.
+- The supervisor runs ComfyUI as a child and monitors activity.
+- A heartbeat file is touched on every request (`~/.cache/confyui/last_activity`).
+- If no heartbeat is received for `idle_timeout` seconds, the supervisor terminates
+  ComfyUI and exits, releasing RAM and VRAM automatically.
+"""
+
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+from confyui.config import Config
+
+
+def _read_pid(path: Path) -> int | None:
+    if not path.is_file():
+        return None
+    try:
+        return int(path.read_text().strip())
+    except (ValueError, OSError):
+        return None
+
+
+def _pid_alive(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+        return True
+    except (OSError, ProcessLookupError):
+        return False
+
+
+class ServerManager:
+    """Manages the background ComfyUI instance."""
+
+    def __init__(self, config: Config | None = None) -> None:
+        self.cfg = config or Config.from_env()
+        self.cfg.state_dir.mkdir(parents=True, exist_ok=True)
+        self._activity_file = self.cfg.state_dir / "last_activity"
+
+    def touch_activity(self) -> None:
+        """Record activity so the idle watchdog resets its timer."""
+        try:
+            self._activity_file.write_text(str(int(time.time())))
+        except OSError:
+            pass
+
+    def is_up(self) -> bool:
+        """Check if ComfyUI HTTP server is answering."""
+        try:
+            r = httpx.get(f"{self.cfg.base_url}/system_stats", timeout=1.5)
+            return r.status_code == 200
+        except (httpx.RequestError, OSError):
+            return False
+
+    def status(self) -> dict[str, Any]:
+        pid = _read_pid(self.cfg.pid_file)
+        alive = pid is not None and _pid_alive(pid)
+        up = self.is_up()
+
+        idle_remaining = None
+        if alive and self._activity_file.is_file():
+            try:
+                last = int(self._activity_file.read_text().strip())
+                elapsed = int(time.time()) - last
+                idle_remaining = max(0, self.cfg.idle_timeout - elapsed)
+            except (ValueError, OSError):
+                pass
+
+        return {
+            "running": alive,
+            "http_up": up,
+            "pid": pid,
+            "base_url": self.cfg.base_url,
+            "idle_timeout_sec": self.cfg.idle_timeout,
+            "idle_remaining_sec": idle_remaining,
+            "comfyui_dir": str(self.cfg.comfyui_dir),
+            "log_file": str(self.cfg.log_file),
+        }
+
+    def stop(self) -> bool:
+        """Stop the supervisor and ComfyUI."""
+        pid = _read_pid(self.cfg.pid_file)
+        if pid is None or not _pid_alive(pid):
+            # Clean up stale pid file if present
+            if self.cfg.pid_file.is_file():
+                self.cfg.pid_file.unlink(missing_ok=True)
+            return False
+
+        try:
+            # Terminate the supervisor's process group
+            os.killpg(os.getpgid(pid), signal.SIGTERM)
+        except (OSError, ProcessLookupError):
+            try:
+                os.kill(pid, signal.SIGTERM)
+            except (OSError, ProcessLookupError):
+                pass
+
+        # Wait briefly for shutdown
+        for _ in range(20):
+            if not _pid_alive(pid):
+                break
+            time.sleep(0.2)
+
+        self.cfg.pid_file.unlink(missing_ok=True)
+        return True
+
+    def ensure_running(self) -> None:
+        """Make sure ComfyUI is up; if not, spawn it and wait for readiness."""
+        if self.is_up():
+            self.touch_activity()
+            return
+
+        if not self.cfg.comfyui_dir.is_dir():
+            raise FileNotFoundError(
+                f"ComfyUI checkout not found at {self.cfg.comfyui_dir}. Set CONFYUI_DIR to the checkout directory.",
+            )
+
+        if not self.cfg.python_bin.is_file():
+            raise FileNotFoundError(
+                f"Python binary not found at {self.cfg.python_bin}. Set CONFYUI_PYTHON to the venv python.",
+            )
+
+        # Launch the supervisor process detached
+        self.touch_activity()
+        with open(self.cfg.log_file, "a", encoding="utf-8") as log_fp:
+            # Command to run our internal supervisor loop
+            cmd = [
+                sys.executable,
+                "-m",
+                "confyui.server",
+                "--daemon-supervisor",
+                "--comfyui-dir",
+                str(self.cfg.comfyui_dir),
+                "--python-bin",
+                str(self.cfg.python_bin),
+                "--host",
+                self.cfg.host,
+                "--port",
+                str(self.cfg.port),
+                "--idle-timeout",
+                str(self.cfg.idle_timeout),
+                "--state-dir",
+                str(self.cfg.state_dir),
+            ]
+
+            proc = subprocess.Popen(
+                cmd,
+                stdout=log_fp,
+                stderr=subprocess.STDOUT,
+                start_new_session=True,
+                close_fds=True,
+            )
+        self.cfg.pid_file.write_text(str(proc.pid))
+
+        # Wait for HTTP readiness
+        start = time.time()
+        deadline = start + self.cfg.spawn_timeout
+        while time.time() < deadline:
+            if self.is_up():
+                self.touch_activity()
+                return
+            if not _pid_alive(proc.pid):
+                raise RuntimeError(
+                    f"ComfyUI supervisor died during startup. Check {self.cfg.log_file}",
+                )
+            time.sleep(0.5)
+
+        raise TimeoutError(
+            f"ComfyUI failed to respond on {self.cfg.base_url} after {self.cfg.spawn_timeout}s. "
+            f"Check {self.cfg.log_file}",
+        )
+
+
+# ── Supervisor process (runs in the background) ──────────────────────────────
+
+
+def _run_supervisor(args: list[str]) -> None:
+    """Entry point for the detached supervisor process."""
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--daemon-supervisor", action="store_true")
+    parser.add_argument("--comfyui-dir", required=True)
+    parser.add_argument("--python-bin", required=True)
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=8188)
+    parser.add_argument("--idle-timeout", type=int, default=1800)
+    parser.add_argument("--state-dir", required=True)
+    opts = parser.parse_args(args)
+
+    state_dir = Path(opts.state_dir)
+    state_dir.mkdir(parents=True, exist_ok=True)
+    activity_file = state_dir / "last_activity"
+    activity_file.write_text(str(int(time.time())))
+
+    # Spawn ComfyUI as child
+    comfy_cmd = [
+        opts.python_bin,
+        "main.py",
+        "--listen",
+        opts.host,
+        "--port",
+        str(opts.port),
+        "--disable-auto-launch",
+    ]
+    child = subprocess.Popen(
+        comfy_cmd,
+        cwd=opts.comfyui_dir,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+    )
+
+    def _cleanup(*_unused: Any) -> None:
+        try:
+            child.terminate()
+            child.wait(timeout=10)
+        except (subprocess.SubprocessError, OSError):
+            try:
+                child.kill()
+            except (subprocess.SubprocessError, OSError):
+                pass
+        sys.exit(0)
+
+    signal.signal(signal.SIGTERM, _cleanup)
+    signal.signal(signal.SIGINT, _cleanup)
+
+    # Watchdog loop
+    while True:
+        ret = child.poll()
+        if ret is not None:
+            # Child exited on its own
+            sys.exit(ret)
+
+        now = int(time.time())
+        try:
+            last = int(activity_file.read_text().strip())
+        except (ValueError, OSError):
+            last = now
+
+        if (now - last) >= opts.idle_timeout:
+            print(
+                f"[confyui-supervisor] Idle timeout ({opts.idle_timeout}s) reached without activity. Shutting down.",
+                flush=True,
+            )
+            _cleanup()
+
+        time.sleep(10)
+
+
+if __name__ == "__main__":
+    _run_supervisor(sys.argv[1:])

confyui/workflows.py

@@ -0,0 +1,212 @@
+"""API graph builders for ComfyUI.
+
+Generates the exact node-link JSON payload expected by the ComfyUI POST /prompt
+endpoint for txt2img, img2img, and inpainting.
+"""
+
+from __future__ import annotations
+
+import random
+from typing import Any
+
+
+def _resolve_seed(seed: int | None) -> int:
+    if seed is None or seed < 0:
+        return random.randint(1, 2**31 - 1)
+    return seed
+
+
+def build_txt2img_workflow(
+    prompt: str,
+    negative_prompt: str = "",
+    width: int = 512,
+    height: int = 512,
+    batch_size: int = 1,
+    steps: int = 20,
+    cfg: float = 7.0,
+    seed: int | None = None,
+    sampler_name: str = "euler",
+    scheduler: str = "normal",
+    denoise: float = 1.0,
+    ckpt_name: str = "Realistic_Vision_V5.1.safetensors",
+    filename_prefix: str = "confyui_txt2img",
+) -> dict[str, Any]:
+    """Standard txt2img: CheckpointLoader -> CLIPEncode (pos/neg) -> Latent -> KSampler -> VAEDecode -> SaveImage."""
+    s = _resolve_seed(seed)
+    return {
+        "4": {
+            "class_type": "CheckpointLoaderSimple",
+            "inputs": {"ckpt_name": ckpt_name},
+        },
+        "5": {
+            "class_type": "EmptyLatentImage",
+            "inputs": {"width": width, "height": height, "batch_size": batch_size},
+        },
+        "6": {
+            "class_type": "CLIPTextEncode",
+            "inputs": {"text": prompt, "clip": ["4", 1]},
+        },
+        "7": {
+            "class_type": "CLIPTextEncode",
+            "inputs": {"text": negative_prompt, "clip": ["4", 1]},
+        },
+        "3": {
+            "class_type": "KSampler",
+            "inputs": {
+                "seed": s,
+                "steps": steps,
+                "cfg": cfg,
+                "sampler_name": sampler_name,
+                "scheduler": scheduler,
+                "denoise": denoise,
+                "model": ["4", 0],
+                "positive": ["6", 0],
+                "negative": ["7", 0],
+                "latent_image": ["5", 0],
+            },
+        },
+        "8": {
+            "class_type": "VAEDecode",
+            "inputs": {"samples": ["3", 0], "vae": ["4", 2]},
+        },
+        "9": {
+            "class_type": "SaveImage",
+            "inputs": {"filename_prefix": filename_prefix, "images": ["8", 0]},
+        },
+    }
+
+
+def build_img2img_workflow(
+    image_name: str,
+    prompt: str,
+    negative_prompt: str = "",
+    steps: int = 20,
+    cfg: float = 7.0,
+    seed: int | None = None,
+    sampler_name: str = "euler",
+    scheduler: str = "normal",
+    denoise: float = 0.55,
+    ckpt_name: str = "Realistic_Vision_V5.1.safetensors",
+    filename_prefix: str = "confyui_img2img",
+) -> dict[str, Any]:
+    """img2img: LoadImage -> VAEEncode -> KSampler(denoise<1.0) -> VAEDecode -> SaveImage."""
+    s = _resolve_seed(seed)
+    return {
+        "4": {
+            "class_type": "CheckpointLoaderSimple",
+            "inputs": {"ckpt_name": ckpt_name},
+        },
+        "10": {
+            "class_type": "LoadImage",
+            "inputs": {"image": image_name},
+        },
+        "11": {
+            "class_type": "VAEEncode",
+            "inputs": {"pixels": ["10", 0], "vae": ["4", 2]},
+        },
+        "6": {
+            "class_type": "CLIPTextEncode",
+            "inputs": {"text": prompt, "clip": ["4", 1]},
+        },
+        "7": {
+            "class_type": "CLIPTextEncode",
+            "inputs": {"text": negative_prompt, "clip": ["4", 1]},
+        },
+        "3": {
+            "class_type": "KSampler",
+            "inputs": {
+                "seed": s,
+                "steps": steps,
+                "cfg": cfg,
+                "sampler_name": sampler_name,
+                "scheduler": scheduler,
+                "denoise": denoise,
+                "model": ["4", 0],
+                "positive": ["6", 0],
+                "negative": ["7", 0],
+                "latent_image": ["11", 0],
+            },
+        },
+        "8": {
+            "class_type": "VAEDecode",
+            "inputs": {"samples": ["3", 0], "vae": ["4", 2]},
+        },
+        "9": {
+            "class_type": "SaveImage",
+            "inputs": {"filename_prefix": filename_prefix, "images": ["8", 0]},
+        },
+    }
+
+
+def build_inpaint_workflow(
+    image_name: str,
+    mask_name: str,
+    prompt: str,
+    negative_prompt: str = "",
+    steps: int = 25,
+    cfg: float = 7.0,
+    seed: int | None = None,
+    sampler_name: str = "euler",
+    scheduler: str = "normal",
+    denoise: float = 1.0,
+    ckpt_name: str = "Realistic_Vision_V5.1_fp16-no-ema-inpainting.safetensors",
+    filename_prefix: str = "confyui_inpaint",
+) -> dict[str, Any]:
+    """Inpainting: LoadImage + LoadImageMask -> VAEEncode -> SetLatentNoiseMask -> KSampler -> Decode -> Save."""
+    s = _resolve_seed(seed)
+    return {
+        "4": {
+            "class_type": "CheckpointLoaderSimple",
+            "inputs": {"ckpt_name": ckpt_name},
+        },
+        "10": {
+            "class_type": "LoadImage",
+            "inputs": {"image": image_name},
+        },
+        "12": {
+            "class_type": "LoadImage",
+            "inputs": {"image": mask_name},
+        },
+        "11": {
+            "class_type": "VAEEncode",
+            "inputs": {"pixels": ["10", 0], "vae": ["4", 2]},
+        },
+        "13": {
+            "class_type": "SetLatentNoiseMask",
+            "inputs": {
+                "samples": ["11", 0],
+                "mask": ["12", 1],
+            },
+        },
+        "6": {
+            "class_type": "CLIPTextEncode",
+            "inputs": {"text": prompt, "clip": ["4", 1]},
+        },
+        "7": {
+            "class_type": "CLIPTextEncode",
+            "inputs": {"text": negative_prompt, "clip": ["4", 1]},
+        },
+        "3": {
+            "class_type": "KSampler",
+            "inputs": {
+                "seed": s,
+                "steps": steps,
+                "cfg": cfg,
+                "sampler_name": sampler_name,
+                "scheduler": scheduler,
+                "denoise": denoise,
+                "model": ["4", 0],
+                "positive": ["6", 0],
+                "negative": ["7", 0],
+                "latent_image": ["13", 0],
+            },
+        },
+        "8": {
+            "class_type": "VAEDecode",
+            "inputs": {"samples": ["3", 0], "vae": ["4", 2]},
+        },
+        "9": {
+            "class_type": "SaveImage",
+            "inputs": {"filename_prefix": filename_prefix, "images": ["8", 0]},
+        },
+    }

confyui-0.1.0.dist-info/METADATA

@@ -0,0 +1,152 @@
+Metadata-Version: 2.3
+Name: confyui
+Version: 0.1.0
+Summary: KpihX sovereign local image generation and editing daemon over ComfyUI (txt2img, img2img, inpaint; XPU-first)
+Author: KpihX
+Author-email: KpihX <kapoivha@gmail.com>
+Requires-Dist: fastapi>=0.159.1
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: huggingface-hub>=2.2.0
+Requires-Dist: pillow>=13.0.0
+Requires-Dist: psutil>=7.2.2
+Requires-Dist: python-dotenv>=1.2.4
+Requires-Dist: rich>=15.0.0
+Requires-Dist: typer>=0.27.3
+Requires-Dist: uvicorn>=0.54.0
+Requires-Dist: torch>=2.8 ; extra == 'cpu'
+Requires-Dist: torchvision>=0.23 ; extra == 'cpu'
+Requires-Dist: torch>=2.8 ; extra == 'cuda'
+Requires-Dist: torchvision>=0.23 ; extra == 'cuda'
+Requires-Dist: transformers>=4.56 ; extra == 'cuda'
+Requires-Dist: accelerate>=1.10.1 ; extra == 'cuda'
+Requires-Dist: huggingface-hub>=0.34.4 ; extra == 'cuda'
+Requires-Dist: safetensors>=0.6.2 ; extra == 'cuda'
+Requires-Dist: torch>=2.8 ; extra == 'xpu'
+Requires-Dist: torchvision>=0.23 ; extra == 'xpu'
+Requires-Dist: transformers>=4.56 ; extra == 'xpu'
+Requires-Dist: accelerate>=1.10.1 ; extra == 'xpu'
+Requires-Dist: huggingface-hub>=0.34.4 ; extra == 'xpu'
+Requires-Dist: safetensors>=0.6.2 ; extra == 'xpu'
+Requires-Python: >=3.12
+Provides-Extra: cpu
+Provides-Extra: cuda
+Provides-Extra: xpu
+Description-Content-Type: text/markdown
+
+# confyui
+
+KπX sovereign local image generation and editing daemon over ComfyUI.
+
+Hardware-accelerated on Intel Arc (XPU) via PyTorch XPU wheels, with portable CPU and CUDA extras.
+
+## Philosophy
+
+- **0 Magic:** The CLI talks to ComfyUI's standard REST API via structured JSON graphs.
+- **0 Manual Start:** The first call (`generate`, `edit`, `inpaint`) automatically starts ComfyUI in the background.
+- **0 Wasted RAM:** An idle watchdog shuts ComfyUI down after `CONFYUI_IDLE_TIMEOUT` seconds of inactivity (default: 30 minutes).
+- **0 Hardcoding:** Paths expand `$HOME` at runtime and are 100% overridable via environment variables.
+
+---
+
+## Installation
+
+```bash
+# Clone or navigate to the repository
+cd ~/Labs/KpihX-Labs/AI/confyui
+
+# Intel Arc workstation (XPU)
+make sync-xpu
+# or: uv sync --extra xpu
+
+# Generic CPU fallback
+make sync-cpu
+
+# NVIDIA CUDA host
+make sync-cuda
+```
+
+---
+
+## Environment Variables
+
+| Variable | Default | Description |
+|---|---|---|
+| `CONFYUI_DIR` | `~/RAW/comfyui-local/ComfyUI` | Path to the ComfyUI checkout |
+| `CONFYUI_PYTHON` | `$CONFYUI_DIR/.venv/bin/python` | Python interpreter used to run ComfyUI |
+| `CONFYUI_HOST` | `127.0.0.1` | Bind address |
+| `CONFYUI_PORT` | `8188` | Port |
+| `CONFYUI_IDLE_TIMEOUT` | `1800` | Seconds of inactivity before auto-shutdown |
+| `CONFYUI_SPAWN_TIMEOUT` | `90` | Max seconds to wait for daemon readiness |
+| `CONFYUI_STATE_DIR` | `~/.cache/confyui` | Directory for PID, logs, and heartbeat |
+| `CONFYUI_DEFAULT_CKPT` | `Realistic_Vision_V5.1_noVAE.safetensors` | Default checkpoint for txt2img & img2img |
+| `CONFYUI_INPAINT_CKPT` | `Realistic_Vision_V5.1_fp16-no-ema-inpainting.safetensors` | Default inpainting checkpoint |
+
+---
+
+## Usage
+
+### 1. Text-to-Image (`generate`)
+
+```bash
+# Minimal
+uv run confyui generate "a red panda wearing a top hat on the moon, cinematic lighting"
+
+# Full options
+uv run confyui generate "a red panda wearing a top hat on the moon" \
+    --negative "blurry, low quality, artifacts" \
+    --width 512 \
+    --height 512 \
+    --steps 20 \
+    --cfg 7.0 \
+    --seed 42 \
+    --sampler euler \
+    --scheduler normal \
+    --model "Realistic_Vision_V5.1_noVAE.safetensors" \
+    --out panda_moon.png
+```
+
+### 2. Image-to-Image (`edit`)
+
+Modifies an existing image based on a prompt. The source image is kept and only altered proportionally to `--denoise` (0.0 = unchanged, 0.45-0.60 = balanced modification, 1.0 = total repaint):
+
+```bash
+uv run confyui edit panda_moon.png "make the red panda wear a golden astronaut suit" \
+    --denoise 0.50 \
+    --steps 20 \
+    --out panda_astronaut.png
+```
+
+### 3. Inpainting (`inpaint`)
+
+Repaints only the masked region (white pixels in the mask are regenerated, black pixels preserved):
+
+```bash
+uv run confyui inpaint portrait.png torso_mask.png "she wears a long red silk dress" \
+    --denoise 1.0 \
+    --steps 25 \
+    --out portrait_red_dress.png
+```
+
+### 4. Daemon Management
+
+```bash
+# Inspect status, uptime, PID, and idle time remaining
+uv run confyui status
+
+# List installed checkpoints
+uv run confyui models
+
+# Stop the daemon immediately to free RAM and VRAM
+uv run confyui stop
+```
+
+---
+
+## Development
+
+```bash
+make help     # Show available targets
+make check    # Lint (ruff), format check, compile, pyright, pytest
+make smoke    # Fast sanity check of CLI and imports
+make demo     # Run a real 12-step test generation
+```

confyui-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+confyui/__init__.py,sha256=luOnJjwdG0u0yt2pJ8z22JC4gxCqVaDGo8EYLc6PU3I,403
+confyui/cli.py,sha256=G-5I-xBiqFAaXQPbtM14yDnajVsFeWXz5pvI6xqb_30,8004
+confyui/client.py,sha256=jlZDigK_1Q03G0_NXOQSwi79gQ4-OGcI-wv2kCnZBLA,8450
+confyui/config.py,sha256=RfHwnzDcLEK_QrOH0yNOtZ5bHqyEOwQxJgX-LBIXik4,2869
+confyui/server.py,sha256=VVndWUfpTPHEAhNup6IhD_hPIjzzWbW6xYILQi1WOjQ,8354
+confyui/workflows.py,sha256=sre2ZUmL8cUh25GJIzTAanlwp0KqTm-0OKdgPf8IGss,6415
+confyui-0.1.0.dist-info/WHEEL,sha256=5XVLiN68MV2VpIWvmvgvvELLyDEnIzAqfKmdusfYfHI,80
+confyui-0.1.0.dist-info/entry_points.txt,sha256=b_4i9zeIYa6-uhR85tS-TXnK2Jbw6rVcson32GHIYNk,45
+confyui-0.1.0.dist-info/METADATA,sha256=wQqYwRYuNarlULRKphD03XPHKWeJG-cKThTyEjOGABA,4736
+confyui-0.1.0.dist-info/RECORD,,

confyui-0.1.0.dist-info/WHEEL

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

confyui-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+confyui = confyui.cli:app
+