mongo.do 0.1.0 → 0.1.1

package/dist/cli/index.js

@@ -1,219 +1,4106 @@
-#!/usr/bin/env bun
-/**
- * MondoDB CLI Entry Point
- *
- * Main entry point for the MondoDB command-line interface.
- * Provides a MongoDB-compatible database backed by SQLite or Cloudflare Workers.
- *
- * Usage:
- *   mongo.do [options]
- *   bun run src/cli/index.ts [options]
- *
- * @module cli
- */
-import { version } from '../../package.json';
-import { parseArgs, validateOptions, printHelp, printShutdownMessage, runServer, } from './server.js';
-// ============================================================================
-// ANSI Color Codes (no external dependencies)
-// ============================================================================
-const colors = {
-    reset: '\x1b[0m',
-    bold: '\x1b[1m',
-    dim: '\x1b[2m',
-    // Foreground colors
-    red: '\x1b[31m',
-    green: '\x1b[32m',
-    yellow: '\x1b[33m',
-    blue: '\x1b[34m',
-    magenta: '\x1b[35m',
-    cyan: '\x1b[36m',
-    white: '\x1b[37m',
+#!/usr/bin/env node
+import { Database } from 'bun:sqlite';
+import { ObjectId, BSON, Binary, Long } from 'bson';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-/**
- * Check if stdout supports colors
- */
-function supportsColor() {
-    // Check for NO_COLOR environment variable
-    if (process.env.NO_COLOR !== undefined) {
-        return false;
-    }
-    // Check for FORCE_COLOR environment variable
-    if (process.env.FORCE_COLOR !== undefined) {
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/utils/sql-safety.ts
+function validateFieldPath(field) {
+  if (!field || field.length === 0) {
+    throw new Error("Field name cannot be empty");
+  }
+  if (field.includes("\0")) {
+    throw new Error("Field name cannot contain null characters");
+  }
+  if (!SAFE_FIELD_PATTERN.test(field)) {
+    throw new Error(
+      `Invalid field name: "${field}". Field names can only contain alphanumeric characters, underscores, dots, hyphens, and dollar signs.`
+    );
+  }
+  if (field.includes("..") || field.startsWith(".") || field.endsWith(".")) {
+    throw new Error(
+      `Invalid field path: "${field}". Field paths cannot have consecutive, leading, or trailing dots.`
+    );
+  }
+  return field;
+}
+function safeJsonPath(field) {
+  const validField = validateFieldPath(field);
+  return validField.startsWith("$") ? validField : `$.${validField}`;
+}
+var SAFE_FIELD_PATTERN;
+var init_sql_safety = __esm({
+  "src/utils/sql-safety.ts"() {
+    SAFE_FIELD_PATTERN = /^[a-zA-Z0-9_.$-]+$/;
+  }
+});
+
+// src/wire/backend/validation.ts
+function sanitizeDatabaseName(name) {
+  if (!name || typeof name !== "string") {
+    throw new Error("Database name must be a non-empty string");
+  }
+  if (name.includes("..") || name.includes("/") || name.includes("\\")) {
+    throw new Error(`Invalid database name "${name}": contains path traversal characters`);
+  }
+  if (name.includes("\0")) {
+    throw new Error("Invalid database name: contains null byte");
+  }
+  if (name.startsWith(".")) {
+    throw new Error(`Invalid database name "${name}": cannot start with a dot`);
+  }
+  if (name.length > 255) {
+    throw new Error(`Database name too long: ${name.length} characters (max 255)`);
+  }
+  const validNameRegex = /^[a-zA-Z0-9_-]+$/;
+  if (!validNameRegex.test(name)) {
+    throw new Error(
+      `Invalid database name "${name}": only alphanumeric characters, underscores, and hyphens are allowed`
+    );
+  }
+  return name;
+}
+function validateCollectionName(name) {
+  if (!name || typeof name !== "string") {
+    throw new Error("Collection name must be a non-empty string");
+  }
+  if (name.includes("\0")) {
+    throw new Error("Invalid collection name: contains null byte");
+  }
+  if (name.length > 255) {
+    throw new Error(`Collection name too long: ${name.length} characters (max 255)`);
+  }
+  const validNameRegex = /^[a-zA-Z_][a-zA-Z0-9_.-]*$/;
+  if (!validNameRegex.test(name)) {
+    throw new Error(
+      `Invalid collection name "${name}": must start with a letter or underscore, and contain only alphanumeric characters, underscores, hyphens, and dots`
+    );
+  }
+  if (name.startsWith("system.") && !["system.users", "system.indexes", "system.namespaces"].includes(name)) {
+    throw new Error(`Invalid collection name "${name}": cannot use reserved 'system.' prefix`);
+  }
+  return name;
+}
+var init_validation = __esm({
+  "src/wire/backend/validation.ts"() {
+  }
+});
+
+// src/wire/backend/local-sqlite.ts
+var local_sqlite_exports = {};
+__export(local_sqlite_exports, {
+  LocalSQLiteBackend: () => LocalSQLiteBackend,
+  sanitizeDatabaseName: () => sanitizeDatabaseName,
+  validateCollectionName: () => validateCollectionName
+});
+var DEFAULT_BATCH_SIZE, CURSOR_TIMEOUT_MS2, LocalSQLiteBackend;
+var init_local_sqlite = __esm({
+  "src/wire/backend/local-sqlite.ts"() {
+    init_sql_safety();
+    init_validation();
+    init_validation();
+    DEFAULT_BATCH_SIZE = 101;
+    CURSOR_TIMEOUT_MS2 = 10 * 60 * 1e3;
+    LocalSQLiteBackend = class {
+      databases = /* @__PURE__ */ new Map();
+      cursors = /* @__PURE__ */ new Map();
+      nextCursorId = 1n;
+      dataDir;
+      constructor(dataDir = ".mongodo") {
+        this.dataDir = dataDir;
+        const fs = __require("fs");
+        if (!fs.existsSync(dataDir)) {
+          fs.mkdirSync(dataDir, { recursive: true });
+        }
+        setInterval(() => this.cleanupExpiredCursors(), 6e4);
+      }
+      /**
+       * Get or create a database connection
+       */
+      getDatabase(name) {
+        const safeName = sanitizeDatabaseName(name);
+        let db = this.databases.get(safeName);
+        if (!db) {
+          const dbPath = `${this.dataDir}/${safeName}.sqlite`;
+          db = new Database(dbPath);
+          this.initializeSchema(db);
+          this.databases.set(safeName, db);
+        }
+        return db;
+      }
+      /**
+       * Initialize the database schema
+       */
+      initializeSchema(db) {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS collections (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL UNIQUE,
+        options TEXT DEFAULT '{}'
+      );
+
+      CREATE TABLE IF NOT EXISTS documents (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        collection_id INTEGER NOT NULL,
+        _id TEXT NOT NULL,
+        data TEXT NOT NULL DEFAULT '{}',
+        FOREIGN KEY (collection_id) REFERENCES collections(id) ON DELETE CASCADE,
+        UNIQUE(collection_id, _id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_documents_id ON documents(_id);
+      CREATE INDEX IF NOT EXISTS idx_documents_collection_id ON documents(collection_id, _id);
+
+      CREATE TABLE IF NOT EXISTS indexes (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        collection_id INTEGER NOT NULL,
+        name TEXT NOT NULL,
+        key TEXT NOT NULL,
+        options TEXT DEFAULT '{}',
+        FOREIGN KEY (collection_id) REFERENCES collections(id) ON DELETE CASCADE,
+        UNIQUE(collection_id, name)
+      );
+    `);
+      }
+      /**
+       * Get collection ID, creating collection if it doesn't exist
+       */
+      getOrCreateCollectionId(db, name) {
+        const safeName = validateCollectionName(name);
+        const existing = db.query("SELECT id FROM collections WHERE name = ?").get(safeName);
+        if (existing) {
+          return existing.id;
+        }
+        const result = db.query("INSERT INTO collections (name) VALUES (?) RETURNING id").get(safeName);
+        return result.id;
+      }
+      /**
+       * Get collection ID or null if not found
+       */
+      getCollectionId(db, name) {
+        const safeName = validateCollectionName(name);
+        const result = db.query("SELECT id FROM collections WHERE name = ?").get(safeName);
+        return result?.id ?? null;
+      }
+      // ============ Database Operations ============
+      async listDatabases() {
+        const fs = __require("fs");
+        const path = __require("path");
+        let files = [];
+        try {
+          files = fs.readdirSync(this.dataDir);
+        } catch {
+        }
+        const databases = [];
+        for (const file of files) {
+          if (file.endsWith(".sqlite")) {
+            const name = file.replace(".sqlite", "");
+            const filePath = path.join(this.dataDir, file);
+            const stats = fs.statSync(filePath);
+            databases.push({
+              name,
+              sizeOnDisk: stats.size,
+              empty: stats.size < 1e3
+            });
+          }
+        }
+        if (!databases.find((d) => d.name === "admin")) {
+          databases.unshift({ name: "admin", sizeOnDisk: 0, empty: true });
+        }
+        return databases;
+      }
+      async createDatabase(name) {
+        this.getDatabase(name);
+      }
+      async dropDatabase(name) {
+        const safeName = sanitizeDatabaseName(name);
+        const db = this.databases.get(safeName);
+        if (db) {
+          db.close();
+          this.databases.delete(safeName);
+        }
+        const fs = __require("fs");
+        const dbPath = `${this.dataDir}/${safeName}.sqlite`;
+        if (fs.existsSync(dbPath)) {
+          fs.unlinkSync(dbPath);
+        }
+      }
+      async databaseExists(name) {
+        const safeName = sanitizeDatabaseName(name);
+        const fs = __require("fs");
+        return fs.existsSync(`${this.dataDir}/${safeName}.sqlite`);
+      }
+      // ============ Collection Operations ============
+      async listCollections(dbName, filter) {
+        const db = this.getDatabase(dbName);
+        let query = "SELECT name, options FROM collections";
+        const params = [];
+        if (filter?.name && typeof filter.name === "string") {
+          query += " WHERE name = ?";
+          params.push(filter.name);
+        }
+        const rows = db.query(query).all(...params);
+        return rows.map((row) => ({
+          name: row.name,
+          type: "collection",
+          options: JSON.parse(row.options),
+          info: { readOnly: false }
+        }));
+      }
+      async createCollection(dbName, name, options) {
+        const safeName = validateCollectionName(name);
+        const db = this.getDatabase(dbName);
+        const optionsJson = JSON.stringify(options || {});
+        db.query("INSERT OR IGNORE INTO collections (name, options) VALUES (?, ?)").run(safeName, optionsJson);
+      }
+      async dropCollection(dbName, name) {
+        const safeName = validateCollectionName(name);
+        const db = this.getDatabase(dbName);
+        db.query("DELETE FROM collections WHERE name = ?").run(safeName);
+      }
+      async collectionExists(dbName, name) {
+        const safeName = validateCollectionName(name);
+        const db = this.getDatabase(dbName);
+        const result = db.query("SELECT 1 FROM collections WHERE name = ? LIMIT 1").get(safeName);
+        return result !== null;
+      }
+      async collStats(dbName, collection) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (!collectionId) {
+          return {
+            ns: `${dbName}.${collection}`,
+            count: 0,
+            size: 0,
+            avgObjSize: 0,
+            storageSize: 0,
+            totalIndexSize: 0,
+            nindexes: 1,
+            indexSizes: { _id_: 0 }
+          };
+        }
+        const stats = db.query(`
+        SELECT COUNT(*) as count, COALESCE(SUM(LENGTH(data)), 0) as size
+        FROM documents WHERE collection_id = ?
+      `).get(collectionId);
+        return {
+          ns: `${dbName}.${collection}`,
+          count: stats.count,
+          size: stats.size,
+          avgObjSize: stats.count > 0 ? stats.size / stats.count : 0,
+          storageSize: stats.size,
+          totalIndexSize: stats.count * 50,
+          nindexes: 1,
+          indexSizes: { _id_: stats.count * 50 }
+        };
+      }
+      async dbStats(dbName) {
+        const db = this.getDatabase(dbName);
+        const collectionStats = db.query("SELECT COUNT(DISTINCT id) as collections FROM collections").get();
+        const docStats = db.query("SELECT COUNT(*) as objects, COALESCE(SUM(LENGTH(data)), 0) as dataSize FROM documents").get();
+        return {
+          db: dbName,
+          collections: collectionStats.collections,
+          views: 0,
+          objects: docStats.objects,
+          avgObjSize: docStats.objects > 0 ? docStats.dataSize / docStats.objects : 0,
+          dataSize: docStats.dataSize,
+          storageSize: docStats.dataSize,
+          indexes: collectionStats.collections,
+          indexSize: docStats.objects * 50
+        };
+      }
+      // ============ CRUD Operations ============
+      async find(dbName, collection, options) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (!collectionId) {
+          return { documents: [], cursorId: 0n, hasMore: false };
+        }
+        let sql = "SELECT _id, data FROM documents WHERE collection_id = ?";
+        const params = [collectionId];
+        if (options.filter && Object.keys(options.filter).length > 0) {
+          const filterSql = this.buildFilterSql(options.filter, params);
+          if (filterSql) {
+            sql += ` AND (${filterSql})`;
+          }
+        }
+        if (options.sort) {
+          const sortClauses = [];
+          for (const [field, direction] of Object.entries(options.sort)) {
+            const dir = direction === -1 ? "DESC" : "ASC";
+            if (field === "_id") {
+              sortClauses.push(`_id ${dir}`);
+            } else {
+              const safePath = safeJsonPath(validateFieldPath(field));
+              sortClauses.push(`json_extract(data, '${safePath}') ${dir}`);
+            }
+          }
+          if (sortClauses.length > 0) {
+            sql += ` ORDER BY ${sortClauses.join(", ")}`;
+          }
+        }
+        if (options.limit && options.limit > 0) {
+          sql += ` LIMIT ${options.limit}`;
+        }
+        if (options.skip && options.skip > 0) {
+          sql += ` OFFSET ${options.skip}`;
+        }
+        const rows = db.query(sql).all(...params);
+        let documents = rows.map((row) => {
+          const doc = JSON.parse(row.data);
+          doc._id = this.parseId(row._id);
+          return doc;
+        });
+        if (options.projection) {
+          documents = documents.map((doc) => this.applyProjection(doc, options.projection));
+        }
+        const batchSize = options.batchSize || DEFAULT_BATCH_SIZE;
+        if (documents.length > batchSize) {
+          const cursorId = this.nextCursorId++;
+          this.cursors.set(cursorId, {
+            id: cursorId,
+            namespace: `${dbName}.${collection}`,
+            documents,
+            position: batchSize,
+            batchSize,
+            createdAt: Date.now()
+          });
+          return {
+            documents: documents.slice(0, batchSize),
+            cursorId,
+            hasMore: true
+          };
+        }
+        return { documents, cursorId: 0n, hasMore: false };
+      }
+      async insertOne(dbName, collection, doc) {
+        return this.insertMany(dbName, collection, [doc]);
+      }
+      async insertMany(dbName, collection, docs) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getOrCreateCollectionId(db, collection);
+        const insertedIds = /* @__PURE__ */ new Map();
+        let insertedCount = 0;
+        const stmt = db.prepare("INSERT INTO documents (collection_id, _id, data) VALUES (?, ?, ?)");
+        db.transaction(() => {
+          for (let i = 0; i < docs.length; i++) {
+            const doc = { ...docs[i] };
+            if (!doc._id) {
+              doc._id = new ObjectId();
+            }
+            const idStr = this.serializeId(doc._id);
+            const dataJson = JSON.stringify(doc);
+            stmt.run(collectionId, idStr, dataJson);
+            insertedIds.set(i, doc._id);
+            insertedCount++;
+          }
+        })();
+        return { acknowledged: true, insertedIds, insertedCount };
+      }
+      async updateOne(dbName, collection, filter, update, options) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (!collectionId && !options?.upsert) {
+          return { acknowledged: true, matchedCount: 0, modifiedCount: 0, upsertedCount: 0 };
+        }
+        let sql = "SELECT id, _id, data FROM documents WHERE collection_id = ?";
+        const params = [collectionId || 0];
+        const filterSql = this.buildFilterSql(filter, params);
+        if (filterSql) {
+          sql += ` AND (${filterSql})`;
+        }
+        sql += " LIMIT 1";
+        const row = db.query(sql).get(...params);
+        if (!row) {
+          if (options?.upsert) {
+            const cid = this.getOrCreateCollectionId(db, collection);
+            const newDoc = { ...filter };
+            const updatedDoc2 = this.applyUpdate(newDoc, update);
+            if (!updatedDoc2._id) {
+              updatedDoc2._id = new ObjectId();
+            }
+            const idStr = this.serializeId(updatedDoc2._id);
+            db.query("INSERT INTO documents (collection_id, _id, data) VALUES (?, ?, ?)").run(
+              cid,
+              idStr,
+              JSON.stringify(updatedDoc2)
+            );
+            return {
+              acknowledged: true,
+              matchedCount: 0,
+              modifiedCount: 0,
+              upsertedId: updatedDoc2._id,
+              upsertedCount: 1
+            };
+          }
+          return { acknowledged: true, matchedCount: 0, modifiedCount: 0, upsertedCount: 0 };
+        }
+        const doc = JSON.parse(row.data);
+        doc._id = this.parseId(row._id);
+        const updatedDoc = this.applyUpdate(doc, update);
+        db.query("UPDATE documents SET data = ? WHERE id = ?").run(JSON.stringify(updatedDoc), row.id);
+        return { acknowledged: true, matchedCount: 1, modifiedCount: 1, upsertedCount: 0 };
+      }
+      async updateMany(dbName, collection, filter, update, options) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (!collectionId) {
+          if (options?.upsert) {
+            const result = await this.updateOne(dbName, collection, filter, update, options);
+            return result;
+          }
+          return { acknowledged: true, matchedCount: 0, modifiedCount: 0, upsertedCount: 0 };
+        }
+        let sql = "SELECT id, _id, data FROM documents WHERE collection_id = ?";
+        const params = [collectionId];
+        const filterSql = this.buildFilterSql(filter, params);
+        if (filterSql) {
+          sql += ` AND (${filterSql})`;
+        }
+        const rows = db.query(sql).all(...params);
+        if (rows.length === 0 && options?.upsert) {
+          const result = await this.updateOne(dbName, collection, filter, update, options);
+          return result;
+        }
+        const stmt = db.prepare("UPDATE documents SET data = ? WHERE id = ?");
+        db.transaction(() => {
+          for (const row of rows) {
+            const doc = JSON.parse(row.data);
+            doc._id = this.parseId(row._id);
+            const updatedDoc = this.applyUpdate(doc, update);
+            stmt.run(JSON.stringify(updatedDoc), row.id);
+          }
+        })();
+        return {
+          acknowledged: true,
+          matchedCount: rows.length,
+          modifiedCount: rows.length,
+          upsertedCount: 0
+        };
+      }
+      async deleteOne(dbName, collection, filter) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (!collectionId) {
+          return { acknowledged: true, deletedCount: 0 };
+        }
+        let sql = "SELECT id FROM documents WHERE collection_id = ?";
+        const params = [collectionId];
+        const filterSql = this.buildFilterSql(filter, params);
+        if (filterSql) {
+          sql += ` AND (${filterSql})`;
+        }
+        sql += " LIMIT 1";
+        const row = db.query(sql).get(...params);
+        if (!row) {
+          return { acknowledged: true, deletedCount: 0 };
+        }
+        db.query("DELETE FROM documents WHERE id = ?").run(row.id);
+        return { acknowledged: true, deletedCount: 1 };
+      }
+      async deleteMany(dbName, collection, filter) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (!collectionId) {
+          return { acknowledged: true, deletedCount: 0 };
+        }
+        let sql = "DELETE FROM documents WHERE collection_id = ?";
+        const params = [collectionId];
+        const filterSql = this.buildFilterSql(filter, params);
+        if (filterSql) {
+          sql += ` AND (${filterSql})`;
+        }
+        const result = db.query(sql).run(...params);
+        return { acknowledged: true, deletedCount: result.changes };
+      }
+      // ============ Count & Distinct ============
+      async count(dbName, collection, query) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (!collectionId) {
+          return 0;
+        }
+        let sql = "SELECT COUNT(*) as count FROM documents WHERE collection_id = ?";
+        const params = [collectionId];
+        if (query && Object.keys(query).length > 0) {
+          const filterSql = this.buildFilterSql(query, params);
+          if (filterSql) {
+            sql += ` AND (${filterSql})`;
+          }
+        }
+        const result = db.query(sql).get(...params);
+        return result.count;
+      }
+      async distinct(dbName, collection, field, query) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (!collectionId) {
+          return [];
+        }
+        let sql;
+        if (field === "_id") {
+          sql = "SELECT DISTINCT _id as value FROM documents WHERE collection_id = ?";
+        } else {
+          const safePath = safeJsonPath(validateFieldPath(field));
+          sql = `SELECT DISTINCT json_extract(data, '${safePath}') as value FROM documents WHERE collection_id = ?`;
+        }
+        const params = [collectionId];
+        if (query && Object.keys(query).length > 0) {
+          const filterSql = this.buildFilterSql(query, params);
+          if (filterSql) {
+            sql += ` AND (${filterSql})`;
+          }
+        }
+        const rows = db.query(sql).all(...params);
+        return rows.map((r) => r.value).filter((v) => v !== null);
+      }
+      // ============ Aggregation ============
+      async aggregate(dbName, collection, pipeline, options) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (!collectionId) {
+          return { documents: [], cursorId: 0n, hasMore: false };
+        }
+        const rows = db.query("SELECT _id, data FROM documents WHERE collection_id = ?").all(collectionId);
+        let documents = rows.map((row) => {
+          const doc = JSON.parse(row.data);
+          doc._id = this.parseId(row._id);
+          return doc;
+        });
+        documents = this.applyPipeline(documents, pipeline);
+        const batchSize = options?.batchSize || DEFAULT_BATCH_SIZE;
+        if (documents.length > batchSize) {
+          const cursorId = this.nextCursorId++;
+          this.cursors.set(cursorId, {
+            id: cursorId,
+            namespace: `${dbName}.${collection}`,
+            documents,
+            position: batchSize,
+            batchSize,
+            createdAt: Date.now()
+          });
+          return {
+            documents: documents.slice(0, batchSize),
+            cursorId,
+            hasMore: true
+          };
+        }
+        return { documents, cursorId: 0n, hasMore: false };
+      }
+      // ============ Index Operations ============
+      async listIndexes(dbName, collection) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        const indexes = [{ v: 2, key: { _id: 1 }, name: "_id_" }];
+        if (!collectionId) {
+          return indexes;
+        }
+        const rows = db.query("SELECT name, key, options FROM indexes WHERE collection_id = ?").all(collectionId);
+        for (const row of rows) {
+          indexes.push({
+            v: 2,
+            key: JSON.parse(row.key),
+            name: row.name,
+            ...JSON.parse(row.options)
+          });
+        }
+        return indexes;
+      }
+      async createIndexes(dbName, collection, indexes) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getOrCreateCollectionId(db, collection);
+        const createdNames = [];
+        const stmt = db.prepare(
+          "INSERT OR IGNORE INTO indexes (collection_id, name, key, options) VALUES (?, ?, ?, ?)"
+        );
+        for (const spec of indexes) {
+          const name = spec.name || this.generateIndexName(spec.key);
+          const keyJson = JSON.stringify(spec.key);
+          const options = {};
+          if (spec.unique) options.unique = true;
+          if (spec.sparse) options.sparse = true;
+          const result = stmt.run(collectionId, name, keyJson, JSON.stringify(options));
+          if (result.changes > 0) {
+            createdNames.push(name);
+          }
+        }
+        return createdNames;
+      }
+      async dropIndex(dbName, collection, indexName) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (collectionId) {
+          db.query("DELETE FROM indexes WHERE collection_id = ? AND name = ?").run(
+            collectionId,
+            indexName
+          );
+        }
+      }
+      async dropIndexes(dbName, collection) {
+        const db = this.getDatabase(dbName);
+        const collectionId = this.getCollectionId(db, collection);
+        if (collectionId) {
+          db.query("DELETE FROM indexes WHERE collection_id = ? AND name != '_id_'").run(collectionId);
+        }
+      }
+      // ============ Cursor Management ============
+      createCursor(state) {
+        this.cursors.set(state.id, state);
+      }
+      getCursor(id) {
+        return this.cursors.get(id);
+      }
+      advanceCursor(id, count) {
+        const cursor = this.cursors.get(id);
+        if (!cursor) {
+          return [];
+        }
+        const start = cursor.position;
+        const end = Math.min(start + count, cursor.documents.length);
+        cursor.position = end;
+        return cursor.documents.slice(start, end);
+      }
+      closeCursor(id) {
+        return this.cursors.delete(id);
+      }
+      cleanupExpiredCursors() {
+        const now = Date.now();
+        for (const [id, cursor] of this.cursors) {
+          if (now - cursor.createdAt > CURSOR_TIMEOUT_MS2) {
+            this.cursors.delete(id);
+          }
+        }
+      }
+      // ============ Helper Methods ============
+      serializeId(id) {
+        if (id instanceof ObjectId) {
+          return id.toHexString();
+        }
+        if (typeof id === "object" && id !== null && "$oid" in id) {
+          return id.$oid;
+        }
+        return String(id);
+      }
+      parseId(idStr) {
+        if (/^[0-9a-f]{24}$/i.test(idStr)) {
+          return new ObjectId(idStr);
+        }
+        return idStr;
+      }
+      generateIndexName(key) {
+        return Object.entries(key).map(([field, dir]) => `${field}_${dir}`).join("_");
+      }
+      /**
+       * Build simplified SQL filter from MongoDB query
+       */
+      buildFilterSql(filter, params) {
+        const conditions = [];
+        for (const [key, value] of Object.entries(filter)) {
+          if (key === "_id") {
+            params.push(this.serializeId(value));
+            conditions.push("_id = ?");
+          } else if (key === "$and" && Array.isArray(value)) {
+            const subConditions = value.map((sub) => this.buildFilterSql(sub, params)).filter(Boolean);
+            if (subConditions.length > 0) {
+              conditions.push(`(${subConditions.join(" AND ")})`);
+            }
+          } else if (key === "$or" && Array.isArray(value)) {
+            const subConditions = value.map((sub) => this.buildFilterSql(sub, params)).filter(Boolean);
+            if (subConditions.length > 0) {
+              conditions.push(`(${subConditions.join(" OR ")})`);
+            }
+          } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+            const safePath = safeJsonPath(validateFieldPath(key));
+            for (const [op, opValue] of Object.entries(value)) {
+              const path = `json_extract(data, '${safePath}')`;
+              switch (op) {
+                case "$eq":
+                  params.push(opValue);
+                  conditions.push(`${path} = ?`);
+                  break;
+                case "$ne":
+                  params.push(opValue);
+                  conditions.push(`${path} != ?`);
+                  break;
+                case "$gt":
+                  params.push(opValue);
+                  conditions.push(`${path} > ?`);
+                  break;
+                case "$gte":
+                  params.push(opValue);
+                  conditions.push(`${path} >= ?`);
+                  break;
+                case "$lt":
+                  params.push(opValue);
+                  conditions.push(`${path} < ?`);
+                  break;
+                case "$lte":
+                  params.push(opValue);
+                  conditions.push(`${path} <= ?`);
+                  break;
+                case "$exists":
+                  conditions.push(opValue ? `${path} IS NOT NULL` : `${path} IS NULL`);
+                  break;
+                case "$in":
+                  if (Array.isArray(opValue) && opValue.length > 0) {
+                    const placeholders = opValue.map(() => "?").join(", ");
+                    params.push(...opValue);
+                    conditions.push(`${path} IN (${placeholders})`);
+                  }
+                  break;
+              }
+            }
+          } else {
+            const safePath = safeJsonPath(validateFieldPath(key));
+            const sqlValue = typeof value === "boolean" ? value ? 1 : 0 : value;
+            params.push(sqlValue);
+            conditions.push(`json_extract(data, '${safePath}') = ?`);
+          }
+        }
+        return conditions.join(" AND ");
+      }
+      applyProjection(doc, projection) {
+        const includeFields = /* @__PURE__ */ new Set();
+        const excludeFields = /* @__PURE__ */ new Set();
+        let isInclusion = false;
+        for (const [field, value] of Object.entries(projection)) {
+          if (field === "_id" && (value === 0 || value === false)) {
+            excludeFields.add("_id");
+            continue;
+          }
+          if (value === 1 || value === true) {
+            includeFields.add(field);
+            isInclusion = true;
+          } else if (value === 0 || value === false) {
+            excludeFields.add(field);
+          }
+        }
+        if (isInclusion) {
+          const result2 = {};
+          if (!excludeFields.has("_id")) {
+            result2._id = doc._id;
+          }
+          for (const field of includeFields) {
+            if (field in doc) {
+              result2[field] = doc[field];
+            }
+          }
+          return result2;
+        }
+        const result = { ...doc };
+        for (const field of excludeFields) {
+          delete result[field];
+        }
+        return result;
+      }
+      applyUpdate(doc, update) {
+        const result = { ...doc };
+        if (update.$set) {
+          Object.assign(result, update.$set);
+        }
+        if (update.$unset) {
+          for (const key of Object.keys(update.$unset)) {
+            delete result[key];
+          }
+        }
+        if (update.$inc) {
+          for (const [key, value] of Object.entries(update.$inc)) {
+            const current = result[key] || 0;
+            result[key] = current + value;
+          }
+        }
+        if (update.$push) {
+          for (const [key, value] of Object.entries(update.$push)) {
+            const current = result[key] || [];
+            if (typeof value === "object" && value !== null && "$each" in value) {
+              current.push(...value.$each);
+            } else {
+              current.push(value);
+            }
+            result[key] = current;
+          }
+        }
+        const hasOperators = Object.keys(update).some((k) => k.startsWith("$"));
+        if (!hasOperators) {
+          const id = result._id;
+          for (const key of Object.keys(result)) {
+            if (key !== "_id") delete result[key];
+          }
+          Object.assign(result, update);
+          result._id = id;
+        }
+        return result;
+      }
+      applyPipeline(documents, pipeline) {
+        let result = [...documents];
+        for (const stage of pipeline) {
+          const entry = Object.entries(stage)[0];
+          if (!entry) continue;
+          const [op, value] = entry;
+          switch (op) {
+            case "$match":
+              result = result.filter((doc) => this.matchDocument(doc, value));
+              break;
+            case "$project":
+              result = result.map((doc) => this.applyProjection(doc, value));
+              break;
+            case "$sort":
+              result = this.sortDocuments(result, value);
+              break;
+            case "$limit":
+              result = result.slice(0, value);
+              break;
+            case "$skip":
+              result = result.slice(value);
+              break;
+            case "$count":
+              result = [{ [value]: result.length }];
+              break;
+            case "$sample":
+              const size = value.size || 100;
+              result = this.shuffleArray(result).slice(0, size);
+              break;
+            case "$group":
+              result = this.groupDocuments(result, value);
+              break;
+          }
+        }
+        return result;
+      }
+      matchDocument(doc, query) {
+        for (const [key, value] of Object.entries(query)) {
+          if (key === "$and") {
+            if (!value.every((q) => this.matchDocument(doc, q))) {
+              return false;
+            }
+            continue;
+          }
+          if (key === "$or") {
+            if (!value.some((q) => this.matchDocument(doc, q))) {
+              return false;
+            }
+            continue;
+          }
+          const docValue = doc[key];
+          if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+            for (const [op, opValue] of Object.entries(value)) {
+              switch (op) {
+                case "$eq":
+                  if (docValue !== opValue) return false;
+                  break;
+                case "$ne":
+                  if (docValue === opValue) return false;
+                  break;
+                case "$gt":
+                  if (!(docValue > opValue)) return false;
+                  break;
+                case "$gte":
+                  if (!(docValue >= opValue)) return false;
+                  break;
+                case "$lt":
+                  if (!(docValue < opValue)) return false;
+                  break;
+                case "$lte":
+                  if (!(docValue <= opValue)) return false;
+                  break;
+                case "$in":
+                  if (!opValue.includes(docValue)) return false;
+                  break;
+                case "$exists":
+                  if (opValue && docValue === void 0 || !opValue && docValue !== void 0)
+                    return false;
+                  break;
+              }
+            }
+          } else {
+            if (docValue !== value) return false;
+          }
+        }
         return true;
+      }
+      sortDocuments(documents, sort) {
+        return [...documents].sort((a, b) => {
+          for (const [field, direction] of Object.entries(sort)) {
+            const aVal = a[field];
+            const bVal = b[field];
+            const dir = direction === -1 ? -1 : 1;
+            if (aVal === bVal) continue;
+            if (aVal === void 0 || aVal === null) return dir;
+            if (bVal === void 0 || bVal === null) return -dir;
+            if (aVal < bVal) return -dir;
+            if (aVal > bVal) return dir;
+          }
+          return 0;
+        });
+      }
+      shuffleArray(array) {
+        const result = [...array];
+        for (let i = result.length - 1; i > 0; i--) {
+          const j = Math.floor(Math.random() * (i + 1));
+          const temp = result[i];
+          result[i] = result[j];
+          result[j] = temp;
+        }
+        return result;
+      }
+      groupDocuments(documents, groupSpec) {
+        const groups = /* @__PURE__ */ new Map();
+        const idSpec = groupSpec._id;
+        for (const doc of documents) {
+          let groupKey;
+          if (idSpec === null) {
+            groupKey = "__all__";
+          } else if (typeof idSpec === "string" && idSpec.startsWith("$")) {
+            groupKey = JSON.stringify(doc[idSpec.slice(1)]);
+          } else {
+            groupKey = JSON.stringify(idSpec);
+          }
+          if (!groups.has(groupKey)) {
+            groups.set(groupKey, []);
+          }
+          groups.get(groupKey).push(doc);
+        }
+        const result = [];
+        for (const [key, docs] of groups) {
+          const grouped = { _id: key === "__all__" ? null : JSON.parse(key) };
+          for (const [field, spec] of Object.entries(groupSpec)) {
+            if (field === "_id") continue;
+            if (typeof spec === "object" && spec !== null) {
+              const [op, value] = Object.entries(spec)[0];
+              const fieldPath = typeof value === "string" && value.startsWith("$") ? value.slice(1) : null;
+              switch (op) {
+                case "$sum":
+                  if (value === 1) {
+                    grouped[field] = docs.length;
+                  } else if (fieldPath) {
+                    grouped[field] = docs.reduce((sum, doc) => sum + (doc[fieldPath] || 0), 0);
+                  }
+                  break;
+                case "$avg":
+                  if (fieldPath) {
+                    const values = docs.map((doc) => doc[fieldPath]).filter((v) => typeof v === "number");
+                    grouped[field] = values.length > 0 ? values.reduce((a, b) => a + b, 0) / values.length : null;
+                  }
+                  break;
+                case "$first":
+                  if (fieldPath && docs.length > 0) {
+                    const firstDoc = docs[0];
+                    if (firstDoc) {
+                      grouped[field] = firstDoc[fieldPath];
+                    }
+                  }
+                  break;
+                case "$last":
+                  if (fieldPath && docs.length > 0) {
+                    const lastDoc = docs[docs.length - 1];
+                    if (lastDoc) {
+                      grouped[field] = lastDoc[fieldPath];
+                    }
+                  }
+                  break;
+              }
+            }
+          }
+          result.push(grouped);
+        }
+        return result;
+      }
+      /**
+       * Close all database connections
+       */
+      close() {
+        for (const db of this.databases.values()) {
+          db.close();
+        }
+        this.databases.clear();
+        this.cursors.clear();
+      }
+    };
+  }
+});
+
+// src/wire/types.ts
+var OpCode, OpMsgFlags, DEFAULT_CAPABILITIES;
+var init_types = __esm({
+  "src/wire/types.ts"() {
+    OpCode = {
+      /** Standard message format for all operations (MongoDB 3.6+) */
+      OP_MSG: 2013,
+      /** Compressed message wrapper */
+      OP_COMPRESSED: 2012,
+      /** Legacy reply to client (removed in 5.1, but still used for backwards compat) */
+      OP_REPLY: 1,
+      /** Legacy query (deprecated, but still used for initial handshake) */
+      OP_QUERY: 2004,
+      /** Legacy get more (removed in 5.1) */
+      OP_GET_MORE: 2005,
+      /** Legacy kill cursors (removed in 5.1) */
+      OP_KILL_CURSORS: 2007
+    };
+    OpMsgFlags = {
+      /** Message ends with CRC-32C checksum */
+      CHECKSUM_PRESENT: 1 << 0,
+      /** More messages follow; don't respond until bit=0 */
+      MORE_TO_COME: 1 << 1,
+      /** Client accepts multiple replies (exhaust cursors) */
+      EXHAUST_ALLOWED: 1 << 16
+    };
+    DEFAULT_CAPABILITIES = {
+      maxBsonObjectSize: 16 * 1024 * 1024,
+      // 16 MiB
+      maxMessageSizeBytes: 48 * 1024 * 1024,
+      // 48 MiB
+      maxWriteBatchSize: 1e5,
+      minWireVersion: 0,
+      maxWireVersion: 17,
+      // MongoDB 6.0
+      logicalSessionTimeoutMinutes: 30,
+      readOnly: false
+    };
+  }
+});
+function parseHeader(buffer) {
+  if (buffer.length < HEADER_SIZE) {
+    throw new Error(`Buffer too small for header: ${buffer.length} < ${HEADER_SIZE}`);
+  }
+  return {
+    messageLength: buffer.readInt32LE(0),
+    requestID: buffer.readInt32LE(4),
+    responseTo: buffer.readInt32LE(8),
+    opCode: buffer.readInt32LE(12)
+  };
+}
+function parseCString(buffer, offset) {
+  let end = offset;
+  while (end < buffer.length && buffer[end] !== 0) {
+    end++;
+  }
+  const str = buffer.toString("utf8", offset, end);
+  return [str, end + 1];
+}
+function parseBSONDocument(buffer, offset) {
+  const length = buffer.readInt32LE(offset);
+  const doc = BSON.deserialize(buffer.subarray(offset, offset + length));
+  return [doc, offset + length];
+}
+function parseOpMsg(buffer) {
+  const header = parseHeader(buffer);
+  if (header.opCode !== OpCode.OP_MSG) {
+    throw new Error(`Expected OP_MSG (${OpCode.OP_MSG}), got ${header.opCode}`);
+  }
+  let offset = HEADER_SIZE;
+  const flagBits = buffer.readUInt32LE(offset);
+  offset += 4;
+  const hasChecksum = (flagBits & OpMsgFlags.CHECKSUM_PRESENT) !== 0;
+  const messageEnd = hasChecksum ? buffer.length - 4 : buffer.length;
+  const sections = [];
+  while (offset < messageEnd) {
+    const kind = buffer.readUInt8(offset);
+    offset += 1;
+    if (kind === 0) {
+      const [body, newOffset] = parseBSONDocument(buffer, offset);
+      sections.push({ kind: 0, body });
+      offset = newOffset;
+    } else if (kind === 1) {
+      const sectionSize = buffer.readInt32LE(offset);
+      const sectionEnd = offset + sectionSize;
+      offset += 4;
+      const [identifier, docStart] = parseCString(buffer, offset);
+      offset = docStart;
+      const documents = [];
+      while (offset < sectionEnd) {
+        const [doc, newOffset] = parseBSONDocument(buffer, offset);
+        documents.push(doc);
+        offset = newOffset;
+      }
+      sections.push({ kind: 1, identifier, documents });
+    } else {
+      throw new Error(`Unknown section kind: ${kind}`);
+    }
+  }
+  if (hasChecksum) {
+    return { header, flagBits, sections, checksum: buffer.readUInt32LE(messageEnd) };
+  }
+  return { header, flagBits, sections };
+}
+function parseOpQuery(buffer) {
+  const header = parseHeader(buffer);
+  if (header.opCode !== OpCode.OP_QUERY) {
+    throw new Error(`Expected OP_QUERY (${OpCode.OP_QUERY}), got ${header.opCode}`);
+  }
+  let offset = HEADER_SIZE;
+  const flags = buffer.readInt32LE(offset);
+  offset += 4;
+  const [fullCollectionName, afterName] = parseCString(buffer, offset);
+  offset = afterName;
+  const numberToSkip = buffer.readInt32LE(offset);
+  offset += 4;
+  const numberToReturn = buffer.readInt32LE(offset);
+  offset += 4;
+  const [query, afterQuery] = parseBSONDocument(buffer, offset);
+  offset = afterQuery;
+  if (offset < buffer.length) {
+    const [returnFieldsSelector] = parseBSONDocument(buffer, offset);
+    return {
+      header,
+      flags,
+      fullCollectionName,
+      numberToSkip,
+      numberToReturn,
+      query,
+      returnFieldsSelector
+    };
+  }
+  return {
+    header,
+    flags,
+    fullCollectionName,
+    numberToSkip,
+    numberToReturn,
+    query
+  };
+}
+function serializeOpMsg(requestID, responseTo, body, additionalSections) {
+  const bodyBson = Buffer.from(BSON.serialize(body));
+  let sectionsSize = 1 + bodyBson.length;
+  const serializedSections = [];
+  const messageLength = HEADER_SIZE + 4 + sectionsSize;
+  const buffer = Buffer.allocUnsafe(messageLength);
+  let offset = 0;
+  buffer.writeInt32LE(messageLength, offset);
+  offset += 4;
+  buffer.writeInt32LE(requestID, offset);
+  offset += 4;
+  buffer.writeInt32LE(responseTo, offset);
+  offset += 4;
+  buffer.writeInt32LE(OpCode.OP_MSG, offset);
+  offset += 4;
+  buffer.writeUInt32LE(0, offset);
+  offset += 4;
+  buffer.writeUInt8(0, offset);
+  offset += 1;
+  bodyBson.copy(buffer, offset);
+  offset += bodyBson.length;
+  for (const sectionBuf of serializedSections) {
+    sectionBuf.copy(buffer, offset);
+    offset += sectionBuf.length;
+  }
+  return buffer;
+}
+function serializeOpReply(requestID, responseTo, documents, cursorID = 0n, responseFlags = 0) {
+  const docBuffers = documents.map((doc) => Buffer.from(BSON.serialize(doc)));
+  const docsSize = docBuffers.reduce((sum, buf) => sum + buf.length, 0);
+  const messageLength = HEADER_SIZE + 20 + docsSize;
+  const buffer = Buffer.allocUnsafe(messageLength);
+  let offset = 0;
+  buffer.writeInt32LE(messageLength, offset);
+  offset += 4;
+  buffer.writeInt32LE(requestID, offset);
+  offset += 4;
+  buffer.writeInt32LE(responseTo, offset);
+  offset += 4;
+  buffer.writeInt32LE(OpCode.OP_REPLY, offset);
+  offset += 4;
+  buffer.writeInt32LE(responseFlags, offset);
+  offset += 4;
+  buffer.writeBigInt64LE(cursorID, offset);
+  offset += 8;
+  buffer.writeInt32LE(0, offset);
+  offset += 4;
+  buffer.writeInt32LE(documents.length, offset);
+  offset += 4;
+  for (const docBuf of docBuffers) {
+    docBuf.copy(buffer, offset);
+    offset += docBuf.length;
+  }
+  return buffer;
+}
+function parseMessage(buffer) {
+  const header = parseHeader(buffer);
+  switch (header.opCode) {
+    case OpCode.OP_MSG:
+      return parseOpMsg(buffer);
+    case OpCode.OP_QUERY:
+      return parseOpQuery(buffer);
+    default:
+      throw new Error(`Unsupported opcode: ${header.opCode}`);
+  }
+}
+function extractCommand(message) {
+  if ("sections" in message) {
+    const section0 = message.sections.find((s) => s.kind === 0);
+    if (!section0) {
+      throw new Error("OP_MSG missing section 0 (body)");
+    }
+    const command = section0.body;
+    const db = command.$db;
+    if (!db) {
+      throw new Error("OP_MSG command missing $db field");
+    }
+    const documentSequences = /* @__PURE__ */ new Map();
+    for (const section of message.sections) {
+      if (section.kind === 1) {
+        documentSequences.set(section.identifier, section.documents);
+      }
     }
-    // Check if running in a TTY
-    return process.stdout.isTTY ?? false;
+    return { db, command, documentSequences };
+  } else {
+    const parts = message.fullCollectionName.split(".");
+    const db = parts[0] || "admin";
+    const command = message.query;
+    return { db, command, documentSequences: /* @__PURE__ */ new Map() };
+  }
+}
+var HEADER_SIZE;
+var init_message = __esm({
+  "src/wire/message.ts"() {
+    init_types();
+    HEADER_SIZE = 16;
+  }
+});
+
+// src/types/rpc.ts
+function getErrorCodeName(code) {
+  for (const [name, value] of Object.entries(ErrorCode)) {
+    if (value === code) {
+      return name.split("_").map((word) => word.charAt(0) + word.slice(1).toLowerCase()).join("");
+    }
+  }
+  return "UnknownError";
+}
+function successResponse(data = {}) {
+  return { ok: 1, ...data };
 }
-const useColors = supportsColor();
-/**
- * Apply color to text if colors are supported
- */
+function errorResponse(code, errmsg, codeName) {
+  return {
+    ok: 0,
+    code,
+    codeName: codeName || getErrorCodeName(code),
+    errmsg
+  };
+}
+var ErrorCode;
+var init_rpc = __esm({
+  "src/types/rpc.ts"() {
+    ErrorCode = {
+      OK: 0,
+      INTERNAL_ERROR: 1,
+      BAD_VALUE: 2,
+      NO_SUCH_KEY: 4,
+      GRAPH_CONTAINS_CYCLE: 5,
+      HOST_UNREACHABLE: 6,
+      HOST_NOT_FOUND: 7,
+      UNKNOWN_ERROR: 8,
+      FAILED_TO_PARSE: 9,
+      CANNOT_MUTATE_OBJECT: 10,
+      USER_NOT_FOUND: 11,
+      UNSUPPORTED_FORMAT: 12,
+      UNAUTHORIZED: 13,
+      TYPE_MISMATCH: 14,
+      OVERFLOW: 15,
+      INVALID_LENGTH: 16,
+      PROTOCOL_ERROR: 17,
+      AUTHENTICATION_FAILED: 18,
+      CANNOT_REUSE_OBJECT: 19,
+      ILLEGAL_OPERATION: 20,
+      EMPTY_ARRAY_OPERATION: 21,
+      INVALID_BSON: 22,
+      ALREADY_INITIALIZED: 23,
+      LOCK_TIMEOUT: 24,
+      REMOTE_VALIDATION_ERROR: 25,
+      NAMESPACE_NOT_FOUND: 26,
+      INDEX_NOT_FOUND: 27,
+      PATH_NOT_VIABLE: 28,
+      NON_EXISTENT_PATH: 29,
+      INVALID_PATH: 30,
+      ROLE_NOT_FOUND: 31,
+      ROLES_NOT_RELATED: 32,
+      PRIVILEGE_NOT_FOUND: 33,
+      CANNOT_BACKFILL_ARRAY: 34,
+      COMMAND_NOT_FOUND: 59,
+      DATABASE_NOT_FOUND: 60,
+      LOCATION_ERROR: 16755,
+      DUPLICATE_KEY: 11e3
+    };
+  }
+});
+
+// src/wire/commands/types.ts
+function successResponse2(data = {}) {
+  return successResponse(data);
+}
+function errorResponse2(code, errmsg, codeName) {
+  return errorResponse(code, errmsg, codeName);
+}
+var init_types2 = __esm({
+  "src/wire/commands/types.ts"() {
+    init_rpc();
+  }
+});
+var HelloCommand, PingCommand, BuildInfoCommand, HostInfoCommand, WhatsmyuriCommand, GetLogCommand, GetParameterCommand, GetCmdLineOptsCommand;
+var init_hello = __esm({
+  "src/wire/commands/hello.ts"() {
+    init_types2();
+    init_types();
+    HelloCommand = class {
+      processId = new ObjectId();
+      counter = 0n;
+      async execute(command, context) {
+        const now = /* @__PURE__ */ new Date();
+        const response = {
+          // Primary fields
+          ismaster: true,
+          isWritablePrimary: true,
+          // Topology version (changes when server state changes)
+          topologyVersion: {
+            processId: this.processId,
+            counter: Long.fromBigInt(this.counter++)
+          },
+          // Size limits
+          maxBsonObjectSize: DEFAULT_CAPABILITIES.maxBsonObjectSize,
+          maxMessageSizeBytes: DEFAULT_CAPABILITIES.maxMessageSizeBytes,
+          maxWriteBatchSize: DEFAULT_CAPABILITIES.maxWriteBatchSize,
+          // Time
+          localTime: now,
+          // Session support
+          logicalSessionTimeoutMinutes: DEFAULT_CAPABILITIES.logicalSessionTimeoutMinutes,
+          // Connection info
+          connectionId: context.connectionId,
+          // Wire version (MongoDB 6.0 = 17)
+          minWireVersion: DEFAULT_CAPABILITIES.minWireVersion,
+          maxWireVersion: DEFAULT_CAPABILITIES.maxWireVersion,
+          // Not read-only
+          readOnly: DEFAULT_CAPABILITIES.readOnly,
+          // Success
+          ok: 1
+        };
+        if (command.hello || command.helloOk) {
+          response.helloOk = true;
+        }
+        if (command.saslSupportedMechs) {
+          response.saslSupportedMechs = ["SCRAM-SHA-256", "SCRAM-SHA-1"];
+        }
+        if (command.compression && Array.isArray(command.compression)) {
+          response.compression = [];
+        }
+        if (command.client) ;
+        return { response };
+      }
+    };
+    PingCommand = class {
+      async execute(_command, _context) {
+        return { response: successResponse2() };
+      }
+    };
+    BuildInfoCommand = class {
+      async execute(_command, _context) {
+        const response = successResponse2({
+          version: "6.0.0-mongo.do",
+          gitVersion: "mongo.do-0.1.0",
+          modules: [],
+          allocator: "system",
+          javascriptEngine: "none",
+          sysInfo: "mongo.do-on-workers",
+          versionArray: [6, 0, 0, 0],
+          openssl: {
+            running: "not-applicable",
+            compiled: "not-applicable"
+          },
+          buildEnvironment: {
+            target_os: "cloudflare-workers",
+            target_arch: "wasm"
+          },
+          bits: 64,
+          debug: false,
+          maxBsonObjectSize: DEFAULT_CAPABILITIES.maxBsonObjectSize,
+          storageEngines: ["sqlite"]
+        });
+        return { response };
+      }
+    };
+    HostInfoCommand = class {
+      async execute(_command, _context) {
+        const now = /* @__PURE__ */ new Date();
+        const response = successResponse2({
+          system: {
+            currentTime: now,
+            hostname: "mongo.do-server",
+            cpuAddrSize: 64,
+            memSizeMB: 512,
+            memLimitMB: 512,
+            numCores: 1,
+            cpuArch: "wasm",
+            numaEnabled: false
+          },
+          os: {
+            type: "cloudflare-workers",
+            name: "MondoDB",
+            version: "0.1.0"
+          },
+          extra: {
+            note: "Running on Cloudflare Workers Durable Objects"
+          }
+        });
+        return { response };
+      }
+    };
+    WhatsmyuriCommand = class {
+      async execute(_command, _context) {
+        return {
+          response: successResponse2({
+            you: "127.0.0.1:0"
+          })
+        };
+      }
+    };
+    GetLogCommand = class {
+      async execute(command, _context) {
+        const logType = command.getLog;
+        if (logType === "*") {
+          return {
+            response: successResponse2({
+              names: ["global", "startupWarnings"]
+            })
+          };
+        }
+        if (logType === "startupWarnings") {
+          return {
+            response: successResponse2({
+              totalLinesWritten: 1,
+              log: [
+                JSON.stringify({
+                  t: { $date: (/* @__PURE__ */ new Date()).toISOString() },
+                  s: "I",
+                  c: "STORAGE",
+                  msg: "MondoDB using SQLite storage engine"
+                })
+              ]
+            })
+          };
+        }
+        return {
+          response: successResponse2({
+            totalLinesWritten: 0,
+            log: []
+          })
+        };
+      }
+    };
+    GetParameterCommand = class {
+      async execute(command, _context) {
+        const param = command.getParameter;
+        const parameters = {
+          featureCompatibilityVersion: { version: "6.0" },
+          authenticationMechanisms: ["SCRAM-SHA-256", "SCRAM-SHA-1"]
+        };
+        if (param === "*") {
+          return { response: successResponse2(parameters) };
+        }
+        if (typeof param === "string" && param in parameters) {
+          return {
+            response: successResponse2({
+              [param]: parameters[param]
+            })
+          };
+        }
+        return { response: successResponse2({}) };
+      }
+    };
+    GetCmdLineOptsCommand = class {
+      async execute(_command, _context) {
+        return {
+          response: successResponse2({
+            argv: ["mongo.do-server"],
+            parsed: {
+              storage: {
+                engine: "sqlite"
+              }
+            }
+          })
+        };
+      }
+    };
+  }
+});
+
+// src/wire/commands/admin.ts
+var ListDatabasesCommand, ListCollectionsCommand, CreateCommand, DropCommand, DropDatabaseCommand, CollStatsCommand, DbStatsCommand, ServerStatusCommand;
+var init_admin = __esm({
+  "src/wire/commands/admin.ts"() {
+    init_types2();
+    ListDatabasesCommand = class {
+      constructor(backend) {
+        this.backend = backend;
+      }
+      async execute(command, _context) {
+        const databases = await this.backend.listDatabases();
+        const nameOnly = command.nameOnly === true;
+        let filteredDbs = databases;
+        if (command.filter && typeof command.filter === "object") {
+          const filter = command.filter;
+          if (filter.name) {
+            if (typeof filter.name === "string") {
+              filteredDbs = databases.filter((db) => db.name === filter.name);
+            } else if (filter.name.$regex) {
+              const regex = new RegExp(filter.name.$regex, filter.name.$options);
+              filteredDbs = databases.filter((db) => regex.test(db.name));
+            }
+          }
+        }
+        const totalSize = filteredDbs.reduce((sum, db) => sum + db.sizeOnDisk, 0);
+        if (nameOnly) {
+          return {
+            response: successResponse2({
+              databases: filteredDbs.map((db) => ({ name: db.name }))
+            })
+          };
+        }
+        return {
+          response: successResponse2({
+            databases: filteredDbs,
+            totalSize,
+            totalSizeMb: totalSize / (1024 * 1024)
+          })
+        };
+      }
+    };
+    ListCollectionsCommand = class {
+      constructor(backend) {
+        this.backend = backend;
+      }
+      async execute(command, context) {
+        const db = context.db;
+        const filter = command.filter;
+        const nameOnly = command.nameOnly === true;
+        const collections = await this.backend.listCollections(db, filter);
+        if (nameOnly) {
+          return {
+            response: successResponse2({
+              cursor: {
+                id: 0n,
+                ns: `${db}.$cmd.listCollections`,
+                firstBatch: collections.map((c) => ({ name: c.name, type: c.type }))
+              }
+            })
+          };
+        }
+        return {
+          response: successResponse2({
+            cursor: {
+              id: 0n,
+              ns: `${db}.$cmd.listCollections`,
+              firstBatch: collections
+            }
+          })
+        };
+      }
+    };
+    CreateCommand = class {
+      constructor(backend) {
+        this.backend = backend;
+      }
+      async execute(command, context) {
+        const collectionName = command.create;
+        if (!collectionName || typeof collectionName !== "string") {
+          return {
+            response: errorResponse2(ErrorCode.BAD_VALUE, "create requires a string collection name")
+          };
+        }
+        const options = {};
+        if (command.capped) options.capped = command.capped;
+        if (command.size) options.size = command.size;
+        if (command.max) options.max = command.max;
+        if (command.validator) options.validator = command.validator;
+        if (command.validationLevel) options.validationLevel = command.validationLevel;
+        if (command.validationAction) options.validationAction = command.validationAction;
+        await this.backend.createCollection(context.db, collectionName, options);
+        return { response: successResponse2() };
+      }
+    };
+    DropCommand = class {
+      constructor(backend) {
+        this.backend = backend;
+      }
+      async execute(command, context) {
+        const collectionName = command.drop;
+        if (!collectionName || typeof collectionName !== "string") {
+          return {
+            response: errorResponse2(ErrorCode.BAD_VALUE, "drop requires a string collection name")
+          };
+        }
+        const exists = await this.backend.collectionExists(context.db, collectionName);
+        if (!exists) {
+          return {
+            response: errorResponse2(
+              ErrorCode.NAMESPACE_NOT_FOUND,
+              `ns not found: ${context.db}.${collectionName}`
+            )
+          };
+        }
+        await this.backend.dropCollection(context.db, collectionName);
+        return {
+          response: successResponse2({
+            nIndexesWas: 1,
+            ns: `${context.db}.${collectionName}`
+          })
+        };
+      }
+    };
+    DropDatabaseCommand = class {
+      constructor(backend) {
+        this.backend = backend;
+      }
+      async execute(_command, context) {
+        await this.backend.dropDatabase(context.db);
+        return {
+          response: successResponse2({
+            dropped: context.db
+          })
+        };
+      }
+    };
+    CollStatsCommand = class {
+      constructor(backend) {
+        this.backend = backend;
+      }
+      async execute(command, context) {
+        const collectionName = command.collStats;
+        if (!collectionName || typeof collectionName !== "string") {
+          return {
+            response: errorResponse2(ErrorCode.BAD_VALUE, "collStats requires a collection name")
+          };
+        }
+        const exists = await this.backend.collectionExists(context.db, collectionName);
+        if (!exists) {
+          return {
+            response: errorResponse2(
+              ErrorCode.NAMESPACE_NOT_FOUND,
+              `Collection [${context.db}.${collectionName}] not found`
+            )
+          };
+        }
+        const stats = await this.backend.collStats(context.db, collectionName);
+        return {
+          response: successResponse2({
+            ...stats,
+            wiredTiger: {},
+            // Empty for SQLite
+            indexDetails: {},
+            scaleFactor: 1
+          })
+        };
+      }
+    };
+    DbStatsCommand = class {
+      constructor(backend) {
+        this.backend = backend;
+      }
+      async execute(command, context) {
+        const scale = typeof command.scale === "number" ? command.scale : 1;
+        const stats = await this.backend.dbStats(context.db);
+        return {
+          response: successResponse2({
+            db: stats.db,
+            collections: stats.collections,
+            views: stats.views,
+            objects: stats.objects,
+            avgObjSize: stats.avgObjSize,
+            dataSize: stats.dataSize / scale,
+            storageSize: stats.storageSize / scale,
+            indexes: stats.indexes,
+            indexSize: stats.indexSize / scale,
+            totalSize: (stats.dataSize + stats.indexSize) / scale,
+            scaleFactor: scale,
+            fsUsedSize: stats.storageSize / scale,
+            fsTotalSize: stats.storageSize * 10 / scale
+            // Estimate
+          })
+        };
+      }
+    };
+    ServerStatusCommand = class {
+      startTime = /* @__PURE__ */ new Date();
+      constructor(_backend) {
+      }
+      async execute(_command, _context) {
+        const now = /* @__PURE__ */ new Date();
+        const uptimeSeconds = Math.floor((now.getTime() - this.startTime.getTime()) / 1e3);
+        return {
+          response: successResponse2({
+            host: "mongo.do-server",
+            version: "6.0.0-mongo.do",
+            process: "mongo.do-server",
+            pid: process.pid || 1,
+            uptime: uptimeSeconds,
+            uptimeMillis: uptimeSeconds * 1e3,
+            uptimeEstimate: uptimeSeconds,
+            localTime: now,
+            connections: {
+              current: 1,
+              available: 100,
+              totalCreated: 1,
+              active: 1
+            },
+            opcounters: {
+              insert: 0,
+              query: 0,
+              update: 0,
+              delete: 0,
+              getmore: 0,
+              command: 0
+            },
+            mem: {
+              bits: 64,
+              resident: 50,
+              virtual: 100,
+              supported: true
+            },
+            storageEngine: {
+              name: "sqlite",
+              supportsCommittedReads: true,
+              oldestRequiredTimestampForCrashRecovery: null,
+              supportsPendingDrops: false,
+              dropPendingIdents: 0,
+              supportsSnapshotReadConcern: true,
+              readOnly: false,
+              persistent: true,
+              backupCursorOpen: false
+            },
+            asserts: {
+              regular: 0,
+              warning: 0,
+              msg: 0,
+              user: 0,
+              tripwire: 0,
+              rollovers: 0
+            },
+            network: {
+              bytesIn: 0,
+              bytesOut: 0,
+              numRequests: 0
+            }
+          })
+        };
+      }
+    };
+  }
+});
+var FindCommand, InsertCommand, UpdateCommand, DeleteCommand, CountCommand, DistinctCommand, GetMoreCommand, KillCursorsCommand;
+var init_crud = __esm({
+  "src/wire/commands/crud.ts"() {
+    init_types2();
+    FindCommand = class {
+      constructor(backend) {
+        this.backend = backend;
+      }
+      async execute(command, context) {
+        const collection = command.find;
+        if (!collection || typeof collection !== "string") {
+          return {
+            response: errorResponse2(ErrorCode.BAD_VALUE, "find requires a collection name")
+          };
+        }
+        const options = {
+          filter: command.filter,
+          projection: command.projection,
+          sort: command.sort,
+          limit: command.limit,
+          skip: command.skip,
+          batchSize: command.batchSize || 101,
+          hint: command.hint,
+          collation: command.collation,
+          allowDiskUse: command.allowDiskUse
+        };
+        if (command.singleBatch === true) {
+          options.batchSize = options.limit || 1e6;
+        }
+        const result = await this.backend.find(context.db, collection, options);
+        return {
+          response: successResponse2({
+            cursor: {
+              id: Long.fromBigInt(result.cursorId),
+              ns: `${context.db}.${collection}`,
+              firstBatch: result.documents
+            }
+          })
+        };
+      }
+    };
+    InsertCommand = class {
+      constructor(backend) {
+        this.backend = backend;
+      }
+      async execute(command, context) {
+        const collection = command.insert;
+        if (!collection || typeof collection !== "string") {
+          return {
+            response: errorResponse2(ErrorCode.BAD_VALUE, "insert requires a collection name")
+          };
+        }
+        let documents = command.documents;
+        if (!documents && context.documentSequences.has("documents")) {
+          documents = context.documentSequences.get("documents");
+        }
+        if (!documents || !Array.isArray(documents) || documents.length === 0) {
+          return {
+            response: errorResponse2(ErrorCode.BAD_VALUE, "insert requires documents array")
+          };
+        }
+        const ordered = command.ordered !== false;
+        try {
+          const result = await this.backend.insertMany(context.db, collection, documents);
+          return {
+            response: successResponse2({
+              n: result.insertedCount
+            })
+          };
+        } catch (error) {
+          if (ordered) {
+            return {
+              response: errorResponse2(
+                ErrorCode.INTERNAL_ERROR,
+                error instanceof Error ? error.message : "Insert failed"
+              )
+            };
+          }
+          throw error;
+        }
+      }
+    };
+    UpdateCommand = class {
+      constructor(backend) {
+        this.backend = backend;
+      }
+      async execute(command, context) {
+        const collection = command.update;
+        if (!collection || typeof collection !== "string") {
+          return {
+            response: errorResponse2(ErrorCode.BAD_VALUE, "update requires a collection name")
+          };
+        }
+        let updates = command.updates;
+        if (!updates && context.documentSequences.has("updates")) {
+          updates = context.documentSequences.get("updates");
+        }
+        if (!updates || !Array.isArray(updates) || updates.length === 0) {
+          return {
+            response: errorResponse2(ErrorCode.BAD_VALUE, "update requires updates array")
+          };
+        }
+        let totalMatched = 0;
+        let totalModified = 0;
+        let upserted = [];
+        for (let i = 0; i < updates.length; i++) {
+          const op = updates[i];
+          const filter = op?.q;
+          const update = op?.u;
+          const multi = op?.multi === true;
+          const upsert = op?.upsert === true;
+          const arrayFilters = op?.arrayFilters;
+          const result = multi ? await this.backend.updateMany(context.db, collection, filter, update, {
+            upsert,
+            arrayFilters
+          }) : await this.backend.updateOne(context.db, collection, filter, update, {
+            upsert,
+            arrayFilters
+          });
+          totalMatched += result.matchedCount;
+          totalModified += result.modifiedCount;
+          if (result.upsertedId !== void 0) {
+            upserted.push({ index: i, _id: result.upsertedId });
+          }
+        }
+        const response = {
+          n: totalMatched,
+          nModified: totalModified,
+          ok: 1
+        };
+        if (upserted.length > 0) {
+          response.upserted = upserted;
+        }
+        return { response };
+      }
+    };
+    DeleteCommand = class {
+      constructor(backend) {
+        this.backend = backend;
+      }
+      async execute(command, context) {
+        const collection = command.delete;
+        if (!collection || typeof collection !== "string") {
+          return {
+            response: errorResponse2(ErrorCode.BAD_VALUE, "delete requires a collection name")
+          };
+        }
+        let deletes = command.deletes;
+        if (!deletes && context.documentSequences.has("deletes")) {
+          deletes = context.documentSequences.get("deletes");
+        }
+        if (!deletes || !Array.isArray(deletes) || deletes.length === 0) {
+          return {
+            response: errorResponse2(ErrorCode.BAD_VALUE, "delete requires deletes array")
+          };
+        }
+        let totalDeleted = 0;
+        for (const op of deletes) {
+          const filter = op.q;
+          const limit = op.limit;
+          const result = limit === 0 || limit === void 0 ? await this.backend.deleteMany(context.db, collection, filter) : await this.backend.deleteOne(context.db, collection, filter);
+          totalDeleted += result.deletedCount;
+        }
+        return {
+          response: successResponse2({
+            n: totalDeleted
+          })
+        };
+      }
+    };
+    CountCommand = class {
+      constructor(backend) {
+        this.backend = backend;
+      }
+      async execute(command, context) {
+        const collection = command.count;
+        if (!collection || typeof collection !== "string") {
+          return {
+            response: errorResponse2(ErrorCode.BAD_VALUE, "count requires a collection name")
+          };
+        }
+        const query = command.query;
+        const count = await this.backend.count(context.db, collection, query);
+        let adjustedCount = count;
+        if (command.skip && typeof command.skip === "number") {
+          adjustedCount = Math.max(0, adjustedCount - command.skip);
+        }
+        if (command.limit && typeof command.limit === "number" && command.limit > 0) {
+          adjustedCount = Math.min(adjustedCount, command.limit);
+        }
+        return {
+          response: successResponse2({
+            n: adjustedCount
+          })
+        };
+      }
+    };
+    DistinctCommand = class {
+      constructor(backend) {
+        this.backend = backend;
+      }
+      async execute(command, context) {
+        const collection = command.distinct;
+        if (!collection || typeof collection !== "string") {
+          return {
+            response: errorResponse2(ErrorCode.BAD_VALUE, "distinct requires a collection name")
+          };
+        }
+        const key = command.key;
+        if (!key || typeof key !== "string") {
+          return {
+            response: errorResponse2(ErrorCode.BAD_VALUE, "distinct requires a key field")
+          };
+        }
+        const query = command.query;
+        const values = await this.backend.distinct(context.db, collection, key, query);
+        return {
+          response: successResponse2({
+            values
+          })
+        };
+      }
+    };
+    GetMoreCommand = class {
+      constructor(backend) {
+        this.backend = backend;
+      }
+      async execute(command, context) {
+        const cursorId = command.getMore;
+        const collection = command.collection;
+        const batchSize = command.batchSize || 101;
+        if (cursorId === void 0) {
+          return {
+            response: errorResponse2(ErrorCode.BAD_VALUE, "getMore requires a cursor id")
+          };
+        }
+        let cursorBigInt;
+        if (typeof cursorId === "bigint") {
+          cursorBigInt = cursorId;
+        } else if (cursorId instanceof Long) {
+          cursorBigInt = cursorId.toBigInt();
+        } else {
+          cursorBigInt = BigInt(cursorId);
+        }
+        const cursor = this.backend.getCursor(cursorBigInt);
+        if (!cursor) {
+          return {
+            response: errorResponse2(
+              ErrorCode.NAMESPACE_NOT_FOUND,
+              `cursor id ${cursorId} not found`
+            )
+          };
+        }
+        const documents = this.backend.advanceCursor(cursorBigInt, batchSize);
+        const updatedCursor = this.backend.getCursor(cursorBigInt);
+        const hasMore = updatedCursor ? updatedCursor.position < updatedCursor.documents.length : false;
+        if (!hasMore) {
+          this.backend.closeCursor(cursorBigInt);
+        }
+        return {
+          response: successResponse2({
+            cursor: {
+              id: hasMore ? Long.fromBigInt(cursorBigInt) : Long.ZERO,
+              ns: `${context.db}.${collection}`,
+              nextBatch: documents
+            }
+          })
+        };
+      }
+    };
+    KillCursorsCommand = class {
+      constructor(backend) {
+        this.backend = backend;
+      }
+      async execute(command, _context) {
+        const cursors = command.cursors;
+        if (!cursors || !Array.isArray(cursors)) {
+          return {
+            response: errorResponse2(ErrorCode.BAD_VALUE, "killCursors requires cursors array")
+          };
+        }
+        const cursorsKilled = [];
+        const cursorsNotFound = [];
+        const cursorsAlive = [];
+        const cursorsUnknown = [];
+        for (const cursorId of cursors) {
+          let cursorBigInt;
+          if (typeof cursorId === "bigint") {
+            cursorBigInt = cursorId;
+          } else if (cursorId instanceof Long) {
+            cursorBigInt = cursorId.toBigInt();
+          } else {
+            cursorBigInt = BigInt(cursorId);
+          }
+          const killed = this.backend.closeCursor(cursorBigInt);
+          const longId = Long.fromBigInt(cursorBigInt);
+          if (killed) {
+            cursorsKilled.push(longId);
+          } else {
+            cursorsNotFound.push(longId);
+          }
+        }
+        return {
+          response: successResponse2({
+            cursorsKilled,
+            cursorsNotFound,
+            cursorsAlive,
+            cursorsUnknown
+          })
+        };
+      }
+    };
+  }
+});
+var AggregateCommand;
+var init_aggregate = __esm({
+  "src/wire/commands/aggregate.ts"() {
+    init_types2();
+    AggregateCommand = class {
+      constructor(backend) {
+        this.backend = backend;
+      }
+      async execute(command, context) {
+        const collection = command.aggregate;
+        if (!collection || typeof collection !== "string") {
+          return {
+            response: errorResponse2(ErrorCode.BAD_VALUE, "aggregate requires a collection name")
+          };
+        }
+        const pipeline = command.pipeline;
+        if (!pipeline || !Array.isArray(pipeline)) {
+          return {
+            response: errorResponse2(ErrorCode.BAD_VALUE, "aggregate requires a pipeline array")
+          };
+        }
+        if (collection === "1" || collection === 1) {
+          return this.handleDatabaseAggregation(pipeline, context);
+        }
+        const batchSize = command.cursor?.batchSize || 101;
+        const allowDiskUse = command.allowDiskUse;
+        const lastStage = pipeline[pipeline.length - 1];
+        const hasOutputStage = lastStage && ("$out" in lastStage || "$merge" in lastStage);
+        try {
+          const result = await this.backend.aggregate(context.db, collection, pipeline, {
+            batchSize,
+            allowDiskUse
+          });
+          if (hasOutputStage) {
+            return {
+              response: successResponse2()
+            };
+          }
+          return {
+            response: successResponse2({
+              cursor: {
+                id: Long.fromBigInt(result.cursorId),
+                ns: `${context.db}.${collection}`,
+                firstBatch: result.documents
+              }
+            })
+          };
+        } catch (error) {
+          return {
+            response: errorResponse2(
+              ErrorCode.INTERNAL_ERROR,
+              error instanceof Error ? error.message : "Aggregation failed"
+            )
+          };
+        }
+      }
+      async handleDatabaseAggregation(pipeline, context) {
+        const firstStage = pipeline[0];
+        if (firstStage && "$listLocalSessions" in firstStage) {
+          return {
+            response: successResponse2({
+              cursor: {
+                id: Long.ZERO,
+                ns: `${context.db}.$cmd.aggregate`,
+                firstBatch: []
+              }
+            })
+          };
+        }
+        if (firstStage && "$currentOp" in firstStage) {
+          return {
+            response: successResponse2({
+              cursor: {
+                id: Long.ZERO,
+                ns: `${context.db}.$cmd.aggregate`,
+                firstBatch: []
+              }
+            })
+          };
+        }
+        return {
+          response: errorResponse2(
+            ErrorCode.COMMAND_NOT_FOUND,
+            "Database-level aggregation not supported"
+          )
+        };
+      }
+    };
+  }
+});
+var ListIndexesCommand, CreateIndexesCommand, DropIndexesCommand;
+var init_commands = __esm({
+  "src/wire/commands/index.ts"() {
+    init_types2();
+    ListIndexesCommand = class {
+      constructor(backend) {
+        this.backend = backend;
+      }
+      async execute(command, context) {
+        const collection = command.listIndexes;
+        if (!collection || typeof collection !== "string") {
+          return {
+            response: errorResponse2(ErrorCode.BAD_VALUE, "listIndexes requires a collection name")
+          };
+        }
+        const exists = await this.backend.collectionExists(context.db, collection);
+        if (!exists) {
+          return {
+            response: errorResponse2(
+              ErrorCode.NAMESPACE_NOT_FOUND,
+              `ns not found: ${context.db}.${collection}`
+            )
+          };
+        }
+        const indexes = await this.backend.listIndexes(context.db, collection);
+        return {
+          response: successResponse2({
+            cursor: {
+              id: Long.ZERO,
+              ns: `${context.db}.${collection}`,
+              firstBatch: indexes
+            }
+          })
+        };
+      }
+    };
+    CreateIndexesCommand = class {
+      constructor(backend) {
+        this.backend = backend;
+      }
+      async execute(command, context) {
+        const collection = command.createIndexes;
+        if (!collection || typeof collection !== "string") {
+          return {
+            response: errorResponse2(ErrorCode.BAD_VALUE, "createIndexes requires a collection name")
+          };
+        }
+        const indexes = command.indexes;
+        if (!indexes || !Array.isArray(indexes) || indexes.length === 0) {
+          return {
+            response: errorResponse2(ErrorCode.BAD_VALUE, "createIndexes requires indexes array")
+          };
+        }
+        const indexSpecs = indexes.map((idx) => ({
+          key: idx.key,
+          name: idx.name,
+          unique: idx.unique,
+          sparse: idx.sparse,
+          background: idx.background,
+          expireAfterSeconds: idx.expireAfterSeconds,
+          partialFilterExpression: idx.partialFilterExpression
+        }));
+        let existingIndexes = [];
+        try {
+          const existing = await this.backend.listIndexes(context.db, collection);
+          existingIndexes = existing.map((idx) => idx.name);
+        } catch {
+        }
+        const createdNames = await this.backend.createIndexes(context.db, collection, indexSpecs);
+        const numIndexesBefore = existingIndexes.length;
+        const numIndexesAfter = numIndexesBefore + createdNames.length;
+        return {
+          response: successResponse2({
+            numIndexesBefore,
+            numIndexesAfter,
+            createdCollectionAutomatically: false,
+            note: createdNames.length > 0 ? void 0 : "all indexes already exist"
+          })
+        };
+      }
+    };
+    DropIndexesCommand = class {
+      constructor(backend) {
+        this.backend = backend;
+      }
+      async execute(command, context) {
+        const collection = command.dropIndexes;
+        if (!collection || typeof collection !== "string") {
+          return {
+            response: errorResponse2(ErrorCode.BAD_VALUE, "dropIndexes requires a collection name")
+          };
+        }
+        const index = command.index;
+        if (index === "*") {
+          await this.backend.dropIndexes(context.db, collection);
+          return {
+            response: successResponse2({
+              msg: "non-_id indexes dropped"
+            })
+          };
+        }
+        if (typeof index === "string") {
+          if (index === "_id_") {
+            return {
+              response: errorResponse2(
+                ErrorCode.ILLEGAL_OPERATION,
+                "cannot drop _id index"
+              )
+            };
+          }
+          await this.backend.dropIndex(context.db, collection, index);
+          return {
+            response: successResponse2({
+              nIndexesWas: 1
+            })
+          };
+        }
+        if (Array.isArray(index)) {
+          for (const name of index) {
+            if (name === "_id_") continue;
+            await this.backend.dropIndex(context.db, collection, name);
+          }
+          return { response: successResponse2() };
+        }
+        if (typeof index === "object") {
+          return {
+            response: errorResponse2(
+              ErrorCode.BAD_VALUE,
+              "dropping index by key specification not yet supported"
+            )
+          };
+        }
+        return {
+          response: errorResponse2(ErrorCode.BAD_VALUE, "invalid index specification")
+        };
+      }
+    };
+  }
+});
+function requiresAuthentication(commandName) {
+  return !UNAUTHENTICATED_COMMANDS.has(commandName);
+}
+var SaslStartCommand, SaslContinueCommand, AuthenticateCommand, LogoutCommand, UNAUTHENTICATED_COMMANDS;
+var init_auth = __esm({
+  "src/wire/commands/auth.ts"() {
+    init_types2();
+    SaslStartCommand = class {
+      constructor(authenticator) {
+        this.authenticator = authenticator;
+      }
+      async execute(command, context) {
+        const mechanism = command.mechanism;
+        const payload = command.payload;
+        const options = command.options;
+        if (!mechanism) {
+          return {
+            response: errorResponse2(
+              ErrorCode.BAD_VALUE,
+              "saslStart requires mechanism field"
+            )
+          };
+        }
+        if (!payload) {
+          return {
+            response: errorResponse2(
+              ErrorCode.BAD_VALUE,
+              "saslStart requires payload field"
+            )
+          };
+        }
+        let authDb = context.db;
+        if (options?.authdb) {
+          authDb = options.authdb;
+        }
+        const result = await this.authenticator.saslStart(mechanism, payload, authDb);
+        if (!result.success) {
+          return {
+            response: errorResponse2(
+              ErrorCode.AUTHENTICATION_FAILED,
+              result.error || "Authentication failed"
+            )
+          };
+        }
+        return {
+          response: successResponse2({
+            conversationId: result.conversationId,
+            payload: new Binary(result.payload),
+            done: result.done
+          })
+        };
+      }
+    };
+    SaslContinueCommand = class {
+      constructor(authenticator) {
+        this.authenticator = authenticator;
+      }
+      async execute(command, context) {
+        const conversationId = command.conversationId;
+        const payload = command.payload;
+        if (conversationId === void 0 || conversationId === null) {
+          return {
+            response: errorResponse2(
+              ErrorCode.BAD_VALUE,
+              "saslContinue requires conversationId field"
+            )
+          };
+        }
+        if (!payload) {
+          return {
+            response: errorResponse2(
+              ErrorCode.BAD_VALUE,
+              "saslContinue requires payload field"
+            )
+          };
+        }
+        const result = await this.authenticator.saslContinue(conversationId, payload);
+        if (!result.success) {
+          return {
+            response: errorResponse2(
+              ErrorCode.AUTHENTICATION_FAILED,
+              result.error || "Authentication failed"
+            )
+          };
+        }
+        if (result.done) {
+          const user = this.authenticator.getConversationUser(conversationId);
+          if (user && context.setAuthenticated) {
+            context.setAuthenticated(user.username, user.db);
+          }
+          this.authenticator.cleanupConversation(conversationId);
+        }
+        return {
+          response: successResponse2({
+            conversationId: result.conversationId,
+            payload: new Binary(result.payload),
+            done: result.done
+          })
+        };
+      }
+    };
+    AuthenticateCommand = class {
+      async execute(_command, _context) {
+        return {
+          response: errorResponse2(
+            ErrorCode.AUTHENTICATION_FAILED,
+            "Legacy authenticate command is not supported. Use SCRAM-SHA-256 via saslStart/saslContinue."
+          )
+        };
+      }
+    };
+    LogoutCommand = class {
+      constructor(clearAuthentication) {
+        this.clearAuthentication = clearAuthentication;
+      }
+      async execute(_command, context) {
+        this.clearAuthentication(context.connectionId);
+        return {
+          response: successResponse2({
+            // MongoDB returns ok: 1 for logout
+          })
+        };
+      }
+    };
+    UNAUTHENTICATED_COMMANDS = /* @__PURE__ */ new Set([
+      // Handshake commands
+      "hello",
+      "ismaster",
+      "isMaster",
+      "buildInfo",
+      "buildinfo",
+      // Authentication commands
+      "saslStart",
+      "saslContinue",
+      "authenticate",
+      "logout",
+      // Basic connectivity
+      "ping",
+      "whatsmyuri",
+      // Required for driver initialization
+      "getParameter",
+      "getCmdLineOpts"
+    ]);
+  }
+});
+async function createScramCredentials(username, password, db, iterationCount = 15e3) {
+  const saltBytes = new Uint8Array(16);
+  crypto.getRandomValues(saltBytes);
+  const salt = Buffer.from(saltBytes).toString("base64");
+  const saltedPassword = await pbkdf2Sha256(password, saltBytes, iterationCount);
+  const clientKey = await hmacSha256(saltedPassword, "Client Key");
+  const storedKey = await sha256(clientKey);
+  const serverKey = await hmacSha256(saltedPassword, "Server Key");
+  return {
+    username,
+    salt,
+    storedKey: storedKey.toString("base64"),
+    serverKey: serverKey.toString("base64"),
+    iterationCount,
+    db
+  };
+}
+async function pbkdf2Sha256(password, salt, iterations) {
+  const encoder = new TextEncoder();
+  const keyMaterial = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(password),
+    "PBKDF2",
+    false,
+    ["deriveBits"]
+  );
+  const derivedBits = await crypto.subtle.deriveBits(
+    {
+      name: "PBKDF2",
+      salt: new Uint8Array(salt),
+      iterations,
+      hash: "SHA-256"
+    },
+    keyMaterial,
+    256
+    // 32 bytes
+  );
+  return Buffer.from(derivedBits);
+}
+async function sha256(data) {
+  const hashBuffer = await crypto.subtle.digest("SHA-256", new Uint8Array(data));
+  return Buffer.from(hashBuffer);
+}
+async function hmacSha256(key, message) {
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    new Uint8Array(key),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign(
+    "HMAC",
+    cryptoKey,
+    new TextEncoder().encode(message)
+  );
+  return Buffer.from(signature);
+}
+var ScramAuthenticator, InMemoryCredentialsProvider;
+var init_scram = __esm({
+  "src/wire/auth/scram.ts"() {
+    ScramAuthenticator = class {
+      constructor(credentialsProvider) {
+        this.credentialsProvider = credentialsProvider;
+      }
+      conversations = /* @__PURE__ */ new Map();
+      nextConversationId = 1;
+      /**
+       * Handle saslStart command - begin authentication
+       *
+       * @param mechanism - Should be "SCRAM-SHA-256"
+       * @param payload - Client's first message (Binary or Buffer)
+       * @param db - Authentication database
+       */
+      async saslStart(mechanism, payload, db) {
+        if (mechanism !== "SCRAM-SHA-256") {
+          return {
+            success: false,
+            done: true,
+            error: `Mechanism ${mechanism} is not supported. Only SCRAM-SHA-256 is available.`
+          };
+        }
+        const payloadBytes = payload instanceof Binary ? payload.buffer : Buffer.from(payload);
+        const clientFirstMessage = payloadBytes.toString("utf-8");
+        const parsed = this.parseClientFirstMessage(clientFirstMessage);
+        if (!parsed) {
+          return {
+            success: false,
+            done: true,
+            error: "Invalid client-first-message format"
+          };
+        }
+        const { username, clientNonce, clientFirstMessageBare } = parsed;
+        const credentials = await this.credentialsProvider.getCredentials(username, db);
+        if (!credentials) {
+          const fakeSalt = await this.generateSalt();
+          const serverNonce2 = clientNonce + await this.generateNonce();
+          const iterationCount = 15e3;
+          const conversationId2 = this.nextConversationId++;
+          this.conversations.set(conversationId2, {
+            username,
+            db,
+            clientNonce,
+            serverNonce: serverNonce2,
+            salt: fakeSalt,
+            iterationCount,
+            clientFirstMessageBare,
+            serverFirstMessage: "",
+            step: "init"
+          });
+          const serverFirstMessage2 = `r=${serverNonce2},s=${fakeSalt},i=${iterationCount}`;
+          const conv2 = this.conversations.get(conversationId2);
+          conv2.serverFirstMessage = serverFirstMessage2;
+          conv2.step = "challenge";
+          return {
+            success: true,
+            conversationId: conversationId2,
+            payload: Buffer.from(serverFirstMessage2, "utf-8"),
+            done: false
+          };
+        }
+        const serverNonce = clientNonce + await this.generateNonce();
+        const conversationId = this.nextConversationId++;
+        this.conversations.set(conversationId, {
+          username,
+          db,
+          clientNonce,
+          serverNonce,
+          salt: credentials.salt,
+          iterationCount: credentials.iterationCount,
+          clientFirstMessageBare,
+          serverFirstMessage: "",
+          step: "init"
+        });
+        const serverFirstMessage = `r=${serverNonce},s=${credentials.salt},i=${credentials.iterationCount}`;
+        const conv = this.conversations.get(conversationId);
+        conv.serverFirstMessage = serverFirstMessage;
+        conv.step = "challenge";
+        return {
+          success: true,
+          conversationId,
+          payload: Buffer.from(serverFirstMessage, "utf-8"),
+          done: false
+        };
+      }
+      /**
+       * Handle saslContinue command - continue authentication
+       *
+       * @param conversationId - Conversation ID from saslStart
+       * @param payload - Client's response message
+       */
+      async saslContinue(conversationId, payload) {
+        const conv = this.conversations.get(conversationId);
+        if (!conv) {
+          return {
+            success: false,
+            done: true,
+            error: "Invalid conversation ID"
+          };
+        }
+        const payloadBytes = payload instanceof Binary ? payload.buffer : Buffer.from(payload);
+        const clientMessage = payloadBytes.toString("utf-8");
+        if (conv.step === "challenge") {
+          const parsed = this.parseClientFinalMessage(clientMessage);
+          if (!parsed) {
+            this.conversations.delete(conversationId);
+            return {
+              success: false,
+              done: true,
+              error: "Invalid client-final-message format"
+            };
+          }
+          const { clientProof, nonce, clientFinalMessageWithoutProof } = parsed;
+          if (nonce !== conv.serverNonce) {
+            this.conversations.delete(conversationId);
+            return {
+              success: false,
+              done: true,
+              error: "Authentication failed: nonce mismatch"
+            };
+          }
+          const credentials = await this.credentialsProvider.getCredentials(
+            conv.username,
+            conv.db
+          );
+          if (!credentials) {
+            this.conversations.delete(conversationId);
+            return {
+              success: false,
+              done: true,
+              error: "Authentication failed"
+            };
+          }
+          const verified = await this.verifyClientProof(
+            conv,
+            clientProof,
+            clientFinalMessageWithoutProof,
+            credentials
+          );
+          if (!verified.success) {
+            this.conversations.delete(conversationId);
+            return {
+              success: false,
+              done: true,
+              error: "Authentication failed"
+            };
+          }
+          conv.step = "complete";
+          const serverFinalMessage = `v=${verified.serverSignature}`;
+          return {
+            success: true,
+            conversationId,
+            payload: Buffer.from(serverFinalMessage, "utf-8"),
+            done: true
+          };
+        }
+        this.conversations.delete(conversationId);
+        return {
+          success: false,
+          done: true,
+          error: "Unexpected conversation state"
+        };
+      }
+      /**
+       * Parse client-first-message
+       * Format: gs2-header n=username,r=client-nonce
+       * gs2-header is typically "n,," (no channel binding, no authzid)
+       */
+      parseClientFirstMessage(message) {
+        const match = message.match(/^([nyp])(=([^,]*))?,,(.+)$/);
+        if (!match) return null;
+        const clientFirstMessageBare = match[4];
+        if (!clientFirstMessageBare) return null;
+        const parts = /* @__PURE__ */ new Map();
+        for (const part of clientFirstMessageBare.split(",")) {
+          const eqIdx = part.indexOf("=");
+          if (eqIdx > 0) {
+            parts.set(part.slice(0, eqIdx), part.slice(eqIdx + 1));
+          }
+        }
+        const username = parts.get("n");
+        const clientNonce = parts.get("r");
+        if (!username || !clientNonce) return null;
+        const decodedUsername = username.replace(/=2C/g, ",").replace(/=3D/g, "=");
+        return { username: decodedUsername, clientNonce, clientFirstMessageBare };
+      }
+      /**
+       * Parse client-final-message
+       * Format: c=channel-binding,r=nonce,p=client-proof
+       */
+      parseClientFinalMessage(message) {
+        const proofMatch = message.match(/,p=([A-Za-z0-9+/=]+)$/);
+        if (!proofMatch) return null;
+        const clientProof = proofMatch[1];
+        const clientFinalMessageWithoutProof = message.slice(
+          0,
+          message.length - proofMatch[0].length
+        );
+        const parts = /* @__PURE__ */ new Map();
+        for (const part of clientFinalMessageWithoutProof.split(",")) {
+          const eqIdx = part.indexOf("=");
+          if (eqIdx > 0) {
+            parts.set(part.slice(0, eqIdx), part.slice(eqIdx + 1));
+          }
+        }
+        const channelBinding = parts.get("c");
+        const nonce = parts.get("r");
+        if (!channelBinding || !nonce || !clientProof) return null;
+        return { channelBinding, nonce, clientProof, clientFinalMessageWithoutProof };
+      }
+      /**
+       * Verify client proof and generate server signature
+       */
+      async verifyClientProof(conv, clientProofBase64, clientFinalMessageWithoutProof, credentials) {
+        try {
+          const authMessage = `${conv.clientFirstMessageBare},${conv.serverFirstMessage},${clientFinalMessageWithoutProof}`;
+          const storedKey = Buffer.from(credentials.storedKey, "base64");
+          const serverKey = Buffer.from(credentials.serverKey, "base64");
+          const clientSignature = await this.hmacSha256(storedKey, authMessage);
+          const clientProof = Buffer.from(clientProofBase64, "base64");
+          const clientKey = Buffer.alloc(clientProof.length);
+          for (let i = 0; i < clientProof.length; i++) {
+            clientKey[i] = (clientProof[i] ?? 0) ^ (clientSignature[i] ?? 0);
+          }
+          const computedStoredKey = await this.sha256(clientKey);
+          if (!this.timingSafeEqual(computedStoredKey, storedKey)) {
+            return { success: false };
+          }
+          const serverSignature = await this.hmacSha256(serverKey, authMessage);
+          return {
+            success: true,
+            serverSignature: serverSignature.toString("base64")
+          };
+        } catch {
+          return { success: false };
+        }
+      }
+      /**
+       * Generate a random nonce
+       */
+      async generateNonce() {
+        const bytes = new Uint8Array(24);
+        crypto.getRandomValues(bytes);
+        return Buffer.from(bytes).toString("base64");
+      }
+      /**
+       * Generate a random salt
+       */
+      async generateSalt() {
+        const bytes = new Uint8Array(16);
+        crypto.getRandomValues(bytes);
+        return Buffer.from(bytes).toString("base64");
+      }
+      /**
+       * Compute SHA-256 hash
+       */
+      async sha256(data) {
+        const hashBuffer = await crypto.subtle.digest("SHA-256", new Uint8Array(data));
+        return Buffer.from(hashBuffer);
+      }
+      /**
+       * Compute HMAC-SHA-256
+       */
+      async hmacSha256(key, message) {
+        const cryptoKey = await crypto.subtle.importKey(
+          "raw",
+          new Uint8Array(key),
+          { name: "HMAC", hash: "SHA-256" },
+          false,
+          ["sign"]
+        );
+        const signature = await crypto.subtle.sign(
+          "HMAC",
+          cryptoKey,
+          new TextEncoder().encode(message)
+        );
+        return Buffer.from(signature);
+      }
+      /**
+       * Timing-safe comparison
+       */
+      timingSafeEqual(a, b) {
+        if (a.length !== b.length) return false;
+        let result = 0;
+        for (let i = 0; i < a.length; i++) {
+          result |= (a[i] ?? 0) ^ (b[i] ?? 0);
+        }
+        return result === 0;
+      }
+      /**
+       * Clean up a conversation
+       */
+      cleanupConversation(conversationId) {
+        this.conversations.delete(conversationId);
+      }
+      /**
+       * Get conversation username for successful auth
+       */
+      getConversationUser(conversationId) {
+        const conv = this.conversations.get(conversationId);
+        if (!conv || conv.step !== "complete") return null;
+        return { username: conv.username, db: conv.db };
+      }
+    };
+    InMemoryCredentialsProvider = class {
+      credentials = /* @__PURE__ */ new Map();
+      /**
+       * Add a user with a password
+       */
+      async addUser(username, password, db, roles) {
+        const creds = await createScramCredentials(username, password, db);
+        if (roles) {
+          creds.roles = roles;
+        }
+        this.credentials.set(`${db}.${username}`, creds);
+      }
+      /**
+       * Add pre-computed credentials
+       */
+      addCredentials(credentials) {
+        this.credentials.set(`${credentials.db}.${credentials.username}`, credentials);
+      }
+      /**
+       * Get credentials for a user
+       */
+      async getCredentials(username, db) {
+        return this.credentials.get(`${db}.${username}`) || null;
+      }
+      /**
+       * Remove a user
+       */
+      removeUser(username, db) {
+        return this.credentials.delete(`${db}.${username}`);
+      }
+      /**
+       * Check if a user exists
+       */
+      hasUser(username, db) {
+        return this.credentials.has(`${db}.${username}`);
+      }
+    };
+  }
+});
+
+// src/wire/commands/router.ts
+var CommandRouter;
+var init_router = __esm({
+  "src/wire/commands/router.ts"() {
+    init_types2();
+    init_hello();
+    init_admin();
+    init_crud();
+    init_aggregate();
+    init_commands();
+    init_auth();
+    init_scram();
+    CommandRouter = class {
+      handlers;
+      authEnabled;
+      authenticator;
+      getConnectionState;
+      setConnectionAuthenticated;
+      clearConnectionAuthentication;
+      constructor(backend, options = {}) {
+        this.authEnabled = options.authEnabled ?? false;
+        this.getConnectionState = options.getConnectionState;
+        this.setConnectionAuthenticated = options.setConnectionAuthenticated;
+        this.clearConnectionAuthentication = options.clearConnectionAuthentication;
+        if (options.credentialsProvider) {
+          this.authenticator = new ScramAuthenticator(options.credentialsProvider);
+        }
+        this.handlers = /* @__PURE__ */ new Map([
+          // Handshake & discovery
+          ["hello", new HelloCommand()],
+          ["ismaster", new HelloCommand()],
+          ["isMaster", new HelloCommand()],
+          // System info
+          ["ping", new PingCommand()],
+          ["buildInfo", new BuildInfoCommand()],
+          ["buildinfo", new BuildInfoCommand()],
+          ["hostInfo", new HostInfoCommand()],
+          ["whatsmyuri", new WhatsmyuriCommand()],
+          ["getLog", new GetLogCommand()],
+          ["getParameter", new GetParameterCommand()],
+          ["getCmdLineOpts", new GetCmdLineOptsCommand()],
+          // Admin commands
+          ["listDatabases", new ListDatabasesCommand(backend)],
+          ["listCollections", new ListCollectionsCommand(backend)],
+          ["create", new CreateCommand(backend)],
+          ["drop", new DropCommand(backend)],
+          ["dropDatabase", new DropDatabaseCommand(backend)],
+          ["collStats", new CollStatsCommand(backend)],
+          ["dbStats", new DbStatsCommand(backend)],
+          ["serverStatus", new ServerStatusCommand(backend)],
+          // CRUD
+          ["find", new FindCommand(backend)],
+          ["insert", new InsertCommand(backend)],
+          ["update", new UpdateCommand(backend)],
+          ["delete", new DeleteCommand(backend)],
+          ["count", new CountCommand(backend)],
+          ["distinct", new DistinctCommand(backend)],
+          ["getMore", new GetMoreCommand(backend)],
+          ["killCursors", new KillCursorsCommand(backend)],
+          // Aggregation
+          ["aggregate", new AggregateCommand(backend)],
+          // Indexes
+          ["listIndexes", new ListIndexesCommand(backend)],
+          ["createIndexes", new CreateIndexesCommand(backend)],
+          ["dropIndexes", new DropIndexesCommand(backend)]
+        ]);
+        if (this.authenticator) {
+          this.handlers.set("saslStart", new SaslStartCommand(this.authenticator));
+          this.handlers.set("saslContinue", new SaslContinueCommand(this.authenticator));
+        }
+        this.handlers.set("authenticate", new AuthenticateCommand());
+        if (this.clearConnectionAuthentication) {
+          this.handlers.set("logout", new LogoutCommand(this.clearConnectionAuthentication));
+        }
+      }
+      /**
+       * Route a command to its handler
+       */
+      async route(command, context) {
+        const commandName = Object.keys(command).find((key) => !key.startsWith("$"));
+        if (!commandName) {
+          return {
+            response: errorResponse2(
+              ErrorCode.COMMAND_NOT_FOUND,
+              "no command found in request"
+            )
+          };
+        }
+        if (this.authEnabled && requiresAuthentication(commandName)) {
+          const connState = this.getConnectionState?.(context.connectionId);
+          if (!connState?.authenticated) {
+            return {
+              response: errorResponse2(
+                ErrorCode.UNAUTHORIZED,
+                `command ${commandName} requires authentication`
+              )
+            };
+          }
+        }
+        const handler = this.handlers.get(commandName);
+        if (!handler) {
+          const lowerName = commandName.toLowerCase();
+          for (const [name, h] of this.handlers) {
+            if (name.toLowerCase() === lowerName) {
+              return this.executeHandler(h, command, context, commandName);
+            }
+          }
+          return {
+            response: errorResponse2(
+              ErrorCode.COMMAND_NOT_FOUND,
+              `no such command: '${commandName}'`
+            )
+          };
+        }
+        return this.executeHandler(handler, command, context, commandName);
+      }
+      async executeHandler(handler, command, context, commandName) {
+        try {
+          if (commandName === "saslStart" || commandName === "saslContinue") {
+            const authContext = {
+              ...context,
+              setAuthenticated: (username, db) => {
+                this.setConnectionAuthenticated?.(context.connectionId, username, db);
+              }
+            };
+            return await handler.execute(command, authContext);
+          }
+          return await handler.execute(command, context);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          console.error(`Error executing command '${commandName}':`, message);
+          return {
+            response: errorResponse2(ErrorCode.INTERNAL_ERROR, message)
+          };
+        }
+      }
+      /**
+       * Check if a command exists
+       */
+      hasCommand(name) {
+        return this.handlers.has(name);
+      }
+      /**
+       * Register a new command handler
+       */
+      registerCommand(name, handler) {
+        this.handlers.set(name, handler);
+      }
+    };
+  }
+});
+
+// src/wire/server.ts
+var server_exports = {};
+__export(server_exports, {
+  WireProtocolServer: () => WireProtocolServer,
+  createServer: () => createServer
+});
+async function createServer(backend, options = {}) {
+  const server = new WireProtocolServer(backend, options);
+  await server.start();
+  return server;
+}
+var DEFAULT_OPTIONS, WireProtocolServer;
+var init_server = __esm({
+  "src/wire/server.ts"() {
+    init_message();
+    init_router();
+    init_types();
+    init_auth();
+    init_scram();
+    init_auth();
+    DEFAULT_OPTIONS = {
+      port: 27017,
+      host: "localhost",
+      verbose: false
+    };
+    WireProtocolServer = class {
+      options;
+      router;
+      connections = /* @__PURE__ */ new Map();
+      nextConnectionId = 1;
+      nextRequestId = 1;
+      // Use unknown to avoid typing issues with Bun.listen union types
+      server = null;
+      authenticator = null;
+      constructor(backend, options = {}) {
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+        this.router = new CommandRouter(backend);
+        if (this.options.auth?.enabled) {
+          const credentialsProvider = new InMemoryCredentialsProvider();
+          credentialsProvider.addUser(
+            this.options.auth.username,
+            this.options.auth.password,
+            "admin"
+            // Default auth database
+          ).then(() => {
+            console.log(`Authentication enabled for user: ${this.options.auth.username}`);
+          });
+          this.authenticator = new ScramAuthenticator(credentialsProvider);
+          this.router.registerCommand("saslStart", new SaslStartCommand(this.authenticator));
+          this.router.registerCommand("saslContinue", new SaslContinueCommand(this.authenticator));
+          this.router.registerCommand("logout", new LogoutCommand((connId) => {
+            const conn = this.connections.get(connId);
+            if (conn) {
+              conn.authenticated = false;
+            }
+          }));
+        }
+      }
+      /**
+       * Start the server
+       */
+      async start() {
+        const { port, host, verbose, tls } = this.options;
+        const socketHandlers = {
+          open: (socket) => {
+            const connectionId = this.nextConnectionId++;
+            socket.data = { connectionId, buffer: Buffer.alloc(0) };
+            this.connections.set(connectionId, {
+              id: connectionId,
+              authenticated: false,
+              compressionEnabled: false,
+              cursors: /* @__PURE__ */ new Map()
+            });
+            if (verbose) {
+              const connType = tls ? "TLS connection" : "Connection";
+              console.log(`[${connectionId}] ${connType} opened`);
+            }
+          },
+          data: async (socket, data) => {
+            socket.data.buffer = Buffer.concat([socket.data.buffer, data]);
+            await this.processBuffer(socket);
+          },
+          close: (socket) => {
+            const connId = socket.data.connectionId;
+            if (verbose) {
+              console.log(`[${connId}] Connection closed`);
+            }
+            this.connections.delete(connId);
+          },
+          error: (socket, error) => {
+            const { connectionId } = socket.data;
+            console.error(`[${connectionId}] Socket error:`, error);
+          }
+        };
+        if (tls) {
+          this.server = Bun.listen({
+            hostname: host,
+            port,
+            socket: socketHandlers,
+            tls: this.buildTlsConfig(tls)
+          });
+          console.log(`mongo.do wire protocol server listening on TLS ${host}:${port}`);
+        } else {
+          this.server = Bun.listen({
+            hostname: host,
+            port,
+            socket: socketHandlers
+          });
+          console.log(`mongo.do wire protocol server listening on TCP ${host}:${port}`);
+        }
+      }
+      /**
+       * Build TLS configuration object from TlsOptions
+       */
+      buildTlsConfig(tlsOptions) {
+        const config = {
+          key: tlsOptions.key,
+          cert: tlsOptions.cert
+        };
+        if (tlsOptions.ca !== void 0) {
+          config.ca = tlsOptions.ca;
+        }
+        if (tlsOptions.passphrase !== void 0) {
+          config.passphrase = tlsOptions.passphrase;
+        }
+        if (tlsOptions.requestCert !== void 0) {
+          config.requestCert = tlsOptions.requestCert;
+        }
+        if (tlsOptions.rejectUnauthorized !== void 0) {
+          config.rejectUnauthorized = tlsOptions.rejectUnauthorized;
+        }
+        if (tlsOptions.minVersion !== void 0) {
+          config.minVersion = tlsOptions.minVersion;
+        }
+        if (tlsOptions.maxVersion !== void 0) {
+          config.maxVersion = tlsOptions.maxVersion;
+        }
+        if (tlsOptions.serverName !== void 0) {
+          config.serverName = tlsOptions.serverName;
+        }
+        if (tlsOptions.ALPNProtocols !== void 0) {
+          config.ALPNProtocols = tlsOptions.ALPNProtocols;
+        }
+        return config;
+      }
+      /**
+       * Stop the server
+       */
+      async stop() {
+        if (this.server) {
+          this.server.stop();
+          this.server = null;
+          console.log("Server stopped");
+        }
+      }
+      /**
+       * Process accumulated buffer for complete messages
+       */
+      async processBuffer(socket) {
+        const { connectionId, buffer } = socket.data;
+        while (buffer.length >= 4) {
+          const messageLength = buffer.readInt32LE(0);
+          if (buffer.length < messageLength) {
+            break;
+          }
+          const messageBuffer = buffer.subarray(0, messageLength);
+          socket.data.buffer = buffer.subarray(messageLength);
+          try {
+            const response = await this.handleMessage(connectionId, messageBuffer);
+            if (response) {
+              socket.write(response);
+            }
+          } catch (error) {
+            console.error(`[${connectionId}] Error handling message:`, error);
+            const errorResponse3 = serializeOpMsg(
+              this.nextRequestId++,
+              messageBuffer.readInt32LE(4),
+              // responseTo = requestID
+              { ok: 0, errmsg: error instanceof Error ? error.message : "Unknown error", code: 1 }
+            );
+            socket.write(errorResponse3);
+          }
+        }
+      }
+      /**
+       * Handle a single message
+       */
+      async handleMessage(connectionId, buffer) {
+        const message = parseMessage(buffer);
+        const { db, command, documentSequences } = extractCommand(message);
+        const cmdName = Object.keys(command).find((k) => !k.startsWith("$"));
+        if (this.options.verbose) {
+          console.log(`[${connectionId}] ${cmdName} on ${db}`);
+        }
+        const connection = this.connections.get(connectionId);
+        if (this.options.auth?.enabled && connection) {
+          const isAuthRequired = requiresAuthentication(cmdName || "");
+          if (isAuthRequired && !connection.authenticated) {
+            const errorResult = {
+              ok: 0,
+              errmsg: "Authentication required. Use SCRAM-SHA-256 to authenticate.",
+              code: 13,
+              // Unauthorized
+              codeName: "Unauthorized"
+            };
+            if (message.header.opCode === OpCode.OP_QUERY) {
+              return serializeOpReply(this.nextRequestId++, message.header.requestID, [errorResult]);
+            } else {
+              return serializeOpMsg(this.nextRequestId++, message.header.requestID, errorResult);
+            }
+          }
+        }
+        const context = {
+          db,
+          connectionId,
+          requestId: message.header.requestID,
+          documentSequences,
+          // Pass auth info for SASL handlers
+          auth: this.options.auth
+        };
+        if (connection !== void 0) {
+          context.connection = connection;
+        }
+        const result = await this.router.route(command, context);
+        if (cmdName === "saslContinue" && result.response.ok === 1 && result.response.done === true) {
+          if (connection) {
+            connection.authenticated = true;
+          }
+        }
+        if (message.header.opCode === OpCode.OP_QUERY) {
+          return serializeOpReply(
+            this.nextRequestId++,
+            message.header.requestID,
+            [result.response]
+          );
+        } else {
+          return serializeOpMsg(
+            this.nextRequestId++,
+            message.header.requestID,
+            result.response
+          );
+        }
+      }
+      /**
+       * Get server address info
+       */
+      get address() {
+        return {
+          host: this.options.host,
+          port: this.options.port,
+          tls: this.isTls
+        };
+      }
+      /**
+       * Check if server is using TLS
+       */
+      get isTls() {
+        return this.options.tls !== void 0;
+      }
+      /**
+       * Get the MongoDB connection string for this server
+       * Returns mongodb:// for non-TLS or mongodb+srv:// style for TLS
+       */
+      get connectionString() {
+        const { host, port } = this.options;
+        const protocol = this.isTls ? "mongodb+ssl" : "mongodb";
+        return `${protocol}://${host}:${port}`;
+      }
+    };
+  }
+});
+
+// package.json
+var version = "0.1.1";
+
+// src/wire/backend/workers-proxy.ts
+var MongoProxyError = class extends Error {
+  code;
+  codeName;
+  constructor(message, code, codeName) {
+    super(message);
+    this.name = "MongoProxyError";
+    this.code = code;
+    if (codeName) {
+      this.codeName = codeName;
+    }
+  }
+};
+var CURSOR_TIMEOUT_MS = 10 * 60 * 1e3;
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var NON_RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set([
+  2,
+  // BadValue
+  13,
+  // Unauthorized
+  26,
+  // NamespaceNotFound
+  59,
+  // CommandNotFound
+  11e3
+  // DuplicateKey
+]);
+var WorkersProxyBackend = class {
+  endpoint;
+  authToken;
+  timeout;
+  retries;
+  retryDelay;
+  cursors = /* @__PURE__ */ new Map();
+  constructor(options) {
+    if (!options.endpoint) {
+      throw new Error("WorkersProxyBackend requires an endpoint URL");
+    }
+    try {
+      new URL(options.endpoint);
+    } catch {
+      throw new Error(`WorkersProxyBackend endpoint is not a valid URL: ${options.endpoint}`);
+    }
+    this.endpoint = options.endpoint;
+    if (options.authToken) {
+      this.authToken = options.authToken;
+    }
+    this.timeout = options.timeout ?? 3e4;
+    this.retries = options.retries ?? 0;
+    this.retryDelay = options.retryDelay ?? 1e3;
+  }
+  // ==========================================================================
+  // Private Helper Methods
+  // ==========================================================================
+  /**
+   * Make an RPC call to the Workers endpoint
+   */
+  async rpc(request, attempt = 0) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.authToken) {
+      headers["Authorization"] = `Bearer ${this.authToken}`;
+    }
+    try {
+      const response = await fetch(this.endpoint, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(request),
+        signal: AbortSignal.timeout(this.timeout)
+      });
+      if (!response.ok && !response.headers.get("Content-Type")?.includes("application/json")) {
+        const error = new Error(`HTTP error: ${response.status} ${response.statusText}`);
+        if (RETRYABLE_STATUS_CODES.has(response.status) && attempt < this.retries) {
+          await this.delay(this.retryDelay);
+          return this.rpc(request, attempt + 1);
+        }
+        throw error;
+      }
+      let data;
+      try {
+        data = await response.json();
+      } catch {
+        throw new Error("Invalid JSON response from RPC endpoint");
+      }
+      if (data.ok === 0) {
+        const error = new MongoProxyError(data.error, data.code, data.codeName);
+        if (NON_RETRYABLE_ERROR_CODES.has(data.code)) {
+          throw error;
+        }
+        throw error;
+      }
+      return data.result;
+    } catch (error) {
+      if (attempt < this.retries && error instanceof Error && !("code" in error && NON_RETRYABLE_ERROR_CODES.has(error.code))) {
+        await this.delay(this.retryDelay);
+        return this.rpc(request, attempt + 1);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Delay for a specified number of milliseconds
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Convert cursor ID from string to bigint
+   */
+  parseCursorId(cursorId) {
+    if (typeof cursorId === "bigint") return cursorId;
+    return BigInt(cursorId);
+  }
+  // ==========================================================================
+  // Database Operations
+  // ==========================================================================
+  async listDatabases() {
+    return this.rpc({ method: "listDatabases" });
+  }
+  async createDatabase(name) {
+    await this.rpc({ method: "createDatabase", db: name });
+  }
+  async dropDatabase(name) {
+    await this.rpc({ method: "dropDatabase", db: name });
+  }
+  async databaseExists(name) {
+    return this.rpc({ method: "databaseExists", db: name });
+  }
+  // ==========================================================================
+  // Collection Operations
+  // ==========================================================================
+  async listCollections(db, filter) {
+    const request = {
+      method: "listCollections",
+      db
+    };
+    if (filter) {
+      request.filter = filter;
+    }
+    return this.rpc(request);
+  }
+  async createCollection(db, name, options) {
+    const request = {
+      method: "createCollection",
+      db,
+      collection: name
+    };
+    if (options) {
+      request.options = options;
+    }
+    await this.rpc(request);
+  }
+  async dropCollection(db, name) {
+    await this.rpc({
+      method: "dropCollection",
+      db,
+      collection: name
+    });
+  }
+  async collectionExists(db, name) {
+    return this.rpc({
+      method: "collectionExists",
+      db,
+      collection: name
+    });
+  }
+  async collStats(db, collection) {
+    return this.rpc({
+      method: "collStats",
+      db,
+      collection
+    });
+  }
+  async dbStats(db) {
+    return this.rpc({
+      method: "dbStats",
+      db
+    });
+  }
+  // ==========================================================================
+  // CRUD Operations
+  // ==========================================================================
+  async find(db, collection, options) {
+    const request = {
+      method: "find",
+      db,
+      collection
+    };
+    if (options.filter) {
+      request.filter = options.filter;
+    }
+    const findOptions = {};
+    if (options.projection) findOptions.projection = options.projection;
+    if (options.sort) findOptions.sort = options.sort;
+    if (options.limit !== void 0) findOptions.limit = options.limit;
+    if (options.skip !== void 0) findOptions.skip = options.skip;
+    if (options.batchSize !== void 0) findOptions.batchSize = options.batchSize;
+    if (options.hint) findOptions.hint = options.hint;
+    if (options.comment) findOptions.comment = options.comment;
+    if (options.allowDiskUse !== void 0) findOptions.allowDiskUse = options.allowDiskUse;
+    if (options.collation) findOptions.collation = options.collation;
+    if (Object.keys(findOptions).length > 0) {
+      request.options = findOptions;
+    }
+    const result = await this.rpc(request);
+    return {
+      documents: result.documents,
+      cursorId: this.parseCursorId(result.cursorId),
+      hasMore: result.hasMore
+    };
+  }
+  async insertOne(db, collection, doc) {
+    const result = await this.rpc({
+      method: "insertOne",
+      db,
+      collection,
+      document: doc
+    });
+    return {
+      acknowledged: result.acknowledged,
+      insertedIds: new Map(Object.entries(result.insertedIds).map(([k, v]) => [Number(k), v])),
+      insertedCount: result.insertedCount
+    };
+  }
+  async insertMany(db, collection, docs) {
+    const result = await this.rpc({
+      method: "insertMany",
+      db,
+      collection,
+      documents: docs
+    });
+    return {
+      acknowledged: result.acknowledged,
+      insertedIds: new Map(Object.entries(result.insertedIds).map(([k, v]) => [Number(k), v])),
+      insertedCount: result.insertedCount
+    };
+  }
+  async updateOne(db, collection, filter, update, options) {
+    const request = {
+      method: "updateOne",
+      db,
+      collection,
+      filter,
+      update
+    };
+    if (options) {
+      request.options = options;
+    }
+    return this.rpc(request);
+  }
+  async updateMany(db, collection, filter, update, options) {
+    const request = {
+      method: "updateMany",
+      db,
+      collection,
+      filter,
+      update
+    };
+    if (options) {
+      request.options = options;
+    }
+    return this.rpc(request);
+  }
+  async deleteOne(db, collection, filter) {
+    return this.rpc({
+      method: "deleteOne",
+      db,
+      collection,
+      filter
+    });
+  }
+  async deleteMany(db, collection, filter) {
+    return this.rpc({
+      method: "deleteMany",
+      db,
+      collection,
+      filter
+    });
+  }
+  // ==========================================================================
+  // Count and Distinct
+  // ==========================================================================
+  async count(db, collection, query) {
+    const request = {
+      method: "count",
+      db,
+      collection
+    };
+    if (query) {
+      request.query = query;
+    }
+    return this.rpc(request);
+  }
+  async distinct(db, collection, field, query) {
+    const request = {
+      method: "distinct",
+      db,
+      collection,
+      field
+    };
+    if (query) {
+      request.query = query;
+    }
+    return this.rpc(request);
+  }
+  // ==========================================================================
+  // Aggregation
+  // ==========================================================================
+  async aggregate(db, collection, pipeline, options) {
+    const request = {
+      method: "aggregate",
+      db,
+      collection,
+      pipeline
+    };
+    if (options) {
+      request.options = options;
+    }
+    const result = await this.rpc(request);
+    return {
+      documents: result.documents,
+      cursorId: this.parseCursorId(result.cursorId),
+      hasMore: result.hasMore
+    };
+  }
+  // ==========================================================================
+  // Index Operations
+  // ==========================================================================
+  async listIndexes(db, collection) {
+    return this.rpc({
+      method: "listIndexes",
+      db,
+      collection
+    });
+  }
+  async createIndexes(db, collection, indexes) {
+    return this.rpc({
+      method: "createIndexes",
+      db,
+      collection,
+      options: { indexes }
+    });
+  }
+  async dropIndex(db, collection, indexName) {
+    await this.rpc({
+      method: "dropIndex",
+      db,
+      collection,
+      options: { indexName }
+    });
+  }
+  async dropIndexes(db, collection) {
+    await this.rpc({
+      method: "dropIndexes",
+      db,
+      collection
+    });
+  }
+  // ==========================================================================
+  // Cursor Management
+  // ==========================================================================
+  createCursor(state) {
+    this.cursors.set(state.id, state);
+  }
+  getCursor(id) {
+    return this.cursors.get(id);
+  }
+  advanceCursor(id, count) {
+    const cursor = this.cursors.get(id);
+    if (!cursor) {
+      return [];
+    }
+    const start = cursor.position;
+    const end = Math.min(start + count, cursor.documents.length);
+    cursor.position = end;
+    return cursor.documents.slice(start, end);
+  }
+  closeCursor(id) {
+    return this.cursors.delete(id);
+  }
+  cleanupExpiredCursors() {
+    const now = Date.now();
+    for (const [id, cursor] of this.cursors) {
+      if (now - cursor.createdAt > CURSOR_TIMEOUT_MS) {
+        this.cursors.delete(id);
+      }
+    }
+  }
+};
+
+// src/cli/server.ts
+var LocalSQLiteBackend2;
+var WireProtocolServer2;
+async function loadBunModules() {
+  if (!LocalSQLiteBackend2) {
+    const localModule = await Promise.resolve().then(() => (init_local_sqlite(), local_sqlite_exports));
+    LocalSQLiteBackend2 = localModule.LocalSQLiteBackend;
+  }
+  if (!WireProtocolServer2) {
+    const serverModule = await Promise.resolve().then(() => (init_server(), server_exports));
+    WireProtocolServer2 = serverModule.WireProtocolServer;
+  }
+}
+function parseArgs(args) {
+  const options = {
+    port: 27017,
+    host: "localhost",
+    dataDir: "./data",
+    verbose: false,
+    help: false
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg) continue;
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+      continue;
+    }
+    if (arg === "--verbose" || arg === "-v") {
+      options.verbose = true;
+      continue;
+    }
+    if (arg.startsWith("--port=")) {
+      options.port = parseInt(arg.slice(7), 10);
+      continue;
+    }
+    if (arg.startsWith("-p=")) {
+      options.port = parseInt(arg.slice(3), 10);
+      continue;
+    }
+    if (arg === "--port" || arg === "-p") {
+      const nextArg = args[++i];
+      if (nextArg) {
+        options.port = parseInt(nextArg, 10);
+      }
+      continue;
+    }
+    if (arg.startsWith("--host=")) {
+      options.host = arg.slice(7);
+      continue;
+    }
+    if (arg.startsWith("-H=")) {
+      options.host = arg.slice(3);
+      continue;
+    }
+    if (arg === "--host" || arg === "-H") {
+      const nextArg = args[++i];
+      if (nextArg) {
+        options.host = nextArg;
+      }
+      continue;
+    }
+    if (arg.startsWith("--data=")) {
+      options.dataDir = arg.slice(7);
+      continue;
+    }
+    if (arg.startsWith("-d=")) {
+      options.dataDir = arg.slice(3);
+      continue;
+    }
+    if (arg === "--data" || arg === "-d") {
+      const nextArg = args[++i];
+      if (nextArg) {
+        options.dataDir = nextArg;
+      }
+      continue;
+    }
+    if (arg.startsWith("--remote=")) {
+      options.remote = arg.slice(9);
+      continue;
+    }
+    if (arg.startsWith("-r=")) {
+      options.remote = arg.slice(3);
+      continue;
+    }
+    if (arg === "--remote" || arg === "-r") {
+      const nextArg = args[++i];
+      if (nextArg) {
+        options.remote = nextArg;
+      }
+      continue;
+    }
+  }
+  return options;
+}
+function validateOptions(options) {
+  const errors = [];
+  if (typeof options.port !== "number" || isNaN(options.port) || !Number.isInteger(options.port) || options.port < 1 || options.port > 65535) {
+    errors.push(`Invalid port: ${options.port}. Port must be an integer between 1 and 65535.`);
+  }
+  if (!options.host || typeof options.host !== "string" || options.host.trim() === "") {
+    errors.push("Invalid host: host cannot be empty");
+  }
+  if (!options.remote) {
+    if (!options.dataDir || typeof options.dataDir !== "string" || options.dataDir.trim() === "") {
+      errors.push("Invalid data directory: path cannot be empty");
+    }
+  }
+  if (options.remote !== void 0) {
+    if (!options.remote || typeof options.remote !== "string" || options.remote.trim() === "") {
+      errors.push("Invalid remote URL: URL cannot be empty. Use https://your-worker.workers.dev");
+    } else {
+      try {
+        const url = new URL(options.remote);
+        if (url.protocol !== "http:" && url.protocol !== "https:") {
+          errors.push(`Invalid remote URL: protocol must be http or https, got "${url.protocol.slice(0, -1)}"`);
+        }
+      } catch {
+        errors.push(`Invalid remote URL: "${options.remote}" is not a valid URL. Use https://your-worker.workers.dev`);
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+async function createBackend(options) {
+  if (options.remote) {
+    return new WorkersProxyBackend({
+      endpoint: options.remote
+    });
+  }
+  await loadBunModules();
+  return new LocalSQLiteBackend2(options.dataDir);
+}
+function printHelp() {
+  console.log(`
+Usage: mongo.do serve [options]
+
+Start a MongoDB wire protocol server backed by SQLite.
+
+Options:
+  -p, --port <port>     Port to listen on (default: 27017)
+  -H, --host <host>     Host to bind to (default: localhost)
+  -d, --data <path>     Data directory for local SQLite storage (default: ./data)
+  -r, --remote <url>    Proxy/forward to remote Cloudflare Workers endpoint
+  -v, --verbose         Enable verbose logging
+  -V, --version         Show version number
+  -h, --help            Show this help message
+
+Examples:
+  # Start local server on default port
+  mongo.do serve
+
+  # Start on custom port with verbose logging
+  mongo.do serve --port 27018 --verbose
+
+  # Bind to all interfaces
+  mongo.do serve --host 0.0.0.0
+
+  # Use custom data directory
+  mongo.do serve --data /var/lib/mongodo
+
+  # Proxy to remote Cloudflare Workers
+  mongo.do serve --remote https://my-mongo-do.workers.dev
+
+  # Combine options
+  mongo.do serve --port 27018 --host 0.0.0.0 --verbose
+`);
+}
+function printShutdownMessage() {
+  console.log("MondoDB server gracefully shutdown. Clean stop complete.");
+}
+async function runServer(options, backend) {
+  const validationResult = validateOptions(options);
+  if (!validationResult.valid) {
+    throw new Error(validationResult.errors[0]);
+  }
+  const serverBackend = await createBackend(options);
+  if (options.remote && true) {
+    try {
+      await serverBackend.listDatabases();
+    } catch (e) {
+      throw new Error(`Failed to connect to remote worker: ${options.remote}. Network unreachable or worker not responding.`);
+    }
+  }
+  await loadBunModules();
+  const wireServer = new WireProtocolServer2(serverBackend, {
+    port: options.port,
+    host: options.host,
+    verbose: options.verbose
+  });
+  let running = false;
+  let acceptingConnections = false;
+  let connectionCount = 0;
+  const handleSignal = async () => {
+    if (running) {
+      await controller.stop();
+    }
+  };
+  const sigintHandler = handleSignal;
+  const sigtermHandler = handleSignal;
+  const controller = {
+    get isRunning() {
+      return running;
+    },
+    get isAcceptingConnections() {
+      return acceptingConnections;
+    },
+    get activeConnections() {
+      return connectionCount;
+    },
+    get address() {
+      return { host: options.host, port: options.port };
+    },
+    async stop() {
+      if (!running) return;
+      running = false;
+      acceptingConnections = false;
+      connectionCount = 0;
+      await wireServer.stop();
+      if ("close" in serverBackend && typeof serverBackend.close === "function") {
+        await serverBackend.close();
+      }
+      process.removeListener("SIGINT", sigintHandler);
+      process.removeListener("SIGTERM", sigtermHandler);
+    }
+  };
+  process.on("SIGINT", sigintHandler);
+  process.on("SIGTERM", sigtermHandler);
+  try {
+    await wireServer.start();
+    running = true;
+    acceptingConnections = true;
+  } catch (e) {
+    process.removeListener("SIGINT", sigintHandler);
+    process.removeListener("SIGTERM", sigtermHandler);
+    if (e instanceof Error && e.message.includes("EADDRINUSE")) {
+      throw new Error(`Port ${options.port} is already in use (EADDRINUSE)`);
+    }
+    throw e;
+  }
+  return controller;
+}
+
+// src/cli/index.ts
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  // Foreground colors
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m"
+};
+function supportsColor() {
+  if (process.env.NO_COLOR !== void 0) {
+    return false;
+  }
+  if (process.env.FORCE_COLOR !== void 0) {
+    return true;
+  }
+  return process.stdout.isTTY ?? false;
+}
+var useColors = supportsColor();
 function colorize(text, color) {
-    if (!useColors)
-        return text;
-    return `${colors[color]}${text}${colors.reset}`;
-}
-// ============================================================================
-// Output Functions
-// ============================================================================
-/**
- * Print the ASCII banner for MondoDB
- */
+  if (!useColors) return text;
+  return `${colors[color]}${text}${colors.reset}`;
+}
 function printBanner() {
-    const banner = `
-${colorize('MondoDB', 'cyan')} ${colorize(`v${version}`, 'dim')}
-${colorize('MongoDB-compatible database backed by SQLite', 'dim')}
+  const banner = `
+${colorize("MondoDB", "cyan")} ${colorize(`v${version}`, "dim")}
+${colorize("MongoDB-compatible database backed by SQLite", "dim")}
 `;
-    console.log(banner);
+  console.log(banner);
 }
-/**
- * Print version information
- */
 function printVersion() {
-    console.log(`mongo.do version ${version}`);
+  console.log(`mongo.do version ${version}`);
 }
-/**
- * Print an error message
- */
 function printError(message) {
-    console.error(`${colorize('error:', 'red')} ${message}`);
+  console.error(`${colorize("error:", "red")} ${message}`);
 }
-/**
- * Print enhanced startup message with colors
- */
 function printColoredStartupMessage(options) {
-    const connectionString = `mongodb://${options.host}:${options.port}`;
-    console.log('');
-    if (options.remote) {
-        console.log(`${colorize('Mode:', 'bold')} ${colorize('Proxy/Remote', 'magenta')}`);
-        console.log(`${colorize('Connect:', 'bold')} ${colorize(connectionString, 'cyan')}`);
-        console.log(`${colorize('Proxying to:', 'bold')} ${colorize(options.remote, 'blue')}`);
-    }
-    else {
-        console.log(`${colorize('Mode:', 'bold')} ${colorize('Local/SQLite', 'green')}`);
-        console.log(`${colorize('Connect:', 'bold')} ${colorize(connectionString, 'cyan')}`);
-        console.log(`${colorize('Data directory:', 'bold')} ${options.dataDir}`);
-    }
-    if (options.verbose) {
-        console.log(`${colorize('Verbose logging:', 'bold')} ${colorize('enabled', 'yellow')}`);
-    }
-    console.log('');
-    console.log(`${colorize('Ready to accept connections.', 'green')} Press ${colorize('Ctrl+C', 'bold')} to stop.`);
-    console.log('');
-}
-/**
- * Parse command line arguments with version flag support
- */
+  const connectionString = `mongodb://${options.host}:${options.port}`;
+  console.log("");
+  if (options.remote) {
+    console.log(`${colorize("Mode:", "bold")} ${colorize("Proxy/Remote", "magenta")}`);
+    console.log(`${colorize("Connect:", "bold")} ${colorize(connectionString, "cyan")}`);
+    console.log(`${colorize("Proxying to:", "bold")} ${colorize(options.remote, "blue")}`);
+  } else {
+    console.log(`${colorize("Mode:", "bold")} ${colorize("Local/SQLite", "green")}`);
+    console.log(`${colorize("Connect:", "bold")} ${colorize(connectionString, "cyan")}`);
+    console.log(`${colorize("Data directory:", "bold")} ${options.dataDir}`);
+  }
+  if (options.verbose) {
+    console.log(`${colorize("Verbose logging:", "bold")} ${colorize("enabled", "yellow")}`);
+  }
+  console.log("");
+  console.log(`${colorize("Ready to accept connections.", "green")} Press ${colorize("Ctrl+C", "bold")} to stop.`);
+  console.log("");
+}
 function parseArgsExtended(args) {
-    const baseOptions = parseArgs(args);
-    // Check for version flag
-    const hasVersion = args.some((arg) => arg === '--version' || arg === '-V');
-    return {
-        ...baseOptions,
-        version: hasVersion,
-    };
+  const baseOptions = parseArgs(args);
+  const hasVersion = args.some(
+    (arg) => arg === "--version" || arg === "-V"
+  );
+  return {
+    ...baseOptions,
+    version: hasVersion
+  };
 }
-// ============================================================================
-// Main Entry Point
-// ============================================================================
-/**
- * Main CLI function
- */
 async function main() {
+  try {
+    const options = parseArgsExtended(process.argv.slice(2));
+    if (options.version) {
+      printVersion();
+      process.exit(0);
+    }
+    if (options.help) {
+      printHelp();
+      process.exit(0);
+    }
     try {
-        // Parse arguments
-        const options = parseArgsExtended(process.argv.slice(2));
-        // Handle --version flag
-        if (options.version) {
-            printVersion();
-            process.exit(0);
-        }
-        // Handle --help flag
-        if (options.help) {
-            printHelp();
-            process.exit(0);
-        }
-        // Validate options
-        try {
-            validateOptions(options);
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                printError(error.message);
-            }
-            else {
-                printError('Invalid options');
-            }
-            console.log('');
-            console.log(`Run ${colorize('mongo.do --help', 'cyan')} for usage information.`);
-            process.exit(1);
-        }
-        // Print banner
-        printBanner();
-        // Start the server
-        const controller = await runServer(options);
-        // Print startup message
-        printColoredStartupMessage(options);
-        // Handle graceful shutdown
-        const shutdown = async (signal) => {
-            console.log('');
-            console.log(`${colorize(`Received ${signal}, shutting down...`, 'yellow')}`);
-            try {
-                await controller.stop();
-                printShutdownMessage();
-                process.exit(0);
-            }
-            catch (error) {
-                printError(`Error during shutdown: ${error instanceof Error ? error.message : 'Unknown error'}`);
-                process.exit(1);
-            }
-        };
-        // Register signal handlers
-        process.on('SIGINT', () => shutdown('SIGINT'));
-        process.on('SIGTERM', () => shutdown('SIGTERM'));
-        // Handle uncaught exceptions
-        process.on('uncaughtException', (error) => {
-            printError(`Uncaught exception: ${error.message}`);
-            if (options.verbose) {
-                console.error(error.stack);
-            }
-            process.exit(1);
-        });
-        // Handle unhandled promise rejections
-        process.on('unhandledRejection', (reason) => {
-            printError(`Unhandled rejection: ${reason instanceof Error ? reason.message : String(reason)}`);
-            if (options.verbose && reason instanceof Error) {
-                console.error(reason.stack);
-            }
-            process.exit(1);
-        });
+      validateOptions(options);
+    } catch (error) {
+      if (error instanceof Error) {
+        printError(error.message);
+      } else {
+        printError("Invalid options");
+      }
+      console.log("");
+      console.log(`Run ${colorize("mongo.do --help", "cyan")} for usage information.`);
+      process.exit(1);
     }
-    catch (error) {
-        // Handle startup errors gracefully
-        if (error instanceof Error) {
-            printError(error.message);
-            // Provide helpful hints for common errors
-            if (error.message.includes('EADDRINUSE')) {
-                console.log('');
-                console.log(`${colorize('Hint:', 'yellow')} The port is already in use. Try a different port with ${colorize('--port', 'cyan')}.`);
-            }
-            else if (error.message.includes('EACCES')) {
-                console.log('');
-                console.log(`${colorize('Hint:', 'yellow')} Permission denied. Ports below 1024 require root privileges.`);
-                console.log(`      Try using a port number above 1024, e.g., ${colorize('--port=27017', 'cyan')}.`);
-            }
-            else if (error.message.includes('Failed to connect to remote')) {
-                console.log('');
-                console.log(`${colorize('Hint:', 'yellow')} Could not connect to the remote worker.`);
-                console.log(`      Check that the URL is correct and the worker is running.`);
-            }
-        }
-        else {
-            printError('An unexpected error occurred');
-        }
+    printBanner();
+    const controller = await runServer(options);
+    printColoredStartupMessage(options);
+    const shutdown = async (signal) => {
+      console.log("");
+      console.log(`${colorize(`Received ${signal}, shutting down...`, "yellow")}`);
+      try {
+        await controller.stop();
+        printShutdownMessage();
+        process.exit(0);
+      } catch (error) {
+        printError(`Error during shutdown: ${error instanceof Error ? error.message : "Unknown error"}`);
         process.exit(1);
+      }
+    };
+    process.on("SIGINT", () => shutdown("SIGINT"));
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+    process.on("uncaughtException", (error) => {
+      printError(`Uncaught exception: ${error.message}`);
+      if (options.verbose) {
+        console.error(error.stack);
+      }
+      process.exit(1);
+    });
+    process.on("unhandledRejection", (reason) => {
+      printError(`Unhandled rejection: ${reason instanceof Error ? reason.message : String(reason)}`);
+      if (options.verbose && reason instanceof Error) {
+        console.error(reason.stack);
+      }
+      process.exit(1);
+    });
+  } catch (error) {
+    if (error instanceof Error) {
+      printError(error.message);
+      if (error.message.includes("EADDRINUSE")) {
+        console.log("");
+        console.log(`${colorize("Hint:", "yellow")} The port is already in use. Try a different port with ${colorize("--port", "cyan")}.`);
+      } else if (error.message.includes("EACCES")) {
+        console.log("");
+        console.log(`${colorize("Hint:", "yellow")} Permission denied. Ports below 1024 require root privileges.`);
+        console.log(`      Try using a port number above 1024, e.g., ${colorize("--port=27017", "cyan")}.`);
+      } else if (error.message.includes("Failed to connect to remote")) {
+        console.log("");
+        console.log(`${colorize("Hint:", "yellow")} Could not connect to the remote worker.`);
+        console.log(`      Check that the URL is correct and the worker is running.`);
+      }
+    } else {
+      printError("An unexpected error occurred");
     }
+    process.exit(1);
+  }
 }
-// Run the CLI
 main();
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map