@otto-code/protocol 0.5.0

package/dist/chat/rpc-schemas.d.ts

@@ -0,0 +1,158 @@
+import { z } from "zod";
+export declare const ChatCreateRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"chat/create">;
+    requestId: z.ZodString;
+    name: z.ZodString;
+    purpose: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ChatListRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"chat/list">;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+export declare const ChatInspectRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"chat/inspect">;
+    requestId: z.ZodString;
+    room: z.ZodString;
+}, z.core.$strip>;
+export declare const ChatDeleteRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"chat/delete">;
+    requestId: z.ZodString;
+    room: z.ZodString;
+}, z.core.$strip>;
+export declare const ChatPostRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"chat/post">;
+    requestId: z.ZodString;
+    room: z.ZodString;
+    body: z.ZodString;
+    authorAgentId: z.ZodOptional<z.ZodString>;
+    replyToMessageId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ChatReadRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"chat/read">;
+    requestId: z.ZodString;
+    room: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    since: z.ZodOptional<z.ZodString>;
+    authorAgentId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ChatWaitRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"chat/wait">;
+    requestId: z.ZodString;
+    room: z.ZodString;
+    afterMessageId: z.ZodOptional<z.ZodString>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const ChatCreateResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"chat/create/response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        room: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            purpose: z.ZodNullable<z.ZodString>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+            messageCount: z.ZodNumber;
+            lastMessageAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ChatListResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"chat/list/response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        rooms: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            purpose: z.ZodNullable<z.ZodString>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+            messageCount: z.ZodNumber;
+            lastMessageAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ChatInspectResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"chat/inspect/response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        room: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            purpose: z.ZodNullable<z.ZodString>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+            messageCount: z.ZodNumber;
+            lastMessageAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ChatDeleteResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"chat/delete/response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        room: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            purpose: z.ZodNullable<z.ZodString>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+            messageCount: z.ZodNumber;
+            lastMessageAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ChatPostResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"chat/post/response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        message: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            roomId: z.ZodString;
+            authorAgentId: z.ZodString;
+            body: z.ZodString;
+            replyToMessageId: z.ZodNullable<z.ZodString>;
+            mentionAgentIds: z.ZodArray<z.ZodString>;
+            createdAt: z.ZodString;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ChatReadResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"chat/read/response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        messages: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            roomId: z.ZodString;
+            authorAgentId: z.ZodString;
+            body: z.ZodString;
+            replyToMessageId: z.ZodNullable<z.ZodString>;
+            mentionAgentIds: z.ZodArray<z.ZodString>;
+            createdAt: z.ZodString;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ChatWaitResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"chat/wait/response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        messages: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            roomId: z.ZodString;
+            authorAgentId: z.ZodString;
+            body: z.ZodString;
+            replyToMessageId: z.ZodNullable<z.ZodString>;
+            mentionAgentIds: z.ZodArray<z.ZodString>;
+            createdAt: z.ZodString;
+        }, z.core.$strip>>;
+        timedOut: z.ZodBoolean;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+//# sourceMappingURL=rpc-schemas.d.ts.map

package/dist/chat/rpc-schemas.js

@@ -0,0 +1,103 @@
+import { z } from "zod";
+import { ChatMessageSchema, ChatRoomDetailSchema } from "./types.js";
+export const ChatCreateRequestSchema = z.object({
+    type: z.literal("chat/create"),
+    requestId: z.string(),
+    name: z.string(),
+    purpose: z.string().optional(),
+});
+export const ChatListRequestSchema = z.object({
+    type: z.literal("chat/list"),
+    requestId: z.string(),
+});
+export const ChatInspectRequestSchema = z.object({
+    type: z.literal("chat/inspect"),
+    requestId: z.string(),
+    room: z.string(),
+});
+export const ChatDeleteRequestSchema = z.object({
+    type: z.literal("chat/delete"),
+    requestId: z.string(),
+    room: z.string(),
+});
+export const ChatPostRequestSchema = z.object({
+    type: z.literal("chat/post"),
+    requestId: z.string(),
+    room: z.string(),
+    body: z.string(),
+    authorAgentId: z.string().optional(),
+    replyToMessageId: z.string().optional(),
+});
+export const ChatReadRequestSchema = z.object({
+    type: z.literal("chat/read"),
+    requestId: z.string(),
+    room: z.string(),
+    limit: z.number().int().nonnegative().optional(),
+    since: z.string().optional(),
+    authorAgentId: z.string().optional(),
+});
+export const ChatWaitRequestSchema = z.object({
+    type: z.literal("chat/wait"),
+    requestId: z.string(),
+    room: z.string(),
+    afterMessageId: z.string().optional(),
+    timeoutMs: z.number().int().nonnegative().optional(),
+});
+export const ChatCreateResponseSchema = z.object({
+    type: z.literal("chat/create/response"),
+    payload: z.object({
+        requestId: z.string(),
+        room: ChatRoomDetailSchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const ChatListResponseSchema = z.object({
+    type: z.literal("chat/list/response"),
+    payload: z.object({
+        requestId: z.string(),
+        rooms: z.array(ChatRoomDetailSchema),
+        error: z.string().nullable(),
+    }),
+});
+export const ChatInspectResponseSchema = z.object({
+    type: z.literal("chat/inspect/response"),
+    payload: z.object({
+        requestId: z.string(),
+        room: ChatRoomDetailSchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const ChatDeleteResponseSchema = z.object({
+    type: z.literal("chat/delete/response"),
+    payload: z.object({
+        requestId: z.string(),
+        room: ChatRoomDetailSchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const ChatPostResponseSchema = z.object({
+    type: z.literal("chat/post/response"),
+    payload: z.object({
+        requestId: z.string(),
+        message: ChatMessageSchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const ChatReadResponseSchema = z.object({
+    type: z.literal("chat/read/response"),
+    payload: z.object({
+        requestId: z.string(),
+        messages: z.array(ChatMessageSchema),
+        error: z.string().nullable(),
+    }),
+});
+export const ChatWaitResponseSchema = z.object({
+    type: z.literal("chat/wait/response"),
+    payload: z.object({
+        requestId: z.string(),
+        messages: z.array(ChatMessageSchema),
+        timedOut: z.boolean(),
+        error: z.string().nullable(),
+    }),
+});
+//# sourceMappingURL=rpc-schemas.js.map

package/dist/chat/types.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export declare const ChatRoomSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    purpose: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type ChatRoom = z.infer<typeof ChatRoomSchema>;
+export declare const ChatMessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    roomId: z.ZodString;
+    authorAgentId: z.ZodString;
+    body: z.ZodString;
+    replyToMessageId: z.ZodNullable<z.ZodString>;
+    mentionAgentIds: z.ZodArray<z.ZodString>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type ChatMessage = z.infer<typeof ChatMessageSchema>;
+export declare const ChatRoomDetailSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    purpose: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    messageCount: z.ZodNumber;
+    lastMessageAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ChatRoomDetail = z.infer<typeof ChatRoomDetailSchema>;
+//# sourceMappingURL=types.d.ts.map

package/dist/chat/types.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+export const ChatRoomSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    purpose: z.string().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+export const ChatMessageSchema = z.object({
+    id: z.string(),
+    roomId: z.string(),
+    authorAgentId: z.string(),
+    body: z.string(),
+    replyToMessageId: z.string().nullable(),
+    mentionAgentIds: z.array(z.string()),
+    createdAt: z.string(),
+});
+export const ChatRoomDetailSchema = ChatRoomSchema.extend({
+    messageCount: z.number().int().nonnegative(),
+    lastMessageAt: z.string().nullable(),
+});
+//# sourceMappingURL=types.js.map

package/dist/client-capabilities.d.ts

@@ -0,0 +1,8 @@
+export declare const CLIENT_CAPS: {
+    readonly reasoningMergeEnum: "reasoning_merge_enum";
+    readonly customModeIcons: "custom_mode_icons";
+    readonly terminalReflowableSnapshot: "terminal_reflowable_snapshot";
+    readonly browserHost: "browser_host";
+};
+export type ClientCapability = (typeof CLIENT_CAPS)[keyof typeof CLIENT_CAPS];
+//# sourceMappingURL=client-capabilities.d.ts.map

package/dist/client-capabilities.js

@@ -0,0 +1,16 @@
+export const CLIENT_CAPS = {
+    reasoningMergeEnum: "reasoning_merge_enum",
+    // COMPAT(customModeIcons): added in v0.1.84. Old clients pin AgentModeIcon to
+    // a closed enum and crash rendering unknown values; daemon downgrades icons
+    // outside the legacy set to "ShieldCheck" when this cap is absent. Drop the
+    // gate when floor >= v0.1.84.
+    customModeIcons: "custom_mode_icons",
+    // COMPAT(terminalReflowableSnapshot): added in v0.1.88. The daemon attaches
+    // per-row soft-wrap flags (gridWrapped/scrollbackWrapped) to terminal snapshots
+    // only when the client advertises this, so restored content can reflow on resize.
+    // Old clients use a strict TerminalState schema and would reject the extra fields.
+    // Drop the gate (always send the flags) when floor >= v0.1.88.
+    terminalReflowableSnapshot: "terminal_reflowable_snapshot",
+    browserHost: "browser_host",
+};
+//# sourceMappingURL=client-capabilities.js.map

package/dist/connection-offer.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+/**
+ * Relay-only pairing offer.
+ *
+ * `serverId` is a stable daemon identifier scoped to `OTTO_HOME`, and is also
+ * used as the relay session identifier.
+ */
+export declare const ConnectionOfferV2Schema: z.ZodObject<{
+    v: z.ZodLiteral<2>;
+    serverId: z.ZodString;
+    daemonPublicKeyB64: z.ZodString;
+    relay: z.ZodObject<{
+        endpoint: z.ZodString;
+        useTls: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ConnectionOfferV2 = z.infer<typeof ConnectionOfferV2Schema>;
+export declare const ConnectionOfferSchema: z.ZodObject<{
+    v: z.ZodLiteral<2>;
+    serverId: z.ZodString;
+    daemonPublicKeyB64: z.ZodString;
+    relay: z.ZodObject<{
+        endpoint: z.ZodString;
+        useTls: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ConnectionOffer = ConnectionOfferV2;
+export declare function decodeOfferFragmentPayload(encoded: string): unknown;
+/**
+ * Parse a pairing-offer URL of the form `https://app.otto-code.me/#offer=<base64url>`.
+ *
+ * Returns `null` if the input has no `#offer=` fragment. Throws if the fragment
+ * exists but the payload is malformed or fails schema validation.
+ */
+export declare function parseConnectionOfferFromUrl(input: string): ConnectionOffer | null;
+//# sourceMappingURL=connection-offer.d.ts.map

package/dist/connection-offer.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+/**
+ * Relay-only pairing offer.
+ *
+ * `serverId` is a stable daemon identifier scoped to `OTTO_HOME`, and is also
+ * used as the relay session identifier.
+ */
+export const ConnectionOfferV2Schema = z.object({
+    v: z.literal(2),
+    serverId: z.string().min(1),
+    daemonPublicKeyB64: z.string().min(1),
+    relay: z.object({
+        endpoint: z.string().min(1),
+        useTls: z.boolean().optional(),
+    }),
+});
+export const ConnectionOfferSchema = ConnectionOfferV2Schema;
+function decodeBase64UrlToUtf8(input) {
+    const base64 = input.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = base64.padEnd(base64.length + ((4 - (base64.length % 4)) % 4), "=");
+    const binary = globalThis.atob(padded);
+    const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+}
+export function decodeOfferFragmentPayload(encoded) {
+    const json = decodeBase64UrlToUtf8(encoded);
+    return JSON.parse(json);
+}
+const OFFER_FRAGMENT_PREFIX = "#offer=";
+function extractOfferFragmentEncoded(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return null;
+    const fragmentIndex = trimmed.indexOf(OFFER_FRAGMENT_PREFIX);
+    if (fragmentIndex === -1)
+        return null;
+    const encoded = trimmed.slice(fragmentIndex + OFFER_FRAGMENT_PREFIX.length).trim();
+    return encoded.length > 0 ? encoded : null;
+}
+/**
+ * Parse a pairing-offer URL of the form `https://app.otto-code.me/#offer=<base64url>`.
+ *
+ * Returns `null` if the input has no `#offer=` fragment. Throws if the fragment
+ * exists but the payload is malformed or fails schema validation.
+ */
+export function parseConnectionOfferFromUrl(input) {
+    const encoded = extractOfferFragmentEncoded(input);
+    if (!encoded)
+        return null;
+    const payload = decodeOfferFragmentPayload(encoded);
+    return ConnectionOfferSchema.parse(payload);
+}
+//# sourceMappingURL=connection-offer.js.map

package/dist/daemon-endpoints.d.ts

@@ -0,0 +1,47 @@
+export interface HostPortParts {
+    host: string;
+    port: number;
+    isIpv6: boolean;
+}
+export interface ConnectionUriParts extends HostPortParts {
+    useTls: boolean;
+}
+export interface ParsedConnectionUri extends ConnectionUriParts {
+    password?: string;
+}
+export type RelayRole = "server" | "client";
+export type RelayProtocolVersion = "1" | "2";
+export declare const CURRENT_RELAY_PROTOCOL_VERSION: RelayProtocolVersion;
+export declare const DEFAULT_RELAY_ENDPOINT = "relay.otto-code.me:443";
+export declare function normalizeRelayProtocolVersion(value: unknown, fallback?: RelayProtocolVersion): RelayProtocolVersion;
+export declare function parseHostPort(input: string): HostPortParts;
+export declare function normalizeHostPort(input: string): string;
+export declare function parseConnectionUri(input: string): ParsedConnectionUri;
+export declare function serializeConnectionUri(parts: ConnectionUriParts): string;
+export declare function serializeConnectionUriForStorage(parts: ParsedConnectionUri): string;
+export declare function normalizeLoopbackToLocalhost(endpoint: string): string;
+export declare function deriveLabelFromEndpoint(endpoint: string): string;
+export interface WebSocketUrlOptions {
+    useTls: boolean;
+}
+export declare function buildDaemonWebSocketUrl(endpoint: string, opts: WebSocketUrlOptions): string;
+export declare function buildRelayWebSocketUrl(params: {
+    endpoint: string;
+    useTls: boolean;
+    serverId: string;
+    role: RelayRole;
+    /**
+     * Per-connection routing identifier used by the daemon to open server data sockets.
+     * Clients should NOT provide this — the relay assigns a routing ID on connect.
+     */
+    connectionId?: string;
+    version?: RelayProtocolVersion | 1 | 2;
+}): string;
+/**
+ * @deprecated Migration fallback for stored relay connections/offers that predate
+ * explicit relay useTls. Delete after two release cycles.
+ */
+export declare function shouldUseTlsForDefaultHostedRelay(endpoint: string): boolean;
+export declare function extractHostPortFromWebSocketUrl(wsUrl: string): string;
+export declare function isRelayClientWebSocketUrl(url: string): boolean;
+//# sourceMappingURL=daemon-endpoints.d.ts.map

package/dist/daemon-endpoints.js

@@ -0,0 +1,201 @@
+export const CURRENT_RELAY_PROTOCOL_VERSION = "2";
+export const DEFAULT_RELAY_ENDPOINT = "relay.otto-code.me:443";
+export function normalizeRelayProtocolVersion(value, fallback = CURRENT_RELAY_PROTOCOL_VERSION) {
+    if (value == null) {
+        return fallback;
+    }
+    let normalized = "";
+    if (typeof value === "string") {
+        normalized = value.trim();
+    }
+    else if (typeof value === "number") {
+        normalized = String(value);
+    }
+    if (!normalized) {
+        return fallback;
+    }
+    if (normalized === "1" || normalized === "2") {
+        return normalized;
+    }
+    throw new Error('Relay version must be "1" or "2"');
+}
+function parsePort(portStr, context) {
+    const port = Number(portStr);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error(`${context}: port must be between 1 and 65535`);
+    }
+    return port;
+}
+export function parseHostPort(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        throw new Error("Host is required");
+    }
+    // IPv6: [::1]:6868
+    if (trimmed.startsWith("[")) {
+        const match = trimmed.match(/^\[([^\]]+)\]:(\d{1,5})$/);
+        if (!match) {
+            throw new Error("Invalid host:port (expected [::1]:6868)");
+        }
+        const host = match[1].trim();
+        if (!host)
+            throw new Error("Host is required");
+        const port = parsePort(match[2], "Invalid host:port");
+        return { host, port, isIpv6: true };
+    }
+    const match = trimmed.match(/^(.+):(\d{1,5})$/);
+    if (!match) {
+        throw new Error("Invalid host:port (expected localhost:6868)");
+    }
+    const host = match[1].trim();
+    if (!host)
+        throw new Error("Host is required");
+    const port = parsePort(match[2], "Invalid host:port");
+    return { host, port, isIpv6: false };
+}
+export function normalizeHostPort(input) {
+    const { host, port, isIpv6 } = parseHostPort(input);
+    return isIpv6 ? `[${host}]:${port}` : `${host}:${port}`;
+}
+export function parseConnectionUri(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        throw new Error("Connection URI is required");
+    }
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        throw new Error("Invalid connection URI");
+    }
+    if (parsed.protocol !== "tcp:") {
+        throw new Error("Connection URI protocol must be tcp:");
+    }
+    if (!parsed.hostname) {
+        throw new Error("Connection URI host is required");
+    }
+    if (!parsed.port) {
+        throw new Error("Connection URI port is required");
+    }
+    if (parsed.username || parsed.password) {
+        throw new Error("Connection URI userinfo is not supported");
+    }
+    const isIpv6 = parsed.hostname.startsWith("[") && parsed.hostname.endsWith("]");
+    const host = isIpv6 ? parsed.hostname.slice(1, -1) : parsed.hostname;
+    const password = parsed.searchParams.get("password") || undefined;
+    return {
+        host,
+        port: parsePort(parsed.port, "Invalid connection URI"),
+        isIpv6,
+        useTls: parsed.searchParams.get("ssl") === "true",
+        ...(password ? { password } : {}),
+    };
+}
+export function serializeConnectionUri(parts) {
+    return createConnectionUri(parts).toString();
+}
+export function serializeConnectionUriForStorage(parts) {
+    const url = createConnectionUri(parts);
+    if (parts.password) {
+        url.searchParams.set("password", parts.password);
+    }
+    return url.toString();
+}
+function createConnectionUri(parts) {
+    const hostPart = parts.isIpv6 ? `[${parts.host}]` : parts.host;
+    const url = new URL(`tcp://${hostPart}:${parts.port}`);
+    if (parts.useTls) {
+        url.searchParams.set("ssl", "true");
+    }
+    return url;
+}
+export function normalizeLoopbackToLocalhost(endpoint) {
+    const { host, port, isIpv6 } = parseHostPort(endpoint);
+    if (host === "127.0.0.1" || (!isIpv6 && host === "0.0.0.0")) {
+        return `localhost:${port}`;
+    }
+    if (isIpv6 && (host === "::1" || host === "::")) {
+        return `localhost:${port}`;
+    }
+    return endpoint;
+}
+export function deriveLabelFromEndpoint(endpoint) {
+    try {
+        const { host } = parseHostPort(endpoint);
+        return host || "Unnamed Host";
+    }
+    catch {
+        return "Unnamed Host";
+    }
+}
+export function buildDaemonWebSocketUrl(endpoint, opts) {
+    const { host, port, isIpv6 } = parseHostPort(endpoint);
+    const protocol = opts.useTls ? "wss" : "ws";
+    const hostPart = isIpv6 ? `[${host}]` : host;
+    return new URL(`${protocol}://${hostPart}:${port}/ws`).toString();
+}
+export function buildRelayWebSocketUrl(params) {
+    const { host, port, isIpv6 } = parseHostPort(params.endpoint);
+    const protocol = params.useTls ? "wss" : "ws";
+    const hostPart = isIpv6 ? `[${host}]` : host;
+    const url = new URL(`${protocol}://${hostPart}:${port}/ws`);
+    url.searchParams.set("serverId", params.serverId);
+    url.searchParams.set("role", params.role);
+    url.searchParams.set("v", normalizeRelayProtocolVersion(params.version));
+    if (params.connectionId) {
+        url.searchParams.set("connectionId", params.connectionId);
+    }
+    return url.toString();
+}
+/**
+ * @deprecated Migration fallback for stored relay connections/offers that predate
+ * explicit relay useTls. Delete after two release cycles.
+ */
+export function shouldUseTlsForDefaultHostedRelay(endpoint) {
+    try {
+        const { port } = parseHostPort(endpoint);
+        return port === 443;
+    }
+    catch {
+        return false;
+    }
+}
+export function extractHostPortFromWebSocketUrl(wsUrl) {
+    const parsed = new URL(wsUrl);
+    if (parsed.protocol !== "ws:" && parsed.protocol !== "wss:") {
+        throw new Error("Invalid WebSocket URL protocol");
+    }
+    if (parsed.pathname.replace(/\/+$/, "") !== "/ws") {
+        throw new Error("Invalid WebSocket URL (expected /ws path)");
+    }
+    const host = parsed.hostname;
+    let port;
+    if (parsed.port) {
+        port = Number(parsed.port);
+    }
+    else if (parsed.protocol === "wss:") {
+        port = 443;
+    }
+    else {
+        port = 80;
+    }
+    if (!host) {
+        throw new Error("Invalid WebSocket URL (missing hostname)");
+    }
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error("Invalid WebSocket URL (invalid port)");
+    }
+    const isIpv6 = host.includes(":") && !host.startsWith("[") && !host.endsWith("]");
+    return isIpv6 ? `[${host}]:${port}` : `${host}:${port}`;
+}
+export function isRelayClientWebSocketUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return parsed.searchParams.get("role") === "client" && parsed.searchParams.has("serverId");
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=daemon-endpoints.js.map

package/dist/default-personalities.d.ts

@@ -0,0 +1,3 @@
+import type { AgentPersonality } from "./messages.js";
+export declare const DEFAULT_AGENT_PERSONALITIES: readonly AgentPersonality[];
+//# sourceMappingURL=default-personalities.d.ts.map