context-mode 1.0.14 → 1.0.16

package/build/adapters/cursor/index.js

@@ -0,0 +1,413 @@
+/**
+ * adapters/cursor — Cursor platform adapter.
+ *
+ * Native Cursor hooks use lower-camel hook names and flat command entries in
+ * `.cursor/hooks.json` / `~/.cursor/hooks.json`.
+ */
+import { createHash } from "node:crypto";
+import { readFileSync, writeFileSync, mkdirSync, copyFileSync, accessSync, chmodSync, constants, existsSync, } from "node:fs";
+import { execSync } from "node:child_process";
+import { resolve, join } from "node:path";
+import { homedir } from "node:os";
+import { HOOK_TYPES as CURSOR_HOOK_NAMES, HOOK_SCRIPTS as CURSOR_HOOK_SCRIPTS, PRE_TOOL_USE_MATCHER_PATTERN, REQUIRED_HOOKS, OPTIONAL_HOOKS, isContextModeHook, buildHookCommand, } from "./hooks.js";
+const CURSOR_ENTERPRISE_HOOKS_PATH = "/Library/Application Support/Cursor/hooks.json";
+export class CursorAdapter {
+    name = "Cursor";
+    paradigm = "json-stdio";
+    capabilities = {
+        preToolUse: true,
+        postToolUse: true,
+        preCompact: false,
+        sessionStart: false,
+        canModifyArgs: true,
+        canModifyOutput: false,
+        canInjectSessionContext: true,
+    };
+    parsePreToolUseInput(raw) {
+        const input = raw;
+        return {
+            toolName: input.tool_name ?? "",
+            toolInput: input.tool_input ?? {},
+            sessionId: this.extractSessionId(input),
+            projectDir: this.getProjectDir(input),
+            raw,
+        };
+    }
+    parsePostToolUseInput(raw) {
+        const input = raw;
+        return {
+            toolName: input.tool_name ?? "",
+            toolInput: input.tool_input ?? {},
+            toolOutput: input.tool_output ?? input.error_message,
+            isError: Boolean(input.error_message),
+            sessionId: this.extractSessionId(input),
+            projectDir: this.getProjectDir(input),
+            raw,
+        };
+    }
+    parseSessionStartInput(raw) {
+        const input = raw;
+        const rawSource = input.source ?? input.trigger ?? "startup";
+        let source;
+        switch (rawSource) {
+            case "compact":
+                source = "compact";
+                break;
+            case "resume":
+                source = "resume";
+                break;
+            case "clear":
+                source = "clear";
+                break;
+            default:
+                source = "startup";
+        }
+        return {
+            sessionId: this.extractSessionId(input),
+            source,
+            projectDir: this.getProjectDir(input),
+            raw,
+        };
+    }
+    formatPreToolUseResponse(response) {
+        if (response.decision === "deny") {
+            return {
+                permission: "deny",
+                user_message: response.reason ?? "Blocked by context-mode hook",
+            };
+        }
+        if (response.decision === "modify" && response.updatedInput) {
+            return { updated_input: response.updatedInput };
+        }
+        if (response.decision === "context" && response.additionalContext) {
+            return { agent_message: response.additionalContext };
+        }
+        if (response.decision === "ask") {
+            return {
+                permission: "ask",
+                user_message: response.reason ?? "Action requires user confirmation (security policy)",
+            };
+        }
+        // Cursor rejects empty stdout as "no valid response", so adapter callers
+        // need the same explicit no-op payload the hook scripts emit at runtime.
+        return { agent_message: "" };
+    }
+    formatPostToolUseResponse(response) {
+        // Cursor rejects empty stdout as "no valid response", so emit a no-op
+        // additional_context payload when there is nothing to inject.
+        return { additional_context: response.additionalContext ?? "" };
+    }
+    formatSessionStartResponse(response) {
+        // SessionStart follows the same rule: always emit valid JSON, even when
+        // the payload is effectively a no-op.
+        return { additional_context: response.context ?? "" };
+    }
+    getSettingsPath() {
+        return resolve(".cursor", "hooks.json");
+    }
+    getSessionDir() {
+        const dir = join(homedir(), ".cursor", "context-mode", "sessions");
+        mkdirSync(dir, { recursive: true });
+        return dir;
+    }
+    getSessionDBPath(projectDir) {
+        const hash = createHash("sha256")
+            .update(projectDir)
+            .digest("hex")
+            .slice(0, 16);
+        return join(this.getSessionDir(), `${hash}.db`);
+    }
+    getSessionEventsPath(projectDir) {
+        const hash = createHash("sha256")
+            .update(projectDir)
+            .digest("hex")
+            .slice(0, 16);
+        return join(this.getSessionDir(), `${hash}-events.md`);
+    }
+    generateHookConfig(_pluginRoot) {
+        const hooks = {
+            [CURSOR_HOOK_NAMES.PRE_TOOL_USE]: [
+                {
+                    type: "command",
+                    command: buildHookCommand(CURSOR_HOOK_NAMES.PRE_TOOL_USE),
+                    matcher: PRE_TOOL_USE_MATCHER_PATTERN,
+                    loop_limit: null,
+                    failClosed: false,
+                },
+            ],
+            [CURSOR_HOOK_NAMES.POST_TOOL_USE]: [
+                {
+                    type: "command",
+                    command: buildHookCommand(CURSOR_HOOK_NAMES.POST_TOOL_USE),
+                    loop_limit: null,
+                    failClosed: false,
+                },
+            ],
+            [CURSOR_HOOK_NAMES.SESSION_START]: [
+                {
+                    type: "command",
+                    command: buildHookCommand(CURSOR_HOOK_NAMES.SESSION_START),
+                    loop_limit: null,
+                    failClosed: false,
+                },
+            ],
+        };
+        return hooks;
+    }
+    readSettings() {
+        for (const configPath of this.getCandidateHookConfigPaths()) {
+            try {
+                const raw = readFileSync(configPath, "utf-8");
+                return JSON.parse(raw);
+            }
+            catch {
+                continue;
+            }
+        }
+        return null;
+    }
+    writeSettings(settings) {
+        const configPath = this.getSettingsPath();
+        mkdirSync(resolve(".cursor"), { recursive: true });
+        writeFileSync(configPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    }
+    validateHooks(_pluginRoot) {
+        const results = [];
+        const loaded = this.loadNativeHookConfig();
+        if (!loaded) {
+            results.push({
+                check: "Native hook config",
+                status: "fail",
+                message: "No readable native Cursor hook config found in .cursor/hooks.json or ~/.cursor/hooks.json",
+                fix: "context-mode upgrade",
+            });
+        }
+        else {
+            const hooks = loaded.config.hooks ?? {};
+            results.push({
+                check: "Native hook config",
+                status: "pass",
+                message: `Loaded ${loaded.path}`,
+            });
+            for (const hookType of REQUIRED_HOOKS) {
+                const entries = hooks[hookType];
+                const hasHook = Array.isArray(entries)
+                    && entries.some((entry) => isContextModeHook(entry, hookType));
+                results.push({
+                    check: hookType,
+                    status: hasHook ? "pass" : "fail",
+                    message: hasHook
+                        ? `${hookType} hook configured`
+                        : `${hookType} hook not configured in ${loaded.path}`,
+                    fix: hasHook ? undefined : "context-mode upgrade",
+                });
+            }
+            for (const hookType of OPTIONAL_HOOKS) {
+                const entries = hooks[hookType];
+                const hasHook = Array.isArray(entries)
+                    && entries.some((entry) => isContextModeHook(entry, hookType));
+                results.push({
+                    check: hookType,
+                    status: hasHook ? "pass" : "warn",
+                    message: hasHook
+                        ? `${hookType} hook configured`
+                        : `${hookType} hook missing — session event capture will be reduced`,
+                });
+            }
+        }
+        if (existsSync(CURSOR_ENTERPRISE_HOOKS_PATH)) {
+            results.push({
+                check: "Enterprise hook config",
+                status: "warn",
+                message: "Enterprise Cursor hook config detected at /Library/Application Support/Cursor/hooks.json (read-only informational layer)",
+            });
+        }
+        if (this.hasClaudeCompatibilityHooks()) {
+            results.push({
+                check: "Claude compatibility",
+                status: "warn",
+                message: "Claude-compatible hooks detected; native Cursor hooks are the supported configuration",
+            });
+        }
+        return results;
+    }
+    checkPluginRegistration() {
+        const mcpPaths = [resolve(".cursor", "mcp.json"), join(homedir(), ".cursor", "mcp.json")];
+        for (const configPath of mcpPaths) {
+            try {
+                const raw = readFileSync(configPath, "utf-8");
+                const config = JSON.parse(raw);
+                const servers = (config.mcpServers ?? config.servers);
+                if (!servers)
+                    continue;
+                const hasContextMode = Object.entries(servers).some(([name, value]) => {
+                    if (name.includes("context-mode"))
+                        return true;
+                    if (!value || typeof value !== "object")
+                        return false;
+                    const server = value;
+                    return server.command === "context-mode";
+                });
+                if (hasContextMode) {
+                    return {
+                        check: "MCP registration",
+                        status: "pass",
+                        message: `context-mode found in ${configPath}`,
+                    };
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return {
+            check: "MCP registration",
+            status: "warn",
+            message: "Could not find context-mode in .cursor/mcp.json or ~/.cursor/mcp.json",
+        };
+    }
+    getInstalledVersion() {
+        try {
+            const output = execSync("cursor --version", {
+                encoding: "utf-8",
+                stdio: ["ignore", "pipe", "ignore"],
+            }).trim();
+            return output.split(/\r?\n/)[0] || "unknown";
+        }
+        catch {
+            return "not installed";
+        }
+    }
+    configureAllHooks(_pluginRoot) {
+        const settings = this.readSettings() ?? { version: 1, hooks: {} };
+        const hooks = (settings.hooks ?? {});
+        const changes = [];
+        this.upsertHookEntry(hooks, CURSOR_HOOK_NAMES.PRE_TOOL_USE, {
+            type: "command",
+            command: buildHookCommand(CURSOR_HOOK_NAMES.PRE_TOOL_USE),
+            matcher: PRE_TOOL_USE_MATCHER_PATTERN,
+            loop_limit: null,
+            failClosed: false,
+        }, changes);
+        this.upsertHookEntry(hooks, CURSOR_HOOK_NAMES.POST_TOOL_USE, {
+            type: "command",
+            command: buildHookCommand(CURSOR_HOOK_NAMES.POST_TOOL_USE),
+            loop_limit: null,
+            failClosed: false,
+        }, changes);
+        this.upsertHookEntry(hooks, CURSOR_HOOK_NAMES.SESSION_START, {
+            type: "command",
+            command: buildHookCommand(CURSOR_HOOK_NAMES.SESSION_START),
+            loop_limit: null,
+            failClosed: false,
+        }, changes);
+        settings.version = 1;
+        settings.hooks = hooks;
+        this.writeSettings(settings);
+        changes.push(`Wrote native Cursor hooks to ${this.getSettingsPath()}`);
+        return changes;
+    }
+    backupSettings() {
+        const settingsPath = this.getSettingsPath();
+        try {
+            accessSync(settingsPath, constants.R_OK);
+            const backupPath = settingsPath + ".bak";
+            copyFileSync(settingsPath, backupPath);
+            return backupPath;
+        }
+        catch {
+            return null;
+        }
+    }
+    setHookPermissions(pluginRoot) {
+        const set = [];
+        const hooksDir = join(pluginRoot, "hooks", "cursor");
+        for (const scriptName of Object.values(CURSOR_HOOK_SCRIPTS)) {
+            const scriptPath = resolve(hooksDir, scriptName);
+            try {
+                accessSync(scriptPath, constants.R_OK);
+                chmodSync(scriptPath, 0o755);
+                set.push(scriptPath);
+            }
+            catch {
+                /* skip missing scripts */
+            }
+        }
+        return set;
+    }
+    updatePluginRegistry(_pluginRoot, _version) {
+        // Cursor manages extensions and native hooks internally.
+    }
+    getRoutingInstructionsConfig() {
+        return {
+            fileName: "AGENTS.md",
+            globalPath: "",
+            projectRelativePath: "AGENTS.md",
+        };
+    }
+    writeRoutingInstructions(_projectDir, _pluginRoot) {
+        // Native Cursor hook support ships independently from any instruction-file story.
+        return null;
+    }
+    getCandidateHookConfigPaths() {
+        const paths = [this.getSettingsPath(), join(homedir(), ".cursor", "hooks.json")];
+        if (process.platform === "darwin") {
+            paths.push(CURSOR_ENTERPRISE_HOOKS_PATH);
+        }
+        return paths;
+    }
+    getProjectDir(input) {
+        return input.cwd
+            || input.workspace_roots?.[0]
+            || process.env.CURSOR_CWD
+            || process.cwd();
+    }
+    extractSessionId(input) {
+        if (input.conversation_id)
+            return input.conversation_id;
+        if (input.session_id)
+            return input.session_id;
+        if (process.env.CURSOR_SESSION_ID)
+            return process.env.CURSOR_SESSION_ID;
+        if (process.env.CURSOR_TRACE_ID)
+            return process.env.CURSOR_TRACE_ID;
+        return `pid-${process.ppid}`;
+    }
+    loadNativeHookConfig() {
+        for (const configPath of this.getCandidateHookConfigPaths()) {
+            try {
+                const raw = readFileSync(configPath, "utf-8");
+                const config = JSON.parse(raw);
+                if (config && typeof config === "object") {
+                    return { path: configPath, config };
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return null;
+    }
+    hasClaudeCompatibilityHooks() {
+        const compatPaths = [
+            resolve(".claude", "settings.json"),
+            resolve(".claude", "settings.local.json"),
+            join(homedir(), ".claude", "settings.json"),
+        ];
+        return compatPaths.some((configPath) => existsSync(configPath));
+    }
+    upsertHookEntry(hooks, hookType, entry, changes) {
+        const existingRaw = hooks[hookType];
+        const existing = Array.isArray(existingRaw) ? [...existingRaw] : [];
+        const idx = existing.findIndex((candidate) => isContextModeHook(candidate, hookType));
+        if (idx >= 0) {
+            existing[idx] = entry;
+            changes.push(`Updated existing ${hookType} hook entry`);
+        }
+        else {
+            existing.push(entry);
+            changes.push(`Added ${hookType} hook entry`);
+        }
+        hooks[hookType] = existing;
+    }
+}

package/build/adapters/detect.d.ts

@@ -11,6 +11,7 @@
  *   - Gemini CLI:     GEMINI_PROJECT_DIR (hooks), GEMINI_CLI (MCP) | ~/.gemini/
  *   - OpenCode:       OPENCODE, OPENCODE_PID | ~/.config/opencode/
  *   - Codex CLI:      CODEX_CI, CODEX_THREAD_ID | ~/.codex/
+ *   - Cursor:         CURSOR_TRACE_ID (MCP), CURSOR_CLI (terminal) | ~/.cursor/
  *   - VS Code Copilot: VSCODE_PID, VSCODE_CWD | ~/.vscode/
  */
 import type { PlatformId, DetectionSignal, HookAdapter } from "./types.js";

package/build/adapters/detect.js

@@ -11,6 +11,7 @@
  *   - Gemini CLI:     GEMINI_PROJECT_DIR (hooks), GEMINI_CLI (MCP) | ~/.gemini/
  *   - OpenCode:       OPENCODE, OPENCODE_PID | ~/.config/opencode/
  *   - Codex CLI:      CODEX_CI, CODEX_THREAD_ID | ~/.codex/
+ *   - Cursor:         CURSOR_TRACE_ID (MCP), CURSOR_CLI (terminal) | ~/.cursor/
  *   - VS Code Copilot: VSCODE_PID, VSCODE_CWD | ~/.vscode/
  */
 import { existsSync } from "node:fs";
@@ -49,6 +50,13 @@ export function detectPlatform() {
             reason: "CODEX_CI or CODEX_THREAD_ID env var set",
         };
     }
+    if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CLI) {
+        return {
+            platform: "cursor",
+            confidence: "high",
+            reason: "CURSOR_TRACE_ID or CURSOR_CLI env var set",
+        };
+    }
     if (process.env.VSCODE_PID || process.env.VSCODE_CWD) {
         return {
             platform: "vscode-copilot",
@@ -79,6 +87,13 @@ export function detectPlatform() {
             reason: "~/.codex/ directory exists",
         };
     }
+    if (existsSync(resolve(home, ".cursor"))) {
+        return {
+            platform: "cursor",
+            confidence: "medium",
+            reason: "~/.cursor/ directory exists",
+        };
+    }
     if (existsSync(resolve(home, ".config", "opencode"))) {
         return {
             platform: "opencode",
@@ -120,6 +135,10 @@ export async function getAdapter(platform) {
             const { VSCodeCopilotAdapter } = await import("./vscode-copilot/index.js");
             return new VSCodeCopilotAdapter();
         }
+        case "cursor": {
+            const { CursorAdapter } = await import("./cursor/index.js");
+            return new CursorAdapter();
+        }
         default: {
             // Unsupported platform — fall back to Claude Code adapter
             // (MCP server works everywhere, hooks may not)

package/build/adapters/opencode/index.js

@@ -196,10 +196,11 @@ export class OpenCodeAdapter {
         };
     }
     readSettings() {
-        // Try opencode.json, then .opencode/opencode.json
+        // Try project-local paths first, then global config
         const paths = [
             resolve("opencode.json"),
             resolve(".opencode", "opencode.json"),
+            join(homedir(), ".config", "opencode", "opencode.json"),
         ];
         for (const configPath of paths) {
             try {
@@ -322,6 +323,7 @@ export class OpenCodeAdapter {
         const paths = [
             resolve("opencode.json"),
             resolve(".opencode", "opencode.json"),
+            join(homedir(), ".config", "opencode", "opencode.json"),
         ];
         for (const configPath of paths) {
             try {

package/build/adapters/types.d.ts

@@ -206,7 +206,7 @@ export interface DiagnosticResult {
     fix?: string;
 }
 /** Supported platform identifiers. */
-export type PlatformId = "claude-code" | "gemini-cli" | "opencode" | "codex" | "vscode-copilot" | "unknown";
+export type PlatformId = "claude-code" | "gemini-cli" | "opencode" | "codex" | "vscode-copilot" | "cursor" | "unknown";
 /** Detection signal used to identify which platform is running. */
 export interface DetectionSignal {
     /** Platform identifier. */

package/build/cli.js

@@ -45,6 +45,11 @@ const HOOK_MAP = {
         precompact: "hooks/vscode-copilot/precompact.mjs",
         sessionstart: "hooks/vscode-copilot/sessionstart.mjs",
     },
+    "cursor": {
+        pretooluse: "hooks/cursor/pretooluse.mjs",
+        posttooluse: "hooks/cursor/posttooluse.mjs",
+        sessionstart: "hooks/cursor/sessionstart.mjs",
+    },
 };
 async function hookDispatch(platform, event) {
     // Suppress stderr at OS fd level — native C++ modules (better-sqlite3) write

package/build/executor.js

@@ -284,6 +284,8 @@ export class PolyglotExecutor {
             "NO_PROXY",
             "SSL_CERT_FILE",
             "CURL_CA_BUNDLE",
+            "NODE_EXTRA_CA_CERTS",
+            "REQUESTS_CA_BUNDLE",
             // XDG (config paths for gh, gcloud, etc.)
             "XDG_CONFIG_HOME",
             "XDG_DATA_HOME",

package/build/opencode-plugin.js

@@ -21,6 +21,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { SessionDB } from "./session/db.js";
 import { extractEvents } from "./session/extract.js";
 import { buildResumeSnapshot } from "./session/snapshot.js";
+import { OpenCodeAdapter } from "./adapters/opencode/index.js";
 // ── Helpers ───────────────────────────────────────────────
 function getSessionDir() {
     const dir = join(homedir(), ".config", "opencode", "context-mode", "sessions");
@@ -51,6 +52,13 @@ export const ContextModePlugin = async (ctx) => {
     const db = new SessionDB({ dbPath: getDBPath(projectDir) });
     const sessionId = randomUUID();
     db.ensureSession(sessionId, projectDir);
+    // Auto-write AGENTS.md on startup for OpenCode projects
+    try {
+        new OpenCodeAdapter().writeRoutingInstructions(projectDir, resolve(buildDir, ".."));
+    }
+    catch {
+        // best effort — never break plugin init
+    }
     // Clean up old sessions on startup (replaces SessionStart hook)
     db.cleanupOldSessions(0);
     return {

package/build/server.js

@@ -13,7 +13,8 @@ import { ContentStore, cleanupStaleDBs } from "./store.js";
 import { readBashPolicies, evaluateCommandDenyOnly, extractShellCommands, readToolDenyPatterns, evaluateFilePath, } from "./security.js";
 import { detectRuntimes, getRuntimeSummary, getAvailableLanguages, hasBunRuntime, } from "./runtime.js";
 import { classifyNonZeroExit } from "./exit-classify.js";
-const VERSION = "1.0.14";
+import { initSync, flushSync, destroySync } from "./sync/index.js";
+const VERSION = "1.0.16";
 // Prevent silent server death from unhandled async errors
 process.on("unhandledRejection", (err) => {
     process.stderr.write(`[context-mode] unhandledRejection: ${err}\n`);
@@ -1454,10 +1455,22 @@ async function main() {
         executor.cleanupBackgrounded();
         if (_store)
             _store.cleanup();
+        try {
+            destroySync();
+        }
+        catch { /* sync cleanup is best-effort */ }
+    };
+    const gracefulShutdown = async () => {
+        try {
+            await flushSync();
+        }
+        catch { /* flush is best-effort */ }
+        shutdown();
+        process.exit(0);
     };
     process.on("exit", shutdown);
-    process.on("SIGINT", () => { shutdown(); process.exit(0); });
-    process.on("SIGTERM", () => { shutdown(); process.exit(0); });
+    process.on("SIGINT", () => { gracefulShutdown(); });
+    process.on("SIGTERM", () => { gracefulShutdown(); });
     const transport = new StdioServerTransport();
     await server.connect(transport);
     // Write routing instructions for hookless platforms (e.g. Codex CLI)
@@ -1474,6 +1487,25 @@ async function main() {
         }
     }
     catch { /* best effort — don't block server startup */ }
+    // Initialize cloud sync (fire-and-forget, never blocks server)
+    try {
+        const syncProjectDir = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
+        const syncSessionId = createHash("sha256").update(syncProjectDir + ":" + Date.now()).digest("hex").slice(0, 16);
+        let gitRemote;
+        try {
+            const { execSync } = await import("node:child_process");
+            gitRemote = execSync("git remote get-url origin", {
+                cwd: syncProjectDir,
+                timeout: 3000,
+                stdio: ["ignore", "pipe", "ignore"],
+            }).toString().trim() || undefined;
+        }
+        catch { /* no git remote available */ }
+        const syncOk = initSync(syncSessionId, syncProjectDir, gitRemote);
+        if (syncOk)
+            console.error("[context-mode] Cloud sync initialized");
+    }
+    catch { /* sync init failure must never block the plugin */ }
     console.error(`Context Mode MCP server v${VERSION} running on stdio`);
     console.error(`Detected runtimes:\n${getRuntimeSummary(runtimes)}`);
     if (!hasBunRuntime()) {

package/build/session/db.js

@@ -7,6 +7,8 @@
  */
 import { SQLiteBase, defaultDBPath } from "../db-base.js";
 import { createHash } from "node:crypto";
+import { execSync } from "node:child_process";
+import { cloudPostEvent } from "../sync/cloud-post.js";
 // ─────────────────────────────────────────────────────────
 // Constants
 // ─────────────────────────────────────────────────────────
@@ -188,6 +190,25 @@ export class SessionDB extends SQLiteBase {
             this.stmt(S.updateMetaLastEvent).run(sessionId);
         });
         transaction();
+        // Fire-and-forget: POST event directly to cloud (works in short-lived hook processes)
+        try {
+            const projectDir = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
+            let gitRemote;
+            try {
+                gitRemote = execSync("git remote get-url origin", { cwd: projectDir, timeout: 2000 })
+                    .toString().trim() || undefined;
+            }
+            catch { /* no git remote available */ }
+            cloudPostEvent({
+                type: event.type,
+                category: event.category,
+                priority: event.priority,
+                data: event.data,
+                source_hook: sourceHook,
+                created_at: new Date().toISOString(),
+            }, projectDir, sessionId, gitRemote);
+        }
+        catch { /* cloud sync must never break local event storage */ }
     }
     /**
      * Retrieve events for a session with optional filtering.

package/build/sync/batcher.d.ts

@@ -0,0 +1,23 @@
+import type { SanitizedEvent } from "./types.js";
+interface BatcherOpts {
+    batchSize: number;
+    flushIntervalMs: number;
+    maxBufferSize: number;
+    onFlush: (events: SanitizedEvent[]) => Promise<void>;
+}
+export declare class EventBatcher {
+    private opts;
+    private buffer;
+    private timer;
+    private inflightPromise;
+    private consecutiveFailures;
+    constructor(opts: BatcherOpts);
+    private startTimer;
+    push(event: SanitizedEvent): void;
+    flush(): Promise<void>;
+    resetCircuitBreaker(): void;
+    get bufferSize(): number;
+    get isCircuitOpen(): boolean;
+    destroy(): void;
+}
+export {};