codeblog-app 0.1.0

package/src/scanner/platform.ts

@@ -0,0 +1,44 @@
+import * as fs from "fs"
+import * as os from "os"
+import * as path from "path"
+
+export type Platform = "macos" | "windows" | "linux"
+
+export function getPlatform(): Platform {
+  switch (os.platform()) {
+    case "win32":
+      return "windows"
+    case "darwin":
+      return "macos"
+    default:
+      return "linux"
+  }
+}
+
+export function getHome(): string {
+  return os.homedir()
+}
+
+export function getAppDataDir(): string {
+  const platform = getPlatform()
+  if (platform === "windows") return process.env.APPDATA || path.join(getHome(), "AppData", "Roaming")
+  if (platform === "macos") return path.join(getHome(), "Library", "Application Support")
+  return process.env.XDG_CONFIG_HOME || path.join(getHome(), ".config")
+}
+
+export function getLocalAppDataDir(): string {
+  const platform = getPlatform()
+  if (platform === "windows") return process.env.LOCALAPPDATA || path.join(getHome(), "AppData", "Local")
+  if (platform === "macos") return path.join(getHome(), "Library", "Application Support")
+  return process.env.XDG_DATA_HOME || path.join(getHome(), ".local", "share")
+}
+
+export function resolvePaths(candidates: string[]): string[] {
+  return candidates.filter((p) => {
+    try {
+      return fs.existsSync(p)
+    } catch {
+      return false
+    }
+  })
+}

package/src/scanner/registry.ts

@@ -0,0 +1,68 @@
+import type { Scanner, Session, ParsedSession } from "./types"
+
+const scanners: Scanner[] = []
+
+export function registerScanner(scanner: Scanner): void {
+  scanners.push(scanner)
+}
+
+export function getScanners(): Scanner[] {
+  return [...scanners]
+}
+
+export function getScannerBySource(source: string): Scanner | undefined {
+  return scanners.find((s) => s.sourceType === source)
+}
+
+function safeScannerCall<T>(scannerName: string, method: string, fn: () => T, fallback: T): T {
+  try {
+    return fn()
+  } catch (err) {
+    console.error(`[codeblog] Scanner "${scannerName}" ${method} failed:`, err instanceof Error ? err.message : err)
+    return fallback
+  }
+}
+
+export function scanAll(limit = 20, source?: string): Session[] {
+  const all: Session[] = []
+  const targets = source ? scanners.filter((s) => s.sourceType === source) : scanners
+
+  for (const scanner of targets) {
+    const sessions = safeScannerCall(scanner.name, "scan", () => scanner.scan(limit), [])
+    all.push(...sessions)
+  }
+
+  all.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime())
+  return all.slice(0, limit)
+}
+
+export function parseSession(filePath: string, source: string, maxTurns?: number): ParsedSession | null {
+  const scanner = getScannerBySource(source)
+  if (!scanner) return null
+  return safeScannerCall(scanner.name, "parse", () => scanner.parse(filePath, maxTurns), null)
+}
+
+export function listScannerStatus(): Array<{
+  name: string
+  source: string
+  description: string
+  available: boolean
+  dirs: string[]
+  error?: string
+}> {
+  return scanners.map((s) => {
+    try {
+      const dirs = s.getSessionDirs()
+      return { name: s.name, source: s.sourceType, description: s.description, available: dirs.length > 0, dirs }
+    } catch (err) {
+      return {
+        name: s.name,
+        source: s.sourceType,
+        description: s.description,
+        available: false,
+        dirs: [],
+        error: err instanceof Error ? err.message : String(err),
+      }
+    }
+  })
+}

package/src/scanner/types.ts

@@ -0,0 +1,62 @@
+export interface Session {
+  id: string
+  source: SourceType
+  project: string
+  projectPath?: string
+  projectDescription?: string
+  title: string
+  messageCount: number
+  humanMessages: number
+  aiMessages: number
+  preview: string
+  filePath: string
+  modifiedAt: Date
+  sizeBytes: number
+}
+
+export interface ConversationTurn {
+  role: "human" | "assistant" | "system" | "tool"
+  content: string
+  timestamp?: Date
+}
+
+export interface ParsedSession extends Session {
+  turns: ConversationTurn[]
+}
+
+export interface SessionAnalysis {
+  summary: string
+  topics: string[]
+  languages: string[]
+  keyInsights: string[]
+  codeSnippets: Array<{
+    language: string
+    code: string
+    context: string
+  }>
+  problems: string[]
+  solutions: string[]
+  suggestedTitle: string
+  suggestedTags: string[]
+}
+
+export type SourceType =
+  | "claude-code"
+  | "cursor"
+  | "windsurf"
+  | "codex"
+  | "warp"
+  | "vscode-copilot"
+  | "aider"
+  | "continue"
+  | "zed"
+  | "unknown"
+
+export interface Scanner {
+  name: string
+  sourceType: SourceType
+  description: string
+  getSessionDirs(): string[]
+  scan(limit: number): Session[]
+  parse(filePath: string, maxTurns?: number): ParsedSession | null
+}

package/src/scanner/vscode-copilot.ts

@@ -0,0 +1,125 @@
+import * as path from "path"
+import * as fs from "fs"
+import type { Scanner, Session, ParsedSession, ConversationTurn } from "./types"
+import { getHome, getPlatform } from "./platform"
+import { listFiles, listDirs, safeReadJson, safeStats } from "./fs-utils"
+
+export const vscodeCopilotScanner: Scanner = {
+  name: "VS Code Copilot Chat",
+  sourceType: "vscode-copilot",
+  description: "GitHub Copilot Chat sessions in VS Code",
+
+  getSessionDirs(): string[] {
+    const home = getHome()
+    const platform = getPlatform()
+    const candidates: string[] = []
+    const variants = ["Code", "Code - Insiders", "VSCodium"]
+    for (const variant of variants) {
+      if (platform === "macos") {
+        candidates.push(path.join(home, "Library", "Application Support", variant, "User", "workspaceStorage"))
+        candidates.push(path.join(home, "Library", "Application Support", variant, "User", "globalStorage", "github.copilot-chat"))
+      } else if (platform === "windows") {
+        const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming")
+        candidates.push(path.join(appData, variant, "User", "workspaceStorage"))
+        candidates.push(path.join(appData, variant, "User", "globalStorage", "github.copilot-chat"))
+      } else {
+        candidates.push(path.join(home, ".config", variant, "User", "workspaceStorage"))
+        candidates.push(path.join(home, ".config", variant, "User", "globalStorage", "github.copilot-chat"))
+      }
+    }
+    return candidates.filter((d) => {
+      try { return fs.existsSync(d) } catch { return false }
+    })
+  },
+
+  scan(limit: number): Session[] {
+    const sessions: Session[] = []
+    for (const baseDir of this.getSessionDirs()) {
+      if (baseDir.includes("globalStorage")) {
+        for (const filePath of listFiles(baseDir, [".json"])) {
+          const session = tryParseConversationFile(filePath)
+          if (session) sessions.push(session)
+        }
+        continue
+      }
+      for (const hashDir of listDirs(baseDir)) {
+        for (const filePath of listFiles(path.join(hashDir, "github.copilot-chat"), [".json"])) {
+          const session = tryParseConversationFile(filePath)
+          if (session) sessions.push(session)
+        }
+      }
+    }
+    sessions.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime())
+    return sessions.slice(0, limit)
+  },
+
+  parse(filePath: string, maxTurns?: number): ParsedSession | null {
+    const data = safeReadJson<Record<string, unknown>>(filePath)
+    if (!data) return null
+    const stats = safeStats(filePath)
+    const turns = extractCopilotTurns(data, maxTurns)
+    if (turns.length === 0) return null
+    const humanMsgs = turns.filter((t) => t.role === "human")
+    const aiMsgs = turns.filter((t) => t.role === "assistant")
+    return {
+      id: path.basename(filePath, ".json"), source: "vscode-copilot",
+      project: path.basename(path.dirname(filePath)),
+      title: humanMsgs[0]?.content.slice(0, 80) || "Copilot Chat session",
+      messageCount: turns.length, humanMessages: humanMsgs.length, aiMessages: aiMsgs.length,
+      preview: humanMsgs[0]?.content.slice(0, 200) || "",
+      filePath, modifiedAt: stats?.mtime || new Date(), sizeBytes: stats?.size || 0, turns,
+    }
+  },
+}
+
+function tryParseConversationFile(filePath: string): Session | null {
+  const stats = safeStats(filePath)
+  if (!stats || stats.size < 100) return null
+  const data = safeReadJson<Record<string, unknown>>(filePath)
+  if (!data) return null
+  const turns = extractCopilotTurns(data)
+  if (turns.length < 2) return null
+  const humanMsgs = turns.filter((t) => t.role === "human")
+  const preview = humanMsgs[0]?.content.slice(0, 200) || "(copilot session)"
+  return {
+    id: path.basename(filePath, ".json"), source: "vscode-copilot",
+    project: path.basename(path.dirname(filePath)),
+    title: preview.slice(0, 80), messageCount: turns.length,
+    humanMessages: humanMsgs.length, aiMessages: turns.length - humanMsgs.length,
+    preview, filePath, modifiedAt: stats.mtime, sizeBytes: stats.size,
+  }
+}
+
+function extractCopilotTurns(data: Record<string, unknown>, maxTurns?: number): ConversationTurn[] {
+  const turns: ConversationTurn[] = []
+  if (Array.isArray(data.conversations)) {
+    for (const conv of data.conversations) {
+      if (!conv || typeof conv !== "object") continue
+      const c = conv as Record<string, unknown>
+      if (!Array.isArray(c.turns)) continue
+      for (const turn of c.turns) {
+        if (maxTurns && turns.length >= maxTurns) break
+        const t = turn as Record<string, unknown>
+        if (t.request && typeof t.request === "string") turns.push({ role: "human", content: t.request })
+        if (t.response && typeof t.response === "string") turns.push({ role: "assistant", content: t.response })
+        if (t.message && typeof t.message === "string") {
+          turns.push({ role: t.role === "user" ? "human" : "assistant", content: t.message })
+        }
+      }
+    }
+    return turns
+  }
+  for (const arr of [data.messages, data.history, data.entries]) {
+    if (!Array.isArray(arr)) continue
+    for (const msg of arr) {
+      if (maxTurns && turns.length >= maxTurns) break
+      if (!msg || typeof msg !== "object") continue
+      const m = msg as Record<string, unknown>
+      const content = (m.content || m.text || m.message) as string | undefined
+      if (typeof content !== "string") continue
+      turns.push({ role: m.role === "user" ? "human" : "assistant", content })
+    }
+    if (turns.length > 0) return turns
+  }
+  return turns
+}

package/src/scanner/warp.ts

@@ -0,0 +1,19 @@
+import type { Scanner, Session, ParsedSession } from "./types"
+
+export const warpScanner: Scanner = {
+  name: "Warp Terminal",
+  sourceType: "warp",
+  description: "Warp Terminal (AI chat is cloud-only, no local history)",
+
+  getSessionDirs(): string[] {
+    return []
+  },
+
+  scan(_limit: number): Session[] {
+    return []
+  },
+
+  parse(_filePath: string, _maxTurns?: number): ParsedSession | null {
+    return null
+  },
+}

package/src/scanner/windsurf.ts

@@ -0,0 +1,147 @@
+import * as path from "path"
+import * as fs from "fs"
+import { Database as BunDatabase } from "bun:sqlite"
+import type { Scanner, Session, ParsedSession, ConversationTurn } from "./types"
+import { getHome, getPlatform } from "./platform"
+import { listDirs, safeReadJson, safeStats, extractProjectDescription } from "./fs-utils"
+
+interface VscdbChatIndex {
+  version: number
+  entries: Record<string, VscdbChatEntry>
+}
+
+interface VscdbChatEntry {
+  messages?: Array<{ role?: string; content?: string; text?: string }>
+  [key: string]: unknown
+}
+
+export const windsurfScanner: Scanner = {
+  name: "Windsurf",
+  sourceType: "windsurf",
+  description: "Windsurf (Codeium) Cascade chat sessions (SQLite)",
+
+  getSessionDirs(): string[] {
+    const home = getHome()
+    const platform = getPlatform()
+    const candidates: string[] = []
+    if (platform === "macos") {
+      candidates.push(path.join(home, "Library", "Application Support", "Windsurf", "User", "workspaceStorage"))
+    } else if (platform === "windows") {
+      const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming")
+      candidates.push(path.join(appData, "Windsurf", "User", "workspaceStorage"))
+    } else {
+      candidates.push(path.join(home, ".config", "Windsurf", "User", "workspaceStorage"))
+    }
+    return candidates.filter((d) => {
+      try { return fs.existsSync(d) } catch { return false }
+    })
+  },
+
+  scan(limit: number): Session[] {
+    const sessions: Session[] = []
+    for (const baseDir of this.getSessionDirs()) {
+      for (const wsDir of listDirs(baseDir)) {
+        const dbPath = path.join(wsDir, "state.vscdb")
+        if (!fs.existsSync(dbPath)) continue
+        const wsJson = safeReadJson<{ folder?: string }>(path.join(wsDir, "workspace.json"))
+        let projectPath: string | undefined
+        if (wsJson?.folder) {
+          try { projectPath = decodeURIComponent(new URL(wsJson.folder).pathname) } catch { /* */ }
+        }
+        const project = projectPath ? path.basename(projectPath) : path.basename(wsDir)
+        const projectDescription = projectPath ? extractProjectDescription(projectPath) || undefined : undefined
+        const chatData = readVscdbChatSessions(dbPath)
+        if (!chatData || Object.keys(chatData.entries).length === 0) continue
+        for (const [sessionId, entry] of Object.entries(chatData.entries)) {
+          const messages = extractVscdbMessages(entry)
+          if (messages.length < 2) continue
+          const humanMsgs = messages.filter((m) => m.role === "human")
+          const preview = humanMsgs[0]?.content.slice(0, 200) || "(windsurf session)"
+          const dbStats = safeStats(dbPath)
+          sessions.push({
+            id: sessionId, source: "windsurf", project, projectPath, projectDescription,
+            title: preview.slice(0, 80), messageCount: messages.length,
+            humanMessages: humanMsgs.length, aiMessages: messages.length - humanMsgs.length,
+            preview, filePath: `${dbPath}|${sessionId}`,
+            modifiedAt: dbStats?.mtime || new Date(), sizeBytes: dbStats?.size || 0,
+          })
+        }
+      }
+    }
+    sessions.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime())
+    return sessions.slice(0, limit)
+  },
+
+  parse(filePath: string, maxTurns?: number): ParsedSession | null {
+    const sepIdx = filePath.lastIndexOf("|")
+    const dbPath = sepIdx > 0 ? filePath.slice(0, sepIdx) : filePath
+    const targetSessionId = sepIdx > 0 ? filePath.slice(sepIdx + 1) : null
+    const chatData = readVscdbChatSessions(dbPath)
+    if (!chatData) return null
+    const stats = safeStats(dbPath)
+    const entries = Object.entries(chatData.entries)
+    if (entries.length === 0) return null
+    let targetEntry: VscdbChatEntry | null = null
+    let targetId = path.basename(path.dirname(dbPath))
+    if (targetSessionId && chatData.entries[targetSessionId]) {
+      targetEntry = chatData.entries[targetSessionId]
+      targetId = targetSessionId
+    } else {
+      for (const [id, entry] of entries) {
+        const msgs = extractVscdbMessages(entry)
+        if (msgs.length >= 2) { targetEntry = entry; targetId = id; break }
+      }
+    }
+    if (!targetEntry) return null
+    const allTurns = extractVscdbMessages(targetEntry)
+    const turns = maxTurns ? allTurns.slice(0, maxTurns) : allTurns
+    if (turns.length === 0) return null
+    const humanMsgs = turns.filter((t) => t.role === "human")
+    const aiMsgs = turns.filter((t) => t.role === "assistant")
+    return {
+      id: targetId, source: "windsurf", project: path.basename(path.dirname(filePath)),
+      title: humanMsgs[0]?.content.slice(0, 80) || "Windsurf session",
+      messageCount: turns.length, humanMessages: humanMsgs.length, aiMessages: aiMsgs.length,
+      preview: humanMsgs[0]?.content.slice(0, 200) || "",
+      filePath: dbPath, modifiedAt: stats?.mtime || new Date(), sizeBytes: stats?.size || 0, turns,
+    }
+  },
+}
+
+function readVscdbChatSessions(dbPath: string): VscdbChatIndex | null {
+  try {
+    const db = new BunDatabase(dbPath, { readonly: true })
+    let row: { value: string | Buffer } | undefined
+    try {
+      row = db.prepare("SELECT value FROM ItemTable WHERE key = 'chat.ChatSessionStore.index'").get() as any
+    } finally { db.close() }
+    if (!row?.value) return null
+    const valueStr = typeof row.value === "string" ? row.value : (row.value as Buffer).toString("utf-8")
+    return JSON.parse(valueStr) as VscdbChatIndex
+  } catch { return null }
+}
+
+function extractVscdbMessages(entry: VscdbChatEntry): ConversationTurn[] {
+  const turns: ConversationTurn[] = []
+  if (Array.isArray(entry.messages)) {
+    for (const msg of entry.messages) {
+      if (!msg || typeof msg !== "object") continue
+      const content = msg.content || msg.text
+      if (typeof content !== "string" || !content.trim()) continue
+      turns.push({ role: msg.role === "user" || msg.role === "human" ? "human" : "assistant", content })
+    }
+    return turns
+  }
+  for (const [, value] of Object.entries(entry)) {
+    if (!Array.isArray(value)) continue
+    for (const item of value) {
+      if (!item || typeof item !== "object") continue
+      const m = item as Record<string, unknown>
+      const content = (m.content || m.text) as string | undefined
+      if (typeof content !== "string" || !content.trim()) continue
+      turns.push({ role: m.role === "user" || m.role === "human" ? "human" : "assistant", content })
+    }
+    if (turns.length > 0) return turns
+  }
+  return turns
+}

package/src/scanner/zed.ts

@@ -0,0 +1,88 @@
+import * as path from "path"
+import * as fs from "fs"
+import type { Scanner, Session, ParsedSession, ConversationTurn } from "./types"
+import { getHome, getPlatform } from "./platform"
+import { listFiles, safeReadJson, safeStats } from "./fs-utils"
+
+export const zedScanner: Scanner = {
+  name: "Zed",
+  sourceType: "zed",
+  description: "Zed editor AI assistant conversations",
+
+  getSessionDirs(): string[] {
+    const home = getHome()
+    const platform = getPlatform()
+    const candidates: string[] = []
+    if (platform === "macos") {
+      candidates.push(path.join(home, "Library", "Application Support", "Zed", "conversations"))
+    }
+    if (platform === "windows") {
+      const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming")
+      candidates.push(path.join(appData, "Zed", "conversations"))
+    }
+    candidates.push(path.join(home, ".config", "zed", "conversations"))
+    return candidates.filter((d) => {
+      try { return fs.existsSync(d) } catch { return false }
+    })
+  },
+
+  scan(limit: number): Session[] {
+    const sessions: Session[] = []
+    for (const dir of this.getSessionDirs()) {
+      for (const filePath of listFiles(dir, [".json", ".zed"], true)) {
+        const stats = safeStats(filePath)
+        if (!stats || stats.size < 100) continue
+        const data = safeReadJson<Record<string, unknown>>(filePath)
+        if (!data) continue
+        const turns = extractZedTurns(data)
+        if (turns.length < 2) continue
+        const humanMsgs = turns.filter((t) => t.role === "human")
+        const preview = humanMsgs[0]?.content.slice(0, 200) || "(zed session)"
+        sessions.push({
+          id: path.basename(filePath).replace(/\.\w+$/, ""), source: "zed",
+          project: (data.project as string) || path.basename(path.dirname(filePath)),
+          title: (data.title as string) || preview.slice(0, 80),
+          messageCount: turns.length, humanMessages: humanMsgs.length, aiMessages: turns.length - humanMsgs.length,
+          preview, filePath, modifiedAt: stats.mtime, sizeBytes: stats.size,
+        })
+      }
+    }
+    sessions.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime())
+    return sessions.slice(0, limit)
+  },
+
+  parse(filePath: string, maxTurns?: number): ParsedSession | null {
+    const data = safeReadJson<Record<string, unknown>>(filePath)
+    if (!data) return null
+    const stats = safeStats(filePath)
+    const turns = extractZedTurns(data, maxTurns)
+    if (turns.length === 0) return null
+    const humanMsgs = turns.filter((t) => t.role === "human")
+    const aiMsgs = turns.filter((t) => t.role === "assistant")
+    return {
+      id: path.basename(filePath).replace(/\.\w+$/, ""), source: "zed",
+      project: (data.project as string) || path.basename(path.dirname(filePath)),
+      title: (data.title as string) || humanMsgs[0]?.content.slice(0, 80) || "Zed session",
+      messageCount: turns.length, humanMessages: humanMsgs.length, aiMessages: aiMsgs.length,
+      preview: humanMsgs[0]?.content.slice(0, 200) || "",
+      filePath, modifiedAt: stats?.mtime || new Date(), sizeBytes: stats?.size || 0, turns,
+    }
+  },
+}
+
+function extractZedTurns(data: Record<string, unknown>, maxTurns?: number): ConversationTurn[] {
+  const turns: ConversationTurn[] = []
+  for (const arr of [data.messages, data.conversation, data.entries]) {
+    if (!Array.isArray(arr)) continue
+    for (const msg of arr) {
+      if (maxTurns && turns.length >= maxTurns) break
+      if (!msg || typeof msg !== "object") continue
+      const m = msg as Record<string, unknown>
+      const content = (m.content || m.body || m.text) as string | undefined
+      if (typeof content !== "string") continue
+      turns.push({ role: m.role === "user" || m.role === "human" ? "human" : "assistant", content })
+    }
+    if (turns.length > 0) return turns
+  }
+  return turns
+}

package/src/server/index.ts

@@ -0,0 +1,48 @@
+import { Hono } from "hono"
+import { Log } from "../util/log"
+
+const log = Log.create({ service: "server" })
+
+export namespace Server {
+  let instance: ReturnType<typeof Bun.serve> | null = null
+
+  export function start(app: Hono, port: number): ReturnType<typeof Bun.serve> {
+    if (instance) {
+      log.warn("server already running, stopping previous instance")
+      instance.stop()
+    }
+    instance = Bun.serve({ port, fetch: app.fetch })
+    log.info("server started", { port })
+    return instance
+  }
+
+  export function stop() {
+    if (instance) {
+      instance.stop()
+      instance = null
+      log.info("server stopped")
+    }
+  }
+
+  export function running(): boolean {
+    return instance !== null
+  }
+
+  export function createCallbackServer(onCallback: (params: URLSearchParams) => Promise<string>): {
+    app: Hono
+    port: number
+  } {
+    const port = 19823
+    const app = new Hono()
+
+    app.get("/callback", async (c) => {
+      const params = new URL(c.req.url).searchParams
+      const html = await onCallback(params)
+      return c.html(html)
+    })
+
+    app.get("/health", (c) => c.json({ ok: true }))
+
+    return { app, port }
+  }
+}

package/src/storage/db.ts

@@ -0,0 +1,68 @@
+import { Database as BunDatabase } from "bun:sqlite"
+import { drizzle } from "drizzle-orm/bun-sqlite"
+import { Context } from "../util/context"
+import { lazy } from "../util/lazy"
+import { Global } from "../global"
+import { Log } from "../util/log"
+import path from "path"
+import * as schema from "./schema"
+
+const log = Log.create({ service: "db" })
+
+export namespace Database {
+  type Schema = typeof schema
+
+  export const Client = lazy(() => {
+    const dbpath = path.join(Global.Path.data, "codeblog.db")
+    log.info("opening database", { path: dbpath })
+
+    const sqlite = new BunDatabase(dbpath, { create: true })
+
+    sqlite.run("PRAGMA journal_mode = WAL")
+    sqlite.run("PRAGMA synchronous = NORMAL")
+    sqlite.run("PRAGMA busy_timeout = 5000")
+    sqlite.run("PRAGMA cache_size = -64000")
+    sqlite.run("PRAGMA foreign_keys = ON")
+
+    // Auto-create tables
+    sqlite.run(`CREATE TABLE IF NOT EXISTS published_sessions (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      source TEXT NOT NULL,
+      post_id TEXT,
+      file_path TEXT NOT NULL,
+      time_created INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+      time_updated INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+    )`)
+
+    sqlite.run(`CREATE TABLE IF NOT EXISTS cached_posts (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      author_name TEXT,
+      votes INTEGER DEFAULT 0,
+      comments_count INTEGER DEFAULT 0,
+      tags TEXT,
+      time_created INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+      time_updated INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+    )`)
+
+    sqlite.run(`CREATE TABLE IF NOT EXISTS notifications_cache (
+      id TEXT PRIMARY KEY,
+      type TEXT NOT NULL,
+      message TEXT NOT NULL,
+      read INTEGER DEFAULT 0,
+      post_id TEXT,
+      time_created INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+      time_updated INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+    )`)
+
+    return drizzle({ client: sqlite, schema })
+  })
+
+  const ctx = Context.create<{ tx: any; effects: (() => void | Promise<void>)[] }>("database")
+
+  export function use<T>(callback: (db: ReturnType<typeof Client>) => T): T {
+    return callback(Client())
+  }
+}