openAgent

1import { useDialog } from "../ui/dialog"
2import { DialogSelect } from "../ui/dialog-select"
3import { useRoute } from "../context/route"
4import { useSync } from "../context/sync"
5import { createMemo, createResource, createSignal, onCleanup, onMount } from "solid-js"
6import path from "path"
7import { Locale } from "../util/locale"
8import { useProject } from "../context/project"
9import { useTheme } from "../context/theme"
10import { useSDK } from "../context/sdk"
11import { useLocal } from "../context/local"
12import { DialogSessionRename } from "./dialog-session-rename"
13import { createDebouncedSignal } from "../util/signal"
14import { useToast } from "../ui/toast"
15import { openWorkspaceSelect, type WorkspaceSelection, warpWorkspaceSession } from "./dialog-workspace-create"
16import { Spinner } from "./spinner"
17import { errorMessage } from "../util/error"
18import { DialogSessionDeleteFailed } from "./dialog-session-delete-failed"
19import { useCommandShortcut } from "../keymap"
20import { useEvent } from "../context/event"
21 
22type SessionListFilter = { scope?: "project"; path?: string }
23 
24export function createDialogSessionListQuery(input: { search?: string; filter: SessionListFilter }) {
25  const search = input.search?.trim()
26  return {
27    roots: true,
28    limit: search ? 30 : 100,
29    ...(search ? { search } : {}),
30    ...input.filter,
31  }
32}
33 
34export function loadDialogSessionList<T>(input: {
35  search?: string
36  filter: SessionListFilter
37  list: (query: ReturnType<typeof createDialogSessionListQuery>) => Promise<{ data?: T[] }>
38}) {
39  return input.list(createDialogSessionListQuery(input)).then(
40    (result) => result.data,
41    () => undefined,
42  )
43}
44 
45export function DialogSessionList() {
46  const dialog = useDialog()
47  const route = useRoute()
48  const sync = useSync()
49  const project = useProject()
50  const { theme } = useTheme()
51  const sdk = useSDK()
52  const event = useEvent()
53  const local = useLocal()
54  const toast = useToast()
55  const [toDelete, setToDelete] = createSignal<string>()
56  const [deleted, setDeleted] = createSignal(new Set<string>())
57  const [search, setSearch] = createDebouncedSignal("", 150)
58  const deleteHint = useCommandShortcut("session.delete")
59  const quickSwitch1 = useCommandShortcut("session.quick_switch.1")
60  const quickSwitch9 = useCommandShortcut("session.quick_switch.9")
61 
62  const [browseResults, { refetch: refetchBrowse }] = createResource(
63    () => sync.session.query(),
64    (filter) => loadDialogSessionList({ filter, list: (query) => sdk.client.session.list(query) }),
65  )
66  const [searchResults, { refetch }] = createResource(
67    () => ({ query: search(), filter: sync.session.query() }),
68    (input) => {
69      if (!input.query) return undefined
70      return loadDialogSessionList({
71        search: input.query,
72        filter: input.filter,
73        list: (query) => sdk.client.session.list(query),
74      })
75    },
76  )
77 
78  const currentSessionID = createMemo(() => (route.data.type === "session" ? route.data.sessionID : undefined))
79  const sessions = createMemo(() => {
80    const result = searchResults() ?? browseResults() ?? sync.data.session
81    const synced = new Map(sync.data.session.map((session) => [session.id, session]))
82    const ids = new Set(result.map((session) => session.id))
83    const extra = [currentSessionID(), ...local.session.pinned()].flatMap((id) => {
84      if (!id || ids.has(id)) return []
85      const session = synced.get(id)
86      if (session) ids.add(id)
87      return session ? [session] : []
88    })
89    const query = search().trim().toLowerCase()
90    return [...result.map((session) => synced.get(session.id) ?? session), ...extra]
91      .filter((session) => !deleted().has(session.id))
92      .filter((session) => !query || session.title.toLowerCase().includes(query))
93  })
94 
95  onCleanup(
96    event.on("session.deleted", (event) => {
97      setDeleted((current) => new Set(current).add(event.properties.info.id))
98    }),
99  )
100 
101  function recover(session: NonNullable<ReturnType<typeof sessions>[number]>) {
102    const workspace = project.workspace.get(session.workspaceID!)
103    const list = () => dialog.replace(() => <DialogSessionList />)
104    const warp = async (selection: WorkspaceSelection) => {
105      const workspaceID = await (async () => {
106        if (selection.type === "none") return null
107        if (selection.type === "existing") return selection.workspaceID
108        let result
109        try {
110          result = await sdk.client.experimental.workspace.create({ type: selection.workspaceType, branch: null })
111        } catch (err) {
112          toast.show({
113            title: "Failed to create workspace",
114            message: errorMessage(err),
115            variant: "error",
116          })
117          return
118        }
119        const workspace = result?.data
120        if (!workspace) {
121          toast.show({
122            title: "Failed to create workspace",
123            message: errorMessage(result?.error ?? "no response"),
124            variant: "error",
125          })
126          return
127        }
128        await project.workspace.sync()
129        return workspace.id
130      })()
131      if (workspaceID === undefined) return
132      await warpWorkspaceSession({
133        dialog,
134        sdk,
135        sync,
136        project,
137        toast,
138        sourceWorkspaceID: session.workspaceID,
139        workspaceID,
140        sessionID: session.id,
141        copyChanges: false,
142        done: list,
143      })
144    }
145    dialog.replace(() => (
146      <DialogSessionDeleteFailed
147        session={session.title}
148        workspace={workspace?.name ?? session.workspaceID!}
149        onDone={list}
150        onDelete={async () => {
151          const current = currentSessionID()
152          const info = current ? sync.data.session.find((item) => item.id === current) : undefined
153          const result = await sdk.client.experimental.workspace.remove({ id: session.workspaceID! })
154          if (result.error) {
155            toast.show({
156              variant: "error",
157              title: "Failed to delete workspace",
158              message: errorMessage(result.error),
159            })
160            return false
161          }
162          await project.workspace.sync()
163          await sync.session.refresh()
164          await refetchBrowse()
165          if (search()) await refetch()
166          if (info?.workspaceID === session.workspaceID) {
167            route.navigate({ type: "home" })
168          }
169          return true
170        }}
171        onRestore={() => {
172          void openWorkspaceSelect({
173            dialog,
174            sdk,
175            sync,
176            project,
177            toast,
178            onSelect: (selection) => {
179              void warp(selection)
180            },
181          })
182          return false
183        }}
184      />
185    ))
186  }
187 
188  function orderByRecency(sessionsList: NonNullable<ReturnType<typeof sessions>>) {
189    return sessionsList
190      .filter((x) => x.parentID === undefined)
191      .toSorted((a, b) => b.time.updated - a.time.updated)
192      .map((x) => x.id)
193  }
194 
195  const browseOrder = createMemo(() => orderByRecency(browseResults() ?? sync.data.session))
196 
197  const quickSwitchHint = createMemo(() => {
198    const first = quickSwitch1()
199    const last = quickSwitch9()
200    if (!first || !last) return undefined
201    return quickSwitchRange(first, last)
202  })
203  const quickSwitchFooterHints = createMemo(() => {
204    const hint = quickSwitchHint()
205    return hint && local.session.slots().length > 0 ? [{ title: "switch", label: hint }] : []
206  })
207 
208  const options = createMemo(() => {
209    const today = new Date().toDateString()
210    const sessionMap = new Map(
211      sessions()
212        .filter((x) => x.parentID === undefined)
213        .map((x) => [x.id, x]),
214    )
215 
216    const searchResult = searchResults()
217    const order = searchResult ? orderByRecency(sessions()) : browseOrder()
218    const current = currentSessionID()
219    const displayOrder = current && sessionMap.has(current) && !order.includes(current) ? [...order, current] : order
220 
221    const pinned = local.session.pinned().filter((id) => sessionMap.has(id))
222    const pinnedSet = new Set(pinned)
223    const slotByID = new Map<string, number>(local.session.slots().map((id, i) => [id, i + 1]))
224 
225    function buildOption(id: string, category: string) {
226      const x = sessionMap.get(id)
227      if (!x) return undefined
228      const directory = x.path
229        ? x.directory.endsWith(x.path)
230          ? x.directory.slice(0, -x.path.length).replace(/\/$/, "")
231          : undefined
232        : x.directory
233      const footer =
234        directory && directory !== project.data.project.mainDir ? Locale.truncate(path.basename(directory), 20) : ""
235 
236      const isDeleting = toDelete() === x.id
237      const status = sync.data.session_status?.[x.id]
238      const isWorking = status?.type === "busy" || status?.type === "retry"
239      const slot = slotByID.get(x.id)
240      const gutter = isWorking
241        ? () => <Spinner />
242        : slot !== undefined
243          ? () => <text fg={theme.accent}>{slot}</text>
244          : undefined
245      return {
246        title: isDeleting ? `Press ${deleteHint()} again to confirm` : x.title,
247        bg: isDeleting ? theme.error : undefined,
248        value: x.id,
249        category,
250        footer,
251        gutter,
252      }
253    }
254 
255    const remaining = displayOrder
256      .filter((id) => !pinnedSet.has(id))
257      .map((id) => {
258        const x = sessionMap.get(id)
259        if (!x) return undefined
260        const label = new Date(x.time.updated).toDateString()
261        return buildOption(id, label === today ? "Today" : label)
262      })
263      .filter((x) => x !== undefined)
264 
265    return [...pinned.map((id) => buildOption(id, "Pinned")).filter((x) => x !== undefined), ...remaining]
266  })
267 
268  onMount(() => {
269    dialog.setSize("large")
270  })
271 
272  return (
273    <DialogSelect
274      title="Sessions"
275      options={options()}
276      skipFilter={true}
277      preserveSelection={true}
278      current={currentSessionID()}
279      onFilter={setSearch}
280      onMove={() => {
281        setToDelete(undefined)
282      }}
283      onSelect={(option) => {
284        route.navigate({
285          type: "session",
286          sessionID: option.value,
287        })
288        dialog.clear()
289      }}
290      actions={[
291        {
292          command: "session.pin.toggle",
293          title: "pin/unpin",
294          onTrigger: (option: { value: string }) => {
295            local.session.togglePin(option.value)
296          },
297        },
298        {
299          command: "session.delete",
300          title: "delete",
301          onTrigger: async (option) => {
302            if (toDelete() === option.value) {
303              const session = sessions().find((item) => item.id === option.value)
304              const status = session?.workspaceID ? project.workspace.status(session.workspaceID) : undefined
305 
306              try {
307                const result = await sdk.client.session.delete({
308                  sessionID: option.value,
309                })
310                if (result.error) {
311                  if (session?.workspaceID) {
312                    recover(session)
313                  } else {
314                    toast.show({
315                      variant: "error",
316                      title: "Failed to delete session",
317                      message: errorMessage(result.error),
318                    })
319                  }
320                  setToDelete(undefined)
321                  return
322                }
323              } catch (err) {
324                if (session?.workspaceID) {
325                  recover(session)
326                } else {
327                  toast.show({
328                    variant: "error",
329                    title: "Failed to delete session",
330                    message: errorMessage(err),
331                  })
332                }
333                setToDelete(undefined)
334                return
335              }
336              if (status && status !== "connected") {
337                await sync.session.refresh()
338              }
339              await refetchBrowse()
340              if (search()) await refetch()
341              setToDelete(undefined)
342              return
343            }
344            setToDelete(option.value)
345          },
346        },
347        {
348          command: "session.rename",
349          title: "rename",
350          onTrigger: async (option) => {
351            dialog.replace(() => <DialogSessionRename session={option.value} />)
352          },
353        },
354      ]}
355      footerHints={quickSwitchFooterHints()}
356    />
357  )
358}
359 
360function quickSwitchRange(first: string, last: string) {
361  const prefix = first.slice(0, -1)
362  if (first.endsWith("1") && last === `${prefix}9`) return `${prefix}1-9`
363  return `${first} through ${last}`
364}
365