feat: add session loading and history thing

Author: bajrangCoder

src/lib/acp/client.ts

@@ -6,6 +6,7 @@ import {
 	type ContentBlock,
 	type Implementation,
 	type InitializeResponse as InitializeResult,
+	type ListSessionsResponse as ListSessionsResult,
 	type McpServer,
 	type NewSessionResponse as NewSessionResult,
 	type RequestPermissionRequest as PermissionRequest,
@@ -236,6 +237,57 @@ export class ACPClient {
 		return this._session;
 	}
 
+	async loadSession(
+		sessionId: string,
+		cwd: string,
+		mcpServers?: McpServer[],
+	): Promise<ACPSession> {
+		this.ensureReady();
+
+		if (!this._agentCapabilities?.loadSession) {
+			throw new Error("This agent does not support session/load");
+		}
+
+		const connection = this.getConnection();
+		const session = new ACPSession(sessionId, cwd);
+
+		this._session?.dispose();
+		this._session = session;
+
+		try {
+			await this.runWhileConnected(
+				connection.loadSession({
+					sessionId,
+					cwd,
+					mcpServers: mcpServers ?? [],
+				}),
+			);
+			return session;
+		} catch (error) {
+			if (this._session === session) {
+				session.dispose();
+				this._session = null;
+			}
+			throw error;
+		}
+	}
+
+	async unstableListSessions(cwd?: string): Promise<ListSessionsResult> {
+		this.ensureReady();
+
+		if (!this._agentCapabilities?.sessionCapabilities?.list) {
+			throw new Error("This agent does not support session/list");
+		}
+
+		const connection = this.getConnection();
+
+		return (await this.runWhileConnected(
+			connection.unstable_listSessions({
+				cwd: cwd || undefined,
+			}),
+		)) as ListSessionsResult;
+	}
+
 	async startSession({
 		url,
 		cwd,

src/lib/acp/history.ts

@@ -0,0 +1,129 @@
+const STORAGE_KEY = "acpSessionHistory";
+const MAX_ENTRIES = 30;
+
+export interface ACPHistoryEntry {
+	sessionId: string;
+	url: string;
+	cwd: string;
+	agentName: string;
+	title: string;
+	preview: string;
+	createdAt: string;
+	updatedAt: string;
+}
+
+type ACPHistoryFilter = {
+	url?: string;
+};
+
+type ACPHistoryRemoveParams = {
+	sessionId: string;
+	url: string;
+};
+
+type ACPHistorySaveInput = Partial<ACPHistoryEntry> &
+	Pick<ACPHistoryEntry, "sessionId" | "url">;
+
+function normalizeEntry(entry: Partial<ACPHistoryEntry> = {}): ACPHistoryEntry {
+	const createdAt = entry.createdAt || new Date().toISOString();
+	const updatedAt = entry.updatedAt || createdAt;
+
+	return {
+		sessionId:
+			typeof entry.sessionId === "string" ? entry.sessionId.trim() : "",
+		url: typeof entry.url === "string" ? entry.url.trim() : "",
+		cwd: typeof entry.cwd === "string" ? entry.cwd.trim() : "",
+		agentName:
+			typeof entry.agentName === "string" ? entry.agentName.trim() : "",
+		title: typeof entry.title === "string" ? entry.title.trim() : "",
+		preview: typeof entry.preview === "string" ? entry.preview.trim() : "",
+		createdAt,
+		updatedAt,
+	};
+}
+
+function getTimestamp(value: string): number {
+	const parsed = Date.parse(value);
+	return Number.isNaN(parsed) ? 0 : parsed;
+}
+
+function sortEntries(entries: ACPHistoryEntry[]): ACPHistoryEntry[] {
+	return [...entries].sort((a, b) => {
+		return getTimestamp(b.updatedAt) - getTimestamp(a.updatedAt);
+	});
+}
+
+function parseEntries(): ACPHistoryEntry[] {
+	let entries = null;
+	try {
+		entries = JSON.parse(localStorage.getItem(STORAGE_KEY) || "[]");
+	} catch {
+		entries = [];
+	}
+	if (!Array.isArray(entries)) return [];
+
+	return entries
+		.map((entry) => normalizeEntry(entry))
+		.filter((entry) => entry.sessionId && entry.url);
+}
+
+function persist(entries: ACPHistoryEntry[]): void {
+	const nextEntries = sortEntries(entries).slice(0, MAX_ENTRIES);
+	localStorage.setItem(STORAGE_KEY, JSON.stringify(nextEntries));
+}
+
+const acpHistory = {
+	list(filter: ACPHistoryFilter = {}): ACPHistoryEntry[] {
+		return sortEntries(parseEntries()).filter((entry) => {
+			if (!filter.url) return true;
+			return entry.url === filter.url;
+		});
+	},
+
+	save(entry: ACPHistorySaveInput): ACPHistoryEntry | null {
+		const normalized = normalizeEntry(entry);
+		if (!normalized.sessionId || !normalized.url) return null;
+
+		const entries = parseEntries();
+		const index = entries.findIndex((item) => {
+			return (
+				item.sessionId === normalized.sessionId && item.url === normalized.url
+			);
+		});
+
+		if (index >= 0) {
+			const current = entries[index];
+			entries[index] = {
+				...current,
+				...normalized,
+				cwd: normalized.cwd || current.cwd,
+				agentName: normalized.agentName || current.agentName,
+				title: normalized.title || current.title,
+				preview: normalized.preview || current.preview,
+				createdAt: current.createdAt,
+				updatedAt: normalized.updatedAt || new Date().toISOString(),
+			};
+		} else {
+			entries.unshift({
+				...normalized,
+				createdAt: normalized.createdAt || new Date().toISOString(),
+				updatedAt: normalized.updatedAt || new Date().toISOString(),
+			});
+		}
+
+		persist(entries);
+		return normalized;
+	},
+
+	remove({ sessionId, url }: ACPHistoryRemoveParams): void {
+		if (!sessionId || !url) return;
+
+		persist(
+			parseEntries().filter((entry) => {
+				return !(entry.sessionId === sessionId && entry.url === url);
+			}),
+		);
+	},
+};
+
+export default acpHistory;

src/lib/acp/session.ts

@@ -30,6 +30,8 @@ export class ACPSession {
 	readonly timeline: TimelineEntry[] = [];
 	readonly toolCalls: Map<string, ToolCall> = new Map();
 	plan: Plan | null = null;
+	title: string | null = null;
+	updatedAt: string | null = null;
 
 	private agentTextBuffer = "";
 	private currentAgentMessageId: string | null = null;
@@ -102,6 +104,9 @@ export class ACPSession {
 			case "plan":
 				this.handlePlan(update.entries);
 				break;
+			case "session_info_update":
+				this.handleSessionInfoUpdate(update);
+				break;
 		}
 	}
 
@@ -248,6 +253,18 @@ export class ACPSession {
 		this.emit("plan", this.plan);
 	}
 
+	private handleSessionInfoUpdate(update: {
+		title?: string | null;
+		updatedAt?: string | null;
+	}): void {
+		if ("title" in update) {
+			this.title = update.title ?? null;
+		}
+		if ("updatedAt" in update) {
+			this.updatedAt = update.updatedAt ?? null;
+		}
+	}
+
 	private nextMessageId(): string {
 		return `msg_${++this.messageIdCounter}_${Date.now()}`;
 	}