pipane 0.1.6 → 0.1.8

package/dist/server/shared/trust-protocol.js

@@ -0,0 +1,97 @@
+export const TRUST_PROTOCOL_VERSION = 1;
+export const CONNECTION_TICKET_VERSION = 1;
+export const PIPANE_DATA_CHANNEL_LABEL = "pipane";
+export const PIPANE_DATA_CHANNEL_PROTOCOL = "pipane.v1";
+export function deviceChallengePayload(challenge) {
+    return [
+        `pipane-device-challenge-v${TRUST_PROTOCOL_VERSION}`,
+        challenge.challengeId,
+        challenge.nonce,
+        challenge.purpose,
+        challenge.deviceId,
+        challenge.devicePublicKey,
+        challenge.backendId ?? "",
+        challenge.connectionId ?? "",
+        challenge.pairId ?? "",
+        challenge.targetDeviceId ?? "",
+        String(challenge.expiresAt),
+    ].join("\n");
+}
+export function connectionTicketSignaturePayload(encodedClaims) {
+    return `pipane-connection-ticket-v${CONNECTION_TICKET_VERSION}\n${encodedClaims}`;
+}
+export function backendIdentityBindingPayload(binding) {
+    return [
+        `pipane-backend-binding-v${TRUST_PROTOCOL_VERSION}`,
+        binding.backendId,
+        binding.publicKey,
+        binding.connectionId,
+        binding.offerSha256,
+        binding.answerSha256,
+        binding.dtlsFingerprint,
+        String(binding.expiresAt),
+    ].join("\n");
+}
+export function deviceConnectionProofPayload(ticket, bindingSignature) {
+    return [
+        `pipane-device-connection-v${TRUST_PROTOCOL_VERSION}`,
+        ticket,
+        bindingSignature,
+    ].join("\n");
+}
+export function decodeDataChannelAuthenticateFrame(raw) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isRecord(value)
+        || value.protocolVersion !== TRUST_PROTOCOL_VERSION
+        || value.type !== "authenticate"
+        || !isNonEmptyString(value.ticket)
+        || !isNonEmptyString(value.bindingSignature)
+        || !isNonEmptyString(value.deviceSignature)
+        || !isOptionalString(value.pairingSecret)) {
+        return undefined;
+    }
+    return value;
+}
+export function parseConnectionTicketClaims(value) {
+    if (!isRecord(value)
+        || value.version !== CONNECTION_TICKET_VERSION
+        || (value.kind !== "pairing" && value.kind !== "connection")
+        || !isNonEmptyString(value.ticketId)
+        || !isNonEmptyString(value.backendId)
+        || !isNonEmptyString(value.connectionId)
+        || !isNonEmptyString(value.deviceId)
+        || !isNonEmptyString(value.devicePublicKey)
+        || !isOptionalString(value.accountId)
+        || !isOptionalString(value.pairId)
+        || !isNonNegativeInteger(value.issuedAt)
+        || !isPositiveInteger(value.expiresAt)
+        || value.expiresAt <= value.issuedAt) {
+        return undefined;
+    }
+    if (value.kind === "pairing" && !isNonEmptyString(value.pairId))
+        return undefined;
+    if (value.kind === "connection" && !isNonEmptyString(value.accountId))
+        return undefined;
+    return value;
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.length > 0;
+}
+function isOptionalString(value) {
+    return value === undefined || isNonEmptyString(value);
+}
+function isNonNegativeInteger(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+function isPositiveInteger(value) {
+    return Number.isSafeInteger(value) && value > 0;
+}

package/dist/server/shared/updates.js

@@ -0,0 +1,4 @@
+export const UPDATE_TARGETS = ["pipane", "pi", "extensions"];
+export function isUpdateTarget(value) {
+    return typeof value === "string" && UPDATE_TARGETS.includes(value);
+}

package/dist/server/shared/ws-protocol.js

@@ -1 +1,473 @@
-export {};
+/** Increment when a breaking WebSocket wire change is introduced. */
+export const WS_PROTOCOL_VERSION = 1;
+class ValidationFailure extends Error {
+    code;
+    constructor(code, path, message) {
+        super(`${path}: ${message}`);
+        this.code = code;
+    }
+}
+function fail(path, message, code = "invalid_message") {
+    throw new ValidationFailure(code, path, message);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function record(value, path) {
+    if (!isRecord(value))
+        fail(path, "expected an object");
+    return value;
+}
+function string(value, path, allowEmpty = true) {
+    if (typeof value !== "string" || (!allowEmpty && value.length === 0)) {
+        fail(path, allowEmpty ? "expected a string" : "expected a non-empty string");
+    }
+    return value;
+}
+function optionalString(value, path) {
+    return value === undefined ? undefined : string(value, path);
+}
+function boolean(value, path) {
+    if (typeof value !== "boolean")
+        fail(path, "expected a boolean");
+    return value;
+}
+function integer(value, path) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        fail(path, "expected a non-negative safe integer");
+    }
+    return value;
+}
+function finiteNumber(value, path) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        fail(path, "expected a finite number");
+    return value;
+}
+function array(value, path) {
+    if (!Array.isArray(value))
+        fail(path, "expected an array");
+    return value;
+}
+function stringArray(value, path) {
+    return array(value, path).map((item, index) => string(item, `${path}[${index}]`));
+}
+function stringRecord(value, path) {
+    const source = record(value, path);
+    for (const [key, item] of Object.entries(source))
+        string(item, `${path}.${key}`);
+    return source;
+}
+function statusRecord(value, path) {
+    const source = record(value, path);
+    for (const [key, item] of Object.entries(source)) {
+        if (item !== "running" && item !== "done")
+            fail(`${path}.${key}`, "expected 'running' or 'done'");
+    }
+    return source;
+}
+function queuesRecord(value, path) {
+    const source = record(value, path);
+    for (const [key, item] of Object.entries(source))
+        stringArray(item, `${path}.${key}`);
+    return source;
+}
+function thinkingLevel(value, path) {
+    if (!["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(String(value))) {
+        fail(path, "expected a supported thinking level");
+    }
+    return value;
+}
+function compactModel(value, path) {
+    const model = record(value, path);
+    string(model.provider, `${path}.provider`, false);
+    string(model.modelId, `${path}.modelId`, false);
+    return model;
+}
+function wireModel(value, path) {
+    const model = record(value, path);
+    string(model.provider, `${path}.provider`, false);
+    const id = optionalString(model.id, `${path}.id`);
+    const modelId = optionalString(model.modelId, `${path}.modelId`);
+    if (!id && !modelId)
+        fail(path, "expected id or modelId");
+    return model;
+}
+function images(value, path) {
+    return array(value, path).map((item, index) => {
+        const image = record(item, `${path}[${index}]`);
+        if (image.type !== "image")
+            fail(`${path}[${index}].type`, "expected 'image'");
+        string(image.data, `${path}[${index}].data`);
+        string(image.mimeType, `${path}[${index}].mimeType`, false);
+        return image;
+    });
+}
+function optionalCommandFields(command, path) {
+    if (command.thinkingLevel !== undefined)
+        thinkingLevel(command.thinkingLevel, `${path}.thinkingLevel`);
+    if (command.controlRevision !== undefined)
+        integer(command.controlRevision, `${path}.controlRevision`);
+    if (command.images !== undefined)
+        images(command.images, `${path}.images`);
+}
+function validateVersion(message, path) {
+    if (message.protocolVersion !== WS_PROTOCOL_VERSION) {
+        const actual = message.protocolVersion === undefined ? "missing" : JSON.stringify(message.protocolVersion);
+        fail(`${path}.protocolVersion`, `unsupported protocol version ${actual}; expected ${WS_PROTOCOL_VERSION}`, "unsupported_version");
+    }
+}
+function decodeJson(raw) {
+    try {
+        return { ok: true, value: JSON.parse(raw) };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: {
+                code: "invalid_json",
+                message: `Invalid JSON: ${error instanceof Error ? error.message : String(error)}`,
+                requestId: null,
+                command: "parse",
+            },
+        };
+    }
+}
+function decodeFailure(value, failure, fallbackCommand) {
+    const source = isRecord(value) ? value : undefined;
+    const requestId = typeof source?.id === "string" ? source.id : null;
+    const command = typeof source?.type === "string" ? source.type : fallbackCommand;
+    const validation = failure instanceof ValidationFailure
+        ? failure
+        : new ValidationFailure("invalid_message", "$", failure instanceof Error ? failure.message : String(failure));
+    return {
+        ok: false,
+        error: {
+            code: validation.code,
+            message: validation.message,
+            requestId,
+            command,
+        },
+    };
+}
+export function decodeClientCommand(raw) {
+    const parsed = decodeJson(raw);
+    if (!parsed.ok)
+        return parsed;
+    const value = parsed.value;
+    try {
+        const command = record(value, "$command");
+        validateVersion(command, "$command");
+        string(command.id, "$command.id", false);
+        const type = string(command.type, "$command.type", false);
+        const sessionPath = () => string(command.sessionPath, "$command.sessionPath");
+        switch (type) {
+            case "install_pi":
+            case "get_available_models":
+            case "get_default_model":
+            case "get_session_statuses":
+            case "reload_processes":
+                break;
+            case "get_commands":
+                optionalString(command.sessionPath, "$command.sessionPath");
+                optionalString(command.cwd, "$command.cwd");
+                break;
+            case "subscribe_session":
+            case "abort":
+            case "hard_kill":
+            case "get_session_stats":
+                sessionPath();
+                break;
+            case "prompt":
+                sessionPath();
+                string(command.message, "$command.message");
+                optionalString(command.cwd, "$command.cwd");
+                compactModel(command.model, "$command.model");
+                optionalCommandFields(command, "$command");
+                break;
+            case "steer":
+                sessionPath();
+                string(command.message, "$command.message");
+                break;
+            case "remove_steering":
+                sessionPath();
+                integer(command.index, "$command.index");
+                break;
+            case "compact":
+                sessionPath();
+                optionalString(command.customInstructions, "$command.customInstructions");
+                break;
+            case "fork":
+                sessionPath();
+                string(command.entryId, "$command.entryId", false);
+                break;
+            case "fork_prompt":
+                sessionPath();
+                string(command.message, "$command.message");
+                compactModel(command.model, "$command.model");
+                optionalCommandFields(command, "$command");
+                break;
+            case "set_session_name":
+                sessionPath();
+                string(command.name, "$command.name");
+                break;
+            default:
+                fail("$command.type", `unknown command '${type}'`, "unknown_command");
+        }
+        return { ok: true, value: command };
+    }
+    catch (error) {
+        return decodeFailure(value, error, "unknown");
+    }
+}
+function validateSlashCommands(value, path) {
+    array(value, path).forEach((item, index) => {
+        const command = record(item, `${path}[${index}]`);
+        string(command.name, `${path}[${index}].name`, false);
+        optionalString(command.description, `${path}[${index}].description`);
+        if (!["extension", "prompt", "skill"].includes(String(command.source))) {
+            fail(`${path}[${index}].source`, "expected extension, prompt, or skill");
+        }
+        if (command.sourceInfo !== undefined)
+            record(command.sourceInfo, `${path}[${index}].sourceInfo`);
+        optionalString(command.location, `${path}[${index}].location`);
+        optionalString(command.path, `${path}[${index}].path`);
+    });
+}
+function validateSessionStats(value, path) {
+    const stats = record(value, path);
+    string(stats.sessionFile, `${path}.sessionFile`, false);
+    string(stats.sessionId, `${path}.sessionId`, false);
+    for (const field of ["userMessages", "assistantMessages", "toolCalls", "toolResults", "totalMessages"]) {
+        integer(stats[field], `${path}.${field}`);
+    }
+    const tokens = record(stats.tokens, `${path}.tokens`);
+    for (const field of ["input", "output", "cacheRead", "cacheWrite", "total"]) {
+        integer(tokens[field], `${path}.tokens.${field}`);
+    }
+    if (finiteNumber(stats.cost, `${path}.cost`) < 0)
+        fail(`${path}.cost`, "expected a non-negative number");
+    if (stats.contextUsage !== undefined) {
+        const context = record(stats.contextUsage, `${path}.contextUsage`);
+        if (context.tokens !== null)
+            integer(context.tokens, `${path}.contextUsage.tokens`);
+        integer(context.contextWindow, `${path}.contextUsage.contextWindow`);
+        if (context.percent !== null && finiteNumber(context.percent, `${path}.contextUsage.percent`) < 0) {
+            fail(`${path}.contextUsage.percent`, "expected a non-negative number or null");
+        }
+    }
+}
+function validateSuccessData(command, value, path) {
+    const data = record(value, path);
+    switch (command) {
+        case "install_pi":
+        case "subscribe_session":
+        case "steer":
+        case "remove_steering":
+        case "abort":
+        case "set_session_name":
+            break;
+        case "prompt":
+        case "fork_prompt":
+            string(data.newSessionPath, `${path}.newSessionPath`, false);
+            break;
+        case "hard_kill":
+            boolean(data.killed, `${path}.killed`);
+            if (data.reason !== undefined && data.reason !== "signal_failed" && data.reason !== "not_attached") {
+                fail(`${path}.reason`, "expected signal_failed or not_attached");
+            }
+            break;
+        case "compact":
+            break;
+        case "get_available_models":
+            array(data.models, `${path}.models`).forEach((model, index) => wireModel(model, `${path}.models[${index}]`));
+            break;
+        case "get_default_model":
+            if (data.model !== null)
+                wireModel(data.model, `${path}.model`);
+            thinkingLevel(data.thinkingLevel, `${path}.thinkingLevel`);
+            break;
+        case "get_session_statuses":
+            statusRecord(data.statuses, `${path}.statuses`);
+            break;
+        case "get_session_stats":
+            validateSessionStats(data, path);
+            break;
+        case "fork":
+            string(data.text, `${path}.text`);
+            boolean(data.cancelled, `${path}.cancelled`);
+            if (data.newSessionPath !== null)
+                string(data.newSessionPath, `${path}.newSessionPath`, false);
+            break;
+        case "get_commands":
+            validateSlashCommands(data.commands, `${path}.commands`);
+            break;
+        case "reload_processes":
+            integer(data.killed, `${path}.killed`);
+            integer(data.draining, `${path}.draining`);
+            break;
+    }
+}
+const CLIENT_COMMAND_TYPES = new Set([
+    "install_pi",
+    "subscribe_session",
+    "prompt",
+    "steer",
+    "remove_steering",
+    "abort",
+    "hard_kill",
+    "compact",
+    "get_available_models",
+    "get_default_model",
+    "get_session_statuses",
+    "get_session_stats",
+    "fork",
+    "fork_prompt",
+    "set_session_name",
+    "get_commands",
+    "reload_processes",
+]);
+function clientCommandType(value, path) {
+    const type = string(value, path, false);
+    if (!CLIENT_COMMAND_TYPES.has(type))
+        fail(path, `unknown response command '${type}'`, "unknown_message");
+    return type;
+}
+function validatePatches(value, path) {
+    array(value, path).forEach((item, index) => {
+        const patch = record(item, `${path}[${index}]`);
+        integer(patch.offset, `${path}[${index}].offset`);
+        integer(patch.deleteCount, `${path}[${index}].deleteCount`);
+        string(patch.insert, `${path}[${index}].insert`);
+    });
+}
+export function decodeServerMessage(raw) {
+    const parsed = decodeJson(raw);
+    if (!parsed.ok)
+        return parsed;
+    const value = parsed.value;
+    try {
+        const message = record(value, "$message");
+        validateVersion(message, "$message");
+        const type = string(message.type, "$message.type", false);
+        switch (type) {
+            case "response": {
+                const success = boolean(message.success, "$message.success");
+                if (success) {
+                    string(message.id, "$message.id", false);
+                    const command = clientCommandType(message.command, "$message.command");
+                    validateSuccessData(command, message.data, "$message.data");
+                }
+                else {
+                    if (message.id !== null)
+                        string(message.id, "$message.id", false);
+                    string(message.command, "$message.command", false);
+                    string(message.error, "$message.error", false);
+                    if (!["invalid_json", "invalid_message", "unsupported_version", "unknown_command", "unknown_message", "command_failed"].includes(String(message.code))) {
+                        fail("$message.code", "expected a protocol error code");
+                    }
+                }
+                break;
+            }
+            case "init":
+                statusRecord(message.sessionStatuses, "$message.sessionStatuses");
+                queuesRecord(message.steeringQueues, "$message.steeringQueues");
+                stringRecord(message.providerUsageStatuses, "$message.providerUsageStatuses");
+                break;
+            case "pi_install_required":
+                string(message.command, "$message.command", false);
+                boolean(message.installable, "$message.installable");
+                boolean(message.installing, "$message.installing");
+                string(message.message, "$message.message", false);
+                break;
+            case "session_status_change":
+                string(message.sessionPath, "$message.sessionPath", false);
+                if (message.status !== "running" && message.status !== "done")
+                    fail("$message.status", "expected running or done");
+                break;
+            case "provider_usage":
+                stringRecord(message.statuses, "$message.statuses");
+                break;
+            case "extension_status":
+                string(message.sessionPath, "$message.sessionPath", false);
+                stringRecord(message.statuses, "$message.statuses");
+                break;
+            case "session_sync":
+                string(message.sessionPath, "$message.sessionPath", false);
+                integer(message.revision, "$message.revision");
+                string(message.hash, "$message.hash", false);
+                if (message.op === "full") {
+                    string(message.data, "$message.data");
+                }
+                else if (message.op === "delta") {
+                    string(message.baseHash, "$message.baseHash", false);
+                    validatePatches(message.patches, "$message.patches");
+                }
+                else {
+                    fail("$message.op", "expected full or delta");
+                }
+                break;
+            case "control_state":
+                string(message.sessionPath, "$message.sessionPath", false);
+                if (message.controlRevision !== undefined)
+                    integer(message.controlRevision, "$message.controlRevision");
+                wireModel(message.model, "$message.model");
+                thinkingLevel(message.thinkingLevel, "$message.thinkingLevel");
+                break;
+            case "session_attached":
+                string(message.sessionPath, "$message.sessionPath", false);
+                optionalString(message.cwd, "$message.cwd");
+                optionalString(message.firstMessage, "$message.firstMessage");
+                break;
+            case "sessions_changed":
+                string(message.file, "$message.file");
+                break;
+            default:
+                fail("$message.type", `unknown server message '${type}'`, "unknown_message");
+        }
+        return { ok: true, value: message };
+    }
+    catch (error) {
+        return decodeFailure(value, error, "unknown");
+    }
+}
+export function decodeSessionStateJson(raw) {
+    const parsed = decodeJson(raw);
+    if (!parsed.ok)
+        return parsed;
+    const value = parsed.value;
+    try {
+        const state = record(value, "$session");
+        array(state.messages, "$session.messages").forEach((item, index) => {
+            const message = record(item, `$session.messages[${index}]`);
+            string(message.role, `$session.messages[${index}].role`, false);
+        });
+        boolean(state.isStreaming, "$session.isStreaming");
+        stringArray(state.pendingToolCalls, "$session.pendingToolCalls");
+        const timings = record(state.toolCallTimings, "$session.toolCallTimings");
+        for (const [toolCallId, value] of Object.entries(timings)) {
+            const timing = record(value, `$session.toolCallTimings.${toolCallId}`);
+            finiteNumber(timing.startedAt, `$session.toolCallTimings.${toolCallId}.startedAt`);
+            if (timing.completedAt !== undefined) {
+                finiteNumber(timing.completedAt, `$session.toolCallTimings.${toolCallId}.completedAt`);
+            }
+        }
+        if (state.model !== null)
+            compactModel(state.model, "$session.model");
+        thinkingLevel(state.thinkingLevel, "$session.thinkingLevel");
+        stringArray(state.steeringQueue, "$session.steeringQueue");
+        optionalString(state.error, "$session.error");
+        return { ok: true, value: state };
+    }
+    catch (error) {
+        return decodeFailure(value, error, "session_sync");
+    }
+}
+export function encodeClientCommand(payload, id) {
+    return JSON.stringify({ protocolVersion: WS_PROTOCOL_VERSION, id, ...payload });
+}
+export function encodeServerMessage(payload) {
+    return JSON.stringify({ protocolVersion: WS_PROTOCOL_VERSION, ...payload });
+}
+export function assertNever(value) {
+    throw new Error(`Unhandled protocol variant: ${JSON.stringify(value)}`);
+}