@buoy-gg/mcp 7.0.16 → 7.0.18

package/dist/cli.mjs

@@ -3,7 +3,7 @@ import {
   SyncClient,
   createMcpServer,
   runInit
-} from "./chunk-P2OALRPK.mjs";
+} from "./chunk-ZLTXVKRQ.mjs";
 
 // src/cli.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

package/dist/index.d.mts

@@ -47,7 +47,11 @@ declare class SyncClient {
     private devices;
     /** Latest snapshot payload per `${deviceId}::${toolId}`. */
     private snapshots;
-    /** Tools we've asked the broker to keep streaming, as `${deviceId}::${toolId}`. */
+    /**
+     * Capture-mode watches this client holds, keyed by snapKey. Stored with
+     * their addressing because they have to be RE-SENT on every reconnect: the
+     * broker keys watch state by socket id, and a reconnect gets a new one.
+     */
     private watching;
     /** In-flight actions awaiting a result, keyed by requestId. */
     private pendingActions;
@@ -87,15 +91,47 @@ declare class SyncClient {
      * is blocked.
      */
     requireProDevice(deviceId?: string): string;
+    /**
+     * Keep the device RECORDING this tool, without asking it to stream.
+     *
+     * A dashboard watches for as long as its panel is open; this client is
+     * request/response, so it used to watch and unwatch around every single
+     * read. That works for a tool whose state just IS (the query cache, the env
+     * table) and is useless for one that records a timeline: the unwatch drops
+     * the device's subscriber count to zero, which stops capture, so nothing is
+     * ever recorded between two reads. The list comes back empty and reads as
+     * "the app made no requests" — a wrong conclusion that is very expensive to
+     * chase, because everything about the app looks fine.
+     *
+     * Capture-mode watches are held for the life of the connection and released
+     * on disconnect (the broker also drops them for us). They cost the device's
+     * ring buffer, not the socket: no snapshot is pushed, and reads still go
+     * through `request-devtool-state`.
+     */
     private ensureWatching;
+    private sendWatch;
+    /**
+     * Re-arm every held watch after a reconnect.
+     *
+     * The broker tracks watches per SOCKET, so a reconnect (broker restart, a
+     * dropped wifi link) silently discards all of ours while `watching` still
+     * says we hold them — `ensureWatching` would then short-circuit forever and
+     * the device would never record again. Silent and permanent: the exact
+     * failure this whole capture-mode change exists to remove.
+     */
+    private rearmWatches;
     /** Stop streaming a tool (releases the device-side backpressure). */
     unwatch(toolId: string, targetDeviceId: string): void;
     /** Last snapshot received for a tool/device, if any. */
     cachedSnapshot(toolId: string, deviceId: string): unknown;
     /**
-     * Get a tool's current state. Starts watching (so the device begins emitting),
-     * explicitly requests state, and resolves with the next snapshot. Falls back
-     * to the last cached snapshot if the request times out.
+     * Get a tool's current state: arm capture (once, for the connection), ask
+     * for state explicitly, and resolve with the snapshot that comes back.
+     * Falls back to the last cached snapshot if the request times out.
+     *
+     * The capture watch is deliberately NOT released afterwards — see
+     * `ensureWatching`. It costs the device nothing on the socket, and dropping
+     * it is what made every timeline tool look permanently empty from here.
      */
     getSnapshot(toolId: string, deviceId?: string, opts?: {
         timeoutMs?: number;

package/dist/index.d.ts

@@ -47,7 +47,11 @@ declare class SyncClient {
     private devices;
     /** Latest snapshot payload per `${deviceId}::${toolId}`. */
     private snapshots;
-    /** Tools we've asked the broker to keep streaming, as `${deviceId}::${toolId}`. */
+    /**
+     * Capture-mode watches this client holds, keyed by snapKey. Stored with
+     * their addressing because they have to be RE-SENT on every reconnect: the
+     * broker keys watch state by socket id, and a reconnect gets a new one.
+     */
     private watching;
     /** In-flight actions awaiting a result, keyed by requestId. */
     private pendingActions;
@@ -87,15 +91,47 @@ declare class SyncClient {
      * is blocked.
      */
     requireProDevice(deviceId?: string): string;
+    /**
+     * Keep the device RECORDING this tool, without asking it to stream.
+     *
+     * A dashboard watches for as long as its panel is open; this client is
+     * request/response, so it used to watch and unwatch around every single
+     * read. That works for a tool whose state just IS (the query cache, the env
+     * table) and is useless for one that records a timeline: the unwatch drops
+     * the device's subscriber count to zero, which stops capture, so nothing is
+     * ever recorded between two reads. The list comes back empty and reads as
+     * "the app made no requests" — a wrong conclusion that is very expensive to
+     * chase, because everything about the app looks fine.
+     *
+     * Capture-mode watches are held for the life of the connection and released
+     * on disconnect (the broker also drops them for us). They cost the device's
+     * ring buffer, not the socket: no snapshot is pushed, and reads still go
+     * through `request-devtool-state`.
+     */
     private ensureWatching;
+    private sendWatch;
+    /**
+     * Re-arm every held watch after a reconnect.
+     *
+     * The broker tracks watches per SOCKET, so a reconnect (broker restart, a
+     * dropped wifi link) silently discards all of ours while `watching` still
+     * says we hold them — `ensureWatching` would then short-circuit forever and
+     * the device would never record again. Silent and permanent: the exact
+     * failure this whole capture-mode change exists to remove.
+     */
+    private rearmWatches;
     /** Stop streaming a tool (releases the device-side backpressure). */
     unwatch(toolId: string, targetDeviceId: string): void;
     /** Last snapshot received for a tool/device, if any. */
     cachedSnapshot(toolId: string, deviceId: string): unknown;
     /**
-     * Get a tool's current state. Starts watching (so the device begins emitting),
-     * explicitly requests state, and resolves with the next snapshot. Falls back
-     * to the last cached snapshot if the request times out.
+     * Get a tool's current state: arm capture (once, for the connection), ask
+     * for state explicitly, and resolve with the snapshot that comes back.
+     * Falls back to the last cached snapshot if the request times out.
+     *
+     * The capture watch is deliberately NOT released afterwards — see
+     * `ensureWatching`. It costs the device nothing on the socket, and dropping
+     * it is what made every timeline tool look permanently empty from here.
      */
     getSnapshot(toolId: string, deviceId?: string, opts?: {
         timeoutMs?: number;