@kb-labs/shared-testing-platform 2.96.0

package/dist/index.js

@@ -0,0 +1,1175 @@
+import { resetPlatform, platform } from '@kb-labs/core-runtime';
+import { mockLogger, mockLLM, mockCache, mockStorage } from '@kb-labs/shared-testing';
+export { MockEmbeddings, mockCache, mockLLM, mockLogger, mockStorage } from '@kb-labs/shared-testing';
+import { vi } from 'vitest';
+
+// src/setup-platform.ts
+function setupTestPlatform(options = {}) {
+  resetPlatform();
+  const adapterMap = [
+    ["llm", options.llm],
+    ["cache", options.cache],
+    ["embeddings", options.embeddings],
+    ["vectorStore", options.vectorStore],
+    ["storage", options.storage],
+    ["analytics", options.analytics],
+    ["logger", options.logger],
+    ["eventBus", options.eventBus]
+  ];
+  for (const [key, instance] of adapterMap) {
+    if (instance !== void 0) {
+      platform.setAdapter(key, instance);
+    }
+  }
+  return {
+    platform,
+    cleanup: () => resetPlatform()
+  };
+}
+function createMockTrace() {
+  return {
+    traceId: "test-trace-id",
+    spanId: "test-span-id",
+    parentSpanId: void 0,
+    addEvent: () => {
+    },
+    setAttribute: () => {
+    },
+    recordError: () => {
+    }
+  };
+}
+function createMockUI() {
+  const messages = [];
+  const mockColor = (text) => text;
+  const mockColors = {
+    success: mockColor,
+    error: mockColor,
+    warning: mockColor,
+    info: mockColor,
+    primary: mockColor,
+    accent: mockColor,
+    highlight: mockColor,
+    secondary: mockColor,
+    emphasis: mockColor,
+    muted: mockColor,
+    foreground: mockColor,
+    dim: mockColor,
+    bold: mockColor,
+    underline: mockColor,
+    inverse: mockColor
+  };
+  return {
+    colors: mockColors,
+    symbols: {
+      success: "+",
+      error: "x",
+      warning: "!",
+      info: "i",
+      bullet: "-",
+      clock: "T",
+      folder: "D",
+      package: "P",
+      pointer: ">",
+      section: "#",
+      separator: "-",
+      border: "|",
+      topLeft: "+",
+      topRight: "+",
+      bottomLeft: "+",
+      bottomRight: "+",
+      leftT: "+",
+      rightT: "+",
+      step: "o",
+      stepDone: "*",
+      arrow: ">",
+      diamond: "<>"
+    },
+    write: vi.fn((text) => messages.push(`WRITE: ${text}`)),
+    info: vi.fn((msg) => messages.push(`INFO: ${msg}`)),
+    success: vi.fn((msg) => messages.push(`SUCCESS: ${msg}`)),
+    warn: vi.fn((msg) => messages.push(`WARN: ${msg}`)),
+    error: vi.fn((err) => messages.push(`ERROR: ${err instanceof Error ? err.message : err}`)),
+    debug: vi.fn((msg) => messages.push(`DEBUG: ${msg}`)),
+    spinner: vi.fn((msg) => {
+      messages.push(`SPINNER: ${msg}`);
+      return {
+        update: vi.fn((m) => messages.push(`SPINNER UPDATE: ${m}`)),
+        succeed: vi.fn((m) => messages.push(`SPINNER SUCCEED: ${m ?? msg}`)),
+        fail: vi.fn((m) => messages.push(`SPINNER FAIL: ${m ?? msg}`)),
+        stop: vi.fn()
+      };
+    }),
+    table: vi.fn((data) => messages.push(`TABLE: ${JSON.stringify(data)}`)),
+    json: vi.fn((data) => messages.push(`JSON: ${JSON.stringify(data)}`)),
+    newline: vi.fn(() => messages.push("")),
+    divider: vi.fn(() => messages.push("-".repeat(40))),
+    box: vi.fn((content, title) => {
+      if (title) {
+        messages.push(`+- ${title} -+`);
+      }
+      messages.push(content);
+      if (title) {
+        messages.push(`+${"-".repeat(title.length + 4)}+`);
+      }
+    }),
+    sideBox: vi.fn((options) => {
+      messages.push(`+- ${options.title} -+`);
+      if (options.summary) {
+        Object.entries(options.summary).forEach(([key, value]) => {
+          messages.push(`  ${key}: ${value}`);
+        });
+      }
+      if (options.sections) {
+        options.sections.forEach((section) => {
+          if (section.header) {
+            messages.push(`  ${section.header}:`);
+          }
+          section.items.forEach((item) => messages.push(`    ${item}`));
+        });
+      }
+      if (options.timing) {
+        messages.push(`  Timing: ${options.timing}ms`);
+      }
+      messages.push("+" + "-".repeat(options.title.length + 4) + "+");
+    }),
+    chain: vi.fn((items) => {
+      items.forEach((item) => messages.push(`CHAIN: ${item.title}`));
+    }),
+    confirm: vi.fn(async () => true),
+    prompt: vi.fn(async () => ""),
+    select: async (_msg, choices) => choices[0]?.value,
+    multiSelect: async (_msg, choices) => choices.filter((c) => c.checked).map((c) => c.value),
+    log: vi.fn()
+  };
+}
+function createMockRuntime() {
+  const mockFS = {
+    readFile: vi.fn(async () => ""),
+    readFileBuffer: vi.fn(async () => new Uint8Array()),
+    writeFile: vi.fn(async () => {
+    }),
+    readdir: vi.fn(async () => []),
+    readdirWithStats: vi.fn(async () => []),
+    mkdir: vi.fn(async () => {
+    }),
+    rm: vi.fn(async () => {
+    }),
+    copy: vi.fn(async () => {
+    }),
+    move: vi.fn(async () => {
+    }),
+    glob: vi.fn(async () => []),
+    stat: vi.fn(async () => ({
+      isFile: () => false,
+      isDirectory: () => false,
+      size: 0,
+      mtime: Date.now(),
+      ctime: Date.now()
+    })),
+    exists: vi.fn(async () => false),
+    resolve: (path) => path,
+    relative: (path) => path,
+    join: (...segments) => segments.join("/"),
+    dirname: (path) => path.split("/").slice(0, -1).join("/"),
+    basename: (path) => path.split("/").pop() ?? "",
+    extname: (path) => {
+      const base = path.split("/").pop() ?? "";
+      const idx = base.lastIndexOf(".");
+      return idx > 0 ? base.slice(idx) : "";
+    }
+  };
+  const mockFetch = vi.fn(async () => new Response("mock"));
+  const mockEnv = vi.fn((_key) => void 0);
+  return {
+    fs: mockFS,
+    fetch: mockFetch,
+    env: mockEnv
+  };
+}
+function createMockEnvironmentAPI() {
+  return {
+    create: vi.fn(async () => ({
+      environmentId: "env_mock_1",
+      provider: "mock",
+      status: "ready",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    })),
+    status: vi.fn(async (environmentId) => ({
+      environmentId,
+      status: "ready",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    })),
+    destroy: vi.fn(async () => {
+    }),
+    renewLease: vi.fn(async () => ({
+      leaseId: "lease_mock_1",
+      acquiredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      expiresAt: new Date(Date.now() + 10 * 60 * 1e3).toISOString()
+    }))
+  };
+}
+function createMockWorkspaceAPI() {
+  return {
+    materialize: vi.fn(async () => ({
+      workspaceId: "ws_mock_1",
+      provider: "mock",
+      status: "ready",
+      rootPath: "/tmp/ws_mock_1",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    })),
+    attach: vi.fn(async (request) => ({
+      workspaceId: request.workspaceId,
+      environmentId: request.environmentId,
+      mountPath: request.mountPath ?? "/workspace",
+      attachedAt: (/* @__PURE__ */ new Date()).toISOString()
+    })),
+    release: vi.fn(async () => {
+    }),
+    status: vi.fn(async (workspaceId) => ({
+      workspaceId,
+      status: "ready",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }))
+  };
+}
+function createMockSnapshotAPI() {
+  return {
+    capture: vi.fn(async (request) => ({
+      snapshotId: request.snapshotId ?? "snap_mock_1",
+      provider: "mock",
+      status: "ready",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      workspaceId: request.workspaceId,
+      environmentId: request.environmentId
+    })),
+    restore: vi.fn(async (request) => ({
+      snapshotId: request.snapshotId,
+      restoredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      workspaceId: request.workspaceId,
+      environmentId: request.environmentId,
+      targetPath: request.targetPath
+    })),
+    status: vi.fn(async (snapshotId) => ({
+      snapshotId,
+      status: "ready",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    })),
+    delete: vi.fn(async () => {
+    }),
+    gc: vi.fn(async (request) => ({
+      scanned: 0,
+      deleted: 0,
+      dryRun: request?.dryRun ?? false
+    }))
+  };
+}
+function createInfraApiMocks() {
+  return {
+    environment: createMockEnvironmentAPI(),
+    workspace: createMockWorkspaceAPI(),
+    snapshot: createMockSnapshotAPI()
+  };
+}
+function createMockPluginAPI() {
+  const infra = createInfraApiMocks();
+  return {
+    lifecycle: {
+      onCleanup: vi.fn()
+    },
+    state: {
+      get: vi.fn(async () => void 0),
+      set: vi.fn(async () => {
+      }),
+      delete: vi.fn(async () => {
+      }),
+      has: vi.fn(async () => false),
+      getMany: vi.fn(async () => /* @__PURE__ */ new Map()),
+      setMany: vi.fn(async () => {
+      })
+    },
+    artifacts: {
+      write: vi.fn(async () => "/mock/path"),
+      list: vi.fn(async () => []),
+      read: vi.fn(async () => ""),
+      readBuffer: vi.fn(async () => new Uint8Array()),
+      exists: vi.fn(async () => false),
+      path: vi.fn(() => "/mock/path")
+    },
+    shell: {
+      exec: vi.fn(async () => ({ code: 0, stdout: "", stderr: "", ok: true }))
+    },
+    events: {
+      emit: vi.fn(async () => {
+      })
+    },
+    invoke: {
+      call: vi.fn(async (_pluginId, _input, _options) => void 0)
+    },
+    workflows: {
+      run: vi.fn(async () => "mock-run-id"),
+      wait: vi.fn(async () => void 0),
+      status: vi.fn(async () => null),
+      cancel: vi.fn(async () => {
+      }),
+      list: vi.fn(async () => [])
+    },
+    jobs: {
+      submit: vi.fn(async () => "mock-job-id"),
+      schedule: vi.fn(async () => "mock-scheduled-job-id"),
+      wait: vi.fn(async () => void 0),
+      status: vi.fn(async () => null),
+      cancel: vi.fn(async () => false),
+      list: vi.fn(async () => [])
+    },
+    cron: {
+      register: vi.fn(async () => {
+      }),
+      unregister: vi.fn(async () => {
+      }),
+      list: vi.fn(async () => []),
+      pause: vi.fn(async () => {
+      }),
+      resume: vi.fn(async () => {
+      }),
+      trigger: vi.fn(async () => {
+      })
+    },
+    environment: infra.environment,
+    workspace: infra.workspace,
+    snapshot: infra.snapshot
+  };
+}
+var createMockPlatformApi = createMockPluginAPI;
+function createMockPluginContextV3(options = {}) {
+  return createTestContext(options);
+}
+function createTestContext(options = {}) {
+  const {
+    pluginId = "test-plugin",
+    pluginVersion = "0.0.0",
+    host = "cli",
+    hostContext,
+    config,
+    cwd = process.cwd(),
+    outdir,
+    tenantId,
+    signal,
+    platform: platformOverrides,
+    ui: uiOverrides,
+    syncSingleton = true
+  } = options;
+  const resolvedOutdir = outdir ?? `${cwd}/.kb/output`;
+  const defaultHostContext = hostContext ?? (() => {
+    switch (host) {
+      case "cli":
+        return { host: "cli", argv: ["test"], flags: {} };
+      case "rest":
+        return {
+          host: "rest",
+          method: "GET",
+          path: "/test",
+          requestId: "test-req-001",
+          traceId: "test-trace-001"
+        };
+      case "workflow":
+        return { host: "workflow", workflowId: "test-wf", runId: "test-run", stepId: "test-step" };
+      case "webhook":
+        return { host: "webhook", event: "test:event", namespaceId: "test-ns", webhookId: "test-webhook-001" };
+    }
+  })();
+  const defaultLogger = mockLogger();
+  const defaultLLM = mockLLM();
+  const defaultCache = mockCache();
+  const defaultStorage = mockStorage();
+  const defaultPlatform = {
+    logger: defaultLogger,
+    llm: defaultLLM,
+    embeddings: {
+      embed: vi.fn(async () => []),
+      embedBatch: vi.fn(async () => [[]]),
+      dimensions: 1536,
+      getDimensions: vi.fn(async () => 1536)
+    },
+    vectorStore: {
+      search: vi.fn(async () => []),
+      upsert: vi.fn(async () => {
+      }),
+      delete: vi.fn(async () => {
+      }),
+      count: vi.fn(async () => 0)
+    },
+    cache: defaultCache,
+    storage: defaultStorage,
+    analytics: {
+      track: vi.fn(async () => {
+      }),
+      identify: vi.fn(async () => {
+      }),
+      flush: vi.fn(async () => {
+      })
+    },
+    eventBus: {
+      publish: vi.fn(async () => {
+      }),
+      subscribe: vi.fn(() => () => {
+      })
+    },
+    config: {
+      getConfig: vi.fn(async () => ({})),
+      getRawConfig: vi.fn(async () => ({}))
+    },
+    invoke: {
+      call: vi.fn(async () => ({ success: true, data: null })),
+      isAvailable: vi.fn(async () => false)
+    },
+    documentDatabase: {
+      find: vi.fn(async () => []),
+      findStream: vi.fn(async function* () {
+      }),
+      findById: vi.fn(async () => null),
+      count: vi.fn(async () => 0),
+      insertOne: vi.fn(async () => ({ id: "mock", createdAt: 0, updatedAt: 0 })),
+      insertMany: vi.fn(async () => []),
+      updateOne: vi.fn(async () => null),
+      updateMany: vi.fn(async () => 0),
+      updateById: vi.fn(async () => null),
+      deleteMany: vi.fn(async () => 0),
+      deleteById: vi.fn(async () => false),
+      bulkWrite: vi.fn(async () => ({ inserted: 0, updated: 0, deleted: 0 })),
+      transaction: vi.fn(async () => void 0),
+      ensureCollection: vi.fn(async () => void 0),
+      ping: vi.fn(async () => ({ ok: true, latencyMs: 0 })),
+      close: vi.fn(async () => {
+      })
+    },
+    kvStore: {
+      get: vi.fn(async () => null),
+      getMany: vi.fn(async () => []),
+      set: vi.fn(async () => true),
+      setMany: vi.fn(async () => {
+      }),
+      setIfNotExists: vi.fn(async () => true),
+      delete: vi.fn(async () => false),
+      exists: vi.fn(async () => false),
+      cas: vi.fn(async () => false),
+      incr: vi.fn(async () => 0),
+      ttl: vi.fn(async () => null),
+      expire: vi.fn(async () => false),
+      persist: vi.fn(async () => false),
+      scan: vi.fn(async function* () {
+      }),
+      ping: vi.fn(async () => ({ ok: true, latencyMs: 0 })),
+      close: vi.fn(async () => {
+      })
+    },
+    logs: {
+      query: vi.fn(async () => ({ logs: [], total: 0, hasMore: false, source: "buffer" })),
+      getById: vi.fn(async () => null),
+      search: vi.fn(async () => ({ logs: [], total: 0, hasMore: false })),
+      subscribe: vi.fn(() => () => {
+      }),
+      getStats: vi.fn(async () => ({})),
+      getCapabilities: vi.fn(() => ({ hasBuffer: false, hasPersistence: false, hasSearch: false, hasStreaming: false }))
+    }
+  };
+  const finalPlatform = {
+    ...defaultPlatform,
+    ...platformOverrides
+  };
+  let cleanupFn = () => {
+  };
+  if (syncSingleton) {
+    const result = setupTestPlatform({
+      llm: finalPlatform.llm,
+      cache: finalPlatform.cache,
+      storage: finalPlatform.storage,
+      logger: finalPlatform.logger,
+      analytics: finalPlatform.analytics,
+      embeddings: finalPlatform.embeddings,
+      vectorStore: finalPlatform.vectorStore,
+      eventBus: finalPlatform.eventBus
+    });
+    cleanupFn = result.cleanup;
+  }
+  const defaultUI = createMockUI();
+  const finalUI = {
+    ...defaultUI,
+    ...uiOverrides
+  };
+  const ctx = {
+    host,
+    requestId: "test-trace:test-span",
+    pluginId,
+    pluginVersion,
+    tenantId,
+    cwd,
+    outdir: resolvedOutdir,
+    config,
+    signal,
+    trace: createMockTrace(),
+    hostContext: defaultHostContext,
+    ui: finalUI,
+    platform: finalPlatform,
+    runtime: createMockRuntime(),
+    api: createMockPluginAPI()
+  };
+  return { ctx, cleanup: cleanupFn };
+}
+
+// src/test-command.ts
+async function testCommand(handler, options = {}) {
+  const {
+    flags,
+    argv = [],
+    query,
+    body,
+    params,
+    input: rawInput,
+    host = "cli",
+    config,
+    cwd,
+    tenantId,
+    signal,
+    platform: platform2,
+    ui,
+    syncSingleton = true
+  } = options;
+  const ctxOptions = {
+    host,
+    config,
+    cwd,
+    tenantId,
+    signal,
+    platform: platform2,
+    ui,
+    syncSingleton
+  };
+  const { ctx, cleanup } = createTestContext(ctxOptions);
+  let input;
+  if (rawInput !== void 0) {
+    input = rawInput;
+  } else if (host === "rest") {
+    input = {
+      ...query !== void 0 ? { query } : {},
+      ...body !== void 0 ? { body } : {},
+      ...params !== void 0 ? { params } : {}
+    };
+  } else {
+    input = { flags: flags ?? {}, argv };
+  }
+  let raw;
+  try {
+    raw = await handler.execute(ctx, input);
+  } finally {
+    await handler.cleanup?.();
+  }
+  let exitCode = 0;
+  let result;
+  let meta;
+  if (raw != null && typeof raw === "object" && "exitCode" in raw) {
+    const cmdResult = raw;
+    exitCode = cmdResult.exitCode;
+    result = cmdResult.result;
+    meta = cmdResult.meta;
+  } else if (raw === void 0 || raw === null) {
+    exitCode = 0;
+    result = void 0;
+    meta = void 0;
+  } else {
+    exitCode = 0;
+    result = raw;
+    meta = void 0;
+  }
+  return {
+    exitCode,
+    result,
+    meta,
+    raw,
+    ui: ctx.ui,
+    ctx,
+    cleanup
+  };
+}
+
+// src/in-memory-document-database.ts
+function nextId() {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function clone(value) {
+  return value === void 0 || value === null ? value : JSON.parse(JSON.stringify(value));
+}
+function matchScalar(value, ops) {
+  if (ops === null || ops === void 0 || typeof ops !== "object") {
+    return value === ops;
+  }
+  const o = ops;
+  if ("$eq" in o && o.$eq !== void 0 && value !== o.$eq) {
+    return false;
+  }
+  if ("$ne" in o && o.$ne !== void 0 && value === o.$ne) {
+    return false;
+  }
+  if ("$gt" in o && o.$gt !== void 0 && !(value > o.$gt)) {
+    return false;
+  }
+  if ("$gte" in o && o.$gte !== void 0 && !(value >= o.$gte)) {
+    return false;
+  }
+  if ("$lt" in o && o.$lt !== void 0 && !(value < o.$lt)) {
+    return false;
+  }
+  if ("$lte" in o && o.$lte !== void 0 && !(value <= o.$lte)) {
+    return false;
+  }
+  if ("$in" in o && Array.isArray(o.$in) && !o.$in.includes(value)) {
+    return false;
+  }
+  if ("$nin" in o && Array.isArray(o.$nin) && o.$nin.includes(value)) {
+    return false;
+  }
+  if ("$exists" in o && typeof o.$exists === "boolean") {
+    const present = value !== void 0;
+    if (present !== o.$exists) {
+      return false;
+    }
+  }
+  if ("$startsWith" in o && typeof o.$startsWith === "string") {
+    if (typeof value !== "string" || !value.startsWith(o.$startsWith)) {
+      return false;
+    }
+  }
+  if ("$contains" in o && typeof o.$contains === "string") {
+    if (typeof value !== "string" || !value.includes(o.$contains)) {
+      return false;
+    }
+  }
+  if ("$endsWith" in o && typeof o.$endsWith === "string") {
+    if (typeof value !== "string" || !value.endsWith(o.$endsWith)) {
+      return false;
+    }
+  }
+  return true;
+}
+function matchFilter(doc, filter) {
+  const source = doc;
+  if (filter.$and && Array.isArray(filter.$and)) {
+    if (!filter.$and.every((f) => matchFilter(doc, f))) {
+      return false;
+    }
+  }
+  if (filter.$or && Array.isArray(filter.$or)) {
+    if (!filter.$or.some((f) => matchFilter(doc, f))) {
+      return false;
+    }
+  }
+  for (const key of Object.keys(filter)) {
+    if (key === "$and" || key === "$or") {
+      continue;
+    }
+    const fieldValue = source[key];
+    const expectation = filter[key];
+    if (!matchScalar(fieldValue, expectation)) {
+      return false;
+    }
+  }
+  return true;
+}
+function applyUpdate(doc, update) {
+  const next = { ...doc };
+  if (update.$set) {
+    for (const [k, v] of Object.entries(update.$set)) {
+      next[k] = v;
+    }
+  }
+  if (update.$unset) {
+    for (const k of Object.keys(update.$unset)) {
+      delete next[k];
+    }
+  }
+  if (update.$inc) {
+    for (const [k, delta] of Object.entries(update.$inc)) {
+      const current = typeof next[k] === "number" ? next[k] : 0;
+      if (typeof delta !== "number" || !Number.isFinite(delta)) {
+        throw new Error(`$inc value for "${k}" must be a finite number`);
+      }
+      next[k] = current + delta;
+    }
+  }
+  next.updatedAt = Date.now();
+  return next;
+}
+function applyProjection(doc, projection) {
+  if (!projection) {
+    return doc;
+  }
+  const entries = Object.entries(projection);
+  const includes = entries.filter(([, v]) => v === 1).map(([k]) => k);
+  const excludes = entries.filter(([, v]) => v === 0).map(([k]) => k);
+  if (includes.length > 0 && excludes.length > 0) {
+    throw new Error("projection cannot mix include (1) and exclude (0)");
+  }
+  const source = doc;
+  if (includes.length > 0) {
+    const out2 = {};
+    for (const k of includes) {
+      out2[k] = source[k];
+    }
+    return out2;
+  }
+  const out = { ...source };
+  for (const k of excludes) {
+    delete out[k];
+  }
+  return out;
+}
+function sortDocs(docs, sort) {
+  if (!sort) {
+    return docs;
+  }
+  const entries = Object.entries(sort);
+  return [...docs].sort((a, b) => {
+    for (const [field, dir] of entries) {
+      const av = a[field];
+      const bv = b[field];
+      if (av === bv) {
+        continue;
+      }
+      const cmp = av < bv ? -1 : 1;
+      return dir === 1 ? cmp : -cmp;
+    }
+    return 0;
+  });
+}
+function checkUniqueIndexes(collection, doc, ignoreId) {
+  for (const idx of collection.indexes) {
+    if (!idx.unique) {
+      continue;
+    }
+    const paths = Array.isArray(idx.path) ? idx.path : [idx.path];
+    const newKey = paths.map((p) => JSON.stringify(doc[p])).join("|");
+    for (const existing of collection.docs.values()) {
+      if (ignoreId !== void 0 && existing.id === ignoreId) {
+        continue;
+      }
+      const existingKey = paths.map((p) => JSON.stringify(existing[p])).join("|");
+      if (existingKey === newKey) {
+        throw new Error(`unique index violation on [${paths.join(", ")}]`);
+      }
+    }
+  }
+}
+var InMemoryDocumentDatabase = class {
+  collections = /* @__PURE__ */ new Map();
+  now;
+  closed = false;
+  constructor(opts = {}) {
+    this.now = opts.now ?? (() => Date.now());
+  }
+  getCollection(name) {
+    let c = this.collections.get(name);
+    if (!c) {
+      c = { docs: /* @__PURE__ */ new Map(), indexes: [] };
+      this.collections.set(name, c);
+    }
+    return c;
+  }
+  throwIfClosed() {
+    if (this.closed) {
+      throw new Error("InMemoryDocumentDatabase is closed");
+    }
+  }
+  async ensureCollection(name, options) {
+    this.throwIfClosed();
+    const c = this.getCollection(name);
+    if (options?.indexes) {
+      for (const idx of options.indexes) {
+        const paths = Array.isArray(idx.path) ? idx.path.join(",") : idx.path;
+        const exists = c.indexes.some((existing) => {
+          const existingPaths = Array.isArray(existing.path) ? existing.path.join(",") : existing.path;
+          return existingPaths === paths;
+        });
+        if (!exists) {
+          c.indexes.push(idx);
+        }
+      }
+    }
+  }
+  async find(collection, filter, options) {
+    this.throwIfClosed();
+    const c = this.getCollection(collection);
+    let docs = Array.from(c.docs.values());
+    docs = docs.filter((d) => matchFilter(d, filter));
+    docs = sortDocs(docs, options?.sort);
+    if (options?.skip) {
+      docs = docs.slice(options.skip);
+    }
+    if (options?.limit !== void 0) {
+      docs = docs.slice(0, options.limit);
+    }
+    return docs.map((d) => applyProjection(clone(d), options?.project));
+  }
+  findStream(collection, filter, options) {
+    const self = this;
+    return {
+      async *[Symbol.asyncIterator]() {
+        const results = await self.find(collection, filter, options);
+        for (const r of results) {
+          yield r;
+        }
+      }
+    };
+  }
+  async findById(collection, id) {
+    this.throwIfClosed();
+    const doc = this.getCollection(collection).docs.get(id);
+    return doc ? clone(doc) : null;
+  }
+  async count(collection, filter) {
+    this.throwIfClosed();
+    const docs = Array.from(this.getCollection(collection).docs.values());
+    return docs.filter((d) => matchFilter(d, filter)).length;
+  }
+  async insertOne(collection, doc) {
+    this.throwIfClosed();
+    const c = this.getCollection(collection);
+    const now = this.now();
+    const full = { ...doc, id: nextId(), createdAt: now, updatedAt: now };
+    checkUniqueIndexes(c, full);
+    c.docs.set(full.id, clone(full));
+    return clone(full);
+  }
+  async insertMany(collection, docs) {
+    this.throwIfClosed();
+    const c = this.getCollection(collection);
+    const now = this.now();
+    const staged = [];
+    for (const d of docs) {
+      const full = { ...d, id: nextId(), createdAt: now, updatedAt: now };
+      checkUniqueIndexes(c, full);
+      for (const s of staged) {
+        try {
+          checkUniqueIndexes({ docs: /* @__PURE__ */ new Map([[s.id, s]]), indexes: c.indexes }, full);
+        } catch (e) {
+          throw e;
+        }
+      }
+      staged.push(full);
+    }
+    for (const s of staged) {
+      c.docs.set(s.id, clone(s));
+    }
+    return staged.map(clone);
+  }
+  async updateOne(collection, filter, update, options) {
+    this.throwIfClosed();
+    const c = this.getCollection(collection);
+    for (const existing of c.docs.values()) {
+      if (matchFilter(existing, filter)) {
+        const next = applyUpdate(existing, update);
+        checkUniqueIndexes(c, next, existing.id);
+        c.docs.set(existing.id, clone(next));
+        return clone(next);
+      }
+    }
+    if (options?.upsert) {
+      const now = this.now();
+      const seed = { id: nextId(), createdAt: now, updatedAt: now };
+      for (const [k, v] of Object.entries(filter)) {
+        if (k === "$and" || k === "$or") {
+          continue;
+        }
+        if (v !== null && typeof v === "object") {
+          continue;
+        }
+        seed[k] = v;
+      }
+      const next = applyUpdate(seed, update);
+      checkUniqueIndexes(c, next);
+      c.docs.set(next.id, clone(next));
+      return clone(next);
+    }
+    return null;
+  }
+  async updateMany(collection, filter, update) {
+    this.throwIfClosed();
+    const c = this.getCollection(collection);
+    let n = 0;
+    for (const existing of c.docs.values()) {
+      if (matchFilter(existing, filter)) {
+        const next = applyUpdate(existing, update);
+        checkUniqueIndexes(c, next, existing.id);
+        c.docs.set(existing.id, clone(next));
+        n++;
+      }
+    }
+    return n;
+  }
+  async updateById(collection, id, update) {
+    this.throwIfClosed();
+    const c = this.getCollection(collection);
+    const existing = c.docs.get(id);
+    if (!existing) {
+      return null;
+    }
+    const next = applyUpdate(existing, update);
+    checkUniqueIndexes(c, next, id);
+    c.docs.set(id, clone(next));
+    return clone(next);
+  }
+  async deleteMany(collection, filter) {
+    this.throwIfClosed();
+    const c = this.getCollection(collection);
+    let n = 0;
+    for (const [id, doc] of c.docs) {
+      if (matchFilter(doc, filter)) {
+        c.docs.delete(id);
+        n++;
+      }
+    }
+    return n;
+  }
+  async deleteById(collection, id) {
+    this.throwIfClosed();
+    return this.getCollection(collection).docs.delete(id);
+  }
+  async bulkWrite(collection, ops) {
+    this.throwIfClosed();
+    const c = this.getCollection(collection);
+    const snapshot = new Map(c.docs);
+    const result = { inserted: 0, updated: 0, deleted: 0 };
+    try {
+      for (const op of ops) {
+        if (op.type === "insert") {
+          await this.insertOne(collection, op.doc);
+          result.inserted++;
+        } else if (op.type === "update") {
+          const target = await this.updateOne(collection, op.filter, op.update, { upsert: op.upsert });
+          if (target) {
+            result.updated++;
+          }
+        } else {
+          result.deleted += await this.deleteMany(collection, op.filter);
+        }
+      }
+      return result;
+    } catch (err) {
+      c.docs.clear();
+      for (const [k, v] of snapshot) {
+        c.docs.set(k, v);
+      }
+      throw err;
+    }
+  }
+  async transaction(fn) {
+    this.throwIfClosed();
+    const snapshot = /* @__PURE__ */ new Map();
+    for (const [name, c] of this.collections) {
+      snapshot.set(name, new Map(c.docs));
+    }
+    const tx = {
+      find: this.find.bind(this),
+      findById: this.findById.bind(this),
+      count: this.count.bind(this),
+      insertOne: this.insertOne.bind(this),
+      insertMany: this.insertMany.bind(this),
+      updateOne: this.updateOne.bind(this),
+      updateMany: this.updateMany.bind(this),
+      updateById: this.updateById.bind(this),
+      deleteMany: this.deleteMany.bind(this),
+      deleteById: this.deleteById.bind(this)
+    };
+    try {
+      return await fn(tx);
+    } catch (err) {
+      for (const [name, docs] of snapshot) {
+        const c = this.collections.get(name);
+        if (c) {
+          c.docs.clear();
+          for (const [k, v] of docs) {
+            c.docs.set(k, v);
+          }
+        }
+      }
+      throw err;
+    }
+  }
+  async ping() {
+    return { ok: !this.closed, latencyMs: 0 };
+  }
+  async close() {
+    this.closed = true;
+  }
+};
+function createInMemoryDocumentDatabase(opts) {
+  return new InMemoryDocumentDatabase(opts);
+}
+
+// src/in-memory-kv-store.ts
+var InMemoryKVStore = class {
+  map = /* @__PURE__ */ new Map();
+  closed = false;
+  throwIfClosed() {
+    if (this.closed) {
+      throw new Error("InMemoryKVStore is closed");
+    }
+  }
+  isExpired(entry, at = Date.now()) {
+    return entry.expiresAt !== null && entry.expiresAt <= at;
+  }
+  getLive(key) {
+    const e = this.map.get(key);
+    if (!e) {
+      return null;
+    }
+    if (this.isExpired(e)) {
+      this.map.delete(key);
+      return null;
+    }
+    return e;
+  }
+  async get(key) {
+    this.throwIfClosed();
+    if (typeof key !== "string" || key.length === 0) {
+      throw new Error("KV key must be a non-empty string");
+    }
+    const e = this.getLive(key);
+    return e ? e.value : null;
+  }
+  async getMany(keys) {
+    this.throwIfClosed();
+    return Promise.all(keys.map((k) => this.get(k)));
+  }
+  async set(key, value, options) {
+    this.throwIfClosed();
+    if (typeof key !== "string" || key.length === 0) {
+      throw new Error("KV key must be a non-empty string");
+    }
+    if (options?.ifNotExists && options?.ifExists) {
+      throw new Error("ifNotExists and ifExists are mutually exclusive");
+    }
+    const present = this.getLive(key) !== null;
+    if (options?.ifNotExists && present) {
+      return false;
+    }
+    if (options?.ifExists && !present) {
+      return false;
+    }
+    const expiresAt = typeof options?.ttlMs === "number" ? Date.now() + options.ttlMs : null;
+    this.map.set(key, { value, expiresAt });
+    return true;
+  }
+  async setMany(entries) {
+    this.throwIfClosed();
+    for (const e of entries) {
+      if (typeof e.key !== "string" || e.key.length === 0) {
+        throw new Error("KV key must be a non-empty string");
+      }
+    }
+    const now = Date.now();
+    for (const e of entries) {
+      this.map.set(e.key, {
+        value: e.value,
+        expiresAt: typeof e.ttlMs === "number" ? now + e.ttlMs : null
+      });
+    }
+  }
+  async setIfNotExists(key, value, options) {
+    return this.set(key, value, { ttlMs: options?.ttlMs, ifNotExists: true });
+  }
+  async delete(key) {
+    this.throwIfClosed();
+    const existed = this.getLive(key) !== null;
+    this.map.delete(key);
+    return existed;
+  }
+  async exists(key) {
+    this.throwIfClosed();
+    return this.getLive(key) !== null;
+  }
+  async cas(key, expected, next, options) {
+    this.throwIfClosed();
+    const current = this.getLive(key);
+    const currentValue = current ? current.value : null;
+    if (JSON.stringify(currentValue) !== JSON.stringify(expected)) {
+      return false;
+    }
+    const expiresAt = typeof options?.ttlMs === "number" ? Date.now() + options.ttlMs : current?.expiresAt ?? null;
+    this.map.set(key, { value: next, expiresAt });
+    return true;
+  }
+  async incr(key, delta = 1, options) {
+    this.throwIfClosed();
+    if (!Number.isFinite(delta)) {
+      throw new Error("incr delta must be a finite number");
+    }
+    const current = this.getLive(key);
+    if (current && typeof current.value !== "number") {
+      throw new Error(`incr target "${key}" is not a number`);
+    }
+    const nextValue = (current ? current.value : 0) + delta;
+    const expiresAt = typeof options?.ttlMs === "number" ? Date.now() + options.ttlMs : current?.expiresAt ?? null;
+    this.map.set(key, { value: nextValue, expiresAt });
+    return nextValue;
+  }
+  async ttl(key) {
+    this.throwIfClosed();
+    const e = this.getLive(key);
+    if (!e || e.expiresAt === null) {
+      return null;
+    }
+    return Math.max(0, e.expiresAt - Date.now());
+  }
+  async expire(key, ttlMs) {
+    this.throwIfClosed();
+    const e = this.getLive(key);
+    if (!e) {
+      return false;
+    }
+    e.expiresAt = Date.now() + ttlMs;
+    return true;
+  }
+  async persist(key) {
+    this.throwIfClosed();
+    const e = this.getLive(key);
+    if (!e) {
+      return false;
+    }
+    e.expiresAt = null;
+    return true;
+  }
+  scan(prefix = "", _options) {
+    const self = this;
+    return {
+      async *[Symbol.asyncIterator]() {
+        self.throwIfClosed();
+        for (const [key, entry] of [...self.map.entries()]) {
+          if (self.isExpired(entry)) {
+            self.map.delete(key);
+            continue;
+          }
+          if (!key.startsWith(prefix)) {
+            continue;
+          }
+          yield { key, value: entry.value };
+        }
+      }
+    };
+  }
+  async ping() {
+    return { ok: !this.closed, latencyMs: 0 };
+  }
+  async close() {
+    this.closed = true;
+  }
+};
+function createInMemoryKVStore() {
+  return new InMemoryKVStore();
+}
+
+export { InMemoryDocumentDatabase, InMemoryKVStore, createInMemoryDocumentDatabase, createInMemoryKVStore, createInfraApiMocks, createMockEnvironmentAPI, createMockPlatformApi, createMockPluginAPI, createMockPluginContextV3, createMockRuntime, createMockSnapshotAPI, createMockTrace, createMockUI, createMockWorkspaceAPI, createTestContext, setupTestPlatform, testCommand };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map