@camerontaylor/paseo-protocol 0.12.0-fork.1 → 0.13.0-fork.1

package/dist/host-target.d.ts

@@ -0,0 +1,18 @@
+import { type ConnectionOffer } from "./connection-offer.js";
+import { type SshTransportTarget } from "./ssh-transport.js";
+export type HostTarget = {
+    kind: "ssh";
+    ssh: SshTransportTarget;
+    password?: string;
+    description: string;
+} | {
+    kind: "socket";
+    url: string;
+    socketPath?: string;
+    password?: string;
+    offer?: ConnectionOffer;
+    description: string;
+};
+/** The shared saved-host and CLI grammar. Errors never echo credential-bearing input. */
+export declare function parseHostTarget(input: string): HostTarget;
+//# sourceMappingURL=host-target.d.ts.map

package/dist/host-target.js

@@ -0,0 +1,118 @@
+import { parseConnectionOfferFromUrl } from "./connection-offer.js";
+import { buildDaemonWebSocketUrl, buildRelayWebSocketUrl, normalizeHostPort, parseConnectionUri, parseRelayConnectionUri, shouldUseTlsForDefaultHostedRelay, } from "./daemon-endpoints.js";
+import { parseSshTransportUri } from "./ssh-transport.js";
+/** The shared saved-host and CLI grammar. Errors never echo credential-bearing input. */
+export function parseHostTarget(input) {
+    try {
+        return parse(input.trim());
+    }
+    catch {
+        throw Object.assign(new Error("Invalid host connection. Use host:port, ws(s)://, tcp://, unix://, pipe://, ssh:// or a pairing URL."), { code: "invalid_connection" });
+    }
+}
+function parse(input) {
+    if (!input)
+        throw new Error("empty");
+    if (input.startsWith("ssh://")) {
+        return sshTarget(input);
+    }
+    if (input.startsWith("relay://") || input.includes("#connect=")) {
+        const relay = parseRelayConnectionUri(input);
+        return relayTarget(relay.offer, relay.password);
+    }
+    const offer = parseConnectionOfferFromUrl(input);
+    if (offer)
+        return relayTarget(offer);
+    if (input.startsWith("unix://") ||
+        input.startsWith("pipe://") ||
+        input.startsWith("/") ||
+        input.startsWith("~") ||
+        input.startsWith("\\\\.\\pipe\\")) {
+        const socketPath = input.replace(/^(unix|pipe):\/\//, "");
+        if (!socketPath || socketPath === "~")
+            throw new Error("empty socket");
+        const pipe = input.startsWith("pipe://") || input.startsWith("\\\\.\\pipe\\");
+        return {
+            kind: "socket",
+            socketPath,
+            url: pipe ? "ws://localhost/ws" : `ws+unix://${socketPath}:/ws`,
+            description: `${pipe ? "pipe" : "unix"}://${socketPath}`,
+        };
+    }
+    if (input.startsWith("tcp://"))
+        return tcpTarget(input);
+    if (/^wss?:\/\//.test(input))
+        return websocketTarget(input);
+    const endpoint = validatedEndpoint(/^\d+$/.test(input) ? `127.0.0.1:${input}` : input);
+    return {
+        kind: "socket",
+        url: buildDaemonWebSocketUrl(endpoint, { useTls: false }),
+        description: `tcp://${endpoint}`,
+    };
+}
+function relayTarget(offer, password) {
+    const endpoint = validatedEndpoint(offer.relay.endpoint);
+    return {
+        kind: "socket",
+        url: buildRelayWebSocketUrl({
+            endpoint,
+            serverId: offer.serverId,
+            role: "client",
+            useTls: offer.relay.useTls ?? shouldUseTlsForDefaultHostedRelay(offer.relay.endpoint),
+        }),
+        offer,
+        password,
+        description: `relay://${endpoint}/${encodeURIComponent(offer.serverId)}`,
+    };
+}
+function tcpTarget(input) {
+    const uri = new URL(input);
+    if (uri.pathname && uri.pathname !== "/")
+        throw new Error("Unexpected TCP path");
+    if (uri.hash)
+        throw new Error("Unexpected TCP fragment");
+    const parts = parseConnectionUri(input);
+    const endpoint = validatedEndpoint(`${parts.isIpv6 ? `[${parts.host}]` : parts.host}:${parts.port}`);
+    return {
+        kind: "socket",
+        url: buildDaemonWebSocketUrl(endpoint, { useTls: parts.useTls }),
+        password: parts.password,
+        description: `tcp://${endpoint}`,
+    };
+}
+function websocketTarget(input) {
+    const url = new URL(input);
+    if (!url.hostname || url.username || url.password || url.hash)
+        throw new Error("invalid url");
+    const password = url.searchParams.get("password") ?? undefined;
+    // Unknown query parameters may themselves contain credentials; discovery shows only the origin.
+    if (url.pathname === "/")
+        url.pathname = "/ws";
+    url.searchParams.delete("password");
+    return { kind: "socket", url: url.toString(), password, description: url.origin };
+}
+function sshTarget(input) {
+    const uri = new URL(input);
+    if (uri.searchParams.getAll("password").length > 1)
+        throw new Error("Duplicate daemon password");
+    const password = uri.searchParams.get("password") || undefined;
+    uri.searchParams.delete("password");
+    const ssh = parseSshTransportUri(uri.toString());
+    return {
+        kind: "ssh",
+        ssh,
+        ...(password ? { password } : {}),
+        description: `ssh://${uri.hostname}${ssh.sshPort ? `:${ssh.sshPort}` : ""} (daemon port ${ssh.daemonPort})`,
+    };
+}
+/** A bare endpoint has exactly one authority; URL syntax must use an explicit supported scheme. */
+function validatedEndpoint(input) {
+    if (!/^(?:[a-zA-Z0-9_][a-zA-Z0-9_.-]*|\[[0-9a-fA-F:.]+\]):[0-9]{1,5}$/.test(input))
+        throw new Error("Invalid endpoint");
+    // URL parsing validates IPv6 literals and rejects invalid authority/port encodings.
+    const url = new URL(`http://${input}`);
+    if (!url.hostname)
+        throw new Error("Missing endpoint host");
+    return normalizeHostPort(input);
+}
+//# sourceMappingURL=host-target.js.map

package/dist/hosts.d.ts

@@ -0,0 +1,303 @@
+import { z } from "zod";
+export declare const HostMetadataSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+export declare const HostAddSchema: z.ZodObject<{
+    connection: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    sourceKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const HostUpdateSchema: z.ZodObject<{
+    label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    connection: z.ZodOptional<z.ZodString>;
+    replaceIdentity: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const HostSummarySchema: z.ZodObject<{
+    registrationId: z.ZodString;
+    serverId: z.ZodNullable<z.ZodString>;
+    label: z.ZodNullable<z.ZodString>;
+    source: z.ZodObject<{
+        id: z.ZodString;
+        key: z.ZodString;
+    }, z.core.$strip>;
+    metadata: z.ZodRecord<z.ZodString, z.ZodString>;
+    enabled: z.ZodBoolean;
+    status: z.ZodEnum<{
+        error: "error";
+        connecting: "connecting";
+        online: "online";
+        offline: "offline";
+        disabled: "disabled";
+    }>;
+    targetDescription: z.ZodString;
+    lastOnlineAt: z.ZodNullable<z.ZodString>;
+    nextRetryAt: z.ZodNullable<z.ZodString>;
+    error: z.ZodNullable<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const HostDirectorySchema: z.ZodObject<{
+    self: z.ZodObject<{
+        serverId: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strip>;
+    hosts: z.ZodArray<z.ZodObject<{
+        registrationId: z.ZodString;
+        serverId: z.ZodNullable<z.ZodString>;
+        label: z.ZodNullable<z.ZodString>;
+        source: z.ZodObject<{
+            id: z.ZodString;
+            key: z.ZodString;
+        }, z.core.$strip>;
+        metadata: z.ZodRecord<z.ZodString, z.ZodString>;
+        enabled: z.ZodBoolean;
+        status: z.ZodEnum<{
+            error: "error";
+            connecting: "connecting";
+            online: "online";
+            offline: "offline";
+            disabled: "disabled";
+        }>;
+        targetDescription: z.ZodString;
+        lastOnlineAt: z.ZodNullable<z.ZodString>;
+        nextRetryAt: z.ZodNullable<z.ZodString>;
+        error: z.ZodNullable<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type HostAdd = z.infer<typeof HostAddSchema>;
+export type HostUpdate = z.infer<typeof HostUpdateSchema>;
+export type HostSummary = z.infer<typeof HostSummarySchema>;
+export type HostDirectory = z.infer<typeof HostDirectorySchema>;
+export declare const HostsListRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hosts.list.request">;
+    requestId: z.ZodString;
+    observe: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const HostsAddRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hosts.add.request">;
+    requestId: z.ZodString;
+    input: z.ZodObject<{
+        connection: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        sourceKey: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const HostsUpdateRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hosts.update.request">;
+    requestId: z.ZodString;
+    registrationId: z.ZodString;
+    patch: z.ZodObject<{
+        label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        connection: z.ZodOptional<z.ZodString>;
+        replaceIdentity: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const HostsRemoveRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hosts.remove.request">;
+    requestId: z.ZodString;
+    registrationId: z.ZodString;
+}, z.core.$strip>;
+export declare const HostsRouteOpenRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hosts.route.open.request">;
+    requestId: z.ZodString;
+    serverId: z.ZodString;
+    scopeId: z.ZodString;
+}, z.core.$strip>;
+export declare const HostsRouteFrameRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hosts.route.frame.request">;
+    routeId: z.ZodString;
+    data: z.ZodString;
+    binary: z.ZodLiteral<false>;
+}, z.core.$strip>;
+export declare const HostsRouteCloseRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hosts.route.close.request">;
+    routeId: z.ZodOptional<z.ZodString>;
+    scopeId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const HostsListResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hosts.list.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        directory: z.ZodObject<{
+            self: z.ZodObject<{
+                serverId: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>;
+            hosts: z.ZodArray<z.ZodObject<{
+                registrationId: z.ZodString;
+                serverId: z.ZodNullable<z.ZodString>;
+                label: z.ZodNullable<z.ZodString>;
+                source: z.ZodObject<{
+                    id: z.ZodString;
+                    key: z.ZodString;
+                }, z.core.$strip>;
+                metadata: z.ZodRecord<z.ZodString, z.ZodString>;
+                enabled: z.ZodBoolean;
+                status: z.ZodEnum<{
+                    error: "error";
+                    connecting: "connecting";
+                    online: "online";
+                    offline: "offline";
+                    disabled: "disabled";
+                }>;
+                targetDescription: z.ZodString;
+                lastOnlineAt: z.ZodNullable<z.ZodString>;
+                nextRetryAt: z.ZodNullable<z.ZodString>;
+                error: z.ZodNullable<z.ZodObject<{
+                    code: z.ZodString;
+                    message: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        subscriptionId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const HostsChangedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hosts.changed">;
+    payload: z.ZodObject<{
+        subscriptionId: z.ZodString;
+        directory: z.ZodObject<{
+            self: z.ZodObject<{
+                serverId: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>;
+            hosts: z.ZodArray<z.ZodObject<{
+                registrationId: z.ZodString;
+                serverId: z.ZodNullable<z.ZodString>;
+                label: z.ZodNullable<z.ZodString>;
+                source: z.ZodObject<{
+                    id: z.ZodString;
+                    key: z.ZodString;
+                }, z.core.$strip>;
+                metadata: z.ZodRecord<z.ZodString, z.ZodString>;
+                enabled: z.ZodBoolean;
+                status: z.ZodEnum<{
+                    error: "error";
+                    connecting: "connecting";
+                    online: "online";
+                    offline: "offline";
+                    disabled: "disabled";
+                }>;
+                targetDescription: z.ZodString;
+                lastOnlineAt: z.ZodNullable<z.ZodString>;
+                nextRetryAt: z.ZodNullable<z.ZodString>;
+                error: z.ZodNullable<z.ZodObject<{
+                    code: z.ZodString;
+                    message: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const HostsAddResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hosts.add.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        host: z.ZodObject<{
+            registrationId: z.ZodString;
+            serverId: z.ZodNullable<z.ZodString>;
+            label: z.ZodNullable<z.ZodString>;
+            source: z.ZodObject<{
+                id: z.ZodString;
+                key: z.ZodString;
+            }, z.core.$strip>;
+            metadata: z.ZodRecord<z.ZodString, z.ZodString>;
+            enabled: z.ZodBoolean;
+            status: z.ZodEnum<{
+                error: "error";
+                connecting: "connecting";
+                online: "online";
+                offline: "offline";
+                disabled: "disabled";
+            }>;
+            targetDescription: z.ZodString;
+            lastOnlineAt: z.ZodNullable<z.ZodString>;
+            nextRetryAt: z.ZodNullable<z.ZodString>;
+            error: z.ZodNullable<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const HostsUpdateResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hosts.update.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        host: z.ZodObject<{
+            registrationId: z.ZodString;
+            serverId: z.ZodNullable<z.ZodString>;
+            label: z.ZodNullable<z.ZodString>;
+            source: z.ZodObject<{
+                id: z.ZodString;
+                key: z.ZodString;
+            }, z.core.$strip>;
+            metadata: z.ZodRecord<z.ZodString, z.ZodString>;
+            enabled: z.ZodBoolean;
+            status: z.ZodEnum<{
+                error: "error";
+                connecting: "connecting";
+                online: "online";
+                offline: "offline";
+                disabled: "disabled";
+            }>;
+            targetDescription: z.ZodString;
+            lastOnlineAt: z.ZodNullable<z.ZodString>;
+            nextRetryAt: z.ZodNullable<z.ZodString>;
+            error: z.ZodNullable<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const HostsRemoveResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hosts.remove.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const HostsRouteOpenResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hosts.route.open.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        routeId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const HostsRouteFrameSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hosts.route.frame">;
+    payload: z.ZodObject<{
+        subscriptionId: z.ZodString;
+        data: z.ZodString;
+        binary: z.ZodLiteral<false>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const HostsRouteClosedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hosts.route.closed">;
+    payload: z.ZodObject<{
+        subscriptionId: z.ZodString;
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const HostsLinkOpenRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hosts.link.open.request">;
+    requestId: z.ZodString;
+    channelId: z.ZodString;
+}, z.core.$strip>;
+export declare const HostsLinkOpenResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hosts.link.open.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        routeId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+//# sourceMappingURL=hosts.d.ts.map

package/dist/hosts.js

@@ -0,0 +1,117 @@
+import { z } from "zod";
+export const HostMetadataSchema = z.record(z.string().max(256), z.string().max(4096));
+export const HostAddSchema = z.object({
+    connection: z.string().min(1).max(16384),
+    label: z.string().max(256).optional(),
+    metadata: HostMetadataSchema.optional(),
+    sourceKey: z.string().min(1).max(256).optional(),
+});
+export const HostUpdateSchema = z.object({
+    label: z.string().max(256).nullable().optional(),
+    metadata: HostMetadataSchema.optional(),
+    enabled: z.boolean().optional(),
+    connection: z.string().min(1).max(16384).optional(),
+    replaceIdentity: z.boolean().optional(),
+});
+export const HostSummarySchema = z.object({
+    registrationId: z.string(),
+    serverId: z.string().nullable(),
+    label: z.string().nullable(),
+    source: z.object({ id: z.string(), key: z.string() }),
+    metadata: HostMetadataSchema,
+    enabled: z.boolean(),
+    status: z.enum(["connecting", "online", "offline", "error", "disabled"]),
+    targetDescription: z.string(),
+    lastOnlineAt: z.string().nullable(),
+    nextRetryAt: z.string().nullable(),
+    error: z.object({ code: z.string(), message: z.string() }).nullable(),
+});
+export const HostDirectorySchema = z.object({
+    self: z.object({ serverId: z.string(), label: z.string() }),
+    hosts: z.array(HostSummarySchema),
+});
+export const HostsListRequestSchema = z.object({
+    type: z.literal("hosts.list.request"),
+    requestId: z.string(),
+    observe: z.boolean().optional(),
+});
+export const HostsAddRequestSchema = z.object({
+    type: z.literal("hosts.add.request"),
+    requestId: z.string(),
+    input: HostAddSchema,
+});
+export const HostsUpdateRequestSchema = z.object({
+    type: z.literal("hosts.update.request"),
+    requestId: z.string(),
+    registrationId: z.string(),
+    patch: HostUpdateSchema,
+});
+export const HostsRemoveRequestSchema = z.object({
+    type: z.literal("hosts.remove.request"),
+    requestId: z.string(),
+    registrationId: z.string(),
+});
+export const HostsRouteOpenRequestSchema = z.object({
+    type: z.literal("hosts.route.open.request"),
+    requestId: z.string(),
+    serverId: z.string(),
+    scopeId: z.string().min(1).max(256),
+});
+export const HostsRouteFrameRequestSchema = z.object({
+    type: z.literal("hosts.route.frame.request"),
+    routeId: z.string(),
+    data: z.string().max(100 * 1024 * 1024),
+    binary: z.literal(false),
+});
+export const HostsRouteCloseRequestSchema = z.object({
+    type: z.literal("hosts.route.close.request"),
+    routeId: z.string().optional(),
+    scopeId: z.string().optional(),
+});
+export const HostsListResponseSchema = z.object({
+    type: z.literal("hosts.list.response"),
+    payload: z.object({
+        requestId: z.string(),
+        directory: HostDirectorySchema,
+        subscriptionId: z.string().optional(),
+    }),
+});
+export const HostsChangedSchema = z.object({
+    type: z.literal("hosts.changed"),
+    payload: z.object({ subscriptionId: z.string(), directory: HostDirectorySchema }),
+});
+export const HostsAddResponseSchema = z.object({
+    type: z.literal("hosts.add.response"),
+    payload: z.object({ requestId: z.string(), host: HostSummarySchema }),
+});
+export const HostsUpdateResponseSchema = z.object({
+    type: z.literal("hosts.update.response"),
+    payload: z.object({ requestId: z.string(), host: HostSummarySchema }),
+});
+export const HostsRemoveResponseSchema = z.object({
+    type: z.literal("hosts.remove.response"),
+    payload: z.object({ requestId: z.string() }),
+});
+export const HostsRouteOpenResponseSchema = z.object({
+    type: z.literal("hosts.route.open.response"),
+    payload: z.object({ requestId: z.string(), routeId: z.string() }),
+});
+export const HostsRouteFrameSchema = z.object({
+    type: z.literal("hosts.route.frame"),
+    payload: z.object({ subscriptionId: z.string(), data: z.string(), binary: z.literal(false) }),
+});
+export const HostsRouteClosedSchema = z.object({
+    type: z.literal("hosts.route.closed"),
+    payload: z.object({ subscriptionId: z.string(), code: z.string(), message: z.string() }),
+});
+// Logical B sessions are admitted under the authenticated physical link, never hello auth.
+export const HostsLinkOpenRequestSchema = z.object({
+    type: z.literal("hosts.link.open.request"),
+    requestId: z.string(),
+    channelId: z.string().min(1).max(256),
+});
+export const HostsLinkOpenResponseSchema = z.object({
+    type: z.literal("hosts.link.open.response"),
+    payload: z.object({ requestId: z.string(), routeId: z.string() }),
+});
+//# sourceMappingURL=hosts.js.map