pipane 0.1.6 → 0.1.8

package/dist/server/server/rendezvous-client.js

@@ -0,0 +1,282 @@
+import { WebSocket } from "ws";
+import { RENDEZVOUS_PROTOCOL_VERSION, decodeBackendMessage, encodeRendezvousMessage, rendezvousWebSocketUrl, } from "../shared/rendezvous-protocol.js";
+import { signBackendChallenge } from "./backend-identity.js";
+export { rendezvousWebSocketUrl } from "../shared/rendezvous-protocol.js";
+export class BackendRendezvousClient {
+    endpoint;
+    identity;
+    metadata;
+    createWebSocket;
+    schedule;
+    cancelSchedule;
+    maxReconnectDelayMs;
+    statusListeners = new Set();
+    connectionListeners = new Set();
+    signalListeners = new Set();
+    closedListeners = new Set();
+    revocationListeners = new Set();
+    errorListeners = new Set();
+    activePairings = new Map();
+    pairingResolvers = new Map();
+    confirmationResolvers = new Map();
+    socket = null;
+    reconnectTimer;
+    reconnectAttempt = 0;
+    stopped = true;
+    registered = false;
+    firstRegistrationSettled = false;
+    firstRegistration;
+    resolveFirstRegistration;
+    rejectFirstRegistration;
+    _ticketPublicKey;
+    _iceServers = [];
+    constructor(options) {
+        this.endpoint = rendezvousWebSocketUrl(options.url, "backend");
+        this.identity = options.identity;
+        this.metadata = options.metadata;
+        this.createWebSocket = options.createWebSocket ?? ((url) => new WebSocket(url));
+        this.schedule = options.schedule ?? globalThis.setTimeout.bind(globalThis);
+        this.cancelSchedule = options.cancelSchedule ?? globalThis.clearTimeout.bind(globalThis);
+        this.maxReconnectDelayMs = options.maxReconnectDelayMs ?? 10_000;
+        this.firstRegistration = new Promise((resolve, reject) => {
+            this.resolveFirstRegistration = resolve;
+            this.rejectFirstRegistration = reject;
+        });
+    }
+    get isRegistered() {
+        return this.registered;
+    }
+    get ticketPublicKey() {
+        if (!this._ticketPublicKey)
+            throw new Error("Rendezvous ticket verification key is unavailable");
+        return this._ticketPublicKey;
+    }
+    get iceServers() {
+        return this._iceServers.map((server) => ({
+            ...server,
+            urls: Array.isArray(server.urls) ? [...server.urls] : server.urls,
+        }));
+    }
+    start() {
+        if (this.stopped) {
+            this.stopped = false;
+            this.open();
+        }
+        return this.firstRegistration;
+    }
+    stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        this.registered = false;
+        if (this.reconnectTimer) {
+            this.cancelSchedule(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+        const error = new Error("Rendezvous client stopped");
+        if (!this.firstRegistrationSettled) {
+            this.firstRegistrationSettled = true;
+            this.rejectFirstRegistration(error);
+        }
+        for (const pending of this.pairingResolvers.values())
+            pending.reject(error);
+        for (const pending of this.confirmationResolvers.values())
+            pending.reject(error);
+        this.pairingResolvers.clear();
+        this.confirmationResolvers.clear();
+        this.socket?.close(1000, "Backend stopped");
+        this.socket = null;
+    }
+    onStatus(listener) {
+        this.statusListeners.add(listener);
+        return () => this.statusListeners.delete(listener);
+    }
+    onConnectionRequest(listener) {
+        this.connectionListeners.add(listener);
+        return () => this.connectionListeners.delete(listener);
+    }
+    onSignal(listener) {
+        this.signalListeners.add(listener);
+        return () => this.signalListeners.delete(listener);
+    }
+    onConnectionClosed(listener) {
+        this.closedListeners.add(listener);
+        return () => this.closedListeners.delete(listener);
+    }
+    onAuthorizationRevoked(listener) {
+        this.revocationListeners.add(listener);
+        return () => this.revocationListeners.delete(listener);
+    }
+    onError(listener) {
+        this.errorListeners.add(listener);
+        return () => this.errorListeners.delete(listener);
+    }
+    openPairing(pairId, expiresAt) {
+        this.activePairings.set(pairId, expiresAt);
+        const existing = this.pairingResolvers.get(pairId);
+        if (existing)
+            return Promise.reject(new Error("Pairing request is already pending"));
+        const promise = new Promise((resolve, reject) => this.pairingResolvers.set(pairId, { resolve, reject }));
+        if (this.registered)
+            this.send({ type: "open_pairing", pairId, expiresAt });
+        return promise;
+    }
+    confirmPairing(connectionId) {
+        if (this.confirmationResolvers.has(connectionId))
+            return Promise.reject(new Error("Pairing confirmation is already pending"));
+        const promise = new Promise((resolve, reject) => {
+            this.confirmationResolvers.set(connectionId, { resolve, reject });
+        });
+        this.send({ type: "confirm_pairing", connectionId });
+        return promise;
+    }
+    sendSignal(connectionId, signal) {
+        this.send({ type: "signal", connectionId, signal });
+    }
+    sendIdentityBinding(connectionId, binding) {
+        this.send({ type: "connection_binding", connectionId, binding });
+    }
+    closeConnection(connectionId, reason) {
+        this.send({ type: "close_connection", connectionId, reason });
+    }
+    open() {
+        if (this.stopped)
+            return;
+        const socket = this.createWebSocket(this.endpoint);
+        this.socket = socket;
+        socket.on("message", (raw) => this.handleMessage(socket, raw.toString()));
+        socket.on("error", (error) => this.emitError(error));
+        socket.on("close", () => {
+            if (this.socket !== socket)
+                return;
+            this.socket = null;
+            const interruption = new Error("Rendezvous disconnected during pairing confirmation");
+            for (const pending of this.confirmationResolvers.values())
+                pending.reject(interruption);
+            this.confirmationResolvers.clear();
+            const wasRegistered = this.registered;
+            this.registered = false;
+            if (wasRegistered)
+                this.emitStatus(false);
+            if (!this.stopped)
+                this.scheduleReconnect();
+        });
+    }
+    handleMessage(socket, raw) {
+        if (socket !== this.socket)
+            return;
+        const decoded = decodeBackendMessage(raw);
+        if (!decoded.ok) {
+            this.emitError(new Error(decoded.error.message));
+            socket.close(1002, "Invalid rendezvous message");
+            return;
+        }
+        const message = decoded.value;
+        switch (message.type) {
+            case "challenge":
+                this.sendRaw({
+                    type: "register_backend",
+                    publicKey: this.identity.publicKey,
+                    signature: signBackendChallenge(this.identity, message.nonce),
+                    metadata: this.metadata,
+                });
+                break;
+            case "registered":
+                if (message.backendId !== this.identity.backendId) {
+                    this.emitError(new Error("Rendezvous registered an unexpected backend identity"));
+                    socket.close(1002, "Backend identity mismatch");
+                    return;
+                }
+                this._ticketPublicKey = message.ticketPublicKey;
+                this._iceServers = message.iceServers;
+                this.registered = true;
+                this.reconnectAttempt = 0;
+                this.emitStatus(true);
+                if (!this.firstRegistrationSettled) {
+                    this.firstRegistrationSettled = true;
+                    this.resolveFirstRegistration(message.backendId);
+                }
+                for (const [pairId, expiresAt] of this.activePairings) {
+                    if (expiresAt > Date.now())
+                        this.send({ type: "open_pairing", pairId, expiresAt });
+                    else
+                        this.activePairings.delete(pairId);
+                }
+                break;
+            case "pairing_opened": {
+                const pending = this.pairingResolvers.get(message.pairId);
+                this.pairingResolvers.delete(message.pairId);
+                pending?.resolve();
+                break;
+            }
+            case "pairing_confirmed": {
+                const pending = this.confirmationResolvers.get(message.connectionId);
+                this.confirmationResolvers.delete(message.connectionId);
+                this.activePairings.delete(message.pairId);
+                pending?.resolve(message);
+                break;
+            }
+            case "connection_request":
+                for (const listener of this.connectionListeners)
+                    listener({
+                        connectionId: message.connectionId,
+                        ticket: message.ticket,
+                        iceServers: message.iceServers,
+                    });
+                break;
+            case "signal":
+                for (const listener of this.signalListeners)
+                    listener(message.connectionId, message.signal);
+                break;
+            case "connection_closed": {
+                const pending = this.confirmationResolvers.get(message.connectionId);
+                this.confirmationResolvers.delete(message.connectionId);
+                pending?.reject(new Error(message.reason));
+                for (const listener of this.closedListeners)
+                    listener(message.connectionId, message.reason);
+                break;
+            }
+            case "authorization_revoked":
+                for (const listener of this.revocationListeners)
+                    listener(message);
+                break;
+            case "error": {
+                this.emitError(message);
+                if (message.connectionId) {
+                    const pending = this.confirmationResolvers.get(message.connectionId);
+                    this.confirmationResolvers.delete(message.connectionId);
+                    pending?.reject(new Error(message.message));
+                }
+                break;
+            }
+        }
+    }
+    send(command) {
+        if (!this.registered)
+            throw new Error("Backend is not registered with rendezvous");
+        this.sendRaw(command);
+    }
+    sendRaw(command) {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN)
+            throw new Error("Rendezvous WebSocket is not connected");
+        this.socket.send(encodeRendezvousMessage({ protocolVersion: RENDEZVOUS_PROTOCOL_VERSION, ...command }));
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer || this.stopped)
+            return;
+        this.reconnectAttempt++;
+        const delay = Math.min(500 * 2 ** (this.reconnectAttempt - 1), this.maxReconnectDelayMs);
+        this.reconnectTimer = this.schedule(() => {
+            this.reconnectTimer = undefined;
+            this.open();
+        }, delay);
+    }
+    emitStatus(connected) {
+        for (const listener of this.statusListeners)
+            listener(connected);
+    }
+    emitError(error) {
+        for (const listener of this.errorListeners)
+            listener(error);
+    }
+}

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

@@ -1,222 +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 { parseSessionEntries } from "@earendil-works/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 = {}) {
-    localSettingsStore = options.localSettingsStore ?? new LocalSettingsStore();
-    sessionIndex = new SessionIndex({
-        cwdDisplayFormatter: (cwd) => localSettingsStore.formatCwdTitle(cwd),
-    });
-    startLocalSettingsWatcher(options.onLocalSettingsReloaded);
+    const api = options.api ?? new LocalBackendApi(options);
     app.get("/api/sessions", async (_req, res) => {
         try {
-            res.json(await sessionIndex.listSessions());
+            res.json(await api.listSessions());
         }
-        catch (err) {
-            res.status(500).json({ error: err.message });
+        catch (error) {
+            sendError(res, error);
         }
     });
-    app.get("/api/settings/local", (_req, res) => {
+    app.delete("/api/sessions", async (req, res) => {
         try {
-            res.json(localSettingsStore.read());
+            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 (err) {
-            res.status(500).json({ error: err.message });
+        catch (error) {
+            sendError(res, error);
         }
     });
-    app.post("/api/settings/local/validate", async (req, res) => {
+    app.get("/api/sessions/fork-messages", async (req, res) => {
         try {
-            const body = await readJsonBody(req);
-            if (typeof body.content !== "string") {
-                res.status(400).json({ error: "Missing 'content' string" });
-                return;
-            }
-            res.json(localSettingsStore.validate(body.content));
+            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) });
         }
-        catch (err) {
-            res.status(500).json({ error: err.message });
+        catch (error) {
+            sendError(res, error);
         }
     });
-    app.patch("/api/settings/local", async (req, res) => {
+    app.get("/api/sessions/raw", 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 result = localSettingsStore.patch(body);
-            if (!result.valid) {
-                res.status(400).json(result);
-                return;
-            }
-            await sessionIndex.invalidateAll();
-            options.onLocalSettingsReloaded?.();
-            res.json(result);
+            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.put("/api/settings/local", async (req, res) => {
+    app.get("/api/files/content", async (req, res) => {
         try {
-            const body = await readJsonBody(req);
-            if (typeof body.content !== "string") {
-                res.status(400).json({ error: "Missing 'content' string" });
-                return;
+            if (typeof req.query.sessionPath !== "string" || typeof req.query.path !== "string") {
+                throw new LocalBackendApiError("Missing 'sessionPath' or 'path' query parameter", 400, "invalid_request");
             }
-            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.getFileContent(req.query.sessionPath, req.query.path));
         }
-        catch (err) {
-            res.status(500).json({ error: err.message });
+        catch (error) {
+            sendError(res, error);
         }
     });
-    app.delete("/api/sessions", async (req, res) => {
+    app.post("/api/files/uploads", 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;
+            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");
             }
-            const remove = () => unlink(sessionPath);
-            if (options.runSessionMutation) {
-                await options.runSessionMutation(sessionPath, "delete session", remove);
-            }
-            else {
-                await remove();
-            }
-            res.json({ success: true });
+            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.get("/api/sessions/fork-messages", (req, res) => {
+    app.post("/api/files/uploads/:uploadId/chunks", 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;
+            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");
             }
-            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.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.get("/api/sessions/raw", (req, res) => {
+    app.post("/api/files/uploads/:uploadId/complete", 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;
+            res.json(await api.completeFileUpload(req.params.uploadId));
+        }
+        catch (error) {
+            sendError(res, error);
+        }
+    });
+    app.get("/api/browse", async (req, res) => {
+        try {
+            res.json(await api.browseDirectory(typeof req.query.path === "string" ? req.query.path : ""));
+        }
+        catch (error) {
+            sendError(res, error);
+        }
+    });
+    app.post("/api/directories", async (req, res) => {
+        try {
+            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");
-            res.type("text/plain").send(content);
+            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/browse", (req, res) => {
+    app.get("/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;
+            res.json(await api.getLocalSettings());
+        }
+        catch (error) {
+            sendError(res, error);
+        }
+    });
+    app.post("/api/settings/local/validate", async (req, res) => {
+        try {
+            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 (error) {
+            sendError(res, error);
+        }
+    });
+    app.patch("/api/settings/local", async (req, res) => {
+        try {
+            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 });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
+            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 (error) {
+            sendError(res, error);
         }
     });
+    return api;
 }