@zintrust/core 2.4.1 → 2.4.3

package/src/proxy/kv/ZintrustKvProxy.ts

@@ -1,354 +0,0 @@
-import { SystemTraceWorkerBridge } from '@/trace/SystemTraceWorkerBridge';
-import { isObject, isString } from '@helper/index';
-import {
-  getEnvInt,
-  json,
-  normalizeBindingName,
-  readAndVerifyJson,
-  toErrorResponse,
-} from '@proxy/CloudflareProxyShared';
-import { RequestValidator } from '@proxy/RequestValidator';
-
-type KVNamespacePutOptions = {
-  expirationTtl?: number;
-};
-
-type KvGetType = 'text' | 'json' | 'arrayBuffer';
-
-type KVListResult = {
-  keys: Array<{ name: string }>;
-  cursor: string;
-  list_complete: boolean;
-};
-
-type KVNamespace = {
-  get: {
-    (key: string): Promise<string | null>;
-    (key: string, type: 'json'): Promise<Record<string, unknown> | null>;
-    (key: string, type: 'arrayBuffer'): Promise<ArrayBuffer | null>;
-    (key: string, type: KvGetType): Promise<Record<string, unknown> | ArrayBuffer | string | null>;
-  };
-  put: (key: string, value: string, options?: KVNamespacePutOptions) => Promise<void>;
-  delete: (key: string) => Promise<void>;
-  list: (options: { prefix?: string; limit?: number; cursor?: string }) => Promise<KVListResult>;
-};
-
-type KvEnv = {
-  CACHE?: KVNamespace;
-  KV_NAMESPACE?: string;
-  APP_KEY?: string;
-  KV_REMOTE_SECRET?: string;
-  ZT_PROXY_SIGNING_WINDOW_MS?: string;
-  ZT_NONCES?: KVNamespace;
-  ZT_MAX_BODY_BYTES?: string;
-  ZT_KV_PREFIX?: string;
-  ZT_KV_LIST_LIMIT?: string;
-};
-
-type ListRequest = {
-  namespace?: string;
-  prefix?: string;
-  limit?: number;
-  cursor?: string;
-};
-
-const DEFAULT_SIGNING_WINDOW_MS = 60_000;
-const DEFAULT_MAX_BODY_BYTES = 128 * 1024;
-const DEFAULT_LIST_LIMIT = 100;
-
-const requireCache = (env: KvEnv): Response | KVNamespace => {
-  if (env.CACHE !== undefined && env.CACHE !== null) return env.CACHE;
-
-  const bindingName = normalizeBindingName(env.KV_NAMESPACE);
-  if (bindingName !== null) {
-    const record = env as unknown as Record<string, unknown>;
-    const kv = record[bindingName] as KVNamespace | undefined;
-    if (kv !== undefined && kv !== null) return kv;
-  }
-
-  return toErrorResponse(500, 'CONFIG_ERROR', 'Missing KV binding (CACHE)');
-};
-
-const normalizeNamespace = (value: unknown): string | undefined => {
-  if (!isString(value)) return undefined;
-  const trimmed = value.trim();
-  return trimmed === '' ? undefined : trimmed;
-};
-
-const buildStorageKey = (env: KvEnv, params: { namespace?: string; key: string }): string => {
-  const prefix = isString(env.ZT_KV_PREFIX) ? env.ZT_KV_PREFIX : '';
-  const namespace = normalizeNamespace(params.namespace);
-
-  const parts: string[] = [];
-  if (prefix.trim() !== '') parts.push(prefix.trim());
-  if (namespace !== undefined) parts.push(namespace);
-  parts.push(params.key);
-
-  return parts.join(':');
-};
-
-const resolveCacheRequest = async (
-  request: Request,
-  env: KvEnv
-): Promise<
-  | { ok: true; cache: KVNamespace; payload: Record<string, unknown> | null }
-  | { ok: false; response: Response }
-> => {
-  const check = await readAndVerifyJson(request, env, {
-    secretEnvVar: 'KV_REMOTE_SECRET',
-    missingSecretStatus: 500,
-    missingSecretMessage: 'Missing signing secret (KV_REMOTE_SECRET or APP_KEY)',
-    defaultSigningWindowMs: DEFAULT_SIGNING_WINDOW_MS,
-    defaultMaxBodyBytes: DEFAULT_MAX_BODY_BYTES,
-  });
-  if (!check.ok) return { ok: false, response: check.response };
-
-  const cache = requireCache(env);
-  if (cache instanceof Response) return { ok: false, response: cache };
-
-  return { ok: true, cache, payload: check.payload };
-};
-
-const parseGetPayload = (
-  payload: unknown
-):
-  | { ok: true; namespace?: string; key: string; type: KvGetType }
-  | { ok: false; response: Response } => {
-  if (!isObject(payload)) {
-    return { ok: false, response: toErrorResponse(400, 'VALIDATION_ERROR', 'Invalid body') };
-  }
-
-  const key = payload['key'];
-  const type = payload['type'];
-
-  if (!isString(key) || key.trim() === '') {
-    return { ok: false, response: toErrorResponse(400, 'VALIDATION_ERROR', 'key is required') };
-  }
-
-  const typeValue: KvGetType =
-    type === 'text' || type === 'arrayBuffer' || type === 'json' ? type : 'text';
-  return { ok: true, namespace: normalizeNamespace(payload['namespace']), key, type: typeValue };
-};
-
-const handleGet = async (request: Request, env: KvEnv): Promise<Response> => {
-  const resolved = await resolveCacheRequest(request, env);
-  if (!resolved.ok) return resolved.response;
-
-  const parsed = parseGetPayload(resolved.payload);
-  if (!parsed.ok) return parsed.response;
-
-  const storageKey = buildStorageKey(env, { namespace: parsed.namespace, key: parsed.key });
-  const startedAt = Date.now();
-
-  if (parsed.type === 'json') {
-    const value = await resolved.cache.get(storageKey, 'json');
-    SystemTraceWorkerBridge.emitCache(
-      'get',
-      storageKey,
-      Date.now() - startedAt,
-      value !== null,
-      value,
-      'kv-proxy'
-    );
-    return json(200, { value: value ?? null });
-  }
-
-  if (parsed.type === 'arrayBuffer') {
-    const value = await resolved.cache.get(storageKey, 'arrayBuffer');
-    SystemTraceWorkerBridge.emitCache(
-      'get',
-      storageKey,
-      Date.now() - startedAt,
-      value !== null,
-      value,
-      'kv-proxy'
-    );
-    return json(200, { value: value ?? null });
-  }
-
-  const value = await resolved.cache.get(storageKey);
-  SystemTraceWorkerBridge.emitCache(
-    'get',
-    storageKey,
-    Date.now() - startedAt,
-    value !== null,
-    value,
-    'kv-proxy'
-  );
-  return json(200, { value: value ?? null });
-};
-
-const parsePutPayload = (
-  payload: unknown
-):
-  | { ok: true; namespace?: string; key: string; value: unknown; ttlSeconds?: number }
-  | { ok: false; response: Response } => {
-  if (!isObject(payload)) {
-    return { ok: false, response: toErrorResponse(400, 'VALIDATION_ERROR', 'Invalid body') };
-  }
-
-  const key = payload['key'];
-  if (!isString(key) || key.trim() === '') {
-    return { ok: false, response: toErrorResponse(400, 'VALIDATION_ERROR', 'key is required') };
-  }
-
-  const ttlSeconds = payload['ttlSeconds'];
-  const ttl =
-    typeof ttlSeconds === 'number' && Number.isFinite(ttlSeconds) && ttlSeconds > 0
-      ? ttlSeconds
-      : undefined;
-
-  return {
-    ok: true,
-    namespace: normalizeNamespace(payload['namespace']),
-    key,
-    value: payload['value'],
-    ttlSeconds: ttl,
-  };
-};
-
-const handlePut = async (request: Request, env: KvEnv): Promise<Response> => {
-  const resolved = await resolveCacheRequest(request, env);
-  if (!resolved.ok) return resolved.response;
-
-  const parsed = parsePutPayload(resolved.payload);
-  if (!parsed.ok) return parsed.response;
-
-  const storageKey = buildStorageKey(env, { namespace: parsed.namespace, key: parsed.key });
-  const value = JSON.stringify(parsed.value);
-  const startedAt = Date.now();
-
-  const options: KVNamespacePutOptions = {};
-  if (parsed.ttlSeconds !== undefined) {
-    options.expirationTtl = Math.floor(parsed.ttlSeconds);
-  }
-
-  await resolved.cache.put(storageKey, value, options);
-  SystemTraceWorkerBridge.emitCache(
-    'set',
-    storageKey,
-    Date.now() - startedAt,
-    undefined,
-    parsed.value,
-    'kv-proxy',
-    parsed.ttlSeconds
-  );
-  return json(200, { ok: true });
-};
-
-const parseDeletePayload = (
-  payload: unknown
-): { ok: true; namespace?: string; key: string } | { ok: false; response: Response } => {
-  if (!isObject(payload)) {
-    return { ok: false, response: toErrorResponse(400, 'VALIDATION_ERROR', 'Invalid body') };
-  }
-
-  const key = payload['key'];
-  if (!isString(key) || key.trim() === '') {
-    return { ok: false, response: toErrorResponse(400, 'VALIDATION_ERROR', 'key is required') };
-  }
-
-  return { ok: true, namespace: normalizeNamespace(payload['namespace']), key };
-};
-
-const handleDelete = async (request: Request, env: KvEnv): Promise<Response> => {
-  const resolved = await resolveCacheRequest(request, env);
-  if (!resolved.ok) return resolved.response;
-
-  const parsed = parseDeletePayload(resolved.payload);
-  if (!parsed.ok) return parsed.response;
-
-  const storageKey = buildStorageKey(env, { namespace: parsed.namespace, key: parsed.key });
-  const startedAt = Date.now();
-  await resolved.cache.delete(storageKey);
-  SystemTraceWorkerBridge.emitCache(
-    'delete',
-    storageKey,
-    Date.now() - startedAt,
-    undefined,
-    undefined,
-    'kv-proxy'
-  );
-  return json(200, { ok: true });
-};
-
-const parseListPayload = (
-  payload: unknown
-): { ok: true; params: ListRequest } | { ok: false; response: Response } => {
-  if (payload === null) return { ok: true, params: {} };
-  if (!isObject(payload)) {
-    return { ok: false, response: toErrorResponse(400, 'VALIDATION_ERROR', 'Invalid body') };
-  }
-
-  const namespace = normalizeNamespace(payload['namespace']);
-  const prefix = isString(payload['prefix']) ? payload['prefix'] : undefined;
-  const cursor = isString(payload['cursor']) ? payload['cursor'] : undefined;
-  const limitRaw = payload['limit'];
-  const limitParsed =
-    typeof limitRaw === 'number' && Number.isFinite(limitRaw) ? Math.floor(limitRaw) : undefined;
-
-  return { ok: true, params: { namespace, prefix, cursor, limit: limitParsed } };
-};
-
-const handleList = async (request: Request, env: KvEnv): Promise<Response> => {
-  const resolved = await resolveCacheRequest(request, env);
-  if (!resolved.ok) return resolved.response;
-
-  const parsed = parseListPayload(resolved.payload);
-  if (!parsed.ok) return parsed.response;
-
-  const envLimit = getEnvInt(env, 'ZT_KV_LIST_LIMIT', DEFAULT_LIST_LIMIT);
-  const requested = parsed.params.limit ?? envLimit;
-  const limit = Math.max(1, Math.min(requested, envLimit));
-
-  const prefixKey = parsed.params.prefix;
-  const namespacePrefix = normalizeNamespace(parsed.params.namespace);
-  const basePrefix = buildStorageKey(env, { namespace: namespacePrefix, key: '' });
-  const fullPrefix = prefixKey === undefined ? basePrefix : `${basePrefix}${prefixKey}`;
-
-  const out = await resolved.cache.list({
-    prefix: fullPrefix,
-    limit,
-    cursor: parsed.params.cursor,
-  });
-
-  SystemTraceWorkerBridge.emitEvent('kv-proxy.list', 1, {
-    prefix: fullPrefix,
-    limit,
-    cursor: parsed.params.cursor,
-  });
-
-  return json(200, {
-    keys: out.keys.map((key) => key.name),
-    cursor: out.cursor,
-    listComplete: out.list_complete,
-  });
-};
-
-export const ZintrustKvProxy = Object.freeze({
-  _ZINTRUST_CLOUDFLARE_KV_PROXY_VERSION: '0.1.15',
-  _ZINTRUST_CLOUDFLARE_KV_PROXY_BUILD_DATE: '__BUILD_DATE__',
-  async fetch(request: Request, env: KvEnv): Promise<Response> {
-    const url = new URL(request.url);
-
-    const methodError = RequestValidator.requirePost(request.method);
-    if (methodError !== null) {
-      return toErrorResponse(405, methodError.code, 'Method not allowed');
-    }
-
-    switch (url.pathname) {
-      case '/zin/kv/get':
-        return handleGet(request, env);
-      case '/zin/kv/put':
-        return handlePut(request, env);
-      case '/zin/kv/delete':
-        return handleDelete(request, env);
-      case '/zin/kv/list':
-        return handleList(request, env);
-      default:
-        return toErrorResponse(404, 'NOT_FOUND', 'Not found');
-    }
-  },
-});
-
-export default ZintrustKvProxy;

package/src/proxy/kv/register.ts

@@ -1,6 +0,0 @@
-import { ProxyRegistry } from '@proxy/ProxyRegistry';
-
-ProxyRegistry.register({
-  name: 'kv',
-  description: 'Cloudflare KV Worker proxy endpoint',
-});

package/src/proxy/mongodb/MongoDBProxyServer.ts

@@ -1,337 +0,0 @@
-import { SystemTraceBridge } from '@/trace/SystemTraceBridge';
-import { Env } from '@config/env';
-import { Logger } from '@config/logger';
-import { ErrorFactory } from '@exceptions/ZintrustError';
-import type { IncomingMessage } from '@node-singletons/http';
-import { ErrorHandler } from '@proxy/ErrorHandler';
-import type { ProxyBackend, ProxyResponse } from '@proxy/ProxyBackend';
-import type { ProxySigningConfig } from '@proxy/ProxyConfig';
-import { createProxyServer } from '@proxy/ProxyServer';
-import { resolveProxySigningConfig } from '@proxy/ProxySigningConfigResolver';
-import { verifyProxySignatureIfNeeded } from '@proxy/ProxySigningRequest';
-import { RequestValidator } from '@proxy/RequestValidator';
-
-type MongoCollectionLike = Record<string, unknown>;
-type MongoDatabaseLike = {
-  collection: (name: string) => MongoCollectionLike;
-};
-type MongoClientLike = {
-  connect: () => Promise<void>;
-  db: (name: string) => MongoDatabaseLike;
-  close: () => Promise<void>;
-};
-
-type ProxyConfig = {
-  host: string;
-  port: number;
-  maxBodyBytes: number;
-  mongoOptions: {
-    uri: string;
-    database: string;
-  };
-  signing: ProxySigningConfig;
-};
-
-type ProxyOverrides = Partial<{
-  host: string;
-  port: number;
-  maxBodyBytes: number;
-  mongoUri: string;
-  mongoDb: string;
-  requireSigning: boolean;
-  keyId: string;
-  secret: string;
-  signingWindowMs: number;
-}>;
-
-const resolveProxyConfig = (
-  overrides: ProxyOverrides = {}
-): {
-  host: string;
-  port: number;
-  maxBodyBytes: number;
-} => {
-  const host = overrides?.host ?? Env.get('MONGODB_PROXY_HOST', Env.HOST ?? '127.0.0.1');
-  const port = overrides.port ?? Env.getInt('MONGODB_PROXY_PORT', Env.PORT ?? 3000);
-  const maxBodyBytes =
-    overrides.maxBodyBytes ?? Env.getInt('MONGODB_PROXY_MAX_BODY_BYTES', Env.MAX_BODY_SIZE ?? 0);
-
-  return { host, port, maxBodyBytes };
-};
-
-const resolveMongoConfig = (
-  overrides: ProxyOverrides = {}
-): {
-  uri: string;
-  database: string;
-} => {
-  const uri = overrides.mongoUri ?? Env.get('MONGO_URI', 'mongodb://localhost:27017');
-  const database = overrides.mongoDb ?? Env.get('MONGO_DB', 'zintrust');
-
-  return { uri, database };
-};
-
-const resolveSigningConfig = (
-  overrides: ProxyOverrides = {}
-): {
-  keyId: string;
-  secret: string;
-  requireSigning: boolean;
-  signingWindowMs: number;
-} =>
-  resolveProxySigningConfig(overrides, {
-    keyIdEnvVar: 'MONGODB_PROXY_KEY_ID',
-    secretEnvVar: 'MONGODB_PROXY_SECRET',
-    requireEnvVar: 'MONGODB_PROXY_REQUIRE_SIGNING',
-    windowEnvVar: 'MONGODB_PROXY_SIGNING_WINDOW_MS',
-  });
-
-const resolveConfig = (overrides: ProxyOverrides = {}): ProxyConfig => {
-  const proxyConfig = resolveProxyConfig(overrides);
-  const mongoConfig = resolveMongoConfig(overrides);
-  const signingConfig = resolveSigningConfig(overrides);
-
-  return {
-    host: proxyConfig.host,
-    port: proxyConfig.port,
-    maxBodyBytes: proxyConfig.maxBodyBytes,
-    mongoOptions: mongoConfig,
-    signing: {
-      keyId: signingConfig.keyId,
-      secret: signingConfig.secret,
-      require: signingConfig.requireSigning,
-      windowMs: signingConfig.signingWindowMs,
-    },
-  };
-};
-
-const validateOperationPayload = (
-  payload: Record<string, unknown>
-): {
-  valid: boolean;
-  operation?: string;
-  collection?: string;
-  args?: Record<string, unknown>;
-  error?: { code: string; message: string };
-} => {
-  const operation = payload['operation'];
-  const collection = payload['collection'];
-  const args = payload['args'];
-
-  if (typeof operation !== 'string' || operation.trim() === '') {
-    return {
-      valid: false,
-      error: { code: 'VALIDATION_ERROR', message: 'operation is required' },
-    };
-  }
-
-  if (typeof collection !== 'string' || collection.trim() === '') {
-    return {
-      valid: false,
-      error: { code: 'VALIDATION_ERROR', message: 'collection is required' },
-    };
-  }
-
-  return {
-    valid: true,
-    operation,
-    collection,
-    args: (args as Record<string, unknown>) ?? {},
-  };
-};
-
-const getMongoModule = async (): Promise<{ MongoClient: new (uri: string) => MongoClientLike }> => {
-  const mongoModule = (await import('mongodb')) as { MongoClient?: unknown };
-  const MongoDBClient = mongoModule.MongoClient;
-  if (typeof MongoDBClient !== 'function') {
-    throw ErrorFactory.createDatabaseError('MongoDB driver is unavailable');
-  }
-  return { MongoClient: MongoDBClient as new (uri: string) => MongoClientLike };
-};
-
-const createMongoClient = async (uri: string): Promise<MongoClientLike> => {
-  const { MongoClient: MongoDBClient } = await getMongoModule();
-  const client = new MongoDBClient(uri);
-  await client.connect();
-  return client;
-};
-
-const callMethod = async (
-  coll: MongoCollectionLike,
-  methodName: string,
-  ...params: unknown[]
-): Promise<unknown> => {
-  const method = (coll as unknown as Record<string, unknown>)[methodName];
-  if (typeof method === 'function') {
-    const result = (method as (...input: unknown[]) => unknown)(...params);
-    if (result !== null && typeof result === 'object' && 'toArray' in result) {
-      const toArray = (result as { toArray?: () => Promise<unknown> }).toArray;
-      if (typeof toArray === 'function') {
-        return toArray();
-      }
-    }
-    return result;
-  }
-  throw ErrorFactory.createDatabaseError(`Method ${methodName} not found on collection`);
-};
-
-const OPERATION_HANDLERS = Object.freeze({
-  find: async (coll: MongoCollectionLike, args: Record<string, unknown>) =>
-    callMethod(coll, 'find', args['filter'] ?? {}),
-  findOne: async (coll: MongoCollectionLike, args: Record<string, unknown>) =>
-    callMethod(coll, 'findOne', args['filter'] ?? {}),
-  insertOne: async (coll: MongoCollectionLike, args: Record<string, unknown>) =>
-    callMethod(coll, 'insertOne', args['document'] ?? {}),
-  insertMany: async (coll: MongoCollectionLike, args: Record<string, unknown>) =>
-    callMethod(coll, 'insertMany', (args['documents'] as unknown[]) ?? []),
-  updateOne: async (coll: MongoCollectionLike, args: Record<string, unknown>) =>
-    callMethod(coll, 'updateOne', args['filter'] ?? {}, args['update'] ?? {}),
-  updateMany: async (coll: MongoCollectionLike, args: Record<string, unknown>) =>
-    callMethod(coll, 'updateMany', args['filter'] ?? {}, args['update'] ?? {}),
-  deleteOne: async (coll: MongoCollectionLike, args: Record<string, unknown>) =>
-    callMethod(coll, 'deleteOne', args['filter'] ?? {}),
-  deleteMany: async (coll: MongoCollectionLike, args: Record<string, unknown>) =>
-    callMethod(coll, 'deleteMany', args['filter'] ?? {}),
-  countDocuments: async (coll: MongoCollectionLike, args: Record<string, unknown>) =>
-    callMethod(coll, 'countDocuments', args['filter'] ?? {}),
-  aggregate: async (coll: MongoCollectionLike, args: Record<string, unknown>) =>
-    callMethod(coll, 'aggregate', (args['pipeline'] as unknown[]) ?? []),
-} as const);
-
-const executeOperation = async (
-  client: MongoClientLike,
-  dbName: string,
-  collectionName: string,
-  operation: string,
-  args: Record<string, unknown>
-): Promise<unknown> => {
-  const db = client.db(dbName);
-  const coll = db.collection(collectionName);
-
-  if (Object.prototype.hasOwnProperty.call(OPERATION_HANDLERS, operation)) {
-    const handler = OPERATION_HANDLERS[operation as keyof typeof OPERATION_HANDLERS];
-    return handler(coll, args);
-  }
-
-  throw ErrorFactory.createDatabaseError(`Unsupported MongoDB operation: ${String(operation)}`);
-};
-
-const createBackend = (client: MongoClientLike, config: ProxyConfig): ProxyBackend => ({
-  name: 'mongodb',
-  handle: async (request) => {
-    const methodError = RequestValidator.requirePost(request.method);
-    if (methodError) {
-      return {
-        status: 405,
-        body: { code: methodError.code, message: methodError.message },
-      };
-    }
-
-    if (request.path !== '/zin/mongodb/operation') {
-      return { status: 404, body: { code: 'NOT_FOUND', message: 'Unknown endpoint' } };
-    }
-
-    const parsed = RequestValidator.parseJson(request.body);
-    if (!parsed.ok) {
-      return { status: 400, body: { code: parsed.error.code, message: parsed.error.message } };
-    }
-
-    const validated = validateOperationPayload(parsed.value);
-    if (!validated.valid) {
-      return {
-        status: 400,
-        body: {
-          code: validated.error?.code ?? 'VALIDATION_ERROR',
-          message: validated.error?.message ?? 'Invalid request',
-        },
-      };
-    }
-
-    try {
-      const startedAt = Date.now();
-      const result = await executeOperation(
-        client,
-        config.mongoOptions.database,
-        validated.collection ?? '',
-        validated.operation ?? '',
-        validated.args ?? {}
-      );
-
-      SystemTraceBridge.emitEvent('mongodb-proxy.operation', 1, {
-        operation: validated.operation,
-        collection: validated.collection,
-        args: validated.args,
-        duration: Date.now() - startedAt,
-      });
-
-      return { status: 200, body: { success: true, result } };
-    } catch (error) {
-      Logger.error('MongoDB proxy operation failed', { error });
-      return ErrorHandler.toProxyError(500, 'MONGODB_PROXY_ERROR', String(error));
-    }
-  },
-  health: async (): Promise<ProxyResponse> => {
-    try {
-      client.db(config.mongoOptions.database);
-      await Promise.resolve();
-      return { status: 200, body: { status: 'ok' } };
-    } catch (error) {
-      await Promise.resolve();
-      return { status: 503, body: { status: 'unhealthy', error: String(error) } };
-    }
-  },
-  shutdown: async (): Promise<void> => {
-    await client.close();
-  },
-});
-
-const createVerifier = (
-  config: ProxyConfig
-): ((
-  req: IncomingMessage,
-  body: string
-) => Promise<{ ok: true } | { ok: false; status: number; message: string }>) => {
-  return async (req, body) => {
-    const verified = await verifyProxySignatureIfNeeded(req, body, config.signing);
-    if (!verified.ok) {
-      const error = verified.error ?? { status: 401, message: 'Unauthorized' };
-      return { ok: false as const, status: error.status, message: error.message };
-    }
-
-    return { ok: true as const };
-  };
-};
-
-export const MongoDBProxyServer = Object.freeze({
-  async start(overrides: ProxyOverrides = {}) {
-    const config = resolveConfig(overrides);
-    Logger.info(
-      `Starting MongoDB proxy on ${config.host}:${config.port} → ${config.mongoOptions.uri}`
-    );
-
-    const client = await createMongoClient(config.mongoOptions.uri);
-    const backend = createBackend(client, config);
-    const verifier = createVerifier(config);
-
-    const server = createProxyServer({
-      host: config.host,
-      port: config.port,
-      maxBodyBytes: config.maxBodyBytes,
-      backend,
-      verify: verifier,
-    });
-
-    await server.start();
-    Logger.info(`✓ MongoDB proxy listening on ${config.host}:${config.port}`);
-
-    return {
-      server,
-      client,
-      async close() {
-        await server.stop();
-        await client.close();
-        Logger.info('MongoDB proxy server closed');
-      },
-    };
-  },
-});

package/src/proxy/mongodb/register.ts

@@ -1,5 +0,0 @@
-import { ProxyRegistry } from '@proxy/ProxyRegistry';
-ProxyRegistry.register({
-  name: 'mongodb',
-  description: 'MongoDB HTTP proxy',
-});