fix: enable WebSocket ping heartbeat to detect dead connections

[Go1c]

Problem

heartbeat_interval: 30 was defined in config but never used. Both ping_interval and ping_timeout were set to None, disabling all keepalive. When the WebSocket connection silently died, the async for raw in self.ws receive loop hung indefinitely — no error, no reconnect, no incoming events.

Confirmed in logs: connection established at 08:23:28, last activity at 08:45:08, then complete silence. Files created on the server after that point were never received by the CLI.

Fix

Pass heartbeat_interval from config to ping_interval and ping_timeout on the WebSocket connection. The websockets library sends a ping every 30s and expects a pong within 30s. A missed pong raises ConnectionClosed, which exits _listen(), triggers the reconnect loop, and _on_reconnect runs an incremental sync to catch up on missed events.

Test plan

• Start run, let it idle for >30s, confirm ping/pong in debug logs
• Kill network briefly, confirm CLI detects disconnect and reconnects
• Create a note on server while CLI is reconnecting, confirm it arrives after reconnect

Summary by Sourcery

Bug Fixes:

• Use the configured heartbeat interval for WebSocket ping and timeout settings so dead connections are detected instead of hanging indefinitely.

[sourcery-ai]

Reviewer's guide (collapsed on small PRs)

Reviewer's Guide

This PR enables WebSocket heartbeat-based keepalive by wiring the existing heartbeat_interval configuration into the websockets.connect call, so dead connections are detected and the existing reconnect logic can run.

Updated class diagram for WebSocket client heartbeat configuration

classDiagram
    class CLIClient {
        Config config
        WebSocket ws
        _connect() void
        _listen() void
        _on_reconnect() void
    }

    class Config {
        ClientConfig client
    }

    class ClientConfig {
        int heartbeat_interval
    }

    class WebSocket {
        connect(url, max_size, ping_interval, ping_timeout, close_timeout) WebSocket
    }

    CLIClient --> Config : uses
    Config --> ClientConfig : has
    CLIClient --> WebSocket : establishes

    %% Detail of _connect behavior
    class CLIClient_connect {
        _connect() void
    }

    CLIClient ..> CLIClient_connect : behavior

    CLIClient_connect : interval = config.client.heartbeat_interval
    CLIClient_connect : ws = websockets.connect(
    CLIClient_connect :   url,
    CLIClient_connect :   max_size=128MB,
    CLIClient_connect :   ping_interval=interval,
    CLIClient_connect :   ping_timeout=interval,
    CLIClient_connect :   close_timeout=10
    CLIClient_connect : )

Loading

File-Level Changes

Change	Details	Files
Enable WebSocket ping/pong heartbeat using configured heartbeat_interval to detect dead connections and trigger reconnects.	Read heartbeat_interval from the client configuration before establishing the WebSocket connection. Pass the heartbeat interval as ping_interval to websockets.connect so the client sends periodic pings. Pass the same heartbeat interval as ping_timeout so missing pongs cause the WebSocket to raise ConnectionClosed instead of hanging indefinitely.	fns_cli/client.py

---

Tips and commands

Interacting with Sourcery

• Trigger a new review: Comment @sourcery-ai review on the pull request.
• Continue discussions: Reply directly to Sourcery's review comments.
• Generate a GitHub issue from a review comment: Ask Sourcery to create an
  issue from a review comment by replying to it. You can also reply to a
  review comment with @sourcery-ai issue to create an issue from it.
• Generate a pull request title: Write @sourcery-ai anywhere in the pull
  request title to generate a title at any time. You can also comment
  @sourcery-ai title on the pull request to (re-)generate the title at any time.
• Generate a pull request summary: Write @sourcery-ai summary anywhere in
  the pull request body to generate a PR summary at any time exactly where you
  want it. You can also comment @sourcery-ai summary on the pull request to
  (re-)generate the summary at any time.
• Generate reviewer's guide: Comment @sourcery-ai guide on the pull
  request to (re-)generate the reviewer's guide at any time.
• Resolve all Sourcery comments: Comment @sourcery-ai resolve on the
  pull request to resolve all Sourcery comments. Useful if you've already
  addressed all the comments and don't want to see them anymore.
• Dismiss all Sourcery reviews: Comment @sourcery-ai dismiss on the pull
  request to dismiss all existing Sourcery reviews. Especially useful if you
  want to start fresh with a new review - don't forget to comment
  @sourcery-ai review to trigger a new review!

Customizing Your Experience

Access your dashboard to:

• Enable or disable review features such as the Sourcery-generated pull request
  summary, the reviewer's guide, and others.
• Change the review language.
• Add, remove or edit custom review instructions.
• Adjust other review settings.

Getting Help

• Contact our support team for questions or feedback.
• Visit our documentation for detailed guides and information.
• Keep in touch with the Sourcery team by following us on X/Twitter, LinkedIn or GitHub.

[sourcery-ai]

Hey - I've found 1 issue, and left some high level feedback:

• Consider handling edge cases for heartbeat_interval (e.g., None or very small/zero values) explicitly before passing it to websockets.connect, so misconfiguration doesn't lead to confusing runtime errors or tight ping loops.
• You might want to allow configuring ping_interval and ping_timeout separately rather than tying both to heartbeat_interval, in case future tuning requires a shorter timeout than interval or vice versa.

Prompt for AI Agents

Please address the comments from this code review:

## Overall Comments
- Consider handling edge cases for `heartbeat_interval` (e.g., `None` or very small/zero values) explicitly before passing it to `websockets.connect`, so misconfiguration doesn't lead to confusing runtime errors or tight ping loops.
- You might want to allow configuring `ping_interval` and `ping_timeout` separately rather than tying both to `heartbeat_interval`, in case future tuning requires a shorter timeout than interval or vice versa.

## Individual Comments

### Comment 1
<location path="fns_cli/client.py" line_range="124" />
<code_context>
         )
         log.info("Connecting to %s", url)

+        interval = self.config.client.heartbeat_interval
         self.ws = await websockets.connect(
             url,
</code_context>
<issue_to_address>
**issue (bug_risk):** Validate/normalize `heartbeat_interval` before passing it to `websockets.connect`.

Because `ping_interval=None` previously disabled ping/pong, passing `self.config.client.heartbeat_interval` directly means invalid values (e.g. `0` or negative) could now cause `websockets.connect` to raise or act unexpectedly. Consider normalizing here (e.g., map `<= 0` to `None` or enforce a minimum positive value) so behavior is robust against misconfigured heartbeat values.
</issue_to_address>

---

Sourcery is free for open source - if you like our reviews please consider sharing them ✨

• X
• Mastodon
• LinkedIn
• Facebook

_{Help me be more useful! Please click 👍 or 👎 on each comment and I'll use the feedback to improve your reviews.}

[sourcery-ai]

issue (bug_risk): Validate/normalize heartbeat_interval before passing it to websockets.connect.

Because ping_interval=None previously disabled ping/pong, passing self.config.client.heartbeat_interval directly means invalid values (e.g. 0 or negative) could now cause websockets.connect to raise or act unexpectedly. Consider normalizing here (e.g., map <= 0 to None or enforce a minimum positive value) so behavior is robust against misconfigured heartbeat values.