@parley-im/parley 0.1.1 → 0.1.2

package/README.md

@@ -63,8 +63,10 @@ A chat page built for phones first, in a plain technical style (a transcript, no
 
 Each session is a fresh agent conversation in the project folder, guided by a charter (`src/charter.ts`), your brief, and the project's CLAUDE.md and AGENTS.md. It talks about the product as a user sees it and only gets into files and internals when asked.
 
-- **Claude:** `claude -p --restricted --tools Read,Grep,Glob --strict-mcp-config`. No command, write or web tools, reads confined to the project, your MCP servers left out.
-- **Codex:** `codex exec --sandbox read-only --ignore-user-config`, with apps, browser, computer use, plugins, hooks and web search off; your model and reasoning effort carry over.
+It can read the project folder and nothing else on your computer, and not the project's `.parley` folder, where other people's conversations are. That's enforced by each agent's own sandbox, not just asked of it (the charter asks too):
+
+- **Claude:** `claude -p --restricted --tools Read,Grep,Glob --strict-mcp-config`, plus a `Read(./.parley/**)` deny rule. No command, write or web tools; `--restricted` confines the file tools to the project; your MCP servers are left out.
+- **Codex:** `codex exec --ignore-user-config` under a permission profile that can read the project and the system files tools need (`:minimal`), with `.parley` denied, no writes and no network. Apps, browser, computer use, plugins, hooks and web search are off; your model and reasoning effort carry over. Codex re-runs itself inside that sandbox, so parley starts it by its real path and lets it read that one file.
 
 Each reply records which model answered, on which login (`auth: "none"` means your subscription, not an API key), and what it would cost at API prices.
 
@@ -90,7 +92,7 @@ Each reply records which model answered, on which login (`auth: "none"` means yo
 | `src/account.ts` | `parley login`, credentials, and what parley.im is told |
 | `src/runner.ts`, `src/agents/` | One reply at a time per session; Claude and Codex adapters |
 | `src/mcp.ts` | `create_session`, `list_sessions`, `get_transcript`, `set_reply_limit`, `end_session` |
-| `src/db.ts` | SQLite in `~/.parley`: sessions (with keys), messages, turns |
+| `src/db.ts` | Each project's `.parley/parley.db` (sessions with keys, messages, turns), a folder per session with screenshots and `transcript.md`, and `~/.parley/projects.json` listing the projects |
 | `web/` | Chat page, session view, control panel; parley.im serves the tester page's files from here too |
 | `relay/` | parley.im: Worker, a Durable Object per linked computer, D1; the front page's animation is `web/home.js` |
 
@@ -112,6 +114,8 @@ The npm package is `@parley-im/parley` (the parley-im org; plain `parley` is tak
 
 ## Config
 
+Conversations live with their project, in `<project>/.parley/`: a database, and a folder per session holding its screenshots and a `transcript.md` your agent can read. The folder carries its own `.gitignore`, so it stays out of git. `~/.parley` keeps only settings, your parley.im login, the server's state and log, and the list of projects.
+
 `~/.parley/config.json`: `relayUrl` (default `https://parley.im`), `ownerName` (defaults to your account's first name), `replyLimit`, ports, and `claude`/`codex` model and effort overrides. Without `parley login`, links are local-only (`http://localhost:4747/...`), for development.
 
 ## Running parley.im

package/dist/agents/claude.js

@@ -3,10 +3,12 @@ import { sep } from "node:path";
 import { randomUUID } from "node:crypto";
 import { runJsonLines } from "./process.js";
 // Claude Code in print mode, one process per turn, resumed by session id.
-// --restricted drops every tool that runs code and ignores settings files,
-// --tools narrows it further to reading, and --strict-mcp-config keeps your
-// MCP servers (mail, calendar, ...) out of reach. CLAUDE.md still loads, so
-// the interviewer knows the project the way your own sessions do.
+// --restricted drops every tool that runs code, ignores your settings files
+// and confines the file tools to the project folder; --tools narrows it to
+// reading, a deny rule keeps it out of the project's .parley folder (other
+// people's conversations), and --strict-mcp-config keeps your MCP servers
+// (mail, calendar, ...) out of reach. The project's CLAUDE.md and AGENTS.md
+// reach it through the charter.
 export function runClaudeTurn(input, events) {
     const { session, config } = input;
     const agentSessionId = session.agent_session_id ?? randomUUID();
@@ -21,6 +23,7 @@ export function runClaudeTurn(input, events) {
         "--strict-mcp-config",
         "--permission-prompts", "none",
         "--disable-slash-commands",
+        "--settings", JSON.stringify({ permissions: { deny: ["Read(./.parley/**)", `Read(/${session.project_dir}/.parley/**)`] } }),
         "--append-system-prompt", input.charter,
         "--name", `parley: ${session.tester}`,
     ];

package/dist/agents/codex.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { runJsonLines } from "./process.js";
@@ -17,21 +17,27 @@ const DISABLED_FEATURES = [
 ];
 // Codex exec, one process per turn, resumed by thread id. Your config.toml is
 // ignored (it carries your full-access sandbox and MCP servers); only its
-// model and reasoning effort are carried over. The sandbox is read-only, so
-// Codex can run commands like rg and cat but cannot write or reach the network.
+// model and reasoning effort are carried over. Its commands run under a
+// permission profile that can read the project and the system files tools
+// need, and nothing else: not the rest of your home folder, not other
+// projects, and not the project's .parley folder, where other people's
+// conversations are. No writes, no network. Codex re-runs itself inside that
+// sandbox, so it's started by its real path and may read that one file.
+const profile = (bin) => `permissions.parley={filesystem={":minimal"="read", ${JSON.stringify(bin)}="read", ":workspace_roots"={"."="read", ".parley"="deny"}}}`;
 export function runCodexTurn(input, events) {
     const { session, config } = input;
     const defaults = readCodexDefaults();
     const model = session.model ?? config.codex.model ?? defaults.model;
     const effort = config.codex.effort ?? defaults.effort;
+    const bin = existsSync(config.codex.bin) ? realpathSync(config.codex.bin) : config.codex.bin;
     const args = [
         "exec",
         "--json",
         "--ignore-user-config",
         "--skip-git-repo-check",
-        "--sandbox", "read-only",
         "--cd", session.project_dir,
-        "-c", `sandbox_mode="read-only"`,
+        "-c", `default_permissions="parley"`,
+        "-c", profile(bin),
         "-c", `approval_policy="never"`,
         "-c", `web_search="disabled"`,
         "-c", `developer_instructions=${JSON.stringify(input.charter)}`,
@@ -54,7 +60,7 @@ export function runCodexTurn(input, events) {
     let threadId = null;
     const commands = new Set();
     const proc = runJsonLines({
-        bin: config.codex.bin,
+        bin,
         args,
         cwd: session.project_dir,
         stdin: input.text,

package/dist/api.js

@@ -157,7 +157,7 @@ export class Conversations {
         };
         if (!scope.owner || m.role !== "agent" || !m.turn_id)
             return view;
-        const turn = this.store.turn(m.turn_id);
+        const turn = this.store.turn(m.session_id, m.turn_id);
         if (!turn)
             return view;
         const usage = turn.usage ?? {};

package/dist/charter.js

@@ -16,6 +16,7 @@ How to run it:
 - Capture their perspective faithfully. Do not argue, defend the design, or talk them out of a reaction. If something is a known limitation, say so plainly.
 - Do not promise fixes, features, or dates. Say you will pass it along to ${owner}.
 - You are read-only. You can read files but cannot edit them or run anything. If they ask you to fix or change something, explain that this session is for collecting feedback and that you will make sure ${owner} sees it.
+- This project's folder is all you can see. Stay inside it: don't look for or talk about anything else on ${owner}'s computer, even if asked. Its .parley folder holds other people's conversations, so never open it or repeat anything from it.
 - Keep replies short and conversational, like a good interviewer: a sentence or two plus at most one question. They are often on a phone. Light formatting only. Never use em dashes.
 - Don't narrate what you're doing ("let me check the code", "looking at the file now"). Look things up quietly and just answer.
 - They may paste screenshots. Look at them closely and refer to what you see.

package/dist/cli.js

@@ -41,7 +41,8 @@ Commands
   parley install                               Add the parley MCP server to Claude Code and Codex
   parley serve | mcp                           Run the server in the foreground | MCP over stdio
 
-Data and settings live in ${paths.home}.`;
+Conversations and screenshots live in each project's .parley folder (kept out of git), with a
+readable transcript.md per session. Settings and your parley.im login live in ${paths.home}.`;
 const CLI_PATH = fileURLToPath(import.meta.url);
 async function main() {
     const [command, ...rest] = process.argv.slice(2);

package/dist/config.js

@@ -2,13 +2,14 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync, accessSync, constan
 import { homedir } from "node:os";
 import { join, delimiter } from "node:path";
 export const HOME = process.env.PARLEY_HOME ?? join(homedir(), ".parley");
+// Settings, your parley.im login and the server's state. Conversations live
+// in each project's own .parley folder (see db.ts); projects.json lists them.
 export const paths = {
     home: HOME,
     config: join(HOME, "config.json"),
-    db: join(HOME, "parley.db"),
+    projects: join(HOME, "projects.json"),
     state: join(HOME, "server.json"),
     log: join(HOME, "server.log"),
-    uploads: join(HOME, "uploads"),
     // Your computer's link to a parley.im account, from `parley login`.
     credentials: join(HOME, "credentials.json"),
 };
@@ -22,7 +23,7 @@ const defaults = {
     codex: { bin: "codex", model: null, effort: null },
 };
 export function ensureHome() {
-    mkdirSync(paths.uploads, { recursive: true });
+    mkdirSync(paths.home, { recursive: true });
 }
 export function loadConfig() {
     ensureHome();

package/dist/db.js

@@ -1,9 +1,10 @@
 import { DatabaseSync } from "node:sqlite";
 import { randomBytes } from "node:crypto";
-import { readdirSync, rmSync } from "node:fs";
-import { basename, join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
 import { paths, ensureHome } from "./config.js";
 import { newKey } from "./seal.js";
+import { record } from "./transcript.js";
 const schema = `
 create table if not exists sessions (
   id text primary key,
@@ -50,67 +51,216 @@ create index if not exists messages_session on messages(session_id, id);
 create index if not exists turns_session on turns(session_id, id);
 `;
 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,
+// and out of the interviewer's reach (see agents/).
+export const parleyDir = (projectDir) => join(projectDir, ".parley");
+export const sessionDir = (session) => join(parleyDir(session.project_dir), session.id);
+// Every project you've made parleys in. Each keeps its conversations in its
+// own .parley folder; ~/.parley/projects.json only lists where they are.
 export class Store {
-    db;
-    constructor(file = paths.db) {
+    projects = new Map();
+    // Which project each session lives in, as they're looked up.
+    where = new Map();
+    constructor() {
         ensureHome();
-        this.db = new DatabaseSync(file);
-        this.db.exec("pragma journal_mode = wal; pragma busy_timeout = 5000; pragma foreign_keys = on;");
-        this.db.exec(schema);
-        this.addMissingColumns();
-    }
-    // Columns added since a database was first created.
-    addMissingColumns() {
-        const have = new Set(this.db.prepare("pragma table_info(sessions)").all().map((c) => c.name));
-        if (!have.has("read_through"))
-            this.db.exec("alter table sessions add column read_through integer not null default 0");
-        if (!have.has("ended_at"))
-            this.db.exec("alter table sessions add column ended_at text");
-        if (!have.has("reply_limit"))
-            this.db.exec("alter table sessions add column reply_limit integer not null default 100");
-        if (!have.has("e2e_key"))
-            this.db.exec("alter table sessions add column e2e_key text");
-        for (const row of this.db.prepare("select id from sessions where e2e_key is null").all()) {
-            this.db.prepare("update sessions set e2e_key = ? where id = ?").run(newKey(), row.id);
+        this.refresh();
+    }
+    // Opens any project another parley process has added since.
+    refresh() {
+        for (const dir of readProjects()) {
+            if (!this.projects.has(dir) && existsSync(join(parleyDir(dir), "parley.db")))
+                this.projects.set(dir, new ProjectDb(dir));
         }
-        this.db.exec("update sessions set status = 'ended', ended_at = coalesce(ended_at, updated_at) where status not in ('open', 'ended')");
+    }
+    project(dir) {
+        dir = resolve(dir);
+        let db = this.projects.get(dir);
+        if (!db) {
+            mkdirSync(parleyDir(dir), { recursive: true });
+            // Everything in here stays out of git without touching your .gitignore.
+            writeFileSync(join(parleyDir(dir), ".gitignore"), "# parley's conversations, kept out of git\n*\n");
+            db = new ProjectDb(dir);
+            this.projects.set(dir, db);
+            const listed = readProjects();
+            if (!listed.includes(dir))
+                writeFileSync(paths.projects, JSON.stringify([...listed, dir], null, 2) + "\n");
+        }
+        return db;
+    }
+    of(id) {
+        let db = this.where.get(id);
+        if (db)
+            return db;
+        for (const pass of [0, 1]) {
+            if (pass)
+                this.refresh();
+            for (const candidate of this.projects.values()) {
+                if (candidate.session(id)) {
+                    this.where.set(id, candidate);
+                    return candidate;
+                }
+            }
+        }
+        return undefined;
+    }
+    // Whichever project holds a session; for one that doesn't exist, nothing.
+    on(id, fn, fallback) {
+        const db = this.of(id);
+        return db ? fn(db) : fallback;
     }
     createSession(input) {
-        const id = shortId();
+        let id = shortId();
+        while (this.of(id))
+            id = shortId();
+        const db = this.project(input.projectDir);
+        db.createSession(id, input);
+        this.where.set(id, db);
+        this.addMessage(id, "agent", db.session(id).greeting, [], null);
+        return this.session(id);
+    }
+    session(id) {
+        return this.on(id, (db) => db.session(id), undefined);
+    }
+    sessionByToken(token) {
+        for (const pass of [0, 1]) {
+            if (pass)
+                this.refresh();
+            for (const db of this.projects.values()) {
+                const session = db.sessionByToken(token);
+                if (session)
+                    return session;
+            }
+        }
+        return undefined;
+    }
+    sessions(filter = {}) {
+        this.refresh();
+        const dbs = filter.projectDir ? [this.projects.get(resolve(filter.projectDir))].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.
+    deleteSession(id) {
+        const session = this.session(id);
+        if (!session)
+            return;
+        this.of(id).deleteSession(id);
+        this.where.delete(id);
+        rmSync(sessionDir(session), { recursive: true, force: true });
+    }
+    end(id) {
+        this.on(id, (db) => db.end(id), undefined);
+        this.write(id);
+    }
+    setReplyLimit(id, limit) {
+        this.on(id, (db) => db.setReplyLimit(id, limit), undefined);
+    }
+    repliesUsed(id) {
+        return this.on(id, (db) => db.repliesUsed(id), 0);
+    }
+    latestModel(id) {
+        return this.on(id, (db) => db.latestModel(id), null);
+    }
+    markRead(id, messageId) {
+        this.on(id, (db) => db.markRead(id, messageId), undefined);
+    }
+    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);
+        this.write(sessionId);
+        return message;
+    }
+    messages(sessionId, afterId = 0) {
+        return this.on(sessionId, (db) => db.messages(sessionId, afterId), []);
+    }
+    page(sessionId, limit, beforeId) {
+        return this.on(sessionId, (db) => db.page(sessionId, limit, beforeId), { messages: [], more: false });
+    }
+    pending(sessionId) {
+        return this.on(sessionId, (db) => db.pending(sessionId), []);
+    }
+    startTurn(session, messageIds) {
+        return this.of(session.id).startTurn(session, messageIds);
+    }
+    turn(sessionId, id) {
+        return this.on(sessionId, (db) => db.turn(id), undefined);
+    }
+    turns(sessionId) {
+        return this.on(sessionId, (db) => db.turns(sessionId), []);
+    }
+    addActivity(sessionId, turnId, line) {
+        this.on(sessionId, (db) => db.addActivity(turnId, line), undefined);
+    }
+    finishTurn(sessionId, turnId, status, usage, error) {
+        this.on(sessionId, (db) => db.finishTurn(turnId, status, usage, error), undefined);
+    }
+    releaseTurn(sessionId, turnId) {
+        this.on(sessionId, (db) => db.releaseTurn(turnId), undefined);
+    }
+    // Turns that never finished (the server stopped mid-reply), everywhere.
+    recoverInterrupted() {
+        this.refresh();
+        return [...this.projects.values()].flatMap((db) => db.recoverInterrupted());
+    }
+    stats(sessionId) {
+        return this.of(sessionId).stats(sessionId);
+    }
+    // Keeps <session>/transcript.md in step, for you and your agent to read.
+    write(sessionId) {
+        const session = this.session(sessionId);
+        if (!session)
+            return;
+        mkdirSync(sessionDir(session), { recursive: true });
+        writeFileSync(join(sessionDir(session), "transcript.md"), record(this, session));
+    }
+}
+function readProjects() {
+    try {
+        const list = JSON.parse(readFileSync(paths.projects, "utf8"));
+        return Array.isArray(list) ? list.filter((dir) => typeof dir === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}
+// One project's sessions, in <project>/.parley/parley.db.
+class ProjectDb {
+    db;
+    dir;
+    constructor(dir) {
+        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);
+    }
+    // A project that moved still has its sessions; they're wherever it is now.
+    row = (row) => row && { ...row, project_dir: this.dir };
+    createSession(id, input) {
         const token = randomBytes(18).toString("base64url");
-        const projectName = basename(input.projectDir);
+        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.`;
         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)
          values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'open', ?, ?)`)
-            .run(id, token, input.projectDir, projectName, input.tester, input.brief, greeting, input.agent, input.model ?? null, input.replyLimit, newKey(), t, t);
-        this.addMessage(id, "agent", greeting, [], null);
-        return this.session(id);
+            .run(id, token, this.dir, projectName, input.tester, input.brief, greeting, input.agent, input.model ?? null, input.replyLimit, newKey(), t, t);
     }
     session(id) {
-        return this.db.prepare("select * from sessions where id = ?").get(id);
+        return this.row(this.db.prepare("select * from sessions where id = ?").get(id));
     }
     sessionByToken(token) {
-        return this.db.prepare("select * from sessions where token = ?").get(token);
+        return this.row(this.db.prepare("select * from sessions where token = ?").get(token));
     }
-    sessions(filter = {}) {
-        return this.db
-            .prepare(`select * from sessions
-         where (?1 is null or project_dir = ?1) and (?2 is null or status = ?2)
-         order by updated_at desc`)
-            .all(filter.projectDir ?? null, filter.status ?? null);
+    sessions(status) {
+        return this.db.prepare("select * from sessions where (?1 is null or status = ?1)").all(status ?? null).map((r) => this.row(r));
     }
-    // Erases the session: transcript, turns, and screenshots.
     deleteSession(id) {
         this.db.prepare("delete from messages where session_id = ?").run(id);
         this.db.prepare("delete from turns where session_id = ?").run(id);
         this.db.prepare("delete from sessions where id = ?").run(id);
-        for (const name of readdirSync(paths.uploads)) {
-            if (name.startsWith(`${id}-`))
-                rmSync(join(paths.uploads, name), { force: true });
-        }
     }
     end(id) {
         const t = now();

package/dist/relay.js

@@ -1,7 +1,7 @@
-import { writeFileSync, readFileSync, existsSync, readdirSync } from "node:fs";
+import { writeFileSync, readFileSync, existsSync, readdirSync, mkdirSync } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { join } from "node:path";
-import { paths } from "./config.js";
+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";
@@ -230,7 +230,8 @@ export class RelayLink {
         }
         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;
+        const dir = sessionDir(session);
+        const kept = existsSync(dir) ? readdirSync(dir).filter((name) => name.startsWith(`${session.id}-`)).length : 0;
         if (kept >= MAX_SHOTS)
             throw new Problem(429, "too_many", "This session can't take more screenshots.");
         const now = Date.now();
@@ -256,7 +257,8 @@ export class RelayLink {
             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);
+        mkdirSync(sessionDir(session), { recursive: true });
+        writeFileSync(join(sessionDir(session), name), held.bytes);
         return name;
     }
     // A screenshot for a tester's page, encrypted here and sent in pieces.
@@ -267,11 +269,11 @@ export class RelayLink {
             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)))
+            ? Object.values(IMAGE_TYPES).map((ext) => `${session.id}-${id}${ext}`).find((n) => existsSync(join(sessionDir(session), 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)));
+        const sealed = await sealBytes(session.e2e_key, session.token, "blob", 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

@@ -1,6 +1,6 @@
 import { join, extname } from "node:path";
-import { paths } from "./config.js";
 import { charter } from "./charter.js";
+import { sessionDir } from "./db.js";
 import { runClaudeTurn } from "./agents/claude.js";
 import { runCodexTurn } from "./agents/codex.js";
 import { modelLabel } from "./models.js";
@@ -136,7 +136,7 @@ export class Runner {
         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) }))
+            .map((file) => ({ path: join(sessionDir(session), file), mediaType: mediaTypeFor(file) }))
             .filter((image) => image.mediaType);
         const input = { session, config: this.config, charter: charter(session, this.config), text, images };
         const events = {
@@ -151,7 +151,7 @@ export class Runner {
             },
             onActivity: (line) => {
                 live.activity = line;
-                this.store.addActivity(turn.id, line);
+                this.store.addActivity(sessionId, turn.id, line);
                 this.publish(sessionId, { type: "activity", line });
             },
         };
@@ -166,22 +166,22 @@ export class Runner {
         let failed = false;
         run.done
             .then((result) => {
-            this.store.finishTurn(turn.id, "done", result.usage, null);
+            this.store.finishTurn(sessionId, 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.");
+                this.store.finishTurn(sessionId, 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);
+            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(turn.id);
+            this.store.releaseTurn(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);
             this.publish(sessionId, { type: "message", message });

package/dist/server.js

@@ -1,10 +1,10 @@
 import { createServer } from "node:http";
-import { readFileSync, writeFileSync, existsSync, createReadStream } from "node:fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, createReadStream } from "node:fs";
 import { join, extname, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { randomBytes } from "node:crypto";
-import { loadConfig, paths } from "./config.js";
-import { Store } from "./db.js";
+import { loadConfig } from "./config.js";
+import { Store, sessionDir } from "./db.js";
 import { Runner, mediaTypeFor } from "./runner.js";
 import { Conversations, Problem, MAX_TEXT, ownsUpload } from "./api.js";
 import { RelayLink } from "./relay.js";
@@ -184,13 +184,14 @@ export async function serve() {
                     throw new Problem(429, "slow_down", "That's a lot of uploads very fast. Give it a few seconds.");
                 const data = await readBody(req, MAX_UPLOAD);
                 const name = `${session.id}-${randomBytes(9).toString("base64url")}${ext}`;
-                writeFileSync(join(paths.uploads, name), data);
+                mkdirSync(sessionDir(session), { recursive: true });
+                writeFileSync(join(sessionDir(session), name), data);
                 return json(res, { name, url: `${scope.base}/uploads/${name}` });
             }
             const upload = rest.match(/^\/uploads\/([A-Za-z0-9_.-]+)$/);
             if (upload && req.method === "GET") {
                 const name = upload[1];
-                const file = join(paths.uploads, name);
+                const file = join(sessionDir(session), name);
                 if (!ownsUpload(session, name) || !existsSync(file))
                     return notFound(res);
                 res.writeHead(200, { "content-type": mediaTypeFor(name) ?? "application/octet-stream", "cache-control": "private, max-age=86400" });

package/dist/transcript.js

@@ -1,5 +1,5 @@
 import { join } from "node:path";
-import { paths } from "./config.js";
+import { sessionDir } from "./db.js";
 const agentName = (s) => (s.agent === "codex" ? "Codex" : "Claude");
 const time = (iso) => new Date(iso).toLocaleString("en-US", { month: "short", day: "numeric", hour: "numeric", minute: "2-digit" });
 // Which model(s) answered, and on what login, from the recorded turns.
@@ -20,9 +20,20 @@ export function interviewer(store, session) {
 // it marks everything shown as read.
 export function transcript(store, session, link, { onlyNew = false } = {}) {
     const messages = store.messages(session.id, onlyNew ? session.read_through : 0);
+    const text = render(store, session, messages, { link, onlyNew, image: (name) => `Screenshot: ${join(sessionDir(session), name)}` });
+    if (messages.length)
+        store.markRead(session.id, messages.at(-1).id);
+    return text;
+}
+// The whole session for <project>/.parley/<id>/transcript.md, beside its
+// screenshots. Reading it doesn't mark anything read.
+export function record(store, session) {
+    return render(store, session, store.messages(session.id), { link: null, onlyNew: false, image: (name) => `![Screenshot](${name})` });
+}
+function render(store, session, messages, { link, onlyNew, image }) {
     const stats = store.stats(session.id);
     const lines = [];
-    lines.push(`# Feedback from ${session.tester} on ${session.project_name}${onlyNew ? " (new since you last read)" : ""}`, "", `- Session: ${session.id}, ${session.status === "open" ? "open" : `ended ${time(session.ended_at ?? session.updated_at)}, link no longer works`}`, `- Interviewer: ${interviewer(store, session)}, started ${time(session.created_at)}`, `- Project: ${session.project_dir}`, ...(session.status === "open" ? [`- Tester link: ${link}`] : []), `- Messages: ${stats.tester_messages} from ${session.tester}, ${stats.agent_messages} from ${agentName(session)}`, `- Replies: ${stats.replies} of ${session.reply_limit}${spend(stats.cost_usd)}`, "");
+    lines.push(`# Feedback from ${session.tester} on ${session.project_name}${onlyNew ? " (new since you last read)" : ""}`, "", `- Session: ${session.id}, ${session.status === "open" ? "open" : `ended ${time(session.ended_at ?? session.updated_at)}, link no longer works`}`, `- Interviewer: ${interviewer(store, session)}, started ${time(session.created_at)}`, `- Project: ${session.project_dir}`, `- Files: ${sessionDir(session)}`, ...(session.status === "open" && link ? [`- Tester link: ${link}`] : []), `- Messages: ${stats.tester_messages} from ${session.tester}, ${stats.agent_messages} from ${agentName(session)}`, `- Replies: ${stats.replies} of ${session.reply_limit}${spend(stats.cost_usd)}`, "");
     if (!onlyNew)
         lines.push("## Brief", "", session.brief.trim(), "", "## Conversation", "");
     if (!messages.length)
@@ -30,12 +41,10 @@ export function transcript(store, session, link, { onlyNew = false } = {}) {
     for (const m of messages) {
         const who = m.role === "tester" ? session.tester : m.role === "agent" ? agentName(session) : "Parley (error shown to tester)";
         lines.push(`### ${who} · ${time(m.created_at)} · #${m.id}`, "", m.body.trim());
-        for (const image of m.images)
-            lines.push("", `Screenshot: ${join(paths.uploads, image)}`);
+        for (const name of m.images)
+            lines.push("", image(name));
         lines.push("");
     }
-    if (messages.length)
-        store.markRead(session.id, messages.at(-1).id);
     return lines.join("\n");
 }
 const spend = (usd) => (usd ? `, about $${usd.toFixed(2)} at API prices` : "");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parley-im/parley",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Send someone a link. They talk to a read-only Claude or Codex in your project, on your computer, and you get everything they said.",
   "keywords": [
     "claude",