openAgent

1import type { ExperimentalWorkspaceAdapterListResponse, Workspace } from "@opencode-ai/sdk/v2"
2import { useDialog } from "../ui/dialog"
3import { DialogSelect, type DialogSelectOption } from "../ui/dialog-select"
4import { useSync } from "../context/sync"
5import { useProject } from "../context/project"
6import { useRoute } from "../context/route"
7import { createMemo, createSignal, onMount } from "solid-js"
8import { errorMessage } from "../util/error"
9import { useSDK } from "../context/sdk"
10import { useToast } from "../ui/toast"
11import { DialogAlert } from "../ui/dialog-alert"
12import { DialogWorkspaceFileChanges } from "./dialog-workspace-file-changes"
13 
14type Adapter = ExperimentalWorkspaceAdapterListResponse[number]
15 
16export type WorkspaceSelection =
17  | {
18      type: "none"
19    }
20  | {
21      type: "new"
22      workspaceType: string
23      workspaceName: string
24    }
25  | {
26      type: "existing"
27      workspaceID: string
28      workspaceType: string
29      workspaceName: string
30    }
31 
32type WorkspaceSelectValue = WorkspaceSelection | { type: "existing-list" }
33type ExistingWorkspaceSelectValue = { workspace: Workspace }
34 
35export function recentConnectedWorkspaces<WorkspaceInfo extends { id: string; timeUsed: number | string }>(input: {
36  workspaces: readonly WorkspaceInfo[]
37  status: (workspaceID: string) => string | undefined
38  limit?: number
39  omitWorkspaceID?: string
40}) {
41  const allWorkspaces = input.workspaces.filter((workspace) => input.status(workspace.id) === "connected")
42  const workspaces = allWorkspaces.toSorted((a, b) => Number(b.timeUsed) - Number(a.timeUsed))
43  const recent = workspaces.slice(0, input.limit ?? 3)
44 
45  return { recent, hasMore: recent.length < workspaces.length }
46}
47 
48export function warpReminderText(dir: string) {
49  return `<system-reminder>The user has changed the current working directory to "${dir}". This is still the same project but at a possibly new location; take this into account when working with any files from now on.</system-reminder>`
50}
51 
52async function loadWorkspaceAdapters(input: {
53  sdk: ReturnType<typeof useSDK>
54  sync: ReturnType<typeof useSync>
55  toast: ReturnType<typeof useToast>
56}) {
57  const dir = input.sync.path.directory || input.sdk.directory
58  try {
59    const response = await input.sdk.client.experimental.workspace.adapter.list({ directory: dir })
60    if (response.error) throw response.error
61    return response.data
62  } catch (err) {
63    input.toast.show({
64      title: "Failed to load workspace adapters",
65      message: errorMessage(err),
66      variant: "error",
67    })
68    return undefined
69  }
70}
71 
72export async function openWorkspaceSelect(input: {
73  dialog: ReturnType<typeof useDialog>
74  sdk: ReturnType<typeof useSDK>
75  sync: ReturnType<typeof useSync>
76  project: ReturnType<typeof useProject>
77  toast: ReturnType<typeof useToast>
78  onSelect: (selection: WorkspaceSelection) => Promise<void> | void
79}) {
80  input.dialog.clear()
81  await input.sdk.client.experimental.workspace.syncList().catch(() => undefined)
82  await input.project.workspace.sync().catch(() => undefined)
83  const adapters = await loadWorkspaceAdapters(input)
84  if (!adapters) return
85  input.dialog.replace(() => <DialogWorkspaceSelect adapters={adapters} onSelect={input.onSelect} />)
86}
87 
88export async function warpWorkspaceSession(input: {
89  dialog: ReturnType<typeof useDialog>
90  sdk: ReturnType<typeof useSDK>
91  sync: ReturnType<typeof useSync>
92  project: ReturnType<typeof useProject>
93  toast: ReturnType<typeof useToast>
94  sourceWorkspaceID?: string
95  workspaceID: string | null
96  sessionID: string
97  copyChanges: boolean
98  done?: () => void
99}): Promise<boolean> {
100  let result
101  try {
102    result = await input.sdk.client.experimental.workspace.warp({
103      id: input.workspaceID,
104      sessionID: input.sessionID,
105      copyChanges: input.copyChanges,
106    })
107  } catch (err) {
108    input.toast.show({
109      title: "Failed to warp session",
110      message: errorMessage(err),
111      variant: "error",
112    })
113    return false
114  }
115  if (!result?.data) {
116    if (result?.error && "name" in result.error && result.error.name === "VcsApplyError") {
117      await DialogAlert.show(
118        input.dialog,
119        "Unable to Warp Session",
120        "Unable to apply file changes to this workspace. It has existing changes that conflict or is based off a different branch. Session has not been warped.",
121      )
122      return false
123    }
124 
125    input.toast.show({
126      title: "Failed to warp session",
127      message: errorMessage(result?.error ?? "no response"),
128      variant: "error",
129    })
130    return false
131  }
132 
133  input.project.workspace.set(input.workspaceID)
134 
135  await input.sync.bootstrap({ fatal: false }).catch(() => undefined)
136 
137  const dir = input.project.instance.directory() || input.sync.path.directory
138  if (dir) {
139    await input.sdk.client.session
140      .promptAsync({
141        sessionID: input.sessionID,
142        workspace: input.workspaceID ?? undefined,
143        noReply: true,
144        parts: [
145          {
146            type: "text",
147            text: warpReminderText(dir),
148            synthetic: true,
149          },
150        ],
151      })
152      .catch(() => undefined)
153  }
154 
155  await Promise.all([input.project.workspace.sync(), input.sync.session.refresh()])
156 
157  if (input.done) {
158    input.done()
159    return true
160  }
161  input.dialog.clear()
162  return true
163}
164 
165export async function confirmWorkspaceFileChanges(input: {
166  dialog: ReturnType<typeof useDialog>
167  sdk: ReturnType<typeof useSDK>
168  sourceWorkspaceID?: string
169}) {
170  const status = await input.sdk.client.vcs.status({ workspace: input.sourceWorkspaceID }).catch(() => undefined)
171  const fileChangeChoice = status?.data?.length
172    ? await DialogWorkspaceFileChanges.show(input.dialog, status.data)
173    : "no"
174  if (!fileChangeChoice) return
175  return fileChangeChoice === "yes"
176}
177 
178export function DialogWorkspaceSelect(props: {
179  adapters?: Adapter[]
180  onSelect: (selection: WorkspaceSelection) => Promise<void> | void
181}) {
182  const dialog = useDialog()
183  const project = useProject()
184  const route = useRoute()
185  const sync = useSync()
186  const sdk = useSDK()
187  const toast = useToast()
188  const [adapters, setAdapters] = createSignal<Adapter[] | undefined>(props.adapters)
189  const omittedWorkspaceID = createMemo(() => (route.data.type === "session" ? project.workspace.current() : undefined))
190 
191  onMount(() => {
192    dialog.setSize("medium")
193    void (async () => {
194      if (adapters()) return
195      const res = await loadWorkspaceAdapters({ sdk, sync, toast })
196      if (!res) return
197      setAdapters(res)
198    })()
199  })
200 
201  const options = createMemo<DialogSelectOption<WorkspaceSelectValue>[]>(() => {
202    const list = adapters()
203    if (!list) return []
204    const { recent, hasMore } = recentConnectedWorkspaces({
205      workspaces: project.workspace.list(),
206      status: project.workspace.status,
207      omitWorkspaceID: omittedWorkspaceID(),
208    })
209    return [
210      ...list.map((adapter) => ({
211        title: adapter.name,
212        value: { type: "new" as const, workspaceType: adapter.type, workspaceName: adapter.name },
213        description: adapter.description,
214        category: "New workspace",
215      })),
216      {
217        title: "None",
218        value: { type: "none" as const },
219        description: "Use the local project",
220        category: "Choose workspace",
221      },
222      ...recent.map((workspace: Workspace) => ({
223        title: workspace.name,
224        description: `(${workspace.type})`,
225        value: {
226          type: "existing" as const,
227          workspaceID: workspace.id,
228          workspaceType: workspace.type,
229          workspaceName: workspace.name,
230        },
231        category: "Choose workspace",
232      })),
233      ...(hasMore
234        ? [
235            {
236              title: "View all workspaces",
237              value: { type: "existing-list" as const },
238              description: "Choose from all workspaces",
239              category: "Choose workspace",
240            },
241          ]
242        : []),
243    ]
244  })
245 
246  if (!adapters()) return null
247  return (
248    <DialogSelect<WorkspaceSelectValue>
249      title="Warp"
250      skipFilter={true}
251      renderFilter={false}
252      options={options()}
253      onSelect={(option) => {
254        if (!option.value) return
255        if (option.value.type === "none") {
256          void props.onSelect(option.value)
257          return
258        }
259        if (option.value.type === "new") {
260          void props.onSelect(option.value)
261          return
262        }
263        if (option.value.type === "existing") {
264          void props.onSelect(option.value)
265          return
266        }
267 
268        dialog.replace(() => (
269          <DialogExistingWorkspaceSelect omitWorkspaceID={omittedWorkspaceID()} onSelect={props.onSelect} />
270        ))
271      }}
272    />
273  )
274}
275 
276function DialogExistingWorkspaceSelect(props: {
277  omitWorkspaceID?: string
278  onSelect: (selection: WorkspaceSelection) => Promise<void> | void
279}) {
280  const project = useProject()
281 
282  const options = createMemo<DialogSelectOption<ExistingWorkspaceSelectValue>[]>(() =>
283    project.workspace
284      .list()
285      .filter((workspace) => project.workspace.status(workspace.id) === "connected")
286      .filter((workspace) => workspace.id !== props.omitWorkspaceID)
287      .map((workspace: Workspace) => ({
288        title: workspace.name,
289        description: `(${workspace.type})`,
290        value: { workspace },
291      })),
292  )
293 
294  return (
295    <DialogSelect<ExistingWorkspaceSelectValue>
296      title="Existing Workspace"
297      options={options()}
298      onSelect={(option) => {
299        void props.onSelect({
300          type: "existing",
301          workspaceID: option.value.workspace.id,
302          workspaceType: option.value.workspace.type,
303          workspaceName: option.value.workspace.name,
304        })
305      }}
306    />
307  )
308}
309