@parley-im/parley 0.0.0-stage → 0.1.1

package/dist/relay.js

@@ -0,0 +1,304 @@
+import { writeFileSync, readFileSync, existsSync, readdirSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { join } from "node:path";
+import { paths } from "./config.js";
+import { Problem, MAX_IMAGES } from "./api.js";
+import { readCredentials, relay as registry } from "./account.js";
+import { seal, open, sealBytes, openBytes } from "./seal.js";
+const IMAGE_TYPES = { "image/png": ".png", "image/jpeg": ".jpg", "image/gif": ".gif", "image/webp": ".webp" };
+const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+const MAX_SEALED_BYTES = 11 * 1024 * 1024;
+const MAX_SHOTS = 200; // per session
+// Screenshots cross parley.im in pieces that fit one frame each.
+const PIECE = 512 * 1024;
+// An uploaded screenshot waits here, decrypted, until the message that sends
+// it arrives. Ones that never get sent are dropped.
+const HELD_MS = 30 * 60_000;
+const MAX_HELD_BYTES = 200 * 1024 * 1024;
+// A request older than this, or seen before, is a replay and gets refused.
+const FRESH_MS = 5 * 60_000;
+// This computer's connection to parley.im. It connects out (nothing listens
+// on your machine for the internet), answers tester pages' encrypted
+// requests, and pushes each session's live events to them, encrypted with
+// that session's key. parley.im only sees which session a frame is for.
+export class RelayLink {
+    store;
+    runner;
+    api;
+    config;
+    ws = null;
+    status;
+    delay = 1000;
+    stopped = false;
+    retry = null;
+    ping = null;
+    seen = new Map();
+    incoming = new Map();
+    held = new Map();
+    // Events go out in order even though sealing them is asynchronous.
+    queue = Promise.resolve();
+    constructor(store, runner, api, config) {
+        this.store = store;
+        this.runner = runner;
+        this.api = api;
+        this.config = config;
+        this.status = { state: "signed-out", relayUrl: config.relayUrl };
+        runner.listeners.add((sessionId, entry) => this.forward(sessionId, entry));
+    }
+    start() {
+        this.stopped = false;
+        this.connect();
+    }
+    // After `parley login` or `parley logout`.
+    restart() {
+        this.stop();
+        this.delay = 1000;
+        this.start();
+    }
+    stop() {
+        this.stopped = true;
+        if (this.retry)
+            clearTimeout(this.retry);
+        if (this.ping)
+            clearInterval(this.ping);
+        this.ws?.close(1000, "bye");
+        this.ws = null;
+    }
+    connect() {
+        const creds = readCredentials(this.config);
+        if (!creds) {
+            this.status = { state: "signed-out", relayUrl: this.config.relayUrl };
+            return;
+        }
+        this.status = { state: "connecting", relayUrl: creds.relayUrl, email: creds.account.email };
+        const ws = new WebSocket(`${creds.relayUrl.replace(/^http/, "ws")}/api/connect`, ["parley.v1", `parley.token.${creds.token}`]);
+        this.ws = ws;
+        ws.onopen = async () => {
+            this.delay = 1000;
+            this.status = { state: "connected", relayUrl: creds.relayUrl, email: creds.account.email, since: new Date().toISOString() };
+            this.ping = setInterval(() => ws.readyState === WebSocket.OPEN && ws.send('{"t":"ping"}'), 30_000);
+            // Tell parley.im which sessions are open, so their links work.
+            try {
+                await registry.sync(creds, this.store.sessions({ status: "open" }));
+            }
+            catch (error) {
+                console.error(`parley.im sync failed: ${error.message}`);
+            }
+        };
+        ws.onmessage = (event) => {
+            this.onFrame(String(event.data)).catch((error) => console.error("relay frame:", error));
+        };
+        ws.onclose = (event) => {
+            if (this.ping)
+                clearInterval(this.ping);
+            if (this.ws !== ws || this.stopped)
+                return;
+            this.ws = null;
+            if (event.code === 4401) {
+                this.status = { state: "unlinked", relayUrl: creds.relayUrl, error: "This computer was unlinked from its parley.im account. Run parley login." };
+                return;
+            }
+            if (event.code === 4000) {
+                this.status = { state: "replaced", relayUrl: creds.relayUrl, error: "Another parley on this computer took over the connection." };
+                return;
+            }
+            this.status = { state: "offline", relayUrl: creds.relayUrl, email: creds.account.email, error: `Reconnecting to ${creds.relayUrl}` };
+            this.retry = setTimeout(() => this.checkThenReconnect(creds), this.delay);
+            this.delay = Math.min(this.delay * 2, 30_000);
+        };
+        ws.onerror = () => { };
+    }
+    // A refused connection looks the same as a network blip, so ask whether
+    // this computer is still linked before trying again.
+    async checkThenReconnect(creds) {
+        try {
+            const res = await fetch(`${creds.relayUrl}/api/me`, { headers: { authorization: `Bearer ${creds.token}` }, signal: AbortSignal.timeout(10_000) });
+            if (res.status === 401) {
+                this.status = { state: "unlinked", relayUrl: creds.relayUrl, error: "This computer isn't linked to a parley.im account anymore. Run parley login." };
+                return;
+            }
+        }
+        catch { }
+        if (!this.stopped)
+            this.connect();
+    }
+    send(frame) {
+        if (this.ws?.readyState === WebSocket.OPEN)
+            this.ws.send(JSON.stringify(frame));
+    }
+    async onFrame(raw) {
+        let frame;
+        try {
+            frame = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (typeof frame.s === "string" && typeof frame.r === "string") {
+            if (frame.t === "up")
+                return this.receive(frame);
+            if (frame.t === "get")
+                return this.serve(frame);
+        }
+        if (frame.t !== "req" || typeof frame.s !== "string" || typeof frame.r !== "string")
+            return;
+        const fail = (error) => this.send({ t: "res", s: frame.s, c: frame.c, r: frame.r, error });
+        const session = this.store.sessionByToken(frame.s);
+        if (!session)
+            return fail("missing");
+        if (session.status !== "open")
+            return fail("ended");
+        let req;
+        try {
+            req = await open(session.e2e_key, session.token, "req", frame.d);
+        }
+        catch {
+            // Not sealed with this session's key: tampered with, or a stale link.
+            return fail("bad_request");
+        }
+        if (req.r !== frame.r || typeof req.at !== "number" || Math.abs(Date.now() - req.at) > FRESH_MS || this.replayed(`${frame.s}:${frame.r}`)) {
+            return fail("stale");
+        }
+        const reply = async (payload) => this.send({ t: "res", s: frame.s, c: frame.c, r: frame.r, d: await seal(session.e2e_key, session.token, "res", payload) });
+        const scope = { session, owner: false, base: "", images: "ref" };
+        try {
+            if (req.op === "state")
+                return await reply({ ok: true, result: this.api.state(scope) });
+            if (req.op === "history")
+                return await reply({ ok: true, result: this.api.history(scope, Number(req.before)) });
+            if (req.op === "send") {
+                const text = String(req.text ?? "").trim();
+                const images = Array.isArray(req.images) ? req.images : [];
+                this.api.check(scope, text, images.length);
+                const names = [];
+                for (const image of images.slice(0, MAX_IMAGES))
+                    names.push(this.saveImage(session, image));
+                return await reply({ ok: true, result: this.api.post(scope, text, names) });
+            }
+            return await reply({ ok: false, error: "unknown", message: "Unknown request." });
+        }
+        catch (error) {
+            if (error instanceof Problem)
+                return reply({ ok: false, status: error.status, error: error.code, message: error.message });
+            console.error(error);
+            return reply({ ok: false, error: "broken", message: "Something broke on this end." });
+        }
+    }
+    // A screenshot arriving from a tester's page, in pieces, still encrypted.
+    // parley.im only passes it along; it's decrypted and kept here.
+    async receive(frame) {
+        const now = Date.now();
+        for (const [r, up] of this.incoming)
+            if (now - up.at > 120_000)
+                this.incoming.delete(r);
+        let up = this.incoming.get(frame.r);
+        if (!up)
+            this.incoming.set(frame.r, (up = { parts: [], size: 0, at: now }));
+        if (typeof frame.d === "string") {
+            const part = Buffer.from(frame.d, "base64url");
+            up.size += part.length;
+            if (up.size <= MAX_SEALED_BYTES)
+                up.parts.push(part);
+        }
+        if (!frame.end)
+            return;
+        this.incoming.delete(frame.r);
+        if (frame.abort)
+            return;
+        const answer = (reply) => this.send({ t: "piece", r: frame.r, end: true, ...reply });
+        try {
+            if (up.size > MAX_SEALED_BYTES)
+                throw new Problem(413, "too_big", "That image is too big. The limit is 10 MB.");
+            answer({ id: await this.hold(frame.s, Buffer.concat(up.parts)) });
+        }
+        catch (error) {
+            if (!(error instanceof Problem))
+                console.error(error);
+            answer(error instanceof Problem ? { error: error.code, status: error.status, message: error.message } : { error: "broken", status: 500, message: "Something broke on this end." });
+        }
+    }
+    async hold(token, sealed) {
+        const session = this.store.sessionByToken(token);
+        if (!session || session.status !== "open")
+            throw new Problem(410, "ended", "This parley has ended.");
+        let plain;
+        try {
+            plain = await openBytes(session.e2e_key, session.token, "blob", sealed);
+        }
+        catch {
+            throw new Problem(400, "bad_image", "That screenshot didn't arrive intact. Try adding it again.");
+        }
+        if (plain.length > MAX_IMAGE_BYTES)
+            throw new Problem(413, "too_big", "That image is too big. The limit is 10 MB.");
+        const kept = readdirSync(paths.uploads).filter((name) => name.startsWith(`${session.id}-`)).length;
+        if (kept >= MAX_SHOTS)
+            throw new Problem(429, "too_many", "This session can't take more screenshots.");
+        const now = Date.now();
+        let total = plain.length;
+        for (const [id, item] of [...this.held].reverse()) {
+            if (now - item.at > HELD_MS || total + item.bytes.length > MAX_HELD_BYTES)
+                this.held.delete(id);
+            else
+                total += item.bytes.length;
+        }
+        const id = randomBytes(12).toString("base64url");
+        this.held.set(id, { session: session.id, bytes: plain, at: now });
+        return id;
+    }
+    // Keeps a screenshot that a tester's message refers to.
+    saveImage(session, image) {
+        const ext = IMAGE_TYPES[image?.type];
+        if (!ext || typeof image.id !== "string" || !/^[A-Za-z0-9_-]{8,40}$/.test(image.id)) {
+            throw new Problem(415, "not_an_image", "Images only: PNG, JPEG, GIF or WebP.");
+        }
+        const held = this.held.get(image.id);
+        if (!held || held.session !== session.id)
+            throw new Problem(400, "bad_image", "That screenshot didn't arrive. Try adding it again.");
+        this.held.delete(image.id);
+        const name = `${session.id}-${image.id}${ext}`;
+        writeFileSync(join(paths.uploads, name), held.bytes);
+        return name;
+    }
+    // A screenshot for a tester's page, encrypted here and sent in pieces.
+    async serve(frame) {
+        const answer = (reply) => this.send({ t: "piece", r: frame.r, end: true, ...reply });
+        const session = this.store.sessionByToken(frame.s);
+        if (!session || session.status !== "open")
+            return answer({ error: "ended", status: 410, message: "This parley has ended." });
+        const id = String(frame.id ?? "");
+        const name = /^[A-Za-z0-9_-]{8,40}$/.test(id)
+            ? Object.values(IMAGE_TYPES).map((ext) => `${session.id}-${id}${ext}`).find((n) => existsSync(join(paths.uploads, n)))
+            : undefined;
+        if (!name)
+            return answer({ error: "missing", status: 404, message: "No such screenshot." });
+        const sealed = await sealBytes(session.e2e_key, session.token, "blob", readFileSync(join(paths.uploads, name)));
+        for (let at = 0; at < sealed.length; at += PIECE)
+            this.send({ t: "piece", r: frame.r, d: Buffer.from(sealed.subarray(at, at + PIECE)).toString("base64url") });
+        answer({});
+    }
+    forward(sessionId, entry) {
+        if (this.ws?.readyState !== WebSocket.OPEN)
+            return;
+        const session = this.store.session(sessionId);
+        if (!session)
+            return;
+        const view = this.api.eventView(entry.event, { session, owner: false, base: "", images: "ref" });
+        if (!view)
+            return;
+        const epoch = this.runner.epoch;
+        this.queue = this.queue
+            .then(async () => this.send({ t: "evt", s: session.token, d: await seal(session.e2e_key, session.token, "evt", { epoch, seq: entry.seq, event: view }) }))
+            .catch((error) => console.error("relay event:", error));
+    }
+    replayed(id) {
+        const now = Date.now();
+        if (this.seen.size > 5000)
+            for (const [key, at] of this.seen)
+                if (now - at > FRESH_MS * 2)
+                    this.seen.delete(key);
+        if (this.seen.has(id))
+            return true;
+        this.seen.set(id, now);
+        return false;
+    }
+}

package/dist/runner.js

@@ -0,0 +1,198 @@
+import { join, extname } from "node:path";
+import { paths } from "./config.js";
+import { charter } from "./charter.js";
+import { runClaudeTurn } from "./agents/claude.js";
+import { runCodexTurn } from "./agents/codex.js";
+import { modelLabel } from "./models.js";
+// Recent events per session, kept for clients that poll for updates.
+const LOG_LIMIT = 2000;
+const IMAGE_TYPES = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+};
+export const mediaTypeFor = (file) => IMAGE_TYPES[extname(file).toLowerCase()];
+// One reply at a time per session. Messages that arrive while the agent is
+// replying wait, then go to it together as the next turn.
+export class Runner {
+    store;
+    config;
+    live = new Map();
+    runs = new Map();
+    // Changes on every server start, so clients from before a restart reload.
+    epoch = Date.now().toString(36);
+    seq = 0;
+    logs = new Map();
+    trimmed = new Map();
+    waiters = new Map();
+    // Anyone following every session's events, like the link to parley.im.
+    listeners = new Set();
+    constructor(store, config) {
+        this.store = store;
+        this.config = config;
+    }
+    publish(sessionId, event) {
+        let log = this.logs.get(sessionId);
+        if (!log)
+            this.logs.set(sessionId, (log = []));
+        const entry = { seq: ++this.seq, event };
+        log.push(entry);
+        if (log.length > LOG_LIMIT)
+            this.trimmed.set(sessionId, log.splice(0, log.length - LOG_LIMIT).at(-1).seq);
+        for (const wake of this.waiters.get(sessionId) ?? [])
+            wake();
+        for (const listener of this.listeners)
+            listener(sessionId, entry);
+    }
+    // Events after `after`, or null when the client missed some and should
+    // reload the whole session instead.
+    since(sessionId, after) {
+        if (after > this.seq || after < (this.trimmed.get(sessionId) ?? 0))
+            return null;
+        return (this.logs.get(sessionId) ?? []).filter((entry) => entry.seq > after);
+    }
+    // Long poll: answers as soon as there is something new, or after `ms`.
+    wait(sessionId, after, ms, signal) {
+        const ready = this.since(sessionId, after);
+        if (ready === null || ready.length)
+            return Promise.resolve(ready);
+        return new Promise((resolve) => {
+            let set = this.waiters.get(sessionId);
+            if (!set)
+                this.waiters.set(sessionId, (set = new Set()));
+            let done = false;
+            const finish = () => {
+                if (done)
+                    return;
+                done = true;
+                clearTimeout(timer);
+                set.delete(wake);
+                signal.removeEventListener("abort", finish);
+                resolve(this.since(sessionId, after));
+            };
+            // Let a burst of streamed text gather into one response.
+            const wake = () => setTimeout(finish, 30);
+            const timer = setTimeout(finish, ms);
+            set.add(wake);
+            signal.addEventListener("abort", finish);
+        });
+    }
+    submit(session, text, images) {
+        const message = this.store.addMessage(session.id, "tester", text, images, null);
+        this.publish(session.id, { type: "message", message });
+        this.kick(session.id);
+        return message;
+    }
+    resume() {
+        for (const sessionId of this.store.recoverInterrupted())
+            this.kick(sessionId);
+        for (const session of this.store.sessions())
+            if (session.status === "open")
+                this.kick(session.id);
+    }
+    stopAll() {
+        for (const run of this.runs.values())
+            run.cancel();
+    }
+    // Kills the link for good: any reply in progress stops, open pages clear
+    // themselves, and every tester route answers 410 from here on.
+    end(sessionId) {
+        this.store.end(sessionId);
+        this.runs.get(sessionId)?.cancel();
+        this.publish(sessionId, { type: "ended" });
+    }
+    repliesLeft(sessionId) {
+        const session = this.store.session(sessionId);
+        return session ? Math.max(0, session.reply_limit - this.store.repliesUsed(sessionId)) : 0;
+    }
+    // After every reply: how many are left, and which model is answering.
+    publishReplies(sessionId) {
+        this.publish(sessionId, { type: "replies", left: this.repliesLeft(sessionId), model: modelLabel(this.store.latestModel(sessionId)) });
+    }
+    // You changed the limit: tell open pages, and answer anything waiting.
+    setReplyLimit(sessionId, limit) {
+        this.store.setReplyLimit(sessionId, limit);
+        this.publishReplies(sessionId);
+        this.kick(sessionId);
+    }
+    kick(sessionId) {
+        if (this.live.has(sessionId))
+            return;
+        const session = this.store.session(sessionId);
+        if (!session || session.status !== "open")
+            return;
+        const pending = this.store.pending(sessionId);
+        if (!pending.length)
+            return;
+        // Out of replies: messages wait until you raise the limit.
+        if (this.repliesLeft(sessionId) <= 0)
+            return;
+        const turn = this.store.startTurn(session, pending.map((m) => m.id));
+        const live = { turnId: turn.id, text: "", activity: null };
+        this.live.set(sessionId, live);
+        this.publish(sessionId, { type: "turn", live });
+        const text = pending.map((m) => m.body).join("\n\n");
+        const images = pending
+            .flatMap((m) => m.images)
+            .map((file) => ({ path: join(paths.uploads, file), mediaType: mediaTypeFor(file) }))
+            .filter((image) => image.mediaType);
+        const input = { session, config: this.config, charter: charter(session, this.config), text, images };
+        const events = {
+            onAgentSessionId: (id) => this.store.setAgentSessionId(sessionId, id),
+            onDelta: (delta) => {
+                live.text += delta;
+                this.publish(sessionId, { type: "delta", text: delta });
+            },
+            onBreak: () => {
+                live.text += "\n\n";
+                this.publish(sessionId, { type: "delta", text: "\n\n" });
+            },
+            onActivity: (line) => {
+                live.activity = line;
+                this.store.addActivity(turn.id, line);
+                this.publish(sessionId, { type: "activity", line });
+            },
+        };
+        let run;
+        try {
+            run = session.agent === "codex" ? runCodexTurn(input, events) : runClaudeTurn(input, events);
+        }
+        catch (error) {
+            run = { done: Promise.reject(error), cancel() { } };
+        }
+        this.runs.set(sessionId, run);
+        let failed = false;
+        run.done
+            .then((result) => {
+            this.store.finishTurn(turn.id, "done", result.usage, null);
+            const message = this.store.addMessage(sessionId, "agent", result.text, [], turn.id);
+            this.publish(sessionId, { type: "message", message });
+        })
+            .catch((error) => {
+            if (this.store.session(sessionId)?.status !== "open") {
+                this.store.finishTurn(turn.id, "interrupted", null, "Session ended mid-reply.");
+                failed = true;
+                return;
+            }
+            const reason = String(error?.message ?? error).slice(0, 2000);
+            console.error(`[${sessionId}] turn ${turn.id} failed: ${reason}`);
+            this.store.finishTurn(turn.id, "failed", null, reason);
+            // Unanswered messages go back in the queue and ride along with the
+            // tester's next message, rather than retrying in a loop.
+            this.store.releaseTurn(turn.id);
+            failed = true;
+            const message = this.store.addMessage(sessionId, "error", "Something went wrong on my end and I couldn't reply. Your message is saved, and I'll see it along with the next one you send.", [], turn.id);
+            this.publish(sessionId, { type: "message", message });
+        })
+            .finally(() => {
+            this.live.delete(sessionId);
+            this.runs.delete(sessionId);
+            this.publish(sessionId, { type: "turn", live: null });
+            this.publishReplies(sessionId);
+            if (!failed)
+                this.kick(sessionId);
+        });
+    }
+}

package/dist/seal.js

@@ -0,0 +1,51 @@
+// End-to-end encryption between your computer and a tester's browser.
+//
+// Each session has its own random 256-bit key. It lives in your parley
+// database and in the tester's link after the "#", which browsers never send
+// to a server, so parley.im only ever carries ciphertext. Everything is
+// AES-256-GCM with a fresh 96-bit IV per message, and bound to the session and
+// direction ("req", "res", "evt", "blob") so a relay can't replay a reply as
+// a request or move a message between sessions. web/seal.js is the browser
+// side of the same format.
+const subtle = globalThis.crypto.subtle;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+const keys = new Map();
+export function newKey() {
+    return toBase64url(globalThis.crypto.getRandomValues(new Uint8Array(32)));
+}
+function importKey(key) {
+    let imported = keys.get(key);
+    if (!imported)
+        keys.set(key, (imported = subtle.importKey("raw", own(fromBase64url(key)), "AES-GCM", false, ["encrypt", "decrypt"])));
+    return imported;
+}
+const aad = (session, purpose) => encoder.encode(`parley:${session}:${purpose}`);
+// Web Crypto wants buffers it owns outright.
+const own = (bytes) => bytes;
+export async function sealBytes(key, session, purpose, plain) {
+    const iv = globalThis.crypto.getRandomValues(new Uint8Array(12));
+    const sealed = new Uint8Array(await subtle.encrypt({ name: "AES-GCM", iv, additionalData: aad(session, purpose) }, await importKey(key), own(plain)));
+    const out = new Uint8Array(12 + sealed.length);
+    out.set(iv);
+    out.set(sealed, 12);
+    return out;
+}
+export async function openBytes(key, session, purpose, data) {
+    if (data.length < 28)
+        throw new Error("Too short to be a sealed message.");
+    const plain = await subtle.decrypt({ name: "AES-GCM", iv: own(data.subarray(0, 12)), additionalData: aad(session, purpose) }, await importKey(key), own(data.subarray(12)));
+    return new Uint8Array(plain);
+}
+export async function seal(key, session, purpose, value) {
+    return toBase64url(await sealBytes(key, session, purpose, encoder.encode(JSON.stringify(value))));
+}
+export async function open(key, session, purpose, sealed) {
+    return JSON.parse(decoder.decode(await openBytes(key, session, purpose, fromBase64url(sealed))));
+}
+export function toBase64url(bytes) {
+    return Buffer.from(bytes).toString("base64url");
+}
+export function fromBase64url(text) {
+    return new Uint8Array(Buffer.from(text, "base64url"));
+}