pipane 0.1.5 → 0.1.7

package/dist/server/server/backend-webrtc.js

@@ -0,0 +1,239 @@
+import nodeDataChannel from "node-datachannel";
+import { PIPANE_DATA_CHANNEL_LABEL, PIPANE_DATA_CHANNEL_PROTOCOL, TRUST_PROTOCOL_VERSION, decodeDataChannelAuthenticateFrame, deviceConnectionProofPayload, } from "../shared/trust-protocol.js";
+import { deriveDeviceId, verifyConnectionTicket, verifyDeviceSignature } from "../shared/node-trust-crypto.js";
+import { signBackendIdentityBinding, } from "./backend-identity.js";
+import { toNodeIceServers } from "./ice-servers.js";
+export { PIPANE_DATA_CHANNEL_LABEL, PIPANE_DATA_CHANNEL_PROTOCOL } from "../shared/trust-protocol.js";
+const AUTHENTICATION_TIMEOUT_MS = 10_000;
+const MAX_AUTHENTICATION_FRAME_BYTES = 32 * 1024;
+/** Answer-side WebRTC peers that expose channels only after ticket and device proof validation. */
+export class BackendWebRtcManager {
+    signaling;
+    identity;
+    ticketPublicKey;
+    authorize;
+    iceServers;
+    iceTransportPolicy;
+    bindAddress;
+    authenticationTimeoutMs;
+    peers = new Map();
+    channelListeners = new Set();
+    errorListeners = new Set();
+    unsubscribers;
+    constructor(options) {
+        this.signaling = options.signaling;
+        this.identity = options.identity;
+        this.ticketPublicKey = options.ticketPublicKey;
+        this.authorize = options.authorize;
+        this.iceServers = options.iceServers ?? [];
+        this.iceTransportPolicy = options.iceTransportPolicy ?? "all";
+        this.bindAddress = options.bindAddress;
+        this.authenticationTimeoutMs = options.authenticationTimeoutMs ?? AUTHENTICATION_TIMEOUT_MS;
+        this.unsubscribers = [
+            this.signaling.onConnectionRequest((request) => this.createPeer(request)),
+            this.signaling.onSignal((connectionId, signal) => this.applySignal(connectionId, signal)),
+            this.signaling.onConnectionClosed((connectionId) => this.removePeer(connectionId)),
+        ];
+    }
+    onDataChannel(listener) {
+        this.channelListeners.add(listener);
+        return () => this.channelListeners.delete(listener);
+    }
+    onError(listener) {
+        this.errorListeners.add(listener);
+        return () => this.errorListeners.delete(listener);
+    }
+    closeAuthorization(accountId, deviceId) {
+        for (const [connectionId, state] of this.peers) {
+            if (state.authenticated?.accountId !== accountId)
+                continue;
+            if (deviceId && state.authenticated.deviceId !== deviceId)
+                continue;
+            // Rendezvous already removed the route before delivering revocation.
+            this.removePeer(connectionId);
+        }
+    }
+    close() {
+        for (const unsubscribe of this.unsubscribers.splice(0))
+            unsubscribe();
+        for (const connectionId of [...this.peers.keys()])
+            this.removePeer(connectionId);
+    }
+    createPeer(request) {
+        this.removePeer(request.connectionId);
+        let claims;
+        try {
+            claims = verifyConnectionTicket(request.ticket, this.ticketPublicKey());
+            if (claims.connectionId !== request.connectionId || claims.backendId !== this.identity.backendId) {
+                throw new Error("Connection ticket does not match this backend route");
+            }
+            if (deriveDeviceId(claims.devicePublicKey) !== claims.deviceId)
+                throw new Error("Connection ticket device identity is invalid");
+        }
+        catch (error) {
+            this.rejectRequest(request.connectionId, error);
+            return;
+        }
+        const peer = new nodeDataChannel.PeerConnection(request.connectionId, {
+            iceServers: request.iceServers.length > 0 ? toNodeIceServers(request.iceServers) : this.iceServers,
+            iceTransportPolicy: this.iceTransportPolicy,
+            bindAddress: this.bindAddress,
+        });
+        const state = { request, claims, peer };
+        this.peers.set(request.connectionId, state);
+        peer.onLocalDescription((sdp, type) => {
+            if (this.peers.get(request.connectionId) !== state || type !== "answer" || !state.offerSdp)
+                return;
+            try {
+                const binding = signBackendIdentityBinding(this.identity, {
+                    connectionId: request.connectionId,
+                    offerSdp: state.offerSdp,
+                    answerSdp: sdp,
+                    expiresAt: claims.expiresAt,
+                });
+                state.binding = binding;
+                this.signaling.sendSignal(request.connectionId, { kind: "description", type: "answer", sdp });
+                this.signaling.sendIdentityBinding(request.connectionId, binding);
+            }
+            catch (error) {
+                this.failPeer(request.connectionId, error);
+            }
+        });
+        peer.onLocalCandidate((candidate, mid) => {
+            if (this.peers.get(request.connectionId) !== state)
+                return;
+            this.safeSendSignal(request.connectionId, {
+                kind: "candidate",
+                candidate,
+                sdpMid: mid || null,
+                sdpMLineIndex: null,
+            });
+        });
+        peer.onDataChannel((channel) => this.handleDataChannel(state, channel));
+        peer.onStateChange((connectionState) => {
+            if (connectionState === "failed" || connectionState === "closed")
+                this.removePeer(request.connectionId);
+        });
+    }
+    handleDataChannel(state, channel) {
+        if (channel.getLabel() !== PIPANE_DATA_CHANNEL_LABEL || channel.getProtocol() !== PIPANE_DATA_CHANNEL_PROTOCOL) {
+            channel.close();
+            return;
+        }
+        state.authenticationTimer = setTimeout(() => this.failPeer(state.request.connectionId, new Error("DataChannel authentication timed out")), this.authenticationTimeoutMs);
+        state.authenticationTimer.unref?.();
+        channel.onMessage((message) => {
+            if (state.authenticated)
+                return;
+            const raw = message.toString();
+            if (Buffer.byteLength(raw) > MAX_AUTHENTICATION_FRAME_BYTES) {
+                this.failAuthentication(state, channel, "Authentication frame is too large");
+                return;
+            }
+            const hello = decodeDataChannelAuthenticateFrame(raw);
+            if (!hello) {
+                this.failAuthentication(state, channel, "First DataChannel frame must authenticate the device");
+                return;
+            }
+            void this.authenticateChannel(state, channel, hello).catch((error) => {
+                if (this.peers.get(state.request.connectionId) !== state)
+                    return;
+                this.failAuthentication(state, channel, error instanceof Error ? error.message : String(error));
+            });
+        });
+    }
+    async authenticateChannel(state, channel, hello) {
+        if (!state.binding)
+            throw new Error("Backend identity binding is not ready");
+        if (state.claims.expiresAt <= Date.now())
+            throw new Error("Connection ticket expired during negotiation");
+        if (hello.ticket !== state.request.ticket || hello.bindingSignature !== state.binding.signature) {
+            throw new Error("Device proof does not match the negotiated connection");
+        }
+        if (!verifyDeviceSignature(state.claims.devicePublicKey, deviceConnectionProofPayload(hello.ticket, hello.bindingSignature), hello.deviceSignature)) {
+            throw new Error("Invalid device connection signature");
+        }
+        const authorization = await this.authorize({ claims: state.claims, pairingSecret: hello.pairingSecret });
+        if (this.peers.get(state.request.connectionId) !== state)
+            throw new Error("Connection closed during authorization");
+        if (authorization.deviceId !== state.claims.deviceId)
+            throw new Error("Authorized device does not match the ticket");
+        state.authenticated = authorization;
+        if (state.authenticationTimer)
+            clearTimeout(state.authenticationTimer);
+        state.authenticationTimer = undefined;
+        const response = {
+            protocolVersion: TRUST_PROTOCOL_VERSION,
+            type: "authenticated",
+            accountId: authorization.accountId,
+            deviceId: authorization.deviceId,
+        };
+        channel.sendMessage(JSON.stringify(response));
+        for (const listener of this.channelListeners) {
+            listener({ connectionId: state.request.connectionId, channel, ...authorization });
+        }
+    }
+    failAuthentication(state, channel, message) {
+        const response = {
+            protocolVersion: TRUST_PROTOCOL_VERSION,
+            type: "authentication_error",
+            message,
+        };
+        channel.sendMessage(JSON.stringify(response));
+        this.failPeer(state.request.connectionId, new Error(message));
+    }
+    applySignal(connectionId, signal) {
+        const state = this.peers.get(connectionId);
+        if (!state) {
+            this.signaling.closeConnection(connectionId, "Unknown backend WebRTC connection");
+            return;
+        }
+        try {
+            if (signal.kind === "candidate") {
+                state.peer.addRemoteCandidate(signal.candidate, signal.sdpMid ?? "0");
+                return;
+            }
+            if (signal.type !== "offer")
+                throw new Error("Backend WebRTC peer expected an offer");
+            state.offerSdp = signal.sdp;
+            state.peer.setRemoteDescription(signal.sdp, "offer");
+        }
+        catch (error) {
+            this.failPeer(connectionId, error);
+        }
+    }
+    safeSendSignal(connectionId, signal) {
+        try {
+            this.signaling.sendSignal(connectionId, signal);
+        }
+        catch (error) {
+            this.failPeer(connectionId, error);
+        }
+    }
+    rejectRequest(connectionId, error) {
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        for (const listener of this.errorListeners)
+            listener(connectionId, normalized);
+        this.signaling.closeConnection(connectionId, normalized.message);
+    }
+    failPeer(connectionId, error) {
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        for (const listener of this.errorListeners)
+            listener(connectionId, normalized);
+        try {
+            this.signaling.closeConnection(connectionId, "WebRTC negotiation failed");
+        }
+        finally {
+            this.removePeer(connectionId);
+        }
+    }
+    removePeer(connectionId) {
+        const state = this.peers.get(connectionId);
+        if (!state)
+            return;
+        this.peers.delete(connectionId);
+        if (state.authenticationTimer)
+            clearTimeout(state.authenticationTimer);
+        state.peer.close();
+    }
+}

package/dist/server/server/bundled-extensions.js

@@ -0,0 +1,6 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+/** Absolute entrypoint for the bundled common-subscription usage extension. */
+export function resolveUsageExtensionPath() {
+    return require.resolve("@sreetej510/pi-usage/dist/index.js");
+}

package/dist/server/server/conversation-file-access.js

@@ -0,0 +1,97 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { parseSessionEntries } from "@earendil-works/pi-coding-agent";
+import { buildSessionDisplayMessages } from "./session-jsonl.js";
+const PATH_CONTINUATION = /[\p{L}\p{N}_~.%/\\:+-]/u;
+function expandHome(value) {
+    return value.replace(/^~/, process.env.HOME || "/");
+}
+function addCandidate(candidates, value) {
+    if (!value || value === ".")
+        return;
+    candidates.add(value);
+    try {
+        candidates.add(encodeURI(value)
+            .replaceAll("(", "%28")
+            .replaceAll(")", "%29"));
+    }
+    catch {
+        // Invalid surrogate pairs cannot be represented in a URL, but the raw
+        // spelling can still be checked without weakening the exact match.
+    }
+}
+function buildMentionCandidates(rawRequestPath, requestedPath, resolvedPath, sessionCwd) {
+    const candidates = new Set();
+    addCandidate(candidates, rawRequestPath);
+    const cwd = path.resolve(expandHome(sessionCwd));
+    for (const candidatePath of new Set([path.resolve(requestedPath), path.resolve(resolvedPath)])) {
+        addCandidate(candidates, candidatePath);
+        addCandidate(candidates, pathToFileURL(candidatePath).href);
+        const relative = path.relative(cwd, candidatePath);
+        if (relative && !path.isAbsolute(relative)) {
+            addCandidate(candidates, relative);
+            if (!relative.startsWith(`..${path.sep}`) && relative !== "..") {
+                addCandidate(candidates, `.${path.sep}${relative}`);
+            }
+        }
+    }
+    return candidates;
+}
+function containsExactPathMention(text, candidate) {
+    let index = text.indexOf(candidate);
+    while (index >= 0) {
+        const before = index > 0 ? text[index - 1] : "";
+        const end = index + candidate.length;
+        const after = end < text.length ? text[end] : "";
+        if ((!before || !PATH_CONTINUATION.test(before))
+            && (!after || !PATH_CONTINUATION.test(after))) {
+            return true;
+        }
+        index = text.indexOf(candidate, index + 1);
+    }
+    return false;
+}
+function conversationText(message) {
+    if (message?.role === "compactionSummary" && typeof message.summary === "string") {
+        return [message.summary];
+    }
+    if (message?.role !== "user" && message?.role !== "assistant")
+        return [];
+    if (typeof message.content === "string")
+        return [message.content];
+    if (!Array.isArray(message.content))
+        return [];
+    const text = [];
+    for (const chunk of message.content) {
+        if (chunk?.type === "text" && typeof chunk.text === "string")
+            text.push(chunk.text);
+        if (chunk?.type === "thinking" && typeof chunk.thinking === "string")
+            text.push(chunk.thinking);
+    }
+    return text;
+}
+/**
+ * Allow an exact path outside the session CWD only when its spelling (absolute,
+ * file URL, or CWD-relative) appears in the currently displayed conversation.
+ */
+export function conversationMentionsFile(options) {
+    try {
+        const entries = parseSessionEntries(readFileSync(options.sessionPath, "utf8"));
+        const messages = buildSessionDisplayMessages(entries);
+        const candidates = buildMentionCandidates(options.rawRequestPath, options.requestedPath, options.resolvedPath, options.sessionCwd);
+        for (const message of messages) {
+            for (const text of conversationText(message)) {
+                for (const candidate of candidates) {
+                    if (containsExactPathMention(text, candidate))
+                        return true;
+                }
+            }
+        }
+    }
+    catch {
+        // Authorization failures are deny-by-default. The endpoint reports the
+        // same 403 as an ordinary unmentioned CWD escape.
+    }
+    return false;
+}

package/dist/server/server/extension-status.js

@@ -0,0 +1,31 @@
+import { stripVTControlCharacters } from "node:util";
+export const PROVIDER_USAGE_STATUS_KEY = "provider-usage";
+const MAX_STATUS_KEY_LENGTH = 128;
+const MAX_STATUS_TEXT_LENGTH = 512;
+const KEY_CONTROL_CHARACTER = /[\u0000-\u001f\u007f-\u009f]/;
+const CONTROL_CHARACTERS = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g;
+export function isValidExtensionStatusKey(value) {
+    return typeof value === "string"
+        && value.length > 0
+        && value.length <= MAX_STATUS_KEY_LENGTH
+        && !KEY_CONTROL_CHARACTER.test(value);
+}
+export function normalizeExtensionStatusText(value) {
+    return stripVTControlCharacters(value)
+        .replace(/[\r\n\t]+/g, " ")
+        .replace(CONTROL_CHARACTERS, "")
+        .replace(/\s{2,}/g, " ")
+        .trim()
+        .slice(0, MAX_STATUS_TEXT_LENGTH);
+}
+export function extensionStatusSnapshot(statuses) {
+    return Object.fromEntries(statuses ?? []);
+}
+/** Identify successful pi-usage status text; transient states such as "checking" do not match. */
+export function providerForUsageStatus(text) {
+    if (/^codex(?:\s|$)/i.test(text))
+        return "codex";
+    if (/^(?:anthropic|claude)(?:\s|$)/i.test(text))
+        return "anthropic";
+    return undefined;
+}

package/dist/server/server/frame-connection.js

@@ -0,0 +1,48 @@
+export const FRAME_CONNECTION_OPEN = 1;
+export const FRAME_CONNECTION_CLOSED = 3;
+/** Adapts an authenticated reliable DataChannel to the server's frame connection contract. */
+export class DataChannelFrameConnection {
+    channel;
+    messageListeners = new Set();
+    closeListeners = new Set();
+    state = FRAME_CONNECTION_OPEN;
+    constructor(channel) {
+        this.channel = channel;
+        channel.onMessage((message) => {
+            for (const listener of this.messageListeners)
+                listener(message);
+        });
+        channel.onClosed(() => {
+            if (this.state === FRAME_CONNECTION_CLOSED)
+                return;
+            this.state = FRAME_CONNECTION_CLOSED;
+            for (const listener of this.closeListeners)
+                listener();
+        });
+    }
+    get readyState() {
+        return this.state === FRAME_CONNECTION_OPEN && this.channel.isOpen()
+            ? FRAME_CONNECTION_OPEN
+            : FRAME_CONNECTION_CLOSED;
+    }
+    send(frame) {
+        if (this.readyState !== FRAME_CONNECTION_OPEN || !this.channel.sendMessage(frame)) {
+            throw new Error("DataChannel frame connection is closed");
+        }
+    }
+    close() {
+        if (this.state === FRAME_CONNECTION_CLOSED)
+            return;
+        this.state = FRAME_CONNECTION_CLOSED;
+        this.channel.close();
+        for (const listener of this.closeListeners)
+            listener();
+    }
+    on(event, listener) {
+        if (event === "message")
+            this.messageListeners.add(listener);
+        else
+            this.closeListeners.add(listener);
+        return this;
+    }
+}

package/dist/server/server/frame-router.js

@@ -0,0 +1,45 @@
+import { isBackendProtocolFrame } from "../shared/backend-protocol.js";
+class RoutedFrameConnection {
+    connection;
+    messageListeners = new Set();
+    closeListeners = new Set();
+    constructor(connection) {
+        this.connection = connection;
+    }
+    get readyState() { return this.connection.readyState; }
+    send(frame) { return this.connection.send(frame); }
+    close(code, reason) { return this.connection.close(code, reason); }
+    on(event, listener) {
+        if (event === "message")
+            this.messageListeners.add(listener);
+        else
+            this.closeListeners.add(listener);
+        return this;
+    }
+    emitMessage(raw) {
+        const frame = { toString: () => raw };
+        for (const listener of this.messageListeners)
+            listener(frame);
+    }
+    emitClose() {
+        for (const listener of this.closeListeners)
+            listener();
+    }
+}
+/** Splits application v1 and semantic v2 frames without creating extra DataChannels. */
+export function routeFrameConnection(connection) {
+    const application = new RoutedFrameConnection(connection);
+    const semantic = new RoutedFrameConnection(connection);
+    connection.on("message", (frame) => {
+        const raw = frame.toString();
+        if (isBackendProtocolFrame(raw))
+            semantic.emitMessage(raw);
+        else
+            application.emitMessage(raw);
+    });
+    connection.on("close", () => {
+        application.emitClose();
+        semantic.emitClose();
+    });
+    return { application, semantic };
+}

package/dist/server/server/ice-servers.js

@@ -0,0 +1,24 @@
+/** Converts browser ICE server records into node-datachannel's explicit relay shape. */
+export function toNodeIceServers(servers) {
+    const result = [];
+    for (const server of servers) {
+        for (const url of Array.isArray(server.urls) ? server.urls : [server.urls]) {
+            if (url.startsWith("stun:")) {
+                result.push(url);
+                continue;
+            }
+            const match = /^(turns?):(?:\/\/)?(\[[^\]]+\]|[^:?]+)(?::(\d+))?(?:\?transport=(udp|tcp))?$/iu.exec(url);
+            if (!match)
+                throw new Error(`Unsupported ICE server URL: ${url}`);
+            const secure = match[1].toLowerCase() === "turns";
+            result.push({
+                hostname: match[2].replace(/^\[|\]$/gu, ""),
+                port: match[3] ? Number.parseInt(match[3], 10) : secure ? 5349 : 3478,
+                username: server.username,
+                password: server.credential,
+                relayType: secure ? "TurnTls" : match[4]?.toLowerCase() === "tcp" ? "TurnTcp" : "TurnUdp",
+            });
+        }
+    }
+    return result;
+}