cloving 1.2.0 → 1.4.0

package/dist/src/relay/pairing-follow.d.ts

@@ -0,0 +1,8 @@
+import type { OpenPairing, PairingSessions } from "./pairing-session.ts";
+import type { RelayStore } from "./relay-store.ts";
+export interface FollowContext {
+    readonly store: RelayStore;
+    readonly sessions: PairingSessions;
+}
+export declare function denied(open: OpenPairing): Promise<void>;
+export declare function followPairing(context: FollowContext, open: OpenPairing): Promise<void>;

package/dist/src/relay/pairing-follow.js

@@ -0,0 +1,95 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { checkedRequest, checkValid, } from "./pairing-checks.js";
+import { relayRequest } from "./relay-http.js";
+function field(body, name) {
+    return typeof body === "object" && body !== null
+        ? Reflect.get(body, name)
+        : undefined;
+}
+export async function denied(open) {
+    await relayRequest(open.registration.link.origin, {
+        method: "POST",
+        path: `/api/v1/relay/pairings/${open.pairingId}/deny`,
+        token: open.registration.link.token,
+    }).catch(() => undefined);
+}
+async function revoked(store, deviceId) {
+    return (await store.devices()).some((device) => device.deviceId === deviceId && device.removedAt !== null);
+}
+async function refusalOf(context, checked) {
+    if (checked.kind === "refused")
+        return checked.code;
+    const removed = await revoked(context.store, checked.request.deviceId);
+    return removed ? "pairing-device-revoked" : null;
+}
+async function onRequest(context, exchange) {
+    const { open } = exchange;
+    if (open.stage !== "open")
+        return;
+    const checked = checkedRequest(open.secret, field(exchange.body, "request"));
+    const code = await refusalOf(context, checked);
+    if (code !== null || checked.kind === "refused") {
+        await denied(open);
+        context.sessions.end(open, code);
+        return;
+    }
+    open.request = checked.request;
+    open.stage = "requested";
+}
+async function onCheck(context, exchange) {
+    const { open } = exchange;
+    const { request, nonce } = open;
+    if (open.stage !== "checking" || request === undefined || nonce === undefined)
+        return;
+    const valid = checkValid(field(exchange.body, "check"), {
+        daemonId: open.registration.link.daemonId,
+        deviceId: request.deviceId,
+        nonce,
+        answerPublicKey: request.answerPublicKey,
+        now: Date.now(),
+    });
+    if (valid)
+        await context.store.connect(request.deviceId);
+    context.sessions.end(open, valid ? null : "pairing-check-invalid");
+}
+function onEnd(context, exchange) {
+    const { open } = exchange;
+    const expired = field(exchange.body, "stage") === "expired";
+    context.sessions.end(open, expired && open.stage !== "checking" ? "pairing-expired" : null);
+    return Promise.resolve();
+}
+const handlers = {
+    requested: onRequest,
+    checked: onCheck,
+    denied: onEnd,
+    expired: onEnd,
+};
+async function polled(open, stage) {
+    try {
+        return await relayRequest(open.registration.link.origin, {
+            method: "GET",
+            path: `/api/v1/relay/pairings/${open.pairingId}?wait=25&stage=${stage}`,
+            token: open.registration.link.token,
+            signal: open.stop.signal,
+            timeoutMilliseconds: 40_000,
+        });
+    }
+    catch {
+        await delay(1000, undefined, { signal: open.stop.signal }).catch(() => undefined);
+        return undefined;
+    }
+}
+export async function followPairing(context, open) {
+    let stage = "open";
+    while (context.sessions.current() === open) {
+        const reply = await polled(open, stage);
+        if (reply === undefined)
+            continue;
+        if (reply.status !== 200) {
+            context.sessions.end(open, "pairing-expired");
+            return;
+        }
+        stage = String(field(reply.body, "stage"));
+        await handlers[stage]?.(context, { open, body: reply.body });
+    }
+}

package/dist/src/relay/pairing-session.d.ts

@@ -0,0 +1,29 @@
+import type { PairingRequest } from "./pairing-checks.ts";
+import type { Registration } from "./relay-registration.ts";
+export interface OpenPairing {
+    readonly pairingId: string;
+    readonly secret: Buffer;
+    readonly link: string;
+    readonly expiresAt: string;
+    readonly registration: Registration;
+    readonly stop: AbortController;
+    stage: "open" | "requested" | "checking";
+    request: PairingRequest | undefined;
+    nonce: string | undefined;
+}
+export declare class RegistrationEnded extends Error {
+    constructor();
+}
+export interface PairingSessions {
+    readonly current: () => OpenPairing | undefined;
+    readonly refusal: () => string | null;
+    readonly generation: () => number;
+    readonly start: (registration: Registration, startedIn: number) => Promise<OpenPairing>;
+    readonly end: (open: OpenPairing, refusal: string | null) => void;
+    readonly cancel: () => void;
+}
+export interface SessionSettings {
+    readonly secret: () => Buffer;
+    readonly follow: (open: OpenPairing) => Promise<void>;
+}
+export declare function pairingSessions(settings: SessionSettings): PairingSessions;

package/dist/src/relay/pairing-session.js

@@ -0,0 +1,87 @@
+import { pairingIdentity, pairingLink } from "./daemon-keys.js";
+import { relayRequest } from "./relay-http.js";
+export class RegistrationEnded extends Error {
+    constructor() {
+        super("registration-ended: cloving.ai does not know this computer.");
+    }
+}
+function expiry(body) {
+    const value = typeof body === "object" && body !== null
+        ? Reflect.get(body, "expires_at")
+        : undefined;
+    if (typeof value !== "string" || Number.isNaN(Date.parse(value)))
+        throw new Error("pairing-invalid: cloving.ai sent no expiry.");
+    return value;
+}
+async function created(registration, secret) {
+    const pairingId = pairingIdentity(secret);
+    const reply = await relayRequest(registration.link.origin, {
+        method: "POST",
+        path: "/api/v1/relay/pairings",
+        token: registration.link.token,
+        body: { pairing_id: pairingId },
+    });
+    if (reply.status === 401)
+        throw new RegistrationEnded();
+    if (reply.status !== 201)
+        throw new Error(`pairing-failed: cloving.ai answered ${String(reply.status)}.`);
+    return {
+        pairingId,
+        secret,
+        expiresAt: expiry(reply.body),
+        registration,
+        stop: new AbortController(),
+        stage: "open",
+        request: undefined,
+        nonce: undefined,
+        link: pairingLink(registration.link.origin, {
+            secret,
+            keys: registration.keys,
+        }),
+    };
+}
+function cancelled() {
+    return new Error("pairing-cancelled: The pairing was cancelled.");
+}
+export function pairingSessions(settings) {
+    let open;
+    let refusal = null;
+    let timer;
+    let generation = 0;
+    const end = (ended, code) => {
+        if (open !== ended)
+            return;
+        clearTimeout(timer);
+        ended.stop.abort();
+        open = undefined;
+        refusal = code;
+    };
+    return {
+        current: () => open,
+        refusal: () => refusal,
+        end,
+        cancel: () => {
+            generation += 1;
+            if (open !== undefined)
+                end(open, null);
+        },
+        generation: () => generation,
+        start: async (registration, startedIn) => {
+            if (startedIn !== generation)
+                throw cancelled();
+            const started = await created(registration, settings.secret());
+            if (startedIn !== generation)
+                throw cancelled();
+            open = started;
+            refusal = null;
+            timer = setTimeout(() => {
+                end(started, started.stage === "requested" ? "pairing-expired" : null);
+            }, Date.parse(started.expiresAt) - Date.now());
+            timer.unref();
+            settings.follow(started).catch(() => {
+                end(started, "pairing-failed");
+            });
+            return started;
+        },
+    };
+}

package/dist/src/relay/phone-delivery.d.ts

@@ -0,0 +1,51 @@
+import { Actor, type EffectSuccessPayload } from "solid-objects";
+export type PostedEnvelope = {
+    readonly envelopeId: string;
+    readonly kind: string;
+    readonly ciphertext: string;
+    readonly expiresAt: string;
+    readonly push: string;
+    readonly collapseId: string | null;
+};
+export type DeliveryTopic = "decision" | "closed";
+export type DeviceDelivery = {
+    readonly deviceId: string;
+    readonly topic: DeliveryTopic;
+    readonly state: "pending" | "sent" | "failed" | "cancelled";
+    readonly attempts: number;
+    readonly lastAttemptAt: number | null;
+    readonly lastFailure: string | null;
+    readonly envelopes: readonly PostedEnvelope[];
+};
+export type DeviceEnvelopes = {
+    readonly deviceId: string;
+    readonly envelopes: readonly PostedEnvelope[];
+};
+export type PostOutcome = {
+    readonly at: number;
+    readonly failure: string | null;
+};
+export declare const postEnvelopesEffect = "phone_post_envelopes";
+export declare const deviceRemoved = "device-removed";
+export declare class PhoneDelivery extends Actor {
+    static readonly actorType = "PhoneDelivery";
+    deliveries: DeviceDelivery[];
+    closedAt: number | null;
+    promptDigest: string | null;
+    offer(device: DeviceEnvelopes & {
+        readonly promptDigest: string;
+    }): boolean;
+    close({ devices, at, }: {
+        readonly devices: readonly DeviceEnvelopes[];
+        readonly at: number;
+    }): boolean;
+    posted({ arguments: request, result, }: EffectSuccessPayload<{
+        deviceId: string;
+        topic: DeliveryTopic;
+    }, PostOutcome>): void;
+    retry(key: {
+        readonly deviceId: string;
+        readonly topic: DeliveryTopic;
+    }): void;
+    retire(): void;
+}

package/dist/src/relay/phone-delivery.js

@@ -0,0 +1,139 @@
+import { Actor } from "solid-objects";
+import { deliveryBackoffMilliseconds } from "../delivery-backoff.js";
+import { outboxIdentity, PhoneOutbox } from "./phone-outbox.js";
+export const postEnvelopesEffect = "phone_post_envelopes";
+export const deviceRemoved = "device-removed";
+const attemptLimit = deliveryBackoffMilliseconds.length;
+const retentionMilliseconds = 7 * 86_400_000;
+function same(item, key) {
+    return item.deviceId === key.deviceId && item.topic === key.topic;
+}
+function replaced(deliveries, delivery) {
+    return deliveries.map((item) => (same(item, delivery) ? delivery : item));
+}
+function ended(delivery) {
+    if (delivery.state === "sent" || delivery.state === "cancelled")
+        return true;
+    return (delivery.state === "failed" &&
+        (delivery.attempts >= attemptLimit ||
+            delivery.lastFailure === deviceRemoved));
+}
+function started(topic, device) {
+    return {
+        ...device,
+        topic,
+        state: "pending",
+        attempts: 1,
+        lastAttemptAt: null,
+        lastFailure: null,
+    };
+}
+function settled(delivery, result) {
+    if (result.failure === null)
+        return {
+            ...delivery,
+            state: "sent",
+            lastAttemptAt: result.at,
+            lastFailure: null,
+            envelopes: [],
+        };
+    return {
+        ...delivery,
+        state: "failed",
+        lastAttemptAt: result.at,
+        lastFailure: result.failure,
+    };
+}
+function afterClose(delivery, closedAt) {
+    const stopped = delivery.topic === "decision" &&
+        delivery.state === "failed" &&
+        closedAt !== null;
+    return stopped ? { ...delivery, state: "cancelled" } : delivery;
+}
+export class PhoneDelivery extends Actor {
+    static actorType = "PhoneDelivery";
+    deliveries = [];
+    closedAt = null;
+    promptDigest = null;
+    offer(device) {
+        const known = this.deliveries.some((item) => same(item, { deviceId: device.deviceId, topic: "decision" }));
+        if (known || this.closedAt !== null)
+            return false;
+        const delivery = started("decision", {
+            deviceId: device.deviceId,
+            envelopes: device.envelopes,
+        });
+        this.promptDigest ??= device.promptDigest;
+        this.deliveries = [...this.deliveries, delivery];
+        this.emit(postEnvelopesEffect, {
+            arguments: {
+                deviceId: delivery.deviceId,
+                envelopes: delivery.envelopes,
+                topic: delivery.topic,
+            },
+            onSuccess: "posted",
+        });
+        return true;
+    }
+    close({ devices, at, }) {
+        if (this.closedAt !== null)
+            return false;
+        this.closedAt = at;
+        const closing = devices.map((device) => started("closed", device));
+        this.deliveries = [
+            ...this.deliveries.map((item) => item.state === "failed" ? { ...item, state: "cancelled" } : item),
+            ...closing,
+        ];
+        for (const device of devices)
+            this.emit(postEnvelopesEffect, {
+                arguments: { ...device, topic: "closed" },
+                onSuccess: "posted",
+            });
+        if (closing.length === 0)
+            this.schedule({ at: new Date(at + retentionMilliseconds) }).retire();
+        return true;
+    }
+    posted({ arguments: request, result, }) {
+        const delivery = this.deliveries.find((item) => same(item, request) && item.state === "pending");
+        if (delivery === undefined)
+            return;
+        const updated = afterClose(settled(delivery, result), this.closedAt);
+        this.deliveries = replaced(this.deliveries, updated);
+        if (!ended(updated)) {
+            const wait = deliveryBackoffMilliseconds[updated.attempts] ?? 0;
+            this.schedule({
+                at: new Date(result.at + wait),
+                key: `${updated.topic}:${updated.deviceId}`,
+            }).retry({ deviceId: updated.deviceId, topic: updated.topic });
+            return;
+        }
+        const closing = this.deliveries.filter((item) => item.topic === "closed");
+        if (updated.topic === "closed" && closing.every(ended))
+            this.schedule({
+                at: new Date(result.at + retentionMilliseconds),
+            }).retire();
+    }
+    retry(key) {
+        const delivery = this.deliveries.find((item) => same(item, key) && item.state === "failed");
+        if (delivery === undefined || ended(delivery))
+            return;
+        this.deliveries = replaced(this.deliveries, {
+            ...delivery,
+            state: "pending",
+            attempts: delivery.attempts + 1,
+        });
+        this.emit(postEnvelopesEffect, {
+            arguments: {
+                deviceId: delivery.deviceId,
+                topic: delivery.topic,
+                envelopes: delivery.envelopes,
+            },
+            onSuccess: "posted",
+        });
+    }
+    retire() {
+        this.sendTo(PhoneOutbox.ref(outboxIdentity)).retire({
+            decisionId: this.actorId,
+        });
+    }
+}

package/dist/src/relay/phone-devices.d.ts

@@ -0,0 +1,36 @@
+import { Actor } from "solid-objects";
+export type PhoneDevice = {
+    readonly deviceId: string;
+    readonly name: string;
+    readonly platform: string;
+    readonly agreementPublicKey: string;
+    readonly answerPublicKey: string;
+    readonly approvalPublicKey: string;
+    readonly pairedAt: string;
+    readonly state: "checking" | "connected";
+    readonly removedAt: string | null;
+};
+export declare class PhoneDevices extends Actor {
+    static readonly actorType = "PhoneDevices";
+    devices: PhoneDevice[];
+    sequences: {
+        readonly deviceId: string;
+        readonly sequence: number;
+    }[];
+    add({ device }: {
+        readonly device: PhoneDevice;
+    }): PhoneDevice;
+    nextSequence({ deviceId }: {
+        readonly deviceId: string;
+    }): number;
+    connect({ deviceId }: {
+        readonly deviceId: string;
+    }): boolean;
+    remove({ deviceId, removedAt, }: {
+        readonly deviceId: string;
+        readonly removedAt: string;
+    }): boolean;
+    removeAll({ removedAt }: {
+        readonly removedAt: string;
+    }): number;
+}

package/dist/src/relay/phone-devices.js

@@ -0,0 +1,46 @@
+import { Actor } from "solid-objects";
+export class PhoneDevices extends Actor {
+    static actorType = "PhoneDevices";
+    devices = [];
+    sequences = [];
+    add({ device }) {
+        const removed = this.devices.some((item) => item.deviceId === device.deviceId && item.removedAt !== null);
+        if (removed)
+            this.reject("pairing_device_revoked", {
+                message: "This phone was removed. Connect it again as a new phone.",
+            });
+        this.devices = [
+            ...this.devices.filter((item) => item.deviceId !== device.deviceId),
+            device,
+        ];
+        return device;
+    }
+    nextSequence({ deviceId }) {
+        const sequence = (this.sequences.find((item) => item.deviceId === deviceId)?.sequence ??
+            0) + 1;
+        this.sequences = [
+            ...this.sequences.filter((item) => item.deviceId !== deviceId),
+            { deviceId, sequence },
+        ];
+        return sequence;
+    }
+    connect({ deviceId }) {
+        const found = this.devices.some((item) => item.deviceId === deviceId && item.removedAt === null);
+        this.devices = this.devices.map((item) => item.deviceId === deviceId && item.removedAt === null
+            ? { ...item, state: "connected" }
+            : item);
+        return found;
+    }
+    remove({ deviceId, removedAt, }) {
+        const found = this.devices.some((item) => item.deviceId === deviceId && item.removedAt === null);
+        this.devices = this.devices.map((item) => item.deviceId === deviceId && item.removedAt === null
+            ? { ...item, removedAt }
+            : item);
+        return found;
+    }
+    removeAll({ removedAt }) {
+        const count = this.devices.filter((item) => item.removedAt === null).length;
+        this.devices = this.devices.map((item) => item.removedAt === null ? { ...item, removedAt } : item);
+        return count;
+    }
+}

package/dist/src/relay/phone-inbox.d.ts

@@ -0,0 +1,18 @@
+import { Actor } from "solid-objects";
+import type { PostedEnvelope } from "./phone-delivery.ts";
+export type InboxWork = {
+    readonly answerId: string;
+    readonly sequence: number;
+    readonly deviceId: string;
+    readonly envelope: PostedEnvelope | null;
+};
+export declare class PhoneInbox extends Actor {
+    static readonly actorType = "PhoneInbox";
+    cursor: number;
+    work: InboxWork[];
+    record(work: InboxWork): InboxWork;
+    complete({ answerId, sequence, }: {
+        readonly answerId: string;
+        readonly sequence: number;
+    }): void;
+}

package/dist/src/relay/phone-inbox.js

@@ -0,0 +1,17 @@
+import { Actor } from "solid-objects";
+export class PhoneInbox extends Actor {
+    static actorType = "PhoneInbox";
+    cursor = 0;
+    work = [];
+    record(work) {
+        const known = this.work.find((item) => item.answerId === work.answerId);
+        if (known !== undefined)
+            return known;
+        this.work = [...this.work, work];
+        return work;
+    }
+    complete({ answerId, sequence, }) {
+        this.work = this.work.filter((item) => item.answerId !== answerId);
+        this.cursor = Math.max(this.cursor, sequence);
+    }
+}

package/dist/src/relay/phone-operations.d.ts

@@ -0,0 +1,18 @@
+import type { Fields, Reply } from "../protocol.ts";
+import type { PairingSessions } from "./pairing-session.ts";
+import { type RegistrationContext } from "./relay-registration.ts";
+import type { RelayStore } from "./relay-store.ts";
+export interface OperationState {
+    readonly context: RegistrationContext;
+    readonly store: RelayStore;
+    readonly sessions: PairingSessions;
+    readonly registration: {
+        lost: boolean;
+    };
+}
+export declare function result(fields: Fields): Reply;
+export declare function refused(code: string, detail: string): Reply;
+export declare function pairAccept(relay: OperationState, parameters: Fields): Promise<Reply>;
+export declare function pairDeny(relay: OperationState, parameters: Fields): Promise<Reply>;
+export declare function phoneRemove(relay: OperationState, parameters: Fields): Promise<Reply>;
+export declare function phoneReset(relay: OperationState): Promise<Reply>;

package/dist/src/relay/phone-operations.js

@@ -0,0 +1,121 @@
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+import { signedReceipt } from "./pairing-checks.js";
+import { denied } from "./pairing-follow.js";
+import { relayRequest } from "./relay-http.js";
+import { readLink } from "./relay-registration.js";
+export function result(fields) {
+    return { kind: "result", result: fields };
+}
+export function refused(code, detail) {
+    return { kind: "error", error: { code, detail } };
+}
+function requestedPairing(relay) {
+    const open = relay.sessions.current();
+    return open?.stage === "requested" && open.request !== undefined
+        ? open
+        : undefined;
+}
+const noRequest = refused("pairing-not-requested", "No phone waits for an answer. Click Connect a phone and scan the code again.");
+const changed = refused("pairing-changed", "The pairing changed. Check the name and the code on the watch page again.");
+const acceptances = new WeakMap();
+export function pairAccept(relay, parameters) {
+    const open = requestedPairing(relay);
+    if (open === undefined)
+        return Promise.resolve(noRequest);
+    if (parameters["pairingId"] !== open.pairingId)
+        return Promise.resolve(changed);
+    const running = acceptances.get(open);
+    if (running !== undefined)
+        return running;
+    const accepting = accepted(relay, open).finally(() => acceptances.delete(open));
+    acceptances.set(open, accepting);
+    return accepting;
+}
+async function accepted(relay, open) {
+    const { request } = open;
+    if (request === undefined)
+        return noRequest;
+    const pairedAt = new Date().toISOString();
+    const rejection = await relay.store.add({
+        deviceId: request.deviceId,
+        name: request.name,
+        platform: request.platform,
+        agreementPublicKey: request.agreementPublicKey,
+        answerPublicKey: request.answerPublicKey,
+        approvalPublicKey: request.approvalPublicKey,
+        pairedAt,
+        state: "checking",
+        removedAt: null,
+    });
+    if (rejection !== undefined) {
+        await denied(open);
+        relay.sessions.end(open, rejection);
+        return refused(rejection, "This phone was removed. Connect it as a new phone.");
+    }
+    const { receipt, nonce } = signedReceipt(open.registration.keys, {
+        daemonId: open.registration.link.daemonId,
+        deviceId: request.deviceId,
+        pairedAt,
+    });
+    const reply = await relayRequest(open.registration.link.origin, {
+        method: "POST",
+        path: `/api/v1/relay/pairings/${open.pairingId}/receipt`,
+        token: open.registration.link.token,
+        body: { receipt },
+    });
+    if (reply.status !== 200)
+        return refused("receipt-failed", `cloving.ai answered ${String(reply.status)} to the receipt.`);
+    open.nonce = nonce;
+    open.stage = "checking";
+    return result({ deviceId: request.deviceId, state: "checking" });
+}
+export async function pairDeny(relay, parameters) {
+    const open = requestedPairing(relay);
+    if (open === undefined)
+        return noRequest;
+    if (parameters["pairingId"] !== open.pairingId)
+        return changed;
+    await denied(open);
+    relay.sessions.end(open, null);
+    return result({ pairing: null });
+}
+function warning(status, subject) {
+    if (status >= 200 && status < 300)
+        return null;
+    return `cloving.ai did not remove ${subject} (answer ${String(status)}). This computer keeps it removed.`;
+}
+async function serverCall(relay, call) {
+    const link = await readLink(relay.context.phoneDirectory);
+    if (link === undefined)
+        return null;
+    const reply = await relayRequest(link.origin, {
+        method: call.method,
+        path: call.path,
+        token: link.token,
+    }).catch(() => ({ status: 0, body: null }));
+    return warning(reply.status, call.subject);
+}
+export async function phoneRemove(relay, parameters) {
+    const deviceId = parameters["deviceId"];
+    if (typeof deviceId !== "string" || !(await relay.store.remove(deviceId)))
+        return refused("phone-unknown", "No connected phone has this device ID.");
+    const notice = await serverCall(relay, {
+        method: "DELETE",
+        path: `/api/v1/relay/devices/${encodeURIComponent(deviceId)}`,
+        subject: "the phone",
+    });
+    return result({ deviceId, removed: true, warning: notice });
+}
+export async function phoneReset(relay) {
+    relay.sessions.cancel();
+    const notice = await serverCall(relay, {
+        method: "DELETE",
+        path: "/api/v1/relay/daemon",
+        subject: "this computer",
+    });
+    const removed = await relay.store.removeAll();
+    for (const file of ["link.json", "daemon-keys.json"])
+        await rm(join(relay.context.phoneDirectory, file), { force: true });
+    return result({ removed, warning: notice });
+}