feat: add private RSS reader and read-only FreshRSS integration
Build and publish container images / images (push) Failing after 6m19s

This commit is contained in:
Anya Tokugawa committed 2026-11-08 03:35:02 +09:00
1 parent 0c2cf263b6
commit 0d8997972c
25 files changed
+1911 -14

No files matched your search

+1 -1
View File
@@ -27,7 +27,7 @@
| ADR-O1 | organizerはtyped metadataと任意Page参照 | タスク初版は専用表+既存CAS Document Store(2026-09-24)。通常のObject閲覧・リンク・削除の権限境界を拡大せず、個人所有を確実に分離する。DBは捨てられる索引ではない。[実装契約](tasks-implementation.md) |
| ADR-O2 | task共通部+ticket workflow | 提案。番号・外部依頼者・遷移権限の要件確認 |
| ADR-O3 | ICS/vCard入出力→read-only DAV→双方向 | 推奨順。対象サーバー/clientを選んで互換表を作る |
| ADR-O4 | 簡易利用は内蔵正本、本格運用はFreshRSS正本+PagesWiki connector+newsboat | 2026-11-08利用者指定で採用。source単位で正本を分離し、自動fallbackや二重管理はしない。実環境の接続先・版・資格情報は別途指定 |
| ADR-O4 | 簡易利用は内蔵正本、本格運用はFreshRSS正本+PagesWiki connector+newsboat | 2026-11-08利用者指定で採用。内蔵・FreshRSS読取・共通UIまで実装。source単位で正本を分離し、自動fallbackや二重管理はしない。OPML・外部書戻しは残件。実環境の接続先・版・資格情報は別途指定 |
| ADR-O5 | IMAP read-only、Wikiコピーは明示操作 | 初期設計方針。providerとsampleが実装前提 |
| ADR-O6 | HTMLパーツを先行し全面WYSIWYGは保留 | 提案。round-tripと操作改善の評価でgo/no-go |
| ADR-O7 | Wiki Pathと外部UID/hrefを分離 | 共通の設計制約。rename fixtureを全connectorで実施 |
+98 -7
View File
@@ -1,6 +1,8 @@
# 15. RSSビューア・FreshRSS・newsboat
状態:正本の役割分担は決定、実装は未着手。既存のブログRSS「配信」と、本章の外部RSS「購読」は別機能。
状態:内蔵簡易reader、FreshRSS読取connector、共通viewer、Wiki保存・タスク化、ダッシュボードを実装。
FreshRSSへの書戻し・OPMLは残件。本番反映と実FreshRSSへの接続は未実施。
既存のブログRSS「配信」と、本章の外部RSS「購読」は別機能。
2026-11-08:利用者指定のサブプロジェクト順で最初に実施する。内蔵readerは簡易利用の
正本、本格運用はFreshRSSを正本とする。実環境の接続先・版・資格情報は別途指定する。
@@ -28,11 +30,74 @@ FreshRSS停止時は取得済みcacheと鮮度・接続状態を示し、内蔵
内蔵からFreshRSSへの移行はOPML等による明示的なexport/importとし、初期版では既読・star・
記事IDの完全移行を保証しません。移行完了の確認前に内蔵データを削除しません。
## 読取MVP
## 実装済みの読取機能
購読一覧、フォルダ、記事一覧、外部原文、Wiki保存を提供します。初期段階では表示しただけでFreshRSSへ既読を送りません。UIには「読取専用・既読は同期していない」と明示します。ブラウザへFreshRSS password/tokenを渡さず、backend connectorがsecret参照を使います。
`/v/feeds` に購読一覧、フォルダ、記事一覧、外部原文へのリンク、Wiki保存を提供します。
FreshRSSの記事・既読・starは取得しますが、状態の変更は送信しません。UIにも読取専用と明示し、
FreshRSS passwordを設定時以外にブラウザへ返さず、login tokenはbackend内でのみ利用します。
資格情報は既存の暗号化機構を使い、Domain・所有者・source UUID・用途に束縛します。
最小cache案はsource UUID、remote feed/item ID、title、safe excerpt/body hash、canonical URL、published/updated/fetched時刻、remote state/versionです。IDなしRSSにはfeed単位の保守的な代替キーを使い、題名だけで重複排除しません。Atomはentry IDと更新情報を持つ形式です。[Atom仕様](https://www.rfc-editor.org/rfc/rfc4287)。
cacheはsource UUID、remote item ID、title、安全なテキスト本文、記事URL、公開日時、配信元、
フォルダ、read/starを保持します。取得時刻・ETag・Last-Modified・失敗分類はsource側に持ちます。
IDなしRSSは記事URL、URLもなければ題名・日時・本文の組合せから代替キーを作り、題名だけで
重複排除しません。Atomはentry IDを使います。[Atom仕様](https://www.rfc-editor.org/rfc/rfc4287)。
### 高密度ビューア
newsboat/neomuttを参考に、デスクトップは左から購読元・一行記事一覧・本文の3ペインとします。
一覧には未読/star、日付、配信元、件名を並べます。狭幅は一覧と本文を切り替え、スマホでは
行とボタンのタッチ領域を広げます。設定と保存フォームは本文ペイン内に置き、モーダルを増やしません。
`j/k`・上下矢印で移動、`Enter/l`で本文、`Esc/h`で一覧、`/`で件名・配信元検索、`n`で次の未読、
`m`で既読切替、`*`でstar、`r`で背景更新予約、`?`でキー案内です。フォーム入力・IME変換中は
一覧ショートカットを抑止します。FreshRSSでは`m`と`*`も外部変更を行いません。
本文は常にtext表示です。script・画像・CSS・Wiki macroを実行せず、記事表示のための外部画像や
原文サイトのfetchも行いません。検索とページングは保存済みcacheだけを対象にし、画面表示で
feed取得の完了を待ちません。ダッシュボードには任意追加のRSS widgetを用意します。
### APIと保存層
API prefixは `/_/api/v1/extension/organizer.feeds/`。Domain内の本人専用で、匿名・他人のsourceには
アクセスできません。readonlyアカウントは読取のみです。すべての応答はprivate/no-storeとします。
| endpoint | 操作 |
| --- | --- |
| `GET sources` / `POST sources` | source一覧/追加・設定更新。新規はUUIDで再送を識別、更新はversion CAS |
| `POST sources/{uuid}/refresh` | 次回背景取得を予約。画面から外部通信しない |
| `POST sources/{uuid}/delete` | versionを照合してsource・cache・内蔵read/starを削除 |
| `GET items` | source/unread/starred/件名・配信元で絞り込み、100件単位のkeysetページング |
| `GET item?source=…&id=…` | 本人の記事本文 |
| `POST state` | 内蔵read/starの条件付き変更。FreshRSSは拒否 |
| `POST note` | 公開範囲確認付きのWiki単独保存。request_idと入力hashで再送を識別 |
managed schema `feeds` v1に `feed_sources`、`feed_items`、`feed_states`、`feed_note_receipts`を追加します。
既存テーブルを破壊・再構成しません。SQLiteのforeign_keys設定に依存せず削除を完遂するtriggerを
持ちます。内蔵read/starを本文cacheから分離し、記事を保持窓から落としても状態は黙って消しません。
DBは内蔵購読・状態・保存receiptの正本であり、全体を捨てられるcacheとは扱いません。
sourceのprovider・URL・資格情報の変更は別sourceを作る契約です。設定versionとworker claimの
両方を照合し、停止/削除/設定更新後に古い取得結果を書き戻しません。完了保存時にも本人の
所属・状態・extension有効状態をwriter transaction内で確認します。
### 背景取得の上限
| 項目 | 初期実装の値・挙動 |
| --- | --- |
| 個人のsource数 | Domain・本人ごとに32 |
| 定期event | `feed.source.sync`、既定60秒周期、低優先度、1回最大4 sourceを直列取得 |
| source更新間隔 | 5〜1440分、既定30分。取得候補になる間隔であり、混雑時の完了時刻保証ではない |
| 通信予算 | 1 source 8秒、batch 35秒、応答/展開後本文4 MiB |
| 外部接続 | 公開HTTPS/443のみ。DNS検査・接続先固定、内部アドレス・redirect・proxyを拒否 |
| 内蔵記事cache | 1 source最大500件、本文32 KiB。超過本文は切詰めを明示 |
| 内蔵read/star | 1 source最大10,000件。上限では新規状態保存を拒否し、既存状態を捨てない |
| FreshRSS | reading-list最新200件の窓を取得。更新成功時はその窓で置換し、全履歴同期とはしない |
| 再試行 | 次の設定間隔まで待機。手動予約にも最終成功から60秒の制限、取得中の重複claim拒否 |
内蔵は条件付きGET、304ではcacheを保持します。どちらのproviderも通信・認証・構文失敗で
前回cacheを消しません。sourceには安全な失敗分類と最終成功日時を表示し、イベントログには
成功/失敗件数だけを記録します。資格情報・生本文・秘密を含み得るURLをログへ出しません。
extension無効化は画面・API・取得・完了保存に適用します。購読を登録するまで外部通信は発生しません。
## 既読・star同期を追加する条件
@@ -47,7 +112,9 @@ FreshRSS APIに条件付き更新がない操作もあり得るため、対応
既読・starの保持期間を分離し、古い記事を再取得しただけで未読へ戻る挙動を防ぎます。
高度な自動分類、全文収集、reader向け互換APIはFreshRSSとの機能競争として追加しません。
定期event、条件付きGET、host別同時数、timeout、応答サイズ、展開サイズ、backoffを設けます。XML外部entityを無効にし、feed HTMLを安全化します。redirect/DNSを含むSSRF対策、外部画像の同意、個人購読URLや認証情報の秘匿が必要です。
初期版では全体を直列化し、上記の予算内で取得します。将来の並列化時にhost別同時数・公平性・
指数backoff/Retry-Afterを追加します。RSS 2.0とAtomを対象とし、XML外部entityは展開しません。
外部画像の同意付き表示は未実装で、現在は一律に取得・表示しません。
OPMLは購読の入出力として扱い、既読・star・全本文のバックアップと同一視しません。importはpreview・追加/置換選択・重複確認を行い、既存購読を黙って削除しません。
@@ -55,9 +122,32 @@ OPMLは購読の入出力として扱い、既読・star・全本文のバック
既定はURL、出典、短いメモの保存です。全文保存は取得可能性・利用条件・個人用途等を確認する独立操作とし、feedが短いからといって有料記事を自動取得しません。保存先が自動公開範囲なら内容と添付の公開を明示確認します。
Wiki単独は親Path配下の `rss-{request UUID}` に新規作成します。既存Pathを上書きせず、Page・Path・
初回Revision・活動outbox・再送receiptを同じDB transactionで保存します。権限はtransaction内でも
再確認します。初期版の単独保存は通常Wiki空間のみで、独自所有契約を持つ`/u`・`/g`は対象外です。
タスクも作成する場合は既存capture APIの原子的なWiki+タスク保存を使います。この経路のPathは
既存契約の`mail-{request UUID}`です。途中失敗時は部分的なPage/タスクを残さず、同じ要求で再試行できます。
保存先の公開範囲確認を必須にし、取得済み本文のコピーは別チェックとします。
購読削除で明示保存したWikiやタスクは消しません。内蔵cacheを削除しても既存Wikiへの参照と
再送receiptは残します。文書payloadの不変ファイルは既存Document Storeに保存するため、DB失敗時に
未参照payloadが残る可能性は既存GC契約に従い、参照のないPage/Pathとは区別します。
## TODOと受け入れ
RSS-1:read-only FreshRSS fixture。RSS-2:安全な共通一覧と出典付きWiki保存。RSS-3:FreshRSSへの明示的な既読/star操作。RSS-4:内蔵簡易readerとOPML。オフライン、欠落ID、巨大feed、未知HTML、同期再送、他user情報、feed削除後の保存Page維持を試験します。内蔵とFreshRSSの正本を混ぜないこと、停止時の自動切替がないこと、移行後も保存済みWiki/タスクが残ることを両provider共通の受入条件とします。
- [x] RSS-1:read-only FreshRSS connectorと合成fixture。実接続の受入は別。
- [x] RSS-2:安全な共通一覧、出典付きWiki保存、任意のタスク化、ダッシュボード。
- [ ] RSS-3:FreshRSSへの明示的な既読/star操作と送信状態・競合・再送の契約。
- [x] RSS-4a:内蔵簡易reader、購読設定、既読・star、背景取得。
- [ ] RSS-4b:OPML export/importのpreview、重複確認、明示移行。
- [ ] RSS-5:FreshRSS実環境の接続先・版・API資格情報を指定してread-only受入。
- [ ] RSS-6:大規模利用時の公平性、host別並列上限、Retry-After/backoff、資格情報rotation UI。
- [ ] RSS-7:FreshRSSの購読一覧・カテゴリを使うnavigation。現在の左ペインはPagesWikiに登録したsourceとそのフォルダで、FreshRSSの全購読一覧ではない。
隔離試験はRSS/Atom・FreshRSS login/read、欠落ID・巨大/不正feed、条件付きGET、失敗時cache保持、
本人分離・失効・readonly、二重送信・版競合・旧worker拒否、migration再実行/失敗rollback、
Wiki保存失敗の原子性を含みます。Chromiumの1440px/390pxで一覧・本文・検索・キー操作・
Wiki保存を試験します。実FreshRSS、newsboat、実機Safariの受入はこの合成試験に含めません。
## 実施段階
@@ -69,7 +159,8 @@ RSS-1:read-only FreshRSS fixture。RSS-2:安全な共通一覧と出典付
待たず、schedulerで有界に更新し、取得済みcacheと鮮度を表示する。source停止・失効も検証する。
3. **Wiki保存とタスク化**:タイトル・URL・出典・短いメモをpreviewし、保存先Pathを選ぶ。
既存captureと権限確認を再利用し、二重送信・保存先競合・自動公開範囲を検査する。全文保存は
独立した明示操作。タスク作成が失敗しても保存済みWikiを消さず、部分成功と再試行方法を示す。
独立した明示操作。Wiki単独保存とWiki+タスクの原子保存を分け、要求内の失敗では部分成功を
残さない。過去に保存済みのWikiは別のタスク作成失敗で削除しない。
4. **ダッシュボードとprovider完成**:読める記事だけのwidget、内蔵簡易readerとOPML、
FreshRSSの明示的な既読/star操作を段階的に追加する。接続先・対象版の指定後に実環境で
read-only→書込の順に受入し、read-only連携を有効化しただけで外部状態を変更しない。
+3 -2
View File
@@ -1,6 +1,7 @@
# 実装残件台帳
更新日:2026-11-08。照合基準は `e65ca56`(作業履歴・日次メールの後続実装まで)。
更新日:2026-11-08。全体照合基準は `e65ca56`(作業履歴・日次メールの後続実装まで)。
RSS-01はその後の内蔵reader・FreshRSS読取・共通UI実装まで個別更新。
設計書の大項目をそのまま未実装機能と数えず、既存機能の続きとして着手できる単位に整理する。
実装順は本書、個別契約はリンク先、過去の経緯は[原ロードマップ](../implementation-roadmap.md)と
[実装記録](../implementation-status.md)を参照する。将来の更新でも以下のIDを再利用する。
@@ -110,7 +111,7 @@ P0は認可・整合性・復旧の安全条件、P1は日常利用の回復性
| ID / 優先 | 状態・次の作業 | 着手ゲート・最初の検証 | 詳細 |
| --- | --- | --- | --- |
| RSS-01 / P2 | 未実装・役割決定済み:内蔵簡易正本+本格運用のFreshRSS正本 | 共通UI、合成fixture→Wiki保存・タスク化。FreshRSSの接続先・版を指定して受入。newsboatは同じFreshRSSへ接続。二重正本・停止時の自動切替なし | [RSS](feeds.md) |
| RSS-01 / P2 | 一部実装:内蔵簡易正本、FreshRSS読取connector、3ペインUI・キー操作、Wiki保存・タスク化・dashboard | 残件はOPML、FreshRSS既読/star書戻し、実接続受入、公平性/backoff。managed schema feeds v1・隔離fixture。本番未反映。二重正本・停止時の自動切替なし | [RSS](feeds.md) |
| IMAP-01 / P3 | 未実装・選定待ち:IMAP読取同期 | provider/認証/保持を決める。UIDVALIDITY/UID、添付量、外部画像、失効をfixture化。neomutt captureは実装済みで別 | [メール](mail.md) |
| TICKET-01 / P3 | 未実装:queue/番号/workflow/外部依頼者 | 共有範囲と状態遷移を定義、同時採番・失効・監査。既存個人タスクをticketと呼び替えない | [タスクとticket](tasks-tickets.md) |
| EXT-01 / P3 | built-inのみ:第三者manifest/署名/隔離runtime、停止・rollback・観測 | capability・secret・host・予算・export契約。任意コードをGoプロセス内へ直接ロードしない | [拡張](extensions.md) |
+1
View File
@@ -21,6 +21,7 @@ type Manifest struct {
func Catalog() []Manifest {
return []Manifest{
{ID: "organizer.feeds", APIVersion: 1, Version: "0.1.0", Kind: "feeds", Scope: "domain", NameKey: "feeds.title", DescriptionKey: "feeds.help", Capabilities: []string{"feeds.own.read", "feeds.own.write"}, Events: []string{"feed.source.sync"}, SettingsPanel: "extensions", Builtin: true, Enabled: true, ResourceClass: "background+network+index"},
{ID: "organizer.contacts", APIVersion: 1, Version: "0.2.0", Kind: "contacts", Scope: "domain", NameKey: "contacts.title", DescriptionKey: "contacts.help", Capabilities: []string{"contacts.own.read", "contacts.own.write"}, Events: []string{}, SettingsPanel: "extensions", Builtin: true, Enabled: true, ResourceClass: "foreground+index"},
{ID: "organizer.tasks", APIVersion: 1, Version: "0.14.0", Kind: "tasks", Scope: "domain", NameKey: "tasks.title", DescriptionKey: "tasks.help", Capabilities: []string{"tasks.own.read", "tasks.own.write"}, Events: []string{"organizer.task.changed", "organizer.project.changed", "task.digest.deliver"}, SettingsPanel: "extensions", Builtin: true, Enabled: true, ResourceClass: "foreground+background+index"},
{ID: "organizer.calendar", APIVersion: 1, Version: "0.2.0", Kind: "calendar", Scope: "domain", NameKey: "calendar.title", DescriptionKey: "calendar.help", Capabilities: []string{"calendar.read", "calendar.write"}, Events: []string{}, SettingsPanel: "extensions", Builtin: true, Enabled: true, ResourceClass: "foreground+index"},
+1
View File
@@ -16,6 +16,7 @@ func (s *Server) registeredEventHandlers() *dregarnuhr.Registry {
s.eventHandlersOnce.Do(func() {
registry := &dregarnuhr.Registry{}
handlers := map[string]dregarnuhr.Handler{
store.FeedSyncEventType: s.syncFeedSources,
store.TaskDigestEventType: s.deliverTaskDigests,
store.NotificationPushEventType: func(ctx context.Context, job *store.EventJob) error {
return s.deliverNotificationPushContext(ctx, job)
+3
View File
@@ -58,6 +58,9 @@ func (s *Server) startEventScheduler() {
if s.store == nil {
return
}
if err := s.store.EnsureFeedEvent(); err != nil {
log.Printf("feed scheduler initialization failed")
}
if err := s.store.EnsureBuiltinResourceEvent(); err != nil {
log.Printf("resource monitor initialization failed: %v", err)
}
+202
View File
@@ -0,0 +1,202 @@
package server
import (
"net/http"
"net/url"
"strconv"
"strings"
"github.com/google/uuid"
"pageswiki/internal/store"
)
const feedsAPI = "/_/api/v1/extension/organizer.feeds/"
func feedRoute(p string) bool { return p == "/v/feeds" || strings.HasPrefix(p, feedsAPI) }
func (s *Server) handleFeeds(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Cache-Control", "private, no-store")
domain := s.domainUUIDForRequest(r)
if !s.systemExtensionEnabled(domain, "organizer.feeds") {
http.NotFound(w, r)
return
}
actor, active := s.calendarActor(r)
if actor == "" {
s.authRequired(w, r)
return
}
if r.Method != "GET" && r.Method != "HEAD" && !active {
taskError(w, store.ErrAccessDenied)
return
}
if r.URL.Path == "/v/feeds" {
if r.Method != "GET" && r.Method != "HEAD" {
w.WriteHeader(405)
return
}
if _, e := s.store.FeedSources(r.Context(), domain, actor); e != nil {
taskError(w, e)
return
}
s.renderWithContext(w, r, "feeds.gohtml", map[string]any{"Title": "RSS", "FeedWritable": active})
return
}
key := strings.TrimPrefix(r.URL.Path, feedsAPI)
switch {
case key == "note" && r.Method == "POST":
var input struct {
RequestID string `json:"request_id"`
Source string `json:"source"`
ID string `json:"id"`
Path string `json:"path"`
Title string `json:"title"`
Body string `json:"body"`
Confirm bool `json:"confirm_publication"`
}
if !taskJSONLimit(w, r, &input, 128<<10) {
return
}
if !input.Confirm {
taskError(w, store.ErrTaskInvalid)
return
}
for _, capability := range []string{"read", "create", "write"} {
if s.authorizePathRequest(r, capability, input.Path) != nil {
taskError(w, store.ErrAccessDenied)
return
}
}
page, e := s.store.CaptureFeedNote(r.Context(), domain, actor, input.RequestID, input.Source, input.ID, input.Path, input.Title, input.Body)
if e != nil {
taskError(w, e)
return
}
writeEventJSON(w, 201, map[string]string{"page_uuid": page})
return
case key == "sources" && r.Method == "GET":
sources, e := s.store.FeedSources(r.Context(), domain, actor)
if e != nil {
taskError(w, e)
return
}
writeEventJSON(w, 200, map[string]any{"sources": sources})
return
case key == "sources" && r.Method == "POST":
var input struct {
store.FeedSource
Username string `json:"username"`
Password string `json:"password"`
}
if !taskJSON(w, r, &input) {
return
}
if !validCalendarSourceURL(input.URL) || len(input.Username) > 256 || len(input.Password) > 4096 {
taskError(w, store.ErrTaskInvalid)
return
}
if input.Provider == "freshrss" {
u, _ := url.Parse(input.URL)
if u.RawQuery != "" || !strings.HasSuffix(strings.TrimRight(u.Path, "/"), "/greader.php") {
taskError(w, store.ErrTaskInvalid)
return
}
}
if input.UUID == "" {
input.UUID = uuid.NewString()
}
if input.Version == 0 && input.Provider == "freshrss" {
if input.Username == "" || input.Password == "" {
taskError(w, store.ErrTaskInvalid)
return
}
cipher, e := s.store.SealFeedCredential(domain, actor, input.UUID, input.Username, input.Password)
if e != nil {
taskError(w, e)
return
}
input.Credential = cipher
} else if input.Username != "" || input.Password != "" {
taskError(w, store.ErrTaskInvalid)
return
}
v, e := s.store.SaveFeedSource(r.Context(), domain, actor, input.FeedSource)
if e != nil {
taskError(w, e)
return
}
writeEventJSON(w, 200, map[string]any{"source": v})
return
case strings.HasPrefix(key, "sources/") && r.Method == "POST":
parts := strings.Split(key, "/")
if len(parts) != 3 {
http.NotFound(w, r)
return
}
var input struct {
Version int64 `json:"version"`
}
if !taskJSON(w, r, &input) {
return
}
if e := s.store.FeedSourceAction(r.Context(), domain, actor, parts[1], parts[2], input.Version); e != nil {
taskError(w, e)
return
}
writeEventJSON(w, 200, map[string]bool{"ok": true})
return
case key == "items" && r.Method == "GET":
q := r.URL.Query()
before := int64(-1)
if q.Has("before") {
var e error
before, e = strconv.ParseInt(q.Get("before"), 10, 64)
if e != nil || before < 0 {
taskError(w, store.ErrTaskInvalid)
return
}
}
items, e := s.store.FeedItems(r.Context(), domain, actor, q.Get("source"), q.Get("filter"), q.Get("q"), before, q.Get("key"))
if e != nil {
taskError(w, e)
return
}
more := len(items) > 100
if more {
items = items[:100]
}
writeEventJSON(w, 200, map[string]any{"items": items, "more": more})
return
case key == "item" && r.Method == "GET":
v, e := s.store.FeedItem(r.Context(), domain, actor, r.URL.Query().Get("source"), r.URL.Query().Get("id"))
if e != nil {
taskError(w, e)
return
}
writeEventJSON(w, 200, map[string]any{"item": v})
return
case key == "state" && r.Method == "POST":
var input struct {
Source string `json:"source"`
ID string `json:"id"`
Read bool `json:"read"`
Starred bool `json:"starred"`
Version int64 `json:"version"`
}
if !taskJSON(w, r, &input) {
return
}
if e := s.store.SetFeedState(r.Context(), domain, actor, input.Source, input.ID, input.Read, input.Starred, input.Version); e != nil {
taskError(w, e)
return
}
writeEventJSON(w, 200, map[string]any{"version": input.Version + 1})
return
}
http.NotFound(w, r)
}
func init() {
translations["en"]["feeds.title"] = "RSS reader"
translations["ja"]["feeds.title"] = "RSSリーダー"
translations["en"]["feeds.help"] = "Private local feeds and read-only FreshRSS integration"
translations["ja"]["feeds.help"] = "個人用の簡易RSSとFreshRSS読取連携"
}
+414
View File
@@ -0,0 +1,414 @@
package server
import (
"bytes"
"context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"encoding/xml"
"errors"
"fmt"
"html"
"io"
"net/http"
"net/url"
"strconv"
"strings"
"time"
"unicode/utf8"
"github.com/microcosm-cc/bluemonday"
"golang.org/x/net/html/charset"
"pageswiki/internal/store"
)
var errFeedInvalid = errors.New("invalid_feed")
var feedTextPolicy = bluemonday.StrictPolicy()
func feedText(raw string, limit int) string {
// Text-only reader: no remote images, CSS, script, macros or active HTML.
for _, tag := range []string{"</p>", "</div>", "<br>", "<br/>", "<br />", "</li>"} {
raw = strings.ReplaceAll(raw, tag, tag+"\n")
}
text := strings.TrimSpace(html.UnescapeString(feedTextPolicy.Sanitize(raw)))
if len(text) > limit {
text = text[:limit-16]
for !utf8.ValidString(text) {
text = text[:len(text)-1]
}
text += "\n[… truncated]"
}
return text
}
func feedLink(base, raw string) string {
if strings.TrimSpace(raw) == "" || len(raw) > 4096 {
return ""
}
u, e := url.Parse(strings.TrimSpace(raw))
if e != nil {
return ""
}
b, e := url.Parse(base)
if e != nil {
return ""
}
u = b.ResolveReference(u)
if (u.Scheme != "https" && u.Scheme != "http") || u.Hostname() == "" || u.User != nil {
return ""
}
result := u.String()
if len(result) > 4096 {
return ""
}
return result
}
func feedDate(v string) int64 {
for _, layout := range []string{time.RFC3339Nano, time.RFC1123Z, time.RFC1123, time.RFC822Z, time.RFC822, "2006-01-02T15:04:05-0700"} {
if t, e := time.Parse(layout, v); e == nil && t.UnixMilli() > 0 && t.Before(time.Now().AddDate(1, 0, 0)) {
return t.UnixMilli()
}
}
return 0
}
type rssEntry struct {
ID string `xml:"guid"`
Title string `xml:"title"`
Link string `xml:"link"`
Description string `xml:"description"`
Content string `xml:"encoded"`
Date string `xml:"pubDate"`
Category string `xml:"category"`
}
type atomEntry struct {
ID string `xml:"id"`
Title string `xml:"title"`
Links []struct {
Href string `xml:"href,attr"`
Rel string `xml:"rel,attr"`
} `xml:"link"`
Summary string `xml:"summary"`
Content struct {
Text string `xml:",chardata"`
Inner string `xml:",innerxml"`
} `xml:"content"`
Published string `xml:"published"`
Updated string `xml:"updated"`
Category struct {
Term string `xml:"term,attr"`
} `xml:"category"`
}
func parseFeed(raw []byte, base string) ([]store.FeedItem, error) {
if len(raw) > 4<<20 {
return nil, errors.New("limit")
}
d := xml.NewDecoder(bytes.NewReader(raw))
d.CharsetReader = charset.NewReaderLabel
root := ""
title := ""
depth := 0
out := []store.FeedItem{}
seen := map[string]bool{}
for {
tok, e := d.Token()
if e == io.EOF {
break
}
if e != nil {
return nil, errFeedInvalid
}
switch t := tok.(type) {
case xml.Directive:
return nil, errFeedInvalid // DTD/entities have no role in a feed.
case xml.StartElement:
depth++
if depth == 1 && root != "" {
return nil, errFeedInvalid
}
if depth > 64 {
return nil, errFeedInvalid
}
if root == "" {
root = t.Name.Local
if root != "rss" && root != "feed" {
return nil, errFeedInvalid
}
}
var item store.FeedItem
isItem := false
if root == "rss" && t.Name.Local == "item" && depth == 3 {
var v rssEntry
if d.DecodeElement(&v, &t) != nil {
return nil, errFeedInvalid
}
depth--
body := v.Content
if body == "" {
body = v.Description
}
item = store.FeedItem{ID: v.ID, Title: v.Title, URL: feedLink(base, v.Link), Body: body, PublishedMS: feedDate(v.Date), Folder: v.Category}
isItem = true
} else if root == "feed" && t.Name.Local == "entry" && depth == 2 {
var v atomEntry
if d.DecodeElement(&v, &t) != nil {
return nil, errFeedInvalid
}
depth--
body := v.Content.Text
if body == "" {
body = v.Content.Inner
}
if body == "" {
body = v.Summary
}
link := ""
for _, l := range v.Links {
if l.Rel == "" || l.Rel == "alternate" {
link = feedLink(base, l.Href)
break
}
}
date := v.Published
if date == "" {
date = v.Updated
}
item = store.FeedItem{ID: v.ID, Title: v.Title, URL: link, Body: body, PublishedMS: feedDate(date), Folder: v.Category.Term}
isItem = true
} else if t.Name.Local == "title" && ((root == "rss" && depth == 3) || (root == "feed" && depth == 2)) {
if d.DecodeElement(&title, &t) != nil {
return nil, errFeedInvalid
}
depth--
}
if isItem {
if len(out) >= 500 {
return nil, errors.New("limit")
}
item.Title = feedText(item.Title, 2048)
item.Body = feedText(item.Body, 32768)
item.Feed = feedText(title, 512)
item.Folder = feedText(item.Folder, 512)
if item.ID == "" {
key := item.URL
if key == "" {
key = item.Title + "\x00" + strconv.FormatInt(item.PublishedMS, 10) + "\x00" + item.Body
}
h := sha256.Sum256([]byte(key))
item.ID = "sha256:" + hex.EncodeToString(h[:])
}
if len(item.ID) > 1024 || seen[item.ID] {
return nil, errFeedInvalid
}
seen[item.ID] = true
out = append(out, item)
}
case xml.EndElement:
depth--
}
}
if root == "" || depth != 0 {
return nil, errFeedInvalid
}
return out, nil
}
func feedRequest(ctx context.Context, client *http.Client, method, target, auth string, form url.Values, headers map[string]string) ([]byte, http.Header, int, error) {
var body io.Reader
if form != nil {
body = strings.NewReader(form.Encode())
}
r, e := http.NewRequestWithContext(ctx, method, target, body)
if e != nil {
return nil, nil, 0, errFeedInvalid
}
if auth != "" {
r.Header.Set("Authorization", "GoogleLogin auth="+auth)
}
if form != nil {
r.Header.Set("Content-Type", "application/x-www-form-urlencoded")
}
r.Header.Set("User-Agent", "PagesWiki-Feeds/0.1")
for k, v := range headers {
r.Header.Set(k, v)
}
res, e := client.Do(r)
if e != nil {
return nil, nil, 0, errors.New("network")
}
defer res.Body.Close()
if res.StatusCode == 401 || res.StatusCode == 403 {
return nil, nil, res.StatusCode, errors.New("credentials")
}
if res.StatusCode == 304 {
return nil, res.Header, 304, nil
}
if res.StatusCode != 200 {
return nil, nil, res.StatusCode, errors.New("remote_error")
}
raw, e := io.ReadAll(io.LimitReader(res.Body, (4<<20)+1))
if e != nil {
return nil, nil, 0, errors.New("network")
}
if len(raw) > 4<<20 {
return nil, nil, 0, errors.New("limit")
}
return raw, res.Header, res.StatusCode, nil
}
func fetchFreshRSS(ctx context.Context, client *http.Client, v store.FeedSource, user, password string) ([]store.FeedItem, error) {
base := strings.TrimRight(v.URL, "/")
raw, _, _, e := feedRequest(ctx, client, "POST", base+"/accounts/ClientLogin", "", url.Values{"Email": {user}, "Passwd": {password}}, nil)
if e != nil {
return nil, e
}
auth := ""
for _, line := range strings.Split(string(raw), "\n") {
if strings.HasPrefix(line, "Auth=") {
auth = strings.TrimSpace(strings.TrimPrefix(line, "Auth="))
}
}
if auth == "" || len(auth) > 4096 || strings.ContainsAny(auth, "\r\n") {
return nil, errors.New("credentials")
}
raw, _, _, e = feedRequest(ctx, client, "GET", base+"/reader/api/0/stream/contents/reading-list?output=json&n=200", auth, nil, nil)
if e != nil {
return nil, e
}
var response struct {
Items []struct {
ID string `json:"id"`
Title string `json:"title"`
Published int64 `json:"published"`
Categories []string `json:"categories"`
Origin struct {
Title string `json:"title"`
} `json:"origin"`
Alternate []struct {
Href string `json:"href"`
} `json:"alternate"`
Summary struct {
Content string `json:"content"`
} `json:"summary"`
Content struct {
Content string `json:"content"`
} `json:"content"`
} `json:"items"`
}
if json.Unmarshal(raw, &response) != nil || response.Items == nil || len(response.Items) > 200 {
return nil, errFeedInvalid
}
out := []store.FeedItem{}
seen := map[string]bool{}
for _, i := range response.Items {
if i.ID == "" || len(i.ID) > 1024 || seen[i.ID] {
return nil, errFeedInvalid
}
seen[i.ID] = true
item := store.FeedItem{ID: i.ID, Title: feedText(i.Title, 2048), Feed: feedText(i.Origin.Title, 512)}
if i.Published > 0 && i.Published < time.Now().AddDate(1, 0, 0).Unix() {
item.PublishedMS = i.Published * 1000
}
body := i.Summary.Content
if body == "" {
body = i.Content.Content
}
item.Body = feedText(body, 32768)
if len(i.Alternate) > 0 {
item.URL = feedLink(base, i.Alternate[0].Href)
}
for _, c := range i.Categories {
if strings.HasSuffix(c, "/state/com.google/read") {
item.Read = true
}
if strings.HasSuffix(c, "/state/com.google/starred") {
item.Starred = true
}
if pos := strings.Index(c, "/label/"); pos >= 0 {
item.Folder = feedText(c[pos+7:], 512)
}
}
out = append(out, item)
}
return out, nil
}
func (s *Server) syncFeedSources(ctx context.Context, job *store.EventJob) error {
client := calendarSourceClient()
client.CheckRedirect = func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }
defer client.CloseIdleConnections()
return s.syncFeedSourcesWithClient(ctx, job, client)
}
// Tests inject a synthetic transport; production always uses the DNS-pinned,
// public HTTPS-only transport above, never a user-configurable HTTP client.
func (s *Server) syncFeedSourcesWithClient(ctx context.Context, job *store.EventJob, client *http.Client) error {
ctx, cancel := context.WithTimeout(ctx, 35*time.Second)
defer cancel()
sources, e := s.store.DueFeedSources(ctx)
if e != nil {
return e
}
done, failed := 0, 0
for _, v := range sources {
if ctx.Err() != nil {
break
}
if !s.systemExtensionEnabled(v.Domain, "organizer.feeds") {
continue
}
v, e = s.store.ClaimFeed(ctx, v)
if e != nil {
continue
}
child, stop := context.WithTimeout(ctx, 8*time.Second)
var items []store.FeedItem
etag, modified := v.ETag, v.Modified
unchanged := false
if !validCalendarSourceURL(v.URL) {
e = errFeedInvalid
} else if v.Provider == "freshrss" {
var user, password string
user, password, e = s.store.OpenFeedCredential(v)
if e == nil {
items, e = fetchFreshRSS(child, client, v, user, password)
} else {
e = errors.New("credentials")
}
} else {
var raw []byte
var h http.Header
var status int
raw, h, status, e = feedRequest(child, client, "GET", v.URL, "", nil, map[string]string{"If-None-Match": v.ETag, "If-Modified-Since": v.Modified})
if e == nil {
unchanged = status == 304
if !unchanged {
items, e = parseFeed(raw, v.URL)
etag, modified = h.Get("ETag"), h.Get("Last-Modified")
}
}
}
stop()
if e == nil && (len(etag) > 1024 || len(modified) > 1024) {
e = errors.New("limit")
etag, modified = v.ETag, v.Modified
items = nil
}
code := ""
if e != nil {
code = e.Error()
switch code {
case "network", "invalid_feed", "credentials", "remote_error", "limit":
default:
code = "invalid_feed"
}
failed++
} else {
done++
}
if e = s.store.CompleteFeed(ctx, v, items, etag, modified, code, unchanged); e != nil && !errors.Is(e, store.ErrAccessDenied) && !errors.Is(e, store.ErrTaskConflict) {
return e
}
}
s.addEventProgressLog(ctx, job, fmt.Sprintf("feed sources updated=%d failed=%d", done, failed))
return nil
}
+535
View File
@@ -0,0 +1,535 @@
package server
import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"net/http/httptest"
"net/url"
"os"
"os/exec"
"strings"
"testing"
"time"
"github.com/google/uuid"
"pageswiki/internal/store"
)
func feedFixture(t *testing.T) (*Server, string, string, string, store.FeedSource) {
t.Helper()
s, token, domain, actor := taskFixture(t)
source, e := s.store.SaveFeedSource(context.Background(), domain, actor, store.FeedSource{UUID: uuid.NewString(), Provider: "local", Title: "Synthetic news", Folder: "Tech", URL: "https://example.org/feed.xml", Enabled: true, Interval: 300})
if e != nil {
t.Fatal(e)
}
sources, e := s.store.FeedSources(context.Background(), domain, actor)
if e != nil || len(sources) != 1 {
t.Fatal(e)
}
source = sources[0]
return s, token, domain, actor, source
}
func feedRequestTest(s *Server, token, method, key string, body any) *httptest.ResponseRecorder {
raw, _ := json.Marshal(body)
r := httptest.NewRequest(method, "http://localhost"+feedsAPI+key, strings.NewReader(string(raw)))
r.Header.Set("Content-Type", "application/json")
if token != "" {
r.Header.Set("Authorization", "Bearer "+token)
}
w := httptest.NewRecorder()
s.withAuthorization(s.mux).ServeHTTP(w, r)
return w
}
func TestFeedReaderStateIsolationAndFencing(t *testing.T) {
s, token, domain, actor, source := feedFixture(t)
ctx := context.Background()
claim, e := s.store.ClaimFeed(ctx, source)
if e != nil {
t.Fatal(e)
}
if _, e = s.store.ClaimFeed(ctx, source); !errors.Is(e, store.ErrTaskConflict) {
t.Fatal("double claim", e)
}
item := store.FeedItem{ID: "one", Title: "日本語 news", Body: "safe text", URL: "https://example.org/one", PublishedMS: 1}
if e = s.store.CompleteFeed(ctx, claim, []store.FeedItem{item}, "e1", "", "", false); e != nil {
t.Fatal(e)
}
if w := feedRequestTest(s, token, "GET", "items", nil); w.Code != 200 || !strings.Contains(w.Body.String(), "日本語") {
t.Fatal(w.Code, w.Body)
}
if w := feedRequestTest(s, "", "GET", "items", nil); w.Code == 200 {
t.Fatal("anonymous")
}
if _, e = s.store.FeedItem(ctx, domain, uuid.NewString(), source.UUID, "one"); !errors.Is(e, store.ErrAccessDenied) {
t.Fatal(e)
}
state := map[string]any{"source": source.UUID, "id": "one", "read": true, "starred": true, "version": 0}
if w := feedRequestTest(s, token, "POST", "state", state); w.Code != 200 {
t.Fatal(w.Code, w.Body)
}
if w := feedRequestTest(s, token, "POST", "state", state); w.Code != 412 {
t.Fatal("stale state", w.Code, w.Body)
}
got, e := s.store.FeedItem(ctx, domain, actor, source.UUID, "one")
if e != nil || !got.Read || !got.Starred || got.Version != 1 {
t.Fatal(got, e)
}
if e = s.store.CompleteFeed(ctx, claim, nil, "", "", "", false); !errors.Is(e, store.ErrTaskConflict) {
t.Fatal("old completion", e)
}
// Re-fetch must preserve local read/star; config edits invalidate in-flight work.
source.Version = 1
source, e = s.store.SaveFeedSource(ctx, domain, actor, source)
if e != nil {
t.Fatal(e)
}
sources, _ := s.store.FeedSources(ctx, domain, actor)
claim, e = s.store.ClaimFeed(ctx, sources[0])
if e != nil {
t.Fatal(e)
}
if e = s.store.CompleteFeed(ctx, claim, []store.FeedItem{item}, "", "", "", false); e != nil {
t.Fatal(e)
}
got, _ = s.store.FeedItem(ctx, domain, actor, source.UUID, "one")
if !got.Read || !got.Starred {
t.Fatal("lost state")
}
source, e = s.store.SaveFeedSource(ctx, domain, actor, source)
if e != nil {
t.Fatal(e)
}
sources, _ = s.store.FeedSources(ctx, domain, actor)
claim, e = s.store.ClaimFeed(ctx, sources[0])
if e != nil {
t.Fatal(e)
}
source.Enabled = false
source, e = s.store.SaveFeedSource(ctx, domain, actor, source)
if e != nil {
t.Fatal(e)
}
if e = s.store.CompleteFeed(ctx, claim, []store.FeedItem{item}, "", "", "", false); !errors.Is(e, store.ErrTaskConflict) {
t.Fatal("disabled late commit", e)
}
if e = s.setSystemExtensionEnabled(domain, "organizer.feeds", false); e != nil {
t.Fatal(e)
}
if _, e = s.store.FeedItems(ctx, domain, actor, "", "", "", -1, ""); !errors.Is(e, store.ErrAccessDenied) {
t.Fatal(e)
}
if w := feedRequestTest(s, token, "GET", "items", nil); w.Code != 404 {
t.Fatal(w.Code)
}
}
func TestFeedParserSafetyAndFormats(t *testing.T) {
rss := `<?xml version="1.0"?><rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>News</title><item><guid>id</guid><title>日本語</title><link>/one</link><content:encoded><![CDATA[<p>Hello</p><script>alert(1)</script><img src="https://evil.invalid/pixel"><b>world</b>]]></content:encoded><pubDate>Fri, 06 Nov 2026 10:00:00 +0000</pubDate></item></channel></rss>`
items, e := parseFeed([]byte(rss), "https://example.org/feed")
if e != nil || len(items) != 1 || items[0].URL != "https://example.org/one" || strings.Contains(items[0].Body, "alert") || strings.Contains(items[0].Body, "pixel") || items[0].PublishedMS == 0 {
t.Fatal(items, e)
}
atom := `<feed xmlns="http://www.w3.org/2005/Atom"><title>Atom</title><entry><id>urn:one</id><title>One</title><link href="https://example.org/one"/><updated>2026-11-01T10:00:00Z</updated><content type="html">&lt;p&gt;Body&lt;/p&gt;</content></entry></feed>`
items, e = parseFeed([]byte(atom), "https://example.org")
if e != nil || len(items) != 1 || items[0].Body != "Body" {
t.Fatal(items, e)
}
for _, raw := range []string{`<!DOCTYPE rss [<!ENTITY x SYSTEM "file:///etc/passwd">]><rss/>`, `<html>error</html>`, `<rss/><rss/>`, `<rss><channel><item><guid>x</guid></item><item><guid>x</guid></item></channel></rss>`, strings.Repeat("x", (4<<20)+1)} {
if _, e = parseFeed([]byte(raw), "https://example.org"); e == nil {
t.Fatal("accepted malformed feed")
}
}
if feedLink("https://example.org", "javascript:alert(1)") != "" || feedLink("https://example.org", "https://user:pass@example.org") != "" {
t.Fatal("unsafe link")
}
items, e = parseFeed([]byte(`<rss><channel><item><title>No ID or link</title><description>First body</description></item><item><title>No ID or link</title><description>Second body</description></item></channel></rss>`), "https://example.org/feed")
if e != nil || len(items) != 2 || items[0].ID == items[1].ID || items[0].URL != "" {
t.Fatal("missing IDs must not collapse to the feed URL", items, e)
}
}
func TestFreshRSSReadOnlyContract(t *testing.T) {
requests := []string{}
remote := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
requests = append(requests, r.Method+" "+r.URL.Path)
switch r.URL.Path {
case "/api/greader.php/accounts/ClientLogin":
if r.Method != "POST" {
t.Error("login method")
}
r.ParseForm()
if r.Form.Get("Email") != "reader" || r.Form.Get("Passwd") != "api-secret" {
t.Error("login form")
}
fmt.Fprint(w, "SID=x\nAuth=reader/token\n")
case "/api/greader.php/reader/api/0/stream/contents/reading-list":
if r.Header.Get("Authorization") != "GoogleLogin auth=reader/token" || r.URL.Query().Get("n") != "200" {
t.Error("request contract")
}
fmt.Fprint(w, `{"items":[{"id":"tag:1","title":"Title","summary":{"content":"<p>Text</p>"},"published":1793500000,"categories":["user/reader/state/com.google/read","user/reader/state/com.google/starred","user/reader/label/Tech"],"origin":{"title":"Feed"},"alternate":[{"href":"https://example.org/article"}]}]}`)
default:
t.Error("unexpected mutation", r.URL.Path)
w.WriteHeader(404)
}
}))
defer remote.Close()
items, e := fetchFreshRSS(context.Background(), remote.Client(), store.FeedSource{URL: remote.URL + "/api/greader.php"}, "reader", "api-secret")
if e != nil || len(items) != 1 || !items[0].Read || !items[0].Starred || items[0].Folder != "Tech" || items[0].Body != "Text" || len(requests) != 2 {
t.Fatal(items, e, requests)
}
for _, bad := range []string{"http://example.org/feed", "https://127.0.0.1/feed", "https://10.0.0.1/feed", "https://example.org:8443/feed", "https://user:pass@example.org/feed"} {
if validCalendarSourceURL(bad) {
t.Fatal("SSRF URL", bad)
}
}
}
func TestFeedPaginationFailureAndDelete(t *testing.T) {
s, token, domain, actor, source := feedFixture(t)
ctx := context.Background()
claim, e := s.store.ClaimFeed(ctx, source)
if e != nil {
t.Fatal(e)
}
items := []store.FeedItem{}
for i := 0; i < 205; i++ {
items = append(items, store.FeedItem{ID: fmt.Sprintf("id-%03d", i), Title: "Title", Body: "Body", PublishedMS: 100})
}
if e = s.store.CompleteFeed(ctx, claim, items, "old", "", "", false); e != nil {
t.Fatal(e)
}
seen := map[string]bool{}
before := int64(-1)
key := ""
for {
batch, e := s.store.FeedItems(ctx, domain, actor, "", "", "", before, key)
if e != nil {
t.Fatal(e)
}
more := len(batch) > 100
if more {
batch = batch[:100]
}
for _, item := range batch {
if seen[item.ID] {
t.Fatal("duplicate")
}
seen[item.ID] = true
}
if !more {
break
}
last := batch[len(batch)-1]
before = last.PublishedMS
key = last.Source + ":" + last.ID
}
if len(seen) != 205 {
t.Fatal(len(seen))
}
source, e = s.store.SaveFeedSource(ctx, domain, actor, source)
if e != nil {
t.Fatal(e)
}
sources, _ := s.store.FeedSources(ctx, domain, actor)
claim, e = s.store.ClaimFeed(ctx, sources[0])
if e != nil {
t.Fatal(e)
}
if e = s.store.CompleteFeed(ctx, claim, nil, "", "", "network", false); e != nil {
t.Fatal(e)
}
if _, e = s.store.FeedItem(ctx, domain, actor, source.UUID, "id-001"); e != nil {
t.Fatal("cache lost on failure", e)
}
if w := feedRequestTest(s, token, "POST", "sources/"+source.UUID+"/delete", map[string]int64{"version": source.Version}); w.Code != 200 {
t.Fatal(w.Code, w.Body)
}
var count int
if e = s.store.DB.QueryRow(`SELECT count(*) FROM feed_items`).Scan(&count); e != nil || count != 0 {
t.Fatal("cascade", count, e)
}
var integrity string
if e = s.store.DB.QueryRow(`PRAGMA integrity_check`).Scan(&integrity); e != nil || integrity != "ok" {
t.Fatal(integrity, e)
}
}
func TestFeedSourceAPIAndCredentialBinding(t *testing.T) {
s, token, domain, actor, _ := feedFixture(t)
input := map[string]any{"uuid": uuid.NewString(), "provider": "freshrss", "title": "Remote", "url": "https://rss.example.org/api/greader.php", "interval_seconds": 300, "enabled": true, "username": "reader", "password": "top-secret"}
w := feedRequestTest(s, token, "POST", "sources", input)
if w.Code != 200 || strings.Contains(w.Body.String(), "secret") {
t.Fatal(w.Code, w.Body)
}
// Each HTTP retry seals a different ciphertext, but identical credentials and
// request UUID must still return the same source, not create a duplicate.
if retry := feedRequestTest(s, token, "POST", "sources", input); retry.Code != 200 || retry.Body.String() != w.Body.String() {
t.Fatal("source replay", retry.Code, retry.Body)
}
input["password"] = "changed-secret"
if retry := feedRequestTest(s, token, "POST", "sources", input); retry.Code != 412 {
t.Fatal("changed source replay", retry.Code, retry.Body)
}
input["password"] = "top-secret"
sources, e := s.store.FeedSources(context.Background(), domain, actor)
if e != nil {
t.Fatal(e)
}
if len(sources) != 2 {
t.Fatal("duplicate source", len(sources))
}
var remote store.FeedSource
for _, v := range sources {
if v.Provider == "freshrss" {
remote = v
}
}
u, p, e := s.store.OpenFeedCredential(remote)
if e != nil || u != "reader" || p != "top-secret" {
t.Fatal("credential", e)
}
remote.Owner = uuid.NewString()
if _, _, e = s.store.OpenFeedCredential(remote); e == nil {
t.Fatal("credential rebound")
}
if w = feedRequestTest(s, token, "GET", "sources", nil); w.Code != 200 || strings.Contains(w.Body.String(), "top-secret") || strings.Contains(w.Body.String(), "credential") {
t.Fatal(w.Code, w.Body)
}
input["url"] = "https://127.0.0.1/api/greader.php"
if w = feedRequestTest(s, token, "POST", "sources", input); w.Code != 422 {
t.Fatal(w.Code, w.Body)
}
}
func TestFeedFreshRSSAuthorityAndRevocation(t *testing.T) {
s, token, domain, actor, local := feedFixture(t)
ctx := context.Background()
v, e := s.store.SaveFeedSource(ctx, domain, actor, store.FeedSource{UUID: uuid.NewString(), Provider: "freshrss", Title: "FreshRSS", URL: "https://example.org/api/greader.php", Enabled: true, Interval: 300})
if e != nil {
t.Fatal(e)
}
claim := func() store.FeedSource {
t.Helper()
// Simulate the next scheduler tick without a wall-clock wait.
if _, err := s.store.DB.Exec(`UPDATE feed_sources SET next_ms=0 WHERE uuid=?`, v.UUID); err != nil {
t.Fatal(err)
}
all, err := s.store.FeedSources(ctx, domain, actor)
if err != nil {
t.Fatal(err)
}
for _, source := range all {
if source.UUID == v.UUID {
v = source
}
}
c, err := s.store.ClaimFeed(ctx, v)
if err != nil {
t.Fatal(err)
}
return c
}
c := claim()
if e = s.store.CompleteFeed(ctx, c, []store.FeedItem{{ID: "removed", Title: "Removed"}, {ID: "kept", Title: "Kept", Read: true, Starred: true}}, "", "", "", false); e != nil {
t.Fatal(e)
}
if e = s.store.SetFeedState(ctx, domain, actor, v.UUID, "kept", false, false, 0); !errors.Is(e, store.ErrAccessDenied) {
t.Fatal("remote state mutation", e)
}
c = claim()
if e = s.store.CompleteFeed(ctx, c, []store.FeedItem{{ID: "kept", Title: "Changed elsewhere", Read: false}}, "", "", "", false); e != nil {
t.Fatal(e)
}
items, e := s.store.FeedItems(ctx, domain, actor, v.UUID, "", "", -1, "")
if e != nil || len(items) != 1 || items[0].Read || items[0].Starred || items[0].Title != "Changed elsewhere" {
t.Fatal("non-authoritative cache", items, e)
}
c = claim()
if e = s.store.SetPrincipalState(domain, actor, "readonly"); e != nil {
t.Fatal(e)
}
// Changing principal state invalidates the previous session.
token, e = s.store.CreateAuthSession(domain, actor)
if e != nil {
t.Fatal(e)
}
if _, e = s.store.FeedItems(ctx, domain, actor, "", "", "", -1, ""); e != nil {
t.Fatal("readonly read", e)
}
if e = s.store.CompleteFeed(ctx, c, nil, "", "", "", false); !errors.Is(e, store.ErrAccessDenied) {
t.Fatal("late revoked worker", e)
}
if w := feedRequestTest(s, token, "POST", "sources/"+local.UUID+"/delete", map[string]int64{"version": 1}); w.Code != 403 {
t.Fatal("readonly API", w.Code, w.Body)
}
if due, err := s.store.DueFeedSources(ctx); err != nil || len(due) != 0 {
t.Fatal("inactive source starves queue", due, err)
}
if e = s.store.SetPrincipalState(domain, actor, "active"); e != nil {
t.Fatal(e)
}
if e = s.setSystemExtensionEnabled(domain, "organizer.feeds", false); e != nil {
t.Fatal(e)
}
if due, err := s.store.DueFeedSources(ctx); err != nil || len(due) != 0 {
t.Fatal("disabled extension starves queue", due, err)
}
}
func TestFeedNoteAtomicReceiptAndPermissions(t *testing.T) {
s, token, domain, _, source := feedFixture(t)
ctx := context.Background()
claim, e := s.store.ClaimFeed(ctx, source)
if e != nil {
t.Fatal(e)
}
if e = s.store.CompleteFeed(ctx, claim, []store.FeedItem{{ID: "note", Title: "Title", Body: "Body"}}, "", "", "", false); e != nil {
t.Fatal(e)
}
id := uuid.NewString()
input := map[string]any{"request_id": id, "source": source.UUID, "id": "note", "path": "/notes/rss-" + id, "title": "RSS title", "body": "Source: https://example.org\n{{children}} <script>bad()</script>", "confirm_publication": true}
w := feedRequestTest(s, token, "POST", "note", input)
if w.Code != 201 {
t.Fatal(w.Code, w.Body)
}
original := w.Body.String()
if w = feedRequestTest(s, token, "POST", "note", input); w.Code != 201 || w.Body.String() != original {
t.Fatal("replay", w.Code, w.Body)
}
var response map[string]string
json.Unmarshal(w.Body.Bytes(), &response)
rev, e := s.store.GetLatestRevision(response["page_uuid"])
if e != nil || strings.Contains(rev.Body, "{{children}}") || strings.Contains(rev.Body, "<script>") {
t.Fatal(rev, e)
}
input["body"] = "changed"
if w = feedRequestTest(s, token, "POST", "note", input); w.Code != 412 {
t.Fatal("changed replay", w.Code, w.Body)
}
input["request_id"] = uuid.NewString()
if w = feedRequestTest(s, token, "POST", "note", input); w.Code != 409 {
t.Fatal("path exists", w.Code, w.Body)
}
input["path"] = "/u/other/rss"
if w = feedRequestTest(s, token, "POST", "note", input); w.Code != 403 {
t.Fatal("reserved user space", w.Code, w.Body)
}
// Roll back page/path when the durable receipt cannot be committed.
if _, e = s.store.DB.Exec(`CREATE TRIGGER fail_feed_receipt BEFORE INSERT ON feed_note_receipts BEGIN SELECT RAISE(ABORT,'synthetic failure'); END`); e != nil {
t.Fatal(e)
}
input["path"] = "/notes/rollback"
if w = feedRequestTest(s, token, "POST", "note", input); w.Code != 500 {
t.Fatal(w.Code, w.Body)
}
var n int
if e = s.store.DB.QueryRow(`SELECT count(*) FROM paths WHERE domain_uuid=? AND path='/notes/rollback'`, domain).Scan(&n); e != nil || n != 0 {
t.Fatal("partial note", n, e)
}
}
type feedTransportFunc func(*http.Request) (*http.Response, error)
func (f feedTransportFunc) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) }
func TestFeedBackgroundConditionalFetch(t *testing.T) {
s, _, domain, actor, source := feedFixture(t)
ctx := context.Background()
step := 0
client := &http.Client{Transport: feedTransportFunc(func(r *http.Request) (*http.Response, error) {
step++
if r.URL.String() != source.URL || r.Method != "GET" {
t.Fatal("unexpected request", r.Method, r.URL)
}
deadline, ok := r.Context().Deadline()
if !ok || time.Until(deadline) > 8*time.Second {
t.Fatal("unbounded fetch")
}
switch step {
case 1:
return &http.Response{StatusCode: 200, Header: http.Header{"Etag": {`"feed-1"`}}, Body: io.NopCloser(strings.NewReader(`<rss><channel><item><guid>id</guid><title>First</title></item></channel></rss>`))}, nil
case 2:
if r.Header.Get("If-None-Match") != `"feed-1"` {
t.Fatal("missing conditional GET")
}
return &http.Response{StatusCode: 304, Header: http.Header{}, Body: io.NopCloser(strings.NewReader(""))}, nil
default:
return nil, errors.New("synthetic failure containing a secret URL; must not be persisted")
}
})}
for tick := 1; tick <= 3; tick++ {
if _, e := s.store.DB.Exec(`UPDATE feed_sources SET next_ms=0 WHERE uuid=?`, source.UUID); e != nil {
t.Fatal(e)
}
if e := s.syncFeedSourcesWithClient(ctx, &store.EventJob{UUID: uuid.NewString(), Type: store.FeedSyncEventType}, client); e != nil {
t.Fatal(e)
}
if step != tick {
t.Fatal("wrong fetch count", step, tick)
}
item, e := s.store.FeedItem(ctx, domain, actor, source.UUID, "id")
if e != nil || item.Title != "First" {
t.Fatal("cache not preserved", item, e)
}
all, e := s.store.FeedSources(ctx, domain, actor)
if e != nil || len(all) != 1 || all[0].ETag != `"feed-1"` || all[0].Lease != "" || all[0].NextMS <= time.Now().UnixMilli() {
t.Fatal("worker metadata", all, e)
}
if tick == 3 && all[0].Error != "network" {
t.Fatal("secret error leaked", all[0].Error)
}
if e := s.syncFeedSourcesWithClient(ctx, &store.EventJob{UUID: uuid.NewString()}, client); e != nil {
t.Fatal(e)
}
if step != tick {
t.Fatal("cooldown ignored")
}
}
}
func TestFeedsChromium(t *testing.T) {
if os.Getenv("PAGESWIKI_BROWSER_TEST") != "1" {
t.Skip("opt-in Chromium")
}
s, token, domain, actor, source := feedFixture(t)
claim, e := s.store.ClaimFeed(context.Background(), source)
if e != nil {
t.Fatal(e)
}
items := []store.FeedItem{}
for i := 0; i < 120; i++ {
items = append(items, store.FeedItem{ID: fmt.Sprint(i), Title: fmt.Sprintf("%03d 日本語のRSS記事 — リーダーの密度とキーボード操作", i), Body: "安全な本文です。\n\n<script>display as text</script> {{children}}\n\nSource content stays inert.", Feed: "技術ニュース", URL: "https://example.org/article", PublishedMS: int64(1793500000000 + i)})
}
if e = s.store.CompleteFeed(context.Background(), claim, items, "", "", "", false); e != nil {
t.Fatal(e)
}
_ = domain
_ = actor
s.store.BackgroundJobsDisabled = true
s = New(s.store)
script, e := os.ReadFile("internal/server/testdata/feeds.js")
if e != nil {
t.Fatal(e)
}
handler := s.handler()
web := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
r.Host = "localhost"
r.Header.Set("Authorization", "Bearer "+token)
if r.URL.Path == "/fixture" {
w.Header().Set("Content-Type", "text/html; charset=utf-8")
fmt.Fprint(w, "<!doctype html><body style='margin:0'><script>"+string(script)+"</script></body>")
return
}
handler.ServeHTTP(w, r)
}))
defer web.Close()
for _, width := range []string{"1440", "390"} {
ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
args := []string{"internal/server/testdata/vim-browser-smoke.mjs", web.URL + "/fixture?width=" + url.QueryEscape(width), t.TempDir(), "/tmp/pageswiki-feeds-" + width + ".png", width, "850"}
out, e := exec.CommandContext(ctx, "node", args...).CombinedOutput()
cancel()
if e != nil {
t.Fatalf("browser %s: %v %s", width, e, out)
}
}
}
+2
View File
@@ -93,6 +93,8 @@ func (s *Server) handleDashboardData(w http.ResponseWriter, r *http.Request, act
func organizerSection(path string) string {
switch {
case feedRoute(path):
return "feeds"
case path == "/v/plan/dashboard":
return "dashboard"
case strings.HasPrefix(path, "/-/sys/config"):
+1
View File
@@ -68,6 +68,7 @@ func (s *Server) renderWithContext(
data["CalendarEnabled"] = s.systemExtensionEnabled(domainUUID, "organizer.calendar")
data["TasksEnabled"] = s.systemExtensionEnabled(domainUUID, "organizer.tasks")
data["ContactsEnabled"] = s.systemExtensionEnabled(domainUUID, "organizer.contacts")
data["FeedsEnabled"] = s.systemExtensionEnabled(domainUUID, "organizer.feeds")
data["OrganizerSection"] = organizerSection(r.URL.Path)
if r.URL.Path == "/" {
data["IsHome"] = true
+5
View File
@@ -20,6 +20,9 @@ import (
const tasksAPI = "/_/api/v1/extension/organizer.tasks/"
func taskRoute(p string) bool {
if feedRoute(p) {
return true
}
if p == "/v/plan/dashboard" {
return true
}
@@ -30,6 +33,8 @@ func taskRoute(p string) bool {
}
func (s *Server) registerTaskRoutes() {
s.mux.HandleFunc("/v/feeds", s.handleFeeds)
s.mux.HandleFunc(feedsAPI, s.handleFeeds)
s.mux.HandleFunc("/v/plan/dashboard", s.handleOrganizerDashboard)
s.mux.HandleFunc(contactDAV, s.handleContactDAV)
s.mux.HandleFunc(strings.TrimSuffix(contactDAV, "/"), s.handleContactDAV)
+21
View File
@@ -0,0 +1,21 @@
(async()=>{
const delay=ms=>new Promise(r=>setTimeout(r,ms)),assert=(ok,msg)=>{if(!ok)throw Error(msg);};
const wait=async check=>{for(let i=0;i<200;i++){if(check())return;await delay(30);}throw Error('Timeout: '+check);};
const frame=document.createElement('iframe');frame.style='display:block;width:100%;height:100vh;border:0';document.body.append(frame);
try{
await new Promise(resolve=>{frame.onload=resolve;frame.src='/v/feeds';});const d=frame.contentDocument,w=frame.contentWindow;
await wait(()=>d.querySelectorAll('.feed-row').length===100);
assert(d.documentElement.scrollWidth<=w.innerWidth,'Viewport overflow');
d.getElementById('feed-rows').focus();d.dispatchEvent(new w.KeyboardEvent('keydown',{key:'j',bubbles:true}));
await wait(()=>d.querySelector('#feed-reader .feed-body'));assert(d.querySelector('#feed-reader .feed-body').textContent.includes('<script>'),'Text not preserved');assert(!d.querySelector('#feed-reader script'),'Active article HTML');
d.dispatchEvent(new w.KeyboardEvent('keydown',{key:'*',bubbles:true}));await wait(()=>d.querySelector('.feed-row[aria-selected=true]').textContent.includes('★'));
d.dispatchEvent(new w.KeyboardEvent('keydown',{key:'Escape',bubbles:true}));await wait(()=>!d.querySelector('.feed-layout').classList.contains('reading'));
d.getElementById('feed-more').click();await wait(()=>d.querySelectorAll('.feed-row').length===120);
d.dispatchEvent(new w.KeyboardEvent('keydown',{key:'/',bubbles:true}));await wait(()=>d.activeElement.type==='search');d.activeElement.value='119';d.activeElement.dispatchEvent(new w.Event('input',{bubbles:true}));await wait(()=>d.querySelectorAll('.feed-row').length===1);
d.querySelector('.feed-row').click();await wait(()=>d.querySelector('#feed-reader .feed-body'));
d.querySelector('#feed-reader .feed-actions button:last-child').click();await wait(()=>d.querySelector('#feed-reader form'));
const form=d.querySelector('#feed-reader form'),inputs=form.querySelectorAll('input');inputs[2].value='/notes/feed-ui';inputs[2].dispatchEvent(new w.Event('input'));inputs[5].checked=true;form.requestSubmit();await wait(()=>d.querySelector('#feed-reader a[href^="/v/uuid:"]'));
const search=d.querySelector('#feed-toolbar input');search.value='';search.dispatchEvent(new w.Event('input',{bubbles:true}));await wait(()=>d.querySelectorAll('.feed-row').length===100);d.querySelector('.feed-row').click();await wait(()=>d.querySelector('#feed-reader .feed-body'));
assert(d.documentElement.scrollWidth<=w.innerWidth,'Reader overflow');document.body.dataset.vimReady='1';
}catch(e){const out=document.createElement('pre');out.id='error';out.textContent=e.stack;document.body.append(out);}
})();
+451
View File
@@ -0,0 +1,451 @@
package store
import (
"context"
"crypto/sha256"
"database/sql"
"encoding/json"
"errors"
"fmt"
"strings"
"time"
"unicode/utf8"
"github.com/google/uuid"
"pageswiki/internal/db"
)
const FeedSyncEventType = "feed.source.sync"
var feedMigrations = []db.SQLMigration{{Version: 1, Name: "private_feed_reader", Statements: []string{
`CREATE TABLE feed_sources(uuid TEXT PRIMARY KEY,domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,provider TEXT NOT NULL CHECK(provider IN ('local','freshrss')),title TEXT NOT NULL,folder TEXT NOT NULL,url TEXT NOT NULL,credential TEXT NOT NULL DEFAULT '',version INTEGER NOT NULL,enabled INTEGER NOT NULL,interval_seconds INTEGER NOT NULL,next_ms INTEGER NOT NULL DEFAULT 0,lease TEXT NOT NULL DEFAULT '',lease_until INTEGER NOT NULL DEFAULT 0,last_ms INTEGER NOT NULL DEFAULT 0,error TEXT NOT NULL DEFAULT '',etag TEXT NOT NULL DEFAULT '',modified TEXT NOT NULL DEFAULT '')`,
`CREATE INDEX feed_sources_owner ON feed_sources(domain_uuid,owner_uuid,uuid)`,
`CREATE INDEX feed_sources_due ON feed_sources(enabled,next_ms,uuid)`,
`CREATE TABLE feed_items(source_uuid TEXT NOT NULL REFERENCES feed_sources(uuid) ON DELETE CASCADE,id TEXT NOT NULL,title TEXT NOT NULL,url TEXT NOT NULL,body TEXT NOT NULL,published_ms INTEGER NOT NULL,feed TEXT NOT NULL,folder TEXT NOT NULL,is_read INTEGER NOT NULL,starred INTEGER NOT NULL,PRIMARY KEY(source_uuid,id))`,
`CREATE INDEX feed_items_date ON feed_items(source_uuid,published_ms DESC,id DESC)`,
`CREATE TABLE feed_states(source_uuid TEXT NOT NULL REFERENCES feed_sources(uuid) ON DELETE CASCADE,id TEXT NOT NULL,is_read INTEGER NOT NULL,starred INTEGER NOT NULL,version INTEGER NOT NULL,PRIMARY KEY(source_uuid,id))`,
`CREATE TRIGGER feed_source_delete AFTER DELETE ON feed_sources BEGIN DELETE FROM feed_items WHERE source_uuid=old.uuid; DELETE FROM feed_states WHERE source_uuid=old.uuid; END`,
`CREATE TABLE feed_note_receipts(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,request_id TEXT NOT NULL,input_hash TEXT NOT NULL,page_uuid TEXT NOT NULL,PRIMARY KEY(domain_uuid,owner_uuid,request_id))`,
}, Assertions: []string{schemaColumns("feed_sources", "uuid,domain_uuid,owner_uuid,provider,title,folder,url,credential,version,enabled,interval_seconds,next_ms,lease,lease_until,last_ms,error,etag,modified"), schemaColumns("feed_items", "source_uuid,id,title,url,body,published_ms,feed,folder,is_read,starred"), schemaUnique("feed_items", "source_uuid,id"), schemaUnique("feed_states", "source_uuid,id"), schemaUnique("feed_note_receipts", "domain_uuid,owner_uuid,request_id"), `SELECT 1 WHERE NOT EXISTS(SELECT 1 FROM sqlite_master WHERE type='trigger' AND name='feed_source_delete')`}}}
// CaptureFeedNote creates an inert Wiki note and receipt atomically. It does not
// mutate the feed or create a task, and rechecks grants under the writer lock.
func (s *Store) CaptureFeedNote(ctx context.Context, domain, owner, request, source, id, target, title, body string) (string, error) {
if _, e := uuid.Parse(request); e != nil {
return "", ErrTaskInvalid
}
if !ValidTaskWikiPrefix(target) || target == "/" || len(target) > 500 || len(title) > 300 || title == "" || len(body) > 65536 {
return "", ErrTaskInvalid
}
// User/group spaces have additional ownership/publication contracts. Initial
// capture supports ordinary Wiki paths only, rather than bypassing those caps.
first := strings.Split(strings.TrimPrefix(target, "/"), "/")[0]
if first == "u" || first == "g" {
return "", ErrAccessDenied
}
raw, _ := json.Marshal([]string{source, id, target, title, body})
hash := fmt.Sprintf("%x", sha256.Sum256(raw))
page := ""
e := s.feedWrite(ctx, domain, owner, func(tx *sql.Tx) error {
caps, e := loadLocalityAccess(tx, domain, owner)
if e != nil {
return e
}
for _, capability := range []string{"read", "create", "write"} {
basis := authorizeGrantFrom(tx, AuthorizationRequest{DomainUUID: domain, PrincipalUUID: owner, Capability: capability, TargetType: "path", TargetID: target}, false)
if basis != nil && !errors.Is(basis, ErrAccessDenied) {
return basis
}
if !caps.Decide(target, capability, basis == nil) {
return ErrAccessDenied
}
}
var oldHash string
e = tx.QueryRowContext(ctx, `SELECT input_hash,page_uuid FROM feed_note_receipts WHERE domain_uuid=? AND owner_uuid=? AND request_id=?`, domain, owner, request).Scan(&oldHash, &page)
if e == nil {
if oldHash != hash {
return ErrTaskConflict
}
return nil
}
if !errors.Is(e, sql.ErrNoRows) {
return e
}
var exists bool
if e = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM feed_items i JOIN feed_sources s ON s.uuid=i.source_uuid WHERE s.domain_uuid=? AND s.owner_uuid=? AND s.uuid=? AND i.id=?)`, domain, owner, source, id).Scan(&exists); e != nil {
return e
}
if !exists {
return sql.ErrNoRows
}
item := TaskRecord{Title: title}
if e = s.createCapturedTaskWiki(ctx, tx, domain, owner, &item, target, body); e != nil {
return e
}
page = item.PageUUID
_, e = tx.ExecContext(ctx, `INSERT INTO feed_note_receipts VALUES(?,?,?,?,?)`, domain, owner, request, hash, page)
return e
})
if e == nil {
s.InvalidatePathCaches()
}
return page, e
}
type FeedSource struct {
UUID string `json:"uuid"`
Domain string `json:"-"`
Owner string `json:"-"`
Provider string `json:"provider"`
Title string `json:"title"`
Folder string `json:"folder"`
URL string `json:"url"`
Credential string `json:"-"`
Version int64 `json:"version"`
Enabled bool `json:"enabled"`
Interval int `json:"interval_seconds"`
NextMS int64 `json:"next_ms"`
Lease string `json:"-"`
LeaseUntil int64 `json:"-"`
LastMS int64 `json:"last_ms"`
Error string `json:"error"`
ETag string `json:"-"`
Modified string `json:"-"`
}
type FeedItem struct {
Source string `json:"source"`
ID string `json:"id"`
Title string `json:"title"`
URL string `json:"url"`
Body string `json:"body,omitempty"`
PublishedMS int64 `json:"published_ms"`
Feed string `json:"feed"`
Folder string `json:"folder"`
Read bool `json:"read"`
Starred bool `json:"starred"`
Version int64 `json:"version"`
Provider string `json:"provider"`
}
const feedSourceColumns = `uuid,domain_uuid,owner_uuid,provider,title,folder,url,credential,version,enabled,interval_seconds,next_ms,lease,lease_until,last_ms,error,etag,modified`
func scanFeedSource(row interface{ Scan(...any) error }) (v FeedSource, e error) {
e = row.Scan(&v.UUID, &v.Domain, &v.Owner, &v.Provider, &v.Title, &v.Folder, &v.URL, &v.Credential, &v.Version, &v.Enabled, &v.Interval, &v.NextMS, &v.Lease, &v.LeaseUntil, &v.LastMS, &v.Error, &v.ETag, &v.Modified)
return
}
func feedActor(ctx context.Context, q interface {
QueryRowContext(context.Context, string, ...any) *sql.Row
}, domain, owner string, write bool) error {
if e := taskActor(ctx, q, domain, owner, write); e != nil {
return e
}
var raw string
e := q.QueryRowContext(ctx, `SELECT value FROM config WHERE domain_uuid=? AND key='system_extension_states'`, domain).Scan(&raw)
if e != nil && !errors.Is(e, sql.ErrNoRows) {
return e
}
states := map[string]bool{}
if raw != "" && json.Unmarshal([]byte(raw), &states) != nil {
return ErrAccessDenied
}
if enabled, ok := states["organizer.feeds"]; ok && !enabled {
return ErrAccessDenied
}
return nil
}
func (s *Store) feedWrite(ctx context.Context, domain, owner string, fn func(*sql.Tx) error) error {
if s.ReadOnly {
return ErrReadOnly
}
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
tx, e := s.DB.BeginTx(ctx, nil)
if e != nil {
return e
}
defer tx.Rollback()
if _, e = tx.ExecContext(ctx, `UPDATE domain_memberships SET state=state WHERE domain_uuid=? AND principal_uuid=?`, domain, owner); e != nil {
return e
}
if e = feedActor(ctx, tx, domain, owner, true); e != nil {
return e
}
if e = fn(tx); e != nil {
return e
}
return tx.Commit()
}
func (s *Store) FeedSources(ctx context.Context, domain, owner string) ([]FeedSource, error) {
if e := feedActor(ctx, s.DB, domain, owner, false); e != nil {
return nil, e
}
rows, e := s.DB.QueryContext(ctx, `SELECT `+feedSourceColumns+` FROM feed_sources WHERE domain_uuid=? AND owner_uuid=? ORDER BY folder,title,uuid LIMIT 32`, domain, owner)
if e != nil {
return nil, e
}
defer rows.Close()
out := []FeedSource{}
for rows.Next() {
v, e := scanFeedSource(rows)
if e != nil {
return nil, e
}
out = append(out, v)
}
return out, rows.Err()
}
func (s *Store) SaveFeedSource(ctx context.Context, domain, owner string, v FeedSource) (FeedSource, error) {
if _, e := uuid.Parse(v.UUID); e != nil {
return v, ErrTaskInvalid
}
v.Title = strings.TrimSpace(v.Title)
v.Folder = strings.TrimSpace(v.Folder)
if v.Title == "" || len(v.Title) > 200 || len(v.Folder) > 200 || len(v.URL) > 4096 || !utf8.ValidString(v.Title+v.Folder) || v.Interval < 300 || v.Interval > 86400 || (v.Provider != "local" && v.Provider != "freshrss") {
return v, ErrTaskInvalid
}
e := s.feedWrite(ctx, domain, owner, func(tx *sql.Tx) error {
if v.Version == 0 {
old, lookup := scanFeedSource(tx.QueryRowContext(ctx, `SELECT `+feedSourceColumns+` FROM feed_sources WHERE uuid=?`, v.UUID))
if lookup == nil {
if old.Domain != domain || old.Owner != owner || old.Version != 1 || old.Provider != v.Provider || old.Title != v.Title || old.Folder != v.Folder || old.URL != v.URL || old.Interval != v.Interval || old.Enabled != v.Enabled {
return ErrTaskConflict
}
if old.Credential != v.Credential {
candidate := v
candidate.Domain = domain
candidate.Owner = owner
u, p, e := s.OpenFeedCredential(candidate)
if e != nil {
return ErrTaskConflict
}
ou, op, e := s.OpenFeedCredential(old)
if e != nil || u != ou || p != op {
return ErrTaskConflict
}
}
return nil
}
if !errors.Is(lookup, sql.ErrNoRows) {
return lookup
}
var n int
if e := tx.QueryRowContext(ctx, `SELECT count(*) FROM feed_sources WHERE domain_uuid=? AND owner_uuid=?`, domain, owner).Scan(&n); e != nil {
return e
}
if n >= 32 {
return ErrTaskDAVLimit
}
_, e := tx.ExecContext(ctx, `INSERT INTO feed_sources(uuid,domain_uuid,owner_uuid,provider,title,folder,url,credential,version,enabled,interval_seconds) VALUES(?,?,?,?,?,?,?,?,1,?,?)`, v.UUID, domain, owner, v.Provider, v.Title, v.Folder, v.URL, v.Credential, v.Enabled, v.Interval)
return e
}
old, e := scanFeedSource(tx.QueryRowContext(ctx, `SELECT `+feedSourceColumns+` FROM feed_sources WHERE uuid=? AND domain_uuid=? AND owner_uuid=?`, v.UUID, domain, owner))
if e != nil {
return e
}
// Changing remote identity requires a new source, not reassignment of cached IDs.
if old.Provider != v.Provider || old.URL != v.URL || v.Credential != "" {
return ErrTaskInvalid
}
result, e := tx.ExecContext(ctx, `UPDATE feed_sources SET title=?,folder=?,enabled=?,interval_seconds=?,version=version+1,next_ms=0,lease='',lease_until=0 WHERE uuid=? AND version=?`, v.Title, v.Folder, v.Enabled, v.Interval, v.UUID, v.Version)
if e != nil {
return e
}
n, _ := result.RowsAffected()
if n != 1 {
return ErrTaskConflict
}
return nil
})
v.Version++
v.Credential = ""
return v, e
}
func (s *Store) FeedSourceAction(ctx context.Context, domain, owner, id, action string, version int64) error {
return s.feedWrite(ctx, domain, owner, func(tx *sql.Tx) error {
var result sql.Result
var e error
switch action {
case "refresh":
result, e = tx.ExecContext(ctx, `UPDATE feed_sources SET next_ms=0 WHERE uuid=? AND domain_uuid=? AND owner_uuid=? AND version=? AND enabled=1 AND lease_until<? AND (last_ms=0 OR last_ms<?)`, id, domain, owner, version, time.Now().UnixMilli(), time.Now().Add(-time.Minute).UnixMilli())
case "delete":
result, e = tx.ExecContext(ctx, `DELETE FROM feed_sources WHERE uuid=? AND domain_uuid=? AND owner_uuid=? AND version=?`, id, domain, owner, version)
default:
return ErrTaskInvalid
}
if e != nil {
return e
}
n, _ := result.RowsAffected()
if n != 1 {
return ErrTaskConflict
}
return nil
})
}
func (s *Store) FeedItems(ctx context.Context, domain, owner, source, filter, query string, before int64, beforeID string) ([]FeedItem, error) {
if len(query) > 200 || len(beforeID) > 1200 {
return nil, ErrTaskInvalid
}
if e := feedActor(ctx, s.DB, domain, owner, false); e != nil {
return nil, e
}
rows, e := s.DB.QueryContext(ctx, `SELECT i.source_uuid,i.id,i.title,i.url,i.published_ms,i.feed,CASE WHEN s.folder<>'' THEN s.folder ELSE i.folder END,CASE WHEN s.provider='local' THEN COALESCE(t.is_read,0) ELSE i.is_read END,CASE WHEN s.provider='local' THEN COALESCE(t.starred,0) ELSE i.starred END,COALESCE(t.version,0),s.provider FROM feed_items i JOIN feed_sources s ON s.uuid=i.source_uuid LEFT JOIN feed_states t ON t.source_uuid=i.source_uuid AND t.id=i.id WHERE s.domain_uuid=? AND s.owner_uuid=? AND (?='' OR s.uuid=?) AND (?='' OR instr(lower(i.title),lower(?))>0 OR instr(lower(i.feed),lower(?))>0) AND (?<0 OR i.published_ms<? OR (i.published_ms=? AND (i.source_uuid||':'||i.id)<?)) AND (?<>'unread' OR (CASE WHEN s.provider='local' THEN COALESCE(t.is_read,0) ELSE i.is_read END)=0) AND (?<>'starred' OR (CASE WHEN s.provider='local' THEN COALESCE(t.starred,0) ELSE i.starred END)=1) ORDER BY i.published_ms DESC,i.source_uuid||':'||i.id DESC LIMIT 101`, domain, owner, source, source, query, query, query, before, before, before, beforeID, filter, filter)
if e != nil {
return nil, e
}
defer rows.Close()
out := []FeedItem{}
for rows.Next() {
var v FeedItem
if e = rows.Scan(&v.Source, &v.ID, &v.Title, &v.URL, &v.PublishedMS, &v.Feed, &v.Folder, &v.Read, &v.Starred, &v.Version, &v.Provider); e != nil {
return nil, e
}
out = append(out, v)
}
return out, rows.Err()
}
func (s *Store) FeedItem(ctx context.Context, domain, owner, source, id string) (FeedItem, error) {
var v FeedItem
if e := feedActor(ctx, s.DB, domain, owner, false); e != nil {
return v, e
}
e := s.DB.QueryRowContext(ctx, `SELECT i.source_uuid,i.id,i.title,i.url,i.body,i.published_ms,i.feed,i.folder,CASE WHEN s.provider='local' THEN COALESCE(t.is_read,0) ELSE i.is_read END,CASE WHEN s.provider='local' THEN COALESCE(t.starred,0) ELSE i.starred END,COALESCE(t.version,0),s.provider FROM feed_items i JOIN feed_sources s ON s.uuid=i.source_uuid LEFT JOIN feed_states t ON t.source_uuid=i.source_uuid AND t.id=i.id WHERE s.domain_uuid=? AND s.owner_uuid=? AND s.uuid=? AND i.id=?`, domain, owner, source, id).Scan(&v.Source, &v.ID, &v.Title, &v.URL, &v.Body, &v.PublishedMS, &v.Feed, &v.Folder, &v.Read, &v.Starred, &v.Version, &v.Provider)
return v, e
}
func (s *Store) SetFeedState(ctx context.Context, domain, owner, source, id string, read, star bool, version int64) error {
return s.feedWrite(ctx, domain, owner, func(tx *sql.Tx) error {
var provider string
if e := tx.QueryRowContext(ctx, `SELECT s.provider FROM feed_sources s JOIN feed_items i ON i.source_uuid=s.uuid WHERE s.uuid=? AND s.domain_uuid=? AND s.owner_uuid=? AND i.id=?`, source, domain, owner, id).Scan(&provider); e != nil {
return e
}
if provider != "local" {
return ErrAccessDenied
}
if version == 0 {
var n int
if e := tx.QueryRowContext(ctx, `SELECT count(*) FROM feed_states WHERE source_uuid=?`, source).Scan(&n); e != nil {
return e
}
if n >= 10000 {
return ErrTaskDAVLimit
}
}
result, e := tx.ExecContext(ctx, `INSERT INTO feed_states(source_uuid,id,is_read,starred,version) SELECT ?,?,?,?,1 WHERE ?=0 ON CONFLICT(source_uuid,id) DO NOTHING`, source, id, read, star, version)
if e != nil {
return e
}
n, _ := result.RowsAffected()
if n == 1 {
return nil
}
result, e = tx.ExecContext(ctx, `UPDATE feed_states SET is_read=?,starred=?,version=version+1 WHERE source_uuid=? AND id=? AND version=?`, read, star, source, id, version)
if e != nil {
return e
}
n, _ = result.RowsAffected()
if n != 1 {
return ErrTaskConflict
}
return nil
})
}
func (s *Store) SealFeedCredential(domain, owner, id, user, password string) (string, error) {
b, _ := json.Marshal([]string{"feed-source-v1", domain, owner, id, user, password})
return s.encryptAuthSecret(b)
}
func (s *Store) OpenFeedCredential(v FeedSource) (string, string, error) {
b, e := s.decryptAuthSecret(v.Credential)
if e != nil {
return "", "", e
}
var f []string
if json.Unmarshal(b, &f) != nil || len(f) != 6 || f[0] != "feed-source-v1" || f[1] != v.Domain || f[2] != v.Owner || f[3] != v.UUID {
return "", "", ErrAccessDenied
}
return f[4], f[5], nil
}
func (s *Store) EnsureFeedEvent() error {
if s.ReadOnly {
return ErrReadOnly
}
now := time.Now().UnixMilli()
_, e := s.DB.Exec(`INSERT OR IGNORE INTO event_definitions(uuid,name,event_type,event_key,payload,schedule_kind,interval_seconds,next_run_at_ms,enabled,priority,max_attempts,created_at_ms,updated_at_ms) VALUES('builtin.feed.sync','RSS source synchronization',?,'local','{}','interval',60,?,1,-5,1,?,?)`, FeedSyncEventType, now, now, now)
return e
}
func (s *Store) DueFeedSources(ctx context.Context) ([]FeedSource, error) {
rows, e := s.DB.QueryContext(ctx, `SELECT `+feedSourceColumns+` FROM feed_sources WHERE enabled=1 AND next_ms<=? AND lease_until<? AND EXISTS(SELECT 1 FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid JOIN domains d ON d.uuid=m.domain_uuid WHERE p.uuid=feed_sources.owner_uuid AND m.domain_uuid=feed_sources.domain_uuid AND p.state='active' AND m.state='active' AND d.enabled=1 AND COALESCE(d.placement,'local')='local') AND NOT EXISTS(SELECT 1 FROM config c WHERE c.domain_uuid=feed_sources.domain_uuid AND c.key='system_extension_states' AND COALESCE(json_extract(CASE WHEN json_valid(c.value) THEN c.value ELSE '{"organizer.feeds":false}' END,'$."organizer.feeds"'),1)=0) ORDER BY next_ms,uuid LIMIT 4`, time.Now().UnixMilli(), time.Now().UnixMilli())
if e != nil {
return nil, e
}
defer rows.Close()
out := []FeedSource{}
for rows.Next() {
v, e := scanFeedSource(rows)
if e != nil {
return nil, e
}
out = append(out, v)
}
return out, rows.Err()
}
func (s *Store) ClaimFeed(ctx context.Context, v FeedSource) (FeedSource, error) {
v.Lease = uuid.NewString()
e := s.feedWrite(ctx, v.Domain, v.Owner, func(tx *sql.Tx) error {
now := time.Now().UnixMilli()
result, e := tx.ExecContext(ctx, `UPDATE feed_sources SET lease=?,lease_until=?,next_ms=? WHERE uuid=? AND version=? AND enabled=1 AND lease_until<? AND next_ms<=?`, v.Lease, now+60000, now+int64(v.Interval)*1000, v.UUID, v.Version, now, now)
if e != nil {
return e
}
n, _ := result.RowsAffected()
if n != 1 {
return ErrTaskConflict
}
return nil
})
return v, e
}
// Failed fetches preserve the previous cache. Version and claim token fence stale workers.
func (s *Store) CompleteFeed(ctx context.Context, v FeedSource, items []FeedItem, etag, modified, code string, unchanged bool) error {
if len(items) > 500 || len(etag) > 1024 || len(modified) > 1024 {
return ErrTaskInvalid
}
switch code {
case "", "network", "invalid_feed", "credentials", "remote_error", "limit":
default:
return ErrTaskInvalid
}
for _, i := range items {
if i.ID == "" || len(i.ID) > 1024 || len(i.Title) > 2048 || len(i.URL) > 4096 || len(i.Body) > 32768 || len(i.Feed) > 512 || len(i.Folder) > 512 || i.PublishedMS < 0 {
return ErrTaskInvalid
}
}
return s.feedWrite(ctx, v.Domain, v.Owner, func(tx *sql.Tx) error {
result, e := tx.ExecContext(ctx, `UPDATE feed_sources SET lease='',lease_until=0,last_ms=CASE WHEN ?='' THEN ? ELSE last_ms END,error=?,etag=CASE WHEN ?='' THEN ? ELSE etag END,modified=CASE WHEN ?='' THEN ? ELSE modified END WHERE uuid=? AND version=? AND lease=? AND enabled=1`, code, time.Now().UnixMilli(), code, code, etag, code, modified, v.UUID, v.Version, v.Lease)
if e != nil {
return e
}
n, _ := result.RowsAffected()
if n != 1 {
return ErrTaskConflict
}
if code != "" || unchanged {
return nil
}
// FreshRSS is authoritative: retain exactly this bounded recent window,
// not stale rows from unsubscribed feeds or old external read/star state.
if v.Provider == "freshrss" {
if _, e = tx.ExecContext(ctx, `DELETE FROM feed_items WHERE source_uuid=?`, v.UUID); e != nil {
return e
}
}
for _, i := range items {
_, e = tx.ExecContext(ctx, `INSERT INTO feed_items(source_uuid,id,title,url,body,published_ms,feed,folder,is_read,starred) VALUES(?,?,?,?,?,?,?,?,?,?) ON CONFLICT(source_uuid,id) DO UPDATE SET title=excluded.title,url=excluded.url,body=excluded.body,published_ms=excluded.published_ms,feed=excluded.feed,folder=excluded.folder,is_read=excluded.is_read,starred=excluded.starred`, v.UUID, i.ID, i.Title, i.URL, i.Body, i.PublishedMS, i.Feed, i.Folder, i.Read, i.Starred)
if e != nil {
return e
}
}
_, e = tx.ExecContext(ctx, `DELETE FROM feed_items WHERE source_uuid=? AND id NOT IN(SELECT id FROM feed_items WHERE source_uuid=? ORDER BY published_ms DESC,id DESC LIMIT 500)`, v.UUID, v.UUID)
return e
})
}
+49
View File
@@ -0,0 +1,49 @@
package store
import (
"context"
"testing"
"pageswiki/internal/db"
)
func TestFeedMigrationAtomicRepeatAndCleanup(t *testing.T) {
st := newSchemaTestStore(t)
ctx := context.Background()
// Fail after creating the tables, and verify the entire migration rolls back.
broken := append([]db.SQLMigration(nil), feedMigrations...)
broken[0].Statements = append(append([]string(nil), feedMigrations[0].Statements...), `INSERT INTO no_such_feed_table VALUES(1)`)
if e := db.ApplySQLiteMigrations(ctx, st.DB, "feeds", broken); e == nil {
t.Fatal("expected injected failure")
}
var count int
if e := st.DB.QueryRow(`SELECT count(*) FROM sqlite_master WHERE name='feed_sources'`).Scan(&count); e != nil || count != 0 {
t.Fatal("partial schema", count, e)
}
if e := st.ensureSchemaComponent("feeds"); e != nil {
t.Fatal(e)
}
if _, e := st.DB.Exec(`INSERT INTO feed_sources(uuid,domain_uuid,owner_uuid,provider,title,folder,url,version,enabled,interval_seconds) VALUES('s','d','u','local','title','','https://example.org',1,1,300); INSERT INTO feed_items VALUES('s','i','title','','body',0,'','',0,0); INSERT INTO feed_states VALUES('s','i',1,1,1)`); e != nil {
t.Fatal(e)
}
for range 2 {
if e := st.ensureSchemaComponent("feeds"); e != nil {
t.Fatal(e)
}
}
if e := st.DB.QueryRow(`SELECT count(*) FROM feed_items`).Scan(&count); e != nil || count != 1 {
t.Fatal("lost data", e)
}
if _, e := st.DB.Exec(`PRAGMA foreign_keys=OFF; DELETE FROM feed_sources WHERE uuid='s'`); e != nil {
t.Fatal(e)
}
for _, table := range []string{"feed_items", "feed_states"} {
if e := st.DB.QueryRow(`SELECT count(*) FROM ` + table).Scan(&count); e != nil || count != 0 {
t.Fatal("orphan", table, count, e)
}
}
var result string
if e := st.DB.QueryRow(`PRAGMA integrity_check`).Scan(&result); e != nil || result != "ok" {
t.Fatal(result, e)
}
}
+2 -2
View File
@@ -21,13 +21,13 @@ func DefaultDashboard() []DashboardWidget {
}
func ValidateDashboard(items []DashboardWidget) error {
if len(items) > 6 {
if len(items) > 7 {
return ErrTaskInvalid
}
seen := map[string]bool{}
for _, item := range items {
switch item.ID {
case "progress", "today", "tomorrow", "tasks", "schedule", "activity":
case "progress", "today", "tomorrow", "tasks", "schedule", "activity", "feeds":
default:
return ErrTaskInvalid
}
+1
View File
@@ -12,6 +12,7 @@ import (
// Once released, add a new version; never edit an applied definition.
// Auth, City, tasks and calendars remain in their existing migration paths.
var managedStoreSchemas = map[string][]db.SQLMigration{
"feeds": feedMigrations,
"contacts": contactMigrations,
"task-productivity": taskProductivityMigrations,
"cli-auth": cliAuthMigrations,
+3
View File
@@ -111,6 +111,9 @@ func NewWithDocumentRoot(
if err := st.ensureSchemaComponent("contacts"); err != nil {
panic(err)
}
if err := st.ensureSchemaComponent("feeds"); err != nil {
panic(err)
}
if err := st.EnsureBrowserNavigationSchema(); err != nil {
panic(err)
}
+1 -1
View File
@@ -73,7 +73,7 @@ func (s *Store) createCapturedTaskWiki(ctx context.Context, tx *sql.Tx, domain,
}
content := "<h1>" + escape(item.Title) + "</h1>\n<pre>" + escape(body) + "</pre>\n"
now := time.Now()
rev := &Revision{UUID: uuid.NewString(), ObjectUUID: item.PageUUID, DocumentHash: revisionHash(content), Language: "und", ContentType: "text/html; charset=utf-8", Body: content, Message: "Capture mail as task Wiki", CreatedAt: now.Unix(), CreatedAtMS: now.UnixMilli()}
rev := &Revision{UUID: uuid.NewString(), ObjectUUID: item.PageUUID, DocumentHash: revisionHash(content), Language: "und", ContentType: "text/html; charset=utf-8", Body: content, Message: "Capture attributed text as Wiki", CreatedAt: now.Unix(), CreatedAtMS: now.UnixMilli()}
if err := s.persistDocument(rev.DocumentHash, rev.Body); err != nil {
return err
}
+6
View File
@@ -0,0 +1,6 @@
.feeds-page{height:100dvh;overflow:hidden;display:flex;flex-direction:column;background:var(--bg);color:var(--fg)}
.feeds-page .topbar,.feeds-page .organizer-nav{flex-shrink:0}.feeds-page #feeds-app{flex:1;min-height:0;display:flex;flex-direction:column;width:100%;max-width:none;margin:0;padding:0 .5rem .25rem;box-sizing:border-box}
#feed-toolbar{display:flex;align-items:center;gap:.35rem;min-height:2.5rem;flex-wrap:wrap}#feed-toolbar input{flex:1;min-width:8rem;max-width:32rem}#feeds-app button,#feeds-app input,#feeds-app select{font:inherit;color:inherit;background:var(--panel,var(--bg));border:1px solid var(--border,#6666);border-radius:.2rem;padding:.2rem .45rem;min-height:1.8rem}#feeds-app button{cursor:pointer}#feeds-app button:disabled{opacity:.45;cursor:default}#feeds-app a{color:var(--accent,#659de4)}#feed-status{margin:0;min-height:1.25rem;font-size:.78rem;color:var(--muted,var(--fg));overflow-wrap:anywhere}
.feed-layout{flex:1;min-height:0;display:grid;grid-template-columns:12rem minmax(18rem,1fr) minmax(18rem,42%);border:1px solid var(--border,#6666)}#feed-sources,.feed-index,#feed-reader{min-width:0;min-height:0;overflow:auto;overscroll-behavior:contain}#feed-sources{border-right:1px solid var(--border,#6666);padding:.3rem}.feed-source{display:flex;align-items:center}.feed-source>button:first-child{flex:1;text-align:left;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;border:0!important}.feed-source small{font-size:.68rem}.feed-source[aria-current=true]{background:color-mix(in srgb,var(--accent,#659de4) 20%,transparent)}#feed-sources h3{font-size:.75rem;margin:.5rem 0 .15rem}.feed-index{display:flex;flex-direction:column}#feed-rows{flex:1;min-height:0;overflow:auto;outline-offset:-2px}#feed-columns,.feed-row{display:grid;grid-template-columns:1.8rem 5.4rem 8rem minmax(0,1fr);align-items:center;gap:.3rem;font-size:.8rem;padding:.25rem .4rem;box-sizing:border-box}#feed-columns{font-size:.7rem;border-bottom:1px solid var(--border,#6666);opacity:.7}.feed-row{cursor:pointer;min-height:1.85rem;content-visibility:auto;contain-intrinsic-size:auto 30px}.feed-row>span{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.feed-row.unread{font-weight:650}.feed-row[aria-selected=true]{background:color-mix(in srgb,var(--accent,#659de4) 24%,var(--bg,#16191f));box-shadow:inset 3px 0 var(--accent,#659de4)}.feed-row:hover{background:color-mix(in srgb,var(--accent,#659de4) 12%,transparent)}#feed-reader{border-left:1px solid var(--border,#6666);padding:.75rem}#feed-reader h1{font-size:1.1rem;margin:0 0 .4rem;overflow-wrap:anywhere}#feed-reader .feed-body{white-space:pre-wrap;overflow-wrap:anywhere;font-family:inherit;font-size:.9rem;line-height:1.6}.feed-actions{display:flex;flex-wrap:wrap;gap:.3rem;align-items:center}.feed-meta{font-size:.75rem;opacity:.7;margin:.4rem 0}#feed-keys{font-size:.72rem;padding:.3rem;opacity:.75}#feeds-app form{display:grid;gap:.5rem}#feeds-app form label{display:grid;gap:.2rem;font-size:.85rem}#feeds-app form input,#feeds-app form select{width:100%;box-sizing:border-box}#feeds-app form .feed-actions{display:flex}#feeds-app .feed-warning{font-size:.8rem;line-height:1.5;opacity:.8}.feed-source-error{color:var(--danger,#e57a7a)}
@media(max-width:1100px){.feed-layout{grid-template-columns:10rem minmax(0,1fr)}#feed-reader{display:none}.feed-layout.reading .feed-index{display:none}.feed-layout.reading #feed-reader{display:block}#feed-columns,.feed-row{grid-template-columns:1.5rem 4.7rem 7rem minmax(0,1fr)}}
@media(max-width:600px){.feed-layout{display:flex;flex-direction:column}#feed-sources{display:none;max-height:35%;flex-shrink:0;border-bottom:1px solid var(--border,#6666)}.feed-layout.sources-open #feed-sources{display:block}.feed-index,#feed-reader{flex:1;width:100%;box-sizing:border-box}#feed-columns,.feed-row{grid-template-columns:1.5rem 3.5rem minmax(0,1fr);font-size:.85rem}.feed-row{min-height:2.75rem}#feed-columns>span:nth-child(3),.feed-row>span:nth-child(3){display:none}#feeds-app button{min-height:2.3rem}#feed-keys{display:none}#feed-reader{border-left:0}.feeds-page .organizer-nav{font-size:.8rem}}
+90
View File
@@ -0,0 +1,90 @@
(() => {
'use strict';
const root=document.getElementById('feeds-app');if(!root)return;
const ja=document.documentElement.lang.startsWith('ja'),t=(en,jp)=>ja?jp:en;
const api='/_/api/v1/extension/organizer.feeds/',writable=root.dataset.writable==='true';
const toolbar=document.getElementById('feed-toolbar'),status=document.getElementById('feed-status'),sourcesView=document.getElementById('feed-sources'),rows=document.getElementById('feed-rows'),reader=document.getElementById('feed-reader'),layout=root.querySelector('.feed-layout'),more=document.getElementById('feed-more');
const el=(tag,text,cls)=>{const n=document.createElement(tag);if(text!==undefined)n.textContent=text;if(cls)n.className=cls;return n;};
const report=e=>{if(e.name!=='AbortError')status.textContent=e.message;};
function button(text,label,fn){const b=el('button',text);b.type='button';b.title=b.ariaLabel=label;b.addEventListener('click',()=>Promise.resolve().then(fn).catch(report));return b;}
async function request(path,options={}){const response=await fetch(api+path,{credentials:'same-origin',cache:'no-store',...options,headers:{'Content-Type':'application/json',...options.headers}});if(response.redirected||response.status===401)throw Error(t('Please sign in again.','再度ログインしてください。'));const data=await response.json().catch(()=>({}));if(!response.ok)throw Error(response.status===412?t('Changed elsewhere or refresh is cooling down. Reload before retrying.','別の操作と競合したか、更新の待機時間中です。再読込して確認してください。'):t('Request failed: ','操作に失敗しました: ')+(data.error||response.status));return data;}
const post=(path,body)=>request(path,{method:'POST',body:JSON.stringify(body)});
let sources=[],items=[],selected=-1,currentSource='',filter='',search='',next=null,loading=false,seq=0,detailSeq=0,editing=false,controller,detailController;
const sourceLabel=el('strong','RSS'),searchbox=el('input');searchbox.type='search';searchbox.placeholder=t('Search titles / feeds… /','件名・配信元を検索… /');searchbox.ariaLabel=searchbox.placeholder;
const filters=el('select');for(const [v,en,jp]of [['','All','すべて'],['unread','Unread','未読'],['starred','Starred','star付き']]){const o=el('option',t(en,jp));o.value=v;filters.append(o);}filters.ariaLabel=t('Filter','絞り込み');filters.onchange=()=>{filter=filters.value;load(false).catch(report);};
const refresh=button('↻',t('Queue source refresh (r)','背景更新を予約 (r)'),queueRefresh);refresh.disabled=!writable;
toolbar.append(button('☰',t('Sources','購読元'),()=>layout.classList.toggle('sources-open')),sourceLabel,searchbox,filters,refresh);
if(writable)toolbar.append(button('+',t('Add source','購読元を追加'),()=>sourceForm()));
toolbar.append(button('?',t('Keyboard shortcuts','キー操作'),showHelp));
let debounce;searchbox.addEventListener('input',()=>{clearTimeout(debounce);debounce=setTimeout(()=>{search=searchbox.value.trim();load(false).catch(report);},180);});
const columns=document.getElementById('feed-columns');for(const s of ['',t('Date','日付'),t('Feed','配信元'),t('Subject','件名')])columns.append(el('span',s));
document.getElementById('feed-keys').textContent=t('j/k move · Enter read · Esc index · / search · n unread · m read/unread · * star · r refresh · ? help','j/k 移動 · Enter 本文 · Esc 一覧 · / 検索 · n 次の未読 · m 既読/未読 · * star · r 背景更新 · ? ヘルプ');
function showHelp(){status.textContent=document.getElementById('feed-keys').textContent+' · '+t('FreshRSS state is read-only. Reading never marks it read automatically.','FreshRSSの状態は読取専用です。表示だけで自動既読にはしません。');}
function date(ms){return ms?new Intl.DateTimeFormat(ja?'ja-JP':'en-GB',{month:'2-digit',day:'2-digit'}).format(new Date(ms)):'—';}
function closeReader(){editing=false;detailSeq++;detailController?.abort();layout.classList.remove('reading');rows.focus();}
function drawSources(){sourcesView.replaceChildren();const all=button(t('All sources','すべての購読元'),'',()=>chooseSource(''));sourcesView.append(all);let folder=null;
for(const source of sources){if(folder!==source.folder){folder=source.folder;sourcesView.append(el('h3',folder||t('Sources','購読元')));}const row=el('div',undefined,'feed-source');row.setAttribute('aria-current',String(currentSource===source.uuid));
const b=button((source.enabled?'':'⏸ ')+source.title,source.title,()=>chooseSource(source.uuid));if(source.error){b.classList.add('feed-source-error');b.title+=' · '+source.error;}row.append(b);if(writable)row.append(button('⚙',t('Source settings','購読元設定'),()=>sourceForm(source)));sourcesView.append(row);
}if(!sources.length)sourcesView.append(el('p',t('Add an RSS/Atom URL or FreshRSS API source.','RSS/Atom URLまたはFreshRSS APIを追加してください。'),'feed-warning'));
}
async function chooseSource(id){currentSource=id;drawSources();layout.classList.remove('sources-open','reading');editing=false;await load(false);}
function rowNode(item,index){const row=el('div',undefined,'feed-row'+(item.read?'':' unread'));row.id='feed-row-'+index;row.setAttribute('role','option');row.setAttribute('aria-selected',String(index===selected));for(const text of [(item.starred?'★':item.read?' ':'●'),date(item.published_ms),item.feed||sources.find(s=>s.uuid===item.source)?.title||'',item.title||t('(Untitled)','(無題)')])row.append(el('span',text));row.title=item.title;row.onclick=()=>open(index).catch(report);return row;}
function drawRows(){rows.replaceChildren(...items.map(rowNode));more.hidden=!next;more.textContent=t('Load next 100 ↓','次の100件 ↓');if(!items.length)rows.append(el('p',t('No cached articles. Add a source or wait for background refresh.','取得済みの記事はありません。購読元を追加し、背景更新をお待ちください。'),'feed-warning'));}
async function load(append){if(append&&(!next||loading))return;controller?.abort();controller=new AbortController();const version=++seq;loading=true;more.disabled=true;
try{const q=new URLSearchParams({source:currentSource,filter,q:search});if(append){q.set('before',next.ms);q.set('key',next.key);}const data=await request('items?'+q,{signal:controller.signal});if(version!==seq)return;
if(!append){detailSeq++;items=[];selected=-1;reader.replaceChildren(el('p',t('Select an article.','記事を選択してください。')));layout.classList.remove('reading');editing=false;}items.push(...data.items);const last=data.items.at(-1);next=data.more&&last?{ms:last.published_ms,key:last.source+':'+last.id}:null;drawRows();status.textContent=items.length+t(' cached articles · up to 500/source; FreshRSS fetches the latest 200 per refresh.','件を表示 · 購読元ごとに最大500件保持/FreshRSSは更新ごとに最新200件取得。');
}finally{if(version===seq){loading=false;more.disabled=false;}}
}
more.onclick=()=>load(true).catch(report);
async function reload(){sources=(await request('sources')).sources;drawSources();await load(false);}
async function queueRefresh(){const targets=sources.filter(s=>s.enabled&&(!currentSource||currentSource===s.uuid));let queued=0;for(const s of targets){await post('sources/'+s.uuid+'/refresh',{version:s.version});queued++;}status.textContent=queued+t(' sources queued. Refreshing runs in the background; reload the list shortly.','件を予約しました。取得は背景で実行されます。少し待って一覧を再読込してください。');}
toolbar.append(button('⟳',t('Reload cached list','取得済み一覧を再読込'),reload));
async function open(index){if(index<0||index>=items.length)return;editing=false;selected=index;detailController?.abort();detailController=new AbortController();const version=++detailSeq;for(const [i,row]of [...rows.querySelectorAll('.feed-row')].entries())row.setAttribute('aria-selected',String(i===index));rows.setAttribute('aria-activedescendant','feed-row-'+index);document.getElementById('feed-row-'+index)?.scrollIntoView({block:'nearest'});
layout.classList.add('reading');reader.replaceChildren(el('p',t('Loading…','読み込み中…')));const item=(await request('item?'+new URLSearchParams({source:items[index].source,id:items[index].id}),{signal:detailController.signal})).item;if(version!==detailSeq)return;items[index]=item;renderItem(item);
}
function renderItem(item){reader.replaceChildren();const actions=el('div',undefined,'feed-actions');actions.append(button('←',t('Back to list','一覧へ戻る'),closeReader));
const read=button(item.read?'●':'○',t('Toggle read state (m)','既読/未読 (m)'),()=>setState(!item.read,item.starred));const star=button(item.starred?'★':'☆',t('Toggle star (*)','star切替 (*)'),()=>setState(item.read,!item.starred));read.disabled=star.disabled=!writable||item.provider!=='local';actions.append(read,star);
if(item.url){const a=el('a',t('Original ↗','原文 ↗'));a.href=item.url;a.target='_blank';a.rel='noopener noreferrer';actions.append(a);}
if(writable)actions.append(button(t('+ Wiki / Task','+ Wiki・タスク'),t('Capture with attribution','出典付きで取り込む'),()=>captureForm(item)));
reader.append(actions,el('h1',item.title||t('(Untitled)','(無題)')),el('p',(item.feed||'')+' · '+(item.published_ms?new Date(item.published_ms).toLocaleString():t('Date unknown','日付不明')),'feed-meta'));
if(item.provider==='freshrss')reader.append(el('p',t('FreshRSS is authoritative. Read/star changes are not enabled in this read-only connector.','FreshRSSが正本です。この読取連携では既読・starを変更しません。'),'feed-warning'));
reader.append(el('div',item.body||t('(No article text)','(本文なし)'),'feed-body'));
}
async function setState(read,starred){const item=items[selected];if(!item||!writable||item.provider!=='local')return;const source=item.source,id=item.id;const data=await post('state',{source,id,read,starred,version:item.version});Object.assign(item,{read,starred,version:data.version});drawRows();if(items[selected]===item&&!editing)renderItem(item);}
function field(form,label,value='',type='text'){const wrap=el('label',label),input=el('input');input.type=type;input.value=value;wrap.append(input);form.append(wrap);return input;}
function sourceForm(source){editing=true;detailSeq++;layout.classList.add('reading');reader.replaceChildren();const form=el('form'),buttons=el('div',undefined,'feed-actions');reader.append(form);form.append(el('h1',t('Source settings','購読元設定')));
const title=field(form,t('Name','表示名'),source?.title||''),folder=field(form,t('Folder','フォルダ'),source?.folder||'');title.required=true;title.maxLength=folder.maxLength=200;
const label=el('label',t('Provider','正本')),provider=el('select');for(const [id,name]of [['local',t('Local · RSS / Atom','内蔵 · RSS / Atom')],['freshrss','FreshRSS']]){const o=el('option',name);o.value=id;provider.append(o);}provider.value=source?.provider||'local';provider.disabled=!!source;label.append(provider);form.append(label);
const url=field(form,t('Public HTTPS feed / greader.php API URL','公開HTTPSのfeed / greader.php API URL'),source?.url||'','url');url.required=true;url.readOnly=!!source;
const user=field(form,t('FreshRSS user','FreshRSSユーザー')),password=field(form,t('FreshRSS API password','FreshRSS APIパスワード'),'','password');password.autocomplete='new-password';
const interval=field(form,t('Refresh interval (minutes, 5–1440)','更新間隔(分、5〜1440)'),String((source?.interval_seconds||1800)/60),'number');interval.min='5';interval.max='1440';interval.required=true;
const enabled=field(form,t('Enabled','有効'),'','checkbox');enabled.checked=source?source.enabled:true;
const toggle=()=>{user.parentElement.hidden=password.parentElement.hidden=!!source||provider.value!=='freshrss';user.required=password.required=!source&&provider.value==='freshrss';};provider.onchange=toggle;toggle();
form.append(el('p',t('Background only. Public HTTPS/443, no redirects or private addresses. To change the endpoint or credentials, create a new source. Existing Wiki/tasks are not deleted with a source.','背景取得のみ。公開HTTPS/443に限定し、リダイレクト・内部アドレスは拒否します。接続先や資格情報の変更は新しい購読元を作成してください。削除しても保存済みWiki・タスクは残ります。'),'feed-warning'));
if(source)form.append(el('p',t('Last success: ','最終成功: ')+(source.last_ms?new Date(source.last_ms).toLocaleString():'—')+' · '+(source.error||'OK'),'feed-meta'));
const sourceID=source?.uuid||crypto.randomUUID();
const save=el('button',t('Save','保存'));save.type='submit';buttons.append(save,button(t('Cancel','取消'),'',closeReader));if(source)buttons.append(button(t('Delete source','購読元を削除'),'',async()=>{if(!confirm(t('Delete this source, cached articles and local read/star state?','購読元・取得記事・内蔵の既読/star状態を削除しますか?')))return;await post('sources/'+source.uuid+'/delete',{version:source.version});currentSource='';await reload();}));form.append(buttons);
form.onsubmit=async event=>{event.preventDefault();save.disabled=true;try{await post('sources',{uuid:sourceID,version:source?.version||0,provider:provider.value,title:title.value,folder:folder.value,url:url.value,interval_seconds:Number(interval.value)*60,enabled:enabled.checked,username:user.value,password:password.value});password.value='';await reload();status.textContent=t('Saved. Background synchronization will run shortly.','保存しました。背景同期が順次実行されます。');}catch(e){report(e);}finally{save.disabled=false;}};title.focus();
}
function captureForm(item){
editing=true;detailSeq++;reader.replaceChildren();const form=el('form');reader.append(form);form.append(el('h1',t('Attributed Wiki note / task','出典付きWikiメモ・タスク')));
const title=field(form,t('Title','件名'),item.title.slice(0,250));title.required=true;title.maxLength=300;
const task=field(form,t('Also create a task','タスクを作成する'),'','checkbox');task.disabled=root.dataset.tasks!=='true';
const prefix=field(form,t('Wiki parent Path (empty = task only)','Wikiの親Path(空ならタスクのみ)'),'');prefix.placeholder='/notes/feeds';prefix.required=true;
const notes=field(form,t('Your note','メモ'));const copy=field(form,t('Include cached text (explicit copy)','取得済み本文も保存する(明示コピー)'),'','checkbox');
const confirm=field(form,t('I checked the destination publication policy and the material to copy.','保存先の公開範囲と、コピーする内容を確認しました。'),'','checkbox');confirm.required=true;
const validate=()=>{prefix.required=!task.checked;confirm.required=!!prefix.value.trim()||!task.checked;};task.onchange=prefix.oninput=validate;
form.append(el('p',t('Stored as inert text with attribution. No full website fetch. A Wiki note and optional task survive source deletion.','出典付きの安全なテキストとして保存します。原文サイトの全文取得はしません。購読元を削除してもWiki・タスクは残ります。'),'feed-warning'));
const save=el('button',t('Create','作成'));save.type='submit';form.append(save,button(t('Cancel','取消'),'',()=>{editing=false;renderItem(item);}));let pending=null;
form.onsubmit=async event=>{event.preventDefault();const body='Source: '+item.url+'\nFeed: '+item.feed+'\n\n'+notes.value+(copy.checked?'\n\n'+item.body:'');const spec={title:title.value,notes:notes.value,prefix:prefix.value.trim(),body,task:task.checked};const fingerprint=JSON.stringify(spec);if(!pending||pending.fingerprint!==fingerprint)pending={fingerprint,request_id:crypto.randomUUID()};save.disabled=true;
try{let data;if(task.checked){const input={request_id:pending.request_id,title:title.value,notes:(notes.value+'\nSource: '+item.url).trim()};if(spec.prefix){input.wiki_prefix=spec.prefix;input.wiki_body=body;}const res=await fetch('/_/api/v1/extension/organizer.tasks/capture',{method:'POST',credentials:'same-origin',headers:{'Content-Type':'application/json'},body:JSON.stringify(input)});data=await res.json().catch(()=>({}));if(!res.ok||res.redirected)throw Error(t('Capture failed: ','作成に失敗: ')+(data.error||res.status));}
else data=await post('note',{request_id:pending.request_id,source:item.source,id:item.id,path:spec.prefix.replace(/\/$/,'')+'/rss-'+pending.request_id,title:title.value,body,confirm_publication:confirm.checked});
reader.replaceChildren(el('p',t('Created.','作成しました。')));if(data.item){const a=el('a',t('Open task','タスクを開く'));a.href='/v/plan/task/'+encodeURIComponent(data.item.uuid);reader.append(a);}const page=data.page_uuid||data.item?.page_uuid;if(page){const a=el('a',t('Open Wiki','Wikiを開く'));a.href='/v/uuid:'+encodeURIComponent(page);reader.append(el('p'),a);}editing=false;
}catch(e){report(e);}finally{save.disabled=false;}
};
}
document.addEventListener('keydown',event=>{if(event.defaultPrevented||event.isComposing||event.ctrlKey||event.altKey||event.metaKey)return;const input=event.target.closest?.('input,textarea,select,[contenteditable=true]');if(input){if(event.key==='Escape'){event.target.blur();event.preventDefault();}return;}if(event.key==='Enter'&&event.target.closest?.('button,a'))return;if(editing){if(event.key==='Escape'){closeReader();event.preventDefault();}return;}
let action;switch(event.key){case 'j':case 'ArrowDown':action=()=>open(Math.min(items.length-1,selected+1));break;case 'k':case 'ArrowUp':action=()=>open(Math.max(0,selected-1));break;case 'Enter':case 'l':action=()=>open(Math.max(0,selected));break;case 'Escape':case 'h':action=closeReader;break;case '/':action=()=>searchbox.focus();break;case 'r':if(writable)action=queueRefresh;break;case 'm':action=()=>setState(!items[selected]?.read,!!items[selected]?.starred);break;case '*':action=()=>setState(!!items[selected]?.read,!items[selected]?.starred);break;case 'n':action=()=>{const i=items.findIndex((x,i)=>i>selected&&!x.read);if(i>=0)return open(i);};break;case '?':action=showHelp;break;}if(action){event.preventDefault();Promise.resolve().then(action).catch(report);}
});
(async()=>{const q=new URLSearchParams(location.search);currentSource=q.get('source')||'';await reload();if(q.has('settings')&&writable){sourceForm();return;}if(q.has('id')&&currentSource){let index=items.findIndex(x=>x.source===currentSource&&x.id===q.get('id'));if(index<0){const data=await request('item?'+new URLSearchParams({source:currentSource,id:q.get('id')}));items.unshift(data.item);index=0;drawRows();}await open(index);}})().catch(report);
})();
+9 -1
View File
@@ -7,6 +7,8 @@
const writable=root.dataset.writable==='true',today=root.dataset.today,zone=root.dataset.timezone;
const names={progress:t('Today’s completion','本日の達成率'),today:t('Today’s tasks','本日のタスク'),tomorrow:t('Tomorrow’s tasks','明日のタスク'),tasks:t('Tasks','タスク'),schedule:t('Today’s schedule','本日のスケジュール'),activity:t('Activity report','達成度・作業レポート')};
const defaults=[['progress',4,3],['today',4,3],['tomorrow',4,3],['tasks',8,4],['schedule',4,4],['activity',12,5]].map(([id,width,height])=>({id,width,height,...(id==='tasks'?{tab:'inbox'}:{})}));
names.feeds=t('RSS · latest cached articles','RSS · 最近の取得記事');
const available=[...defaults,{id:'feeds',width:6,height:4}];
const tabs={inbox:'Inbox',backlog:'Backlog',someday:'Someday',review:'Review',all:'Incomplete',done:'Done'};
const el=(tag,text,cls)=>{const n=document.createElement(tag);if(text!==undefined)n.textContent=text;if(cls)n.className=cls;return n;};
function button(text,label,fn){const b=el('button',text);b.type='button';b.title=b.ariaLabel=label;b.onclick=fn;return b;}
@@ -31,7 +33,7 @@
});
const edit=button('⚙',t('Arrange widgets','ウィジェットを配置'),()=>{editing=!editing;root.classList.toggle('is-arranging',editing);edit.setAttribute('aria-pressed',String(editing));});edit.setAttribute('aria-pressed','false');
const refresh=button('↻',t('Refresh visible widgets','ウィジェットを更新'),()=>{for(const item of widgets){const card=cards.get(item.id);if(card)loadWidget(item,card);}});
const add=el('select');add.ariaLabel=t('Add widget','ウィジェットを追加');add.onchange=()=>{const item=defaults.find(w=>w.id===add.value);if(item){widgets.push({...item});render();changed();}};
const add=el('select');add.ariaLabel=t('Add widget','ウィジェットを追加');add.onchange=()=>{const item=available.find(w=>w.id===add.value);if(item){widgets.push({...item});render();changed();}};
const reset=button(t('Reset layout','初期配置'),t('Reset layout','初期配置'),()=>{if(confirm(t('Replace this layout with the default layout? Save to apply.','初期配置に戻しますか? 保存するまでは確定しません。'))){widgets=defaults.map(x=>({...x}));render();changed();}});
controls.append(refresh);if(writable)controls.append(edit,add,reset,save);
function updateControls(){save.disabled=!dirty||saving||!loaded;edit.disabled=add.disabled=reset.disabled=saving||!loaded;refresh.disabled=!loaded;root.classList.toggle('dashboard-saving',saving);for(const card of cards.values())card.querySelectorAll('.widget-arrange button,.widget-arrange select,.widget-drag,.widget-resize').forEach(n=>n.disabled=saving);add.replaceChildren();const option=el('option',t('+ Add widget','+ ウィジェットを追加'));option.value='';add.append(option);for(const [id,name] of Object.entries(names)){if(widgets.some(w=>w.id===id)||id==='schedule'&&root.dataset.calendar!=='true')continue;const o=el('option',name);o.value=id;add.append(o);}}
@@ -45,6 +47,7 @@
const card=el('section',undefined,'dashboard-widget');card.id=item.id;card.dataset.widget=item.id;applySize(item,card);
const header=el('header',undefined,'widget-header'),heading=el('h2',names[item.id]);heading.id='widget-title-'+item.id;card.setAttribute('aria-labelledby',heading.id);
header.append(heading);const destinations={progress:'/v/plan/today',today:'/v/plan/today',tomorrow:'/v/plan/tasks/tomorrow',tasks:'/v/plan/tasks',schedule:'/v/plan',activity:'/v/plan/dashboard#activity'};
destinations.feeds='/v/feeds';
const open=link('↗',destinations[item.id]);open.title=open.ariaLabel=t('Open ','開く: ')+names[item.id];header.append(open);
const arrange=el('div',undefined,'widget-arrange');
if(writable){
@@ -78,6 +81,11 @@
if(controller.signal.aborted||!card.isConnected)return;
const signal=AbortSignal.any([controller.signal,AbortSignal.timeout(15000)]);
try{
if(item.id==='feeds'){
const data=await request('/_/api/v1/extension/organizer.feeds/items',{signal});if(controller.signal.aborted)return;
const list=el('ul',undefined,'dashboard-list');for(const item of data.items.slice(0,12)){const row=el('li');row.append(el('span',item.read?'○':'●'),link(item.title||t('(Untitled)','(無題)'),'/v/feeds?'+new URLSearchParams({source:item.source,id:item.id})));list.append(row);}
body.replaceChildren(list);if(!data.items.length)body.append(el('p',t('No cached articles.','取得済みの記事はありません。')));return;
}
if(item.id==='activity'){
body.replaceChildren();const report=el('section');report.id='task-productivity';report.dataset.view='report';const h=el('h3');h.className='visually-hidden';const message=el('p');message.id='productivity-status';message.role='status';const content=el('div');content.id='productivity-content';report.append(h,message,content);body.append(report);await window.PagesWikiProductivityMount(report,controller.signal);return;
}
+9
View File
@@ -0,0 +1,9 @@
{{ define "feeds.gohtml" }}<!doctype html>
<html lang="{{ .Locale }}"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
<title>{{ T "feeds.title" }} · {{ .WikiName }}</title>
<link rel="stylesheet" href="/static/css/main.css"><link rel="stylesheet" href="/static/css/theme/base.css"><link rel="stylesheet" href="{{ .ThemeCSS }}"><link rel="stylesheet" href="/static/css/feeds.css?v=1"></head>
<body class="mode-view organizer-page feeds-page"><header class="topbar"><div class="brand"><a href="/">{{ .WikiName }}</a></div>{{ template "auth-menu" . }}</header>{{ template "organizer-nav" . }}
<main id="feeds-app" data-writable="{{ .FeedWritable }}" data-tasks="{{ .TasksEnabled }}">
<div id="feed-toolbar"></div><p id="feed-status" role="status" aria-live="polite"></p>
<div class="feed-layout"><aside id="feed-sources" aria-label="{{ T "feeds.title" }}"></aside><section class="feed-index"><div id="feed-columns" aria-hidden="true"></div><div id="feed-rows" tabindex="0" role="listbox" aria-label="{{ T "feeds.title" }}"></div><button type="button" id="feed-more" hidden>↓</button></section><article id="feed-reader" tabindex="0"></article></div>
<footer id="feed-keys"></footer></main><script src="/static/js/feeds.js?v=1" defer></script></body></html>{{ end }}
@@ -3,6 +3,7 @@
<body class="mode-config organizer-page"><header class="topbar"><div class="brand"><a href="/">{{ .WikiName }}</a></div>{{ template "auth-menu" . }}</header>{{ template "organizer-nav" . }}
<main class="config-main"><div class="config-layout"><aside class="config-sidebar"><nav class="sidebar-nav"><a href="/-/sys/config?panel=organizer" aria-current="page">{{ T "organizer.settings" }}</a>{{ if .TasksEnabled }}<a href="#task-productivity">{{ T "tasks.title" }}</a>{{ end }}{{ if .CalendarEnabled }}<a href="#organizer-calendar-defaults">{{ T "organizer.calendar_defaults" }}</a>{{ end }}{{ if .ContactsEnabled }}<a href="/v/plan/contacts">{{ T "organizer.contacts" }} ↗</a>{{ end }}{{ if .AuthIsAdmin }}<a href="/-/sys/config">{{ T "config.title" }} ↗</a>{{ end }}</nav></aside>
<section class="organizer-settings-content"><h1>{{ T "organizer.settings" }}</h1><p>{{ T "organizer.private" }}</p>
{{ if .FeedsEnabled }}<section><h2>{{ T "feeds.title" }}</h2><p>{{ T "feeds.help" }}</p><a href="/v/feeds?settings=1">⚙ {{ T "feeds.title" }}</a></section>{{ end }}
{{ if .TasksEnabled }}<section id="task-productivity" data-view="settings" data-writable="{{ .TaskWritable }}"><h2></h2><p id="productivity-status" role="status" aria-live="polite"></p><div id="productivity-content"></div></section><section id="task-digest-history" data-writable="{{ .TaskWritable }}"></section>{{ end }}
{{ if .CalendarEnabled }}<section id="organizer-calendar-defaults" data-writable="{{ .TaskWritable }}"><h2>{{ T "organizer.calendar_defaults" }}</h2><p role="status"></p><div data-calendar-defaults></div></section>{{ end }}
</section></div></main><script src="/static/js/task-productivity.js?v=6" defer></script><script src="/static/js/task-digest-history.js?v=1" defer></script><script src="/static/js/organizer-settings.js?v=1" defer></script></body></html>{{ end }}
+2
View File
@@ -1,12 +1,14 @@
{{ define "organizer-nav" }}
<link rel="stylesheet" href="/static/css/organizer.css?v=1">
<nav class="organizer-nav" aria-label="{{ T "organizer.title" }}">
{{ if .FeedsEnabled }}<a href="/v/feeds" {{ if eq .OrganizerSection "feeds" }}aria-current="page"{{ end }}>◉ <span>{{ T "feeds.title" }}</span></a>{{ end }}
{{ if .TasksEnabled }}<a href="/v/plan/dashboard" {{ if eq .OrganizerSection "dashboard" }}aria-current="page"{{ end }}>▦ <span>{{ T "organizer.dashboard" }}</span></a><a href="/v/plan/tasks" {{ if eq .OrganizerSection "tasks" }}aria-current="page"{{ end }}>✓ <span>{{ T "tasks.title" }}</span></a>{{ end }}
{{ if .CalendarEnabled }}<a href="/v/plan" {{ if eq .OrganizerSection "calendar" }}aria-current="page"{{ end }}>▤ <span>{{ T "calendar.title" }}</span></a>{{ end }}
{{ if .ContactsEnabled }}<a href="/v/plan/contacts" {{ if eq .OrganizerSection "contacts" }}aria-current="page"{{ end }}>♧ <span>{{ T "organizer.contacts" }}</span></a>{{ end }}
{{ if .AuthUser }}<a href="/-/sys/config?panel=organizer" {{ if eq .OrganizerSection "settings" }}aria-current="page"{{ end }}>⚙ <span>{{ T "organizer.settings" }}</span></a>{{ end }}
</nav>{{ end }}
{{ define "organizer-shortcuts" }}
{{ if .FeedsEnabled }}<a href="/v/feeds" class="organizer-launch" data-home-shortcut="feeds" title="{{ T "feeds.title" }}" aria-label="{{ T "feeds.title" }}"><svg viewBox="0 0 24 24" aria-hidden="true"><circle cx="5" cy="19" r="1"/><path d="M4 11a9 9 0 0 1 9 9M4 4a16 16 0 0 1 16 16"/></svg></a>{{ end }}
{{ if .TasksEnabled }}<a href="/v/plan/dashboard" class="organizer-launch" data-home-shortcut="dashboard" title="{{ T "organizer.dashboard" }}" aria-label="{{ T "organizer.dashboard" }}"><svg viewBox="0 0 24 24" aria-hidden="true"><path d="M3 3h7v7H3zM14 3h7v11h-7zM3 14h7v7H3zM14 18h7v3h-7z"/></svg></a>{{ end }}
{{ if .ContactsEnabled }}<a href="/v/plan/contacts" class="organizer-launch" data-home-shortcut="contacts" title="{{ T "organizer.contacts" }}" aria-label="{{ T "organizer.contacts" }}"><svg viewBox="0 0 24 24" aria-hidden="true"><rect x="4" y="3" width="15" height="18" rx="2"/><circle cx="12" cy="9" r="3"/><path d="M8 17c0-5 8-5 8 0M2 7h4M2 12h4M2 17h4"/></svg></a>{{ end }}
{{ end }}