@yefengr/pi-reach 0.0.0-stage → 0.0.2

package/dist/vendor/protocol/outer/codec.js

@@ -0,0 +1,105 @@
+import { decodeBase64, decodeUtf8, encodeBase64, encodeUtf8 } from "../encoding.js";
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function parseJson(value) {
+    if (typeof value !== "string" && !(value instanceof Uint8Array))
+        return value;
+    try {
+        return JSON.parse(typeof value === "string" ? value : decodeUtf8(value));
+    }
+    catch {
+        return undefined;
+    }
+}
+function isId(value) {
+    return typeof value === "string" && value.length > 0 && value.length <= 256;
+}
+function isUuid(value) {
+    return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
+function hasOnlyKeys(value, allowed) {
+    return Object.keys(value).every((key) => allowed.includes(key));
+}
+function decodeMetadata(value) {
+    if (!isRecord(value) || !hasOnlyKeys(value, ["kind", "name", "cwd", "pid", "started_at", "model", "thinking", "working"]) || (value.kind !== "daemon" && value.kind !== "interactive"))
+        return undefined;
+    const scalar = (key, type) => value[key] === undefined || typeof value[key] === type;
+    if (!scalar("name", "string") || !scalar("cwd", "string") || !scalar("pid", "number") || !scalar("started_at", "number") || !scalar("model", "string") || !scalar("thinking", "string") || !scalar("working", "boolean"))
+        return undefined;
+    return value;
+}
+function decodeEndpoint(value) {
+    if (!isRecord(value) || !isUuid(value.endpoint_id) || !isUuid(value.runtime_instance_id))
+        return undefined;
+    const metadata = decodeMetadata(value.metadata);
+    return metadata ? { endpoint_id: value.endpoint_id, runtime_instance_id: value.runtime_instance_id, metadata } : undefined;
+}
+export function decodeRoute(value) {
+    if (!isRecord(value) || value.type !== "route" || (value.purpose !== "pairing" && value.purpose !== "session") || !isId(value.device_id) || !isUuid(value.endpoint_id) || !isUuid(value.runtime_instance_id) || typeof value.ct !== "string")
+        return undefined;
+    const allowed = new Set(["type", "purpose", "device_id", "endpoint_id", "runtime_instance_id", "target_owner_id", "source_owner_id", "ct"]);
+    if (Object.keys(value).some((key) => !allowed.has(key)))
+        return undefined;
+    if (value.target_owner_id !== undefined && !isId(value.target_owner_id))
+        return undefined;
+    if (value.source_owner_id !== undefined && !isId(value.source_owner_id))
+        return undefined;
+    return value;
+}
+export function decodeControlFrame(value) {
+    if (!isRecord(value) || typeof value.type !== "string")
+        return undefined;
+    if (value.type === "pairing_target" && hasOnlyKeys(value, ["type", "in_reply_to", "code", "device_id", "endpoint_id", "runtime_instance_id"]) && isId(value.in_reply_to) && isId(value.code) && isId(value.device_id) && isUuid(value.endpoint_id) && isUuid(value.runtime_instance_id)) {
+        return { type: "pairing_target", in_reply_to: value.in_reply_to, code: value.code, device_id: value.device_id, endpoint_id: value.endpoint_id, runtime_instance_id: value.runtime_instance_id };
+    }
+    if (value.type === "pairing_code_error" && hasOnlyKeys(value, ["type", "in_reply_to", "reason"]) && isId(value.in_reply_to) && (value.reason === "unknown_code" || value.reason === "expired_code" || value.reason === "stale_target" || value.reason === "rate_limited")) {
+        return { type: "pairing_code_error", in_reply_to: value.in_reply_to, reason: value.reason };
+    }
+    if (!isId(value.device_id))
+        return undefined;
+    if (value.type === "endpoints" && hasOnlyKeys(value, ["type", "device_id", "endpoints"]) && Array.isArray(value.endpoints)) {
+        const endpoints = value.endpoints.map(decodeEndpoint);
+        return endpoints.every((endpoint) => endpoint !== undefined) ? { type: "endpoints", device_id: value.device_id, endpoints } : undefined;
+    }
+    if ((value.type === "endpoint_announced" || value.type === "endpoint_updated") && hasOnlyKeys(value, ["type", "device_id", "endpoint_id", "runtime_instance_id", "metadata"]) && isUuid(value.endpoint_id) && isUuid(value.runtime_instance_id)) {
+        const metadata = decodeMetadata(value.metadata);
+        return metadata ? { type: value.type, device_id: value.device_id, endpoint_id: value.endpoint_id, runtime_instance_id: value.runtime_instance_id, metadata } : undefined;
+    }
+    if (value.type === "endpoint_ended" && hasOnlyKeys(value, ["type", "device_id", "endpoint_id", "runtime_instance_id"]) && isUuid(value.endpoint_id) && isUuid(value.runtime_instance_id))
+        return { type: "endpoint_ended", device_id: value.device_id, endpoint_id: value.endpoint_id, runtime_instance_id: value.runtime_instance_id };
+    return undefined;
+}
+export function decodeRelayFrame(value) {
+    const route = decodeRoute(value);
+    if (route)
+        return { kind: "route", route };
+    const control = decodeControlFrame(value);
+    return control ? { kind: "control", frame: control } : undefined;
+}
+export function encodeRoutePayload(payload) {
+    return encodeBase64(typeof payload === "string" ? encodeUtf8(payload) : payload, "standard");
+}
+export function decodeRoutePayload(route) {
+    try {
+        return decodeBase64(route.ct, "standard");
+    }
+    catch {
+        return undefined;
+    }
+}
+export function encodeControlFrame(frame) {
+    return JSON.stringify(frame);
+}
+export function decodeChallenge(value) {
+    const parsed = parseJson(value);
+    if (!isRecord(parsed) || !hasOnlyKeys(parsed, ["type", "nonce"]) || parsed.type !== "challenge" || typeof parsed.nonce !== "string")
+        return undefined;
+    try {
+        decodeBase64(parsed.nonce, "standard");
+    }
+    catch {
+        return undefined;
+    }
+    return { type: "challenge", nonce: parsed.nonce };
+}

package/dist/vendor/protocol/outer/index.d.ts

@@ -0,0 +1,4 @@
+export { PAIRING_INVITE_TTL_MS, PAIR_TTL_MAX_MS, PAIR_TTL_MIN_MS, PROTOCOL_VERSION, } from "../constants.js";
+export * from "../encoding.js";
+export * from "./types.js";
+export * from "./codec.js";

package/dist/vendor/protocol/outer/index.js

@@ -0,0 +1,4 @@
+export { PAIRING_INVITE_TTL_MS, PAIR_TTL_MAX_MS, PAIR_TTL_MIN_MS, PROTOCOL_VERSION, } from "../constants.js";
+export * from "../encoding.js";
+export * from "./types.js";
+export * from "./codec.js";

package/dist/vendor/protocol/outer/types.d.ts

@@ -0,0 +1,120 @@
+import type { PROTOCOL_VERSION } from "../constants.js";
+export type EndpointMetadata = {
+    kind: "daemon" | "interactive";
+    name?: string | null;
+    cwd?: string | null;
+    pid?: number | null;
+    started_at?: number | null;
+    model?: string | null;
+    thinking?: string | null;
+    working?: boolean | null;
+};
+export type EndpointInfo = {
+    endpoint_id: string;
+    runtime_instance_id: string;
+    metadata: EndpointMetadata;
+};
+export type RoutePurpose = "pairing" | "session";
+export type RouteFrame = {
+    type: "route";
+    purpose: RoutePurpose;
+    device_id: string;
+    endpoint_id: string;
+    runtime_instance_id: string;
+    target_owner_id?: string;
+    source_owner_id?: string;
+    ct: string;
+};
+export type OwnerHelloFrame = {
+    type: "hello";
+    protocol_version: typeof PROTOCOL_VERSION;
+    role: "owner";
+    pubkey: string;
+};
+export type HostHelloFrame = {
+    type: "hello";
+    protocol_version: typeof PROTOCOL_VERSION;
+    role: "host";
+    pubkey: string;
+    endpoint_id: string;
+    runtime_instance_id: string;
+    metadata: EndpointMetadata;
+    authorized_owner_ids: readonly string[];
+};
+export type HelloFrame = OwnerHelloFrame | HostHelloFrame;
+export type ChallengeFrame = {
+    type: "challenge";
+    nonce: string;
+};
+export type AuthFrame = {
+    type: "auth";
+    sig: string;
+};
+export type EndpointUpdateFrame = {
+    type: "endpoint_update";
+    metadata?: EndpointMetadata;
+    authorized_owner_ids?: readonly string[];
+};
+export type PairingOfferFrame = {
+    type: "pairing_offer";
+    code: string;
+    endpoint_id: string;
+    runtime_instance_id: string;
+    expires_at: number;
+};
+export type HostControlOutbound = EndpointUpdateFrame | PairingOfferFrame;
+export type PairingTargetControl = {
+    type: "pairing_target";
+    in_reply_to: string;
+    code: string;
+    device_id: string;
+    endpoint_id: string;
+    runtime_instance_id: string;
+};
+export type PairingCodeErrorReason = "unknown_code" | "expired_code" | "stale_target" | "rate_limited";
+export type PairingCodeErrorControl = {
+    type: "pairing_code_error";
+    in_reply_to: string;
+    reason: PairingCodeErrorReason;
+};
+export type EndpointsControl = {
+    type: "endpoints";
+    device_id: string;
+    endpoints: EndpointInfo[];
+};
+export type EndpointAnnouncedControl = {
+    type: "endpoint_announced";
+    device_id: string;
+    endpoint_id: string;
+    runtime_instance_id: string;
+    metadata: EndpointMetadata;
+};
+export type EndpointUpdatedControl = {
+    type: "endpoint_updated";
+    device_id: string;
+    endpoint_id: string;
+    runtime_instance_id: string;
+    metadata: EndpointMetadata;
+};
+export type EndpointEndedControl = {
+    type: "endpoint_ended";
+    device_id: string;
+    endpoint_id: string;
+    runtime_instance_id: string;
+};
+export type ControlFrame = PairingTargetControl | PairingCodeErrorControl | EndpointsControl | EndpointAnnouncedControl | EndpointUpdatedControl | EndpointEndedControl;
+export type ControlOutbound = {
+    type: "resolve_pairing_code";
+    request_id: string;
+    code: string;
+} | {
+    type: "subscribe_endpoints";
+    device_ids: string[];
+};
+export type RelayFrame = {
+    kind: "route";
+    route: RouteFrame;
+} | {
+    kind: "control";
+    frame: ControlFrame;
+};

package/dist/vendor/protocol/outer/types.js

@@ -0,0 +1 @@
+export {};

package/dist/vendor/protocol/session/codec.d.ts

@@ -0,0 +1,41 @@
+import type { ClientFrame, ServerFrame } from "./frames.js";
+import type { TimelineEvent, TimelinePartial } from "./schema.js";
+export declare const DECODE_ERROR_CODES: {
+    readonly invalid: "invalid";
+    readonly unsupported: "unsupported";
+    readonly version: "version";
+    readonly schema: "schema";
+    readonly size: "size";
+    readonly direction: "direction";
+};
+export type DecodeErrorCode = (typeof DECODE_ERROR_CODES)[keyof typeof DECODE_ERROR_CODES];
+export declare class DecodeError extends Error {
+    readonly code: DecodeErrorCode;
+    readonly name = "DecodeError";
+    constructor(code: DecodeErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function getUtf8ByteLengthV2(value: unknown): number;
+export declare function parseProtocolJsonV2(raw: unknown, maxBytes?: number): unknown;
+export declare function decodeClientFrameV2(raw: unknown): ClientFrame;
+export declare function decodeServerFrameV2(raw: unknown): ServerFrame;
+export declare function encodeClientFrameV2(frame: ClientFrame): Uint8Array;
+export declare function encodeServerFrameV2(frame: ServerFrame): Uint8Array;
+export declare function encodeClientFrameTextV2(frame: ClientFrame): string;
+export declare function encodeServerFrameTextV2(frame: ServerFrame): string;
+export declare function validateFragmentSizeV2(fragment: unknown): number;
+export declare function validateHistoryChunkSizeV2(chunk: unknown): number;
+export declare function validateWindowSizeV2(events: readonly unknown[]): number;
+export declare function validateEncodedSizeV2(value: unknown, maxBytes?: number): number;
+export declare function parseTimelineEventV2(raw: unknown): TimelineEvent;
+export declare function parseTimelinePartialV2(raw: unknown): TimelinePartial;
+export declare function validateFrameSizeV2(raw: unknown, maxBytes?: number): number;
+export declare const validateTimelineEventFragmentV2: typeof validateFragmentSizeV2;
+export declare const validateSessionHistoryChunkV2: typeof validateHistoryChunkSizeV2;
+export declare const validateTimelineWindowV2: typeof validateWindowSizeV2;
+export declare const validateFrameSize: typeof validateFrameSizeV2;
+export declare const validateFragmentSize: typeof validateFragmentSizeV2;
+export declare const validateSessionHistoryChunkSize: typeof validateHistoryChunkSizeV2;
+export declare const validateWindowSize: typeof validateWindowSizeV2;

package/dist/vendor/protocol/session/codec.js

@@ -0,0 +1,236 @@
+import { clientFrameSchema, clientFrameTypes, serverFrameSchema, serverFrameTypes, sessionHistoryChunkFrameSchema, timelineEventFragmentFrameSchema, } from "./frames.js";
+import { historyFragmentSchema, timelineEventFragmentSchema, timelineEventSchema, timelinePartialSchema, } from "./schema.js";
+import { MAX_FRAGMENT_BYTES, MAX_FRAME_BYTES, MAX_HISTORY_CHUNK_BYTES, MAX_WINDOW_BYTES, } from "./schema.js";
+export const DECODE_ERROR_CODES = {
+    invalid: "invalid",
+    unsupported: "unsupported",
+    version: "version",
+    schema: "schema",
+    size: "size",
+    direction: "direction",
+};
+export class DecodeError extends Error {
+    code;
+    name = "DecodeError";
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+    }
+}
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder("utf-8", { fatal: true });
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function encodeJson(value) {
+    try {
+        const encoded = JSON.stringify(value);
+        if (encoded === undefined)
+            throw new Error("value is not JSON serializable");
+        return textEncoder.encode(encoded);
+    }
+    catch (error) {
+        if (error instanceof DecodeError)
+            throw error;
+        throw new DecodeError("invalid", "value is not JSON serializable", { cause: error });
+    }
+}
+export function getUtf8ByteLengthV2(value) {
+    return encodeJson(value).byteLength;
+}
+function parseRaw(raw, maxBytes = MAX_WINDOW_BYTES) {
+    if (typeof raw === "string") {
+        const bytes = textEncoder.encode(raw).byteLength;
+        if (bytes > maxBytes)
+            throw new DecodeError("size", `raw value exceeds ${maxBytes} bytes`);
+        try {
+            return { value: JSON.parse(raw), bytes };
+        }
+        catch (error) {
+            throw new DecodeError("invalid", "raw string is not valid JSON", { cause: error });
+        }
+    }
+    if (raw instanceof Uint8Array) {
+        if (raw.byteLength > maxBytes)
+            throw new DecodeError("size", `raw value exceeds ${maxBytes} bytes`);
+        try {
+            return { value: JSON.parse(textDecoder.decode(raw)), bytes: raw.byteLength };
+        }
+        catch (error) {
+            throw new DecodeError("invalid", "raw bytes are not valid UTF-8 JSON", { cause: error });
+        }
+    }
+    if (isRecord(raw)) {
+        const bytes = getUtf8ByteLengthV2(raw);
+        if (bytes > maxBytes)
+            throw new DecodeError("size", `raw value exceeds ${maxBytes} bytes`);
+        return { value: raw, bytes };
+    }
+    throw new DecodeError("invalid", "raw frame must be an object, JSON string, or Uint8Array");
+}
+export function parseProtocolJsonV2(raw, maxBytes = MAX_WINDOW_BYTES) {
+    return parseRaw(raw, maxBytes).value;
+}
+function schemaMessage(error) {
+    return error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ");
+}
+function assertByteLimit(value, bytes, limit = MAX_FRAME_BYTES) {
+    if (bytes > limit) {
+        throw new DecodeError("size", `${String(value.type)} exceeds ${limit} encoded UTF-8 bytes`);
+    }
+}
+function assertVersion(value) {
+    if (value.protocol_version !== 2) {
+        throw new DecodeError("version", "protocol_version must be 2");
+    }
+}
+function assertDirection(type, direction) {
+    const knownClient = clientFrameTypes.has(type);
+    const knownServer = serverFrameTypes.has(type);
+    if (!knownClient && !knownServer) {
+        throw new DecodeError("unsupported", `unsupported frame type: ${type}`);
+    }
+    if ((direction === "client" && !knownClient) || (direction === "server" && !knownServer)) {
+        throw new DecodeError("direction", `${type} is not a ${direction} frame`);
+    }
+}
+function frameType(value) {
+    if (!isRecord(value) || typeof value.type !== "string") {
+        throw new DecodeError("invalid", "frame must contain a string type");
+    }
+    return value.type;
+}
+function parseFrame(raw, direction, schema) {
+    const parsed = parseRaw(raw, MAX_FRAME_BYTES);
+    const type = frameType(parsed.value);
+    assertDirection(type, direction);
+    assertVersion(parsed.value);
+    const result = schema.safeParse(parsed.value);
+    if (!result.success) {
+        throw new DecodeError("schema", schemaMessage(result.error), { cause: result.error });
+    }
+    assertByteLimit(parsed.value, parsed.bytes);
+    if (type === "timeline_event_fragment")
+        validateFragmentSizeV2(parsed.value);
+    if (type === "session_history_chunk")
+        validateHistoryChunkSizeV2(parsed.value);
+    return result.data;
+}
+export function decodeClientFrameV2(raw) {
+    return parseFrame(raw, "client", clientFrameSchema);
+}
+export function decodeServerFrameV2(raw) {
+    return parseFrame(raw, "server", serverFrameSchema);
+}
+function encodeFrame(frame, direction) {
+    const parsed = direction === "client"
+        ? parseFrame(frame, direction, clientFrameSchema)
+        : parseFrame(frame, direction, serverFrameSchema);
+    const encoded = encodeJson(parsed);
+    assertByteLimit(isRecord(parsed) ? parsed : { type: "frame" }, encoded.byteLength);
+    return encoded;
+}
+export function encodeClientFrameV2(frame) {
+    return encodeFrame(frame, "client");
+}
+export function encodeServerFrameV2(frame) {
+    return encodeFrame(frame, "server");
+}
+export function encodeClientFrameTextV2(frame) {
+    return textDecoder.decode(encodeClientFrameV2(frame));
+}
+export function encodeServerFrameTextV2(frame) {
+    return textDecoder.decode(encodeServerFrameV2(frame));
+}
+function decodeBase64Bytes(value) {
+    try {
+        const binary = atob(value);
+        const bytes = new Uint8Array(binary.length);
+        for (let index = 0; index < binary.length; index += 1) {
+            bytes[index] = binary.charCodeAt(index);
+        }
+        return bytes;
+    }
+    catch (error) {
+        throw new DecodeError("schema", "data_base64 is not valid base64", { cause: error });
+    }
+}
+export function validateFragmentSizeV2(fragment) {
+    const realtimeFrameResult = timelineEventFragmentFrameSchema.safeParse(fragment);
+    const realtimeResult = timelineEventFragmentSchema.safeParse(fragment);
+    const historyResult = historyFragmentSchema.safeParse(fragment);
+    if (!realtimeFrameResult.success && !realtimeResult.success && !historyResult.success) {
+        throw new DecodeError("schema", schemaMessage(realtimeFrameResult.error), { cause: realtimeFrameResult.error });
+    }
+    const dataBase64 = realtimeFrameResult.success
+        ? realtimeFrameResult.data.data_base64
+        : realtimeResult.success
+            ? realtimeResult.data.data_base64
+            : historyResult.success
+                ? historyResult.data.data_base64
+                : undefined;
+    if (dataBase64 === undefined)
+        throw new DecodeError("schema", "fragment data is missing");
+    const bytes = decodeBase64Bytes(dataBase64).byteLength;
+    if (bytes > MAX_FRAGMENT_BYTES) {
+        throw new DecodeError("size", `fragment exceeds ${MAX_FRAGMENT_BYTES} decoded bytes`);
+    }
+    return bytes;
+}
+export function validateHistoryChunkSizeV2(chunk) {
+    const result = sessionHistoryChunkFrameSchema.safeParse(chunk);
+    if (!result.success)
+        throw new DecodeError("schema", schemaMessage(result.error), { cause: result.error });
+    const bytes = getUtf8ByteLengthV2(result.data);
+    if (bytes > MAX_HISTORY_CHUNK_BYTES) {
+        throw new DecodeError("size", `history chunk exceeds ${MAX_HISTORY_CHUNK_BYTES} encoded UTF-8 bytes`);
+    }
+    for (const fragment of result.data.fragments)
+        validateFragmentSizeV2(fragment);
+    return bytes;
+}
+export function validateWindowSizeV2(events) {
+    let total = 0;
+    for (const event of events) {
+        const result = timelineEventSchema.safeParse(event);
+        if (!result.success)
+            throw new DecodeError("schema", schemaMessage(result.error), { cause: result.error });
+        total += getUtf8ByteLengthV2(result.data);
+        if (total > MAX_WINDOW_BYTES) {
+            throw new DecodeError("size", `decoded window exceeds ${MAX_WINDOW_BYTES} bytes`);
+        }
+    }
+    return total;
+}
+export function validateEncodedSizeV2(value, maxBytes = MAX_WINDOW_BYTES) {
+    const bytes = getUtf8ByteLengthV2(value);
+    if (bytes > maxBytes)
+        throw new DecodeError("size", `encoded value exceeds ${maxBytes} bytes`);
+    return bytes;
+}
+export function parseTimelineEventV2(raw) {
+    const value = parseProtocolJsonV2(raw);
+    const result = timelineEventSchema.safeParse(value);
+    if (!result.success)
+        throw new DecodeError("schema", schemaMessage(result.error), { cause: result.error });
+    validateEncodedSizeV2(result.data, MAX_WINDOW_BYTES);
+    return result.data;
+}
+export function parseTimelinePartialV2(raw) {
+    const value = parseProtocolJsonV2(raw);
+    const result = timelinePartialSchema.safeParse(value);
+    if (!result.success)
+        throw new DecodeError("schema", schemaMessage(result.error), { cause: result.error });
+    validateEncodedSizeV2(result.data, MAX_HISTORY_CHUNK_BYTES);
+    return result.data;
+}
+export function validateFrameSizeV2(raw, maxBytes = MAX_FRAME_BYTES) {
+    return parseRaw(raw, maxBytes).bytes;
+}
+export const validateTimelineEventFragmentV2 = validateFragmentSizeV2;
+export const validateSessionHistoryChunkV2 = validateHistoryChunkSizeV2;
+export const validateTimelineWindowV2 = validateWindowSizeV2;
+export const validateFrameSize = validateFrameSizeV2;
+export const validateFragmentSize = validateFragmentSizeV2;
+export const validateSessionHistoryChunkSize = validateHistoryChunkSizeV2;
+export const validateWindowSize = validateWindowSizeV2;