@agentstrack/collector 0.2.0 → 0.3.0

package/dist/daemon.d.ts

@@ -1,5 +1,10 @@
 import { loadConfig, type Config } from './config.js';
+import { Spool } from './queue/spool.js';
+import { deterministicEventId } from './queue/event-id.js';
+export { deterministicEventId };
+import { ApiClient, VERSION } from './transport/client.js';
 import type { AgentAdapter } from './adapters/types.js';
+export { VERSION };
 export declare function log(message: string): void;
 export declare function buildAdapters(config: Config): AgentAdapter[];
 /**
@@ -14,6 +19,13 @@ export declare function buildAdapters(config: Config): AgentAdapter[];
 export declare function attributable(eventType: string, occurredAt: string, liveSinceMs: number): boolean;
 /** Recursively lists .jsonl files under a directory, newest first. */
 export declare function listTranscripts(dir: string, maxAgeDays?: number): string[];
+/** Splits one peeked wave into `batchSize` slices, every event in exactly one. */
+export declare function chunkWave<T>(wave: T[], batchSize: number): T[][];
+type PauseReason = 'auth' | 'quota' | 'schema';
+/** Spool meta key naming the current upload pause (`<reason>: <detail>`); `status` prints it. */
+export declare const UPLOAD_PAUSE_META = "upload_paused_reason";
+/** The subset of ApiClient the daemon uses — a test hands in a fake. */
+type Transport = Pick<ApiClient, 'registerCollector' | 'getConfig' | 'sendBatch' | 'health'>;
 export declare class Collector {
     private config;
     private readonly spool;
@@ -22,6 +34,7 @@ export declare class Collector {
     /** Null when git metadata is switched off — then we never shell out to git. */
     private readonly commitWatcher;
     private serverConfig;
+    private orgRules;
     /**
      * When this collector started, and therefore the earliest event it can
      * honestly attribute to an account.
@@ -35,10 +48,22 @@ export declare class Collector {
      */
     private readonly liveSinceMs;
     private uploadFailures;
-    /** Shrinks on 413, recovers on success. Never below 1. */
+    /** Shrinks on 413, recovers on success. Never below 1, never above maxBatchSize. */
     private batchSize;
+    /** Local batch_size clamped to the server's max_batch_events. */
+    private maxBatchSize;
+    /** Uploads are gated on this instead of sleeping, so scanning never stops. */
+    private nextUploadAt;
+    private pausedReason;
+    /** cwd -> repo, valid for one scan pass. */
+    private readonly repoCache;
+    /** agent::session_id -> last activity, for idle session.ended. */
+    private readonly openSessions;
     private running;
-    constructor(config: Config);
+    constructor(config: Config, deps?: {
+        spool?: Spool;
+        client?: Transport;
+    });
     start(): Promise<void>;
     stop(): void;
     /** Registers this device once and remembers the id. */
@@ -46,34 +71,61 @@ export declare class Collector {
     private refreshServerConfig;
     /** One pass over every tracked transcript file. */
     private scan;
+    /**
+     * Polls a database-backed adapter. Its cursors and "already started" markers
+     * are buffered and written in the same transaction as the events — an
+     * enqueue that fails (SQLITE_FULL) must not leave a cursor pointing past
+     * rows that were never spooled, or a session marked started that never was.
+     */
+    private pollAdapter;
+    /**
+     * Emits session.ended for every tracked session quiet for longer than
+     * `idleMs`. Claude Code and Codex never write an end marker, so without this
+     * their sessions stay in_progress on the server forever. `occurred_at` is
+     * when the timeout elapsed, not now: a backfilled session ended back then.
+     */
+    private endIdleSessions;
+    private repoFor;
     private enqueue;
-    /** Drains the spool, oldest first, until it is empty or the server pushes back. */
+    private trackSession;
     /**
-     * Drains the spool.
+     * Drains the spool, one wave of `upload.concurrency` batches at a time.
      *
-     * Batches go out `upload.concurrency` at a time. Uploading is round-trip
-     * bound, not bandwidth bound — a first import moved ~330 events/s
-     * sequentially, which is one 100-event batch per ~300ms of mostly waiting —
-     * so sending several at once divides the wall clock of a backfill by roughly
-     * that number.
+     * Uploading is round-trip bound, not bandwidth bound — a first import moved
+     * ~330 events/s sequentially, which is one 100-event batch per ~300ms of
+     * mostly waiting — so sending several at once divides the wall clock of a
+     * backfill by roughly that number. Order is deliberately NOT preserved
+     * across in-flight batches: the server derives a session's start from
+     * min(recorded start, earliest stored event), so a later batch landing first
+     * is corrected once the rest arrive. Within a batch the spool still yields
+     * oldest-first.
      *
-     * Order is deliberately NOT preserved across in-flight batches, and does not
-     * need to be: the server derives a session's start from
-     * min(recorded start, earliest stored event) and re-runs reconstruction after
-     * every batch, so a later batch arriving first is corrected once the rest
-     * land. Within a single batch the spool still yields oldest-first.
-     */
-    flush(): Promise<void>;
-    /**
-     * Sends one batch. Returns false when the wave should stop.
+     * The failure policy runs ONCE per wave, on the collected outcomes:
+     *  - any 413        -> batch size halves once
+     *  - any retryable  -> one backoff step; uploads are gated on nextUploadAt,
+     *                      never slept on, so tailing continues meanwhile
+     *  - any poison     -> strikes for those batches only
+     *  - 401/403, quota, whole-batch schema rejection -> paused, nothing dropped
+     *  - every batch ok -> counter reset, batch size creeps back up
      *
-     * Every failure branch is the same policy this had when batches went out one
-     * at a time; only the `return` became `return false`.
+     * Returns true when it stopped only because `maxWaves` ran out, i.e. there
+     * is more to send right now.
      */
+    flush(maxWaves?: number): Promise<boolean>;
+    /** Sends one batch and reports what happened. Touches no shared state. */
     private sendBatch;
+    /** Backs off and records why, once per reason, where `agentstrack status` can read it. */
+    private pause;
+    private resume;
     private reportHealth;
     queueDepth(): number;
+    /** Upload policy state, for tests and diagnostics. */
+    uploadState(): {
+        failures: number;
+        batchSize: number;
+        nextUploadAt: number;
+        paused: PauseReason | null;
+    };
 }
-export declare const VERSION = "0.1.0";
 export declare function errorMessage(error: unknown): string;
 export { loadConfig };