better-codex 0.1.0

package/apps/backend/src/services/supervisor.ts

@@ -0,0 +1,102 @@
+import { EventEmitter } from 'node:events'
+import { CodexAppServer } from '../core/app-server'
+import type { HubConfig } from '../config'
+import type { Profile } from './profile-store'
+
+type SupervisorEvents = {
+  notification: (payload: {
+    profileId: string
+    method: string
+    params?: unknown
+  }) => void
+  serverRequest: (payload: {
+    profileId: string
+    id: number
+    method: string
+    params?: unknown
+  }) => void
+  diagnostic: (payload: { profileId: string; message: string }) => void
+  exit: (payload: { profileId: string; code: number | null }) => void
+  error: (payload: { profileId: string; error: Error }) => void
+}
+
+export class CodexSupervisor extends EventEmitter {
+  private readonly processes = new Map<string, CodexAppServer>()
+
+  constructor(private readonly config: HubConfig) {
+    super()
+  }
+
+  async start(profile: Profile): Promise<CodexAppServer> {
+    const existing = this.processes.get(profile.id)
+    if (existing) {
+      return existing
+    }
+
+    const server = new CodexAppServer({
+      codexBin: this.config.codexBin,
+      codexArgs: this.config.codexArgs,
+      appServerArgs: this.config.codexAppServerArgs,
+      codexHome: profile.codexHome,
+      clientInfo: this.config.clientInfo,
+      cwd: this.config.defaultCwd,
+    })
+
+    server.on('notification', (message) => {
+      this.emit('notification', {
+        profileId: profile.id,
+        method: message.method,
+        params: message.params,
+      })
+    })
+    server.on('serverRequest', (message) => {
+      this.emit('serverRequest', {
+        profileId: profile.id,
+        id: message.id,
+        method: message.method,
+        params: message.params,
+      })
+    })
+    server.on('stderr', (message) => {
+      this.emit('diagnostic', { profileId: profile.id, message })
+    })
+    server.on('exit', (code) => {
+      this.processes.delete(profile.id)
+      this.emit('exit', { profileId: profile.id, code })
+    })
+    server.on('error', (error) => {
+      this.emit('error', { profileId: profile.id, error })
+    })
+
+    await server.start()
+    this.processes.set(profile.id, server)
+    return server
+  }
+
+  async stop(profileId: string): Promise<void> {
+    const server = this.processes.get(profileId)
+    if (!server) {
+      return
+    }
+    await server.stop()
+    this.processes.delete(profileId)
+  }
+
+  async request(profileId: string, method: string, params?: unknown): Promise<unknown> {
+    const server = this.processes.get(profileId)
+    if (!server) {
+      throw new Error('profile app-server not running')
+    }
+    return server.request(method, params)
+  }
+
+  respond(profileId: string, id: number, result?: unknown, error?: { code?: number; message: string }): void {
+    const server = this.processes.get(profileId)
+    if (!server) {
+      return
+    }
+    server.respond(id, result, error)
+  }
+}
+
+export type CodexSupervisorEventsMap = SupervisorEvents

package/apps/backend/src/thread-index/service.ts

@@ -0,0 +1,75 @@
+import { ThreadIndexStore, type ThreadIndexRow, type ThreadSearchQuery } from './store'
+
+export type ThreadListItem = {
+  id: string
+  preview?: string
+  modelProvider?: string
+  createdAt?: number
+  path?: string
+  cwd?: string
+  cliVersion?: string
+  source?: string
+}
+
+export class ThreadIndexService {
+  constructor(private readonly store: ThreadIndexStore) {}
+
+  init(): void {
+    this.store.init()
+  }
+
+  recordThreadList(profileId: string, threads: ThreadListItem[], fetchedAt = Date.now()): void {
+    threads.forEach((thread) => {
+      this.store.upsertThread(this.toRow(profileId, thread, fetchedAt))
+    })
+  }
+
+  recordThreadStart(profileId: string, thread?: ThreadListItem): void {
+    if (!thread?.id) {
+      return
+    }
+    this.store.upsertThread(this.toRow(profileId, thread, Date.now()))
+  }
+
+  recordThreadResume(profileId: string, thread?: ThreadListItem): void {
+    if (!thread?.id) {
+      return
+    }
+    this.store.upsertThread(this.toRow(profileId, thread, Date.now()))
+  }
+
+  recordThreadArchive(profileId: string, threadId: string): void {
+    this.store.markArchived(profileId, threadId)
+  }
+
+  search(query: ThreadSearchQuery): ThreadIndexRow[] {
+    return this.store.search(query)
+  }
+
+  private toRow(profileId: string, thread: ThreadListItem, fetchedAt: number): ThreadIndexRow {
+    return {
+      threadId: thread.id,
+      profileId,
+      preview: thread.preview ?? null,
+      modelProvider: thread.modelProvider ?? null,
+      createdAt: normalizeTimestamp(thread.createdAt),
+      path: thread.path ?? null,
+      cwd: thread.cwd ?? null,
+      source: thread.source ?? null,
+      cliVersion: thread.cliVersion ?? null,
+      status: 'active',
+      archivedAt: null,
+      lastSeenAt: fetchedAt,
+    }
+  }
+}
+
+const normalizeTimestamp = (value?: number): number | null => {
+  if (!value) {
+    return null
+  }
+  if (value > 1000000000000) {
+    return Math.floor(value / 1000)
+  }
+  return value
+}

package/apps/backend/src/thread-index/store.ts

@@ -0,0 +1,195 @@
+import { Database } from 'bun:sqlite'
+
+export type ThreadIndexRow = {
+  threadId: string
+  profileId: string
+  preview: string | null
+  modelProvider: string | null
+  createdAt: number | null
+  path: string | null
+  cwd: string | null
+  source: string | null
+  cliVersion: string | null
+  status: 'active' | 'archived'
+  archivedAt: number | null
+  lastSeenAt: number | null
+}
+
+export type ThreadSearchQuery = {
+  query?: string
+  profileId?: string
+  model?: string
+  status?: 'active' | 'archived'
+  createdAfter?: number
+  createdBefore?: number
+  limit?: number
+  offset?: number
+}
+
+export class ThreadIndexStore {
+  private readonly db: Database
+
+  constructor(private readonly dbPath: string) {
+    this.db = new Database(dbPath)
+  }
+
+  init(): void {
+    this.db.exec(`
+      pragma journal_mode = wal;
+      create table if not exists thread_index (
+        thread_id text primary key,
+        profile_id text not null,
+        preview text,
+        model_provider text,
+        created_at integer,
+        path text,
+        cwd text,
+        source text,
+        cli_version text,
+        status text not null default 'active',
+        archived_at integer,
+        last_seen_at integer
+      );
+      create index if not exists thread_index_profile on thread_index(profile_id);
+      create index if not exists thread_index_model on thread_index(model_provider);
+      create index if not exists thread_index_created on thread_index(created_at);
+      create index if not exists thread_index_status on thread_index(status);
+
+      create virtual table if not exists thread_index_fts using fts5(
+        thread_id,
+        preview,
+        path,
+        cwd,
+        model_provider,
+        profile_id
+      );
+    `)
+  }
+
+  upsertThread(row: ThreadIndexRow): void {
+    this.db
+      .prepare(
+        `insert into thread_index
+          (thread_id, profile_id, preview, model_provider, created_at, path, cwd, source, cli_version, status, archived_at, last_seen_at)
+         values
+          ($thread_id, $profile_id, $preview, $model_provider, $created_at, $path, $cwd, $source, $cli_version, $status, $archived_at, $last_seen_at)
+         on conflict(thread_id) do update set
+          profile_id = excluded.profile_id,
+          preview = excluded.preview,
+          model_provider = excluded.model_provider,
+          created_at = excluded.created_at,
+          path = excluded.path,
+          cwd = excluded.cwd,
+          source = excluded.source,
+          cli_version = excluded.cli_version,
+          status = excluded.status,
+          archived_at = excluded.archived_at,
+          last_seen_at = excluded.last_seen_at
+        `
+      )
+      .run({
+        $thread_id: row.threadId,
+        $profile_id: row.profileId,
+        $preview: row.preview,
+        $model_provider: row.modelProvider,
+        $created_at: row.createdAt,
+        $path: row.path,
+        $cwd: row.cwd,
+        $source: row.source,
+        $cli_version: row.cliVersion,
+        $status: row.status,
+        $archived_at: row.archivedAt,
+        $last_seen_at: row.lastSeenAt,
+      })
+
+    this.db
+      .prepare('delete from thread_index_fts where thread_id = $thread_id')
+      .run({ $thread_id: row.threadId })
+    this.db
+      .prepare(
+        `insert into thread_index_fts (thread_id, preview, path, cwd, model_provider, profile_id)
+         values ($thread_id, $preview, $path, $cwd, $model_provider, $profile_id)
+        `
+      )
+      .run({
+        $thread_id: row.threadId,
+        $preview: row.preview ?? '',
+        $path: row.path ?? '',
+        $cwd: row.cwd ?? '',
+        $model_provider: row.modelProvider ?? '',
+        $profile_id: row.profileId,
+      })
+  }
+
+  markArchived(profileId: string, threadId: string): void {
+    const timestamp = Date.now()
+    this.db
+      .prepare(
+        `update thread_index
+         set status = 'archived', archived_at = $archived_at
+         where thread_id = $thread_id and profile_id = $profile_id
+        `
+      )
+      .run({
+        $thread_id: threadId,
+        $profile_id: profileId,
+        $archived_at: timestamp,
+      })
+  }
+
+  search(query: ThreadSearchQuery): ThreadIndexRow[] {
+    const limit = Math.min(200, Math.max(1, query.limit ?? 50))
+    const offset = Math.max(0, query.offset ?? 0)
+    const filters: string[] = []
+    // bun's Statement typing does not currently accept named params; values are string | number | null
+    const params: Record<string, string | number | null> = {
+      $limit: limit,
+      $offset: offset,
+      $profile_id: query.profileId ?? null,
+      $model: query.model ?? null,
+      $status: query.status ?? null,
+      $created_after: query.createdAfter ?? null,
+      $created_before: query.createdBefore ?? null,
+    }
+
+    if (query.profileId) {
+      filters.push('t.profile_id = $profile_id')
+    }
+    if (query.model) {
+      filters.push('t.model_provider = $model')
+    }
+    if (query.status) {
+      filters.push('t.status = $status')
+    }
+    if (query.createdAfter) {
+      filters.push('t.created_at >= $created_after')
+    }
+    if (query.createdBefore) {
+      filters.push('t.created_at <= $created_before')
+    }
+
+    const filterSql = filters.length ? `and ${filters.join(' and ')}` : ''
+
+    if (query.query && query.query.trim()) {
+      params.$query = query.query
+      const sql = `
+        select t.* from thread_index t
+        join thread_index_fts f on t.thread_id = f.thread_id
+        where f.thread_index_fts match $query
+        ${filterSql}
+        order by t.created_at desc
+        limit $limit offset $offset
+      `
+      return this.db.prepare(sql).all(params as any) as ThreadIndexRow[]
+    }
+
+    const sql = `
+      select t.* from thread_index t
+      where 1 = 1
+      ${filterSql}
+      order by t.created_at desc
+      limit $limit offset $offset
+    `
+    return this.db.prepare(sql).all(params as any) as ThreadIndexRow[]
+  }
+}

package/apps/backend/src/ws/messages.ts

@@ -0,0 +1,73 @@
+export type WsRequest =
+  | {
+      type: 'profile.start'
+      profileId: string
+    }
+  | {
+      type: 'profile.stop'
+      profileId: string
+    }
+  | {
+      type: 'rpc.request'
+      requestId: string
+      profileId: string
+      method: string
+      params?: unknown
+    }
+  | {
+      type: 'rpc.response'
+      profileId: string
+      id: number
+      result?: unknown
+      error?: { code?: number; message: string }
+    }
+
+export type WsEvent =
+  | {
+      type: 'rpc.event'
+      profileId: string
+      method: string
+      params?: unknown
+    }
+  | {
+      type: 'rpc.serverRequest'
+      profileId: string
+      id: number
+      method: string
+      params?: unknown
+    }
+  | {
+      type: 'profile.diagnostic'
+      profileId: string
+      message: string
+    }
+  | {
+      type: 'profile.exit'
+      profileId: string
+      code: number | null
+    }
+  | {
+      type: 'profile.error'
+      profileId: string
+      message: string
+    }
+
+export type WsResponse =
+  | {
+      type: 'rpc.response'
+      requestId: string
+      result?: unknown
+      error?: string
+    }
+  | {
+      type: 'profile.started'
+      profileId: string
+    }
+  | {
+      type: 'profile.stopped'
+      profileId: string
+    }
+  | {
+      type: 'error'
+      message: string
+    }

package/apps/backend/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "ESNext"
+    ],
+    "module": "ESNext",
+    "target": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleDetection": "force",
+    "noUncheckedIndexedAccess": true,
+    "noEmit": true,
+    "types": [
+      "bun"
+    ]
+  }
+}

package/apps/web/README.md

@@ -0,0 +1,24 @@
+# Codex Hub Web UI
+
+Frontend for the multi-account Codex hub. It connects to the local backend over
+REST + WebSocket.
+
+## Setup
+
+1. Install dependencies
+   ```bash
+   bun install
+   ```
+2. Start the dev server
+   ```bash
+   bun run dev
+   ```
+
+## Environment variables
+
+Create a `.env` file with:
+
+```bash
+VITE_CODEX_HUB_URL=http://127.0.0.1:7711
+VITE_CODEX_HUB_TOKEN=... # printed by the backend on boot
+```