@opengsd/gsd-pi 1.0.2-dev.50223bc → 1.0.2-dev.5961fbf

package/packages/daemon/dist/mcp-cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=mcp-cli.d.ts.map

package/packages/daemon/dist/mcp-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-cli.d.ts","sourceRoot":"","sources":["../src/mcp-cli.ts"],"names":[],"mappings":""}

package/packages/daemon/dist/mcp-cli.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { handleCloudRuntimeCommand } from "./cloud-cli.js";
+handleCloudRuntimeCommand(process.argv.slice(2), { binaryName: "gsd-mcp" }).catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`gsd-mcp: fatal: ${msg}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=mcp-cli.js.map

package/packages/daemon/dist/mcp-cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-cli.js","sourceRoot":"","sources":["../src/mcp-cli.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAE3D,yBAAyB,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,GAAY,EAAE,EAAE;IACjG,MAAM,GAAG,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC7D,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAAC;IACjD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC","sourcesContent":["#!/usr/bin/env node\nimport { handleCloudRuntimeCommand } from \"./cloud-cli.js\";\n\nhandleCloudRuntimeCommand(process.argv.slice(2), { binaryName: \"gsd-mcp\" }).catch((err: unknown) => {\n  const msg = err instanceof Error ? err.message : String(err);\n  process.stderr.write(`gsd-mcp: fatal: ${msg}\\n`);\n  process.exit(1);\n});\n"]}

package/packages/daemon/dist/mcp-cli.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mcp-cli.test.d.ts.map

package/packages/daemon/dist/mcp-cli.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-cli.test.d.ts","sourceRoot":"","sources":["../src/mcp-cli.test.ts"],"names":[],"mappings":""}

package/packages/daemon/dist/mcp-cli.test.js

@@ -0,0 +1,13 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { test } from "node:test";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+test("gsd-mcp help prints execution-focused usage", () => {
+    const result = execFileSync(process.execPath, [join(__dirname, "mcp-cli.js"), "--help"], { encoding: "utf-8", timeout: 5000 });
+    assert.ok(result.includes("Usage: gsd-mcp"));
+    assert.ok(result.includes("pair --gateway"));
+    assert.ok(result.includes("connect"));
+});
+//# sourceMappingURL=mcp-cli.test.js.map

package/packages/daemon/dist/mcp-cli.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-cli.test.js","sourceRoot":"","sources":["../src/mcp-cli.test.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,oBAAoB,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,MAAM,SAAS,GAAG,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAE1D,IAAI,CAAC,6CAA6C,EAAE,GAAG,EAAE;IACvD,MAAM,MAAM,GAAG,YAAY,CACzB,OAAO,CAAC,QAAQ,EAChB,CAAC,IAAI,CAAC,SAAS,EAAE,YAAY,CAAC,EAAE,QAAQ,CAAC,EACzC,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CACrC,CAAC;IACF,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAC,CAAC;IAC7C,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAC,CAAC;IAC7C,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC;AACxC,CAAC,CAAC,CAAC","sourcesContent":["import assert from \"node:assert/strict\";\nimport { execFileSync } from \"node:child_process\";\nimport { dirname, join } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { test } from \"node:test\";\n\nconst __dirname = dirname(fileURLToPath(import.meta.url));\n\ntest(\"gsd-mcp help prints execution-focused usage\", () => {\n  const result = execFileSync(\n    process.execPath,\n    [join(__dirname, \"mcp-cli.js\"), \"--help\"],\n    { encoding: \"utf-8\", timeout: 5000 },\n  );\n  assert.ok(result.includes(\"Usage: gsd-mcp\"));\n  assert.ok(result.includes(\"pair --gateway\"));\n  assert.ok(result.includes(\"connect\"));\n});\n"]}

package/packages/daemon/dist/mcp-runtime-cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=mcp-runtime-cli.d.ts.map

package/packages/daemon/dist/mcp-runtime-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-runtime-cli.d.ts","sourceRoot":"","sources":["../src/mcp-runtime-cli.ts"],"names":[],"mappings":""}

package/packages/daemon/dist/mcp-runtime-cli.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { handleCloudRuntimeCommand } from "./cloud-cli.js";
+handleCloudRuntimeCommand(process.argv.slice(2), { binaryName: "gsd-mcp-runtime" }).catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`gsd-mcp-runtime: fatal: ${msg}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=mcp-runtime-cli.js.map

package/packages/daemon/dist/mcp-runtime-cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-runtime-cli.js","sourceRoot":"","sources":["../src/mcp-runtime-cli.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAE3D,yBAAyB,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,UAAU,EAAE,iBAAiB,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,GAAY,EAAE,EAAE;IACzG,MAAM,GAAG,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC7D,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,2BAA2B,GAAG,IAAI,CAAC,CAAC;IACzD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC","sourcesContent":["#!/usr/bin/env node\nimport { handleCloudRuntimeCommand } from \"./cloud-cli.js\";\n\nhandleCloudRuntimeCommand(process.argv.slice(2), { binaryName: \"gsd-mcp-runtime\" }).catch((err: unknown) => {\n  const msg = err instanceof Error ? err.message : String(err);\n  process.stderr.write(`gsd-mcp-runtime: fatal: ${msg}\\n`);\n  process.exit(1);\n});\n"]}

package/packages/daemon/dist/message-batcher.d.ts

@@ -0,0 +1,78 @@
+/**
+ * message-batcher.ts — Rate-limit-aware message batcher for Discord.
+ *
+ * Accumulates FormattedEvent payloads and flushes them to a Discord channel
+ * respecting the 5 msg/5s rate limit. Supports:
+ *   - Timer-based periodic flush (default 1.5s)
+ *   - Capacity-based flush when buffer hits maxBatchSize
+ *   - Immediate priority flush for blockers (bypasses batching)
+ *   - Combining multiple embeds into a single send() call
+ *   - Error isolation: send() failures are logged, never crash the batcher
+ */
+import type { FormattedEvent } from './types.js';
+/** Payload passed to the send callback — matches Discord TextChannel.send() shape. */
+export interface SendPayload {
+    content: string;
+    embeds: unknown[];
+    components: unknown[];
+}
+/** Send callback abstraction. Returns void or a promise. */
+export type SendFn = (payload: SendPayload) => Promise<void> | void;
+/** Logger interface — just needs error/warn/debug. */
+export interface BatcherLogger {
+    error(msg: string, data?: Record<string, unknown>): void;
+    warn(msg: string, data?: Record<string, unknown>): void;
+    debug(msg: string, data?: Record<string, unknown>): void;
+}
+/** MessageBatcher configuration options. */
+export interface BatcherOptions {
+    /** Interval between timed flushes in ms. Default: 1500 */
+    flushIntervalMs?: number;
+    /** Max events before triggering an immediate capacity flush. Default: 4 */
+    maxBatchSize?: number;
+}
+export declare class MessageBatcher {
+    private readonly send;
+    private readonly logger;
+    private readonly flushIntervalMs;
+    private readonly maxBatchSize;
+    private buffer;
+    private timer;
+    private flushing;
+    private destroyed;
+    constructor(send: SendFn, logger?: BatcherLogger, options?: BatcherOptions);
+    /** Start the periodic flush timer. */
+    start(): void;
+    /** Stop the periodic flush timer without flushing. */
+    stop(): void;
+    /** Flush remaining buffer and stop. Safe to call multiple times. */
+    destroy(): Promise<void>;
+    /**
+     * Enqueue a formatted event for batched sending.
+     * Triggers an immediate capacity flush if buffer reaches maxBatchSize.
+     */
+    enqueue(formatted: FormattedEvent): void;
+    /**
+     * Immediately send a high-priority event (e.g. blocker).
+     * Flushes any pending buffer first, then sends the priority event alone.
+     */
+    enqueueImmediate(formatted: FormattedEvent): Promise<void>;
+    /** Current number of events in the buffer (for testing/diagnostics). */
+    get pending(): number;
+    /**
+     * Flush the current buffer as a single Discord message.
+     * Multiple embeds are combined into one send() call (Discord supports up to 10).
+     * No-op if buffer is empty.
+     */
+    private flush;
+    /**
+     * Build a SendPayload from a batch of FormattedEvents and invoke the send callback.
+     * Catches and logs errors — never throws.
+     *
+     * For batched messages (2+ events), we send content-only to avoid duplication
+     * between content text and embed descriptions, and to stay under Discord's
+     * 10-embed limit. Single-event sends include the embed for rich formatting.
+     */
+    private doSend;
+}
+//# sourceMappingURL=message-batcher.d.ts.map

package/packages/daemon/dist/message-batcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-batcher.d.ts","sourceRoot":"","sources":["../src/message-batcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAMjD,sFAAsF;AACtF,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,OAAO,EAAE,CAAC;IAClB,UAAU,EAAE,OAAO,EAAE,CAAC;CACvB;AAED,4DAA4D;AAC5D,MAAM,MAAM,MAAM,GAAG,CAAC,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAEpE,sDAAsD;AACtD,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACzD,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACxD,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC1D;AAED,4CAA4C;AAC5C,MAAM,WAAW,cAAc;IAC7B,0DAA0D;IAC1D,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,2EAA2E;IAC3E,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAgBD,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IAEtC,OAAO,CAAC,MAAM,CAAwB;IACtC,OAAO,CAAC,KAAK,CAA+C;IAC5D,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,SAAS,CAAS;gBAEd,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,cAAc;IAW1E,sCAAsC;IACtC,KAAK,IAAI,IAAI;IAYb,sDAAsD;IACtD,IAAI,IAAI,IAAI;IAQZ,oEAAoE;IAC9D,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ9B;;;OAGG;IACH,OAAO,CAAC,SAAS,EAAE,cAAc,GAAG,IAAI;IAQxC;;;OAGG;IACG,gBAAgB,CAAC,SAAS,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAQhE,wEAAwE;IACxE,IAAI,OAAO,IAAI,MAAM,CAEpB;IAMD;;;;OAIG;YACW,KAAK;IAanB;;;;;;;OAOG;YACW,MAAM;CA8CrB"}

package/packages/daemon/dist/message-batcher.js

@@ -0,0 +1,173 @@
+/**
+ * message-batcher.ts — Rate-limit-aware message batcher for Discord.
+ *
+ * Accumulates FormattedEvent payloads and flushes them to a Discord channel
+ * respecting the 5 msg/5s rate limit. Supports:
+ *   - Timer-based periodic flush (default 1.5s)
+ *   - Capacity-based flush when buffer hits maxBatchSize
+ *   - Immediate priority flush for blockers (bypasses batching)
+ *   - Combining multiple embeds into a single send() call
+ *   - Error isolation: send() failures are logged, never crash the batcher
+ */
+// ---------------------------------------------------------------------------
+// Default no-op logger
+// ---------------------------------------------------------------------------
+const noopLogger = {
+    error() { },
+    warn() { },
+    debug() { },
+};
+// ---------------------------------------------------------------------------
+// MessageBatcher
+// ---------------------------------------------------------------------------
+export class MessageBatcher {
+    send;
+    logger;
+    flushIntervalMs;
+    maxBatchSize;
+    buffer = [];
+    timer = null;
+    flushing = false;
+    destroyed = false;
+    constructor(send, logger, options) {
+        this.send = send;
+        this.logger = logger ?? noopLogger;
+        this.flushIntervalMs = options?.flushIntervalMs ?? 1500;
+        this.maxBatchSize = options?.maxBatchSize ?? 4;
+    }
+    // -----------------------------------------------------------------------
+    // Public API
+    // -----------------------------------------------------------------------
+    /** Start the periodic flush timer. */
+    start() {
+        if (this.timer)
+            return; // already running
+        this.timer = setInterval(() => {
+            void this.flush();
+        }, this.flushIntervalMs);
+        // Don't hold the process open for the timer
+        if (this.timer && typeof this.timer === 'object' && 'unref' in this.timer) {
+            this.timer.unref();
+        }
+        this.logger.debug('Batcher started', { flushIntervalMs: this.flushIntervalMs });
+    }
+    /** Stop the periodic flush timer without flushing. */
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.logger.debug('Batcher stopped');
+    }
+    /** Flush remaining buffer and stop. Safe to call multiple times. */
+    async destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.stop();
+        await this.flush();
+        this.logger.debug('Batcher destroyed');
+    }
+    /**
+     * Enqueue a formatted event for batched sending.
+     * Triggers an immediate capacity flush if buffer reaches maxBatchSize.
+     */
+    enqueue(formatted) {
+        if (this.destroyed)
+            return;
+        this.buffer.push(formatted);
+        if (this.buffer.length >= this.maxBatchSize) {
+            void this.flush();
+        }
+    }
+    /**
+     * Immediately send a high-priority event (e.g. blocker).
+     * Flushes any pending buffer first, then sends the priority event alone.
+     */
+    async enqueueImmediate(formatted) {
+        if (this.destroyed)
+            return;
+        // Flush pending buffer first so ordering is preserved
+        await this.flush();
+        // Send the priority event immediately, alone
+        await this.doSend([formatted]);
+    }
+    /** Current number of events in the buffer (for testing/diagnostics). */
+    get pending() {
+        return this.buffer.length;
+    }
+    // -----------------------------------------------------------------------
+    // Internal
+    // -----------------------------------------------------------------------
+    /**
+     * Flush the current buffer as a single Discord message.
+     * Multiple embeds are combined into one send() call (Discord supports up to 10).
+     * No-op if buffer is empty.
+     */
+    async flush() {
+        if (this.buffer.length === 0)
+            return;
+        if (this.flushing)
+            return; // prevent re-entrant flush
+        this.flushing = true;
+        const batch = this.buffer.splice(0); // take all
+        try {
+            await this.doSend(batch);
+        }
+        finally {
+            this.flushing = false;
+        }
+    }
+    /**
+     * Build a SendPayload from a batch of FormattedEvents and invoke the send callback.
+     * Catches and logs errors — never throws.
+     *
+     * For batched messages (2+ events), we send content-only to avoid duplication
+     * between content text and embed descriptions, and to stay under Discord's
+     * 10-embed limit. Single-event sends include the embed for rich formatting.
+     */
+    async doSend(batch) {
+        if (batch.length === 0)
+            return;
+        // Combine content lines
+        const content = batch.map((e) => e.content).join('\n');
+        // For single events, include the embed for rich formatting.
+        // For batches, skip embeds — the content lines are self-descriptive and
+        // embeds would duplicate the information + risk hitting Discord's 10-embed cap.
+        const embeds = [];
+        if (batch.length === 1 && batch[0].embed) {
+            embeds.push(batch[0].embed);
+        }
+        // Collect all component rows (only from the last event with components —
+        // Discord only supports one set of components per message)
+        let components = [];
+        for (const e of batch) {
+            if (e.components && e.components.length > 0) {
+                components = e.components;
+            }
+        }
+        const payload = { content, embeds, components };
+        try {
+            await this.send(payload);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.logger.error('Batcher send failed', { error: message, batchSize: batch.length });
+            // Retry once after a short delay
+            try {
+                await new Promise((r) => setTimeout(r, 1000));
+                await this.send(payload);
+                this.logger.debug('Batcher retry succeeded');
+            }
+            catch (retryErr) {
+                const retryMessage = retryErr instanceof Error ? retryErr.message : String(retryErr);
+                this.logger.warn('Batcher retry also failed, dropping batch', {
+                    error: retryMessage,
+                    batchSize: batch.length,
+                });
+                // Drop the batch — don't re-enqueue to prevent infinite loops
+            }
+        }
+    }
+}
+//# sourceMappingURL=message-batcher.js.map

package/packages/daemon/dist/message-batcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-batcher.js","sourceRoot":"","sources":["../src/message-batcher.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * message-batcher.ts — Rate-limit-aware message batcher for Discord.\n *\n * Accumulates FormattedEvent payloads and flushes them to a Discord channel\n * respecting the 5 msg/5s rate limit. Supports:\n *   - Timer-based periodic flush (default 1.5s)\n *   - Capacity-based flush when buffer hits maxBatchSize\n *   - Immediate priority flush for blockers (bypasses batching)\n *   - Combining multiple embeds into a single send() call\n *   - Error isolation: send() failures are logged, never crash the batcher\n */\n\nimport type { FormattedEvent } from './types.js';\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\n/** Payload passed to the send callback — matches Discord TextChannel.send() shape. */\nexport interface SendPayload {\n  content: string;\n  embeds: unknown[];\n  components: unknown[];\n}\n\n/** Send callback abstraction. Returns void or a promise. */\nexport type SendFn = (payload: SendPayload) => Promise<void> | void;\n\n/** Logger interface — just needs error/warn/debug. */\nexport interface BatcherLogger {\n  error(msg: string, data?: Record<string, unknown>): void;\n  warn(msg: string, data?: Record<string, unknown>): void;\n  debug(msg: string, data?: Record<string, unknown>): void;\n}\n\n/** MessageBatcher configuration options. */\nexport interface BatcherOptions {\n  /** Interval between timed flushes in ms. Default: 1500 */\n  flushIntervalMs?: number;\n  /** Max events before triggering an immediate capacity flush. Default: 4 */\n  maxBatchSize?: number;\n}\n\n// ---------------------------------------------------------------------------\n// Default no-op logger\n// ---------------------------------------------------------------------------\n\nconst noopLogger: BatcherLogger = {\n  error() {},\n  warn() {},\n  debug() {},\n};\n\n// ---------------------------------------------------------------------------\n// MessageBatcher\n// ---------------------------------------------------------------------------\n\nexport class MessageBatcher {\n  private readonly send: SendFn;\n  private readonly logger: BatcherLogger;\n  private readonly flushIntervalMs: number;\n  private readonly maxBatchSize: number;\n\n  private buffer: FormattedEvent[] = [];\n  private timer: ReturnType<typeof setInterval> | null = null;\n  private flushing = false;\n  private destroyed = false;\n\n  constructor(send: SendFn, logger?: BatcherLogger, options?: BatcherOptions) {\n    this.send = send;\n    this.logger = logger ?? noopLogger;\n    this.flushIntervalMs = options?.flushIntervalMs ?? 1500;\n    this.maxBatchSize = options?.maxBatchSize ?? 4;\n  }\n\n  // -----------------------------------------------------------------------\n  // Public API\n  // -----------------------------------------------------------------------\n\n  /** Start the periodic flush timer. */\n  start(): void {\n    if (this.timer) return; // already running\n    this.timer = setInterval(() => {\n      void this.flush();\n    }, this.flushIntervalMs);\n    // Don't hold the process open for the timer\n    if (this.timer && typeof this.timer === 'object' && 'unref' in this.timer) {\n      this.timer.unref();\n    }\n    this.logger.debug('Batcher started', { flushIntervalMs: this.flushIntervalMs });\n  }\n\n  /** Stop the periodic flush timer without flushing. */\n  stop(): void {\n    if (this.timer) {\n      clearInterval(this.timer);\n      this.timer = null;\n    }\n    this.logger.debug('Batcher stopped');\n  }\n\n  /** Flush remaining buffer and stop. Safe to call multiple times. */\n  async destroy(): Promise<void> {\n    if (this.destroyed) return;\n    this.destroyed = true;\n    this.stop();\n    await this.flush();\n    this.logger.debug('Batcher destroyed');\n  }\n\n  /**\n   * Enqueue a formatted event for batched sending.\n   * Triggers an immediate capacity flush if buffer reaches maxBatchSize.\n   */\n  enqueue(formatted: FormattedEvent): void {\n    if (this.destroyed) return;\n    this.buffer.push(formatted);\n    if (this.buffer.length >= this.maxBatchSize) {\n      void this.flush();\n    }\n  }\n\n  /**\n   * Immediately send a high-priority event (e.g. blocker).\n   * Flushes any pending buffer first, then sends the priority event alone.\n   */\n  async enqueueImmediate(formatted: FormattedEvent): Promise<void> {\n    if (this.destroyed) return;\n    // Flush pending buffer first so ordering is preserved\n    await this.flush();\n    // Send the priority event immediately, alone\n    await this.doSend([formatted]);\n  }\n\n  /** Current number of events in the buffer (for testing/diagnostics). */\n  get pending(): number {\n    return this.buffer.length;\n  }\n\n  // -----------------------------------------------------------------------\n  // Internal\n  // -----------------------------------------------------------------------\n\n  /**\n   * Flush the current buffer as a single Discord message.\n   * Multiple embeds are combined into one send() call (Discord supports up to 10).\n   * No-op if buffer is empty.\n   */\n  private async flush(): Promise<void> {\n    if (this.buffer.length === 0) return;\n    if (this.flushing) return; // prevent re-entrant flush\n\n    this.flushing = true;\n    const batch = this.buffer.splice(0); // take all\n    try {\n      await this.doSend(batch);\n    } finally {\n      this.flushing = false;\n    }\n  }\n\n  /**\n   * Build a SendPayload from a batch of FormattedEvents and invoke the send callback.\n   * Catches and logs errors — never throws.\n   *\n   * For batched messages (2+ events), we send content-only to avoid duplication\n   * between content text and embed descriptions, and to stay under Discord's\n   * 10-embed limit. Single-event sends include the embed for rich formatting.\n   */\n  private async doSend(batch: FormattedEvent[]): Promise<void> {\n    if (batch.length === 0) return;\n\n    // Combine content lines\n    const content = batch.map((e) => e.content).join('\\n');\n\n    // For single events, include the embed for rich formatting.\n    // For batches, skip embeds — the content lines are self-descriptive and\n    // embeds would duplicate the information + risk hitting Discord's 10-embed cap.\n    const embeds: unknown[] = [];\n    if (batch.length === 1 && batch[0].embed) {\n      embeds.push(batch[0].embed);\n    }\n\n    // Collect all component rows (only from the last event with components —\n    // Discord only supports one set of components per message)\n    let components: unknown[] = [];\n    for (const e of batch) {\n      if (e.components && e.components.length > 0) {\n        components = e.components;\n      }\n    }\n\n    const payload: SendPayload = { content, embeds, components };\n\n    try {\n      await this.send(payload);\n    } catch (err) {\n      const message = err instanceof Error ? err.message : String(err);\n      this.logger.error('Batcher send failed', { error: message, batchSize: batch.length });\n\n      // Retry once after a short delay\n      try {\n        await new Promise((r) => setTimeout(r, 1000));\n        await this.send(payload);\n        this.logger.debug('Batcher retry succeeded');\n      } catch (retryErr) {\n        const retryMessage = retryErr instanceof Error ? retryErr.message : String(retryErr);\n        this.logger.warn('Batcher retry also failed, dropping batch', {\n          error: retryMessage,\n          batchSize: batch.length,\n        });\n        // Drop the batch — don't re-enqueue to prevent infinite loops\n      }\n    }\n  }\n}\n"]}

package/packages/daemon/dist/message-batcher.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=message-batcher.test.d.ts.map

package/packages/daemon/dist/message-batcher.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-batcher.test.d.ts","sourceRoot":"","sources":["../src/message-batcher.test.ts"],"names":[],"mappings":""}

package/packages/daemon/dist/message-batcher.test.js

@@ -0,0 +1,242 @@
+import { describe, it, mock } from 'node:test';
+import assert from 'node:assert/strict';
+import { MessageBatcher } from './message-batcher.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Create a minimal FormattedEvent for testing. */
+function fakeEvent(content, hasEmbed = false) {
+    const fe = { content };
+    if (hasEmbed) {
+        // Minimal mock embed — just needs to be truthy and pass through
+        fe.embed = { data: { title: content } };
+    }
+    return fe;
+}
+/** Create a tracking send function. */
+function createSend() {
+    const calls = [];
+    const fn = mock.fn(async (payload) => {
+        calls.push(payload);
+    });
+    return { fn, calls };
+}
+/** Create a logger that captures error/warn calls. */
+function createLogger() {
+    const errors = [];
+    const warns = [];
+    const debugs = [];
+    const logger = {
+        error(msg) { errors.push(msg); },
+        warn(msg) { warns.push(msg); },
+        debug(msg) { debugs.push(msg); },
+    };
+    return { logger, errors, warns, debugs };
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('MessageBatcher', () => {
+    describe('enqueue + capacity flush', () => {
+        it('flushes when buffer reaches maxBatchSize', async () => {
+            const { fn, calls } = createSend();
+            const batcher = new MessageBatcher(fn, undefined, { maxBatchSize: 3, flushIntervalMs: 60_000 });
+            batcher.enqueue(fakeEvent('a'));
+            batcher.enqueue(fakeEvent('b'));
+            assert.equal(calls.length, 0, 'should not flush yet');
+            batcher.enqueue(fakeEvent('c')); // hits capacity
+            // flush is async — give it a tick
+            await new Promise((r) => setTimeout(r, 10));
+            assert.equal(calls.length, 1, 'should have flushed once');
+            assert.equal(calls[0].content, 'a\nb\nc');
+            assert.equal(batcher.pending, 0);
+            await batcher.destroy();
+        });
+        it('skips embeds for batched messages (only content)', async () => {
+            const { fn, calls } = createSend();
+            const batcher = new MessageBatcher(fn, undefined, { maxBatchSize: 2, flushIntervalMs: 60_000 });
+            batcher.enqueue(fakeEvent('a', true));
+            batcher.enqueue(fakeEvent('b', true)); // triggers flush
+            await new Promise((r) => setTimeout(r, 10));
+            assert.equal(calls.length, 1);
+            assert.equal(calls[0].embeds.length, 0, 'batched sends skip embeds to avoid duplication');
+            assert.equal(calls[0].content, 'a\nb');
+            await batcher.destroy();
+        });
+    });
+    describe('enqueueImmediate', () => {
+        it('flushes pending buffer then sends immediately', async () => {
+            const { fn, calls } = createSend();
+            const batcher = new MessageBatcher(fn, undefined, { maxBatchSize: 10, flushIntervalMs: 60_000 });
+            batcher.enqueue(fakeEvent('buffered-1'));
+            batcher.enqueue(fakeEvent('buffered-2'));
+            await batcher.enqueueImmediate(fakeEvent('blocker!'));
+            // First call: the pending buffer flush
+            // Second call: the immediate event
+            assert.equal(calls.length, 2, 'should have two send calls');
+            assert.equal(calls[0].content, 'buffered-1\nbuffered-2');
+            assert.equal(calls[1].content, 'blocker!');
+            assert.equal(batcher.pending, 0);
+            await batcher.destroy();
+        });
+        it('sends immediately when buffer is empty', async () => {
+            const { fn, calls } = createSend();
+            const batcher = new MessageBatcher(fn, undefined, { maxBatchSize: 10, flushIntervalMs: 60_000 });
+            await batcher.enqueueImmediate(fakeEvent('urgent'));
+            assert.equal(calls.length, 1);
+            assert.equal(calls[0].content, 'urgent');
+            await batcher.destroy();
+        });
+    });
+    describe('timer-based flush', () => {
+        it('flushes on interval', async () => {
+            const { fn, calls } = createSend();
+            const batcher = new MessageBatcher(fn, undefined, { maxBatchSize: 100, flushIntervalMs: 50 });
+            batcher.start();
+            batcher.enqueue(fakeEvent('timed-1'));
+            batcher.enqueue(fakeEvent('timed-2'));
+            // Wait longer than flushIntervalMs
+            await new Promise((r) => setTimeout(r, 120));
+            assert.ok(calls.length >= 1, 'timer should have triggered at least one flush');
+            assert.equal(calls[0].content, 'timed-1\ntimed-2');
+            assert.equal(batcher.pending, 0);
+            await batcher.destroy();
+        });
+        it('stop prevents further timer flushes', async () => {
+            const { fn, calls } = createSend();
+            const batcher = new MessageBatcher(fn, undefined, { maxBatchSize: 100, flushIntervalMs: 30 });
+            batcher.start();
+            batcher.stop();
+            batcher.enqueue(fakeEvent('orphan'));
+            await new Promise((r) => setTimeout(r, 80));
+            assert.equal(calls.length, 0, 'no flush after stop');
+            // Cleanup without triggering flush timer
+            batcher.stop(); // idempotent
+            // Manually drain for cleanup
+            await batcher.destroy();
+        });
+    });
+    describe('destroy', () => {
+        it('flushes remaining buffer on destroy', async () => {
+            const { fn, calls } = createSend();
+            const batcher = new MessageBatcher(fn, undefined, { maxBatchSize: 100, flushIntervalMs: 60_000 });
+            batcher.enqueue(fakeEvent('leftover-1'));
+            batcher.enqueue(fakeEvent('leftover-2'));
+            await batcher.destroy();
+            assert.equal(calls.length, 1);
+            assert.equal(calls[0].content, 'leftover-1\nleftover-2');
+        });
+        it('is idempotent — second destroy is no-op', async () => {
+            const { fn, calls } = createSend();
+            const batcher = new MessageBatcher(fn, undefined, { maxBatchSize: 100, flushIntervalMs: 60_000 });
+            batcher.enqueue(fakeEvent('once'));
+            await batcher.destroy();
+            await batcher.destroy(); // second call
+            assert.equal(calls.length, 1, 'only flushed once');
+        });
+        it('enqueue after destroy is silently ignored', async () => {
+            const { fn, calls } = createSend();
+            const batcher = new MessageBatcher(fn, undefined, { maxBatchSize: 2, flushIntervalMs: 60_000 });
+            await batcher.destroy();
+            batcher.enqueue(fakeEvent('post-destroy'));
+            await new Promise((r) => setTimeout(r, 10));
+            assert.equal(calls.length, 0, 'no sends after destroy');
+        });
+    });
+    describe('empty buffer', () => {
+        it('flush of empty buffer is no-op', async () => {
+            const { fn, calls } = createSend();
+            const batcher = new MessageBatcher(fn, undefined, { maxBatchSize: 100, flushIntervalMs: 60_000 });
+            batcher.start();
+            // Force a timer tick with an empty buffer
+            await new Promise((r) => setTimeout(r, 10));
+            await batcher.destroy();
+            // Only the destroy-triggered flush, which should also be a no-op
+            assert.equal(calls.length, 0, 'no sends for empty buffer');
+        });
+    });
+    describe('single-item flush', () => {
+        it('handles a single item in buffer at destroy', async () => {
+            const { fn, calls } = createSend();
+            const batcher = new MessageBatcher(fn, undefined, { maxBatchSize: 100, flushIntervalMs: 60_000 });
+            batcher.enqueue(fakeEvent('solo'));
+            await batcher.destroy();
+            assert.equal(calls.length, 1);
+            assert.equal(calls[0].content, 'solo');
+            assert.equal(calls[0].embeds.length, 0);
+            assert.equal(calls[0].components.length, 0);
+        });
+    });
+    describe('error handling', () => {
+        it('logs error and continues when send throws', async () => {
+            let attempt = 0;
+            const sendFn = async () => {
+                attempt++;
+                throw new Error('Discord rate limit');
+            };
+            const { logger, errors, warns } = createLogger();
+            const batcher = new MessageBatcher(sendFn, logger, { maxBatchSize: 2, flushIntervalMs: 60_000 });
+            batcher.enqueue(fakeEvent('x'));
+            batcher.enqueue(fakeEvent('y')); // triggers flush
+            // Wait for flush + retry
+            await new Promise((r) => setTimeout(r, 1500));
+            assert.ok(errors.length >= 1, 'should have logged an error');
+            assert.ok(warns.length >= 1, 'should have logged a warning on retry failure');
+            assert.equal(batcher.pending, 0, 'buffer cleared even on error');
+            // Batcher should still be alive — enqueue more
+            batcher.enqueue(fakeEvent('after-error'));
+            assert.equal(batcher.pending, 1, 'can still enqueue after error');
+            await batcher.destroy();
+        });
+        it('succeeds on retry if first attempt fails', async () => {
+            let attempt = 0;
+            const calls = [];
+            const sendFn = async (payload) => {
+                attempt++;
+                if (attempt === 1)
+                    throw new Error('transient');
+                calls.push(payload);
+            };
+            const { logger, errors } = createLogger();
+            const batcher = new MessageBatcher(sendFn, logger, { maxBatchSize: 2, flushIntervalMs: 60_000 });
+            batcher.enqueue(fakeEvent('retry-me'));
+            batcher.enqueue(fakeEvent('retry-too'));
+            // Wait for flush + retry delay
+            await new Promise((r) => setTimeout(r, 1500));
+            assert.equal(errors.length, 1, 'logged one error on first attempt');
+            assert.equal(calls.length, 1, 'retry succeeded');
+            assert.equal(calls[0].content, 'retry-me\nretry-too');
+            await batcher.destroy();
+        });
+    });
+    describe('buffer at exactly capacity', () => {
+        it('flushes at exactly maxBatchSize', async () => {
+            const { fn, calls } = createSend();
+            const batcher = new MessageBatcher(fn, undefined, { maxBatchSize: 4, flushIntervalMs: 60_000 });
+            batcher.enqueue(fakeEvent('1'));
+            batcher.enqueue(fakeEvent('2'));
+            batcher.enqueue(fakeEvent('3'));
+            assert.equal(calls.length, 0, 'not flushed at 3/4');
+            batcher.enqueue(fakeEvent('4')); // exactly at capacity
+            await new Promise((r) => setTimeout(r, 10));
+            assert.equal(calls.length, 1);
+            assert.equal(calls[0].content, '1\n2\n3\n4');
+            await batcher.destroy();
+        });
+    });
+    describe('components handling', () => {
+        it('uses components from the last event that has them', async () => {
+            const { fn, calls } = createSend();
+            const batcher = new MessageBatcher(fn, undefined, { maxBatchSize: 3, flushIntervalMs: 60_000 });
+            const fakeRow = { type: 'ActionRow', components: [] };
+            batcher.enqueue(fakeEvent('no-components'));
+            batcher.enqueue({ content: 'with-components', components: [fakeRow] });
+            batcher.enqueue(fakeEvent('also-no-components')); // triggers flush
+            await new Promise((r) => setTimeout(r, 10));
+            assert.equal(calls.length, 1);
+            assert.deepEqual(calls[0].components, [fakeRow]);
+            await batcher.destroy();
+        });
+    });
+});
+//# sourceMappingURL=message-batcher.test.js.map