diff --git a/packages/app/e2e/regression/command-palette.spec.ts b/packages/app/e2e/regression/command-palette.spec.ts index 77be50624850..1c3daaad8482 100644 --- a/packages/app/e2e/regression/command-palette.spec.ts +++ b/packages/app/e2e/regression/command-palette.spec.ts @@ -48,6 +48,29 @@ test("lists recent sessions before a query is entered", async ({ page }) => { await expect(page.getByRole("heading", { name: paletteSession.title, exact: true })).toBeVisible() }) +test("pins the open session from the palette", async ({ page }) => { + const { dialog, input } = await openCommandPalette(page) + await input.pressSequentially("pin session") + const pin = dialog.getByRole("option", { name: /^Pin session/ }) + await expect(pin).toHaveAttribute("aria-selected", "true") + await input.press("Enter") + await expect(dialog).toHaveCount(0) + + await page.keyboard.press("ControlOrMeta+Shift+P") + const reopened = page.getByRole("dialog").getByRole("textbox") + await reopened.pressSequentially("pin session") + await expect(page.getByRole("option", { name: /^Unpin session/ })).toHaveAttribute("aria-selected", "true") + await page.keyboard.press("Escape") + + await page.getByRole("button", { name: "Home", exact: true }).click() + const list = page.getByRole("region", { name: "Recent sessions" }) + await expect(list.getByText("Pinned", { exact: true })).toBeVisible() + await expect(list.locator('[data-component="home-session-row-container"]').first()).toHaveAttribute( + "data-session-id", + paletteSession.id, + ) +}) + test("reopens from its shortcut as soon as it closes", async ({ page }) => { const { dialog, input } = await openCommandPalette(page) await input.press("Escape") diff --git a/packages/app/e2e/regression/home.spec.ts b/packages/app/e2e/regression/home.spec.ts index ddc15b838427..2900e587478b 100644 --- a/packages/app/e2e/regression/home.spec.ts +++ b/packages/app/e2e/regression/home.spec.ts @@ -26,15 +26,15 @@ test("the session context menu renames, exports, and deletes a Home session", as await target.focus() await target.press("Shift+F10") - await expect(page.getByRole("menuitem", { name: "Rename" })).toBeVisible() + await expect(page.getByRole("menuitem", { name: "Pin" })).toBeVisible() await page.keyboard.press("Escape") - await expect(page.getByRole("menuitem", { name: "Rename" })).toBeHidden() + await expect(page.getByRole("menuitem", { name: "Pin" })).toBeHidden() await expect(target).toBeFocused() const box = await target.boundingBox() await target.click({ button: "right", position: { x: 48, y: 12 } }) await expect(page).toHaveURL("/") - await expect(page.getByRole("menuitem")).toHaveText(["Rename", "Export…", "Delete…"]) + await expect(page.getByRole("menuitem")).toHaveText(["Pin", "Rename", "Export…", "Delete…"]) const menu = await page.locator('[data-component="menu-v2-content"]').boundingBox() expect(Math.abs((menu?.x ?? 0) - (box?.x ?? 0) - 48)).toBeLessThan(4) @@ -77,6 +77,34 @@ test("the session context menu renames, exports, and deletes a Home session", as await expect(renamedRow).toBeHidden() }) +test("pinning a Home session keeps it above the other sessions", async ({ page }) => { + await openHome(page) + const list = page.getByRole("region", { name: "Recent sessions" }) + const target = row(page, fixture.expected.targetTitle) + await expect(target).toBeVisible() + await expect(list.getByText("Pinned", { exact: true })).toHaveCount(0) + + await target.click({ button: "right" }) + await page.getByRole("menuitem", { name: "Pin", exact: true }).click() + + await expect(list.getByText("Pinned", { exact: true })).toBeVisible() + await expect(list.locator('[data-component="home-session-row-container"]').first()).toHaveAttribute( + "data-session-id", + fixture.targetID, + ) + + await page.reload() + await expect(list.getByText("Pinned", { exact: true })).toBeVisible() + await expect(list.locator('[data-component="home-session-row-container"]').first()).toHaveAttribute( + "data-session-id", + fixture.targetID, + ) + + await target.click({ button: "right" }) + await page.getByRole("menuitem", { name: "Unpin", exact: true }).click() + await expect(list.getByText("Pinned", { exact: true })).toHaveCount(0) +}) + test("the Home shortcut focuses session search, and the Home button leaves focus alone", async ({ page }) => { await mockStressTimeline(page) await seed(page, { diff --git a/packages/app/src/app.tsx b/packages/app/src/app.tsx index 78d11175f81e..c344bc77c715 100644 --- a/packages/app/src/app.tsx +++ b/packages/app/src/app.tsx @@ -10,6 +10,7 @@ import { type Component, createRenderEffect, ErrorBoundary, type JSX, type Paren import { Dynamic } from "solid-js/web" import { CommandProvider } from "@/shell/commands/command" import { DesktopCommands } from "@/shell/commands/desktop" +import { SessionPinsProvider } from "@/home/sessions/pins" import { GlobalProvider } from "@/runtime/server/runtime" import { LanguageProvider, UiI18nBridge, type Locale } from "@/runtime/i18n/language" import { ServerConnection, ServersProvider } from "@/runtime/server/registry" @@ -94,16 +95,18 @@ export function AppInterface(props: { // route changes. Draft and session routes override only their server-bound data // providers beneath it. const Root = (rootProps: ParentProps) => ( - - - - - - {props.children} - {rootProps.children} - - - + + + + + + + {props.children} + {rootProps.children} + + + + ) return ( diff --git a/packages/app/src/home/sessions/controller.tsx b/packages/app/src/home/sessions/controller.tsx index 3e27ebc2f051..a708fbbd05d3 100644 --- a/packages/app/src/home/sessions/controller.tsx +++ b/packages/app/src/home/sessions/controller.tsx @@ -4,6 +4,7 @@ import { Button } from "@opencode/ui/button" import { DialogFooter, DialogHeader, DialogTitleGroup, Dialog } from "@opencode/ui/dialog" import { skipToken, useQuery, useQueryClient } from "@tanstack/solid-query" import { type Accessor, createEffect, createMemo, type JSX, startTransition, untrack } from "solid-js" +import { createStore } from "solid-js/store" import { notifySessionTabsRemoved } from "@/shell/titlebar/session-events" import { useCommand } from "@/shell/commands/command" import { @@ -27,6 +28,7 @@ import { showToast } from "@/shell/notifications/toast" import { archiveHomeSession } from "./archive" import type { HomeController } from "../model" import { buildHomeSessionRecords, homeProjectForSession, homeSessionLocation, type HomeSessionRecord } from "./records" +import { useSessionPins } from "./pins" export type { HomeSessionRecord } from "./records" @@ -34,7 +36,7 @@ export type { HomeSessionRecord } from "./records" const selectSessions = (sessions: SessionInfo[]) => () => sessions export type HomeSessionGroup = { - id: "today" | "yesterday" | "older" + id: "pinned" | "today" | "yesterday" | "older" title: string sessions: HomeSessionRecord[] } @@ -48,6 +50,7 @@ export function createHomeSessionsController(home: HomeController) { const language = useLanguage() const platform = usePlatform() const queryClient = useQueryClient() + const pins = useSessionPins() const projectDirectories = createMemo(() => { const selected = home.selection.value().directory @@ -91,17 +94,70 @@ export function createHomeSessionsController(home: HomeController) { ) }) - const allRecords = createMemo(() => - buildHomeSessionRecords({ - sessions: indexedSessions, + const serverKey = createMemo(() => { + const conn = home.server.focused() + + return conn ? ServerConnection.key(conn) : undefined + }) + + const pinnedIDs = createMemo(() => { + const server = serverKey() + + return server ? pins.ids(server) : [] + }) + + // Pinned sessions can outlive the fetched index, so resolve the ones it does not hold. + const resolvedPins = new Set() + const [resolved, setResolved] = createStore<{ sessions: Record }>({ sessions: {} }) + + createEffect(() => { + const ctx = home.server.focusedContext() + const server = serverKey() + + if (!ctx || !server) return + const indexed = new Set(indexedSessions().map((session) => session.id)) + + pinnedIDs() + .filter((sessionID) => !indexed.has(sessionID)) + .forEach((sessionID) => { + const key = `${server}\0${sessionID}` + + if (resolvedPins.has(key)) return + resolvedPins.add(key) + void untrack(() => ctx.sdk.api.session.get({ sessionID })).then( + (session) => setResolved("sessions", key, session), + () => undefined, + ) + }) + }) + + const pinnedSessions = createMemo(() => { + const server = serverKey() + + if (!server) return [] + const indexed = new Map(indexedSessions().map((session) => [session.id, session] as const)) + + return pinnedIDs().flatMap((sessionID) => { + const session = indexed.get(sessionID) ?? resolved.sessions[`${server}\0${sessionID}`] + + return session && !session.parentID && session.time.archived === undefined ? [session] : [] + }) + }) + + const allRecords = createMemo(() => { + const pinned = new Map(pinnedIDs().map((id, index) => [id, index] as const)) + const rank = (sessionID: string) => pinned.get(sessionID) ?? Number.MAX_SAFE_INTEGER + + return buildHomeSessionRecords({ + sessions: () => [...pinnedSessions(), ...indexedSessions()], projectDirectories, projects: home.project.list, resolveProject: (session) => home.server.focusedContext()?.projects.forSession(session), - }), - ) + }).toSorted((a, b) => rank(a.session.id) - rank(b.session.id)) + }) const records = createMemo(() => allRecords().slice(0, HOME_SESSION_LIMIT)) - const groups = createMemo(() => groupSessions(records(), language)) + const groups = createMemo(() => groupSessions(records(), language, new Set(pinnedIDs()))) const prefetched = new Set() const location = (record: HomeSessionRecord) => { @@ -249,10 +305,11 @@ export function createHomeSessionsController(home: HomeController) { .remove(session.id) .then(() => { notifySessionTabsRemoved({ - server: ServerConnection.key(conn), + server, directory: session.location.directory, sessionIDs: ids, }) + pins.forget(server, ids) return true }) @@ -388,6 +445,19 @@ export function createHomeSessionsController(home: HomeController) { return !!server && sessionHasOpenTab(tabs.store, server, record.session) }, }, + pin: { + is: (record: HomeSessionRecord) => { + const server = serverKey() + + return !!server && pins.pinned(server, record.session.id) + }, + toggle: (record: HomeSessionRecord) => { + const server = serverKey() + + if (!server) return + pins.toggle(server, record.session.id) + }, + }, } } @@ -404,14 +474,20 @@ function localDay(date: Date) { return date.getFullYear() * 10_000 + date.getMonth() * 100 + date.getDate() } -function groupSessions(records: HomeSessionRecord[], language: ReturnType): HomeSessionGroup[] { +function groupSessions( + records: HomeSessionRecord[], + language: ReturnType, + pinned: Set, +): HomeSessionGroup[] { const now = new Date() const today = localDay(now) const yesterday = localDay(new Date(now.getFullYear(), now.getMonth(), now.getDate() - 1)) const day = (record: HomeSessionRecord) => localDay(new Date(record.session.time.updated ?? record.session.time.created)) - const todaySessions = records.filter((record) => day(record) === today) - const yesterdaySessions = records.filter((record) => day(record) === yesterday) - const olderSessions = records.filter((record) => day(record) !== today && day(record) !== yesterday) + const pinnedRecords = records.filter((record) => pinned.has(record.session.id)) + const recent = records.filter((record) => !pinned.has(record.session.id)) + const todaySessions = recent.filter((record) => day(record) === today) + const yesterdaySessions = recent.filter((record) => day(record) === yesterday) + const olderSessions = recent.filter((record) => day(record) !== today && day(record) !== yesterday) const olderTitle = todaySessions.length === 0 && yesterdaySessions.length === 0 @@ -419,6 +495,7 @@ function groupSessions(records: HomeSessionRecord[], language: ReturnType { + test("keeps the order pins were added in and ignores a repeat", () => { + const pins = withPin(withPin({}, server, "ses_a"), server, "ses_b") + + expect(pinnedIDs(pins, server)).toEqual(["ses_a", "ses_b"]) + expect(withPin(pins, server, "ses_a")).toBe(pins) + }) + + test("keeps the remaining order when unpinning and drops the server once empty", () => { + const pins = withPin(withPin({}, server, "ses_a"), server, "ses_b") + + expect(pinnedIDs(withoutPins(pins, server, ["ses_a"]), server)).toEqual(["ses_b"]) + expect(withoutPins(pins, server, ["ses_a", "ses_b"])).toEqual({}) + expect(withoutPins(pins, server, ["ses_missing"])).toBe(pins) + }) +}) diff --git a/packages/app/src/home/sessions/pins.tsx b/packages/app/src/home/sessions/pins.tsx new file mode 100644 index 000000000000..63d96ca0a77b --- /dev/null +++ b/packages/app/src/home/sessions/pins.tsx @@ -0,0 +1,67 @@ +import { createSimpleContext } from "@opencode/ui/context" +import { Schema } from "effect" +import { reconcile } from "solid-js/store" +import { Persistence } from "@/runtime/persistence/schema" +import { Persist, persisted } from "@/runtime/persistence/storage" +import type { ServerConnection } from "@/runtime/server/registry" + +// Session IDs per server, in the order they were pinned. +export const PinnedSessions = Persistence.record(Persistence.array(Schema.String)) + +export type PinnedSessions = typeof PinnedSessions.Type + +export function pinnedIDs(pins: PinnedSessions, server: ServerConnection.Key) { + return pins[server] ?? [] +} + +export function isPinned(pins: PinnedSessions, server: ServerConnection.Key, sessionID: string) { + return pinnedIDs(pins, server).includes(sessionID) +} + +export function withPin(pins: PinnedSessions, server: ServerConnection.Key, sessionID: string) { + const ids = pinnedIDs(pins, server) + + if (ids.includes(sessionID)) return pins + + return { ...pins, [server]: [...ids, sessionID] } +} + +export function withoutPins(pins: PinnedSessions, server: ServerConnection.Key, sessionIDs: readonly string[]) { + const current = pinnedIDs(pins, server) + const ids = current.filter((id) => !sessionIDs.includes(id)) + + if (ids.length === current.length) return pins + + if (ids.length > 0) return { ...pins, [server]: ids } + + const next = { ...pins } + + delete next[server] + + return next +} + +export const { use: useSessionPins, provider: SessionPinsProvider } = createSimpleContext({ + name: "SessionPins", + gate: false, + init: () => { + const [store, setStore] = persisted(Persist.global("home.sessions.pinned"), PinnedSessions, {}) + + return { + ids: (server: ServerConnection.Key) => pinnedIDs(store, server), + pinned: (server: ServerConnection.Key, sessionID: string) => isPinned(store, server, sessionID), + toggle(server: ServerConnection.Key, sessionID: string) { + setStore( + reconcile( + isPinned(store, server, sessionID) + ? withoutPins(store, server, [sessionID]) + : withPin(store, server, sessionID), + ), + ) + }, + forget(server: ServerConnection.Key, sessionIDs: readonly string[]) { + setStore(reconcile(withoutPins(store, server, sessionIDs))) + }, + } + }, +}) diff --git a/packages/app/src/home/sessions/region.tsx b/packages/app/src/home/sessions/region.tsx index 979fb7fdf96d..1cb7dfa5e722 100644 --- a/packages/app/src/home/sessions/region.tsx +++ b/packages/app/src/home/sessions/region.tsx @@ -31,8 +31,10 @@ export function HomeSessions(props: { searchNoResultsLabel={props.search.result.noResultsLabel()} titleOpacity={props.scroll.header.titleOpacity} isOpenTab={props.sessions.tab.isOpen} + isPinned={props.sessions.pin.is} onCreateSession={props.sessions.session.create} onOpenSession={props.sessions.session.open} + onTogglePin={props.sessions.pin.toggle} onArchiveSession={props.sessions.session.archive} onRenameSession={props.sessions.session.rename} onExportSession={props.sessions.session.export} diff --git a/packages/app/src/home/sessions/view.tsx b/packages/app/src/home/sessions/view.tsx index f83940f13fd1..f58a5a70071c 100644 --- a/packages/app/src/home/sessions/view.tsx +++ b/packages/app/src/home/sessions/view.tsx @@ -38,7 +38,7 @@ const HOME_SESSION_LONG_PRESS_MS = 500 function isBackgroundOpen(event: MouseEvent) { return shouldOpenSessionInBackground({ button: event.button, - mac: typeof navigator === "object" && /(Mac|iPod|iPhone|iPad)/.test(navigator.platform), + mac: "navigator" in globalThis && /(Mac|iPod|iPhone|iPad)/.test(navigator.platform), meta: event.metaKey, ctrl: event.ctrlKey, shift: event.shiftKey, @@ -65,8 +65,10 @@ export type HomeSessionsViewProps = { searchNoResultsLabel: string titleOpacity: (id: HomeSessionGroup["id"]) => number isOpenTab: (record: HomeSessionRecord) => boolean + isPinned: (record: HomeSessionRecord) => boolean onCreateSession: () => void onOpenSession: (session: SessionInfo, options?: OpenSessionOptions) => void + onTogglePin: (record: HomeSessionRecord) => void onArchiveSession: (session: SessionInfo) => Promise onRenameSession: (server: ServerConnection.Key, session: SessionInfo, title: string) => Promise onExportSession: (server: ServerConnection.Key, session: SessionInfo) => Promise @@ -779,6 +781,9 @@ function HomeSessionRow( requestAnimationFrame(() => rowButton()?.focus()) }} > + props.onTogglePin(props.record)}> + {props.language.t(props.isPinned(props.record) ? "common.unpin" : "common.pin")} + {props.language.t("common.rename")} void props.onExportSession(props.server, props.record.session)}> {props.language.t("common.export")}… diff --git a/packages/app/src/runtime/i18n/en.ts b/packages/app/src/runtime/i18n/en.ts index 6ee0b5aaffaa..14a09742bf44 100644 --- a/packages/app/src/runtime/i18n/en.ts +++ b/packages/app/src/runtime/i18n/en.ts @@ -83,6 +83,9 @@ export const dict = { "command.session.fork.description": "Create a new session from a previous message", "command.session.export": "Export session", "command.session.export.description": "Export the full session transcript as JSON", + "command.session.pin": "Pin session", + "command.session.pin.description": "Keep this session at the top of the session list", + "command.session.unpin": "Unpin session", "command.session.import": "Import session", "command.session.copyID": "Copy Session ID", @@ -516,6 +519,7 @@ export const dict = { "home.sessions.search.noResults": "No sessions found for {{query}}", "home.sessions.empty": "Nothing here yet", "home.sessions.empty.description": "Create a session to get started", + "home.sessions.group.pinned": "Pinned", "home.sessions.group.today": "Today", "home.sessions.group.yesterday": "Yesterday", "home.sessions.group.older": "Older", @@ -618,6 +622,8 @@ export const dict = { "common.learnMore": "Learn more", "common.rename": "Rename", "common.export": "Export", + "common.pin": "Pin", + "common.unpin": "Unpin", "common.reset": "Reset", "common.archive": "Archive", "common.delete": "Delete", diff --git a/packages/app/src/session/commands/use-session-commands.tsx b/packages/app/src/session/commands/use-session-commands.tsx index ebfba7abfe6e..e5ee8cb056d0 100644 --- a/packages/app/src/session/commands/use-session-commands.tsx +++ b/packages/app/src/session/commands/use-session-commands.tsx @@ -15,6 +15,8 @@ import { fetchSessionExport, saveSessionExport, sessionExportFilename } from "@/ import { usePlatform } from "@/runtime/platform/platform" import type { SessionModel } from "@/session/model" import type { SessionRevert } from "@/session/revert" +import { useServer } from "@/runtime/server/current" +import { useSessionPins } from "@/home/sessions/pins" import { Command } from "@opencode/gui-extensions/sdk" import { useExtensionHost } from "@/runtime/extension/host" import type { Region } from "@/runtime/extension/panels" @@ -60,6 +62,8 @@ export const useSessionCommands = (actions: SessionCommandContext) => { const platform = usePlatform() const layout = useLayout() const host = useExtensionHost() + const server = useServer() + const pins = useSessionPins() const openDialog = async (load: () => Promise, show: (value: T) => void) => { const owner = actions.session.ownership.capture() @@ -301,6 +305,27 @@ export const useSessionCommands = (actions: SessionCommandContext) => { const undo = actions.revert.undo const redo = actions.revert.redo + // Subagent sessions are not listed on Home, so they cannot be pinned. + const pinnableSessionID = () => { + const sessionID = actions.session.identity.params.id + + if (!sessionID || actions.session.data.info()?.parentID) return + + return sessionID + } + + const pinned = () => { + const sessionID = pinnableSessionID() + + return !!sessionID && pins.pinned(server.key, sessionID) + } + + const togglePin = () => { + const sessionID = pinnableSessionID() + + if (sessionID) pins.toggle(server.key, sessionID) + } + const compact = async () => { const sessionID = actions.session.identity.params.id @@ -382,6 +407,13 @@ export const useSessionCommands = (actions: SessionCommandContext) => { disabled: !actions.session.identity.params.id, onSelect: copySessionID, }), + sessionCommand({ + id: "session.pin", + title: language.t(pinned() ? "command.session.unpin" : "command.session.pin"), + description: language.t("command.session.pin.description"), + disabled: !pinnableSessionID(), + onSelect: togglePin, + }), ] const fileCmds = () => {