@agenthoney/analytics 0.0.0-stage → 0.14.0

package/dist/express.d.ts

@@ -0,0 +1,65 @@
+import { type Collector } from "./core/collector.js";
+import { type AgentHoneyConfig } from "./core/config.js";
+import { type TagOptions } from "./serve/tag.js";
+import { type TwinOptions } from "./serve/twin.js";
+/**
+ * Express middleware.
+ *
+ *   app.use(agenthoney());
+ *
+ * ── How it observes a completed response without touching it ─────────────────
+ * By listening, not by wrapping. `res` is a writable stream and the tempting
+ * approach -- monkey-patching `res.write` and `res.end` to inspect what goes
+ * out -- is wrong three ways: it adds a function call to every chunk, it holds
+ * the bytes in memory, and any mistake in re-emitting them corrupts the
+ * customer's response. Everything we need is already in the headers by the time
+ * the response finishes.
+ *
+ * ⚠️ **`finish` and `close`, with a latch.** `finish` fires when the response
+ * completed. `close` fires when the socket went away, which for an aborted
+ * request is the ONLY event that fires -- and an aborted request is exactly the
+ * kind an AI client makes when it has read enough. Listening to `finish` alone
+ * silently loses them. Both are registered and a latch makes sure one event is
+ * recorded, not two.
+ */
+type Req = {
+    method?: string;
+    originalUrl?: string;
+    url?: string;
+    headers: Record<string, string | string[] | undefined>;
+    protocol?: string;
+    secure?: boolean;
+    [key: string]: any;
+};
+type Res = {
+    statusCode: number;
+    writableFinished?: boolean;
+    getHeader(name: string): number | string | string[] | undefined;
+    once(event: string, listener: () => void): unknown;
+    [key: string]: any;
+};
+type Next = (error?: unknown) => void;
+export interface ExpressOptions extends AgentHoneyConfig {
+    collector?: Collector;
+    /**
+     * Serve a markdown twin. Omit it and this middleware is observation-only,
+     * byte-for-byte as before -- the serve half is opt-in, because it is the half
+     * that can change what a visitor receives.
+     */
+    twin?: TwinOptions;
+    /**
+     * Serve the page tag at `/_agenthoney/t.js`.
+     *
+     * ⚠️ Opt-in, exactly as `twin` is, and for a stronger version of the same
+     * reason: this one puts code in a visitor's browser. Omit it and the
+     * middleware serves nothing at that path -- not an empty file, not a 204. A
+     * 404 is the honest answer when a customer has not asked for the tag.
+     *
+     * ⚠️ Independent of `twin`. A customer may want the tag without serving
+     * twins yet -- indeed that is the normal order, since the tag is what will
+     * produce the twins.
+     */
+    tag?: TagOptions;
+}
+export declare function agenthoney(options?: ExpressOptions): (req: Req, res: Res, next: Next) => void;
+export {};

package/dist/express.js

@@ -0,0 +1,6 @@
+export { agenthoney } from './chunk-R76CTIBG.js';
+import './chunk-CD4WLJX7.js';
+import './chunk-L22VERBM.js';
+import './chunk-F3PRHEXB.js';
+//# sourceMappingURL=express.js.map
+//# sourceMappingURL=express.js.map

package/dist/express.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"express.js"}