sync

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

@@ -0,0 +1,147 @@
+import type { Argv } from "yargs"
+import { cmd } from "./cmd"
+import { bootstrap } from "../bootstrap"
+import { UI } from "../ui"
+import { db } from "../../storage/db"
+import { ProjectTable } from "../../project/project.sql"
+import { Project } from "../../project/project"
+import {
+  SessionTable,
+  MessageTable,
+  PartTable,
+  SessionDiffTable,
+  TodoTable,
+  PermissionTable,
+} from "../../session/session.sql"
+import { Session } from "../../session"
+import { SessionShareTable, ShareTable } from "../../share/share.sql"
+import path from "path"
+import fs from "fs/promises"
+
+export const DatabaseCommand = cmd({
+  command: "database",
+  describe: "database management commands",
+  builder: (yargs) => yargs.command(ExportCommand).demandCommand(),
+  async handler() {},
+})
+
+const ExportCommand = cmd({
+  command: "export",
+  describe: "export database to JSON files",
+  builder: (yargs: Argv) => {
+    return yargs.option("output", {
+      alias: ["o"],
+      describe: "output directory",
+      type: "string",
+      demandOption: true,
+    })
+  },
+  handler: async (args) => {
+    await bootstrap(process.cwd(), async () => {
+      const outDir = path.resolve(args.output)
+      await fs.mkdir(outDir, { recursive: true })
+
+      const stats = {
+        projects: 0,
+        sessions: 0,
+        messages: 0,
+        parts: 0,
+        diffs: 0,
+        todos: 0,
+        permissions: 0,
+        sessionShares: 0,
+        shares: 0,
+      }
+
+      // Export projects
+      const projectDir = path.join(outDir, "project")
+      await fs.mkdir(projectDir, { recursive: true })
+      for (const row of db().select().from(ProjectTable).all()) {
+        const project = Project.fromRow(row)
+        await Bun.write(path.join(projectDir, `${row.id}.json`), JSON.stringify(project, null, 2))
+        stats.projects++
+      }
+
+      // Export sessions (organized by projectID)
+      const sessionDir = path.join(outDir, "session")
+      for (const row of db().select().from(SessionTable).all()) {
+        const dir = path.join(sessionDir, row.projectID)
+        await fs.mkdir(dir, { recursive: true })
+        await Bun.write(path.join(dir, `${row.id}.json`), JSON.stringify(Session.fromRow(row), null, 2))
+        stats.sessions++
+      }
+
+      // Export messages (organized by sessionID)
+      const messageDir = path.join(outDir, "message")
+      for (const row of db().select().from(MessageTable).all()) {
+        const dir = path.join(messageDir, row.sessionID)
+        await fs.mkdir(dir, { recursive: true })
+        await Bun.write(path.join(dir, `${row.id}.json`), JSON.stringify(row.data, null, 2))
+        stats.messages++
+      }
+
+      // Export parts (organized by messageID)
+      const partDir = path.join(outDir, "part")
+      for (const row of db().select().from(PartTable).all()) {
+        const dir = path.join(partDir, row.messageID)
+        await fs.mkdir(dir, { recursive: true })
+        await Bun.write(path.join(dir, `${row.id}.json`), JSON.stringify(row.data, null, 2))
+        stats.parts++
+      }
+
+      // Export session diffs
+      const diffDir = path.join(outDir, "session_diff")
+      await fs.mkdir(diffDir, { recursive: true })
+      for (const row of db().select().from(SessionDiffTable).all()) {
+        await Bun.write(path.join(diffDir, `${row.sessionID}.json`), JSON.stringify(row.data, null, 2))
+        stats.diffs++
+      }
+
+      // Export todos
+      const todoDir = path.join(outDir, "todo")
+      await fs.mkdir(todoDir, { recursive: true })
+      for (const row of db().select().from(TodoTable).all()) {
+        await Bun.write(path.join(todoDir, `${row.sessionID}.json`), JSON.stringify(row.data, null, 2))
+        stats.todos++
+      }
+
+      // Export permissions
+      const permDir = path.join(outDir, "permission")
+      await fs.mkdir(permDir, { recursive: true })
+      for (const row of db().select().from(PermissionTable).all()) {
+        await Bun.write(path.join(permDir, `${row.projectID}.json`), JSON.stringify(row.data, null, 2))
+        stats.permissions++
+      }
+
+      // Export session shares
+      const sessionShareDir = path.join(outDir, "session_share")
+      await fs.mkdir(sessionShareDir, { recursive: true })
+      for (const row of db().select().from(SessionShareTable).all()) {
+        await Bun.write(path.join(sessionShareDir, `${row.sessionID}.json`), JSON.stringify(row.data, null, 2))
+        stats.sessionShares++
+      }
+
+      // Export shares
+      const shareDir = path.join(outDir, "share")
+      await fs.mkdir(shareDir, { recursive: true })
+      for (const row of db().select().from(ShareTable).all()) {
+        await Bun.write(path.join(shareDir, `${row.sessionID}.json`), JSON.stringify(row.data, null, 2))
+        stats.shares++
+      }
+
+      // Create migration marker so this can be imported back
+      await Bun.write(path.join(outDir, "migration"), Date.now().toString())
+
+      UI.println(`Exported to ${outDir}:`)
+      UI.println(`  ${stats.projects} projects`)
+      UI.println(`  ${stats.sessions} sessions`)
+      UI.println(`  ${stats.messages} messages`)
+      UI.println(`  ${stats.parts} parts`)
+      UI.println(`  ${stats.diffs} session diffs`)
+      UI.println(`  ${stats.todos} todos`)
+      UI.println(`  ${stats.permissions} permissions`)
+      UI.println(`  ${stats.sessionShares} session shares`)
+      UI.println(`  ${stats.shares} shares`)
+    })
+  },
+})

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

@@ -2,7 +2,8 @@ import type { Argv } from "yargs"
 import { Session } from "../../session"
 import { cmd } from "./cmd"
 import { bootstrap } from "../bootstrap"
-import { Storage } from "../../storage/storage"
+import { db } from "../../storage/db"
+import { SessionTable, MessageTable, PartTable } from "../../session/session.sql"
 import { Instance } from "../../project/instance"
 import { EOL } from "os"
 
@@ -81,13 +82,31 @@ export const ImportCommand = cmd({
         return
       }
 
-      await Storage.write(["session", Instance.project.id, exportData.info.id], exportData.info)
+      db().insert(SessionTable).values(Session.toRow(exportData.info)).onConflictDoNothing().run()
 
       for (const msg of exportData.messages) {
-        await Storage.write(["message", exportData.info.id, msg.info.id], msg.info)
+        db()
+          .insert(MessageTable)
+          .values({
+            id: msg.info.id,
+            sessionID: exportData.info.id,
+            createdAt: msg.info.time?.created ?? Date.now(),
+            data: msg.info,
+          })
+          .onConflictDoNothing()
+          .run()
 
         for (const part of msg.parts) {
-          await Storage.write(["part", msg.info.id, part.id], part)
+          db()
+            .insert(PartTable)
+            .values({
+              id: part.id,
+              messageID: msg.info.id,
+              sessionID: exportData.info.id,
+              data: part,
+            })
+            .onConflictDoNothing()
+            .run()
         }
       }
 

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

@@ -2,7 +2,8 @@ import type { Argv } from "yargs"
 import { cmd } from "./cmd"
 import { Session } from "../../session"
 import { bootstrap } from "../bootstrap"
-import { Storage } from "../../storage/storage"
+import { db } from "../../storage/db"
+import { SessionTable } from "../../session/session.sql"
 import { Project } from "../../project/project"
 import { Instance } from "../../project/instance"
 
@@ -83,25 +84,8 @@ async function getCurrentProject(): Promise<Project.Info> {
 }
 
 async function getAllSessions(): Promise<Session.Info[]> {
-  const sessions: Session.Info[] = []
-
-  const projectKeys = await Storage.list(["project"])
-  const projects = await Promise.all(projectKeys.map((key) => Storage.read<Project.Info>(key)))
-
-  for (const project of projects) {
-    if (!project) continue
-
-    const sessionKeys = await Storage.list(["session", project.id])
-    const projectSessions = await Promise.all(sessionKeys.map((key) => Storage.read<Session.Info>(key)))
-
-    for (const session of projectSessions) {
-      if (session) {
-        sessions.push(session)
-      }
-    }
-  }
-
-  return sessions
+  const rows = db().select().from(SessionTable).all()
+  return rows.map((row) => Session.fromRow(row))
 }
 
 export async function aggregateSessionStats(days?: number, projectFilter?: string): Promise<SessionStats> {