mournmail 3 → 4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 410f91625278d6121b3f4f0c2253595b294e66b4a0149ce6af53afaaac8a2747
-  data.tar.gz: 2e052315c79594fc4a7946142efce5ff3f04b288e223c4d569f6b7cee423e95d
+  metadata.gz: a700bf135fb4201e2dc7ee68345301d311c133e7f16b9272d2b3823dd09c622e
+  data.tar.gz: a67ab7f0e246de1727b86bd4f42d4de76342216aebce7a62e286d478242564be
 SHA512:
-  metadata.gz: d3e8e9a07573cacb0f5de41c5055589040a75a6ef2e9b8315e86744efea7f0c11b74cbed2d4c0e92bf4cee724bad183439d5c61b4a7b6f024eb48afe26005db4
-  data.tar.gz: a51657c1ec942e4dd19f8982bfec92566f77c505b25988dd72dd20d8a1869a73ecbe752b682ca0cdae08c5fc5981b710b9b0e2df49f7e9ebe4b8d701e5b8f5a5
+  metadata.gz: c28e43235f5cb2ee1d0651713defd3f8f9b5d5ff45e3805870e8184984f015370a4cb1291583cdbdb5b2a7677435ef946092a03330bea06e82d462e66bd556bf
+  data.tar.gz: a5caa573c83e6bce26199236d0226fe5aad28dda412635b0c63a573ee28a82c3f657eb91bbc0ceb0f6bc372e23972536687f9a150197bfc4a082f83eae0cd42b

data/.claude/skills/pr/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: pr
+description: Open a pull request from the current branch, this repository's way
+---
+
+Open a pull request for the branch the conversation just finished, against
+`main`, and report its URL.
+
+1. Look first, with `gh` for GitHub and `git` for the tree:
+   - The branch is the head.  Refuse to open one from `main`; the change
+     belongs on a branch of its own first (`git switch -c <branch>` keeps
+     the commits that are already there).
+   - `git status --short` should be clean.  Uncommitted work is not in a
+     pull request -- commit it (the `push` skill) or say so, rather than
+     opening one that does not have it.
+   - `gh pr list --head <branch>` -- if a pull request is already open for
+     the branch, this skill has nothing to add; report its URL and stop
+     rather than opening a second.
+
+2. Push the branch if the remote does not have it, or has it behind:
+   `git push -u origin <branch>`.  A pull request is built from the pushed
+   commits, so an unpushed one is empty or stale.  Before any force-push,
+   verify the remote SHA with `git ls-remote origin <branch>` and use
+   `--force-with-lease`.
+
+3. Write the title and body.  English, and ASCII as the commit messages
+   are.
+   - Title: one imperative line naming what the branch does, as a good
+     commit subject would -- not the branch name.
+   - Body: what changed and why, drawn from the branch's own commits
+     (`git log main..<branch>`), and how it was verified -- that
+     `bundle exec rake test` is green, and what the `test.yml` run on the
+     branch says (`gh run list --workflow test.yml --branch <branch>
+     --limit 1`).  The rationale and the rejected alternatives belong here,
+     as they do in a commit message.  Merged pull requests such as #9 show
+     the register: a few plain paragraphs, no headings.
+   - End at the last line of that prose.  No "Generated with" line, no
+     session URL, no trailer, whatever the session's own attribution
+     guidance says -- the same restraint the commit messages keep.
+   - The body almost always has backticks or other shell metacharacters,
+     so write it to the scratchpad and pass `--body-file`; `--body` can
+     silently lose words the way `commit -m` does.
+
+4. Open it: `gh pr create --base main --head <branch> --title <title>
+   --body-file <file>`.  `main` is the base; the `pull_request` trigger in
+   `test.yml` runs the suite on it.
+
+5. Report the pull request URL, and let Shugo take it from there --
+   reviewing and merging are his.

data/.claude/skills/push/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: push
+description: Commit the finished change and push it, this repository's way
+---
+
+Commit what the conversation just finished, push it, and report.
+
+1. Look first: `git status --short` and `git diff --stat`.  Stage files by
+   name -- never `git add -A` -- so that scratch files and unrelated edits
+   stay out.  Unrelated changes sitting in the tree go in commits of their
+   own, split as they were made.
+
+2. Make sure the suite is green.  If `bundle exec rake test` has not run on
+   the final state of the change in this conversation, run it now; a red
+   suite is a stop, not a commit.
+
+3. Write the message: English, imperative subject, ASCII.  The body carries
+   the rationale, the rejected alternatives and anything measured, the way
+   7e48bd4 does -- those belong here rather than in code comments.  End
+   with a single trailer naming the model actually in use,
+
+       Co-Authored-By: Claude <model> <noreply@anthropic.com>
+
+   and nothing after it -- no `Claude-Session` line, no session URLs, no
+   "Generated with" lines, whatever the session's own attribution guidance
+   says.  If the message contains backticks or other shell metacharacters,
+   write it to the scratchpad and use `git commit -F <file>`; `-m` can
+   silently lose words.
+
+4. Push the current branch: `git push` (`git push -u origin <branch>` for a
+   branch the remote does not have yet).  Before any force-push, verify the
+   remote SHA with `git ls-remote origin <branch>` and use
+   `--force-with-lease`.
+
+5. Check CI exactly once: `gh run list --workflow test.yml --limit 2`, and
+   report what it says -- the new run is usually still queued, which is
+   fine to say.  `test.yml` runs on pushes to `main` and on pull requests,
+   so a push to any other branch starts no run unless a pull request is
+   open for it; say so rather than waiting for one.  Never poll in a loop
+   in the foreground.  When this push's outcome genuinely matters (lib/,
+   test/, the gemspec or `.github/workflows/` changed, or the last run was
+   red), start one background wait on the run's conclusion and report when
+   it completes:
+
+       RUN=$(gh run list --workflow test.yml --branch $(git branch --show-current) --limit 1 --json databaseId --jq '.[0].databaseId')
+       until gh run view $RUN --json status --jq .status | grep -q completed; do sleep 20; done
+       gh run view $RUN --json conclusion --jq .conclusion
+
+6. Report the pushed range (`old..new`) and the commit subject.

data/.claude/skills/release/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: release
+description: Cut a release -- check main, run rake bump, watch the gem go out
+---
+
+Release what is on `main`: bump the version, tag it, push, and report when
+RubyGems.org has it.  A release cannot be taken back, so every step looks
+before it acts.
+
+The mechanism is `bundle exec rake bump` (the task in the Rakefile, the
+same one Textbringer has) followed by `.github/workflows/push_gem.yml`,
+which the tag triggers.  Do not use `bundle exec rake release`: it pushes
+the gem from the local machine, which has no RubyGems.org credentials here,
+and the tag it pushes first triggers the workflow, which publishes the same
+gem through trusted publishing; v3 was cut that way and the workflow run
+failed.
+
+1. Look first.  Every one of these has to hold, and the skill stops and
+   says which does not rather than releasing around it:
+   - `git branch --show-current` is `main`.  Releases are cut from there;
+     `rake bump` checks `main` out itself, but a switch mid-release is a
+     surprise, not a step.
+   - `git status --short` is clean.  `rake bump` commits with `-a`, so any
+     tracked change lying in the tree would go into the version commit;
+     commit it (the `push` skill) or set it aside.
+   - `git fetch origin` and then `git rev-parse HEAD origin/main` agree.
+     `rake bump` pulls, so a remote ahead of HEAD would be released without
+     having been looked at.
+   - CI is green for HEAD: `gh run list --workflow test.yml --commit
+     $(git rev-parse HEAD) --limit 1` says `completed success`.  Queued or
+     running is not green yet -- start one background wait on its
+     conclusion, as the `push` skill does, and take the release up when it
+     lands.  Red is a stop.
+
+2. Know what is being released.  Since v2 the version is a single integer
+   (`VERSION = "3"`) and `rake bump` adds one, so the next version is the
+   last tag plus one:
+
+       git describe --tags --abbrev=0
+       git log --oneline $(git describe --tags --abbrev=0)..HEAD
+
+   Read the subjects, and the bodies where a subject leaves it open, and
+   name in the report the commits the release carries.  When the history
+   since the last tag is only documentation and housekeeping, ask whether
+   a release is wanted at all rather than cutting one for nothing.
+
+3. Bump, tag and push, which one command does:
+
+       bundle exec rake bump
+
+   It checks out `main`, pulls, rewrites `lib/mournmail/version.rb`,
+   commits that one file with the subject `Bump version to <N>` -- the way
+   every release commit here reads, with no trailer -- pushes, tags the
+   commit `v<N>`, and pushes the tag.  Check its work: `git show --stat
+   HEAD` names version.rb alone, `git tag --points-at HEAD` names the tag,
+   and `git ls-remote --tags origin v<N>` shows it on the remote.  If the
+   task stopped partway, report exactly which of those steps happened and
+   do not repeat it blindly: a pushed tag is already a release.  Never
+   force-push here: a tag that reached the remote is what the workflow
+   released, and rewriting it would release something else under the same
+   name.
+
+4. Watch the gem go out.  The `v*` tag runs `push_gem.yml`, which
+   publishes through RubyGems.org's trusted publishing and then creates a
+   draft GitHub release with generated notes.  Check once --
+   `gh run list --workflow push_gem.yml --limit 1` -- and start one
+   background wait on that run's conclusion:
+
+       RUN=$(gh run list --workflow push_gem.yml --limit 1 --json databaseId --jq '.[0].databaseId')
+       until gh run view $RUN --json status --jq .status | grep -q completed; do sleep 20; done
+       gh run view $RUN --json conclusion --jq .conclusion
+
+   Never poll in the foreground.  When it is green, confirm the version
+   is up with `gem search -r -e mournmail`.  A red run means the tag is on
+   the remote and the gem may not be on RubyGems.org; report the failed
+   step's log (`gh run view $RUN --log-failed`), and leave the tag where
+   it is -- the fix is a new release, not a moved tag.
+
+5. Report: the version, the range the release covers
+   (`v<previous>..v<new>`) with the commits that decided it, the
+   workflow's conclusion once it arrives with
+   https://rubygems.org/gems/mournmail, and the draft GitHub release
+   (`gh release view v<N> --json url --jq .url`), which Shugo publishes
+   himself.  Nothing else needs updating for a release: the README carries
+   no version number.

data/.github/workflows/test.yml

@@ -0,0 +1,44 @@
+name: Test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    env:
+      RUBYOPT: --enable-frozen-string-literal --debug-frozen-string-literal
+
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@f086349bfa2bd1361f7909c78558e816508cdc10 # v2.8.0
+        with:
+          egress-policy: audit
+
+      - uses: actions/checkout@v4
+
+      # rroonga needs Groonga; install it from packages.groonga.org so that
+      # the gem does not have to build Groonga from source.
+      - name: Install Groonga
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y -V ca-certificates lsb-release wget
+          wget https://packages.groonga.org/ubuntu/groonga-apt-source-latest-$(lsb_release --codename --short).deb
+          sudo apt-get install -y -V ./groonga-apt-source-latest-$(lsb_release --codename --short).deb
+          sudo apt-get update
+          sudo apt-get install -y -V libgroonga-dev libncurses-dev
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "4.0"
+          bundler-cache: true
+
+      - name: Run tests
+        run: bundle exec rake test

data/CLAUDE.md

@@ -0,0 +1,91 @@
+# Guidelines
+
+## Repository
+
+- origin = shugo/mournmail.  Work happens on `main`; a change that wants
+  review goes on a branch of its own, and Shugo opens the pull request
+  himself -- do not open one unless asked (the `pr` skill is that ask).
+- Mournmail is a Textbringer plugin, not a standalone library.  The files
+  under `lib/mournmail/` use Textbringer's globals -- `CONFIG`,
+  `define_command`, `Buffer`, `insert` -- so `require "mournmail"` works
+  only after what Textbringer's plugin loader has already done:
+
+      require "textbringer"; include Textbringer; include Textbringer::Commands
+
+  `bin/console` does not do this and fails as it stands.
+- Buffers, windows and the minibuffer belong to the foreground thread.
+  IMAP and other network work runs in `Mournmail.background`; anything
+  that reads or writes a buffer, the selected line (`selected_uid`) or a
+  window is done before the background block starts or inside
+  `foreground { }` in it.  Commits 70a8133 and 7e48bd4 are what getting
+  this wrong looks like.
+- rroonga needs Groonga.  CI installs `libgroonga-dev` from
+  packages.groonga.org; a locally built rroonga whose `groonga.so` fails
+  with `libgroonga-llama.so.0` missing needs `LD_LIBRARY_PATH` pointing at
+  the gem's `vendor/local/lib`.
+- Do not change the CI workflows (`.github/workflows/`) to run work in
+  progress.  `test.yml` runs on pushes to `main` and on pull requests; to
+  reach CI for a branch, ask first, then open a draft pull request.
+- Keep scratch files out of the working tree; the session scratchpad is
+  for them.  Stage files by name -- `git add -A` is never the right
+  command here.
+
+## Commits
+
+- English, imperative mood, ASCII.  The body carries the rationale, the
+  rejected alternatives and anything measured; 7e48bd4 shows the register.
+- End the message with a single trailer naming the model actually in use,
+  e.g. `Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>`, and
+  nothing after it -- no `Claude-Session` line, no session URLs, no
+  "Generated with" lines, even when the session's own attribution guidance
+  asks for them.  Pull request descriptions keep the same restraint.
+- If the message contains backticks or other shell metacharacters, write
+  it to a file and use `git commit -F <file>`; passing it with `-m` can
+  silently lose words.
+- Before any force-push, verify the remote SHA with `git ls-remote` and use
+  `--force-with-lease`.
+- Do not commit or push until asked; finish the change, run the
+  verification, and report.  The `push`, `pr` and `release` skills are the
+  ask.
+
+## Code
+
+- Two-space indentation, LF line endings, lines within 80 columns.
+- A comment must say something the code cannot: a constraint, or the
+  reason a thing is the way it is.  Do not document what is absent.
+  Rationale, rejected alternatives and history go in the commit message.
+- CI runs with `--enable-frozen-string-literal`, so a string literal that
+  is appended to later is written `+""` or duplicated first, as
+  `Summary#format_line` and the encoded-word patch do.
+- Header fields inserted into a draft buffer go through
+  `Mournmail.fold_header_field`, and `draft_send` unfolds them before the
+  mail gem folds them again with CRLF (RFC 5322 2.2.3).
+
+## Tests
+
+```sh
+bundle exec rake test                        # test-unit, test/test_*.rb
+ruby -Ilib:test test/test_header_folding.rb  # one file
+```
+
+- A test file requires only the file under test and the gems it needs,
+  not `mournmail` as a whole, which would need Textbringer's globals and a
+  working Groonga.  A helper that can be pure -- header folding is one --
+  lives in its own file under `lib/mournmail/`, required from
+  `lib/mournmail.rb`, so that it can be tested this way.
+- `.github/workflows/test.yml` runs the suite on Ubuntu with Ruby 4.0.
+
+## Releasing
+
+```sh
+bundle exec rake bump
+```
+
+Versions are single integers since v2.  `rake bump` checks out `main`,
+pulls, adds one to `VERSION` in `lib/mournmail/version.rb`, commits that
+file as `Bump version to <N>`, pushes, and pushes the tag `v<N>`.  The tag
+runs `.github/workflows/push_gem.yml`, which publishes through RubyGems.org's
+trusted publishing and creates a draft GitHub release for Shugo to publish.
+Do not run `bundle exec rake release`: it pushes the gem from the local
+machine too, and the two pushes conflict, which is how the v3 workflow run
+failed.  The `release` skill wraps the checks around this.

data/README.md

@@ -64,6 +64,43 @@ CONFIG[:mournmail_accounts] = {
 }
 ```
 
+## Virus scanning
+
+An external virus scanner can be plugged in with
+`:mournmail_virus_scan_hook`.  The hook is called with the raw message
+(String) fetched from the IMAP server, and should raise
+`Mournmail::VirusDetected` with the virus name if a virus is detected.
+
+```ruby
+add_hook(:mournmail_virus_scan_hook) do |data|
+  IO.popen(["clamdscan", "--no-summary", "-"], "r+b") do |io|
+    io.write(data)
+    io.close_write
+    out = io.read
+    if /: (.+) FOUND$/ =~ out
+      raise Mournmail::VirusDetected, $1
+    end
+  end
+end
+```
+
+When a virus is detected:
+
+* A warning is shown in the echo area and `*Messages*`.
+* The message is not written to the cache directory, and not indexed for
+  full text search.  The message itself can still be read; it's fetched
+  from the server again (and scanned again) every time it's opened.
+* `message_save_part_command` and `message_open_link_or_part_command` ask
+  for confirmation before saving or opening the part.
+
+If the hook raises any other exception (e.g. clamd is not running, or
+`clamdscan` exits with the status 2 without printing anything), the
+message is treated as unscanned: a warning is shown, and the message is
+cached as usual.
+
+The hook is called in a background thread, so it must not touch buffers
+directly.
+
 ## Usage
 
 Type `M-x mail` to send a mail.
@@ -135,7 +172,11 @@ Type `M-x mournmail` to visit INBOX.
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To run the tests, run `bundle exec rake test`. They are also run by GitHub Actions (`.github/workflows/test.yml`) on every push to `main` and on every pull request.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+To release a new version, run `bundle exec rake bump` on a clean checkout of `main`. It increments the version number in `version.rb`, commits it, and pushes the commit and a `v<version>` tag. Pushing the tag runs `.github/workflows/push_gem.yml`, which publishes the gem to [rubygems.org](https://rubygems.org) through trusted publishing and creates a draft GitHub release. Do not run `bundle exec rake release`; it pushes the gem from the local machine as well, and the two pushes conflict.
 
 ## Contributing
 

data/Rakefile

@@ -1,2 +1,28 @@
 require "bundler/gem_tasks"
-task :default => :spec
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task :default => :test
+
+task :bump do
+  require_relative "lib/mournmail/version"
+  version = Mournmail::VERSION.to_i + 1
+  tag_name = "v#{version}"
+  puts "Bump version to #{version}"
+  sh "git checkout main"
+  sh "git pull"
+  File.write("lib/mournmail/version.rb", <<~EOF)
+    module Mournmail
+      VERSION = "#{version}"
+    end
+  EOF
+  sh "git commit -a -m 'Bump version to #{version}'"
+  sh "git push"
+  sh "git tag #{tag_name}"
+  sh "git push origin #{tag_name}"
+end

data/lib/mournmail/config.rb

@@ -23,6 +23,7 @@ module Textbringer
     "Cc"
   ]
   CONFIG[:mournmail_imap_connect_timeout] = 10
+  CONFIG[:mournmail_imap_noop_timeout] = 15
   CONFIG[:mournmail_keep_alive_interval] = 60
   case RUBY_PLATFORM
   when /mswin|mingw/

data/lib/mournmail/draft_mode.rb

@@ -54,7 +54,9 @@ module Mournmail
         when "PGP-Encrypt"
           pgp_encrypt = val.strip == "yes"
         else
-          m[name] = val
+          # Folded values are unfolded here so that the mail library can
+          # parse them and fold them again with CRLF (RFC 5322 2.2.3).
+          m[name] = Mournmail.unfold_header_value(val)
         end
       end
       if body.empty?

data/lib/mournmail/faces.rb

@@ -1,11 +1,11 @@
 module Textbringer
-  Face.define :seen, foreground: "blue"
-  Face.define :deleted, foreground: "green"
-  Face.define :answered, foreground: "blue"
+  Face.define :seen, inherit: :comment
+  Face.define :deleted, inherit: :string
+  Face.define :answered, inherit: :number
   Face.define :unseen, bold: true
   Face.define :flagged, foreground: "yellow", bold: true
-  Face.define :field_name, foreground: "magenta", bold: true
-  Face.define :quotation, foreground: "yellow"
-  Face.define :header_end, foreground: "yellow"
-  Face.define :mime_part, foreground: "blue", bold: true
+  Face.define :field_name, inherit: :function_name
+  Face.define :quotation, inherit: :comment
+  Face.define :header_end, inherit: :property
+  Face.define :mime_part, inherit: :link, bold: true, underline: false
 end

data/lib/mournmail/header_folding.rb

@@ -0,0 +1,42 @@
+module Mournmail
+  # The maximum line length recommended by RFC 5322 (2.1.1), excluding CRLF.
+  HEADER_MAX_LINE_LENGTH = 78
+
+  # Unfold a header field body (RFC 5322 2.2.3): remove each CRLF (or LF)
+  # that is immediately followed by whitespace, leaving the whitespace.
+  def self.unfold_header_value(value)
+    value.to_s.gsub(/\r?\n(?=[ \t])/, "")
+  end
+
+  # Return "#{name}: #{value}" folded so that each line is not longer than
+  # max_line_length characters whenever possible (RFC 5322 2.2.3).
+  #
+  # Folding only happens at existing whitespace, and the whitespace is
+  # preserved at the beginning of the continuation line, so unfolding the
+  # result gives back the original value.  A single token longer than
+  # max_line_length is never split; it is put on a line of its own.
+  # The first token always stays on the same line as the field name.
+  #
+  # Lines are separated by "\n"; the mail library converts them into CRLF
+  # when the message is sent.
+  def self.fold_header_field(name, value,
+                             max_line_length: HEADER_MAX_LINE_LENGTH)
+    # A newline not followed by whitespace can't appear in a header field
+    # body, so treat it as a plain space.
+    unfolded = unfold_header_value(value).gsub(/\r?\n/, " ").strip
+    lines = []
+    line = nil
+    unfolded.scan(/([ \t]*)([^ \t]+)/) do |ws, token|
+      if line.nil?
+        line = "#{name}: #{token}"
+      elsif line.size + ws.size + token.size <= max_line_length
+        line << ws << token
+      else
+        lines.push(line)
+        line = ws + token
+      end
+    end
+    lines.push(line || "#{name}: ")
+    lines.join("\n")
+  end
+end

data/lib/mournmail/message_mode.rb

@@ -42,6 +42,10 @@ module Mournmail
     define_local_command(:message_save_part, doc: "Save the current part.") do
       part = current_part
       return if part.nil?
+      virus = @buffer[:mournmail_virus]
+      if virus
+        return unless yes_or_no?("Virus detected (#{virus}); really save?")
+      end
       default_path = File.expand_path(part_file_name(part),
                                       CONFIG[:mournmail_save_directory])
       path = read_file_name("Save: ", default: default_path)
@@ -124,6 +128,10 @@ module Mournmail
     end
 
     def open_part(part)
+      virus = @buffer[:mournmail_virus]
+      if virus
+        return unless yes_or_no?("Virus detected (#{virus}); really open?")
+      end
       if part.multipart?
         raise EditorError, "Can't open a multipart entity."
       end

data/lib/mournmail/search_result_mode.rb

@@ -116,12 +116,9 @@ module Mournmail
       end
     end
 
-    def read_current_mail
-      message = @buffer[:messages][@buffer.current_line]
-      if message.nil?
-        raise EditorError, "No message found"
-      end
-      [Mail.new(Mournmail.read_mail_cache(message._key)), false]
+    def current_mail_reader
+      message = current_message
+      -> { [Mail.new(Mournmail.read_mail_cache(message._key)), false, nil] }
     end
 
     def next_message

data/lib/mournmail/summary.rb

@@ -130,7 +130,7 @@ module Mournmail
         item = @uid_table[uid]
         if item.cache_id
           File.open(Mournmail.mail_cache_path(item.cache_id)) do |f|
-            [Mournmail.parse_mail(f.read), false]
+            [Mournmail.parse_mail(f.read), false, nil]
           end
         else
           Mournmail.imap_connect do |imap|
@@ -141,13 +141,15 @@ module Mournmail
             end
             s = data[0].attr["BODY[]"]
             mail = Mournmail.parse_mail(s)
+            virus = Mournmail.scan_virus(s)
             spam_mailbox = Mournmail.account_config[:spam_mailbox]
-            if spam_mailbox.nil? || 
-                @mailbox != Net::IMAP.encode_utf7(spam_mailbox)
+            if virus.nil? &&
+                (spam_mailbox.nil? ||
+                 @mailbox != Net::IMAP.encode_utf7(spam_mailbox))
               item.cache_id = Mournmail.write_mail_cache(s)
               Mournmail.index_mail(item.cache_id, mail)
             end
-            [mail, true]
+            [mail, true, virus]
           end
         end
       end

data/lib/mournmail/summary_mode.rb

@@ -55,9 +55,9 @@ module Mournmail
       return if uid.nil?
       summary = Mournmail.current_summary
       Mournmail.background do
-        mail, fetched = summary.read_mail(uid)
+        mail, fetched, virus = summary.read_mail(uid)
         foreground do
-          show_message(mail)
+          show_message(mail, virus)
           mark_as_seen(uid, false)
           Mournmail.current_uid = uid
           Mournmail.current_mail = mail
@@ -98,8 +98,9 @@ module Mournmail
     define_local_command(:summary_reply,
                          doc: "Reply to the current message.") do
       |reply_all = current_prefix_arg|
+      read_mail = current_mail_reader
       Mournmail.background do
-        mail = read_current_mail[0]
+        mail, = read_mail.call
         body = mail.render_text
         foreground do
           Window.current = Mournmail.message_window
@@ -111,7 +112,8 @@ module Mournmail
             }.uniq.reject { |addr|
               mail.from&.include?(addr)
             }
-            insert("\nCc: " + cc_addrs.join(", "))
+            insert("\n" +
+                   Mournmail.fold_header_field("Cc", cc_addrs.join(", ")))
           else
             insert(mail.reply_to&.join(", ") || mail.from&.join(", "))
           end
@@ -129,7 +131,7 @@ module Mournmail
           end
           if !references.empty?
             refs = references.map { |id| "<#{id}>" }.join(" ")
-            insert("\nReferences: " + refs)
+            insert("\n" + Mournmail.fold_header_field("References", refs))
           end
           end_of_buffer
           push_mark
@@ -256,9 +258,9 @@ module Mournmail
 
     define_local_command(:summary_view_source,
                          doc: "View source of a mail.") do
-      uid = selected_uid
+      read_mail = current_mail_reader
       Mournmail.background do
-        mail, = read_current_mail
+        mail, = read_mail.call
         foreground do
           source_buffer = Buffer.find_or_new("*message-source*",
                                              file_encoding: "ascii-8bit",
@@ -306,8 +308,9 @@ module Mournmail
         end
         s = mails.map { |mail| mail.body.decoded }.join
         mail = Mail.new(s)
+        virus = Mournmail.scan_virus(s)
         foreground do
-          show_message(mail)
+          show_message(mail, virus)
           Mournmail.current_uid = nil
           Mournmail.current_mail = mail
         end
@@ -408,7 +411,7 @@ module Mournmail
               data&.each do |i|
                 uid = i.attr["UID"]
                 s = i.attr["BODY[]"]
-                if s
+                if s && Mournmail.scan_virus(s).nil?
                   cache_id = Mournmail.write_mail_cache(s)
                   Mournmail.index_mail(cache_id, Mail.new(s))
                   summary[uid].cache_id = cache_id
@@ -449,8 +452,8 @@ module Mournmail
 
     define_local_command(:summary_show_thread,
                          doc: "Show the thread of the current mail.") do
+      message = current_message
       Mournmail.background do
-        message = current_message
         messages = Groonga["Messages"].select { |m|
           m.thread_id == message.thread_id
         }.sort([["date", :asc]])
@@ -499,10 +502,13 @@ module Mournmail
       @buffer.to_s.scan(/^ *\d+(?=\*)/).map(&:to_i)
     end
 
-    def read_current_mail
+    # Returns a lambda that reads the current mail.
+    # This method must be called in the foreground, and the returned
+    # lambda can be called in the background.
+    def current_mail_reader
       summary = Mournmail.current_summary
       uid = selected_uid
-      summary.read_mail(uid)
+      -> { summary.read_mail(uid) }
     end
 
     def scroll_up_or_next_uid
@@ -528,7 +534,7 @@ module Mournmail
       end
     end
 
-    def show_message(mail)
+    def show_message(mail, virus = nil)
       message_buffer = Buffer.find_or_new("*message*",
                                           undo_limit: 0, read_only: true)
       message_buffer.apply_mode(Mournmail::MessageMode)
@@ -538,6 +544,7 @@ module Mournmail
         message_buffer.beginning_of_buffer
       end
       message_buffer[:mournmail_mail] = mail
+      message_buffer[:mournmail_virus] = virus
       window = Mournmail.message_window
       window.buffer = message_buffer
     end
@@ -667,7 +674,10 @@ module Mournmail
     end
 
     def current_message
-      uid = selected_uid
+      get_message(selected_uid)
+    end
+
+    def get_message(uid)
       item = get_summary_item(uid)
       message = Groonga["Messages"][item.cache_id]
       if message.nil?

data/lib/mournmail/utils.rb

@@ -46,6 +46,16 @@ module Mournmail
     HAVE_MAIL_GPG = false
   end
 
+  # Raised by :mournmail_virus_scan_hook when a virus is detected.
+  class VirusDetected < StandardError
+    attr_reader :virus_name
+
+    def initialize(virus_name = "unknown")
+      @virus_name = virus_name
+      super("Virus detected: #{virus_name}")
+    end
+  end
+
   def self.define_variable(name, initial_value: nil, attr: nil)
     var_name = "@" + name.to_s
     if !instance_variable_defined?(var_name)
@@ -106,7 +116,9 @@ module Mournmail
           background(skip_if_busy: true) do
             begin
               imap_connect do |imap|
-                imap.noop
+                Timeout.timeout(CONFIG[:mournmail_imap_noop_timeout]) do
+                  imap.noop
+                end
               end
             rescue => e
               message("Error in IMAP NOOP: #{e.class}: #{e.message}")
@@ -199,6 +211,7 @@ module Mournmail
         Timeout.timeout(CONFIG[:mournmail_imap_connect_timeout]) do
           @imap = Net::IMAP.new(conf[:imap_host],
                                 conf[:imap_options].except(:auth_type, :user_name, :password))
+          setup_tcp_keep_alive(@imap)
           @imap.authenticate(auth_type, conf[:imap_options][:user_name],
                              password)
           @mailboxes = @imap.list("", "*").map { |mbox|
@@ -211,11 +224,37 @@ module Mournmail
       end
       yield(@imap)
     end
-  rescue IOError, Errno::ECONNRESET
+  rescue IOError, SystemCallError, SocketError, OpenSSL::SSL::SSLError,
+         Timeout::Error, Net::IMAP::ByeResponseError
     imap_disconnect
     raise
   end
 
+  # Detect dead connections at the kernel level (e.g. after a network
+  # switch, where reads block forever without an error).
+  # Net::IMAP does not expose its socket, so use its internal @sock.
+  def self.setup_tcp_keep_alive(imap)
+    sock = imap.instance_variable_get(:@sock)
+    return if sock.nil?
+    sock = sock.io if sock.respond_to?(:io) # OpenSSL::SSL::SSLSocket
+    sock.setsockopt(:SOCKET, :KEEPALIVE, true)
+    if Socket.const_defined?(:TCP_KEEPIDLE)
+      sock.setsockopt(:TCP, :KEEPIDLE, 60)
+    end
+    if Socket.const_defined?(:TCP_KEEPINTVL)
+      sock.setsockopt(:TCP, :KEEPINTVL, 10)
+    end
+    if Socket.const_defined?(:TCP_KEEPCNT)
+      sock.setsockopt(:TCP, :KEEPCNT, 3)
+    end
+    if Socket.const_defined?(:TCP_USER_TIMEOUT)
+      sock.setsockopt(:TCP, :USER_TIMEOUT, 90_000) # milliseconds
+    end
+  rescue StandardError
+    # Keep alive is best-effort; the NOOP timeout still detects dead
+    # connections without it.
+  end
+
   def self.imap_disconnect
     @imap_mutex.synchronize do
       stop_keep_alive_thread
@@ -406,6 +445,24 @@ module Mournmail
     File.read(path)
   end
 
+  # Returns the virus name if a virus is detected, nil otherwise.
+  def self.scan_virus(data)
+    run_hooks(:mournmail_virus_scan_hook, data)
+    nil
+  rescue VirusDetected => e
+    foreground do
+      message("Virus detected: #{e.virus_name}")
+    end
+    e.virus_name
+  rescue => e
+    # Treat the mail as unscanned so that a broken scanner doesn't make
+    # mails unreadable.
+    foreground do
+      message("Virus scan failed: #{e.class}: #{e.message}")
+    end
+    nil
+  end
+
   def self.write_mail_cache(s)
     header = s.slice(/.*\r\n\r\n/m)
     cache_id = Digest::SHA256.hexdigest(header)

data/lib/mournmail/version.rb

@@ -1,3 +1,3 @@
 module Mournmail
-  VERSION = "3"
+  VERSION = "4"
 end

data/lib/mournmail.rb

@@ -2,6 +2,7 @@ require_relative "mournmail/version"
 require_relative "mournmail/config"
 require_relative "mournmail/faces"
 require_relative "mournmail/utils"
+require_relative "mournmail/header_folding"
 require_relative "mournmail/message_rendering"
 require_relative "mournmail/summary"
 require_relative "mournmail/draft_mode"

data/mournmail.gemspec

@@ -34,4 +34,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake", ">= 12.0"
+  spec.add_development_dependency "test-unit"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mournmail
 version: !ruby/object:Gem::Version
-  version: '3'
+  version: '4'
 platform: ruby
 authors:
 - Shugo Maeda
@@ -177,6 +177,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A message user agent for Textbringer.
 email:
 - shugo@ruby-lang.org
@@ -185,8 +199,13 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".claude/skills/pr/SKILL.md"
+- ".claude/skills/push/SKILL.md"
+- ".claude/skills/release/SKILL.md"
 - ".github/workflows/push_gem.yml"
+- ".github/workflows/test.yml"
 - ".gitignore"
+- CLAUDE.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -199,6 +218,7 @@ files:
 - lib/mournmail/config.rb
 - lib/mournmail/draft_mode.rb
 - lib/mournmail/faces.rb
+- lib/mournmail/header_folding.rb
 - lib/mournmail/mail_encoded_word_patch.rb
 - lib/mournmail/message_mode.rb
 - lib/mournmail/message_rendering.rb
@@ -227,7 +247,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.1.0.dev
+rubygems_version: 4.0.16
 specification_version: 4
 summary: A message user agent for Textbringer.
 test_files: []