claude-controller 0.1.1 → 0.2.0

package/web/handler_fs.py

@@ -0,0 +1,152 @@
+"""
+File System & Config HTTP 핸들러 Mixin
+
+포함 엔드포인트:
+  - GET/POST /api/config
+  - GET/POST /api/recent-dirs
+  - GET  /api/dirs
+  - POST /api/mkdir
+"""
+
+import json
+import os
+
+from config import DATA_DIR, SETTINGS_FILE, RECENT_DIRS_FILE
+
+
+class FsHandlerMixin:
+
+    def _handle_get_config(self):
+        defaults = {
+            "skip_permissions": True,
+            "allowed_tools": "Bash,Read,Write,Edit,Glob,Grep,Agent,NotebookEdit,WebFetch,WebSearch",
+            "model": "",
+            "max_jobs": 10,
+            "append_system_prompt": "",
+            "target_repo": "",
+            "base_branch": "main",
+            "checkpoint_interval": 5,
+            "locale": "ko",
+        }
+        try:
+            if SETTINGS_FILE.exists():
+                saved = json.loads(SETTINGS_FILE.read_text("utf-8"))
+                defaults.update(saved)
+        except (json.JSONDecodeError, OSError):
+            pass
+        self._json_response(defaults)
+
+    def _handle_save_config(self):
+        body = self._read_body()
+        if not body or not isinstance(body, dict):
+            return self._error_response("설정 데이터가 필요합니다")
+
+        current = {}
+        try:
+            if SETTINGS_FILE.exists():
+                current = json.loads(SETTINGS_FILE.read_text("utf-8"))
+        except (json.JSONDecodeError, OSError):
+            pass
+
+        allowed_keys = {
+            "skip_permissions", "allowed_tools", "model", "max_jobs",
+            "append_system_prompt", "target_repo", "base_branch",
+            "checkpoint_interval", "locale",
+        }
+        for k, v in body.items():
+            if k in allowed_keys:
+                current[k] = v
+
+        try:
+            DATA_DIR.mkdir(parents=True, exist_ok=True)
+            SETTINGS_FILE.write_text(
+                json.dumps(current, ensure_ascii=False, indent=2), "utf-8"
+            )
+            self._json_response({"ok": True, "config": current})
+        except OSError as e:
+            self._error_response(f"설정 저장 실패: {e}", 500)
+
+    def _handle_get_recent_dirs(self):
+        try:
+            if RECENT_DIRS_FILE.exists():
+                data = json.loads(RECENT_DIRS_FILE.read_text("utf-8"))
+            else:
+                data = []
+            self._json_response(data)
+        except (json.JSONDecodeError, OSError):
+            self._json_response([])
+
+    def _handle_save_recent_dirs(self):
+        body = self._read_body()
+        dirs = body.get("dirs")
+        if not isinstance(dirs, list):
+            return self._error_response("dirs 배열이 필요합니다")
+        dirs = [d for d in dirs if isinstance(d, str)][:8]
+        try:
+            DATA_DIR.mkdir(parents=True, exist_ok=True)
+            RECENT_DIRS_FILE.write_text(json.dumps(dirs, ensure_ascii=False), "utf-8")
+            self._json_response({"ok": True})
+        except OSError as e:
+            self._error_response(f"저장 실패: {e}", 500)
+
+    def _handle_dirs(self, dir_path):
+        try:
+            dir_path = os.path.abspath(os.path.expanduser(dir_path))
+            if not os.path.isdir(dir_path):
+                return self._error_response("디렉토리가 아닙니다", 400)
+
+            entries = []
+            try:
+                items = sorted(os.listdir(dir_path))
+            except PermissionError:
+                return self._error_response("접근 권한 없음", 403)
+
+            parent = os.path.dirname(dir_path)
+            if parent != dir_path:
+                entries.append({"name": "..", "path": parent, "type": "dir"})
+
+            for item in items:
+                if item.startswith("."):
+                    continue
+                full = os.path.join(dir_path, item)
+                entry = {"name": item, "path": full}
+                if os.path.isdir(full):
+                    entry["type"] = "dir"
+                else:
+                    entry["type"] = "file"
+                    try:
+                        entry["size"] = os.path.getsize(full)
+                    except OSError:
+                        entry["size"] = 0
+                entries.append(entry)
+
+            self._json_response({"current": dir_path, "entries": entries})
+        except Exception as e:
+            self._error_response(f"디렉토리 읽기 실패: {e}", 500)
+
+    def _handle_mkdir(self):
+        body = self._read_body()
+        parent = body.get("parent", "").strip()
+        name = body.get("name", "").strip()
+
+        if not parent or not name:
+            return self._error_response("parent와 name 필드가 필요합니다")
+
+        if "/" in name or "\\" in name or name in (".", ".."):
+            return self._error_response("잘못된 디렉토리 이름입니다")
+
+        try:
+            parent = os.path.abspath(os.path.expanduser(parent))
+            if not os.path.isdir(parent):
+                return self._error_response("상위 디렉토리가 존재하지 않습니다", 400)
+
+            new_dir = os.path.join(parent, name)
+            if os.path.exists(new_dir):
+                return self._error_response("이미 존재하는 이름입니다", 409)
+
+            os.makedirs(new_dir)
+            self._json_response({"ok": True, "path": new_dir}, 201)
+        except PermissionError:
+            self._error_response("접근 권한 없음", 403)
+        except OSError as e:
+            self._error_response(f"디렉토리 생성 실패: {e}", 500)

package/web/handler_jobs.py

@@ -0,0 +1,249 @@
+"""
+Job 관련 HTTP 핸들러 Mixin
+
+포함 엔드포인트:
+  - GET  /api/jobs, /api/jobs/:id/result, /api/jobs/:id/stream, /api/jobs/:id/checkpoints
+  - GET  /api/session/:id/job
+  - POST /api/send, /api/upload, /api/service/start, /api/service/stop
+  - POST /api/jobs/:id/rewind
+  - DELETE /api/jobs, /api/jobs/:id
+"""
+
+import base64
+import json
+import os
+import time
+from urllib.parse import urlparse, parse_qs
+
+from config import LOGS_DIR, UPLOADS_DIR
+from utils import parse_meta_file
+
+IMAGE_EXTS = {".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"}
+ALLOWED_UPLOAD_EXTS = IMAGE_EXTS | {
+    ".txt", ".md", ".csv", ".json", ".xml", ".yaml", ".yml", ".toml",
+    ".py", ".js", ".ts", ".jsx", ".tsx", ".html", ".css", ".scss",
+    ".sh", ".bash", ".zsh", ".fish",
+    ".c", ".cpp", ".h", ".hpp", ".java", ".kt", ".go", ".rs", ".rb",
+    ".swift", ".m", ".r", ".sql", ".graphql",
+    ".log", ".env", ".conf", ".ini", ".cfg",
+    ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".pptx",
+    ".zip", ".tar", ".gz",
+}
+
+
+class JobHandlerMixin:
+
+    def _handle_jobs(self):
+        self._json_response(self._jobs_mod().get_all_jobs())
+
+    def _handle_job_result(self, job_id):
+        result, err = self._jobs_mod().get_job_result(job_id)
+        if err:
+            self._error_response(err, 404)
+        else:
+            self._json_response(result)
+
+    def _handle_upload(self):
+        body = self._read_body()
+        data_b64 = body.get("data", "")
+        filename = body.get("filename", "file")
+
+        if not data_b64:
+            return self._error_response("data 필드가 필요합니다")
+        if "," in data_b64:
+            data_b64 = data_b64.split(",", 1)[1]
+
+        try:
+            raw = base64.b64decode(data_b64)
+        except Exception:
+            return self._error_response("잘못된 base64 데이터")
+
+        ext = os.path.splitext(filename)[1].lower()
+        if ext not in ALLOWED_UPLOAD_EXTS:
+            ext = ext if ext else ".bin"
+        prefix = "img" if ext in IMAGE_EXTS else "file"
+        safe_name = f"{prefix}_{int(time.time())}_{os.getpid()}_{id(raw) % 10000}{ext}"
+
+        UPLOADS_DIR.mkdir(parents=True, exist_ok=True)
+        filepath = UPLOADS_DIR / safe_name
+        filepath.write_bytes(raw)
+
+        is_image = ext in IMAGE_EXTS
+        self._json_response({
+            "path": str(filepath),
+            "filename": safe_name,
+            "originalName": filename,
+            "size": len(raw),
+            "isImage": is_image,
+        }, 201)
+
+    def _handle_send(self):
+        body = self._read_body()
+        prompt = body.get("prompt", "").strip()
+        if not prompt:
+            return self._error_response("prompt 필드가 필요합니다")
+
+        result, err = self._jobs_mod().send_to_fifo(
+            prompt,
+            cwd=body.get("cwd") or None,
+            job_id=body.get("id") or None,
+            images=body.get("images") or None,
+            session=body.get("session") or None,
+        )
+        if err:
+            self._error_response(err, 502)
+        else:
+            self._json_response(result, 201)
+
+    def _handle_service_start(self):
+        ok, _ = self._jobs_mod().start_controller_service()
+        if ok:
+            self._json_response({"started": True})
+        else:
+            self._error_response("서비스 시작 실패", 500)
+
+    def _handle_service_stop(self):
+        ok, err = self._jobs_mod().stop_controller_service()
+        if ok:
+            self._json_response({"stopped": True})
+        else:
+            self._error_response(err or "서비스 종료 실패", 500)
+
+    def _handle_delete_job(self, job_id):
+        meta_file = LOGS_DIR / f"job_{job_id}.meta"
+        out_file = LOGS_DIR / f"job_{job_id}.out"
+
+        if not meta_file.exists():
+            return self._error_response("작업을 찾을 수 없습니다", 404)
+
+        meta = parse_meta_file(meta_file)
+        if meta and meta.get("STATUS") == "running":
+            pid = meta.get("PID")
+            if pid:
+                try:
+                    os.kill(int(pid), 0)
+                    return self._error_response("실행 중인 작업은 삭제할 수 없습니다", 409)
+                except (ProcessLookupError, ValueError, OSError):
+                    pass
+
+        try:
+            if meta_file.exists():
+                meta_file.unlink()
+            if out_file.exists():
+                out_file.unlink()
+            self._json_response({"deleted": True, "job_id": job_id})
+        except OSError as e:
+            self._error_response(f"삭제 실패: {e}", 500)
+
+    def _handle_delete_completed_jobs(self):
+        deleted = []
+        for mf in list(LOGS_DIR.glob("job_*.meta")):
+            meta = parse_meta_file(mf)
+            if not meta:
+                continue
+            status = meta.get("STATUS", "")
+            if status in ("done", "failed"):
+                pid = meta.get("PID")
+                if pid and status == "running":
+                    try:
+                        os.kill(int(pid), 0)
+                        continue
+                    except (ProcessLookupError, ValueError, OSError):
+                        pass
+                job_id = meta.get("JOB_ID", "")
+                out_file = LOGS_DIR / f"job_{job_id}.out"
+                try:
+                    mf.unlink()
+                    if out_file.exists():
+                        out_file.unlink()
+                    deleted.append(job_id)
+                except OSError:
+                    pass
+        self._json_response({"deleted": deleted, "count": len(deleted)})
+
+    def _handle_job_stream(self, job_id):
+        out_file = LOGS_DIR / f"job_{job_id}.out"
+        meta_file = LOGS_DIR / f"job_{job_id}.meta"
+
+        if not meta_file.exists():
+            return self._error_response("작업을 찾을 수 없습니다", 404)
+
+        parsed = urlparse(self.path)
+        qs = parse_qs(parsed.query)
+        offset = int(qs.get("offset", [0])[0])
+
+        if not out_file.exists():
+            return self._json_response({"events": [], "offset": 0, "done": False})
+
+        try:
+            events = []
+            with open(out_file, "r") as f:
+                f.seek(offset)
+                for raw_line in f:
+                    if '"type":"assistant"' not in raw_line and '"type":"result"' not in raw_line:
+                        continue
+                    try:
+                        evt = json.loads(raw_line)
+                        evt_type = evt.get("type", "")
+                        if evt_type == "assistant":
+                            msg = evt.get("message", {})
+                            content = msg.get("content", [])
+                            text_parts = [c.get("text", "") for c in content if c.get("type") == "text"]
+                            if text_parts:
+                                events.append({"type": "text", "text": "".join(text_parts)})
+                            for tp in content:
+                                if tp.get("type") == "tool_use":
+                                    events.append({
+                                        "type": "tool_use",
+                                        "tool": tp.get("name", ""),
+                                        "input": str(tp.get("input", ""))[:200]
+                                    })
+                        elif evt_type == "result":
+                            events.append({
+                                "type": "result",
+                                "result": evt.get("result", ""),
+                                "cost_usd": evt.get("total_cost_usd"),
+                                "duration_ms": evt.get("duration_ms"),
+                                "is_error": evt.get("is_error", False),
+                                "session_id": evt.get("session_id", "")
+                            })
+                    except json.JSONDecodeError:
+                        continue
+                new_offset = f.tell()
+
+            meta = parse_meta_file(meta_file)
+            done = meta.get("STATUS", "") in ("done", "failed")
+            self._json_response({"events": events, "offset": new_offset, "done": done})
+        except OSError as e:
+            self._error_response(f"스트림 읽기 실패: {e}", 500)
+
+    def _handle_job_checkpoints(self, job_id):
+        checkpoints, err = self._ckpt_mod().get_job_checkpoints(job_id)
+        if err:
+            self._error_response(err, 404)
+        else:
+            self._json_response(checkpoints)
+
+    def _handle_job_by_session(self, session_id):
+        jobs = self._jobs_mod().get_all_jobs()
+        matched = [j for j in jobs if j.get("session_id") == session_id]
+        if not matched:
+            return self._error_response(
+                f"Session ID '{session_id[:8]}...'에 해당하는 작업을 찾을 수 없습니다", 404)
+        self._json_response(matched[0])
+
+    def _handle_job_rewind(self, job_id):
+        body = self._read_body()
+        checkpoint_hash = body.get("checkpoint", "").strip()
+        new_prompt = body.get("prompt", "").strip()
+
+        if not checkpoint_hash:
+            return self._error_response("checkpoint 필드가 필요합니다")
+        if not new_prompt:
+            return self._error_response("prompt 필드가 필요합니다")
+
+        result, err = self._ckpt_mod().rewind_job(job_id, checkpoint_hash, new_prompt)
+        if err:
+            self._error_response(err, 400 if "찾을 수 없습니다" in err else 500)
+        else:
+            self._json_response(result, 201)

package/web/handler_sessions.py

@@ -0,0 +1,132 @@
+"""
+Session 목록 HTTP 핸들러 Mixin
+
+Claude Code 네이티브 세션 + history.log + job meta 파일을 통합하여 세션 목록을 제공한다.
+"""
+
+import json
+import os
+
+from config import LOGS_DIR, SESSIONS_DIR, CLAUDE_PROJECTS_DIR
+from utils import parse_meta_file, cwd_to_project_dir, scan_claude_sessions
+
+
+class SessionHandlerMixin:
+
+    def _handle_sessions(self, filter_cwd=None):
+        seen = {}
+
+        # 0) Claude Code 네이티브 세션 스캔
+        if filter_cwd:
+            proj_name = cwd_to_project_dir(filter_cwd)
+            project_dirs = [CLAUDE_PROJECTS_DIR / proj_name]
+        else:
+            if CLAUDE_PROJECTS_DIR.exists():
+                all_dirs = sorted(
+                    (d for d in CLAUDE_PROJECTS_DIR.iterdir() if d.is_dir()),
+                    key=lambda d: d.stat().st_mtime,
+                    reverse=True,
+                )
+                project_dirs = all_dirs[:15]
+            else:
+                project_dirs = []
+
+        for pd in project_dirs:
+            native = scan_claude_sessions(pd, limit=60)
+            for sid, info in native.items():
+                if sid not in seen:
+                    seen[sid] = info
+
+        # 1) Job meta 파일에서 보강
+        if LOGS_DIR.exists():
+            meta_files = sorted(
+                LOGS_DIR.glob("job_*.meta"),
+                key=lambda f: int(f.stem.split("_")[1]),
+                reverse=True,
+            )
+            for mf in meta_files:
+                meta = parse_meta_file(mf)
+                if not meta:
+                    continue
+                sid = meta.get("SESSION_ID", "").strip()
+                if not sid:
+                    continue
+
+                status = meta.get("STATUS", "unknown")
+                if status == "running" and meta.get("PID"):
+                    try:
+                        os.kill(int(meta["PID"]), 0)
+                    except (ProcessLookupError, ValueError, OSError):
+                        status = "done"
+
+                job_id = meta.get("JOB_ID", "")
+                cost_usd = None
+                if status in ("done", "failed"):
+                    out_file = LOGS_DIR / f"job_{job_id}.out"
+                    if out_file.exists():
+                        try:
+                            for line in open(out_file, "r"):
+                                try:
+                                    obj = json.loads(line.strip())
+                                    if obj.get("type") == "result":
+                                        cost_usd = obj.get("total_cost_usd")
+                                except json.JSONDecodeError:
+                                    continue
+                        except OSError:
+                            pass
+
+                entry = {
+                    "session_id": sid,
+                    "job_id":     job_id,
+                    "prompt":     meta.get("PROMPT", ""),
+                    "timestamp":  meta.get("CREATED_AT", ""),
+                    "status":     status,
+                    "cwd":        meta.get("CWD", ""),
+                    "cost_usd":   cost_usd,
+                    "slug":       "",
+                }
+
+                if sid not in seen:
+                    seen[sid] = entry
+                else:
+                    existing = seen[sid]
+                    if existing.get("job_id") is None:
+                        existing.update({"job_id": job_id, "status": status, "cost_usd": cost_usd})
+                    else:
+                        try:
+                            if int(job_id) > int(existing.get("job_id", 0)):
+                                seen[sid] = entry
+                        except (ValueError, TypeError):
+                            pass
+
+        # 2) history.log 보충
+        history_file = SESSIONS_DIR / "history.log"
+        if history_file.exists():
+            try:
+                for line in history_file.read_text("utf-8").strip().split("\n"):
+                    parts = line.split("|", 2)
+                    if len(parts) >= 2:
+                        ts, sid = parts[0].strip(), parts[1].strip()
+                        if not sid:
+                            continue
+                        prompt = parts[2].strip() if len(parts) > 2 else ""
+                        if sid not in seen:
+                            seen[sid] = {
+                                "session_id": sid, "job_id": None,
+                                "prompt": prompt, "timestamp": ts,
+                                "status": "done", "cwd": None,
+                                "cost_usd": None, "slug": "",
+                            }
+            except OSError:
+                pass
+
+        # cwd 필터 적용
+        if filter_cwd:
+            norm = os.path.normpath(filter_cwd)
+            seen = {
+                sid: s for sid, s in seen.items()
+                if s.get("cwd") and os.path.normpath(s["cwd"]) == norm
+            }
+
+        sessions = sorted(seen.values(), key=lambda s: s.get("timestamp") or "", reverse=True)
+        self._json_response(sessions[:50])

package/web/jobs.py

@@ -108,7 +108,15 @@ def get_job_result(job_id):
 
     meta = parse_meta_file(meta_file)
     if meta.get("STATUS") == "running":
-        return {"status": "running", "result": None}, None
+        # 프로세스가 실제로 살아있는지 확인 — meta가 running이지만 PID가 죽었으면 done 처리
+        pid = meta.get("PID")
+        if pid:
+            try:
+                os.kill(int(pid), 0)
+            except (ProcessLookupError, ValueError, OSError):
+                meta["STATUS"] = "done"
+        if meta.get("STATUS") == "running":
+            return {"status": "running", "result": None}, None
 
     if not out_file.exists():
         return None, "출력 파일이 없습니다"