offsite 0.0.6 → 0.0.10

package/apps/server/dist/main.mjs

@@ -1,21 +1,26 @@
-import { createReadStream, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, watch, writeFileSync } from "node:fs";
+import { chmodSync, closeSync, createReadStream, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, watch, writeFileSync } from "node:fs";
 import { createServer } from "node:http";
 import path from "node:path";
 import { consola } from "consola";
+import { renderUnicodeCompact } from "uqr";
 import { WebSocketServer } from "ws";
 import os from "node:os";
 import { deleteSession, forkSession, getSessionMessages, getSubagentMessages, listSessions, query, renameSession } from "@anthropic-ai/claude-agent-sdk";
-import { randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { execFile, spawn } from "node:child_process";
 import readline from "node:readline";
 import { Command } from "@commander-js/extra-typings";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { OpenCode } from "@opencode/client";
 import { ensure, headers } from "@opencode/client/service";
+import { and, eq, inArray, sql } from "drizzle-orm";
 import { DatabaseSync } from "node:sqlite";
+import { drizzle } from "drizzle-orm/node-sqlite";
+import { migrate } from "drizzle-orm/node-sqlite/migrator";
+import webPush from "web-push";
+import { integer, snakeCase, text } from "drizzle-orm/sqlite-core";
 import { lstat, open, readFile, readdir, readlink, stat } from "node:fs/promises";
 import { promisify } from "node:util";
-import webPush from "web-push";
 import { spawn as spawn$1 } from "@lydell/node-pty";
 //#region ../core/src/protocol.ts
 const HOSTED_APP = "https://offsite.sayad.dev";
@@ -47,7 +52,7 @@ function broadcast(event) {
 //#region src/args.ts
 let command = "web";
 let name = null;
-const program = new Command("offsite").description("Starts the server and the web app").option("--host <host>", "Address to listen on", "127.0.0.1").option("--port <port>", "Port to listen on", "47841").option("--dir <dir>", "Folder for settings and accounts", path.join(os.homedir(), ".offsite")).option("--no-auth", "Accept connections without the pairing token").option("--no-pair", "Don't create a pairing token or print pairing links");
+const program = new Command("offsite").description("Starts the server and the web app").option("--host <host>", "Address to listen on", "127.0.0.1").option("--port <port>", "Port to listen on", "47841").option("--dir <dir>", "Folder for settings and accounts", path.join(os.homedir(), ".offsite")).option("--no-auth", "Accept connections without the pairing token").option("--no-pair", "Don't create a pairing token or print pairing links").option("--fallback <url>", "Address to try when this one is unreachable, e.g. a Cloudflare tunnel");
 program.command("web", { isDefault: true }).description("Starts the server and the web app, same as offsite");
 program.command("serve").description("Starts only the server, without the web app").action(() => {
 	command = "serve";
@@ -177,27 +182,6 @@ const defaults = {
 		}
 	}
 };
-const retired = [
-	"theme",
-	"diff",
-	"terminal.font",
-	"terminal.cursor",
-	"terminal.padding",
-	"terminal.scrollback",
-	"terminal.boldIsBright",
-	"terminal.behavior.modernizeShiftEnter",
-	"terminal.behavior.pasteBrowserImages",
-	"terminal.behavior.captureShortcuts",
-	"terminal.behavior.bellFlash",
-	"terminal.behavior.bellSound",
-	"terminal.behavior.clickToMoveCursor",
-	"terminal.behavior.optionAsMeta",
-	"terminal.behavior.confirmCloseBusyTab",
-	"composer.accountId",
-	"composer.model",
-	"composer.effort",
-	"composer.permissionMode"
-];
 const choices = {
 	"composer.provider": [
 		"claude",
@@ -298,7 +282,6 @@ function saveConfig(value) {
 	return value;
 }
 function merge(config, keys, user) {
-	if (retired.includes(keys.join("."))) return config;
 	if (isObject(keys.reduce((value, key) => isObject(value) ? value[key] : void 0, config)) && isObject(user)) {
 		let next = config;
 		for (const [key, value] of Object.entries(user)) next = merge(next, [...keys, key], value);
@@ -343,6 +326,8 @@ function isObject(value) {
 //#endregion
 //#region src/lib/codex/app-server.ts
 const IDLE_LIMIT$3 = 18e5;
+const START_TIMEOUT = 15e3;
+const REQUEST_TIMEOUT = 3e4;
 const codexBaseDir = process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex");
 const servers = /* @__PURE__ */ new Map();
 function appServer(home) {
@@ -400,13 +385,16 @@ var AppServer = class {
 				experimentalApi: true,
 				requestAttestation: false
 			}
-		}).then(() => this.write({ method: "initialized" }));
+		}, START_TIMEOUT).then(() => this.write({ method: "initialized" }), (error) => {
+			this.child.kill();
+			throw error;
+		});
 		this.armIdleTimer();
 	}
 	async request(method, params) {
 		await this.ready;
 		this.armIdleTimer();
-		return await this.call(method, params);
+		return await this.call(method, params, REQUEST_TIMEOUT);
 	}
 	reply(id, result) {
 		this.write({
@@ -428,14 +416,26 @@ var AppServer = class {
 		if (servers.get(this.home) === this) servers.delete(this.home);
 		this.child.stdin.end();
 	}
-	call(method, params) {
+	call(method, params, timeout) {
 		if (this.exited !== null) return Promise.reject(this.exited);
 		this.next += 1;
 		const id = this.next;
-		const result = new Promise((resolve, reject) => this.waiting.set(id, {
-			resolve,
-			reject
-		}));
+		const result = new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.waiting.delete(id);
+				reject(/* @__PURE__ */ new Error(`Codex did not answer ${method} within ${timeout / 1e3} seconds`));
+			}, timeout);
+			this.waiting.set(id, {
+				resolve: (value) => {
+					clearTimeout(timer);
+					resolve(value);
+				},
+				reject: (error) => {
+					clearTimeout(timer);
+					reject(error);
+				}
+			});
+		});
 		this.write({
 			id,
 			method,
@@ -617,7 +617,7 @@ function isMirror(dir) {
 }
 //#endregion
 //#region src/lib/codex/items.ts
-const statuses = {
+const statuses$1 = {
 	inProgress: "running",
 	completed: "completed",
 	failed: "failed",
@@ -683,7 +683,7 @@ function toItems$1(turnId, item, parent, time) {
 			command: item.command,
 			description: "",
 			output: item.aggregatedOutput ?? "",
-			status: statuses[item.status],
+			status: statuses$1[item.status],
 			background: null
 		}];
 		case "fileChange": return item.changes.map((change, index) => ({
@@ -699,7 +699,7 @@ function toItems$1(turnId, item, parent, time) {
 				after: ""
 			}] : hunks(change.diff),
 			output: "",
-			status: statuses[item.status]
+			status: statuses$1[item.status]
 		}));
 		case "mcpToolCall": return [{
 			...base,
@@ -707,7 +707,7 @@ function toItems$1(turnId, item, parent, time) {
 			name: `${item.server}.${item.tool}`,
 			input: record$1(item.arguments),
 			output: item.error?.message ?? (item.result === null ? "" : contentText$1(item.result.content)),
-			status: statuses[item.status]
+			status: statuses$1[item.status]
 		}];
 		case "dynamicToolCall": return [{
 			...base,
@@ -715,7 +715,7 @@ function toItems$1(turnId, item, parent, time) {
 			name: item.tool,
 			input: record$1(item.arguments),
 			output: contentText$1(item.contentItems ?? []),
-			status: statuses[item.status]
+			status: statuses$1[item.status]
 		}];
 		case "collabAgentToolCall":
 			if (item.tool === "spawnAgent") return [{
@@ -724,14 +724,14 @@ function toItems$1(turnId, item, parent, time) {
 				agent: item.model ?? "Agent",
 				description: item.prompt ?? "",
 				agentId: item.receiverThreadIds[0] ?? null,
-				status: statuses[item.status]
+				status: statuses$1[item.status]
 			}];
 			return [{
 				...base,
 				kind: "agent_message",
 				target: item.receiverThreadIds[0] ?? null,
 				summary: item.prompt ?? item.tool,
-				status: statuses[item.status]
+				status: statuses$1[item.status]
 			}];
 		case "webSearch": return [{
 			...base,
@@ -974,6 +974,7 @@ var CodexRun = class CodexRun {
 	prompted = false;
 	backgroundTasks = 0;
 	tasks = {};
+	activeAt = Date.now();
 	model;
 	close;
 	turnId = null;
@@ -1078,11 +1079,12 @@ var CodexRun = class CodexRun {
 		this.server.request("thread/unsubscribe", { threadId: this.sessionId }).catch((error) => console.warn(`could not unload Codex thread: ${error}`)).finally(() => this.end());
 	}
 	exited() {
-		this.put(errorItem(randomUUID(), "Codex stopped"));
+		this.put(errorItem(randomUUID(), this.pending.size === 0 ? "Codex stopped" : "Codex stopped, its open requests expired"));
 		if (runs.get(this.sessionId) === this) runs.delete(this.sessionId);
 		this.end();
 	}
 	notify(method, params) {
+		this.activeAt = Date.now();
 		switch (method) {
 			case "turn/started": {
 				const turn = params.turn;
@@ -1437,23 +1439,67 @@ async function readThread(threadId) {
 	})).thread;
 }
 //#endregion
+//#region src/storage/schema.ts
+const machine = snakeCase.table("machine", {
+	id: text().primaryKey(),
+	pushPublicKey: text().notNull(),
+	pushPrivateKey: text().notNull()
+});
+const projects$2 = snakeCase.table("projects", {
+	id: text().primaryKey(),
+	path: text().notNull().unique(),
+	name: text().notNull(),
+	logo: text()
+});
+const sessions$1 = snakeCase.table("sessions", {
+	sessionId: text().primaryKey(),
+	interactedAt: integer(),
+	status: text({ enum: [
+		"active",
+		"pinned",
+		"minimized"
+	] }).notNull()
+});
+const tokens = snakeCase.table("tokens", {
+	hash: text().primaryKey(),
+	name: text(),
+	createdAt: integer().notNull(),
+	lastUsedAt: integer()
+});
+const pushSubscriptions = snakeCase.table("push_subscriptions", {
+	endpoint: text().primaryKey(),
+	p256dh: text().notNull(),
+	auth: text().notNull(),
+	server: text().notNull()
+});
+//#endregion
 //#region src/storage/db.ts
-const db = new DatabaseSync(path.join(home, "offsite.db"));
-db.exec(`
-  CREATE TABLE IF NOT EXISTS projects (
-    path TEXT PRIMARY KEY,
-    name TEXT NOT NULL,
-    logo TEXT
-  )
-`);
-db.exec("DROP TABLE IF EXISTS prompts");
-db.exec(`
-  CREATE TABLE IF NOT EXISTS sessions (
-    session_id TEXT PRIMARY KEY,
-    interacted_at INTEGER,
-    status TEXT NOT NULL CHECK (status IN ('active', 'pinned', 'minimized'))
-  )
+const file = path.join(home, "offsite.db");
+closeSync(openSync(file, "a", 384));
+chmodSync(file, 384);
+const client = new DatabaseSync(file);
+client.exec(`
+  PRAGMA journal_mode = WAL;
+  PRAGMA busy_timeout = 5000;
+  PRAGMA synchronous = NORMAL;
+  PRAGMA foreign_keys = ON;
 `);
+const db = drizzle({ client });
+migrate(db, { migrationsFolder: path.join(serverDir, "drizzle") });
+db.transaction((tx) => {
+	if (tx.select().from(machine).get() !== void 0) return;
+	const keys = webPush.generateVAPIDKeys();
+	tx.insert(machine).values({
+		id: randomUUID(),
+		pushPublicKey: keys.publicKey,
+		pushPrivateKey: keys.privateKey
+	}).run();
+}, { behavior: "immediate" });
+function machineInfo() {
+	const row = db.select().from(machine).get();
+	if (row === void 0) throw new Error("the machine row is missing");
+	return row;
+}
 //#endregion
 //#region src/services/projects.ts
 const LOGO_TYPES = [
@@ -1467,32 +1513,42 @@ const LOGO_TYPES = [
 ];
 const LOGO_LIMIT = 524288;
 function projects$1() {
-	return db.prepare("SELECT path, name, logo FROM projects").all().map(toProject);
+	return db.select().from(projects$2).all();
+}
+function projectPath(id) {
+	const project = db.select().from(projects$2).where(eq(projects$2.id, id)).get();
+	if (project === void 0) throw new Error("That project was removed");
+	return project.path;
 }
 async function addProject(input) {
 	const folder = path.resolve(expandHome(input.trim()));
 	if (!(await stat(folder)).isDirectory()) throw new Error(`${folder} is not a folder`);
-	db.prepare("INSERT OR IGNORE INTO projects (path, name, logo) VALUES (?, ?, NULL)").run(folder, path.basename(folder) || folder);
+	db.insert(projects$2).values({
+		id: randomUUID(),
+		path: folder,
+		name: path.basename(folder) || folder,
+		logo: null
+	}).onConflictDoNothing({ target: projects$2.path }).run();
 	publish$1();
 	const project = projects$1().find((item) => item.path === folder);
 	if (project === void 0) throw new Error(`Could not add ${folder}`);
 	return project;
 }
-function updateProject(folder, patch) {
+function updateProject(id, patch) {
 	if (patch.name !== void 0) {
 		const name = patch.name.trim();
 		if (name === "") throw new Error("Project name cannot be empty");
-		db.prepare("UPDATE projects SET name = ? WHERE path = ?").run(name, folder);
+		db.update(projects$2).set({ name }).where(eq(projects$2.id, id)).run();
 	}
 	if (patch.logo !== void 0) {
 		if (patch.logo !== null) checkLogo(patch.logo);
-		db.prepare("UPDATE projects SET logo = ? WHERE path = ?").run(patch.logo, folder);
+		db.update(projects$2).set({ logo: patch.logo }).where(eq(projects$2.id, id)).run();
 	}
 	publish$1();
 	return null;
 }
-function removeProject(folder) {
-	db.prepare("DELETE FROM projects WHERE path = ?").run(folder);
+function removeProject(id) {
+	db.delete(projects$2).where(eq(projects$2.id, id)).run();
 	publish$1();
 }
 async function directories(input) {
@@ -1514,14 +1570,6 @@ function publish$1() {
 		projects: projects$1()
 	});
 }
-function toProject(row) {
-	if (typeof row.path !== "string" || typeof row.name !== "string" || typeof row.logo !== "string" && row.logo !== null) throw new Error("The projects table has an unexpected row");
-	return {
-		path: row.path,
-		name: row.name,
-		logo: row.logo
-	};
-}
 function checkLogo(logo) {
 	const type = /^data:([^;,]+);base64,/.exec(logo)?.[1];
 	if (type === void 0 || !LOGO_TYPES.includes(type)) throw new Error("Use a PNG, JPEG, GIF, WebP, SVG or ICO image");
@@ -1535,54 +1583,43 @@ function expandHome(input) {
 //#endregion
 //#region src/services/sessions.ts
 const day = 864e5;
+const LIST_TIMEOUT = 1e4;
+const REFRESH_DELAY = 1e3;
+const allProviders = [
+	"claude",
+	"codex",
+	"opencode"
+];
+const listed = {
+	claude: [],
+	codex: [],
+	opencode: []
+};
+const statuses = {
+	claude: {
+		provider: "claude",
+		state: "loading",
+		error: null
+	},
+	codex: {
+		provider: "codex",
+		state: "loading",
+		error: null
+	},
+	opencode: {
+		provider: "opencode",
+		state: "loading",
+		error: null
+	}
+};
+const refreshing = /* @__PURE__ */ new Map();
+const timers = /* @__PURE__ */ new Map();
 const providers = /* @__PURE__ */ new Map();
 let watchers = [];
-let timer;
-async function sessions() {
-	const records = readRecords();
-	const paths = projects$1().map((project) => project.path);
-	const [claude, codex, opencode] = await Promise.all([
-		Promise.all(paths.map(async (cwd) => (await listSessions({
-			dir: cwd,
-			includeWorktrees: false,
-			includeProgrammatic: false
-		})).map((item) => ({
-			id: item.sessionId,
-			provider: "claude",
-			title: item.summary,
-			cwd,
-			branch: item.gitBranch ?? null,
-			updatedAt: item.lastModified
-		})))),
-		codexThreads(paths).catch((error) => {
-			console.warn(`could not list Codex threads: ${error}`);
-			return [];
-		}),
-		openCodeSessions(paths).catch((error) => {
-			console.warn(`could not list OpenCode sessions: ${error}`);
-			return [];
-		})
-	]);
-	return [
-		...claude.flat(),
-		...codex.map((thread) => ({
-			id: thread.id,
-			provider: "codex",
-			title: thread.name ?? thread.preview,
-			cwd: thread.cwd,
-			branch: thread.gitInfo?.branch ?? null,
-			updatedAt: thread.updatedAt * 1e3
-		})),
-		...opencode.map((session) => ({
-			id: session.id,
-			provider: "opencode",
-			title: session.title ?? "New session",
-			cwd: session.location.directory,
-			branch: null,
-			updatedAt: session.time.updated
-		}))
-	].map((item) => {
-		providers.set(item.id, item.provider);
+function sessions() {
+	const records = new Map(db.select().from(sessions$1).all().map((record) => [record.sessionId, record]));
+	const known = new Set(projects$1().map((project) => project.id));
+	return allProviders.flatMap((provider) => listed[provider].filter((item) => known.has(item.projectId)).map((item) => {
 		const record = records.get(item.id);
 		const updatedAt = record?.interactedAt ?? item.updatedAt;
 		return {
@@ -1590,7 +1627,13 @@ async function sessions() {
 			updatedAt,
 			status: record === void 0 || record.status === "active" && Date.now() - updatedAt > day ? "inactive" : record.status
 		};
-	});
+	}));
+}
+function providerStatuses() {
+	return allProviders.map((provider) => statuses[provider]);
+}
+function listedUpdatedAt(provider, sessionId) {
+	return listed[provider].find((item) => item.id === sessionId)?.updatedAt ?? null;
 }
 function providerOf(sessionId) {
 	const provider = runs.get(sessionId)?.provider ?? providers.get(sessionId);
@@ -1598,23 +1641,138 @@ function providerOf(sessionId) {
 	return provider;
 }
 function recordInteraction(id) {
-	db.prepare("INSERT INTO sessions (session_id, interacted_at, status) VALUES (?, ?, 'active') ON CONFLICT (session_id) DO UPDATE SET interacted_at = excluded.interacted_at, status = CASE status WHEN 'pinned' THEN 'pinned' WHEN 'minimized' THEN 'minimized' ELSE 'active' END").run(id, Date.now());
+	db.insert(sessions$1).values({
+		sessionId: id,
+		interactedAt: Date.now(),
+		status: "active"
+	}).onConflictDoUpdate({
+		target: sessions$1.sessionId,
+		set: {
+			interactedAt: Date.now(),
+			status: sql`CASE ${sessions$1.status} WHEN 'pinned' THEN 'pinned' WHEN 'minimized' THEN 'minimized' ELSE 'active' END`
+		}
+	}).run();
+}
+function publishSessions() {
+	broadcast({
+		type: "sessions",
+		sessions: sessions()
+	});
+}
+function refreshAll() {
+	for (const provider of allProviders) refresh(provider);
+}
+function refreshSessions(provider) {
+	if (timers.has(provider)) return;
+	timers.set(provider, setTimeout(() => {
+		timers.delete(provider);
+		refresh(provider);
+	}, REFRESH_DELAY));
+}
+async function refresh(provider) {
+	const current = refreshing.get(provider);
+	if (current !== void 0) {
+		current.again = true;
+		return;
+	}
+	const entry = { again: true };
+	refreshing.set(provider, entry);
+	while (entry.again) {
+		entry.again = false;
+		await list$1(provider);
+	}
+	refreshing.delete(provider);
 }
-async function publishSessions() {
+async function list$1(provider) {
+	const paths = new Map(projects$1().map((project) => [project.path, project.id]));
+	const before = statuses[provider];
+	let timer;
 	try {
-		broadcast({
-			type: "sessions",
-			sessions: await sessions()
-		});
+		const found = await Promise.race([find(provider, paths), new Promise((_, reject) => {
+			timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`${providerName(provider)} did not list its sessions within ${LIST_TIMEOUT / 1e3} seconds`)), LIST_TIMEOUT);
+		})]);
+		if (found === null) {
+			listed[provider] = [];
+			statuses[provider] = {
+				provider,
+				state: "missing",
+				error: null
+			};
+		} else {
+			listed[provider] = found;
+			statuses[provider] = {
+				provider,
+				state: "ready",
+				error: null
+			};
+			for (const item of found) providers.set(item.id, provider);
+		}
 	} catch (error) {
-		console.warn(`could not list threads: ${error}`);
+		const message = error instanceof Error ? error.message : String(error);
+		console.warn(`could not list ${providerName(provider)} sessions: ${message}`);
+		statuses[provider] = {
+			provider,
+			state: "error",
+			error: message
+		};
+	} finally {
+		clearTimeout(timer);
+	}
+	publishSessions();
+	if (JSON.stringify(statuses[provider]) !== JSON.stringify(before)) broadcast({
+		type: "providers",
+		providers: providerStatuses()
+	});
+}
+async function find(provider, paths) {
+	switch (provider) {
+		case "claude": return (await Promise.all([...paths].map(async ([cwd, projectId]) => (await listSessions({
+			dir: cwd,
+			includeWorktrees: false,
+			includeProgrammatic: false
+		})).map((item) => ({
+			id: item.sessionId,
+			provider: "claude",
+			title: item.summary,
+			projectId,
+			branch: item.gitBranch ?? null,
+			updatedAt: item.lastModified
+		}))))).flat();
+		case "codex":
+			if (!codexInstalled()) return null;
+			return (await codexThreads([...paths.keys()])).flatMap((thread) => {
+				const projectId = paths.get(thread.cwd);
+				if (projectId === void 0) return [];
+				return [{
+					id: thread.id,
+					provider: "codex",
+					title: thread.name ?? thread.preview,
+					projectId,
+					branch: thread.gitInfo?.branch ?? null,
+					updatedAt: thread.updatedAt * 1e3
+				}];
+			});
+		case "opencode":
+			if (!openCodeInstalled()) return null;
+			return (await openCodeSessions([...paths.keys()])).flatMap((session) => {
+				const projectId = paths.get(session.location.directory);
+				if (projectId === void 0) return [];
+				return [{
+					id: session.id,
+					provider: "opencode",
+					title: session.title ?? "New session",
+					projectId,
+					branch: null,
+					updatedAt: session.time.updated
+				}];
+			});
 	}
 }
 function watchSessions() {
 	for (const watcher of watchers) watcher.close();
-	watchers = [path.join(readConfig().claudeBaseDir, "projects"), path.join(codexBaseDir, "sessions")].flatMap((dir) => {
+	watchers = [["claude", path.join(readConfig().claudeBaseDir, "projects")], ["codex", path.join(codexBaseDir, "sessions")]].flatMap(([provider, dir]) => {
 		try {
-			const watcher = watch(dir, { recursive: true }, refreshSessions);
+			const watcher = watch(dir, { recursive: true }, () => refreshSessions(provider));
 			watcher.on("error", (error) => console.warn(`stopped watching ${dir}: ${error}`));
 			return [watcher];
 		} catch (error) {
@@ -1623,12 +1781,6 @@ function watchSessions() {
 		}
 	});
 }
-function refreshSessions() {
-	timer ??= setTimeout(() => {
-		timer = void 0;
-		publishSessions();
-	}, 1e3);
-}
 async function updateSession(id, patch) {
 	if (patch.title !== void 0) switch (providerOf(id)) {
 		case "claude":
@@ -1639,8 +1791,15 @@ async function updateSession(id, patch) {
 			break;
 		case "opencode": await renameOpenCode(id, patch.title);
 	}
-	if (patch.status === "inactive") db.prepare("DELETE FROM sessions WHERE session_id = ?").run(id);
-	else if (patch.status !== void 0) db.prepare("INSERT INTO sessions (session_id, status) VALUES (?, ?) ON CONFLICT (session_id) DO UPDATE SET status = excluded.status").run(id, patch.status);
+	if (patch.status === "inactive") db.delete(sessions$1).where(eq(sessions$1.sessionId, id)).run();
+	else if (patch.status !== void 0) db.insert(sessions$1).values({
+		sessionId: id,
+		status: patch.status
+	}).onConflictDoUpdate({
+		target: sessions$1.sessionId,
+		set: { status: patch.status }
+	}).run();
+	if (patch.title !== void 0) refreshSessions(providerOf(id));
 }
 async function removeSession(id) {
 	const provider = providerOf(id);
@@ -1658,13 +1817,15 @@ async function removeSession(id) {
 			break;
 		case "opencode": await removeOpenCode(id);
 	}
-	db.prepare("DELETE FROM sessions WHERE session_id = ?").run(id);
+	db.delete(sessions$1).where(eq(sessions$1.sessionId, id)).run();
+	listed[provider] = listed[provider].filter((item) => item.id !== id);
 }
-async function fork(sessionId, cwd, messageId) {
+async function fork(sessionId, projectId, messageId) {
 	const provider = providerOf(sessionId);
-	const result = await forkWith(provider, sessionId, cwd, messageId);
+	const result = await forkWith(provider, sessionId, projectPath(projectId), messageId);
 	providers.set(result.sessionId, provider);
 	recordInteraction(result.sessionId);
+	refreshSessions(provider);
 	return result;
 }
 async function forkWith(provider, sessionId, cwd, messageId) {
@@ -1676,17 +1837,6 @@ async function forkWith(provider, sessionId, cwd, messageId) {
 		upToMessageId: messageId
 	})).sessionId };
 }
-function readRecords() {
-	const records = /* @__PURE__ */ new Map();
-	for (const row of db.prepare("SELECT session_id, interacted_at, status FROM sessions").all()) {
-		if (typeof row.session_id !== "string" || typeof row.interacted_at !== "number" && row.interacted_at !== null || row.status !== "active" && row.status !== "pinned" && row.status !== "minimized") throw new Error("The sessions table has an unexpected row");
-		records.set(row.session_id, {
-			interactedAt: row.interacted_at,
-			status: row.status
-		});
-	}
-	return records;
-}
 //#endregion
 //#region src/lib/opencode/client.ts
 const listChanges = /* @__PURE__ */ new Set([
@@ -1699,6 +1849,9 @@ const listChanges = /* @__PURE__ */ new Set([
 	"session.execution.failed",
 	"session.execution.interrupted"
 ]);
+const SILENCE_LIMIT$1 = 45e3;
+const RECONNECT_ATTEMPTS = 5;
+const RECONNECT_DELAY = 2e3;
 let connection;
 function findOpenCode() {
 	const name = process.platform === "win32" ? "opencode.exe" : "opencode";
@@ -1709,16 +1862,12 @@ function findOpenCode() {
 	return null;
 }
 function openCode() {
-	connection ??= connect();
+	connection ??= start();
 	return connection;
 }
-async function connect() {
+async function start() {
 	try {
-		const endpoint = await ensure();
-		const client = OpenCode.make({
-			baseUrl: endpoint.url,
-			headers: headers(endpoint)
-		});
+		const client = await connect();
 		listen(client);
 		return client;
 	} catch (error) {
@@ -1726,27 +1875,61 @@ async function connect() {
 		throw error;
 	}
 }
+async function connect() {
+	const endpoint = await ensure();
+	return OpenCode.make({
+		baseUrl: endpoint.url,
+		headers: headers(endpoint)
+	});
+}
 async function listen(client) {
+	const controller = new AbortController();
+	const silence = setTimeout(() => controller.abort(), SILENCE_LIMIT$1);
 	try {
-		for await (const event of client.event.subscribe()) route(event);
+		for await (const event of client.event.subscribe({
+			signal: controller.signal,
+			onActivity: () => silence.refresh()
+		})) route(event);
 		console.warn("the OpenCode event stream ended");
 	} catch (error) {
-		console.warn(`lost the OpenCode event stream: ${error}`);
+		console.warn(controller.signal.aborted ? `the OpenCode event stream was silent for ${SILENCE_LIMIT$1 / 1e3} seconds` : `lost the OpenCode event stream: ${error}`);
+	} finally {
+		clearTimeout(silence);
+	}
+	connection = reconnect();
+	connection.catch(() => void 0);
+}
+async function reconnect() {
+	let failure;
+	for (let attempt = 0; attempt < RECONNECT_ATTEMPTS; attempt++) {
+		await setTimeout$1(RECONNECT_DELAY);
+		let client;
+		try {
+			client = await connect();
+		} catch (error) {
+			failure = error;
+			continue;
+		}
+		listen(client);
+		await catchUp(client).catch((error) => console.warn(`could not catch up with OpenCode: ${error}`));
+		return client;
 	}
+	console.warn(`could not reconnect to OpenCode: ${failure}`);
 	connection = void 0;
-	if (openCodeRuns().length === 0) return;
-	await setTimeout$1(1e3);
-	try {
-		const active = await (await openCode()).session.active();
-		for (const run of openCodeRuns()) run.resync(run.sessionId in active);
-		refreshSessions();
-	} catch (error) {
-		console.warn(`could not reconnect to OpenCode: ${error}`);
-		for (const run of openCodeRuns()) run.exited();
+	for (const run of openCodeRuns()) run.exited();
+	refreshSessions("opencode");
+	throw failure;
+}
+async function catchUp(client) {
+	const active = await client.session.active();
+	for (const run of openCodeRuns()) {
+		const [permissions, forms] = await Promise.all([client.permission.request.list({ location: { directory: run.cwd } }), client.session.form.list({ sessionID: run.sessionId })]);
+		run.reconcile(client, run.sessionId in active, permissions.data.filter((permission) => permission.sessionID === run.sessionId), forms);
 	}
+	refreshSessions("opencode");
 }
 function route(event) {
-	if (listChanges.has(event.type)) refreshSessions();
+	if (listChanges.has(event.type)) refreshSessions("opencode");
 	const sessionId = sessionOf(event);
 	if (sessionId === null) return;
 	const run = runs.get(sessionId);
@@ -1887,8 +2070,8 @@ function toolItems(base, tool) {
 		case "shell": return [{
 			...base,
 			kind: "command",
-			command: text$1(input.command),
-			description: text$1(input.description),
+			command: text$2(input.command),
+			description: text$2(input.description),
 			output,
 			status,
 			background: null
@@ -1896,10 +2079,10 @@ function toolItems(base, tool) {
 		case "edit": return [{
 			...base,
 			kind: "file_change",
-			path: text$1(input.path ?? input.filePath),
+			path: text$2(input.path ?? input.filePath),
 			diffs: [{
-				before: text$1(input.oldString),
-				after: text$1(input.newString)
+				before: text$2(input.oldString),
+				after: text$2(input.newString)
 			}],
 			output,
 			status
@@ -1907,10 +2090,10 @@ function toolItems(base, tool) {
 		case "write": return [{
 			...base,
 			kind: "file_change",
-			path: text$1(input.path ?? input.filePath),
+			path: text$2(input.path ?? input.filePath),
 			diffs: [{
 				before: "",
-				after: text$1(input.content)
+				after: text$2(input.content)
 			}],
 			output,
 			status
@@ -1922,8 +2105,8 @@ function toolItems(base, tool) {
 				...base,
 				id: `${base.id}:${index}`,
 				kind: "file_change",
-				path: text$1(record(file).file),
-				diffs: hunks(text$1(record(file).patch)),
+				path: text$2(record(file).file),
+				diffs: hunks(text$2(record(file).patch)),
 				output,
 				status
 			}));
@@ -1931,16 +2114,16 @@ function toolItems(base, tool) {
 			...base,
 			kind: "todo_list",
 			steps: list(input.todos).map((todo) => ({
-				text: text$1(record(todo).content),
-				status: todoStatuses$1[text$1(record(todo).status)] ?? "pending"
+				text: text$2(record(todo).content),
+				status: todoStatuses$1[text$2(record(todo).status)] ?? "pending"
 			}))
 		}];
 		case "subagent":
 		case "task": return [{
 			...base,
 			kind: "subagent",
-			agent: text$1(input.agent ?? input.subagent_type) || "Agent",
-			description: text$1(input.description),
+			agent: text$2(input.agent ?? input.subagent_type) || "Agent",
+			description: text$2(input.description),
 			agentId: typeof metadata.sessionID === "string" ? metadata.sessionID : null,
 			status
 		}];
@@ -1948,20 +2131,20 @@ function toolItems(base, tool) {
 		case "websearch": return [{
 			...base,
 			kind: "web_search",
-			query: tool.name === "websearch" ? text$1(input.query) : null,
-			url: tool.name === "webfetch" ? text$1(input.url) : null,
+			query: tool.name === "websearch" ? text$2(input.query) : null,
+			url: tool.name === "webfetch" ? text$2(input.url) : null,
 			results: [],
 			output,
 			status
 		}];
 		case "question": {
 			const questions = list(input.questions).map((item) => ({
-				question: text$1(record(item).question),
-				header: text$1(record(item).header),
+				question: text$2(record(item).question),
+				header: text$2(record(item).header),
 				multiSelect: record(item).multiple === true,
 				options: list(record(item).options).map((option) => ({
-					label: text$1(record(option).label),
-					description: text$1(record(option).description)
+					label: text$2(record(option).label),
+					description: text$2(record(option).description)
 				}))
 			}));
 			const answers = metadata.answers;
@@ -1969,14 +2152,14 @@ function toolItems(base, tool) {
 				...base,
 				kind: "question",
 				questions,
-				answers: Array.isArray(answers) ? Object.fromEntries(questions.map((question, index) => [question.question, list(answers[index]).map(text$1).join(", ")])) : null,
+				answers: Array.isArray(answers) ? Object.fromEntries(questions.map((question, index) => [question.question, list(answers[index]).map(text$2).join(", ")])) : null,
 				status
 			}];
 		}
 		case "skill": return [{
 			...base,
 			kind: "skill",
-			skill: text$1(input.name),
+			skill: text$2(input.name),
 			output,
 			status
 		}];
@@ -2017,7 +2200,7 @@ function optionValue(options, label) {
 function contentText(content) {
 	return content.map((block) => block.type === "text" ? block.text : block.uri).join("\n");
 }
-function text$1(value) {
+function text$2(value) {
 	return typeof value === "string" ? value : "";
 }
 function list(value) {
@@ -2255,28 +2438,24 @@ var OpenCodeRun = class OpenCodeRun {
 	prompted = false;
 	backgroundTasks = 0;
 	tasks = {};
-	client;
 	close;
 	applied;
 	loading = Promise.resolve();
 	refreshTimer;
 	idleTimer;
 	static async start(cwd, settings) {
-		const client = await openCode();
-		const session = await client.session.create({
+		const session = await (await openCode()).session.create({
 			location: { directory: cwd },
 			...settings.mode === null ? {} : { agent: settings.mode },
 			...settings.model === null ? {} : { model: modelRef(settings.model, settings.effort) }
 		});
-		return new OpenCodeRun(client, session.id, cwd, settings, settings);
+		return new OpenCodeRun(session.id, cwd, settings, settings);
 	}
 	static async resume(sessionId, cwd, settings) {
-		const client = await openCode();
-		const session = await client.session.get({ sessionID: sessionId });
-		return new OpenCodeRun(client, sessionId, cwd, settings, sessionSettings(session, settings));
+		const session = await (await openCode()).session.get({ sessionID: sessionId });
+		return new OpenCodeRun(sessionId, cwd, settings, sessionSettings(session, settings));
 	}
-	constructor(client, sessionId, cwd, settings, applied) {
-		this.client = client;
+	constructor(sessionId, cwd, settings, applied) {
 		this.sessionId = sessionId;
 		this.cwd = cwd;
 		this.settings = settings;
@@ -2294,7 +2473,7 @@ var OpenCodeRun = class OpenCodeRun {
 		}
 		switch (delivery) {
 			case "steer":
-				await this.client.session.prompt({
+				await (await openCode()).session.prompt({
 					sessionID: this.sessionId,
 					text: prompt.text,
 					files: files(prompt),
@@ -2331,7 +2510,7 @@ var OpenCodeRun = class OpenCodeRun {
 		});
 	}
 	async interrupt() {
-		await this.client.session.interrupt({ sessionID: this.sessionId });
+		await (await openCode()).session.interrupt({ sessionID: this.sessionId });
 	}
 	stopTask() {
 		throw new Error("OpenCode has no background tasks to stop");
@@ -2340,16 +2519,17 @@ var OpenCodeRun = class OpenCodeRun {
 		const pending = this.pending.get(requestId);
 		if (pending === void 0) return;
 		const sessionID = this.sessionId;
-		if (pending.kind === "permission") await this.client.permission.reply({
+		const client = await openCode();
+		if (pending.kind === "permission") await client.permission.reply({
 			sessionID,
 			requestID: requestId,
 			decision: replies[decision]
 		});
-		else if (decision === "deny") await this.client.session.form.cancel({
+		else if (decision === "deny") await client.session.form.cancel({
 			sessionID,
 			formID: requestId
 		});
-		else await this.client.session.form.reply({
+		else await client.session.form.reply({
 			sessionID,
 			formID: requestId,
 			answer: formAnswer(pending.form, answers ?? {})
@@ -2361,11 +2541,15 @@ var OpenCodeRun = class OpenCodeRun {
 		this.end();
 	}
 	exited() {
-		this.put([errorItem(randomUUID(), "Lost the connection to OpenCode")]);
+		this.put([errorItem(randomUUID(), this.pending.size === 0 ? "Lost the connection to OpenCode" : "Lost the connection to OpenCode, its open requests expired")]);
 		this.stop();
 	}
-	resync(active) {
-		this.refresh();
+	reconcile(client, active, permissions, forms) {
+		this.refresh(client);
+		const open = /* @__PURE__ */ new Set([...permissions.map((permission) => permission.id), ...forms.map((form) => form.id)]);
+		for (const requestId of [...this.pending.keys()]) if (!open.has(requestId)) this.settle(requestId);
+		for (const permission of permissions) if (!this.pending.has(permission.id)) this.ask(permission);
+		for (const form of forms) if (!this.pending.has(form.id)) this.askForm(form);
 		if (this.running && !active) this.finishTurn();
 	}
 	receive(event) {
@@ -2401,15 +2585,7 @@ var OpenCodeRun = class OpenCodeRun {
 				this.settle(event.data.requestID);
 				return;
 			case "form.created":
-				this.addPending({
-					kind: "form",
-					request: {
-						id: event.data.form.id,
-						kind: "question",
-						questions: formQuestions(event.data.form)
-					},
-					form: event.data.form
-				});
+				this.askForm(event.data.form);
 				return;
 			case "form.replied":
 			case "form.cancelled":
@@ -2420,18 +2596,18 @@ var OpenCodeRun = class OpenCodeRun {
 				this.refreshTimer = setTimeout(() => this.refresh(), 100);
 		}
 	}
-	refresh() {
+	refresh(client) {
 		clearTimeout(this.refreshTimer);
-		this.loading = this.loading.then(() => this.load()).catch((error) => console.warn(`could not load OpenCode messages: ${error}`));
+		this.loading = this.loading.then(async () => this.load(client ?? await openCode())).catch((error) => console.warn(`could not load OpenCode messages: ${error}`));
 	}
-	async load() {
-		const messages = (await this.client.message.list({
+	async load(client) {
+		const messages = (await client.message.list({
 			sessionID: this.sessionId,
 			limit: RECENT,
 			order: "desc"
 		})).data.toReversed();
 		this.put(messages.flatMap((message) => messageItems(message, null)).filter((item) => JSON.stringify(this.items.get(item.id)) !== JSON.stringify(item)));
-		const context = await contextOf(this.client, this.cwd, messages);
+		const context = await contextOf(client, this.cwd, messages);
 		if (context === null || context.tokens === this.context?.tokens) return;
 		this.context = context;
 		publish$2(this.sessionId, {
@@ -2456,16 +2632,17 @@ var OpenCodeRun = class OpenCodeRun {
 		}
 	}
 	async send(prompt) {
+		const client = await openCode();
 		const sessionID = this.sessionId;
 		const location = { directory: this.cwd };
 		const match = /^\/(\S+)\s*([\s\S]*)$/.exec(prompt.text);
 		if (match !== null) {
 			if (match[1] === "compact" && prompt.images.length === 0) {
-				await this.client.session.compact({ sessionID });
+				await client.session.compact({ sessionID });
 				return;
 			}
-			if ((await this.client.command.list({ location })).data.some((command) => command.name === match[1])) {
-				await this.client.session.command({
+			if ((await client.command.list({ location })).data.some((command) => command.name === match[1])) {
+				await client.session.command({
 					sessionID,
 					name: match[1],
 					text: match[2],
@@ -2473,9 +2650,9 @@ var OpenCodeRun = class OpenCodeRun {
 				});
 				return;
 			}
-			const skill = (await this.client.skill.list({ location })).data.find((item) => item.name === match[1]);
+			const skill = (await client.skill.list({ location })).data.find((item) => item.name === match[1]);
 			if (skill !== void 0) {
-				await this.client.session.prompt({
+				await client.session.prompt({
 					sessionID,
 					text: match[2],
 					files: files(prompt),
@@ -2484,20 +2661,21 @@ var OpenCodeRun = class OpenCodeRun {
 				return;
 			}
 		}
-		await this.client.session.prompt({
+		await client.session.prompt({
 			sessionID,
 			text: prompt.text,
 			files: files(prompt)
 		});
 	}
 	async apply() {
+		const client = await openCode();
 		const settings = this.settings;
 		const model = settings.model ?? this.applied.model;
-		if (model !== null && (model !== this.applied.model || settings.effort !== this.applied.effort)) await this.client.session.switchModel({
+		if (model !== null && (model !== this.applied.model || settings.effort !== this.applied.effort)) await client.session.switchModel({
 			sessionID: this.sessionId,
 			model: modelRef(model, settings.effort)
 		});
-		if (settings.mode !== null && settings.mode !== this.applied.mode) await this.client.session.switchAgent({
+		if (settings.mode !== null && settings.mode !== this.applied.mode) await client.session.switchAgent({
 			sessionID: this.sessionId,
 			agent: settings.mode
 		});
@@ -2530,6 +2708,17 @@ var OpenCodeRun = class OpenCodeRun {
 			}
 		});
 	}
+	askForm(form) {
+		this.addPending({
+			kind: "form",
+			request: {
+				id: form.id,
+				kind: "question",
+				questions: formQuestions(form)
+			},
+			form
+		});
+	}
 	addPending(pending) {
 		this.pending.set(pending.request.id, pending);
 		publish$2(this.sessionId, {
@@ -2620,10 +2809,7 @@ function providerName(provider) {
 	return providerNames[provider];
 }
 function storedAccounts() {
-	return (readJson("accounts.json") ?? []).map((item) => ({
-		...item,
-		provider: item.provider ?? "claude"
-	}));
+	return readJson("accounts.json") ?? [];
 }
 function storedAccount(provider, accountId) {
 	if (accountId === null) throw new Error(`Add a ${providerName(provider)} account in Settings → Accounts`);
@@ -3030,10 +3216,10 @@ function toItems(messages) {
 						break;
 					case "tool_use":
 						if (block.name === "SendMessage") {
-							const owner = owners.get(text(block.input.to));
+							const owner = owners.get(text$1(block.input.to));
 							if (owner !== void 0) change(owner, { status: "running" });
 						}
-						if (block.name === "TaskStop") stops.set(block.id, text(block.input.task_id));
+						if (block.name === "TaskStop") stops.set(block.id, text$1(block.input.task_id));
 						tools.set(block.id, items.length);
 						items.push(toolItem(block, parent, message.time, (to) => {
 							const owner = owners.get(to);
@@ -3124,7 +3310,7 @@ function toRequest(options) {
 		case "ExitPlanMode": return {
 			id: options.id,
 			kind: "plan",
-			plan: text(options.input.plan)
+			plan: text$1(options.input.plan)
 		};
 		default: return {
 			id: options.id,
@@ -3151,8 +3337,8 @@ function toolItem(tool, parent, time, ownerOf) {
 		case "Bash": return {
 			...base,
 			kind: "command",
-			command: text(input.command),
-			description: text(input.description),
+			command: text$1(input.command),
+			description: text$1(input.description),
 			output: "",
 			status: "running",
 			background: input.run_in_background === true ? {
@@ -3164,8 +3350,8 @@ function toolItem(tool, parent, time, ownerOf) {
 		case "Monitor": return {
 			...base,
 			kind: "command",
-			command: text(input.command) || (isRecord(input.ws) ? text(input.ws.url) : ""),
-			description: text(input.description),
+			command: text$1(input.command) || (isRecord(input.ws) ? text$1(input.ws.url) : ""),
+			description: text$1(input.description),
 			output: "",
 			status: "running",
 			background: {
@@ -3177,10 +3363,10 @@ function toolItem(tool, parent, time, ownerOf) {
 		case "Edit": return {
 			...base,
 			kind: "file_change",
-			path: text(input.file_path),
+			path: text$1(input.file_path),
 			diffs: [{
-				before: text(input.old_string),
-				after: text(input.new_string)
+				before: text$1(input.old_string),
+				after: text$1(input.new_string)
 			}],
 			output: "",
 			status: "running"
@@ -3188,7 +3374,7 @@ function toolItem(tool, parent, time, ownerOf) {
 		case "MultiEdit": return {
 			...base,
 			kind: "file_change",
-			path: text(input.file_path),
+			path: text$1(input.file_path),
 			diffs: input.edits.map((edit) => ({
 				before: edit.old_string,
 				after: edit.new_string
@@ -3199,10 +3385,10 @@ function toolItem(tool, parent, time, ownerOf) {
 		case "Write": return {
 			...base,
 			kind: "file_change",
-			path: text(input.file_path),
+			path: text$1(input.file_path),
 			diffs: [{
 				before: "",
-				after: text(input.content)
+				after: text$1(input.content)
 			}],
 			output: "",
 			status: "running"
@@ -3210,7 +3396,7 @@ function toolItem(tool, parent, time, ownerOf) {
 		case "NotebookEdit": return {
 			...base,
 			kind: "file_change",
-			path: text(input.notebook_path),
+			path: text$1(input.notebook_path),
 			diffs: [],
 			output: "",
 			status: "running"
@@ -3219,7 +3405,7 @@ function toolItem(tool, parent, time, ownerOf) {
 			...base,
 			kind: "web_search",
 			query: null,
-			url: text(input.url),
+			url: text$1(input.url),
 			results: [],
 			output: "",
 			status: "running"
@@ -3227,7 +3413,7 @@ function toolItem(tool, parent, time, ownerOf) {
 		case "WebSearch": return {
 			...base,
 			kind: "web_search",
-			query: text(input.query),
+			query: text$1(input.query),
 			url: null,
 			results: [],
 			output: "",
@@ -3236,7 +3422,7 @@ function toolItem(tool, parent, time, ownerOf) {
 		case "Skill": return {
 			...base,
 			kind: "skill",
-			skill: text(input.skill),
+			skill: text$1(input.skill),
 			output: "",
 			status: "running"
 		};
@@ -3251,7 +3437,7 @@ function toolItem(tool, parent, time, ownerOf) {
 		case "ExitPlanMode": return {
 			...base,
 			kind: "plan",
-			plan: text(input.plan)
+			plan: text$1(input.plan)
 		};
 		case "AskUserQuestion": return {
 			...base,
@@ -3262,23 +3448,23 @@ function toolItem(tool, parent, time, ownerOf) {
 		};
 		case "Agent":
 		case "Task": {
-			const agent = text(input.subagent_type);
+			const agent = text$1(input.subagent_type);
 			return {
 				...base,
 				kind: "subagent",
 				agent: agent === "" ? "general-purpose" : agent,
-				description: text(input.description),
+				description: text$1(input.description),
 				agentId: null,
 				status: "running"
 			};
 		}
 		case "SendMessage": {
-			const summary = text(input.summary);
+			const summary = text$1(input.summary);
 			return {
 				...base,
 				kind: "agent_message",
-				target: ownerOf(text(input.to)),
-				summary: summary === "" ? text(input.message).split("\n")[0] : summary,
+				target: ownerOf(text$1(input.to)),
+				summary: summary === "" ? text$1(input.message).split("\n")[0] : summary,
 				status: "running"
 			};
 		}
@@ -3368,7 +3554,7 @@ function userText(value) {
 		text: value
 	};
 }
-function text(value) {
+function text$1(value) {
 	return typeof value === "string" ? value : "";
 }
 //#endregion
@@ -3497,11 +3683,13 @@ async function history(sessionId, cwd) {
 	const seen = new Set(messages.map((item) => item.uuid));
 	const last = kept.findLast((item) => item.type === "assistant" && item.parent_tool_use_id === null);
 	const tokens = last === void 0 ? null : contextTokens(last.message);
+	const live = run?.messages ?? [];
+	const compacted = live.findLastIndex((item) => item.type === "compaction");
 	return {
 		type: "history",
 		sessionId,
 		provider: "claude",
-		items: toItems([...messages, ...run?.messages.filter((item) => !seen.has(item.uuid)) ?? []]),
+		items: toItems([...messages, ...live.slice(compacted + 1).filter((item) => !seen.has(item.uuid))]),
 		requests: [...run?.pending.values() ?? []].map((item) => item.request),
 		queue: run?.queue ?? [],
 		settings: run?.settings ?? null,
@@ -4253,60 +4441,43 @@ function walk(root) {
 }
 //#endregion
 //#region src/services/push.ts
-const pushFile = path.join(home, "push.json");
 const TITLE_LIMIT = 100;
 const BODY_LIMIT = 500;
 const TIME_TO_LIVE = 900;
 const SEND_TIMEOUT = 1e4;
 const SUBJECT = "https://github.com/NazmusSayad/offsite";
 let server$1 = "";
-let active = false;
 function startPush(address) {
 	server$1 = address;
-	try {
-		const store = readJson("push.json");
-		if (store !== null) track(store);
-	} catch (error) {
-		console.warn(`push notifications are off until a browser turns them on again, could not read ${pushFile}: ${error}`);
-	}
 }
 function pushActive() {
-	return active;
+	return ours().length > 0;
 }
 function pushKey() {
-	return { publicKey: read().publicKey };
+	return { publicKey: machineInfo().pushPublicKey };
 }
 function subscribe(subscription) {
 	if (new URL(subscription.endpoint).protocol !== "https:") throw new Error("the endpoint must be an https URL");
-	update((store) => {
-		store.subscriptions = store.subscriptions.filter((existing) => existing.endpoint !== subscription.endpoint);
-		store.subscriptions.push({
-			endpoint: subscription.endpoint,
-			keys: {
-				p256dh: subscription.keys.p256dh,
-				auth: subscription.keys.auth
-			},
-			server: server$1
-		});
-	});
+	const values = {
+		endpoint: subscription.endpoint,
+		p256dh: subscription.keys.p256dh,
+		auth: subscription.keys.auth,
+		server: server$1
+	};
+	db.insert(pushSubscriptions).values(values).onConflictDoUpdate({
+		target: pushSubscriptions.endpoint,
+		set: values
+	}).run();
 	console.log("a browser subscribed to push notifications");
 }
 function unsubscribe(endpoint) {
-	update((store) => {
-		store.subscriptions = store.subscriptions.filter((existing) => existing.endpoint !== endpoint);
-	});
+	db.delete(pushSubscriptions).where(eq(pushSubscriptions.endpoint, endpoint)).run();
 	console.log("a browser unsubscribed from push notifications");
 }
 async function sendPush(message) {
-	let store;
-	try {
-		store = read();
-	} catch (error) {
-		console.error(`could not read push subscriptions: ${error}`);
-		return;
-	}
-	const subscriptions = store.subscriptions.filter(ours);
+	const subscriptions = ours();
 	if (subscriptions.length === 0) return;
+	const keys = machineInfo();
 	const payload = JSON.stringify({
 		...message,
 		title: [...message.title].slice(0, TITLE_LIMIT).join(""),
@@ -4315,11 +4486,17 @@ async function sendPush(message) {
 	const gone = [];
 	await Promise.all(subscriptions.map(async (subscription) => {
 		try {
-			await webPush.sendNotification(subscription, payload, {
+			await webPush.sendNotification({
+				endpoint: subscription.endpoint,
+				keys: {
+					p256dh: subscription.p256dh,
+					auth: subscription.auth
+				}
+			}, payload, {
 				vapidDetails: {
 					subject: SUBJECT,
-					publicKey: store.publicKey,
-					privateKey: store.privateKey
+					publicKey: keys.pushPublicKey,
+					privateKey: keys.pushPrivateKey
 				},
 				TTL: TIME_TO_LIVE,
 				urgency: "high",
@@ -4341,59 +4518,10 @@ async function sendPush(message) {
 		}
 	}));
 	if (gone.length === 0) return;
-	try {
-		update((current) => {
-			current.subscriptions = current.subscriptions.filter((subscription) => !gone.includes(subscription.endpoint));
-		});
-	} catch (error) {
-		console.error(`could not remove gone push subscriptions: ${error}`);
-	}
+	db.delete(pushSubscriptions).where(and(eq(pushSubscriptions.server, server$1), inArray(pushSubscriptions.endpoint, gone))).run();
 }
-function ours(subscription) {
-	return subscription.server === server$1;
-}
-function track(store) {
-	active = store.subscriptions.some(ours);
-}
-function load() {
-	let store;
-	try {
-		store = readJson("push.json");
-	} catch (error) {
-		if (!(error instanceof SyntaxError)) throw error;
-		return replaceCorrupt(error);
-	}
-	if (store === null) return create();
-	if (typeof store.publicKey !== "string" || typeof store.privateKey !== "string" || !Array.isArray(store.subscriptions)) return replaceCorrupt(/* @__PURE__ */ new Error("it is missing its keys or subscriptions"));
-	return store;
-}
-function replaceCorrupt(error) {
-	const aside = `${pushFile}.corrupt-${randomUUID()}`;
-	renameSync(pushFile, aside);
-	console.warn(`${pushFile} is corrupt, moved it to ${aside} and created a new one: ${error}`);
-	return create();
-}
-function create() {
-	const store = {
-		...webPush.generateVAPIDKeys(),
-		subscriptions: []
-	};
-	save(store);
-	return store;
-}
-function save(store) {
-	writeJson("push.json", store);
-}
-function read() {
-	const store = load();
-	track(store);
-	return store;
-}
-function update(change) {
-	const store = load();
-	change(store);
-	save(store);
-	track(store);
+function ours() {
+	return db.select().from(pushSubscriptions).where(eq(pushSubscriptions.server, server$1)).all();
 }
 //#endregion
 //#region src/services/runs.ts
@@ -4414,9 +4542,10 @@ function rewind(request) {
 }
 async function rewindNow(request) {
 	const sessionId = request.sessionId;
-	if (runs.get(sessionId)?.running === true) throw new Error("Stop Claude before rewinding");
+	const cwd = projectPath(request.projectId);
+	if (runs.get(sessionId)?.running === true) throw new Error(`Stop ${providerName(providerOf(sessionId))} before rewinding`);
 	if ((runs.get(sessionId)?.backgroundTasks ?? 0) > 0) throw new Error("Wait for background tasks to finish before rewinding");
-	const run = await runFor(sessionId, request.cwd, request.settings);
+	const run = await runFor(sessionId, cwd, request.settings);
 	if (run.provider === "codex") {
 		if (request.code) throw new Error("Codex cannot restore files");
 		if (request.dryRun || !request.conversation) return null;
@@ -4429,7 +4558,7 @@ async function rewindNow(request) {
 		const result = await rewindOpenCode(request);
 		if (request.dryRun) return result;
 		run.items.clear();
-		publish$2(sessionId, await openCodeHistory(sessionId, request.cwd));
+		publish$2(sessionId, await openCodeHistory(sessionId, cwd));
 		return result;
 	}
 	let result = null;
@@ -4443,58 +4572,63 @@ async function rewindNow(request) {
 		};
 	}
 	if (request.dryRun || !request.conversation) return result;
-	const disk = await getSessionMessages(sessionId, { dir: request.cwd });
+	const disk = await getSessionMessages(sessionId, { dir: cwd });
 	const index = disk.findIndex((item) => item.uuid === request.messageId);
 	if (index < 1) throw new Error("Cannot rewind the conversation to that point");
 	run.stop();
 	await run.closed;
 	new Run({
 		sessionId,
-		cwd: request.cwd,
+		cwd,
 		resume: true,
 		resumeAt: disk[index - 1].uuid,
 		settings: request.settings
 	});
-	publish$2(sessionId, await history(sessionId, request.cwd));
+	publish$2(sessionId, await history(sessionId, cwd));
 	return result;
 }
-async function open$1(client, sessionId, cwd) {
+async function open$1(client, sessionId, projectId) {
 	client.opening = sessionId;
-	const event = await sessionHistory(sessionId, cwd);
+	const event = await sessionHistory(sessionId, projectPath(projectId));
 	if (client.opening !== sessionId) return;
 	client.sessionId = sessionId;
 	client.send(event);
 }
 async function send$1(client, request) {
-	if (!statSync(request.cwd, { throwIfNoEntry: false })?.isDirectory()) throw new Error(`${request.cwd} is not a folder`);
+	const cwd = projectPath(request.projectId);
+	if (!statSync(cwd, { throwIfNoEntry: false })?.isDirectory()) throw new Error(`${cwd} is not a folder`);
 	if (request.sessionId === null) {
-		const run = await startRun(request.cwd, request.settings);
+		const run = await startRun(cwd, request.settings);
 		const sessionId = run.sessionId;
 		client.opening = sessionId;
 		client.sessionId = sessionId;
 		client.send({
 			type: "started",
 			sessionId,
-			cwd: request.cwd
+			projectId: request.projectId
 		});
 		await run.submit(request.prompt, request.delivery);
 		recordInteraction(sessionId);
 		return;
 	}
 	const sessionId = request.sessionId;
-	await locked(sessionId, () => sendExisting(client, sessionId, request));
+	await locked(sessionId, () => sendExisting(client, sessionId, cwd, request));
 }
-async function sendExisting(client, sessionId, request) {
+async function sendExisting(client, sessionId, cwd, request) {
 	const provider = providerOf(sessionId);
 	if (request.settings.provider !== provider) throw new Error(`This session belongs to ${providerName(provider)}`);
 	const existing = runs.get(sessionId);
-	if (existing?.provider === "claude" && !existing.running && existing.backgroundTasks === 0 && await changedElsewhere(existing, request.cwd)) {
+	if (existing?.provider === "claude" && !existing.running && existing.backgroundTasks === 0 && await changedElsewhere(existing, cwd)) {
+		existing.stop();
+		await existing.closed;
+	}
+	if (existing?.provider === "codex" && !existing.running && existing.pending.size === 0 && (listedUpdatedAt("codex", sessionId) ?? 0) > existing.activeAt) {
 		existing.stop();
 		await existing.closed;
 	}
-	const run = await runFor(sessionId, request.cwd, request.settings);
+	const run = await runFor(sessionId, cwd, request.settings);
 	if (run === existing) await run.configure(request.settings);
-	else await open$1(client, sessionId, request.cwd);
+	else await open$1(client, sessionId, request.projectId);
 	await run.submit(request.prompt, request.delivery);
 	recordInteraction(sessionId);
 }
@@ -5138,7 +5272,7 @@ async function request(connection, message) {
 			return;
 		}
 		case "createTab":
-			await createTab(message.cwd);
+			await createTab(message.projectId);
 			break;
 		case "closeTab":
 			closeTab(message.id);
@@ -5162,17 +5296,17 @@ async function request(connection, message) {
 			break;
 		}
 		case "select": {
-			const project = projects.get(message.cwd) ?? {
+			const project = projects.get(message.projectId) ?? {
 				tabs: [],
 				activeTab: null
 			};
-			projects.set(message.cwd, project);
+			projects.set(message.projectId, project);
 			const tab = project.tabs.find((item) => item.id === message.tabId);
 			if (tab !== void 0) {
 				tab.minimized = false;
 				project.activeTab = tab.id;
 			}
-			if (project.tabs.length === 0) await createTab(message.cwd);
+			if (project.tabs.length === 0) await createTab(message.projectId);
 			break;
 		}
 	}
@@ -5205,16 +5339,17 @@ function input(connection, bytes) {
 	}
 	terminal.pty.write(Buffer.from(frame.data));
 }
-async function createTab(cwd) {
+async function createTab(projectId) {
+	const cwd = projectPath(projectId);
 	if (!statSync(cwd, { throwIfNoEntry: false })?.isDirectory()) {
 		console.error(`${cwd} is not a folder, terminal not created`);
 		return;
 	}
-	const project = projects.get(cwd) ?? {
+	const project = projects.get(projectId) ?? {
 		tabs: [],
 		activeTab: null
 	};
-	projects.set(cwd, project);
+	projects.set(projectId, project);
 	const active = project.activeTab === null ? void 0 : terminals.get(project.activeTab);
 	let directory = cwd;
 	if (active !== void 0) try {
@@ -5347,7 +5482,8 @@ function push(id, alert, windowTitle) {
 	sendPush({
 		title,
 		body,
-		cwd: entry[0],
+		machineId: machineInfo().id,
+		projectId: entry[0],
 		tabId: id
 	});
 }
@@ -5387,33 +5523,38 @@ function send(connection, event) {
 //#region src/api/socket.ts
 const handlers = {
 	ping: () => null,
-	sync: async () => ({
-		...configInfo(),
-		protocol: 2,
-		hostname: os.hostname(),
-		projects: projects$1(),
-		sessions: await sessions(),
-		activity: activity()
-	}),
+	sync: () => {
+		refreshAll();
+		return {
+			...configInfo(),
+			protocol: 3,
+			machineId: machineInfo().id,
+			hostname: os.hostname(),
+			projects: projects$1(),
+			sessions: sessions(),
+			providers: providerStatuses(),
+			activity: activity()
+		};
+	},
 	"config.get": () => configInfo(),
 	"config.save": (params) => {
 		const before = readConfig().claudeBaseDir;
 		const saved = saveConfig(params);
 		if (saved.claudeBaseDir === before) return saved;
 		watchSessions();
-		publishSessions();
+		refreshAll();
 		publishAccounts();
 		return saved;
 	},
 	"projects.add": async (params) => {
 		const project = await addProject(params.path);
-		publishSessions();
+		refreshAll();
 		return project;
 	},
-	"projects.update": (params) => updateProject(params.path, params.patch),
+	"projects.update": (params) => updateProject(params.id, params.patch),
 	"projects.remove": (params) => {
-		removeProject(params.path);
-		publishSessions();
+		removeProject(params.id);
+		refreshAll();
 		return null;
 	},
 	"directories.list": (params) => directories(params.path),
@@ -5434,14 +5575,14 @@ const handlers = {
 		return null;
 	},
 	"sessions.open": async (params, client) => {
-		await open$1(client, params.sessionId, params.cwd);
+		await open$1(client, params.sessionId, params.projectId);
 		return null;
 	},
 	"sessions.earlier": (params) => earlier(params.sessionId, params.before),
 	"sessions.image": (params) => image(params.sessionId, params.itemId, params.index),
 	"sessions.agent": (params) => {
 		switch (providerOf(params.sessionId)) {
-			case "claude": return agentMessages(params.sessionId, params.cwd, params.agentId, params.parent);
+			case "claude": return agentMessages(params.sessionId, projectPath(params.projectId), params.agentId, params.parent);
 			case "codex": return codexAgent(params.agentId, params.parent);
 			case "opencode": return openCodeAgent(params.agentId, params.parent);
 		}
@@ -5479,7 +5620,7 @@ const handlers = {
 	},
 	"sessions.rewind": (params) => rewind(params),
 	"sessions.fork": async (params) => {
-		const result = await fork(params.sessionId, params.cwd, params.messageId);
+		const result = await fork(params.sessionId, params.projectId, params.messageId);
 		publishSessions();
 		return result;
 	},
@@ -5499,17 +5640,17 @@ const handlers = {
 		publishAccounts();
 		return null;
 	},
-	capabilities: (params) => capabilities(params.accountId, params.cwd),
-	"files.list": (params) => listFiles(params.cwd),
-	"files.read": (params) => readProjectFile(params.cwd, params.path),
+	capabilities: (params) => capabilities(params.accountId, projectPath(params.projectId)),
+	"files.list": (params) => listFiles(projectPath(params.projectId)),
+	"files.read": (params) => readProjectFile(projectPath(params.projectId), params.path),
 	"files.upload": (params) => saveUpload(params.name, Buffer.from(params.data, "base64")),
 	"tasks.output": (params) => taskOutput(params.sessionId, params.path),
-	"git.status": (params) => gitStatus(params.cwd),
-	"git.diff": (params) => projectDiff(params.cwd),
-	"git.commit": (params) => commit(params.cwd, params.message),
-	"git.push": (params) => push$1(params.cwd),
-	"git.pullRequest": (params) => createPullRequest(params.cwd),
-	"git.message": (params) => suggestCommitMessage(params.provider, params.accountId, params.cwd),
+	"git.status": (params) => gitStatus(projectPath(params.projectId)),
+	"git.diff": (params) => projectDiff(projectPath(params.projectId)),
+	"git.commit": (params) => commit(projectPath(params.projectId), params.message),
+	"git.push": (params) => push$1(projectPath(params.projectId)),
+	"git.pullRequest": (params) => createPullRequest(projectPath(params.projectId)),
+	"git.message": (params) => suggestCommitMessage(params.provider, params.accountId, projectPath(params.projectId)),
 	"push.key": () => pushKey(),
 	"push.subscribe": (params) => {
 		subscribe(params);
@@ -5578,40 +5719,32 @@ async function answer(client, text) {
 //#endregion
 //#region src/storage/token.ts
 function readTokens() {
-	const stored = readJson("tokens.json");
-	return stored === null ? [] : stored.tokens;
+	return db.select().from(tokens).orderBy(tokens.createdAt).all();
 }
 function addToken(name) {
 	const token = randomBytes(32).toString("base64url");
-	writeJson("tokens.json", { tokens: [...readTokens(), {
-		token,
+	db.insert(tokens).values({
+		hash: hashToken(token),
 		name,
 		createdAt: Date.now()
-	}] });
+	}).run();
 	return token;
 }
-function removeTokens(tokens) {
-	writeJson("tokens.json", { tokens: readTokens().filter((item) => !tokens.includes(item.token)) });
+function removeTokens(hashes) {
+	db.delete(tokens).where(inArray(tokens.hash, hashes)).run();
 }
-function firstToken() {
-	return readTokens().at(0)?.token ?? addToken(null);
+function hasTokens() {
+	return db.select().from(tokens).limit(1).get() !== void 0;
 }
 function matchesToken(given) {
 	if (given === null) return false;
-	const actual = Buffer.from(given);
-	return readTokens().some((item) => {
-		const expected = Buffer.from(item.token);
-		return expected.length === actual.length && timingSafeEqual(expected, actual);
-	});
-}
-function readUsage() {
-	return readJson("token-usage.json") ?? {};
+	return db.select().from(tokens).where(eq(tokens.hash, hashToken(given))).get() !== void 0;
 }
 function recordUse(token) {
-	writeJson("token-usage.json", {
-		...readUsage(),
-		[token]: Date.now()
-	});
+	db.update(tokens).set({ lastUsedAt: Date.now() }).where(eq(tokens.hash, hashToken(token))).run();
+}
+function hashToken(token) {
+	return createHash("sha256").update(token).digest("hex");
 }
 //#endregion
 //#region src/main.ts
@@ -5633,11 +5766,17 @@ if (!Number.isInteger(port) || port < 1 || port > 65535) {
 	process.exit(1);
 }
 const address = `http://${args.host}:${port}`;
+const fallback = args.fallback === void 0 ? null : readFallback(args.fallback);
 if (args.command === "pair") {
 	const links = pairingLinks(addToken(args.name));
-	console.log("Open one of these links in the browser to pair:");
-	console.log(`  ${links.local}`);
+	console.log(`Scan this to pair a phone with ${HOSTED_APP}:`);
+	console.log("");
+	console.log(renderUnicodeCompact(links.hosted, { border: 2 }));
+	console.log("");
+	console.log("Or open one of these links in the browser to pair:");
 	console.log(`  ${links.hosted}`);
+	console.log(`  ${links.local}`);
+	if (fallback !== null) console.log(`Fallback: ${fallback}`);
 	process.exit(0);
 }
 if (args.command === "unpair") {
@@ -5647,12 +5786,13 @@ if (args.command === "unpair") {
 lockHome();
 process.env.CLAUDE_CONFIG_DIR = readConfig().claudeBaseDir;
 watchSessions();
+refreshAll();
 if (findClaude() === null) {
 	console.error("could not find claude on PATH; install Claude Code first");
 	process.exit(1);
 }
 const publicDir = path.join(import.meta.dirname, "..", "..", "web", "dist");
-const token = args.auth && args.pair ? firstToken() : null;
+const token = args.auth && args.pair && !hasTokens() ? addToken(null) : null;
 const server = createServer((request, response) => {
 	const url = new URL(request.url ?? "/", "http://localhost");
 	if (url.pathname === "/version") {
@@ -5660,7 +5800,8 @@ const server = createServer((request, response) => {
 		response.setHeader("content-type", "application/json");
 		response.end(JSON.stringify({
 			version,
-			protocol: 2,
+			protocol: 3,
+			machineId: machineInfo().id,
 			authorized: authorized(url)
 		}));
 		return;
@@ -5677,7 +5818,7 @@ const paired = /* @__PURE__ */ new Map();
 server.on("upgrade", (request, socket, head) => {
 	const url = new URL(request.url ?? "/", "http://localhost");
 	const given = url.searchParams.get("token");
-	if (url.pathname !== "/ws" || url.searchParams.get("protocol") !== String(2) || !authorized(url)) {
+	if (url.pathname !== "/ws" || url.searchParams.get("protocol") !== String(3) || !authorized(url)) {
 		socket.destroy();
 		return;
 	}
@@ -5694,10 +5835,13 @@ if (args.auth) setInterval(() => {
 }, UNPAIR_CHECK);
 server.listen(port, args.host, () => {
 	startPush(`${args.host}:${port}`);
-	if (args.pair) {
+	if (args.pair && (token !== null || !args.auth)) {
 		const links = pairingLinks(token);
 		if (args.command === "web") console.log(`offsite is running at ${links.local}`);
 		console.log(`Open it on ${HOSTED_APP}: ${links.hosted}`);
+	} else if (args.pair) {
+		console.log(`offsite is running at ${address}`);
+		console.log("Run offsite pair to pair another browser");
 	} else {
 		console.log(`offsite is running at ${address}`);
 		console.log(`Open it on ${HOSTED_APP}`);
@@ -5723,23 +5867,18 @@ async function unpair() {
 		console.error("offsite unpair needs an interactive terminal");
 		process.exit(1);
 	}
-	const usage = readUsage();
 	const picked = await consola.prompt("Which browsers should be unpaired?", {
 		type: "multiselect",
 		required: false,
 		cancel: "null",
-		options: tokens.map((item) => {
-			const used = usage[item.token];
-			return {
-				value: item.token,
-				label: [
-					item.name ?? "Unnamed",
-					`${item.token.slice(0, 6)}…`,
-					`paired ${new Date(item.createdAt).toLocaleString()}`,
-					used === void 0 ? "never used" : `last used ${new Date(used).toLocaleString()}`
-				].join(" · ")
-			};
-		})
+		options: tokens.map((item) => ({
+			value: item.hash,
+			label: [
+				item.name ?? "Unnamed",
+				`paired ${new Date(item.createdAt).toLocaleString()}`,
+				item.lastUsedAt === null ? "never used" : `last used ${new Date(item.lastUsedAt).toLocaleString()}`
+			].join(" · ")
+		}))
 	});
 	if (picked === null || picked.length === 0) {
 		console.log("Nothing unpaired");
@@ -5748,9 +5887,24 @@ async function unpair() {
 	removeTokens(picked);
 	console.log(`Unpaired ${picked.length} ${picked.length === 1 ? "browser" : "browsers"}; a running offsite disconnects them within seconds`);
 }
+function readFallback(link) {
+	let url;
+	try {
+		url = new URL(link);
+	} catch {
+		console.error(`invalid fallback URL ${link}`);
+		process.exit(1);
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") {
+		console.error(`the fallback URL ${link} needs http:// or https://`);
+		process.exit(1);
+	}
+	return url.origin;
+}
 function pairingLinks(token) {
 	const hosted = new URLSearchParams({
 		machine: address,
+		...fallback !== null && { fallback },
 		...token !== null && { token }
 	});
 	return {