feat: add session export cli command

opencode session export [sessionID]

export session transcript to file

Positionals:
  sessionID  session id to export

Options:
  -o, --output      output file path
  -f, --format      output format
  [string] [choices: "markdown", "json"] [default: "markdown"]

Signed-off-by: Christian Stewart <[email protected]>

Author: paralin

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

@@ -5,11 +5,12 @@ import { bootstrap } from "../bootstrap"
 import { UI } from "../ui"
 import { Locale } from "../../util/locale"
 import { EOL } from "os"
+import * as prompts from "@clack/prompts"
 
 export const SessionCommand = cmd({
   command: "session",
   describe: "manage sessions",
-  builder: (yargs: Argv) => yargs.command(SessionListCommand).demandCommand(),
+  builder: (yargs: Argv) => yargs.command(SessionListCommand).command(SessionExportCommand).demandCommand(),
   async handler() {},
 })
 
@@ -104,3 +105,119 @@ function formatSessionJSON(sessions: Session.Info[]): string {
   }))
   return JSON.stringify(jsonData, null, 2)
 }
+
+export const SessionExportCommand = cmd({
+  command: "export [sessionID]",
+  describe: "export session transcript to file",
+  builder: (yargs: Argv) => {
+    return yargs
+      .positional("sessionID", {
+        describe: "session id to export",
+        type: "string",
+      })
+      .option("output", {
+        alias: "o",
+        describe: "output file path",
+        type: "string",
+      })
+      .option("format", {
+        alias: "f",
+        describe: "output format",
+        type: "string",
+        choices: ["markdown", "json"],
+        default: "markdown",
+      })
+  },
+  handler: async (args) => {
+    await bootstrap(process.cwd(), async () => {
+      let sessionID = args.sessionID
+
+      if (!sessionID) {
+        prompts.intro("Export session", {
+          output: process.stderr,
+        })
+
+        const sessions = []
+        for await (const session of Session.list()) {
+          sessions.push(session)
+        }
+
+        if (sessions.length === 0) {
+          prompts.log.error("No sessions found", {
+            output: process.stderr,
+          })
+          prompts.outro("Done", {
+            output: process.stderr,
+          })
+          return
+        }
+
+        sessions.sort((a, b) => b.time.updated - a.time.updated)
+
+        const selectedSession = await prompts.autocomplete({
+          message: "Select session to export",
+          maxItems: 10,
+          options: sessions.map((session) => ({
+            label: session.title,
+            value: session.id,
+            hint: `${new Date(session.time.updated).toLocaleString()} • ${session.id.slice(-8)}`,
+          })),
+          output: process.stderr,
+        })
+
+        if (prompts.isCancel(selectedSession)) {
+          throw new UI.CancelledError()
+        }
+
+        sessionID = selectedSession as string
+      }
+
+      const sessionInfo = await Session.get(sessionID!)
+
+      let content: string
+      let defaultExtension: string
+
+      if (args.format === "json") {
+        const sessionMessages = await Session.messages({ sessionID: sessionID! })
+        const exportData = {
+          info: sessionInfo,
+          messages: sessionMessages.map((msg) => ({
+            info: msg.info,
+            parts: msg.parts,
+          })),
+        }
+        content = JSON.stringify(exportData, null, 2)
+        defaultExtension = "json"
+      } else {
+        content = await Session.exportMarkdown({
+          sessionID: sessionID!,
+          includeThinking: true,
+          includeToolDetails: true,
+        })
+        defaultExtension = "md"
+      }
+
+      const outputPath = await (async () => {
+        if (args.output) return args.output
+        const defaultFilename = `session-${sessionInfo.id.slice(0, 8)}.${defaultExtension}`
+        const filenameInput = await prompts.text({
+          message: "Export filename",
+          defaultValue: defaultFilename,
+          output: process.stderr,
+        })
+
+        if (prompts.isCancel(filenameInput)) {
+          throw new UI.CancelledError()
+        }
+
+        return filenameInput.trim()
+      })()
+
+      await Bun.write(outputPath, content)
+
+      prompts.outro(`Session exported to ${outputPath}`, {
+        output: process.stderr,
+      })
+    })
+  },
+})

packages/opencode/src/cli/cmd/tui/routes/session/index.tsx

@@ -66,6 +66,7 @@ import stripAnsi from "strip-ansi"
 import { Footer } from "./footer.tsx"
 import { usePromptRef } from "../../context/prompt"
 import { Filesystem } from "@/util/filesystem"
+import { Session as SessionNamespace } from "@/session"
 import { DialogExportOptions } from "../../ui/dialog-export-options"
 
 addDefaultParsers(parsers.parsers)
@@ -821,10 +822,7 @@ export function Session() {
       category: "Session",
       onSelect: async (dialog) => {
         try {
-          // Format session transcript as markdown
           const sessionData = session()
-          const sessionMessages = messages()
-
           const defaultFilename = `session-${sessionData.id.slice(0, 8)}.md`
 
           const options = await DialogExportOptions.show(dialog, defaultFilename, showThinking(), showDetails())
@@ -833,53 +831,20 @@ export function Session() {
 
           const { filename: customFilename, thinking: includeThinking, toolDetails: includeToolDetails } = options
 
-          let transcript = `# ${sessionData.title}\n\n`
-          transcript += `**Session ID:** ${sessionData.id}\n`
-          transcript += `**Created:** ${new Date(sessionData.time.created).toLocaleString()}\n`
-          transcript += `**Updated:** ${new Date(sessionData.time.updated).toLocaleString()}\n\n`
-          transcript += `---\n\n`
-
-          for (const msg of sessionMessages) {
-            const parts = sync.data.part[msg.id] ?? []
-            const role = msg.role === "user" ? "User" : "Assistant"
-            transcript += `## ${role}\n\n`
-
-            for (const part of parts) {
-              if (part.type === "text" && !part.synthetic) {
-                transcript += `${part.text}\n\n`
-              } else if (part.type === "reasoning") {
-                if (includeThinking) {
-                  transcript += `_Thinking:_\n\n${part.text}\n\n`
-                }
-              } else if (part.type === "tool") {
-                transcript += `\`\`\`\nTool: ${part.tool}\n`
-                if (includeToolDetails && part.state.input) {
-                  transcript += `\n**Input:**\n\`\`\`json\n${JSON.stringify(part.state.input, null, 2)}\n\`\`\``
-                }
-                if (includeToolDetails && part.state.status === "completed" && part.state.output) {
-                  transcript += `\n**Output:**\n\`\`\`\n${part.state.output}\n\`\`\``
-                }
-                if (includeToolDetails && part.state.status === "error" && part.state.error) {
-                  transcript += `\n**Error:**\n\`\`\`\n${part.state.error}\n\`\`\``
-                }
-                transcript += `\n\`\`\`\n\n`
-              }
-            }
-
-            transcript += `---\n\n`
-          }
+          const transcript = await SessionNamespace.exportMarkdown({
+            sessionID: route.sessionID,
+            includeThinking,
+            includeToolDetails,
+          })
 
-          // Save to file in current working directory
           const exportDir = process.cwd()
           const filename = customFilename.trim()
           const filepath = path.join(exportDir, filename)
 
           await Bun.write(filepath, transcript)
 
-          // Open with EDITOR if available
           const result = await Editor.open({ value: transcript, renderer })
           if (result !== undefined) {
-            // User edited the file, save the changes
             await Bun.write(filepath, result)
           }
 

packages/opencode/src/session/index.ts

@@ -275,6 +275,55 @@ export namespace Session {
     },
   )
 
+  export const exportMarkdown = fn(
+    z.object({
+      sessionID: Identifier.schema("session"),
+      includeThinking: z.boolean().optional().default(true),
+      includeToolDetails: z.boolean().optional().default(true),
+    }),
+    async (input) => {
+      const sessionInfo = await get(input.sessionID)
+      const sessionMessages = await messages({ sessionID: input.sessionID })
+
+      let transcript = `# ${sessionInfo.title}\n\n`
+      transcript += `**Session ID:** ${sessionInfo.id}\n`
+      transcript += `**Created:** ${new Date(sessionInfo.time.created).toLocaleString()}\n`
+      transcript += `**Updated:** ${new Date(sessionInfo.time.updated).toLocaleString()}\n\n`
+      transcript += `---\n\n`
+
+      for (const msg of sessionMessages) {
+        const role = msg.info.role === "user" ? "User" : "Assistant"
+        transcript += `## ${role}\n\n`
+
+        for (const part of msg.parts) {
+          if (part.type === "text" && !part.synthetic) {
+            transcript += `${part.text}\n\n`
+          } else if (part.type === "reasoning") {
+            if (input.includeThinking) {
+              transcript += `_Thinking:_\n\n${part.text}\n\n`
+            }
+          } else if (part.type === "tool") {
+            transcript += `\`\`\`\nTool: ${part.tool}\n`
+            if (input.includeToolDetails && part.state.input) {
+              transcript += `\n**Input:**\n\`\`\`json\n${JSON.stringify(part.state.input, null, 2)}\n\`\`\``
+            }
+            if (input.includeToolDetails && part.state.status === "completed" && part.state.output) {
+              transcript += `\n**Output:**\n\`\`\`\n${part.state.output}\n\`\`\``
+            }
+            if (input.includeToolDetails && part.state.status === "error" && part.state.error) {
+              transcript += `\n**Error:**\n\`\`\`\n${part.state.error}\n\`\`\``
+            }
+            transcript += `\n\`\`\`\n\n`
+          }
+        }
+
+        transcript += `---\n\n`
+      }
+
+      return transcript
+    },
+  )
+
   export async function* list() {
     const project = Instance.project
     for (const item of await Storage.list(["session", project.id])) {