offsite 0.0.55 → 0.0.57

package/apps/server/dist/main.mjs

@@ -21,7 +21,7 @@ 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 { integer, snakeCase, text } from "drizzle-orm/sqlite-core";
+import { integer, real, snakeCase, text } from "drizzle-orm/sqlite-core";
 import sharp from "sharp";
 import { promisify } from "node:util";
 import webPush from "web-push";
@@ -1597,6 +1597,30 @@ async function codexThread(threadId) {
 		includeTurns: false
 	})).thread;
 }
+async function codexSearch(term) {
+	return (await appServer(codexBaseDir).request("thread/search", {
+		searchTerm: term,
+		limit: 50,
+		sortKey: "updated_at",
+		sourceKinds: [
+			"cli",
+			"vscode",
+			"appServer"
+		]
+	})).data;
+}
+async function codexMessages(threadId) {
+	return (await readThread(threadId)).turns.flatMap((turn) => turn.items.flatMap((item) => {
+		if (item.type === "userMessage") return [{
+			author: "user",
+			text: item.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n")
+		}];
+		return item.type === "agentMessage" ? [{
+			author: "assistant",
+			text: item.text
+		}] : [];
+	}));
+}
 async function codexHistory(sessionId) {
 	const run = codexRun(sessionId);
 	const items = turnItems((await readThread(sessionId)).turns, null);
@@ -1694,6 +1718,118 @@ async function readThread(threadId) {
 		includeTurns: true
 	})).thread;
 }
+const WORD_START = .8;
+const MID_WORD = .3;
+const PHRASE_BONUS = .25;
+const MID_WORD_LENGTH = 4;
+const SNIPPET_LEAD = 24;
+const SNIPPET_LENGTH = 160;
+const alphanumeric = /[\p{L}\p{N}]/u;
+const lowercase = /\p{Ll}/u;
+const uppercase = /\p{Lu}/u;
+const digit = /\p{N}/u;
+function fold(text) {
+	return text.replace(/[\u0080-￿]/g, (character) => {
+		const folded = character.normalize("NFKD").replace(/\p{M}/gu, "").toLowerCase();
+		return folded.length === 1 ? folded : character;
+	}).toLowerCase();
+}
+function searchWords(query) {
+	return fold(query).replace(/^["'`]+|["'`]+$/g, "").split(/\s+/).filter(Boolean);
+}
+function hasSearchableWord(query) {
+	return searchWords(query).some((word) => word.length >= 3);
+}
+function isWordStart(text, index) {
+	const character = text[index];
+	const previous = text[index - 1] ?? "";
+	const next = text[index + 1] ?? "";
+	return alphanumeric.test(character) && (previous === "" || !alphanumeric.test(previous) || lowercase.test(previous) && uppercase.test(character) || uppercase.test(previous) && uppercase.test(character) && lowercase.test(next) || digit.test(previous) !== digit.test(character));
+}
+function isWordEnd(text, end) {
+	return end >= text.length || !alphanumeric.test(text[end]) || isWordStart(text, end);
+}
+function findWord(text, folded, word) {
+	let quality = 0;
+	let at = -1;
+	for (let index = folded.indexOf(word); index !== -1; index = folded.indexOf(word, index + 1)) {
+		const found = !isWordStart(text, index) ? MID_WORD : isWordEnd(text, index + word.length) ? 1 : WORD_START;
+		if (found > quality) {
+			quality = found;
+			at = index;
+		}
+	}
+	return at === -1 ? null : {
+		quality,
+		at
+	};
+}
+function matchMessage(query, text) {
+	const words = searchWords(query);
+	if (words.length === 0) return null;
+	const folded = fold(text);
+	let quality = 1;
+	let offset = text.length;
+	for (const word of words) {
+		const found = findWord(text, folded, word);
+		if (found === null || found.quality === MID_WORD && word.length < MID_WORD_LENGTH) return null;
+		if (word.length >= 3) quality = Math.min(quality, found.quality);
+		offset = Math.min(offset, found.at);
+	}
+	const phrase = words.length > 1 ? folded.indexOf(words.join(" ")) : -1;
+	return phrase === -1 ? {
+		quality,
+		offset
+	} : {
+		quality: quality + PHRASE_BONUS,
+		offset: phrase
+	};
+}
+function messageSnippet(text, offset) {
+	let start = Math.max(0, offset - SNIPPET_LEAD);
+	const space = text.slice(start, offset).search(/\s/);
+	if (start > 0 && space !== -1) start += space + 1;
+	const shown = text.slice(start, start + 320).replace(/\s+/g, " ").trim();
+	const cut = shown.length > SNIPPET_LENGTH;
+	return `${start > 0 ? "…" : ""}${shown.slice(0, SNIPPET_LENGTH)}${cut ? "…" : ""}`;
+}
+// ../core/src/search.ts
+const OPEN_REPEAT = 6e5;
+const PICK_WINDOW = 18144e5;
+const PICK_LIMIT = 3;
+const PICK_LENGTH = 32;
+const USAGE_HALF_LIFE = 12096e5;
+function decay(age) {
+	return 2 ** (-Math.max(0, age) / USAGE_HALF_LIFE);
+}
+function storedQuery(query) {
+	return searchWords(query).join(" ").slice(0, PICK_LENGTH).trim();
+}
+function nextOpens(previous, at, query) {
+	const pick = storedQuery(query ?? "");
+	const earlier = (previous?.picks ?? []).filter((entry) => at - entry.at <= PICK_WINDOW && entry.query !== pick);
+	const kept = (pick === "" ? earlier : [{
+		query: pick,
+		at
+	}, ...earlier]).slice(0, PICK_LIMIT);
+	if (previous === null) return {
+		score: 1,
+		openedAt: at,
+		picks: kept
+	};
+	if (at - previous.openedAt < OPEN_REPEAT) return {
+		...previous,
+		picks: kept
+	};
+	return {
+		score: previous.score * decay(at - previous.openedAt) + 1,
+		openedAt: at,
+		picks: kept
+	};
+}
+function compareMessages(left, right) {
+	return right.quality - left.quality || Number(right.author === "user") - Number(left.author === "user");
+}
 // src/lib/opencode/items.ts
 const toolStatuses = {
 	streaming: "running",
@@ -2100,6 +2236,19 @@ async function openCodeHistory(sessionId, cwd) {
 		partial: run?.partial ?? ""
 	};
 }
+async function openCodeMessages(sessionId) {
+	return (await allMessages(await openCode(), sessionId)).flatMap((message) => {
+		if (message.type === "user") return [{
+			author: "user",
+			text: message.text
+		}];
+		if (message.type !== "assistant") return [];
+		return [{
+			author: "assistant",
+			text: message.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n")
+		}];
+	});
+}
 async function openCodeAgent(agentId, parent) {
 	return (await allMessages(await openCode(), agentId)).flatMap((message) => messageItems(message, parent));
 }
@@ -2586,6 +2735,12 @@ const sessions$1 = snakeCase.table("sessions", {
 		"minimized"
 	] }).notNull()
 });
+const sessionOpens = snakeCase.table("session_opens", {
+	sessionId: text().primaryKey(),
+	score: real().notNull(),
+	openedAt: integer().notNull(),
+	picks: text({ mode: "json" }).$type().notNull()
+});
 const pairingCodes = snakeCase.table("pairing_codes", {
 	hash: text().primaryKey(),
 	name: text(),
@@ -2610,7 +2765,7 @@ const pushSubscriptions = snakeCase.table("push_subscriptions", {
 // src/services/files.ts
 const FILE_LIMIT = 2e4;
 const OUTPUT_LIMIT$1 = 262144;
-const READ_LIMIT = 1048576;
+const READ_LIMIT$1 = 1048576;
 const MEDIA_LINK_LIFETIME = 36e5;
 const browseToken = randomBytes(32).toString("base64url");
 const mediaLinks = /* @__PURE__ */ new Map();
@@ -2661,10 +2816,10 @@ function readProjectFile(cwd, file) {
 	const full = resolveProjectFile(cwd, file);
 	const stats = statSync(full);
 	if (!stats.isFile()) throw new Error(`${file} is not a file`);
-	if (stats.size > READ_LIMIT) return {
+	if (stats.size > READ_LIMIT$1) return {
 		kind: "large",
 		size: stats.size,
-		limit: READ_LIMIT
+		limit: READ_LIMIT$1
 	};
 	const data = readFileSync(full);
 	const mediaType = mediaTypes.get(path.extname(full).toLowerCase());
@@ -2850,7 +3005,7 @@ const UNTRACKED_LIMIT = 100;
 const NEW_FILE_LIMIT = 262144;
 const REPO_DEPTH = 3;
 const FETCH_TIMEOUT = 6e4;
-const run$2 = promisify(execFile);
+const run$3 = promisify(execFile);
 const PULL_REQUEST_INSTRUCTIONS = `You write GitHub pull requests as Markdown.
 
 ## TITLE RULES
@@ -2937,7 +3092,7 @@ async function sync(cwd) {
 async function fetchProject(cwd) {
 	await Promise.all((await projectRepos(cwd)).map(async (repo) => {
 		try {
-			await run$2("git", ["fetch"], {
+			await run$3("git", ["fetch"], {
 				cwd: path.join(cwd, repo),
 				env: {
 					...process.env,
@@ -2968,7 +3123,7 @@ async function switchBranch(cwd, branch, create) {
 async function pullRequestBranches(cwd) {
 	const head = (await gitStatus(cwd)).branch;
 	if (head === null) throw new Error("Not on a branch");
-	const base = (await run$2("gh", [
+	const base = (await run$3("gh", [
 		"repo",
 		"view",
 		"--json",
@@ -2993,7 +3148,7 @@ async function preparePullRequest(cwd, base, commitChanges) {
 	if (commitChanges) await commit(cwd, "", true);
 	const status = await gitStatus(cwd);
 	if (status.upstream === null || status.ahead > 0) await push$1(cwd);
-	const open = (await run$2("gh", [
+	const open = (await run$3("gh", [
 		"pr",
 		"list",
 		"--head",
@@ -3040,7 +3195,7 @@ async function preparePullRequest(cwd, base, commitChanges) {
 	};
 }
 async function createPullRequest(cwd, request) {
-	const url = (await run$2("gh", [
+	const url = (await run$3("gh", [
 		"pr",
 		"create",
 		"--title",
@@ -3073,7 +3228,7 @@ async function projectDiff(cwd) {
 	return (await Promise.all(repos.map((repo) => repoDiff(path.join(cwd, repo), repo === "" ? "" : `${repo}/`)))).join("");
 }
 function git(cwd, args) {
-	return run$2("git", args, {
+	return run$3("git", args, {
 		cwd,
 		maxBuffer: 67108864
 	});
@@ -3367,6 +3522,13 @@ function expandHome(input) {
 	return input;
 }
 // src/services/provider-sessions.ts
+const TIME_LIMIT = 1e4;
+function timeLimit(work, message) {
+	let timer;
+	return Promise.race([work, new Promise((_, reject) => {
+		timer = setTimeout(() => reject(new Error(message)), TIME_LIMIT);
+	})]).finally(() => clearTimeout(timer));
+}
 async function info(provider, id, paths) {
 	switch (provider) {
 		case "claude": return (await Promise.all([...paths].map(async ([cwd, projectId]) => {
@@ -3450,7 +3612,6 @@ async function find(provider, paths) {
 }
 // src/services/sessions.ts
 const day = 864e5;
-const LIST_TIMEOUT = 1e4;
 const REFRESH_DELAY = 1e3;
 const allProviders = [
 	"claude",
@@ -3490,13 +3651,34 @@ function sessions() {
 async function inactiveSessions(projectId) {
 	return (await everything(projectPaths().filter(([, id]) => projectId === null || id === projectId))).filter((session) => session.status === "inactive").sort((a, b) => b.updatedAt - a.updatedAt);
 }
-async function searchSessions(query) {
-	const words = query.toLowerCase().split(/\s+/).filter(Boolean);
-	const folders = new Map(projects().map((project) => [project.id, project.path]));
-	return (await everything(projectPaths())).filter((session) => {
-		const text = `${session.title} ${folders.get(session.projectId) ?? ""}`.toLowerCase();
-		return words.every((word) => text.includes(word));
-	}).sort((a, b) => b.updatedAt - a.updatedAt).slice(0, 50);
+async function searchableSessions() {
+	const paths = projectPaths();
+	const lists = await Promise.all(enabledProviders().map(async (provider) => {
+		try {
+			return {
+				provider,
+				items: await timeLimit(find(provider, new Map(paths)), `${providerName(provider)} did not list its sessions in time`) ?? [],
+				failed: false
+			};
+		} catch (error) {
+			console.warn(`could not search ${providerName(provider)}: ${error}`);
+			return {
+				provider,
+				items: [],
+				failed: true
+			};
+		}
+	}));
+	const found = lists.flatMap((list) => list.items);
+	for (const item of found) providers.set(item.id, item.provider);
+	const opens = new Map(db.select().from(sessionOpens).all().map((record) => [record.sessionId, record]));
+	return {
+		sessions: withStatus(found).map((session) => ({
+			...session,
+			opens: opens.get(session.id) ?? null
+		})),
+		failed: lists.filter((list) => list.failed).map((list) => list.provider)
+	};
 }
 async function findSession(id) {
 	const paths = new Map(projectPaths());
@@ -3516,7 +3698,7 @@ async function findSession(id) {
 	return null;
 }
 async function everything(paths) {
-	const found = (await Promise.all(allProviders.filter((provider) => readConfig().enabledProviders[provider]).map((provider) => find(provider, new Map(paths))))).flatMap((items) => items ?? []);
+	const found = (await Promise.all(enabledProviders().map((provider) => find(provider, new Map(paths))))).flatMap((items) => items ?? []);
 	for (const item of found) providers.set(item.id, item.provider);
 	return withStatus(found);
 }
@@ -3532,6 +3714,9 @@ function withStatus(items) {
 		};
 	});
 }
+function enabledProviders() {
+	return allProviders.filter((provider) => readConfig().enabledProviders[provider]);
+}
 function projectPaths() {
 	return projects().map((project) => [project.path, project.id]);
 }
@@ -3562,6 +3747,16 @@ function recordInteraction(id) {
 		}
 	}).run();
 }
+function recordOpen(id, query) {
+	const opens = nextOpens(db.select().from(sessionOpens).where(eq(sessionOpens.sessionId, id)).get() ?? null, Date.now(), query);
+	db.insert(sessionOpens).values({
+		sessionId: id,
+		...opens
+	}).onConflictDoUpdate({
+		target: sessionOpens.sessionId,
+		set: opens
+	}).run();
+}
 function publishSessions() {
 	broadcast({
 		type: "sessions",
@@ -3595,7 +3790,6 @@ async function refresh(provider) {
 async function list(provider) {
 	const paths = new Map(projectPaths());
 	const before = statuses[provider];
-	let timer;
 	try {
 		if (!readConfig().enabledProviders[provider]) {
 			listed[provider] = [];
@@ -3606,9 +3800,7 @@ async function list(provider) {
 			};
 			return;
 		}
-		const found = await Promise.race([tracked(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);
-		})]);
+		const found = await timeLimit(tracked(provider, paths), `${providerName(provider)} did not list its sessions in time`);
 		if (found === null) {
 			listed[provider] = [];
 			statuses[provider] = {
@@ -3634,7 +3826,6 @@ async function list(provider) {
 			error: message
 		};
 	} finally {
-		clearTimeout(timer);
 		publishSessions();
 		if (JSON.stringify(statuses[provider]) !== JSON.stringify(before)) broadcast({
 			type: "providers",
@@ -3722,6 +3913,7 @@ async function removeSession(id) {
 		case "opencode": await removeOpenCode(id);
 	}
 	db.delete(sessions$1).where(eq(sessions$1.sessionId, id)).run();
+	db.delete(sessionOpens).where(eq(sessionOpens.sessionId, id)).run();
 	listed[provider] = listed[provider].filter((item) => item.id !== id);
 }
 async function fork(sessionId, projectId, messageId) {
@@ -5354,6 +5546,140 @@ var Run = class {
 		});
 	}
 };
+// src/services/message-search.ts
+const READ_LIMIT = 30;
+const CODEX_READ_LIMIT = 10;
+const RG_TIME_LIMIT = 5e3;
+const generatedText = /^(?:This session is being continued from a previous conversation|<command-|<local-command-|<bash-|<task-notification|<cross-session-message|Another Claude session sent a message:|\[Request interrupted by user)/;
+const run$2 = promisify(execFile);
+async function searchMessages(query) {
+	if (!hasSearchableWord(query)) return {
+		matches: [],
+		failed: []
+	};
+	const paths = new Map(projects().map((project) => [project.path, project.id]));
+	const folders = new Map(projects().map((project) => [project.id, project.path]));
+	const results = await Promise.all([
+		"claude",
+		"codex",
+		"opencode"
+	].filter((provider) => readConfig().enabledProviders[provider]).map(async (provider) => {
+		try {
+			return {
+				provider,
+				matches: await timeLimit(search(provider, query, paths, folders), `${providerName(provider)} did not search in time`),
+				failed: false
+			};
+		} catch (error) {
+			console.warn(`could not search ${providerName(provider)} messages: ${error}`);
+			return {
+				provider,
+				matches: [],
+				failed: true
+			};
+		}
+	}));
+	return {
+		matches: results.flatMap((result) => result.matches),
+		failed: results.filter((result) => result.failed).map((result) => result.provider)
+	};
+}
+async function search(provider, query, paths, folders) {
+	const found = await find(provider, paths);
+	if (found === null) return [];
+	const sessions = newestFirst(found);
+	switch (provider) {
+		case "claude": return searchClaude(query, sessions, folders);
+		case "codex": return searchCodex(query, sessions);
+		case "opencode": return readAndMatch(query, sessions.slice(0, READ_LIMIT), openCodeMessages);
+	}
+}
+function newestFirst(sessions) {
+	return [...sessions].sort((a, b) => b.updatedAt - a.updatedAt);
+}
+async function searchClaude(query, sessions, folders) {
+	const candidates = await claudeCandidates(query);
+	const matching = candidates === null ? sessions : sessions.filter((session) => candidates.has(session.id));
+	const projectOf = new Map(sessions.map((session) => [session.id, session.projectId]));
+	return readAndMatch(query, matching.slice(0, READ_LIMIT), (sessionId) => claudeMessages(sessionId, folders.get(projectOf.get(sessionId) ?? "")));
+}
+async function claudeMessages(sessionId, dir) {
+	return (await getSessionMessages(sessionId, { dir })).flatMap((item) => {
+		if (item.type === "system" || item.parent_tool_use_id !== null) return [];
+		const text = toMessage(item.type, item, null).content.flatMap((block) => block.type === "text" ? [block.text] : []).join("\n");
+		return generatedText.test(text) ? [] : [{
+			author: item.type,
+			text
+		}];
+	});
+}
+async function claudeCandidates(query) {
+	const words = searchWords(query).filter((word) => word.length >= 3 && !/["\\]/.test(word));
+	if (words.length === 0) return null;
+	try {
+		const lists = await Promise.all(words.map((word) => sessionsWith(word)));
+		return new Set(lists[0].filter((id) => lists.every((list) => list.includes(id))));
+	} catch (error) {
+		console.warn(`could not narrow Claude sessions with rg: ${error}`);
+		return null;
+	}
+}
+async function sessionsWith(word) {
+	return (await run$2("rg", [
+		"--files-with-matches",
+		"--fixed-strings",
+		"--ignore-case",
+		"--no-ignore",
+		"--hidden",
+		"--max-depth",
+		"2",
+		"--glob",
+		"*.jsonl",
+		"--",
+		word,
+		path.join(claudeBaseDir(), "projects")
+	], {
+		maxBuffer: 16777216,
+		timeout: RG_TIME_LIMIT
+	}).catch((error) => {
+		if (error.code === 1) return { stdout: "" };
+		throw error;
+	})).stdout.split("\n").filter(Boolean).map((file) => path.basename(file, ".jsonl"));
+}
+async function searchCodex(query, sessions) {
+	const longest = [...searchWords(query)].sort((a, b) => b.length - a.length)[0];
+	const known = new Map(sessions.map((session) => [session.id, session]));
+	const found = (await codexSearch(longest)).filter((result) => known.has(result.thread.id)).sort((a, b) => b.thread.updatedAt - a.thread.updatedAt);
+	const verified = await readAndMatch(query, found.slice(0, CODEX_READ_LIMIT).map((result) => ({ id: result.thread.id })), codexMessages);
+	const unverified = found.slice(CODEX_READ_LIMIT).flatMap((result) => {
+		const match = matchMessage(query, result.snippet);
+		return match === null ? [] : [{
+			sessionId: result.thread.id,
+			author: "assistant",
+			quality: match.quality,
+			snippet: messageSnippet(result.snippet, match.offset)
+		}];
+	});
+	return [...verified, ...unverified];
+}
+async function readAndMatch(query, sessions, read) {
+	return (await Promise.all(sessions.map(async (session) => bestMatch(query, session.id, await read(session.id))))).filter((match) => match !== null);
+}
+function bestMatch(query, sessionId, messages) {
+	let best = null;
+	for (const message of messages) {
+		const match = matchMessage(query, message.text);
+		if (match === null) continue;
+		const candidate = {
+			sessionId,
+			author: message.author,
+			quality: match.quality,
+			snippet: messageSnippet(message.text, match.offset)
+		};
+		if (best === null || compareMessages(candidate, best) < 0) best = candidate;
+	}
+	return best;
+}
 // src/services/proxy.ts
 const proxies = /* @__PURE__ */ new Map();
 const pageScriptPath = "/__offsite/browser.js";
@@ -7008,10 +7334,12 @@ const handlers = {
 	"sessions.open": async (params, client) => {
 		const session = await findSession(params.sessionId);
 		await open$1(client, params.sessionId, params.projectId);
+		if (params.opened && session !== null) recordOpen(params.sessionId, params.query);
 		return session;
 	},
 	"sessions.inactive": (params) => inactiveSessions(params.projectId),
-	"sessions.search": (params) => searchSessions(params.query),
+	"sessions.searchable": () => searchableSessions(),
+	"sessions.searchMessages": (params) => searchMessages(params.query),
 	"sessions.earlier": (params) => earlier(params.sessionId, params.before),
 	"sessions.image": (params) => image(params.sessionId, params.itemId, params.index),
 	"sessions.agent": (params) => {