Upload 3 files

backend/file_manager.py

@@ -0,0 +1,30 @@
+import os
+import json
+
+BASE_DIR = "/tmp/workspaces"
+
+class FileManager:
+    def __init__(self, session_id):
+        self.session_dir = os.path.join(BASE_DIR, session_id)
+        os.makedirs(self.session_dir, exist_ok=True)
+
+    def save(self, filename, content):
+        path = os.path.join(self.session_dir, filename)
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "w") as f:
+            f.write(content)
+
+    def load(self, filename):
+        path = os.path.join(self.session_dir, filename)
+        if os.path.exists(path):
+            with open(path, "r") as f:
+                return f.read()
+        return None
+
+    def list_files(self):
+        files = []
+        for root, dirs, filenames in os.walk(self.session_dir):
+            rel = os.path.relpath(root, self.session_dir)
+            for f in filenames:
+                files.append(os.path.join(rel, f))
+        return files

backend/main.py

@@ -0,0 +1,86 @@
+import os
+import asyncio
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException
+from fastapi.responses import FileResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+from typing import Optional
+import uuid
+
+from .ai_model import generate, generate_with_debug
+from .terminal import TerminalManager
+from .file_manager import FileManager
+
+app = FastAPI()
+
+# Mount static files (hasil build React)
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+# Manager untuk terminal sessions
+term_manager = TerminalManager()
+file_managers = {}
+
+class GenerateRequest(BaseModel):
+    prompt: str
+    debug: bool = False
+
+class SaveFileRequest(BaseModel):
+    session_id: str
+    filename: str
+    content: str
+
+class LoadFileRequest(BaseModel):
+    session_id: str
+    filename: str
+
+@app.get("/")
+async def serve_frontend():
+    return FileResponse("static/index.html")
+
+@app.post("/api/generate")
+async def api_generate(req: GenerateRequest):
+    try:
+        if req.debug:
+            code = generate_with_debug(req.prompt)
+        else:
+            code = generate(req.prompt)
+        return {"code": code}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/api/files/save")
+async def save_file(req: SaveFileRequest):
+    if req.session_id not in file_managers:
+        file_managers[req.session_id] = FileManager(req.session_id)
+    fm = file_managers[req.session_id]
+    fm.save(req.filename, req.content)
+    return {"status": "ok"}
+
+@app.get("/api/files/{session_id}/{filename:path}")
+async def load_file(session_id: str, filename: str):
+    if session_id not in file_managers:
+        file_managers[session_id] = FileManager(session_id)
+    fm = file_managers[session_id]
+    content = fm.load(filename)
+    if content is None:
+        raise HTTPException(status_code=404, detail="File not found")
+    return {"content": content}
+
+@app.get("/api/files/{session_id}")
+async def list_files(session_id: str):
+    if session_id not in file_managers:
+        file_managers[session_id] = FileManager(session_id)
+    fm = file_managers[session_id]
+    return {"files": fm.list_files()}
+
+@app.websocket("/ws/terminal/{session_id}")
+async def websocket_terminal(websocket: WebSocket, session_id: str):
+    await websocket.accept()
+    term = term_manager.get_session(session_id)
+    term.add_websocket(websocket)
+    try:
+        while True:
+            command = await websocket.receive_text()
+            term.write(command)
+    except WebSocketDisconnect:
+        term.remove_websocket(websocket)

backend/terminal.py

@@ -0,0 +1,65 @@
+import os
+import pty
+import select
+import termios
+import struct
+import fcntl
+import threading
+import subprocess
+
+class TerminalSession:
+    def __init__(self, session_id):
+        self.session_id = session_id
+        self.workspace = f"/tmp/workspaces/{session_id}"
+        os.makedirs(self.workspace, exist_ok=True)
+        self.master_fd, self.slave_fd = pty.openpty()
+        self.process = subprocess.Popen(
+            ["/bin/bash"],
+            preexec_fn=os.setsid,
+            stdin=self.slave_fd,
+            stdout=self.slave_fd,
+            stderr=self.slave_fd,
+            cwd=self.workspace,
+            universal_newlines=True,
+        )
+        self.websockets = []
+        self.running = True
+        self.thread = threading.Thread(target=self._read_output)
+        self.thread.daemon = True
+        self.thread.start()
+
+    def _read_output(self):
+        while self.running:
+            try:
+                r, _, _ = select.select([self.master_fd], [], [], 0.1)
+                if self.master_fd in r:
+                    data = os.read(self.master_fd, 1024)
+                    if data:
+                        for ws in self.websockets:
+                            asyncio.run_coroutine_threadsafe(ws.send_text(data.decode()), asyncio.get_event_loop())
+            except (OSError, ValueError):
+                break
+
+    def write(self, data):
+        os.write(self.master_fd, data.encode())
+
+    def add_websocket(self, ws):
+        self.websockets.append(ws)
+
+    def remove_websocket(self, ws):
+        self.websockets.remove(ws)
+
+    def close(self):
+        self.running = False
+        self.process.terminate()
+        os.close(self.master_fd)
+        os.close(self.slave_fd)
+
+class TerminalManager:
+    def __init__(self):
+        self.sessions = {}
+
+    def get_session(self, session_id):
+        if session_id not in self.sessions:
+            self.sessions[session_id] = TerminalSession(session_id)
+        return self.sessions[session_id]