WS /substrate/v1/watch/{pid} — real-time state stream

const pid = 12847;
const key = "sk_nsp_...";
const url = `ws://127.0.0.1:7842/substrate/v1/watch/${pid}?key=${key}`;

function connect() {
  const ws = new WebSocket(url);

  ws.onopen = () => {
    console.log("Watching PID", pid);
  };

  ws.onmessage = (msg) => {
    const event = JSON.parse(msg.data);
    console.log("Capture:", event.capture_id);
    console.log("Changed keys:", event.changed_keys);
    console.log("Sequence:", event.sequence);
  };

  ws.onclose = (e) => {
    console.warn("Connection closed:", e.code, e.reason);
    if (e.code !== 1000) {
      // Reconnect with exponential backoff.
      setTimeout(connect, 2000);
    }
  };

  ws.onerror = (err) => {
    console.error("WebSocket error:", err);
  };
}

connect();

import asyncio
import json
import websockets
from websockets.exceptions import ConnectionClosedError

PID = 12847
KEY = "sk_nsp_..."
URL = f"ws://127.0.0.1:7842/substrate/v1/watch/{PID}?key={KEY}"

async def watch():
    backoff = 1
    while True:
        try:
            async with websockets.connect(URL) as ws:
                backoff = 1  # Reset on successful connect.
                async for raw in ws:
                    event = json.loads(raw)
                    print(f"Seq {event['sequence']}  changed: {event['changed_keys']}")
        except ConnectionClosedError as e:
            if e.code == 1000:
                print("Process exited — stopping watch.")
                break
            print(f"Disconnected (code {e.code}), reconnecting in {backoff}s…")
            await asyncio.sleep(backoff)
            backoff = min(backoff * 2, 30)

asyncio.run(watch())

from nelieo import NspClient

client = NspClient(api_key="sk_nsp_...", base_url="http://127.0.0.1:7842")
session = await client.attach("Gmail")

# The SDK handles reconnection automatically.
async with session.watch() as stream:
    async for event in stream:
        print(event.changed_keys)
        print(event.sequence)

        # Fetch the full diff for this capture.
        diff = await session.diff(since=event.prev_capture_id)
        for change in diff.changed:
            print(f"  {change.path}: {change.before} → {change.after}")