offsite 0.0.10 → 0.0.12

package/apps/server/dist/main.mjs

@@ -1,29 +1,29 @@
+import { createHash, randomBytes, randomUUID } from "node:crypto";
 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 { createHash, randomBytes, randomUUID } from "node:crypto";
 import { execFile, spawn } from "node:child_process";
 import readline from "node:readline";
+import { z } from "zod";
 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 { and, eq, gt, inArray, lte, sql } from "drizzle-orm";
+import { sumBy } from "es-toolkit";
 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";
 function encodeFrame(kind, id, data) {
 	const frame = new Uint8Array(5 + data.length);
 	frame[0] = kind;
@@ -40,6 +40,27 @@ function decodeFrame(frame) {
 	};
 }
 //#endregion
+//#region src/constants.ts
+const deprecatedModels = {
+	claude: [
+		"claude-sonnet-5",
+		"claude-opus-5",
+		"claude-fable-5",
+		"claude-haiku-4-5-20251001",
+		"claude-opus-4-8",
+		"claude-opus-4-7",
+		"claude-opus-4-6",
+		"claude-sonnet-4-6"
+	],
+	codex: [],
+	opencode: []
+};
+const defaultModels = {
+	claude: "claude-opus-5-5",
+	codex: null,
+	opencode: null
+};
+//#endregion
 //#region src/lib/hub.ts
 const clients = /* @__PURE__ */ new Set();
 function publish$2(sessionId, event) {
@@ -49,281 +70,6 @@ function broadcast(event) {
 	for (const client of clients) client.send(event);
 }
 //#endregion
-//#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").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";
-});
-program.command("pair").description("Creates a pairing token for another browser and prints its links").option("--name <name>", "Name to recognize this browser by").action((options) => {
-	command = "pair";
-	name = options.name ?? null;
-});
-program.command("unpair").description("Picks paired browsers to unpair").action(() => {
-	command = "unpair";
-});
-program.parse();
-const options = program.opts();
-const args = {
-	...options,
-	dir: path.resolve(options.dir),
-	command,
-	name
-};
-const serverDir = path.join(import.meta.dirname, "..");
-//#endregion
-//#region src/storage/storage.ts
-const home = args.dir;
-const lockFile = path.join(home, "server.pid");
-mkdirSync(home, { recursive: true });
-function lockHome() {
-	lock();
-	process.on("exit", () => unlinkSync(lockFile));
-}
-function lock() {
-	try {
-		writeFileSync(lockFile, `${process.pid}\n`, { flag: "wx" });
-		return;
-	} catch (error) {
-		if (!hasCode(error, "EEXIST")) throw error;
-	}
-	let content;
-	let modified;
-	try {
-		content = readFileSync(lockFile, "utf8");
-		modified = statSync(lockFile).mtimeMs;
-	} catch (error) {
-		if (hasCode(error, "ENOENT")) return lock();
-		throw error;
-	}
-	const pid = Number(content);
-	const validPid = Number.isInteger(pid) && pid > 0;
-	const writtenThisBoot = modified > Date.now() - os.uptime() * 1e3;
-	if (validPid && writtenThisBoot && pid !== process.pid && isRunning(pid)) {
-		consola.error(`offsite is already running for ${home} (pid ${pid})`);
-		process.exit(1);
-	}
-	unlinkSync(lockFile);
-	lock();
-}
-function isRunning(pid) {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch (error) {
-		if (hasCode(error, "ESRCH")) return false;
-		if (hasCode(error, "EPERM")) return true;
-		throw error;
-	}
-}
-function hasCode(error, code) {
-	return error instanceof Error && "code" in error && error.code === code;
-}
-function readJson(name) {
-	try {
-		return JSON.parse(readFileSync(path.join(home, name), "utf8"));
-	} catch (error) {
-		if (error.code === "ENOENT") return null;
-		throw error;
-	}
-}
-function writeJson(name, value) {
-	const file = path.join(home, name);
-	mkdirSync(home, { recursive: true });
-	writeFileSync(`${file}.tmp`, `${JSON.stringify(value, null, 2)}\n`, { mode: 384 });
-	renameSync(`${file}.tmp`, file);
-}
-//#endregion
-//#region src/storage/config.ts
-const version = "0.0.0";
-const configFile = path.join(home, "config.json");
-const defaults = {
-	claudeBaseDir: path.join(os.homedir(), ".claude"),
-	composer: {
-		provider: "claude",
-		claude: {
-			accountId: null,
-			model: "haiku",
-			effort: "low",
-			mode: "bypassPermissions",
-			plan: false
-		},
-		codex: {
-			accountId: null,
-			model: null,
-			effort: null,
-			mode: "auto",
-			plan: false
-		},
-		opencode: {
-			accountId: "opencode",
-			model: null,
-			effort: null,
-			mode: null,
-			plan: false
-		}
-	},
-	commitModels: {
-		claude: "haiku",
-		codex: "gpt-6-luna",
-		opencode: null
-	},
-	terminal: {
-		shell: {
-			macos: null,
-			linux: null,
-			windows: null
-		},
-		behavior: {
-			terminalIdentity: "offsite",
-			shellIntegration: true
-		}
-	}
-};
-const choices = {
-	"composer.provider": [
-		"claude",
-		"codex",
-		"opencode"
-	],
-	"composer.claude.effort": [
-		"low",
-		"medium",
-		"high",
-		"xhigh",
-		"max"
-	],
-	"composer.claude.mode": [
-		"default",
-		"acceptEdits",
-		"bypassPermissions",
-		"plan",
-		"dontAsk",
-		"auto"
-	],
-	"composer.codex.mode": [
-		"read-only",
-		"auto",
-		"full-access"
-	],
-	"terminal.behavior.terminalIdentity": [
-		"offsite",
-		"ghostty",
-		"iterm2"
-	]
-};
-const nullable = [
-	"composer.claude.accountId",
-	"composer.claude.model",
-	"composer.claude.effort",
-	"composer.claude.mode",
-	"composer.codex.accountId",
-	"composer.codex.model",
-	"composer.codex.effort",
-	"composer.codex.mode",
-	"composer.opencode.accountId",
-	"composer.opencode.model",
-	"composer.opencode.effort",
-	"composer.opencode.mode",
-	"commitModels.claude",
-	"commitModels.codex",
-	"commitModels.opencode",
-	"terminal.shell.macos",
-	"terminal.shell.linux",
-	"terminal.shell.windows"
-];
-function platform() {
-	if (process.platform === "darwin") return "macos";
-	if (process.platform === "linux") return "linux";
-	if (process.platform === "win32") return "windows";
-	throw new Error(`unsupported platform ${process.platform}`);
-}
-function defaultShell() {
-	if (process.platform === "win32") return process.env.COMSPEC ?? "cmd.exe";
-	return os.userInfo().shell ?? "/bin/sh";
-}
-function configInfo() {
-	return {
-		config: readConfig(),
-		defaults,
-		platform: platform(),
-		version,
-		defaultShell: defaultShell()
-	};
-}
-function readConfig() {
-	let user;
-	try {
-		user = readJson("config.json");
-	} catch (error) {
-		console.warn(`invalid ${configFile}, using the default config: ${error}`);
-		return structuredClone(defaults);
-	}
-	if (user === null) return structuredClone(defaults);
-	if (!isObject(user)) {
-		console.warn(`${configFile} is not an object, using the default config`);
-		return structuredClone(defaults);
-	}
-	let config = structuredClone(defaults);
-	for (const [key, value] of Object.entries(user)) config = merge(config, [key], value);
-	return config;
-}
-function saveConfig(value) {
-	const error = invalid(value, defaults, []);
-	if (error !== null) throw new Error(error);
-	writeJson("config.json", value);
-	process.env.CLAUDE_CONFIG_DIR = value.claudeBaseDir;
-	broadcast({
-		type: "config",
-		config: value
-	});
-	return value;
-}
-function merge(config, keys, user) {
-	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);
-		return next;
-	}
-	const candidate = structuredClone(config);
-	const parent = keys.slice(0, -1).reduce((value, key) => value[key], candidate);
-	parent[keys[keys.length - 1]] = user;
-	const error = invalid(candidate, defaults, []);
-	if (error === null) return candidate;
-	console.warn(`invalid ${keys.join(".")} in ${configFile}, using its default: ${error}`);
-	return config;
-}
-function invalid(value, template, keys) {
-	const name = keys.join(".");
-	if (isObject(template)) {
-		if (!isObject(value)) return `${name || "config"} must be an object`;
-		for (const key of Object.keys(value)) if (!(key in template)) return `unknown setting ${[...keys, key].join(".")}`;
-		for (const key of Object.keys(template)) {
-			if (!(key in value)) return `missing setting ${[...keys, key].join(".")}`;
-			const error = invalid(value[key], template[key], [...keys, key]);
-			if (error !== null) return error;
-		}
-		return null;
-	}
-	if (nullable.includes(name) && value === null) return null;
-	if (name === "claudeBaseDir") return typeof value === "string" && path.isAbsolute(value) ? null : "claudeBaseDir must be an absolute path";
-	if (name in choices) {
-		if (choices[name].includes(value)) return null;
-		return `${name} must be one of ${choices[name].join(", ")}`;
-	}
-	if (template === null) {
-		if (typeof value === "string") return null;
-		return `${name} must be text or null`;
-	}
-	if (typeof value !== typeof template) return `${name} must be a ${typeof template}`;
-	return null;
-}
-function isObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-//#endregion
 //#region src/lib/codex/app-server.ts
 const IDLE_LIMIT$3 = 18e5;
 const START_TIMEOUT = 15e3;
@@ -340,6 +86,9 @@ function appServer(home) {
 function stopAppServers() {
 	for (const server of servers.values()) server.stop();
 }
+function stopAppServer(home) {
+	servers.get(home)?.stop();
+}
 function findCodex() {
 	const name = process.platform === "win32" ? "codex.exe" : "codex";
 	for (const dir of (process.env.PATH ?? "").split(path.delimiter)) {
@@ -378,8 +127,8 @@ var AppServer = class {
 		this.ready = this.call("initialize", {
 			clientInfo: {
 				name: "offsite",
-				title: "Offsite",
-				version
+				title: "OffSite",
+				version: "0.0.0"
 			},
 			capabilities: {
 				experimentalApi: true,
@@ -616,82 +365,210 @@ function isMirror(dir) {
 	}
 }
 //#endregion
-//#region src/lib/codex/items.ts
-const statuses$1 = {
-	inProgress: "running",
-	completed: "completed",
-	failed: "failed",
-	declined: "stopped",
-	interrupted: "stopped"
-};
-function turnItems(turns, parent) {
-	return turns.flatMap((turn) => [...turn.items.flatMap((item) => toItems$1(turn.id, item, parent, turn.startedAt === null ? null : turn.startedAt * 1e3)), ...turn.status === "failed" && turn.error !== null ? [errorItem(`${turn.id}:error`, turn.error.message)] : []]);
-}
-function itemId(turnId, id) {
-	return `${turnId}:${id}`;
+//#region src/lib/claude/content.ts
+const imageTypes = [
+	"image/png",
+	"image/jpeg",
+	"image/gif",
+	"image/webp"
+];
+function toMessage(type, item, time) {
+	return {
+		type,
+		uuid: item.uuid,
+		time,
+		content: isRecord(item.message) ? toBlocks(item.message.content, answersOf(item.tool_use_result)) : [],
+		parent: item.parent_tool_use_id
+	};
 }
-function turnOf(itemId) {
-	const index = itemId.indexOf(":");
-	if (index < 0) throw new Error(`${itemId} is not a Codex item`);
-	return itemId.slice(0, index);
+function toUserInput(prompt, uuid, priority) {
+	for (const image of prompt.images) if (!imageTypes.includes(image.mediaType)) throw new Error(`${image.mediaType} images are not supported`);
+	return {
+		type: "user",
+		message: {
+			role: "user",
+			content: [...prompt.images.map((image) => ({
+				type: "image",
+				source: {
+					type: "base64",
+					media_type: image.mediaType,
+					data: image.data
+				}
+			})), ...prompt.text === "" ? [] : [{
+				type: "text",
+				text: prompt.text
+			}]]
+		},
+		parent_tool_use_id: null,
+		uuid,
+		...priority === void 0 ? {} : { priority }
+	};
 }
-function errorItem(id, text) {
+function promptMessage(prompt, uuid) {
 	return {
-		id,
-		parent: null,
+		type: "user",
+		uuid,
 		time: Date.now(),
-		kind: "error",
-		text
+		content: [...prompt.images.map((image) => ({
+			type: "image",
+			...image
+		})), ...prompt.text === "" ? [] : [{
+			type: "text",
+			text: prompt.text
+		}]],
+		parent: null
 	};
 }
-function toItems$1(turnId, item, parent, time) {
-	const base = {
-		id: itemId(turnId, item.id),
-		parent,
-		time
+function notice(text) {
+	return {
+		type: "notice",
+		uuid: randomUUID(),
+		time: Date.now(),
+		text,
+		isError: true
 	};
-	switch (item.type) {
-		case "userMessage": return [{
-			...base,
-			kind: "user",
-			text: item.content.flatMap((input) => userText$1(input)).join("\n").trim(),
-			images: item.content.flatMap((input) => userImages(input)),
-			format: "text"
-		}];
-		case "agentMessage": return item.text.trim() === "" ? [] : [{
-			...base,
-			kind: "assistant",
-			text: item.text,
-			message: base.id
-		}];
-		case "reasoning": {
-			const text = [...item.summary, ...item.content].join("\n\n").trim();
-			return text === "" ? [] : [{
-				...base,
-				kind: "reasoning",
-				text
-			}];
-		}
-		case "plan": return [{
-			...base,
-			kind: "plan",
-			plan: item.text
-		}];
-		case "commandExecution": return [{
-			...base,
-			kind: "command",
-			command: item.command,
-			description: "",
-			output: item.aggregatedOutput ?? "",
-			status: statuses$1[item.status],
-			background: null
-		}];
-		case "fileChange": return item.changes.map((change, index) => ({
-			...base,
-			id: `${base.id}:${index}`,
-			kind: "file_change",
-			path: change.path,
-			diffs: change.kind.type === "add" ? [{
+}
+function contextTokens(message) {
+	if (!isRecord(message) || !isRecord(message.usage)) return null;
+	const usage = message.usage;
+	return [
+		usage.input_tokens,
+		usage.cache_creation_input_tokens,
+		usage.cache_read_input_tokens,
+		usage.output_tokens
+	].reduce((total, value) => total + (typeof value === "number" ? value : 0), 0);
+}
+function answersOf(output) {
+	if (!isRecord(output) || !isRecord(output.answers)) return null;
+	const answers = {};
+	for (const [question, answer] of Object.entries(output.answers)) {
+		if (typeof answer !== "string") return null;
+		answers[question] = answer;
+	}
+	return answers;
+}
+function toBlocks(content, answers) {
+	if (typeof content === "string") return [{
+		type: "text",
+		text: content
+	}];
+	if (!Array.isArray(content)) return [];
+	return content.flatMap((block) => {
+		if (!isRecord(block)) return [];
+		switch (block.type) {
+			case "text": return typeof block.text === "string" && !block.text.startsWith("<system-reminder>") && !block.text.startsWith("<local-command-caveat>") ? [{
+				type: "text",
+				text: block.text
+			}] : [];
+			case "thinking": return typeof block.thinking === "string" && block.thinking !== "" ? [{
+				type: "thinking",
+				thinking: block.thinking
+			}] : [];
+			case "image": {
+				const source = block.source;
+				return isRecord(source) && source.type === "base64" && typeof source.media_type === "string" && typeof source.data === "string" ? [{
+					type: "image",
+					mediaType: source.media_type,
+					data: source.data
+				}] : [];
+			}
+			case "tool_use": return typeof block.id === "string" && typeof block.name === "string" && isRecord(block.input) ? [{
+				type: "tool_use",
+				id: block.id,
+				name: block.name,
+				input: block.input
+			}] : [];
+			case "tool_result": return typeof block.tool_use_id === "string" ? [{
+				type: "tool_result",
+				toolUseId: block.tool_use_id,
+				content: toBlocks(block.content, null).filter((item) => item.type === "text"),
+				isError: block.is_error === true,
+				answers
+			}] : [];
+			default: return [];
+		}
+	});
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/lib/codex/items.ts
+const statuses$1 = {
+	inProgress: "running",
+	completed: "completed",
+	failed: "failed",
+	declined: "stopped",
+	interrupted: "stopped"
+};
+function turnItems(turns, parent) {
+	return turns.flatMap((turn) => [...turn.items.flatMap((item) => toItems$1(turn.id, item, parent, turn.startedAt === null ? null : turn.startedAt * 1e3)), ...turn.status === "failed" && turn.error !== null ? [errorItem(`${turn.id}:error`, turn.error.message)] : []]);
+}
+function itemId(turnId, id) {
+	return `${turnId}:${id}`;
+}
+function turnOf(itemId) {
+	const index = itemId.indexOf(":");
+	if (index < 0) throw new Error(`${itemId} is not a Codex item`);
+	return itemId.slice(0, index);
+}
+function errorItem(id, text) {
+	return {
+		id,
+		parent: null,
+		time: Date.now(),
+		kind: "error",
+		text
+	};
+}
+function toItems$1(turnId, item, parent, time) {
+	const base = {
+		id: itemId(turnId, item.id),
+		parent,
+		time
+	};
+	switch (item.type) {
+		case "userMessage": return [{
+			...base,
+			kind: "user",
+			text: item.content.flatMap(userText$1).join("\n").trim(),
+			images: item.content.flatMap(userImages),
+			format: "text"
+		}];
+		case "agentMessage": return item.text.trim() === "" ? [] : [{
+			...base,
+			kind: "assistant",
+			text: item.text,
+			message: base.id
+		}];
+		case "reasoning": {
+			const text = [...item.summary, ...item.content].join("\n\n").trim();
+			return text === "" ? [] : [{
+				...base,
+				kind: "reasoning",
+				text
+			}];
+		}
+		case "plan": return [{
+			...base,
+			kind: "plan",
+			plan: item.text
+		}];
+		case "commandExecution": return [{
+			...base,
+			kind: "command",
+			command: item.command,
+			description: "",
+			output: item.aggregatedOutput ?? "",
+			status: statuses$1[item.status],
+			background: null
+		}];
+		case "fileChange": return item.changes.map((change, index) => ({
+			...base,
+			id: `${base.id}:${index}`,
+			kind: "file_change",
+			path: change.path,
+			diffs: change.kind.type === "add" ? [{
 				before: "",
 				after: change.diff
 			}] : change.kind.type === "delete" ? [{
@@ -812,50 +689,293 @@ function hunks(diff) {
 	return result;
 }
 function contentText$1(content) {
-	return content.map((block) => typeof block === "object" && block !== null && "text" in block && typeof block.text === "string" ? block.text : JSON.stringify(block)).join("\n");
+	return content.map((block) => isRecord(block) && typeof block.text === "string" ? block.text : JSON.stringify(block)).join("\n");
 }
 function record$1(value) {
-	if (typeof value === "object" && value !== null && !Array.isArray(value)) return value;
-	return { value };
+	return isRecord(value) ? value : { value };
 }
 //#endregion
-//#region src/lib/live.ts
-const runs = /* @__PURE__ */ new Map();
-function activity() {
-	const result = {};
-	for (const run of runs.values()) result[run.sessionId] = {
-		running: run.running,
-		waiting: run.pending.size > 0,
-		prompted: run.prompted,
-		tasks: run.tasks
-	};
-	return result;
+//#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 pairing").option("--no-pair", "Don't create a pairing code or print pairing links").option("--pwa", "Serve the web app as an installable app that works offline");
+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";
+});
+program.command("pair").description("Creates a pairing code for another browser and prints its link").option("--name <name>", "Name to recognize this browser by").action((options) => {
+	command = "pair";
+	name = options.name ?? null;
+});
+program.command("unpair").description("Picks paired browsers to unpair").action(() => {
+	command = "unpair";
+});
+program.parse();
+const options = program.opts();
+const args = {
+	...options,
+	dir: path.resolve(options.dir),
+	command,
+	name
+};
+const serverDir = path.join(import.meta.dirname, "..");
+//#endregion
+//#region src/storage/storage.ts
+const home = args.dir;
+const lockFile = path.join(home, "server.pid");
+mkdirSync(home, { recursive: true });
+function lockHome() {
+	lock();
+	process.on("exit", () => unlinkSync(lockFile));
 }
-function broadcastActivity() {
-	broadcast({
-		type: "activity",
-		activity: activity()
-	});
+function lock() {
+	try {
+		writeFileSync(lockFile, `${process.pid}\n`, { flag: "wx" });
+		return;
+	} catch (error) {
+		if (!hasCode(error, "EEXIST")) throw error;
+	}
+	let content;
+	let modified;
+	try {
+		content = readFileSync(lockFile, "utf8");
+		modified = statSync(lockFile).mtimeMs;
+	} catch (error) {
+		if (hasCode(error, "ENOENT")) return lock();
+		throw error;
+	}
+	const pid = Number(content);
+	const validPid = Number.isInteger(pid) && pid > 0;
+	const writtenThisBoot = modified > Date.now() - os.uptime() * 1e3;
+	if (validPid && writtenThisBoot && pid !== process.pid && isRunning(pid)) {
+		consola.error(`offsite is already running for ${home} (pid ${pid})`);
+		process.exit(1);
+	}
+	unlinkSync(lockFile);
+	lock();
+}
+function isRunning(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		if (hasCode(error, "ESRCH")) return false;
+		if (hasCode(error, "EPERM")) return true;
+		throw error;
+	}
+}
+function hasCode(error, code) {
+	return error instanceof Error && "code" in error && error.code === code;
+}
+function readJson(name) {
+	try {
+		return JSON.parse(readFileSync(path.join(home, name), "utf8"));
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+function writeJson(name, value) {
+	const file = path.join(home, name);
+	mkdirSync(home, { recursive: true });
+	writeFileSync(`${file}.tmp`, `${JSON.stringify(value, null, 2)}\n`, { mode: 384 });
+	renameSync(`${file}.tmp`, file);
 }
 //#endregion
-//#region src/lib/codex/requests.ts
-function toRequest$1(requestId, method, params, items) {
-	const turnId = params.turnId;
-	switch (method) {
-		case "item/commandExecution/requestApproval": return {
-			id: requestId,
-			kind: "approval",
-			title: params.reason ?? "Run this command?",
-			canAlwaysAllow: true,
-			item: items.get(itemId(turnId, params.itemId)) ?? {
-				id: itemId(turnId, params.itemId),
-				parent: null,
-				time: Date.now(),
-				kind: "command",
-				command: params.command ?? "",
-				description: "",
-				output: "",
-				status: "running",
+//#region src/storage/config.ts
+const configFile = path.join(home, "config.json");
+const modelSetting = z.strictObject({
+	hidden: z.boolean(),
+	effort: z.string().nullable()
+});
+const configSchema = z.strictObject({
+	claudeBaseDir: z.string().refine((value) => path.isAbsolute(value), "must be an absolute path").default(path.join(os.homedir(), ".claude")),
+	enabledProviders: z.strictObject({
+		claude: z.boolean().default(true),
+		codex: z.boolean().default(true),
+		opencode: z.boolean().default(true)
+	}).prefault({}),
+	composer: z.strictObject({
+		provider: z.enum([
+			"claude",
+			"codex",
+			"opencode"
+		]).default("claude"),
+		claude: z.strictObject({
+			accountId: z.string().nullable().default(null),
+			model: z.string().nullable().default(null),
+			effort: z.enum([
+				"low",
+				"medium",
+				"high",
+				"xhigh",
+				"max"
+			]).nullable().default(null),
+			mode: z.enum([
+				"default",
+				"acceptEdits",
+				"bypassPermissions",
+				"plan",
+				"dontAsk",
+				"auto"
+			]).nullable().default("bypassPermissions"),
+			plan: z.boolean().default(false)
+		}).prefault({}),
+		codex: z.strictObject({
+			accountId: z.string().nullable().default(null),
+			model: z.string().nullable().default(null),
+			effort: z.string().nullable().default(null),
+			mode: z.enum([
+				"read-only",
+				"auto",
+				"full-access"
+			]).nullable().default("auto"),
+			plan: z.boolean().default(false)
+		}).prefault({}),
+		opencode: z.strictObject({
+			accountId: z.null().default(null),
+			model: z.string().nullable().default(null),
+			effort: z.string().nullable().default(null),
+			mode: z.string().nullable().default(null),
+			plan: z.boolean().default(false)
+		}).prefault({})
+	}).prefault({}),
+	commitMessage: z.strictObject({
+		provider: z.enum([
+			"claude",
+			"codex",
+			"opencode"
+		]).nullable().default(null),
+		accountId: z.string().nullable().default(null),
+		model: z.string().nullable().default(null)
+	}).prefault({}),
+	models: z.strictObject({
+		claude: z.record(z.string(), modelSetting).default({}),
+		codex: z.record(z.string(), modelSetting).default({}),
+		opencode: z.record(z.string(), modelSetting).default({})
+	}).prefault({}),
+	delivery: z.enum(["queue", "steer"]).default("steer"),
+	autoResolve: z.strictObject({
+		questions: z.number().positive().nullable().default(3),
+		permissions: z.number().positive().nullable().default(1),
+		permissionDecision: z.enum(["allow", "deny"]).default("allow")
+	}).prefault({}),
+	terminal: z.strictObject({
+		shell: z.strictObject({
+			macos: z.string().nullable().default(null),
+			linux: z.string().nullable().default(null),
+			windows: z.string().nullable().default(null)
+		}).prefault({}),
+		behavior: z.strictObject({
+			terminalIdentity: z.enum([
+				"offsite",
+				"ghostty",
+				"iterm2"
+			]).default("offsite"),
+			shellIntegration: z.boolean().default(true)
+		}).prefault({})
+	}).prefault({})
+});
+const defaults = configSchema.parse({});
+function platform() {
+	if (process.platform === "darwin") return "macos";
+	if (process.platform === "linux") return "linux";
+	if (process.platform === "win32") return "windows";
+	throw new Error(`unsupported platform ${process.platform}`);
+}
+function defaultShell() {
+	if (process.platform === "win32") return process.env.COMSPEC ?? "cmd.exe";
+	return os.userInfo().shell ?? "/bin/sh";
+}
+function configInfo() {
+	return {
+		config: readConfig(),
+		defaults,
+		platform: platform(),
+		defaultShell: defaultShell()
+	};
+}
+function readConfig() {
+	let user;
+	try {
+		user = readJson("config.json");
+	} catch (error) {
+		console.warn(`invalid ${configFile}, using the default config: ${error}`);
+		return structuredClone(defaults);
+	}
+	if (user === null) return structuredClone(defaults);
+	const result = configSchema.safeParse(user);
+	if (!result.success) {
+		console.warn(`invalid ${configFile}, using the default config:\n${z.prettifyError(result.error)}`);
+		return structuredClone(defaults);
+	}
+	return result.data;
+}
+function saveConfig(value) {
+	const result = configSchema.safeParse(value);
+	if (!result.success) throw new Error(z.prettifyError(result.error));
+	writeJson("config.json", result.data);
+	process.env.CLAUDE_CONFIG_DIR = result.data.claudeBaseDir;
+	broadcast({
+		type: "config",
+		config: result.data
+	});
+	return result.data;
+}
+//#endregion
+//#region src/lib/live.ts
+const runs = /* @__PURE__ */ new Map();
+function activity() {
+	const result = {};
+	for (const run of runs.values()) result[run.sessionId] = {
+		running: run.running,
+		waiting: run.pending.size > 0,
+		prompted: run.prompted,
+		tasks: run.tasks
+	};
+	return result;
+}
+function broadcastActivity() {
+	broadcast({
+		type: "activity",
+		activity: activity()
+	});
+}
+function scheduleAutoResolve(sessionId, request) {
+	if (request.kind === "plan") return;
+	const settings = readConfig().autoResolve;
+	const minutes = request.kind === "question" ? settings.questions : settings.permissions;
+	if (minutes === null) return;
+	setTimeout(async () => {
+		const run = runs.get(sessionId);
+		if (run === void 0) return;
+		try {
+			if (request.kind === "question") await run.respond(request.id, "allow", {});
+			else await run.respond(request.id, readConfig().autoResolve.permissionDecision, null);
+		} catch (error) {
+			console.warn(`could not auto-resolve ${request.id}: ${error}`);
+		}
+	}, minutes * 6e4);
+}
+//#endregion
+//#region src/lib/codex/requests.ts
+function toRequest$1(requestId, method, params, items) {
+	const turnId = params.turnId;
+	switch (method) {
+		case "item/commandExecution/requestApproval": return {
+			id: requestId,
+			kind: "approval",
+			title: params.reason ?? "Run this command?",
+			canAlwaysAllow: true,
+			item: items.get(itemId(turnId, params.itemId)) ?? {
+				id: itemId(turnId, params.itemId),
+				parent: null,
+				time: Date.now(),
+				kind: "command",
+				command: params.command ?? "",
+				description: "",
+				output: "",
+				status: "running",
 				background: null
 			}
 		};
@@ -1182,6 +1302,7 @@ var CodexRun = class CodexRun {
 			request
 		});
 		broadcastActivity();
+		scheduleAutoResolve(this.sessionId, request);
 	}
 	async startTurn(prompt) {
 		clearTimeout(this.idleTimer);
@@ -1439,1058 +1560,530 @@ 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 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 = [
-	"image/png",
-	"image/jpeg",
-	"image/gif",
-	"image/webp",
-	"image/svg+xml",
-	"image/x-icon",
-	"image/vnd.microsoft.icon"
-];
-const LOGO_LIMIT = 524288;
-function projects$1() {
-	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.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(id, patch) {
-	if (patch.name !== void 0) {
-		const name = patch.name.trim();
-		if (name === "") throw new Error("Project name cannot be empty");
-		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.update(projects$2).set({ logo: patch.logo }).where(eq(projects$2.id, id)).run();
+//#region src/lib/opencode/items.ts
+const toolStatuses = {
+	streaming: "running",
+	running: "running",
+	completed: "completed",
+	error: "failed"
+};
+const todoStatuses$1 = {
+	pending: "pending",
+	in_progress: "running",
+	completed: "completed",
+	cancelled: "completed"
+};
+function messageItems(message, parent) {
+	const base = {
+		id: message.id,
+		parent,
+		time: message.time.created
+	};
+	switch (message.type) {
+		case "user": return [{
+			...base,
+			kind: "user",
+			text: message.text,
+			images: (message.files ?? []).filter((file) => file.mime.startsWith("image/")).map((file) => ({
+				mediaType: file.mime,
+				data: file.data
+			})),
+			format: "text"
+		}];
+		case "skill": return [{
+			...base,
+			kind: "skill",
+			skill: message.name,
+			output: "",
+			status: "completed"
+		}];
+		case "shell": return [{
+			...base,
+			kind: "command",
+			command: message.command,
+			description: "",
+			output: message.output?.output ?? "",
+			status: message.status === "running" ? "running" : message.status === "exited" ? message.exit === 0 ? "completed" : "failed" : "stopped",
+			background: null
+		}];
+		case "assistant": return message.content.flatMap((part, index) => partItems(message, part, index, parent));
+		case "compaction": return message.status === "failed" ? [{
+			...errorItem(message.id, message.error.message),
+			parent
+		}] : [{
+			...base,
+			kind: "compaction"
+		}];
+		case "idle": return message.outcome === "failed" && message.error !== void 0 ? [{
+			...errorItem(message.id, message.error.message),
+			parent
+		}] : [];
+		case "agent-switched":
+		case "model-switched":
+		case "location-switched":
+		case "synthetic":
+		case "system": return [];
 	}
-	publish$1();
-	return null;
 }
-function removeProject(id) {
-	db.delete(projects$2).where(eq(projects$2.id, id)).run();
-	publish$1();
+function formQuestions(form) {
+	return form.fields.flatMap((field) => field.type === "external" ? [] : [{
+		question: questionText(field),
+		header: field.title ?? "",
+		multiSelect: field.type === "multiselect",
+		options: fieldOptions(field)
+	}]);
 }
-async function directories(input) {
-	const folder = path.resolve(expandHome(input.trim()));
-	const entries = await readdir(folder, { withFileTypes: true });
-	const parent = path.dirname(folder);
-	return {
-		path: folder,
-		parent: parent === folder ? null : parent,
-		directories: entries.filter((entry) => entry.isDirectory()).map((entry) => ({
-			name: entry.name,
-			path: path.join(folder, entry.name)
-		})).sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()))
-	};
+function formAnswer(form, answers) {
+	return Object.fromEntries(form.fields.flatMap((field) => {
+		if (field.type === "external") return [];
+		const answer = answers[questionText(field)];
+		if (answer === void 0 || answer === "") return [];
+		switch (field.type) {
+			case "string": return [[field.key, optionValue(field.options ?? [], answer)]];
+			case "multiselect": return [[field.key, answer.split(", ").map((label) => optionValue(field.options, label))]];
+			case "boolean":
+				if (answer === "Yes") return [[field.key, true]];
+				if (answer === "No") return [[field.key, false]];
+				throw new Error(`${field.key} needs Yes or No`);
+			case "number":
+			case "integer": return [[field.key, Number(answer)]];
+		}
+	}));
 }
-function publish$1() {
-	broadcast({
-		type: "projects",
-		projects: projects$1()
-	});
+function partItems(message, part, index, parent) {
+	const base = {
+		id: `${message.id}:${index}`,
+		parent,
+		time: message.time.created
+	};
+	switch (part.type) {
+		case "text": return part.text.trim() === "" ? [] : [{
+			...base,
+			kind: "assistant",
+			text: part.text,
+			message: message.id
+		}];
+		case "reasoning": return part.text.trim() === "" ? [] : [{
+			...base,
+			kind: "reasoning",
+			text: part.text.trim()
+		}];
+		case "tool": return toolItems({
+			id: `${message.id}:${part.id}`,
+			parent,
+			time: part.time.created
+		}, part);
+	}
 }
-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");
-	if (logo.length > LOGO_LIMIT) throw new Error("Use an image smaller than 384 KB");
+function toolItems(base, tool) {
+	const state = tool.state;
+	const status = toolStatuses[state.status];
+	const input = state.status === "streaming" ? {} : state.input;
+	const metadata = state.status === "streaming" ? {} : state.metadata ?? {};
+	const output = state.status === "error" ? state.error.message : state.status === "completed" ? contentText(state.content) : "";
+	switch (tool.name) {
+		case "shell": return [{
+			...base,
+			kind: "command",
+			command: text$2(input.command),
+			description: text$2(input.description),
+			output,
+			status,
+			background: null
+		}];
+		case "edit": return [{
+			...base,
+			kind: "file_change",
+			path: text$2(input.path ?? input.filePath),
+			diffs: [{
+				before: text$2(input.oldString),
+				after: text$2(input.newString)
+			}],
+			output,
+			status
+		}];
+		case "write": return [{
+			...base,
+			kind: "file_change",
+			path: text$2(input.path ?? input.filePath),
+			diffs: [{
+				before: "",
+				after: text$2(input.content)
+			}],
+			output,
+			status
+		}];
+		case "patch":
+		case "apply_patch":
+			if (!Array.isArray(metadata.files)) break;
+			return metadata.files.map((file, index) => ({
+				...base,
+				id: `${base.id}:${index}`,
+				kind: "file_change",
+				path: text$2(record(file).file),
+				diffs: hunks(text$2(record(file).patch)),
+				output,
+				status
+			}));
+		case "todowrite": return [{
+			...base,
+			kind: "todo_list",
+			steps: list$1(input.todos).map((todo) => ({
+				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$2(input.agent ?? input.subagent_type) || "Agent",
+			description: text$2(input.description),
+			agentId: typeof metadata.sessionID === "string" ? metadata.sessionID : null,
+			status
+		}];
+		case "webfetch":
+		case "websearch": return [{
+			...base,
+			kind: "web_search",
+			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$1(input.questions).map((item) => ({
+				question: text$2(record(item).question),
+				header: text$2(record(item).header),
+				multiSelect: record(item).multiple === true,
+				options: list$1(record(item).options).map((option) => ({
+					label: text$2(record(option).label),
+					description: text$2(record(option).description)
+				}))
+			}));
+			const answers = metadata.answers;
+			return [{
+				...base,
+				kind: "question",
+				questions,
+				answers: Array.isArray(answers) ? Object.fromEntries(questions.map((question, index) => [question.question, list$1(answers[index]).map(text$2).join(", ")])) : null,
+				status
+			}];
+		}
+		case "skill": return [{
+			...base,
+			kind: "skill",
+			skill: text$2(input.name),
+			output,
+			status
+		}];
+	}
+	return [{
+		...base,
+		kind: "tool",
+		name: tool.name,
+		input,
+		output,
+		status
+	}];
 }
-function expandHome(input) {
-	if (input === "~") return os.homedir();
-	if (input.startsWith("~/")) return path.join(os.homedir(), input.slice(2));
-	return input;
+function questionText(field) {
+	return field.description ?? field.title ?? field.key;
 }
-//#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
+function fieldOptions(field) {
+	switch (field.type) {
+		case "string":
+		case "multiselect": return (field.options ?? []).map((option) => ({
+			label: option.label,
+			description: option.description ?? ""
+		}));
+		case "boolean": return [{
+			label: "Yes",
+			description: ""
+		}, {
+			label: "No",
+			description: ""
+		}];
+		case "number":
+		case "integer": return [];
 	}
-};
-const refreshing = /* @__PURE__ */ new Map();
-const timers = /* @__PURE__ */ new Map();
-const providers = /* @__PURE__ */ new Map();
-let watchers = [];
-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 {
-			...item,
-			updatedAt,
-			status: record === void 0 || record.status === "active" && Date.now() - updatedAt > day ? "inactive" : record.status
-		};
-	}));
 }
-function providerStatuses() {
-	return allProviders.map((provider) => statuses[provider]);
+function optionValue(options, label) {
+	return options.find((option) => option.label === label)?.value ?? label;
 }
-function listedUpdatedAt(provider, sessionId) {
-	return listed[provider].find((item) => item.id === sessionId)?.updatedAt ?? null;
+function contentText(content) {
+	return content.map((block) => block.type === "text" ? block.text : block.uri).join("\n");
 }
-function providerOf(sessionId) {
-	const provider = runs.get(sessionId)?.provider ?? providers.get(sessionId);
-	if (provider === void 0) throw new Error("offsite does not know this session yet, reload the page");
-	return provider;
+function text$2(value) {
+	return typeof value === "string" ? value : "";
 }
-function recordInteraction(id) {
-	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 list$1(value) {
+	return Array.isArray(value) ? value : [];
 }
-function publishSessions() {
-	broadcast({
-		type: "sessions",
-		sessions: sessions()
+function record(value) {
+	return isRecord(value) ? value : {};
+}
+//#endregion
+//#region src/lib/opencode/sessions.ts
+const PAGE = 100;
+const COMMIT_LIMIT = 12e4;
+const temporary = /* @__PURE__ */ new Set();
+function openCodeInstalled() {
+	return findOpenCode() !== null;
+}
+async function openCodeCapabilities(cwd) {
+	const client = await openCode();
+	const location = { directory: cwd };
+	const [models, commands, skills, agents] = await Promise.all([
+		client.model.list({ location }),
+		client.command.list({ location }),
+		client.skill.list({ location }),
+		client.agent.list({ location })
+	]);
+	return {
+		models: models.data.filter((model) => model.enabled).map((model) => ({
+			value: `${model.providerID}/${model.id}`,
+			name: model.name,
+			description: model.providerID,
+			efforts: model.variants.map((variant) => variant.id)
+		})),
+		commands: [{
+			name: "compact",
+			description: "Summarize the conversation to free up context",
+			hint: ""
+		}, ...[...commands.data, ...skills.data].map((command) => ({
+			name: command.name,
+			description: command.description ?? "",
+			hint: ""
+		}))],
+		agents: agents.data.filter((agent) => agent.mode !== "subagent" && !agent.hidden).map((agent) => ({
+			id: agent.id,
+			name: agent.name,
+			description: agent.description ?? ""
+		}))
+	};
+}
+async function openCodeSessions(paths) {
+	if (paths.length === 0 || !openCodeInstalled()) return [];
+	const client = await openCode();
+	return (await Promise.all(paths.map(async (directory) => {
+		const found = [];
+		let cursor = null;
+		do {
+			const page = await client.session.list(cursor === null ? {
+				directory,
+				parentID: null,
+				limit: PAGE
+			} : { cursor });
+			found.push(...page.data);
+			cursor = page.data.length === PAGE ? page.cursor.next ?? null : null;
+		} while (cursor !== null);
+		return found;
+	}))).flat().filter((session) => !temporary.has(session.id));
+}
+async function openCodeHistory(sessionId, cwd) {
+	const run = openCodeRun(sessionId);
+	const client = await openCode();
+	const messages = await allMessages(client, sessionId);
+	return {
+		type: "history",
+		sessionId,
+		provider: "opencode",
+		items: messages.flatMap((message) => messageItems(message, null)),
+		requests: [...run?.pending.values() ?? []].map((item) => item.request),
+		queue: run?.queue ?? [],
+		settings: run?.settings ?? null,
+		context: run?.context ?? await contextOf(client, cwd, messages),
+		before: null,
+		partial: run?.partial ?? ""
+	};
+}
+async function openCodeAgent(agentId, parent) {
+	return (await allMessages(await openCode(), agentId)).flatMap((message) => messageItems(message, parent));
+}
+async function renameOpenCode(sessionId, title) {
+	await (await openCode()).session.update({
+		sessionID: sessionId,
+		title
 	});
 }
-function refreshAll() {
-	for (const provider of allProviders) refresh(provider);
+async function removeOpenCode(sessionId) {
+	await (await openCode()).session.remove({ sessionID: sessionId });
 }
-function refreshSessions(provider) {
-	if (timers.has(provider)) return;
-	timers.set(provider, setTimeout(() => {
-		timers.delete(provider);
-		refresh(provider);
-	}, REFRESH_DELAY));
+async function forkOpenCode(sessionId, messageId) {
+	const client = await openCode();
+	const messages = await allMessages(client, sessionId);
+	const index = messages.findIndex((message) => message.id === messageId);
+	if (index < 0) throw new Error("Cannot fork the session at that point");
+	const next = messages.at(index + 1);
+	return { sessionId: (await client.session.fork({
+		sessionID: sessionId,
+		...next === void 0 ? {} : { before: next.id }
+	})).id };
 }
-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 rewindOpenCode(request) {
+	if (request.code && !request.conversation && !request.dryRun) throw new Error("OpenCode restores files only with the conversation");
+	const client = await openCode();
+	const sessionID = request.sessionId;
+	const files = (await client.session.revert.stage({
+		sessionID,
+		messageID: request.messageId,
+		files: request.code
+	})).files ?? [];
+	const result = request.code ? {
+		files: files.map((file) => file.file),
+		insertions: sumBy(files, (file) => file.additions),
+		deletions: sumBy(files, (file) => file.deletions)
+	} : null;
+	if (request.dryRun) await client.session.revert.clear({ sessionID });
+	else await client.session.revert.commit({ sessionID });
+	return result;
 }
-async function list$1(provider) {
-	const paths = new Map(projects$1().map((project) => [project.path, project.id]));
-	const before = statuses[provider];
-	let timer;
+async function openCodeCommitMessage(cwd, model, prompt) {
+	const client = await openCode();
+	const session = await client.session.create({
+		location: { directory: cwd },
+		agent: "plan",
+		model: modelRef(model, null)
+	});
+	temporary.add(session.id);
 	try {
-		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);
+		await client.session.prompt({
+			sessionID: session.id,
+			text: prompt
+		});
+		await client.session.wait({ sessionID: session.id }, { signal: AbortSignal.timeout(COMMIT_LIMIT) });
+		const messages = await allMessages(client, session.id);
+		for (const message of messages.toReversed()) {
+			if (message.type === "idle" && message.outcome === "failed") throw new Error(message.error?.message ?? "OpenCode failed");
+			if (message.type !== "assistant") continue;
+			const text = message.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("").trim();
+			if (text !== "") return { message: text };
 		}
-	} catch (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
-		};
+		throw new Error("OpenCode did not reply");
 	} finally {
-		clearTimeout(timer);
+		await client.session.remove({ sessionID: session.id });
+		temporary.delete(session.id);
 	}
-	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
-				}];
-			});
-	}
+async function contextOf(client, cwd, messages) {
+	const last = messages.findLast((message) => message.type === "assistant" && message.tokens !== void 0);
+	if (last?.type !== "assistant" || last.tokens === void 0) return null;
+	const tokens = last.tokens;
+	const model = (await client.model.list({ location: { directory: cwd } })).data.find((item) => item.providerID === last.model.providerID && item.id === last.model.id);
+	return {
+		tokens: tokens.input + tokens.output + tokens.reasoning + tokens.cache.read + tokens.cache.write,
+		window: model?.limit.context ?? null
+	};
 }
-function watchSessions() {
-	for (const watcher of watchers) watcher.close();
-	watchers = [["claude", path.join(readConfig().claudeBaseDir, "projects")], ["codex", path.join(codexBaseDir, "sessions")]].flatMap(([provider, dir]) => {
-		try {
-			const watcher = watch(dir, { recursive: true }, () => refreshSessions(provider));
-			watcher.on("error", (error) => console.warn(`stopped watching ${dir}: ${error}`));
-			return [watcher];
-		} catch (error) {
-			if (error.code !== "ENOENT") throw error;
-			return [];
-		}
-	});
+function modelRef(value, effort) {
+	const index = value.indexOf("/");
+	if (index < 0) throw new Error(`${value} is not an OpenCode model`);
+	return {
+		providerID: value.slice(0, index),
+		id: value.slice(index + 1),
+		...effort === null ? {} : { variant: effort }
+	};
 }
-async function updateSession(id, patch) {
-	if (patch.title !== void 0) switch (providerOf(id)) {
-		case "claude":
-			await renameSession(id, patch.title);
-			break;
-		case "codex":
-			await renameThread(id, patch.title);
-			break;
-		case "opencode": await renameOpenCode(id, patch.title);
-	}
-	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);
-	const run = runs.get(id);
-	if (run !== void 0) {
-		run.stop();
-		await run.closed;
-	}
-	switch (provider) {
-		case "claude":
-			await deleteSession(id);
-			break;
-		case "codex":
-			await deleteThread(id);
-			break;
-		case "opencode": await removeOpenCode(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, projectId, messageId) {
-	const provider = providerOf(sessionId);
-	const result = await forkWith(provider, sessionId, projectPath(projectId), messageId);
-	providers.set(result.sessionId, provider);
-	recordInteraction(result.sessionId);
-	refreshSessions(provider);
-	return result;
+async function allMessages(client, sessionId) {
+	const messages = [];
+	let cursor = null;
+	do {
+		const page = await client.message.list(cursor === null ? {
+			sessionID: sessionId,
+			limit: PAGE,
+			order: "asc"
+		} : {
+			sessionID: sessionId,
+			cursor
+		});
+		messages.push(...page.data);
+		cursor = page.data.length === PAGE ? page.cursor.next ?? null : null;
+	} while (cursor !== null);
+	return messages;
 }
-async function forkWith(provider, sessionId, cwd, messageId) {
-	if (provider === "codex") return forkThread(sessionId, messageId);
-	if (provider === "opencode") return forkOpenCode(sessionId, messageId);
-	if ((await getSessionMessages(sessionId, { dir: cwd })).findIndex((item) => item.uuid === messageId) < 0) throw new Error("Cannot fork the session at that point");
-	return { sessionId: (await forkSession(sessionId, {
-		dir: cwd,
-		upToMessageId: messageId
-	})).sessionId };
+function openCodeRun(sessionId) {
+	const run = runs.get(sessionId);
+	return run?.provider === "opencode" ? run : void 0;
 }
 //#endregion
-//#region src/lib/opencode/client.ts
-const listChanges = /* @__PURE__ */ new Set([
-	"session.created",
-	"session.renamed",
-	"session.moved",
-	"session.forked",
-	"session.deleted",
-	"session.execution.succeeded",
-	"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";
-	for (const dir of (process.env.PATH ?? "").split(path.delimiter)) {
-		const candidate = path.join(dir, name);
-		if (statSync(candidate, { throwIfNoEntry: false })?.isFile()) return candidate;
+//#region src/lib/opencode/run.ts
+const IDLE_LIMIT$1 = 18e5;
+const RECENT = 30;
+const replies = {
+	allow: "once",
+	always: "always",
+	deny: "reject"
+};
+var OpenCodeRun = class OpenCodeRun {
+	provider = "opencode";
+	sessionId;
+	cwd;
+	pending = /* @__PURE__ */ new Map();
+	items = /* @__PURE__ */ new Map();
+	closed;
+	queue = [];
+	settings;
+	context = null;
+	partial = "";
+	running = false;
+	prompted = false;
+	backgroundTasks = 0;
+	tasks = {};
+	close;
+	applied;
+	loading = Promise.resolve();
+	refreshTimer;
+	idleTimer;
+	static async start(cwd, settings) {
+		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(session.id, cwd, settings, settings);
 	}
-	return null;
-}
-function openCode() {
-	connection ??= start();
-	return connection;
-}
-async function start() {
-	try {
-		const client = await connect();
-		listen(client);
-		return client;
-	} catch (error) {
-		connection = void 0;
-		throw error;
+	static async resume(sessionId, cwd, settings) {
+		const session = await (await openCode()).session.get({ sessionID: sessionId });
+		return new OpenCodeRun(sessionId, cwd, settings, sessionSettings(session, settings));
 	}
-}
-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({
-			signal: controller.signal,
-			onActivity: () => silence.refresh()
-		})) route(event);
-		console.warn("the OpenCode event stream ended");
-	} catch (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);
+	constructor(sessionId, cwd, settings, applied) {
+		this.sessionId = sessionId;
+		this.cwd = cwd;
+		this.settings = settings;
+		this.applied = applied;
+		const closed = Promise.withResolvers();
+		this.closed = closed.promise;
+		this.close = closed.resolve;
+		runs.set(sessionId, this);
+		this.armIdleTimer();
 	}
-	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;
+	async submit(prompt, delivery) {
+		if (!this.running) {
+			await this.startTurn(prompt);
+			return;
+		}
+		switch (delivery) {
+			case "steer":
+				await (await openCode()).session.prompt({
+					sessionID: this.sessionId,
+					text: prompt.text,
+					files: files(prompt),
+					delivery: "steer"
+				});
+				return;
+			case "queue":
+				this.queue = [...this.queue, {
+					id: randomUUID(),
+					prompt
+				}];
+				this.publishQueue();
 		}
-		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;
-	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("opencode");
-	const sessionId = sessionOf(event);
-	if (sessionId === null) return;
-	const run = runs.get(sessionId);
-	if (run?.provider === "opencode") run.receive(event);
-}
-function sessionOf(event) {
-	if (event.type === "form.created") return event.data.form.sessionID;
-	const data = "data" in event ? event.data : null;
-	if (typeof data === "object" && data !== null && "sessionID" in data && typeof data.sessionID === "string") return data.sessionID;
-	return null;
-}
-function openCodeRuns() {
-	return [...runs.values()].flatMap((run) => run.provider === "opencode" ? [run] : []);
-}
-//#endregion
-//#region src/lib/opencode/items.ts
-const toolStatuses = {
-	streaming: "running",
-	running: "running",
-	completed: "completed",
-	error: "failed"
-};
-const todoStatuses$1 = {
-	pending: "pending",
-	in_progress: "running",
-	completed: "completed",
-	cancelled: "completed"
-};
-function messageItems(message, parent) {
-	const base = {
-		id: message.id,
-		parent,
-		time: message.time.created
-	};
-	switch (message.type) {
-		case "user": return [{
-			...base,
-			kind: "user",
-			text: message.text,
-			images: (message.files ?? []).filter((file) => file.mime.startsWith("image/")).map((file) => ({
-				mediaType: file.mime,
-				data: file.data
-			})),
-			format: "text"
-		}];
-		case "skill": return [{
-			...base,
-			kind: "skill",
-			skill: message.name,
-			output: "",
-			status: "completed"
-		}];
-		case "shell": return [{
-			...base,
-			kind: "command",
-			command: message.command,
-			description: "",
-			output: message.output?.output ?? "",
-			status: message.status === "running" ? "running" : message.status === "exited" ? message.exit === 0 ? "completed" : "failed" : "stopped",
-			background: null
-		}];
-		case "assistant": return message.content.flatMap((part, index) => partItems(message, part, index, parent));
-		case "compaction": return message.status === "failed" ? [{
-			...errorItem(message.id, message.error.message),
-			parent
-		}] : [{
-			...base,
-			kind: "compaction"
-		}];
-		case "idle": return message.outcome === "failed" && message.error !== void 0 ? [{
-			...errorItem(message.id, message.error.message),
-			parent
-		}] : [];
-		case "agent-switched":
-		case "model-switched":
-		case "location-switched":
-		case "synthetic":
-		case "system": return [];
-	}
-}
-function formQuestions(form) {
-	return form.fields.flatMap((field) => field.type === "external" ? [] : [{
-		question: questionText(field),
-		header: field.title ?? "",
-		multiSelect: field.type === "multiselect",
-		options: fieldOptions(field)
-	}]);
-}
-function formAnswer(form, answers) {
-	return Object.fromEntries(form.fields.flatMap((field) => {
-		if (field.type === "external") return [];
-		const answer = answers[questionText(field)];
-		if (answer === void 0 || answer === "") return [];
-		switch (field.type) {
-			case "string": return [[field.key, optionValue(field.options ?? [], answer)]];
-			case "multiselect": return [[field.key, answer.split(", ").map((label) => optionValue(field.options, label))]];
-			case "boolean":
-				if (answer === "Yes") return [[field.key, true]];
-				if (answer === "No") return [[field.key, false]];
-				throw new Error(`${field.key} needs Yes or No`);
-			case "number":
-			case "integer": return [[field.key, Number(answer)]];
-		}
-	}));
-}
-function partItems(message, part, index, parent) {
-	const base = {
-		id: `${message.id}:${index}`,
-		parent,
-		time: message.time.created
-	};
-	switch (part.type) {
-		case "text": return part.text.trim() === "" ? [] : [{
-			...base,
-			kind: "assistant",
-			text: part.text,
-			message: message.id
-		}];
-		case "reasoning": return part.text.trim() === "" ? [] : [{
-			...base,
-			kind: "reasoning",
-			text: part.text.trim()
-		}];
-		case "tool": return toolItems({
-			id: `${message.id}:${part.id}`,
-			parent,
-			time: part.time.created
-		}, part);
-	}
-}
-function toolItems(base, tool) {
-	const state = tool.state;
-	const status = toolStatuses[state.status];
-	const input = state.status === "streaming" ? {} : state.input;
-	const metadata = state.status === "streaming" ? {} : state.metadata ?? {};
-	const output = state.status === "error" ? state.error.message : state.status === "completed" ? contentText(state.content) : "";
-	switch (tool.name) {
-		case "shell": return [{
-			...base,
-			kind: "command",
-			command: text$2(input.command),
-			description: text$2(input.description),
-			output,
-			status,
-			background: null
-		}];
-		case "edit": return [{
-			...base,
-			kind: "file_change",
-			path: text$2(input.path ?? input.filePath),
-			diffs: [{
-				before: text$2(input.oldString),
-				after: text$2(input.newString)
-			}],
-			output,
-			status
-		}];
-		case "write": return [{
-			...base,
-			kind: "file_change",
-			path: text$2(input.path ?? input.filePath),
-			diffs: [{
-				before: "",
-				after: text$2(input.content)
-			}],
-			output,
-			status
-		}];
-		case "patch":
-		case "apply_patch":
-			if (!Array.isArray(metadata.files)) break;
-			return metadata.files.map((file, index) => ({
-				...base,
-				id: `${base.id}:${index}`,
-				kind: "file_change",
-				path: text$2(record(file).file),
-				diffs: hunks(text$2(record(file).patch)),
-				output,
-				status
-			}));
-		case "todowrite": return [{
-			...base,
-			kind: "todo_list",
-			steps: list(input.todos).map((todo) => ({
-				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$2(input.agent ?? input.subagent_type) || "Agent",
-			description: text$2(input.description),
-			agentId: typeof metadata.sessionID === "string" ? metadata.sessionID : null,
-			status
-		}];
-		case "webfetch":
-		case "websearch": return [{
-			...base,
-			kind: "web_search",
-			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$2(record(item).question),
-				header: text$2(record(item).header),
-				multiSelect: record(item).multiple === true,
-				options: list(record(item).options).map((option) => ({
-					label: text$2(record(option).label),
-					description: text$2(record(option).description)
-				}))
-			}));
-			const answers = metadata.answers;
-			return [{
-				...base,
-				kind: "question",
-				questions,
-				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$2(input.name),
-			output,
-			status
-		}];
-	}
-	return [{
-		...base,
-		kind: "tool",
-		name: tool.name,
-		input,
-		output,
-		status
-	}];
-}
-function questionText(field) {
-	return field.description ?? field.title ?? field.key;
-}
-function fieldOptions(field) {
-	switch (field.type) {
-		case "string":
-		case "multiselect": return (field.options ?? []).map((option) => ({
-			label: option.label,
-			description: option.description ?? ""
-		}));
-		case "boolean": return [{
-			label: "Yes",
-			description: ""
-		}, {
-			label: "No",
-			description: ""
-		}];
-		case "number":
-		case "integer": return [];
-	}
-}
-function optionValue(options, label) {
-	return options.find((option) => option.label === label)?.value ?? label;
-}
-function contentText(content) {
-	return content.map((block) => block.type === "text" ? block.text : block.uri).join("\n");
-}
-function text$2(value) {
-	return typeof value === "string" ? value : "";
-}
-function list(value) {
-	return Array.isArray(value) ? value : [];
-}
-function record(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
-}
-//#endregion
-//#region src/lib/opencode/sessions.ts
-const PAGE = 100;
-const COMMIT_LIMIT = 12e4;
-const temporary = /* @__PURE__ */ new Set();
-function openCodeAccount() {
-	return {
-		id: "opencode",
-		provider: "opencode",
-		name: "OpenCode",
-		configDir: "",
-		email: null,
-		plan: null,
-		error: null,
-		limits: [],
-		linked: true,
-		valid: true
-	};
-}
-function openCodeInstalled() {
-	return findOpenCode() !== null;
-}
-async function openCodeCapabilities(cwd) {
-	const client = await openCode();
-	const location = { directory: cwd };
-	const [models, commands, skills, agents] = await Promise.all([
-		client.model.list({ location }),
-		client.command.list({ location }),
-		client.skill.list({ location }),
-		client.agent.list({ location })
-	]);
-	return {
-		models: models.data.filter((model) => model.enabled).map((model) => ({
-			value: `${model.providerID}/${model.id}`,
-			name: model.name,
-			description: model.providerID,
-			efforts: model.variants.map((variant) => variant.id)
-		})),
-		commands: [
-			{
-				name: "compact",
-				description: "Summarize the conversation to free up context",
-				hint: ""
-			},
-			...commands.data.map((command) => ({
-				name: command.name,
-				description: command.description ?? "",
-				hint: ""
-			})),
-			...skills.data.map((skill) => ({
-				name: skill.name,
-				description: skill.description ?? "",
-				hint: ""
-			}))
-		],
-		agents: agents.data.filter((agent) => agent.mode !== "subagent" && !agent.hidden).map((agent) => ({
-			id: agent.id,
-			name: agent.name,
-			description: agent.description ?? ""
-		}))
-	};
-}
-async function openCodeSessions(paths) {
-	if (paths.length === 0 || !openCodeInstalled()) return [];
-	const client = await openCode();
-	return (await Promise.all(paths.map(async (directory) => {
-		const found = [];
-		let cursor = null;
-		do {
-			const page = await client.session.list(cursor === null ? {
-				directory,
-				parentID: null,
-				limit: PAGE
-			} : { cursor });
-			found.push(...page.data);
-			cursor = page.data.length === PAGE ? page.cursor.next ?? null : null;
-		} while (cursor !== null);
-		return found;
-	}))).flat().filter((session) => !temporary.has(session.id));
-}
-async function openCodeHistory(sessionId, cwd) {
-	const run = openCodeRun(sessionId);
-	const client = await openCode();
-	const messages = await allMessages(client, sessionId);
-	return {
-		type: "history",
-		sessionId,
-		provider: "opencode",
-		items: messages.flatMap((message) => messageItems(message, null)),
-		requests: [...run?.pending.values() ?? []].map((item) => item.request),
-		queue: run?.queue ?? [],
-		settings: run?.settings ?? null,
-		context: run?.context ?? await contextOf(client, cwd, messages),
-		before: null,
-		partial: run?.partial ?? ""
-	};
-}
-async function openCodeAgent(agentId, parent) {
-	return (await allMessages(await openCode(), agentId)).flatMap((message) => messageItems(message, parent));
-}
-async function renameOpenCode(sessionId, title) {
-	await (await openCode()).session.update({
-		sessionID: sessionId,
-		title
-	});
-}
-async function removeOpenCode(sessionId) {
-	await (await openCode()).session.remove({ sessionID: sessionId });
-}
-async function forkOpenCode(sessionId, messageId) {
-	const client = await openCode();
-	const messages = await allMessages(client, sessionId);
-	const index = messages.findIndex((message) => message.id === messageId);
-	if (index < 0) throw new Error("Cannot fork the session at that point");
-	const next = messages.at(index + 1);
-	return { sessionId: (await client.session.fork({
-		sessionID: sessionId,
-		...next === void 0 ? {} : { before: next.id }
-	})).id };
-}
-async function rewindOpenCode(request) {
-	if (request.code && !request.conversation && !request.dryRun) throw new Error("OpenCode restores files only with the conversation");
-	const client = await openCode();
-	const sessionID = request.sessionId;
-	const files = (await client.session.revert.stage({
-		sessionID,
-		messageID: request.messageId,
-		files: request.code
-	})).files ?? [];
-	const result = request.code ? {
-		files: files.map((file) => file.file),
-		insertions: files.reduce((sum, file) => sum + file.additions, 0),
-		deletions: files.reduce((sum, file) => sum + file.deletions, 0)
-	} : null;
-	if (request.dryRun) await client.session.revert.clear({ sessionID });
-	else await client.session.revert.commit({ sessionID });
-	return result;
-}
-async function openCodeCommitMessage(cwd, model, prompt) {
-	const client = await openCode();
-	const session = await client.session.create({
-		location: { directory: cwd },
-		agent: "plan",
-		model: modelRef(model, null)
-	});
-	temporary.add(session.id);
-	try {
-		await client.session.prompt({
-			sessionID: session.id,
-			text: prompt
-		});
-		await client.session.wait({ sessionID: session.id }, { signal: AbortSignal.timeout(COMMIT_LIMIT) });
-		const messages = await allMessages(client, session.id);
-		for (const message of messages.toReversed()) {
-			if (message.type === "idle" && message.outcome === "failed") throw new Error(message.error?.message ?? "OpenCode failed");
-			if (message.type !== "assistant") continue;
-			const text = message.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("").trim();
-			if (text !== "") return { message: text };
-		}
-		throw new Error("OpenCode did not reply");
-	} finally {
-		await client.session.remove({ sessionID: session.id });
-		temporary.delete(session.id);
-	}
-}
-async function contextOf(client, cwd, messages) {
-	const last = messages.findLast((message) => message.type === "assistant" && message.tokens !== void 0);
-	if (last?.type !== "assistant" || last.tokens === void 0) return null;
-	const tokens = last.tokens;
-	const model = (await client.model.list({ location: { directory: cwd } })).data.find((item) => item.providerID === last.model.providerID && item.id === last.model.id);
-	return {
-		tokens: tokens.input + tokens.output + tokens.reasoning + tokens.cache.read + tokens.cache.write,
-		window: model?.limit.context ?? null
-	};
-}
-function modelRef(value, effort) {
-	const index = value.indexOf("/");
-	if (index < 0) throw new Error(`${value} is not an OpenCode model`);
-	return {
-		providerID: value.slice(0, index),
-		id: value.slice(index + 1),
-		...effort === null ? {} : { variant: effort }
-	};
-}
-async function allMessages(client, sessionId) {
-	const messages = [];
-	let cursor = null;
-	do {
-		const page = await client.message.list(cursor === null ? {
-			sessionID: sessionId,
-			limit: PAGE,
-			order: "asc"
-		} : {
-			sessionID: sessionId,
-			cursor
-		});
-		messages.push(...page.data);
-		cursor = page.data.length === PAGE ? page.cursor.next ?? null : null;
-	} while (cursor !== null);
-	return messages;
-}
-function openCodeRun(sessionId) {
-	const run = runs.get(sessionId);
-	return run?.provider === "opencode" ? run : void 0;
-}
-//#endregion
-//#region src/lib/opencode/run.ts
-const IDLE_LIMIT$1 = 18e5;
-const RECENT = 30;
-const replies = {
-	allow: "once",
-	always: "always",
-	deny: "reject"
-};
-var OpenCodeRun = class OpenCodeRun {
-	provider = "opencode";
-	sessionId;
-	cwd;
-	pending = /* @__PURE__ */ new Map();
-	items = /* @__PURE__ */ new Map();
-	closed;
-	queue = [];
-	settings;
-	context = null;
-	partial = "";
-	running = false;
-	prompted = false;
-	backgroundTasks = 0;
-	tasks = {};
-	close;
-	applied;
-	loading = Promise.resolve();
-	refreshTimer;
-	idleTimer;
-	static async start(cwd, settings) {
-		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(session.id, cwd, settings, settings);
-	}
-	static async resume(sessionId, cwd, settings) {
-		const session = await (await openCode()).session.get({ sessionID: sessionId });
-		return new OpenCodeRun(sessionId, cwd, settings, sessionSettings(session, settings));
-	}
-	constructor(sessionId, cwd, settings, applied) {
-		this.sessionId = sessionId;
-		this.cwd = cwd;
-		this.settings = settings;
-		this.applied = applied;
-		const closed = Promise.withResolvers();
-		this.closed = closed.promise;
-		this.close = closed.resolve;
-		runs.set(sessionId, this);
-		this.armIdleTimer();
-	}
-	async submit(prompt, delivery) {
-		if (!this.running) {
-			await this.startTurn(prompt);
-			return;
-		}
-		switch (delivery) {
-			case "steer":
-				await (await openCode()).session.prompt({
-					sessionID: this.sessionId,
-					text: prompt.text,
-					files: files(prompt),
-					delivery: "steer"
-				});
-				return;
-			case "queue":
-				this.queue = [...this.queue, {
-					id: randomUUID(),
-					prompt
-				}];
-				this.publishQueue();
-		}
-	}
-	unqueue(id) {
-		this.queue = this.queue.filter((item) => item.id !== id);
-		this.publishQueue();
+	unqueue(id) {
+		this.queue = this.queue.filter((item) => item.id !== id);
+		this.publishQueue();
 	}
 	steer(id) {
 		const item = this.queue.find((queued) => queued.id === id);
@@ -2616,187 +2209,704 @@ var OpenCodeRun = class OpenCodeRun {
 			context
 		});
 	}
-	async startTurn(prompt) {
-		clearTimeout(this.idleTimer);
-		this.running = true;
-		this.prompted = true;
-		broadcastActivity();
-		try {
-			await this.apply();
-			await this.send(prompt);
-		} catch (error) {
-			this.running = false;
-			broadcastActivity();
-			this.armIdleTimer();
-			throw error;
-		}
+	async startTurn(prompt) {
+		clearTimeout(this.idleTimer);
+		this.running = true;
+		this.prompted = true;
+		broadcastActivity();
+		try {
+			await this.apply();
+			await this.send(prompt);
+		} catch (error) {
+			this.running = false;
+			broadcastActivity();
+			this.armIdleTimer();
+			throw error;
+		}
+	}
+	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 client.session.compact({ sessionID });
+				return;
+			}
+			if ((await client.command.list({ location })).data.some((command) => command.name === match[1])) {
+				await client.session.command({
+					sessionID,
+					name: match[1],
+					text: match[2],
+					files: files(prompt)
+				});
+				return;
+			}
+			const skill = (await client.skill.list({ location })).data.find((item) => item.name === match[1]);
+			if (skill !== void 0) {
+				await client.session.prompt({
+					sessionID,
+					text: match[2],
+					files: files(prompt),
+					skills: [{ id: skill.id }]
+				});
+				return;
+			}
+		}
+		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 client.session.switchModel({
+			sessionID: this.sessionId,
+			model: modelRef(model, settings.effort)
+		});
+		if (settings.mode !== null && settings.mode !== this.applied.mode) await client.session.switchAgent({
+			sessionID: this.sessionId,
+			agent: settings.mode
+		});
+		this.applied = {
+			...settings,
+			model,
+			mode: settings.mode ?? this.applied.mode
+		};
+	}
+	ask(permission) {
+		const source = permission.source;
+		const item = source === void 0 ? void 0 : this.items.get(`${source.messageID}:${source.id}`);
+		this.addPending({
+			kind: "permission",
+			request: {
+				id: permission.id,
+				kind: "approval",
+				title: permission.message ?? `Allow ${permission.action} ${permission.resources.join(", ")}?`,
+				canAlwaysAllow: (permission.save ?? []).length > 0,
+				item: item ?? {
+					id: permission.id,
+					parent: null,
+					time: Date.now(),
+					kind: "tool",
+					name: permission.action,
+					input: { resources: permission.resources },
+					output: "",
+					status: "running"
+				}
+			}
+		});
+	}
+	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, {
+			type: "request",
+			sessionId: this.sessionId,
+			request: pending.request
+		});
+		broadcastActivity();
+		scheduleAutoResolve(this.sessionId, pending.request);
+	}
+	finishTurn() {
+		this.partial = "";
+		const [next, ...rest] = this.queue;
+		if (next !== void 0) {
+			this.queue = rest;
+			this.publishQueue();
+			this.startTurn(next.prompt).catch((error) => this.fail(error));
+			return;
+		}
+		this.running = false;
+		broadcastActivity();
+		this.armIdleTimer();
+	}
+	settle(requestId) {
+		if (!this.pending.delete(requestId)) return;
+		publish$2(this.sessionId, {
+			type: "requestDone",
+			sessionId: this.sessionId,
+			requestId
+		});
+		broadcastActivity();
+	}
+	put(items) {
+		if (items.length === 0) return;
+		for (const item of items) this.items.set(item.id, item);
+		if (items.some((item) => item.kind === "assistant")) this.partial = "";
+		publish$2(this.sessionId, {
+			type: "items",
+			sessionId: this.sessionId,
+			items
+		});
+	}
+	fail(error) {
+		this.put([errorItem(randomUUID(), error instanceof Error ? error.message : String(error))]);
+	}
+	armIdleTimer() {
+		clearTimeout(this.idleTimer);
+		if (this.running) return;
+		this.idleTimer = setTimeout(() => {
+			if (!this.running && this.pending.size === 0) this.stop();
+		}, IDLE_LIMIT$1);
+	}
+	end() {
+		clearTimeout(this.idleTimer);
+		clearTimeout(this.refreshTimer);
+		for (const requestId of [...this.pending.keys()]) this.settle(requestId);
+		this.running = false;
+		broadcastActivity();
+		this.close();
+	}
+	publishQueue() {
+		publish$2(this.sessionId, {
+			type: "queue",
+			sessionId: this.sessionId,
+			queue: this.queue
+		});
+	}
+};
+function sessionSettings(session, settings) {
+	const variant = session.model?.variant;
+	return {
+		...settings,
+		model: session.model === void 0 ? null : `${session.model.providerID}/${session.model.id}`,
+		effort: variant === void 0 || variant === "default" ? null : variant,
+		mode: session.agent ?? null
+	};
+}
+function files(prompt) {
+	return prompt.images.map((image) => ({ uri: `data:${image.mediaType};base64,${image.data}` }));
+}
+//#endregion
+//#region src/storage/db.ts
+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") });
+//#endregion
+//#region src/storage/schema.ts
+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 pairingCodes = snakeCase.table("pairing_codes", {
+	hash: text().primaryKey(),
+	name: text(),
+	expiresAt: integer().notNull()
+});
+const devices = snakeCase.table("devices", {
+	hash: text().primaryKey(),
+	name: text(),
+	createdAt: integer().notNull(),
+	expiresAt: integer().notNull(),
+	lastUsedAt: integer()
+});
+const pushSubscriptions = snakeCase.table("push_subscriptions", {
+	endpoint: text().primaryKey(),
+	p256dh: text().notNull(),
+	auth: text().notNull(),
+	publicKey: text().notNull(),
+	privateKey: text().notNull(),
+	machine: text().notNull(),
+	server: text().notNull()
+});
+//#endregion
+//#region src/services/projects.ts
+const LOGO_TYPES = [
+	"image/png",
+	"image/jpeg",
+	"image/gif",
+	"image/webp",
+	"image/svg+xml",
+	"image/x-icon",
+	"image/vnd.microsoft.icon"
+];
+const LOGO_LIMIT = 524288;
+function projects$1() {
+	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.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(id, patch) {
+	if (patch.name !== void 0) {
+		const name = patch.name.trim();
+		if (name === "") throw new Error("Project name cannot be empty");
+		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.update(projects$2).set({ logo: patch.logo }).where(eq(projects$2.id, id)).run();
 	}
-	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 client.session.compact({ sessionID });
-				return;
-			}
-			if ((await client.command.list({ location })).data.some((command) => command.name === match[1])) {
-				await client.session.command({
-					sessionID,
-					name: match[1],
-					text: match[2],
-					files: files(prompt)
-				});
-				return;
-			}
-			const skill = (await client.skill.list({ location })).data.find((item) => item.name === match[1]);
-			if (skill !== void 0) {
-				await client.session.prompt({
-					sessionID,
-					text: match[2],
-					files: files(prompt),
-					skills: [{ id: skill.id }]
-				});
-				return;
-			}
-		}
-		await client.session.prompt({
-			sessionID,
-			text: prompt.text,
-			files: files(prompt)
-		});
+	publish$1();
+	return null;
+}
+function removeProject(id) {
+	db.delete(projects$2).where(eq(projects$2.id, id)).run();
+	publish$1();
+}
+async function directories(input) {
+	const folder = path.resolve(expandHome(input.trim()));
+	const entries = await readdir(folder, { withFileTypes: true });
+	const parent = path.dirname(folder);
+	return {
+		path: folder,
+		parent: parent === folder ? null : parent,
+		directories: entries.filter((entry) => entry.isDirectory()).map((entry) => ({
+			name: entry.name,
+			path: path.join(folder, entry.name)
+		})).sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()))
+	};
+}
+function publish$1() {
+	broadcast({
+		type: "projects",
+		projects: projects$1()
+	});
+}
+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");
+	if (logo.length > LOGO_LIMIT) throw new Error("Use an image smaller than 384 KB");
+}
+function expandHome(input) {
+	if (input === "~") return os.homedir();
+	if (input.startsWith("~/")) return path.join(os.homedir(), input.slice(2));
+	return 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
 	}
-	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 client.session.switchModel({
-			sessionID: this.sessionId,
-			model: modelRef(model, settings.effort)
-		});
-		if (settings.mode !== null && settings.mode !== this.applied.mode) await client.session.switchAgent({
-			sessionID: this.sessionId,
-			agent: settings.mode
-		});
-		this.applied = {
-			...settings,
-			model,
-			mode: settings.mode ?? this.applied.mode
+};
+const refreshing = /* @__PURE__ */ new Map();
+const timers = /* @__PURE__ */ new Map();
+const providers = /* @__PURE__ */ new Map();
+let watchers = [];
+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 {
+			...item,
+			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);
+	if (provider === void 0) throw new Error("offsite does not know this session yet, reload the page");
+	return provider;
+}
+function recordInteraction(id) {
+	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;
 	}
-	ask(permission) {
-		const source = permission.source;
-		const item = source === void 0 ? void 0 : this.items.get(`${source.messageID}:${source.id}`);
-		this.addPending({
-			kind: "permission",
-			request: {
-				id: permission.id,
-				kind: "approval",
-				title: permission.message ?? `Allow ${permission.action} ${permission.resources.join(", ")}?`,
-				canAlwaysAllow: (permission.save ?? []).length > 0,
-				item: item ?? {
-					id: permission.id,
-					parent: null,
-					time: Date.now(),
-					kind: "tool",
-					name: permission.action,
-					input: { resources: permission.resources },
-					output: "",
-					status: "running"
-				}
-			}
-		});
+	const entry = { again: true };
+	refreshing.set(provider, entry);
+	while (entry.again) {
+		entry.again = false;
+		await list(provider);
 	}
-	askForm(form) {
-		this.addPending({
-			kind: "form",
-			request: {
-				id: form.id,
-				kind: "question",
-				questions: formQuestions(form)
-			},
-			form
+	refreshing.delete(provider);
+}
+async function list(provider) {
+	const paths = new Map(projects$1().map((project) => [project.path, project.id]));
+	const before = statuses[provider];
+	let timer;
+	try {
+		if (!readConfig().enabledProviders[provider]) {
+			listed[provider] = [];
+			statuses[provider] = {
+				provider,
+				state: "disabled",
+				error: null
+			};
+			return;
+		}
+		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) {
+		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()
 		});
 	}
-	addPending(pending) {
-		this.pending.set(pending.request.id, pending);
-		publish$2(this.sessionId, {
-			type: "request",
-			sessionId: this.sessionId,
-			request: pending.request
-		});
-		broadcastActivity();
+}
+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
+				}];
+			});
 	}
-	finishTurn() {
-		this.partial = "";
-		const [next, ...rest] = this.queue;
-		if (next !== void 0) {
-			this.queue = rest;
-			this.publishQueue();
-			this.startTurn(next.prompt).catch((error) => this.fail(error));
-			return;
+}
+function watchSessions() {
+	for (const watcher of watchers) watcher.close();
+	watchers = [["claude", path.join(readConfig().claudeBaseDir, "projects")], ["codex", path.join(codexBaseDir, "sessions")]].flatMap(([provider, dir]) => {
+		if (!readConfig().enabledProviders[provider]) return [];
+		try {
+			const watcher = watch(dir, { recursive: true }, () => refreshSessions(provider));
+			watcher.on("error", (error) => console.warn(`stopped watching ${dir}: ${error}`));
+			return [watcher];
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+			return [];
 		}
-		this.running = false;
-		broadcastActivity();
-		this.armIdleTimer();
+	});
+}
+async function updateSession(id, patch) {
+	if (patch.title !== void 0) switch (providerOf(id)) {
+		case "claude":
+			await renameSession(id, patch.title);
+			break;
+		case "codex":
+			await renameThread(id, patch.title);
+			break;
+		case "opencode": await renameOpenCode(id, patch.title);
 	}
-	settle(requestId) {
-		if (!this.pending.delete(requestId)) return;
-		publish$2(this.sessionId, {
-			type: "requestDone",
-			sessionId: this.sessionId,
-			requestId
-		});
-		broadcastActivity();
+	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);
+	const run = runs.get(id);
+	if (run !== void 0) {
+		run.stop();
+		await run.closed;
 	}
-	put(items) {
-		if (items.length === 0) return;
-		for (const item of items) this.items.set(item.id, item);
-		if (items.some((item) => item.kind === "assistant")) this.partial = "";
-		publish$2(this.sessionId, {
-			type: "items",
-			sessionId: this.sessionId,
-			items
-		});
+	switch (provider) {
+		case "claude":
+			await deleteSession(id);
+			break;
+		case "codex":
+			await deleteThread(id);
+			break;
+		case "opencode": await removeOpenCode(id);
 	}
-	fail(error) {
-		this.put([errorItem(randomUUID(), error instanceof Error ? error.message : String(error))]);
+	db.delete(sessions$1).where(eq(sessions$1.sessionId, id)).run();
+	listed[provider] = listed[provider].filter((item) => item.id !== id);
+}
+async function fork(sessionId, projectId, messageId) {
+	const provider = providerOf(sessionId);
+	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) {
+	if (provider === "codex") return forkThread(sessionId, messageId);
+	if (provider === "opencode") return forkOpenCode(sessionId, messageId);
+	if ((await getSessionMessages(sessionId, { dir: cwd })).findIndex((item) => item.uuid === messageId) < 0) throw new Error("Cannot fork the session at that point");
+	return { sessionId: (await forkSession(sessionId, {
+		dir: cwd,
+		upToMessageId: messageId
+	})).sessionId };
+}
+//#endregion
+//#region src/lib/opencode/client.ts
+const listChanges = /* @__PURE__ */ new Set([
+	"session.created",
+	"session.renamed",
+	"session.moved",
+	"session.forked",
+	"session.deleted",
+	"session.execution.succeeded",
+	"session.execution.failed",
+	"session.execution.interrupted"
+]);
+const SILENCE_LIMIT$1 = 45e3;
+const RECONNECT_ATTEMPTS = 5;
+const RECONNECT_DELAY = 2e3;
+let connection;
+let listener;
+function findOpenCode() {
+	const name = process.platform === "win32" ? "opencode.exe" : "opencode";
+	for (const dir of (process.env.PATH ?? "").split(path.delimiter)) {
+		const candidate = path.join(dir, name);
+		if (statSync(candidate, { throwIfNoEntry: false })?.isFile()) return candidate;
 	}
-	armIdleTimer() {
-		clearTimeout(this.idleTimer);
-		if (this.running) return;
-		this.idleTimer = setTimeout(() => {
-			if (!this.running && this.pending.size === 0) this.stop();
-		}, IDLE_LIMIT$1);
+	return null;
+}
+function openCode() {
+	connection ??= start();
+	return connection;
+}
+function disconnectOpenCode() {
+	const controller = listener;
+	listener = void 0;
+	connection = void 0;
+	controller?.abort();
+}
+async function start() {
+	try {
+		const client = await connect();
+		listen(client);
+		return client;
+	} catch (error) {
+		connection = void 0;
+		throw error;
 	}
-	end() {
-		clearTimeout(this.idleTimer);
-		clearTimeout(this.refreshTimer);
-		for (const requestId of [...this.pending.keys()]) this.settle(requestId);
-		this.running = false;
-		broadcastActivity();
-		this.close();
+}
+async function connect() {
+	const endpoint = await ensure();
+	return OpenCode.make({
+		baseUrl: endpoint.url,
+		headers: headers(endpoint)
+	});
+}
+async function listen(client) {
+	const controller = new AbortController();
+	listener = controller;
+	const silence = setTimeout(() => controller.abort(), SILENCE_LIMIT$1);
+	try {
+		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) {
+		if (listener !== controller) return;
+		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);
+	}
+	if (listener !== controller) return;
+	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;
 	}
-	publishQueue() {
-		publish$2(this.sessionId, {
-			type: "queue",
-			sessionId: this.sessionId,
-			queue: this.queue
-		});
+	console.warn(`could not reconnect to OpenCode: ${failure}`);
+	connection = void 0;
+	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);
 	}
-};
-function sessionSettings(session, settings) {
-	const variant = session.model?.variant;
-	return {
-		...settings,
-		model: session.model === void 0 ? null : `${session.model.providerID}/${session.model.id}`,
-		effort: variant === void 0 || variant === "default" ? null : variant,
-		mode: session.agent ?? null
-	};
+	refreshSessions("opencode");
 }
-function files(prompt) {
-	return prompt.images.map((image) => ({ uri: `data:${image.mediaType};base64,${image.data}` }));
+function route(event) {
+	if (listChanges.has(event.type)) refreshSessions("opencode");
+	const sessionId = sessionOf(event);
+	if (sessionId === null) return;
+	const run = runs.get(sessionId);
+	if (run?.provider === "opencode") run.receive(event);
+}
+function sessionOf(event) {
+	if (event.type === "form.created") return event.data.form.sessionID;
+	const data = "data" in event ? event.data : null;
+	if (isRecord(data) && typeof data.sessionID === "string") return data.sessionID;
+	return null;
+}
+function openCodeRuns() {
+	return [...runs.values()].flatMap((run) => run.provider === "opencode" ? [run] : []);
 }
 //#endregion
 //#region src/services/accounts.ts
@@ -2809,7 +2919,36 @@ function providerName(provider) {
 	return providerNames[provider];
 }
 function storedAccounts() {
-	return readJson("accounts.json") ?? [];
+	return (readJson("accounts.json") ?? []).map((item) => ({
+		id: item.id,
+		provider: item.provider,
+		name: item.name,
+		configDir: item.configDir,
+		enabled: item.enabled ?? true,
+		hiddenModels: item.hiddenModels ?? {}
+	}));
+}
+function assertEnabled(provider, accountId) {
+	if (!readConfig().enabledProviders[provider]) throw new Error(`${providerName(provider)} is disabled in Settings`);
+	if (provider === "opencode") return;
+	if (!storedAccount(provider, accountId).enabled) throw new Error("That account is disabled in Settings");
+}
+async function stopProvider(provider) {
+	const stopping = [...runs.values()].filter((run) => run.provider === provider);
+	for (const run of stopping) run.stop();
+	await Promise.all(stopping.map((run) => run.closed));
+	if (provider === "codex") stopAppServers();
+	if (provider === "opencode") disconnectOpenCode();
+	if (provider === "claude") {
+		for (const account of storedAccounts()) if (account.provider === "claude") forgetClaude(account.id);
+	}
+}
+async function stopAccount(account) {
+	const stopping = [...runs.values()].filter((run) => run.settings.accountId === account.id);
+	for (const run of stopping) run.stop();
+	await Promise.all(stopping.map((run) => run.closed));
+	if (account.provider === "codex") stopAppServer(account.configDir);
+	if (account.provider === "claude") forgetClaude(account.id);
 }
 function storedAccount(provider, accountId) {
 	if (accountId === null) throw new Error(`Add a ${providerName(provider)} account in Settings → Accounts`);
@@ -2820,49 +2959,92 @@ function storedAccount(provider, accountId) {
 }
 async function accounts() {
 	const stored = await Promise.all(storedAccounts().map((account) => {
+		if (!account.enabled || !readConfig().enabledProviders[account.provider]) return disabledAccount(account);
 		switch (account.provider) {
 			case "claude": return claudeAccount(account);
 			case "codex": return codexAccount(account);
-			case "opencode": throw new Error("OpenCode has no stored accounts");
 		}
 	}));
-	return openCodeInstalled() ? [...stored, openCodeAccount()] : stored;
+	return {
+		claudeAccounts: stored.filter((item) => item.provider === "claude"),
+		codexAccounts: stored.filter((item) => item.provider === "codex"),
+		openCode: { available: openCodeInstalled() && readConfig().enabledProviders.opencode }
+	};
+}
+function disabledAccount(account) {
+	return {
+		...account,
+		email: null,
+		plan: null,
+		error: null,
+		limits: [],
+		linked: true,
+		valid: false
+	};
 }
 async function publishAccounts() {
 	try {
 		broadcast({
 			type: "accounts",
-			accounts: await accounts()
+			...await accounts()
 		});
 	} catch (error) {
 		console.warn(`could not list accounts: ${error}`);
 	}
 }
-function capabilities(accountId, cwd) {
-	if (accountId === openCodeAccount().id) return openCodeCapabilities(cwd);
-	const account = storedAccounts().find((item) => item.id === accountId);
-	if (account === void 0) throw new Error("That account was removed");
-	switch (account.provider) {
-		case "claude": return claudeCapabilities(account, cwd);
-		case "codex": return codexCapabilities(account, cwd);
-		case "opencode": throw new Error("OpenCode has no stored accounts");
+async function capabilities(provider, accountId, cwd) {
+	assertEnabled(provider, accountId);
+	const result = await providerCapabilities(provider, accountId, cwd);
+	const settings = readConfig().models[provider];
+	const overrides = provider === "opencode" ? {} : storedAccount(provider, accountId).hiddenModels;
+	return {
+		...result,
+		defaultModel: defaultModels[provider],
+		models: result.models.map((model) => {
+			const deprecated = deprecatedModels[provider].includes(model.value);
+			const setting = settings[model.value] ?? {
+				hidden: deprecated,
+				effort: null
+			};
+			return {
+				...model,
+				deprecated,
+				hidden: overrides[model.value] ?? setting.hidden,
+				effort: setting.effort
+			};
+		})
+	};
+}
+function providerCapabilities(provider, accountId, cwd) {
+	switch (provider) {
+		case "claude": return claudeCapabilities(storedAccount(provider, accountId), cwd);
+		case "codex": return codexCapabilities(storedAccount(provider, accountId), cwd);
+		case "opencode":
+			if (accountId !== null) throw new Error("OpenCode has no accounts. Connect providers in OpenCode");
+			return openCodeCapabilities(cwd);
 	}
 }
 function addAccount(provider, name, configDir) {
-	if (provider === "opencode") throw new Error("OpenCode has no accounts. Connect providers in OpenCode");
 	saveAccounts([...storedAccounts(), {
 		id: randomUUID(),
 		provider,
-		...validAccount(name, configDir)
+		...validAccount(name, configDir),
+		enabled: true,
+		hiddenModels: {}
 	}]);
 }
-function updateAccount(id, name, configDir) {
-	const account = validAccount(name, configDir);
-	saveAccounts(storedAccounts().map((item) => item.id === id ? {
+async function updateAccount(update) {
+	const before = storedAccounts().find((item) => item.id === update.id);
+	if (before === void 0) throw new Error("That account was removed");
+	const account = validAccount(update.name, update.configDir);
+	saveAccounts(storedAccounts().map((item) => item.id === update.id ? {
 		...item,
-		...account
+		...account,
+		enabled: update.enabled,
+		hiddenModels: update.hiddenModels
 	} : item));
-	forgetClaude(id);
+	forgetClaude(update.id);
+	if (before.enabled && !update.enabled) await stopAccount(before);
 }
 function removeAccount(id) {
 	saveAccounts(storedAccounts().filter((item) => item.id !== id));
@@ -2885,81 +3067,6 @@ function saveAccounts(items) {
 	writeJson("accounts.json", items);
 }
 //#endregion
-//#region src/lib/claude/content.ts
-function toMessage(type, item, time) {
-	return {
-		type,
-		uuid: item.uuid,
-		time,
-		content: isRecord(item.message) ? toBlocks(item.message.content, answersOf(item.tool_use_result)) : [],
-		parent: item.parent_tool_use_id
-	};
-}
-function contextTokens(message) {
-	if (!isRecord(message) || !isRecord(message.usage)) return null;
-	const usage = message.usage;
-	return [
-		usage.input_tokens,
-		usage.cache_creation_input_tokens,
-		usage.cache_read_input_tokens,
-		usage.output_tokens
-	].reduce((total, value) => total + (typeof value === "number" ? value : 0), 0);
-}
-function answersOf(output) {
-	if (!isRecord(output) || !isRecord(output.answers)) return null;
-	const answers = {};
-	for (const [question, answer] of Object.entries(output.answers)) {
-		if (typeof answer !== "string") return null;
-		answers[question] = answer;
-	}
-	return answers;
-}
-function toBlocks(content, answers) {
-	if (typeof content === "string") return [{
-		type: "text",
-		text: content
-	}];
-	if (!Array.isArray(content)) return [];
-	return content.flatMap((block) => {
-		if (!isRecord(block)) return [];
-		switch (block.type) {
-			case "text": return typeof block.text === "string" && !block.text.startsWith("<system-reminder>") && !block.text.startsWith("<local-command-caveat>") ? [{
-				type: "text",
-				text: block.text
-			}] : [];
-			case "thinking": return typeof block.thinking === "string" && block.thinking !== "" ? [{
-				type: "thinking",
-				thinking: block.thinking
-			}] : [];
-			case "image": {
-				const source = block.source;
-				return isRecord(source) && source.type === "base64" && typeof source.media_type === "string" && typeof source.data === "string" ? [{
-					type: "image",
-					mediaType: source.media_type,
-					data: source.data
-				}] : [];
-			}
-			case "tool_use": return typeof block.id === "string" && typeof block.name === "string" && isRecord(block.input) ? [{
-				type: "tool_use",
-				id: block.id,
-				name: block.name,
-				input: block.input
-			}] : [];
-			case "tool_result": return typeof block.tool_use_id === "string" ? [{
-				type: "tool_result",
-				toolUseId: block.tool_use_id,
-				content: toBlocks(block.content, null).filter((item) => item.type === "text"),
-				isError: block.is_error === true,
-				answers
-			}] : [];
-			default: return [];
-		}
-	});
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-//#endregion
 //#region src/lib/claude/claude.ts
 const efforts = [
 	"low",
@@ -3002,13 +3109,15 @@ function claudeMode(value) {
 }
 function claudeOptions(accountId, cwd) {
 	const account = storedAccount("claude", accountId);
+	const env = {
+		...process.env,
+		CLAUDE_CODE_ENTRYPOINT: "offsite",
+		CLAUDE_CONFIG_DIR: account.configDir
+	};
+	if (path.resolve(account.configDir) === path.join(os.homedir(), ".claude")) delete env.CLAUDE_CONFIG_DIR;
 	return {
 		cwd,
-		env: {
-			...process.env,
-			CLAUDE_CODE_ENTRYPOINT: "offsite",
-			CLAUDE_CONFIG_DIR: account.configDir
-		},
+		env,
 		pathToClaudeCodeExecutable: executable$1,
 		systemPrompt: {
 			type: "preset",
@@ -3017,7 +3126,7 @@ function claudeOptions(accountId, cwd) {
 		hooks: { PostToolUse: [{
 			matcher: "PushNotification",
 			hooks: [async (input) => {
-				if (input.hook_event_name !== "PostToolUse" || typeof input.tool_input !== "object" || input.tool_input === null || !("message" in input.tool_input) || typeof input.tool_input.message !== "string") throw new Error("Unexpected PushNotification hook input");
+				if (input.hook_event_name !== "PostToolUse" || !isRecord(input.tool_input) || typeof input.tool_input.message !== "string") throw new Error("Unexpected PushNotification hook input");
 				broadcast({
 					type: "notification",
 					sessionId: input.session_id,
@@ -3038,12 +3147,15 @@ function claudeOptions(accountId, cwd) {
 async function claudeCapabilities(account, cwd) {
 	const result = await initialization(account.id, cwd);
 	return {
-		models: result.models.map((model) => ({
-			value: model.value,
-			name: model.displayName,
-			description: model.description,
-			efforts: model.supportedEffortLevels ?? []
-		})),
+		models: result.models.filter((model) => model.value !== "default").map((model) => {
+			if (model.resolvedModel === void 0) throw new Error(`Claude did not resolve the ${model.value} model`);
+			return {
+				value: model.resolvedModel,
+				name: model.displayName,
+				description: model.description,
+				efforts: model.supportedEffortLevels ?? []
+			};
+		}),
 		commands: result.commands.map((command) => ({
 			name: command.name,
 			description: command.description,
@@ -3104,6 +3216,28 @@ function recordLimit(accountId, info) {
 	limits.set(accountId, current);
 	return accountLimits(accountId);
 }
+async function recordUsage(accountId, probe) {
+	try {
+		const usage = await probe.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET({ skipBehaviors: true });
+		if (usage.rate_limits === null) return;
+		const current = limits.get(accountId) ?? /* @__PURE__ */ new Map();
+		const windows = {
+			five_hour: usage.rate_limits.five_hour,
+			seven_day: usage.rate_limits.seven_day,
+			seven_day_opus: usage.rate_limits.seven_day_opus,
+			seven_day_sonnet: usage.rate_limits.seven_day_sonnet
+		};
+		for (const [name, window] of Object.entries(windows)) if (window !== void 0 && window !== null) current.set(name, {
+			window: name,
+			utilization: window.utilization === null ? null : window.utilization / 100,
+			resetsAt: window.resets_at === null ? null : Date.parse(window.resets_at) / 1e3,
+			rejected: window.utilization !== null && window.utilization >= 100
+		});
+		limits.set(accountId, current);
+	} catch (error) {
+		console.warn(`could not read Claude usage limits: ${error}`);
+	}
+}
 function isLinked(configDir) {
 	const base = readConfig().claudeBaseDir;
 	try {
@@ -3133,7 +3267,9 @@ async function runProbe(accountId, cwd) {
 		options: claudeOptions(accountId, cwd)
 	});
 	try {
-		return await probe.initializationResult();
+		const result = await probe.initializationResult();
+		await recordUsage(accountId, probe);
+		return result;
 	} finally {
 		closed.resolve();
 		probe.close();
@@ -3192,14 +3328,15 @@ function toItems(messages) {
 		}
 		if (message.type === "assistant") {
 			message.content.forEach((block, index) => {
-				const id = `${message.uuid}:${index}`;
-				const parent = message.parent;
+				const shared = {
+					id: `${message.uuid}:${index}`,
+					parent: message.parent,
+					time: message.time
+				};
 				switch (block.type) {
 					case "text":
 						if (block.text.trim() !== "") items.push({
-							id,
-							parent,
-							time: message.time,
+							...shared,
 							kind: "assistant",
 							text: block.text,
 							message: message.uuid
@@ -3207,9 +3344,7 @@ function toItems(messages) {
 						break;
 					case "thinking":
 						if (block.thinking.trim() !== "") items.push({
-							id,
-							parent,
-							time: message.time,
+							...shared,
 							kind: "reasoning",
 							text: block.thinking
 						});
@@ -3221,7 +3356,7 @@ function toItems(messages) {
 						}
 						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) => {
+						items.push(toolItem(block, message.parent, message.time, (to) => {
 							const owner = owners.get(to);
 							return owner === void 0 ? null : items[owner].id;
 						}));
@@ -3725,12 +3860,6 @@ async function agentMessages(sessionId, cwd, agentId, parent) {
 //#endregion
 //#region src/lib/claude/run.ts
 const IDLE_LIMIT = 6e5;
-const imageTypes = [
-	"image/png",
-	"image/jpeg",
-	"image/gif",
-	"image/webp"
-];
 var Run = class {
 	provider = "claude";
 	sessionId;
@@ -3860,42 +3989,10 @@ var Run = class {
 	}
 	push(prompt, priority) {
 		clearTimeout(this.idleTimer);
-		for (const image of prompt.images) if (!imageTypes.includes(image.mediaType)) throw new Error(`${image.mediaType} images are not supported`);
 		const uuid = randomUUID();
-		this.inbox.push({
-			type: "user",
-			message: {
-				role: "user",
-				content: [...prompt.images.map((image) => ({
-					type: "image",
-					source: {
-						type: "base64",
-						media_type: image.mediaType,
-						data: image.data
-					}
-				})), ...prompt.text === "" ? [] : [{
-					type: "text",
-					text: prompt.text
-				}]]
-			},
-			parent_tool_use_id: null,
-			uuid,
-			...priority === void 0 ? {} : { priority }
-		});
+		this.inbox.push(toUserInput(prompt, uuid, priority));
 		this.wake?.();
-		this.add({
-			type: "user",
-			uuid,
-			time: Date.now(),
-			content: [...prompt.images.map((image) => ({
-				type: "image",
-				...image
-			})), ...prompt.text === "" ? [] : [{
-				type: "text",
-				text: prompt.text
-			}]],
-			parent: null
-		});
+		this.add(promptMessage(prompt, uuid));
 		this.running = true;
 		this.prompted = true;
 		broadcastActivity();
@@ -4089,6 +4186,7 @@ var Run = class {
 				request
 			});
 			broadcastActivity();
+			scheduleAutoResolve(this.sessionId, request);
 			options.signal.addEventListener("abort", () => this.settle(request.id, {
 				behavior: "deny",
 				message: "Cancelled"
@@ -4139,21 +4237,13 @@ var Run = class {
 		});
 	}
 };
-function notice(text) {
-	return {
-		type: "notice",
-		uuid: randomUUID(),
-		time: Date.now(),
-		text,
-		isError: true
-	};
-}
 //#endregion
 //#region src/services/git.ts
 const DIFF_LIMIT = 8e4;
 const UNTRACKED_LIMIT = 100;
 const NEW_FILE_LIMIT = 262144;
 const REPO_DEPTH = 3;
+const run$1 = promisify(execFile);
 async function gitStatus(cwd) {
 	let output;
 	try {
@@ -4207,20 +4297,24 @@ async function push$1(cwd) {
 	return gitStatus(cwd);
 }
 async function createPullRequest(cwd) {
-	const { stdout } = await promisify(execFile)("gh", [
+	const url = (await run$1("gh", [
 		"pr",
 		"create",
 		"--fill"
-	], { cwd });
-	const url = stdout.trim().split("\n").at(-1);
+	], { cwd })).stdout.trim().split("\n").at(-1);
 	if (url === void 0) throw new Error("gh did not return a pull request URL");
 	return { url };
 }
-async function suggestCommitMessage(provider, accountId, cwd) {
-	const diff = (await workingDiff(cwd)).slice(0, DIFF_LIMIT);
+async function suggestCommitMessage(cwd) {
+	const settings = readConfig().commitMessage;
+	const provider = settings.provider;
+	const accountId = settings.accountId;
+	const model = settings.model;
+	if (provider === null || model === null) throw new Error("Choose a commit message model in Settings → Git");
+	assertEnabled(provider, accountId);
+	if (!await isRepo(cwd)) throw new Error(`${cwd} is not a git repository`);
+	const diff = (await repoDiff(cwd, "")).slice(0, DIFF_LIMIT);
 	if (diff === "") throw new Error("There is nothing to commit");
-	const model = readConfig().commitModels[provider];
-	if (model === null) throw new Error(`Choose a ${providerName(provider)} commit model in Settings → Accounts`);
 	const prompt = `Write a git commit message for this diff. Reply with only the message: a short summary line, optionally followed by a blank line and a brief body.\n\n${diff}`;
 	if (provider === "codex") return codexCommitMessage(accountId, cwd, model, prompt);
 	if (provider === "opencode") return openCodeCommitMessage(cwd, model, prompt);
@@ -4243,10 +4337,6 @@ async function suggestCommitMessage(provider, accountId, cwd) {
 	}
 	throw new Error("Claude did not reply");
 }
-async function workingDiff(cwd) {
-	if (!await isRepo(cwd)) throw new Error(`${cwd} is not a git repository`);
-	return repoDiff(cwd, "");
-}
 async function projectDiff(cwd) {
 	if (await isRepo(cwd)) return repoDiff(cwd, "");
 	const repos = childRepos(cwd, "", REPO_DEPTH);
@@ -4254,7 +4344,7 @@ async function projectDiff(cwd) {
 	return (await Promise.all(repos.map((repo) => repoDiff(path.join(cwd, repo), `${repo}/`)))).join("");
 }
 function git(cwd, args) {
-	return promisify(execFile)("git", args, {
+	return run$1("git", args, {
 		cwd,
 		maxBuffer: 67108864
 	});
@@ -4403,7 +4493,7 @@ async function taskOutput(sessionId, file) {
 	try {
 		stats = await lstat(file);
 	} catch (error) {
-		if (error instanceof Error && "code" in error && error.code === "ENOENT") return null;
+		if (hasCode(error, "ENOENT")) return null;
 		throw error;
 	}
 	if (!stats.isFile()) throw new Error("Background task output is not a regular file");
@@ -4447,42 +4537,57 @@ const TIME_TO_LIVE = 900;
 const SEND_TIMEOUT = 1e4;
 const SUBJECT = "https://github.com/NazmusSayad/offsite";
 let server$1 = "";
+let notifier = null;
 function startPush(address) {
 	server$1 = address;
 }
 function pushActive() {
-	return ours().length > 0;
+	return targets().length > 0;
+}
+function notifierClient() {
+	return notifier === null ? null : notifier.client;
 }
-function pushKey() {
-	return { publicKey: machineInfo().pushPublicKey };
+function claimNotifier(client, endpoint) {
+	notifier = {
+		client,
+		endpoint
+	};
+	for (const item of clients) item.send({
+		type: "notifier",
+		active: item === client
+	});
 }
-function subscribe(subscription) {
-	if (new URL(subscription.endpoint).protocol !== "https:") throw new Error("the endpoint must be an https URL");
+function subscribe(registration, client) {
+	if (new URL(registration.subscription.endpoint).protocol !== "https:") throw new Error("the endpoint must be an https URL");
 	const values = {
-		endpoint: subscription.endpoint,
-		p256dh: subscription.keys.p256dh,
-		auth: subscription.keys.auth,
+		endpoint: registration.subscription.endpoint,
+		p256dh: registration.subscription.keys.p256dh,
+		auth: registration.subscription.keys.auth,
+		publicKey: registration.publicKey,
+		privateKey: registration.privateKey,
+		machine: registration.machine,
 		server: server$1
 	};
 	db.insert(pushSubscriptions).values(values).onConflictDoUpdate({
 		target: pushSubscriptions.endpoint,
 		set: values
 	}).run();
+	if (notifier !== null && notifier.client === client) notifier.endpoint = registration.subscription.endpoint;
 	console.log("a browser subscribed to push notifications");
 }
 function unsubscribe(endpoint) {
 	db.delete(pushSubscriptions).where(eq(pushSubscriptions.endpoint, endpoint)).run();
+	if (notifier !== null && notifier.endpoint === endpoint) notifier.endpoint = null;
 	console.log("a browser unsubscribed from push notifications");
 }
 async function sendPush(message) {
-	const subscriptions = ours();
+	const subscriptions = targets();
 	if (subscriptions.length === 0) return;
-	const keys = machineInfo();
-	const payload = JSON.stringify({
+	const trimmed = {
 		...message,
 		title: [...message.title].slice(0, TITLE_LIMIT).join(""),
 		body: [...message.body].slice(0, BODY_LIMIT).join("")
-	});
+	};
 	const gone = [];
 	await Promise.all(subscriptions.map(async (subscription) => {
 		try {
@@ -4492,11 +4597,14 @@ async function sendPush(message) {
 					p256dh: subscription.p256dh,
 					auth: subscription.auth
 				}
-			}, payload, {
+			}, JSON.stringify({
+				...trimmed,
+				machineId: subscription.machine
+			}), {
 				vapidDetails: {
 					subject: SUBJECT,
-					publicKey: keys.pushPublicKey,
-					privateKey: keys.pushPrivateKey
+					publicKey: subscription.publicKey,
+					privateKey: subscription.privateKey
 				},
 				TTL: TIME_TO_LIVE,
 				urgency: "high",
@@ -4520,8 +4628,9 @@ async function sendPush(message) {
 	if (gone.length === 0) return;
 	db.delete(pushSubscriptions).where(and(eq(pushSubscriptions.server, server$1), inArray(pushSubscriptions.endpoint, gone))).run();
 }
-function ours() {
-	return db.select().from(pushSubscriptions).where(eq(pushSubscriptions.server, server$1)).all();
+function targets() {
+	if (notifier === null || notifier.endpoint === null) return [];
+	return db.select().from(pushSubscriptions).where(and(eq(pushSubscriptions.server, server$1), eq(pushSubscriptions.endpoint, notifier.endpoint))).all();
 }
 //#endregion
 //#region src/services/runs.ts
@@ -4595,6 +4704,7 @@ async function open$1(client, sessionId, projectId) {
 	client.send(event);
 }
 async function send$1(client, request) {
+	assertEnabled(request.settings.provider, request.settings.accountId);
 	const cwd = projectPath(request.projectId);
 	if (!statSync(cwd, { throwIfNoEntry: false })?.isDirectory()) throw new Error(`${cwd} is not a folder`);
 	if (request.sessionId === null) {
@@ -4618,11 +4728,7 @@ 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, cwd)) {
-		existing.stop();
-		await existing.closed;
-	}
-	if (existing?.provider === "codex" && !existing.running && existing.pending.size === 0 && (listedUpdatedAt("codex", sessionId) ?? 0) > existing.activeAt) {
+	if (existing?.provider === "claude" && !existing.running && existing.backgroundTasks === 0 && await changedElsewhere(existing, cwd) || existing?.provider === "codex" && !existing.running && existing.pending.size === 0 && (listedUpdatedAt("codex", sessionId) ?? 0) > existing.activeAt) {
 		existing.stop();
 		await existing.closed;
 	}
@@ -4772,7 +4878,7 @@ function shellIntegrationIssue(command, platform, defaultShell) {
 }
 //#endregion
 //#region src/services/terminal/shell-integration.ts
-const scripts = path.join(serverDir, "src", "services", "terminal", "shell-integration");
+const scripts = path.join(serverDir, "src/services/terminal/shell-integration");
 const folder = path.join(home, "shell-integration");
 function prepare(env, command, shell) {
 	if (shellIntegrationIssue(command, platform(), shell) !== null) return null;
@@ -4989,7 +5095,7 @@ function launch() {
 		offsite: [
 			"offsite",
 			"offsite",
-			version
+			"0.0.0"
 		],
 		ghostty: [
 			"ghostty",
@@ -5457,7 +5563,7 @@ function scan(id, terminal, data) {
 		return;
 	}
 	const alert = terminal.scanner.scan(data);
-	if (alert === null || browserOpen()) return;
+	if (alert === null || notifierWatching()) return;
 	if (!(alert.type === "bell" ? terminal.alerts.startBell() : terminal.alerts.startNotification())) return;
 	const windowTitle = terminal.scanner.title;
 	setTimeout(() => push(id, alert, windowTitle), 500);
@@ -5474,7 +5580,7 @@ function push(id, alert, windowTitle) {
 		title = alert.title;
 		body = alert.body;
 	}
-	if (browserOpen()) return;
+	if (notifierWatching()) return;
 	const entry = [...projects].find(([, project]) => project.tabs.some((tab) => tab.id === id));
 	if (entry === void 0) return;
 	const tab = findTab(id);
@@ -5482,19 +5588,17 @@ function push(id, alert, windowTitle) {
 	sendPush({
 		title,
 		body,
-		machineId: machineInfo().id,
 		projectId: entry[0],
 		tabId: id
 	});
 }
-function browserOpen() {
-	return [...connections.values()].some((connection) => Date.now() - connection.client.heardAt < SILENCE_LIMIT);
+function notifierWatching() {
+	const client = notifierClient();
+	if (client === null || !connections.has(client)) return false;
+	return Date.now() - client.heardAt < SILENCE_LIMIT;
 }
 function findTab(id) {
-	for (const project of projects.values()) {
-		const tab = project.tabs.find((item) => item.id === id);
-		if (tab !== void 0) return tab;
-	}
+	return [...projects.values()].flatMap((project) => project.tabs).find((tab) => tab.id === id);
 }
 function nearestVisible(tabs, index) {
 	for (let position = index; position < tabs.length; position++) if (!tabs[position].minimized) return position;
@@ -5527,8 +5631,6 @@ const handlers = {
 		refreshAll();
 		return {
 			...configInfo(),
-			protocol: 3,
-			machineId: machineInfo().id,
 			hostname: os.hostname(),
 			projects: projects$1(),
 			sessions: sessions(),
@@ -5537,10 +5639,15 @@ const handlers = {
 		};
 	},
 	"config.get": () => configInfo(),
-	"config.save": (params) => {
-		const before = readConfig().claudeBaseDir;
+	"config.save": async (params) => {
+		const before = readConfig();
 		const saved = saveConfig(params);
-		if (saved.claudeBaseDir === before) return saved;
+		for (const provider of [
+			"claude",
+			"codex",
+			"opencode"
+		]) if (before.enabledProviders[provider] && !saved.enabledProviders[provider]) await stopProvider(provider);
+		if (saved.claudeBaseDir === before.claudeBaseDir && JSON.stringify(saved.enabledProviders) === JSON.stringify(before.enabledProviders)) return saved;
 		watchSessions();
 		refreshAll();
 		publishAccounts();
@@ -5630,8 +5737,8 @@ const handlers = {
 		publishAccounts();
 		return null;
 	},
-	"accounts.update": (params) => {
-		updateAccount(params.id, params.name, params.configDir);
+	"accounts.update": async (params) => {
+		await updateAccount(params);
 		publishAccounts();
 		return null;
 	},
@@ -5640,7 +5747,7 @@ const handlers = {
 		publishAccounts();
 		return null;
 	},
-	capabilities: (params) => capabilities(params.accountId, projectPath(params.projectId)),
+	capabilities: (params) => capabilities(params.provider, params.accountId, params.projectId === null ? os.homedir() : 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")),
@@ -5650,16 +5757,19 @@ const handlers = {
 	"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);
+	"git.message": (params) => suggestCommitMessage(projectPath(params.projectId)),
+	"push.subscribe": (params, client) => {
+		subscribe(params, client);
 		return null;
 	},
 	"push.unsubscribe": (params) => {
 		unsubscribe(params.endpoint);
 		return null;
 	},
+	"notifications.claim": (params, client) => {
+		claimNotifier(client, params.endpoint);
+		return null;
+	},
 	terminal: async (params, client) => {
 		await terminalRequest(client, params);
 		return null;
@@ -5717,38 +5827,58 @@ async function answer(client, text) {
 	}
 }
 //#endregion
-//#region src/storage/token.ts
-function readTokens() {
-	return db.select().from(tokens).orderBy(tokens.createdAt).all();
+//#region src/storage/auth.ts
+const CODE_LIFETIME = 3e5;
+const DEVICE_LIFETIME = 2592e6;
+function addCode(name) {
+	const code = randomBytes(16).toString("base64url");
+	db.delete(pairingCodes).where(lte(pairingCodes.expiresAt, Date.now())).run();
+	db.insert(pairingCodes).values({
+		hash: hash(code),
+		name,
+		expiresAt: Date.now() + CODE_LIFETIME
+	}).run();
+	return code;
 }
-function addToken(name) {
+function redeemCode(code) {
+	const found = db.delete(pairingCodes).where(eq(pairingCodes.hash, hash(code))).returning().get();
+	if (found === void 0 || found.expiresAt <= Date.now()) return null;
 	const token = randomBytes(32).toString("base64url");
-	db.insert(tokens).values({
-		hash: hashToken(token),
-		name,
-		createdAt: Date.now()
+	const now = Date.now();
+	db.insert(devices).values({
+		hash: hash(token),
+		name: found.name,
+		createdAt: now,
+		expiresAt: now + DEVICE_LIFETIME
 	}).run();
 	return token;
 }
-function removeTokens(hashes) {
-	db.delete(tokens).where(inArray(tokens.hash, hashes)).run();
+function findDevice(token) {
+	const found = db.select().from(devices).where(and(eq(devices.hash, hash(token)), gt(devices.expiresAt, Date.now()))).get();
+	return found === void 0 ? null : found.hash;
 }
-function hasTokens() {
-	return db.select().from(tokens).limit(1).get() !== void 0;
+function isPaired(device) {
+	return db.select().from(devices).where(and(eq(devices.hash, device), gt(devices.expiresAt, Date.now()))).get() !== void 0;
 }
-function matchesToken(given) {
-	if (given === null) return false;
-	return db.select().from(tokens).where(eq(tokens.hash, hashToken(given))).get() !== void 0;
+function hasDevices() {
+	return db.select().from(devices).where(gt(devices.expiresAt, Date.now())).limit(1).get() !== void 0;
 }
-function recordUse(token) {
-	db.update(tokens).set({ lastUsedAt: Date.now() }).where(eq(tokens.hash, hashToken(token))).run();
+function readDevices() {
+	return db.select().from(devices).orderBy(devices.createdAt).all();
 }
-function hashToken(token) {
-	return createHash("sha256").update(token).digest("hex");
+function removeDevices(hashes) {
+	db.delete(devices).where(inArray(devices.hash, hashes)).run();
+}
+function recordUse(device) {
+	db.update(devices).set({ lastUsedAt: Date.now() }).where(eq(devices.hash, device)).run();
+}
+function hash(secret) {
+	return createHash("sha256").update(secret).digest("hex");
 }
 //#endregion
 //#region src/main.ts
 const UNPAIR_CHECK = 5e3;
+const TICKET_LIFETIME = 6e4;
 const contentTypes = {
 	".html": "text/html; charset=utf-8",
 	".js": "text/javascript; charset=utf-8",
@@ -5766,17 +5896,10 @@ 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(`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}`);
+	const links = pairingLinks(addCode(args.name));
+	console.log("Open this link in a browser within 5 minutes to pair it:");
 	console.log(`  ${links.local}`);
-	if (fallback !== null) console.log(`Fallback: ${fallback}`);
 	process.exit(0);
 }
 if (args.command === "unpair") {
@@ -5792,23 +5915,17 @@ if (findClaude() === null) {
 	process.exit(1);
 }
 const publicDir = path.join(import.meta.dirname, "..", "..", "web", "dist");
-const token = args.auth && args.pair && !hasTokens() ? addToken(null) : null;
+const code = args.auth && args.pair && !hasDevices() ? addCode(null) : null;
+const tickets = /* @__PURE__ */ new Map();
 const server = createServer((request, response) => {
 	const url = new URL(request.url ?? "/", "http://localhost");
-	if (url.pathname === "/version") {
-		response.setHeader("access-control-allow-origin", "*");
-		response.setHeader("content-type", "application/json");
-		response.end(JSON.stringify({
-			version,
-			protocol: 3,
-			machineId: machineInfo().id,
-			authorized: authorized(url)
-		}));
+	if (url.pathname.startsWith("/api/")) {
+		answerApi(url.pathname, request, response);
 		return;
 	}
 	if (args.command === "serve") {
 		response.statusCode = 404;
-		response.end(`offsite serve has no web app; open ${HOSTED_APP}`);
+		response.end("offsite serve has no web app");
 		return;
 	}
 	serveFile(url.pathname, response);
@@ -5817,34 +5934,31 @@ const sockets = new WebSocketServer({ noServer: true });
 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(3) || !authorized(url)) {
+	const device = args.auth ? redeemTicket(url.searchParams.get("ticket")) : null;
+	if (url.pathname !== "/ws" || args.auth && device === null) {
 		socket.destroy();
 		return;
 	}
 	sockets.handleUpgrade(request, socket, head, (client) => {
 		connectClient(client);
-		if (!args.auth || given === null) return;
-		paired.set(client, given);
+		if (device === null) return;
+		paired.set(client, device);
 		client.on("close", () => paired.delete(client));
-		recordUse(given);
+		recordUse(device);
 	});
 });
 if (args.auth) setInterval(() => {
-	for (const [client, given] of paired) if (!matchesToken(given)) client.close();
+	for (const [client, device] of paired) if (!isPaired(device)) client.close();
+	for (const [ticket, item] of tickets) if (item.expiresAt <= Date.now()) tickets.delete(ticket);
 }, UNPAIR_CHECK);
 server.listen(port, args.host, () => {
 	startPush(`${args.host}:${port}`);
-	if (args.pair && (token !== null || !args.auth)) {
-		const links = pairingLinks(token);
+	if (args.pair && (code !== null || !args.auth)) {
+		const links = pairingLinks(code);
 		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}`);
+		if (args.pair) console.log("Run offsite pair to pair another browser");
 	}
 	if (!args.auth) console.warn("auth is off; anyone who can reach this port can control this machine");
 });
@@ -5854,12 +5968,67 @@ function stop() {
 	stopAll();
 	process.exit(0);
 }
-function authorized(url) {
-	return !args.auth || matchesToken(url.searchParams.get("token"));
+function answerApi(pathname, request, response) {
+	response.setHeader("access-control-allow-origin", "*");
+	if (request.method === "OPTIONS") {
+		response.setHeader("access-control-allow-methods", "POST");
+		response.setHeader("access-control-allow-headers", "authorization");
+		response.statusCode = 204;
+		response.end();
+		return;
+	}
+	if (request.method !== "POST") {
+		response.statusCode = 405;
+		response.end("use POST");
+		return;
+	}
+	const given = request.headers.authorization?.match(/^Bearer (.+)$/)?.[1] ?? null;
+	if (pathname === "/api/pair") {
+		const token = given === null ? null : redeemCode(given);
+		if (token === null) {
+			response.statusCode = 401;
+			response.end("That pairing code expired or was already used");
+			return;
+		}
+		answerJson(response, { token });
+		return;
+	}
+	if (pathname === "/api/ticket") {
+		if (!args.auth) {
+			answerJson(response, { ticket: null });
+			return;
+		}
+		const device = given === null ? null : findDevice(given);
+		if (device === null) {
+			response.statusCode = 401;
+			response.end("This browser needs pairing");
+			return;
+		}
+		const ticket = randomBytes(32).toString("base64url");
+		tickets.set(ticket, {
+			device,
+			expiresAt: Date.now() + TICKET_LIFETIME
+		});
+		answerJson(response, { ticket });
+		return;
+	}
+	response.statusCode = 404;
+	response.end("not found");
+}
+function answerJson(response, body) {
+	response.setHeader("content-type", "application/json");
+	response.end(JSON.stringify(body));
+}
+function redeemTicket(ticket) {
+	if (ticket === null) return null;
+	const found = tickets.get(ticket);
+	tickets.delete(ticket);
+	if (found === void 0 || found.expiresAt <= Date.now()) return null;
+	return found.device;
 }
 async function unpair() {
-	const tokens = readTokens();
-	if (tokens.length === 0) {
+	const devices = readDevices();
+	if (devices.length === 0) {
 		console.log("No browsers are paired");
 		return;
 	}
@@ -5871,11 +6040,12 @@ async function unpair() {
 		type: "multiselect",
 		required: false,
 		cancel: "null",
-		options: tokens.map((item) => ({
+		options: devices.map((item) => ({
 			value: item.hash,
 			label: [
 				item.name ?? "Unnamed",
 				`paired ${new Date(item.createdAt).toLocaleString()}`,
+				`${item.expiresAt <= Date.now() ? "expired" : "expires"} ${new Date(item.expiresAt).toLocaleString()}`,
 				item.lastUsedAt === null ? "never used" : `last used ${new Date(item.lastUsedAt).toLocaleString()}`
 			].join(" · ")
 		}))
@@ -5884,35 +6054,21 @@ async function unpair() {
 		console.log("Nothing unpaired");
 		return;
 	}
-	removeTokens(picked);
+	removeDevices(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({
+function pairingLinks(code) {
+	return { local: `${address}/pair#${new URLSearchParams({
 		machine: address,
-		...fallback !== null && { fallback },
-		...token !== null && { token }
-	});
-	return {
-		local: token === null ? address : `${address}/pair#${new URLSearchParams({ token })}`,
-		hosted: `${HOSTED_APP}/pair#${hosted}`
-	};
+		...code !== null && { code }
+	})}` };
 }
 function serveFile(pathname, response) {
+	if (!args.pwa && pathname === "/manifest.webmanifest") {
+		response.statusCode = 404;
+		response.end("offsite runs without --pwa");
+		return;
+	}
 	const requested = path.join(publicDir, path.normalize(pathname));
 	const file = requested.startsWith(publicDir + path.sep) && statSync(requested, { throwIfNoEntry: false })?.isFile() ? requested : path.join(publicDir, "index.html");
 	if (!existsSync(file)) {
@@ -5921,6 +6077,10 @@ function serveFile(pathname, response) {
 		return;
 	}
 	response.setHeader("content-type", contentTypes[path.extname(file)] ?? "application/octet-stream");
+	if (!args.pwa && path.basename(file) === "index.html") {
+		response.end(readFileSync(file, "utf8").replace(/<link rel="manifest"[^>]*>/, ""));
+		return;
+	}
 	createReadStream(file).pipe(response);
 }
 //#endregion