xedoc-cli 0.1.0

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "xedoc-cli",
+  "version": "0.1.0",
+  "description": "Local web UI for Codex account, chat, execution, and workspace management.",
+  "author": "Edward Nguyen <monokaijs@gmail.com>",
+  "type": "module",
+  "packageManager": "pnpm@10.33.0",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/monokaijs/xedoc.git"
+  },
+  "bin": {
+    "xedoc": "bin/xedoc.mjs"
+  },
+  "files": [
+    "bin/xedoc.mjs",
+    "build/client/",
+    "build/server/index.js",
+    "prisma/schema.prisma",
+    "server/index.mjs",
+    "server/sqlite-setup.mjs",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "react-router dev --host 0.0.0.0",
+    "build": "react-router build --mode production --minify terser",
+    "start": "node ./server/index.mjs",
+    "typecheck": "tsc --noEmit",
+    "clean:build": "node -e \"import('node:fs/promises').then(({ rm }) => rm('build', { recursive: true, force: true }))\"",
+    "prepublishOnly": "pnpm typecheck",
+    "prepack": "pnpm clean:build && pnpm build",
+    "publish": "npm publish --access public",
+    "publish:dry-run": "npm publish --access public --dry-run",
+    "prisma:generate": "prisma generate --schema prisma/schema.prisma",
+    "db:setup": "node -e \"import('./server/sqlite-setup.mjs').then((m)=>m.setupSqliteDatabase())\""
+  },
+  "dependencies": {
+    "@base-ui/react": "^1.4.1",
+    "@fontsource-variable/geist": "^5.2.9",
+    "@openai/codex": "^0.130.0",
+    "@prisma/client": "^6.19.3",
+    "@react-router/node": "^7.15.1",
+    "@tanstack/react-query": "^5.100.10",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "cmdk": "^1.1.1",
+    "dotenv": "16.6.1",
+    "highlight.js": "^11.11.1",
+    "isbot": "^5.1.32",
+    "lucide-react": "^1.16.0",
+    "next-themes": "^0.4.6",
+    "prisma": "^6.19.3",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
+    "react-markdown": "^10.1.0",
+    "react-router": "^7.15.1",
+    "remark-gfm": "^4.0.1",
+    "socket.io": "^4.8.3",
+    "socket.io-client": "^4.8.3",
+    "sonner": "^2.0.7",
+    "tailwind-merge": "^3.6.0",
+    "tw-animate-css": "^1.4.0"
+  },
+  "devDependencies": {
+    "@react-router/dev": "^7.15.1",
+    "@tailwindcss/vite": "^4.3.0",
+    "@types/node": "^24.12.4",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "shadcn": "^4.7.0",
+    "tailwindcss": "^4.3.0",
+    "terser": "^5.47.1",
+    "typescript": "5.9.3",
+    "vite": "^8.0.12"
+  },
+  "pnpm": {
+    "overrides": {
+      "lightningcss": "1.30.1"
+    }
+  }
+}

package/prisma/schema.prisma

@@ -0,0 +1,171 @@
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "sqlite"
+  url      = env("DATABASE_URL")
+}
+
+enum AccountStatus {
+  DISCONNECTED
+  AUTHENTICATING
+  CONNECTED
+  ERROR
+}
+
+enum ChatStatus {
+  IDLE
+  RUNNING
+  ARCHIVED
+}
+
+enum MessageRole {
+  USER
+  ASSISTANT
+  SYSTEM
+  TOOL
+}
+
+enum MessageStatus {
+  PENDING
+  STREAMING
+  COMPLETED
+  FAILED
+}
+
+enum MessageKind {
+  CHAT
+  THINKING
+  TOOL_ACTIVITY
+  COMMAND_EXECUTION
+  FILE_CHANGE
+  PLAN
+  APPROVAL
+  USER_INPUT_PROMPT
+  ERROR
+}
+
+enum RunStatus {
+  QUEUED
+  RUNNING
+  COMPLETED
+  FAILED
+  CANCELLED
+}
+
+model User {
+  id         String         @id @default(uuid())
+  externalId String?        @unique
+  name       String?
+  createdAt  DateTime       @default(now())
+  updatedAt  DateTime       @updatedAt
+  accounts   CodexAccount[]
+  chats      Chat[]
+}
+
+model ServerAuth {
+  id           String   @id @default("server")
+  passwordHash String
+  tokenSecret  String
+  createdAt    DateTime @default(now())
+  updatedAt    DateTime @updatedAt
+}
+
+model CodexAccount {
+  id          String        @id @default(uuid())
+  userId      String
+  displayName String
+  status      AccountStatus @default(DISCONNECTED)
+  command     String        @default("codex")
+  args        Json          @default("[\"app-server\"]")
+  environment Json?
+  defaultModel String?
+  defaultPermissionMode String?
+  defaultReasoningEffort String?
+  defaultServiceTier String?
+  lastAuthUrl String?
+  lastError   String?
+  createdAt   DateTime      @default(now())
+  updatedAt   DateTime      @updatedAt
+  user        User          @relation(fields: [userId], references: [id], onDelete: Cascade)
+  chats       Chat[]
+  runs        ChatRun[]
+
+  @@index([userId])
+}
+
+model Chat {
+  id                String        @id @default(uuid())
+  userId            String
+  accountId         String?
+  title             String
+  workingDirectory  String?
+  model             String?
+  reasoningEffort   String?
+  serviceTier       String?
+  collaborationMode String        @default("default")
+  permissionMode    String        @default("default")
+  status            ChatStatus    @default(IDLE)
+  externalThreadId  String?
+  lastActivityAt    DateTime      @default(now())
+  createdAt         DateTime      @default(now())
+  updatedAt         DateTime      @updatedAt
+  user              User          @relation(fields: [userId], references: [id], onDelete: Cascade)
+  account           CodexAccount? @relation(fields: [accountId], references: [id], onDelete: SetNull)
+  messages          ChatMessage[]
+  runs              ChatRun[]
+
+  @@index([userId, updatedAt])
+  @@index([userId, lastActivityAt])
+  @@index([accountId])
+}
+
+model ChatMessage {
+  id          String        @id @default(uuid())
+  chatId      String
+  runId       String?
+  sequence    Int
+  role        MessageRole
+  kind        MessageKind   @default(CHAT)
+  status      MessageStatus @default(COMPLETED)
+  turnId      String?
+  itemId      String?
+  requestId   String?
+  content     String
+  metadata    Json?
+  rawPayload  Json?
+  createdAt   DateTime      @default(now())
+  completedAt DateTime?
+  chat        Chat          @relation(fields: [chatId], references: [id], onDelete: Cascade)
+  run         ChatRun?      @relation(fields: [runId], references: [id], onDelete: SetNull)
+
+  @@unique([chatId, sequence])
+  @@index([chatId, sequence])
+  @@index([chatId, turnId])
+  @@index([chatId, itemId])
+  @@index([requestId])
+  @@index([runId])
+}
+
+model ChatRun {
+  id        String        @id @default(uuid())
+  chatId    String
+  accountId String
+  status    RunStatus     @default(QUEUED)
+  request   Json
+  error     String?
+  externalTurnId String?
+  interruptRequestedAt DateTime?
+  startedAt DateTime?
+  endedAt   DateTime?
+  createdAt DateTime      @default(now())
+  updatedAt DateTime      @updatedAt
+  chat      Chat          @relation(fields: [chatId], references: [id], onDelete: Cascade)
+  account   CodexAccount  @relation(fields: [accountId], references: [id], onDelete: Restrict)
+  messages  ChatMessage[]
+
+  @@index([chatId, createdAt])
+  @@index([accountId])
+  @@index([externalTurnId])
+}

package/server/index.mjs

@@ -0,0 +1,261 @@
+import "dotenv/config"
+import { createHmac, createHash, timingSafeEqual } from "node:crypto"
+import { createReadStream, statSync } from "node:fs"
+import { createServer } from "node:http"
+import { dirname, extname, join, normalize, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+import { PrismaClient } from "@prisma/client"
+import { createRequestListener } from "@react-router/node"
+import { Server as SocketServer } from "socket.io"
+
+process.env.NODE_ENV = process.env.NODE_ENV ?? "production"
+
+const DEFAULT_PORT = "6354"
+const SERVER_AUTH_ID = "server"
+const serverRoot = dirname(fileURLToPath(import.meta.url))
+const packageRoot = resolve(serverRoot, "..")
+const prisma = new PrismaClient()
+const options = parseArgs(process.argv.slice(2))
+const build = await import(join(packageRoot, "build/server/index.js"))
+const clientRoot = join(packageRoot, "build/client")
+const requestListener = createRequestListener({
+  build,
+  mode: process.env.NODE_ENV,
+})
+
+const server = createServer((request, response) => {
+  if (serveStaticAsset(request, response)) {
+    return
+  }
+  requestListener(request, response)
+})
+
+installSocketServer(server)
+
+const port = Number.parseInt(options.port ?? process.env.PORT ?? DEFAULT_PORT, 10)
+const host = options.host ?? process.env.HOST ?? "0.0.0.0"
+
+server.listen(port, host, () => {
+  console.log(`xedoc listening on http://${host}:${port}`)
+})
+
+function parseArgs(argv) {
+  const parsed = {}
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index]
+    if (arg.startsWith("--")) {
+      const [name, inlineValue] = arg.split("=", 2)
+      const value = inlineValue ?? argv[++index]
+      if (!value || value.startsWith("--")) {
+        fail(`${name} requires a value.`)
+      }
+      assignOption(parsed, name, value)
+    } else {
+      fail(`Unknown argument: ${arg}`)
+    }
+  }
+  return parsed
+}
+
+function assignOption(parsed, name, value) {
+  switch (name) {
+    case "--host":
+      parsed.host = value
+      return
+    case "--port":
+      parsed.port = value
+      return
+    default:
+      fail(`Unknown option: ${name}`)
+  }
+}
+
+function fail(message) {
+  console.error(message)
+  process.exit(1)
+}
+
+function installSocketServer(httpServer) {
+  const io = new SocketServer(httpServer, {
+    path: "/socket.io",
+    serveClient: false,
+  })
+
+  io.use((socket, next) => {
+    const token = readSocketToken(socket.handshake.auth)
+    if (!token) {
+      next(new Error("Missing auth token."))
+      return
+    }
+    void verifyToken(token)
+      .then(() => next())
+      .catch((error) => {
+        next(error instanceof Error ? error : new Error("Invalid auth token."))
+      })
+  })
+
+  io.on("connection", (socket) => {
+    socket.on("chat:join", (chatId, ack) => {
+      if (!isValidChatId(chatId)) {
+        ack?.({ ok: false, message: "Invalid chat id." })
+        return
+      }
+      socket.join(chatRoomName(chatId))
+      ack?.({ ok: true })
+      socket.emit("chat:connected", { chatId })
+    })
+
+    socket.on("chat:leave", (chatId, ack) => {
+      if (!isValidChatId(chatId)) {
+        ack?.({ ok: false, message: "Invalid chat id." })
+        return
+      }
+      socket.leave(chatRoomName(chatId))
+      ack?.({ ok: true })
+    })
+  })
+
+  const state = getRealtimeState()
+  const handler = (event) => {
+    io.to(chatRoomName(event.chatId)).emit("chat:event", event)
+  }
+  state.handlers.add(handler)
+  httpServer.once("close", () => {
+    state.handlers.delete(handler)
+    io.close()
+  })
+}
+
+function serveStaticAsset(request, response) {
+  if (request.method !== "GET" && request.method !== "HEAD") {
+    return false
+  }
+
+  const host = request.headers.host ?? "localhost"
+  const url = new URL(request.url ?? "/", `http://${host}`)
+  const pathname = decodeURIComponent(url.pathname)
+  if (pathname === "/" || pathname.includes("\0")) {
+    return false
+  }
+
+  const candidate = resolve(clientRoot, `.${normalize(pathname)}`)
+  if (!candidate.startsWith(`${clientRoot}/`) && candidate !== clientRoot) {
+    return false
+  }
+
+  let stats
+  try {
+    stats = statSync(candidate)
+  } catch {
+    return false
+  }
+  if (!stats.isFile()) {
+    return false
+  }
+
+  response.statusCode = 200
+  response.setHeader("Content-Type", contentType(candidate))
+  response.setHeader(
+    "Cache-Control",
+    pathname.startsWith("/assets/")
+      ? "public, max-age=31536000, immutable"
+      : "no-cache",
+  )
+  if (request.method === "HEAD") {
+    response.end()
+    return true
+  }
+  createReadStream(candidate).pipe(response)
+  return true
+}
+
+function readSocketToken(auth) {
+  if (!auth || typeof auth !== "object") {
+    return undefined
+  }
+  const token = auth.token
+  return typeof token === "string" && token.trim() ? token.trim() : undefined
+}
+
+async function verifyToken(token) {
+  const auth = await requireServerAuth()
+  const [encodedPayload, signature, extra] = token.split(".")
+  if (!encodedPayload || !signature || extra !== undefined) {
+    throw new Error("Invalid auth token.")
+  }
+  if (!constantTimeEqual(signature, sign(encodedPayload, auth.tokenSecret))) {
+    throw new Error("Invalid auth token.")
+  }
+
+  const payload = JSON.parse(
+    Buffer.from(encodedPayload, "base64url").toString("utf8"),
+  )
+  if (payload?.authHash !== hash(auth.passwordHash)) {
+    throw new Error("Auth token has been revoked.")
+  }
+}
+
+function sign(value, tokenSecret) {
+  return createHmac("sha256", tokenSecret).update(value).digest("base64url")
+}
+
+function hash(value) {
+  return createHash("sha256").update(value).digest("hex")
+}
+
+async function requireServerAuth() {
+  const auth = await prisma.serverAuth.findUnique({
+    where: { id: SERVER_AUTH_ID },
+  })
+  if (!auth) {
+    throw new Error("Server password has not been configured.")
+  }
+  return auth
+}
+
+function constantTimeEqual(left, right) {
+  const leftBuffer = Buffer.from(left)
+  const rightBuffer = Buffer.from(right)
+  return (
+    leftBuffer.length === rightBuffer.length &&
+    timingSafeEqual(leftBuffer, rightBuffer)
+  )
+}
+
+function getRealtimeState() {
+  globalThis.__xedocRealtimeState__ ??= { handlers: new Set() }
+  return globalThis.__xedocRealtimeState__
+}
+
+function chatRoomName(chatId) {
+  return `chat:${chatId}`
+}
+
+function isValidChatId(value) {
+  return typeof value === "string" && value.trim().length > 0 && value.length <= 128
+}
+
+function contentType(pathname) {
+  switch (extname(pathname)) {
+    case ".css":
+      return "text/css; charset=utf-8"
+    case ".html":
+      return "text/html; charset=utf-8"
+    case ".js":
+      return "text/javascript; charset=utf-8"
+    case ".json":
+      return "application/json; charset=utf-8"
+    case ".map":
+      return "application/json; charset=utf-8"
+    case ".png":
+      return "image/png"
+    case ".svg":
+      return "image/svg+xml"
+    case ".webp":
+      return "image/webp"
+    case ".woff2":
+      return "font/woff2"
+    default:
+      return "application/octet-stream"
+  }
+}

package/server/sqlite-setup.mjs

@@ -0,0 +1,155 @@
+import "dotenv/config"
+import { mkdir } from "node:fs/promises"
+import { dirname, isAbsolute, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const schemaDirectory = dirname(
+  fileURLToPath(new URL("../prisma/schema.prisma", import.meta.url)),
+)
+
+export async function setupSqliteDatabase() {
+  await ensureSqliteDirectory()
+  const { PrismaClient } = await import("@prisma/client")
+  const prisma = new PrismaClient()
+  try {
+    await prisma.$executeRawUnsafe("PRAGMA foreign_keys = ON")
+    for (const statement of schemaStatements) {
+      try {
+        await prisma.$executeRawUnsafe(statement)
+      } catch (error) {
+        if (!isDuplicateColumnError(error)) {
+          throw error
+        }
+      }
+    }
+  } finally {
+    await prisma.$disconnect()
+  }
+}
+
+function isDuplicateColumnError(error) {
+  const message = error instanceof Error ? error.message : String(error)
+  return message.toLowerCase().includes("duplicate column name")
+}
+
+async function ensureSqliteDirectory() {
+  const databaseUrl = process.env.DATABASE_URL
+  if (!databaseUrl?.startsWith("file:")) {
+    return
+  }
+  const filePath = databaseUrl.slice("file:".length)
+  if (!filePath || filePath === ":memory:" || filePath.includes("?")) {
+    return
+  }
+  const resolvedPath = isAbsolute(filePath)
+    ? filePath
+    : resolve(schemaDirectory, filePath)
+  await mkdir(dirname(resolvedPath), { recursive: true })
+}
+
+const schemaStatements = [
+  `CREATE TABLE IF NOT EXISTS "User" (
+        "id" TEXT NOT NULL PRIMARY KEY,
+        "externalId" TEXT,
+        "name" TEXT,
+        "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        "updatedAt" DATETIME NOT NULL
+      )`,
+  `CREATE TABLE IF NOT EXISTS "ServerAuth" (
+        "id" TEXT NOT NULL PRIMARY KEY DEFAULT 'server',
+        "passwordHash" TEXT NOT NULL,
+        "tokenSecret" TEXT NOT NULL,
+        "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        "updatedAt" DATETIME NOT NULL
+      )`,
+  `CREATE TABLE IF NOT EXISTS "CodexAccount" (
+        "id" TEXT NOT NULL PRIMARY KEY,
+        "userId" TEXT NOT NULL,
+        "displayName" TEXT NOT NULL,
+        "status" TEXT NOT NULL DEFAULT 'DISCONNECTED',
+        "command" TEXT NOT NULL DEFAULT 'codex',
+        "args" JSONB NOT NULL DEFAULT '["app-server"]',
+        "environment" JSONB,
+        "defaultModel" TEXT,
+        "defaultPermissionMode" TEXT,
+        "defaultReasoningEffort" TEXT,
+        "defaultServiceTier" TEXT,
+        "lastAuthUrl" TEXT,
+        "lastError" TEXT,
+        "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        "updatedAt" DATETIME NOT NULL,
+        CONSTRAINT "CodexAccount_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User" ("id") ON DELETE CASCADE ON UPDATE CASCADE
+      )`,
+  `CREATE TABLE IF NOT EXISTS "Chat" (
+        "id" TEXT NOT NULL PRIMARY KEY,
+        "userId" TEXT NOT NULL,
+        "accountId" TEXT,
+        "title" TEXT NOT NULL,
+        "workingDirectory" TEXT,
+        "model" TEXT,
+        "reasoningEffort" TEXT,
+        "serviceTier" TEXT,
+        "collaborationMode" TEXT NOT NULL DEFAULT 'default',
+        "permissionMode" TEXT NOT NULL DEFAULT 'default',
+        "status" TEXT NOT NULL DEFAULT 'IDLE',
+        "externalThreadId" TEXT,
+        "lastActivityAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        "updatedAt" DATETIME NOT NULL,
+        CONSTRAINT "Chat_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+        CONSTRAINT "Chat_accountId_fkey" FOREIGN KEY ("accountId") REFERENCES "CodexAccount" ("id") ON DELETE SET NULL ON UPDATE CASCADE
+      )`,
+  `CREATE TABLE IF NOT EXISTS "ChatMessage" (
+        "id" TEXT NOT NULL PRIMARY KEY,
+        "chatId" TEXT NOT NULL,
+        "runId" TEXT,
+        "sequence" INTEGER NOT NULL,
+        "role" TEXT NOT NULL,
+        "kind" TEXT NOT NULL DEFAULT 'CHAT',
+        "status" TEXT NOT NULL DEFAULT 'COMPLETED',
+        "turnId" TEXT,
+        "itemId" TEXT,
+        "requestId" TEXT,
+        "content" TEXT NOT NULL,
+        "metadata" JSONB,
+        "rawPayload" JSONB,
+        "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        "completedAt" DATETIME,
+        CONSTRAINT "ChatMessage_chatId_fkey" FOREIGN KEY ("chatId") REFERENCES "Chat" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+        CONSTRAINT "ChatMessage_runId_fkey" FOREIGN KEY ("runId") REFERENCES "ChatRun" ("id") ON DELETE SET NULL ON UPDATE CASCADE
+      )`,
+  `CREATE TABLE IF NOT EXISTS "ChatRun" (
+        "id" TEXT NOT NULL PRIMARY KEY,
+        "chatId" TEXT NOT NULL,
+        "accountId" TEXT NOT NULL,
+        "status" TEXT NOT NULL DEFAULT 'QUEUED',
+        "request" JSONB NOT NULL,
+        "error" TEXT,
+        "externalTurnId" TEXT,
+        "interruptRequestedAt" DATETIME,
+        "startedAt" DATETIME,
+        "endedAt" DATETIME,
+        "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        "updatedAt" DATETIME NOT NULL,
+        CONSTRAINT "ChatRun_chatId_fkey" FOREIGN KEY ("chatId") REFERENCES "Chat" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+        CONSTRAINT "ChatRun_accountId_fkey" FOREIGN KEY ("accountId") REFERENCES "CodexAccount" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+      )`,
+  'CREATE UNIQUE INDEX IF NOT EXISTS "User_externalId_key" ON "User"("externalId")',
+  'ALTER TABLE "CodexAccount" ADD COLUMN "defaultModel" TEXT',
+  'ALTER TABLE "CodexAccount" ADD COLUMN "defaultPermissionMode" TEXT',
+  'ALTER TABLE "CodexAccount" ADD COLUMN "defaultReasoningEffort" TEXT',
+  'ALTER TABLE "CodexAccount" ADD COLUMN "defaultServiceTier" TEXT',
+  'CREATE INDEX IF NOT EXISTS "CodexAccount_userId_idx" ON "CodexAccount"("userId")',
+  'CREATE INDEX IF NOT EXISTS "Chat_userId_updatedAt_idx" ON "Chat"("userId", "updatedAt")',
+  'CREATE INDEX IF NOT EXISTS "Chat_userId_lastActivityAt_idx" ON "Chat"("userId", "lastActivityAt")',
+  'CREATE INDEX IF NOT EXISTS "Chat_accountId_idx" ON "Chat"("accountId")',
+  'CREATE INDEX IF NOT EXISTS "ChatMessage_chatId_sequence_idx" ON "ChatMessage"("chatId", "sequence")',
+  'CREATE INDEX IF NOT EXISTS "ChatMessage_chatId_turnId_idx" ON "ChatMessage"("chatId", "turnId")',
+  'CREATE INDEX IF NOT EXISTS "ChatMessage_chatId_itemId_idx" ON "ChatMessage"("chatId", "itemId")',
+  'CREATE INDEX IF NOT EXISTS "ChatMessage_requestId_idx" ON "ChatMessage"("requestId")',
+  'CREATE INDEX IF NOT EXISTS "ChatMessage_runId_idx" ON "ChatMessage"("runId")',
+  'CREATE UNIQUE INDEX IF NOT EXISTS "ChatMessage_chatId_sequence_key" ON "ChatMessage"("chatId", "sequence")',
+  'CREATE INDEX IF NOT EXISTS "ChatRun_chatId_createdAt_idx" ON "ChatRun"("chatId", "createdAt")',
+  'CREATE INDEX IF NOT EXISTS "ChatRun_accountId_idx" ON "ChatRun"("accountId")',
+  'CREATE INDEX IF NOT EXISTS "ChatRun_externalTurnId_idx" ON "ChatRun"("externalTurnId")',
+]