From 204cdb8a0a2e32b658797bf4334164f6e1fd8553 Mon Sep 17 00:00:00 2001 From: RealDoc06 <73218979+RealDoc06@users.noreply.github.com> Date: Sat, 21 Nov 2026 05:59:29 +0100 Subject: [PATCH 1/4] feat(cli): page search past 100, add --since, --until and --kind Search silently stopped at 100 results. It now pages until --limit: global search with Telegram's (rate, peer, ID) cursor, search in one chat with the last message ID, stopping when a page is empty, when no next rate is given, or when the cursor does not move on. --since and --until bound message dates (a day, an RFC 3339 time or an age like 7d). --kind keeps a search everywhere to users, groups or channels. The demo backend now names the chat of each result and sorts them by date, like Telegram. Co-Authored-By: Claude Opus 5.5 --- internal/cli/cli.go | 51 ++++++++++++++++++++++- internal/cli/cli_test.go | 31 ++++++++++++++ internal/cli/guide.txt | 5 +++ internal/core/core.go | 5 +++ internal/demo/demo.go | 14 +++++-- internal/mtp/backend.go | 85 +++++++++++++++++++++++++++++++------- internal/mtp/mtp_test.go | 89 ++++++++++++++++++++++++++++++++++++++++ 7 files changed, 260 insertions(+), 20 deletions(-) diff --git a/internal/cli/cli.go b/internal/cli/cli.go index d0ab18a..693ee17 100644 --- a/internal/cli/cli.go +++ b/internal/cli/cli.go @@ -463,12 +463,32 @@ func (a *app) searchCmd() *command { c.long = `Search messages in every chat, or in one with --chat. Telegram does the matching: by whole words and their beginnings and inflections, not by substring, so "introduce" also finds "introducing". Newest matches are kept -when there are more than --limit.` +when there are more than --limit. --since and --until narrow it to a time +range, --kind a search everywhere to one kind of chat.` chatRef := c.flags.StringP("chat", "c", "", "search only in this chat") limit := c.flags.IntP("limit", "n", 30, "maximum number of messages") + since := c.flags.String("since", "", "only messages from then on: 2026-11-01, 2026-11-01T15:04:05Z, or an age like 7d or 12h") + until := c.flags.String("until", "", "only messages until then, same forms. A day counts in full") + kind := c.flags.String("kind", "", "search everywhere only in chats of this kind: user (bots too), group or channel") c.run = func(ctx context.Context, args []string) error { + q := core.SearchQuery{Text: strings.Join(args, " "), Limit: *limit, Kind: core.ChatKind(*kind)} + switch q.Kind { + case "", core.KindUser, core.KindGroup, core.KindChannel: + default: + return errUsage{fmt.Errorf("--kind %q: use user, group or channel", *kind)} + } + if q.Kind != "" && *chatRef != "" { + return errUsage{errors.New("--kind only applies to a search everywhere, drop --chat or --kind")} + } + now := time.Now() + var err error + if q.Since, err = parseWhen(*since, now, false); err != nil { + return errUsage{fmt.Errorf("--since: %w", err)} + } + if q.Until, err = parseWhen(*until, now, true); err != nil { + return errUsage{fmt.Errorf("--until: %w", err)} + } return a.backend(ctx, false, func(ctx context.Context, be core.Backend) error { - q := core.SearchQuery{Text: strings.Join(args, " "), Limit: *limit} var chat *core.Chat if *chatRef != "" { resolved, err := be.Resolve(ctx, *chatRef) @@ -495,6 +515,33 @@ when there are more than --limit.` return c } +// parseWhen reads a --since or --until value: a day, an RFC 3339 time, or an +// age before now in days (7d), hours or minutes (12h, 30m). With endOfDay, a +// day means its end, so --until 2026-11-01 includes that day. Empty is zero. +func parseWhen(s string, now time.Time, endOfDay bool) (time.Time, error) { + if s == "" { + return time.Time{}, nil + } + if days, ok := strings.CutSuffix(s, "d"); ok { + if n, err := strconv.Atoi(days); err == nil && n >= 0 { + return now.AddDate(0, 0, -n), nil + } + } + if age, err := time.ParseDuration(s); err == nil && age >= 0 { + return now.Add(-age), nil + } + if day, err := time.ParseInLocation(time.DateOnly, s, time.Local); err == nil { + if endOfDay { + day = day.AddDate(0, 0, 1).Add(-time.Second) + } + return day, nil + } + if t, err := time.Parse(time.RFC3339, s); err == nil { + return t, nil + } + return time.Time{}, fmt.Errorf("%q is not a date (2026-11-01), a time (2026-11-01T15:04:05Z) or an age (7d, 12h)", s) +} + func (a *app) markReadCmd() *command { c := a.newCommand("mark-read ", "Mark every message of a chat as read", 1, 1) c.run = func(ctx context.Context, args []string) error { diff --git a/internal/cli/cli_test.go b/internal/cli/cli_test.go index 0d5e814..9549d9e 100644 --- a/internal/cli/cli_test.go +++ b/internal/cli/cli_test.go @@ -99,6 +99,9 @@ func TestUsageErrors(t *testing.T) { {"read", "alice", "--bogus"}, {"nope"}, {"send", "alice"}, // no text, stdin is not a pipe with content + {"search", "x", "--kind", "bot"}, + {"search", "x", "--kind", "channel", "-c", "alice"}, + {"search", "x", "--since", "yesterday"}, } { if err := run(t, args...); !errors.As(err, new(errUsage)) { t.Errorf("tg %s: got %v, want a usage error", strings.Join(args, " "), err) @@ -110,6 +113,34 @@ func TestUsageErrors(t *testing.T) { } } +// A day passed to --until counts in full, so --since and --until with the +// same day cover that day. +func TestParseWhen(t *testing.T) { + now := time.Date(2026, 11, 21, 12, 0, 0, 0, time.Local) + for _, c := range []struct { + in string + endOfDay bool + want time.Time + }{ + {"", false, time.Time{}}, + {"7d", false, now.AddDate(0, 0, -7)}, + {"12h", false, now.Add(-12 * time.Hour)}, + {"2026-11-01", false, time.Date(2026, 11, 1, 0, 0, 0, 0, time.Local)}, + {"2026-11-01", true, time.Date(2026, 11, 1, 23, 59, 59, 0, time.Local)}, + {"2026-11-01T15:04:05Z", true, time.Date(2026, 11, 1, 15, 4, 5, 0, time.UTC)}, + } { + got, err := parseWhen(c.in, now, c.endOfDay) + if err != nil || !got.Equal(c.want) { + t.Errorf("parseWhen(%q, %v) = %v, %v, want %v", c.in, c.endOfDay, got, err, c.want) + } + } + for _, in := range []string{"yesterday", "-3d", "-2h", "7"} { + if _, err := parseWhen(in, now, false); err == nil { + t.Errorf("parseWhen(%q) accepted", in) + } + } +} + func TestMessageLine(t *testing.T) { date := time.Date(2026, 3, 4, 9, 5, 0, 0, time.UTC) cases := map[string]core.Message{ diff --git a/internal/cli/guide.txt b/internal/cli/guide.txt index f7c21e8..59062cb 100644 --- a/internal/cli/guide.txt +++ b/internal/cli/guide.txt @@ -19,6 +19,11 @@ ALSO tg read --after only what is newer than a message tg read --before page back through older history tg search [-c ] search everywhere, or in one chat + tg search --since 7d --until 2026-11-01 --kind channel + only in a time range (a date, an RFC + 3339 time or an age like 7d, 12h), or + everywhere in chats of one kind: user, + group or channel tg send -f "caption" attach a file or image tg download -o save a message's photo or file. Never over an existing file, never into tg's diff --git a/internal/core/core.go b/internal/core/core.go index 00f5718..45a5b86 100644 --- a/internal/core/core.go +++ b/internal/core/core.go @@ -189,6 +189,11 @@ type SearchQuery struct { Text string ChatID int64 Limit int + // Since and Until bound the message dates when set. + Since, Until time.Time + // Kind, when set, keeps a search everywhere to chats of that kind. + // KindUser covers bots too, Telegram does not tell them apart here. + Kind ChatKind } // EventKind tells what happened in an Event. diff --git a/internal/demo/demo.go b/internal/demo/demo.go index 8cd522d..05b4907 100644 --- a/internal/demo/demo.go +++ b/internal/demo/demo.go @@ -337,15 +337,23 @@ func (b *Backend) Search(_ context.Context, q core.SearchQuery) ([]core.Message, defer b.mu.Unlock() var out []core.Message for _, c := range b.chats { - if q.ChatID != 0 && c.ID != q.ChatID { + kind := c.Kind + if kind == core.KindBot { + kind = core.KindUser // as on Telegram + } + if q.ChatID != 0 && c.ID != q.ChatID || q.Kind != "" && kind != q.Kind { continue } for _, m := range b.messages[c.ID] { - if strings.Contains(strings.ToLower(m.Text), strings.ToLower(q.Text)) { - out = append(out, m) + if !strings.Contains(strings.ToLower(m.Text), strings.ToLower(q.Text)) || + !q.Since.IsZero() && m.Date.Before(q.Since) || !q.Until.IsZero() && m.Date.After(q.Until) { + continue } + m.Chat = c.Title + out = append(out, m) } } + slices.SortStableFunc(out, func(x, y core.Message) int { return x.Date.Compare(y.Date) }) if q.Limit > 0 && len(out) > q.Limit { out = out[len(out)-q.Limit:] } diff --git a/internal/mtp/backend.go b/internal/mtp/backend.go index 6dc32ab..521e637 100644 --- a/internal/mtp/backend.go +++ b/internal/mtp/backend.go @@ -353,30 +353,77 @@ func (b *backend) CreateGroup(ctx context.Context, title string) (core.Chat, err return core.Chat{}, errors.New("Telegram did not return the new group") } +// Search pages through Telegram's results until q.Limit matches. Global +// search moves on with a (rate, peer, ID) cursor, search in one chat with the +// last message ID. Paging stops when a page is empty, when Telegram says no +// more are left, or when the cursor does not move on. func (b *backend) Search(ctx context.Context, q core.SearchQuery) ([]core.Message, error) { limit := q.Limit - if limit <= 0 || limit > pageSize { + if limit <= 0 { limit = pageSize } - var res tg.MessagesMessagesClass - var err error - if q.ChatID == 0 { - res, err = b.api.MessagesSearchGlobal(ctx, &tg.MessagesSearchGlobalRequest{ - Q: q.Text, Filter: &tg.InputMessagesFilterEmpty{}, OffsetPeer: &tg.InputPeerEmpty{}, Limit: limit, - }) - } else { - var peer tg.InputPeerClass + var peer tg.InputPeerClass + if q.ChatID != 0 { + var err error if peer, err = b.peers.input(q.ChatID); err != nil { return nil, err } - res, err = b.api.MessagesSearch(ctx, &tg.MessagesSearchRequest{ - Peer: peer, Q: q.Text, Filter: &tg.InputMessagesFilterEmpty{}, Limit: limit, - }) } - if err != nil { - return nil, err + minDate, maxDate := unixDate(q.Since), unixDate(q.Until) + global := tg.MessagesSearchGlobalRequest{ + Q: q.Text, Filter: &tg.InputMessagesFilterEmpty{}, MinDate: minDate, MaxDate: maxDate, + OffsetPeer: &tg.InputPeerEmpty{}, + BroadcastsOnly: q.Kind == core.KindChannel, GroupsOnly: q.Kind == core.KindGroup, UsersOnly: q.Kind == core.KindUser, + } + inChat := tg.MessagesSearchRequest{Peer: peer, Q: q.Text, Filter: &tg.InputMessagesFilterEmpty{}, MinDate: minDate, MaxDate: maxDate} + var out []core.Message + for len(out) < limit { + want := min(pageSize, limit-len(out)) + var res tg.MessagesMessagesClass + var err error + if peer == nil { + global.Limit = want + res, err = b.api.MessagesSearchGlobal(ctx, &global) + } else { + inChat.Limit = want + res, err = b.api.MessagesSearch(ctx, &inChat) + } + if err != nil { + return nil, err + } + page, ok := res.AsModified() + if !ok || len(page.GetMessages()) == 0 { + break + } + out = append(out, b.messages(res)...) + raw := page.GetMessages() + last := raw[len(raw)-1] + if _, all := res.(*tg.MessagesMessages); all { + break + } + if peer != nil { + // Results come newest first, so the last ID only goes down. + if inChat.OffsetID != 0 && last.GetID() >= inChat.OffsetID { + break + } + inChat.OffsetID = last.GetID() + continue + } + slice, ok := res.(*tg.MessagesMessagesSlice) + if !ok { + break + } + rate, more := slice.GetNextRate() + msg, ok := last.AsNotEmpty() + if !more || !ok || (rate == global.OffsetRate && last.GetID() == global.OffsetID) { + break + } + lastPeer, err := b.peers.input(chatIDOf(msg.GetPeerID())) + if err != nil { + break + } + global.OffsetRate, global.OffsetPeer, global.OffsetID = rate, lastPeer, last.GetID() } - out := b.messages(res) for i := range out { if chat, ok := b.peers.chat(out[i].ChatID); ok { out[i].Chat = chat.Title @@ -386,6 +433,14 @@ func (b *backend) Search(ctx context.Context, q core.SearchQuery) ([]core.Messag return out, nil } +// unixDate converts a date bound of a request, 0 when there is none. +func unixDate(t time.Time) int { + if t.IsZero() { + return 0 + } + return int(t.Unix()) +} + func (b *backend) Avatar(ctx context.Context, chat core.Chat) ([]byte, error) { if chat.PhotoID == 0 { return nil, fmt.Errorf("chat %d has no photo", chat.ID) diff --git a/internal/mtp/mtp_test.go b/internal/mtp/mtp_test.go index 87592c8..dd394ed 100644 --- a/internal/mtp/mtp_test.go +++ b/internal/mtp/mtp_test.go @@ -1,10 +1,14 @@ package mtp import ( + "context" + "errors" + "fmt" "path/filepath" "slices" "testing" + "github.com/gotd/td/bin" "github.com/gotd/td/tg" "github.com/RealDoc06/tg-cli/internal/core" @@ -178,3 +182,88 @@ func TestTextLinks(t *testing.T) { t.Fatalf("textLinks = %+v, want %+v", links, want) } } + +// fakeSearch answers searches from canned pages and records each request. +type fakeSearch struct { + pages []tg.MessagesMessagesClass + global []tg.MessagesSearchGlobalRequest + inChat []tg.MessagesSearchRequest +} + +func (f *fakeSearch) Invoke(_ context.Context, in bin.Encoder, out bin.Decoder) error { + switch req := in.(type) { + case *tg.MessagesSearchGlobalRequest: + f.global = append(f.global, *req) + case *tg.MessagesSearchRequest: + f.inChat = append(f.inChat, *req) + default: + return fmt.Errorf("unexpected request %T", in) + } + if len(f.pages) == 0 { + return errors.New("asked for a page past the end") + } + var buf bin.Buffer + box := tg.MessagesMessagesBox{Messages: f.pages[0]} + f.pages = f.pages[1:] + if err := box.Encode(&buf); err != nil { + return err + } + return out.Decode(&buf) +} + +// channelPost is message id of channel 50, n minutes after the epoch. +func channelPost(id, n int) tg.MessageClass { + return &tg.Message{ID: id, PeerID: &tg.PeerChannel{ChannelID: 50}, Date: n * 60, Message: "deal"} +} + +// Global search moves on with the (rate, peer, ID) cursor of the previous +// page, and stops when Telegram gives no next rate. +func TestSearchGlobalPages(t *testing.T) { + channel := []tg.ChatClass{&tg.Channel{ID: 50, AccessHash: 500, Title: "Deals", Broadcast: true, Photo: &tg.ChatPhotoEmpty{}}} + fake := &fakeSearch{pages: []tg.MessagesMessagesClass{ + &tg.MessagesMessagesSlice{Count: 5, NextRate: 77, Messages: []tg.MessageClass{channelPost(9, 9), channelPost(8, 8)}, Chats: channel}, + &tg.MessagesMessagesSlice{Count: 5, NextRate: 66, Messages: []tg.MessageClass{channelPost(7, 7), channelPost(6, 6)}, Chats: channel}, + &tg.MessagesMessagesSlice{Count: 5, Messages: []tg.MessageClass{channelPost(5, 5)}, Chats: channel}, + }} + b := &backend{api: tg.NewClient(fake), peers: testStore(t)} + + msgs, err := b.Search(context.Background(), core.SearchQuery{Text: "deal", Limit: 101, Kind: core.KindChannel}) + if err != nil { + t.Fatal(err) + } + var ids []int + for _, m := range msgs { + ids = append(ids, m.ID) + } + if !slices.Equal(ids, []int{5, 6, 7, 8, 9}) || msgs[0].Chat != "Deals" { + t.Fatalf("messages = %v, chat %q", ids, msgs[0].Chat) + } + if len(fake.global) != 3 { + t.Fatalf("%d requests, want 3", len(fake.global)) + } + second := fake.global[1] + peer, ok := second.OffsetPeer.(*tg.InputPeerChannel) + if second.OffsetRate != 77 || second.OffsetID != 8 || !ok || peer.ChannelID != 50 || peer.AccessHash != 500 { + t.Errorf("second request cursor = rate %d, ID %d, peer %+v", second.OffsetRate, second.OffsetID, second.OffsetPeer) + } + if !second.BroadcastsOnly || second.Limit != 99 { + t.Errorf("second request = broadcasts only %v, limit %d", second.BroadcastsOnly, second.Limit) + } +} + +// Search in one chat stops when Telegram hands back the same page. +func TestSearchInChatStopsWithoutProgress(t *testing.T) { + page := &tg.MessagesChannelMessages{Count: 9, Messages: []tg.MessageClass{channelPost(4, 4), channelPost(3, 3)}, + Chats: []tg.ChatClass{&tg.Channel{ID: 50, AccessHash: 500, Title: "Deals", Broadcast: true, Photo: &tg.ChatPhotoEmpty{}}}} + fake := &fakeSearch{pages: []tg.MessagesMessagesClass{page, page, page}} + b := &backend{api: tg.NewClient(fake), peers: testStore(t)} + b.peers.learn(tg.EntitiesFrom(nil, page.Chats), 0) + + msgs, err := b.Search(context.Background(), core.SearchQuery{Text: "deal", ChatID: channelChatID(50), Limit: 300}) + if err != nil { + t.Fatal(err) + } + if len(fake.inChat) != 2 || fake.inChat[1].OffsetID != 3 || len(msgs) != 4 { + t.Errorf("%d requests, second offset %d, %d messages", len(fake.inChat), fake.inChat[len(fake.inChat)-1].OffsetID, len(msgs)) + } +} From 132fea9b4ba4d2ec332caca573c7c7d21e3af914 Mon Sep 17 00:00:00 2001 From: RealDoc06 <73218979+RealDoc06@users.noreply.github.com> Date: Sat, 21 Nov 2026 06:08:29 +0100 Subject: [PATCH 2/4] fix(cli): search paging never repeats a page, includes its date bounds Check that the cursor moved before taking a page, stop at the exact count Telegram gives, fall back to the last message's date without a next rate, and widen Telegram's exclusive date bounds by a second. Co-Authored-By: Claude Opus 5.5 --- internal/cli/cli.go | 3 ++ internal/cli/cli_test.go | 1 + internal/cli/guide.txt | 2 +- internal/mtp/backend.go | 89 +++++++++++++++++++++++++++------------- internal/mtp/mtp_test.go | 59 +++++++++++++++++--------- 5 files changed, 106 insertions(+), 48 deletions(-) diff --git a/internal/cli/cli.go b/internal/cli/cli.go index 693ee17..9c7a826 100644 --- a/internal/cli/cli.go +++ b/internal/cli/cli.go @@ -488,6 +488,9 @@ range, --kind a search everywhere to one kind of chat.` if q.Until, err = parseWhen(*until, now, true); err != nil { return errUsage{fmt.Errorf("--until: %w", err)} } + if !q.Since.IsZero() && !q.Until.IsZero() && q.Since.After(q.Until) { + return errUsage{errors.New("--since is after --until, nothing can match: swap them")} + } return a.backend(ctx, false, func(ctx context.Context, be core.Backend) error { var chat *core.Chat if *chatRef != "" { diff --git a/internal/cli/cli_test.go b/internal/cli/cli_test.go index 9549d9e..8bc2b38 100644 --- a/internal/cli/cli_test.go +++ b/internal/cli/cli_test.go @@ -102,6 +102,7 @@ func TestUsageErrors(t *testing.T) { {"search", "x", "--kind", "bot"}, {"search", "x", "--kind", "channel", "-c", "alice"}, {"search", "x", "--since", "yesterday"}, + {"search", "x", "--since", "2026-11-02", "--until", "2026-11-01"}, } { if err := run(t, args...); !errors.As(err, new(errUsage)) { t.Errorf("tg %s: got %v, want a usage error", strings.Join(args, " "), err) diff --git a/internal/cli/guide.txt b/internal/cli/guide.txt index 59062cb..6f0d6cb 100644 --- a/internal/cli/guide.txt +++ b/internal/cli/guide.txt @@ -19,7 +19,7 @@ ALSO tg read --after only what is newer than a message tg read --before page back through older history tg search [-c ] search everywhere, or in one chat - tg search --since 7d --until 2026-11-01 --kind channel + tg search --since 2026-10-01 --until 2026-10-31 --kind channel -n 500 only in a time range (a date, an RFC 3339 time or an age like 7d, 12h), or everywhere in chats of one kind: user, diff --git a/internal/mtp/backend.go b/internal/mtp/backend.go index 521e637..e8f4a00 100644 --- a/internal/mtp/backend.go +++ b/internal/mtp/backend.go @@ -5,6 +5,7 @@ import ( "context" "errors" "fmt" + "math" "os" "path/filepath" "slices" @@ -354,9 +355,9 @@ func (b *backend) CreateGroup(ctx context.Context, title string) (core.Chat, err } // Search pages through Telegram's results until q.Limit matches. Global -// search moves on with a (rate, peer, ID) cursor, search in one chat with the -// last message ID. Paging stops when a page is empty, when Telegram says no -// more are left, or when the cursor does not move on. +// search moves on with a (rate, chat, ID) cursor, search in one chat with the +// last message ID. Paging stops when a page is empty, repeats the last one, +// or ends the count Telegram gave. func (b *backend) Search(ctx context.Context, q core.SearchQuery) ([]core.Message, error) { limit := q.Limit if limit <= 0 { @@ -369,7 +370,14 @@ func (b *backend) Search(ctx context.Context, q core.SearchQuery) ([]core.Messag return nil, err } } - minDate, maxDate := unixDate(q.Since), unixDate(q.Until) + // Telegram's bounds leave out the second they name, the query's include it. + var minDate, maxDate int + if !q.Since.IsZero() { + minDate = clampDate(q.Since.Unix() - 1) + } + if !q.Until.IsZero() { + maxDate = clampDate(q.Until.Unix() + 1) + } global := tg.MessagesSearchGlobalRequest{ Q: q.Text, Filter: &tg.InputMessagesFilterEmpty{}, MinDate: minDate, MaxDate: maxDate, OffsetPeer: &tg.InputPeerEmpty{}, @@ -377,6 +385,8 @@ func (b *backend) Search(ctx context.Context, q core.SearchQuery) ([]core.Messag } inChat := tg.MessagesSearchRequest{Peer: peer, Q: q.Text, Filter: &tg.InputMessagesFilterEmpty{}, MinDate: minDate, MaxDate: maxDate} var out []core.Message + var lastChat int64 // the chat of global.OffsetID + seen := 0 for len(out) < limit { want := min(pageSize, limit-len(out)) var res tg.MessagesMessagesClass @@ -392,37 +402,40 @@ func (b *backend) Search(ctx context.Context, q core.SearchQuery) ([]core.Messag return nil, err } page, ok := res.AsModified() - if !ok || len(page.GetMessages()) == 0 { + if !ok { + break + } + last, ok := lastMessage(page.GetMessages()) + if !ok { + break + } + chat := chatIDOf(last.GetPeerID()) + // Results come newest first: a page that does not go past the + // cursor repeats what was already taken. + if peer != nil && inChat.OffsetID != 0 && last.GetID() >= inChat.OffsetID || + peer == nil && last.GetID() == global.OffsetID && chat == lastChat { break } out = append(out, b.messages(res)...) - raw := page.GetMessages() - last := raw[len(raw)-1] - if _, all := res.(*tg.MessagesMessages); all { + seen += len(page.GetMessages()) + if complete(res, seen) { break } if peer != nil { - // Results come newest first, so the last ID only goes down. - if inChat.OffsetID != 0 && last.GetID() >= inChat.OffsetID { - break - } inChat.OffsetID = last.GetID() continue } - slice, ok := res.(*tg.MessagesMessagesSlice) - if !ok { - break - } - rate, more := slice.GetNextRate() - msg, ok := last.AsNotEmpty() - if !more || !ok || (rate == global.OffsetRate && last.GetID() == global.OffsetID) { - break - } - lastPeer, err := b.peers.input(chatIDOf(msg.GetPeerID())) + next, err := b.peers.input(chat) if err != nil { break } - global.OffsetRate, global.OffsetPeer, global.OffsetID = rate, lastPeer, last.GetID() + rate := last.GetDate() // what offset_rate falls back to without a next rate + if slice, ok := res.(*tg.MessagesMessagesSlice); ok { + if r, ok := slice.GetNextRate(); ok { + rate = r + } + } + global.OffsetRate, global.OffsetPeer, global.OffsetID, lastChat = rate, next, last.GetID(), chat } for i := range out { if chat, ok := b.peers.chat(out[i].ChatID); ok { @@ -433,12 +446,32 @@ func (b *backend) Search(ctx context.Context, q core.SearchQuery) ([]core.Messag return out, nil } -// unixDate converts a date bound of a request, 0 when there is none. -func unixDate(t time.Time) int { - if t.IsZero() { - return 0 +// lastMessage is the oldest message of a page of results, skipping deleted ones. +func lastMessage(raw []tg.MessageClass) (tg.NotEmptyMessage, bool) { + for i := len(raw) - 1; i >= 0; i-- { + if m, ok := raw[i].AsNotEmpty(); ok { + return m, true + } } - return int(t.Unix()) + return nil, false +} + +// complete tells whether seen messages are all the results there are. +func complete(res tg.MessagesMessagesClass, seen int) bool { + switch r := res.(type) { + case *tg.MessagesMessages: + return true + case *tg.MessagesMessagesSlice: + return !r.Inexact && seen >= r.Count + case *tg.MessagesChannelMessages: + return !r.Inexact && seen >= r.Count + } + return false +} + +// clampDate fits a Unix time in the 32 bits Telegram sends dates in. +func clampDate(unix int64) int { + return int(min(max(unix, 1), math.MaxInt32)) } func (b *backend) Avatar(ctx context.Context, chat core.Chat) ([]byte, error) { diff --git a/internal/mtp/mtp_test.go b/internal/mtp/mtp_test.go index dd394ed..7c1d4c5 100644 --- a/internal/mtp/mtp_test.go +++ b/internal/mtp/mtp_test.go @@ -7,6 +7,7 @@ import ( "path/filepath" "slices" "testing" + "time" "github.com/gotd/td/bin" "github.com/gotd/td/tg" @@ -217,17 +218,19 @@ func channelPost(id, n int) tg.MessageClass { } // Global search moves on with the (rate, peer, ID) cursor of the previous -// page, and stops when Telegram gives no next rate. +// page, and stops once it has the count Telegram gave. func TestSearchGlobalPages(t *testing.T) { channel := []tg.ChatClass{&tg.Channel{ID: 50, AccessHash: 500, Title: "Deals", Broadcast: true, Photo: &tg.ChatPhotoEmpty{}}} fake := &fakeSearch{pages: []tg.MessagesMessagesClass{ &tg.MessagesMessagesSlice{Count: 5, NextRate: 77, Messages: []tg.MessageClass{channelPost(9, 9), channelPost(8, 8)}, Chats: channel}, &tg.MessagesMessagesSlice{Count: 5, NextRate: 66, Messages: []tg.MessageClass{channelPost(7, 7), channelPost(6, 6)}, Chats: channel}, - &tg.MessagesMessagesSlice{Count: 5, Messages: []tg.MessageClass{channelPost(5, 5)}, Chats: channel}, + &tg.MessagesMessagesSlice{Count: 6, Messages: []tg.MessageClass{channelPost(5, 5)}, Chats: channel}, + &tg.MessagesMessagesSlice{Count: 6, Messages: []tg.MessageClass{channelPost(4, 4)}, Chats: channel}, }} b := &backend{api: tg.NewClient(fake), peers: testStore(t)} - msgs, err := b.Search(context.Background(), core.SearchQuery{Text: "deal", Limit: 101, Kind: core.KindChannel}) + since, until := time.Unix(1000, 0), time.Unix(2000, 0) + msgs, err := b.Search(context.Background(), core.SearchQuery{Text: "deal", Limit: 101, Kind: core.KindChannel, Since: since, Until: until}) if err != nil { t.Fatal(err) } @@ -235,11 +238,19 @@ func TestSearchGlobalPages(t *testing.T) { for _, m := range msgs { ids = append(ids, m.ID) } - if !slices.Equal(ids, []int{5, 6, 7, 8, 9}) || msgs[0].Chat != "Deals" { + if !slices.Equal(ids, []int{4, 5, 6, 7, 8, 9}) || msgs[0].Chat != "Deals" { t.Fatalf("messages = %v, chat %q", ids, msgs[0].Chat) } - if len(fake.global) != 3 { - t.Fatalf("%d requests, want 3", len(fake.global)) + if len(fake.global) != 4 { + t.Fatalf("%d requests, want 4", len(fake.global)) + } + // Without a next rate, the date of the last message stands in. + if fake.global[3].OffsetRate != 5*60 || fake.global[3].OffsetID != 5 { + t.Errorf("fourth request cursor = rate %d, ID %d", fake.global[3].OffsetRate, fake.global[3].OffsetID) + } + // Telegram's bounds leave their own second out. + if first := fake.global[0]; first.MinDate != 999 || first.MaxDate != 2001 { + t.Errorf("date bounds = %d, %d", first.MinDate, first.MaxDate) } second := fake.global[1] peer, ok := second.OffsetPeer.(*tg.InputPeerChannel) @@ -251,19 +262,29 @@ func TestSearchGlobalPages(t *testing.T) { } } -// Search in one chat stops when Telegram hands back the same page. -func TestSearchInChatStopsWithoutProgress(t *testing.T) { - page := &tg.MessagesChannelMessages{Count: 9, Messages: []tg.MessageClass{channelPost(4, 4), channelPost(3, 3)}, - Chats: []tg.ChatClass{&tg.Channel{ID: 50, AccessHash: 500, Title: "Deals", Broadcast: true, Photo: &tg.ChatPhotoEmpty{}}}} - fake := &fakeSearch{pages: []tg.MessagesMessagesClass{page, page, page}} - b := &backend{api: tg.NewClient(fake), peers: testStore(t)} - b.peers.learn(tg.EntitiesFrom(nil, page.Chats), 0) +// Search in one chat stops when Telegram repeats a page, without taking its +// messages twice, and when it has handed over the exact count it gave. +func TestSearchInChatStops(t *testing.T) { + chats := []tg.ChatClass{&tg.Channel{ID: 50, AccessHash: 500, Title: "Deals", Broadcast: true, Photo: &tg.ChatPhotoEmpty{}}} + page := &tg.MessagesChannelMessages{Count: 9, Messages: []tg.MessageClass{channelPost(4, 4), channelPost(3, 3)}, Chats: chats} + for _, c := range []struct { + name string + pages []tg.MessagesMessagesClass + requests int + }{ + {"repeated page", []tg.MessagesMessagesClass{page, page}, 2}, + {"count reached", []tg.MessagesMessagesClass{&tg.MessagesChannelMessages{Count: 2, Messages: page.Messages, Chats: chats}}, 1}, + } { + fake := &fakeSearch{pages: c.pages} + b := &backend{api: tg.NewClient(fake), peers: testStore(t)} + b.peers.learn(tg.EntitiesFrom(nil, chats), 0) - msgs, err := b.Search(context.Background(), core.SearchQuery{Text: "deal", ChatID: channelChatID(50), Limit: 300}) - if err != nil { - t.Fatal(err) - } - if len(fake.inChat) != 2 || fake.inChat[1].OffsetID != 3 || len(msgs) != 4 { - t.Errorf("%d requests, second offset %d, %d messages", len(fake.inChat), fake.inChat[len(fake.inChat)-1].OffsetID, len(msgs)) + msgs, err := b.Search(context.Background(), core.SearchQuery{Text: "deal", ChatID: channelChatID(50), Limit: 300}) + if err != nil { + t.Fatal(err) + } + if len(fake.inChat) != c.requests || len(msgs) != 2 { + t.Errorf("%s: %d requests, %d messages", c.name, len(fake.inChat), len(msgs)) + } } } From 2d0f2c3ee5f162fe2b6c54c76a78baf7e35f1c72 Mon Sep 17 00:00:00 2001 From: RealDoc06 <73218979+RealDoc06@users.noreply.github.com> Date: Sat, 21 Nov 2026 06:14:30 +0100 Subject: [PATCH 3/4] fix(cli): cut search bounds to the second, ignore a missing count Co-Authored-By: Claude Opus 5.5 --- internal/cli/cli.go | 4 +++- internal/cli/cli_test.go | 2 +- internal/mtp/backend.go | 7 ++++--- 3 files changed, 8 insertions(+), 5 deletions(-) diff --git a/internal/cli/cli.go b/internal/cli/cli.go index 9c7a826..87f9965 100644 --- a/internal/cli/cli.go +++ b/internal/cli/cli.go @@ -521,10 +521,12 @@ range, --kind a search everywhere to one kind of chat.` // parseWhen reads a --since or --until value: a day, an RFC 3339 time, or an // age before now in days (7d), hours or minutes (12h, 30m). With endOfDay, a // day means its end, so --until 2026-11-01 includes that day. Empty is zero. +// Times are cut to the second, as message dates are. func parseWhen(s string, now time.Time, endOfDay bool) (time.Time, error) { if s == "" { return time.Time{}, nil } + now = now.Truncate(time.Second) if days, ok := strings.CutSuffix(s, "d"); ok { if n, err := strconv.Atoi(days); err == nil && n >= 0 { return now.AddDate(0, 0, -n), nil @@ -540,7 +542,7 @@ func parseWhen(s string, now time.Time, endOfDay bool) (time.Time, error) { return day, nil } if t, err := time.Parse(time.RFC3339, s); err == nil { - return t, nil + return t.Truncate(time.Second), nil } return time.Time{}, fmt.Errorf("%q is not a date (2026-11-01), a time (2026-11-01T15:04:05Z) or an age (7d, 12h)", s) } diff --git a/internal/cli/cli_test.go b/internal/cli/cli_test.go index 8bc2b38..34cb884 100644 --- a/internal/cli/cli_test.go +++ b/internal/cli/cli_test.go @@ -128,7 +128,7 @@ func TestParseWhen(t *testing.T) { {"12h", false, now.Add(-12 * time.Hour)}, {"2026-11-01", false, time.Date(2026, 11, 1, 0, 0, 0, 0, time.Local)}, {"2026-11-01", true, time.Date(2026, 11, 1, 23, 59, 59, 0, time.Local)}, - {"2026-11-01T15:04:05Z", true, time.Date(2026, 11, 1, 15, 4, 5, 0, time.UTC)}, + {"2026-11-01T15:04:05.5Z", true, time.Date(2026, 11, 1, 15, 4, 5, 0, time.UTC)}, } { got, err := parseWhen(c.in, now, c.endOfDay) if err != nil || !got.Equal(c.want) { diff --git a/internal/mtp/backend.go b/internal/mtp/backend.go index e8f4a00..dfdf1d4 100644 --- a/internal/mtp/backend.go +++ b/internal/mtp/backend.go @@ -456,15 +456,16 @@ func lastMessage(raw []tg.MessageClass) (tg.NotEmptyMessage, bool) { return nil, false } -// complete tells whether seen messages are all the results there are. +// complete tells whether seen messages are all the results there are. A +// count of 0 alongside messages means Telegram did not give one. func complete(res tg.MessagesMessagesClass, seen int) bool { switch r := res.(type) { case *tg.MessagesMessages: return true case *tg.MessagesMessagesSlice: - return !r.Inexact && seen >= r.Count + return !r.Inexact && r.Count > 0 && seen >= r.Count case *tg.MessagesChannelMessages: - return !r.Inexact && seen >= r.Count + return !r.Inexact && r.Count > 0 && seen >= r.Count } return false } From 24cf8c7426024713b5ce07c6429c4ec575054642 Mon Sep 17 00:00:00 2001 From: RealDoc06 <73218979+RealDoc06@users.noreply.github.com> Date: Sat, 21 Nov 2026 06:15:45 +0100 Subject: [PATCH 4/4] fix(cli): cut fractional ages to the second too Co-Authored-By: Claude Opus 5.5 --- internal/cli/cli.go | 2 +- internal/cli/cli_test.go | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/internal/cli/cli.go b/internal/cli/cli.go index 87f9965..15ff56d 100644 --- a/internal/cli/cli.go +++ b/internal/cli/cli.go @@ -533,7 +533,7 @@ func parseWhen(s string, now time.Time, endOfDay bool) (time.Time, error) { } } if age, err := time.ParseDuration(s); err == nil && age >= 0 { - return now.Add(-age), nil + return now.Add(-age).Truncate(time.Second), nil } if day, err := time.ParseInLocation(time.DateOnly, s, time.Local); err == nil { if endOfDay { diff --git a/internal/cli/cli_test.go b/internal/cli/cli_test.go index 34cb884..a1e607e 100644 --- a/internal/cli/cli_test.go +++ b/internal/cli/cli_test.go @@ -126,6 +126,7 @@ func TestParseWhen(t *testing.T) { {"", false, time.Time{}}, {"7d", false, now.AddDate(0, 0, -7)}, {"12h", false, now.Add(-12 * time.Hour)}, + {"1.5s", false, now.Add(-2 * time.Second)}, {"2026-11-01", false, time.Date(2026, 11, 1, 0, 0, 0, 0, time.Local)}, {"2026-11-01", true, time.Date(2026, 11, 1, 23, 59, 59, 0, time.Local)}, {"2026-11-01T15:04:05.5Z", true, time.Date(2026, 11, 1, 15, 4, 5, 0, time.UTC)},