Use turso db

Author: Nifury

bun.lock

@@ -1,11 +1,17 @@
+FROM node:20-slim AS libsql-native
+WORKDIR /libsql
+RUN npm install @libsql/linux-x64-gnu@0.5.22
+
 FROM debian:12-slim AS base
 
 # Disable the runtime transpiler cache by default inside Docker containers.
 # On ephemeral containers, the cache is not useful
 ARG BUN_RUNTIME_TRANSPILER_CACHE_PATH=0
 ENV BUN_RUNTIME_TRANSPILER_CACHE_PATH=${BUN_RUNTIME_TRANSPILER_CACHE_PATH}
-RUN apt-get update && apt-get install -y ripgrep libgcc-s1 && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y ripgrep libgcc-s1 ca-certificates && rm -rf /var/lib/apt/lists/*
 
 COPY dist/opencode-linux-x64/bin/opencode /usr/local/bin/opencode
+COPY --from=libsql-native /libsql/node_modules/@libsql/linux-x64-gnu /node_modules/@libsql/linux-x64-gnu
+ENV NODE_PATH=/node_modules
 RUN opencode --version
 ENTRYPOINT ["opencode"]

packages/opencode/Dockerfile

@@ -1,10 +1,11 @@
 import { defineConfig } from "drizzle-kit"
 
 export default defineConfig({
-  dialect: "sqlite",
+  dialect: "turso",
   schema: "./src/**/*.sql.ts",
   out: "./migration",
   dbCredentials: {
-    url: "/home/thdxr/.local/share/opencode/opencode.db",
+    url: process.env["OPENCODE_DB_URL"] ?? `file:${process.env["HOME"]}/.local/share/opencode/opencode.db`,
+    authToken: process.env["OPENCODE_DB_TOKEN"],
   },
 })

packages/opencode/drizzle.config.ts

@@ -56,6 +56,7 @@
     "zod-to-json-schema": "3.24.5"
   },
   "dependencies": {
+    "@libsql/client": "^0.17.0",
     "@actions/core": "1.11.1",
     "@actions/github": "6.0.1",
     "@agentclientprotocol/sdk": "0.14.1",

packages/opencode/package.json

@@ -13,10 +13,6 @@ export { AccessToken, AccountID, OrgID } from "./service"
 
 import { runtime } from "@/effect/runtime"
 
-function runSync<A>(f: (service: AccountService.Service) => Effect.Effect<A, AccountError>) {
-  return runtime.runSync(AccountService.use(f))
-}
-
 function runPromise<A>(f: (service: AccountService.Service) => Effect.Effect<A, AccountError>) {
   return runtime.runPromise(AccountService.use(f))
 }
@@ -25,8 +21,8 @@ export namespace Account {
   export const Account = AccountSchema
   export type Account = AccountSchema
 
-  export function active(): Account | undefined {
-    return Option.getOrUndefined(runSync((service) => service.active()))
+  export async function active(): Promise<Account | undefined> {
+    return Option.getOrUndefined(await runPromise((service) => service.active()))
   }
 
   export async function config(accountID: AccountID, orgID: OrgID): Promise<Record<string, unknown> | undefined> {

packages/opencode/src/account/index.ts

@@ -42,27 +42,27 @@ export class AccountRepo extends ServiceMap.Service<AccountRepo, AccountRepo.Ser
     Effect.gen(function* () {
       const decode = Schema.decodeUnknownSync(Account)
 
-      const query = <A>(f: (db: DbClient) => A) =>
-        Effect.try({
+      const query = <A>(f: (db: DbClient) => Promise<A>) =>
+        Effect.tryPromise({
           try: () => Database.use(f),
           catch: (cause) => new AccountRepoError({ message: "Database operation failed", cause }),
         })
 
-      const tx = <A>(f: (db: DbClient) => A) =>
-        Effect.try({
+      const tx = <A>(f: (db: DbClient) => Promise<A>) =>
+        Effect.tryPromise({
           try: () => Database.transaction(f),
           catch: (cause) => new AccountRepoError({ message: "Database operation failed", cause }),
         })
 
-      const current = (db: DbClient) => {
-        const state = db.select().from(AccountStateTable).where(eq(AccountStateTable.id, ACCOUNT_STATE_ID)).get()
+      const current = async (db: DbClient) => {
+        const state = await db.select().from(AccountStateTable).where(eq(AccountStateTable.id, ACCOUNT_STATE_ID)).get()
         if (!state?.active_account_id) return
-        const account = db.select().from(AccountTable).where(eq(AccountTable.id, state.active_account_id)).get()
+        const account = await db.select().from(AccountTable).where(eq(AccountTable.id, state.active_account_id)).get()
         if (!account) return
         return { ...account, active_org_id: state.active_org_id ?? null }
       }
 
-      const state = (db: DbClient, accountID: AccountID, orgID: Option.Option<OrgID>) => {
+      const state = async (db: DbClient, accountID: AccountID, orgID: Option.Option<OrgID>) => {
         const id = Option.getOrNull(orgID)
         return db
           .insert(AccountStateTable)
@@ -75,41 +75,39 @@ export class AccountRepo extends ServiceMap.Service<AccountRepo, AccountRepo.Ser
       }
 
       const active = Effect.fn("AccountRepo.active")(() =>
-        query((db) => current(db)).pipe(Effect.map((row) => (row ? Option.some(decode(row)) : Option.none()))),
+        query(async (db) => current(db)).pipe(Effect.map((row) => (row ? Option.some(decode(row)) : Option.none()))),
       )
 
       const list = Effect.fn("AccountRepo.list")(() =>
-        query((db) =>
-          db
-            .select()
-            .from(AccountTable)
-            .all()
-            .map((row: AccountRow) => decode({ ...row, active_org_id: null })),
-        ),
+        query(async (db) => {
+          const rows = await db.select().from(AccountTable).all()
+          return rows.map((row: AccountRow) => decode({ ...row, active_org_id: null }))
+        }),
       )
 
       const remove = Effect.fn("AccountRepo.remove")((accountID: AccountID) =>
-        tx((db) => {
-          db.update(AccountStateTable)
+        tx(async (db) => {
+          await db
+            .update(AccountStateTable)
             .set({ active_account_id: null, active_org_id: null })
             .where(eq(AccountStateTable.active_account_id, accountID))
             .run()
-          db.delete(AccountTable).where(eq(AccountTable.id, accountID)).run()
+          await db.delete(AccountTable).where(eq(AccountTable.id, accountID)).run()
         }).pipe(Effect.asVoid),
       )
 
       const use = Effect.fn("AccountRepo.use")((accountID: AccountID, orgID: Option.Option<OrgID>) =>
-        query((db) => state(db, accountID, orgID)).pipe(Effect.asVoid),
+        query(async (db) => state(db, accountID, orgID)).pipe(Effect.asVoid),
       )
 
       const getRow = Effect.fn("AccountRepo.getRow")((accountID: AccountID) =>
-        query((db) => db.select().from(AccountTable).where(eq(AccountTable.id, accountID)).get()).pipe(
+        query(async (db) => db.select().from(AccountTable).where(eq(AccountTable.id, accountID)).get()).pipe(
           Effect.map(Option.fromNullishOr),
         ),
       )
 
       const persistToken = Effect.fn("AccountRepo.persistToken")((input) =>
-        query((db) =>
+        query(async (db) =>
           db
             .update(AccountTable)
             .set({
@@ -123,8 +121,9 @@ export class AccountRepo extends ServiceMap.Service<AccountRepo, AccountRepo.Ser
       )
 
       const persistAccount = Effect.fn("AccountRepo.persistAccount")((input) =>
-        tx((db) => {
-          db.insert(AccountTable)
+        tx(async (db) => {
+          await db
+            .insert(AccountTable)
             .values({
               id: input.id,
               email: input.email,
@@ -142,7 +141,7 @@ export class AccountRepo extends ServiceMap.Service<AccountRepo, AccountRepo.Ser
               },
             })
             .run()
-          void state(db, input.id, input.orgID)
+          await state(db, input.id, input.orgID)
         }).pipe(Effect.asVoid),
       )
 

packages/opencode/src/account/repo.ts

@@ -108,11 +108,20 @@ const MigrateCommand = cmd({
   },
 })
 
+const SyncCommand = cmd({
+  command: "sync",
+  describe: "sync local database replica with remote Turso database",
+  handler: async () => {
+    await Database.sync()
+    process.stdout.write("Database sync complete." + EOL)
+  },
+})
+
 export const DbCommand = cmd({
   command: "db",
   describe: "database tools",
   builder: (yargs: Argv) => {
-    return yargs.command(QueryCommand).command(PathCommand).command(MigrateCommand).demandCommand()
+    return yargs.command(QueryCommand).command(PathCommand).command(MigrateCommand).command(SyncCommand).demandCommand()
   },
   handler: () => {},
 })

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

@@ -158,7 +158,7 @@ export const ImportCommand = cmd({
         projectID: Instance.project.id,
       })
       const row = Session.toRow(info)
-      Database.use((db) =>
+      await Database.use(async (db) =>
         db
           .insert(SessionTable)
           .values(row)
@@ -169,7 +169,7 @@ export const ImportCommand = cmd({
       for (const msg of exportData.messages) {
         const msgInfo = MessageV2.Info.parse(msg.info)
         const { id, sessionID: _, ...msgData } = msgInfo
-        Database.use((db) =>
+        await Database.use(async (db) =>
           db
             .insert(MessageTable)
             .values({
@@ -185,7 +185,7 @@ export const ImportCommand = cmd({
         for (const part of msg.parts) {
           const partInfo = MessageV2.Part.parse(part)
           const { id: partId, sessionID: _s, messageID, ...partData } = partInfo
-          Database.use((db) =>
+          await Database.use(async (db) =>
             db
               .insert(PartTable)
               .values({

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

@@ -90,7 +90,7 @@ export const SessionListCommand = cmd({
   },
   handler: async (args) => {
     await bootstrap(process.cwd(), async () => {
-      const sessions = [...Session.list({ roots: true, limit: args.maxCount })]
+      const sessions = await Array.fromAsync(Session.list({ roots: true, limit: args.maxCount }))
 
       if (sessions.length === 0) {
         return