@parley-im/parley 0.1.2 → 0.2.1

package/dist/db.js

@@ -1,6 +1,6 @@
 import { DatabaseSync } from "node:sqlite";
 import { randomBytes } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
 import { paths, ensureHome } from "./config.js";
 import { newKey } from "./seal.js";
@@ -11,7 +11,7 @@ create table if not exists sessions (
   token text not null unique,
   project_dir text not null,
   project_name text not null,
-  tester text not null,
+  guest text not null,
   brief text not null,
   greeting text not null,
   agent text not null,
@@ -42,14 +42,27 @@ create table if not exists messages (
   role text not null,
   body text not null,
   images text not null default '[]',
-  -- For tester messages: the turn that answered it (null while waiting).
+  -- For guest messages: the turn that answered it (null while waiting).
   -- For agent and error messages: the turn that produced it.
   turn_id integer references turns(id),
+  tries integer not null default 0,
+  client_id text,
   created_at text not null
 );
 create index if not exists messages_session on messages(session_id, id);
 create index if not exists turns_session on turns(session_id, id);
+create unique index if not exists messages_client on messages(session_id, client_id) where client_id is not null;
 `;
+// Changes to a project's database since parley 0.1.2, in order. New
+// databases start with the schema above, which already has them all; a
+// project's .parley folder can outlive any version of parley, so these stay.
+const UPGRADES = [
+    `alter table messages add column tries integer not null default 0;
+   alter table messages add column client_id text;
+   create unique index messages_client on messages(session_id, client_id) where client_id is not null;`,
+    `alter table sessions rename column tester to guest;
+   update messages set role = 'guest' where role = 'tester';`,
+];
 const now = () => new Date().toISOString();
 // A project's own parley folder: its sessions' database, and a folder per
 // session with the screenshots and a readable transcript. Kept out of git,
@@ -66,15 +79,38 @@ export class Store {
         ensureHome();
         this.refresh();
     }
-    // Opens any project another parley process has added since.
+    // Opens any project another parley process has added since, and lets go
+    // of any whose .parley folder isn't there anymore (moved or deleted).
     refresh() {
-        for (const dir of readProjects()) {
-            if (!this.projects.has(dir) && existsSync(join(parleyDir(dir), "parley.db")))
-                this.projects.set(dir, new ProjectDb(dir));
+        for (const [dir, db] of this.projects) {
+            if (existsSync(join(parleyDir(dir), "parley.db")))
+                continue;
+            db.close();
+            this.projects.delete(dir);
+            for (const [id, owner] of this.where)
+                if (owner === db)
+                    this.where.delete(id);
+        }
+        const listed = readProjects();
+        if (!listed)
+            return;
+        for (const dir of listed) {
+            if (this.projects.has(dir) || !existsSync(join(parleyDir(dir), "parley.db")))
+                continue;
+            const db = new ProjectDb(dir);
+            // A copied project brings copies of its sessions, keys and all. The
+            // first one listed keeps them; the copy is left alone.
+            const taken = db.ids().some((id) => [...this.projects.values()].some((other) => other.session(id)));
+            if (taken) {
+                console.error(`parley: ${dir} holds copies of another project's sessions; leaving it out.`);
+                db.close();
+                continue;
+            }
+            this.projects.set(dir, db);
         }
     }
     project(dir) {
-        dir = resolve(dir);
+        dir = realpathSync(dir);
         let db = this.projects.get(dir);
         if (!db) {
             mkdirSync(parleyDir(dir), { recursive: true });
@@ -83,8 +119,10 @@ export class Store {
             db = new ProjectDb(dir);
             this.projects.set(dir, db);
             const listed = readProjects();
+            if (!listed)
+                throw new Error(`Can't read ${paths.projects}. Fix or delete it, then try again.`);
             if (!listed.includes(dir))
-                writeFileSync(paths.projects, JSON.stringify([...listed, dir], null, 2) + "\n");
+                writeProjects([...listed, dir]);
         }
         return db;
     }
@@ -136,7 +174,8 @@ export class Store {
     }
     sessions(filter = {}) {
         this.refresh();
-        const dbs = filter.projectDir ? [this.projects.get(resolve(filter.projectDir))].filter((db) => !!db) : [...this.projects.values()];
+        const dir = filter.projectDir && (existsSync(filter.projectDir) ? realpathSync(filter.projectDir) : resolve(filter.projectDir));
+        const dbs = dir ? [this.projects.get(dir)].filter((db) => !!db) : [...this.projects.values()];
         return dbs.flatMap((db) => db.sessions(filter.status)).sort((a, b) => b.updated_at.localeCompare(a.updated_at));
     }
     // Erases the session: transcript, turns, screenshots and its folder.
@@ -167,8 +206,8 @@ export class Store {
     setAgentSessionId(id, agentSessionId) {
         this.on(id, (db) => db.setAgentSessionId(id, agentSessionId), undefined);
     }
-    addMessage(sessionId, role, body, images, turnId) {
-        const message = this.of(sessionId).addMessage(sessionId, role, body, images, turnId);
+    addMessage(sessionId, role, body, images, turnId, clientId = null) {
+        const message = this.of(sessionId).addMessage(sessionId, role, body, images, turnId, clientId);
         this.write(sessionId);
         return message;
     }
@@ -199,6 +238,12 @@ export class Store {
     releaseTurn(sessionId, turnId) {
         this.on(sessionId, (db) => db.releaseTurn(turnId), undefined);
     }
+    failTurn(sessionId, turnId) {
+        return this.on(sessionId, (db) => db.failTurn(turnId), { retrying: 0, setAside: 0 });
+    }
+    messageByClient(sessionId, clientId) {
+        return this.on(sessionId, (db) => db.messageByClient(sessionId, clientId), undefined);
+    }
     // Turns that never finished (the server stopped mid-reply), everywhere.
     recoverInterrupted() {
         this.refresh();
@@ -208,23 +253,35 @@ export class Store {
         return this.of(sessionId).stats(sessionId);
     }
     // Keeps <session>/transcript.md in step, for you and your agent to read.
+    // Not if the project has moved out from under us: no folders get made at
+    // the old path.
     write(sessionId) {
         const session = this.session(sessionId);
-        if (!session)
+        if (!session || !existsSync(parleyDir(session.project_dir)))
             return;
         mkdirSync(sessionDir(session), { recursive: true });
         writeFileSync(join(sessionDir(session), "transcript.md"), record(this, session));
     }
 }
+// The listed projects; an empty list if there's no file yet, and null if
+// it can't be read (so nothing overwrites it with a list of one).
 function readProjects() {
+    if (!existsSync(paths.projects))
+        return [];
     try {
         const list = JSON.parse(readFileSync(paths.projects, "utf8"));
-        return Array.isArray(list) ? list.filter((dir) => typeof dir === "string") : [];
+        return Array.isArray(list) ? list.filter((dir) => typeof dir === "string") : null;
     }
     catch {
-        return [];
+        return null;
     }
 }
+// Written whole and then swapped in, so a crash can't leave half a file.
+function writeProjects(list) {
+    const temp = `${paths.projects}.${process.pid}.tmp`;
+    writeFileSync(temp, JSON.stringify(list, null, 2) + "\n");
+    renameSync(temp, paths.projects);
+}
 // One project's sessions, in <project>/.parley/parley.db.
 class ProjectDb {
     db;
@@ -233,20 +290,34 @@ class ProjectDb {
         this.dir = dir;
         this.db = new DatabaseSync(join(parleyDir(dir), "parley.db"));
         this.db.exec("pragma journal_mode = wal; pragma busy_timeout = 5000; pragma foreign_keys = on;");
-        this.db.exec(schema);
+        const fresh = !this.db.prepare("select 1 from sqlite_master where name = 'sessions'").get();
+        if (fresh)
+            this.db.exec(`begin; ${schema} pragma user_version = ${UPGRADES.length}; commit;`);
+        const at = Number(this.db.prepare("pragma user_version").get().user_version);
+        for (let v = at; v < UPGRADES.length; v++)
+            this.db.exec(`begin; ${UPGRADES[v]} pragma user_version = ${v + 1}; commit;`);
     }
     // A project that moved still has its sessions; they're wherever it is now.
     row = (row) => row && { ...row, project_dir: this.dir };
+    ids() {
+        return this.db.prepare("select id from sessions").all().map((r) => String(r.id));
+    }
+    close() {
+        try {
+            this.db.close();
+        }
+        catch { }
+    }
     createSession(id, input) {
         const token = randomBytes(18).toString("base64url");
         const projectName = basename(this.dir);
         const greeting = input.greeting?.trim() ||
-            `Hi ${input.tester}! Thanks for trying ${projectName}. Tell me anything: what you tried, what tripped you up, what you liked. Long rambling brain dumps are perfect.`;
+            `Hi ${input.guest}! Thanks for trying ${projectName}. Tell me anything: what you tried, what tripped you up, what you liked. Long rambling brain dumps are perfect.`;
         const t = now();
         this.db
-            .prepare(`insert into sessions (id, token, project_dir, project_name, tester, brief, greeting, agent, model, reply_limit, e2e_key, status, created_at, updated_at)
+            .prepare(`insert into sessions (id, token, project_dir, project_name, guest, brief, greeting, agent, model, reply_limit, e2e_key, status, created_at, updated_at)
          values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'open', ?, ?)`)
-            .run(id, token, this.dir, projectName, input.tester, input.brief, greeting, input.agent, input.model ?? null, input.replyLimit, newKey(), t, t);
+            .run(id, token, this.dir, projectName, input.guest, input.brief, greeting, input.agent, input.model ?? null, input.replyLimit, newKey(), t, t);
     }
     session(id) {
         return this.row(this.db.prepare("select * from sessions where id = ?").get(id));
@@ -290,10 +361,10 @@ class ProjectDb {
     touch(id) {
         this.db.prepare("update sessions set updated_at = ? where id = ?").run(now(), id);
     }
-    addMessage(sessionId, role, body, images, turnId) {
+    addMessage(sessionId, role, body, images, turnId, clientId = null) {
         const result = this.db
-            .prepare("insert into messages (session_id, role, body, images, turn_id, created_at) values (?, ?, ?, ?, ?, ?)")
-            .run(sessionId, role, body, JSON.stringify(images), turnId, now());
+            .prepare("insert into messages (session_id, role, body, images, turn_id, client_id, created_at) values (?, ?, ?, ?, ?, ?, ?)")
+            .run(sessionId, role, body, JSON.stringify(images), turnId, clientId, now());
         this.touch(sessionId);
         return this.message(Number(result.lastInsertRowid));
     }
@@ -314,7 +385,7 @@ class ProjectDb {
     }
     pending(sessionId) {
         return this.db
-            .prepare("select * from messages where session_id = ? and role = 'tester' and turn_id is null order by id")
+            .prepare("select * from messages where session_id = ? and role = 'guest' and turn_id is null order by id")
             .all(sessionId).map(parseMessage);
     }
     startTurn(session, messageIds) {
@@ -346,7 +417,20 @@ class ProjectDb {
             .run(status, usage ? JSON.stringify(usage) : null, error, now(), turnId);
     }
     releaseTurn(turnId) {
-        this.db.prepare("update messages set turn_id = null where turn_id = ? and role = 'tester'").run(turnId);
+        this.db.prepare("update messages set turn_id = null where turn_id = ? and role = 'guest'").run(turnId);
+    }
+    // A reply failed: its messages go back in the queue to ride along with the
+    // next one, unless they've already failed once, in which case they're set
+    // aside (still saved, never retried) so one bad message can't sink the rest.
+    failTurn(turnId) {
+        this.db.prepare("update messages set tries = tries + 1 where turn_id = ? and role = 'guest'").run(turnId);
+        const back = this.db.prepare("update messages set turn_id = null where turn_id = ? and role = 'guest' and tries < 2").run(turnId);
+        const aside = this.db.prepare("select count(*) as n from messages where turn_id = ? and role = 'guest'").get(turnId);
+        return { retrying: Number(back.changes), setAside: Number(aside.n) };
+    }
+    messageByClient(sessionId, clientId) {
+        const row = this.db.prepare("select * from messages where session_id = ? and client_id = ?").get(sessionId, clientId);
+        return row && parseMessage(row);
     }
     // A turn that never finished (server stopped mid-reply) gives its messages
     // back to the queue so they are answered when the server comes back.
@@ -363,11 +447,11 @@ class ProjectDb {
     stats(sessionId) {
         const row = this.db
             .prepare(`select
-           coalesce(sum(m.role = 'tester'), 0) as tester_messages,
+           coalesce(sum(m.role = 'guest'), 0) as guest_messages,
            coalesce(sum(m.role = 'agent'), 0) as agent_messages,
-           coalesce(sum(m.role = 'tester' and m.id > s.read_through), 0) as unread,
+           coalesce(sum(m.role = 'guest' and m.id > s.read_through), 0) as unread,
            max(m.created_at) as last_message_at,
-           max(case when m.role = 'tester' then m.created_at end) as last_tester_at
+           max(case when m.role = 'guest' then m.created_at end) as last_guest_at
          from sessions s left join messages m on m.session_id = s.id
          where s.id = ?`)
             .get(sessionId);

package/dist/mcp.js

@@ -8,9 +8,9 @@ import { linkFor, dashboardUrl, isServerUp } from "./state.js";
 import { transcript, summaryLine } from "./transcript.js";
 import { startSession, endSession, setReplyLimit } from "./control.js";
 import { readCredentials } from "./account.js";
-const INSTRUCTIONS = `Parley lets the user hand a tester a link to a private web chat with a read-only Claude or Codex running in their project folder. The tester talks; the agent listens, asks follow-ups, answers questions from the code, and everything is recorded.
+const INSTRUCTIONS = `Parley lets the user hand a guest a link to a private web chat with a read-only Claude or Codex running in their project folder. The guest talks; the agent listens, asks follow-ups, answers questions from the code, and everything is recorded.
 
-Use create_session when the user wants someone to give feedback on a project. Write the brief from what you know about the project and what the user wants to learn. Later, use list_sessions to see which sessions are open, which have new messages, and how many replies each has used and spent; get_transcript to read them; set_reply_limit to give a session more room or less; and end_session when the user is done with one. Links live on parley.im and are end-to-end encrypted; the conversation itself happens on the user's computer, so testers can only get replies while it's awake and the parley server is running.`;
+Use create_session when the user wants someone to give feedback on a project. Write the brief from what you know about the project and what the user wants to learn. Later, use list_sessions to see which sessions are open, which have new messages, and how many replies each has used and spent; get_transcript to read them; set_reply_limit to give a session more room or less; and end_session when the user is done with one. Links live on parley.im and are end-to-end encrypted; the conversation itself happens on the user's computer, so guests can only get replies while it's awake and the parley server is running.`;
 export async function runMcp() {
     const config = loadConfig();
     const store = new Store();
@@ -20,25 +20,25 @@ export async function runMcp() {
     const currentLink = (id) => linkFor(store.session(id), config);
     server.registerTool("create_session", {
         title: "Create a feedback session",
-        description: "Create a parley session: a private link the user can send to a tester. The tester chats with a fresh, read-only " +
+        description: "Create a parley session: a private link the user can send to a guest. The guest chats with a fresh, read-only " +
             "agent in the project folder that hears their feedback, answers questions by reading the code, and records everything. " +
             "Starts the local server and tunnel if needed. Returns the link to give the user.",
         inputSchema: {
             project_dir: z.string().describe("Absolute path of the project folder, normally your current working directory."),
-            tester: z.string().describe("Name of the person who will give feedback, e.g. 'Sam'."),
+            guest: z.string().describe("Name of the person who will give feedback, e.g. 'Sam'."),
             brief: z
                 .string()
                 .describe("Instructions for the interviewer, written to it directly. Cover what the project is and its current state, " +
-                "how the tester will try it (URL, build, steps), what the user most wants to learn, known issues not worth " +
-                "digging into, and anything about the tester that helps. A few short paragraphs."),
+                "how the guest will try it (URL, build, steps), what the user most wants to learn, known issues not worth " +
+                "digging into, and anything about the guest that helps. A few short paragraphs."),
             greeting: z
                 .string()
                 .optional()
-                .describe("The first message the tester sees, from the interviewer. Short and warm. A default is used if omitted."),
+                .describe("The first message the guest sees, from the interviewer. Short and warm. A default is used if omitted."),
             agent: z
                 .enum(["claude", "codex"])
                 .optional()
-                .describe("Which agent interviews the tester. Defaults to whichever agent is calling this tool."),
+                .describe("Which agent interviews the guest. Defaults to whichever agent is calling this tool."),
             model: z.string().optional().describe("Model override for the interviewer. Usually leave unset."),
             reply_limit: z
                 .number()
@@ -52,7 +52,7 @@ export async function runMcp() {
         try {
             made = await startSession(store, config, {
                 projectDir: args.project_dir,
-                tester: args.tester,
+                guest: args.guest,
                 brief: args.brief,
                 greeting: args.greeting,
                 agent: args.agent ?? callerAgent(),
@@ -65,9 +65,9 @@ export async function runMcp() {
         }
         const { session } = made;
         const lines = [
-            `Created session ${session.id} for ${session.tester} (${session.agent}, read-only in ${session.project_dir}, up to ${session.reply_limit} replies).`,
+            `Created session ${session.id} for ${session.guest} (${session.agent}, read-only in ${session.project_dir}, up to ${session.reply_limit} replies).`,
             "",
-            `Link for ${session.tester}: ${linkFor(session, config)}`,
+            `Link for ${session.guest}: ${linkFor(session, config)}`,
             `Watch it live on the control panel: ${dashboardUrl(config, session)}`,
             "",
         ];
@@ -81,15 +81,15 @@ export async function runMcp() {
             lines.push("Warning: parley.im didn't take the session yet. It will once the connection is back; `parley status` shows it.");
         }
         else {
-            lines.push("Everything after the # in the link is the session's encryption key: share the whole link, and only with the tester. " +
+            lines.push("Everything after the # in the link is the session's encryption key: share the whole link, and only with the guest. " +
                 "Replies come from this computer, so it needs to be awake with parley running.");
         }
         return reply(lines.join("\n"));
     });
     server.registerTool("list_sessions", {
         title: "List feedback sessions",
-        description: "List parley sessions, newest activity first, with how many tester messages are new since you last read each one. " +
-            "Open sessions include their current tester link.",
+        description: "List parley sessions, newest activity first, with how many guest messages are new since you last read each one. " +
+            "Open sessions include their current guest link.",
         inputSchema: {
             status: z.enum(["open", "ended", "all"]).optional().describe("Defaults to open."),
             project_dir: z.string().optional().describe("Only sessions for this project folder. Omit for every project."),
@@ -103,14 +103,14 @@ export async function runMcp() {
         if (!sessions.length)
             return reply(status === "all" ? "No sessions yet." : `No ${status} sessions.`);
         const down = status !== "ended" && !(await isServerUp(config))
-            ? "The parley server is not running, so testers can't get replies. Run `parley start` to bring it back.\n\n"
+            ? "The parley server is not running, so guests can't get replies. Run `parley start` to bring it back.\n\n"
             : "";
         return reply(down + sessions.map((s) => summaryLine(store, s, linkFor(s, config))).join("\n\n"));
     });
     server.registerTool("get_transcript", {
         title: "Read a feedback session",
         description: "Read a parley session as Markdown: the brief, every message, which model interviewed, and paths to screenshots the " +
-            "tester shared. Set only_new to read just what came in since you last read it. Reading marks it read.",
+            "guest shared. Set only_new to read just what came in since you last read it. Reading marks it read.",
         inputSchema: {
             session_id: z.string(),
             only_new: z.boolean().optional(),
@@ -123,7 +123,7 @@ export async function runMcp() {
     });
     server.registerTool("end_session", {
         title: "End a feedback session",
-        description: "End a parley session for good when the user is done with it. The tester's link stops working entirely and an open " +
+        description: "End a parley session for good when the user is done with it. The guest's link stops working entirely and an open " +
             "page clears itself. The transcript stays readable here. This can't be undone; make a new session to talk again.",
         inputSchema: { session_id: z.string() },
     }, async (args) => {
@@ -133,12 +133,12 @@ export async function runMcp() {
         if (session.status !== "open")
             return reply(`Session ${session.id} had already ended.`);
         await endSession(config, store, session.id);
-        return reply(`Ended ${session.id} (${session.tester} on ${session.project_name}). The link no longer works; the transcript is kept. ` +
+        return reply(`Ended ${session.id} (${session.guest} on ${session.project_name}). The link no longer works; the transcript is kept. ` +
             `To erase it completely, the user can run \`parley delete ${session.id}\`.`);
     });
     server.registerTool("set_reply_limit", {
         title: "Change a session's reply limit",
-        description: "Set how many replies the interviewer may give in a session in total. When a session runs out it pauses: the tester " +
+        description: "Set how many replies the interviewer may give in a session in total. When a session runs out it pauses: the guest " +
             "can't send more until the limit is raised. Use it when the user wants to give a session more room, or rein it in.",
         inputSchema: { session_id: z.string(), limit: z.number().int().positive().describe("Total replies allowed, including ones already given.") },
     }, async (args) => {
@@ -147,7 +147,7 @@ export async function runMcp() {
             return { ...reply(`No session ${args.session_id}.`), isError: true };
         await setReplyLimit(config, store, session.id, args.limit);
         const used = store.repliesUsed(session.id);
-        return reply(`${session.id} (${session.tester}) may now give ${args.limit} replies in total; ${used} used so far.`);
+        return reply(`${session.id} (${session.guest}) may now give ${args.limit} replies in total; ${used} used so far.`);
     });
     await server.connect(new StdioServerTransport());
 }

package/dist/models.js

@@ -1,10 +1,16 @@
-// "claude-opus-5-5" reads better as "Opus 5.5". Anything else (Codex models,
-// aliases) is shown as it is.
+// Models by the names their makers use: "claude-opus-5-5" is "Opus 5.5" and
+// "gpt-6-astra" is "GPT-6 Astra". Anything else (aliases, o-series) is shown
+// as it is.
 export function modelLabel(model) {
     if (!model)
         return null;
     const claude = model.match(/^claude-([a-z]+)-(\d+)-(\d+)(?:-\d{8})?$/);
     if (claude)
         return `${claude[1][0].toUpperCase()}${claude[1].slice(1)} ${claude[2]}.${claude[3]}`;
+    const gpt = model.match(/^gpt-([\d.]+)((?:-[a-z0-9]+)*)$/);
+    if (gpt) {
+        const words = gpt[2].split("-").filter(Boolean).map((w) => (/^(mini|nano)$/.test(w) ? w : w[0].toUpperCase() + w.slice(1)));
+        return [`GPT-${gpt[1]}`, ...words].join(" ");
+    }
     return model;
 }

package/dist/relay.js

@@ -5,6 +5,7 @@ import { sessionDir } from "./db.js";
 import { Problem, MAX_IMAGES } from "./api.js";
 import { readCredentials, relay as registry } from "./account.js";
 import { seal, open, sealBytes, openBytes } from "./seal.js";
+import { VERSION } from "./version.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;
@@ -18,7 +19,7 @@ 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
+// on your machine for the internet), answers guest 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 {
@@ -33,6 +34,9 @@ export class RelayLink {
     retry = null;
     ping = null;
     seen = new Map();
+    // parley.im's clock minus ours, from its hello. Guests' pages use the same
+    // clock, so a phone or laptop set to the wrong time doesn't matter.
+    clock = 0;
     incoming = new Map();
     held = new Map();
     // Events go out in order even though sealing them is asynchronous.
@@ -71,12 +75,13 @@ export class RelayLink {
             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}`]);
+        const ws = new WebSocket(`${creds.relayUrl.replace(/^http/, "ws")}/api/connect`, ["parley.v1", `parley.token.${creds.token}`, `parley.version.${VERSION}`]);
         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);
+            // parley.im counts this computer as gone after about a minute without one.
+            this.ping = setInterval(() => ws.readyState === WebSocket.OPEN && ws.send('{"t":"ping"}'), 20_000);
             // Tell parley.im which sessions are open, so their links work.
             try {
                 await registry.sync(creds, this.store.sessions({ status: "open" }));
@@ -98,6 +103,10 @@ export class RelayLink {
                 this.status = { state: "unlinked", relayUrl: creds.relayUrl, error: "This computer was unlinked from its parley.im account. Run parley login." };
                 return;
             }
+            if (event.code === 4426) {
+                this.status = { state: "outdated", relayUrl: creds.relayUrl, error: event.reason || "parley on this computer is out of date. Update it with: npm install -g @parley-im/parley" };
+                return;
+            }
             if (event.code === 4000) {
                 this.status = { state: "replaced", relayUrl: creds.relayUrl, error: "Another parley on this computer took over the connection." };
                 return;
@@ -134,6 +143,10 @@ export class RelayLink {
         catch {
             return;
         }
+        if (frame.t === "hello" && typeof frame.now === "number") {
+            this.clock = frame.now - Date.now();
+            return;
+        }
         if (typeof frame.s === "string" && typeof frame.r === "string") {
             if (frame.t === "up")
                 return this.receive(frame);
@@ -156,10 +169,10 @@ export class RelayLink {
             // 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}`)) {
+        if (req.r !== frame.r || typeof req.at !== "number" || Math.abs(Date.now() + this.clock - 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 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:${frame.r}`, payload) });
         const scope = { session, owner: false, base: "", images: "ref" };
         try {
             if (req.op === "state")
@@ -169,11 +182,23 @@ export class RelayLink {
             if (req.op === "send") {
                 const text = String(req.text ?? "").trim();
                 const images = Array.isArray(req.images) ? req.images : [];
+                const clientId = typeof req.cid === "string" ? req.cid.slice(0, 64) : null;
+                const again = this.api.resent(scope, clientId);
+                if (again)
+                    return await reply({ ok: true, result: again });
                 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: true, result: this.api.post(scope, text, names, clientId) });
+            }
+            if (req.op === "end") {
+                this.api.endByGuest(scope);
+                await reply({ ok: true, result: { ended: true } });
+                const creds = readCredentials(this.config);
+                if (creds)
+                    await registry.end(creds, session).catch((error) => console.error(`parley.im didn't hear ${session.id} ended: ${error.message}`));
+                return;
             }
             return await reply({ ok: false, error: "unknown", message: "Unknown request." });
         }
@@ -184,7 +209,7 @@ export class RelayLink {
             return reply({ ok: false, error: "broken", message: "Something broke on this end." });
         }
     }
-    // A screenshot arriving from a tester's page, in pieces, still encrypted.
+    // A screenshot arriving from a guest'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();
@@ -246,7 +271,7 @@ export class RelayLink {
         this.held.set(id, { session: session.id, bytes: plain, at: now });
         return id;
     }
-    // Keeps a screenshot that a tester's message refers to.
+    // Keeps a screenshot that a guest'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)) {
@@ -261,7 +286,7 @@ export class RelayLink {
         writeFileSync(join(sessionDir(session), name), held.bytes);
         return name;
     }
-    // A screenshot for a tester's page, encrypted here and sent in pieces.
+    // A screenshot for a guest'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);
@@ -273,7 +298,7 @@ export class RelayLink {
             : 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(sessionDir(session), name)));
+        const sealed = await sealBytes(session.e2e_key, session.token, `shot:${id}`, readFileSync(join(sessionDir(session), 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({});

package/dist/runner.js

@@ -79,8 +79,8 @@ export class Runner {
             signal.addEventListener("abort", finish);
         });
     }
-    submit(session, text, images) {
-        const message = this.store.addMessage(session.id, "tester", text, images, null);
+    submit(session, text, images, clientId = null) {
+        const message = this.store.addMessage(session.id, "guest", text, images, null, clientId);
         this.publish(session.id, { type: "message", message });
         this.kick(session.id);
         return message;
@@ -97,7 +97,7 @@ export class Runner {
             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.
+    // themselves, and every guest route answers 410 from here on.
     end(sessionId) {
         this.store.end(sessionId);
         this.runs.get(sessionId)?.cancel();
@@ -179,11 +179,13 @@ export class Runner {
             const reason = String(error?.message ?? error).slice(0, 2000);
             console.error(`[${sessionId}] turn ${turn.id} failed: ${reason}`);
             this.store.finishTurn(sessionId, 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(sessionId, turn.id);
+            // Unanswered messages ride along with the guest's next message,
+            // rather than retrying in a loop; a second failure sets them aside.
+            const { setAside } = this.store.failTurn(sessionId, 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);
+            const message = this.store.addMessage(sessionId, "error", setAside
+                ? "I still couldn't reply to that, so I've set it aside. It's saved for the person who sent you this link. Try saying it another way, or send it without the screenshot."
+                : "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(() => {

package/dist/seal.js

@@ -1,12 +1,14 @@
-// End-to-end encryption between your computer and a tester's browser.
+// End-to-end encryption between your computer and a guest'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
+// database and in the guest'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.
+// purpose so a relay can't replay a reply as a request or move a message
+// between sessions: "req", "evt", "blob" (an upload), a reply to one request
+// ("res:<request id>") and a screenshot by its id ("shot:<id>"), so replies
+// and screenshots can't be swapped for others either. web/seal.js is the
+// browser side of the same format.
 const subtle = globalThis.crypto.subtle;
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();