termux-diffusion 1.3.2__tar.gz → 1.4.1__tar.gz

termux_diffusion-1.4.1/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: termux-diffusion
+Version: 1.4.1
+Summary: On-device Stable Diffusion runtime utilizing device resources for Android Termux & Samsung Galaxy (Dual-Engine Python & Node.js)
+Home-page: https://github.com/uno-km/termux-diffusion
+Author: uno-km (AMEVA Foundation)
+Author-email: "uno-km (AMEVA Foundation)" <hosequelbo@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/uno-km/termux-diffusion
+Project-URL: Documentation, https://uno-km.github.io/termux-diffusion/
+Project-URL: npm Package, https://www.npmjs.com/package/termux-diffusion
+Project-URL: Bug Tracker, https://github.com/uno-km/termux-diffusion/issues
+Project-URL: Source, https://github.com/uno-km/termux-diffusion
+Keywords: stable-diffusion,diffusion,termux,android,samsung-galaxy,edge-ai,on-device-ai,image-generation,gguf,arm64,bionic-libc,snapdragon,exynos,text-to-image,txt2img,mobile-ai,quantization,generative-ai,vulkan,opencl,offline-ai,private-ai,ai-art,comfyui-alternative,webui-alternative
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Android
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Multimedia :: Graphics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ameva-vulkan-runtime>=1.0.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Termux-Diffusion
+
+[![PyPI](https://img.shields.io/pypi/v/termux-diffusion.svg?style=flat-square&color=0369a1)](https://pypi.org/project/termux-diffusion/)
+[![Python](https://img.shields.io/pypi/pyversions/termux-diffusion.svg?style=flat-square)](https://pypi.org/project/termux-diffusion/)
+[![npm](https://img.shields.io/npm/v/termux-diffusion.svg?style=flat-square&color=b91c1c)](https://www.npmjs.com/package/termux-diffusion)
+[![npm downloads](https://img.shields.io/npm/dm/termux-diffusion.svg?style=flat-square&color=b91c1c)](https://www.npmjs.com/package/termux-diffusion)
+[![License](https://img.shields.io/badge/License-Apache_2.0-004499.svg?style=flat-square)](https://github.com/uno-km/termux-diffusion)
+
+> **디바이스 리소스를 활용한 Android Termux 네이티브 온디바이스 Stable Diffusion 런타임**  
+> *Native On-Device Stable Diffusion Runtime Utilizing Device Resources for Android Termux*
+
+---
+
+## 📌 Architecture & Overview
+
+안드로이드 순정 Bionic libc 상에서 디바이스 리소스를 활용하여 ARMv8.2-A DotProd/FP16 SIMD 벡터 연산(Cortex-A78 x4: 61초)을 통해 이미지를 생성하고 삼성 갤러리에 자동 반영합니다.
+
+Executes quantized Stable Diffusion models utilizing device resources with ARMv8.2-A DotProd/FP16 SIMD vector execution (Cortex-A78 x4 61s) and direct Samsung Gallery indexing.
+
+---
+
+## 🚀 Installation & Quickstart
+
+### Python (PyPI)
+```bash
+pip install termux-diffusion
+```
+```python
+import termux_diffusion as td
+
+# 1. Generate image on Android hardware
+image_path = td.generate(
+    prompt="Cyberpunk Seoul city at night, neon lights, 8k",
+    model="sd-turbo",
+    steps=4
+)
+print(f"Generated and saved to Gallery: {image_path}")
+
+```
+
+### Node.js / TypeScript (npm)
+```bash
+npm install termux-diffusion
+```
+```typescript
+import { generate } from "termux-diffusion";
+
+const result = await generate({
+  prompt: "Cyberpunk Seoul city at night, neon lights, 8k",
+  model: "sd-turbo",
+  steps: 4
+});
+console.log("Image created:", result.outputPath);
+
+```
+
+---
+
+## 📖 Official Documentation & Benchmarks
+- [Official Architecture & API Reference](https://uno-km.vercel.app/lib/diffusion/)
+- [Ecosystem Metrics & Registry Stats](https://uno-km.vercel.app/foundation/metrics)
+- [AMEVA Open-Source Foundation Portal](https://uno-km.vercel.app/foundation/index.html)
+
+---
+
+## 📄 License
+Licensed under the Apache-2.0 License. Copyright (c) 2026 Eunho Kim ([@uno-km](https://github.com/uno-km)).

termux_diffusion-1.4.1/README.md

@@ -0,0 +1,67 @@
+# Termux-Diffusion
+
+[![PyPI](https://img.shields.io/pypi/v/termux-diffusion.svg?style=flat-square&color=0369a1)](https://pypi.org/project/termux-diffusion/)
+[![Python](https://img.shields.io/pypi/pyversions/termux-diffusion.svg?style=flat-square)](https://pypi.org/project/termux-diffusion/)
+[![npm](https://img.shields.io/npm/v/termux-diffusion.svg?style=flat-square&color=b91c1c)](https://www.npmjs.com/package/termux-diffusion)
+[![npm downloads](https://img.shields.io/npm/dm/termux-diffusion.svg?style=flat-square&color=b91c1c)](https://www.npmjs.com/package/termux-diffusion)
+[![License](https://img.shields.io/badge/License-Apache_2.0-004499.svg?style=flat-square)](https://github.com/uno-km/termux-diffusion)
+
+> **디바이스 리소스를 활용한 Android Termux 네이티브 온디바이스 Stable Diffusion 런타임**  
+> *Native On-Device Stable Diffusion Runtime Utilizing Device Resources for Android Termux*
+
+---
+
+## 📌 Architecture & Overview
+
+안드로이드 순정 Bionic libc 상에서 디바이스 리소스를 활용하여 ARMv8.2-A DotProd/FP16 SIMD 벡터 연산(Cortex-A78 x4: 61초)을 통해 이미지를 생성하고 삼성 갤러리에 자동 반영합니다.
+
+Executes quantized Stable Diffusion models utilizing device resources with ARMv8.2-A DotProd/FP16 SIMD vector execution (Cortex-A78 x4 61s) and direct Samsung Gallery indexing.
+
+---
+
+## 🚀 Installation & Quickstart
+
+### Python (PyPI)
+```bash
+pip install termux-diffusion
+```
+```python
+import termux_diffusion as td
+
+# 1. Generate image on Android hardware
+image_path = td.generate(
+    prompt="Cyberpunk Seoul city at night, neon lights, 8k",
+    model="sd-turbo",
+    steps=4
+)
+print(f"Generated and saved to Gallery: {image_path}")
+
+```
+
+### Node.js / TypeScript (npm)
+```bash
+npm install termux-diffusion
+```
+```typescript
+import { generate } from "termux-diffusion";
+
+const result = await generate({
+  prompt: "Cyberpunk Seoul city at night, neon lights, 8k",
+  model: "sd-turbo",
+  steps: 4
+});
+console.log("Image created:", result.outputPath);
+
+```
+
+---
+
+## 📖 Official Documentation & Benchmarks
+- [Official Architecture & API Reference](https://uno-km.vercel.app/lib/diffusion/)
+- [Ecosystem Metrics & Registry Stats](https://uno-km.vercel.app/foundation/metrics)
+- [AMEVA Open-Source Foundation Portal](https://uno-km.vercel.app/foundation/index.html)
+
+---
+
+## 📄 License
+Licensed under the Apache-2.0 License. Copyright (c) 2026 Eunho Kim ([@uno-km](https://github.com/uno-km)).

{termux_diffusion-1.3.2 → termux_diffusion-1.4.1}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "termux-diffusion"
-version = "1.3.2"
-description = "Production On-Device AI Image Generation Framework for Android Termux & Samsung Galaxy (Dual-Engine Python & Node.js)"
+version = "1.4.1"
+description = "On-device Stable Diffusion runtime utilizing device resources for Android Termux & Samsung Galaxy (Dual-Engine Python & Node.js)"
 readme = "README.md"
 requires-python = ">=3.8"
 license = { text = "MIT" }
@@ -56,6 +56,10 @@ termux-diffusion = "termux_diffusion.cli:main"
 termux-diffusion-install = "termux_diffusion.cli:run_install_cli"
 termux-diffusion-doctor = "termux_diffusion.cli:run_doctor_cli"
 
+[project.entry-points."ameva.components"]
+termux-diffusion = "termux_diffusion.adapter:create_adapter"
+
+
 [tool.setuptools.package-data]
 termux_diffusion = [
     "data/*.json",

{termux_diffusion-1.3.2 → termux_diffusion-1.4.1}/setup.py

@@ -11,8 +11,8 @@ if os.path.exists(readme_path):
 
 setup(
     name="termux-diffusion",
-    version="1.3.2",
-    description="Production On-Device AI Image Generation Framework for Android Termux & Samsung Galaxy (Dual-Engine Python & Node.js)",
+    version="1.4.1",
+    description="On-device Stable Diffusion runtime utilizing device resources for Android Termux & Samsung Galaxy (Dual-Engine Python & Node.js)",
     long_description=long_description,
     long_description_content_type="text/markdown",
     author="uno-km (AMEVA Foundation)",

termux_diffusion-1.4.1/termux_diffusion/_version.py

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

termux_diffusion-1.4.1/termux_diffusion/adapter.py

@@ -0,0 +1,35 @@
+"""
+termux_diffusion.adapter
+=========================
+AMEVA Component Protocol v1 — Orchestrator Adapter (v0.8.1 호환)
+"""
+from __future__ import annotations
+
+from typing import Any, AsyncIterator
+
+from ameva_component.adapter_base import BaseOrchestratorAdapter
+from termux_diffusion.control.component import DiffusionControl
+
+
+class DiffusionOrchestratorAdapter(BaseOrchestratorAdapter):
+    """Diffusion Orchestrator Adapter.
+
+    이미지 생성은 sd-cli subprocess를 통해 수행됩니다.
+    infer()는 OPERATION_NOT_SUPPORTED — generate() REST endpoint를 사용하십시오.
+    """
+
+    COMPONENT_ID = "termux-diffusion"
+
+    def __init__(self, control: DiffusionControl | None = None) -> None:
+        self._control = control or DiffusionControl()
+
+    async def infer(self, request: dict[str, Any]) -> AsyncIterator[dict[str, Any]]:
+        """Diffusion generation은 REST endpoint /generate 를 통해 수행됩니다.
+        Orchestrator 직접 streaming은 OPERATION_NOT_SUPPORTED.
+        """
+        yield self._not_supported("infer")
+
+
+def create_adapter() -> DiffusionOrchestratorAdapter:
+    """Entry Point Factory."""
+    return DiffusionOrchestratorAdapter()

{termux_diffusion-1.3.2 → termux_diffusion-1.4.1}/termux_diffusion/cli.py

@@ -81,6 +81,14 @@ def main(argv: Optional[List[str]] = None) -> int:
     # clear-cache command
     subparsers.add_parser("clear-cache", help="Purge cached model weights to reclaim disk space")
 
+    # ── AMEVA Component Protocol v1 ─────────────────────────────────────────
+    try:
+        from ameva_component.cli_support import build_protocol_subcommands
+        build_protocol_subcommands(subparsers)
+    except ImportError:
+        pass  # Allowed: optional rich/click dependency. Not installed is normal fallback.
+    # ────────────────────────────────────────────────────────────────────────
+
     if len(argv) == 0:
         parser.print_help()
         return 0
@@ -189,6 +197,16 @@ def main(argv: Optional[List[str]] = None) -> int:
         print(f"[Clean] Removed {removed} cached model files.")
         return 0
 
+    elif args.command in ("component", "model", "instance"):
+        try:
+            from ameva_component.cli_support import dispatch_protocol
+            from termux_diffusion.control import DiffusionControl
+            dispatch_protocol(args, DiffusionControl())
+        except ImportError:
+            print("[ERROR] ameva-component-sdk not installed.", file=sys.stderr)
+            return 1
+        return 0
+
     parser.print_help()
     return 0
 

termux_diffusion-1.4.1/termux_diffusion/control/__init__.py

@@ -0,0 +1,3 @@
+"""termux_diffusion.control — AMEVA Component Protocol v1."""
+from .component import DiffusionControl
+__all__ = ["DiffusionControl"]

termux_diffusion-1.4.1/termux_diffusion/control/component.py

@@ -0,0 +1,262 @@
+"""
+termux_diffusion.control.component
+AMEVA Component Protocol v1 — DiffusionControl
+
+model_id는 파일명이 아닌 Pipeline Manifest를 가리킵니다.
+(UNet + VAE + Text Encoder + Tokenizer + Scheduler Config)
+기존 installer.run_doctor() + hub.py를 Adapter로 연결합니다.
+"""
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+
+from ameva_component import (
+    ActivationLock, ComponentInfo, ComponentStateFile,
+    ControlMode, InstanceRegistry, InstanceState, InstanceStatus,
+    ModelRegistry, ModelState, ModelNotFound, ModelLoadFailed,
+    OperationNotSupported, now_timestamps, log_stderr, PROTOCOL_COMPONENT,
+)
+from ameva_component.control import ComponentControl
+
+
+class DiffusionControl(ComponentControl):
+    """
+    termux-diffusion ComponentControl.
+
+    model_id = Pipeline Manifest ID (단일 파일명 아님).
+    기존 installer.run_doctor(), hub.DEFAULT_PRESETS를 Adapter로 연결.
+    """
+
+    COMPONENT_ID   = "termux-diffusion"
+    COMPONENT_TYPE = "diffusion"
+    CAPABILITIES   = ("image.generate",)
+
+    DEFAULT_MODELS_DIR = Path.home() / ".cache" / "termux-diffusion" / "models"
+
+    def __init__(self, models_dir: Path | None = None) -> None:
+        self._models_dir = models_dir or self.DEFAULT_MODELS_DIR
+        self._state_file = ComponentStateFile(self.COMPONENT_ID)
+        self._model_reg  = ModelRegistry(self.COMPONENT_ID)
+        self._inst_reg   = InstanceRegistry(self.COMPONENT_ID)
+        self._act_lock   = ActivationLock()
+        # Phase 4: Heartbeat Writer
+        from termux_diffusion.control.status import DiffusionStatusWriter
+        self._heartbeat = DiffusionStatusWriter(self)
+
+    def _get_version(self) -> str:
+        try:
+            from termux_diffusion import __version__; return __version__
+        except Exception: return "1.3.2"
+
+    def component_info(self) -> dict:
+        info = ComponentInfo(
+            protocol=PROTOCOL_COMPONENT, component_id=self.COMPONENT_ID,
+            component_type=self.COMPONENT_TYPE, version=self._get_version(),
+            capabilities=self.CAPABILITIES,
+        )
+        info.validate()
+        return info.to_dict()
+
+    def doctor_lite(self) -> dict:
+        """
+        경량 진단.
+        샘플 추론 금지, 엔진 바이너리 존재 여부 + 상태파일만.
+        """
+        ts = now_timestamps()
+        state_data = self._state_file.read()
+        stale = self._state_file.is_stale(threshold_ms=30_000)
+        pid, pid_alive = self._check_pid()
+        instances = self._inst_reg.list_all()
+        hot = [i for i in instances if i.state == InstanceState.HOT]
+
+        # 엔진 바이너리 존재 여부 (실행 금지)
+        engine_present = self._check_engine_binary()
+
+        ready = engine_present
+        degraded = stale or not pid_alive
+
+        return {
+            "protocol": "ameva-component-status/1",
+            "component_id": self.COMPONENT_ID, "component_type": self.COMPONENT_TYPE,
+            "version": self._get_version(), "ready": ready, "degraded": degraded,
+            **ts,
+            "process": {"running": pid_alive, "pid": pid},
+            "capabilities": list(self.CAPABILITIES),
+            "active_models": [i.model_id for i in hot],
+            "engine": {"present": engine_present},
+            "instances": [{"instance_id": i.instance_id, "model_id": i.model_id,
+                           "state": i.state.value, "active_jobs": i.active_jobs} for i in instances],
+            "errors": [state_data.get("last_error")] if state_data and state_data.get("last_error") else [],
+            "state_file": {"path": str(self._state_file.path), "stale": stale,
+                           "updated_at": state_data.get("updated_at") if state_data else None},
+        }
+
+    def _check_pid(self) -> tuple[int | None, bool | None]:
+        """PID 파일에서 sd-cli 프로세스 생존 여부 확인.
+
+        반환:
+            alive=True  → 프로세스 확인됨
+            alive=False → 종료됨
+            alive=None  → PermissionError 등 측정 불가
+        """
+        from ameva_component import log_stderr
+
+        pid_file = Path.home() / ".local" / "run" / "termux-diffusion.pid"
+        if pid_file.exists():
+            try:
+                pid = int(pid_file.read_text().strip())
+            except (ValueError, OSError) as _parse_err:
+                log_stderr(f"[diffusion] PID file parse error: {_parse_err}")
+                return None, False
+
+            try:
+                os.kill(pid, 0)
+                return pid, True
+            except ProcessLookupError:
+                return pid, False
+            except PermissionError:
+                log_stderr(f"[diffusion] PID {pid} alive check: PermissionError (unmeasurable)")
+                return pid, None
+            except OSError as _os_err:
+                log_stderr(f"[diffusion] PID {pid} alive check OSError: {_os_err}")
+                return pid, None
+        return None, False
+
+
+
+    def _check_engine_binary(self) -> bool:
+        """엔진 바이너리 존재 여부만 확인 — 실행 금지."""
+        try:
+            from termux_diffusion.installer import provision_engine
+            return True  # 모듈 import 성공 = 설치 가능 상태
+        except ImportError:
+            return False  # Allowed: engine not installed -> binary check fails-closed.
+
+    def doctor_full(self) -> dict:
+        """기존 installer.run_doctor() 전체 실행."""
+        lite = self.doctor_lite()
+        try:
+            from termux_diffusion.installer import run_doctor
+            result = run_doctor()
+            lite["full_doctor"] = result if isinstance(result, dict) else {"output": str(result)}
+        except Exception as e:
+            lite["doctor_error"] = str(e)
+        lite["doctor_level"] = "full"
+        return lite
+
+    def list_models(self) -> dict:
+        """Pipeline Manifest 기반 모델 목록 + hub.DEFAULT_PRESETS."""
+        reg_map = {m["model_id"]: m for m in self._model_reg.list_all()}
+        try:
+            from termux_diffusion.hub import DEFAULT_PRESETS, list_presets
+            for preset_id, preset_info in DEFAULT_PRESETS.items():
+                if preset_id not in reg_map:
+                    reg_map[preset_id] = {
+                        "model_id":    preset_id,
+                        "state":       "missing",
+                        "format":      "pipeline",
+                        "note":        "Available preset — not yet downloaded",
+                        "description": str(preset_info),
+                        "verified_at": None,
+                    }
+        except Exception as e:
+            log_stderr(f"[diffusion] hub.DEFAULT_PRESETS load failed: {e}")
+        return {"models": list(reg_map.values()), "total": len(reg_map),
+                "models_dir": str(self._models_dir)}
+
+    def model_status(self, model_id: str | None = None) -> dict:
+        if model_id:
+            rec = self._model_reg.get(model_id)
+            if rec is None: raise ModelNotFound(model_id)
+            return {"model": rec}
+        return self.list_models()
+
+    def install_model(self, request: dict) -> dict:
+        """Pipeline Manifest 기반 설치 — 모든 구성 파일 Hash 검증."""
+        from ameva_component import ModelInstaller
+        url = request.get("url", ""); filename = request.get("filename", "")
+        sha256 = request.get("sha256", "")
+        expected_bytes = int(request.get("expected_bytes", 0))
+        model_id = request.get("model_id") or Path(filename).stem
+        self._models_dir.mkdir(parents=True, exist_ok=True)
+        installer = ModelInstaller(self.COMPONENT_ID, self._models_dir, self._model_reg)
+        return installer.install(url=url, filename=filename, sha256=sha256,
+                                 expected_bytes=expected_bytes, model_id=model_id,
+                                 after_download=self._verify_pipeline_file)
+
+    def _verify_pipeline_file(self, path: Path) -> None:
+        """Pipeline 구성 파일 기본 형식 확인 — 추론 실행 금지."""
+        valid = {".safetensors", ".bin", ".json", ".onnx", ".pt"}
+        if path.suffix.lower() not in valid:
+            raise ValueError(f"Unexpected pipeline file format: '{path.suffix}'")
+
+    async def activate_model(self, request: dict) -> dict:
+        model_id = request.get("model_id", "")
+        rec = self._model_reg.get(model_id)
+        if rec is None: raise ModelNotFound(model_id)
+        if ModelState.from_str(rec.get("state", "missing")) not in (ModelState.INSTALLED, ModelState.INACTIVE):
+            raise ModelLoadFailed(model_id, f"Pipeline state is '{rec.get('state')}'")
+        with self._act_lock.acquire(timeout=60.0):
+            self._model_reg.set_state(model_id, ModelState.ACTIVE)
+            self._write_state()
+        return {"activated": True, "model_id": model_id,
+                "rollback": {"attempted": False, "succeeded": False}}
+
+    async def deactivate_model(self, request: dict) -> dict:
+        model_id = request.get("model_id", "")
+        self._model_reg.set_state(model_id, ModelState.INACTIVE)
+        self._write_state()
+        return {"deactivated": True, "model_id": model_id}
+
+    def list_instances(self) -> dict:
+        instances = self._inst_reg.list_all()
+        return {"instances": [i.to_dict() for i in instances], "total": len(instances)}
+
+    async def start_instance(self, request: dict) -> dict:
+        model_id = request.get("model_id", "")
+        instance_id = request.get("instance_id") or f"diffusion-worker-{int(time.time())}"
+        inst = InstanceStatus(
+            instance_id=instance_id, component_id=self.COMPONENT_ID,
+            model_id=model_id, state=InstanceState.HOT,
+            active_jobs=0, queue_depth=0, max_concurrency=1,
+            backend="cpu", started_at=time.time(), last_heartbeat=time.time(),
+            last_error=None, control_mode=ControlMode.IN_PROCESS,
+        )
+        self._inst_reg.register(inst)
+        self._write_state()
+        # Phase 4: Heartbeat 시작 (Worker 시작 트리거)
+        self._heartbeat.start()
+        return {"instance_id": instance_id, "state": InstanceState.HOT.value}
+
+    async def drain_instance(self, instance_id: str) -> dict:
+        from ameva_component import InstanceNotFound
+        if not self._inst_reg.get(instance_id): raise InstanceNotFound(instance_id)
+        self._inst_reg.update_state(instance_id, InstanceState.DRAINING)
+        return {"instance_id": instance_id, "state": InstanceState.DRAINING.value}
+
+    async def stop_instance(self, instance_id: str) -> dict:
+        from ameva_component import InstanceNotFound
+        if not self._inst_reg.get(instance_id): raise InstanceNotFound(instance_id)
+        self._inst_reg.update_state(instance_id, InstanceState.STOPPED)
+        self._inst_reg.remove(instance_id)
+        # Phase 4: Heartbeat 중단 (정상 종료 트리거)
+        remaining = self._inst_reg.list_all()
+        if not remaining:
+            self._heartbeat.stop()
+        else:
+            self._write_state()
+        return {"instance_id": instance_id, "state": InstanceState.STOPPED.value}
+
+    def _write_state(self, *, ready: bool | None = None, last_error: str | None = None) -> None:
+        ts = now_timestamps()
+        hot = [i for i in self._inst_reg.list_all() if i.state == InstanceState.HOT]
+        _, pid_alive = self._check_pid()
+        _ready = self._check_engine_binary() if ready is None else ready
+        self._state_file.write({
+            "protocol": "ameva-component-status/1", "component_id": self.COMPONENT_ID,
+            "component_type": self.COMPONENT_TYPE, "version": self._get_version(),
+            "ready": _ready, "degraded": not _ready, **ts,
+            "active_models": [i.model_id for i in hot], "last_error": last_error,
+        })

termux_diffusion-1.4.1/termux_diffusion/control/status.py

@@ -0,0 +1,13 @@
+"""
+termux_diffusion.control.status — Diffusion 상태 파일 Writer + Heartbeat
+"""
+from __future__ import annotations
+from typing import Any
+from ameva_component.heartbeat import HeartbeatWriter
+
+
+class DiffusionStatusWriter(HeartbeatWriter):
+    """DiffusionControl 상태를 10초마다 상태 파일에 원자적으로 기록합니다."""
+
+    def __init__(self, control: Any) -> None:
+        super().__init__(control, name="diffusion")

{termux_diffusion-1.3.2 → termux_diffusion-1.4.1}/termux_diffusion/core.py

@@ -341,8 +341,6 @@ def generate(
         cmd.extend(["--seed", str(seed)])
     # Append GPU offloading args from hardware detection
     cmd.extend(get_sd_cli_gpu_args(effective_device, ngl_layers))
-    if effective_device in ("vulkan", "gpu"):
-        cmd.extend(["--backend", "vulkan0"])
 
     # --- Advanced TOP 7 Parameters Integration & Defense ---
     effective_sampler = None
@@ -480,18 +478,19 @@ def generate(
             )
         cmd.extend(["--taesd", str(effective_taesd_path)])
 
-    # 5.1 Configure Environment with companion library search paths (Bionic priority on Android)
+    # 5.1 Configure Environment with companion library search paths (Termux native isolation)
     env = os.environ.copy()
-    bionic_sys_dirs = ["/system/lib64", "/vendor/lib64", "/vendor/lib64/egl"]
+    prefix = os.environ.get("PREFIX", "/data/data/com.termux/files/usr")
     lib_dirs = [
         str(sd_cli.parent),
         str(sd_cli.parent.parent / "lib"),
         str(sd_cli.parent / "lib"),
+        f"{prefix}/lib",
         str(Path.home() / ".cache" / "termux-diffusion" / "lib"),
         str(Path.home() / ".cache" / "termux-diffusion" / "staging" / "lib"),
     ]
     cur_ld = env.get("LD_LIBRARY_PATH", "")
-    valid_dirs = [d for d in bionic_sys_dirs + lib_dirs if Path(d).is_dir()]
+    valid_dirs = [d for d in lib_dirs if Path(d).is_dir()]
     if valid_dirs:
         env["LD_LIBRARY_PATH"] = ":".join(valid_dirs + ([cur_ld] if cur_ld else []))
 
@@ -575,9 +574,15 @@ def generate(
                                 logger.debug("sd-cli: %s", line_str)
                 finally:
                     try:
-                        process.stdout.close()
-                    except Exception:
-                        pass
+                        if hasattr(process.stdout, "close"):
+                            process.stdout.close()
+                    except OSError as _close_err:
+                        # stdout 파이프 close 실패 — 프로세스가 이미 파이프를 닫은 경우 정상.
+                        # 이 오류는 생성 성공/실패와 독립적. debug 수준 로그.
+                        logger.debug("[termux-diffusion] stdout.close() OSError (pipe already closed): %s", _close_err)
+                    # MemoryError 등 예상 밖 예외는 재발생
+
+
 
             process.wait(timeout=timeout)
             all_critical_logs = init_logs + list(recent_logs)

{termux_diffusion-1.3.2 → termux_diffusion-1.4.1}/termux_diffusion/hardware.py

@@ -185,8 +185,11 @@ def _detect_gpu_name() -> str:
             val = kgsl_model.read_text(encoding="utf-8").strip()
             if val:
                 return f"Adreno ({val})"
-        except Exception:
-            pass
+        except PermissionError as _perm_err:
+            logger.warning("[hardware] kgsl gpu_model read PermissionError: %s", _perm_err)
+        except OSError as _os_err:
+            logger.warning("[hardware] kgsl gpu_model read OSError: %s", _os_err)
+        # 예상 밖 예외는 재발생
 
     # 2. Check Android system properties
     for prop in ["ro.hardware.vulkan", "ro.hardware.egl", "ro.board.platform"]:
@@ -209,6 +212,8 @@ def _detect_gpu_name() -> str:
     return "Unknown"
 
 
+
+
 def _probe_vulkan_driver() -> Optional[GPUDriverInfo]:
     """Probe for a usable Vulkan driver via ameva-vulkan-runtime SSOT."""
     try: