';
}
el.innerHTML = html;
- if (isFirstRender || wasAtBottom) { el.scrollTop = el.scrollHeight; document.getElementById('scrollDownBtn').classList.remove('visible'); }
+ currentMaxMsgID = maxMsgID;
+ currentMaxTimestamp = maxTimestamp;
+ // On first visit, store max timestamp (no separator shown)
+ var chName = channelName(selectedChannel);
+ if (isFirstVisit && maxTimestamp > 0) {
+ setLastSeenTimestamp(chName, maxTimestamp);
+ }
+ // Update lastSeen when user has scrolled to the bottom (messages are "seen")
+ if (wasAtBottom && maxTimestamp > 0 && !isFirstVisit) {
+ setLastSeenTimestamp(chName, maxTimestamp);
+ }
+ // Scroll to new messages separator only on first render for this channel
+ if (newMsgSepInserted && !newMsgScrollDone) {
+ newMsgScrollDone = true;
+ setTimeout(function () {
+ var sep = document.getElementById('newMsgSep');
+ if (sep) sep.scrollIntoView({ behavior: 'smooth', block: 'start' });
+ }, 100);
+ } else if (isFirstRender || wasAtBottom) {
+ el.scrollTop = el.scrollHeight;
+ document.getElementById('scrollDownBtn').classList.remove('visible');
+ }
}
// ===== LOG =====
@@ -3003,6 +3210,46 @@
// Handle thefeed:// URI hash import
(function () { var h = location.hash; if (h && h.startsWith('#thefeed://')) { document.getElementById('importUriInput').value = decodeURIComponent(h.substring(1)); openProfiles(); doImportUri() } })();
+ // ===== AUTO-SCROLL DURING TEXT SELECTION =====
+ (function () {
+ var scrollSpeed = 0, scrollFrame = null, messagesEl = null;
+ function startAutoScroll() {
+ if (scrollFrame) return;
+ function step() {
+ if (scrollSpeed === 0 || !messagesEl) { scrollFrame = null; return }
+ messagesEl.scrollTop += scrollSpeed;
+ scrollFrame = requestAnimationFrame(step);
+ }
+ scrollFrame = requestAnimationFrame(step);
+ }
+ function stopAutoScroll() {
+ scrollSpeed = 0;
+ if (scrollFrame) { cancelAnimationFrame(scrollFrame); scrollFrame = null }
+ }
+ document.addEventListener('DOMContentLoaded', function () {
+ messagesEl = document.getElementById('messages');
+ if (!messagesEl) return;
+ var edgeZone = 40;
+ function handleMove(clientY) {
+ var sel = window.getSelection();
+ if (!sel || sel.isCollapsed) return;
+ var rect = messagesEl.getBoundingClientRect();
+ if (clientY < rect.top + edgeZone) {
+ scrollSpeed = -Math.max(2, (edgeZone - (clientY - rect.top)) / 3);
+ startAutoScroll();
+ } else if (clientY > rect.bottom - edgeZone) {
+ scrollSpeed = Math.max(2, (edgeZone - (rect.bottom - clientY)) / 3);
+ startAutoScroll();
+ } else { stopAutoScroll() }
+ }
+ messagesEl.addEventListener('touchmove', function (e) { if (e.touches[0]) handleMove(e.touches[0].clientY) });
+ messagesEl.addEventListener('touchend', stopAutoScroll);
+ messagesEl.addEventListener('touchcancel', stopAutoScroll);
+ messagesEl.addEventListener('mousemove', function (e) { if (e.buttons === 1) handleMove(e.clientY) });
+ document.addEventListener('mouseup', stopAutoScroll);
+ });
+ })();
+
init();
diff --git a/internal/web/web.go b/internal/web/web.go
index 9717af0..218a64f 100644
--- a/internal/web/web.go
+++ b/internal/web/web.go
@@ -769,6 +769,24 @@ func (s *Server) startCheckerThenRefresh() {
})
}
+// skipCheckerUseSaved uses saved resolvers from the last scan and starts
+// periodic health checks without an initial scan pass.
+func (s *Server) skipCheckerUseSaved() {
+ s.mu.RLock()
+ checker := s.checker
+ ctx := s.fetcherCtx
+ fetcher := s.fetcher
+ s.mu.RUnlock()
+ if checker == nil || fetcher == nil {
+ return
+ }
+ if ls := s.loadLastScan(); ls != nil && len(ls.Resolvers) > 0 {
+ fetcher.SetActiveResolvers(ls.Resolvers)
+ }
+ checker.StartPeriodic(ctx)
+ go s.refreshMetadataOnly()
+}
+
// nextFetchDeadline returns the Time when the server will next fetch from Telegram.
// Returns zero value if nextFetch is not set or has already passed.
func (s *Server) nextFetchDeadline() time.Time {
@@ -939,13 +957,13 @@ func (s *Server) refreshChannel(channelNum int) {
s.refreshMu.Unlock()
}()
- // Use the cached in-memory metadata if it is fresh enough (< metaCacheTTL, default 3 min).
+ // Use the cached in-memory metadata if it is fresh enough (< metaCacheTTL, default 30 sec).
// This avoids a redundant metadata DNS fetch for every channel refresh.
// If the metadata is stale (or was never fetched), fetch it from DNS now.
s.mu.RLock()
ttl := s.metaCacheTTL
if ttl <= 0 {
- ttl = 2 * time.Minute
+ ttl = 30 * time.Second
}
// Cap TTL at the time remaining until the server's next Telegram fetch.
// If nextFetch is sooner than our TTL the cached metadata may already be stale.
@@ -1218,9 +1236,10 @@ func (s *Server) handleProfiles(w http.ResponseWriter, r *http.Request) {
case http.MethodPost:
var req struct {
- Action string `json:"action"` // "create", "update", "delete", "reorder"
- Profile Profile `json:"profile"`
- Order []string `json:"order"` // for reorder
+ Action string `json:"action"` // "create", "update", "delete", "reorder"
+ Profile Profile `json:"profile"`
+ Order []string `json:"order"` // for reorder
+ SkipCheck bool `json:"skipCheck"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
http.Error(w, "invalid JSON", 400)
@@ -1306,6 +1325,8 @@ func (s *Server) handleProfiles(w http.ResponseWriter, r *http.Request) {
s.mu.Unlock()
if err := s.initFetcher(); err != nil {
log.Printf("[web] re-init fetcher after profile change: %v", err)
+ } else if req.SkipCheck {
+ s.skipCheckerUseSaved()
} else {
s.startCheckerThenRefresh()
}
@@ -1328,7 +1349,8 @@ func (s *Server) handleProfileSwitch(w http.ResponseWriter, r *http.Request) {
return
}
var req struct {
- ID string `json:"id"`
+ ID string `json:"id"`
+ SkipCheck bool `json:"skipCheck"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
http.Error(w, "invalid JSON", 400)
@@ -1373,7 +1395,11 @@ func (s *Server) handleProfileSwitch(w http.ResponseWriter, r *http.Request) {
http.Error(w, fmt.Sprintf("init fetcher: %v", err), 500)
return
}
- s.startCheckerThenRefresh()
+ if req.SkipCheck {
+ s.skipCheckerUseSaved()
+ } else {
+ s.startCheckerThenRefresh()
+ }
writeJSON(w, map[string]any{"ok": true})
}
diff --git a/test/e2e/web_e2e_test.go b/test/e2e/web_e2e_test.go
index c07e517..e86c3c8 100644
--- a/test/e2e/web_e2e_test.go
+++ b/test/e2e/web_e2e_test.go
@@ -460,3 +460,80 @@ func TestE2E_WebAPI_GlobalAuth(t *testing.T) {
t.Errorf("wrong password: expected 401, got %d", resp.StatusCode)
}
}
+
+// TestE2E_NewMsgSeparator_TimestampBased verifies the index.html uses
+// timestamp-based (not ID-based) comparison for the "new messages" separator.
+// This is critical because X/Twitter post IDs are CRC32 hashes that don't
+// increase monotonically, so ID-based comparison would place the separator
+// in wrong positions.
+func TestE2E_NewMsgSeparator_TimestampBased(t *testing.T) {
+ base, _ := startWebServer(t)
+
+ resp := getJSON(t, base+"/")
+ defer resp.Body.Close()
+ body, _ := io.ReadAll(resp.Body)
+ html := string(body)
+
+ // The separator must compare against timestamp, not message ID.
+ // Look for the timestamp-based lastSeen check in the new-msg separator logic.
+ checks := []struct {
+ name string
+ needle string
+ wantHas bool
+ }{
+ {"uses timestamp for lastSeen storage", "thefeed_seen_ts_", true},
+ {"compares msgTs > lastSeenTs", "msgTs > lastSeenTs", true},
+ {"tracks maxTimestamp", "maxTimestamp", true},
+ {"no old ID-based seen key", "thefeed_seen_'", false},
+ {"no old id > lastSeen comparison", "id > lastSeen", false},
+ }
+ for _, c := range checks {
+ has := strings.Contains(html, c.needle)
+ if has != c.wantHas {
+ if c.wantHas {
+ t.Errorf("%s: expected %q in index.html but not found", c.name, c.needle)
+ } else {
+ t.Errorf("%s: found %q in index.html but should have been removed", c.name, c.needle)
+ }
+ }
+ }
+
+ // Also verify that first-visit logic stores timestamp, not ID
+ if !strings.Contains(html, "setLastSeenTimestamp") {
+ t.Error("expected setLastSeenTimestamp function in index.html")
+ }
+ if !strings.Contains(html, "getLastSeenTimestamp") {
+ t.Error("expected getLastSeenTimestamp function in index.html")
+ }
+
+ // Verify wasAtBottom updates lastSeen on re-renders (prevents stale separator)
+ if !strings.Contains(html, "wasAtBottom && maxTimestamp > 0") {
+ t.Error("expected wasAtBottom to update lastSeen timestamp on re-render")
+ }
+}
+
+// TestE2E_MessagesHaveTimestamps verifies that the messages API response
+// includes Timestamp fields needed for the new-messages separator.
+func TestE2E_MessagesHaveTimestamps(t *testing.T) {
+ base, _ := startWebServer(t)
+
+ resp := getJSON(t, base+"/api/messages/1")
+ defer resp.Body.Close()
+
+ var result struct {
+ Messages []struct {
+ ID uint32 `json:"ID"`
+ Timestamp uint32 `json:"Timestamp"`
+ Text string `json:"Text"`
+ } `json:"messages"`
+ }
+ body, _ := io.ReadAll(resp.Body)
+ if err := json.Unmarshal(body, &result); err != nil {
+ t.Fatalf("decode messages: %v", err)
+ }
+
+ // With no messages configured, the array should be empty or nil — but the
+ // response format must still be valid JSON with a "messages" key.
+ // This verifies the API structure supports the timestamp-based separator.
+ t.Logf("messages response contains %d messages", len(result.Messages))
+}