offsite 0.0.35 → 0.0.37

package/apps/server/dist/main.mjs

@@ -6,15 +6,15 @@ import { consola } from "consola";
 import { WebSocketServer } from "ws";
 import { z } from "zod";
 import os from "node:os";
-import { deleteSession, forkSession, getSessionMessages, getSubagentMessages, listSessions, query, renameSession } from "@anthropic-ai/claude-agent-sdk";
+import { deleteSession, forkSession, getSessionInfo, getSessionMessages, getSubagentMessages, listSessions, query, renameSession } from "@anthropic-ai/claude-agent-sdk";
 import { execFile, spawn } from "node:child_process";
 import readline from "node:readline";
 import { Command } from "@commander-js/extra-typings";
 import { lstat, mkdir, open, readFile, readdir, readlink, stat, writeFile } from "node:fs/promises";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
-import { OpenCode } from "@opencode/client";
+import { OpenCode, isSessionNotFoundError } from "@opencode/client";
 import { ensure, headers } from "@opencode/client/service";
-import { and, eq, gt, inArray, lte, sql } from "drizzle-orm";
+import { and, eq, gt, inArray, lte, max, sql } from "drizzle-orm";
 import { pathToFileURL } from "node:url";
 import { sumBy } from "es-toolkit";
 import { DatabaseSync } from "node:sqlite";
@@ -1551,6 +1551,12 @@ async function codexThreads(paths) {
 	} while (cursor !== null);
 	return threads;
 }
+async function codexThread(threadId) {
+	return (await server$2(threadId).request("thread/read", {
+		threadId,
+		includeTurns: false
+	})).thread;
+}
 async function codexHistory(sessionId) {
 	const run = codexRun(sessionId);
 	const items = turnItems((await readThread(sessionId)).turns, null);
@@ -2038,6 +2044,9 @@ async function openCodeSessions(paths) {
 		return found;
 	}))).flat().filter((session) => !temporary.has(session.id));
 }
+async function openCodeSession(sessionId) {
+	return (await openCode()).session.get({ sessionID: sessionId });
+}
 async function openCodeHistory(sessionId, cwd) {
 	const run = openCodeRun(sessionId);
 	const client = await openCode();
@@ -2529,7 +2538,8 @@ const projects$2 = snakeCase.table("projects", {
 	id: text().primaryKey(),
 	path: text().notNull().unique(),
 	name: text().notNull(),
-	logo: text()
+	logo: text(),
+	position: integer().notNull().default(0)
 });
 const sessions$1 = snakeCase.table("sessions", {
 	sessionId: text().primaryKey(),
@@ -2994,7 +3004,12 @@ const LOGO_TYPES = [
 	"image/vnd.microsoft.icon"
 ];
 function projects$1() {
-	return db.select().from(projects$2).all();
+	return db.select({
+		id: projects$2.id,
+		path: projects$2.path,
+		name: projects$2.name,
+		logo: projects$2.logo
+	}).from(projects$2).orderBy(projects$2.position).all();
 }
 function projectPath(id) {
 	const project = db.select().from(projects$2).where(eq(projects$2.id, id)).get();
@@ -3004,11 +3019,13 @@ function projectPath(id) {
 async function addProject(input) {
 	const folder = path.resolve(expandHome(input.trim()));
 	if (!(await stat(folder)).isDirectory()) throw new Error(`${folder} is not a folder`);
+	const last = db.select({ position: max(projects$2.position) }).from(projects$2).get();
 	db.insert(projects$2).values({
 		id: randomUUID(),
 		path: folder,
 		name: path.basename(folder) || folder,
-		logo: await findLogo(folder)
+		logo: await findLogo(folder),
+		position: last === void 0 || last.position === null ? 0 : last.position + 1
 	}).onConflictDoNothing({ target: projects$2.path }).run();
 	publish$1();
 	const project = projects$1().find((item) => item.path === folder);
@@ -3032,6 +3049,17 @@ function removeProject(id) {
 	db.delete(projects$2).where(eq(projects$2.id, id)).run();
 	publish$1();
 }
+function reorderProjects(ids) {
+	const current = projects$1().map((project) => project.id);
+	if (ids.length !== current.length || !current.every((id) => ids.includes(id))) throw new Error("The projects changed, try again");
+	db.transaction((transaction) => {
+		ids.forEach((id, position) => {
+			transaction.update(projects$2).set({ position }).where(eq(projects$2.id, id)).run();
+		});
+	});
+	publish$1();
+	return null;
+}
 async function directories(input) {
 	const folder = path.resolve(expandHome(input.trim()));
 	const entries = await readdir(folder, { withFileTypes: true });
@@ -3062,6 +3090,89 @@ function expandHome(input) {
 	return input;
 }
 //#endregion
+//#region src/services/provider-sessions.ts
+async function info(provider, id, paths) {
+	switch (provider) {
+		case "claude": return (await Promise.all([...paths].map(async ([cwd, projectId]) => {
+			const item = await getSessionInfo(id, { dir: cwd });
+			return item === void 0 ? null : fromClaude(item, projectId);
+		}))).find((item) => item !== null) ?? null;
+		case "codex": {
+			if (!codexInstalled()) return null;
+			const thread = await codexThread(id).catch((error) => {
+				if (error instanceof Error && error.message.startsWith("thread not loaded")) return null;
+				throw error;
+			});
+			if (thread === null) return null;
+			const projectId = paths.get(thread.cwd);
+			return projectId === void 0 ? null : fromCodex(thread, projectId);
+		}
+		case "opencode": {
+			if (!openCodeInstalled()) return null;
+			const session = await openCodeSession(id).catch((error) => {
+				if (isSessionNotFoundError(error)) return null;
+				throw error;
+			});
+			if (session === null) return null;
+			const projectId = paths.get(session.location.directory);
+			return projectId === void 0 ? null : fromOpenCode(session, projectId);
+		}
+	}
+}
+function fromClaude(item, projectId) {
+	return {
+		id: item.sessionId,
+		provider: "claude",
+		title: item.summary,
+		projectId,
+		branch: item.gitBranch ?? null,
+		updatedAt: item.lastModified
+	};
+}
+function fromCodex(thread, projectId) {
+	return {
+		id: thread.id,
+		provider: "codex",
+		title: thread.name ?? thread.preview.replaceAll(/\[Image: source: [^\]]+\]/g, ""),
+		projectId,
+		branch: thread.gitInfo?.branch ?? null,
+		updatedAt: thread.updatedAt * 1e3
+	};
+}
+function fromOpenCode(session, projectId) {
+	return {
+		id: session.id,
+		provider: "opencode",
+		title: session.title ?? "New session",
+		projectId,
+		branch: null,
+		updatedAt: session.time.updated
+	};
+}
+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) => fromClaude(item, projectId))))).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 [fromCodex(thread, projectId)];
+			});
+		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 [fromOpenCode(session, projectId)];
+			});
+	}
+}
+//#endregion
 //#region ../core/src/terminal.ts
 function encodeFrame(kind, id, data) {
 	const frame = new Uint8Array(5 + data.length);
@@ -4074,9 +4185,45 @@ 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) => {
+	return withStatus(allProviders.flatMap((provider) => listed[provider]).filter((item) => known.has(item.projectId))).filter((session) => session.status !== "inactive");
+}
+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$1().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 findSession(id) {
+	const paths = new Map(projectPaths());
+	const owner = ownerOf(id);
+	if (owner !== void 0) {
+		const item = await info(owner, id, paths);
+		return item === null ? null : withStatus([item])[0];
+	}
+	for (const provider of allProviders) {
+		if (!readConfig().enabledProviders[provider]) continue;
+		const item = await info(provider, id, paths).catch(() => null);
+		if (item !== null) {
+			providers.set(id, provider);
+			return withStatus([item])[0];
+		}
+	}
+	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 ?? []);
+	for (const item of found) providers.set(item.id, item.provider);
+	return withStatus(found);
+}
+function withStatus(items) {
+	const records = new Map(db.select().from(sessions$1).all().map((record) => [record.sessionId, record]));
+	return items.map((item) => {
 		const record = records.get(item.id);
 		const updatedAt = record?.interactedAt ?? item.updatedAt;
 		return {
@@ -4084,7 +4231,13 @@ function sessions() {
 			updatedAt,
 			status: record === void 0 || record.status === "active" && Date.now() - updatedAt > day ? "inactive" : record.status
 		};
-	}));
+	});
+}
+function projectPaths() {
+	return projects$1().map((project) => [project.path, project.id]);
+}
+function ownerOf(sessionId) {
+	return runs.get(sessionId)?.provider ?? providers.get(sessionId);
 }
 function providerStatuses() {
 	return allProviders.map((provider) => statuses[provider]);
@@ -4093,7 +4246,7 @@ 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);
+	const provider = ownerOf(sessionId);
 	if (provider === void 0) throw new Error("offsite does not know this session yet, reload the page");
 	return provider;
 }
@@ -4141,7 +4294,7 @@ async function refresh(provider) {
 	refreshing.delete(provider);
 }
 async function list(provider) {
-	const paths = new Map(projects$1().map((project) => [project.path, project.id]));
+	const paths = new Map(projectPaths());
 	const before = statuses[provider];
 	let timer;
 	try {
@@ -4154,7 +4307,7 @@ async function list(provider) {
 			};
 			return;
 		}
-		const found = await Promise.race([find(provider, paths), new Promise((_, reject) => {
+		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);
 		})]);
 		if (found === null) {
@@ -4190,49 +4343,14 @@ async function list(provider) {
 		});
 	}
 }
-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.replaceAll(/\[Image: source: [^\]]+\]/g, ""),
-					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 tracked(provider, paths) {
+	if (provider === "codex" && !codexInstalled() || provider === "opencode" && !openCodeInstalled()) return null;
+	return (await Promise.all(db.select().from(sessions$1).all().map((record) => {
+		const owner = ownerOf(record.sessionId);
+		if (owner === provider) return info(provider, record.sessionId, paths);
+		if (owner === void 0) return info(provider, record.sessionId, paths).catch(() => null);
+		return null;
+	}))).filter((item) => item !== null);
 }
 function watchSessions() {
 	for (const watcher of watchers) watcher.close();
@@ -4266,7 +4384,7 @@ async function updateSession(id, patch) {
 			await run.closed;
 		}
 		db.delete(sessions$1).where(eq(sessions$1.sessionId, id)).run();
-		const all = sessions();
+		const all = withStatus(allProviders.flatMap((provider) => listed[provider]));
 		const session = all.find((item) => item.id === id);
 		if (session !== void 0 && all.every((item) => item.projectId !== session.projectId || item.status === "inactive")) closeProjectTabs(session.projectId);
 	} else if (patch.status !== void 0) {
@@ -4281,6 +4399,7 @@ async function updateSession(id, patch) {
 			target: sessions$1.sessionId,
 			set
 		}).run();
+		await refresh(providerOf(id));
 	}
 	if (patch.title !== void 0) refreshSessions(providerOf(id));
 }
@@ -6370,6 +6489,7 @@ const handlers = {
 		refreshAll();
 		return null;
 	},
+	"projects.reorder": (params) => reorderProjects(params.ids),
 	"directories.list": (params) => directories(params.path),
 	"sessions.update": async (params) => {
 		try {
@@ -6388,9 +6508,12 @@ const handlers = {
 		return null;
 	},
 	"sessions.open": async (params, client) => {
+		const session = await findSession(params.sessionId);
 		await open$1(client, params.sessionId, params.projectId);
-		return null;
+		return session;
 	},
+	"sessions.inactive": (params) => inactiveSessions(params.projectId),
+	"sessions.search": (params) => searchSessions(params.query),
 	"sessions.earlier": (params) => earlier(params.sessionId, params.before),
 	"sessions.image": (params) => image(params.sessionId, params.itemId, params.index),
 	"sessions.agent": (params) => {