RubyGems - oops-cli - Versions diffs - 0.1.0 → 0.3.0 - Mend

oops-cli 0.1.0 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 238211aa8b381cf9998c6a744627d61d276be3350aa273c9d7fbdba8c078125a
-  data.tar.gz: 1858aff54bd54535e3aa2ebc5b5a0c18b4f6168572c1e55e1dd0d13b97f31fdd
+  metadata.gz: 6e1003df0d3be3f85135c9f36b34aaed5d5ce02002a22d1c75baafd235180b15
+  data.tar.gz: b67d4984e973482dc9c4f4938d14e65dfc4e99c7c149a2deea7a6aee0e2c2297
 SHA512:
-  metadata.gz: dcae845a6bc939a775258eba59a360dfff475dc91af52be47d7495eea915de21cd04ae1c82afc1ea157df0db3e84b0b576e029d1731e6347c3faa429cd18e0d9
-  data.tar.gz: 14472ae5e385e10142be06be2264eff1d828415fca08388fba48d66d8a7c258b64f8bde75da0f86f94b2ef511cd2b331de972563267f597595aadb7eac074d9c
+  metadata.gz: e6754adb99ca3b4ae7f0294eb84547f630fd6fcb9bbe9191cf9112e77d9590b6dd5561aa94300e2c19e683d1a9e50072358d5814485de8c355ece40e349ca360
+  data.tar.gz: ede05535447c896dca5e443e883c9c90d7b225a7ccea09ee0628601d8650f9b1642aa2098c7c0ebedb6d0c8433645134402352140d45cb2dffc25eac07425fba

data/CHANGELOG.ja.md CHANGED Viewed

@@ -2,6 +2,22 @@
 [English](CHANGELOG.md) | 日本語
+## 0.3.0 - 2026-11-02
+- `oops clear` で閉じたタブのログを削除できます。`oops clear --all` は今のタブのログも空にします（[#42](https://github.com/ysb3996-blip/oops/issues/42)）。
+- 変更: 閉じたタブのログは、最後のコマンドから 7 日たつと、タブが記録を始めるときに削除されるようになりました。日数は設定の `retention_days` で変えられます。`retention_days: false` にすると、50 MB の上限までは残ります（[#42](https://github.com/ysb3996-blip/oops/issues/42)）。
+- fish に対応しました。`~/.config/fish/config.fish` に `oops init fish | source` を足します（[#9](https://github.com/ysb3996-blip/oops/issues/9)）。
+- zsh のプラグインマネージャー（antidote・zinit・Oh My Zsh など）向けに `oops.plugin.zsh` を追加。clone したリポジトリの oops を動かすので、gem のインストールはいりません。
+- Homebrew tap を用意しました: `brew install ysb3996-blip/oops/oops`。Homebrew の Ruby で oops を動かします。
+## 0.2.0 - 2026-11-01
+- `oops status` を追加。`recording`・`paused`・`off` のどれかを 1 行で出力し、記録中のときだけ終了コード 0 を返します。プロンプトやスクリプトから、このシェルが記録されているか確認できます。
+- `--time` オプションを追加。各 `$ コマンド` の前に開始時刻（ローカル時刻）を `# 2026-10-31 19:30:09 +09:00` の行として入れ、`--github` の要約にも足します。
+- `--output-only` オプションを追加。`$ コマンド` の行を省き、出力と `(exit N)` だけをコピーします。
+- `oops` と `oops err` に `-n N` オプションを追加。`oops -n 3` は `oops 3` と同じで、`oops err -n 2` は直近の失敗した 2 コマンドを（成功したコマンドは飛ばして）古い順にコピーします。[@ricky9408](https://github.com/ricky9408) さんによる貢献（[#22](https://github.com/ysb3996-blip/oops/pull/22)）。
+- メールアドレスのマスクが、`/opt/homebrew/opt/mysql@8.4` や `go@1.27` のような版付きの名前を伏せないように修正。ドメインの最後の部分が、実際のトップレベルドメインのように英字のときだけ伏せます（[#24](https://github.com/ysb3996-blip/oops/issues/24)）。
 ## 0.1.0 - 2026-10-30
 最初のバージョン。

data/CHANGELOG.md CHANGED Viewed

@@ -2,6 +2,22 @@
 English | [日本語](CHANGELOG.ja.md)
+## 0.3.0 - 2026-11-02
+- `oops clear` deletes the logs of closed tabs, and `oops clear --all` also empties the current tab's log ([#42](https://github.com/ysb3996-blip/oops/issues/42)).
+- Changed: logs of closed tabs are now deleted 7 days after their last command, when a tab starts recording. Set `retention_days` in the config to change the number of days, or `retention_days: false` to keep them until the 50 MB limit ([#42](https://github.com/ysb3996-blip/oops/issues/42)).
+- fish support: add `oops init fish | source` to `~/.config/fish/config.fish` ([#9](https://github.com/ysb3996-blip/oops/issues/9)).
+- `oops.plugin.zsh` for zsh plugin managers (antidote, zinit, Oh My Zsh, ...). It runs oops from the cloned repository, so no gem install is needed.
+- Homebrew tap: `brew install ysb3996-blip/oops/oops`. The formula runs oops with Homebrew's Ruby.
+## 0.2.0 - 2026-11-01
+- `oops status` prints `recording`, `paused` or `off` on one line and exits 0 only when recording, so a prompt or script can show whether this shell is recorded.
+- `--time` option: adds the local time each command started as a `# 2026-10-31 19:30:09 +09:00` line before `$ command`, and to the `--github` summary.
+- `--output-only` option: leaves out the `$ command` line and copies only the output and `(exit N)`.
+- `-n N` option for `oops` and `oops err`: `oops -n 3` is the same as `oops 3`, and `oops err -n 2` copies the last 2 failed commands (oldest first), skipping over successful ones. Contributed by [@ricky9408](https://github.com/ricky9408) in [#22](https://github.com/ysb3996-blip/oops/pull/22).
+- Email masking no longer hides versioned names such as `/opt/homebrew/opt/mysql@8.4` or `go@1.27`: the last part of the domain must now be letters, like a real top-level domain ([#24](https://github.com/ysb3996-blip/oops/issues/24)).
 ## 0.1.0 - 2026-10-30
 First version.

data/README.ja.md CHANGED Viewed

@@ -2,8 +2,12 @@
 [English](README.md) | 日本語
+[![Gem Version](https://img.shields.io/gem/v/oops-cli)](https://rubygems.org/gems/oops-cli) [![CI](https://github.com/ysb3996-blip/oops/actions/workflows/ci.yml/badge.svg)](https://github.com/ysb3996-blip/oops/actions/workflows/ci.yml) [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 直前のシェルコマンドとその出力を、貼り付けられる形でクリップボードにコピーします。
+![デモ: テストが失敗し、oops がコマンドと出力をコピーし、コメント行と pbpaste でクリップボードの中身(コードブロック)を見せる。続いて cat .env、oops で API キーが [secret] になる](docs/demo.gif)
 コマンドを実行して失敗した。その結果をチャットのアシスタントや Slack の同僚、GitHub の issue に見せたい。普通は、出力をドラッグで選択してコピーし、貼り付けて、コードフェンスを自分で付ける、という手間がかかります。oops なら 2 ステップです。
 1. `oops`（直前の失敗したコマンドなら `oops err`）と打つ。
@@ -17,9 +21,41 @@
 gem install oops-cli
 ```
-Homebrew tap: 準備中です。
+Homebrew でも入れられます。
+```sh
+brew install ysb3996-blip/oops/oops
+```
+Homebrew 版は Homebrew の Ruby で oops を動かすので、`PATH` の先に古い Ruby があっても動きます。
+macOS または Linux（WSL は Linux 扱い）、Ruby 3.3 以降、zsh・bash・fish のどれかが必要です。実行時に依存する gem はありません。
+`gem install` は、そのとき有効な Ruby にだけ oops を入れます。gem は Ruby のバージョンごとに別々です。rbenv・asdf・mise などで別の Ruby を使うタブでは、`oops` が `command not found` のエラーになります（シェルの起動時にも出ます）。いつでも使える直し方は、有効な Ruby で `gem install oops-cli` をもう一度実行することです（rbenv なら続けて `rbenv rehash`）。`.ruby-version`・`.tool-versions`・`mise.toml` で Ruby を指定しているディレクトリの外では、代わりにインストールした Ruby を標準（グローバル）の Ruby に設定することもできます（例: `rbenv global 3.3.5`）。
+### zsh のプラグインマネージャーで入れる
+zsh なら、プラグインとして読み込むこともできます。clone したリポジトリの oops をそのまま動かすので、gem のインストールはいりません（Ruby 3.3 以上は必要です）。下の「シェルの設定」の 1 行の代わりになります。
+```sh
+# antidote: ~/.zsh_plugins.txt に追加
+ysb3996-blip/oops
+# zinit: ~/.zshrc に。`wait`（turbo モード）は付けない
+zinit light ysb3996-blip/oops
+# Oh My Zsh: clone してから ~/.zshrc の plugins=(...) に oops を追加
+git clone https://github.com/ysb3996-blip/oops "${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/plugins/oops"
+# プラグインマネージャーなし: clone してから ~/.zshrc に source の行を追加
+git clone https://github.com/ysb3996-blip/oops ~/.oops
+source ~/.oops/oops.plugin.zsh
+```
-macOS または Linux（WSL は Linux 扱い）、Ruby 3.3 以降、zsh または bash が必要です。実行時に依存する gem はありません。
+- 読み込みを後回しにしないでください（zinit の `wait`、zsh-defer など）。プラグインはシェルを記録用に起動し直すので、最初のプロンプトより前に済ませる必要があります。
+- 下の「シェルの設定」にある、行を置く場所の注意は、プラグインを読み込む場所にそのまま当てはまります。powerlevel10k の instant prompt を使っている場合、プラグインは instant prompt のブロックより上で読み込む必要がありますが、プラグインマネージャーはふつうそうなりません。その場合は rc ファイルの 1 行を使ってください。
+- `PATH` の Ruby が古いと、`oops: ... init zsh failed (oops needs Ruby 3.3 or later); recording disabled` と出て、記録なしで普通に起動します。
+- プラグインマネージャーは `main` ブランチから更新するので、最新のリリースより先の内容になることがあります。
 ## シェルの設定
@@ -30,14 +66,21 @@ eval "$(oops init zsh)"    # zsh
 eval "$(oops init bash)"   # bash
 ```
-そのあと新しいタブを開いてください。開いているタブでは `exec zsh`（bash なら `exec bash`）で反映されます。
+fish では、`~/.config/fish/config.fish` に次の 1 行を足します。
+```fish
+oops init fish | source
+```
+そのあと新しいタブを開いてください。開いているタブでは `exec zsh`（bash なら `exec bash`、fish なら `exec fish`）で反映されます。
 この行を置く場所が重要です。
 - oops の入った Ruby を `PATH` に通す設定（rbenv、asdf、mise、Homebrew の `shellenv` など）より**後ろ**に置きます。macOS ではログインシェルが `PATH` をリセットするため、この行が先にあるとシステムの Ruby 2.6 が選ばれて oops が起動しないことがあります。oops が動かなくてもシェル自体は普通に起動します。記録されないだけです。
 - 2 回実行したくない重い処理や出力の多い処理（nvm、プロンプトテーマ、バナーなど）より**前**に置きます。このスニペットは、小さな記録用プログラム（`oops record`、pty 中継）の下でシェルをもう一度起動します。そのため、この行より上は外側のシェルと内側のシェルで 2 回実行され、下は内側のシェルでだけ実行されます。
 - powerlevel10k を使う場合は、`~/.zshrc` の先頭にある instant prompt のブロックより**上**に置きます。instant prompt は `~/.zshrc` の残りを読む間、シェルの入出力をリダイレクトし、その間スニペットは何もしません（実際の端末でだけ動作するため）。すると oops は黙って記録しなくなります。`~/.zshrc` に行があるのにタブが記録されないときは `oops doctor` を実行してください。`recording: no` と表示されます。
-- zsh ではシェルがログインシェルではない形で再起動されます。`~/.zlogin` にだけ書いた設定は、記録されるシェルには適用されません。`~/.zprofile` か `~/.zshrc`（この行より上）に置いてください。bash ではログインシェルは `-l` 付きで再起動されます。
+- zsh ではシェルがログインシェルではない形で再起動されます。`~/.zlogin` にだけ書いた設定は、記録されるシェルには適用されません。`~/.zprofile` か `~/.zshrc`（この行より上）に置いてください。bash ではログインシェルは `-l` 付きで、fish では `--login` 付きで再起動されます。
+- fish は最初のプロンプトを出す直前に再起動されます。そのため、行をどこに置いても、`config.fish` 全体が外側と記録される側の両方で実行されます（もっと早く再起動すると、プロンプトを出さない `fish -i -c` や `fish -i script.fish` まで再起動してしまうためです）。
 おかしいと感じたら `oops doctor` を実行します。このタブが記録されているか、シェルとフックの読み込み状況、使われるクリップボードの方法、設定ファイル、セッションログのサイズ、Ruby のバージョンを報告します。
@@ -48,11 +91,14 @@ eval "$(oops init bash)"   # bash
 | コマンド | 内容 |
 |---|---|
 | `oops` | 直前のコマンドとその出力をコピーする |
-| `oops 3` | 直前の 3 コマンドを（古い順に）1 つのコードブロックとしてコピーする |
+| `oops 3` / `oops -n 3` | 直前の 3 コマンドを（古い順に）1 つのコードブロックとしてコピーする |
 | `oops err` | 終了コードが 0 以外だった直近のコマンドをコピーする（成功したコマンドは飛ばす） |
-| `oops init zsh` / `oops init bash` | シェルのスニペットを出力する（`eval` 用） |
+| `oops err -n 2` | 直近の失敗した 2 コマンドを古い順にコピーする（成功したコマンドは飛ばす） |
+| `oops init zsh` / `oops init bash` / `oops init fish` | シェルのスニペットを出力する（`eval` 用。fish は `\| source`） |
 | `oops doctor` | 記録・フック・クリップボード・設定・ログサイズを診断する |
 | `oops pause` / `oops resume` | 記録を止める／再開する。停止中は何もディスクに書かれない |
+| `oops status` | `recording`・`paused`・`off` のどれかを 1 行で出力する（スクリプトやプロンプト向け） |
+| `oops clear` / `oops clear --all` | 閉じたタブのログを削除する。`--all` を付けると、今のタブのログも空にする |
 | `oops record -- <shell>` | 内部用: 記録用プログラムの下でシェルを起動する。スニペットが呼び出す |
 | `oops --version`, `oops --help` | バージョンと使い方 |
@@ -60,11 +106,16 @@ eval "$(oops init bash)"   # bash
 | オプション | 内容 |
 |---|---|
+| `-n N` | 直前の N コマンドをコピーする（`err` と併用すると直近の失敗した N コマンド） |
 | `--github` | GitHub の issue / PR コメント向けの書式にする |
 | `--tail N` | 出力の最後の N 行だけ残す |
 | `--head N` | 出力の最初の N 行だけ残す（`--tail` と併用すると両端を残す） |
+| `--time` | 各コマンドの開始時刻を `# 2026-10-31 19:30:09 +09:00` の行として付ける |
+| `--output-only` | `$ コマンド` の行を省き、出力だけをコピーする |
 | `--show-secrets` | 秘密情報をマスクせず、置換テーブルも適用しない |
+`N` は正の整数で指定します。件数は位置引数の `N` または `-n N` のどちらかで 1 回だけ指定でき、併用や `-n` の繰り返しは使い方の誤りになります。対象のコマンドが指定件数より少なければ、見つかった分をコピーします。`-n` は上記の書式オプションと併用できます。
 `oops` 自身はコピー対象になりません。直前のコマンドが `oops` だった場合は、その前のコマンドがコピーされます。
 終了コード: `0` コピーした、`1` コピーしなかった（記録していない、まだコマンドがない、失敗したコマンドがない、一時停止中、クリップボードのコマンドが失敗）、`2` 使い方の誤り。
@@ -118,6 +169,22 @@ $ bundle exec rspec
 `oops --tail 50` は出力の最後の 50 行を残し、その前に `... 2,950 lines omitted ...` を入れます。`--head 20` は最初の 20 行を残し、その後ろに同じ印を入れます。両方指定すると、中間が印 1 行に置き換わります。`oops 3` では、行数の制限は各コマンドごとに適用されます。
+### `--time` と `--output-only`
+`oops --time` は、各 `$ コマンド` の前にコマンドを始めたローカル時刻を `#` の行として入れ、`--github` の要約にも時刻を足します。`oops --output-only` は `$ コマンド` の行を省いて出力と `(exit N)` だけを残します。画面に出る `copied: $ ...` の行と `--github` の要約には、コマンドの代わりに終了コードと行数だけが出ます。どちらも他のオプションと併用できます。
+````
+```
+# 2026-10-31 19:30:09 +09:00
+....F
+(exit 1)
+```
+````
+### `oops status`
+`oops status` は `recording`・`paused`・`off`（このシェルが記録されていない、またはログが削除された）のどれかを出力し、記録中のときだけ終了コード `0` を返します。エラーは出さないので、プロンプトやスクリプトから呼べます（例: [starship のカスタムモジュール](https://starship.rs/config/#custom-commands)）。呼ぶたびに Ruby が起動するため 0.1〜0.2 秒ほどかかります。`off` のときの詳しい理由は `oops doctor` で分かります。
 ## 設定
 任意の設定ファイルは `${XDG_CONFIG_HOME:-~/.config}/oops/config.yml` です。
@@ -129,12 +196,14 @@ replace:            # コピー時に適用する単純な文字列置換
 secrets:            # マスクする追加の正規表現
   - "sk_live_[A-Za-z0-9]+"
 clipboard: auto     # auto | pbcopy | wl-copy | xclip | xsel | clip.exe | osc52 | 任意のコマンド（標準入力から読む）
+retention_days: 7   # 閉じたタブのログをこの日数で削除する。false なら残す
 ```
 - 置換とマスクはコピーする瞬間に適用されます。記録済みのログは変更されないため、設定を変えると以前のコマンドにも反映されます。
 - `replace` のキーは長いものから順に、大文字小文字を区別して適用されます。
 - 未知のキーは警告されて無視されます。YAML が壊れている場合も警告が出て、設定なしで続行します。
 - `clipboard: auto` のとき、oops は macOS では `pbcopy`、WSL では `clip.exe`、Wayland では `wl-copy`、X11 では `xclip` か `xsel` を試し、だめなら OSC 52 端末エスケープシーケンスにフォールバックします（SSH 越しでもこれが使われます）。どれを選んだかは `oops doctor` で確認できます。
+- `retention_days`（標準は 7）は、閉じたタブがログに最後に書き込んだ時点から数えます。古いログは、タブが記録を始めるときに削除されます。`false` にすると、閉じたタブのログは 50 MB の上限で削除されるまで残ります。
 - 自分で指定した `clipboard:` のコマンドは、独自のプロセスグループで 5 秒のタイムアウト付きで実行されます。そのため端末の読み取りや設定（パスワード入力、`stty` など）はできません。コピー中の Ctrl-C もそのコマンドには届きません。
 組み込みのマスク対象: AWS アクセスキー、GitHub / GitLab / Slack / npm / OpenAI・Anthropic（`sk-...`）/ Stripe / Google の API トークン、Slack の webhook URL、JWT、`Authorization` ヘッダーの値、秘密鍵ブロック（END 行がなくても）、`key`・`token`・`secret`・`password`・`passwd`・`pwd` を含む名前に代入された値、`--password <値>`・`curl -u user:pass`・`mysql -p<値>`・`docker login -p <値>` で渡されたパスワード、メールアドレス、URL 中の認証情報、公開 IPv4 アドレス（ループバックとプライベート範囲は対象外）。出力だけでなくコマンドラインにも適用されます。
@@ -143,15 +212,18 @@ clipboard: auto     # auto | pbcopy | wl-copy | xclip | xsel | clip.exe | osc52
 ## 仕組み
-1. `oops init` は、rc ファイルから `eval` するスニペットを出力します。まだ記録されていない端末の対話シェルでは、シェルを `oops record` の下で再起動します。
+![oops の仕組み: 録音機があなたとシェルの間にいて、コマンドはディスク上のノートに書かれ、oops と打つと最後のページを秘密を隠して写し、どこにでも貼れる](docs/how-it-works.ja.svg)
+1. `oops init` は、rc ファイルから `eval` する（fish では `| source` する）スニペットを出力します。まだ記録されていない端末の対話シェルでは、シェルを `oops record` の下で再起動します。
 2. `oops record` は、Ruby 製の小さな pty 中継です。キー入力とシェルの出力をそのまま通し、ウィンドウのリサイズをシェルに伝えます。
-3. シェルのフック（zsh は `preexec`/`precmd`、bash は `DEBUG` トラップと `PROMPT_COMMAND`）が、各コマンドの前後に目に見えない APC マーカーを出力します。中継がそれを取り除くので、端末には見えません。
-4. コマンドが終わるたびに、中継は 1 行の JSON（コマンド、ディレクトリ、時刻、終了コード、生の出力）をタブごとのログに追記します。置き場所は `${XDG_STATE_HOME:-~/.local/state}/oops/sessions/` です。出力は 1 コマンドあたり 1 MB まで（末尾を残す）。各タブのログは 50 MB までで、超えると新しいコマンドだけを残して書き直されます（約 37 MiB まで縮む）。タブが記録を始めるとき、閉じたタブのログは古い順に、全ログの合計が 50 MB 以下になるまで削除されます。開いているタブのログは削除されないので、忙しいタブが複数あると合計がそれを超えることがあります。
+3. シェルのフック（zsh は `preexec`/`precmd`、bash は `DEBUG` トラップと `PROMPT_COMMAND`、fish は `fish_preexec`/`fish_postexec` イベント）が、各コマンドの前後に目に見えない APC マーカーを出力します。中継がそれを取り除くので、端末には見えません。
+4. コマンドが終わるたびに、中継は 1 行の JSON（コマンド、ディレクトリ、時刻、終了コード、生の出力）をタブごとのログに追記します。置き場所は `${XDG_STATE_HOME:-~/.local/state}/oops/sessions/` です。出力は 1 コマンドあたり 1 MB まで（末尾を残す）。各タブのログは 50 MB までで、超えると新しいコマンドだけを残して書き直されます（約 37 MiB まで縮む）。タブが記録を始めるとき、閉じたタブのログのうち `retention_days`（標準は 7 日）を過ぎたものが削除され、続いて残りが古い順に、全ログの合計が 50 MB 以下になるまで削除されます。開いているタブのログは削除されないので、忙しいタブが複数あると合計がそれを超えることがあります。
 5. `oops` は現在のタブのログの末尾を読み、テキストを整えてマスクし、コードブロックを組み立ててクリップボードに渡します。コマンドを再実行することはありません。
 ## プライバシーとセキュリティ
-- セッションログには、記録されたすべてのコマンドの生の出力が**マスクされないまま**入っています。マスクと置換テーブルはコピーするときにだけ適用されます。ログは `${XDG_STATE_HOME:-~/.local/state}/oops/sessions/` にあり、あなただけが読めます（ファイルは 0600、ディレクトリは 0700）。すべて削除するには `rm -rf "${XDG_STATE_HOME:-$HOME/.local/state}/oops"` を実行します（標準では `rm -rf ~/.local/state/oops`）。ディスクに残したくない秘密情報を表示する前には `oops pause` を使ってください。
+- セッションログには、記録されたすべてのコマンドの生の出力が**マスクされないまま**入っています。マスクと置換テーブルはコピーするときにだけ適用されます。ログは `${XDG_STATE_HOME:-~/.local/state}/oops/sessions/` にあり、あなただけが読めます（ファイルは 0600、ディレクトリは 0700）。閉じたタブのログは 7 日後に削除されます（`retention_days`）。`oops clear` ですぐに削除でき、`oops clear --all` なら今のタブのログも空にします。開いている他のタブのログも含めてすべて削除するには `rm -rf "${XDG_STATE_HOME:-$HOME/.local/state}/oops"` を実行します（標準では `rm -rf ~/.local/state/oops`）。ディスクに残したくない秘密情報を表示する前には `oops pause` を使ってください。
+- セキュリティ上の問題を非公開で報告する方法は [SECURITY.ja.md](SECURITY.ja.md) を見てください。公開の issue には書かないでください。
 - 記録される出力は信頼できません。実行したプログラムは、oops のマーカーに見せかけたテキストを出力できます。そのため oops は、`oops pause` / `oops resume` が作るフラグファイルと一致する一時停止・再開マーカーにだけ従います。出力によって黙って記録を止められることはありません。ただし、プログラムがログ上でコマンドの開始と終了の位置を偽装することはできるので、貼り付ける内容は確認してください。
 ## 既知の制限
@@ -164,16 +236,16 @@ clipboard: auto     # auto | pbcopy | wl-copy | xclip | xsel | clip.exe | osc52
 - vim・less・tmux などの全画面アプリの出力は保存されず、`[full-screen app output omitted]` に置き換わります。
 - スペースで始まるコマンドラインは、zsh では記録されますが bash では記録されません（bash はそれを履歴に保存せず、oops はコマンドを履歴から読むため）。
 - [bash-preexec](https://github.com/rcaloras/bash-preexec) を使う bash（atuin や Ghostty の bash 統合の背後にあるものも含む）: oops は自前の `DEBUG` トラップを使わず、bash-preexec にフックを登録します。rc ファイルでどちらが先でも同じです。bash が履歴に保存しなかった行（`HISTCONTROL=ignorespace`、`HISTIGNORE`）は、この場合 `(not saved in history)` と記録されます。行のテキストを履歴から読むためです。bash-preexec がない場合、oops はそのような行の最初のコマンドを記録します。
-- Ghostty 上の bash: Ghostty のシェル統合（プロンプトマーク、同じディレクトリでの新しいタブ、タイトル）は外側のシェルにだけ入るため、記録される側のシェルには入りません。足し戻すには、`~/.bashrc` の oops の行の下に次の行を置きます（bash 3.2 で確認済み）: `[ -n "$GHOSTTY_RESOURCES_DIR" ] && source "$GHOSTTY_RESOURCES_DIR/shell-integration/bash/ghostty.bash"`。zsh は何もしなくて構いません。スニペットがやります。
+- Ghostty 上の bash: Ghostty のシェル統合（プロンプトマーク、同じディレクトリでの新しいタブ、タイトル）は外側のシェルにだけ入るため、記録される側のシェルには入りません。足し戻すには、`~/.bashrc` の oops の行の下に次の行を置きます（bash 3.2 で確認済み）: `[ -n "$GHOSTTY_RESOURCES_DIR" ] && source "$GHOSTTY_RESOURCES_DIR/shell-integration/bash/ghostty.bash"`。zsh と fish は何もしなくて構いません。スニペットがやります。
 - bash: パイプラインの次の行では、`PIPESTATUS` に最後の終了ステータスしか入りません（`false | true` の後に `echo ${PIPESTATUS[*]}` を実行すると、`1 0` ではなく `0` と表示されます）。oops の `PROMPT_COMMAND` の項目が先に実行されるためです。`$?` と `$_` は保たれます。パイプラインの各ステータスを表示するプロンプト（starship の `pipestatus`）は、bash では表示が少なくなります。zsh は `pipestatus` を保ちます。
 - macOS: `pbcopy` は文字エンコーディングを `LANG` / `LC_*` から決めます。日本語などの非 ASCII 文字が文字化けして届くときは、UTF-8 のロケール（例: `LANG=en_US.UTF-8`）が設定されているか確認してください。SSH 越しで起動したシェルでは設定されていないことがあります。
-- fish とネイティブ Windows にはまだ対応していません。
+- ネイティブ Windows にはまだ対応していません。
 ## 開発
 ### 手元の環境を整える
-Git、Ruby 3.3 以降、[Bundler](https://bundler.io/)（Ruby に付属）、そして zsh と bash の両方が必要です（エンドツーエンドのテストが本物のシェルを起動するため）。macOS には zsh と bash が入っています。Debian / Ubuntu では `sudo apt-get install zsh` を実行します。
+Git、Ruby 3.3 以降、[Bundler](https://bundler.io/)（Ruby に付属）、そして zsh と bash の両方が必要です（エンドツーエンドのテストが本物のシェルを起動するため）。macOS には zsh と bash が入っています。Debian / Ubuntu では `sudo apt-get install zsh` を実行します。fish はなくても構いません。入っていなければ fish のエンドツーエンドのテストは飛ばされます（CI では入れています）。
 ```sh
 git clone https://github.com/ysb3996-blip/oops.git
@@ -207,18 +279,18 @@ bundle exec exe/oops doctor
 ```sh
 gem build oops-cli.gemspec
-gem install ./oops-cli-0.1.0.gem     # ファイル名は lib/oops/version.rb に合わせる
+gem install ./oops-cli-0.3.0.gem     # ファイル名は lib/oops/version.rb に合わせる
 rbenv rehash                         # rbenv を使う場合のみ
 ```
-- gem は Ruby のバージョンごとに入ります。新しいタブが、インストールした Ruby とは別の Ruby を使っていると（たとえばリポジトリは 4.0.9 を指定しているのに、標準の Ruby が 3.3.5 の場合）、シェルに `oops: command not found` と出ます。その Ruby でも `gem install` を実行してください（例: `RBENV_VERSION=3.3.5 gem install ./oops-cli-0.1.0.gem`）。
+- gem は Ruby のバージョンごとに入ります。新しいタブが、インストールした Ruby とは別の Ruby を使っていると（たとえばリポジトリは 4.0.9 を指定しているのに、標準の Ruby が 3.3.5 の場合）、シェルの起動時に oops が見つからなくなります（bash では `bash: oops: command not found`、zsh では `command not found: oops` と出ます）。その Ruby でも `gem install` を実行してください（例: `RBENV_VERSION=3.3.5 gem install ./oops-cli-0.3.0.gem`）。
 - 変更のたびに入れ直してください。インストールされた gem はコピーで、チェックアウトへのリンクではありません。
 - 削除するには `gem uninstall oops-cli` です。
 - `eval "$(oops init zsh)"` は、プロンプトで打つだけでなく rc ファイルに書いてください。記録されるシェルは rc ファイルを読み直すため、行がないとフックが入りません（`oops doctor` に `hooks: missing` と出ます）。
 作業中の端末で `oops record` を実行しないでください。テストは自前の pty を通して動かします。試すときは、新しい端末タブを使います。試した結果として残るログを消すには、「プライバシーとセキュリティ」を参照してください。
-テストは、書式、秘密情報のマスク、ログの読み取り、ストリームパーサー、そして実際の zsh と bash を使った中継のエンドツーエンド実行を対象にしています。
+テストは、書式、秘密情報のマスク、ログの読み取り、ストリームパーサー、そして実際の zsh・bash・fish を使った中継のエンドツーエンド実行を対象にしています。
 リリース前の手動チェックリスト:
@@ -229,7 +301,7 @@ rbenv rehash                         # rbenv を使う場合のみ
 ## コントリビュート
-バグ報告、アイデア、プルリクエストを歓迎します。[CONTRIBUTING.ja.md](CONTRIBUTING.ja.md) を読んでください。`good first issue` のラベルが付いた issue が、始めやすい入口です。
+バグ報告、アイデア、プルリクエストを歓迎します。[CONTRIBUTING.ja.md](CONTRIBUTING.ja.md) を読んでください。`good first issue` のラベルが付いた issue が、始めやすい入口です。プルリクエストには、テストと rubocop の結果、新しいタブでの動作確認を必ず貼ってください（[プルリクエストに必ず貼るもの](CONTRIBUTING.ja.md#プルリクエストに必ず貼るもの)）。
 ## ライセンス

data/README.md CHANGED Viewed

@@ -2,8 +2,12 @@
 English | [日本語](README.ja.md)
+[![Gem Version](https://img.shields.io/gem/v/oops-cli)](https://rubygems.org/gems/oops-cli) [![CI](https://github.com/ysb3996-blip/oops/actions/workflows/ci.yml/badge.svg)](https://github.com/ysb3996-blip/oops/actions/workflows/ci.yml) [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 Copy the last shell command and its output to the clipboard, ready to paste.
+![Demo: a test fails, oops copies the command and its output, a comment line and pbpaste show what is on the clipboard; then cat .env, oops, and the API key is shown as [secret]](docs/demo.gif)
 You ran a command and it failed. You want to show it to a chat assistant, a teammate on Slack, or a GitHub issue. Normally that means dragging to select the output, copying, pasting, and adding the code fences yourself. With oops it is two steps:
 1. Type `oops` (or `oops err` for the last failed command).
@@ -17,9 +21,41 @@ What lands on your clipboard is a code block with the command, its output, and t
 gem install oops-cli
 ```
-Homebrew tap: coming soon.
+Or with Homebrew:
+```sh
+brew install ysb3996-blip/oops/oops
+```
+The Homebrew formula runs oops with Homebrew's own Ruby, so it works even if an older Ruby comes first on your `PATH`.
+Requires Ruby 3.3 or newer on macOS or Linux (WSL counts as Linux), and zsh, bash or fish. There are no runtime gem dependencies.
+`gem install` puts oops into the Ruby that is active at that moment; each Ruby version has its own gems. With rbenv, asdf or mise, a tab that uses another Ruby gives a `command not found` error for `oops`, also when the shell starts. The fix that always works is to run `gem install oops-cli` again under the active Ruby (with rbenv, follow with `rbenv rehash`). Outside directories that pin a Ruby with `.ruby-version`, `.tool-versions` or `mise.toml`, you can instead set the Ruby you installed into as your global Ruby (for example `rbenv global 3.3.5`).
+### With a zsh plugin manager
+For zsh you can load oops as a plugin instead. It runs oops from the cloned repository, so there is no gem to install (Ruby 3.3 or newer is still needed), and the plugin replaces the rc line below.
+```sh
+# antidote: add to ~/.zsh_plugins.txt
+ysb3996-blip/oops
+# zinit: in ~/.zshrc, without `wait` (turbo mode)
+zinit light ysb3996-blip/oops
+# Oh My Zsh: clone, then add oops to plugins=(...) in ~/.zshrc
+git clone https://github.com/ysb3996-blip/oops "${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/plugins/oops"
+# No plugin manager: clone, then add the source line to ~/.zshrc
+git clone https://github.com/ysb3996-blip/oops ~/.oops
+source ~/.oops/oops.plugin.zsh
+```
-Requires Ruby 3.3 or newer on macOS or Linux (WSL counts as Linux), and zsh or bash. There are no runtime gem dependencies.
+- Load it right away, not deferred (zinit `wait`, zsh-defer). The plugin starts your shell again under the recorder, which should happen before the first prompt.
+- The notes on where the line goes (below) apply to where the plugin is loaded. With powerlevel10k's instant prompt, the plugin has to be loaded above the instant prompt block, which plugin managers usually are not; use the rc line there.
+- If the Ruby on `PATH` is too old, the shell prints `oops: ... init zsh failed (oops needs Ruby 3.3 or later); recording disabled` and starts as usual, without recording.
+- Plugin managers update from the `main` branch, which can be ahead of the latest release.
 ## Set up your shell
@@ -30,14 +66,21 @@ eval "$(oops init zsh)"    # zsh
 eval "$(oops init bash)"   # bash
 ```
-Then open a new tab. Existing tabs pick it up after `exec zsh` (or `exec bash`).
+For fish, add this line to `~/.config/fish/config.fish`:
+```fish
+oops init fish | source
+```
+Then open a new tab. Existing tabs pick it up after `exec zsh` (or `exec bash`, `exec fish`).
 Where to put the line matters:
 - Put it **after** whatever puts the Ruby that has oops on your `PATH` (rbenv, asdf, mise, Homebrew `shellenv`, and so on). On macOS, login shells reset `PATH`, so if the line comes first, the system Ruby 2.6 may be picked and oops will not start. If oops cannot run, your shell still starts normally, just without recording.
 - Put it **before** slow or noisy setup that you do not want to run twice (nvm, prompt themes, banners). The snippet starts your shell again under a small recorder (`oops record`, a pty relay), so anything above the line runs once in the outer shell and again in the inner one. Anything below it runs only in the inner shell.
 - With powerlevel10k, put the line **above** the instant prompt block at the top of `~/.zshrc`. The instant prompt redirects the shell's input and output while the rest of `~/.zshrc` runs, and the snippet does nothing then (it only acts on a real terminal), so oops would silently not record. If a tab is not recorded although the line is in `~/.zshrc`, run `oops doctor`: it shows `recording: no`.
-- In zsh the shell is restarted as a non-login shell, so setup that lives only in `~/.zlogin` is not applied to the recorded shell. Keep it in `~/.zprofile` or `~/.zshrc` (above the line). In bash, a login shell is restarted with `-l`.
+- In zsh the shell is restarted as a non-login shell, so setup that lives only in `~/.zlogin` is not applied to the recorded shell. Keep it in `~/.zprofile` or `~/.zshrc` (above the line). In bash, a login shell is restarted with `-l`, and in fish with `--login`.
+- fish is restarted just before its first prompt, so all of `config.fish` runs in both the outer and the recorded shell, wherever the line is. (Starting it earlier would also catch `fish -i -c` and `fish -i script.fish`, which never show a prompt and must not be restarted.)
 If something looks wrong, run `oops doctor`. It reports whether this tab is recorded, the shell and whether the hooks are loaded, which clipboard method will be used, the config file, the size of the session logs, and the Ruby version.
@@ -48,11 +91,14 @@ To turn oops off for one shell, start it with `OOPS_DISABLE=1` (for example `OOP
 | Command | What it does |
 |---|---|
 | `oops` | Copy the last command and its output |
-| `oops 3` | Copy the last 3 commands (oldest first) as one code block |
+| `oops 3` / `oops -n 3` | Copy the last 3 commands (oldest first) as one code block |
 | `oops err` | Copy the last command that exited non-zero, skipping over successful ones |
-| `oops init zsh` / `oops init bash` | Print the shell snippet (for `eval`) |
+| `oops err -n 2` | Copy the last 2 failed commands (oldest first), skipping over successful ones |
+| `oops init zsh` / `oops init bash` / `oops init fish` | Print the shell snippet (for `eval`, or `\| source` in fish) |
 | `oops doctor` | Diagnose recording, hooks, clipboard, config and log size |
 | `oops pause` / `oops resume` | Stop and restart recording. While paused, nothing is written to disk |
+| `oops status` | Print `recording`, `paused` or `off` on one line, for scripts and prompts |
+| `oops clear` / `oops clear --all` | Delete the logs of closed tabs; `--all` also empties this tab's log |
 | `oops record -- <shell>` | Internal: runs a shell under the recorder. The snippet calls this |
 | `oops --version`, `oops --help` | Version and usage |
@@ -60,11 +106,16 @@ Options for `oops`, `oops N` and `oops err`:
 | Option | What it does |
 |---|---|
+| `-n N` | Copy the last N commands (with `err`, the last N failed commands) |
 | `--github` | Format for a GitHub issue or PR comment |
 | `--tail N` | Keep only the last N output lines |
 | `--head N` | Keep only the first N output lines (with `--tail`, keeps both ends) |
+| `--time` | Add the time each command started as a `# 2026-10-31 19:30:09 +09:00` line |
+| `--output-only` | Leave out the `$ command` line and copy only the output |
 | `--show-secrets` | Do not mask secrets and do not apply the replace table |
+`N` must be a positive integer. Specify the command count once, either as a positional `N` or with `-n N`; combining them or repeating `-n` is a usage error. If fewer matching commands are available, oops copies those it finds. `-n` can be combined with the formatting options above.
 `oops` never copies itself: if the previous command was `oops`, you get the command before it.
 Exit codes: `0` copied, `1` nothing copied (not recording, no command yet, no failed command, paused, or the clipboard command failed), `2` usage error.
@@ -118,6 +169,22 @@ $ bundle exec rspec
 `oops --tail 50` keeps the last 50 lines of output and puts `... 2,950 lines omitted ...` before them. `--head 20` keeps the first 20 and puts the marker after. With both, the middle is replaced by one marker line. With `oops 3`, the limits apply to each command.
+### `--time` and `--output-only`
+`oops --time` puts the local time the command started on a `#` line before each `$ command`, and adds it to the `--github` summary. `oops --output-only` leaves out the `$ command` line and keeps the output and `(exit N)`; the `copied: $ ...` line on screen and the `--github` summary then show the exit code and line count without the command. Both can be combined with the other options:
+````
+```
+# 2026-10-31 19:30:09 +09:00
+....F
+(exit 1)
+```
+````
+### `oops status`
+`oops status` prints `recording`, `paused` or `off` (this shell is not recorded, or its log was deleted) and exits `0` only when recording. It prints no error, so a prompt or script can call it, for example with a [starship custom module](https://starship.rs/config/#custom-commands). Each call starts Ruby, which takes roughly 0.1 to 0.2 seconds; `oops doctor` tells more when the answer is `off`.
 ## Configuration
 Optional file at `${XDG_CONFIG_HOME:-~/.config}/oops/config.yml`:
@@ -129,12 +196,14 @@ replace:            # plain string replacements applied when copying
 secrets:            # extra regular expressions to mask
   - "sk_live_[A-Za-z0-9]+"
 clipboard: auto     # auto | pbcopy | wl-copy | xclip | xsel | clip.exe | osc52 | any command (reads stdin)
+retention_days: 7   # delete closed tabs' logs after this many days; false keeps them
 ```
 - Replacements and masking are applied at the moment you copy; the recorded log stays untouched, so a config change also affects earlier commands.
 - `replace` keys are applied longest first and are case-sensitive.
 - Unknown keys produce a warning and are ignored. A broken YAML file produces a warning and oops carries on without a config.
 - With `clipboard: auto`, oops tries `pbcopy` on macOS, `clip.exe` on WSL, `wl-copy` on Wayland, `xclip` or `xsel` on X11, and falls back to the OSC 52 terminal escape sequence (also used over SSH). `oops doctor` shows which one it picked.
+- `retention_days` (default 7) counts from the last time a closed tab wrote its log. Old logs are deleted when a tab starts recording. With `false`, closed tabs' logs stay until the 50 MB limit removes them.
 - A custom `clipboard:` command runs in its own process group with a 5 second timeout, so it must not read from or configure the terminal (no password prompts, no `stty`); Ctrl-C during a copy does not reach it.
 Built-in masking covers AWS access keys, GitHub, GitLab, Slack, npm, OpenAI/Anthropic (`sk-...`), Stripe and Google API tokens, Slack webhook URLs, JWTs, `Authorization` header values, private key blocks (also when the END line is missing), values assigned to names containing `key`, `token`, `secret`, `password`, `passwd` or `pwd`, passwords given as `--password <value>`, `curl -u user:pass`, `mysql -p<value>` or `docker login -p <value>`, email addresses, credentials inside URLs, and public IPv4 addresses (loopback and private ranges are left alone). It is applied to the command line as well as the output.
@@ -143,15 +212,18 @@ Masking is pattern based, so it is a safety net, not a guarantee: a secret in a
 ## How it works
-1. `oops init` prints a snippet that you `eval` from your rc file. In an interactive shell on a terminal that is not recorded yet, it restarts the shell under `oops record`.
+![How oops works: a recorder sits between you and your shell, every command is written to a notebook on your disk, typing oops copies the last page with secrets hidden, and you paste it anywhere](docs/how-it-works.svg)
+1. `oops init` prints a snippet that you `eval` from your rc file (`| source` in fish). In an interactive shell on a terminal that is not recorded yet, it restarts the shell under `oops record`.
 2. `oops record` is a small Ruby pty relay: it passes your keystrokes and the shell's output through untouched and forwards window resizes to the shell.
-3. Hooks in the shell (zsh `preexec`/`precmd`, bash `DEBUG` trap and `PROMPT_COMMAND`) emit invisible APC markers around each command. The relay strips them, so your terminal never sees them.
-4. For each finished command the relay appends one JSON line (command, directory, times, exit code, raw output) to a per-tab log under `${XDG_STATE_HOME:-~/.local/state}/oops/sessions/`. Output is capped at 1 MB per command (the tail is kept). Each tab's log is capped at 50 MB: when it passes that, it is rewritten to keep only its newest commands (down to about 37 MiB). When a tab starts recording, logs of closed tabs are deleted, oldest first, until all logs together take at most 50 MB; logs of open tabs are never deleted, so several busy tabs can together use more.
+3. Hooks in the shell (zsh `preexec`/`precmd`, bash `DEBUG` trap and `PROMPT_COMMAND`, fish `fish_preexec`/`fish_postexec` events) emit invisible APC markers around each command. The relay strips them, so your terminal never sees them.
+4. For each finished command the relay appends one JSON line (command, directory, times, exit code, raw output) to a per-tab log under `${XDG_STATE_HOME:-~/.local/state}/oops/sessions/`. Output is capped at 1 MB per command (the tail is kept). Each tab's log is capped at 50 MB: when it passes that, it is rewritten to keep only its newest commands (down to about 37 MiB). When a tab starts recording, logs of closed tabs older than `retention_days` (7 by default) are deleted, and then the oldest of the rest until all logs together take at most 50 MB; logs of open tabs are never deleted, so several busy tabs can together use more.
 5. `oops` reads the end of the current tab's log, cleans and masks the text, builds the code block and hands it to the clipboard. Nothing is ever re-run.
 ## Privacy and security
-- The session logs hold the raw, **unmasked** output of every recorded command. Masking and the replace table are applied only when you copy. The logs live under `${XDG_STATE_HOME:-~/.local/state}/oops/sessions/`, readable only by you (mode 0600, directory 0700). To delete all of them, run `rm -rf "${XDG_STATE_HOME:-$HOME/.local/state}/oops"` (by default `rm -rf ~/.local/state/oops`). Use `oops pause` before showing secrets you do not want on disk.
+- The session logs hold the raw, **unmasked** output of every recorded command. Masking and the replace table are applied only when you copy. The logs live under `${XDG_STATE_HOME:-~/.local/state}/oops/sessions/`, readable only by you (mode 0600, directory 0700). Logs of closed tabs are deleted after 7 days (`retention_days`). `oops clear` deletes them now, and `oops clear --all` also empties the current tab's log. To delete everything, including the logs of other open tabs, run `rm -rf "${XDG_STATE_HOME:-$HOME/.local/state}/oops"` (by default `rm -rf ~/.local/state/oops`). Use `oops pause` before showing secrets you do not want on disk.
+- To report a security problem privately, see [SECURITY.md](SECURITY.md). Please do not open a public issue for it.
 - Recorded output is untrusted: any program you run can print text that looks like oops's markers. oops therefore obeys a pause or resume marker only when it agrees with the flag file that `oops pause` and `oops resume` set, so output cannot silently pause recording. A program can still fake where a command starts and ends in the log, so check what you paste.
 ## Known limitations
@@ -164,16 +236,16 @@ Masking is pattern based, so it is a safety net, not a guarantee: a secret in a
 - Output of full-screen apps (vim, less, tmux and so on) is not kept; it is replaced by `[full-screen app output omitted]`.
 - A command line that starts with a space is recorded in zsh but dropped in bash (bash does not save it to history, which is where oops reads the command).
 - bash with [bash-preexec](https://github.com/rcaloras/bash-preexec) (also behind atuin and Ghostty's bash integration): oops registers its hooks with it instead of using its own `DEBUG` trap, whichever of the two comes first in your rc file. A line that bash did not save to history (`HISTCONTROL=ignorespace`, `HISTIGNORE`) is then recorded as `(not saved in history)`, because the text of the line is read from history there. Without bash-preexec, oops records the first command of such a line instead.
-- bash in Ghostty: Ghostty adds its shell integration (prompt marks, new tabs in the same directory, titles) only to the outer shell, so the recorded shell does not get it. To add it back, put this below the oops line in `~/.bashrc` (checked with bash 3.2): `[ -n "$GHOSTTY_RESOURCES_DIR" ] && source "$GHOSTTY_RESOURCES_DIR/shell-integration/bash/ghostty.bash"`. zsh needs nothing: the snippet does it.
+- bash in Ghostty: Ghostty adds its shell integration (prompt marks, new tabs in the same directory, titles) only to the outer shell, so the recorded shell does not get it. To add it back, put this below the oops line in `~/.bashrc` (checked with bash 3.2): `[ -n "$GHOSTTY_RESOURCES_DIR" ] && source "$GHOSTTY_RESOURCES_DIR/shell-integration/bash/ghostty.bash"`. zsh and fish need nothing: the snippet does it.
 - bash: the line after a pipeline sees `PIPESTATUS` with only the last status (`false | true`, then `echo ${PIPESTATUS[*]}` prints `0`, not `1 0`), because oops's `PROMPT_COMMAND` entry runs first. `$?` and `$_` are kept. A prompt that shows pipeline statuses (starship's `pipestatus`) shows less in bash. zsh keeps `pipestatus`.
 - macOS: `pbcopy` chooses its text encoding from `LANG` / `LC_*`. If Japanese or other non-ASCII text arrives garbled, check that a UTF-8 locale is set (for example `LANG=en_US.UTF-8`), which can be missing in shells started over SSH.
-- fish and native Windows are not supported yet.
+- Native Windows is not supported yet.
 ## Development
 ### Set up your machine
-You need Git, Ruby 3.3 or newer, [Bundler](https://bundler.io/) (it ships with Ruby), and both zsh and bash (the end-to-end tests start real shells). macOS has zsh and bash; on Debian or Ubuntu run `sudo apt-get install zsh`.
+You need Git, Ruby 3.3 or newer, [Bundler](https://bundler.io/) (it ships with Ruby), and both zsh and bash (the end-to-end tests start real shells). macOS has zsh and bash; on Debian or Ubuntu run `sudo apt-get install zsh`. fish is optional: its end-to-end tests are skipped when it is not installed (CI installs it).
 ```sh
 git clone https://github.com/ysb3996-blip/oops.git
@@ -207,18 +279,18 @@ To try it as your shell does, build and install the gem into the Ruby you are us
 ```sh
 gem build oops-cli.gemspec
-gem install ./oops-cli-0.1.0.gem     # the file name follows lib/oops/version.rb
+gem install ./oops-cli-0.3.0.gem     # the file name follows lib/oops/version.rb
 rbenv rehash                         # only with rbenv
 ```
-- A gem is installed per Ruby version. If a new tab uses another Ruby than the one you installed into (for example the repository pins 4.0.9, but your global Ruby is 3.3.5), the shell prints `oops: command not found`. Run `gem install` again under that Ruby, e.g. `RBENV_VERSION=3.3.5 gem install ./oops-cli-0.1.0.gem`.
+- A gem is installed per Ruby version. If a new tab uses another Ruby than the one you installed into (for example the repository pins 4.0.9, but your global Ruby is 3.3.5), the shell cannot find oops when it starts (bash prints `bash: oops: command not found`, zsh prints `command not found: oops`). Run `gem install` again under that Ruby, e.g. `RBENV_VERSION=3.3.5 gem install ./oops-cli-0.3.0.gem`.
 - Reinstall after every change. The installed gem is a copy, not a link to your checkout.
 - To remove it: `gem uninstall oops-cli`.
 - Put `eval "$(oops init zsh)"` in your rc file, not just at the prompt: the recorded shell reads the rc file again, and without the line it has no hooks (`oops doctor` shows `hooks: missing`).
 Never run `oops record` in the terminal you are working in; the tests drive it through their own pty. Try it in a new terminal tab instead. To delete the logs your experiments leave behind, see "Privacy and security".
-The tests cover formatting, secret masking, the log reader, the stream parser and an end-to-end run of the relay with real zsh and bash.
+The tests cover formatting, secret masking, the log reader, the stream parser and an end-to-end run of the relay with real zsh, bash and fish.
 Manual checklist before a release:
@@ -229,7 +301,7 @@ Manual checklist before a release:
 ## Contributing
-Bug reports, ideas and pull requests are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md); issues labeled `good first issue` are a good place to start.
+Bug reports, ideas and pull requests are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md); issues labeled `good first issue` are a good place to start. Every pull request must include the test and rubocop results and a check in a new terminal tab; see [What every pull request must include](CONTRIBUTING.md#what-every-pull-request-must-include).
 ## License

data/SECURITY.ja.md ADDED Viewed

@@ -0,0 +1,34 @@
+# セキュリティポリシー
+[English](SECURITY.md) | 日本語
+oops はシェルの操作を録画し、秘密情報を含みうる文字列を扱います。それがうまくいかないケースを見つけたら、まず非公開で教えてください。
+## 対象バージョン
+| バージョン | 対応 |
+|---|---|
+| RubyGems 上の最新の 0.x リリース | あり |
+| それより古いリリース | なし。アップグレードしてください |
+## セキュリティ問題とみなすもの
+- oops がマスクすると言っている形式の秘密情報（README の「設定」を参照）が、マスクされずにコピーされる。
+- セッションログやそのディレクトリが、ファイル `0600`・ディレクトリ `0700` より緩い権限で作られる。
+- 録画機（`oops record`）が、説明された振る舞いを超えて何かをする。どこかへデータを送る、勝手にコマンドを実行する、状態ディレクトリの外に書き込む、など。
+- プログラムの出力によって、ユーザーの操作なしに記録が止まったり再開したり、oops を操れたりする。
+- 設定ファイルや独自の `clipboard:` コマンドで、本来できないはずのコードが実行できる。
+oops が対応を謳っていない形式の秘密情報が通るのは脆弱性ではありません。マスクはパターンに基づくもので、README にもそう書いています。パターンの追加は通常の issue で頼んでください（[issue #15](https://github.com/ysb3996-blip/oops/issues/15) を参照）。
+## 報告方法
+GitHub の非公開の脆弱性報告を使ってください: [アドバイザリの下書きを作る](https://github.com/ysb3996-blip/oops/security/advisories/new)。メンテナだけが読めます。セキュリティ問題は、公開の issue や pull request には書かないでください。
+報告には、**実際の秘密情報やセッションログを絶対に貼らないでください**。秘密情報は同じ形の作り物の値（例: `sk-live-XXXXXXXXXXXXXXXX`）に置き換え、ログはファイルを添付せず該当行を言葉で説明してください。セッションログには、記録した全コマンドの生の（マスクされていない）出力が入っています。
+## 対応の目安
+- 7 日以内に受け取りの連絡をします。
+- パッチリリースで修正し、CHANGELOG に変更を載せます。希望しない場合を除き、そこに報告者の名前を記載します。
+- アドバイザリは修正版のリリース後に公開します。

data/SECURITY.md ADDED Viewed

@@ -0,0 +1,34 @@
+# Security policy
+English | [日本語](SECURITY.ja.md)
+oops records your shell session and handles text that may contain secrets. If you find a way for that to go wrong, please tell us privately first.
+## Supported versions
+| Version | Supported |
+|---|---|
+| Latest 0.x release on RubyGems | Yes |
+| Older releases | No, please upgrade |
+## What counts as a security issue
+- A secret in a format oops says it masks (see "Configuration" in the README) that is copied unmasked.
+- Session logs, or their directory, created with looser permissions than `0600` for files and `0700` for the directory.
+- The recorder (`oops record`) doing anything beyond its documented behavior: sending data anywhere, running commands on its own, or writing outside the state directory.
+- Program output that can pause or resume recording, or otherwise control oops, without the user asking for it.
+- The config file or a custom `clipboard:` command being able to run code it should not.
+A secret in a format oops does not claim to know is not a vulnerability: masking is pattern based and the README says so. Ask for the pattern in a regular issue instead (see [issue #15](https://github.com/ysb3996-blip/oops/issues/15)).
+## How to report
+Use GitHub's private vulnerability reporting: [open a draft advisory](https://github.com/ysb3996-blip/oops/security/advisories/new). Only the maintainer can see it. Please do not open a public issue or pull request for a security problem.
+In the report, **never paste a real secret or a session log**. Replace secrets with made-up values of the same shape (for example `sk-live-XXXXXXXXXXXXXXXX`), and describe the log line instead of attaching the file. Session logs hold the raw, unmasked output of every recorded command.
+## What to expect
+- An acknowledgement within 7 days.
+- A fix in a patch release, with the change listed in the CHANGELOG. You will be credited there unless you ask not to be.
+- The advisory is published after the fix is released.

data/lib/oops/cli.rb CHANGED Viewed

@@ -11,6 +11,9 @@ module Oops
     NO_CLIPBOARD = "no clipboard tool found (tried pbcopy, wl-copy, xclip, xsel, clip.exe, OSC 52).".freeze
     POSITIVE_INTEGER = /\A\d+\z/
+    CopyTarget = Data.define(:count, :failed_only)
+    COUNT_REPEATED = "specify the command count only once (N or -n)".freeze
+    private_constant :CopyTarget, :COUNT_REPEATED
     def self.run(argv, env: ENV, stdin: $stdin, stdout: $stdout, stderr: $stderr)
       case argv.first
@@ -18,14 +21,25 @@ module Oops
       when "init" then return init(argv.drop(1), stdout: stdout, stderr: stderr)
       when "doctor" then return doctor(argv.drop(1), env: env, stdin: stdin, stdout: stdout)
       when "pause", "resume" then return toggle(argv.first, argv.drop(1), env: env, stdout: stdout)
+      when "status" then return status(argv.drop(1), env: env, stdout: stdout, stderr: stderr)
+      when "clear" then return clear(argv.drop(1), env: env, stdout: stdout)
       end
-      options = { head: nil, tail: nil, github: false, show_secrets: false }
+      options = { head: nil, tail: nil, github: false, show_secrets: false, time: false, output_only: false }
+      count = nil
       parser = OptionParser.new do |o|
-        o.banner = "Usage: oops [N | err] [options]\n       oops init <shell> | pause | resume | doctor"
+        o.banner = "Usage: oops [N | err] [-n N] [options]\n       " \
+                   "oops init <shell> | pause | resume | status | clear [--all] | doctor"
+        o.on("-n N", "Copy the last N commands (with err, last N failures)") do |v|
+          raise UsageError, COUNT_REPEATED if count
+          count = positive(v, "-n")
+        end
         o.on("--github", "Format for a GitHub issue or PR comment") { options[:github] = true }
         o.on("--tail N", "Keep only the last N output lines") { |v| options[:tail] = positive(v, "--tail") }
         o.on("--head N", "Keep only the first N output lines") { |v| options[:head] = positive(v, "--head") }
+        o.on("--time", "Add the time each command started") { options[:time] = true }
+        o.on("--output-only", "Leave out the command line, keep the output") { options[:output_only] = true }
         o.on("--show-secrets", "Do not mask secrets or apply the replace table") { options[:show_secrets] = true }
         o.on("-v", "--version", "Print version and exit") do
           stdout.puts "oops #{VERSION}"
@@ -36,7 +50,7 @@ module Oops
           return 0
         end
       end
-      copy(target(parser.parse(argv)), options, env: env, stdout: stdout, stderr: stderr)
+      copy(target(parser.parse(argv), count: count), options, env: env, stdout: stdout, stderr: stderr)
     rescue OptionParser::ParseError, UsageError => e
       stderr.puts "oops: #{e.message}"
       2
@@ -51,17 +65,18 @@ module Oops
       value.to_i
     end
-    # Positional arguments: none (the last command), N (the last N commands)
-    # or "err" (the last failed command). Returns 1, N or :err.
-    def self.target(args)
+    # Count comes from either a positional N or -n N. "err" filters the
+    # selection to failed commands; without a count, one command is copied.
+    def self.target(args, count:)
       raise UsageError, "unexpected argument: #{args[1]}" if args.size > 1
       arg = args.first
-      return 1 if arg.nil?
-      return :err if arg == "err"
-      return positive(arg, "N") if arg.match?(/\A[+-]?\d/)
+      return CopyTarget.new(count: count || 1, failed_only: arg == "err") if arg.nil? || arg == "err"
-      raise UsageError, "unknown command: #{arg}"
+      raise UsageError, "unknown command: #{arg}" unless arg.match?(/\A[+-]?\d/)
+      raise UsageError, COUNT_REPEATED if count
+      CopyTarget.new(count: positive(arg, "N"), failed_only: false)
     end
     def self.copy(target, options, env:, stdout:, stderr:)
@@ -70,8 +85,8 @@ module Oops
       config = Config.load(env: env)
       config.warnings.each { |w| stderr.puts "oops: warning: #{w}" }
-      records = target == :err ? [log.last_failed].compact : log.last(target)
-      raise Failure, (target == :err ? "no failed command found." : "no command found yet.") if records.empty?
+      records = log.last(target.count, failed_only: target.failed_only)
+      raise Failure, (target.failed_only ? "no failed command found." : "no command found yet.") if records.empty?
       home = env["HOME"].to_s.empty? ? Dir.home : env["HOME"]
       result = Formatter.new(config: config, home: home, **options).format(records)
@@ -103,8 +118,12 @@ module Oops
       path = env["OOPS_SESSION"].to_s
       return SessionLog.new(path) if !path.empty? && File.file?(path)
-      shell, rc = env["SHELL"].to_s.end_with?("bash") ? %w[bash ~/.bashrc] : %w[zsh ~/.zshrc]
-      raise Failure, "not recording in this shell. Add  eval \"$(oops init #{shell})\"  " \
+      line, rc = case env["SHELL"].to_s
+                 when /bash\z/ then [%(eval "$(oops init bash)"), "~/.bashrc"]
+                 when /fish\z/ then ["oops init fish | source", "~/.config/fish/config.fish"]
+                 else [%(eval "$(oops init zsh)"), "~/.zshrc"]
+                 end
+      raise Failure, "not recording in this shell. Add  #{line}  " \
                      "to #{rc} (after whatever puts oops's Ruby on PATH, as early as possible) " \
                      "and open a new tab."
     end
@@ -144,6 +163,43 @@ module Oops
       stdout.flush
     end
+    # `oops status`: one word on stdout. "recording" exits 0; "paused" and
+    # "off" (this shell is not recorded, or its log is gone) exit 1 without a
+    # message, so a prompt can call it.
+    def self.status(args, env:, stdout:, stderr:)
+      unless args.empty?
+        stderr.puts "oops: usage: oops status"
+        return 2
+      end
+      path = env["OOPS_SESSION"].to_s
+      word = if path.empty? || !File.file?(path) then "off"
+             elsif SessionLog.new(path).paused? then "paused"
+             else "recording"
+             end
+      stdout.puts word
+      word == "recording" ? 0 : 1
+    end
+    # `oops clear [--all]`: deletes the logs of closed tabs; with --all, also
+    # empties this tab's log. Logs of other open tabs are never touched.
+    def self.clear(args, env:, stdout:)
+      raise UsageError, "usage: oops clear [--all]" unless args.empty? || args == ["--all"]
+      log = recording_log(env) if args == ["--all"]
+      begin
+        removed = SessionLog.clear!(Paths.sessions_dir(env: env))
+        stdout.puts "removed #{removed} #{removed == 1 ? 'log' : 'logs'} of closed tabs"
+        return 0 unless log
+        log.empty!
+      rescue SystemCallError => e
+        raise Failure, "could not delete the logs: #{e.message}"
+      end
+      stdout.puts "emptied this tab's log"
+      0
+    end
     # `oops doctor`: diagnostics on stdout; always exits 0.
     def self.doctor(args, env:, stdin:, stdout:)
       raise UsageError, "usage: oops doctor" unless args.empty?
@@ -165,7 +221,7 @@ module Oops
       Recorder.new(args, env: env, stdin: stdin, stdout: stdout, stderr: stderr).run
     end
-    # `oops init zsh|bash`: prints the snippet for `eval "$(oops init zsh)"`.
+    # `oops init zsh|bash|fish`: prints the snippet for `eval "$(oops init zsh)"`.
     def self.init(args, stdout:, stderr:)
       supported = ShellInit::SHELLS.join(", ")
       if args.size != 1
@@ -181,6 +237,6 @@ module Oops
     end
     private_class_method :positive, :target, :copy, :report_command, :report_counts, :recording_log, :toggle,
-                         :write_marker, :doctor
+                         :write_marker, :status, :clear, :doctor
   end
 end

data/lib/oops/config.rb CHANGED Viewed

@@ -3,9 +3,10 @@ require_relative "paths"
 module Oops
   # User configuration loaded from a YAML file; problems become warnings.
   class Config
-    KNOWN_KEYS = %w[replace secrets clipboard].freeze
+    KNOWN_KEYS = %w[replace secrets clipboard retention_days].freeze
+    DEFAULT_RETENTION_DAYS = 7
-    attr_reader :replace, :secrets, :clipboard, :warnings
+    attr_reader :replace, :secrets, :clipboard, :retention_days, :warnings
     def self.load(path = nil, env: ENV)
       new(path || Paths.config_file(env: env))
@@ -15,6 +16,7 @@ module Oops
       @replace = {}
       @secrets = []
       @clipboard = "auto"
+      @retention_days = DEFAULT_RETENTION_DAYS
       @warnings = []
       read(path)
     end
@@ -41,6 +43,7 @@ module Oops
       apply_replace(data["replace"]) if data.key?("replace")
       apply_secrets(data["secrets"]) if data.key?("secrets")
       apply_clipboard(data["clipboard"]) if data.key?("clipboard")
+      apply_retention_days(data["retention_days"]) if data.key?("retention_days")
     end
     # YAML reads `clipboard: true` (or false) as a boolean; as a command it
@@ -50,6 +53,15 @@ module Oops
       @clipboard = text.empty? || %w[true false].include?(text) ? "auto" : value.to_s
     end
+    # false keeps closed tabs' logs until the size cap removes them.
+    def apply_retention_days(value)
+      return @retention_days = nil if value == false
+      return @retention_days = value if value.is_a?(Integer) && value >= 1
+      @warnings << "retention_days must be a whole number of days (at least 1) or false; " \
+                   "using #{DEFAULT_RETENTION_DAYS}"
+    end
     def apply_replace(value)
       return @warnings << "replace must be a mapping; ignored" unless value.is_a?(Hash)

data/lib/oops/formatter.rb CHANGED Viewed

@@ -4,7 +4,9 @@ module Oops
   # Per field (command line and output) the pipeline is: strip ANSI, scrub
   # invalid UTF-8, shorten the home directory to "~", mask secrets, apply the
   # config replace table. Output is then truncated (head/tail) and fenced.
-  # With show_secrets, the home/mask/replace steps are skipped.
+  # With show_secrets, the home/mask/replace steps are skipped. With time, a
+  # "# <local start time>" line precedes each command; with output_only, the
+  # "$ command" line is left out.
   class Formatter
     GITHUB_COLLAPSE_LINES = 30
@@ -13,13 +15,18 @@ module Oops
     # command_line: the formatted first command, without "$ " or indentation.
     Result = Struct.new(:text, :lines, :masked_count, :command_line)
-    def initialize(config:, home: Dir.home, show_secrets: false, head: nil, tail: nil, github: false)
+    TIME_FORMAT = "%Y-%m-%d %H:%M:%S %:z".freeze
+    def initialize(config:, home: Dir.home, show_secrets: false, head: nil, tail: nil, github: false,
+                   time: false, output_only: false)
       @config = config
       @home = home.to_s
       @show_secrets = show_secrets
       @head = head
       @tail = tail
       @github = github
+      @time = time
+      @output_only = output_only
       @masked = 0
     end
@@ -37,9 +44,21 @@ module Oops
       shown, count = shown_lines(clean(PromptSp.strip(record.output.to_s)))
       exit_code = record.exit
       exit_code = nil if exit_code.to_i.zero?
-      body = ["$ #{command.gsub("\n", "\n  ").gsub(/^ +$/, '')}", *shown]
+      stamp = start_time(record)
+      body = []
+      body << "# #{stamp}" if stamp
+      body << "$ #{command.gsub("\n", "\n  ").gsub(/^ +$/, '')}" unless @output_only
+      body.concat(shown)
       body << "(exit #{exit_code})" if exit_code
-      { command: command, exit: exit_code, count: count, content: body.join("\n") }
+      { command: command, exit: exit_code, count: count, time: stamp, content: body.join("\n") }
+    end
+    # Local time the command started, or nil without --time or for a record
+    # that has no start time.
+    def start_time(record)
+      return nil unless @time && record.started_at
+      Time.at(record.started_at.to_i).strftime(TIME_FORMAT)
     end
     # Returns [lines to show, real output line count]: trailing blank lines
@@ -98,13 +117,20 @@ module Oops
       parts = []
       parts << "exit #{block[:exit]}" if block[:exit]
       parts << "#{block[:count]} lines"
-      summary = escape_html("$ #{block[:command]}".gsub("\n", " "))
-      "<details>\n<summary><code>#{summary}</code> — #{parts.join(', ')}</summary>\n\n#{fence}\n</details>\n"
+      parts << block[:time] if block[:time]
+      summary = parts.join(", ")
+      unless @output_only
+        command = escape_html("$ #{block[:command]}".gsub("\n", " "))
+        summary = "<code>#{command}</code> — #{summary}"
+      end
+      "<details>\n<summary>#{summary}</summary>\n\n#{fence}\n</details>\n"
     end
     def fenced(content, language)
       longest = content.scan(/`+/).map(&:length).max.to_i
       fence = "`" * [3, longest + 1].max
+      return "#{fence}#{language}\n#{fence}\n" if content.empty?
       "#{fence}#{language}\n#{content}\n#{fence}\n"
     end

data/lib/oops/recorder.rb CHANGED Viewed

@@ -172,7 +172,8 @@ module Oops
     # Rotation only frees space; failing to rotate must not stop recording.
     def rotate_logs(dir)
-      SessionLog.rotate!(dir)
+      days = Config.load(env: @env).retention_days
+      SessionLog.rotate!(dir, max_age: days && (days * 86_400))
     rescue SystemCallError
       nil
     end

data/lib/oops/secrets.rb CHANGED Viewed

@@ -26,7 +26,9 @@ module Oops
       # limit) everything after BEGIN is masked.
       /-----BEGIN [A-Z ]*PRIVATE KEY-----.*?(?:-----END [A-Z ]*PRIVATE KEY-----|\z)/m,
       %r{\b[a-z][a-z0-9+.-]*://(?<secret>[^\s/@:]+:[^\s/@]+)@}i, # URL userinfo
-      %r{[A-Za-z0-9._%+-]+@(?>[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)+)(?!:[\w~/])}, # email, not scp-style git@host:path
+      # Email. The last label must be letters, like a real TLD, so versioned
+      # names such as mysql@8.4 stay; the lookahead skips git@host:path.
+      %r{[A-Za-z0-9._%+-]+@(?>(?:[A-Za-z0-9-]+\.)+[A-Za-z]{2,})(?![A-Za-z0-9-])(?!:[\w~/])},
       # Public IPv4: not private/loopback/unspecified, and not part of a longer
       # dotted number such as a version string (1.2.3.4.5).
       Regexp.new(

data/lib/oops/session_log.rb CHANGED Viewed

@@ -25,19 +25,19 @@ module Oops
       false
     end
-    # Deletes the oldest logs of finished sessions until the total size of
-    # all session logs is at most max_bytes. Logs of live sessions are kept.
-    def self.rotate!(dir, max_bytes: DEFAULT_MAX_BYTES, alive: method(:process_alive?))
-      logs = Dir.children(dir).filter_map do |name|
-        m = LOG_NAME.match(name)
-        next unless m
-        size = begin
-          File.size(File.join(dir, name))
-        rescue SystemCallError
-          next
+    # Deletes logs of finished sessions: with max_age, those last written more
+    # than max_age seconds ago; then the oldest, until the total size of all
+    # session logs is at most max_bytes. Logs of live sessions are kept.
+    def self.rotate!(dir, max_bytes: DEFAULT_MAX_BYTES, max_age: nil, now: Time.now,
+                     alive: method(:process_alive?))
+      logs = list(dir)
+      if max_age
+        logs = logs.reject do |log|
+          next false if log[:mtime] >= now - max_age || alive.call(log[:pid])
+          remove_log(File.join(dir, log[:name]))
+          true
         end
-        { name: name, pid: m[2].to_i, size: size }
       end
       total = logs.sum { |l| l[:size] }
       logs.sort_by { |l| l[:name] }.each do |log|
@@ -51,6 +51,29 @@ module Oops
       nil
     end
+    # Deletes the logs of all finished sessions. Returns how many it deleted.
+    def self.clear!(dir, alive: method(:process_alive?))
+      dead = list(dir).reject { |log| alive.call(log[:pid]) }
+      dead.each { |log| remove_log(File.join(dir, log[:name])) }
+      dead.size
+    rescue Errno::ENOENT
+      0
+    end
+    def self.list(dir)
+      Dir.children(dir).filter_map do |name|
+        m = LOG_NAME.match(name)
+        next unless m
+        stat = begin
+          File.stat(File.join(dir, name))
+        rescue SystemCallError
+          next
+        end
+        { name: name, pid: m[2].to_i, size: stat.size, mtime: stat.mtime }
+      end
+    end
     def self.remove_log(file)
       [file, "#{file}.paused", "#{file}.status", "#{file}.trim"].each do |f|
         File.delete(f)
@@ -58,7 +81,7 @@ module Oops
         nil
       end
     end
-    private_class_method :remove_log
+    private_class_method :list, :remove_log
     def initialize(path, max_bytes: DEFAULT_MAX_BYTES)
       @path = path
@@ -93,11 +116,13 @@ module Oops
       nil
     end
-    # Newest count finished, non-oops records, oldest first.
-    def last(count, skip_oops: true)
+    # Newest count finished, non-oops records, oldest first. With failed_only,
+    # only records with a non-zero integer exit status count toward the limit.
+    def last(count, skip_oops: true, failed_only: false)
       found = []
       each_backward do |r|
         next if r.exit.nil? || (skip_oops && r.oops_self?)
+        next if failed_only && (!r.exit.is_a?(Integer) || r.exit.zero?)
         found << r
         :stop if found.size >= count
@@ -106,10 +131,7 @@ module Oops
     end
     def last_failed
-      each_backward do |r|
-        return r if r.exit.is_a?(Integer) && r.exit != 0 && !r.oops_self?
-      end
-      nil
+      last(1, failed_only: true).first
     end
     def paused?
@@ -126,6 +148,12 @@ module Oops
       nil
     end
+    # The recorder opens the log for each record it appends, so the file can
+    # be cut to nothing while the session goes on.
+    def empty!
+      File.truncate(@path, 0)
+    end
     private
     def pause_path

data/lib/oops/shell/oops.fish ADDED Viewed

@@ -0,0 +1,99 @@
+# oops: fish hooks. Put this line in ~/.config/fish/config.fish, after
+# whatever puts oops's Ruby on PATH and as early as possible after that:
+#
+#   oops init fish | source
+#
+# On a terminal that is not recorded yet, the shell is started again under
+# `oops record` (a pty relay). Inside the recorded shell the hooks write
+# invisible APC markers around every command:
+#
+#   ESC _ oops;start;<seq>;<epoch>;<base64 cwd>;<base64 cmd> ESC \
+#   ESC _ oops;end;<seq>;<exit> ESC \
+#
+# "Recorded" means $OOPS_TTY (set by the relay) names this very terminal, so
+# shells started from a recorded one on another tty (tmux, GUI terminals)
+# get recorded on their own, and `exec fish` on the same tty is not recorded
+# twice. Markers go straight to the terminal device, so a redirected stdout
+# never receives them.
+# This file is read from a pipe (`| source`), so stdin is not the terminal:
+# the checks look at stdout and stderr instead.
+if status is-interactive; and test -t 1; and test -t 2; and not set -q OOPS_DISABLE
+    and set -g __oops_tty (tty <&2 2>/dev/null)
+    set -g __oops_bin __OOPS_BIN__
+    if test "$OOPS_TTY" != "$__oops_tty"
+        # A failed exec ends fish, so check first; without the binary the
+        # shell simply runs unrecorded.
+        if command -q $__oops_bin
+            set -g __oops_login
+            status is-login; and set __oops_login --login
+            # Ghostty injects its shell integration through XDG_DATA_DIRS and
+            # removes the injection again, so the restarted shell would not
+            # get it. Note whether this one has it (its setup function waits
+            # for the first prompt), so the restarted shell can load it again.
+            set -g __oops_ghostty
+            functions -q __ghostty_setup; and set __oops_ghostty 1
+            # Restart at the first prompt, not now: `fish -i -c cmd` and
+            # `fish -i script.fish` count as interactive here but never show a
+            # prompt, so they run their command unrecorded instead of losing it.
+            function __oops_restart --on-event fish_prompt
+                functions -e __oops_restart
+                if test -n "$__oops_ghostty"
+                    set -gx __OOPS_GHOSTTY 1
+                else
+                    set -e __OOPS_GHOSTTY
+                end
+                exec $__oops_bin record -- (status fish-path) $__oops_login
+            end
+        else
+            echo "oops: cannot run $__oops_bin; recording disabled" >&2
+        end
+    else
+        function __oops_b64
+            printf '%s' $argv[1] | base64 | tr -d '\n'
+        end
+        # $argv[1] is the whole command line, several lines for a block. Very
+        # long lines are cut so the marker stays small. A line of spaces runs
+        # nothing, and the other shells make no record for it either.
+        function __oops_preexec --on-event fish_preexec
+            string trim -- $argv[1] | string length -q; or return
+            set -gx __OOPS_SEQ (math $__OOPS_SEQ + 1)
+            set -g __oops_open $__OOPS_SEQ
+            set -l cmd (string sub -l 8192 -- $argv[1] | string collect)
+            printf '\e_oops;start;%s;%s;%s;%s\e\\' $__OOPS_SEQ (date +%s) \
+                (__oops_b64 $PWD) (__oops_b64 "$cmd") 2>/dev/null >$__oops_tty
+        end
+        # $status must be read before anything else runs.
+        function __oops_postexec --on-event fish_postexec
+            set -l exit_status $status
+            if test -n "$__oops_open"
+                printf '\e_oops;end;%s;%s\e\\' $__oops_open $exit_status 2>/dev/null >$__oops_tty
+                set -g __oops_open
+            end
+        end
+        # Once per shell process; sourcing config.fish again must not redo this.
+        if not set -q __oops_hooked
+            set -g __oops_hooked 1
+            set -g __oops_open
+            string match -qr '^[0-9]+$' -- "$__OOPS_SEQ"; or set -gx __OOPS_SEQ 0
+            # Same pid as the shell that set __OOPS_PID: this shell replaced it
+            # with `exec`, so that command (still open in the relay) is done.
+            if test "$__OOPS_PID" = "$fish_pid"; and test "$__OOPS_SEQ" != 0
+                printf '\e_oops;end;%s;%s\e\\' $__OOPS_SEQ 0 2>/dev/null >$__oops_tty
+            end
+            # Exported so a nested shell on this tty continues the numbering.
+            set -gx __OOPS_SEQ $__OOPS_SEQ
+            set -gx __OOPS_PID $fish_pid
+        end
+        # The shell this one replaced had Ghostty's integration (see above);
+        # load it here too, as Ghostty documents for a manual setup.
+        set -l ghostty "$GHOSTTY_RESOURCES_DIR/shell-integration/fish/vendor_conf.d/ghostty-shell-integration.fish"
+        if set -q __OOPS_GHOSTTY; and test -n "$GHOSTTY_RESOURCES_DIR"; and test -r $ghostty
+            and not functions -q __ghostty_setup
+            source $ghostty
+        end
+    end
+end

data/lib/oops/shell_init.rb CHANGED Viewed

@@ -1,11 +1,12 @@
 module Oops
-  # The snippets printed by `oops init zsh|bash`, meant for
-  # `eval "$(oops init zsh)"` in the rc file, after whatever puts oops's Ruby
-  # on PATH and as early as possible after that. The templates live in
-  # lib/oops/shell/; the absolute path of the oops executable is written into
-  # them, so a later change to PATH cannot break the hooks.
+  # The snippets printed by `oops init zsh|bash|fish`, meant for
+  # `eval "$(oops init zsh)"` (or `oops init fish | source`) in the rc file,
+  # after whatever puts oops's Ruby on PATH and as early as possible after
+  # that. The templates live in lib/oops/shell/; the absolute path of the oops
+  # executable is written into them, so a later change to PATH cannot break
+  # the hooks.
   module ShellInit
-    SHELLS = %w[zsh bash].freeze
+    SHELLS = %w[zsh bash fish].freeze
     TEMPLATE_DIR = File.expand_path("shell", __dir__)
     BIN_PLACEHOLDER = "__OOPS_BIN__".freeze
@@ -13,14 +14,19 @@ module Oops
       raise ArgumentError, "unsupported shell: #{shell}" unless SHELLS.include?(shell)
       template = File.read(File.join(TEMPLATE_DIR, "oops.#{shell}"), encoding: Encoding::UTF_8)
-      template.gsub(BIN_PLACEHOLDER) { shell_quote(bin) }
+      template.gsub(BIN_PLACEHOLDER) { shell == "fish" ? fish_quote(bin) : shell_quote(bin) }
     end
-    # One single-quoted word for both shells: ' becomes '\''.
+    # One single-quoted word for zsh and bash: ' becomes '\''.
     def self.shell_quote(text)
       "'#{text.to_s.gsub("'") { "'\\''" }}'"
     end
-    private_class_method :shell_quote
+    # fish single quotes take \' and \\ instead.
+    def self.fish_quote(text)
+      "'#{text.to_s.gsub(/[\\']/) { "\\#{_1}" }}'"
+    end
+    private_class_method :shell_quote, :fish_quote
   end
 end

data/lib/oops/version.rb CHANGED Viewed

@@ -1,3 +1,3 @@
 module Oops
-  VERSION = "0.1.0".freeze
+  VERSION = "0.3.0".freeze
 end

metadata CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oops-cli
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - ysb3996-blip
@@ -22,6 +22,8 @@ files:
 - LICENSE
 - README.ja.md
 - README.md
+- SECURITY.ja.md
+- SECURITY.md
 - exe/oops
 - lib/oops.rb
 - lib/oops/ansi.rb
@@ -38,6 +40,7 @@ files:
 - lib/oops/secrets.rb
 - lib/oops/session_log.rb
 - lib/oops/shell/oops.bash
+- lib/oops/shell/oops.fish
 - lib/oops/shell/oops.zsh
 - lib/oops/shell_init.rb
 - lib/oops/stream_parser.rb