refactor(cli): convert import command to effectCmd (#25467)

packages/opencode/src/cli/cmd/import.ts

@@ -1,17 +1,15 @@
-import type { Argv } from "yargs"
 import type { Session as SDKSession, Message, Part } from "@opencode-ai/sdk/v2"
 import { Session } from "@/session/session"
 import { MessageV2 } from "../../session/message-v2"
-import { cmd } from "./cmd"
+import { CliError, effectCmd } from "../effect-cmd"
-import { bootstrap } from "../bootstrap"
 import { Database } from "@/storage/db"
 import { SessionTable, MessageTable, PartTable } from "../../session/session.sql"
-import { Instance } from "../../project/instance"
+import { InstanceRef } from "@/effect/instance-ref"
+import { InstanceStore } from "@/project/instance-store"
 import { ShareNext } from "@/share/share-next"
 import { EOL } from "os"
 import { Filesystem } from "@/util/filesystem"
-import { AppRuntime } from "@/effect/app-runtime"
+import { Effect, Schema } from "effect"
-import { Schema } from "effect"
 
 const decodeMessageInfo = Schema.decodeUnknownSync(MessageV2.Info)
 const decodePart = Schema.decodeUnknownSync(MessageV2.Part)
@@ -78,135 +76,147 @@ export function transformShareData(shareData: ShareData[]): {
   }
 }
 
-export const ImportCommand = cmd({
+type ExportData = { info: SDKSession; messages: Array<{ info: Message; parts: Part[] }> }
+
+export const ImportCommand = effectCmd({
   command: "import <file>",
   describe: "import session data from JSON file or URL",
-  builder: (yargs: Argv) => {
+  builder: (yargs) =>
-    return yargs.positional("file", {
+    yargs.positional("file", {
       describe: "path to JSON file or share URL",
       type: "string",
       demandOption: true,
+    }),
+  handler: Effect.fn("Cli.import")(function* (args) {
+    // effectCmd always provides InstanceRef via InstanceStore.Service.provide; this is an invariant.
+    const ctx = yield* InstanceRef
+    if (!ctx) return yield* Effect.die("InstanceRef not provided")
+    const store = yield* InstanceStore.Service
+    // Ensure store.dispose runs disposers and emits server.instance.disposed
+    // on every exit path: success, early return, typed failure, defect, interrupt.
+    return yield* runImport(args.file, ctx.project.id).pipe(Effect.ensuring(store.dispose(ctx)))
+  }),
+})
+
+const runImport = Effect.fn("Cli.import.body")(function* (file: string, projectID: string) {
+  const share = yield* ShareNext.Service
+
+  let exportData: ExportData | undefined
+
+  const isUrl = file.startsWith("http://") || file.startsWith("https://")
+
+  if (isUrl) {
+    const slug = parseShareUrl(file)
+    if (!slug) {
+      const baseUrl = yield* Effect.orDie(share.url())
+      process.stdout.write(`Invalid URL format. Expected: ${baseUrl}/share/<slug>`)
+      process.stdout.write(EOL)
+      return
+    }
+
+    const baseUrl = new URL(file).origin
+    const req = yield* Effect.orDie(share.request())
+    const headers = shouldAttachShareAuthHeaders(file, req.baseUrl) ? req.headers : {}
+
+    const tryFetch = (url: string) =>
+      Effect.tryPromise({
+        try: () => fetch(url, { headers }),
+        catch: (e) =>
+          new CliError({
+            message: `Failed to fetch share data: ${e instanceof Error ? e.message : String(e)}`,
+          }),
+      })
+
+    const dataPath = req.api.data(slug)
+    let response = yield* tryFetch(`${baseUrl}${dataPath}`)
+
+    if (!response.ok && dataPath !== `/api/share/${slug}/data`) {
+      response = yield* tryFetch(`${baseUrl}/api/share/${slug}/data`)
+    }
+
+    if (!response.ok) {
+      process.stdout.write(`Failed to fetch share data: ${response.statusText}`)
+      process.stdout.write(EOL)
+      return
+    }
+
+    const shareData = yield* Effect.tryPromise({
+      try: () => response.json() as Promise<ShareData[]>,
+      catch: () => new CliError({ message: "Share data was not valid JSON" }),
     })
-  },
+    const transformed = transformShareData(shareData)
-  handler: async (args) => {
-    await bootstrap(process.cwd(), async () => {
-      let exportData:
-        | {
-            info: SDKSession
-            messages: Array<{
-              info: Message
-              parts: Part[]
-            }>
-          }
-        | undefined
 
-      const isUrl = args.file.startsWith("http://") || args.file.startsWith("https://")
+    if (!transformed) {
+      process.stdout.write(`Share not found or empty: ${slug}`)
+      process.stdout.write(EOL)
+      return
+    }
 
-      if (isUrl) {
+    exportData = transformed
-        const slug = parseShareUrl(args.file)
+  } else {
-        if (!slug) {
+    exportData = yield* Effect.promise(() =>
-          const baseUrl = await AppRuntime.runPromise(ShareNext.Service.use((svc) => svc.url()))
+      Filesystem.readJson<NonNullable<typeof exportData>>(file).catch(() => undefined),
-          process.stdout.write(`Invalid URL format. Expected: ${baseUrl}/share/<slug>`)
+    )
-          process.stdout.write(EOL)
+    if (!exportData) {
-          return
+      process.stdout.write(`File not found: ${file}`)
-        }
+      process.stdout.write(EOL)
+      return
+    }
+  }
 
-        const parsed = new URL(args.file)
+  if (!exportData) {
-        const baseUrl = parsed.origin
+    process.stdout.write(`Failed to read session data`)
-        const req = await AppRuntime.runPromise(ShareNext.Service.use((svc) => svc.request()))
+    process.stdout.write(EOL)
-        const headers = shouldAttachShareAuthHeaders(args.file, req.baseUrl) ? req.headers : {}
+    return
+  }
 
-        const dataPath = req.api.data(slug)
+  const info = Schema.decodeUnknownSync(Session.Info)({
-        let response = await fetch(`${baseUrl}${dataPath}`, {
+    ...exportData.info,
-          headers,
+    projectID,
+  }) as Session.Info
+  const row = Session.toRow(info)
+  Database.use((db) =>
+    db
+      .insert(SessionTable)
+      .values(row)
+      .onConflictDoUpdate({ target: SessionTable.id, set: { project_id: row.project_id } })
+      .run(),
+  )
+
+  for (const msg of exportData.messages) {
+    const msgInfo = decodeMessageInfo(msg.info) as MessageV2.Info
+    const { id, sessionID: _, ...msgData } = msgInfo
+    Database.use((db) =>
+      db
+        .insert(MessageTable)
+        .values({
+          id,
+          session_id: row.id,
+          time_created: msgInfo.time?.created ?? Date.now(),
+          data: msgData,
         })
+        .onConflictDoNothing()
+        .run(),
+    )
 
-        if (!response.ok && dataPath !== `/api/share/${slug}/data`) {
+    for (const part of msg.parts) {
-          response = await fetch(`${baseUrl}/api/share/${slug}/data`, {
+      const partInfo = decodePart(part) as MessageV2.Part
-            headers,
+      const { id: partId, sessionID: _s, messageID, ...partData } = partInfo
-          })
-        }
-
-        if (!response.ok) {
-          process.stdout.write(`Failed to fetch share data: ${response.statusText}`)
-          process.stdout.write(EOL)
-          return
-        }
-
-        const shareData: ShareData[] = await response.json()
-        const transformed = transformShareData(shareData)
-
-        if (!transformed) {
-          process.stdout.write(`Share not found or empty: ${slug}`)
-          process.stdout.write(EOL)
-          return
-        }
-
-        exportData = transformed
-      } else {
-        exportData = await Filesystem.readJson<NonNullable<typeof exportData>>(args.file).catch(() => undefined)
-        if (!exportData) {
-          process.stdout.write(`File not found: ${args.file}`)
-          process.stdout.write(EOL)
-          return
-        }
-      }
-
-      if (!exportData) {
-        process.stdout.write(`Failed to read session data`)
-        process.stdout.write(EOL)
-        return
-      }
-
-      const info = Schema.decodeUnknownSync(Session.Info)({
-        ...exportData.info,
-        projectID: Instance.project.id,
-      }) as Session.Info
-      const row = Session.toRow(info)
       Database.use((db) =>
         db
-          .insert(SessionTable)
+          .insert(PartTable)
-          .values(row)
+          .values({
-          .onConflictDoUpdate({ target: SessionTable.id, set: { project_id: row.project_id } })
+            id: partId,
+            message_id: messageID,
+            session_id: row.id,
+            data: partData,
+          })
+          .onConflictDoNothing()
           .run(),
       )
+    }
+  }
 
-      for (const msg of exportData.messages) {
+  process.stdout.write(`Imported session: ${exportData.info.id}`)
-        const msgInfo = decodeMessageInfo(msg.info) as MessageV2.Info
+  process.stdout.write(EOL)
-        const { id, sessionID: _, ...msgData } = msgInfo
-        Database.use((db) =>
-          db
-            .insert(MessageTable)
-            .values({
-              id,
-              session_id: row.id,
-              time_created: msgInfo.time?.created ?? Date.now(),
-              data: msgData,
-            })
-            .onConflictDoNothing()
-            .run(),
-        )
-
-        for (const part of msg.parts) {
-          const partInfo = decodePart(part) as MessageV2.Part
-          const { id: partId, sessionID: _s, messageID, ...partData } = partInfo
-          Database.use((db) =>
-            db
-              .insert(PartTable)
-              .values({
-                id: partId,
-                message_id: messageID,
-                session_id: row.id,
-                data: partData,
-              })
-              .onConflictDoNothing()
-              .run(),
-          )
-        }
-      }
-
-      process.stdout.write(`Imported session: ${exportData.info.id}`)
-      process.stdout.write(EOL)
-    })
-  },
 })