session-trail 0.2.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
agent_trail/server.py ADDED
@@ -0,0 +1,260 @@
1
+ from __future__ import annotations
2
+
3
+ import json
4
+ import secrets
5
+ import shutil
6
+ import threading
7
+ from dataclasses import asdict
8
+ from datetime import datetime, time, timezone
9
+ from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
10
+ from pathlib import Path
11
+ from typing import Any
12
+ from urllib.parse import parse_qs, urlsplit
13
+
14
+ from .launcher import TerminalLauncher
15
+ from .models import SessionFilter
16
+ from .scanner import ScanService
17
+ from .store import LocalStore
18
+
19
+
20
+ class LocalServer:
21
+ def __init__(
22
+ self,
23
+ store: LocalStore,
24
+ scanner: ScanService,
25
+ port: int = 0,
26
+ launcher: TerminalLauncher | None = None,
27
+ ) -> None:
28
+ self.store = store
29
+ self.scanner = scanner
30
+ self.launcher = launcher or TerminalLauncher()
31
+ self.key = secrets.token_urlsafe(32)
32
+ self._httpd = ThreadingHTTPServer(("127.0.0.1", port), _RequestHandler)
33
+ self._httpd.app = self
34
+ self._thread: threading.Thread | None = None
35
+ self._base_url = f"http://127.0.0.1:{self._httpd.server_port}"
36
+
37
+ @property
38
+ def base_url(self) -> str:
39
+ return self._base_url
40
+
41
+ def start(self) -> str:
42
+ if self._thread is None or not self._thread.is_alive():
43
+ self._thread = threading.Thread(
44
+ target=self._httpd.serve_forever,
45
+ name="agent-trail-http",
46
+ daemon=True,
47
+ )
48
+ self._thread.start()
49
+ return f"{self._base_url}/?key={self.key}"
50
+
51
+ def stop(self) -> None:
52
+ self._httpd.shutdown()
53
+ self._httpd.server_close()
54
+ if self._thread is not None:
55
+ self._thread.join(timeout=5)
56
+
57
+ def _sessions(self, query: dict[str, list[str]]) -> dict[str, Any]:
58
+ sources = tuple(query.get("source", []))
59
+ if "sources" in query:
60
+ sources += tuple(
61
+ source for source in query["sources"][-1].split(",") if source
62
+ )
63
+ filters = SessionFilter(
64
+ since=self._date_filter(query, "since"),
65
+ until=self._date_filter(query, "until"),
66
+ sources=sources,
67
+ workdir=self._one(query, "workdir"),
68
+ query=self._one(query, "query"),
69
+ limit=self._integer(query, "limit", 200, 1, 1000),
70
+ offset=self._integer(query, "offset", 0, 0, 1_000_000),
71
+ )
72
+ sessions = self.store.list_sessions(filters)
73
+ records = []
74
+ for session in sessions:
75
+ record = asdict(session)
76
+ record["workdir_exists"] = Path(session.workdir).is_dir()
77
+ adapter = next(
78
+ (item for item in self.scanner.adapters if item.source == session.source),
79
+ None,
80
+ )
81
+ plan = adapter.resume_plan(session) if adapter is not None else None
82
+ record["cli_available"] = bool(
83
+ plan
84
+ and plan.kind == "cli"
85
+ and plan.executable
86
+ and shutil.which(plan.executable)
87
+ )
88
+ records.append(record)
89
+ return {"sessions": records}
90
+
91
+ def _status(self) -> dict[str, Any]:
92
+ statuses = [asdict(status) for status in self.scanner.statuses]
93
+ scanned = [status["last_scanned_at"] for status in statuses if status["last_scanned_at"]]
94
+ sessions = self.store.list_sessions(SessionFilter(limit=1_000_000))
95
+ return {
96
+ "sources": statuses,
97
+ "last_scanned_at": max(scanned) if scanned else None,
98
+ "session_count": len(sessions),
99
+ }
100
+
101
+ def _resume(self, payload: Any) -> tuple[int, dict[str, Any]]:
102
+ if not isinstance(payload, dict):
103
+ raise ValueError("invalid request")
104
+ source = payload.get("source")
105
+ session_id = payload.get("session_id")
106
+ if (
107
+ not isinstance(source, str)
108
+ or not isinstance(session_id, str)
109
+ or not source
110
+ or not session_id
111
+ or len(source) > 100
112
+ or len(session_id) > 1000
113
+ ):
114
+ raise ValueError("invalid session reference")
115
+ session = self.store.get_session(source, session_id)
116
+ adapter = next(
117
+ (item for item in self.scanner.adapters if item.source == source), None
118
+ )
119
+ if session is None or adapter is None:
120
+ return 404, {"status": "unavailable", "message": "session_not_found"}
121
+ if session.source_missing:
122
+ return 409, {"status": "unavailable", "message": "session_source_missing"}
123
+ plan = adapter.resume_plan(session)
124
+ if plan.kind != "cli":
125
+ return 409, {"status": "unavailable", "message": "session_view_only"}
126
+ result = self.launcher.launch(plan)
127
+ if not result.ok:
128
+ return 409, {"status": "unavailable", "message": result.message}
129
+ return 200, {"status": "launched", "message": result.message}
130
+
131
+ @staticmethod
132
+ def _one(query: dict[str, list[str]], key: str) -> str | None:
133
+ values = query.get(key)
134
+ if not values:
135
+ return None
136
+ if len(values) != 1 or len(values[0]) > 1000:
137
+ raise ValueError("invalid query")
138
+ return values[0]
139
+
140
+ @staticmethod
141
+ def _integer(
142
+ query: dict[str, list[str]], key: str, default: int, minimum: int, maximum: int
143
+ ) -> int:
144
+ raw = LocalServer._one(query, key)
145
+ if raw is None:
146
+ return default
147
+ value = int(raw)
148
+ if not minimum <= value <= maximum:
149
+ raise ValueError("invalid query")
150
+ return value
151
+
152
+ @staticmethod
153
+ def _date_filter(query: dict[str, list[str]], key: str) -> str | None:
154
+ raw = LocalServer._one(query, key)
155
+ if raw is None:
156
+ return None
157
+ parsed = datetime.fromisoformat(raw.replace("Z", "+00:00"))
158
+ if parsed.tzinfo is None:
159
+ parsed = parsed.replace(tzinfo=timezone.utc)
160
+ return parsed.astimezone(timezone.utc).isoformat()
161
+
162
+
163
+ class _RequestHandler(BaseHTTPRequestHandler):
164
+ server_version = "AgentTrail"
165
+ sys_version = ""
166
+
167
+ @property
168
+ def app(self) -> LocalServer:
169
+ return self.server.app
170
+
171
+ def do_GET(self) -> None:
172
+ if not self._valid_host():
173
+ self._error(403)
174
+ return
175
+ path = urlsplit(self.path).path
176
+ if path.startswith("/api/") and not self._valid_key():
177
+ self._error(403)
178
+ return
179
+ try:
180
+ if path == "/api/sessions":
181
+ self._json(200, self.app._sessions(parse_qs(urlsplit(self.path).query)))
182
+ elif path == "/api/status":
183
+ self._json(200, self.app._status())
184
+ elif path == "/":
185
+ self._static("index.html", "text/html; charset=utf-8")
186
+ elif path == "/styles.css":
187
+ self._static("styles.css", "text/css; charset=utf-8")
188
+ elif path == "/app.js":
189
+ self._static("app.js", "text/javascript; charset=utf-8")
190
+ elif path == "/i18n.js":
191
+ self._static("i18n.js", "text/javascript; charset=utf-8")
192
+ else:
193
+ self._error(404)
194
+ except (ValueError, TypeError):
195
+ self._error(400)
196
+
197
+ def do_POST(self) -> None:
198
+ if not self._valid_host() or not self._valid_key() or not self._valid_origin():
199
+ self._error(403)
200
+ return
201
+ path = urlsplit(self.path).path
202
+ if path == "/api/refresh":
203
+ self.app.scanner.scan_all()
204
+ self._json(200, self.app._status())
205
+ elif path == "/api/resume":
206
+ try:
207
+ length = int(self.headers.get("Content-Length", "0"))
208
+ if not 0 < length <= 8192:
209
+ raise ValueError("invalid content length")
210
+ payload = json.loads(self.rfile.read(length).decode("utf-8"))
211
+ status, response = self.app._resume(payload)
212
+ self._json(status, response)
213
+ except (ValueError, TypeError, UnicodeError, json.JSONDecodeError):
214
+ self._error(400)
215
+ else:
216
+ self._error(404)
217
+
218
+ def _valid_host(self) -> bool:
219
+ return self.headers.get("Host", "") == f"127.0.0.1:{self.server.server_port}"
220
+
221
+ def _valid_key(self) -> bool:
222
+ supplied = self.headers.get("X-Agent-Trail-Key", "")
223
+ return bool(supplied) and secrets.compare_digest(supplied, self.app.key)
224
+
225
+ def _valid_origin(self) -> bool:
226
+ return self.headers.get("Origin", "") == self.app.base_url
227
+
228
+ def _json(self, status: int, value: dict[str, Any]) -> None:
229
+ self._respond(status, json.dumps(value, ensure_ascii=False).encode("utf-8"), "application/json; charset=utf-8")
230
+
231
+ def _error(self, status: int) -> None:
232
+ self._json(status, {"error": "request rejected" if status == 403 else "invalid request"})
233
+
234
+ def _static(self, name: str, content_type: str) -> None:
235
+ path = Path(__file__).parent / "static" / name
236
+ try:
237
+ content = path.read_bytes()
238
+ except OSError:
239
+ self._error(404)
240
+ return
241
+ self._respond(200, content, content_type)
242
+
243
+ def _respond(self, status: int, content: bytes, content_type: str) -> None:
244
+ self.send_response(status)
245
+ self.send_header("Content-Type", content_type)
246
+ self.send_header("Content-Length", str(len(content)))
247
+ self.send_header("Cache-Control", "no-store")
248
+ self.send_header("X-Content-Type-Options", "nosniff")
249
+ self.send_header("Referrer-Policy", "no-referrer")
250
+ self.send_header("X-Frame-Options", "DENY")
251
+ self.send_header(
252
+ "Content-Security-Policy",
253
+ "default-src 'self'; connect-src 'self'; img-src 'self' data:; "
254
+ "style-src 'self'; script-src 'self'; base-uri 'none'; frame-ancestors 'none'",
255
+ )
256
+ self.end_headers()
257
+ self.wfile.write(content)
258
+
259
+ def log_message(self, format: str, *args: object) -> None:
260
+ return