cloving 1.2.0 → 1.3.0

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 });
+}

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

@@ -0,0 +1,21 @@
+import { Actor } from "solid-objects";
+export declare const outboxIdentity = "phone";
+export type OpenDecision = {
+    readonly decisionId: string;
+    readonly runId: string;
+};
+export declare class PhoneOutbox extends Actor {
+    static readonly actorType = "PhoneOutbox";
+    decisions: OpenDecision[];
+    retired: string[];
+    track(decision: OpenDecision): boolean;
+    retire({ decisionId }: {
+        readonly decisionId: string;
+    }): void;
+    forget({ decisionId }: {
+        readonly decisionId: string;
+    }): void;
+    untrack({ decisionId }: {
+        readonly decisionId: string;
+    }): boolean;
+}

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

@@ -0,0 +1,25 @@
+import { Actor } from "solid-objects";
+export const outboxIdentity = "phone";
+export class PhoneOutbox extends Actor {
+    static actorType = "PhoneOutbox";
+    decisions = [];
+    retired = [];
+    track(decision) {
+        if (this.decisions.some((item) => item.decisionId === decision.decisionId))
+            return false;
+        this.decisions = [...this.decisions, decision];
+        return true;
+    }
+    retire({ decisionId }) {
+        if (!this.retired.includes(decisionId))
+            this.retired = [...this.retired, decisionId];
+    }
+    forget({ decisionId }) {
+        this.retired = this.retired.filter((item) => item !== decisionId);
+    }
+    untrack({ decisionId }) {
+        const known = this.decisions.some((item) => item.decisionId === decisionId);
+        this.decisions = this.decisions.filter((item) => item.decisionId !== decisionId);
+        return known;
+    }
+}

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

@@ -0,0 +1,6 @@
+import { type Reply, type ServiceRequest } from "../protocol.ts";
+export type PhoneHandler = (request: ServiceRequest) => Promise<Reply>;
+export interface PhoneSocket {
+    readonly close: () => Promise<void>;
+}
+export declare function listenPhoneSocket(path: string, handle: PhoneHandler): Promise<PhoneSocket>;

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

@@ -0,0 +1,63 @@
+import { chmod, rm } from "node:fs/promises";
+import net from "node:net";
+import { maximumFrameBytes, parseRequest, replyLine, } from "../protocol.js";
+function failed(error) {
+    return {
+        kind: "error",
+        error: {
+            code: "phone-relay-failed",
+            detail: String(Reflect.get(Object(error), "message")),
+        },
+    };
+}
+function served(socket, handle) {
+    let buffered = "";
+    socket.setEncoding("utf8");
+    socket.on("error", () => undefined);
+    socket.on("data", (data) => {
+        buffered += data;
+        const end = buffered.indexOf("\n");
+        if (end < 0 && Buffer.byteLength(buffered) <= maximumFrameBytes)
+            return;
+        socket.removeAllListeners("data");
+        const parsed = parseRequest(end < 0 ? "" : buffered.slice(0, end));
+        const answer = (reply) => {
+            socket.end(replyLine(reply));
+        };
+        const replied = parsed.kind === "error"
+            ? Promise.resolve(parsed)
+            : handle(parsed.request);
+        replied.then(answer, (error) => {
+            answer(failed(error));
+        });
+    });
+}
+export async function listenPhoneSocket(path, handle) {
+    await rm(path, { force: true });
+    const sockets = new Set();
+    const server = net.createServer((socket) => {
+        sockets.add(socket);
+        socket.once("close", () => sockets.delete(socket));
+        served(socket, handle);
+    });
+    await new Promise((ready, refuse) => {
+        server.once("error", refuse);
+        server.listen(path, () => {
+            server.off("error", refuse);
+            ready();
+        });
+    });
+    await chmod(path, 0o600);
+    return {
+        close: async () => {
+            const closed = new Promise((settle) => {
+                server.close(() => {
+                    settle();
+                });
+            });
+            for (const socket of sockets)
+                socket.destroy();
+            await closed;
+        },
+    };
+}

package/dist/src/relay/relay-control.d.ts

@@ -0,0 +1,7 @@
+import type { Fields, Reply, ServiceRequest } from "../protocol.ts";
+export declare function relayControl(runtimeDirectory: string): (request: ServiceRequest) => Promise<Reply>;
+export declare function relayEvents(runtimeDirectory: string, stream: {
+    readonly after: number;
+    readonly onEvent: (event: Fields) => void;
+    readonly stopped: Promise<void>;
+}): Promise<Reply>;