pipane 0.1.5 → 0.1.7

package/dist/server/server/rest-api.js

@@ -1,289 +1,179 @@
-/**
- * REST API endpoints for pipane.
- *
- * Stateless handlers that read session data from JSONL files on disk.
- */
-import { existsSync, readFileSync, readdirSync, watchFile } from "node:fs";
-import { unlink } from "node:fs/promises";
-import path from "node:path";
-import { buildSessionContext, parseSessionEntries } from "@mariozechner/pi-coding-agent";
-import { SessionIndex } from "./session-index.js";
-import { LocalSettingsStore } from "./local-settings.js";
-let localSettingsStore;
-let sessionIndex;
-let localSettingsWatcherStarted = false;
-function startLocalSettingsWatcher(onLocalSettingsReloaded) {
-    if (localSettingsWatcherStarted)
-        return;
-    localSettingsWatcherStarted = true;
-    let debounceTimer = null;
-    watchFile(localSettingsStore.path, { interval: 500 }, () => {
-        if (debounceTimer)
-            clearTimeout(debounceTimer);
-        debounceTimer = setTimeout(async () => {
-            const changed = localSettingsStore.reloadFromDiskIfValid();
-            if (!changed)
-                return;
-            await sessionIndex.invalidateAll();
-            onLocalSettingsReloaded?.();
-        }, 150);
-    });
-}
-async function readJsonBody(req) {
+/** HTTP compatibility facade over the carrier-neutral backend service. */
+import { LocalBackendApi, LocalBackendApiError } from "./local-backend-api.js";
+async function readJsonBody(req, maxBytes = Number.POSITIVE_INFINITY) {
     const chunks = [];
-    for await (const chunk of req)
+    let size = 0;
+    for await (const chunk of req) {
+        size += chunk.length;
+        if (size > maxBytes)
+            throw new LocalBackendApiError("Request body is too large", 413, "invalid_request");
         chunks.push(chunk);
-    const raw = Buffer.concat(chunks).toString();
-    return JSON.parse(raw || "{}");
+    }
+    return JSON.parse(Buffer.concat(chunks).toString() || "{}");
+}
+function sendError(res, error) {
+    if (error instanceof LocalBackendApiError) {
+        res.status(error.status).json({ error: error.message, code: error.code });
+        return;
+    }
+    res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
 }
 export function registerRestApi(app, options = {}) {
-    const traceStore = options.traceStore;
-    localSettingsStore = options.localSettingsStore ?? new LocalSettingsStore();
-    sessionIndex = new SessionIndex({
-        cwdDisplayFormatter: (cwd) => localSettingsStore.formatCwdTitle(cwd),
-    });
-    startLocalSettingsWatcher(options.onLocalSettingsReloaded);
-    app.post("/api/debug/load-trace/event", async (req, res) => {
+    const api = options.api ?? new LocalBackendApi(options);
+    app.get("/api/sessions", async (_req, res) => {
         try {
-            if (!traceStore) {
-                res.status(404).json({ error: "Tracing disabled" });
-                return;
-            }
-            const chunks = [];
-            for await (const chunk of req)
-                chunks.push(chunk);
-            const body = JSON.parse(Buffer.concat(chunks).toString() || "{}");
-            const traceId = String(body.traceId || req.headers["x-pi-trace-id"] || "");
-            if (!traceId) {
-                res.status(400).json({ error: "Missing traceId" });
-                return;
-            }
-            traceStore.record(traceId, {
-                ts: new Date().toISOString(),
-                source: "frontend",
-                kind: body.durationMs != null ? "span" : "instant",
-                name: String(body.name || "frontend_event"),
-                durationMs: typeof body.durationMs === "number" ? body.durationMs : undefined,
-                attrs: body.attrs && typeof body.attrs === "object" ? body.attrs : undefined,
-            });
-            res.json({ ok: true });
+            res.json(await api.listSessions());
         }
-        catch (err) {
-            res.status(500).json({ error: err.message });
+        catch (error) {
+            sendError(res, error);
         }
     });
-    app.get("/api/debug/load-trace/latest", (_req, res) => {
-        if (!traceStore) {
-            res.status(404).json({ error: "Tracing disabled" });
-            return;
+    app.delete("/api/sessions", async (req, res) => {
+        try {
+            const body = await readJsonBody(req);
+            if (typeof body.path !== "string")
+                throw new LocalBackendApiError("Missing 'path' string", 400, "invalid_request");
+            await api.deleteSession(body.path);
+            res.json({ success: true });
+        }
+        catch (error) {
+            sendError(res, error);
         }
-        res.json({ traces: traceStore.getLatest() });
     });
-    app.get("/api/debug/load-trace/:traceId", (req, res) => {
-        if (!traceStore) {
-            res.status(404).json({ error: "Tracing disabled" });
-            return;
+    app.get("/api/sessions/fork-messages", async (req, res) => {
+        try {
+            if (typeof req.query.path !== "string")
+                throw new LocalBackendApiError("Missing 'path' query parameter", 400, "invalid_request");
+            res.json({ messages: await api.listForkMessages(req.query.path) });
         }
-        const trace = traceStore.get(req.params.traceId);
-        if (!trace) {
-            res.status(404).json({ error: "Trace not found" });
-            return;
+        catch (error) {
+            sendError(res, error);
         }
-        res.json(trace);
     });
-    app.get("/api/sessions", async (_req, res) => {
+    app.get("/api/sessions/raw", async (req, res) => {
         try {
-            res.json(await sessionIndex.listSessions());
+            if (typeof req.query.path !== "string")
+                throw new LocalBackendApiError("Missing 'path' query parameter", 400, "invalid_request");
+            res.type("text/plain").send(await api.getRawSession(req.query.path));
         }
-        catch (err) {
-            res.status(500).json({ error: err.message });
+        catch (error) {
+            sendError(res, error);
         }
     });
-    app.get("/api/settings/local", (_req, res) => {
+    app.get("/api/files/content", async (req, res) => {
         try {
-            res.json(localSettingsStore.read());
+            if (typeof req.query.sessionPath !== "string" || typeof req.query.path !== "string") {
+                throw new LocalBackendApiError("Missing 'sessionPath' or 'path' query parameter", 400, "invalid_request");
+            }
+            res.json(await api.getFileContent(req.query.sessionPath, req.query.path));
         }
-        catch (err) {
-            res.status(500).json({ error: err.message });
+        catch (error) {
+            sendError(res, error);
         }
     });
-    app.post("/api/settings/local/validate", async (req, res) => {
+    app.post("/api/files/uploads", async (req, res) => {
         try {
-            const body = await readJsonBody(req);
-            if (typeof body.content !== "string") {
-                res.status(400).json({ error: "Missing 'content' string" });
-                return;
+            const body = await readJsonBody(req, 512 * 1024);
+            if (typeof body.fileName !== "string" || typeof body.mimeType !== "string" || typeof body.size !== "number") {
+                throw new LocalBackendApiError("Missing file upload metadata", 400, "invalid_request");
             }
-            res.json(localSettingsStore.validate(body.content));
+            res.status(201).json(await api.createFileUpload({
+                fileName: body.fileName,
+                mimeType: body.mimeType,
+                size: body.size,
+            }));
         }
-        catch (err) {
-            res.status(500).json({ error: err.message });
+        catch (error) {
+            sendError(res, error);
         }
     });
-    app.patch("/api/settings/local", async (req, res) => {
+    app.post("/api/files/uploads/:uploadId/chunks", async (req, res) => {
         try {
-            const body = await readJsonBody(req);
-            if (!body || typeof body !== "object") {
-                res.status(400).json({ error: "Request body must be a JSON object" });
-                return;
+            const body = await readJsonBody(req, 512 * 1024);
+            if (typeof body.offset !== "number" || typeof body.data !== "string") {
+                throw new LocalBackendApiError("Missing file upload chunk", 400, "invalid_request");
             }
-            const result = localSettingsStore.patch(body);
-            if (!result.valid) {
-                res.status(400).json(result);
-                return;
-            }
-            await sessionIndex.invalidateAll();
-            options.onLocalSettingsReloaded?.();
-            res.json(result);
+            res.json(await api.appendFileUpload({
+                uploadId: req.params.uploadId,
+                offset: body.offset,
+                data: body.data,
+            }));
         }
-        catch (err) {
-            res.status(500).json({ error: err.message });
+        catch (error) {
+            sendError(res, error);
         }
     });
-    app.put("/api/settings/local", async (req, res) => {
+    app.post("/api/files/uploads/:uploadId/complete", async (req, res) => {
         try {
-            const body = await readJsonBody(req);
-            if (typeof body.content !== "string") {
-                res.status(400).json({ error: "Missing 'content' string" });
-                return;
-            }
-            const result = localSettingsStore.save(body.content);
-            if (!result.valid) {
-                res.status(400).json(result);
-                return;
-            }
-            await sessionIndex.invalidateAll();
-            options.onLocalSettingsReloaded?.();
-            res.json(result);
+            res.json(await api.completeFileUpload(req.params.uploadId));
         }
-        catch (err) {
-            res.status(500).json({ error: err.message });
+        catch (error) {
+            sendError(res, error);
         }
     });
-    app.delete("/api/sessions", async (req, res) => {
+    app.get("/api/browse", async (req, res) => {
         try {
-            const chunks = [];
-            for await (const chunk of req)
-                chunks.push(chunk);
-            const body = JSON.parse(Buffer.concat(chunks).toString());
-            const { path: sessionPath } = body;
-            if (!sessionPath || typeof sessionPath !== "string") {
-                res.status(400).json({ error: "Missing session path" });
-                return;
-            }
-            if (!sessionPath.endsWith(".jsonl") || !existsSync(sessionPath)) {
-                res.status(404).json({ error: "Session not found" });
-                return;
-            }
-            await unlink(sessionPath);
-            res.json({ success: true });
+            res.json(await api.browseDirectory(typeof req.query.path === "string" ? req.query.path : ""));
         }
-        catch (err) {
-            res.status(500).json({ error: err.message });
+        catch (error) {
+            sendError(res, error);
         }
     });
-    app.get("/api/sessions/messages", (req, res) => {
+    app.post("/api/directories", async (req, res) => {
         try {
-            const sessionPath = req.query.path;
-            if (!sessionPath || !sessionPath.endsWith(".jsonl")) {
-                res.status(400).json({ error: "Missing or invalid session path" });
-                return;
-            }
-            if (!existsSync(sessionPath)) {
-                res.status(404).json({ error: "Session file not found" });
-                return;
+            const body = await readJsonBody(req, 16 * 1024);
+            if (typeof body.parentPath !== "string" || typeof body.name !== "string") {
+                throw new LocalBackendApiError("Missing 'parentPath' or 'name' string", 400, "invalid_request");
             }
-            const content = readFileSync(sessionPath, "utf8");
-            const entries = parseSessionEntries(content);
-            const context = buildSessionContext(entries);
-            res.json({
-                messages: context.messages,
-                model: context.model,
-                thinkingLevel: context.thinkingLevel,
-            });
+            res.status(201).json(await api.createDirectory(body.parentPath, body.name));
         }
-        catch (err) {
-            res.status(500).json({ error: err.message });
+        catch (error) {
+            sendError(res, error);
         }
     });
-    app.get("/api/sessions/fork-messages", (req, res) => {
+    app.get("/api/settings/local", async (_req, res) => {
         try {
-            const sessionPath = req.query.path;
-            if (!sessionPath || !sessionPath.endsWith(".jsonl")) {
-                res.status(400).json({ error: "Missing or invalid session path" });
-                return;
-            }
-            if (!existsSync(sessionPath)) {
-                res.status(404).json({ error: "Session file not found" });
-                return;
-            }
-            const content = readFileSync(sessionPath, "utf8");
-            const entries = parseSessionEntries(content);
-            const messages = [];
-            for (const entry of entries) {
-                if (entry.type !== "message")
-                    continue;
-                const msg = entry.message;
-                if (!msg || msg.role !== "user")
-                    continue;
-                let text = "";
-                if (typeof msg.content === "string") {
-                    text = msg.content;
-                }
-                else if (Array.isArray(msg.content)) {
-                    text = msg.content
-                        .filter((c) => c.type === "text")
-                        .map((c) => c.text)
-                        .join("");
-                }
-                if (text && entry.id) {
-                    messages.push({ entryId: entry.id, text });
-                }
-            }
-            res.json({ messages });
+            res.json(await api.getLocalSettings());
         }
-        catch (err) {
-            res.status(500).json({ error: err.message });
+        catch (error) {
+            sendError(res, error);
         }
     });
-    app.get("/api/sessions/raw", (req, res) => {
+    app.post("/api/settings/local/validate", async (req, res) => {
         try {
-            const sessionPath = req.query.path;
-            if (!sessionPath || !sessionPath.endsWith(".jsonl")) {
-                res.status(400).json({ error: "Missing or invalid session path" });
-                return;
-            }
-            if (!existsSync(sessionPath)) {
-                res.status(404).json({ error: "Session file not found" });
-                return;
-            }
-            const content = readFileSync(sessionPath, "utf8");
-            res.type("text/plain").send(content);
+            const body = await readJsonBody(req);
+            if (typeof body.content !== "string")
+                throw new LocalBackendApiError("Missing 'content' string", 400, "invalid_request");
+            res.json(await api.validateLocalSettings(body.content));
         }
-        catch (err) {
-            res.status(500).json({ error: err.message });
+        catch (error) {
+            sendError(res, error);
         }
     });
-    app.get("/api/browse", (req, res) => {
+    app.patch("/api/settings/local", async (req, res) => {
         try {
-            const requestedPath = req.query.path || process.env.HOME || "/";
-            const resolved = path.resolve(requestedPath.replace(/^~/, process.env.HOME || "/"));
-            if (!existsSync(resolved)) {
-                res.status(404).json({ error: "Path not found" });
-                return;
+            const body = await readJsonBody(req);
+            if (!body || typeof body !== "object" || Array.isArray(body)) {
+                throw new LocalBackendApiError("Request body must be a JSON object", 400, "invalid_request");
             }
-            const entries = readdirSync(resolved, { withFileTypes: true });
-            const dirs = entries
-                .filter((e) => e.isDirectory() && !e.name.startsWith("."))
-                .map((e) => ({
-                name: e.name,
-                path: path.join(resolved, e.name),
-            }))
-                .sort((a, b) => a.name.localeCompare(b.name));
-            res.json({ path: resolved, dirs });
+            const result = await api.patchLocalSettings(body);
+            res.status(result.valid ? 200 : 400).json(result);
+        }
+        catch (error) {
+            sendError(res, error);
+        }
+    });
+    app.put("/api/settings/local", async (req, res) => {
+        try {
+            const body = await readJsonBody(req);
+            if (typeof body.content !== "string")
+                throw new LocalBackendApiError("Missing 'content' string", 400, "invalid_request");
+            const result = await api.saveLocalSettings(body.content);
+            res.status(result.valid ? 200 : 400).json(result);
         }
-        catch (err) {
-            res.status(500).json({ error: err.message });
+        catch (error) {
+            sendError(res, error);
         }
     });
+    return api;
 }