aimb-x/agentgit
repositories / aimb-x / agentgit

agentgit public

git clone https://git.169.58.159.131.nip.io/aimb-x/agentgit.git
agentgit/httpd.py 7871 bytes 1 lines
1
"""agentgit — HTTP server: `POST /mcp` (MCP) plus a GitHub-style web UI in AIMB-X colors.
2
3
Public: `/mcp`, `/healthz`, `/`, `/r/<repo>`, `/search`, `/agents`, `/activity`.
4
Public pages only list `visibility=public` projects; `?token=<ADMIN_TOKEN>` unlocks all.
5
"""
6
from __future__ import annotations
7
8
import argparse
9
import json
10
import os
11
import sys
12
import threading
13
import time
14
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
15
from pathlib import Path
16
from urllib.parse import parse_qs, quote, urlparse
17
18
from . import mcp, web
19
from .db import Store, query_terms
20
21
DATA = Path(os.environ.get("AGENTGIT_DATA", "/var/lib/agentgit")).resolve()
22
DB = Path(os.environ.get("AGENTGIT_DB", str(DATA / "agentgit.kilat")))
23
ADMIN_TOKEN = os.environ.get("AGENTGIT_ADMIN_TOKEN", "")
24
MAX_BODY = 1 << 20
25
26
_store: Store | None = None
27
_store_lock = threading.Lock()
28
29
30
def store() -> Store:
31
global _store
32
with _store_lock:
33
if _store is None:
34
DATA.mkdir(parents=True, exist_ok=True)
35
_store = Store(DB)
36
return _store
37
38
39
def worker_loop(stop: threading.Event) -> None:
40
while not stop.is_set():
41
try:
42
job = store().next_job()
43
except Exception:
44
time.sleep(2)
45
continue
46
if not job:
47
stop.wait(1.0)
48
continue
49
project = store().project(job["project_id"])
50
store().mark_project(project["id"], "running")
51
try:
52
res = mcp.index_project(store(), project, DATA)
53
store().finish_job(job["id"], True, json.dumps(res))
54
except Exception as exc:
55
store().mark_project(project["id"], "failed", str(exc)[:400])
56
store().finish_job(job["id"], False, str(exc)[:400])
57
58
59
class Handler(BaseHTTPRequestHandler):
60
server_version = "agentgit/0.2"
61
protocol_version = "HTTP/1.1"
62
63
# ---------- util ----------
64
def _send(self, code: int, body: bytes, ctype: str = "application/json; charset=utf-8",
65
extra: dict | None = None) -> None:
66
self.send_response(code)
67
self.send_header("Content-Type", ctype)
68
self.send_header("Content-Length", str(len(body)))
69
self.send_header("Cache-Control", "no-store")
70
for k, v in (extra or {}).items():
71
self.send_header(k, v)
72
self.end_headers()
73
if self.command != "HEAD":
74
self.wfile.write(body)
75
76
def _json(self, code: int, obj) -> None:
77
self._send(code, json.dumps(obj, ensure_ascii=False).encode())
78
79
def _html(self, code: int, page: str) -> None:
80
self._send(code, page.encode(), "text/html; charset=utf-8")
81
82
def _token(self) -> str:
83
auth = self.headers.get("Authorization", "")
84
if auth.startswith("Bearer "):
85
return auth[7:].strip()
86
return (self.headers.get("X-Agentgit-Token") or "").strip()
87
88
@staticmethod
89
def _is_admin(query: dict) -> bool:
90
tok = (query.get("token") or [""])[0]
91
return bool(ADMIN_TOKEN) and tok == ADMIN_TOKEN
92
93
def log_message(self, fmt: str, *args) -> None:
94
sys.stdout.write("%s %s\n" % (time.strftime("%Y-%m-%dT%H:%M:%S"), fmt % args))
95
96
# ---------- routes ----------
97
def do_HEAD(self) -> None: # noqa: N802
98
self.do_GET()
99
100
def do_GET(self) -> None: # noqa: N802
101
u = urlparse(self.path)
102
q = parse_qs(u.query)
103
path = u.path.rstrip("/") or "/"
104
admin = self._is_admin(q)
105
token = (q.get("token") or [""])[0] if admin else ""
106
107
if path == "/healthz":
108
return self._json(200, {"ok": True, "service": "agentgit", **store().stats()})
109
110
if path == "/static/app.css":
111
return self._send(200, web.CSS.encode(), "text/css; charset=utf-8",
112
{"Cache-Control": "public, max-age=300"})
113
114
if path in ("/", "/repos"):
115
projects = store().all_projects() if admin else store().public_projects()
116
items = []
117
for p in projects:
118
d = dict(p)
119
d["languages"] = store().project_langs(p["id"])
120
items.append(d)
121
return self._html(200, web.page_home(store().stats(), items, admin, token))
122
123
if path == "/agents":
124
return self._html(200, web.page_agents([dict(a) for a in store().agents_list()], admin))
125
126
if path == "/activity":
127
return self._html(200, web.page_activity([dict(e) for e in store().recent_events()], admin))
128
129
if path == "/search":
130
query = (q.get("q") or [""])[0].strip()
131
projects = store().all_projects() if admin else store().public_projects()
132
ids = [p["id"] for p in projects]
133
rows = store().search(query, ids, 20) if query else []
134
names = {p["id"]: p["name"] for p in projects}
135
results = [
136
{"project": names.get(r["project_id"], "?"), "path": r["path"],
137
"lines": f'{r["start_line"]}-{r["end_line"]}',
138
"snip_html": web.mark_snippet(r["snip"], query_terms(query))}
139
for r in rows
140
]
141
return self._html(200, web.page_search(query, results, len(projects), admin))
142
143
if path == "/admin":
144
if not admin:
145
return self._html(404, web.page_404(False))
146
return self._send(302, b"", "text/plain", {"Location": f"/?token={quote(token)}"})
147
148
if path.startswith("/r/"):
149
name = u.path[3:].strip("/")
150
proj = store().project_by_name(name, only_public=not admin)
151
if not proj:
152
return self._html(404, web.page_404(admin))
153
pid = proj["id"]
154
files = [dict(f) for f in store().file_map(pid)]
155
current = (q.get("path") or [None])[0]
156
chunks: list[dict] = []
157
if current:
158
chunks = [dict(r) for r in store().doc_text(pid, current, 1)]
159
if not chunks:
160
return self._html(404, web.page_404(admin))
161
langs = store().project_langs(pid)
162
return self._html(200, web.page_repo(dict(proj), files, current, chunks, admin,
163
token, langs, {"languages": langs}))
164
165
return self._html(404, web.page_404(admin))
166
167
def do_POST(self) -> None: # noqa: N802
168
u = urlparse(self.path)
169
if u.path != "/mcp":
170
return self._json(404, {"error": "not found"})
171
try:
172
n = int(self.headers.get("Content-Length") or 0)
173
except ValueError:
174
n = 0
175
if n > MAX_BODY:
176
return self._json(413, {"error": "body terlalu besar"})
177
body = self.rfile.read(n) if n else b""
178
token = self._token()
179
if not token:
180
token = (parse_qs(u.query).get("token") or [""])[0]
181
code, res = mcp.handle_http(store(), token, body, DATA)
182
if res is None:
183
return self._send(204, b"")
184
return self._json(code, res)
185
186
187
def serve(host: str, port: int) -> None:
188
store()
189
stop = threading.Event()
190
threading.Thread(target=worker_loop, args=(stop,), daemon=True).start()
191
httpd = ThreadingHTTPServer((host, port), Handler)
192
httpd.daemon_threads = True
193
print(f"agentgit mendengarkan di http://{host}:{port} · data {DATA}")
194
try:
195
httpd.serve_forever()
196
except KeyboardInterrupt:
197
pass
198
finally:
199
stop.set()
200
httpd.server_close()
201
202
203
def main(argv=None) -> int:
204
ap = argparse.ArgumentParser(prog="agentgit-server")
205
ap.add_argument("--host", default=os.environ.get("AGENTGIT_HOST", "127.0.0.1"))
206
ap.add_argument("--port", type=int, default=int(os.environ.get("AGENTGIT_PORT", "8188")))
207
a = ap.parse_args(argv)
208
serve(a.host, a.port)
209
return 0
210
211
212
if __name__ == "__main__":
213
raise SystemExit(main())