@camerontaylor/paseo-protocol 0.9.1-fork.1 → 0.10.1-fork.1

package/dist/client-capabilities.d.ts

@@ -1,4 +1,5 @@
 export declare const CLIENT_CAPS: {
+    readonly helloRejection: "hello_rejection";
     readonly ownedSubscriptions: "owned_subscriptions";
     readonly explicitEventSubscriptions: "explicit_event_subscriptions";
     readonly allProviders: "all_providers";

package/dist/client-capabilities.js

@@ -1,4 +1,5 @@
 export const CLIENT_CAPS = {
+    helloRejection: "hello_rejection",
     // COMPAT(ownedSubscriptions): added in v0.8.0, remove legacy ownership after 2027-03-09.
     ownedSubscriptions: "owned_subscriptions",
     // Clients outside the Paseo app version series can explicitly accept provider IDs.

package/dist/daemon-endpoints.d.ts

@@ -1,3 +1,4 @@
+import type { ConnectionOfferV2 } from "./connection-offer.js";
 export interface HostPortParts {
     host: string;
     port: number;
@@ -9,6 +10,12 @@ export interface ConnectionUriParts extends HostPortParts {
 export interface ParsedConnectionUri extends ConnectionUriParts {
     password?: string;
 }
+export interface ParsedRelayConnectionUri {
+    offer: ConnectionOfferV2;
+    password?: string;
+}
+export declare function parseRelayConnectionUri(input: string): ParsedRelayConnectionUri;
+export declare function serializeRelayConnectionUri(parts: ParsedRelayConnectionUri): string;
 export type RelayRole = "server" | "client";
 export type RelayProtocolVersion = "1" | "2";
 export declare const CURRENT_RELAY_PROTOCOL_VERSION: RelayProtocolVersion;

package/dist/daemon-endpoints.js

@@ -1,3 +1,45 @@
+export function parseRelayConnectionUri(input) {
+    const trimmed = input.trim();
+    const connectIndex = trimmed.indexOf("#connect=");
+    const uri = connectIndex >= 0
+        ? decodeURIComponent(trimmed.slice(connectIndex + "#connect=".length))
+        : trimmed;
+    let url;
+    try {
+        url = new URL(uri);
+    }
+    catch {
+        throw new Error("Invalid relay connection URI");
+    }
+    if (url.protocol !== "relay:" || !url.hostname || !url.port || url.username || url.password) {
+        throw new Error("Invalid relay connection URI");
+    }
+    const serverId = decodeURIComponent(url.pathname.slice(1));
+    const key = url.searchParams.get("key");
+    if (!serverId || !key || serverId.includes("/")) {
+        throw new Error("Relay connection URI requires a server id and key");
+    }
+    const endpoint = normalizeHostPort(url.host);
+    const password = url.searchParams.get("password") || undefined;
+    return {
+        offer: {
+            v: 2,
+            serverId,
+            daemonPublicKeyB64: key,
+            relay: { endpoint, useTls: url.searchParams.get("ssl") === "true" },
+        },
+        ...(password ? { password } : {}),
+    };
+}
+export function serializeRelayConnectionUri(parts) {
+    const url = new URL(`relay://${parts.offer.relay.endpoint}/${encodeURIComponent(parts.offer.serverId)}`);
+    url.searchParams.set("key", parts.offer.daemonPublicKeyB64);
+    if (parts.offer.relay.useTls)
+        url.searchParams.set("ssl", "true");
+    if (parts.password)
+        url.searchParams.set("password", parts.password);
+    return url.toString();
+}
 export const CURRENT_RELAY_PROTOCOL_VERSION = "2";
 export const DEFAULT_RELAY_ENDPOINT = "relay.paseo.sh:443";
 export function normalizeRelayProtocolVersion(value, fallback = CURRENT_RELAY_PROTOCOL_VERSION) {

package/dist/generated/validation/ws-outbound.aot.js

@@ -99978,7 +99978,32 @@ export const WSOutboundMessageSchema = /* @__PURE__ */ (() => {
                     }
                     _d = __du_223;
                     break;
-                default: _e.push({ code: "invalid_union", errors: [], note: "No matching discriminator", discriminator: "type", options: ["pong", "session"], input: _d, path: [].concat("type") });
+                case "hello.rejected":
+                    if (typeof __du_223 !== "object" || __du_223 === null || Array.isArray(__du_223)) {
+                        _e.push({ code: "invalid_type", expected: "object", input: __du_223, path: [] });
+                    }
+                    else {
+                        var __o_6977 = __du_223;
+                        if (__o_6977["type"] !== "hello.rejected") {
+                            _e.push({ code: "invalid_value", values: ["hello.rejected"], input: __o_6977["type"], path: ["type"] });
+                        }
+                        if (__o_6977["reason"] !== "password_required" && __o_6977["reason"] !== "incorrect_password" && __o_6977["reason"] !== "incompatible_protocol") {
+                            _e.push({ code: "invalid_value", values: ["password_required", "incorrect_password", "incompatible_protocol"], input: __o_6977["reason"], path: ["reason"] });
+                        }
+                        if (!Array.isArray(__o_6977["accepts"])) {
+                            _e.push({ code: "invalid_type", expected: "array", input: __o_6977["accepts"], path: ["accepts"] });
+                        }
+                        else {
+                            for (var __i_6978 = 0; __i_6978 < __o_6977["accepts"].length; __i_6978++) {
+                                if (__o_6977["accepts"][__i_6978] !== "password") {
+                                    _e.push({ code: "invalid_value", values: ["password"], input: __o_6977["accepts"][__i_6978], path: ["accepts"].concat(__i_6978) });
+                                }
+                            }
+                        }
+                    }
+                    _d = __du_223;
+                    break;
+                default: _e.push({ code: "invalid_union", errors: [], note: "No matching discriminator", discriminator: "type", options: ["pong", "session", "hello.rejected"], input: _d, path: [].concat("type") });
             }
         }
         return __fin(_e, _d);

package/dist/messages.d.ts

@@ -7508,6 +7508,7 @@ export declare const ServerCapabilitiesSchema: z.ZodObject<{
 }, z.core.$loose>;
 export declare const ServerInfoStatusPayloadSchema: z.ZodPipe<z.ZodObject<{
     status: z.ZodLiteral<"server_info">;
+    protocolVersion: z.ZodOptional<z.ZodNumber>;
     serverId: z.ZodString;
     hostname: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodTransform<string | null, unknown>>>;
     version: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodTransform<string | null, unknown>>>;
@@ -7624,6 +7625,7 @@ export declare const ServerInfoStatusPayloadSchema: z.ZodPipe<z.ZodObject<{
     version: string | null;
     status: "server_info";
     serverId: string;
+    protocolVersion?: number | undefined;
     permissions?: ("daemon.read" | "daemon.manage" | "tunnel.manage" | "access.manage" | "workspace.read" | "workspace.write" | "workspace.manage" | "automation.manage" | "hub.execute")[] | undefined;
     desktopManaged?: boolean | undefined;
     capabilities?: {
@@ -7726,6 +7728,7 @@ export declare const ServerInfoStatusPayloadSchema: z.ZodPipe<z.ZodObject<{
     [x: string]: unknown;
     status: "server_info";
     serverId: string;
+    protocolVersion?: number | undefined;
     hostname?: string | null | undefined;
     version?: string | null | undefined;
     permissions?: ("daemon.read" | "daemon.manage" | "tunnel.manage" | "access.manage" | "workspace.read" | "workspace.write" | "workspace.manage" | "automation.manage" | "hub.execute")[] | undefined;
@@ -33640,9 +33643,17 @@ export declare const WSHelloMessageSchema: z.ZodObject<{
         hub: "hub";
     }>;
     protocolVersion: z.ZodNumber;
+    auth: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"password">;
+        password: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"localCredential">;
+        token: z.ZodString;
+    }, z.core.$strip>], "kind">>;
     appVersion: z.ZodOptional<z.ZodString>;
     capabilities: z.ZodOptional<z.ZodObject<{
         voice: z.ZodOptional<z.ZodBoolean>;
+        hello_rejection: z.ZodOptional<z.ZodBoolean>;
         pushNotifications: z.ZodOptional<z.ZodBoolean>;
         explicit_event_subscriptions: z.ZodOptional<z.ZodBoolean>;
         all_providers: z.ZodOptional<z.ZodBoolean>;
@@ -48312,6 +48323,15 @@ export declare const WSSessionOutboundSchema: z.ZodObject<{
         }, z.core.$strip>;
     }, z.core.$strip>], "type">;
 }, z.core.$strip>;
+export declare const WSHelloRejectedMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hello.rejected">;
+    reason: z.ZodEnum<{
+        password_required: "password_required";
+        incorrect_password: "incorrect_password";
+        incompatible_protocol: "incompatible_protocol";
+    }>;
+    accepts: z.ZodArray<z.ZodLiteral<"password">>;
+}, z.core.$strip>;
 export declare const WSInboundMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"ping">;
 }, z.core.$strip>, z.ZodObject<{
@@ -48325,9 +48345,17 @@ export declare const WSInboundMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
         hub: "hub";
     }>;
     protocolVersion: z.ZodNumber;
+    auth: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"password">;
+        password: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"localCredential">;
+        token: z.ZodString;
+    }, z.core.$strip>], "kind">>;
     appVersion: z.ZodOptional<z.ZodString>;
     capabilities: z.ZodOptional<z.ZodObject<{
         voice: z.ZodOptional<z.ZodBoolean>;
+        hello_rejection: z.ZodOptional<z.ZodBoolean>;
         pushNotifications: z.ZodOptional<z.ZodBoolean>;
         explicit_event_subscriptions: z.ZodOptional<z.ZodBoolean>;
         all_providers: z.ZodOptional<z.ZodBoolean>;
@@ -62996,6 +63024,14 @@ export declare const WSOutboundMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObje
             newVersion: z.ZodNullable<z.ZodString>;
         }, z.core.$strip>;
     }, z.core.$strip>], "type">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"hello.rejected">;
+    reason: z.ZodEnum<{
+        password_required: "password_required";
+        incorrect_password: "incorrect_password";
+        incompatible_protocol: "incompatible_protocol";
+    }>;
+    accepts: z.ZodArray<z.ZodLiteral<"password">>;
 }, z.core.$strip>], "type">;
 export type WSInboundMessage = z.infer<typeof WSInboundMessageSchema>;
 export type WSOutboundMessage = z.infer<typeof WSOutboundMessageSchema>;

package/dist/messages.js

@@ -3036,6 +3036,7 @@ const ServerCapabilitiesFromUnknownSchema = z
 export const ServerInfoStatusPayloadSchema = z
     .object({
     status: z.literal("server_info"),
+    protocolVersion: z.number().int().optional(),
     serverId: z.string().trim().min(1),
     hostname: ServerInfoHostnameSchema.optional(),
     version: ServerInfoVersionSchema.optional(),
@@ -6232,10 +6233,17 @@ export const WSHelloMessageSchema = z.object({
     clientId: z.string().min(1),
     clientType: z.enum(["mobile", "browser", "cli", "mcp", "hub"]),
     protocolVersion: z.number().int(),
+    auth: z
+        .discriminatedUnion("kind", [
+        z.object({ kind: z.literal("password"), password: z.string() }),
+        z.object({ kind: z.literal("localCredential"), token: z.string() }),
+    ])
+        .optional(),
     appVersion: z.string().optional(),
     capabilities: z
         .object({
         voice: z.boolean().optional(),
+        [CLIENT_CAPS.helloRejection]: z.boolean().optional(),
         pushNotifications: z.boolean().optional(),
         [CLIENT_CAPS.explicitEventSubscriptions]: z.boolean().optional(),
         [CLIENT_CAPS.allProviders]: z.boolean().optional(),
@@ -6268,6 +6276,11 @@ export const WSSessionOutboundSchema = z.object({
     type: z.literal("session"),
     message: SessionOutboundMessageSchema,
 });
+export const WSHelloRejectedMessageSchema = z.object({
+    type: z.literal("hello.rejected"),
+    reason: z.enum(["password_required", "incorrect_password", "incompatible_protocol"]),
+    accepts: z.array(z.literal("password")),
+});
 // Complete WebSocket message schemas
 export const WSInboundMessageSchema = z.discriminatedUnion("type", [
     WSPingMessageSchema,
@@ -6278,6 +6291,7 @@ export const WSInboundMessageSchema = z.discriminatedUnion("type", [
 export const WSOutboundMessageSchema = z.discriminatedUnion("type", [
     WSPongMessageSchema,
     WSSessionOutboundSchema,
+    WSHelloRejectedMessageSchema,
 ]);
 // ============================================================================
 // Helper functions for message conversion

package/dist/terminal-profiles.js

@@ -73,7 +73,13 @@ export function formatResolvedCommand(resolved) {
 export function resolveTerminalProfileLaunch(profile, prompt) {
     return { name: profile.name, ...substitutePrompt(profile, prompt) };
 }
-const WELL_KNOWN_COMMAND_ICONS = new Map(KNOWN_PROVIDER_ICON_NAMES.map((name) => [name, name]));
+// CLIs whose binary is not named after their icon. Matching stays exact, so a
+// command only gets an icon when its whole base name is listed.
+const COMMAND_ICON_ALIASES = [["cursor-agent", "cursor"]];
+const WELL_KNOWN_COMMAND_ICONS = new Map([
+    ...KNOWN_PROVIDER_ICON_NAMES.map((name) => [name, name]),
+    ...COMMAND_ICON_ALIASES,
+]);
 function getCommandBaseName(command) {
     const lastSlash = command.lastIndexOf("/");
     const lastBackslash = command.lastIndexOf("\\");

package/dist/validation/ws-outbound-schema-metadata.d.ts

@@ -11818,6 +11818,14 @@ export declare const WSOutboundMessageSchema: {
                 newVersion: import("zod").ZodNullable<import("zod").ZodString>;
             }, import("zod/v4/core").$strip>;
         }, import("zod/v4/core").$strip>], "type">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"hello.rejected">;
+        reason: import("zod").ZodEnum<{
+            password_required: "password_required";
+            incorrect_password: "incorrect_password";
+            incompatible_protocol: "incompatible_protocol";
+        }>;
+        accepts: import("zod").ZodArray<import("zod").ZodLiteral<"password">>;
     }, import("zod/v4/core").$strip>], "type">;
 };
 //# sourceMappingURL=ws-outbound-schema-metadata.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camerontaylor/paseo-protocol",
-  "version": "0.9.1-fork.1",
+  "version": "0.10.1-fork.1",
   "description": "Paseo shared protocol schemas and wire types",
   "files": [
     "dist",