orez 0.1.6 → 0.1.8

package/src/admin/log-store.ts

@@ -29,20 +29,28 @@ export function createLogStore(dataDir: string, writeToDisk = true): LogStore {
   let nextId = 1
 
   const logsDir = join(dataDir, 'logs')
-  const logFile = join(logsDir, 'orez.log')
-  const backupFile = join(logsDir, 'orez.log.1')
 
   if (writeToDisk) {
     mkdirSync(logsDir, { recursive: true })
   }
 
-  function rotateIfNeeded() {
+  // track file sizes to rotate per-source
+  const fileSizes: Record<string, number> = {}
+
+  function getLogFile(source: string): string {
+    return join(logsDir, `${source}.log`)
+  }
+
+  function rotateIfNeeded(source: string) {
     if (!writeToDisk) return
     try {
+      const logFile = getLogFile(source)
       if (!existsSync(logFile)) return
       const stat = statSync(logFile)
+      fileSizes[source] = stat.size
       if (stat.size > MAX_FILE_SIZE) {
-        renameSync(logFile, backupFile)
+        renameSync(logFile, logFile + '.1')
+        fileSizes[source] = 0
       }
     } catch {}
   }
@@ -62,11 +70,13 @@ export function createLogStore(dataDir: string, writeToDisk = true): LogStore {
     if (writeToDisk) {
       try {
         const ts = new Date(entry.ts).toISOString()
-        appendFileSync(
-          logFile,
-          '[' + ts + '] [' + source + '] [' + level + '] ' + entry.msg + '\n'
-        )
-        rotateIfNeeded()
+        const logFile = getLogFile(source)
+        appendFileSync(logFile, `[${ts}] [${level}] ${entry.msg}\n`)
+        // check rotation every ~100 writes to this source
+        fileSizes[source] = (fileSizes[source] || 0) + entry.msg.length + 50
+        if (fileSizes[source] > MAX_FILE_SIZE) {
+          rotateIfNeeded(source)
+        }
       } catch {}
     }
   }

package/src/admin/server.ts

@@ -14,6 +14,7 @@ import type { LogStore } from './log-store.js'
 
 export interface AdminActions {
   restartZero?: () => Promise<void>
+  stopZero?: () => Promise<void>
   resetZero?: () => Promise<void>
   resetZeroFull?: () => Promise<void>
 }
@@ -109,6 +110,17 @@ export function startAdminServer(opts: AdminServerOpts): Promise<Server> {
         return
       }
 
+      if (req.method === 'POST' && url.pathname === '/api/actions/stop-zero') {
+        if (!actions?.stopZero) {
+          json(res, { ok: false, message: 'zero-cache not running' }, 400)
+          return
+        }
+        log.orez('admin: stopping zero-cache for restore')
+        await actions.stopZero()
+        json(res, { ok: true, message: 'zero-cache stopped' })
+        return
+      }
+
       if (req.method === 'POST' && url.pathname === '/api/actions/reset-zero') {
         if (!actions?.resetZero) {
           json(res, { ok: false, message: 'zero-cache not running' }, 400)

package/src/cli.ts

@@ -9,6 +9,34 @@ import { deparseSync, loadModule, parseSync } from 'pgsql-parser'
 import { startZeroLite } from './index.js'
 import { log, url } from './log.js'
 
+// detect admin port from running orez instance
+async function detectAdminPort(dataDir: string): Promise<number | null> {
+  const pidFile = resolve(dataDir, 'orez.pid')
+  const adminFile = resolve(dataDir, 'orez.admin')
+
+  if (!existsSync(pidFile)) return null
+
+  // check if admin port file exists
+  if (existsSync(adminFile)) {
+    try {
+      const port = parseInt(readFileSync(adminFile, 'utf-8').trim(), 10)
+      if (port > 0) return port
+    } catch {}
+  }
+
+  // fallback: try common admin ports
+  for (const port of [6477, 6478, 6479]) {
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}/health`, {
+        signal: AbortSignal.timeout(500),
+      })
+      if (res.ok) return port
+    } catch {}
+  }
+
+  return null
+}
+
 const s3Command = defineCommand({
   meta: {
     name: 's3',
@@ -539,6 +567,23 @@ async function tryWireRestore(opts: {
 
   // connected — restore errors should propagate, not fall back
   log.orez(`connected via wire protocol on port ${opts.port}`)
+
+  // automatically stop zero-cache before restore to prevent conflicts
+  const adminPort = await detectAdminPort(opts.dataDir)
+  if (adminPort) {
+    log.orez('stopping zero-cache for restore...')
+    try {
+      await fetch(`http://127.0.0.1:${adminPort}/api/actions/stop-zero`, {
+        method: 'POST',
+        signal: AbortSignal.timeout(10_000),
+      })
+      // give zero-cache time to stop
+      await new Promise((r) => setTimeout(r, 1000))
+    } catch {
+      log.orez('warning: could not stop zero-cache (may not be running)')
+    }
+  }
+
   try {
     const pubName = process.env.ZERO_APP_PUBLICATIONS?.trim()
     let pubTablesBeforeRestore: string[] = []
@@ -570,12 +615,12 @@ async function tryWireRestore(opts: {
       `restored ${opts.sqlFile} via wire protocol (${executed} statements, ${skipped} skipped)`
     )
 
-    // clear zero replication state
-    await sql.unsafe('TRUNCATE _zero_changes').catch(() => {})
-    await sql.unsafe('TRUNCATE _zero_replication_slots').catch(() => {})
+    // clear zero replication state (in _orez schema)
+    await sql.unsafe('TRUNCATE _orez._zero_changes').catch(() => {})
+    await sql.unsafe('TRUNCATE _orez._zero_replication_slots').catch(() => {})
     log.orez('cleared zero replication state')
 
-    // clear zero cdb change tracking state
+    // drop zero cdb cdc schemas so zero-cache can recreate them fresh
     const cdbSql = postgres({
       host: '127.0.0.1',
       port: opts.port,
@@ -587,14 +632,14 @@ async function tryWireRestore(opts: {
       onnotice: () => {},
     })
     try {
-      const cdbTables = await cdbSql<{ schemaname: string; tablename: string }[]>`
-        SELECT schemaname, tablename FROM pg_tables WHERE schemaname LIKE '%/cdc'
+      const cdcSchemas = await cdbSql<{ nspname: string }[]>`
+        SELECT DISTINCT nspname FROM pg_namespace WHERE nspname LIKE '%/cdc'
       `
-      for (const { schemaname, tablename } of cdbTables) {
-        await cdbSql.unsafe(`TRUNCATE "${schemaname}"."${tablename}"`).catch(() => {})
+      for (const { nspname } of cdcSchemas) {
+        await cdbSql.unsafe(`DROP SCHEMA IF EXISTS "${nspname}" CASCADE`).catch(() => {})
       }
-      if (cdbTables.length > 0) {
-        log.orez(`cleared ${cdbTables.length} cdc table(s)`)
+      if (cdcSchemas.length > 0) {
+        log.orez(`dropped ${cdcSchemas.length} cdc schema(s) from zero_cdb`)
       }
     } catch {
       // zero_cdb might not exist yet
@@ -617,19 +662,16 @@ async function tryWireRestore(opts: {
       const existingSet = new Set(existingPublicTables.map((r) => r.tablename))
 
       // Prefer pre-restore publication membership; if unavailable, fall back to
-      // zero-marked tables (_0_version) from the restored schema.
+      // ALL public tables (prod dumps don't have _0_version columns yet).
       const desired = new Set<string>(
         pubTablesBeforeRestore.filter((t) => existingSet.has(t))
       )
       if (desired.size === 0) {
-        const zeroMarked = await sql<{ tablename: string }[]>`
-          SELECT DISTINCT table_name AS tablename
-          FROM information_schema.columns
-          WHERE table_schema = 'public'
-            AND column_name = '_0_version'
-        `
-        for (const { tablename } of zeroMarked) {
-          if (existingSet.has(tablename)) desired.add(tablename)
+        // Add all public tables except internal ones
+        for (const { tablename } of existingPublicTables) {
+          if (!tablename.startsWith('_')) {
+            desired.add(tablename)
+          }
         }
       }
 
@@ -661,34 +703,37 @@ async function tryWireRestore(opts: {
       log.orez(`publication "${pubName}" has ${count} table(s) after restore`)
     }
 
+    // drop zero shard schemas to prevent conflicts when zero restarts
+    const shardSchemas = await sql<{ nspname: string }[]>`
+      SELECT nspname FROM pg_namespace
+      WHERE nspname LIKE 'chat_%'
+         OR nspname LIKE 'zero_%'
+         OR nspname LIKE 'startchat_%'
+    `
+    for (const { nspname } of shardSchemas) {
+      await sql.unsafe(`DROP SCHEMA IF EXISTS "${nspname}" CASCADE`).catch(() => {})
+    }
+    if (shardSchemas.length > 0) {
+      log.orez(`dropped ${shardSchemas.length} shard schema(s)`)
+    }
+
     log.orez('restore complete')
   } finally {
     await sql.end({ timeout: 1 })
   }
 
-  // signal orez to reset zero state (CVR/CDB + zero-cache)
-  const pidFile = resolve(opts.dataDir, 'orez.pid')
-  const resetFile = resolve(opts.dataDir, 'orez.resetting')
-  if (existsSync(pidFile)) {
+  // restart zero-cache so it recreates shard schemas fresh
+  if (adminPort) {
+    log.orez('restarting zero-cache...')
     try {
-      const pid = parseInt(readFileSync(pidFile, 'utf-8').trim(), 10)
-      if (pid && pid > 0) {
-        log.orez('signaling orez to reset...')
-        process.kill(pid, 'SIGUSR1')
-
-        // wait for reset to complete (orez writes .resetting file during reset)
-        const deadline = Date.now() + 120_000
-        await new Promise((r) => setTimeout(r, 500)) // give handler time to start
-        while (existsSync(resetFile) && Date.now() < deadline) {
-          await new Promise((r) => setTimeout(r, 500))
-        }
-        if (existsSync(resetFile)) {
-          log.orez('warning: reset timed out, continuing anyway')
-        } else {
-          log.orez('reset complete')
-        }
-      }
-    } catch {}
+      await fetch(`http://127.0.0.1:${adminPort}/api/actions/restart-zero`, {
+        method: 'POST',
+        signal: AbortSignal.timeout(10_000),
+      })
+      log.orez('zero-cache restarting')
+    } catch {
+      log.orez('warning: could not restart zero-cache')
+    }
   }
 
   return true
@@ -803,7 +848,10 @@ const pgRestoreCommand = defineCommand({
           sqlFile,
           dataDir: args['data-dir'],
         })
-        if (restored) return
+        if (restored) {
+          // ensure clean exit - don't let any lingering handles keep process alive
+          process.exit(0)
+        }
         log.orez('wire protocol unavailable, falling back to direct PGlite')
       } catch (err: any) {
         // connected but restore failed — report error, don't fall back
@@ -882,7 +930,12 @@ const main = defineCommand({
     },
     'disable-wasm-sqlite': {
       type: 'boolean',
-      description: 'use native @rocicorp/zero-sqlite3 instead of wasm bedrock-sqlite',
+      description: 'force native @rocicorp/zero-sqlite3 (fails if not available)',
+      default: false,
+    },
+    'force-wasm-sqlite': {
+      type: 'boolean',
+      description: 'force wasm bedrock-sqlite even if native is available',
       default: false,
     },
     'on-db-ready': {
@@ -920,6 +973,7 @@ const main = defineCommand({
       logStore,
       httpLog,
       restartZero,
+      stopZero,
       resetZero,
       resetZeroFull,
     } = await startZeroLite({
@@ -933,6 +987,7 @@ const main = defineCommand({
       pgPassword: args['pg-password'],
       skipZeroCache: args['skip-zero-cache'],
       disableWasmSqlite: args['disable-wasm-sqlite'],
+      forceWasmSqlite: args['force-wasm-sqlite'],
       logLevel: (args['log-level'] as 'error' | 'warn' | 'info' | 'debug') || undefined,
       onDbReady: args['on-db-ready'] || undefined,
       onHealthy: args['on-healthy'] || undefined,
@@ -956,7 +1011,7 @@ const main = defineCommand({
         httpLog,
         config,
         zeroEnv,
-        actions: { restartZero, resetZero, resetZeroFull },
+        actions: { restartZero, stopZero, resetZero, resetZeroFull },
         startTime: Date.now(),
       })
       log.orez(`admin: ${url(`http://localhost:${config.adminPort}`)}`)

package/src/config.ts

@@ -16,6 +16,7 @@ export interface ZeroLiteConfig {
   seedFile: string
   skipZeroCache: boolean
   disableWasmSqlite: boolean
+  forceWasmSqlite: boolean
   logLevel: LogLevel
   pgliteOptions: Partial<PGliteOptions>
   // lifecycle hooks
@@ -35,6 +36,7 @@ export function getConfig(overrides: Partial<ZeroLiteConfig> = {}): ZeroLiteConf
     seedFile: overrides.seedFile || 'src/database/seed.sql',
     skipZeroCache: overrides.skipZeroCache || false,
     disableWasmSqlite: overrides.disableWasmSqlite ?? false,
+    forceWasmSqlite: overrides.forceWasmSqlite ?? false,
     logLevel: overrides.logLevel || 'warn',
     pgliteOptions: overrides.pgliteOptions || {},
     onDbReady: overrides.onDbReady,