25 Commits
Author SHA1 Message Date
Anya Tokugawa 38b0fe2a94 fix(dashboard): normalize recoverable layout preferences on save
Build and publish container images / images (push) Successful in 9m27s
Release container images / release (push) Successful in 20s
2026-11-10 07:36:32 +09:00
Anya Tokugawa 667776e43f feat(tasks): add keyboard index and productivity dashboard improvements
Build and publish container images / images (push) Successful in 9m29s
Release container images / release (push) Successful in 18s
2026-11-10 07:12:15 +09:00
Anya Tokugawa 02edb51b8a test(tasks): preserve mail Wiki path diagnostics and regression coverage 2026-11-10 07:12:10 +09:00
Anya Tokugawa b61fbc38a4 docs: record v0.16.0 production deployment [skip ci] 2026-11-09 05:59:11 +09:00
Anya Tokugawa 02fb77f72b feat(slides): add sandboxed Reveal.js viewer and editor preview
Build and publish container images / images (push) Successful in 9m2s
Release container images / release (push) Successful in 21s
2026-11-08 22:10:52 +09:00
Anya Tokugawa 09afb438c9 feat(editor): support atomic multi-cell CSV paste 2026-11-08 21:48:32 +09:00
Anya Tokugawa 2d6ceac0d7 feat(editor): add lossless bounded CSV table editing 2026-11-08 20:58:19 +09:00
Anya Tokugawa bd80ff6a0c docs: record v0.15.0 production deployment [skip ci] 2026-11-08 20:42:17 +09:00
Anya Tokugawa b90aef79d0 feat: add browser upload queue and trusted sessions with bounded projections
Build and publish container images / images (push) Successful in 11m37s
Release container images / release (push) Successful in 22s
2026-11-08 20:27:04 +09:00
Anya Tokugawa 84d52390f9 docs: record v0.14.1 production deployment [skip ci] 2026-11-08 19:43:43 +09:00
Anya Tokugawa 4049acf76e fix(tasks): recover deleted captures without reviving tombstones
Build and publish container images / images (push) Successful in 12m0s
Release container images / release (push) Successful in 19s
2026-11-08 19:26:50 +09:00
Anya Tokugawa 43a2d8c5a1 docs: record v0.14.0 production deployment [skip ci] 2026-11-08 18:21:06 +09:00
Anya Tokugawa 38a4fcf530 feat(tasks): add explicit deletion with DAV tombstones
Build and publish container images / images (push) Successful in 11m42s
Release container images / release (push) Successful in 27s
2026-11-08 18:04:54 +09:00
Anya Tokugawa dc978231e2 docs: record v0.13.0 production deployment [skip ci] 2026-11-08 16:32:53 +09:00
Anya Tokugawa 5321d613b4 feat(feeds): add opt-in Gecko relay and folder shortcuts
Build and publish container images / images (push) Successful in 11m45s
Release container images / release (push) Successful in 21s
Document engine redistribution requirements; exclude upstream engine assets and keep the viewer disabled by default.
2026-11-08 16:14:34 +09:00
Anya Tokugawa b23e63d4c6 docs: record v0.12.0 production release [skip ci] 2026-11-08 14:57:15 +09:00
Anya Tokugawa f4869c7c8b feat(feeds): add optional sandboxed in-tab article preview
Build and publish container images / images (push) Successful in 10m41s
Release container images / release (push) Successful in 24s
2026-11-08 13:55:22 +09:00
Anya Tokugawa ea1ca432c5 feat(feeds): share original articles through X extension
Build and publish container images / images (push) Successful in 11m18s
2026-11-08 13:50:24 +09:00
Anya Tokugawa c2bc637704 fix(feeds): use opaque themed capture dialog surface
Build and publish container images / images (push) Successful in 11m27s
2026-11-08 13:46:46 +09:00
Anya Tokugawa a5f90f933d feat(feeds): add templated capture paths and inline modal
Build and publish container images / images (push) Successful in 11m2s
2026-11-08 13:44:20 +09:00
Anya Tokugawa 78da33d549 feat(feeds): prefill Wiki capture path from personal defaults
Build and publish container images / images (push) Successful in 11m41s
2026-11-08 13:39:54 +09:00
Anya Tokugawa 50a90bcc14 fix(feeds): dismiss shortcut help without leaving article
Build and publish container images / images (push) Successful in 11m20s
2026-11-08 13:37:56 +09:00
Anya Tokugawa bf9a9c2847 feat(feeds): inherit FreshRSS folders in cached subscription tree
Build and publish container images / images (push) Successful in 10m33s
2026-11-08 13:34:22 +09:00
Anya Tokugawa 1057be6d2b feat(feeds): expose retained operation history and read-only rechecks
Build and publish container images / images (push) Successful in 11m14s
2026-11-08 06:35:53 +09:00
Anya Tokugawa e4c184d71c docs: record approved backup and image retention cleanup [skip ci] 2026-11-08 06:35:53 +09:00
209 changed files with 9373 additions and 449 deletions

No files matched your search

+16 -4
View File
@@ -35,8 +35,8 @@ jobs:
[worker.oci]
max-parallelism = 2
- name: Test release tooling and wallpaper palette
run: node --test tools/ci/release-images.test.mjs static/js/home-palette-core.test.cjs
- name: Test release tooling and browser logic
run: node --test tools/ci/release-images.test.mjs static/js/home-palette-core.test.cjs static/js/csv-core.test.cjs
- name: Test
uses: https://github.com/docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
@@ -91,13 +91,25 @@ jobs:
org.opencontainers.image.revision=${{ github.sha }}
org.opencontainers.image.source=${{ github.server_url }}/${{ github.repository }}
- name: Build Gecko relay
uses: https://github.com/docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
with:
context: .
file: Dockerfile.gecko-relay
platforms: linux/amd64
load: true
tags: ${{ env.REGISTRY }}/${{ env.IMAGE_OWNER }}/pageswiki-gecko-relay:${{ env.IMAGE_TAG }}
labels: |
org.opencontainers.image.revision=${{ github.sha }}
org.opencontainers.image.source=${{ github.server_url }}/${{ github.repository }}
# Publish only after all builds succeed. Use the host daemon for registry
# access; BuildKit does not inherit the runner's /etc/hosts entries.
- name: Push images
shell: bash
run: |
set -euo pipefail
for image in pageswiki-app pageswiki-adaptor-gateway pageswiki-excalidraw-viewer; do
for image in pageswiki-app pageswiki-adaptor-gateway pageswiki-excalidraw-viewer pageswiki-gecko-relay; do
docker push "$REGISTRY/$IMAGE_OWNER/$image:$IMAGE_TAG"
done
@@ -105,7 +117,7 @@ jobs:
if: always()
shell: bash
run: |
for image in pageswiki-app pageswiki-adaptor-gateway pageswiki-excalidraw-viewer; do
for image in pageswiki-app pageswiki-adaptor-gateway pageswiki-excalidraw-viewer pageswiki-gecko-relay; do
ref="$REGISTRY/$IMAGE_OWNER/$image:$IMAGE_TAG"
if docker image inspect "$ref" >/dev/null 2>&1; then
docker image rm "$ref" || echo "Could not remove local CI tag: $ref" >&2
+1
View File
@@ -5,6 +5,7 @@ data/*
!data/test_cli_dr.py
!data/pageswiki-remote
/data2/
/docs/local/
/.codex/
/.agents/
/.env
+18
View File
@@ -0,0 +1,18 @@
# The relay image contains no browser engine. Mount the independently verified
# fixed Gecko distribution read-only at /gecko (see docs/operations/gecko-relay.md).
FROM golang:1.25-alpine AS build
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY internal/geckorelay ./internal/geckorelay
COPY cmd/gecko-relay ./cmd/gecko-relay
RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /gecko-relay ./cmd/gecko-relay
FROM scratch
COPY --from=build /gecko-relay /usr/local/bin/gecko-relay
COPY --from=build /usr/local/go/LICENSE /licenses/Go.txt
COPY --from=build /go/pkg/mod/golang.org/x/net@v0.35.0/LICENSE /licenses/golang-x-net.txt
COPY internal/geckorelay/NOTICE.txt /licenses/NOTICE.txt
USER 10001:10001
EXPOSE 3012
ENTRYPOINT ["/usr/local/bin/gecko-relay"]
+6
View File
@@ -342,6 +342,12 @@ window.PagesWikiEditor = {
}),
];
if (options.preserveLineEndings) {
// Split only at LF, keeping any CR bytes in the document. This
// preserves mixed LF/CRLF CSV sources instead of rewriting them.
extensions.push(EditorState.lineSeparator.of("\n"));
}
if (keymapName === "vim") {
installVimCommands();
extensions.push(vim());
+81
View File
@@ -0,0 +1,81 @@
package main
import (
"crypto/rand"
"encoding/hex"
"flag"
"io"
"log"
"net"
"net/http"
"os"
"strings"
"time"
"pageswiki/internal/geckorelay"
)
func main() {
status := flag.Bool("status", false, "print bounded relay resource counters")
flag.Parse()
// File mount avoids placing the shared secret in image layers or process args.
key, err := os.ReadFile(os.Getenv("PAGESWIKI_GECKO_KEY_FILE"))
if err != nil {
log.Fatal("Gecko relay key file unavailable")
}
secret := strings.TrimSpace(string(key))
addr := os.Getenv("PAGESWIKI_GECKO_LISTEN")
if addr == "" {
addr = ":3012"
}
if *status {
host, port, err := net.SplitHostPort(addr)
if err != nil {
log.Fatal("invalid listen address")
}
if host == "" || host == "0.0.0.0" {
host = "127.0.0.1"
}
if host == "::" {
host = "::1"
}
nonce := make([]byte, 24)
if _, err = rand.Read(nonce); err != nil {
log.Fatal("random source unavailable")
}
req, _ := http.NewRequest("GET", "http://"+net.JoinHostPort(host, port)+"/status", nil)
req.Header.Set(geckorelay.GrantHeader, geckorelay.Sign(secret, geckorelay.Grant{Subject: "operator:status", Nonce: hex.EncodeToString(nonce), Expires: time.Now().Add(30 * time.Second).Unix()}))
client := http.Client{Timeout: 5 * time.Second, Transport: &http.Transport{Proxy: nil}, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
resp, err := client.Do(req)
if err != nil {
log.Fatal("relay status unavailable")
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
log.Fatal("relay status denied")
}
if _, err = io.Copy(os.Stdout, io.LimitReader(resp.Body, 4096)); err != nil {
log.Fatal("relay status read failed")
}
return
}
assets := os.Getenv("PAGESWIKI_GECKO_ASSETS")
if assets == "" {
assets = "/gecko"
}
if err := geckorelay.VerifyAssets(assets); err != nil {
log.Fatal(err)
}
distribution, err := geckorelay.VerifyDistribution(assets)
if err != nil {
log.Fatal(err)
}
relay, err := geckorelay.New(secret, assets)
if err != nil {
log.Fatal(err)
}
relay.Distribution = distribution
s := &http.Server{Addr: addr, Handler: relay, ReadHeaderTimeout: 5 * time.Second, IdleTimeout: 30 * time.Second, MaxHeaderBytes: 16 << 10}
log.Printf("Gecko relay listening; authenticated TCP 80/443 only")
log.Fatal(s.ListenAndServe())
}
+2 -2
View File
@@ -1398,13 +1398,13 @@ class PagesWikiCLI:
if not args:
for extension_id, enabled in sorted(states.items()):
print(f"{extension_id}\t{'enabled' if enabled else 'disabled'}")
print("(extensions not listed here use the default: enabled)")
print("(unlisted extensions use their manifest default; viewer.gecko: disabled, others: enabled)")
return
extension_id = args[0].strip()
if not re.fullmatch(r"[a-z][a-z0-9._-]{1,63}", extension_id):
raise CLIError("invalid extension ID")
if len(args) == 1:
print(f"{extension_id}\t{'enabled' if states.get(extension_id, True) else 'disabled'}")
print(f"{extension_id}\t{'enabled' if states.get(extension_id, extension_id != 'viewer.gecko') else 'disabled'}")
return
value = args[1].lower()
if value not in {"on", "off"}:
+22
View File
@@ -1,6 +1,10 @@
import importlib.util
from pathlib import Path
import unittest
import sqlite3
import io
from contextlib import redirect_stdout
from types import SimpleNamespace
SCRIPT = Path(__file__).with_name("pageswiki-cli")
@@ -43,5 +47,23 @@ class ContentTypeDetectionTest(unittest.TestCase):
self.assertEqual(content_type, "text/plain; charset=shift_jis")
class ExtensionDefaultTest(unittest.TestCase):
def test_gecko_is_opt_in(self) -> None:
db = sqlite3.connect(":memory:")
self.addCleanup(db.close)
db.execute("CREATE TABLE config(domain_uuid TEXT,key TEXT,value TEXT,updated_at INTEGER,UNIQUE(domain_uuid,key))")
# Exercise the CLI command without reading any deployment database.
owner = next(value for value in vars(pageswiki_cli).values() if isinstance(value, type) and hasattr(value, "command_extension"))
fixture = SimpleNamespace(db=db, domain_uuid="synthetic")
output = io.StringIO()
with redirect_stdout(output):
owner.command_extension(fixture, ["viewer.gecko"])
owner.command_extension(fixture, ["viewer.gecko", "on"])
owner.command_extension(fixture, ["viewer.gecko"])
owner.command_extension(fixture, ["viewer.gecko", "off"])
owner.command_extension(fixture, ["viewer.gecko"])
self.assertEqual(output.getvalue().splitlines(), ["viewer.gecko\tdisabled", "viewer.gecko\ton", "viewer.gecko\tenabled", "viewer.gecko\toff", "viewer.gecko\tdisabled"])
if __name__ == "__main__":
unittest.main()
+47
View File
@@ -0,0 +1,47 @@
# Optional development/pilot overlay, never selected by the production recipe.
# Requires host egress rules; an isolated bridge alone is not an egress firewall.
services:
app:
environment:
PAGESWIKI_GECKO_RELAY: http://gecko-relay:3012
PAGESWIKI_GECKO_KEY_FILE: /run/secrets/gecko-key
volumes:
- ${PAGESWIKI_GECKO_KEY_PATH:?Set absolute relay key path}:/run/secrets/gecko-key:ro
networks:
default: {}
gecko-front: {}
gecko-relay:
build:
context: .
dockerfile: Dockerfile.gecko-relay
image: ${PAGESWIKI_GECKO_IMAGE:-pageswiki-gecko-relay:dev}
environment:
PAGESWIKI_GECKO_KEY_FILE: /run/secrets/gecko-key
volumes:
- ${PAGESWIKI_GECKO_KEY_PATH:?Set absolute relay key path}:/run/secrets/gecko-key:ro
- ${PAGESWIKI_GECKO_ASSETS_DIR:?Set verified complete Gecko bundle directory}:/gecko:ro
networks:
gecko-front: {}
gecko-egress: {}
read_only: true
cap_drop: [ALL]
security_opt: [no-new-privileges:true]
mem_limit: 256m
cpus: 0.5
pids_limit: 64
restart: unless-stopped
healthcheck:
test: [CMD, /usr/local/bin/gecko-relay, --status]
interval: 30s
timeout: 3s
retries: 3
networks:
gecko-front:
internal: true
ipam:
config:
- subnet: ${PAGESWIKI_GECKO_FRONT_SUBNET:-172.24.0.0/27}
gecko-egress:
ipam:
config:
- subnet: ${PAGESWIKI_GECKO_EGRESS_SUBNET:-172.24.0.32/27}
+5
View File
@@ -0,0 +1,5 @@
services:
app:
image: pageswiki-app:task-index-20261109
app2:
image: pageswiki-app:task-index-20261109
+10 -3
View File
@@ -55,7 +55,12 @@
- `POST /_/api/v1/editor/convert`:作業中 HTML を安全な authoring Markdown に変換。
`POST /_/api/v1/render/markdown` の `authoring:true` で保護フェンスを元の HTML に戻す。
`projection:true` と併用したプレビューでは従来の sanitizer・macro 展開を適用する。
- 変換できない HTML は文書全体を保護する保守的な実装。フェンスは
- 2026-11-09から、全体変換が構造を保てない場合はbody直下のブロック単位に変換する。
往復で構造が一致する見出し・段落・リスト等はMarkdownへ戻し、不一致のブロックだけを保護する。
再結合後も文書全体を比較し、head内要素等を失う場合は全文保護へ戻す。
保護ブロックはDOM再シリアライズを避け、原文の引用符・タグ表記をそのまま保持する。
分割は最大1024区間。省略終了タグ等で境界を確定できない場合も全文保護へ戻す。
リスト・表の構造要素間の空白は比較時に正規化し、インラインの単語境界やコード内空白は保持する。フェンスは
`` ```{=html} `` 形式(本文にバッククォートがある場合はそれより長い区切り)。
任意の属性、コメント、未知要素、表の結合、画像キャプション、コード内空白を保持。
フェンス内を編集でき、外側に Markdown を追記できる。通常のコードフェンス内にある
@@ -70,7 +75,7 @@
- `+` は挿入・下書き、`文` は言語の編集・分岐、`↶` は旧リビジョンを作業バッファへ
読み込む。復元は明示保存で新 Revision を追加し、旧 Revision を書き換えない。
履歴は50件ずつ追加取得し、現在言語で絞り込む。分岐は翻訳生成ではなく本文のコピー。
- 挿入は子ページ・表・画像キャプション・補足・コード・引用の6種の初期パレット。
- 挿入は子ページ・表・画像キャプション・補足・コード・引用・CSV macroの初期パレット。
画像 URL 等のプレースホルダーは編集が必要。ファイルピッカー、図形・外部 widget の
パラメータ編集、プラグインによる挿入パーツ登録は既存の HTML editor 設計に残る。
- touch/coarse pointer + hover 不可の端末ではデスクトップの Vim 設定を上書きせず、
@@ -78,11 +83,13 @@
## 次段階の実装順序
CSVの表編集は既存保存・下書き・履歴の契約へ接続済みです。CSVはHTML変換と文字列自動マージを行わず、競合時は比較して採否を決めます。BOMと混在改行を保持するため、CSV初期値はHTMLのtextarea解析を通さず安全なJS文字列として渡し、CodeMirrorはLFのみで分割します。初期フォーカスの遅延処理も、表セルなどへ移ったフォーカスを奪いません。詳細な上限と残件は[表設計](extensions.md)を参照してください。
1. **E6a presence**:編集中リースの共有ストアと認可付き API、別端末を含む表示。
管理者にだけ見える監視ではなく、同じ Page/language を編集できる参加者に限定する。
2. **E6b realtime**:下記 CRDT 詳細設計・採用ライブラリ・同時変換ルールを確定した後に
feature flag 付きで実装。現時点の CAS を最終コミット時の保護として残す。
3. **E5b / E3b**:HTML ブロック単位の保護、hosted editor/CLI への保護フェンス対応、
3. **E5b / E3b**:入れ子コンポーネント内のより細粒度なMarkdown復元、hosted editor/CLI への保護フェンス対応、
アセットピッカーと拡張挿入パーツ。通常の Markdown だけを扱う外部エディタへ
このフェンスを無断で渡さない。既存の外部エディタ変換経路は本変更の対象外。
4. 保存 API の旧クライアント移行と base 必須化、下書き大容量化・明示破棄 UX、
+16 -2
View File
@@ -48,11 +48,25 @@ IPアドレス管理(IPAM)、DNSゾーン/レコード管理、機器・
## CSV/表・スライド拡張(設計TODO)
CSVをPage本文へ複製せず、認可済みの別Documentをテーブルとして投影するmacroを用意します。候補構文は `{{csv:/data/items.csv range=A1:H200 header=true}}` とし、Path、Revision(またはasset hash)、列・行上限、表示モードを正規化してキャッシュキーに含めます。macroは表示時にboundedなProjectionを作るだけで、結果HTMLを正本へ逆流させません。CSV Editorは元Revisionを編集し、表投影とは別の操作・競合・権限として扱います。
初期CSV macroは実装済みです。`{{csv:/data/items.csv range=A1:H200 header=true}}` を認証済みProjectionで展開し、`rev=` で同じObjectのRevisionへ固定できます。現在のPath閲覧権限を毎回検査し、外部URL、匿名公開、asset指定、共有キャッシュはこの段階に含めません。入力256 KiB・UTF-8、表示200行×32列、走査2,000行・100列、セル16 KiB、Projection当たり4種類のCSVまでに制限します。引用符・改行・BOMに対応し、セルはHTML escapeしてmacroや数式を実行しません。処理不能時は内容を漏らさない警告に置き換えます。Authoringでは元のmacroを保持します。
既存CSVの編集は `/e/-/{path}` の組み込みエディタで行います。デスクトップはソースと表を並べ、700px以下では表を全幅表示してソースへ切り替えます。セル編集、行・列追加/削除、20操作までの表のUndo/Redoに対応。表は200行・32列・セル16 KiB以内を25行ずつ描画し、先頭行を自動でヘッダ扱いしません。矩形でない行の欠落セルは表示だけでは補わず、列追加・貼り付けで必要になった部分だけ空セルを補います。全体256 KiB・UTF-8以内を対象とし、超過・不正形式の表を部分編集可能にして保存することはありません。表上限を超えても全体上限内ならソースで編集できます。
表計算ソフトからの複数セル貼り付けは、フォーカス中のセルを左上として反映します。クリップボードの `text/plain` にタブまたは改行があればタブ区切り表として解析し、引用符内の改行・タブ・二重引用符を保持します。カンマは列区切りにせずセル値として扱い、単一行の通常テキストはセル内への貼り付けです。複数行を一つのセルへ貼る場合は引用符で囲むかソースを編集します。HTML形式のクリップボードは使いません。必要な行・セルの拡張を含めて1操作でUndo/Redoでき、構文・行列・セル・変換後CSV全体の上限を検査してから一括反映します。失敗時は部分反映せず、既存のUndo履歴も変更しません。貼り付け範囲外のセルと改行形式は維持します。
CSV正本をHTMLへ変換せず、未変更fieldの引用符、BOM、混在LF/CRLFを保持します。セル内のHTML、macro、数式は実行しません。表編集も既存の下書き・認証切れ検出・言語別Revision CAS・履歴復元を使用し、他の保存と競合したCSVは文字列の自動マージをせず比較画面へ送ります。原文と編集済み表の両方を別正本として保存しません。DBスキーマ変更はありません。CSV新規作成ウィザード、TSVファイル/文字コード変換、大容量表のwindow編集、矩形選択/範囲コピー、列型/数式、ODSは残件です。
CSVをPage本文へ複製せず、認可済みの別Documentをテーブルとして投影します。共有キャッシュを将来追加する際は、Path、Revision(またはasset hash)、列・行上限、表示モードと権限を考慮します。macroは表示時にboundedなProjectionを作るだけで、結果HTMLを正本へ逆流させません。CSV Editorは元Revisionを編集し、表投影とは別の操作・競合・権限として扱います。
交換形式はRFC 4180互換CSV(UTF-8、CRLF、引用符・改行を含むfield、BOMの扱いを明示)を第一正本とします。複数シート、型、数式、結合セル、書式が必要な場合はODSを別アダプタ/Assetとして扱い、CSVへの不可逆変換を黙って行いません。行数、列数、セル長、総バイト、ネストmacroを制限し、malformed inputは安全なテキスト表示へfallbackします。
スライドは、Markdown/HTMLの正本からReveal.js互換のProjectionを生成する連携アダプタを設けます。HedgeDoc、Slidevは外部originのホスト型アダプタとして、保存・公開・ユーザー情報をPages Wikiの権限へ自動昇格させず、read-only preview→明示的なimport/saveの順にします。JSを使用できない環境向けには、CSS scroll-snap/`:target`/print CSSだけでページ送りできるCSS-only Slide Editorを別実装します。外部ランタイム停止時は静的HTML/Markdownへ安全にfallbackし、任意script、remote import、iframe権限を本文から許可しません。
スライドはローカル同梱のReveal.js 6.0.2で表示します。`/v/slides/{path}` は通常のPath閲覧権限でHTML/Markdownの最新Revisionを取得し、HTMLページのスライドアイコンや「連携アダプタで開く」から移動できます。組み込みHTML/Markdownエディタのスライドアイコンは、未保存の本文を通常プレビューと同じ変換経路で投影します。表示DOMを保存せず、保存・下書き・競合処理は既存エディタに任せます。Markdownの空行で囲んだ `---`、HTMLの直下の `<hr>` が横方向の区切りで、直下の `<section>` も1枚として扱います。コードブロック内の区切りは分割しません。
Reveal実行は `allow-scripts allow-popups` のsandbox iframeに隔離し、`allow-same-origin` は付けません。本文のscript・CSS・iframe・フォーム・任意data属性を渡さず、独自プラグインや外部Markdownを読み込みません。画像は同一originだけ、リンクはHTTP(S)だけです。矢印キー・タッチ・画面内コントロールで移動し、履歴やURL hashを変更しません。ビューアは全画面に対応し、背景・文字色はテーマから引き継ぎます。ライブラリ読込失敗時は静的なサニタイズ済み本文へfallbackします。本文256 KiB・100枚・DOM 10,000ノード/深さ64を上限とし、常時バックグラウンド生成や共有キャッシュは持ちません。`viewer.slides` は拡張設定でドメイン単位に停止でき、停止後のページではビューア・編集切替・アダプタ候補を表示しません。MITライセンス・固定版・配布元・hashは `static/vendor/reveal/` に同梱します。DBスキーマ変更はありません。
700px以下の編集画面ではスライドプレビューを全幅表示し、既存のプレビュー非表示ボタンでソースへ戻ります。小画面で自動スクロール形式に変わらないよう `scrollActivationWidth: null` を指定します([Reveal.js公式仕様](https://revealjs.com/scroll-view/))。
縦方向のスライド、fragments、発表者ノート、macroの非同期展開、スライド専用印刷、外部画像の承認連携は残件です。HedgeDoc、Slidevは外部originのホスト型アダプタとして、保存・公開・ユーザー情報をPages Wikiの権限へ自動昇格させず、read-only preview→明示的なimport/saveの順にします。JSを使用できない環境向けには、CSS scroll-snap/`:target`/print CSSだけでページ送りできるCSS-only Slide Editorを別実装します。
ネットワーク図ではnwdiagを追加候補とします。ソースをbounded parserで検証し、renderer version/theme/document hashをキーに静的SVGをキュー生成します。include、外部画像・font、未知directive、危険なSVG属性は拒否し、renderer停止時はescaped sourceまたは最後に検証済みの静的画像へfallbackします。編集アダプタの保存はone-use ticketと楽観的Revision競合を使い、Kroki経由の場合もorigin、timeout、quotaを明示します。
+166 -10
View File
@@ -50,7 +50,7 @@ newsboat/neomuttを参考に、デスクトップは左から購読元・一
tooltipに残します。タブ名は「RSS」、原文リンクはアイコンです。件数・保持上限・操作の説明は常設せず、
キー案内は`?`で表示します。設定と保存フォームは本文ペイン内に置き、モーダルを増やしません。
`j/k`・上下矢印で移動、`Enter/l`で本文、`Esc/h`で一覧、`/`で件名・配信元検索、`n`で次の未読、
`j/k`・上下矢印で記事移動、`Shift+j/k`で次/前のFreshRSSフォルダ、`Enter/l`で本文、`Esc/h`で一覧、`/`で件名・配信元検索、`n`で次の未読、
`m`で既読切替、`*`でstar、`r`で背景更新予約、`?`でキー案内です。フォーム入力・IME変換中は
一覧ショートカットを抑止します。FreshRSSでは書戻し許可時だけ`m`と`*`で操作を予約します。
@@ -72,13 +72,16 @@ API prefixは `/_/api/v1/extension/organizer.feeds/`。Domain内の本人専用
| `POST sources/{uuid}/refresh` | 次回背景取得を予約。画面から外部通信しない |
| `POST sources/{uuid}/delete` | versionを照合してsource・cache・内蔵read/starを削除 |
| `GET items` | source/unread/starred/件名・配信元で絞り込み、100件単位のkeysetページング |
| `GET catalog?source=…` | 本人のFreshRSS購読・カテゴリの取得済み一覧。外部通信なし |
| `GET catalog?source=…` | 本人のFreshRSS購読・カテゴリの取得済み一覧。`subscriptions`と空フォルダも含む`folders`。外部通信なし |
| `GET item?source=…&id=…` | 本人の記事本文 |
| `POST state` | 内蔵read/starの条件付き変更。FreshRSSは拒否 |
| `POST remote-state` | FreshRSSの一記事・一項目の変更を予約。request_id、source、id、field、desired、source_versionを指定 |
| `GET action?source=…&id=…` | 本人の記事の最新操作記録。外部通信なし |
| `GET actions` | 本人の操作履歴。status/sourceで絞り込み、50件単位のkeysetページング |
| `GET action/export?request_id=…` | 本人の操作記録1件をJSON attachmentで保存。資格情報・本文・worker claimは含めない |
| `POST action/check` | request_idで結果不明操作の読取専用再確認を予約 |
| `POST note` | 公開範囲確認付きのWiki単独保存。request_idと入力hashで再送を識別 |
| `POST capture-preview` | Wiki親Pathのプレースホルダを展開。保存・外部通信なし |
| `GET opml/export` | 本人の内蔵購読をOPML 2.0としてダウンロード |
| `POST opml/preview` | ファイルを解析し、追加可能・登録済み・重複・未対応等を返す。保存・外部通信なし |
| `POST opml/import` | 選択行を再解析・検査し、確認時の購読設定と一致する場合だけ原子的に追加 |
@@ -90,7 +93,10 @@ v3で`feed_import_receipts`を追加し、購読の一括追加と再送記録
v4でsourceに購読一覧、記事にremote feed ID・カテゴリIDを追加します。FreshRSSの旧workerを
versionで無効化し、次の背景取得を予約します。内蔵sourceのversion・取得予約は変更しません。
v5でsourceの`write_enabled`(既定OFF)と`feed_actions`を追加します。操作記録はsourceを削除しても保持し、
送信済みの可能性があるものはunknown、未送信はcancelledにします。DB更新前にバックアップを取得し、
送信済みの可能性があるものはunknown、未送信はcancelledにします。
v6でsourceに`remote_folders`を追加します。既存の購読・記事・設定version・取得予約・worker claim・
書戻しreceiptは変更しません。初回の背景取得までは既存の購読情報から分類を組み立て、
空フォルダは次の取得成功時に追加します。DB更新前にバックアップを取得し、
旧バイナリへの切戻しだけで追加schemaが巻き戻るとは扱いません。
既存テーブルを破壊・再構成しません。SQLiteのforeign_keys設定に依存せず削除を完遂するtriggerを
持ちます。内蔵read/starを本文cacheから分離し、記事を保持窓から落としても状態は黙って消しません。
@@ -113,7 +119,7 @@ sourceのprovider・URL・資格情報の変更は別sourceを作る契約です
| 内蔵記事cache | 1 source最大500件、text本文32 KiB・HTML本文128 KiB。HTML上限超過はtextへフォールバックし、text切詰めを明示 |
| 内蔵read/star | 1 source最大10,000件。上限では新規状態保存を拒否し、既存状態を捨てない |
| FreshRSS | reading-list最新200件の窓を取得。更新成功時はその窓で置換し、全履歴同期とはしない |
| FreshRSS購読一覧 | 最大1,000購読、1購読64カテゴリ、保存JSON 1 MiB。記事と同じ取得予算で収集 |
| FreshRSS購読・分類一覧 | 最大1,000購読・1,000フォルダ、1購読64カテゴリ、保存JSON合計1 MiB。記事と同じ取得予算で収集 |
| 再試行 | 次の設定間隔まで待機。手動予約にも最終成功から60秒の制限、取得中の重複claim拒否 |
内蔵は条件付きGET、304ではcacheを保持します。どちらのproviderも通信・認証・構文失敗で
@@ -123,17 +129,105 @@ extension無効化は画面・API・取得・完了保存に適用します。
### FreshRSSの購読とカテゴリ
背景取得ではlogin後にreading-listと`subscription/list`を読み、両方に成功した場合だけ
記事・購読一覧を同じtransactionで置換します。一方の取得失敗、上限超過、不正なsnapshotでは
前回の両cacheを保持します。記事が取得窓内にない購読も一覧には残します。
背景取得ではlogin後にreading-list・`subscription/list`・`tag/list`を読み、すべてに成功した場合だけ
記事・購読一覧・分類一覧を同じtransactionで置換します。一部の取得失敗、上限超過、不正なsnapshotでは
前回のcache全体を保持します。記事が取得窓内にない購読も一覧には残します。
`tag/list`は`type=folder`だけを分類として取り込み、記事タグとシステムの状態タグは除外します。
購読一覧のカテゴリとIDで統合し、購読元のない空フォルダも保持します。
左ペインでFreshRSS sourceを選ぶと、接続先→分類フォルダ→購読元のツリーを表示します。
フォルダ名は記事の絞り込み、隣の矢印は開閉と役割を分けます。開閉状態は接続先UUID単位で
ブラウザのlocalStorageに保存し、利用できない場合もその画面内では保持します。
閉じたフォルダは購読元のDOMを作らず、展開時は50件ずつ描画します。購読名・分類名で検索すると
該当購読を重複なしで一覧化します。名前に含まれる`/`は文字として扱い、独自の階層には分割しません。
左ペインでFreshRSS sourceを選ぶとカテゴリ選択・購読名の検索・購読一覧を表示します。
カテゴリは表示名でなくremote category ID、購読は`origin.streamId`とsubscription IDを対応させます。
同名でも混同せず、複数カテゴリに属する購読も扱います。`GET items`の`feed`/`category`は
同名でも混同せず、複数カテゴリに属する購読は各フォルダに表示します。記事の分類絞り込みは
記事タグではなく同期した購読元の所属を使い、FreshRSSでの分類移動に追従します。
分類のない購読は「未分類」に表示し、購読一覧にない記事を未分類へ混在させません。
`GET items`の`feed`/`category`/`category_mode=uncategorized`は
source指定と組み合わせ、既存の未読・star・検索・keysetページングと併用できます。
`category`と`category_mode`の同時指定は拒否します。
絞り込み対象は最新200記事のcache内に限られ、購読を選んでも履歴全件を外部取得しません。
購読の追加・削除やカテゴリの編集はFreshRSS側で行います。
`Shift+j`/`Shift+k`は、選択中のFreshRSS接続内のフォルダを表示順に選び直します。
空フォルダと未分類も含め、先頭・末尾では停止します。「すべての購読」からは、下方向なら先頭、
上方向なら末尾を選びます。購読元を選択中なら、その所属フォルダを起点とします。
記事検索・未読/starフィルタ・フォルダ開閉状態は維持し、個別購読元の絞り込みは解除します。
購読・フォルダの検索でツリーが隠れている場合は、そのナビゲータ検索だけを解除します。
前の本文と本文リクエストは破棄して一覧へ戻し、連打では最後の選択だけを反映します。
フォーム・編集可能領域・モーダル・IME入力中、およびCtrl/Alt/Commandとの併用では実行しません。
source自体の切替、分類の移動・書換え、外部再取得、未読/既読変更は行いません。
ショートカットヘルプは`?`で開閉し、`Esc`または閉じるボタンでも閉じます。
ヘルプだけを閉じる操作では閲覧中の記事や入力フォームを変更せず、エラー等のstatus表示も保持します。
`sharing.x`が有効なDomainでは、本文の操作列にX共有アイコンを表示します。
共有するのは記事の件名と原文URLで、RSS画面や非公開WikiのURLではありません。
URLはintentの`url`にだけ渡し、`text`へ重複させません。原文URLのない記事では表示しません。
通常の`target=_blank`リンクを一つだけ使い、JavaScriptによる二重openや自動投稿は行いません。
個人設定の「RSSの記事リンクの開き方」は`rss_link_mode`として保存します。既定は`tab`、
`embedded`を選ぶと原文リンクとHTML本文中の外部HTTP(S)リンクを同一タブ内の大きなdialogで開きます。
外部ページはクリック時だけiframeへ読み込み、閉じる際に破棄します。元の記事・一覧の状態は維持します。
Ctrl/Command/Shift付きのクリック等はブラウザ標準の別タブ操作を維持し、X共有アイコンも対象外です。
設定はRSS画面の再読込後に反映します。個人設定はタスク拡張のpreferencesに保存し、無効時は別タブを使います。
iframeは`allow-scripts`だけのsandboxと`no-referrer`を使い、親画面への操作・同一origin権限・
フォーム送信・popup等は許可しません。PagesWiki自身のoriginはiframe化しません。
リンク先のCSP/X-Frame-Options、ブラウザのmixed-content制限を回避するproxyは用意しません。
表示できないページやログイン・フォーム操作が必要な場合は、dialog内の別タブアイコンを使います。
表示可否をcross-origin DOMの読取で判定したり、失敗を装って自動で別タブへ遷移したりはしません。
### Geckoと自前Wispによる原文閲覧
通信中継方式を採用する。実装は独立した実験的ビューアとして段階導入し、現行の`tab`/`embedded`を
自動置換しない。Geckoビューア・中継・個人設定の接続を実装した。`viewer.gecko`は既定無効で、
管理者による有効化と中継の構成が揃った場合だけ選択できる。本番への配備は別途行う。
端末上の`gecko.js`で1ページを描画し、外部HTTP(S)通信だけを管理者が配置したWispサービスへ中継する。
サーバー上でFirefoxを起動したり画面をストリーミングしたりはしない。Firefox全体の操作画面は含めず、
既存の記事上dialogにcanvas、戻る・進む・再読込・閉じる・別タブの操作を置く。
自前中継を必須とし、Puter等の公開中継への自動fallbackは設けない。
現行upstreamはGeckoのソケット通信をWispへ接続する。通常のWebページの`fetch`へ単純に置き換えて
任意のサイトを直接取得することは前提にしない。GeckoとWisp実装は検証したrevision・プロトコルで固定し、
更新時にサイト互換性とセキュリティ修正を再評価する。
[gecko.js v0.0.1](https://github.com/HeyPuter/firefox-wasm/releases/tag/v0.0.1)、
[Wisp仕様](https://github.com/MercuryWorkshop/wisp-protocol/blob/main/protocol.md)。
中継はPagesWiki本体とは別コンテナ・別ネットワーク境界とする。外部から無認証で利用できる公開proxyにしない。
既存の認証・Domain・本人に束縛した短命セッションを発行し、WebSocketのOriginを検証する。
失効・ログアウト・拡張無効化は既存の接続にも反映する。Cookie・WikiのBearer token・FreshRSS資格情報を
外部ページへ渡さず、中継用の秘密をURLやログに残さない。
接続先は公開HTTP(S)用のTCPポートに限定し、UDPや任意の管理用ポートは許可しない。
DNS解決後の実接続先でloopback・private・link-local・metadata等を拒否し、IPv4/IPv6・DNS rebindingを
含めて検査する。接続検査だけでなくコンテナの外向き通信制限を併用し、Wiki・DB・管理ネットワークへ到達させない。
同時セッション・ソケット・帯域・idle/接続timeoutの上限を設ける。ログは通信量・失敗分類・処理時間に限り、
記事本文や資格情報を記録しない。HTTPSの証明書検証を無効化せず、HTML改変やTLS終端による閲覧制限回避は行わない。
原文クリック時だけエンジンを遅延ロードする。静的WASM資産はversion付きでキャッシュするが、
記事本文・Cookieの永続化は初期対象外とし、上限付きのメモリプロファイルを渡す。
固定版の`destroy()`はWASMの完全終了を保証しないため、初期実装では短時間保持を行わず、
閉じるとiframeごと破棄する。タブ非表示が60秒続いた場合も閉じる。
戻る/進むは最大64件のビューア内URL履歴から再読み込みし、フォームやスクロール位置は復元しない。
上流の最小GREではSessionStoreFunctionsがなく、標準history.back()は失敗する。
中継の接続数・転送量・拒否数は認証付きstatus/CLIで取得できる。設定UIへの監視統合と端末側計測は残件とする。
pthread/SharedArrayBufferのcross-origin isolationはRSSの親documentまで含めて検証する。
COOP/COEPをWiki全体へ一律追加せず、対象ビューだけで既存の壁紙・外部リソース・共有操作への影響を確認する。
isolation不可・端末のメモリ不足・未対応サイトではエラーと別タブ操作を示し、黙って外部中継や別タブへ切り替えない。
受入条件は、合成ページでのnavigation・日本語入力・検索・コピー、私有アドレス拒否・認証失効・中継停止・
資源上限・無効化、デスクトップとiPhone SEのSafariでの初回/再表示時間・スクロール・メモリ確認とする。
実記事での測定は明示した対象で行い、実FreshRSSの全原文や外部カレンダー・メール内容を自動巡回しない。
現時点ではChromiumで合成Wisp記事の描画・クリック遷移・ビューア内の戻る・接続破棄、
接続先制限・資格情報分離・ログアウト/拡張無効化時のWebSocket終了を自動テストした。
導入方法、資産hash、資源上限、外向きfirewallと本番前の残件は[Gecko中継の試験導入](../../operations/gecko-relay.md)にまとめる。
## 既読とstarの書戻し
server-authoritative stateと未送信の操作を分けます。操作ごとのrequest_idで重複を防ぎ、成功応答前に確定済みと表示しません。newsboat等で同時変更された場合、古いローカルcacheをまとめて送り返しません。接続解除・認可失効時は未送信変更を勝手に再送しません。
@@ -174,6 +268,39 @@ readbackは観測結果であり、exactly-onceやリモートCASの保証とは
背景タブでは停止します。記事の既読・star表示は遠隔の状態を確認するまで切り替えません。
再確認で希望値と異なる場合はconflictを表示し、新しい変更は利用者が明示的に操作します。
### 操作履歴の一覧と保全
ツールバーの時計アイコンから、リーダー内に操作履歴を開きます。モーダルは増やしません。
日時、記事・購読元、変更対象と希望値、状態をまとめ、記事がcache内なら本文へ戻れます。
スマホ幅では日時・件名・状態を縦にまとめ、再確認・保存のアイコンをタッチできる大きさにします。
既定の「未解決」はconfirmed/cancelled以外を表示し、処理中、結果不明、すべて、確認済み、
未送信、不一致、中止で絞り込めます。一覧はローカルDBだけを読み、外部通信や自動再試行を行いません。
履歴の更新は再読込アイコンと絞り込み操作で行い、記事画面の2秒pollは履歴画面では停止します。
`GET actions`のstatusは`unresolved`(省略時も同じ)、`pending`、`unknown`、`all`、
`confirmed`、`failed`、`conflict`、`cancelled`です。sourceは削除済みUUIDも指定できます。
続きは末尾のcreated_msとrequest_idを`before`/`key`として渡します。同時刻の操作も重複・欠落なく辿ります。
1回50件+続き判定の1件を読み、所有者の10,000件上限でソート量を制限します。
sourceや記事へのinner joinは使わず、削除済み購読元やcache窓から外れた記事の記録も残します。
記事名・購読元名は現在の取得済み情報であり、操作時点の監査snapshotではありません。
取得できない場合は元のsource UUID/記事IDと「削除済み」「キャッシュ外」を表示します。
結果不明の記録は、同じDomain・本人の有効なFreshRSS sourceが残り、claim期限を過ぎた場合だけ
読取専用再確認を予約できます。書戻しOFFでも再確認でき、readonlyアカウントは閲覧・保存のみです。
削除済みsourceは自動再接続しません。本人の記録に残るsource UUID、および全体の未解決操作に
残るsource UUIDの新規登録を拒否し、別接続先への誤った結び付けを防ぎます。
各行からJSON形式(`pageswiki.feed-action`、version 1)の記録を書き出せます。
Domain/本人/request ID、操作内容、状態、日時、現在の表示用メタデータを含み、
外部URL・資格情報・本文・内部claimは出力しません。ただし元の記事ID自体がURLの場合はそのIDを保持します。
一覧・保存ともDomain・本人で制限し、private/no-storeで返します。schemaはv5のままです。
保存操作はDBからの削除を意味しません。receiptを削除すると同じrequest_idの再送を防げなくなるため、
自動削除・一括削除は未実装です。後段の整理機能では、保全manifest・hash・対象件数を照合した上で、
成功/中止/失敗等の終端記録だけをarchiveへ移し、重複防止に必要なrequest_idと入力識別子を
tombstoneとして保持します。unknownや実行中の記録は移動・削除対象にしません。
tombstoneの保持期間・容量上限・旧クライアントからの再送時応答を決めるまで、現在の10,000件上限を維持します。
外部APIはlogin、記事参照、変更token、edit-tag、記事再参照の順です。記事の個別参照は
`POST stream/items/contents`(読取操作)、変更は`POST edit-tag`に`i`・`T`・`a`または`r`一項目を送ります。
URLや本文、資格情報を操作記録・ログへ保存しません。[FreshRSS API実装](https://github.com/FreshRSS/FreshRSS/blob/edge/p/api/greader.php)。
@@ -225,6 +352,23 @@ previewはsource UUID・設定versionのsnapshotを返し、適用時に一致
既定はURL、出典、短いメモの保存です。全文保存は取得可能性・利用条件・個人用途等を確認する独立操作とし、feedが短いからといって有料記事を自動取得しません。保存先が自動公開範囲なら内容と添付の公開を明示確認します。
タスク拡張が有効な場合、Wiki親Pathの初期値はDomain・本人単位の個人設定`wiki_prefix`を使います。
「個人設定 → メール・RSS取り込みの既定Wiki親Path」で設定し、メール取り込みと共通です。
RSS画面を読み込んだ時点の値を初期表示し、取り込みごとの上書き・空欄への変更を許します。
空欄でタスク作成を選んだ場合はWikiを作らず、個人設定の値を再適用しません。
未設定またはタスク拡張が無効な場合は空欄です。プロジェクトのWiki配下への暗黙の補完はRSSでは行いません。
保存時の公開範囲確認とACL検査は省略しません。既存preferencesを利用するため追加のschema変更はありません。
親Pathでは`{YYYY}`・`{MM}`・`{DD}`・`{Subject}`を使用できます。日付は取り込み時のドメインの
タイムゾーン、Subjectは編集可能な取り込み件名です。件名中の区切り文字・URI演算子・制御文字・
空白はハイフンに変換し、180バイト以内の単一Path要素へ整形します。空になる場合は`untitled`です。
未対応トークンや不正なPathは拒否します。メールcaptureでも同じ展開規則を適用します。
RSS取り込みは本文上のdialogで行い、本文を置き換えません。トークン挿入ボタンと実際の保存先を
表示し、件名・親Path・保存種別を変更した場合はプレビューを更新して公開範囲の確認をやり直します。
展開済みPathを確認後の要求へ固定し、UUIDの末尾(Wiki単独は`rss-`、タスク併設は`mail-`)で
同名記事の衝突を避けます。表示された親Path自体を記事ファイルとして上書きする仕様ではありません。
Wiki単独は親Path配下の `rss-{request UUID}` に新規作成します。既存Pathを上書きせず、Page・Path・
初回Revision・活動outbox・再送receiptを同じDB transactionで保存します。権限はtransaction内でも
再確認します。初期版の単独保存は通常Wiki空間のみで、独自所有契約を持つ`/u`・`/g`は対象外です。
@@ -241,12 +385,24 @@ Wiki単独は親Path配下の `rss-{request UUID}` に新規作成します。
- [x] RSS-1:read-only FreshRSS connectorと合成fixture。実接続の受入は別。
- [x] RSS-2:安全な共通一覧、出典付きWiki保存、任意のタスク化、ダッシュボード。
- [x] RSS-3:opt-inの既読/star書戻し、操作receipt、背景処理、readback、結果不明の再確認、失効・競合・排他の合成試験。
- [ ] RSS-3b:未解決操作の総覧、cache窓から落ちた記事や削除sourceの操作記録確認、保全付きreceiptの整理。既存のGET action/action/checkは記事IDで利用できる。
- [x] RSS-3b1:未解決操作の総覧、cache窓外・削除sourceの記録、再送しない再確認、個別JSON保存。50件ページング、本人分離、readonly、1440px/390pxの合成試験。
- [ ] RSS-3b2:保全manifestの照合、終端receiptのarchive、重複防止tombstoneと保持期間・容量上限。未知結果の記録を捨てない。
- [x] RSS-4a:内蔵簡易reader、購読設定、既読・star、背景取得。
- [x] RSS-4b:OPML export/importのpreview、選択追加、重複確認、原子的な保存と再送防止。置換・状態移行は範囲外。
- [ ] RSS-5:FreshRSS実環境の接続先・版・API資格情報を指定してread-only受入。
- [ ] RSS-6:大規模利用時の公平性、host別並列上限、Retry-After/backoff、資格情報rotation UI。
- [x] RSS-7:FreshRSSの購読一覧・カテゴリを使うnavigation。同名ID分離、複数カテゴリ、cache内絞り込み、背景での原子的更新、失敗時保持。
- [x] RSS-7b:分類フォルダの継承、空フォルダ・未分類、開閉状態保存、50件ずつの購読描画、分類移動への追従。schema v6の再実行・失敗rollbackと1440px/390pxの合成試験。
- [x] RSS-7c:Shift+j/kによるフォルダ選択。空・未分類・端・購読選択中・検索維持・入力/モーダル抑止・連打を合成試験。
- [x] RSS-8a:Gecko端末描画+自前Wisp中継の方式決定。公開中継を使わず、独立・既定無効で導入する。
- [x] RSS-8b1:upstream v0.0.1/hash固定、最小埋め込みと親documentのisolation、Chromiumで合成記事の描画・遷移確認。
- [ ] RSS-8b2:Safari/iPhone SE実機、IME・コピー・実サイト互換性。固定配布物のlicense/notice整備、HTTPSと証明書エラー、日本語findの合成試験は実施済み。
- [x] RSS-8c1:認証付きWisp TCP profile、公開IP/port制限、失効・資源上限・管理者/CLI無効化・内部status。
- [ ] RSS-8c2:運用ホストの外向きfirewall、設定UIへの中継監視統合、負荷時の長時間受入。
- [x] RSS-8d1:個人設定の選択、1ページのpopup閲覧、戻る/進む/再読込/別タブ/終了。
- [ ] RSS-8d2:初回/再表示・低メモリ端末の性能評価、実行中の切断・複数タブのUX、本番配備。起動上限と起動失敗時のiframe破棄・原文リンクへの退避は実装済み。
一覧には配信日と配信時刻(HH:mm)を分けて表示します。Domainの設定タイムゾーンを使い、tooltipには年・秒・タイムゾーンを含めます。配信日時不明は「—」とし、取得日時で補いません。モバイルでも時刻欄を残します。
隔離試験はRSS/Atom・FreshRSS login/read、欠落ID・巨大/不正feed、条件付きGET、失敗時cache保持、
本人分離・失効・readonly、二重送信・版競合・旧worker拒否、migration再実行/失敗rollback、
+4 -4
View File
@@ -103,15 +103,15 @@ P0は認可・整合性・復旧の安全条件、P1は日常利用の回復性
| SHARE-01 / P2 | 未実装:委譲share URL、期限/失効/監査、説明可能な権限総覧 | AUTH-01、PUB-01。login/adapter/federation資格情報と別目的、単一Page投影、caveat・依存物の失効を検証 | [公開](publication.md)、[Schutzaria](schutzaria.md) |
| COLLAB-01 / P2 | 一部実装:Page等の変更購読、最近閲覧/編集、集約通知。コメント/反応/評価は未実装 | OUT-01。現在権限で再投影、private履歴のopt-in/保持。inline commentはRevision変更時の孤立・再接続を扱う | [拡張](extensions.md) |
| BLOG-01 / P2 | 一部実装:安全なtDiary import、最近コメント、遠隔ブログ射影 | COLLAB-01、遠隔はFED-01。importは再開/重複抑止/dry-run。同一instance射影を再実装しない | [ブログ・日記](blog-diary.md) |
| CSV-01 / P2 | viewerのみ実装:別Documentを投影するCSV macro/editor、ODS境界 | 行列・セル・総量上限、Revision固定、権限、CSV引用/改行fixture。表示HTMLをCSV正本へ逆流させない | [表設計](extensions.md) |
| DIAGRAM-01 / P2 | 一部実装:nwdiag/Draw.io provider、slide preview/editor | RENDER-01。安全なSVG・include拒否・renderer版固定、ticket/CAS保存、print。既存Excalidraw/Krokiとは分ける | [Kunstzeal](kunstzeal.md) |
| CSV-01 / P2 | viewer・有界CSV macro・既存CSVの表編集/複数セル貼り付けを実装。残件:新規作成UI、大容量編集、矩形選択/範囲コピー、匿名投影、asset指定、ODS境界 | BOM/改行保持、25行描画、行列・セル・総量上限、貼り付けの一括検証/Undo、Revision CAS、権限、競合確認/履歴復元fixture。表示HTMLをCSV正本へ逆流させない | [表設計](extensions.md) |
| DIAGRAM-01 / P2 | Reveal.jsビューア/編集プレビューを実装。残件:nwdiag/Draw.io provider、縦スライド・notes・専用print | RENDER-01。有界入力、sandbox、固定版ローカル同梱、ドメイン単位停止、Path認可。SVG・include拒否・ticket/CAS保存はprovider別に検証 | [Kunstzeal](kunstzeal.md)、[スライド](extensions.md) |
| RECIPE-01 / P2 | 未実装:構造化レシピmetadataとPage投影の初期slice | 材料・数量・未知単位を保持、人数変更は派生値、Asset認可、版競合、出典・公開確認 | [料理レシピ](recipe-management.md) |
## D. 選定・別サブプロジェクト
| ID / 優先 | 状態・次の作業 | 着手ゲート・最初の検証 | 詳細 |
| --- | --- | --- | --- |
| RSS-01 / P2 | 一部実装:内蔵簡易正本、FreshRSS読取connector、3ペインUI・HTML本文、Wiki保存・タスク化・dashboard、OPML確認付き入出力 | 残件はFreshRSS既読/star書戻し、購読/カテゴリnavigation、実接続受入、公平性/backoff。managed schema feeds v3・隔離fixture。本番未反映。二重正本・停止時の自動切替なし | [RSS](feeds.md) |
| RSS-01 / P2 | 一部実装:内蔵簡易正本、FreshRSS読取・既読/star書戻し、購読/カテゴリnavigation、3ペインUI・HTML本文、Wiki保存・タスク化・dashboard、OPML、配信時刻 | 残件は実接続受入、公平性/backoff、Gecko実機・運用受入。個別の実装/受入状況はRSS設計を参照。二重正本・停止時の自動切替なし | [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) |
@@ -126,7 +126,7 @@ P0は認可・整合性・復旧の安全条件、P1は日常利用の回復性
- **HOLD-01**:`/tasks/` 配下のメールWikiルーティング調査。利用者の棚上げ指定を維持。関連未コミットファイルを今回の実装・文書コミットへ混ぜない。
- **HOLD-02**:vim.wasm runtime改善とnativeアプリ起動。既存設定UIは残すが、自動的に再開しない。
- **HOLD-03**:全面WYSIWYG、E6 CRDT/OT共同編集。まずEDIT-01と認可/presence契約、保存量・オフライン・競合モデルを確定する。
- **HOLD-04**:本番への反映。作業履歴/日次メールのv3/v4移行を含む同世代保全と隔離復元試験、容量確認、SMTP副作用照合が必要。古いbinaryを新schemaへ向ける切戻しは禁止。
- **HOLD-04**:本番反映は実装と別ゲート。[v0.15.0までの配備](../../operations/releases/2026-11-08-v0.15.0.md)は完了。追加変更には同世代保全と隔離復元試験、容量確認、外部副作用照合が必要。古いbinaryを新schemaへ向ける切戻しは禁止。
## 実装と分けて管理する受入
+2 -1
View File
@@ -111,7 +111,8 @@ Cache-Control: private, no-store
- [ ] ディスクcacheの容量・TTL・清掃、renderer更新時の不整合、障害後の一時ファイル残留を管理する。
- [ ] provider宛通信と描画サービス内の外部参照を分け、送信許可・接続先・ネットワーク隔離・バージョン固定を契約化する。
- [ ] nwdiagの有界parser・安全なSVG出力・編集preview、Draw.io等のproviderを追加する。現在のregistryにnwdiagは実装されていない。
- [ ] Reveal互換・HedgeDoc・Slidev・CSS-onlyスライドのimport/save/printを独立providerとして設計する。
- [x] Reveal.jsの有界ビューア・既存HTML/Markdownエディタ内previewをローカル固定版で接続する。Path認可・sandbox・ドメイン停止を持ち、正本への保存は既存エディタを利用する([スライド設計](extensions.md))。
- [ ] Revealの縦スライド・発表者notes・専用print、HedgeDoc・Slidev・CSS-onlyスライドのimport/save/printを独立providerとして設計する。
- [ ] Excalidrawのhosted/browser実行とPDF/動画サムネイル・metadata subprocessを、各々の安全境界を維持したまま段階的に接続する。
## 検証と反映
+8
View File
@@ -14,6 +14,14 @@ childrenは現在Pathを既定にし、表示形式は本文macroの `view` 引
`/v/tree/{path}` は範囲を限定します。展開・全展開・全折りたたみ状態の保持、複数選択、rename・移動・削除はPath操作と一致させます。一般の子一覧から予約ユーザー領域を混入させません。再帰操作は事前の全対象確認と競合検出が必要です。
## Browserのアップロード
`/v/browser/{path}` の一覧へファイルをドロップすると、現在のPath配下へアップロードします。フォルダ行へのドロップではそのフォルダが宛先になります。既存の内部Path移動・選択操作とは区別します。
右下のフローティングカードに待機・送信中・完了・失敗・取消と進捗を表示します。追加ドロップは同じキューへ積み、送信は1件ずつ、最大100件・各256 MiBまで。待機中の取消、折りたたみ、終了分のクリアに対応します。終了後は一覧だけを再取得し、キューは残します。
既存の認可付き `/v/upload` を使用し、`If-None-Match: *` で同名Pathの上書きを防ぎます。通信断は保存結果不明として扱い、自動再送しません。キューはページ内のみで、ページ離脱・再起動後の再開やフォルダの再帰アップロードには未対応です。新規オブジェクト・Path・初回Revisionの一体的なトランザクション化は残課題です。
## ホームとブックマーク
通常トップバー型、中央検索型、検索+セクションカード型を選びます。セクションは手動URL/Path、または指定親の子リンクを表示します。設定は歯車のポップアップで、閲覧画面を編集フォームで埋めません。カード列はviewportに適応します。
+66 -4
View File
@@ -1,6 +1,6 @@
# オーガナイザーのナビゲーションと個人ダッシュボード
タスク・カレンダー・連絡先の入口を共通化し、個人設定と日々の振り返りを分離する。ダッシュボードは本人の作業を見る画面であり、サーバーの実行状態・リソース監視画面とは別に扱う。以下は2026-11-02のソース実装範囲で、2026-11-04にv0.7.0として本番へ反映した。移行・検証・復旧点は[本番反映記録](../../operations/deployments/2026-11-04-v0.7.0.md)を参照する。
タスク・カレンダー・連絡先の入口を共通化し、個人設定と日々の振り返りを分離する。ダッシュボードは本人の作業を見る画面であり、サーバーの実行状態・リソース監視画面とは別に扱う。初期実装は2026-11-04にv0.7.0として本番へ反映した。2026-11-09の追加実装は、明日の予定・コマンドウィジェット、件名Markdown、参照欄、個人の外観設定。これらの追加分は本番未反映。
## 入口と設定の配置
@@ -10,13 +10,14 @@
| --- | --- |
| `/v/plan/dashboard` | ウィジェット形式の個人ダッシュボード |
| `/v/plan/tasks` | 既存のインライン編集可能なタスク一覧 |
| `/v/plan/tasks/index` | neomutt風のキーボード操作によるタスク一覧 |
| `/v/plan` | 既存のカレンダー表示。保存されたビューを尊重 |
| `/v/plan/contacts` | 個人アドレス帳・履歴・CardDAV接続 |
| `/-/sys/config?panel=organizer` | タスクの既定値、日次メール、既定のカレンダー |
| `/-/sys/config?panel=organizer` | タスクの既定値、日次メール、既定のカレンダー、個人の外観 |
旧 `/v/plan/tasks/report` はダッシュボードの達成度ウィジェットへ、旧 `/v/plan/tasks/settings` は個人設定へ303リダイレクトする。カレンダーの表示選択ダイアログはその場の表示変更に使い、既定値の永続化は個人設定へ移す。
個人設定は通常の設定画面と同じURI体系・テーマを使うが、専用の軽量な画面として返す。GET/HEADかつ正確な `panel=organizer` の場合だけ個人向けハンドラーに振り分け、管理用設定やアカウント一覧は取得・描画しない。POSTの管理者チェックは緩和しない。保存先は既存の本人用APIであり、一般利用者に管理権限を付与しない。
個人設定は通常の設定画面と同じURI体系・テーマを使うが、専用の軽量な画面として返す。GET/HEADかつ正確な `panel=organizer`、またはPOSTで `panel=organizer&section=appearance` の場合だけ個人向けハンドラーに振り分ける。管理用設定のPOSTは従来どおり管理者を要求する。個人設定の保存は本人のactiveアカウントに限定し、管理権限を付与しない。
## タスク編集画面と通知既定値
@@ -26,6 +27,43 @@
760px以下では1カラムにし、主な入力と選択ボタンは44px以上のタッチ領域を確保する。個人設定には新規タスクの期限日・取り組む日のInbox通知と通知時刻を設ける。適用条件と既存データの扱いは[タスク通知](task-reminders.md)を参照する。
## キーボード操作のタスク一覧
`/v/plan/tasks/index` を既存のインライン編集とは別の表示として提供する。タスク画面の「キーボード一覧」から開く。左側はプロジェクト、右側は状態・件名・期限・取り組む日・優先度・関連Wikiの表。件名Markdownと選択行のテーマ色を使い、サブタスクは矢印で区別する。順序は指定ソートを優先し、親子の隣接は保証しない。
| キー | 操作 |
| --- | --- |
| `j` / `k`、上下矢印 | 次/前のタスクを選択 |
| `Ctrl+j` / `Ctrl+k` | 次/前のプロジェクトへ表示を切り替え(所属変更ではない) |
| `o` / `O` | ソート選択欄へ/昇順・降順を反転 |
| `l` / `Esc` | 絞り込み欄へ/一覧へ戻る。絞り込みはEnterで適用 |
| `d` | 選択タスクを完了。削除やアーカイブではない |
| `s` | 選択タスクで25分Pomodoroを開始。実行中セッションは上書きしない |
| `c` / `m` | 作成/既存の編集ダイアログを開く |
| `w` | 関連Wikiへ移動。リンクがなければ案内し、暗黙に新規作成しない |
| `?` | キーと絞り込み式のヘルプ |
入力欄、IME変換中、ダイアログ表示中にはショートカットを実行しない。更新系キーはキーリピートを無視する。作成時は選択中のプロジェクトを引き継ぎ、「すべて」では個人の既定値、「プロジェクトなし」では明示的な未所属とする。ブラウザやOSが予約しているキーをページ側へ渡さない環境では、同じ操作を画面のボタンから行う。
初期絞り込みは `~active`。複数条件はAND、`!` を条件の前に付けると否定する。OR・括弧・正規表現は扱わない。空欄はアーカイブ以外の全状態を表示する。
| 書式 | 意味 |
| --- | --- |
| `~s "リリース準備"` | 件名の部分一致。空白を含む値は引用符で囲む |
| `~active` / `~todo` / `~doing` / `~done` / `~cancelled` | 未完了/未着手/着手中/完了/取りやめ |
| `~overdue` | ドメインの今日より前に期限を迎えた未完了タスク |
| `~due <=today` / `~planned tomorrow` / `~start >=2026-11-01` / `~review <today` | 期限・取り組む日・着手日・見直す日。日付はYYYY-MM-DD、today、tomorrow。比較は `= < <= > >=` |
| `~due none` | 日付なし。planned、start、reviewにも使用可能 |
| `~bucket inbox` / `~bucket backlog` / `~bucket someday` | 整理先 |
| `~priority 3` | 優先度0〜3の一致 |
| `~wiki` / `~attachment` / `~archived` | 関連Wikiあり/URL・Path参照あり/アーカイブ済み |
例:`~s "リリース" ~doing !~overdue`。プロジェクト・条件・ソートはURLクエリへreplaceStateで保持し、操作ごとに履歴エントリを増やさない。
取得は既存 `items` APIの `view=index`。`filter`、`sort`(due/planned/title/status/priority/created/updated)、`order`(asc/desc)、`project`、`before`を使う。未所属は `project=none`。サーバーで対象全体を絞り込み・ソートして100件ずつ取得し、末尾での下移動または追加読込で次を取得する。ソート値とUUIDによる順序を使い、他ユーザーのカーソルから内容を返さない。日付未設定は昇順の末尾、完全な逆順では先頭になる。並行更新時の固定スナップショットではないため、再読込で最新状態を確認する。
条件は1000バイト・最大64トークン。SQLは値をバインドし、ソート列は許可リストから選ぶ。不正条件は422で、旧表示を残して操作ボタンを無効化する。プロジェクトも検索・50件単位の追加読込とし、一括取得しない。完了は表示時のversionをIf-Matchで送る。別更新があれば412で止め、メモ等を最新取得しても古い選択行からの更新を無条件に通さない。本人の権限・読み取り専用制限は既存APIに従う。この一覧追加にDBスキーマ変更はない。
## ウィジェット
初期構成は次の6種類。任意のHTML・iframe・外部URL・スクリプトを登録する機能ではなく、サーバーが許可する組み込みIDを使う。
@@ -39,13 +77,15 @@
| `schedule` | 既定カレンダーにある今日の予定 |
| `activity` | 完了数・ポイント・作業時間・集中時間、日別ヒートマップ |
追加メニューには `feeds`(RSS)、`tomorrow-schedule`(明日の予定)、`commands`(タスクコマンド)も用意する。既存の保存済み配置に自動追加せず、追加後に「配置を保存」で確定する。予定は時刻範囲・件名・カレンダー名をカード状に配置し、開催中の予定を強調する。終日予定は時刻の代わりに「終日」を表示する。
タブはウィジェットの枠内で内容を切り替える。iframeを使わず、ページやブラウザ履歴を移動しない。タスク件名や右上の矢印は既存の詳細・一覧へ移動する。タスクの編集操作は従来の一覧・詳細画面を利用する。
達成率の分母は `planned_on=今日`、分子はそのうち `status=done` の件数。取りやめ・アーカイブ・プロジェクトを除く。日付はドメインのタイムゾーンで判定する。対象0件は100%でなく「—」を表示する。期限超過を含む「本日のタスク」の件数とは意図的に異なり、画面に定義を明記する。ヒートマップのポイント計算は[タスクの集計契約](task-productivity-contacts.md)に従う。
## 配置と保存
デスクトップは12列グリッド。幅は3〜12列、高さは2〜10単位、1単位の表示基準は72pxと12pxの間隔。順序に従ってグリッドへ配置するため、幅の組み合わせによって空白が生じる。任意の絶対座標を保持するレイアウトではない。
デスクトップは画面幅いっぱいの12列グリッド。幅は3〜12列、高さは2〜10単位、1単位の表示基準は72pxと12pxの間隔。順序に従ってグリッドへ配置するため、幅の組み合わせによって空白が生じる。任意の絶対座標を保持するレイアウトではない。
歯車で配置モードを開き、ハンドルのドラッグで並べ替え、右下のハンドルでサイズを変える。矢印ボタンと幅・高さの選択欄でも同じ操作が可能。追加・除去・初期配置への復帰に対応し、「配置を保存」で確定する。タブの選択も配置の一部として保存できる。未保存の離脱を警告し、保存失敗・競合時には編集中の配置を残す。ブラウザ再起動をまたぐ未保存レイアウトの下書きは持たない。
@@ -69,6 +109,28 @@ APIは `/_/api/v1/extension/organizer.tasks/` 配下。
## 検証と後続範囲
### タスク表示と参照
件名の保存形式は文字列のまま。Web一覧では太字、斜体、取り消し線、インラインコード、リンクのラベルをDOMで描画する。HTML・画像・マクロを実行しない。インライン編集のフォーカス中はMarkdownソースをそのまま入力できる。関連Wikiがある行は塗りつぶした文書アイコンとテーマ色で区別する。
`TaskRecord.references` はURLまたはWiki Pathの配列(最大20件、1件4096バイト)で、タスクの編集画面の詳細設定から変更する。http/httpsと同一サイトの絶対Pathだけを認め、認証情報入りURL・プロトコル相対URL・制御文字は拒否する。リンク先の取得や公開範囲の変更は行わない。Path参照は文字列のためrenameには追従しない。rename追従が必要な主たる関連Wikiには従来の `page_uuid` を使う。
正本JSONと変更履歴に参照を保存し、タスクの列追加は不要。旧CLI等がこのフィールドを省略した更新では既存値を維持し、明示的な空配列で解除する。CalDAV更新でも維持するが、VTODOのATTACHへの投影は後続範囲。
### タスクコマンド
`add task 件名`、`today UUID`、`tomorrow UUID`、`due UUID YYYY-MM-DD`、`due UUID clear`、`done UUID`、`delete UUID` を提供する。対象は件名検索のサジェストから選ぶとUUIDが入る(250ms debounce、最大10件)。シェルコマンドではない。追加は個人の既定値を読み、通信失敗時は同じUUIDで再試行できる。既存タスクへの操作は取得時のversionをIf-Matchで送信し、競合時は上書きしない。削除は件名を確認してから実行する。今日・明日はダッシュボード読込時のドメイン日付を基準とする。
### 個人の外観とログイン画面
壁紙Path・不透明度・グラス透明度・壁紙からの色抽出を個人設定へ追加する。トップ画面の歯車も同じ本人用保存先を使う。初回は既存のドメイン設定を初期値として引き継ぎ、保存後は個人値を優先する。空の壁紙Pathは「壁紙なし」。フォルダ選択時は従来どおり閲覧可能な直下の画像から選ぶ。
`personal_appearance` はDomain UUIDと本人UUIDを複合キーにしたJSON+versionのテーブル。起動時の設定テーブル初期化で追加する。既存テーブル・正本を破壊せず、保存はversion比較で競合409を返す。タスク既定値・メール同意のversionを変更しない。ドメイン設定画面の外観項目は初期値用として区別する。
ログイン画面は壁紙なしとし、旧 `/_/auth/wallpaper` は404を返す。個人・ドメインのトップ壁紙をログイン前に公開しない。別のログイン専用背景Pathは今回追加しない。
### 回帰検証
合成データで、所有者分離、CAS、読み取り専用、匿名拒否、管理設定への権限拡大がないこと、空配置、禁止ウィジェット、メール設定の不変、今日の集計・予定範囲を検証する。ブラウザではデスクトップとスマホの導線、タブ、設定保存、配置保存、横はみ出しを確認し、デスクトップのドラッグ・リサイズには実ポインター入力を使う。本番の外部取り込みカレンダーは検証に使わない。
次段階は以下を別途設計する。
+6
View File
@@ -23,6 +23,12 @@
### 3. テーマ・アカウント・連絡先
- [x] 信頼できる端末の長期ログイン(2026-11-08ローカル実装、本番未反映):ログイン画面の明示選択で最大30日。Domain管理者は設定→セッションで0〜30日(0で無効)を指定する。通常ログインは既存の絶対期限を維持。パスワード/TOTP、LDAP、OIDC、SMTPマジックリンクに適用し、選択は認証challengeに固定する。CookieとBearerの期限はDBの発行期限と一致し、ログアウト・管理者失効・アカウント停止で無効になる。既存セッションの延長、TOTPの省略、アクセスによる期限延長は行わない。
- [x] 独立CLIの `pages login --remember` / `pages login --oidc --no-browser --remember`。S256 grantに選択を保存し、ブラウザ側のクエリで上書きできない。APIセッションは承認元ブラウザの残存期限を超えない。期限切れ後はlogoutなしで再認証でき、同一アカウントのcwdと未送信タスク下書きを保持する。別アカウントへの下書き移動は拒否する。旧サーバーは選択を無視する場合があるため、実際の期限は応答のexpires_inを正とする。
- [x] タスク編集フッターの関連ページ導線(2026-11-08ローカル実装、本番未反映):アーカイブ・削除・保存と同じ並びに関連ページリンクを表示。新規タブで開き、編集中の内容を保持する。保存済みの関連Pageがない場合、解除した場合、Path変更が未保存の場合は非表示。デスクトップ/モバイル4幅のブラウザテストを追加。
長期ログインのDB変更はmanaged component `cli-auth` v2の `remember` 列追加のみ。既存行はfalse、既存セッションと文書・タスクデータは変更しない。端末名・一覧・個別端末の信頼登録、refresh token rotationは別設計とし、今回は既存セッション管理から失効する。
- [x] 共通ナビの◐からプリセットを選択、リロードせず切替。host限定Cookieに保持し、Domain既定に戻せる。登録済みテーマのみ許可。Domain設定/アカウントの全端末設定ではなくブラウザ上書き。失敗時は現在テーマを保持する。
- [x] 絶対セッション期限:設定→セッション、5〜43200分、既定1440分。Domain単位で新規ブラウザ/APIログイン(OIDC/LDAPを含む)に適用。発行時にDBの期限を固定し、Cookie/APIのexpires_inにも反映。既存セッションの期限とCalDAVアプリパスワードは変更しない。管理者認可とサーバ側失効をfixture検証。
- [ ] 無操作タイムアウトとアカウント別の短縮上書き:background pollingを人間の操作とみなさないactivity契約、再認証、既存セッションへの即時適用を別途設計する。
+8
View File
@@ -26,6 +26,14 @@ v0.3.0のOIDCログインは利用者の動作確認済み。v0.4.0ではOIDC承
## 利用方法
### 信頼できる端末でのログイン継続
2026-11-08ローカル実装、未リリース。独立CLIと対応サーバーを更新すると、`pages login --remember` または `pages login --oidc --no-browser --remember` で最長30日のセッションを要求できる。管理者の `auth_trusted_session_days`(既定30、0で無効)に従い、応答の `expires_in` を期限として保存する。旧サーバーでは通常の期限になる場合がある。
パスワードログインは必要なTOTPを維持する。選択はTOTP challenge/OIDC grantへ固定し、認証完了時の追加パラメーターで変更できない。CLI grantはmanaged component `cli-auth` v2で `remember` 列を追加し、既存行をfalseとして保持する。承認済みgrantの交換とセッション発行は従来どおり単一トランザクションで処理し、期限は承認元ブラウザの期限を超えない。
ローカル期限切れ後は `logout` を挟まず再ログインできる。同一アカウントならcwdと未送信タスク下書きを保持し、認証失敗時は従来のローカル状態を変更しない。ログアウト・管理者による失効・アカウント停止は長期セッションにも適用する。共有端末では使用しない。
```sh
# 初回設定。パスワードはlogin時の非表示プロンプト、必要ならTOTPを続けて入力。
pages configure --origin https://pages.example.test --username anya
+34 -1
View File
@@ -11,7 +11,7 @@
- 見直し:見直す日を迎えたもの、または30日間変更されていない未完了タスク。
- プロジェクト:名前とメモ、関連Wiki、所属タスクの一覧。タスクは一つのプロジェクトへ所属、または未所属。
- タスク:件名、プレーンテキストのメモ、状態、優先度、分単位の見積もり、期限、取り組む日、見直す日、関連Wiki。
- 完了/再開、アーカイブ/復元。完了取消でも過去の版は残る。初版は物理削除を提供しない。
- 完了/再開、アーカイブ/復元。完了取消でも過去の版は残る。タスクの削除はアーカイブとは別の操作(下記)。
- タイトル絞り込みとカーソルページング、変更履歴の版番号・日時表示。
- 日本語/英語、既存テーマ、デスクトップの左ナビとモバイルの横ナビ・全画面編集モーダル。
@@ -34,6 +34,39 @@
一覧GETは `kind=task|project`、`view`、`project`、`q`、`limit`、`before` を受け付けます。既定60件、上限100件。作成はPOST、更新はPUT、`If-Match: "{version}"` 必須。ヘッダーなしは428、古い版は412。UUIDをクライアントで生成し、同内容の作成再送は同じ版を返します。異内容の再送は競合です。成功時は `item` と現在読める `page_path`、ETagを返します。一覧はメモ本文を省略するため、編集やクイック完了前に必ず詳細を取得します。
## タスクの削除
2026-11-08、v0.14.0で本番反映済み。[配備記録](../../operations/releases/2026-11-08-task-deletion.md)。
UUID検索は追加せず、既存のタスク編集画面で「アーカイブ/復元」の隣に「削除」を置きます。未保存の新規タスク、readonly、プロジェクト編集には表示しません。件名と削除範囲を確認してから実行し、削除失敗時は編集内容を保持します。アーカイブ済みタスクも同じ操作で削除できます。
- `DELETE /_/api/v1/extension/organizer.tasks/items/{uuid}`。PUTと同じ厳密な `If-Match: "{version}"` を要求し、成功204、未指定428、古い版412。成功応答を失った場合、同じ所有者・同じ削除前の版で再送できます。
- 所有者・Domain・active状態・システム拡張の有効状態を同一writer transactionで再検査。他人の対象/削除記録は404。プロジェクトの削除は提供しません。
- サブタスクがあれば409 `has_children`(アーカイブ済みも対象)。先に移動または削除します。実行中/一時停止中の集中セッション、実行中の作業記録があれば409 `working`。再帰削除・自動停止はしません。
- head・版参照・期限通知予約・達成度メトリクスを削除し、カレンダー時間枠との関連は解除します。Wiki本文、カレンダーの予定、記録済みの作業時間は独立した記録として残します。削除タスクは通常/アーカイブ一覧・詳細・変更履歴から取得できず、復元操作もありません。
- `organizer_task_deletions` にDomain、所有者、UUID、collectionで修飾したDAV名/UID、削除版、削除時刻だけを保持します。件名・本文は複写しません。DBとDocument Storeを一緒に保全する既存方針は変わりません。CASファイルや既存バックアップの安全消去を意味せず、保持期間・GCは別課題です。
- 削除記録・head除去・関連索引の更新・変更ジャーナル/共通outboxは原子的にコミット。履歴移行ジョブは削除記録から種類を解決し、head欠落で停止しません。
- DAVの一覧/REPORTから対象を除き、GETは404、multigetは対象ごとに404。旧ETagでのPUTは412。同じcollectionの同じUIDまたはhrefを使う新規/無条件PUTは既存の `no-uid-conflict` で拒否し、古い端末からの復活を防ぎます。削除済みUUIDへのJSON再作成は410。同名の件名を持つ**新しいUUID/DAV UID・href**のタスクは作成できます。DAV識別子の予約は索引再構築後も保持します。
- 従来の「DAV DELETEをアーカイブへ変換する」互換動作は変更しません。今回追加した不可逆操作はWeb/APIからの明示的な削除です。クライアント固有の同期/競合UIの挙動まで保証するものではありません。
`internal/server/task_delete_test.go` で条件付き削除・権限・再送・DBロールバック・通知取消・作業履歴保全・DAV索引再構築/再送拒否を検証します。既存のChromiumテストに、削除ボタンの位置、確認キャンセル、版競合、成功後の一覧更新を追加しています。本番データの削除は実施しません。
### 削除済みメール取り込みの再作成
PagesWiki v0.14.1/pages-cli v0.4.2で実装、2026-11-08 19:42 JSTに本番反映済み。[配備記録](../../operations/releases/2026-11-08-task-capture-recovery.md)。サーバーとCLIの両方の更新が必要です。DBスキーマ変更や既存データの削除はありません。
`POST /_/api/v1/extension/organizer.tasks/capture` は、受付記録に対応するタスクの状態を本文ハッシュより先に確認します。削除済みなら同じ内容・異なる内容とも410 `deleted`。タスクと削除記録が両方欠落していれば409 `capture_missing` とし、自動修復・再作成はしません。存続中のタスクへの異内容再送は従来どおり412です。
削除済み要求の保留下書きは `pages task retry REQUEST_UUID --recreate-deleted` で明示的に再取り込みできます。CLIは新しい要求を送る前に保存し、以降の再送用IDを表示します。通信失敗後は表示された新IDで通常の `task retry NEW_REQUEST_UUID` を使います。メール本文・Wiki suffixは保持し、以前のタスクの状態・作業時間・子タスクを復元する操作ではありません。
- APIには `replaces_deleted` に元のrequest UUIDを渡します。新しい `request_id` はURL名前空間のUUIDv5で、名前は `pages:task-recreate:` と元のrequest UUIDを連結したもの。任意の後継IDを拒否し、同じ再取り込みの二重作成を防ぎます。
- 同じDomain・所有者の受付記録と削除記録を要求し、元タスクが存続中なら412、他人の受付記録や不存在の要求は404。writer transaction内でも検査します。受付記録のない直接作成タスクには使えません。
- 新しいタスク・受付記録・変更履歴・通知予約を原子的に保存します。旧受付記録、削除記録、DAV識別子の予約は残し、旧端末の再送による復活を防ぎます。
- Wiki保存先にページが残っていれば、そのUUIDを新しいタスクに関連付けます。本文・リビジョンは上書きしません。存在しなければ保留本文から作成します。read/create/writeの現在権限と入力上限を検査し、ファイルなどページ以外との衝突は409です。保存先は保留要求と現在の既定値から解決するため、移動済みのWikiや既定Path変更を追跡して復元する機能ではありません。
- 再作成済み要求の再送は同じ新タスクを返します。そのタスクも削除済みなら410で停止し、さらに復活させません。元のメールを再入力しただけでは削除済み状態を解除しません。
`internal/server/task_capture_recreate_test.go` でライフサイクル・並行再送・所有者境界・ロールバック・Wiki保持を検証し、CLIの単体テストとHTTP結合テストでも再送IDの保持を検証します。
## 保存と復旧の境界
`organizer_items` はDomain・所有者・UUID・種類・検索用メタデータ・現在版を保持します。本文を含む型付きJSONは既存Document StoreへSHA-256で保存し、同じJSONをDBにも保持します。`organizer_revisions` は版からDocumentへの参照、`organizer_changes` は後続処理用の小さな変更ジャーナルです。head更新・履歴・変更ジャーナルは同じSQLiteトランザクションです。
+101
View File
@@ -0,0 +1,101 @@
# Gecko連携の再配布条件
PagesWiki v0.13.0ではGeckoエンジンの配布を保留しました。
現在は固定版のエンジン、対応ソース、第三者NOTICE、日本語フォントを含む配布bundleを生成できます。
実験機能`viewer.gecko`は既定無効のままです。relayイメージとbundleは別物で、
起動時にbundle全体を検証してから資産を配信します。
本書は今回追加した部品の配布判断と残件を整理するもので、プロジェクト全体の法務監査ではありません。
## 部品と適用条件
| 部品 | 固定する出典・版 | ライセンスと配布時の扱い |
| --- | --- | --- |
| PagesWiki連携・Go relay | このリポジトリのリリースcommit | 自作コード。上流の実装をコピーせずWispフレーム仕様に対応。GeckoのライセンスをWiki全体へ一律適用しない |
| Go runtime / 標準ライブラリ | relayのビルドに使うGo 1.25系 | BSD-3-Clause。実ビルド環境のLICENSEを専用イメージ内`/licenses/Go.txt`へ収録 |
| golang.org/x/net | v0.35.0、WebSocket実装 | BSD-3-Clause。モジュールのLICENSEを`/licenses/golang-x-net.txt`へ収録 |
| Gecko / Mozillaの第三者コード | Firefox fork `2e1e835a5da5907e5ceef19aade58a7493f1e34d` | 主にMPL-2.0。ただし多数の個別licenseがあり、MPLだけの表示では不足。固定commitの総合noticeと該当sourceを扱う |
| gecko.js wrapper / WASM追加コード | v0.0.1 `eadcb5fa828d7e8b54ae2df13b6b3208f6553944` | 後述のMPL追加commitを確認。固定配布物にはLICENSE一式がないため、tarをそのまま再公開しない |
| Emscripten runtime / WasmFS | 6.0.1と上流のpatch | Emscripten本体はMITまたはUIUC/NCSA。libc等のruntime依存には別noticeがあるため、ツールチェーンの最上位LICENSEだけでは棚卸し完了としない |
| zstddec | 0.2.0 | npm metadataは`MIT AND BSD-3-Clause`。JS wrapperと組み込まれたdecoderの両noticeを保持 |
| Liberation fonts | 上記Firefox commit内のPDF.js standard_fonts | SIL OFL 1.1。著作権表示・OFL本文・Reserved Font Namesを保持 |
| Rust standard libraryと依存crate | 1.95.0と`library/Cargo.lock` | RustのMIT/Apache-2.0と各crateの個別条件。lockに記載された全registry crateのsource・noticeを保持 |
| Noto Sans CJK JP | Sans2.004、`523d033d6cb47f4a80c58a35753646f5c3608a78` | SIL OFL 1.1。未改変OTF、Adobeの埋込著作権表示、OFL本文を保持 |
relayのruntimeイメージは`FROM scratch`とし、Goバイナリとlicenseだけを含めます。
Alpine/BusyBoxを新たに再配布する構成にはしません。`go list -deps`でrelayにリンクされる外部Go moduleは
`golang.org/x/net v0.35.0`のみと確認しています。ビルド用イメージと配布用runtimeイメージは区別します。
## 固定版とMPL宣言の関係
上流v0.0.1のcommitにはルートLICENSEがなく、翌日の
[`ac40f56c85060bd49dfc36ca60490f97dd270c50`](https://github.com/HeyPuter/firefox-wasm/commit/ac40f56c85060bd49dfc36ca60490f97dd270c50)
でMPL-2.0のLICENSEが追加されています。
[固定版からの比較](https://github.com/HeyPuter/firefox-wasm/compare/eadcb5fa828d7e8b54ae2df13b6b3208f6553944...ac40f56c85060bd49dfc36ca60490f97dd270c50)
の変更はLICENSE、Makefile、README、chrome demoの2ファイルです。
`gecko.js/js`、`gecko.js/src`、`gecko.js/lib`、`gecko.js/emsdk-patches`はこの間に変更されていません。
この事実を追加コードのMPL宣言の根拠として記録しますが、生成された全バイナリの第三者noticeを代替するものではありません。
v0.0.1の[Makefile](https://github.com/HeyPuter/firefox-wasm/blob/eadcb5fa828d7e8b54ae2df13b6b3208f6553944/Makefile)
はFirefox forkのcommit `2e1e835a5da5907e5ceef19aade58a7493f1e34d`とEmscripten 6.0.1を指定しています。
後続Makefileの参照先変更を混ぜず、再現には固定版側を使います。
固定版の[GRE縮小スクリプト](https://github.com/HeyPuter/firefox-wasm/blob/eadcb5fa828d7e8b54ae2df13b6b3208f6553944/gecko.js/stage-gre-min.sh)
は`chrome/toolkit/content/global/license.html`を明示的に除外し、LiberationのTTFをコピーします。
そのため、配布tarの存在やSHA-256一致だけでnoticeの充足を判断しません。
Wispのwire protocolは独立実装しています。固定版エンジンは独自の`gecko.js/lib/wisp-net.js`を使います。
pnpm-lockにある`@mercuryworkshop/wisp-js`はdemo側依存で、lockfileに記載があることだけを根拠に
PagesWiki relayの依存物・ライセンスとは扱いません。
## エンジンを配布する場合に必要な作業
MPLはファイル単位の義務であり、別実装のWiki全体をMPLへ変更するという意味ではありません。
一方、WASMやJavaScriptを閲覧者のブラウザへ送信することも配布として扱う必要があります。
**「イメージへ入れず、外部mountから配信すれば再配布ではない」という整理はしません。**
[Mozilla MPL FAQ Q8・Q10・Q11・Q16・Q17](https://www.mozilla.org/en-US/MPL/2.0/FAQ/)、
[MPL 2.0本文の3章](https://www.mozilla.org/en-US/MPL/2.0/)。
エンジンの本番有効化・再公開前に次を完了します。
1. 実際の配布WASM/JS/埋め込みGREと、対応するsource・patch・依存版を照合する。
2. Mozillaの固定commitの総合notice、MPL本文、Emscripten/runtime、zstddec、fontの各著作権・licenseを収録する。
Mozillaの総合noticeはbuild条件による表示があるため、未処理のHTMLを置くだけで完了としない。
3. 受領者がnoticeと対応sourceの取得先を閲覧できる画面/ファイルを用意する。
ソースは固定commitで指し、PagesWiki側でエンジンを変更した場合は変更も含める。
4. 提供するsourceとnoticeの可用性・保全、配布物とのhash対応を検査する。
5. Mozillaの商標はコードlicenseとは別に扱い、Firefoxの公式配布であるとの表現やロゴの流用をしない。
### 配布bundle
`tools/gecko/sources.lock.json`に取得元とSHA-256を固定し、`tools/gecko/bundle.py`で組み立てます。
生成物は98ファイル、合計1,196,102,561 bytes(manifest自身を除く)です。
manifestのSHA-256は`84953114f5e393dd97d9f948a5bc51c95b9355b58461dd3355e068a96cb2e381`。
同じ値をrelay側で固定し、列挙された全ファイルのサイズ・hash・通常ファイルであることを起動時に検査します。
不足、改変、symlink、別版混入を許可しません。
元のsource archiveを変更せず保存し、license/copying/copyright/notice/authorsファイルを別の閲覧用テキストにも集約します。
Mozillaの条件付きnoticeは**全分岐を含む保守的な上位集合**としてテキスト化し、元のHTMLはsource archiveに保持します。
Rustの追加依存はCargo.lockのチェックサムで検証します。crateから欠けていたFortanixのMPLヘッダと
vex-sdkのMIT本文も、元ソース・固定commitから補完しています。
Notoの未改変フォントには`© 2014-2021 Adobe (http://www.adobe.com/).`が埋め込まれ、READMEにも保持します。
閲覧画面のⓘは`/_/api/v1/extension/organizer.feeds/browser/distribution/v0.0.1/index.html`を開きます。
同じ入口からNOTICE、manifest、ソース一式を取得できます。認証は必要ですが、RSS・Geckoを無効化した後も、
認証済みの受領者はソースを取得できます。readonly利用者も取得可能です。
relay自体を撤去する場合は、先にbundleと取得先を保全・移設してください。無効化はソース提供の撤回を意味しません。
CIは中継バイナリの4番目のイメージを配布しますが、約1.2GBのbundleを通常イメージへ重複同梱しません。
検証済みbundleをread-onlyでmountする運用です。再配布条件の充足はこの固定版・未改変バイナリ・
保持したsource/noticeを前提とします。依存更新時はlockとnoticeを再確認し、公開済みbundleを上書きしません。
## 一次資料
- [Gecko forkのLICENSEと商標注意](https://github.com/MercuryWorkshop/firefox/blob/2e1e835a5da5907e5ceef19aade58a7493f1e34d/LICENSE)
- [同commitのMozilla総合notice](https://github.com/MercuryWorkshop/firefox/blob/2e1e835a5da5907e5ceef19aade58a7493f1e34d/toolkit/content/license.html)
- [Liberationの著作権とOFL](https://github.com/MercuryWorkshop/firefox/blob/2e1e835a5da5907e5ceef19aade58a7493f1e34d/toolkit/components/pdfjs/content/web/standard_fonts/LICENSE_LIBERATION)
- [Emscripten 6.0.1 LICENSE](https://github.com/emscripten-core/emscripten/blob/6.0.1/LICENSE)
- [zstddec 0.2.0 metadata](https://registry.npmjs.org/zstddec/0.2.0)
- [Go LICENSE](https://go.dev/LICENSE)
- [golang.org/x/net v0.35.0 LICENSE](https://go.googlesource.com/net/+/refs/tags/v0.35.0/LICENSE)
- [Noto CJK固定版OFL](https://github.com/notofonts/noto-cjk/blob/523d033d6cb47f4a80c58a35753646f5c3608a78/LICENSE)
- [vex-sdk固定版MIT](https://github.com/vexide/vex-sdk/blob/6c0b83d35b6fc31a7607efe456e387df45476314/LICENSE.md)
+175
View File
@@ -0,0 +1,175 @@
# RSS Gecko中継の試験導入
RSS本文上で原文を読むための、端末側Gecko WASMと自前Wisp中継の実験機能です。
通常の新規タブ・iframe表示は変更しません。DBスキーマ変更はありません。
本番への自動導入・自動有効化は行いません。
## 構成と有効化条件
PagesWikiのログイン済み・activeな利用者だけが、
`/_/api/v1/extension/organizer.feeds/browser/`以下を使います。
同じDomainで`organizer.feeds`と`viewer.gecko`の両方が有効で、
本体に中継URLと共有鍵ファイルが設定されていることが必要です。
`viewer.gecko`はmanifestで既定無効です。個人設定の「RSSの記事リンクの開き方」で
Geckoを選ぶと、RSS画面だけにCOOP/COEPを追加します。選択済みでも管理者が無効化した場合は新規タブへ戻ります。
ブラウザには中継の鍵を渡しません。本体が認証後に30秒の署名付きgrantを発行して内部HTTP要求へ追加します。
WebSocketではOriginも検査し、grantは一回限りです。既存接続の認証・利用者状態・拡張の有効状態は5秒間隔で再検査します。
中継はCookie、WikiのBearer token、FreshRSSの資格情報を受け取りません。
## 固定するエンジン
[HeyPuter/firefox-wasm v0.0.1](https://github.com/HeyPuter/firefox-wasm/releases/tag/v0.0.1)を使います。
対応commitは`eadcb5fa828d7e8b54ae2df13b6b3208f6553944`です。
配布物`gecko.js-v0.0.1.tar.gz`のSHA-256:
```text
bac28056a00ef6e5fb4345117e73d3629e75aca00dac71389fabbce39c018a73
```
エンジン単体の`dist/`ではなく、後述するsource/notice付きbundleをread-onlyで`/gecko`へmountします。
起動時に次の両ファイルに加え、manifestに列挙された全ソース・NOTICE・フォントをhash検査し、
欠損・改変・異なる版の混在があれば中継は起動しません。
| ファイル | SHA-256 |
| --- | --- |
| gecko.js | e5aeebffd21106eccf23b1219316221add5e95085bc5a1bfb941117cfcd75ef7 |
| gecko.wasm.zst | ebd6c75179152624d9644865e11792ed25cadc714d9e0985f412baf9c637a086 |
資産URLにも`assets/v0.0.1/`を含め、版をまたいだJS/WASMのcache混在を避けます。
初回にはJS・圧縮WASM・日本語フォントの合計54,643,095 bytes(約52.1MiB)の転送とWASMの展開・compileが必要です。
約1.2GBの対応ソースは閲覧の起動時には取得せず、ⓘから明示的にダウンロードするときだけ配信します。
本体のDocker buildにFirefoxのソースビルドを加えません。
`Dockerfile.gecko-relay`は自前の中継バイナリだけを含みます。エンジンは同梱・再配布しません。
**エンジンをイメージへ同梱する場合だけでなく、mountした資産を利用者へ配信する前にもnoticeと対応sourceの提供が必要です。**
固定版のMPL宣言、第三者依存物、今回の配布範囲は[再配布条件](gecko-redistribution.md)を参照してください。
v0.13.0の本番配備ではエンジンを配信していません。新しいrelayは完成したbundleを必須とします。
### bundle生成
Python 3.11以降を使い、十分な空き容量のあるディスク上で実行します。ソースarchiveは展開せず保持します。
```sh
python tools/gecko/bundle.py --cache /srv/gecko-cache --output /srv/gecko/v0.0.1-bundle1
# 同一入力からの再生成。出力先はまだ存在しない新しいディレクトリを指定する。
python tools/gecko/bundle.py --cache /srv/gecko-cache --output /srv/gecko/rebuilt --offline
```
出力manifestのSHA-256が`84953114f5e393dd97d9f948a5bc51c95b9355b58461dd3355e068a96cb2e381`と一致することを確認します。
稼働中のmount先を上書きせず、source/noticeの提供を含めて不変の単位で保全します。
## 配置
任意の追加ファイル`docker-compose.gecko.yml`を通常のCompose定義に重ねます。
このoverlayは`app`だけへ接続設定を追加し、`app2`は自動変更しません。
必要な環境変数:
| 変数 | 内容 |
| --- | --- |
| PAGESWIKI_GECKO_KEY_PATH | 32文字以上の十分ランダムな共有鍵のファイル絶対Path。appとrelayへ同じread-only mount |
| PAGESWIKI_GECKO_ASSETS_DIR | 全ファイルを検証したbundleの絶対Path。engineだけのdistは禁止 |
| PAGESWIKI_GECKO_IMAGE | Giteaで配布した`pageswiki-gecko-relay:sha-...`またはrelease tag。省略時は開発用image |
| PAGESWIKI_GECKO_FRONT_SUBNET | 内部接続網。既定`172.24.0.0/27`。既存LANとの重複を避ける |
| PAGESWIKI_GECKO_EGRESS_SUBNET | 中継の外向き網。既定`172.24.0.32/27` |
鍵はイメージ、Git、コマンド引数、ログへ含めません。relayはUID/GID `10001:10001`で動きます。
mount元ファイルをこのUIDまたはGIDで読み取り可能にし、他の利用者から読めない権限にしてください。
本体の`PAGESWIKI_GECKO_RELAY`は内部の固定URL、`PAGESWIKI_GECKO_KEY_FILE`はmount先です。
これらは初回参照時に読み込むため、変更・鍵ローテーション時は本体とrelayを再起動します。
設定確認・試験起動の例:
```sh
docker compose -f docker-compose.yml -f docker-compose.gecko.yml config --quiet
docker compose -f docker-compose.yml -f docker-compose.gecko.yml build gecko-relay
docker compose -f docker-compose.yml -f docker-compose.gecko.yml up -d gecko-relay app
```
本体も今回の実装を含むイメージに更新する必要があります。既存のregistry/deploy用overrideがある場合は
それも指定し、意図せず旧イメージや開発ビルドを本番へ適用しないでください。
### 外向き通信の制限
relayは公開ポートを持たず、通常のWikiネットワークやDBデータをmountしません。
ただしDocker bridgeの分離だけでは外向き通信を制限できません。試験導入前にホストまたは外部firewallで、
relayのegressから管理網・社内網・metadata・Wiki/DBホストへの到達を拒否し、公開TCP 80/443と管理されたDNSだけを許可します。
rootless Dockerとrootful Dockerでは適用点が異なるため、ホスト固有のiptablesをこのoverlayから自動変更しません。
アプリケーション側でもIPv4/IPv6のprivate、loopback、link-local、特殊用途アドレスを拒否します。
名前解決で返された全アドレスを検証してから、そのIPを直接dialします。検証後の再名前解決はしません。
UDP、80/443以外のTCP、単一ラベルのホスト名は拒否します。
これはWisp v1フレームを用いた**制限付きTCP profile**であり、Wispの全機能互換サーバーではありません。
## 上限と監視
| 対象 | 上限 |
| --- | --- |
| 同時セッション | Domain+本人ごとに1、サービス全体4 |
| 同時TCP stream | セッションごと16 |
| 接続試行 | セッションごと256 |
| 合計転送量 | セッションごと送受信合計256MiB |
| 帯域 | セッションごと送受信合計2MiB/s、初期burst 2MiB |
| セッション期限 | 15分 |
| WebSocket受信idle | 90秒 |
| 宛先接続 | 名前解決込み8秒、個別dial 2秒 |
| relayコンテナ | 256MiB、0.5 CPU、64 PIDs、read-only、capabilitiesなし |
| 閲覧プロファイル | 日本語フォントを含むvolatileな32MiB・2,048 entries、端末のOPFSへ永続化しない |
| source/noticeダウンロード | 全体2接続まで。ETag・Range対応。閲覧streamの枠とは分離 |
relayの稼働状態・接続数・送受信bytes・拒否数は、コンテナ内の次の操作でJSON取得できます。
鍵はファイルから読み、標準出力には含めません。counterは再起動でリセットします。
```sh
docker compose -f docker-compose.yml -f docker-compose.gecko.yml exec gecko-relay gecko-relay --status
```
`/health`は内容なしの死活確認、`/status`は署名付き内部要求だけに応答します。
CPU・メモリはコンテナ監視を使います。設定画面の資源グラフへの統合は未完了です。
記事URL、本文、プロファイル内容、資格情報はrelayログに記録しません。
## 無効化と切り戻し
管理画面の拡張一覧で`viewer.gecko`を無効化できます。UIが使えない場合は、対象Domainを選択した
ローカル`data/pageswiki-cli`で次を実行します。
```text
extension viewer.gecko off
```
既存WebSocketは次の認証再検査時に終了します。新たな閲覧も拒否し、RSSの原文リンクは新規タブへ戻ります。
緊急時はrelayコンテナを停止します。DB移行の巻き戻しは不要です。
## 受入と制約
自動テストでは外部アクセスしない合成Wisp応答を使い、実際のGecko WASMで描画、canvasクリックによる遷移、
ビューア内の「戻る」、iframe削除後の接続終了を確認します。実FreshRSS、外部カレンダー、メール本文は使いません。
専用イメージのbuildと、`--network none`・非root・read-only・資源制限付きの一時コンテナで、
固定資産の起動時検査と`--status`も確認済みです。本番の中継・ネットワーク設定は変更していません。
```sh
go test -race ./internal/geckorelay ./internal/server -run 'TestGrant|TestDestinations|TestRelay|TestAssets|TestFeedGeckoAuthorization|TestFeedGeckoWebsocket'
PAGESWIKI_BROWSER_TEST=1 PAGESWIKI_GECKO_TEST_ASSETS=/verified/bundle go test ./internal/server -run '^TestFeedGeckoChromium$' -count=1
PAGESWIKI_GECKO_TEST_BUNDLE=/verified/bundle go test ./internal/geckorelay -run TestDistribution
# 公開テストサイトへの実通信。実RSS・外部カレンダー・メールは使用しない。
PAGESWIKI_BROWSER_TEST=1 PAGESWIKI_GECKO_TEST_ASSETS=/verified/bundle PAGESWIKI_GECKO_PUBLIC_HTTPS_TEST=1 go test ./internal/server -run '^TestFeedGeckoChromium$' -count=1
node internal/server/testdata/feed-gecko-profile.mjs
```
原文クリック時にだけ起動し、閉じるとiframe・worker・接続を破棄します。タブを60秒非表示にした場合も閉じます。
再表示では静的資産のHTTP cacheを使えますが、エンジンは再起動します。
戻る/進むは最大64件のURLを再読み込みする方式です。上流の最小GREにはSessionStoreFunctionsがなく、
標準のhistory.back()が失敗するため、フォーム内容やスクロール位置を復元する履歴ではありません。
画面のcanvasは最大1920×1080、experimental WASM JITとGPUは無効です。
HTTPSの実描画と期限切れ証明書の拒否を確認しました。上流最小GREはエラーページの部品が不足するため、
`about:neterror`/`about:certerror`を検知してcanvasを隠し、PagesWiki側で説明します。証明書の無視・例外追加は提供しません。
Noto CJKをメモリプロファイルのfontsに置き、エンジンを改変せず日本語描画も確認しています。
検索アイコンまたはCtrl/Cmd+Fからページ内検索できます。検索語は256文字まで、前後検索と一致なしの表示に対応し、合成記事で日本語検索を確認しています。起動失敗または120秒の起動上限到達時はiframeを破棄し、元記事を別タブで開く導線を残します。上流のdestroy呼出しだけではWASM資源の解放にならないため、親側のiframe破棄まで行います。`TestFeedGeckoStartupFailureChromium` はフォント取得失敗時の破棄と代替導線を検証します。
本番の標準機能に昇格する前に、Safari/iPhone SE、IME、コピー、実サイト互換性、
複数タブ・低メモリ端末の測定、コンテナ外向きfirewallを検証します。
外部ページのiframe拒否とは別の仕組みですが、すべてのサイトでの動作や軽さを保証するものではありません。
+3
View File
@@ -11,6 +11,9 @@ runner の環境構築や Gitea の事前疎通診断は行わず、本番へ自
| `pageswiki-app`(app / app2 共通) | `Dockerfile` |
| `pageswiki-adaptor-gateway` | `Dockerfile.adapter-gateway` |
| `pageswiki-excalidraw-viewer` | `Dockerfile.excalidraw-viewer` |
| `pageswiki-gecko-relay`(任意) | `Dockerfile.gecko-relay` |
v0.15.0以降はGecko relayを含む4イメージをビルド・昇格します。以下の「3イメージ」は通常配備するapp・gateway・Excalidrawの組を指します。Gecko relayは別overlayで明示的に配備するもので、通常の本番更新では起動しません。
Kroki、Mermaid、code-server は upstream の配布イメージを使用する。
`main` / `mk_district` への push、手動実行でビルド・公開する。
@@ -0,0 +1,45 @@
# メールWikiのPath依存404の調査
## 状態と回避策
2026年11月6日、別インスタンスでNeoMuttから作成したWikiが一覧には見える一方、`/tasks` とその配下への直接アクセスで `{"detail":"Not Found"}` になる報告があった。同じオブジェクトに `/prj/awesome` 側のリンクを追加すると表示できた。原因は未確定で、修正済みとは扱わない。
回避策は表示できるWiki親prefixを既定値にし、既存オブジェクトには別Pathのリンクを使うこと。メールの再取り込み、オブジェクトの削除、既存Pathの一括移動は不要。Pathごとに権限が異なりうるため、新しいリンク先の公開範囲も確認する。
## アプリ内で確認した境界
タスク画面は `/v/plan/tasks`、APIは `/_/api/v1/extension/organizer.tasks/`。`/tasks` は予約ルートではなく、通常のWiki Pathとして解決する。末尾スラッシュは301で取り除く。
NeoMuttの `pipe_decode=no`・`pipe_split=yes` 相当の標準入力を使い、CLIプロセスから一時DBのフルHTTPハンドラへ取り込む試験を追加した。42パターンは、親prefix7種類、UTF-8/ISO-2022-JPの件名、ML連番/Message-ID/原文hashの組合せ。公開CLI v0.4.0でも一覧のdata-path、直接表示、末尾スラッシュ、言語指定を確認し、代表3パターンをChromiumで表示した。実メール・実アカウント設定は使用しない。
Python・Chromiumに依存しないGoテストでは、実際のAPIへ既定prefix `/tasks` を設定して取り込み、同一オブジェクトの `/tasks/...` と `/prj/awesome` の両方がHTMLの200を返すことを検証する。未認証閲覧のログイン誘導、一覧表示、旧CLI形式も対象。CIでPythonがない場合もこのテストは実行される。
親に文書がない場合は、仮想フォルダページ無効ならHTMLの404、有効ならchildren一覧の200となる。これは作成済み子ページまでJSONの404になる報告とは区別する。設定箇所は `/-/sys/config?panel=home` の「仮想フォルダページ」。設定は対象ドメイン単位で、調査のために自動変更しない。
## 機密情報を共有しない切り分け
以下は問題のインスタンス内で行う。実URL・メール本文・Cookie・Bearer token・ログ全文を外部へ共有しない。
1. 問題のPathへのGET時刻を控え、PagesWikiプロセスのアクセスログに同じ要求が到達するか確認する。到達しない場合はプロキシ、ブラウザ、キャッシュなどアプリより手前を調べる。ログ出力先の取り違えにも注意する。
2. 公開HTTPSとPagesWikiの直接待受で応答を比較する。Domainの振り分けが変わらないよう、同じHostとPathを使う。まず資格情報なし・リダイレクトを追わないGETのstatusとContent-Typeを比較すれば、メール本文を取得せずに判断できる。認証後の比較が必要ならローカル環境内の安全な手順を使い、コマンド履歴に資格情報を残さない。
3. 直接待受は正常でプロキシ経由だけ失敗する場合、`/tasks` に一致するlocation、正規表現location、rewrite、別upstream、Custom Locationsを確認する。実際の設定で確認できるまではプロキシが原因と断定しない。
4. PagesWikiへの直接要求も失敗する場合は、稼働イメージrevision、HostによるDomain選択、Path別ACL、既存リンクの対象UUIDをローカルで確認する。同一オブジェクトの別名が読めても、元Pathの権限が同じとは限らない。
X-Request-IDやServerヘッダーだけで応答元を断定しない。プロキシによる付加・上書きがありうる。原因が判明するまで、推測による `/tasks` 専用ルート追加や権限の緩和はしない。
## 回帰テストと残件
```sh
go test ./internal/server -run 'TestTaskWikiPrefixRouting|TestNeoMuttMailViewerFlow' -count=1
# Chromiumがある開発環境のみ
PAGESWIKI_BROWSER_TEST=1 go test ./internal/server -run '^TestNeoMuttMailViewerFlow$' -count=1
# 配布ELFでも同じ一時プロファイルを用いて確認する場合
PAGES_CLI_TEST_BINARY=/absolute/path/to/pages PAGESWIKI_BROWSER_TEST=1 go test ./internal/server -run '^TestNeoMuttMailViewerFlow$' -count=1
```
- [x] `/tasks` 配下のメール作成から通常ビューアまでの合成HTTP試験。
- [x] 同一オブジェクトの別名、親の仮想フォルダ設定、認証境界のGo回帰テスト。
- [ ] 問題インスタンスで、直接待受とプロキシ経由の差分を確定する。
- [ ] 特定された原因に修正を適用し、元の `/tasks` でも表示できることを確認する。
テストと調査記録の追加は障害修正リリースではない。既存の回避策とデータを維持する。
@@ -0,0 +1,76 @@
# RSSフォルダと取り込み操作のリリース
## 対象
v0.12.0は`f4869c7c8bd2fd48523eec2e1868d3d0750bbdf7`。
2026-11-08 14:55 JSTに本番検証を完了し、注釈付きGitタグとイメージを公開した。
既存v0.11.0タグは移動していない。
独立pages-cliと未コミットのメール保存先調査は含めない。
- [ビルドCI run 64](https://git.anya.jp/anya/pages/actions/runs/64): success。
- [リリースCI run 65](https://git.anya.jp/anya/pages/actions/runs/65): success。
- [Gitea Release v0.12.0](https://git.anya.jp/anya/pages/releases/tag/v0.12.0)。
本番`.env.release`は同コミットの`sha-`タグに固定している。
`v0.12.0`は再ビルドせず同一manifestを昇格し、3イメージすべてのdigestとrevisionを照合済み。
## 変更
- FreshRSSの分類フォルダ・購読元をツリー表示し、空フォルダ・未分類・開閉状態保存に対応。
- 記事・購読元・分類を背景で原子的に更新し、一部失敗時は前回cacheを保持。
- 既読・star書戻しの操作履歴、結果不明の再確認、JSON記録保存。
- ショートカットヘルプを`?`・`Esc`・閉じるボタンで閉じ、元の記事とstatus表示を保持。
- Wiki・タスク追加を本文上のdialogへ整理し、個人設定のWiki親Pathを初期表示。
- `{YYYY}`・`{MM}`・`{DD}`・`{Subject}`を親Pathで使用可能。日付はドメインのタイムゾーン。
- 件名を安全な単一Path要素へ整形し、保存先プレビューと公開範囲確認を表示。
- `sharing.x`の有効・無効に従うRSS記事のX共有。件名と原文URLを別タブのintentへ渡す。
- 個人設定からRSS原文・本文リンクを別タブまたは大きなiframeプレビューで開く方式を選択。
個人設定は`/-/sys/config?panel=organizer`。Wiki親Pathはメール取り込みと共通。
リンクの開き方は既定で別タブとし、設定変更はRSS画面の再読込後に反映する。
iframeはsandbox付きで、外部サイトの埋め込み禁止は回避しない。表示できない場合は別タブへ開く。
本番利用者の既定値やFreshRSS書戻し許可を自動変更しない。
詳細は[RSS設計](../../design/ja/feeds.md)を参照。
## 移行と保全
今回の本番schema差分はfeeds v5→v6。`feed_sources.remote_folders`の列追加であり、
既存記事・購読設定・送信待ちreceipt・source versionを変更しない。
Wiki親Pathとリンク表示モードは既存preferences JSONを使うため追加DDLはない。
旧版がv6を理解するとは仮定せず、単なる旧イメージへの切戻しを自動実行しない。
保全先は`.deployment-backups/release-rss-folders-20261108/`。
旧構成を`config/`、停止時点のデータを`cutover/data`・`cutover/data2`に保存した。
14:53:29 JSTに停止を開始し、14:54:38 JSTにchecksum付き同期・差分ゼロ・DBの一致を確認した。
事前コピーだけでは整合バックアップと扱っていない。
稼働元とはinodeを共有せず、既存の不変バックアップとのみ変更のないファイルを共有する。
旧イメージは`rollback-before-rss-folders-20261108`タグで保全した。
## 検証
手元のGo全体テスト・go vet、RSS関連のrace検査、1440px/390pxのChromium試験を実施。
分類の空・未分類・移動・同名ID、失敗時cache保持、schema v6のrollback・再実行を検査した。
親Pathの日付境界・日本語件名・階層逸脱防止・不正トークン拒否を検査した。
リンクプレビューは別originのローカルfixtureを実際に読み込み、sandboxと復帰を検査した。
実FreshRSS・Xへの投稿・外部カレンダー・実メール本文を検証のために取得・操作していない。
停止済みの前回バックアップから独立コピーを作り、両DBの移行前integrity_checkはok。
配備イメージをネットワーク遮断・workers無効で実際に起動し、両DBでfeeds v6への移行、
ヘルス、管理対象13コンポーネントのschema check、移行後integrity_checkのokを確認した。
schema check単体ではlegacy領域を網羅しないため、起動・SQLite検査と組み合わせた。
本番切替後は以下を確認した。
- app・app2・adaptor-gateway・excalidraw-viewerが対象revisionで稼働、restart countは0。
- 両アプリの`/health`、schema checkが正常。feeds v6、task-productivity v4。
- HTTPSの`/health`とログインは200、匿名のRSS・タスク・設定画面は303、RSS APIは401。
- 配信中の`feeds.js`・`feeds.css`・`task-productivity.js`のSHA-256がリポジトリと一致。
- 起動後ログのpanic・fatal・DB locked・event job failed・schema errorは各0件。
## 配布イメージのdigest
| イメージ(`git.anya.jp/anya/`、タグ`v0.12.0`) | manifest digest |
| --- | --- |
| pageswiki-app | `sha256:46251f9b869e47d456def4d285c3f076e0d375f2a11d69121885fca08997e6a7` |
| pageswiki-adaptor-gateway | `sha256:ee98889018f8389a655126c6a5d1046640be22cae169d97c4b27a7efa08f86c6` |
| pageswiki-excalidraw-viewer | `sha256:e7a577a8f178f625f6b13da93b046afda57c5c4c67e5e3b86cab0daf5c5f14ee` |
@@ -0,0 +1,92 @@
# PagesWiki v0.13.0
RSSフォルダのキーボード移動と、既定無効のGecko原文ビューア基盤を追加するminor releaseです。
エンジン配布を含まない範囲でリリースします。通常のRSS表示・新規タブ・sandbox iframeは維持します。
## 変更
- Shift+j/kでFreshRSSの前後の分類フォルダを選択。検索条件、未読/star絞り込みを維持。
- 認証付きの独立Wisp TCP relayと、Gecko用の本文上popup、個人設定を実装。
- relayは公開TCP 80/443限定、DNS解決後の全IP検査、固定IPへの接続、接続数・帯域・通信量・期限の制限。
- ログアウト・利用者状態・拡張無効化を既存WebSocketにも反映。
- upstream v0.0.1をhash固定。閲覧プロファイルはメモリのみ、終了時はiframeを破棄。
- 戻る/進むは最大64件のビューア内URL履歴を再読み込み。通常ブラウザのフォーム状態復元ではない。
- 拡張manifestの既定無効をサーバーとローカルCLIへ反映。
- 専用relayはscratch runtimeとし、実ビルドのGo・x/netのBSD licenseを収録。
## 再配布と本番の範囲
[再配布条件](../gecko-redistribution.md)にGecko、WASM用追加コード、Emscripten、zstddec、フォントを整理しました。
GeckoのJS/WASM/フォントをGit、通常3イメージ、release assetへ同梱しません。
relay Dockerfileと試験用Compose overlayは提供しますが、CIの配布イメージは従来の3種類です。
固定版生成物にはMozillaの総合noticeが含まれないため、エンジン配布用notice/source bundleは残件です。
外部mountからのブラウザ配信も再配布として扱い、今回の本番では鍵・asset mount・relay起動・
`viewer.gecko`の有効化を追加しません。
通常のRSSフォルダショートカットは利用できます。
## 互換性と検証
DBスキーマ変更はありません。RSSリンクモード`gecko`は既存preferences JSONの追加値です。
未構成・無効時は新規タブ表示に戻り、既存利用者の設定を自動変更しません。
旧版でpreferencesを保存する際、新しい値が残っていれば`tab`または`embedded`へ戻す必要があります。
Go全体テスト、関連race検査、CLI、配布ツール、Chromiumでの1440/390px RSS回帰と実Geckoによる
合成Wisp記事の描画・クリック遷移・戻る・終了を検証対象とします。実FreshRSS・外部カレンダー・メール本文は検証に使いません。
Safari、IME/copy/find、実HTTPSの互換性と証明書エラー、低メモリ・長時間負荷、監視UI統合、
本番の外向きfirewallは実験機能の昇格前の残件です。
構成・上限・切り戻しは[Gecko中継の試験導入](../gecko-relay.md)、機能の進捗は[RSS設計](../../design/ja/feeds.md)を参照してください。
## リリース・本番反映記録
対象commitは`5321d613b40db36238235ff68e256caa6d4e4cf1`。
2026-11-08 16:31:51 JSTに本番の外部HTTPS検証を完了しました。
- [ビルドCI run 66](https://git.anya.jp/anya/pages/actions/runs/66): success。
- [リリースCI run 67](https://git.anya.jp/anya/pages/actions/runs/67): success。
- [Gitea Release v0.13.0](https://git.anya.jp/anya/pages/releases/tag/v0.13.0)。
注釈付きGitタグ`v0.13.0`と同名の3イメージを公開しました。
SHAタグから再ビルドせず昇格し、両タグのmanifest digest一致を確認しています。
本番`.env.release`は`PAGESWIKI_IMAGE_TAG=v0.13.0`です。
app・app2・adaptor-gateway・excalidraw-viewerだけを切り替え、他サービスは変更していません。
### DBと復旧点
現在の両DBをSQLiteのオンラインバックアップで独立コピーし、`integrity_check`のokと、
新イメージをネットワーク遮断・読み取り専用で実行した`schema check`の成功を確認しました。
13管理コンポーネントはすべてcurrentで、feeds v6・task-productivity v4のままです。
この検査はlegacy領域の全移行を網羅するものではありません。今回のschema追加はありません。
最初に選んだ前回切替前バックアップにはfeeds v5が残っていたため、現在のDBのコピーへ検査対象を変更しました。
`/tmp`上の検査コピー作成はI/Oエラーで中断し、その一時コピーだけを除去して、
空き容量のあるディスク上でコピー・整合性検査を完了しています。本番DBへの検査用書き込みはしていません。
復旧点は`.deployment-backups/release-v0.13.0-20261108/`です。
`config/`に旧構成、`cutover/data`・`cutover/data2`に停止時点の全データを保存しました。
16:29:32 JSTに停止を開始し、16:31:01 JSTにchecksum同期・再走査の差分ゼロ・DB一致を確認しました。
稼働元とはinodeを共有せず、不変の旧バックアップとのみ未変更ファイルを共有しています。
旧3イメージは`rollback-before-v0.13.0-20261108`タグで保持しています。
旧版へ戻す場合も更新後の書き込みを失わないよう、データの自動巻き戻しは行いません。
### 配備後検証
- 4サービスのrevisionが対象commitと一致、再起動回数0。
- app・app2の`/health`と管理スキーマ検査が正常。
- 外部HTTPSでhealth・ログイン・カレンダーHTML枠は200、匿名のRSS・設定は303、RSS APIとGecko proxyは401。
カレンダーHTML枠の200は既存の仕様で、実予定データの取得・閲覧は検証していません。
- `feeds.js`・`task-productivity.js`・`feed-gecko.js`・`feed-gecko-profile.mjs`・`feed-gecko.css`の配信SHA-256がソースと一致。
- 起動直後のpanic/fatal・database locked・event job failed・schema errorは各0件。
- 本番へのGecko環境変数・asset mount追加なし、Gecko relayの起動なし。
手元ではGo全体テスト、go vet、関連race検査、CLI、配布ツール、ChromiumによるRSSと合成Gecko記事の試験を通しています。
ライセンス同梱を含め専用scratch relayのビルド・起動・statusも確認しましたが、配布イメージへの追加や本番起動はしていません。
### 配布イメージ
| イメージ(`git.anya.jp/anya/`、タグ`v0.13.0`) | manifest digest |
| --- | --- |
| pageswiki-app | `sha256:87e9a2761c136aff734761f296c9dbe34fc391ad5687eaf332d3c9ba15b03ab5` |
| pageswiki-adaptor-gateway | `sha256:b82bb2184d21ea692b63fa2f9a70f15392474719e444e8d2b7618723cc80c7f1` |
| pageswiki-excalidraw-viewer | `sha256:2fff1ac0191e2fc7d8ad21aba365c82e0500f81d78da3672c030e77cb6a418af` |
+14 -1
View File
@@ -81,7 +81,20 @@ code-server・Kroki・独立CLI・ネットワーク構成は変更しない。
最終バックアップの両ルートともchecksum付きdry-runの差分はゼロ。
旧v0.10.0イメージは`rollback-before-rss-20261108`タグで保持し、ローカルlatestは新イメージに揃えた。
今回作成した隔離リハーサル用の一時コピーとコンテナは片付けたが、旧バックアップは削除していない。
完了時のディスク空きは約4GiB。保全先への転送確認と保持世代の合意後に、容量整理を優先する。
完了時のディスク空きは約4GiB。その後の容量整理は次節のとおり。
FreshRSSの書き戻し許可は自動有効化していない。本番ユーザーの設定・記事状態を試験のために変更せず、
外部取り込みカレンダー・実メール・実FreshRSSへ検証用アクセスを行っていない。
## 容量整理
2026-11-08、ユーザーの削除指示を受け、旧リリースのバックアップ8世代を削除した。
対象はrelease-v0.4.0、v0.5.0、v0.6.0、v0.7.0、v0.7.1、v0.8.0、v0.8.1、v0.9.0の各ディレクトリ。
現在の切替直前を保全した`release-rss-20261108`と、その前の`release-v0.10.0-20261107`を残した。
hardlink共有ファイルも、残したバックアップの参照は維持される。開発時の小さなソース保全やrsyncログは変更していない。
9月のrsyncログを11月のバックアップの外部転送証明とは扱わず、今回の保持世代整理として削除した。
DockerはPagesWikiの指定repositoryだけを対象に、全コンテナの使用中image ID、v0.10.0の切戻し用、
v0.11.0の手元イメージを保護した。旧43 image IDに属する102タグと関連参照をforceなしで削除。
daemon全体のprune、レジストリの削除、他サービスのイメージ/volume削除は行っていない。
本番停止は不要で、空き容量は約4GiBから約61GiBへ増えた。
@@ -0,0 +1,77 @@
# PagesWiki v0.14.1とpages-cli v0.4.2
削除済みタスクの受付記録が残り、変更した下書きの再送で412になっていた問題を修正します。
削除済みなら410、受付記録に対応するタスクと削除記録が両方欠落していれば409 `capture_missing` で停止します。
存続中のタスクを異内容のcaptureで上書きすることは許可しません。
2026-11-08 19:42:51 JSTに本番配備後の確認を完了しました。
DBスキーマ変更・既存データの削除・実タスクの再取り込みは行っていません。
Gecko等の未コミット変更は含みません。
## 再取り込み
サーバーをv0.14.1、利用するCLIをv0.4.2に更新してから実行します。
別インスタンスへ接続している場合は、その接続先サーバーの更新も必要です。
```sh
pages --version
pages task retry REQUEST_UUID --recreate-deleted
```
保持した下書きから、新UUIDのタスクを作成します。旧UUIDの削除記録とDAV識別子予約を残し、
通常の再送で古いタスクが復活するのを防ぎます。再取り込み用IDは決定的で、応答消失や並行再送でも重複作成しません。
既存Wikiが保存先にあれば本文・リビジョンは変更せず、新タスクから関連付けます。
ページがなければ保留本文から作ります。移動済みページの自動探索や旧作業記録の復元ではありません。
通信失敗時はCLIが表示する新IDで `pages task retry NEW_REQUEST_UUID` を実行します。
セッションファイルや受付記録を手動で消さないでください。
詳細は[実装契約](../../design/ja/tasks-implementation.md#削除済みメール取り込みの再作成)と
[CLIのNeoMutt手順](https://git.anya.jp/anya/pages-cli/src/tag/v0.4.2/docs/neomutt.md)を参照してください。
## リリースと検証
| 対象 | タグ | commit | CI |
| --- | --- | --- | --- |
| PagesWiki | [v0.14.1](https://git.anya.jp/anya/pages/releases/tag/v0.14.1) | `4049acf76e36c12b8f3c506de5eaf1e920ac7e86` | [build 72](https://git.anya.jp/anya/pages/actions/runs/72)、[release 75](https://git.anya.jp/anya/pages/actions/runs/75) success |
| pages-cli | [v0.4.2](https://git.anya.jp/anya/pages-cli/releases/tag/v0.4.2) | `e27c023d66a61b73d3fe47e982daa6f34213c41f` | [build 73](https://git.anya.jp/anya/pages-cli/actions/runs/73)、[release 74](https://git.anya.jp/anya/pages-cli/actions/runs/74) success |
- 正確なリリースソースで `go test ./...`。server/storeのgo vet、削除・再取り込み・並行再送のrace検査が成功。
- CLIの52単体テスト、サーバーとCLIのHTTP結合テストが成功。Wiki本文・版の保全、他所有者拒否、readonly、kill switch、入力上限、保存途中のロールバックを検証。
- 公開されたCLIの4配布ファイルをSHA256SUMSで照合し、Pythonソースとcommitを照合。
- 配布Linux ELFでバージョン、メール取り込み、下書き差し替え、削除済み再取り込み、認証・ファイル権限のスモークテストとTLS関連6テストが成功。
- Linux ELFはglibc 2.36以降。macOS/Windowsの未検証バイナリは配布していません。
## 本番切り替えと復旧点
app・app2・adaptor-gateway・excalidraw-viewerを同じv0.14.1へ更新しました。
`.env.release` の選択は `PAGESWIKI_IMAGE_TAG=v0.14.1` です。
- 19:40:36 JSTに停止開始。
- 19:42:17 JSTに、停止時点のdata/data2についてchecksum同期、再走査の差分ゼロ、DBファイル一致を確認。
- 19:42:23 JSTに新版の起動と両アプリのhealth応答を確認。
- 設定と停止時データは `.deployment-backups/release-v0.14.1-20261108/` の `config/` と `cutover/data`、`cutover/data2` に保存。DBのinodeは稼働元と独立しています。
- 旧3イメージを `rollback-before-v0.14.1-20261108` タグで保持。旧バックアップも残しています。
v0.14.0への切り戻しはイメージ選択のみで行い、DBを過去へ戻しません。
その場合は再取り込みAPIが利用できなくなるため、CLIの再取り込み操作を止めてください。
v0.14.0より前への切り戻しは削除記録の扱いが異なり、[v0.14.0の注意点](2026-11-08-task-deletion.md#dbと切り戻し)が引き続き適用されます。
## 配備後確認
- 4サービスのrevisionが対象commitと一致、running、再起動回数0。
- app/app2のhealth正常。管理対象13スキーマはcurrent。これはlegacy領域を含む全移行検証ではありませんが、今回の変更にスキーマ移行はありません。
- 両DBの `quick_check` はok。
- 外部HTTPSのhealth・ログイン画面200。匿名のタスク/ダッシュボード/RSS画面303、タスクAPI401。匿名DELETEとcapture POSTも401。
- tasks.js、tasks.css、organizer-dashboard.js、feeds.js、feed-gecko.jsのSHA-256がリリースcommitと一致。
- 起動直後のfatal/panic、DB lock、schema/migration failure、event job failureは両アプリとも0件。
- 実際のメール本文・利用者の保留下書きを使った再取り込みは実施していません。
## 配布イメージ
SHAタグから再ビルドせず昇格。本番で取得したdigestとCI結果は一致しています。
| イメージ(`git.anya.jp/anya/`、タグ`v0.14.1`) | manifest digest |
| --- | --- |
| pageswiki-app | `sha256:11488fb958db12ec5a25aa265fc8179a31ab5728800f47605759822a44eb81e6` |
| pageswiki-adaptor-gateway | `sha256:ca17704eb5e88a4e73827ff2a5fafda7c4bb7d9be3987b5a83a3a5ae0c780098` |
| pageswiki-excalidraw-viewer | `sha256:a2b692c3864b8c4f13412e746fcea7cd9a2c03d49e0d5ead252432f37930c4c4` |
@@ -0,0 +1,70 @@
# PagesWiki v0.14.0
タスク編集画面に、アーカイブと独立した削除操作を追加するminor releaseです。
本日の達成率ウィジェットは説明文を除き、グラフと完了数/総数を表示します。
Geckoの追加整備やRSSの追加ショートカットなど、並行作業中の変更は含めません。
## 変更と削除範囲
- タスク編集画面の「アーカイブ/復元」の隣に「削除」。確認後に実行し、アーカイブ済みタスクにも対応。
- DELETE APIは所有者・Domain・active状態を検査し、If-Matchを要求。更新競合時は入力を保持。
- サブタスクが残る場合や作業/集中セッションが実行中の場合は削除を拒否。
- タスクhead、版参照、通知予約、達成度メトリクスを削除。カレンダー時間枠との関連は解除。
- Wikiメモ、カレンダー予定、記録済みの作業時間は保持。CASファイル・既存バックアップの安全消去ではありません。
- CalDAV一覧/REPORTから削除対象を除外。削除済みのUUIDとcollection内のDAV UID/hrefを予約し、古い端末からの再作成を拒否。
- 従来のDAV DELETEをアーカイブへ変換する動作は維持。
詳細は[タスクの実装契約](../../design/ja/tasks-implementation.md#タスクの削除)を参照してください。
## DBと切り戻し
`organizer_task_deletions` を追加します。起動時の移行は既存タスクを削除せず、
既存のタスクデータや版参照を変更しません。DAV索引再構築は削除記録の識別子予約にも対応します。
旧版は削除記録を認識しません。削除機能を使用した後の旧版への切り戻しでは、
クライアントの再送で同じDAVタスクが作成されるおそれがあります。
切り戻す場合は書き込み・DAV同期を停止してから判断し、DBを無断で過去へ戻さないでください。
## 検証と配備
対象commitは `38a4fcf5301e0c7c6cad12070e040dc62a03d41b`。
2026-11-08 18:20:25 JSTに配備後の検証を完了しました。
- [ビルドCI run 68](https://git.anya.jp/anya/pages/actions/runs/68)、[リリースCI run 69](https://git.anya.jp/anya/pages/actions/runs/69)はともにsuccess。
- [Gitea Release v0.14.0](https://git.anya.jp/anya/pages/releases/tag/v0.14.0)と注釈付きGitタグを公開。
- リリース対象だけの独立ソースで `go test -p 1 ./...`、server/storeのgo vet、配布ツール等15テスト、PC・モバイル幅のChromium回帰試験が成功。
- 両本番DBのオンラインバックアップを隔離し、`EnsureTasksSchema`を各2回実行。task head・版参照・DAV resource/collection識別子のdigestが移行前後で一致し、削除記録は0件、`integrity_check`はok。
- app・app2・adaptor-gateway・excalidraw-viewerを同じv0.14.0へ更新。他サービス・Gecko設定・利用者設定は変更なし。
本番のタスク削除や外部カレンダー本文を用いた検証は行っていません。
### 復旧点
`.deployment-backups/release-v0.14.0-20261108/` の `config/` に旧構成、
`cutover/data`・`cutover/data2`に停止時点のデータを保存しています。
18:18:53 JSTに停止を開始、18:19:57 JSTにchecksum同期・再走査の差分ゼロ・DB一致を確認しました。
稼働元とinodeを共有しません。旧バックアップは削除していません。
旧3イメージは `rollback-before-v0.14.0-20261108` タグで保持しています。
`.env.release` は `PAGESWIKI_IMAGE_TAG=v0.14.0`。
新版の4サービスは18:20:12〜18:20:18 JSTに起動しました。
### 配備後検証
- 4サービスのrevisionが対象commitと一致、running、再起動回数0。
- app・app2のhealthと管理スキーマ検査が正常。legacy task領域は上記の隔離コピー移行試験で別途確認。
- 両DBの `quick_check` がok、削除記録0件。
- 外部HTTPSのhealth・ログイン画面200。匿名のタスク/ダッシュボード/RSS画面は303、タスクAPIは401。
- 実在しないUUIDへの匿名DELETEを401で拒否。
- tasks.js、tasks.css、organizer-dashboard.js、feeds.js、feed-gecko.jsの配信SHA-256がリリースcommitと一致。未完了Gecko変更の混入なし。
- 起動直後のfatal/panic、DB lock、event job failed、schema/migration errorは両アプリとも各0件。
### 配布イメージ
SHAタグから再ビルドせず昇格し、本番ホストで取得したdigestとCIの昇格結果が一致しています。
| イメージ(`git.anya.jp/anya/`、タグ`v0.14.0`) | manifest digest |
| --- | --- |
| pageswiki-app | `sha256:46edb2640bfda3be73d8bed354bb1e014b050d68b6c17af8036d65d7732378af` |
| pageswiki-adaptor-gateway | `sha256:696f2d0bcdf1a3dce8821c061a78ad9f3d6fcaadda32cc1cb4e5d5a117028fc0` |
| pageswiki-excalidraw-viewer | `sha256:4d72abb4c1964553458af2b95e19722e18ae05fcfa2b02ff086407ad962ca62c` |
@@ -0,0 +1,48 @@
# PagesWiki v0.15.0とpages-cli v0.5.0
ブラウザアップロード、信頼端末ログイン、RSSの配信時刻、CSV投影とタスクの関連ページ導線を追加します。Geckoの整備コードと配布イメージも含みますが、専用relayの本番有効化は行いません。
## 変更内容
- `/v/browser` のファイルドロップと右下のキュー。逐次送信、待機取消、折りたたみ、同名保護、一覧だけの更新。ページを閉じた後の再開とフォルダ再帰アップロードは未対応。
- ログイン時の信頼端末選択。管理者指定の最大30日・絶対期限で、既存セッションは延長しません。パスワード/TOTP、OIDC、LDAP、マジックリンクに選択を引き継ぎます。
- CLIの `login --remember` と期限切れ再ログイン時の作業パス/保留下書き保持。
- RSS一覧の配信時刻とDomainタイムゾーン。本文の日付表示も同じタイムゾーンへ統一。
- 保存済みタスクの関連Wikiページを開くボタン。
- 認証済み閲覧者の権限を確認する有界CSV macro。`{{csv:/data/items.csv range=A1:H200 header=true}}` と同じObjectのRevision固定に対応。CSV編集・匿名投影・外部URL取得は含みません。
- Geckoの日本語ページ内検索、起動上限・失敗時のiframe破棄、固定ソース/notice付き配布物検査。Safari実機、IME・コピー、運用firewallと低メモリ受入は残件。
## リリースと検証
本体commitは `b90aef79d03c21332cd49a47aba015a30f6de1a0`。Gitea [build 76](https://git.anya.jp/anya/pages/actions/runs/76)、[release 79](https://git.anya.jp/anya/pages/actions/runs/79) が成功し、SHAイメージを再ビルドせず `v0.15.0` へ昇格しました。
CLI commitは `bee03094f3bf2fa0c2dab80313d2f4bd15452c3d`。[v0.5.0](https://git.anya.jp/anya/pages-cli/releases/tag/v0.5.0) のCIと55単体テストが成功。公開した4ファイルのSHA256SUMS照合、Pythonソース一致、取得したLinux ELFのバージョン・ログイン・タスク/メール取り込み・下書き回復等の合成スモークテストを確認しました。未検証のmacOS/Windowsバイナリは追加していません。
本体は `go test ./...`、`go vet ./...`、リリースツールと壁紙テスト、Gecko配布ツールのテストが成功。Chromiumで認証・タスク・RSS・Gecko・アップロードの合成試験を実施しました。アップロードキューは1280px/390px幅、逐次送信、同名保護、取消、一覧更新を検証しています。
## DBと復旧
`cli-auth` v1→v2で `auth_cli_requests.remember` を既定0・0/1制約付きで追加します。他の管理対象componentのversionは変わりません。両インスタンスの独立コピーで、ネットワークを遮断しworkerを停止して新イメージを起動し、schema checkとSQLite integrity_checkが成功しました。実外部カレンダーやメール内容は検証に使用していません。
保全先は `.deployment-backups/release-v0.15.0-20261108/`。`config/` に旧設定、`cutover/data` と `cutover/data2` に停止時点のデータを保存します。旧3イメージの `rollback-before-v0.15.0-20261108` タグと既存バックアップを保持します。
新しいmigration履歴を旧版が受け付けるとは限らないため、旧イメージだけのダウングレードは行いません。切戻しが必要ならwriterを止め、切替後データも保全し、停止時バックアップとの変更差分を扱ってからDB・ファイル・設定・イメージを同じ復旧点へ戻します。運用開始後の書き込みを黙って破棄しません。
## 本番反映
2026-11-08 20:41:33 JSTに配備後確認を完了しました。20:40:05に停止し、20:41:10に停止時バックアップを検証、20:41:16に新版の起動とhealthを確認しています。
- app・app2・adaptor-gateway・excalidraw-viewerはすべて対象commitと一致し、running・再起動回数0。
- 両DBのquick_checkはok、管理対象13componentはcurrent。legacy領域全体の検証を意味するものではありません。
- 外部HTTPSのhealth・ログイン画面200。匿名タスク/dashboard/RSS画面303、タスクAPI・DELETE・captureは401。
- tasks、RSS、Gecko、アップロードキュー、信頼端末UIの配信JS/CSSはリリースcommitとSHA-256一致。公開ログイン画面の信頼端末選択も確認。
- 起動直後のfatal/panic、DB/schema failure、event job failureは両アプリとも0件。
- `.env.release` は `PAGESWIKI_IMAGE_TAG=v0.15.0`。Gecko relayコンテナは起動せず、通常3イメージ・4サービスだけを更新。
配備イメージのmanifest digest:
| イメージ(`git.anya.jp/anya/`) | digest |
| --- | --- |
| pageswiki-app | `sha256:43c398f2c294c7802987aaae1bfdf27b3d0c7ea24fa73df912ac03ea312366b0` |
| pageswiki-adaptor-gateway | `sha256:aebc515c3b3e36b58b03ecab1646e6d95b0dd21074a1a863ca5806cb7fde4df1` |
| pageswiki-excalidraw-viewer | `sha256:4a80354aa4567abe52ff17e32a6f224e85d8cd2e0f1a466e5690b4b353d901cc` |
@@ -0,0 +1,39 @@
# PagesWiki v0.16.0
2026-11-09 05:58:14 JSTに本番の配備後確認を完了しました。CSVの表編集・複数セル貼り付けと、Reveal.jsのビューア・編集プレビューを追加します。
## 変更と利用方法
- 既存CSVを `/e/-/{path}` で表編集。行列操作、Undo/Redo、タブ区切りの複数セル貼り付け、既存の下書き・履歴・競合確認に対応します。未変更セルの引用符・BOM・改行を保持し、上限超過時は部分反映しません。
- HTMLページのスライドアイコン、または `/v/slides/{path}` でReveal.js表示。エディタのスライドアイコンで未保存HTML/Markdownをプレビューします。Markdownの空行で囲んだ `---`、HTML直下の `<hr>` で区切ります。
- Reveal.js 6.0.2をMITライセンスとともにローカル同梱。sandbox、Path認可、入力上限、テーマ追従、スマホの全幅プレビューに対応。拡張設定の `viewer.slides` でドメイン単位に停止できます。
CSVは全体256 KiB、表200行・32列・セル16 KiB以内。スライドは256 KiB・100枚以内です。縦スライド・発表者ノート・専用印刷・外部画像承認連携は含みません。通常HTMLの自動表示をスライドへ置き換えません。
## リリースと検証
対象commitは `02fb77f72b45c342c6b458d733f840b38cc3ae56`。[build 80](https://git.anya.jp/anya/pages/actions/runs/80)と[release 81](https://git.anya.jp/anya/pages/actions/runs/81)が成功し、同じSHAのイメージを再ビルドせずv0.16.0へ昇格しました。
開発環境で全Goテスト・go vet・JS単体テスト、1280px/390pxのChromium試験を実施しました。CSV保存・競合・履歴・貼り付け拒否、スライドのライブ更新・通常プレビュー復帰・左右キー・履歴非変更・隔離を確認しています。
本番ではapp・app2・adaptor-gateway・excalidraw-viewerのrevision一致、running、再起動0を確認。両アプリのhealth、外部HTTPSのhealth/login 200、匿名タスク・スライドの303、タスクAPIの401を確認しました。CSV/Reveal.js関連の11配信ファイルはリリースcommitとSHA-256一致。両DBのquick_checkはok、管理対象13componentはcurrentで版変更なしです。legacy領域全体の移行検証を意味しません。起動直後のpanic・fatal・DB/schema失敗・event job失敗に該当するログはありませんでした。
本番の実コンテンツを編集する試験、外部カレンダー・メール内容の取得は行っていません。pages-cliは変更せず、Gecko relayも起動していません。
## 保全と切替
DBスキーマ・ストレージ形式の変更はありません。保全先は `.deployment-backups/release-v0.16.0-20261109/`。`config/` に旧設定、`cutover/data` と `cutover/data2` に停止時点のファイルを保持しています。DBだけは容量を考慮して `pages.db.gz` とし、gzip検査と展開内容のバイト一致を確認しました。他のファイルは停止時checksum比較で一致しています。復旧用に展開する場合は、稼働DBを上書きせず別の停止済み復旧領域に `pages.db` として展開します。
初回は圧縮で変わったバックアップ先フォルダmtimeを厳密差分検査が検出し、新版起動前にv0.15.0へ自動復帰しました。圧縮後にフォルダmtimeを元に合わせる修正を行い、内容の検証は省略せず再実行しています。再試行は05:54:59 JSTに停止、05:57:28にバックアップ検証完了、05:57:34に新版health確認完了です。
旧イメージは `rollback-before-v0.16.0-20261109` タグで保持し、過去のバックアップも削除していません。今回のUI機能を切り戻す場合はwriterを止め、現データを保持してv0.15.0のイメージへ戻せます。バックアップ時点へのデータ復旧を選ぶ場合は、切替後の書き込みを別途保全して差分を扱い、黙って破棄しません。
`.env.release` は `PAGESWIKI_IMAGE_TAG=v0.16.0`。配備後の空き容量は約8.1 GiBのため、次の大きなビルド・バックアップの前に保持世代と不要キャッシュの整理が必要です。
## 配備イメージ
- `pageswiki-app`: `sha256:428f4c38297e7d2b529af13b32d45e6a9b40f58915fbd170148a0ad07958a034`
- `pageswiki-adaptor-gateway`: `sha256:cdf99b4f02a9abade8862caea1c23cfe775f229118c5c1aabf2584d84a02be50`
- `pageswiki-excalidraw-viewer`: `sha256:854fa1d0bb931642e81af394ab4631b47397a94264eb1b34d4f8ff0ca5435e25`
レジストリのprefixは `git.anya.jp/anya/`、共通タグは `v0.16.0` です。
+8
View File
@@ -12,6 +12,14 @@ require (
modernc.org/sqlite v1.32.0
)
require (
github.com/google/go-cmp v0.6.0 // indirect
github.com/google/nftables v0.3.0 // indirect
github.com/mdlayher/netlink v1.7.3-0.20250113171957-fbb4dce95f42 // indirect
github.com/mdlayher/socket v0.5.0 // indirect
golang.org/x/sync v0.11.0 // indirect
)
require (
github.com/Azure/go-ntlmssp v0.1.1 // indirect
github.com/SherClockHolmes/webpush-go v1.4.0
+7
View File
@@ -27,7 +27,10 @@ github.com/golang-jwt/jwt/v5 v5.2.1 h1:OuVbFODueb089Lh128TAcimifWaLhJwVflnrgM17w
github.com/golang-jwt/jwt/v5 v5.2.1/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
github.com/gomarkdown/markdown v0.0.0-20260417124207-7d523f7318df h1:Mwihr/o+v4L5h56rwHLOE20+hh7Okhwno5BHz3zDuao=
github.com/gomarkdown/markdown v0.0.0-20260417124207-7d523f7318df/go.mod h1:JDGcbDT52eL4fju3sZ4TeHGsQwhG9nbDV21aMyhwPoA=
github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/google/nftables v0.3.0 h1:bkyZ0cbpVeMHXOrtlFc8ISmfVqq5gPJukoYieyVmITg=
github.com/google/nftables v0.3.0/go.mod h1:BCp9FsrbF1Fn/Yu6CLUc9GGZFw/+hsxfluNXXmxBfRM=
github.com/google/pprof v0.0.0-20240409012703-83162a5b38cd h1:gbpYu9NMq8jhDVbvlGkMFWCjLFlqqEZjEmObmhUy6Vo=
github.com/google/pprof v0.0.0-20240409012703-83162a5b38cd/go.mod h1:kf6iHlnVGwgKolg33glAes7Yg/8iWP8ukqeldJSO7jw=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
@@ -55,6 +58,10 @@ github.com/jcmturner/rpc/v2 v2.0.3 h1:7FXXj8Ti1IaVFpSAziCZWNzbNuZmnvw/i6CqLNdWfZ
github.com/jcmturner/rpc/v2 v2.0.3/go.mod h1:VUJYCIDm3PVOEHw8sgt091/20OJjskO/YJki3ELg/Hc=
github.com/mattn/go-isatty v0.0.22 h1:j8l17JJ9i6VGPUFUYoTUKPSgKe/83EYU2zBC7YNKMw4=
github.com/mattn/go-isatty v0.0.22/go.mod h1:ZXfXG4SQHsB/w3ZeOYbR0PrPwLy+n6xiMrJlRFqopa4=
github.com/mdlayher/netlink v1.7.3-0.20250113171957-fbb4dce95f42 h1:A1Cq6Ysb0GM0tpKMbdCXCIfBclan4oHk1Jb+Hrejirg=
github.com/mdlayher/netlink v1.7.3-0.20250113171957-fbb4dce95f42/go.mod h1:BB4YCPDOzfy7FniQ/lxuYQ3dgmM2cZumHbK8RpTjN2o=
github.com/mdlayher/socket v0.5.0 h1:ilICZmJcQz70vrWVes1MFera4jGiWNocSkykwwoy3XI=
github.com/mdlayher/socket v0.5.0/go.mod h1:WkcBFfvyG8QENs5+hfQPl1X6Jpd2yeLIYgrGFmJiJxI=
github.com/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwXFM08ygZfk=
github.com/microcosm-cc/bluemonday v1.0.27/go.mod h1:jFi9vgW+H7c3V0lb6nR74Ib/DIB5OBs92Dimizgw2cA=
github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
+2
View File
@@ -21,6 +21,8 @@ type Manifest struct {
func Catalog() []Manifest {
return []Manifest{
{ID: "viewer.slides", APIVersion: 1, Version: "0.1.0", Kind: "viewer", Scope: "domain", NameKey: "slides.title", DescriptionKey: "slides.help", Capabilities: []string{"path.read"}, Events: []string{}, SettingsPanel: "extensions", Builtin: true, Enabled: true, ResourceClass: "client-compute+bounded-read"},
{ID: "viewer.gecko", APIVersion: 1, Version: "0.1.0", Kind: "viewer", Scope: "domain", NameKey: "feeds.gecko", DescriptionKey: "feeds.gecko_help", Capabilities: []string{"feeds.own.read"}, Events: []string{}, SettingsPanel: "extensions", Builtin: true, Enabled: false, ResourceClass: "client-compute+relay-network"},
{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"},
+22
View File
@@ -0,0 +1,22 @@
PagesWiki Gecko relay
This image contains the PagesWiki TCP relay, not Firefox/Gecko, gecko.js,
gecko.wasm.zst, Mozilla runtime assets or browser fonts.
Third-party code linked into the relay binary:
- Go standard library and runtime, Copyright The Go Authors.
BSD-3-Clause; full license: /licenses/Go.txt
Source and release archives: https://go.dev/dl/
- golang.org/x/net v0.35.0 (WebSocket transport), Copyright The Go Authors.
BSD-3-Clause; full license: /licenses/golang-x-net.txt
Source: https://go.googlesource.com/net/+/refs/tags/v0.35.0/
The licenses are copied from the exact toolchain/module used at build time.
The scratch runtime image does not contain Alpine, BusyBox or apk.
The PagesWiki integration source and engine redistribution assessment are in:
https://git.anya.jp/anya/pages
docs/operations/gecko-redistribution.md
Mounting and serving an independently obtained browser engine requires a
separate assessment and delivery of its applicable notices and source offer.
This relay notice is not a license grant for that engine.
+137
View File
@@ -0,0 +1,137 @@
// Package geckorelay provides a bounded TCP-only Wisp transport for Gecko.
// It is not a public general-purpose proxy: the PagesWiki frontend authenticates
// the user and signs each backend request, and every destination is checked here.
package geckorelay
import (
"context"
"crypto/hmac"
"crypto/sha256"
"encoding/base64"
"encoding/json"
"errors"
"net"
"net/netip"
"strconv"
"strings"
"time"
)
const GrantHeader = "X-PagesWiki-Gecko-Grant"
type Grant struct {
Subject string `json:"subject"`
Nonce string `json:"nonce"`
Expires int64 `json:"expires"`
}
func Sign(key string, grant Grant) string {
data, _ := json.Marshal(grant)
body := base64.RawURLEncoding.EncodeToString(data)
h := hmac.New(sha256.New, []byte(key))
h.Write([]byte(body))
return body + "." + base64.RawURLEncoding.EncodeToString(h.Sum(nil))
}
func Verify(key, token string, now time.Time) (Grant, error) {
var grant Grant
parts := strings.Split(token, ".")
if len(key) < 32 || len(token) > 2048 || len(parts) != 2 {
return grant, errors.New("invalid grant")
}
sig, err := base64.RawURLEncoding.DecodeString(parts[1])
if err != nil {
return grant, errors.New("invalid grant")
}
h := hmac.New(sha256.New, []byte(key))
h.Write([]byte(parts[0]))
if !hmac.Equal(sig, h.Sum(nil)) {
return grant, errors.New("invalid grant")
}
data, err := base64.RawURLEncoding.DecodeString(parts[0])
if err != nil {
return grant, errors.New("invalid grant")
}
if json.Unmarshal(data, &grant) != nil || grant.Subject == "" || len(grant.Subject) > 160 || len(grant.Nonce) < 16 || len(grant.Nonce) > 80 || grant.Expires <= now.Unix() || grant.Expires > now.Add(time.Minute).Unix() {
return Grant{}, errors.New("invalid grant")
}
return grant, nil
}
var denied = func() []netip.Prefix {
var result []netip.Prefix
for _, p := range []string{"0.0.0.0/8", "100.64.0.0/10", "192.0.0.0/24", "192.0.2.0/24", "192.88.99.0/24", "198.18.0.0/15", "198.51.100.0/24", "203.0.113.0/24", "240.0.0.0/4", "2001::/23", "2001:db8::/32", "2002::/16", "3fff::/20"} {
result = append(result, netip.MustParsePrefix(p))
}
return result
}()
func PublicIP(ip netip.Addr) bool {
ip = ip.Unmap()
if !ip.IsValid() || ip.Zone() != "" || !ip.IsGlobalUnicast() || ip.IsPrivate() || ip.IsLoopback() || ip.IsLinkLocalUnicast() {
return false
}
// Only globally allocated IPv6 unicast; excludes NAT64, mapped/private and
// future address classes rather than treating unknown ranges as public.
if ip.Is6() && !netip.MustParsePrefix("2000::/3").Contains(ip) {
return false
}
for _, p := range denied {
if p.Contains(ip) {
return false
}
}
return true
}
func ValidDestination(host string, port uint16) bool {
if port != 80 && port != 443 {
return false
}
if ip, err := netip.ParseAddr(host); err == nil {
return PublicIP(ip)
}
host = strings.TrimSuffix(strings.ToLower(host), ".")
if len(host) == 0 || len(host) > 253 || host == "localhost" || strings.HasSuffix(host, ".localhost") || !strings.Contains(host, ".") {
return false
}
for _, label := range strings.Split(host, ".") {
if len(label) == 0 || len(label) > 63 || label[0] == '-' || label[len(label)-1] == '-' {
return false
}
for _, c := range label {
if !(c >= 'a' && c <= 'z' || c >= '0' && c <= '9' || c == '-') {
return false
}
}
}
return true
}
type lookupFunc func(context.Context, string, string) ([]netip.Addr, error)
type dialFunc func(context.Context, string, string) (net.Conn, error)
func dialPublic(ctx context.Context, host string, port uint16, lookup lookupFunc, dial dialFunc) (net.Conn, error) {
if !ValidDestination(host, port) {
return nil, errors.New("blocked destination")
}
ips, err := lookup(ctx, "ip", host)
if err != nil || len(ips) == 0 || len(ips) > 16 {
return nil, errors.New("destination lookup failed")
}
for _, ip := range ips {
if !PublicIP(ip) {
return nil, errors.New("blocked destination")
}
}
for _, ip := range ips {
conn, e := dial(ctx, "tcp", net.JoinHostPort(ip.Unmap().String(), strconv.Itoa(int(port))))
if e == nil {
return conn, nil
}
if ctx.Err() != nil {
break
}
}
return nil, errors.New("destination unavailable")
}
+33
View File
@@ -0,0 +1,33 @@
package geckorelay
import (
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"os"
"path/filepath"
)
const AssetsPrefix = "/assets/v0.0.1/"
// Hashes of the two unmodified files in upstream v0.0.1. The release archive
// itself is pinned in docs/operations/gecko-relay.md. Refuse mixed engine/glue.
func VerifyAssets(dir string) error {
for name, want := range map[string]string{
"gecko.js": "e5aeebffd21106eccf23b1219316221add5e95085bc5a1bfb941117cfcd75ef7",
"gecko.wasm.zst": "ebd6c75179152624d9644865e11792ed25cadc714d9e0985f412baf9c637a086",
} {
f, err := os.Open(filepath.Join(dir, name))
if err != nil {
return fmt.Errorf("required Gecko asset unavailable: %s", name)
}
h := sha256.New()
_, err = io.Copy(h, io.LimitReader(f, 64<<20))
f.Close()
if err != nil || hex.EncodeToString(h.Sum(nil)) != want {
return fmt.Errorf("Gecko asset checksum mismatch: %s", name)
}
}
return nil
}
+85
View File
@@ -0,0 +1,85 @@
package geckorelay
import (
"crypto/sha256"
"encoding/hex"
"encoding/json"
"fmt"
"io"
"os"
"path/filepath"
"regexp"
)
const DistributionPrefix = "/distribution/v0.0.1/"
// Updated only after the reproducible source/notice bundle has been reviewed.
const DistributionManifestSHA256 = "84953114f5e393dd97d9f948a5bc51c95b9355b58461dd3355e068a96cb2e381"
type DistributionFile struct {
File string `json:"file"`
SHA256 string `json:"sha256"`
Size int64 `json:"size"`
Kind string `json:"kind"`
}
var distributionName = regexp.MustCompile(`^[a-zA-Z0-9][a-zA-Z0-9._+-]{0,150}$`)
func VerifyDistribution(dir string) (map[string]DistributionFile, error) {
return verifyDistribution(dir, DistributionManifestSHA256)
}
func verifyDistribution(dir, expected string) (map[string]DistributionFile, error) {
path := filepath.Join(dir, "manifest.json")
info, err := os.Lstat(path)
if err != nil || !info.Mode().IsRegular() || info.Size() > 1<<20 {
return nil, fmt.Errorf("Gecko distribution manifest missing or invalid")
}
raw, err := os.ReadFile(path)
if err != nil {
return nil, err
}
sum := sha256.Sum256(raw)
if hex.EncodeToString(sum[:]) != expected {
return nil, fmt.Errorf("Gecko distribution manifest checksum mismatch")
}
var manifest struct {
Format string `json:"format"`
Version string `json:"version"`
Files []DistributionFile `json:"files"`
}
if json.Unmarshal(raw, &manifest) != nil || manifest.Format != "pageswiki.gecko-distribution.v1" || manifest.Version != "v0.0.1" || len(manifest.Files) > 512 {
return nil, fmt.Errorf("invalid Gecko distribution format")
}
files := map[string]DistributionFile{}
for _, entry := range manifest.Files {
if !distributionName.MatchString(entry.File) || entry.File == "manifest.json" || entry.Size < 1 || entry.Size > 2<<30 || len(entry.SHA256) != 64 {
return nil, fmt.Errorf("invalid distribution entry")
}
if _, exists := files[entry.File]; exists {
return nil, fmt.Errorf("duplicate distribution entry")
}
info, err := os.Lstat(filepath.Join(dir, entry.File))
if err != nil || !info.Mode().IsRegular() || info.Size() != entry.Size {
return nil, fmt.Errorf("distribution file missing or invalid: %s", entry.File)
}
file, err := os.Open(filepath.Join(dir, entry.File))
if err != nil {
return nil, err
}
hash := sha256.New()
_, err = io.Copy(hash, io.LimitReader(file, entry.Size+1))
file.Close()
if err != nil || hex.EncodeToString(hash.Sum(nil)) != entry.SHA256 {
return nil, fmt.Errorf("distribution file checksum mismatch: %s", entry.File)
}
files[entry.File] = entry
}
for _, name := range []string{"index.html", "README.txt", "gecko.js", "gecko.wasm.zst", "firefox.tar.gz", "firefox.tar.gz.notices.txt", "wrapper.tar.gz", "wrapper-MPL.txt", "emscripten.tar.gz", "emscripten.tar.gz.notices.txt", "rust-src.tar.xz", "rust-src.tar.xz.notices.txt", "zstddec.tgz", "zstddec.tgz.notices.txt", "NotoSansCJKjp-Regular.otf", "NotoSansCJK-LICENSE.txt"} {
if _, ok := files[name]; !ok {
return nil, fmt.Errorf("distribution incomplete: %s", name)
}
}
files["manifest.json"] = DistributionFile{File: "manifest.json", SHA256: expected, Size: int64(len(raw)), Kind: "manifest"}
return files, nil
}
+83
View File
@@ -0,0 +1,83 @@
package geckorelay
import (
"crypto/sha256"
"encoding/hex"
"encoding/json"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"testing"
"time"
)
func TestDistribution(t *testing.T) {
dir := t.TempDir()
if _, err := VerifyDistribution(dir); err == nil {
t.Fatal("missing distribution accepted")
}
names := []string{"index.html", "README.txt", "gecko.js", "gecko.wasm.zst", "firefox.tar.gz", "firefox.tar.gz.notices.txt", "wrapper.tar.gz", "wrapper-MPL.txt", "emscripten.tar.gz", "emscripten.tar.gz.notices.txt", "rust-src.tar.xz", "rust-src.tar.xz.notices.txt", "zstddec.tgz", "zstddec.tgz.notices.txt", "NotoSansCJKjp-Regular.otf", "NotoSansCJK-LICENSE.txt"}
content := []byte("synthetic source and notice")
hash := sha256.Sum256(content)
var entries []DistributionFile
for _, name := range names {
if err := os.WriteFile(filepath.Join(dir, name), content, 0600); err != nil {
t.Fatal(err)
}
entries = append(entries, DistributionFile{File: name, Size: int64(len(content)), SHA256: hex.EncodeToString(hash[:])})
}
raw, _ := json.Marshal(map[string]any{"format": "pageswiki.gecko-distribution.v1", "version": "v0.0.1", "files": entries})
if err := os.WriteFile(filepath.Join(dir, "manifest.json"), raw, 0600); err != nil {
t.Fatal(err)
}
sum := sha256.Sum256(raw)
want := hex.EncodeToString(sum[:])
files, err := verifyDistribution(dir, want)
if err != nil {
t.Fatal(err)
}
relay, _ := New(testKey, dir)
relay.Distribution = files
for _, name := range []string{"index.html", "firefox.tar.gz", "manifest.json", "unknown", "../manifest.json"} {
req := httptest.NewRequest("GET", DistributionPrefix+name, nil)
req.Header.Set(GrantHeader, Sign(testKey, Grant{Subject: "test:user", Nonce: "download-test-0123456789", Expires: time.Now().Add(30 * time.Second).Unix()}))
rec := httptest.NewRecorder()
relay.ServeHTTP(rec, req)
expected := 200
if strings.Contains(name, "unknown") || strings.Contains(name, "../") {
expected = 404
}
if rec.Code != expected {
t.Fatalf("%s: %d", name, rec.Code)
}
if expected == 200 && rec.Header().Get("ETag") == "" {
t.Fatal("no ETag")
}
}
if err := os.WriteFile(filepath.Join(dir, "README.txt"), []byte("tampered"), 0600); err != nil {
t.Fatal(err)
}
if _, err := verifyDistribution(dir, want); err == nil {
t.Fatal("tampered notice accepted")
}
if err := os.Remove(filepath.Join(dir, "README.txt")); err != nil {
t.Fatal(err)
}
if err := os.Symlink(filepath.Join(dir, "gecko.js"), filepath.Join(dir, "README.txt")); err != nil {
t.Fatal(err)
}
if _, err := verifyDistribution(dir, want); err == nil {
t.Fatal("symlink accepted")
}
}
func TestDistributionRealBundle(t *testing.T) {
dir := os.Getenv("PAGESWIKI_GECKO_TEST_BUNDLE")
if dir == "" {
t.Skip("opt-in complete distribution")
}
if _, err := VerifyDistribution(dir); err != nil {
t.Fatal(err)
}
}
+396
View File
@@ -0,0 +1,396 @@
package geckorelay
import (
"bytes"
"context"
"encoding/binary"
"encoding/json"
"errors"
"io"
"net"
"net/http"
"os"
"path/filepath"
"strings"
"sync"
"sync/atomic"
"time"
"golang.org/x/net/websocket"
)
const (
window = 8
maxFrame = 256 << 10
maxStreams = 16
maxBytes = 256 << 20
bytesPerSecond = 2 << 20
)
type Relay struct {
Key, Assets string
Distribution map[string]DistributionFile
downloads chan struct{}
mu sync.Mutex
active map[string]bool
used map[string]int64
rx, tx, rejected atomic.Int64
// Overridden only by package tests; deployment always resolves and pins public IPs.
dial func(context.Context, string, uint16) (net.Conn, error)
}
func New(key, assets string) (*Relay, error) {
if len(key) < 32 {
return nil, errors.New("relay key must contain at least 32 bytes")
}
r := &Relay{Key: key, Assets: assets, active: map[string]bool{}, used: map[string]int64{}, downloads: make(chan struct{}, 2)}
r.dial = func(ctx context.Context, host string, port uint16) (net.Conn, error) {
ctx, cancel := context.WithTimeout(ctx, 8*time.Second)
defer cancel()
return dialPublic(ctx, host, port, net.DefaultResolver.LookupNetIP, (&net.Dialer{Timeout: 2 * time.Second}).DialContext)
}
return r, nil
}
func (r *Relay) ServeHTTP(w http.ResponseWriter, req *http.Request) {
w.Header().Set("Cache-Control", "no-store")
if req.URL.Path == "/health" && req.Method == "GET" {
io.WriteString(w, "ok")
return
}
grant, err := Verify(r.Key, req.Header.Get(GrantHeader), time.Now())
if err != nil {
http.Error(w, "forbidden", 403)
return
}
if req.Method != "GET" || req.URL.RawQuery != "" {
http.Error(w, "invalid request", 400)
return
}
if req.URL.Path == "/status" {
r.mu.Lock()
active := len(r.active)
r.mu.Unlock()
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]any{"active_sessions": active, "received_bytes": r.rx.Load(), "sent_bytes": r.tx.Load(), "rejected": r.rejected.Load(), "profile": "tcp-80-443", "max_sessions": 4, "max_streams": maxStreams, "bytes_per_second": bytesPerSecond, "max_session_bytes": maxBytes})
return
}
if strings.HasPrefix(req.URL.Path, DistributionPrefix) {
name := strings.TrimPrefix(req.URL.Path, DistributionPrefix)
entry, ok := r.Distribution[name]
if !ok {
http.NotFound(w, req)
return
}
select {
case r.downloads <- struct{}{}:
defer func() { <-r.downloads }()
default:
http.Error(w, "download limit", 429)
return
}
w.Header().Set("ETag", `"`+entry.SHA256+`"`)
w.Header().Set("Cache-Control", "private, max-age=86400, immutable")
w.Header().Set("X-Content-Type-Options", "nosniff")
w.Header().Set("Content-Security-Policy", "default-src 'none'; base-uri 'none'; frame-ancestors 'self'")
w.Header().Set("Referrer-Policy", "no-referrer")
switch {
case name == "index.html":
w.Header().Set("Content-Type", "text/html; charset=utf-8")
case strings.HasSuffix(name, ".txt"):
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
case name == "manifest.json":
w.Header().Set("Content-Type", "application/json")
default:
w.Header().Set("Content-Type", "application/octet-stream")
w.Header().Set("Content-Disposition", `attachment; filename="`+name+`"`)
}
// ServeContent avoids ServeFile's /index.html -> ./ redirect, which
// would escape the explicit file allowlist at the proxy boundary.
file, err := os.Open(filepath.Join(r.Assets, name))
if err != nil {
http.NotFound(w, req)
return
}
defer file.Close()
http.ServeContent(w, req, name, time.Time{}, file)
return
}
if req.URL.Path == AssetsPrefix+"gecko.js" || req.URL.Path == AssetsPrefix+"gecko.wasm.zst" {
w.Header().Set("Cross-Origin-Resource-Policy", "same-origin")
w.Header().Set("Cache-Control", "private, max-age=86400, immutable")
if strings.HasSuffix(req.URL.Path, ".js") {
w.Header().Set("Content-Type", "text/javascript")
} else {
w.Header().Set("Content-Type", "application/octet-stream")
}
http.ServeFile(w, req, filepath.Join(r.Assets, filepath.Base(req.URL.Path)))
return
}
if req.URL.Path != "/wisp/" {
http.NotFound(w, req)
return
}
r.mu.Lock()
now := time.Now().Unix()
for nonce, expires := range r.used {
if expires <= now {
delete(r.used, nonce)
}
}
if r.active[grant.Subject] || len(r.active) >= 4 || r.used[grant.Nonce] > now || len(r.used) >= 256 {
r.mu.Unlock()
r.rejected.Add(1)
http.Error(w, "session limit", 429)
return
}
r.active[grant.Subject] = true
r.used[grant.Nonce] = grant.Expires
r.mu.Unlock()
defer func() { r.mu.Lock(); delete(r.active, grant.Subject); r.mu.Unlock() }()
wsServer := websocket.Server{Handshake: func(c *websocket.Config, req *http.Request) error {
// Only the authenticated PagesWiki proxy can sign a grant. It validates
// the browser Origin before forwarding, not the untrusted client header.
if req.Header.Get("Origin") == "" {
return errors.New("origin required")
}
return nil
}, Handler: func(ws *websocket.Conn) { r.serve(ws) }}
wsServer.ServeHTTP(w, req)
}
type stream struct {
data chan []byte
done chan struct{}
once sync.Once
mu sync.Mutex
conn net.Conn
}
func (s *stream) close() {
s.once.Do(func() {
close(s.done)
s.mu.Lock()
if s.conn != nil {
s.conn.Close()
}
s.mu.Unlock()
})
}
func packet(kind byte, id uint32, data []byte) []byte {
b := make([]byte, 5+len(data))
b[0] = kind
binary.LittleEndian.PutUint32(b[1:], id)
copy(b[5:], data)
return b
}
func credit() []byte { b := make([]byte, 4); binary.LittleEndian.PutUint32(b, window); return b }
func (r *Relay) serve(ws *websocket.Conn) {
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Minute)
defer cancel()
defer ws.Close()
ws.MaxPayloadBytes = maxFrame + 5
var mu, sendMu, budgetMu sync.Mutex
streams := map[uint32]*stream{}
var workers sync.WaitGroup
var spent int64
tokens := float64(bytesPerSecond)
last := time.Now()
account := func(n int) bool {
budgetMu.Lock()
defer budgetMu.Unlock()
spent += int64(n)
if spent > maxBytes {
return false
}
now := time.Now()
tokens += now.Sub(last).Seconds() * bytesPerSecond
if tokens > bytesPerSecond {
tokens = bytesPerSecond
}
last = now
tokens -= float64(n)
if tokens < 0 {
timer := time.NewTimer(time.Duration(-tokens / bytesPerSecond * float64(time.Second)))
defer timer.Stop()
select {
case <-timer.C:
tokens = 0
last = time.Now()
case <-ctx.Done():
return false
}
}
return true
}
send := func(kind byte, id uint32, data []byte) error {
sendMu.Lock()
defer sendMu.Unlock()
ws.SetWriteDeadline(time.Now().Add(10 * time.Second))
return websocket.Message.Send(ws, packet(kind, id, data))
}
defer func() {
cancel()
mu.Lock()
for _, s := range streams {
s.close()
}
mu.Unlock()
workers.Wait()
}()
go func() { <-ctx.Done(); ws.Close() }()
if send(3, 0, credit()) != nil {
return
}
connections := 0
for {
ws.SetReadDeadline(time.Now().Add(90 * time.Second))
var b []byte
if websocket.Message.Receive(ws, &b) != nil {
return
}
if len(b) < 5 || !account(len(b)) {
return
}
r.rx.Add(int64(len(b)))
kind, id := b[0], binary.LittleEndian.Uint32(b[1:])
if id == 0 {
return
}
mu.Lock()
s := streams[id]
mu.Unlock()
switch kind {
case 1:
connections++
if s != nil || len(b) < 9 || len(b) > 261 || connections > 256 {
return
}
port := binary.LittleEndian.Uint16(b[6:8])
host := string(b[8:])
if b[5] != 1 || !ValidDestination(host, port) {
r.rejected.Add(1)
if send(4, id, []byte{0x48}) != nil {
return
}
continue
}
mu.Lock()
full := len(streams) >= maxStreams
mu.Unlock()
if full {
r.rejected.Add(1)
if send(4, id, []byte{0x49}) != nil {
return
}
continue
}
s = &stream{data: make(chan []byte, window), done: make(chan struct{})}
mu.Lock()
streams[id] = s
mu.Unlock()
workers.Add(1)
go func(id uint32, s *stream, host string, port uint16) {
defer workers.Done()
defer func() { s.close(); mu.Lock(); delete(streams, id); mu.Unlock() }()
dialCtx, stop := context.WithCancel(ctx)
defer stop()
go func() {
select {
case <-s.done:
stop()
case <-dialCtx.Done():
}
}()
conn, e := r.dial(dialCtx, host, port)
if e != nil {
r.rejected.Add(1)
send(4, id, []byte{0x48})
return
}
s.mu.Lock()
s.conn = conn
s.mu.Unlock()
select {
case <-s.done:
conn.Close()
return
default:
}
readerDone := make(chan struct{})
defer func() { conn.Close(); <-readerDone }()
go func() {
defer close(readerDone)
defer s.close()
buffer := make([]byte, 64<<10)
for {
conn.SetReadDeadline(time.Now().Add(60 * time.Second))
n, e := conn.Read(buffer)
if n > 0 {
if !account(n) {
cancel()
return
}
r.tx.Add(int64(n))
if send(2, id, buffer[:n]) != nil {
cancel()
return
}
}
if e != nil {
send(4, id, []byte{2})
return
}
}
}()
count := 0
for {
select {
case <-ctx.Done():
return
case <-s.done:
return
case data := <-s.data:
conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
if _, e = io.Copy(conn, bytes.NewReader(data)); e != nil {
send(4, id, []byte{3})
return
}
count++
if count == window {
count = 0
if send(3, id, credit()) != nil {
cancel()
return
}
}
}
}
}(id, s, host, port)
case 2:
if s == nil {
continue
}
select {
case <-s.done:
case s.data <- b[5:]:
default:
r.rejected.Add(1)
s.close()
if send(4, id, []byte{0x49}) != nil {
return
}
}
case 4:
if len(b) != 6 {
return
}
if s != nil {
s.close()
}
default:
return
}
}
}
+284
View File
@@ -0,0 +1,284 @@
package geckorelay
import (
"context"
"encoding/binary"
"io"
"net"
"net/http"
"net/http/httptest"
"net/netip"
"os"
"path/filepath"
"strings"
"sync/atomic"
"testing"
"time"
"golang.org/x/net/websocket"
)
const testKey = "synthetic-relay-key-at-least-32-bytes-long"
func TestAssetsPin(t *testing.T) {
dir := t.TempDir()
if VerifyAssets(dir) == nil {
t.Fatal("missing assets accepted")
}
for _, name := range []string{"gecko.js", "gecko.wasm.zst"} {
if err := os.WriteFile(filepath.Join(dir, name), []byte("untrusted"), 0600); err != nil {
t.Fatal(err)
}
}
if VerifyAssets(dir) == nil {
t.Fatal("unverified assets accepted")
}
if assets := os.Getenv("PAGESWIKI_GECKO_TEST_ASSETS"); assets != "" {
if err := VerifyAssets(assets); err != nil {
t.Fatal(err)
}
}
}
func TestGrant(t *testing.T) {
now := time.Now()
g := Grant{"domain:actor", "0123456789abcdef", now.Add(30 * time.Second).Unix()}
token := Sign(testKey, g)
if got, e := Verify(testKey, token, now); e != nil || got != g {
t.Fatal(got, e)
}
for _, bad := range []string{token + "x", "", strings.Repeat("x", 2049), Sign(testKey, Grant{g.Subject, g.Nonce, now.Add(2 * time.Minute).Unix()}), Sign(testKey, Grant{g.Subject, g.Nonce, now.Unix()})} {
if _, e := Verify(testKey, bad, now); e == nil {
t.Fatal("accepted invalid grant")
}
}
if _, e := Verify("other-key-at-least-32-bytes-long!!", token, now); e == nil {
t.Fatal("wrong key")
}
}
func TestDestinations(t *testing.T) {
for _, host := range []string{"127.0.0.1", "localhost", "host.localhost", "10.0.0.1", "169.254.169.254", "100.64.0.1", "192.0.2.2", "198.19.0.1", "::1", "::ffff:127.0.0.1", "64:ff9b::808:808", "2002:808:808::1", "2001:db8::1", "3fff::1", "fd00::1", "fe80::1%eth0", "bad/host", "example.org\x00.evil", "singlelabel"} {
if ValidDestination(host, 443) {
t.Fatalf("allowed %q", host)
}
}
for _, host := range []string{"example.org", "EXAMPLE.org.", "8.8.8.8", "2606:4700:4700::1111"} {
if !ValidDestination(host, 443) {
t.Fatal("blocked", host)
}
}
if ValidDestination("example.org", 22) {
t.Fatal("port allowed")
}
called := false
dial := func(_ context.Context, _, addr string) (net.Conn, error) {
called = true
if addr != "8.8.8.8:443" {
t.Fatal("unvalidated DNS re-resolution", addr)
}
a, b := net.Pipe()
b.Close()
return a, nil
}
lookup := func(_ context.Context, _, _ string) ([]netip.Addr, error) {
return []netip.Addr{netip.MustParseAddr("8.8.8.8"), netip.MustParseAddr("127.0.0.1")}, nil
}
if _, err := dialPublic(context.Background(), "example.org", 443, lookup, dial); err == nil || called {
t.Fatal("mixed DNS allowed")
}
lookup = func(_ context.Context, _, _ string) ([]netip.Addr, error) {
return []netip.Addr{netip.MustParseAddr("8.8.8.8")}, nil
}
c, err := dialPublic(context.Background(), "example.org", 443, lookup, dial)
if err != nil || !called {
t.Fatal(err)
}
c.Close()
}
func TestRelayFramesAndLimits(t *testing.T) {
r, _ := New(testKey, t.TempDir())
r.dial = func(ctx context.Context, host string, port uint16) (net.Conn, error) {
a, b := net.Pipe()
go func() { defer b.Close(); io.Copy(b, b) }()
return a, nil
}
s := httptest.NewServer(r)
defer s.Close()
grant := Sign(testKey, Grant{"domain:actor", "nonce-first-connection", time.Now().Add(30 * time.Second).Unix()})
dial := func(token string) (*websocket.Conn, error) {
cfg, _ := websocket.NewConfig("ws"+strings.TrimPrefix(s.URL, "http")+"/wisp/", "https://pages.example")
cfg.Header.Set(GrantHeader, token)
return websocket.DialConfig(cfg)
}
if c, e := dial(""); e == nil {
c.Close()
t.Fatal("anonymous websocket")
}
c, err := dial(grant)
if err != nil {
t.Fatal(err)
}
defer c.Close()
c.SetDeadline(time.Now().Add(5 * time.Second))
receive := func() []byte {
var p []byte
if e := websocket.Message.Receive(c, &p); e != nil {
t.Fatal(e)
}
return p
}
p := receive()
if p[0] != 3 || binary.LittleEndian.Uint32(p[1:]) != 0 || binary.LittleEndian.Uint32(p[5:]) != window {
t.Fatal(p)
}
if second, e := dial(grant); e == nil {
second.Close()
t.Fatal("duplicate actor/replayed grant")
}
connect := func(id uint32, host string, port uint16, kind byte) {
body := []byte{kind, byte(port), byte(port >> 8)}
body = append(body, host...)
if e := websocket.Message.Send(c, packet(1, id, body)); e != nil {
t.Fatal(e)
}
}
connect(1, "127.0.0.1", 80, 1)
if p = receive(); p[0] != 4 || p[5] != 0x48 {
t.Fatal(p)
}
connect(2, "example.org", 443, 2)
if p = receive(); p[0] != 4 {
t.Fatal("UDP accepted")
}
connect(3, "example.org", 443, 1)
for n := 0; n < window; n++ {
if e := websocket.Message.Send(c, packet(2, 3, []byte("hello"))); e != nil {
t.Fatal(e)
}
}
got := 0
creditSeen := false
for got < window*5 || !creditSeen {
p = receive()
switch p[0] {
case 2:
got += len(p) - 5
case 3:
creditSeen = true
default:
t.Fatal(p)
}
}
// Wisp credits count DATA frames, including empty payloads.
for n := 0; n < window; n++ {
if e := websocket.Message.Send(c, packet(2, 3, nil)); e != nil {
t.Fatal(e)
}
}
if p = receive(); p[0] != 3 || binary.LittleEndian.Uint32(p[1:]) != 3 {
t.Fatal("empty frame credit", p)
}
websocket.Message.Send(c, packet(4, 3, []byte{2}))
websocket.Message.Send(c, packet(9, 4, nil))
var b []byte
if websocket.Message.Receive(c, &b) == nil && b[0] != 4 {
t.Fatal("invalid packet accepted")
}
resp, e := http.Get(s.URL + "/status")
if e != nil {
t.Fatal(e)
}
resp.Body.Close()
if resp.StatusCode != 403 {
t.Fatal("unprotected metrics")
}
}
func TestRelayStreamBoundAndCancellation(t *testing.T) {
r, _ := New(testKey, t.TempDir())
var dialing atomic.Int64
r.dial = func(ctx context.Context, host string, port uint16) (net.Conn, error) {
dialing.Add(1)
defer dialing.Add(-1)
<-ctx.Done()
return nil, ctx.Err()
}
server := httptest.NewServer(r)
defer server.Close()
cfg, _ := websocket.NewConfig("ws"+strings.TrimPrefix(server.URL, "http")+"/wisp/", "https://pages.example")
cfg.Header.Set(GrantHeader, Sign(testKey, Grant{"domain:actor", "stream-bound-nonce", time.Now().Add(30 * time.Second).Unix()}))
c, err := websocket.DialConfig(cfg)
if err != nil {
t.Fatal(err)
}
defer c.Close()
c.SetDeadline(time.Now().Add(5 * time.Second))
var frame []byte
if err = websocket.Message.Receive(c, &frame); err != nil {
t.Fatal(err)
}
for id := 1; id <= maxStreams+1; id++ {
if err = websocket.Message.Send(c, packet(1, uint32(id), append([]byte{1, 80, 0}, []byte("example.org")...))); err != nil {
t.Fatal(err)
}
}
if err = websocket.Message.Receive(c, &frame); err != nil || len(frame) != 6 || frame[0] != 4 || binary.LittleEndian.Uint32(frame[1:]) != maxStreams+1 || frame[5] != 0x49 {
t.Fatal("stream cap", frame, err)
}
c.Close()
for n := 0; n < 100; n++ {
r.mu.Lock()
active := len(r.active)
r.mu.Unlock()
if active == 0 && dialing.Load() == 0 {
return
}
time.Sleep(10 * time.Millisecond)
}
t.Fatal("closing session did not cancel pending dials")
}
func TestRelaySessionBoundAndReplay(t *testing.T) {
r, _ := New(testKey, t.TempDir())
server := httptest.NewServer(r)
defer server.Close()
dial := func(subject, nonce string) (*websocket.Conn, error) {
cfg, _ := websocket.NewConfig("ws"+strings.TrimPrefix(server.URL, "http")+"/wisp/", "https://pages.example")
cfg.Header.Set(GrantHeader, Sign(testKey, Grant{subject, nonce, time.Now().Add(30 * time.Second).Unix()}))
return websocket.DialConfig(cfg)
}
var conns []*websocket.Conn
for _, subject := range []string{"one", "two", "three", "four"} {
c, e := dial(subject, "unique-session-nonce-"+subject)
if e != nil {
t.Fatal(e)
}
conns = append(conns, c)
defer c.Close()
}
if c, e := dial("five", "unique-session-nonce-five"); e == nil {
c.Close()
t.Fatal("global cap exceeded")
}
conns[0].Close()
for n := 0; n < 100; n++ {
r.mu.Lock()
active := len(r.active)
r.mu.Unlock()
if active == 3 {
break
}
time.Sleep(10 * time.Millisecond)
}
if c, e := dial("one", "unique-session-nonce-one"); e == nil {
c.Close()
t.Fatal("replayed after close")
}
c, e := dial("five", "unique-session-nonce-retry")
if e != nil {
t.Fatal("slot not released", e)
}
c.Close()
}
+68 -1
View File
@@ -3,6 +3,7 @@ package grammaratur
import (
"bytes"
"encoding/json"
"io"
"sort"
"strings"
@@ -18,11 +19,71 @@ func HTMLToMarkdownAuthoring(source string) (string, error) {
return "", err
}
if htmlStructure(source) != htmlStructure(MarkdownToHTML(converted)) {
return rawHTMLBlock(source), nil
// Protect only the blocks which cannot round-trip. One custom component
// must not turn the headings, lists and paragraphs around it into HTML.
blocks, ok := authoringBlocks(source)
if !ok {
return rawHTMLBlock(source), nil
}
var parts []string
for _, raw := range blocks {
if strings.TrimSpace(raw) == "" {
continue
}
md, e := HTMLToMarkdown(raw)
if e != nil || htmlStructure(raw) != htmlStructure(MarkdownToHTML(md)) {
md = rawHTMLBlock(raw)
}
parts = append(parts, md)
}
mixed := strings.Join(parts, "\n\n")
// Includes head content, comments outside body and fragment edge cases.
if htmlStructure(source) != htmlStructure(MarkdownAuthoringHTML(mixed)) {
return rawHTMLBlock(source), nil
}
return mixed, nil
}
return converted, nil
}
// Token boundaries retain the exact source of protected components (including
// attribute quoting and void-element syntax). Never serialize the parsed DOM
// back over their source. Malformed/implicit nesting uses whole-document fallback.
func authoringBlocks(source string) ([]string, bool) {
z := html.NewTokenizer(strings.NewReader(source))
var stack, blocks []string
start, offset := 0, 0
for {
kind := z.Next()
if kind == html.ErrorToken {
return blocks, z.Err() == io.EOF && len(stack) == 0 && offset == len(source)
}
offset += len(z.Raw())
switch kind {
case html.StartTagToken:
name, _ := z.TagName()
switch string(name) {
case "area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr":
default:
stack = append(stack, string(name))
}
case html.EndTagToken:
name, _ := z.TagName()
if len(stack) == 0 || stack[len(stack)-1] != string(name) {
return nil, false
}
stack = stack[:len(stack)-1]
}
if len(stack) == 0 {
blocks = append(blocks, source[start:offset])
start = offset
if len(blocks) > 1024 {
return nil, false
}
}
}
}
// {=html} is an explicit authoring fence, not an ordinary code sample. The
// closing delimiter is longer than any run in the source, so arbitrary HTML
// (including Markdown examples) cannot accidentally terminate it.
@@ -110,6 +171,12 @@ func htmlStructure(source string) string {
literal = literal || n.Data == "pre" || n.Data == "code" || n.Data == "script" || n.Data == "style"
data := n.Data
if n.Type == html.TextNode && !literal {
if strings.TrimSpace(data) == "" && n.Parent != nil {
switch n.Parent.Data {
case "ul", "ol", "table", "thead", "tbody", "tfoot", "tr":
return
}
}
if strings.TrimSpace(data) == "" && (n.Parent == nil || n.Parent.Data == "body" || n.Parent.Data == "html") {
return
}
+16
View File
@@ -65,3 +65,19 @@ func TestAuthoringWhitespaceComparisonIsConservative(t *testing.T) {
t.Fatal("word boundaries ignored")
}
}
func TestAuthoringPartialMarkdownRecovery(t *testing.T) {
source := `<h1>Title</h1><p>Some <strong>bold</strong> text.</p><figure data-x="keep"><img src="/image"><figcaption>Caption</figcaption></figure><ul><li>First</li><li>Second</li></ul>`
md, err := HTMLToMarkdownAuthoring(source)
if err != nil || !strings.HasPrefix(md, "# Title") || !strings.Contains(md, "**bold**") || strings.Count(md, "{=html}") != 1 || !strings.Contains(md, "- First") {
t.Fatalf("markdown not recovered: %q %v", md, err)
}
if htmlStructure(source) != htmlStructure(MarkdownAuthoringHTML(md)) {
t.Fatal("HTML lost during partial conversion")
}
protected := `<figure data-x='original'><img src=/image><figcaption>Caption</figcaption></figure>`
md, err = HTMLToMarkdownAuthoring("<h1>Title</h1>" + protected + "<p>Tail</p>")
if err != nil || !strings.Contains(MarkdownAuthoringHTML(md), protected) || !strings.HasPrefix(md, "# Title") {
t.Fatalf("protected bytes changed: %q %v", md, err)
}
}
+6 -1
View File
@@ -227,4 +227,9 @@ func textMediaType(descriptor Descriptor) bool {
}
// Catalog returns a copy; callers cannot reorder or disable the shared registry.
func Catalog() []Adapter { return append([]Adapter(nil), projectionAdapters...) }
func Catalog() []Adapter {
items := append([]Adapter(nil), projectionAdapters...)
// Explicitly selected projection. It must not replace normal HTML/text
// viewing in the automatic MIME classifier.
return append(items, Adapter{ID: "reveal", Kind: "slides", Delivery: DeliveryRawFrame, Match: func(Descriptor) bool { return false }})
}
+1 -1
View File
@@ -47,7 +47,7 @@ func TestAdapterCatalogIsCopyAndConcurrent(t *testing.T) {
for _, a := range catalog {
ids = append(ids, a.ID)
}
if strings.Join(ids, ",") != "html,excalidraw,csv,archive,debian-package,eml,pe,json,text,image,audio,video,pdf,download" {
if strings.Join(ids, ",") != "html,excalidraw,csv,archive,debian-package,eml,pe,json,text,image,audio,video,pdf,download,reveal" {
t.Fatal("catalog order changed", ids)
}
catalog[0].ID = "corrupt"
+3
View File
@@ -185,6 +185,9 @@ func (s *Server) adapterActionsForPath(r *http.Request, semanticPath string) ([]
{ID: "download", Name: "download", Mode: "viewer", Builtin: true,
OpenURL: rawProjectionURL("rev:" + revision.UUID)},
}
if (mediaType == "text/html" || mediaType == "text/markdown" || mediaType == "text/x-markdown") && s.systemExtensionEnabled(domainUUID, "viewer.slides") {
actions = append(actions, adapterAction{ID: "reveal", Name: "Reveal.js", Mode: "viewer", Builtin: true, OpenURL: "/v/slides" + semanticPath})
}
if selected.NeedsText || selected.ID == "html" || selected.ID == "excalidraw" {
actions = append(actions, adapterAction{
ID: "editor", Name: "Pages Wiki Editor", Mode: "editor",
+11
View File
@@ -35,6 +35,17 @@ func (s *Server) handleAuthAdmin(w http.ResponseWriter, r *http.Request) {
}
panel := "auth"
switch r.FormValue("action") {
case "save_trusted_session_policy":
panel = "auth-sessions"
days, err := strconv.Atoi(r.PostForm.Get("trusted_session_days"))
if err != nil || days < 0 || days > 30 {
http.Error(w, "trusted session lifetime must be between 0 and 30 days", 400)
return
}
if err := s.store.SetConfigInDomain(domainUUID, "auth_trusted_session_days", strconv.Itoa(days)); err != nil {
http.Error(w, "could not save session policy", 500)
return
}
case "save_session_policy":
panel = "auth-sessions"
minutes, err := strconv.Atoi(r.FormValue("session_minutes"))
+4
View File
@@ -51,4 +51,8 @@ func TestBrowserCookieLoginLogoutChromium(t *testing.T) {
if err := s.store.DB.QueryRow(`SELECT count(*) FROM auth_sessions WHERE revoked_at_ms>0`).Scan(&revoked); err != nil || revoked != 1 {
t.Fatalf("browser revocations=%d %v", revoked, err)
}
var lifetime int64
if err := s.store.DB.QueryRow(`SELECT expires_at_ms-auth_time_ms FROM auth_sessions WHERE revoked_at_ms>0`).Scan(&lifetime); err != nil || lifetime != (30*24*time.Hour).Milliseconds() {
t.Fatalf("trusted browser lifetime=%d %v", lifetime, err)
}
}
+4 -1
View File
@@ -74,7 +74,7 @@ func (s *Server) handleCLIAuth(w http.ResponseWriter, r *http.Request, action st
writeEventJSON(w, 400, map[string]string{"error": "invalid_request"})
return
}
id, device, code, err := s.store.StartCLIAuth(ctx, domain, cliOrigin(r), challenge)
id, device, code, err := s.store.StartCLIAuthForLogin(ctx, domain, cliOrigin(r), challenge, r.PostForm.Get("remember") == "1")
if err != nil {
cliAuthError(w, err)
return
@@ -140,6 +140,9 @@ func (s *Server) verifyCLIAuth(w http.ResponseWriter, r *http.Request) {
return
}
data := map[string]any{"CLIAuth": true, "CLIOrigin": grant.Origin, "CLIRequest": id}
if grant.Remember {
data["CLIRememberDays"] = s.store.TrustedSessionDays(domain)
}
if grant.State != "pending" {
data["CLIDone"] = true
s.renderAuthPage(w, r, data)
+28 -2
View File
@@ -28,6 +28,14 @@ func cliForm(s *Server, path string, form url.Values, cookie, origin string) *ht
}
func TestCLIAuthOIDCFlow(t *testing.T) {
for _, remember := range []bool{false, true} {
t.Run(map[bool]string{false: "normal", true: "trusted"}[remember], func(t *testing.T) {
testCLIAuthOIDCFlow(t, remember)
})
}
}
func testCLIAuthOIDCFlow(t *testing.T, remember bool) {
s, api, domain := configFixture(t)
principal := s.mustCLIPrincipal(t, domain, api)
// An enrolled local factor must not add a second challenge to OIDC consent.
@@ -43,7 +51,13 @@ func TestCLIAuthOIDCFlow(t *testing.T) {
}
verifier := strings.Repeat("x", 43)
sum := sha256.Sum256([]byte(verifier))
start := cliForm(s, "/_/auth/cli/start", url.Values{"code_challenge": {base64.RawURLEncoding.EncodeToString(sum[:])}, "code_challenge_method": {"S256"}}, "", "")
startForm := url.Values{"code_challenge": {base64.RawURLEncoding.EncodeToString(sum[:])}, "code_challenge_method": {"S256"}}
expectedSeconds := 24 * 60 * 60
if remember {
startForm.Set("remember", "1")
expectedSeconds *= 30
}
start := cliForm(s, "/_/auth/cli/start", startForm, "", "")
if start.Code != 200 {
t.Fatalf("start %d %s", start.Code, start.Body.String())
}
@@ -63,7 +77,12 @@ func TestCLIAuthOIDCFlow(t *testing.T) {
t.Fatalf("verify landing: %d %s", verify.Code, verify.Body.String())
}
begin := httptest.NewRecorder()
s.beginOIDC(begin, httptest.NewRequest("GET", "https://localhost/_/auth/oidc?cli="+id, nil))
// The browser query must not override the CLI's persisted choice.
tamperedRemember := "1"
if remember {
tamperedRemember = "0"
}
s.beginOIDC(begin, httptest.NewRequest("GET", "https://localhost/_/auth/oidc?cli="+id+"&remember="+tamperedRemember, nil))
if begin.Code != 302 {
t.Fatalf("oidc begin %d %s", begin.Code, begin.Body.String())
}
@@ -86,6 +105,9 @@ func TestCLIAuthOIDCFlow(t *testing.T) {
for _, cookie := range complete.Result().Cookies() {
if cookie.Name == authCookieName {
browser = cookie.Value
if cookie.MaxAge != expectedSeconds {
t.Fatalf("cookie lifetime %d, want %d", cookie.MaxAge, expectedSeconds)
}
}
}
if browser == "" {
@@ -128,6 +150,7 @@ func TestCLIAuthOIDCFlow(t *testing.T) {
var result struct {
Token string `json:"access_token"`
Username string `json:"username"`
Expires int `json:"expires_in"`
}
if err := json.Unmarshal(exchange.Body.Bytes(), &result); err != nil {
t.Fatal(err)
@@ -135,6 +158,9 @@ func TestCLIAuthOIDCFlow(t *testing.T) {
if !strings.HasPrefix(result.Token, "pw_api_") || result.Username != "admin" || result.Token == browser {
t.Fatal("invalid delegated credential")
}
if result.Expires > expectedSeconds || result.Expires < expectedSeconds-10 {
t.Fatalf("CLI lifetime %d, want approximately %d", result.Expires, expectedSeconds)
}
if _, err := s.store.PrincipalForSession(domain, result.Token); err != nil {
t.Fatal(err)
}
+20 -16
View File
@@ -9,12 +9,14 @@ import (
"log"
"net/http"
"net/url"
"strconv"
"strings"
"time"
)
type oidcChallenge struct{ Verifier, Nonce, Return, Issuer, ClientID, BrowserHash, CLIRequest string }
type oidcChallenge struct {
Verifier, Nonce, Return, Issuer, ClientID, BrowserHash, CLIRequest string
Remember bool
}
func logOIDCFailure(stage, domainUUID, issuer string, err error) {
host := "invalid"
@@ -57,6 +59,7 @@ func (s *Server) beginOIDC(w http.ResponseWriter, r *http.Request) {
ctx, cancel := context.WithTimeout(r.Context(), 8*time.Second)
defer cancel()
cliRequest := r.URL.Query().Get("cli")
remember := r.URL.Query().Get("remember") == "1"
returnPath := safeReturnPath(r.URL.Query().Get("return"))
if cliRequest != "" {
if !cliSecureTransport(r) || !cliProofPattern.MatchString(cliRequest) {
@@ -68,6 +71,12 @@ func (s *Server) beginOIDC(w http.ResponseWriter, r *http.Request) {
return
}
returnPath = cliVerifyPath(cliRequest)
grant, err := s.store.CLIAuthRequest(ctx, domainUUID, cliOrigin(r), cliRequest)
if err != nil {
http.Error(w, "invalid CLI request", 400)
return
}
remember = grant.Remember
}
metadata, err := fetchOIDCMetadata(ctx, config.Issuer)
if err != nil {
@@ -77,7 +86,7 @@ func (s *Server) beginOIDC(w http.ResponseWriter, r *http.Request) {
}
verifier, nonce, browser := randomURLToken(32), randomURLToken(24), randomURLToken(32)
browserDigest := sha256.Sum256([]byte(browser))
state, err := s.store.CreateAuthChallenge(domainUUID, "", "oidc", oidcChallenge{Verifier: verifier, Nonce: nonce, Return: returnPath, Issuer: config.Issuer, ClientID: config.ClientID, BrowserHash: base64.RawURLEncoding.EncodeToString(browserDigest[:]), CLIRequest: cliRequest}, 5*time.Minute)
state, err := s.store.CreateAuthChallenge(domainUUID, "", "oidc", oidcChallenge{Verifier: verifier, Nonce: nonce, Return: returnPath, Issuer: config.Issuer, ClientID: config.ClientID, BrowserHash: base64.RawURLEncoding.EncodeToString(browserDigest[:]), CLIRequest: cliRequest, Remember: remember}, 5*time.Minute)
if err != nil {
http.Error(w, err.Error(), 500)
return
@@ -205,7 +214,7 @@ func (s *Server) completeOIDC(w http.ResponseWriter, r *http.Request) {
http.Error(w, "No local account matches the configured OIDC identity field", http.StatusForbidden)
return
}
token, err := s.store.CreateBrowserAuthSession(domainUUID, principal.UUID, 0)
token, lifetime, err := s.store.CreateLoginSession(domainUUID, principal.UUID, 0, true, challenge.Remember)
if err != nil {
http.Error(w, err.Error(), 500)
return
@@ -217,7 +226,7 @@ func (s *Server) completeOIDC(w http.ResponseWriter, r *http.Request) {
return
}
}
s.setAuthCookie(w, r, token)
s.setAuthCookieForSeconds(w, r, token, int(lifetime.Seconds()))
http.Redirect(w, r, challenge.Return, http.StatusSeeOther)
}
@@ -244,7 +253,7 @@ func (s *Server) requestMagicLink(w http.ResponseWriter, r *http.Request) {
if principalErr == nil {
select {
case s.smtpSlots <- struct{}{}:
token, err := s.store.CreateAuthChallenge(domainUUID, principal.UUID, "magic-link", magicLinkChallenge{Return: safeReturnPath(r.FormValue("return")), Email: principal.Email}, 15*time.Minute)
token, err := s.store.CreateAuthChallenge(domainUUID, principal.UUID, "magic-link", magicLinkChallenge{Return: safeReturnPath(r.FormValue("return")), Email: principal.Email, Remember: r.PostForm.Get("remember") == "1"}, 15*time.Minute)
if err != nil {
<-s.smtpSlots
break
@@ -282,12 +291,12 @@ func (s *Server) verifyMagicLink(w http.ResponseWriter, r *http.Request) {
http.Error(w, "This sign-in link is invalid or expired", http.StatusBadRequest)
return
}
token, err := s.store.CreateBrowserAuthSession(domainUUID, principalUUID, 0)
token, lifetime, err := s.store.CreateLoginSession(domainUUID, principalUUID, 0, true, payload.Remember)
if err != nil {
http.Error(w, "This sign-in link is invalid or expired", http.StatusBadRequest)
return
}
s.setAuthCookie(w, r, token)
s.setAuthCookieForSeconds(w, r, token, int(lifetime.Seconds()))
http.Redirect(w, r, safeReturnPath(payload.Return), http.StatusSeeOther)
}
@@ -306,16 +315,11 @@ func (s *Server) renderAuthPage(w http.ResponseWriter, r *http.Request, data map
data["LDAPEnabled"] = config.Enabled
}
data["Locale"] = s.getLocale(domainUUID)
data["TrustedSessionDays"] = s.store.TrustedSessionDays(domainUUID)
data["RememberRequested"] = r.PostForm.Get("remember") == "1"
transparency := s.homeGlassTransparency(domainUUID)
data["HomeGlassTransparency"] = transparency
data["HomeGlassOpacity"] = 100 - transparency
configured, opacity := s.homeWallpaperConfig(domainUUID)
data["HomeWallpaperOpacity"] = strconv.FormatFloat(float64(opacity)/100, 'f', 2, 64)
if configured != "" {
// Only the administrator-selected login wallpaper is exposed; the
// request cannot choose an arbitrary document address.
data["HomeWallpaperURL"] = "/_/auth/wallpaper"
w.Header().Set("Cache-Control", "private, no-store")
}
// Login has no wallpaper: private home images must not become public.
s.renderWithContext(w, r, "auth.gohtml", data)
}
+12 -11
View File
@@ -62,7 +62,11 @@ func requestIsHTTPS(r *http.Request) bool {
}
func (s *Server) setAuthCookie(w http.ResponseWriter, r *http.Request, token string) {
http.SetCookie(w, &http.Cookie{Name: authCookieName, Value: token, Path: "/", HttpOnly: true, Secure: requestIsHTTPS(r), SameSite: http.SameSiteLaxMode, MaxAge: s.store.AuthSessionLifetimeMinutes(s.domainUUIDForRequest(r)) * 60})
s.setAuthCookieForSeconds(w, r, token, s.store.AuthSessionLifetimeMinutes(s.domainUUIDForRequest(r))*60)
}
func (s *Server) setAuthCookieForSeconds(w http.ResponseWriter, r *http.Request, token string, seconds int) {
http.SetCookie(w, &http.Cookie{Name: authCookieName, Value: token, Path: "/", HttpOnly: true, Secure: requestIsHTTPS(r), SameSite: http.SameSiteLaxMode, MaxAge: seconds})
}
func (s *Server) authTokenFromRequest(r *http.Request) string {
@@ -160,6 +164,7 @@ func (s *Server) handleAuth(w http.ResponseWriter, r *http.Request) {
}
var principal *store.Principal
mfaLevel := 0
remember := r.PostForm.Get("remember") == "1"
if action == "setup" && setup && s.validBootstrapToken(domainUUID, r.FormValue("bootstrap_token")) {
principal, err = s.store.BootstrapOwner(domainUUID, r.FormValue("username"), r.FormValue("password"), r.FormValue("display_name"), r.FormValue("email"))
if err == nil {
@@ -171,7 +176,7 @@ func (s *Server) handleAuth(w http.ResponseWriter, r *http.Request) {
} else if action == "login" && !setup {
principal, err = s.store.AuthenticatePassword(r.FormValue("username"), r.FormValue("password"))
if err == nil && s.store.HasTOTP(principal.UUID) {
challenge, challengeErr := s.store.CreateTOTPLoginChallenge(domainUUID, principal.UUID)
challenge, challengeErr := s.store.CreateTOTPLoginChallengeForLogin(domainUUID, principal.UUID, remember)
if challengeErr != nil {
err = challengeErr
} else if strings.Contains(r.Header.Get("Accept"), "application/json") {
@@ -191,7 +196,7 @@ func (s *Server) handleAuth(w http.ResponseWriter, r *http.Request) {
}
}
var principalUUID string
principalUUID, err = s.store.CompleteTOTPLoginChallenge(domainUUID, challenge, r.FormValue("code"))
principalUUID, remember, err = s.store.CompleteTOTPLoginChallengeForLogin(domainUUID, challenge, r.FormValue("code"))
if err == nil {
principal = &store.Principal{UUID: principalUUID}
mfaLevel = 1
@@ -201,18 +206,14 @@ func (s *Server) handleAuth(w http.ResponseWriter, r *http.Request) {
err = store.ErrAccessDenied
}
if err == nil {
var token string
if strings.Contains(r.Header.Get("Accept"), "application/json") {
token, err = s.store.CreateAuthSessionWithMFA(domainUUID, principal.UUID, mfaLevel)
} else {
token, err = s.store.CreateBrowserAuthSession(domainUUID, principal.UUID, mfaLevel)
}
token, lifetime, issueErr := s.store.CreateLoginSession(domainUUID, principal.UUID, mfaLevel, !strings.Contains(r.Header.Get("Accept"), "application/json"), remember)
err = issueErr
if err == nil {
if strings.Contains(r.Header.Get("Accept"), "application/json") {
writeEventJSON(w, http.StatusOK, map[string]any{"access_token": token, "token_type": "Bearer", "expires_in": s.store.AuthSessionLifetimeMinutes(domainUUID) * 60})
writeEventJSON(w, http.StatusOK, map[string]any{"access_token": token, "token_type": "Bearer", "expires_in": int(lifetime.Seconds())})
return
}
s.setAuthCookie(w, r, token)
s.setAuthCookieForSeconds(w, r, token, int(lifetime.Seconds()))
http.Redirect(w, r, safeReturnPath(r.FormValue("return")), http.StatusSeeOther)
return
}
+4 -9
View File
@@ -221,7 +221,7 @@ func (s *Server) handleLDAPLogin(w http.ResponseWriter, r *http.Request) {
return
}
if s.store.HasTOTP(principal.UUID) {
challenge, challengeErr := s.store.CreateTOTPLoginChallenge(domainUUID, principal.UUID)
challenge, challengeErr := s.store.CreateTOTPLoginChallengeForLogin(domainUUID, principal.UUID, r.PostForm.Get("remember") == "1")
if challengeErr != nil {
http.Error(w, "authentication unavailable", http.StatusServiceUnavailable)
return
@@ -234,20 +234,15 @@ func (s *Server) handleLDAPLogin(w http.ResponseWriter, r *http.Request) {
s.renderAuthPage(w, r, map[string]any{"MFA": true, "Return": returnPath})
return
}
var token string
if strings.Contains(r.Header.Get("Accept"), "application/json") {
token, err = s.store.CreateAuthSession(domainUUID, principal.UUID)
} else {
token, err = s.store.CreateBrowserAuthSession(domainUUID, principal.UUID, 0)
}
token, lifetime, err := s.store.CreateLoginSession(domainUUID, principal.UUID, 0, !strings.Contains(r.Header.Get("Accept"), "application/json"), r.PostForm.Get("remember") == "1")
if err != nil {
http.Error(w, "authentication unavailable", http.StatusServiceUnavailable)
return
}
if strings.Contains(r.Header.Get("Accept"), "application/json") {
writeEventJSON(w, http.StatusOK, map[string]any{"access_token": token, "token_type": "Bearer", "expires_in": s.store.AuthSessionLifetimeMinutes(domainUUID) * 60})
writeEventJSON(w, http.StatusOK, map[string]any{"access_token": token, "token_type": "Bearer", "expires_in": int(lifetime.Seconds())})
return
}
s.setAuthCookie(w, r, token)
s.setAuthCookieForSeconds(w, r, token, int(lifetime.Seconds()))
http.Redirect(w, r, returnPath, http.StatusSeeOther)
}
@@ -6,6 +6,7 @@ import (
"net/url"
"strings"
"testing"
"time"
)
func TestSessionPolicyAdminUIAndCookie(t *testing.T) {
@@ -48,3 +49,99 @@ func TestSessionPolicyAdminUIAndCookie(t *testing.T) {
t.Fatalf("cookie policy %#v", cookies)
}
}
func TestTrustedSessionPolicyAndRevocation(t *testing.T) {
s, admin, domain := configFixture(t)
p := s.mustCLIPrincipal(t, domain, admin)
for _, days := range []string{"30", "7", "0"} {
form := url.Values{"action": {"save_trusted_session_policy"}, "trusted_session_days": {days}}
w := configRequest(s, admin, "POST", "/-/sys/config/auth", form)
if w.Code != 303 {
t.Fatalf("policy %s: %d %s", days, w.Code, w.Body.String())
}
want := 24 * time.Hour
if days == "30" {
want *= 30
}
if days == "7" {
want *= 7
}
for _, browser := range []bool{false, true} {
token, lifetime, err := s.store.CreateLoginSession(domain, p, 0, browser, true)
if err != nil || lifetime != want {
t.Fatalf("duration %v %v", lifetime, err)
}
if _, err = s.store.PrincipalForSession(domain, token); err != nil {
t.Fatal(err)
}
if err = s.store.RevokeAuthSession(token); err != nil {
t.Fatal(err)
}
if _, err = s.store.PrincipalForSession(domain, token); err == nil {
t.Fatal("revoked trusted session accepted")
}
}
w = httptest.NewRecorder()
s.handleAuth(w, httptest.NewRequest("GET", "https://localhost/_/auth/login", nil))
if strings.Contains(w.Body.String(), `id="auth-remember"`) != (days != "0") {
t.Fatal("login choice does not reflect policy")
}
}
for _, bad := range []string{"", "-1", "31", "abc"} {
w := configRequest(s, admin, "POST", "/-/sys/config/auth", url.Values{"action": {"save_trusted_session_policy"}, "trusted_session_days": {bad}})
if w.Code != 400 {
t.Fatalf("invalid policy %q accepted: %d", bad, w.Code)
}
}
user, err := s.store.CreatePasswordAccount(domain, "trusted-reader", "a long test password", "Reader", "")
if err != nil {
t.Fatal(err)
}
if err = s.store.SetConfigInDomain(domain, "auth_trusted_session_days", "30"); err != nil {
t.Fatal(err)
}
token, _, err := s.store.CreateLoginSession(domain, user.UUID, 0, false, true)
if err != nil {
t.Fatal(err)
}
w := configRequest(s, token, "POST", "/-/sys/config/auth", url.Values{"action": {"save_trusted_session_policy"}, "trusted_session_days": {"7"}})
if w.Code != 403 {
t.Fatalf("reader changed trusted policy: %d", w.Code)
}
if err = s.store.SetPrincipalState(domain, user.UUID, "suspended"); err != nil {
t.Fatal(err)
}
if _, err = s.store.PrincipalForSession(domain, token); err == nil {
t.Fatal("suspended trusted session accepted")
}
}
func TestTrustedSessionExpiryIsFixed(t *testing.T) {
s, admin, domain := configFixture(t)
p := s.mustCLIPrincipal(t, domain, admin)
token, lifetime, err := s.store.CreateLoginSession(domain, p, 0, false, true)
if err != nil || lifetime != 30*24*time.Hour {
t.Fatalf("trusted default: %v %v", lifetime, err)
}
var id string
var expiry int64
if err = s.store.DB.QueryRow(`SELECT uuid,expires_at_ms FROM auth_sessions ORDER BY rowid DESC LIMIT 1`).Scan(&id, &expiry); err != nil {
t.Fatal(err)
}
if err = s.store.SetConfigInDomain(domain, "auth_trusted_session_days", "0"); err != nil {
t.Fatal(err)
}
if _, err = s.store.PrincipalForSession(domain, token); err != nil {
t.Fatal(err)
}
var after int64
if err = s.store.DB.QueryRow(`SELECT expires_at_ms FROM auth_sessions WHERE uuid=?`, id).Scan(&after); err != nil || after != expiry {
t.Fatalf("policy/read changed expiry: %d %d %v", expiry, after, err)
}
if _, err = s.store.DB.Exec(`UPDATE auth_sessions SET expires_at_ms=? WHERE uuid=?`, time.Now().Add(-time.Second).UnixMilli(), id); err != nil {
t.Fatal(err)
}
if _, err = s.store.PrincipalForSession(domain, token); err == nil {
t.Fatal("expired trusted session accepted")
}
}
+12
View File
@@ -0,0 +1,12 @@
package server
func init() {
for lang, entries := range map[string]map[string]string{
"en": {"auth.remember": "Keep me signed in on this trusted device", "auth.days": "days", "auth.remember_cli": "Keep this CLI signed in for up to", "auth.trusted_days": "Trusted device session (days; 0 disables)"},
"ja": {"auth.remember": "信頼できる端末でログインを維持する", "auth.days": "日間", "auth.remember_cli": "CLIのログイン継続期間(最大)", "auth.trusted_days": "信頼できる端末の有効期間(日・0で無効)"},
} {
for key, value := range entries {
translations[lang][key] = value
}
}
}
+88
View File
@@ -0,0 +1,88 @@
package server
import (
"context"
"net/http"
"net/http/httptest"
"os"
"os/exec"
"strings"
"sync/atomic"
"testing"
"time"
)
func TestBrowserUploadQueueChromium(t *testing.T) {
if os.Getenv("PAGESWIKI_BROWSER_TEST") != "1" {
t.Skip("opt-in Chromium")
}
for _, width := range []string{"1280", "390"} {
t.Run(width, func(t *testing.T) { testBrowserUploadQueueChromium(t, width) })
}
}
func testBrowserUploadQueueChromium(t *testing.T, width string) {
s, token, domain := configFixture(t)
s.mux.HandleFunc("/v/browser/", s.handleBrowser)
s.mux.HandleFunc("/v/upload", s.handleUpload)
object, err := s.store.CreatePageAtPathInDomain(domain, "/drop/existing.txt")
if err != nil {
t.Fatal(err)
}
if _, err = s.store.SaveRevisionContent(object, []byte("original"), "", "und", "text/plain", "existing.txt"); err != nil {
t.Fatal(err)
}
if _, err = s.store.CreatePageAtPathInDomain(domain, "/drop/sub/seed"); err != nil {
t.Fatal(err)
}
script, err := os.ReadFile("internal/server/testdata/browser-upload.js")
if err != nil {
t.Fatal(err)
}
var active, peak atomic.Int32
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
r.Host = "localhost"
r.Header.Set("Authorization", "Bearer "+token)
if r.Method == "POST" && r.URL.Path == "/v/upload" {
n := active.Add(1)
defer active.Add(-1)
if n > peak.Load() {
peak.Store(n)
}
time.Sleep(100 * time.Millisecond)
}
if r.URL.Path == "/v/browser/drop" && r.URL.Query().Has("fixture") {
rec := httptest.NewRecorder()
s.withAuthorization(s.mux).ServeHTTP(rec, r)
for key, values := range rec.Header() {
w.Header()[key] = values
}
w.WriteHeader(rec.Code)
w.Write([]byte(strings.Replace(rec.Body.String(), "</body>", "<script>"+string(script)+"</script></body>", 1)))
return
}
s.withAuthorization(s.mux).ServeHTTP(w, r)
}))
defer server.Close()
ctx, cancel := context.WithTimeout(context.Background(), 40*time.Second)
defer cancel()
out, err := exec.CommandContext(ctx, "node", "internal/server/testdata/vim-browser-smoke.mjs", server.URL+"/v/browser/drop?fixture=1", t.TempDir(), "/tmp/pageswiki-browser-upload-"+width+".png", width, "850").CombinedOutput()
if err != nil {
t.Fatalf("browser: %v %s", err, out)
}
if peak.Load() != 1 {
t.Fatalf("parallel uploads: %d", peak.Load())
}
for _, path := range []string{"/drop/日本語 #1.txt", "/drop/sub/nested.txt"} {
if _, err = s.store.ResolvePathInDomain(domain, path); err != nil {
t.Fatal(path, err)
}
}
if _, err = s.store.ResolvePathInDomain(domain, "/drop/cancel.txt"); err == nil {
t.Fatal("cancelled file uploaded")
}
revs, err := s.store.ListRevisions(object)
if err != nil || len(revs) != 1 {
t.Fatal("existing file overwritten")
}
}
@@ -72,6 +72,15 @@ func TestCalendarUpcomingDefaultsAndBounds(t *testing.T) {
t.Fatal("tomorrow event in today's widget", event.Start)
}
}
w = calendarRequest(s, token, "GET", calendarAPI+"upcoming?period=day&date="+end.Format("2006-01-02"), "", "")
if w.Code != 200 || json.Unmarshal(w.Body.Bytes(), &result) != nil {
t.Fatal(w.Code, w.Body)
}
for _, event := range result.Events {
if !event.Start.Before(end.AddDate(0, 0, 1)) || !event.End.After(end) {
t.Fatal("event outside tomorrow", event.Start, event.End)
}
}
if w = calendarRequest(s, "", "GET", calendarAPI+"upcoming", "", ""); w.Code != 403 {
t.Fatal("anonymous access", w.Code)
}
+1 -1
View File
@@ -45,7 +45,7 @@ func (s *Server) transpileMarkdownFromPath(r *http.Request, path string, mode ma
html := latest.Body
if mode == markdownProjection {
html = s.expandMacrosForRequest(r, html, path, s.domainUUIDForRequest(r))
html = s.safeHTMLProjection(r, html, path, true)
} else {
return grammaratur.HTMLToMarkdownAuthoring(html)
}
+44 -43
View File
@@ -1078,49 +1078,50 @@ func (s *Server) handleConfig(
s.getSystemNavItems(s.domainUUIDForRequest(r)),
NavContext{},
),
"HomePath": homePath,
"HomeWallpaperPath": homeWallpaperPath,
"HomeWallpaperOpacity": homeWallpaperOpacity,
"HomeGlassTransparency": s.homeGlassTransparency(domainUUID),
"HomePalette": s.homePalette(domainUUID),
"HomeLayout": s.homeLayout(s.domainUUIDForRequest(r)),
"HomeBookmarks": s.homeBookmarksText(s.domainUUIDForRequest(r)),
"VirtualFolderPages": s.getVirtualFolderPages(s.domainUUIDForRequest(r)),
"WikiName": wikiName,
"Locale": s.getLocale(s.domainUUIDForRequest(r)),
"Timezone": s.getTimezoneName(s.domainUUIDForRequest(r)),
"Theme": s.getTheme(s.domainUUIDForRequest(r)),
"ThemeOptions": themeOptions(),
"EditorKeymap": s.getEditorKeymap(s.domainUUIDForRequest(r)),
"EditorFormat": s.getEditorFormat(s.domainUUIDForRequest(r)),
"EditorPreviewDefault": s.getEditorPreviewDefault(s.domainUUIDForRequest(r)),
"EditorSyntax": s.getEditorSyntaxHighlight(s.domainUUIDForRequest(r)),
"EditorAutocomplete": s.getEditorAutocomplete(s.domainUUIDForRequest(r)),
"ZombieGraceHours": zombieGraceHours,
"Objects": recent,
"ZombieObjects": zombies,
"Domains": domains,
"DomainEntries": domainEntries,
"PeriodicalProjections": projections,
"PeriodicalKinds": []string{"diary", "blog"},
"CampusLegacyPeers": legacyPeers,
"Campuses": campuses,
"CampusManaged": campusManaged,
"CampusOnline": campusOnline,
"FederationInstances": federationInstances,
"CampusTokens": campusTokens,
"AuthPrincipals": authPrincipals,
"AuthSessions": authSessions,
"AuthSessionMinutes": s.store.AuthSessionLifetimeMinutes(s.domainUUIDForRequest(r)),
"OIDCConfig": oidcConfig,
"SMTPConfig": smtpConfig,
"LDAPConfig": ldapConfig,
"LDAPTest": r.URL.Query().Get("ldap_test"),
"ObjectsCampusUUID": selectedCampusUUID,
"ObjectsDomainUUID": selectedDomain.UUID,
"ObjectsDomainHost": objectsDomainHost,
"HomeNavItemsConfig": s.getHomeNavItems(s.domainUUIDForRequest(r)),
"SystemNavItemsConfig": s.getSystemNavItems(s.domainUUIDForRequest(r)),
"HomePath": homePath,
"HomeWallpaperPath": homeWallpaperPath,
"HomeWallpaperOpacity": homeWallpaperOpacity,
"HomeGlassTransparency": s.homeGlassTransparency(domainUUID),
"HomePalette": s.homePalette(domainUUID),
"HomeLayout": s.homeLayout(s.domainUUIDForRequest(r)),
"HomeBookmarks": s.homeBookmarksText(s.domainUUIDForRequest(r)),
"VirtualFolderPages": s.getVirtualFolderPages(s.domainUUIDForRequest(r)),
"WikiName": wikiName,
"Locale": s.getLocale(s.domainUUIDForRequest(r)),
"Timezone": s.getTimezoneName(s.domainUUIDForRequest(r)),
"Theme": s.getTheme(s.domainUUIDForRequest(r)),
"ThemeOptions": themeOptions(),
"EditorKeymap": s.getEditorKeymap(s.domainUUIDForRequest(r)),
"EditorFormat": s.getEditorFormat(s.domainUUIDForRequest(r)),
"EditorPreviewDefault": s.getEditorPreviewDefault(s.domainUUIDForRequest(r)),
"EditorSyntax": s.getEditorSyntaxHighlight(s.domainUUIDForRequest(r)),
"EditorAutocomplete": s.getEditorAutocomplete(s.domainUUIDForRequest(r)),
"ZombieGraceHours": zombieGraceHours,
"Objects": recent,
"ZombieObjects": zombies,
"Domains": domains,
"DomainEntries": domainEntries,
"PeriodicalProjections": projections,
"PeriodicalKinds": []string{"diary", "blog"},
"CampusLegacyPeers": legacyPeers,
"Campuses": campuses,
"CampusManaged": campusManaged,
"CampusOnline": campusOnline,
"FederationInstances": federationInstances,
"CampusTokens": campusTokens,
"AuthPrincipals": authPrincipals,
"AuthSessions": authSessions,
"AuthSessionMinutes": s.store.AuthSessionLifetimeMinutes(s.domainUUIDForRequest(r)),
"AuthTrustedSessionDays": s.store.TrustedSessionDays(s.domainUUIDForRequest(r)),
"OIDCConfig": oidcConfig,
"SMTPConfig": smtpConfig,
"LDAPConfig": ldapConfig,
"LDAPTest": r.URL.Query().Get("ldap_test"),
"ObjectsCampusUUID": selectedCampusUUID,
"ObjectsDomainUUID": selectedDomain.UUID,
"ObjectsDomainHost": objectsDomainHost,
"HomeNavItemsConfig": s.getHomeNavItems(s.domainUUIDForRequest(r)),
"SystemNavItemsConfig": s.getSystemNavItems(s.domainUUIDForRequest(r)),
},
)
}
+150
View File
@@ -0,0 +1,150 @@
package server
import (
"bytes"
"context"
"encoding/json"
"html"
"net/http"
"net/http/httptest"
"os"
"os/exec"
"strings"
"testing"
"time"
)
const csvEditorFixtureBody = "\ufeff\"name\",description\r\n日本語,\"a,b\r\nnext\"\r\n"
func TestCSVEditorRevisionAndBounds(t *testing.T) {
s, token, domain, _ := editorFixture(t)
object, err := s.store.CreatePageAtPathInDomain(domain, "/table.csv")
if err != nil {
t.Fatal(err)
}
first, err := s.store.SaveRevisionContent(object, []byte(csvEditorFixtureBody), "", "und", "text/csv; charset=utf-8", "table.csv")
if err != nil {
t.Fatal(err)
}
for _, query := range []string{"", "?edittype=markdown", "?lang=und"} {
w := configRequest(s, token, "GET", "/e/-/table.csv"+query, nil)
if w.Code != 200 || !strings.Contains(w.Body.String(), `data-csv="true"`) || !strings.Contains(w.Body.String(), `value="code"`) || strings.Contains(w.Body.String(), `data-editor-action="markdown"`) {
t.Fatalf("editor %d %s", w.Code, w.Body.String())
}
}
head, _ := s.store.GetRevisionForExactLanguage(object, "und")
if head.UUID != first.UUID {
t.Fatal("GET changed revision")
}
save := func(auth, base, body string) int {
data, _ := json.Marshal(map[string]any{"object_uuid": object, "body": body, "lang": "und", "content_type": "text/csv; charset=utf-8", "filename": "table.csv", "base_revision_uuid": base})
r := httptest.NewRequest("POST", "http://localhost/_/api/v1/revisions/save", bytes.NewReader(data))
r.Header.Set("Authorization", "Bearer "+auth)
r.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
s.withAuthorization(s.mux).ServeHTTP(w, r)
return w.Code
}
changed := strings.Replace(csvEditorFixtureBody, "日本語", "更新", 1)
if code := save(token, first.UUID, changed); code != 200 {
t.Fatal("save", code)
}
if code := save(token, first.UUID, "stale"); code != 409 {
t.Fatal("stale save", code)
}
head, _ = s.store.GetRevisionForExactLanguage(object, "und")
if head.Body != changed || head.ContentType != "text/csv; charset=utf-8" || head.Filename != "table.csv" {
t.Fatal("CSV altered")
}
state := configRequest(s, token, "GET", "/_/api/v1/editor/state?uuid="+object+"&lang=und&revision="+first.UUID, nil)
var content struct {
Body string
Editable bool
}
if err = json.Unmarshal(state.Body.Bytes(), &content); err != nil || state.Code != 200 || !content.Editable || content.Body != csvEditorFixtureBody {
t.Fatal("restore", state.Code, err)
}
reader, err := s.store.CreatePasswordAccount(domain, "csvreader", "a long test password", "Reader", "")
if err != nil {
t.Fatal(err)
}
if err = s.store.SetPrincipalState(domain, reader.UUID, "readonly"); err != nil {
t.Fatal(err)
}
denied, _ := s.store.CreateAuthSession(domain, reader.UUID)
if code := save(denied, head.UUID, "forbidden"); code != 403 {
t.Fatal("readonly save", code)
}
// Initial CSV is embedded as an escaped JS string to preserve CRLF. A
// field must not terminate that script or become executable markup.
if _, err = s.store.SaveRevisionContent(object, []byte("\"</script><script>alert(1)</script>\",value\r\n"), "", "und", "text/csv", "table.csv"); err != nil {
t.Fatal(err)
}
escaped := configRequest(s, token, "GET", "/e/-/table.csv", nil)
if escaped.Code != 200 || strings.Contains(escaped.Body.String(), "<script>alert(1)</script>") || !strings.Contains(escaped.Body.String(), `\u003c/script\u003e`) {
t.Fatal("CSV script string was not escaped")
}
for _, input := range []struct {
body []byte
code int
}{{[]byte(strings.Repeat("x", maxCSVMacroBytes+1)), 413}, {[]byte{0xff, 0xfe}, 415}, {[]byte("a,\x00"), 415}} {
rev, e := s.store.SaveRevisionContent(object, input.body, "", "und", "text/csv", "table.csv")
if e != nil {
t.Fatal(e)
}
w := configRequest(s, token, "GET", "/e/-/table.csv", nil)
if w.Code != input.code {
t.Fatalf("editor bounds %d wanted %d", w.Code, input.code)
}
w = configRequest(s, token, "GET", "/_/api/v1/editor/state?uuid="+object+"&lang=und&revision="+rev.UUID, nil)
if w.Code != input.code {
t.Fatalf("state bounds %d wanted %d", w.Code, input.code)
}
}
}
func TestCSVEditorChromium(t *testing.T) {
if os.Getenv("PAGESWIKI_BROWSER_TEST") != "1" {
t.Skip("opt-in Chromium")
}
for _, width := range []string{"1280", "390"} {
t.Run(width, func(t *testing.T) {
s, token, domain, _ := editorFixture(t)
object, err := s.store.CreatePageAtPathInDomain(domain, "/table.csv")
if err != nil {
t.Fatal(err)
}
if _, err = s.store.SaveRevisionContent(object, []byte(csvEditorFixtureBody), "", "und", "text/csv; charset=utf-8", "table.csv"); err != nil {
t.Fatal(err)
}
script, err := os.ReadFile("internal/server/testdata/csv-editor.js")
if err != nil {
t.Fatal(err)
}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
r.Host = "localhost"
r.Header.Set("Authorization", "Bearer "+token)
if r.URL.Path == "/e/-/table.csv" {
rec := httptest.NewRecorder()
s.withAuthorization(s.mux).ServeHTTP(rec, r)
for k, v := range rec.Header() {
w.Header()[k] = v
}
w.WriteHeader(rec.Code)
_, policy, _ := strings.Cut(rec.Header().Get("Content-Security-Policy"), "'nonce-")
nonce, _, _ := strings.Cut(policy, "'")
w.Write([]byte(strings.Replace(rec.Body.String(), "</body>", `<script nonce="`+html.EscapeString(nonce)+`">`+string(script)+"</script></body>", 1)))
return
}
s.withAuthorization(s.mux).ServeHTTP(w, r)
}))
defer server.Close()
ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
defer cancel()
out, err := exec.CommandContext(ctx, "node", "internal/server/testdata/vim-browser-smoke.mjs", server.URL+"/e/-/table.csv", t.TempDir(), "/tmp/pageswiki-csv-editor-"+width+".png", width, "850").CombinedOutput()
if err != nil {
t.Fatalf("browser: %v %s", err, out)
}
})
}
}
+169
View File
@@ -0,0 +1,169 @@
package server
import (
"encoding/csv"
"errors"
"html"
"io"
"net/http"
"net/url"
"path"
"regexp"
"strconv"
"strings"
"unicode/utf8"
"github.com/google/uuid"
)
// Projection only: no network fetch, shared rendered cache or write-back.
const maxCSVMacroBytes = 256 << 10
var csvMacroRE = regexp.MustCompile(`^\{\{csv:(?:"([^"]+)"|([^\s}]+))(.*?)\}\}$`)
var csvRangeRE = regexp.MustCompile(`^([A-Z]{1,2})([1-9][0-9]{0,3}):([A-Z]{1,2})([1-9][0-9]{0,3})$`)
type csvMacroOptions struct {
Path, Revision string
Row, EndRow, Column, EndColumn int
Header bool
}
func parseCSVMacro(raw string) (csvMacroOptions, error) {
o := csvMacroOptions{Row: 1, EndRow: 200, Column: 1, EndColumn: 32, Header: true}
m := csvMacroRE.FindStringSubmatch(raw)
bad := errors.New("invalid CSV macro")
if m == nil {
return o, bad
}
o.Path = m[1]
if o.Path == "" {
o.Path = m[2]
}
if !strings.HasPrefix(o.Path, "/") || strings.HasPrefix(o.Path, "//") || path.Clean(o.Path) != o.Path || strings.ContainsAny(o.Path, "\\\x00\r\n") || len(o.Path) > 2048 {
return o, bad
}
seen := map[string]bool{}
for _, field := range strings.Fields(m[3]) {
key, value, ok := strings.Cut(field, "=")
if !ok || seen[key] {
return o, bad
}
seen[key] = true
switch key {
case "header":
if value != "true" && value != "false" {
return o, bad
}
o.Header = value == "true"
case "rev":
if _, err := uuid.Parse(value); len(value) != 36 || err != nil {
return o, bad
}
o.Revision = value
case "range":
parts := csvRangeRE.FindStringSubmatch(strings.ToUpper(value))
if parts == nil {
return o, bad
}
col := func(s string) int {
n := 0
for _, c := range s {
n = n*26 + int(c-'A') + 1
}
return n
}
o.Column, o.EndColumn = col(parts[1]), col(parts[3])
o.Row, _ = strconv.Atoi(parts[2])
o.EndRow, _ = strconv.Atoi(parts[4])
if o.Column > o.EndColumn || o.EndColumn > 100 || o.EndColumn-o.Column >= 32 || o.Row > o.EndRow || o.EndRow > 2000 || o.EndRow-o.Row >= 200 {
return o, bad
}
default:
return o, bad
}
}
return o, nil
}
func csvMacroTable(body []byte, o csvMacroOptions) (string, error) {
if len(body) > maxCSVMacroBytes || !utf8.Valid(body) || strings.IndexByte(string(body), 0) >= 0 {
return "", errors.New("invalid CSV input")
}
reader := csv.NewReader(strings.NewReader(strings.TrimPrefix(string(body), "\ufeff")))
reader.FieldsPerRecord = -1
var out strings.Builder
out.WriteString(`<div class="csv-projection table-scroll"><table><caption><a href="` + html.EscapeString((&url.URL{Path: o.Path}).EscapedPath()) + `" title="Revision ` + html.EscapeString(o.Revision) + `">` + html.EscapeString(path.Base(o.Path)) + `</a></caption><tbody>`)
for row := 1; row <= o.EndRow; row++ {
record, err := reader.Read()
if err == io.EOF {
break
}
if err != nil {
return "", err
}
if len(record) > 100 {
return "", errors.New("too many CSV columns")
}
if row < o.Row {
continue
}
out.WriteString("<tr>")
cell := "td"
if o.Header && row == o.Row {
cell = "th"
}
for col := o.Column; col <= o.EndColumn && col <= len(record); col++ {
if len(record[col-1]) > 16<<10 {
return "", errors.New("CSV cell too large")
}
// Never expand macros, formulas or markup from CSV cells.
out.WriteString("<" + cell + ">" + html.EscapeString(record[col-1]) + "</" + cell + ">")
}
out.WriteString("</tr>")
}
out.WriteString("</tbody></table></div>")
return out.String(), nil
}
func (s *Server) expandCSVMacro(r *http.Request, macro string) string {
fallback := `<span class="projection-warning">` + html.EscapeString(translate(s.getLocale(s.domainUUIDForRequest(r)), "viewer.csv_unavailable")) + `</span>`
o, err := parseCSVMacro(macro)
if err != nil || r.Context().Err() != nil || s.store == nil || isAnonymousProjection(r) || !s.pathReadFilter(r)(o.Path) {
return fallback
}
domain := s.domainUUIDForRequest(r)
object, err := s.store.ResolvePathInDomainContext(r.Context(), domain, o.Path)
if err != nil {
return fallback
}
rev, err := s.store.GetLatestRevisionMetadataForLanguagesContext(r.Context(), object, s.revisionLanguageCandidates(r))
if o.Revision != "" {
rev, err = s.store.GetRevisionMetadataContext(r.Context(), o.Revision)
}
if err != nil || rev == nil || rev.UUID == "" || rev.ObjectUUID != object {
return fallback
}
media := strings.ToLower(strings.TrimSpace(strings.Split(rev.ContentType, ";")[0]))
if media != "text/csv" && media != "application/csv" {
return fallback
}
size, err := s.store.DocumentSizeContext(r.Context(), rev.DocumentHash)
if err != nil || size > maxCSVMacroBytes {
return fallback
}
window, err := s.store.ReadDocumentWindowContext(r.Context(), rev.DocumentHash, 0, maxCSVMacroBytes)
if err != nil || window.Truncated {
return fallback
}
o.Revision = rev.UUID
table, err := csvMacroTable(window.Data, o)
if err != nil || r.Context().Err() != nil {
return fallback
}
return table
}
func init() {
translations["en"]["viewer.csv_unavailable"] = "CSV unavailable (access, format or size limit)."
translations["ja"]["viewer.csv_unavailable"] = "CSVを表示できません(権限・形式・サイズ制限)。"
}
+111
View File
@@ -0,0 +1,111 @@
package server
import (
"context"
"net/http/httptest"
"strings"
"testing"
"pageswiki/internal/grammaratur"
)
func TestCSVMacroParsingAndBounds(t *testing.T) {
for _, raw := range []string{`{{csv:/data/a.csv}}`, `{{csv:"/data/日本語 table.csv" range=B2:D4 header=false}}`} {
if _, err := parseCSVMacro(raw); err != nil {
t.Fatal(raw, err)
}
}
for _, raw := range []string{`{{csv:https://example.org/a.csv}}`, `{{csv://evil/a.csv}}`, `{{csv:/a/../secret}}`, `{{csv:/a range=A1:C201}}`, `{{csv:/a range=A1:AG2}}`, `{{csv:/a range=A2001:B2002}}`, `{{csv:/a range=D2:A1}}`, `{{csv:/a header=yes}}`, `{{csv:/a header=true header=false}}`, `{{csv:/a unsupported=1}}`, `{{csv:/a rev=bad}}`} {
if _, err := parseCSVMacro(raw); err == nil {
t.Fatal("accepted", raw)
}
}
o, _ := parseCSVMacro(`{{csv:/data/a.csv range=A1:C3}}`)
body := "\ufeffname,description,formula\r\n日本語,\"a,b\r\nnext\",=1+1\r\n<script>,{{children:/private}},end\r\n"
got, err := csvMacroTable([]byte(body), o)
if err != nil || !strings.Contains(got, "<th>name</th>") || !strings.Contains(got, "a,b\nnext") || !strings.Contains(got, "&lt;script&gt;") || !strings.Contains(got, "{{children:/private}}") {
t.Fatalf("CSV: %s %v", got, err)
}
checkInertProjection(t, got)
for _, bad := range [][]byte{[]byte("a,\"unterminated"), {0xff}, []byte("a,\x00"), []byte(strings.Repeat("x", maxCSVMacroBytes+1)), []byte(strings.Repeat("x", (16<<10)+1)), []byte(strings.Repeat("a,", 101))} {
if _, err := csvMacroTable(bad, o); err == nil {
t.Fatal("invalid/large CSV accepted")
}
}
}
func TestCSVMacroProjectionAuthorizationAndRevision(t *testing.T) {
s, token, domain := configFixture(t)
object, err := s.store.CreatePageAtPathInDomain(domain, "/data/report.csv")
if err != nil {
t.Fatal(err)
}
first, err := s.store.SaveRevisionContent(object, []byte("name,value\r\noriginal,1\r\n"), "", "und", "text/csv", "report.csv")
if err != nil {
t.Fatal(err)
}
r := httptest.NewRequest("GET", "http://localhost/guide", nil)
r.Header.Set("Authorization", "Bearer "+token)
macro := `{{csv:/data/report.csv range=A1:B2}}`
got := s.safeHTMLProjection(r, "<p>"+macro+"</p><code>"+macro+"</code>", "/guide", true)
if strings.Count(got, `class="csv-projection table-scroll"`) != 1 || !strings.Contains(got, "original") || !strings.Contains(got, "<code>"+macro+"</code>") || !strings.Contains(got, first.UUID) {
t.Fatal(got)
}
second, err := s.store.SaveRevisionContent(object, []byte("name,value\nupdated,2\n"), "", "und", "text/csv", "report.csv")
if err != nil {
t.Fatal(err)
}
got = s.safeHTMLProjection(r, macro, "/guide", true)
if !strings.Contains(got, "updated") || !strings.Contains(got, second.UUID) || strings.Contains(got, "original") {
t.Fatal("stale projection", got)
}
got = s.safeHTMLProjection(r, `{{csv:/data/report.csv rev=`+first.UUID+`}}`, "/guide", true)
if !strings.Contains(got, "original") || strings.Contains(got, "updated") {
t.Fatal("pinned revision", got)
}
other, err := s.store.CreatePageAtPathInDomain(domain, "/data/other.csv")
if err != nil {
t.Fatal(err)
}
foreign, err := s.store.SaveRevisionContent(other, []byte("SECRET_DIFFERENT_OBJECT"), "", "und", "text/csv", "other.csv")
if err != nil {
t.Fatal(err)
}
got = s.safeHTMLProjection(r, `{{csv:/data/report.csv rev=`+foreign.UUID+`}}`, "/guide", true)
if strings.Contains(got, "SECRET") || strings.Contains(got, "<table") {
t.Fatal("foreign revision leaked", got)
}
// A fresh request with no credentials must not reuse another reader's table.
denied := httptest.NewRequest("GET", "http://localhost/guide", nil)
got = s.safeHTMLProjection(denied, macro, "/guide", true)
if strings.Contains(got, "updated") || strings.Contains(got, "<table") {
t.Fatal("unauthorized table", got)
}
public := r.WithContext(context.WithValue(r.Context(), anonymousProjectionKey{}, true))
if got = s.safeHTMLProjection(public, macro, "/guide", true); strings.Contains(got, "<table") {
t.Fatal("anonymous CSV expanded", got)
}
ctx, cancel := context.WithCancel(r.Context())
cancel()
if got = s.expandCSVMacro(r.WithContext(ctx), macro); strings.Contains(got, "<table") {
t.Fatal("cancelled projection ran")
}
// Authoring must preserve the macro, never bake projected rows into HTML.
source := "<p>" + macro + "</p>"
md, err := grammaratur.HTMLToMarkdownAuthoring(source)
if err != nil {
t.Fatal(err)
}
if !strings.Contains(grammaratur.MarkdownAuthoringHTML(md), macro) || strings.Contains(md, "updated") {
t.Fatal("authoring expanded CSV", md)
}
// Four distinct CSV reads per projection, then leave authored syntax literal.
input := strings.Repeat(macro, 2)
for _, col := range []string{"A1:A2", "B1:B2", "A1:B1", "A2:B2"} {
input += `{{csv:/data/report.csv range=` + col + `}}`
}
got = s.safeHTMLProjection(r, input, "/guide", true)
if strings.Count(got, "<table>") != 5 || !strings.Contains(got, "{{csv:") {
t.Fatal("CSV budget not enforced", got)
}
}
+2 -2
View File
@@ -2,8 +2,8 @@ package server
func init() {
for lang, entries := range map[string]map[string]string{
"en": {"editor.tools": "Insert component / drafts", "editor.language": "Edit / fork language", "editor.restore": "Restore a revision into the editor"},
"ja": {"editor.tools": "コンポーネント挿入・下書き", "editor.language": "言語の編集・分岐", "editor.restore": "過去のリビジョンをエディタに復元"},
"en": {"editor.tools": "Insert component / drafts", "editor.language": "Edit / fork language", "editor.restore": "Restore a revision into the editor", "editor.csv_source": "CSV source", "editor.csv_table": "CSV table"},
"ja": {"editor.tools": "コンポーネント挿入・下書き", "editor.language": "言語の編集・分岐", "editor.restore": "過去のリビジョンをエディタに復元", "editor.csv_source": "CSVソースを表示", "editor.csv_table": "CSVの表を表示"},
} {
for key, value := range entries {
translations[lang][key] = value
+16 -2
View File
@@ -4,6 +4,7 @@ import (
"encoding/json"
"net/http"
"strings"
"unicode/utf8"
"pageswiki/internal/grammaratur"
)
@@ -73,7 +74,20 @@ func (s *Server) handleEditorState(w http.ResponseWriter, r *http.Request) {
}
out := map[string]any{"revision_uuid": rev.UUID, "head_revision_uuid": head, "lang": rev.Language, "content_type": rev.ContentType, "filename": rev.Filename, "principal_uuid": owner}
if r.URL.Query().Get("metadata") != "1" {
if rev.UUID != "" {
csv := selectProjectionAdapter(contentDescriptor{MediaType: strings.ToLower(strings.TrimSpace(strings.Split(rev.ContentType, ";")[0])), Filename: rev.Filename}).Kind == "csv"
if csv {
size, e := s.store.DocumentSizeContext(r.Context(), rev.DocumentHash)
if e != nil || size > maxCSVMacroBytes {
http.Error(w, "CSV editor size limit exceeded", 413)
return
}
window, e := s.store.ReadDocumentWindowContext(r.Context(), rev.DocumentHash, 0, maxCSVMacroBytes)
if e != nil || window.Truncated || !utf8.Valid(window.Data) || strings.ContainsRune(string(window.Data), 0) {
http.Error(w, "CSV source unavailable or not UTF-8", 415)
return
}
rev.Body = string(window.Data)
} else if rev.UUID != "" {
rev, err = s.store.GetRevision(rev.UUID)
}
if err != nil {
@@ -90,7 +104,7 @@ func (s *Server) handleEditorState(w http.ResponseWriter, r *http.Request) {
}
out["body"], out["markdown"] = rev.Body, markdown
kind := revisionContentView(rev, "").Kind
out["editable"] = rev.UUID == "" || kind == "html" || kind == "code"
out["editable"] = rev.UUID == "" || kind == "html" || kind == "code" || (csv && utf8.ValidString(rev.Body) && !strings.ContainsRune(rev.Body, 0))
}
_ = json.NewEncoder(w).Encode(out)
}
+1 -1
View File
@@ -189,7 +189,7 @@ func readEndpointResolver(path string) (endpointTargetResolver, string) {
return resolveHandler, "read"
case strings.HasPrefix(path, "/_/view/print/"):
return resolvePrint, "read"
case strings.HasPrefix(path, "/v/preview"), strings.HasPrefix(path, "/v/plain"), strings.HasPrefix(path, "/v/markdown"):
case strings.HasPrefix(path, "/v/preview"), strings.HasPrefix(path, "/v/plain"), strings.HasPrefix(path, "/v/markdown"), path == "/v/slides", strings.HasPrefix(path, "/v/slides/"):
return resolveViewPath, "read"
case strings.HasPrefix(path, "/o/e/"):
return resolveObjectURL, "write"
+1 -1
View File
@@ -268,7 +268,7 @@ func objectIDFromRoute(path string) string {
}
func semanticViewPath(route string) string {
for _, prefix := range []string{"/v/preview", "/v/plain", "/v/markdown", "/v/browser"} {
for _, prefix := range []string{"/v/preview", "/v/plain", "/v/markdown", "/v/browser", "/v/slides"} {
if strings.HasPrefix(route, prefix) {
path := strings.TrimPrefix(route, prefix)
if path == "" {
+13 -3
View File
@@ -10,16 +10,26 @@ import (
const systemExtensionStateKey = "system_extension_states"
func (s *Server) systemExtensionEnabled(domainUUID, id string) bool {
defaultEnabled := true
for _, manifest := range systemext.Catalog() {
if manifest.ID == id {
defaultEnabled = manifest.Enabled
break
}
}
raw, err := s.store.GetConfigInDomain(domainUUID, systemExtensionStateKey)
if err != nil || strings.TrimSpace(raw) == "" {
return true
return defaultEnabled
}
var states map[string]bool
if json.Unmarshal([]byte(raw), &states) != nil {
return true
return defaultEnabled
}
enabled, ok := states[id]
return !ok || enabled
if !ok {
return defaultEnabled
}
return enabled
}
func (s *Server) setSystemExtensionEnabled(domainUUID, id string, enabled bool) error {
+45 -6
View File
@@ -5,6 +5,7 @@ import (
"net/url"
"strconv"
"strings"
"time"
"github.com/google/uuid"
"pageswiki/internal/store"
@@ -16,7 +17,8 @@ func feedRoute(p string) bool { return p == "/v/feeds" || strings.HasPrefix(p, f
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") {
licenseDownload := strings.HasPrefix(r.URL.Path, geckoAPI+"distribution/v0.0.1/")
if !licenseDownload && !s.systemExtensionEnabled(domain, "organizer.feeds") {
http.NotFound(w, r)
return
}
@@ -29,6 +31,10 @@ func (s *Server) handleFeeds(w http.ResponseWriter, r *http.Request) {
taskError(w, store.ErrAccessDenied)
return
}
if strings.HasPrefix(r.URL.Path, geckoAPI) {
s.handleFeedBrowser(w, r, domain, actor, active)
return
}
if r.URL.Path == "/v/feeds" {
if r.Method != "GET" && r.Method != "HEAD" {
w.WriteHeader(405)
@@ -38,7 +44,25 @@ func (s *Server) handleFeeds(w http.ResponseWriter, r *http.Request) {
taskError(w, e)
return
}
s.renderWithContext(w, r, "feeds.gohtml", map[string]any{"Title": "RSS", "FeedWritable": active})
prefix := ""
linkMode := "tab"
if s.systemExtensionEnabled(domain, "organizer.tasks") {
preferences, e := s.store.TaskPreferences(r.Context(), domain, actor)
if e != nil {
taskError(w, e)
return
}
prefix = preferences.WikiPrefix
linkMode = preferences.RSSLinkMode
}
if linkMode == "gecko" {
if active && s.geckoAvailable(domain) {
geckoIsolation(w)
} else {
linkMode = "tab"
}
}
s.renderWithContext(w, r, "feeds.gohtml", map[string]any{"Title": "RSS", "FeedTimezone": s.getTimezoneName(domain), "FeedWritable": active, "FeedWikiPrefix": prefix, "FeedLinkMode": linkMode, "FeedShareX": s.systemExtensionEnabled(domain, "sharing.x")})
return
}
key := strings.TrimPrefix(r.URL.Path, feedsAPI)
@@ -50,13 +74,28 @@ func (s *Server) handleFeeds(w http.ResponseWriter, r *http.Request) {
return
}
switch {
case key == "catalog" && r.Method == "GET":
catalog, e := s.store.FeedCatalog(r.Context(), domain, actor, r.URL.Query().Get("source"))
case key == "capture-preview" && r.Method == "POST":
var input struct {
Prefix string `json:"prefix"`
Title string `json:"title"`
}
if !taskJSON(w, r, &input) {
return
}
prefix, e := store.ExpandWikiPrefix(input.Prefix, input.Title, time.Now().In(s.getLocation(domain)))
if e != nil {
taskError(w, e)
return
}
writeEventJSON(w, 200, map[string]any{"subscriptions": catalog})
writeEventJSON(w, 200, map[string]string{"prefix": prefix})
return
case key == "catalog" && r.Method == "GET":
catalog, e := s.store.FeedCatalogSnapshot(r.Context(), domain, actor, r.URL.Query().Get("source"))
if e != nil {
taskError(w, e)
return
}
writeEventJSON(w, 200, catalog)
return
case key == "note" && r.Method == "POST":
var input struct {
@@ -170,7 +209,7 @@ func (s *Server) handleFeeds(w http.ResponseWriter, r *http.Request) {
return
}
}
items, e := s.store.FeedItems(r.Context(), domain, actor, q.Get("source"), q.Get("filter"), q.Get("q"), before, q.Get("key"), q.Get("feed"), q.Get("category"))
items, e := s.store.FeedItems(r.Context(), domain, actor, q.Get("source"), q.Get("filter"), q.Get("q"), before, q.Get("key"), q.Get("feed"), q.Get("category"), q.Get("category_mode"))
if e != nil {
taskError(w, e)
return
+3
View File
@@ -132,6 +132,9 @@ func (s *Server) syncFeedActions(ctx context.Context, client *http.Client) error
}
func (s *Server) handleFeedAction(w http.ResponseWriter, r *http.Request, domain, actor, key string) bool {
if s.handleFeedHistory(w, r, domain, actor, key) {
return true
}
switch {
case key == "action" && r.Method == "GET":
a, e := s.store.FeedAction(r.Context(), domain, actor, r.URL.Query().Get("source"), r.URL.Query().Get("id"))
@@ -0,0 +1,54 @@
package server
import (
"context"
"encoding/json"
"strings"
"testing"
)
func TestRSSLinkPreference(t *testing.T) {
s, token, domain, actor, _ := feedFixture(t)
p, err := s.store.TaskPreferences(context.Background(), domain, actor)
if err != nil || p.RSSLinkMode != "tab" {
t.Fatal(p.RSSLinkMode, err)
}
p.RSSLinkMode = "embedded"
if w := taskRequest(s, token, "PUT", "preferences", p, ""); w.Code != 200 {
t.Fatal(w.Code, w.Body)
}
p, err = s.store.TaskPreferences(context.Background(), domain, actor)
if err != nil || p.RSSLinkMode != "embedded" {
t.Fatal(p.RSSLinkMode, err)
}
p.RSSLinkMode = "gecko"
if w := taskRequest(s, token, "PUT", "preferences", p, ""); w.Code != 200 {
t.Fatal(w.Code, w.Body)
}
p.RSSLinkMode = "unsafe"
if w := taskRequest(s, token, "PUT", "preferences", p, ""); w.Code != 422 {
t.Fatal(w.Code, w.Body)
}
}
func TestFeedCapturePreview(t *testing.T) {
s, token, _, _, _ := feedFixture(t)
for _, tt := range []struct {
prefix string
status int
}{{"/notes/{YYYY}/{MM}/{DD}/{Subject}", 200}, {"/notes/{unknown}", 422}, {"/a/../b", 422}} {
w := feedRequestTest(s, token, "POST", "capture-preview", map[string]string{"prefix": tt.prefix, "title": "日本語 / test"})
if w.Code != tt.status {
t.Fatal(w.Code, w.Body)
}
if w.Code == 200 {
var data map[string]string
if e := json.Unmarshal(w.Body.Bytes(), &data); e != nil || strings.ContainsAny(data["prefix"], "{}") || !strings.HasSuffix(data["prefix"], "/日本語---test") {
t.Fatal(data, e)
}
}
}
if w := feedRequestTest(s, "", "POST", "capture-preview", map[string]string{"prefix": "/notes"}); w.Code != 401 {
t.Fatal(w.Code)
}
}
+16 -3
View File
@@ -49,6 +49,7 @@ func TestFeedCatalogBackgroundSnapshotIsolation(t *testing.T) {
}
calls := 0
failCatalog := false
failFolders := false
client := &http.Client{Transport: feedTransportFunc(func(r *http.Request) (*http.Response, error) {
calls++
body := ""
@@ -63,7 +64,7 @@ func TestFeedCatalogBackgroundSnapshotIsolation(t *testing.T) {
t.Error("article request")
}
body = `{"items":[{"id":"a","title":"First","origin":{"title":"Same title","streamId":"feed/1"},"categories":["user/alice/label/Tech"]},{"id":"b","title":"Second","origin":{"title":"Same title","streamId":"feed/2"},"categories":["user/alice/label/Other"]}]}`
if failCatalog {
if failCatalog || failFolders {
body = `{"items":[]}`
}
case strings.HasSuffix(r.URL.Path, "/subscription/list"):
@@ -74,6 +75,11 @@ func TestFeedCatalogBackgroundSnapshotIsolation(t *testing.T) {
return nil, errors.New("synthetic timeout")
}
body = testFeedCatalog
case strings.HasSuffix(r.URL.Path, "/tag/list"):
if failFolders {
return nil, errors.New("synthetic folder failure")
}
body = `{"tags":[{"id":"user/-/label/Empty/Folder","type":"folder"},{"id":"user/-/label/Not a folder","type":"tag"}]}`
default:
t.Fatalf("unexpected external request %s %s", r.Method, r.URL.Path)
}
@@ -89,7 +95,7 @@ func TestFeedCatalogBackgroundSnapshotIsolation(t *testing.T) {
}
}
run()
if calls != 3 {
if calls != 4 {
t.Fatal("fetch count", calls)
}
w := feedRequestTest(s, token, "GET", "catalog?source="+v.UUID, nil)
@@ -127,9 +133,16 @@ func TestFeedCatalogBackgroundSnapshotIsolation(t *testing.T) {
if _, e := s.store.FeedCatalog(ctx, uuid.NewString(), actor, v.UUID); e == nil {
t.Fatal("cross-domain catalog leak")
}
if calls != 3 {
if calls != 4 {
t.Fatal("foreground external request")
}
failFolders = true
run()
kept, e := s.store.FeedCatalogSnapshot(ctx, domain, actor, v.UUID)
if e != nil || len(kept.Folders) != 3 || len(kept.Subscriptions) != 3 {
t.Fatal("folder failure erased snapshot", kept, e)
}
failFolders = false
failCatalog = true
run()
catalog, e := s.store.FeedCatalog(ctx, domain, actor, v.UUID)
+19 -3
View File
@@ -345,7 +345,7 @@ func freshRSSLogin(ctx context.Context, client *http.Client, v store.FeedSource,
}
return auth, nil
}
func fetchFreshRSS(ctx context.Context, client *http.Client, v store.FeedSource, user, password string, catalogs ...*[]store.FeedRemoteSubscription) ([]store.FeedItem, error) {
func fetchFreshRSS(ctx context.Context, client *http.Client, v store.FeedSource, user, password string, catalogs ...*store.FeedCatalogSnapshot) ([]store.FeedItem, error) {
base := strings.TrimRight(v.URL, "/")
auth, e := freshRSSLogin(ctx, client, v, user, password)
if e != nil {
@@ -368,7 +368,23 @@ func fetchFreshRSS(ctx context.Context, client *http.Client, v store.FeedSource,
if e != nil {
return nil, e
}
*catalogs[0] = catalog
raw, _, _, e = feedRequest(ctx, client, "GET", base+"/reader/api/0/tag/list?output=json", auth, nil, nil)
if e != nil {
return nil, e
}
folders, e := parseFreshRSSFolders(raw)
if e != nil {
return nil, e
}
folders, e = store.FeedFolders(catalog, folders)
if e != nil {
return nil, errFeedInvalid
}
snapshot := store.FeedCatalogSnapshot{Subscriptions: catalog, Folders: folders}
if _, _, e = snapshot.Encode(); e != nil {
return nil, errFeedInvalid
}
*catalogs[0] = snapshot
}
return items, nil
}
@@ -504,7 +520,7 @@ func (s *Server) syncFeedSourcesWithClient(ctx context.Context, job *store.Event
}
child, stop := context.WithTimeout(ctx, 8*time.Second)
var items []store.FeedItem
var catalog []store.FeedRemoteSubscription
var catalog store.FeedCatalogSnapshot
etag, modified := v.ETag, v.Modified
unchanged := false
if !validCalendarSourceURL(v.URL) {
+42
View File
@@ -0,0 +1,42 @@
package server
import (
"encoding/json"
"strings"
"unicode/utf8"
"pageswiki/internal/store"
)
func parseFreshRSSFolders(raw []byte) ([]store.FeedCategory, error) {
if len(raw) > 4<<20 || !utf8.Valid(raw) {
return nil, errFeedInvalid
}
var response struct {
Tags []struct {
ID string `json:"id"`
Type string `json:"type"`
} `json:"tags"`
}
if json.Unmarshal(raw, &response) != nil || response.Tags == nil || len(response.Tags) > 10000 {
return nil, errFeedInvalid
}
folders := []store.FeedCategory{}
seen := map[string]bool{}
for _, tag := range response.Tags {
// Article tags and system state tags are not subscription folders.
if tag.Type != "folder" {
continue
}
prefix, label, ok := strings.Cut(tag.ID, "/label/")
if !ok || !strings.HasPrefix(prefix, "user/") || len(prefix) <= 5 || label == "" || !store.ValidFeedRemoteID(tag.ID) || seen[tag.ID] {
return nil, errFeedInvalid
}
seen[tag.ID] = true
folders = append(folders, store.FeedCategory{ID: tag.ID, Label: feedText(label, 512)})
}
if _, e := store.FeedFolders(nil, folders); e != nil {
return nil, errFeedInvalid
}
return folders, nil
}
+95
View File
@@ -0,0 +1,95 @@
package server
import (
"context"
"encoding/json"
"fmt"
"net/url"
"strings"
"testing"
"pageswiki/internal/store"
)
func TestFreshRSSFoldersParsing(t *testing.T) {
folders, e := parseFreshRSSFolders([]byte(`{"tags":[{"id":"user/-/state/com.google/starred"},{"id":"user/-/label/ArticleTag","type":"tag"},{"id":"user/-/label/技術/Linux","type":"folder"}]}`))
if e != nil || len(folders) != 1 || folders[0].Label != "技術/Linux" {
t.Fatal(folders, e)
}
for _, raw := range []string{`{}`, `{"tags":null}`, `{"tags":[{"id":"invalid","type":"folder"}]}`, `{"tags":[{"id":"user/-/label/","type":"folder"}]}`, `{"tags":[{"id":"user/-/label/A","type":"folder"},{"id":"user/-/label/A","type":"folder"}]}`} {
if _, e = parseFreshRSSFolders([]byte(raw)); e == nil {
t.Fatal("invalid folder accepted", raw)
}
}
tags := []map[string]string{}
for i := 0; i < 1001; i++ {
tags = append(tags, map[string]string{"id": fmt.Sprintf("user/-/label/%d", i), "type": "folder"})
}
raw, _ := json.Marshal(map[string]any{"tags": tags})
if _, e = parseFreshRSSFolders(raw); e == nil {
t.Fatal("unbounded folders")
}
if _, e = store.FeedFolders([]store.FeedRemoteSubscription{{ID: "feed/1", Categories: []store.FeedCategory{{ID: "cat", Label: "A"}}}}, []store.FeedCategory{{ID: "cat", Label: "B"}}); e == nil {
t.Fatal("conflicting labels")
}
large := store.FeedCatalogSnapshot{}
for i := 0; i < 1000; i++ {
large.Subscriptions = append(large.Subscriptions, store.FeedRemoteSubscription{ID: fmt.Sprintf("feed/%d", i), Title: strings.Repeat("s", 512)})
large.Folders = append(large.Folders, store.FeedCategory{ID: fmt.Sprintf("user/-/label/%d", i), Label: strings.Repeat("f", 512)})
}
if _, e := store.FeedCatalogJSON(large.Subscriptions); e != nil {
t.Fatal("catalog alone should fit", e)
}
if _, _, e := large.Encode(); e != store.ErrTaskDAVLimit {
t.Fatal("combined snapshot limit", e)
}
}
func TestFeedFolderMembershipAndUncategorized(t *testing.T) {
s, token, domain, actor, source := feedActionFixture(t)
ctx := context.Background()
if _, e := s.store.DB.Exec(`UPDATE feed_sources SET next_ms=0 WHERE uuid=?`, source.UUID); e != nil {
t.Fatal(e)
}
sources, e := s.store.FeedSources(ctx, domain, actor)
if e != nil {
t.Fatal(e)
}
for _, v := range sources {
if v.UUID == source.UUID {
source = v
}
}
claim, e := s.store.ClaimFeed(ctx, source)
if e != nil {
t.Fatal(e)
}
cat := store.FeedCategory{ID: "user/-/label/New/Folder", Label: "New/Folder"}
snapshot := store.FeedCatalogSnapshot{Subscriptions: []store.FeedRemoteSubscription{{ID: "feed/1", Title: "Moved", Categories: []store.FeedCategory{cat}}, {ID: "feed/2", Title: "Unclassified", Categories: []store.FeedCategory{}}}, Folders: []store.FeedCategory{{ID: "user/-/label/Empty", Label: "Empty"}}}
items := []store.FeedItem{{ID: "a", Title: "Moved", RemoteFeed: "feed/1", RemoteCategories: []string{"user/-/label/Old"}}, {ID: "b", Title: "Unclassified", RemoteFeed: "feed/2", RemoteCategories: []string{"user/-/label/ArticleTag"}}, {ID: "c", Title: "Unknown subscription", RemoteFeed: "feed/unknown"}}
if e = s.store.CompleteFeed(ctx, claim, items, "", "", "", false, snapshot); e != nil {
t.Fatal(e)
}
for _, test := range []struct {
query string
want string
}{{"category=" + url.QueryEscape(cat.ID), "a"}, {"category_mode=uncategorized", "b"}, {"category=user%2F-%2Flabel%2FOld", ""}, {"category=user%2F-%2Flabel%2FEmpty", ""}} {
w := feedRequestTest(s, token, "GET", "items?source="+source.UUID+"&"+test.query, nil)
var data struct {
Items []store.FeedItem `json:"items"`
}
json.Unmarshal(w.Body.Bytes(), &data)
if w.Code != 200 || (test.want == "" && len(data.Items) != 0) || (test.want != "" && (len(data.Items) != 1 || data.Items[0].ID != test.want)) {
t.Fatal(test.query, w.Code, w.Body)
}
}
for _, query := range []string{"category_mode=uncategorized", "source=" + source.UUID + "&category_mode=bad", "source=" + source.UUID + "&category_mode=uncategorized&category=" + url.QueryEscape(cat.ID)} {
if w := feedRequestTest(s, token, "GET", "items?"+query, nil); w.Code != 422 {
t.Fatal(query, w.Code)
}
}
got, e := s.store.FeedCatalogSnapshot(ctx, domain, actor, source.UUID)
if e != nil || len(got.Folders) != 2 {
t.Fatal(got, e)
}
}
+143
View File
@@ -0,0 +1,143 @@
package server
import (
"context"
"io"
"net"
"net/http"
"net/http/httputil"
"net/url"
"os"
"strings"
"time"
"pageswiki/internal/geckorelay"
)
const geckoAPI = feedsAPI + "browser/"
type geckoProxy struct {
origin *url.URL
key string
transport *http.Transport
}
func (s *Server) geckoConfig() *geckoProxy {
s.geckoOnce.Do(func() {
u, err := url.Parse(os.Getenv("PAGESWIKI_GECKO_RELAY"))
if err != nil || (u.Scheme != "http" && u.Scheme != "https") || u.Host == "" || u.User != nil || u.RawQuery != "" || u.Fragment != "" || (u.Path != "" && u.Path != "/") {
return
}
key, err := os.ReadFile(os.Getenv("PAGESWIKI_GECKO_KEY_FILE"))
if err != nil || len(strings.TrimSpace(string(key))) < 32 {
return
}
s.gecko = &geckoProxy{origin: u, key: strings.TrimSpace(string(key)), transport: &http.Transport{Proxy: nil, DialContext: (&net.Dialer{Timeout: 5 * time.Second}).DialContext, ResponseHeaderTimeout: 10 * time.Second, TLSHandshakeTimeout: 5 * time.Second, IdleConnTimeout: 30 * time.Second, MaxIdleConnsPerHost: 4}}
})
return s.gecko
}
func (s *Server) geckoAvailable(domain string) bool {
return s.systemExtensionEnabled(domain, "viewer.gecko") && s.geckoConfig() != nil
}
func geckoIsolation(w http.ResponseWriter) {
w.Header().Set("Cross-Origin-Opener-Policy", "same-origin")
w.Header().Set("Cross-Origin-Embedder-Policy", "require-corp")
w.Header().Set("Cross-Origin-Resource-Policy", "same-origin")
}
func (s *Server) handleFeedBrowser(w http.ResponseWriter, r *http.Request, domain, actor string, active bool) {
path := strings.TrimPrefix(r.URL.Path, geckoAPI)
// Recipients can still obtain sources after the viewer is disabled.
distribution := strings.HasPrefix(path, strings.TrimPrefix(geckorelay.DistributionPrefix, "/"))
if s.geckoConfig() == nil || (!distribution && (!active || !s.geckoAvailable(domain))) {
http.NotFound(w, r)
return
}
if r.Method != "GET" || r.URL.RawQuery != "" {
http.Error(w, "invalid request", 400)
return
}
switch path {
case "":
geckoIsolation(w)
w.Header().Set("Content-Security-Policy", "default-src 'none'; script-src 'self' blob: 'wasm-unsafe-eval'; worker-src 'self' blob:; connect-src 'self' data:; style-src 'self'; img-src 'self' data:; frame-ancestors 'self'; base-uri 'none'; form-action 'none'")
w.Header().Set("Referrer-Policy", "no-referrer")
w.Header().Set("Content-Type", "text/html; charset=utf-8")
io.WriteString(w, geckoShell)
return
case "assets/v0.0.1/gecko.js", "assets/v0.0.1/gecko.wasm.zst":
case "wisp/":
// WebSocket cookies alone are not CSRF protection.
if r.Header.Get("Origin") != externalURL(r, "") || !strings.EqualFold(r.Header.Get("Upgrade"), "websocket") {
http.Error(w, "forbidden", 403)
return
}
default:
if !distribution {
http.NotFound(w, r)
return
}
}
cfg := s.geckoConfig()
ctx, cancel := context.WithCancel(r.Context())
defer cancel()
if path == "wisp/" {
token := s.authTokenFromRequest(r)
go func() {
ticker := time.NewTicker(5 * time.Second)
defer ticker.Stop()
for {
select {
case <-ctx.Done():
return
case <-ticker.C:
p, err := s.store.PrincipalForSession(domain, token)
if err != nil || p.UUID != actor || p.State != "active" || !s.systemExtensionEnabled(domain, "organizer.feeds") || !s.geckoAvailable(domain) {
cancel()
return
}
}
}
}()
}
proxy := &httputil.ReverseProxy{Transport: cfg.transport, Rewrite: func(p *httputil.ProxyRequest) {
p.SetURL(cfg.origin)
p.Out.URL.Path = "/" + path
p.Out.URL.RawPath = ""
// No ambient credentials, forwarding headers, target URL or user-supplied
// grant crosses this boundary. The relay origin is operator-configured.
keep := http.Header{}
for _, h := range []string{"Upgrade", "Connection", "Sec-WebSocket-Key", "Sec-WebSocket-Version", "Origin", "Range", "If-None-Match", "If-Modified-Since"} {
if value := p.Out.Header.Get(h); value != "" {
keep.Set(h, value)
}
}
keep.Set(geckorelay.GrantHeader, geckorelay.Sign(cfg.key, geckorelay.Grant{Subject: domain + ":" + actor, Nonce: randomURLToken(24), Expires: time.Now().Add(30 * time.Second).Unix()}))
p.Out.Header = keep
}, ModifyResponse: func(resp *http.Response) error {
resp.Header.Del("Set-Cookie")
resp.Header.Set("Cross-Origin-Resource-Policy", "same-origin")
if resp.Header.Get("Cache-Control") == "" {
resp.Header.Set("Cache-Control", "private, no-store")
}
return nil
}, ErrorHandler: func(w http.ResponseWriter, r *http.Request, err error) {
w.Header().Set("Cache-Control", "private, no-store")
http.Error(w, "browser relay unavailable", http.StatusBadGateway)
}}
// ReverseProxy adds upstream headers rather than replacing existing values.
// Do not accidentally append the RSS API's no-store to versioned assets.
w.Header().Del("Cache-Control")
proxy.ServeHTTP(w, r.WithContext(ctx))
}
const geckoShell = `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><link rel="stylesheet" href="/static/css/feed-gecko.css?v=1"><title>Gecko</title></head><body><p id="status" role="status"></p><canvas id="screen" tabindex="0" aria-label="Original article"></canvas><script type="module" src="/static/js/feed-gecko.js?v=2"></script></body></html>`
func init() {
translations["en"]["feeds.gecko"] = "Gecko RSS browser (experimental)"
translations["ja"]["feeds.gecko"] = "Gecko RSSブラウザ(実験的)"
translations["en"]["feeds.gecko_help"] = "Requires a separately deployed authenticated relay. Public HTTP/HTTPS only; browsing uses the relay's IP address."
translations["ja"]["feeds.gecko_help"] = "認証付き中継サービスの別途配置が必要です。公開HTTP/HTTPSのみ。閲覧先には中継サーバーのIPが使われます。"
}
+174
View File
@@ -0,0 +1,174 @@
package server
import (
"context"
"encoding/binary"
"fmt"
"io"
"net/http"
"net/http/httptest"
"os"
"os/exec"
"path/filepath"
"strings"
"sync/atomic"
"testing"
"time"
"golang.org/x/net/websocket"
"pageswiki/internal/geckorelay"
"pageswiki/internal/store"
)
// The real engine runs against a synthetic Wisp HTTP responder. This test never
// dials an article server, production source, DNS name or external calendar.
func TestFeedGeckoChromium(t *testing.T) {
testFeedGeckoChromium(t, false)
}
func TestFeedGeckoStartupFailureChromium(t *testing.T) {
testFeedGeckoChromium(t, true)
}
func testFeedGeckoChromium(t *testing.T, failure bool) {
assets := os.Getenv("PAGESWIKI_GECKO_TEST_ASSETS")
if os.Getenv("PAGESWIKI_BROWSER_TEST") != "1" || assets == "" {
t.Skip("opt-in real Gecko assets")
}
var connections atomic.Int64
publicHTTPS := !failure && os.Getenv("PAGESWIKI_GECKO_PUBLIC_HTTPS_TEST") == "1"
realRelay, err := geckorelay.New(geckoTestKey, assets)
if err != nil {
t.Fatal(err)
}
if publicHTTPS {
realRelay.Distribution, err = geckorelay.VerifyDistribution(assets)
if err != nil {
t.Fatal(err)
}
}
backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if failure && strings.HasSuffix(r.URL.Path, "/NotoSansCJKjp-Regular.otf") {
http.Error(w, "synthetic startup failure", 503)
return
}
if publicHTTPS {
realRelay.ServeHTTP(w, r)
return
}
if _, err := geckorelay.Verify(geckoTestKey, r.Header.Get(geckorelay.GrantHeader), time.Now()); err != nil {
http.Error(w, "bad grant", 403)
return
}
if strings.HasPrefix(r.URL.Path, "/assets/") || strings.HasPrefix(r.URL.Path, geckorelay.DistributionPrefix) {
http.ServeFile(w, r, filepath.Join(assets, filepath.Base(r.URL.Path)))
return
}
if r.URL.Path != "/wisp/" {
http.NotFound(w, r)
return
}
websocket.Handler(func(ws *websocket.Conn) {
connections.Add(1)
defer connections.Add(-1)
packet := func(kind byte, id uint32, data []byte) []byte {
out := make([]byte, 5+len(data))
out[0] = kind
binary.LittleEndian.PutUint32(out[1:], id)
copy(out[5:], data)
return out
}
websocket.Message.Send(ws, packet(3, 0, []byte{8, 0, 0, 0}))
requests := map[uint32]string{}
for {
var p []byte
if websocket.Message.Receive(ws, &p) != nil || len(p) < 5 {
return
}
id := binary.LittleEndian.Uint32(p[1:])
switch p[0] {
case 1:
requests[id] = ""
case 2:
requests[id] += string(p[5:])
if !strings.Contains(requests[id], "\r\n\r\n") {
continue
}
body := `<!doctype html><meta charset="utf-8"><body style="margin:0;background:rgb(255,0,0)"><a style="display:block;width:300px;height:100px;background:blue;color:white" href="http://fixture.invalid/next">Synthetic next page</a><h1>日本語の記事:学舎の園</h1>`
if strings.HasPrefix(requests[id], "GET /next ") {
body = `<!doctype html><body style="margin:0;background:rgb(0,255,0)"><h1>Second synthetic page</h1>`
}
response := fmt.Sprintf("HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\nContent-Length: %d\r\nConnection: close\r\n\r\n%s", len(body), body)
websocket.Message.Send(ws, packet(2, id, []byte(response)))
websocket.Message.Send(ws, packet(4, id, []byte{2}))
delete(requests, id)
case 4:
delete(requests, id)
}
}
}).ServeHTTP(w, r)
}))
defer backend.Close()
s, token, domain, actor, source := feedFixture(t)
configureTestGecko(t, s, domain, backend.URL)
p, e := s.store.TaskPreferences(context.Background(), domain, actor)
if e != nil {
t.Fatal(e)
}
p.RSSLinkMode = "gecko"
if _, e = s.store.SaveTaskPreferences(context.Background(), domain, actor, p, time.Now()); e != nil {
t.Fatal(e)
}
claim, e := s.store.ClaimFeed(context.Background(), source)
if e != nil {
t.Fatal(e)
}
articleURL := "http://fixture.invalid/first"
if publicHTTPS {
articleURL = "https://example.com/"
}
if e = s.store.CompleteFeed(context.Background(), claim, []store.FeedItem{{ID: "synthetic", Title: "Gecko synthetic fixture", URL: articleURL, Body: "Synthetic test fixture."}}, "", "", "", false); e != nil {
t.Fatal(e)
}
handler := s.handler()
web := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if publicHTTPS && r.URL.Path == "/static/js/feed-gecko.js" {
js, err := os.ReadFile("static/js/feed-gecko.js")
if err != nil {
t.Error(err)
http.Error(w, "fixture missing", 500)
return
}
w.Header().Set("Content-Type", "text/javascript")
io.WriteString(w, strings.Replace(string(js), "engine=new Gecko(", "globalThis.fixtureEngine=engine=new Gecko(", 1))
return
}
if r.Header.Get("Origin") == "http://"+r.Host {
r.Header.Set("Origin", "http://localhost")
}
r.Host = "localhost"
r.Header.Set("Authorization", "Bearer "+token)
handler.ServeHTTP(w, r)
}))
defer web.Close()
ctx, cancel := context.WithTimeout(context.Background(), 150*time.Second)
defer cancel()
mode := "synthetic"
if failure {
mode = "startup-failure"
}
if publicHTTPS {
mode = "public-https"
}
out, e := exec.CommandContext(ctx, "node", "internal/server/testdata/feed-gecko-browser.mjs", web.URL+"/v/feeds", t.TempDir(), "/tmp/pageswiki-feed-gecko.png", mode).CombinedOutput()
if e != nil {
t.Fatalf("browser: %v\n%s", e, out)
}
io.WriteString(os.Stdout, string(out))
for i := 0; i < 30 && connections.Load() != 0; i++ {
time.Sleep(100 * time.Millisecond)
}
if connections.Load() != 0 {
t.Fatal("viewer close left relay session alive")
}
}
+205
View File
@@ -0,0 +1,205 @@
package server
import (
"context"
"encoding/binary"
"io"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"sync/atomic"
"testing"
"time"
"golang.org/x/net/websocket"
"pageswiki/internal/geckorelay"
)
const geckoTestKey = "synthetic-server-relay-key-at-least-32-bytes"
func configureTestGecko(t *testing.T, s *Server, domain, origin string) {
t.Helper()
path := filepath.Join(t.TempDir(), "key")
if err := os.WriteFile(path, []byte(geckoTestKey), 0600); err != nil {
t.Fatal(err)
}
t.Setenv("PAGESWIKI_GECKO_RELAY", origin)
t.Setenv("PAGESWIKI_GECKO_KEY_FILE", path)
if err := s.setSystemExtensionEnabled(domain, "viewer.gecko", true); err != nil {
t.Fatal(err)
}
}
func TestFeedGeckoAuthorizationAndHeaders(t *testing.T) {
s, token, domain, actor, _ := feedFixture(t)
if s.systemExtensionEnabled(domain, "viewer.gecko") {
t.Fatal("experimental relay enabled by default")
}
for _, raw := range []string{"bad json", `{"organizer.feeds":true}`} {
if err := s.store.SetConfigInDomain(domain, systemExtensionStateKey, raw); err != nil {
t.Fatal(err)
}
if s.systemExtensionEnabled(domain, "viewer.gecko") {
t.Fatal("invalid/absent config enabled relay")
}
}
var requests atomic.Int64
upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
requests.Add(1)
g, err := geckorelay.Verify(geckoTestKey, r.Header.Get(geckorelay.GrantHeader), time.Now())
if err != nil || g.Subject != domain+":"+actor {
t.Error("missing bound grant")
}
for _, h := range []string{"Cookie", "Authorization", "X-Forwarded-For", "Forwarded", "Referer"} {
if r.Header.Get(h) != "" {
t.Error("credential/header leaked", h)
}
}
if r.URL.Path != "/assets/v0.0.1/gecko.js" && r.URL.Path != "/distribution/v0.0.1/manifest.json" {
t.Error("path", r.URL.Path)
}
w.Header().Set("Set-Cookie", "forbidden=1")
w.Header().Set("Cache-Control", "private, max-age=86400, immutable")
io.WriteString(w, "export const fixture=true;")
}))
defer upstream.Close()
configureTestGecko(t, s, domain, upstream.URL)
r := httptest.NewRequest("GET", "http://localhost"+geckoAPI+"assets/v0.0.1/gecko.js", nil)
r.Header.Set("Authorization", "Bearer "+token)
r.Header.Set("Cookie", "private=secret")
r.Header.Set("X-Forwarded-For", "secret")
w := httptest.NewRecorder()
s.withAuthorization(s.mux).ServeHTTP(w, r)
if w.Code != 200 || requests.Load() != 1 || w.Header().Get("Set-Cookie") != "" {
t.Fatal(w.Code, w.Body)
}
if len(w.Header().Values("Cache-Control")) != 1 || strings.Contains(w.Header().Get("Cache-Control"), "no-store") {
t.Fatal("asset cache disabled", w.Header())
}
for _, tc := range []struct {
path, method string
code int
}{{"", "GET", 200}, {"wisp/", "GET", 403}, {"assets/v0.0.1/gecko.js?target=https://example.org", "GET", 400}, {"unknown", "GET", 404}, {"assets/v0.0.1/gecko.js", "POST", 400}} {
w = feedRequestTest(s, token, tc.method, "browser/"+tc.path, nil)
if w.Code != tc.code {
t.Fatalf("%s %s: %d %s", tc.method, tc.path, w.Code, w.Body)
}
if tc.path == "" && w.Header().Get("Cross-Origin-Embedder-Policy") != "require-corp" {
t.Fatal("not isolated")
}
}
if w = feedRequestTest(s, "", "GET", "browser/assets/v0.0.1/gecko.js", nil); w.Code == 200 {
t.Fatal("anonymous")
}
for _, origin := range []string{"https://evil.example", "null", "http://localhost.evil.example"} {
r := httptest.NewRequest("GET", "http://localhost"+geckoAPI+"wisp/", nil)
r.Header.Set("Authorization", "Bearer "+token)
r.Header.Set("Origin", origin)
r.Header.Set("Upgrade", "websocket")
w := httptest.NewRecorder()
s.withAuthorization(s.mux).ServeHTTP(w, r)
if w.Code != 403 {
t.Fatal("cross-site websocket", origin, w.Code)
}
}
prefs, err := s.store.TaskPreferences(context.Background(), domain, actor)
if err != nil {
t.Fatal(err)
}
prefs.RSSLinkMode = "gecko"
if _, err = s.store.SaveTaskPreferences(context.Background(), domain, actor, prefs, time.Now()); err != nil {
t.Fatal(err)
}
page := func() *httptest.ResponseRecorder {
r := httptest.NewRequest("GET", "http://localhost/v/feeds", nil)
r.Header.Set("Authorization", "Bearer "+token)
w := httptest.NewRecorder()
s.withAuthorization(s.mux).ServeHTTP(w, r)
return w
}
w = page()
if w.Code != 200 || w.Header().Get("Cross-Origin-Opener-Policy") != "same-origin" || !strings.Contains(w.Body.String(), `data-link-mode="gecko"`) {
t.Fatal("isolated page", w.Code)
}
if err = s.setSystemExtensionEnabled(domain, "viewer.gecko", false); err != nil {
t.Fatal(err)
}
w = page()
if w.Header().Get("Cross-Origin-Opener-Policy") != "" || !strings.Contains(w.Body.String(), `data-link-mode="tab"`) {
t.Fatal("disabled fallback")
}
if w = feedRequestTest(s, token, "GET", "browser/", nil); w.Code != 404 {
t.Fatal("disabled shell", w.Code)
}
if err = s.setSystemExtensionEnabled(domain, "organizer.feeds", false); err != nil {
t.Fatal(err)
}
if w = feedRequestTest(s, token, "GET", "browser/distribution/v0.0.1/manifest.json", nil); w.Code != 200 {
t.Fatal("sources lost after disabling extensions", w.Code)
}
if w = feedRequestTest(s, "", "GET", "browser/distribution/v0.0.1/manifest.json", nil); w.Code == 200 {
t.Fatal("anonymous source download")
}
if err = s.setSystemExtensionEnabled(domain, "organizer.feeds", true); err != nil {
t.Fatal(err)
}
if err = s.setSystemExtensionEnabled(domain, "viewer.gecko", true); err != nil {
t.Fatal(err)
}
if _, err = s.store.DB.Exec(`UPDATE principals SET state='readonly' WHERE uuid=?`, actor); err != nil {
t.Fatal(err)
}
if w = feedRequestTest(s, token, "GET", "browser/", nil); w.Code != 404 {
t.Fatal("readonly browser", w.Code)
}
if w = feedRequestTest(s, token, "GET", "browser/distribution/v0.0.1/manifest.json", nil); w.Code != 200 {
t.Fatal("readonly recipient lost source access", w.Code)
}
}
func TestFeedGeckoWebsocketRevocation(t *testing.T) {
for _, disable := range []bool{false, true} {
t.Run(map[bool]string{false: "logout", true: "disable"}[disable], func(t *testing.T) {
s, token, domain, _, _ := feedFixture(t)
relay, err := geckorelay.New(geckoTestKey, t.TempDir())
if err != nil {
t.Fatal(err)
}
upstream := httptest.NewServer(relay)
defer upstream.Close()
configureTestGecko(t, s, domain, upstream.URL)
web := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
r.Host = "localhost"
s.withAuthorization(s.mux).ServeHTTP(w, r)
}))
defer web.Close()
cfg, _ := websocket.NewConfig("ws"+strings.TrimPrefix(web.URL, "http")+geckoAPI+"wisp/", "http://localhost")
cfg.Header.Set("Authorization", "Bearer "+token)
conn, err := websocket.DialConfig(cfg)
if err != nil {
t.Fatal(err)
}
defer conn.Close()
conn.SetDeadline(time.Now().Add(12 * time.Second))
var frame []byte
if err = websocket.Message.Receive(conn, &frame); err != nil || len(frame) != 9 || frame[0] != 3 || binary.LittleEndian.Uint32(frame[1:]) != 0 {
t.Fatal(frame, err)
}
if disable {
err = s.setSystemExtensionEnabled(domain, "viewer.gecko", false)
} else {
err = s.store.RevokeAuthSession(token)
}
if err != nil {
t.Fatal(err)
}
start := time.Now()
err = websocket.Message.Receive(conn, &frame)
if err == nil || time.Since(start) > 10*time.Second {
t.Fatal("session not promptly closed", err)
}
})
}
}
+56
View File
@@ -0,0 +1,56 @@
package server
import (
"encoding/json"
"net/http"
"strconv"
"time"
"github.com/google/uuid"
"pageswiki/internal/store"
)
func writeFeedHistoryJSON(w http.ResponseWriter, value any) {
w.Header().Set("Cache-Control", "private, no-store")
w.Header().Set("Content-Type", "application/json; charset=utf-8")
_ = json.NewEncoder(w).Encode(value)
}
func (s *Server) handleFeedHistory(w http.ResponseWriter, r *http.Request, domain, actor, key string) bool {
if r.Method != "GET" || (key != "actions" && key != "action/export") {
return false
}
if key == "action/export" {
a, e := s.store.FeedActionRecord(r.Context(), domain, actor, r.URL.Query().Get("request_id"))
if e != nil {
taskError(w, e)
return true
}
id, _ := uuid.Parse(a.RequestID)
w.Header().Set("Content-Disposition", `attachment; filename="pageswiki-feed-action-`+id.String()+`.json"`)
w.Header().Set("X-Content-Type-Options", "nosniff")
writeFeedHistoryJSON(w, map[string]any{"format": "pageswiki.feed-action", "version": 1, "exported_ms": time.Now().UnixMilli(), "domain_uuid": domain, "owner_uuid": actor, "action": a})
return true
}
q := r.URL.Query()
query := store.FeedActionQuery{Source: q.Get("source"), Status: q.Get("status"), Before: -1, Key: q.Get("key")}
if q.Has("before") {
var e error
query.Before, e = strconv.ParseInt(q.Get("before"), 10, 64)
if e != nil || query.Before < 0 {
taskError(w, store.ErrTaskInvalid)
return true
}
}
items, e := s.store.FeedActionHistory(r.Context(), domain, actor, query)
if e != nil {
taskError(w, e)
return true
}
more := len(items) > 50
if more {
items = items[:50]
}
writeFeedHistoryJSON(w, map[string]any{"actions": items, "more": more})
return true
}
+260
View File
@@ -0,0 +1,260 @@
package server
import (
"context"
"database/sql"
"encoding/json"
"errors"
"fmt"
"strings"
"testing"
"time"
"github.com/google/uuid"
"pageswiki/internal/store"
)
func feedHistoryResponse(t *testing.T, s *Server, token, query string) ([]store.FeedActionRecord, bool) {
t.Helper()
w := feedRequestTest(s, token, "GET", "actions"+query, nil)
if w.Code != 200 {
t.Fatal(w.Code, w.Body)
}
if w.Header().Get("Cache-Control") != "private, no-store" {
t.Fatal("private response cache policy")
}
var data struct {
Actions []store.FeedActionRecord `json:"actions"`
More bool `json:"more"`
}
if e := json.Unmarshal(w.Body.Bytes(), &data); e != nil {
t.Fatal(e)
}
return data.Actions, data.More
}
func TestFeedHistoryOrphansExportAndRecheck(t *testing.T) {
s, token, domain, actor, source := feedActionFixture(t)
ctx := context.Background()
a, e := s.store.QueueFeedAction(ctx, domain, actor, newFeedAction(source))
if e != nil {
t.Fatal(e)
}
queued, _ := feedHistoryResponse(t, s, token, "?status=pending")
if len(queued) != 1 || queued[0].Status != "queued" || queued[0].CanCheck {
t.Fatal("queued history", queued)
}
fake := &feedRemoteFake{timeout: true}
if e = s.syncFeedActions(ctx, fake.client(t)); e != nil {
t.Fatal(e)
}
list, _ := feedHistoryResponse(t, s, token, "")
if len(list) != 1 || list[0].Status != "unknown" || list[0].CanCheck || list[0].CheckAfterMS <= time.Now().UnixMilli() || !list[0].ItemPresent || !list[0].SourcePresent {
t.Fatal("unknown cooldown", list)
}
if _, e = s.store.DB.Exec(`DELETE FROM feed_items WHERE source_uuid=?`, source.UUID); e != nil {
t.Fatal(e)
}
if _, e = s.store.DB.Exec(`UPDATE feed_actions SET until_ms=0 WHERE request_id=?`, a.RequestID); e != nil {
t.Fatal(e)
}
// Read-only connector opt-out does not disable read-only result checks.
source.Credential, source.WriteEnabled = "", false
if _, e = s.store.SaveFeedSource(ctx, domain, actor, source); e != nil {
t.Fatal(e)
}
list, _ = feedHistoryResponse(t, s, token, "?status=unknown")
if len(list) != 1 || list[0].ItemPresent || !list[0].CanCheck || list[0].ItemTitle != "" || list[0].SourceTitle != "Remote" {
t.Fatal("evicted item lost", list)
}
w := feedRequestTest(s, token, "GET", "action/export?request_id="+a.RequestID, nil)
if w.Code != 200 || !strings.Contains(w.Header().Get("Content-Disposition"), a.RequestID+".json") || w.Header().Get("X-Content-Type-Options") != "nosniff" {
t.Fatal("export", w.Code, w.Header())
}
var exported struct {
Format string `json:"format"`
Action store.FeedActionRecord `json:"action"`
}
if e = json.Unmarshal(w.Body.Bytes(), &exported); e != nil || exported.Format != "pageswiki.feed-action" || exported.Action.RequestID != a.RequestID || exported.Action.Status != "unknown" {
t.Fatal("export data", exported, e)
}
for _, secret := range []string{"credential", "secret", source.URL, `"claim"`, `"until_ms"`} {
if strings.Contains(w.Body.String(), secret) {
t.Fatal("export leaked internal credentials or worker metadata", secret)
}
}
if w = feedRequestTest(s, token, "POST", "action/check", map[string]string{"request_id": a.RequestID}); w.Code != 202 {
t.Fatal(w.Code, w.Body)
}
if e = s.syncFeedActions(ctx, fake.client(t)); e != nil || fake.edits != 1 {
t.Fatal("recheck sent a second mutation", fake.edits, e)
}
list, _ = feedHistoryResponse(t, s, token, "")
if len(list) != 0 {
t.Fatal("confirmed action unresolved", list)
}
list, _ = feedHistoryResponse(t, s, token, "?status=confirmed")
if len(list) != 1 || list[0].Status != "confirmed" || list[0].ItemPresent {
t.Fatal("evicted receipt missing", list)
}
if _, e = s.store.DB.Exec(`UPDATE feed_actions SET status='unknown' WHERE request_id=?`, a.RequestID); e != nil {
t.Fatal(e)
}
if _, e = s.store.DB.Exec(`DELETE FROM feed_sources WHERE uuid=?`, source.UUID); e != nil {
t.Fatal(e)
}
list, _ = feedHistoryResponse(t, s, token, "?source="+source.UUID)
if len(list) != 1 || list[0].SourcePresent || list[0].ItemPresent || list[0].CanCheck || list[0].Error != "source_deleted" {
t.Fatal("deleted source receipt lost", list)
}
if w = feedRequestTest(s, token, "POST", "action/check", map[string]string{"request_id": a.RequestID}); w.Code != 412 {
t.Fatal("deleted source recheck accepted", w.Code)
}
if w = feedRequestTest(s, token, "GET", "action/export?request_id="+a.RequestID, nil); w.Code != 200 {
t.Fatal("deleted source export", w.Code)
}
source.Version, source.Credential = 0, ""
source.URL = "https://different.example.org/api/greader.php"
if _, e = s.store.SaveFeedSource(ctx, domain, actor, source); !errors.Is(e, store.ErrTaskConflict) {
t.Fatal("rebound orphan receipt", e)
}
other, e := s.store.CreatePasswordAccount(domain, "historyreuse", "long test password", "Other", "")
if e != nil {
t.Fatal(e)
}
if _, e = s.store.SaveFeedSource(ctx, domain, other.UUID, source); !errors.Is(e, store.ErrTaskConflict) {
t.Fatal("rebound unresolved receipt across owners", e)
}
if _, e = s.store.DB.Exec(`UPDATE feed_actions SET status='confirmed' WHERE request_id=?`, a.RequestID); e != nil {
t.Fatal(e)
}
if _, e = s.store.SaveFeedSource(ctx, domain, actor, source); !errors.Is(e, store.ErrTaskConflict) {
t.Fatal("rebound terminal receipt", e)
}
}
func TestFeedHistoryPaginationValidationAndIsolation(t *testing.T) {
s, token, domain, actor, source := feedActionFixture(t)
ctx := context.Background()
// Same millisecond, stable unique tie-breaker; well above a page boundary.
for i := 0; i < 107; i++ {
if _, e := s.store.DB.Exec(`INSERT INTO feed_actions(domain_uuid,owner_uuid,request_id,source_uuid,item_id,field,desired,source_version,status,created_ms) VALUES(?,?,?,?,?,'read',1,1,'confirmed',1234)`, domain, actor, uuid.NewString(), source.UUID, fmt.Sprint(i)); e != nil {
t.Fatal(e)
}
}
query, seen := "?status=all", map[string]bool{}
for {
list, more := feedHistoryResponse(t, s, token, query)
if len(list) > 50 {
t.Fatal("unbounded list")
}
for _, a := range list {
if seen[a.RequestID] {
t.Fatal("duplicate cursor record")
}
seen[a.RequestID] = true
}
if !more {
break
}
last := list[len(list)-1]
query = fmt.Sprintf("?status=all&before=%d&key=%s", last.CreatedMS, last.RequestID)
}
if len(seen) != 107 {
t.Fatal("cursor omissions", len(seen))
}
for _, query := range []string{"?status=bogus", "?source=bad", "?before=bad", "?before=-1", "?before=1", "?key=" + uuid.NewString(), "?before=1&key=bad"} {
if w := feedRequestTest(s, token, "GET", "actions"+query, nil); w.Code != 422 {
t.Fatal("invalid query", query, w.Code)
}
}
other, e := s.store.CreatePasswordAccount(domain, "historyother", "long test password", "Other", "")
if e != nil {
t.Fatal(e)
}
otherToken, e := s.store.CreateAuthSession(domain, other.UUID)
if e != nil {
t.Fatal(e)
}
otherList, _ := feedHistoryResponse(t, s, otherToken, "?status=all&source="+source.UUID)
if len(otherList) != 0 {
t.Fatal("other owner's HTTP history leaked")
}
list, e := s.store.FeedActionHistory(ctx, domain, other.UUID, store.FeedActionQuery{Source: source.UUID, Status: "all", Before: -1})
if e != nil || len(list) != 0 {
t.Fatal("other owner's actions leaked", list, e)
}
for request := range seen {
if w := feedRequestTest(s, otherToken, "GET", "action/export?request_id="+request, nil); w.Code != 404 {
t.Fatal("other owner's HTTP export", w.Code)
}
if _, e = s.store.FeedActionRecord(ctx, domain, other.UUID, request); !errors.Is(e, sql.ErrNoRows) {
t.Fatal("other owner's receipt leaked", e)
}
break
}
if _, e = s.store.FeedActionHistory(ctx, uuid.NewString(), actor, store.FeedActionQuery{Status: "all", Before: -1}); !errors.Is(e, store.ErrAccessDenied) {
t.Fatal("other domain", e)
}
for _, key := range []string{"actions", "action/export?request_id=" + uuid.NewString()} {
if w := feedRequestTest(s, "", "GET", key, nil); w.Code != 401 {
t.Fatal("anonymous access", w.Code)
}
}
if w := feedRequestTest(s, token, "GET", "action/export?request_id=invalid", nil); w.Code != 422 {
t.Fatal("invalid receipt identifier", w.Code)
}
if e = s.setSystemExtensionEnabled(domain, "organizer.feeds", false); e != nil {
t.Fatal(e)
}
if w := feedRequestTest(s, token, "GET", "actions", nil); w.Code != 404 {
t.Fatal("extension disabled", w.Code)
}
if _, e = s.store.FeedActionRecord(ctx, domain, actor, uuid.NewString()); !errors.Is(e, store.ErrAccessDenied) {
t.Fatal("store disabled", e)
}
}
func TestFeedHistoryReadonlyAndSourceDisabled(t *testing.T) {
s, token, domain, actor, source := feedActionFixture(t)
ctx := context.Background()
a, e := s.store.QueueFeedAction(ctx, domain, actor, newFeedAction(source))
if e != nil {
t.Fatal(e)
}
if _, e = s.store.DB.Exec(`UPDATE feed_actions SET status='unknown',until_ms=0 WHERE request_id=?`, a.RequestID); e != nil {
t.Fatal(e)
}
if e = s.store.SetPrincipalState(domain, actor, "readonly"); e != nil {
t.Fatal(e)
}
token, e = s.store.CreateAuthSession(domain, actor)
if e != nil {
t.Fatal(e)
}
list, _ := feedHistoryResponse(t, s, token, "")
if len(list) != 1 || list[0].CanCheck {
t.Fatal("readonly check permission", list)
}
if w := feedRequestTest(s, token, "POST", "action/check", map[string]string{"request_id": a.RequestID}); w.Code != 403 {
t.Fatal("readonly mutation", w.Code)
}
if w := feedRequestTest(s, token, "GET", "action/export?request_id="+a.RequestID, nil); w.Code != 200 {
t.Fatal("readonly export", w.Code)
}
if e = s.store.SetPrincipalState(domain, actor, "active"); e != nil {
t.Fatal(e)
}
token, e = s.store.CreateAuthSession(domain, actor)
if e != nil {
t.Fatal(e)
}
source.Credential, source.Enabled = "", false
if _, e = s.store.SaveFeedSource(ctx, domain, actor, source); e != nil {
t.Fatal(e)
}
list, _ = feedHistoryResponse(t, s, token, "")
if len(list) != 1 || list[0].CanCheck || !list[0].SourcePresent {
t.Fatal("disabled source recheck", list)
}
}
+41 -2
View File
@@ -531,6 +531,18 @@ func TestFeedsChromium(t *testing.T) {
t.Skip("opt-in Chromium")
}
s, token, domain, actor, source := feedFixture(t)
if err := s.store.SetConfigInDomain(domain, "timezone", "Asia/Tokyo"); err != nil {
t.Fatal(err)
}
prefs, err := s.store.TaskPreferences(context.Background(), domain, actor)
if err != nil {
t.Fatal(err)
}
prefs.WikiPrefix = "/notes/{YYYY}/{MM}/{DD}/{Subject}"
prefs.RSSLinkMode = "embedded"
if _, err = s.store.SaveTaskPreferences(context.Background(), domain, actor, prefs, time.Now()); err != nil {
t.Fatal(err)
}
claim, e := s.store.ClaimFeed(context.Background(), source)
if e != nil {
t.Fatal(e)
@@ -569,7 +581,7 @@ func TestFeedsChromium(t *testing.T) {
if e != nil {
t.Fatal(e)
}
if e = s.store.CompleteFeed(context.Background(), claim, []store.FeedItem{{ID: "catalog-a", Title: "Catalog first", RemoteFeed: "feed/1", RemoteCategories: []string{"user/alice/label/Tech"}}, {ID: "catalog-b", Title: "Catalog second", RemoteFeed: "feed/2", RemoteCategories: []string{"user/alice/label/Other"}}}, "", "", "", false, catalog); e != nil {
if e = s.store.CompleteFeed(context.Background(), claim, []store.FeedItem{{ID: "catalog-a", Title: "Catalog first", RemoteFeed: "feed/1", RemoteCategories: []string{"user/alice/label/Tech"}}, {ID: "catalog-b", Title: "Catalog second", RemoteFeed: "feed/2", RemoteCategories: []string{"user/alice/label/Other"}}}, "", "", "", false, store.FeedCatalogSnapshot{Subscriptions: catalog, Folders: []store.FeedCategory{{ID: "user/-/label/Empty/Folder", Label: "Empty/Folder"}}}); e != nil {
t.Fatal(e)
}
s.store.BackgroundJobsDisabled = true
@@ -582,6 +594,11 @@ func TestFeedsChromium(t *testing.T) {
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/embedded" {
w.Header().Set("Content-Type", "text/html")
io.WriteString(w, `<h1>Isolated external article fixture</h1><script>parent.postMessage('rss-external-fixture-loaded','*')</script>`)
return
}
if r.URL.Path == "/fixture/run-feed-actions" && r.Method == "POST" {
fake := &feedRemoteFake{id: "catalog-b"}
if e := s.syncFeedActions(r.Context(), fake.client(t)); e != nil {
@@ -591,6 +608,28 @@ func TestFeedsChromium(t *testing.T) {
w.WriteHeader(204)
return
}
if r.URL.Path == "/fixture/feed-history" && r.Method == "POST" {
missing, orphan := uuid.NewString(), uuid.NewString()
for _, entry := range []struct{ request, source, item string }{{missing, fresh.UUID, "history-evicted"}, {orphan, uuid.NewString(), `<img src=x onerror=alert(1)>`}} {
if _, e := s.store.DB.Exec(`INSERT INTO feed_actions(domain_uuid,owner_uuid,request_id,source_uuid,item_id,field,desired,source_version,status,created_ms) VALUES(?,?,?,?,?,'read',1,1,'unknown',?)`, domain, actor, entry.request, entry.source, entry.item, time.Now().UnixMilli()); e != nil {
t.Error(e)
http.Error(w, "fixture insert failed", 500)
return
}
}
writeEventJSON(w, 200, map[string]string{"missing": missing, "orphan": orphan})
return
}
if r.URL.Path == "/fixture/check-feed-history" && r.Method == "POST" {
fake := &feedRemoteFake{id: "history-evicted", read: true}
if e := s.syncFeedActions(r.Context(), fake.client(t)); e != nil || fake.edits != 0 {
t.Errorf("history read-only check: %v edits=%d", e, fake.edits)
http.Error(w, "test recheck failed", 500)
return
}
w.WriteHeader(204)
return
}
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>")
@@ -600,7 +639,7 @@ func TestFeedsChromium(t *testing.T) {
}))
defer web.Close()
for _, width := range []string{"1440", "390"} {
if _, e = s.store.DB.Exec(`DELETE FROM feed_actions WHERE source_uuid=?`, fresh.UUID); e != nil {
if _, e = s.store.DB.Exec(`DELETE FROM feed_actions`); e != nil {
t.Fatal(e)
}
if _, e = s.store.DB.Exec(`UPDATE feed_items SET is_read=0 WHERE source_uuid=?`, fresh.UUID); e != nil {
+6 -66
View File
@@ -1,7 +1,6 @@
package server
import (
"bytes"
"crypto/rand"
"math/big"
"mime"
@@ -9,7 +8,6 @@ import (
pathpkg "path"
"strconv"
"strings"
"time"
"pageswiki/internal/store"
)
@@ -23,75 +21,16 @@ type homeWallpaperView struct {
Key string
}
// configuredLoginWallpaper returns only the image selected by the Domain
// administrator as the home/login wallpaper. It intentionally does not use
// the requesting principal's document permissions: choosing an image as the
// login wallpaper makes that one image public on the sign-in surface.
func (s *Server) configuredLoginWallpaper(domainUUID string) *store.Revision {
configured, _ := s.homeWallpaperConfig(domainUUID)
if configured == "" {
return nil
}
if objectUUID, err := s.store.ResolvePathInDomain(domainUUID, configured); err == nil {
revision, revisionErr := s.store.GetLatestRevisionForLanguages(objectUUID, []string{s.getLocale(domainUUID), "und"})
if revisionErr == nil && imageContentType(revision.ContentType) {
return revision
}
}
entries, err := s.store.ListBrowserEntriesInDomain(domainUUID, configured)
if err != nil {
return nil
}
candidates := make([]store.BrowserEntry, 0, len(entries))
for _, entry := range entries {
if !entry.IsDir && entry.RevisionUUID != "" && imageContentType(entry.ContentType) {
candidates = append(candidates, entry)
}
}
if len(candidates) == 0 {
return nil
}
index := 0
if value, randomErr := rand.Int(rand.Reader, big.NewInt(int64(len(candidates)))); randomErr == nil {
index = int(value.Int64())
}
revision, err := s.store.GetRevision(candidates[index].RevisionUUID)
if err != nil || !imageContentType(revision.ContentType) {
return nil
}
return revision
}
// Legacy route retained as a deliberate 404. Home wallpapers are never
// published to unauthenticated clients through the sign-in screen.
func (s *Server) handleAuthWallpaper(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet && r.Method != http.MethodHead {
w.Header().Set("Allow", "GET, HEAD")
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
w.WriteHeader(http.StatusMethodNotAllowed)
return
}
revision := s.configuredLoginWallpaper(s.domainUUIDForRequest(r))
if revision == nil {
http.NotFound(w, r)
return
}
contentType := revision.ContentType
mediaType, _, err := mime.ParseMediaType(contentType)
if err != nil || !strings.HasPrefix(strings.ToLower(mediaType), "image/") {
http.NotFound(w, r)
return
}
filename := strings.TrimSpace(revision.Filename)
if filename == "" {
filename = "wallpaper"
}
w.Header().Set("Cache-Control", "private, no-store")
w.Header().Set("Content-Type", contentType)
w.Header().Set("Content-Disposition", mime.FormatMediaType("inline", map[string]string{"filename": filename}))
w.Header().Set("X-Content-Type-Options", "nosniff")
w.Header().Set("ETag", `"`+revision.DocumentHash+`"`)
if strings.EqualFold(mediaType, "image/svg+xml") {
w.Header().Set("Content-Security-Policy", "default-src 'none'; sandbox")
}
http.ServeContent(w, r, filename, time.UnixMilli(revision.CreatedAtMS), bytes.NewReader([]byte(revision.Body)))
http.NotFound(w, r)
}
func normalizePickerPath(raw string) (string, bool) {
@@ -135,7 +74,8 @@ func (s *Server) homeWallpaperConfig(domainUUID string) (string, int) {
func (s *Server) homeWallpaperForRequest(r *http.Request) homeWallpaperView {
domainUUID := s.domainUUIDForRequest(r)
configured, opacity := s.homeWallpaperConfig(domainUUID)
p := s.appearanceForRequest(r)
configured, opacity := p.Path, p.Opacity
view := homeWallpaperView{Path: configured, Opacity: strconv.FormatFloat(float64(opacity)/100, 'f', 2, 64)}
if configured == "" {
return view
+5 -4
View File
@@ -22,7 +22,7 @@ func saveWallpaperFixture(t *testing.T, s *Server, domain, path, contentType str
}
}
func TestAuthPageUsesConfiguredWallpaperAndGlass(t *testing.T) {
func TestAuthPageDoesNotPublishHomeWallpaper(t *testing.T) {
s, _, domain := configFixture(t)
s.mux.HandleFunc("/_/auth/", s.handleAuth)
saveWallpaperFixture(t, s, domain, "/wallpapers/login.jpg", "image/jpeg")
@@ -46,8 +46,6 @@ func TestAuthPageUsesConfiguredWallpaperAndGlass(t *testing.T) {
for _, expected := range []string{
`class="auth-page"`,
`--home-glass-opacity:53%`,
`class="home-wallpaper" src="/_/auth/wallpaper"`,
`style="opacity:0.41"`,
`/static/css/auth.css?v=1`,
`class="auth-provider-button"`,
`OpenID Connectでログイン`,
@@ -56,10 +54,13 @@ func TestAuthPageUsesConfiguredWallpaperAndGlass(t *testing.T) {
t.Fatalf("auth page missing %q: status=%d body=%s", expected, response.Code, body)
}
}
if strings.Contains(body, `class="home-wallpaper"`) || strings.Contains(body, `/_/auth/wallpaper`) {
t.Fatal("private home wallpaper exposed at login")
}
wallpaper := httptest.NewRecorder()
s.withAuthorization(s.mux).ServeHTTP(wallpaper, httptest.NewRequest(http.MethodGet, "http://localhost/_/auth/wallpaper?path=/private/ignored", nil))
if wallpaper.Code != http.StatusOK || wallpaper.Body.String() != "fixture" || wallpaper.Header().Get("Content-Type") != "image/jpeg" || wallpaper.Header().Get("X-Content-Type-Options") != "nosniff" {
if wallpaper.Code != http.StatusNotFound || wallpaper.Body.String() == "fixture" {
t.Fatalf("login wallpaper: status=%d type=%q body=%q", wallpaper.Code, wallpaper.Header().Get("Content-Type"), wallpaper.Body.String())
}
+15 -2
View File
@@ -20,11 +20,11 @@ import (
"golang.org/x/net/html/atom"
)
const htmlProjectionVersion = "controlled-v2"
const htmlProjectionVersion = "controlled-v3"
const maxProjectionInput = 1 << 20
const maxProjectionOutput = 4 << 20
var projectionMacroRE = regexp.MustCompile(`\{\{(?:children[^}]*|(?:city-breadcrumbs|spot-pages|quartier|street|spot|nearby|city)(?:\s+[^}]*)?)\}\}`)
var projectionMacroRE = regexp.MustCompile(`\{\{(?:csv:[^}]*|children[^}]*|(?:city-breadcrumbs|spot-pages|quartier|street|spot|nearby|city)(?:\s+[^}]*)?)\}\}`)
var languageClassRE = regexp.MustCompile(`^language-[a-zA-Z0-9_+-]{1,40}$`)
func projectionPolicy(generated bool) *bluemonday.Policy {
@@ -199,6 +199,8 @@ func (s *Server) safeHTMLProjection(r *http.Request, body, path string, expand b
}
var output strings.Builder
macros, count := 0, 0
csvCount := 0
csvResults := map[string]string{}
var emit func(*html.Node, int, bool) bool
emit = func(n *html.Node, depth int, literal bool) bool {
count++
@@ -226,6 +228,14 @@ func (s *Server) safeHTMLProjection(r *http.Request, body, path string, expand b
// be reparsed as a nested children request on its raw text.
if isAnonymousProjection(r) {
expanded = s.expandPublicMacro(r, macro, path)
} else if strings.HasPrefix(macro, "{{csv:") {
if cached, ok := csvResults[macro]; ok {
expanded = cached
} else if csvCount < 4 {
csvCount++
expanded = s.expandCSVMacro(r, macro)
csvResults[macro] = expanded
}
} else if strings.HasPrefix(macro, "{{children") {
expanded = s.expandChildrenMacros(macro, path)
} else {
@@ -236,6 +246,9 @@ func (s *Server) safeHTMLProjection(r *http.Request, body, path string, expand b
// promote decoded entities into trusted generated elements.
output.WriteString(stdhtml.EscapeString(macro))
} else {
if output.Len()+len(expanded) > maxProjectionOutput {
return false
}
output.WriteString(expanded)
}
at = loc[1]
+1 -1
View File
@@ -37,7 +37,7 @@ func parseTrustedTemplates(t *template.Template) (*template.Template, error) {
func safeProjectionTemplate(name string) bool {
switch name {
case "periodical.gohtml", "public_periodical.gohtml", "periodical_new.gohtml":
case "periodical.gohtml", "public_periodical.gohtml", "periodical_new.gohtml", "slides.gohtml":
return true
case "city_map.gohtml", "public_tree.gohtml", "anonymous_view.gohtml", "page.gohtml", "home.gohtml", "search_home.gohtml", "object_view.gohtml", "revision_view.gohtml", "preview.gohtml", "print.gohtml", "profile.gohtml", "editor.gohtml", "object_editor.gohtml":
return true
+2 -2
View File
@@ -239,7 +239,7 @@ var translations = map[string]map[string]string{
"home.palette_brightness": "Light and dark",
"home.palette_preserve": "Keep the current theme brightness",
"home.palette_auto": "Choose from the displayed wallpaper",
"home.palette_help": "Applies only to the home page and its dialogs. Warning colors are preserved. If extraction fails, the selected theme remains. Shared by this domain.",
"home.palette_help": "Applies only to the home page and its dialogs. Warning colors are preserved. If extraction fails, the selected theme remains.",
"home.glass_transparency": "Glass transparency (%)",
"home.glass_help": "Controls the shared transparency of the home search, menus, suggestions, cards, and dialogs. Higher values are more transparent.",
"picker.open": "Browse PagesWiki",
@@ -1019,7 +1019,7 @@ var translations = map[string]map[string]string{
"home.palette_brightness": "明暗",
"home.palette_preserve": "現在のテーマの明暗を維持",
"home.palette_auto": "表示中の壁紙から自動判定",
"home.palette_help": "トップ画面とその上のダイアログにのみ適用します。警告色は変更しません。色を抽出できない場合は選択中のテーマを維持します。このドメインで共通の設定です。",
"home.palette_help": "トップ画面とその上のダイアログにのみ適用します。警告色は変更しません。色を抽出できない場合は選択中のテーマを維持します。",
"home.glass_transparency": "グラスの透明度(%)",
"home.glass_help": "トップ画面の検索、メニュー、サジェスト、カード、ダイアログに共通の透明度です。数値を上げるほど背景が透けます。",
"picker.open": "PagesWikiから選択",
+1 -1
View File
@@ -19,7 +19,7 @@ func NormalizePath(
// Hosted adapter assets use directory-relative module and worker URLs.
// DAV collections also require the slash: removing it conflicts with
// ServeMux's collection redirect and causes an infinite redirect loop.
if strings.HasPrefix(p, "/_/adaptor/") || strings.HasPrefix(p, "/_/api/v1/caldav/") || strings.HasPrefix(p, "/_/api/v1/carddav/") {
if strings.HasPrefix(p, "/_/adaptor/") || strings.HasPrefix(p, "/_/api/v1/caldav/") || strings.HasPrefix(p, "/_/api/v1/carddav/") || strings.HasPrefix(p, "/_/api/v1/extension/organizer.feeds/browser/") {
next.ServeHTTP(w, r)
return
}
@@ -24,3 +24,18 @@ func TestNormalizePathDAVCollections(t *testing.T) {
t.Fatal("Wiki canonicalization changed", w.Code, w.Header())
}
}
func TestNormalizePathGeckoWebsocket(t *testing.T) {
for _, path := range []string{"/_/api/v1/extension/organizer.feeds/browser/", "/_/api/v1/extension/organizer.feeds/browser/wisp/"} {
w := httptest.NewRecorder()
NormalizePath(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != path {
t.Fatal(r.URL.Path)
}
w.WriteHeader(401)
})).ServeHTTP(w, httptest.NewRequest("GET", path, nil))
if w.Code != 401 || w.Header().Get("Location") != "" {
t.Fatal("redirected browser endpoint", w.Code)
}
}
}
+14 -2
View File
@@ -9,7 +9,7 @@ import (
)
func personalOrganizerSettings(r *http.Request) bool {
return r.URL.Path == "/-/sys/config" && r.URL.Query().Get("panel") == "organizer" && (r.Method == "GET" || r.Method == "HEAD")
return r.URL.Path == "/-/sys/config" && r.URL.Query().Get("panel") == "organizer" && (r.Method == "GET" || r.Method == "HEAD" || r.Method == "POST" && r.URL.Query().Get("section") == "appearance")
}
func (s *Server) handleOrganizerDashboard(w http.ResponseWriter, r *http.Request) {
@@ -33,7 +33,13 @@ func (s *Server) handleOrganizerSettings(w http.ResponseWriter, r *http.Request)
s.authRequired(w, r)
return
}
s.renderWithContext(w, r, "organizer_settings.gohtml", map[string]any{"TaskWritable": active})
if r.Method == "POST" {
s.savePersonalAppearance(w, r, actor, active)
return
}
data := s.appearanceData(r)
data["TaskWritable"] = active
s.renderWithContext(w, r, "organizer_settings.gohtml", data)
}
func (s *Server) handleDashboardData(w http.ResponseWriter, r *http.Request, actor string, active bool, kind string) {
@@ -110,6 +116,12 @@ func organizerSection(path string) string {
}
func init() {
translations["en"]["home.domain_appearance_defaults"] = "Appearance defaults (personal settings take precedence)"
translations["ja"]["home.domain_appearance_defaults"] = "外観の初期値(個人設定を優先)"
translations["en"]["home.personal_wallpaper"] = "Personal wallpaper Path (empty: none)"
translations["ja"]["home.personal_wallpaper"] = "個人の壁紙Path(空欄:なし)"
translations["en"]["home.personal_opacity"] = "Wallpaper opacity (%)"
translations["ja"]["home.personal_opacity"] = "壁紙の不透明度(%)"
translations["en"]["task.work_history"] = "Work history"
translations["ja"]["task.work_history"] = "作業記録"
for lang, entries := range map[string]map[string]string{
+11 -1
View File
@@ -69,12 +69,22 @@ func TestOrganizerDashboardLayoutIsolationAndCAS(t *testing.T) {
if err = json.Unmarshal(w.Body.Bytes(), &layout); err != nil || len(layout.Widgets) != 0 {
t.Fatal("empty layout reset", layout, err)
}
for _, invalid := range [][]store.DashboardWidget{{{ID: "iframe", Width: 4, Height: 3}}, {{ID: "tasks", Width: 13, Height: 3, Tab: "inbox"}}, {{ID: "tasks", Width: 4, Height: 3, Tab: "secret"}}, {{ID: "progress", Width: 4, Height: 3}, {ID: "progress", Width: 4, Height: 3}}} {
for _, invalid := range [][]store.DashboardWidget{{{ID: "iframe", Width: 4, Height: 3}}} {
w = taskRequest(s, token, "PUT", "dashboard", map[string]any{"version": layout.Version, "widgets": invalid}, "")
if w.Code != 422 {
t.Fatal("invalid accepted", w.Code, w.Body)
}
}
for _, id := range []string{"commands", "tomorrow-schedule", "feeds"} {
input := []store.DashboardWidget{{ID: "tasks", Width: 13, Height: 0}, {ID: id, Width: 6, Height: 4, Tab: "obsolete"}, {ID: id, Width: 6, Height: 4}}
w = taskRequest(s, token, "PUT", "dashboard", map[string]any{"version": layout.Version, "widgets": input}, "")
if w.Code != 200 {
t.Fatal("normalizable layout rejected", w.Code, w.Body)
}
if err = json.Unmarshal(w.Body.Bytes(), &layout); err != nil || len(layout.Widgets) != 2 || layout.Widgets[0].Width != 12 || layout.Widgets[0].Height != 2 || layout.Widgets[0].Tab != "inbox" || layout.Widgets[1].Tab != "" {
t.Fatal("normalization", layout, err)
}
}
other, err := s.store.CreatePasswordAccount(domain, "dashboardother", "long test password", "Other", "")
if err != nil {
t.Fatal(err)
+123
View File
@@ -0,0 +1,123 @@
package server
import (
"database/sql"
"encoding/json"
"errors"
"net/http"
"strconv"
)
// Personal appearance is separate from domain defaults and from organizer mail
// preferences. It never makes the selected documents publicly readable.
type personalAppearance struct {
Version int64
Path string
Opacity int
Glass int
Palette homePaletteSettings
}
func (s *Server) appearanceForRequest(r *http.Request) personalAppearance {
domain := s.domainUUIDForRequest(r)
path, opacity := s.homeWallpaperConfig(domain)
p := personalAppearance{Path: path, Opacity: opacity, Glass: s.homeGlassTransparency(domain), Palette: s.homePalette(domain)}
principal := s.requestPrincipal(r)
if principal == nil {
return p
}
var raw string
var version int64
if s.store.DB.QueryRowContext(r.Context(), `SELECT version,data FROM personal_appearance WHERE domain_uuid=? AND owner_uuid=?`, domain, principal.UUID).Scan(&version, &raw) == nil {
var saved personalAppearance
if json.Unmarshal([]byte(raw), &saved) == nil {
saved.Version = version
return saved
}
}
return p
}
func (s *Server) appearanceData(r *http.Request) map[string]any {
p := s.appearanceForRequest(r)
return map[string]any{"AppearanceVersion": p.Version, "HomeWallpaperPath": p.Path, "HomeWallpaperPercent": p.Opacity, "HomeGlassTransparency": p.Glass, "HomePalette": p.Palette}
}
func (s *Server) savePersonalAppearance(w http.ResponseWriter, r *http.Request, actor string, active bool) {
if !active || s.store.ReadOnly {
http.Error(w, "forbidden", 403)
return
}
r.Body = http.MaxBytesReader(w, r.Body, 16384)
if r.ParseForm() != nil {
http.Error(w, "invalid form", 400)
return
}
domain := s.domainUUIDForRequest(r)
p := s.appearanceForRequest(r)
version, err := strconv.ParseInt(r.FormValue("version"), 10, 64)
if err != nil || version < 0 {
http.Error(w, "invalid version", 400)
return
}
if p.Version != version {
http.Error(w, "Settings changed elsewhere; reload before saving.", 409)
return
}
if p.Glass, err = normalizeHomeGlassTransparency(r.FormValue("home_glass_transparency")); err != nil {
http.Error(w, "invalid transparency", 400)
return
}
if p.Palette, err = s.parseHomePalette(domain, r.Form); err != nil {
http.Error(w, "invalid palette", 400)
return
}
if r.Form.Has("home_wallpaper_path") {
var ok bool
p.Path, ok = normalizePickerPath(r.FormValue("home_wallpaper_path"))
if !ok {
http.Error(w, "invalid Path", 400)
return
}
if p.Path != "" && !s.requestCanReadPath(r, p.Path) {
http.Error(w, "Path not readable", 403)
return
}
}
if r.Form.Has("home_wallpaper_opacity") {
p.Opacity, err = strconv.Atoi(r.FormValue("home_wallpaper_opacity"))
if err != nil || p.Opacity < 0 || p.Opacity > 100 {
http.Error(w, "invalid opacity", 400)
return
}
}
p.Version = version + 1
raw, _ := json.Marshal(p)
result, err := s.store.DB.ExecContext(r.Context(), `INSERT INTO personal_appearance(domain_uuid,owner_uuid,version,data) SELECT ?,?,?,? WHERE ?=0 ON CONFLICT(domain_uuid,owner_uuid) DO NOTHING`, domain, actor, p.Version, string(raw), version)
if err == nil {
var n int64
n, err = result.RowsAffected()
if err == nil && n == 0 {
result, err = s.store.DB.ExecContext(r.Context(), `UPDATE personal_appearance SET version=?,data=? WHERE domain_uuid=? AND owner_uuid=? AND version=?`, p.Version, string(raw), domain, actor, version)
if err == nil {
n, err = result.RowsAffected()
if n == 0 {
err = sql.ErrNoRows
}
}
}
}
if errors.Is(err, sql.ErrNoRows) {
http.Error(w, "Settings changed elsewhere; reload before saving.", 409)
return
}
if err != nil {
http.Error(w, "Unable to save settings", 500)
return
}
if r.Header.Get("Accept") == "application/json" {
writeEventJSON(w, 200, map[string]any{"version": p.Version})
return
}
http.Redirect(w, r, "/-/sys/config?panel=organizer#appearance", http.StatusSeeOther)
}
@@ -0,0 +1,54 @@
package server
import (
"net/url"
"strings"
"testing"
)
func TestPersonalAppearanceIsolationAndCAS(t *testing.T) {
s, admin, domain := configFixture(t)
p, err := s.store.CreatePasswordAccount(domain, "appearanceuser", "long test password", "Member", "")
if err != nil {
t.Fatal(err)
}
token, err := s.store.CreateAuthSession(domain, p.UUID)
if err != nil {
t.Fatal(err)
}
endpoint := "/-/sys/config?panel=organizer&section=appearance"
form := url.Values{"version": {"0"}, "home_wallpaper_path": {""}, "home_wallpaper_opacity": {"50"}, "home_glass_transparency": {"71"}, "home_palette_mode": {"accent"}, "home_palette_strength": {"55"}, "home_palette_brightness": {"preserve"}}
w := configRequest(s, token, "POST", endpoint, form)
if w.Code != 303 || w.Header().Get("Location") != "/-/sys/config?panel=organizer#appearance" {
t.Fatal(w.Code, w.Body)
}
if w = configRequest(s, token, "POST", endpoint, form); w.Code != 409 {
t.Fatal("stale write", w.Code, w.Body)
}
w = configRequest(s, token, "GET", "/-/sys/config?panel=organizer", nil)
if w.Code != 200 || !strings.Contains(w.Body.String(), `name="home_glass_transparency" type="number" min="0" max="85" value="71"`) {
t.Fatal("personal value missing", w.Code, w.Body)
}
w = configRequest(s, admin, "GET", "/-/sys/config?panel=organizer", nil)
if w.Code != 200 || strings.Contains(w.Body.String(), `max="85" value="71"`) {
t.Fatal("owner leakage", w.Code)
}
raw, _ := s.store.GetConfigInDomain(domain, "home_glass_transparency")
if raw == "71" {
t.Fatal("changed domain settings")
}
if w = configRequest(s, "", "POST", endpoint, form); w.Code == 303 && w.Header().Get("Location") == "/-/sys/config?panel=organizer#appearance" {
t.Fatal("anonymous write")
}
if err = s.store.SetPrincipalState(domain, p.UUID, "readonly"); err != nil {
t.Fatal(err)
}
token, err = s.store.CreateAuthSession(domain, p.UUID)
if err != nil {
t.Fatal(err)
}
form.Set("version", "1")
if w = configRequest(s, token, "POST", endpoint, form); w.Code != 403 {
t.Fatal("readonly write", w.Code)
}
}
+11 -6
View File
@@ -69,27 +69,32 @@ func (s *Server) renderWithContext(
data["TasksEnabled"] = s.systemExtensionEnabled(domainUUID, "organizer.tasks")
data["ContactsEnabled"] = s.systemExtensionEnabled(domainUUID, "organizer.contacts")
data["FeedsEnabled"] = s.systemExtensionEnabled(domainUUID, "organizer.feeds")
data["SlidesEnabled"] = s.systemExtensionEnabled(domainUUID, "viewer.slides")
data["OrganizerSection"] = organizerSection(r.URL.Path)
if r.URL.Path == "/" {
data["IsHome"] = true
data["BookmarkSections"] = s.bookmarkSections(r)
canConfigureHome := s.canManageAssets(r)
if controlled, err := s.store.DomainEntryControlled(domainUUID); err != nil || controlled {
canConfigureHome = false
_, canConfigureHome := s.calendarActor(r)
if s.requestPrincipal(r) != nil {
w.Header().Set("Cache-Control", "private, no-store")
}
data["CanManageBookmarks"] = s.canManageAssets(r)
data["CanConfigureHome"] = canConfigureHome
transparency := s.homeGlassTransparency(domainUUID)
appearance := s.appearanceForRequest(r)
for k, v := range s.appearanceData(r) {
data[k] = v
}
transparency := appearance.Glass
data["HomeGlassTransparency"] = transparency
data["HomeGlassOpacity"] = 100 - transparency
wallpaper := s.homeWallpaperForRequest(r)
data["HomeWallpaperURL"] = wallpaper.URL
data["HomeWallpaperOpacity"] = wallpaper.Opacity
data["HomeWallpaperKey"] = wallpaper.Key
data["HomePalette"] = s.homePalette(domainUUID)
data["HomePalette"] = appearance.Palette
data["HomePaletteDomain"] = domainUUID
if wallpaper.URL != "" {
w.Header().Set("Cache-Control", "private, no-cache")
w.Header().Set("Cache-Control", "private, no-store")
}
if data["CanManageBookmarks"] == true {
data["ManagedBookmarks"] = s.managedBookmarks(domainUUID)
+3
View File
@@ -16,6 +16,7 @@ type UIHandlers struct {
Preview http.HandlerFunc
PlainView http.HandlerFunc
MarkdownView http.HandlerFunc
Slides http.HandlerFunc
CompileMarkdown http.HandlerFunc
CompileDiagram http.HandlerFunc
Config http.HandlerFunc
@@ -93,6 +94,8 @@ func RegisterUIRoutes(
handleIfNotNil(mux, "/v/markdown", h.MarkdownView)
handleIfNotNil(mux, "/v/markdown/", h.MarkdownView)
handleIfNotNil(mux, "/v/slides", h.Slides)
handleIfNotNil(mux, "/v/slides/", h.Slides)
handleIfNotNil(mux, "/:/compile/markdown", h.CompileMarkdown)
handleIfNotNil(mux, "/:/compile/markdown/", h.CompileMarkdown)
+44 -9
View File
@@ -9,6 +9,7 @@ import (
"path"
"strings"
"time"
"unicode/utf8"
"pageswiki/internal/grammaratur"
"pageswiki/internal/store"
@@ -211,16 +212,43 @@ func (s *Server) handleSemanticEditor(
}
}
latest, err :=
s.latestRevisionForRequest(
r,
objectUUID,
)
body := ""
// CSV editing needs the complete source, never the viewer's truncated window.
// Check metadata before loading a potentially large document.
metadata, metaErr := s.store.GetLatestRevisionMetadataForLanguagesContext(r.Context(), objectUUID, s.revisionLanguageCandidates(r))
if lang := r.URL.Query().Get("lang"); lang != "" {
latest, err = s.store.GetRevisionForExactLanguage(objectUUID, lang)
metadata, metaErr = s.store.GetRevisionMetadataForExactLanguage(objectUUID, lang)
}
if metaErr != nil || metadata == nil {
http.Error(w, "revision unavailable or invalid language", http.StatusBadRequest)
return
}
csvEditor := selectProjectionAdapter(contentDescriptor{MediaType: strings.ToLower(strings.TrimSpace(strings.Split(metadata.ContentType, ";")[0])), Filename: metadata.Filename}).Kind == "csv"
if csvEditor {
size, sizeErr := s.store.DocumentSizeContext(r.Context(), metadata.DocumentHash)
if sizeErr != nil || size > maxCSVMacroBytes {
http.Error(w, "CSV editor requires a complete document of at most 256 KiB", http.StatusRequestEntityTooLarge)
return
}
}
var latest *store.Revision
if csvEditor {
// Load the immutable revision we checked; a concurrent new head is
// handled by the normal save CAS, not by an unbounded second read.
window, readErr := s.store.ReadDocumentWindowContext(r.Context(), metadata.DocumentHash, 0, maxCSVMacroBytes)
if readErr != nil || window.Truncated {
http.Error(w, "CSV source unavailable", http.StatusServiceUnavailable)
return
}
latest = metadata
latest.Body = string(window.Data)
} else {
latest, err = s.latestRevisionForRequest(r, objectUUID)
if lang := r.URL.Query().Get("lang"); lang != "" {
latest, err = s.store.GetRevisionForExactLanguage(objectUUID, lang)
}
}
body := ""
if err != nil {
http.Error(w, "revision unavailable or invalid language", 400)
return
@@ -233,7 +261,13 @@ func (s *Server) handleSemanticEditor(
if err == nil {
if latest.UUID != "" {
view := revisionContentView(latest, path)
if view.Kind == "code" {
if view.Kind == "csv" {
if !csvEditor || !utf8.ValidString(latest.Body) || strings.ContainsRune(latest.Body, 0) || len(latest.Body) > maxCSVMacroBytes {
http.Error(w, "CSV editor requires bounded UTF-8 text", http.StatusUnsupportedMediaType)
return
}
editType = "code"
} else if view.Kind == "code" {
editType = "code"
if strings.EqualFold(strings.TrimSpace(strings.Split(latest.ContentType, ";")[0]), "text/plain") {
editType = "plain"
@@ -294,6 +328,7 @@ func (s *Server) handleSemanticEditor(
"BaseBody": baseBody,
"BaseRevision": latest.UUID,
"EditType": editType,
"CSVEditor": csvEditor,
"PageLanguage": latest.Language,
"PageContentType": contentType,
"PageFilename": filename,
+4 -1
View File
@@ -21,6 +21,8 @@ import (
)
type Server struct {
geckoOnce sync.Once
gecko *geckoProxy
calendarOnce sync.Once
calendarRepo *calendar.Repository
calendarErr error
@@ -255,6 +257,7 @@ func (s *Server) registerRoutes() {
Preview: s.handlePreview,
PlainView: s.handlePlainView,
MarkdownView: s.handleMarkdownView,
Slides: s.handleSlides,
CompileMarkdown: s.handleCompileMarkdown,
CompileDiagram: s.handleCompileDiagram,
Config: s.handleConfig,
@@ -351,7 +354,7 @@ func (s *Server) handler() http.Handler {
domainHandler = h
h = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
background := r.URL.Query().Get("preview") == "1" ||
strings.HasPrefix(r.URL.Path, "/v/preview-cache/")
strings.HasPrefix(r.URL.Path, "/v/preview-cache/") || r.URL.Path == feedsAPI+"browser/wisp/"
if !background {
s.foregroundRequests.Add(1)
defer s.foregroundRequests.Add(-1)
+6 -1
View File
@@ -77,9 +77,14 @@ func TestBookmarkAndVimSettingsChromium(t *testing.T) {
if len(items) != 2 || items[0].Kind != "section" || !items[0].Children || items[0].Href != "/docs" || items[1].Label != "Reference" {
t.Fatalf("saved bookmarks: %#v", items)
}
if got := s.homeGlassTransparency(domain); got != 57 {
r := httptest.NewRequest("GET", "http://localhost/", nil)
r.Header.Set("Authorization", "Bearer "+token)
if got := s.appearanceForRequest(r).Glass; got != 57 {
t.Fatalf("saved glass transparency: %d", got)
}
if s.homeGlassTransparency(domain) == 57 {
t.Fatal("personal appearance changed domain defaults")
}
vim := s.domainVimSettings(domain)
if !vim.Enabled || vim.Vimrc != "set tabstop=3\n" || vim.ColorName != "uploaded.vim" || !strings.Contains(vim.Colorscheme, "Normal") {
t.Fatalf("saved vim: %#v", vim)
+68
View File
@@ -0,0 +1,68 @@
package server
import (
"net/http"
"strings"
"unicode/utf8"
"pageswiki/internal/grammaratur"
)
const maxSlideSourceBytes = 256 << 10
func (s *Server) handleSlides(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet && r.Method != http.MethodHead {
w.Header().Set("Allow", "GET, HEAD")
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
return
}
domain := s.domainUUIDForRequest(r)
if !s.systemExtensionEnabled(domain, "viewer.slides") {
http.NotFound(w, r)
return
}
path := semanticViewPath(r.URL.Path)
if !s.requestCanReadPath(r, path) {
http.NotFound(w, r)
return
}
object, err := s.store.ResolvePathInDomain(domain, path)
if err != nil {
http.NotFound(w, r)
return
}
revision, err := s.store.GetLatestRevisionMetadataForLanguagesContext(r.Context(), object, s.revisionLanguageCandidates(r))
if err != nil || revision == nil {
http.NotFound(w, r)
return
}
media := strings.ToLower(strings.TrimSpace(strings.Split(revision.ContentType, ";")[0]))
if media != "text/html" && media != "text/markdown" && media != "text/x-markdown" {
http.Error(w, "slides require HTML or Markdown", http.StatusUnsupportedMediaType)
return
}
size, err := s.store.DocumentSizeContext(r.Context(), revision.DocumentHash)
if err != nil {
http.NotFound(w, r)
return
}
if size > maxSlideSourceBytes {
http.Error(w, "slides source exceeds 256 KiB", http.StatusRequestEntityTooLarge)
return
}
window, err := s.store.ReadDocumentWindowContext(r.Context(), revision.DocumentHash, 0, maxSlideSourceBytes)
if err != nil || window.Truncated || !utf8.Valid(window.Data) {
http.Error(w, "invalid slides source", http.StatusUnsupportedMediaType)
return
}
source := string(window.Data)
if media != "text/html" {
source = grammaratur.MarkdownAuthoringHTML(source)
}
source = s.safeHTMLProjection(r, source, path, false)
w.Header().Set("Cache-Control", "private, no-store")
if r.Method == http.MethodHead {
return
}
s.renderWithContext(w, r, "slides.gohtml", map[string]any{"Title": path, "Path": path, "SlideSource": source})
}
+12
View File
@@ -0,0 +1,12 @@
package server
func init() {
for lang, entries := range map[string]map[string]string{
"en": {"slides.title": "Slides", "slides.help": "Local Reveal.js viewer and editor preview. Separate slides with a horizontal rule.", "slides.preview": "Slide preview", "slides.close": "Return to page", "slides.fullscreen": "Fullscreen", "slides.error": "Slides could not be displayed. Use the document view (limit: 256 KiB, 100 slides)."},
"ja": {"slides.title": "スライド", "slides.help": "ローカル同梱のReveal.jsで閲覧・編集プレビュー。水平線でスライドを区切ります。", "slides.preview": "スライドプレビュー", "slides.close": "ページへ戻る", "slides.fullscreen": "全画面", "slides.error": "スライドを表示できません。通常表示を使用してください(上限256 KiB・100枚)。"},
} {
for key, value := range entries {
translations[lang][key] = value
}
}
}
+143
View File
@@ -0,0 +1,143 @@
package server
import (
"context"
"html"
"net/http"
"net/http/httptest"
"os"
"os/exec"
"strings"
"testing"
"time"
"pageswiki/internal/server/routes"
)
const slideFixture = `<h1>First slide</h1><p>日本語のスライド</p><hr><h2>Second slide</h2><ul><li>Local Reveal.js</li><li>No source mutation</li></ul>`
func TestSlidesAccessAndLimits(t *testing.T) {
s, token, domain, _ := editorFixture(t)
routes.RegisterUIRoutes(s.mux, routes.UIHandlers{Slides: s.handleSlides})
s.mux.HandleFunc("/deck", s.handleSemanticRoute)
object, err := s.store.CreatePageAtPathInDomain(domain, "/deck")
if err != nil {
t.Fatal(err)
}
save := func(body, media string) {
t.Helper()
if _, e := s.store.SaveRevisionContent(object, []byte(body), "", "und", media, ""); e != nil {
t.Fatal(e)
}
}
save(slideFixture, "text/html")
w := configRequest(s, token, "GET", "/v/slides/deck", nil)
if w.Code != 200 || !strings.Contains(w.Body.String(), "data-slides-viewer") || !strings.Contains(w.Body.String(), "&lt;h1&gt;First slide") {
t.Fatalf("slides %d %s", w.Code, w.Body.String())
}
if !strings.Contains(w.Header().Get("Content-Security-Policy"), "'nonce-") {
t.Fatal("missing CSP")
}
page := configRequest(s, token, "GET", "/deck", nil)
if !strings.Contains(page.Body.String(), `href="/v/slides/deck"`) {
t.Fatal("viewer action missing")
}
editor := configRequest(s, token, "GET", "/e/-/deck", nil)
if !strings.Contains(editor.Body.String(), `data-editor-action="slides"`) {
t.Fatal("preview action missing")
}
// A missing or unauthorized semantic path is not exposed via the new view.
req := httptest.NewRequest("GET", "http://localhost/v/slides/deck", nil)
denied := httptest.NewRecorder()
s.withAuthorization(s.mux).ServeHTTP(denied, req)
if denied.Code == 200 || strings.Contains(denied.Body.String(), "First slide") {
t.Fatal("anonymous private content exposed")
}
if configRequest(s, token, "GET", "/v/slides/missing", nil).Code != 404 {
t.Fatal("missing deck")
}
if p := policyForRequest(httptest.NewRequest("GET", "/v/slides/deck", nil)); p.Resolver != resolveViewPath || p.Capability != "read" {
t.Fatal("wrong policy")
}
if semanticViewPath("/v/slides/deck") != "/deck" {
t.Fatal("wrong target")
}
save("# Markdown\n\n---\n\n## Second", "text/markdown")
if w = configRequest(s, token, "GET", "/v/slides/deck", nil); w.Code != 200 || !strings.Contains(w.Body.String(), "&lt;hr") {
t.Fatal("markdown projection", w.Code)
}
save("%PDF-synthetic", "application/pdf")
if configRequest(s, token, "GET", "/v/slides/deck", nil).Code != 415 {
t.Fatal("binary accepted")
}
save(strings.Repeat("x", maxSlideSourceBytes+1), "text/html")
if configRequest(s, token, "GET", "/v/slides/deck", nil).Code != 413 {
t.Fatal("oversize accepted")
}
save(slideFixture, "text/html")
if err = s.setSystemExtensionEnabled(domain, "viewer.slides", false); err != nil {
t.Fatal(err)
}
if configRequest(s, token, "GET", "/v/slides/deck", nil).Code != 404 {
t.Fatal("disabled viewer active")
}
editor = configRequest(s, token, "GET", "/e/-/deck", nil)
if strings.Contains(editor.Body.String(), `data-editor-action="slides"`) {
t.Fatal("disabled preview action")
}
}
func TestSlidesChromium(t *testing.T) {
if os.Getenv("PAGESWIKI_BROWSER_TEST") != "1" {
t.Skip("opt-in Chromium")
}
for _, mode := range []string{"viewer", "editor"} {
for _, width := range []string{"1280", "390"} {
t.Run(mode+width, func(t *testing.T) {
s, token, domain, _ := editorFixture(t)
routes.RegisterUIRoutes(s.mux, routes.UIHandlers{Slides: s.handleSlides})
object, err := s.store.CreatePageAtPathInDomain(domain, "/deck")
if err != nil {
t.Fatal(err)
}
if _, err = s.store.SaveRevisionContent(object, []byte(slideFixture), "", "und", "text/html", ""); err != nil {
t.Fatal(err)
}
script, err := os.ReadFile("internal/server/testdata/slides.js")
if err != nil {
t.Fatal(err)
}
route := "/v/slides/deck"
if mode == "editor" {
route = "/e/-/deck"
}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
r.Host = "localhost"
r.Header.Set("Authorization", "Bearer "+token)
if r.URL.Path == route {
rec := httptest.NewRecorder()
s.withAuthorization(s.mux).ServeHTTP(rec, r)
for k, v := range rec.Header() {
w.Header()[k] = v
}
w.WriteHeader(rec.Code)
_, policy, _ := strings.Cut(rec.Header().Get("Content-Security-Policy"), "'nonce-")
nonce, _, _ := strings.Cut(policy, "'")
w.Write([]byte(strings.Replace(rec.Body.String(), "</body>", `<script nonce="`+html.EscapeString(nonce)+`">`+string(script)+"</script></body>", 1)))
return
}
s.withAuthorization(s.mux).ServeHTTP(w, r)
}))
defer server.Close()
ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
defer cancel()
cmd := exec.CommandContext(ctx, "node", "internal/server/testdata/vim-browser-smoke.mjs", server.URL+route, t.TempDir(), "/tmp/pageswiki-slides-"+mode+width+".png", width, "850")
cmd.Env = append(os.Environ(), "PAGESWIKI_SLIDES_BROWSER=1")
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatalf("browser %v: %s", err, out)
}
})
}
}
}
+3 -2
View File
@@ -36,8 +36,9 @@ func (c *smtpLimitedConn) Read(buffer []byte) (int, error) {
}
type magicLinkChallenge struct {
Return string `json:"return"`
Email string `json:"email"`
Return string `json:"return"`
Email string `json:"email"`
Remember bool `json:"remember,omitempty"`
}
func smtpMailbox(value string) (*mail.Address, error) {
@@ -0,0 +1,226 @@
package server
import (
"context"
"encoding/json"
"fmt"
"strings"
"sync"
"testing"
"github.com/google/uuid"
"pageswiki/internal/store"
)
func TestTaskCaptureDeletedRecreation(t *testing.T) {
for _, wiki := range []bool{false, true} {
t.Run(fmt.Sprint(wiki), func(t *testing.T) {
s, token, domain, actor := taskFixture(t)
ctx := context.Background()
id := uuid.NewString()
input := map[string]any{"request_id": id, "title": "Original"}
if wiki {
input["wiki_body"], input["wiki_prefix"] = "Original private body", "/mail"
}
w := taskRequest(s, token, "POST", "capture", input, "")
if w.Code != 201 {
t.Fatal(w.Code, w.Body)
}
var result struct {
Item store.TaskRecord `json:"item"`
Path string `json:"page_path"`
}
if err := json.Unmarshal(w.Body.Bytes(), &result); err != nil {
t.Fatal(err)
}
page, path := result.Item.PageUUID, result.Path
var revision string
if wiki {
r, err := s.store.GetLatestRevision(page)
if err != nil {
t.Fatal(err)
}
revision = r.UUID
}
if w = taskRequest(s, token, "DELETE", "items/"+id, nil, `"1"`); w.Code != 204 {
t.Fatal(w.Code, w.Body)
}
if w = taskRequest(s, token, "GET", "items/"+id, nil, ""); w.Code != 404 {
t.Fatal(w.Code, w.Body)
}
for _, title := range []string{"Original", "Changed"} {
input["title"] = title
if w = taskRequest(s, token, "POST", "capture", input, ""); w.Code != 410 || !strings.Contains(w.Body.String(), `"deleted"`) {
t.Fatal(w.Code, w.Body)
}
}
input["replaces_deleted"], input["request_id"] = id, store.TaskRecreationID(id)
if wiki {
input["wiki_body"] = "Must not overwrite the retained page"
for _, invalidBody := range []string{"bad\x00body", strings.Repeat("x", 256<<10+1)} {
input["wiki_body"] = invalidBody
if w = taskRequest(s, token, "POST", "capture", input, ""); w.Code != 422 {
t.Fatal("reused page bypassed body validation", w.Code, w.Body)
}
}
input["wiki_body"] = "Must not overwrite the retained page"
}
// A lost successful response, including concurrent retries, creates one
// successor. It neither revives the original nor revises the Wiki.
var wg sync.WaitGroup
for i := 0; i < 4; i++ {
wg.Add(1)
go func() {
defer wg.Done()
v := taskRequest(s, token, "POST", "capture", input, "")
if v.Code != 201 {
t.Errorf("concurrent recreation: %d %s", v.Code, v.Body)
}
}()
}
wg.Wait()
w = taskRequest(s, token, "POST", "capture", input, "")
if w.Code != 201 {
t.Fatal(w.Code, w.Body)
}
if err := json.Unmarshal(w.Body.Bytes(), &result); err != nil {
t.Fatal(err)
}
if result.Item.UUID != store.TaskRecreationID(id) || result.Item.UUID == id || result.Item.Title != "Changed" || result.Item.Version != 1 || result.Item.PageUUID != page || result.Path != path {
t.Fatal(result)
}
if wiki {
r, err := s.store.GetLatestRevision(page)
if err != nil || r.UUID != revision || !strings.Contains(r.Body, "Original private body") {
t.Fatal("Wiki changed", r, err)
}
}
for table, expected := range map[string]int{"organizer_items": 1, "organizer_capture_receipts": 2, "organizer_task_deletions": 1, "organizer_revisions": 1} {
var count int
if err := s.store.DB.QueryRow("SELECT count(*) FROM " + table).Scan(&count); err != nil || count != expected {
t.Fatal(table, count, err)
}
}
if _, err := s.store.SaveTask(ctx, domain, actor, store.TaskRecord{UUID: id, Kind: "task", Title: "Offline resurrection", Status: "todo", Bucket: "inbox", Priority: 1}, 0); err != store.ErrTaskDeleted {
t.Fatal("old UUID revived", err)
}
input["title"] = "Different committed recovery"
if w = taskRequest(s, token, "POST", "capture", input, ""); w.Code != 412 {
t.Fatal(w.Code, w.Body)
}
// Deleting the successor cannot be undone by replaying the recovery.
if w = taskRequest(s, token, "DELETE", "items/"+result.Item.UUID, nil, `"1"`); w.Code != 204 {
t.Fatal(w.Code, w.Body)
}
if w = taskRequest(s, token, "POST", "capture", input, ""); w.Code != 410 {
t.Fatal(w.Code, w.Body)
}
})
}
}
func TestTaskCaptureRecreationGuards(t *testing.T) {
s, token, domain, actor := taskFixture(t)
id := uuid.NewString()
input := map[string]any{"request_id": id, "title": "Original"}
if w := taskRequest(s, token, "POST", "capture", input, ""); w.Code != 201 {
t.Fatal(w.Code, w.Body)
}
recreate := map[string]any{"request_id": store.TaskRecreationID(id), "replaces_deleted": id, "title": "New"}
if w := taskRequest(s, token, "POST", "capture", recreate, ""); w.Code != 412 {
t.Fatal("live capture replaced", w.Code, w.Body)
}
if w := taskRequest(s, token, "DELETE", "items/"+id, nil, `"1"`); w.Code != 204 {
t.Fatal(w.Code, w.Body)
}
other, err := s.store.CreatePasswordAccount(domain, "recreateother", "long fixture password", "Other", "")
if err != nil {
t.Fatal(err)
}
otherToken, err := s.store.CreateAuthSession(domain, other.UUID)
if err != nil {
t.Fatal(err)
}
if w := taskRequest(s, otherToken, "POST", "capture", recreate, ""); w.Code != 404 {
t.Fatal("other owner", w.Code, w.Body)
}
if _, err := s.store.RecreateCapturedTask(context.Background(), "other-domain", actor, store.TaskRecreationID(id), "hash", newTaskRecord("task", "Wrong domain"), "", "", id); err != store.ErrAccessDenied {
t.Fatal("wrong domain", err)
}
if err := s.store.SetPrincipalState(domain, actor, "readonly"); err != nil {
t.Fatal(err)
}
if _, err := s.store.RecreateCapturedTask(context.Background(), domain, actor, store.TaskRecreationID(id), "hash", newTaskRecord("task", "Readonly"), "", "", id); err != store.ErrAccessDenied {
t.Fatal("readonly", err)
}
if err := s.store.SetPrincipalState(domain, actor, "active"); err != nil {
t.Fatal(err)
}
token, err = s.store.CreateAuthSession(domain, actor)
if err != nil {
t.Fatal(err)
}
if err := s.store.SetConfigInDomain(domain, "system_extension_states", `{"organizer.tasks":false}`); err != nil {
t.Fatal(err)
}
if _, err := s.store.RecreateCapturedTask(context.Background(), domain, actor, store.TaskRecreationID(id), "hash", newTaskRecord("task", "Disabled"), "", "", id); err != store.ErrAccessDenied {
t.Fatal("extension disabled", err)
}
if err := s.store.SetConfigInDomain(domain, "system_extension_states", `{"organizer.tasks":true}`); err != nil {
t.Fatal(err)
}
for _, invalid := range []string{uuid.NewString(), id, "not-an-id"} {
recreate["request_id"] = invalid
if w := taskRequest(s, token, "POST", "capture", recreate, ""); w.Code != 422 {
t.Fatal("arbitrary recovery ID", w.Code, w.Body)
}
}
recreate["request_id"] = store.TaskRecreationID(id)
// Failure during receipt insertion rolls back the task, page and journals.
if _, err := s.store.DB.Exec(`CREATE TRIGGER reject_recreation BEFORE INSERT ON organizer_capture_receipts BEGIN SELECT RAISE(ABORT,'fixture rejection'); END`); err != nil {
t.Fatal(err)
}
recreate["wiki_body"], recreate["wiki_prefix"] = "New body", "/recreated"
if w := taskRequest(s, token, "POST", "capture", recreate, ""); w.Code != 500 {
t.Fatal(w.Code, w.Body)
}
var count int
if err := s.store.DB.QueryRow(`SELECT count(*) FROM organizer_items`).Scan(&count); err != nil || count != 0 {
t.Fatal("orphan task", count, err)
}
if err := s.store.DB.QueryRow(`SELECT count(*) FROM paths WHERE path LIKE '/recreated/%'`).Scan(&count); err != nil || count != 0 {
t.Fatal("orphan page", count, err)
}
if _, err := s.store.DB.Exec(`DROP TRIGGER reject_recreation`); err != nil {
t.Fatal(err)
}
if w := taskRequest(s, token, "POST", "capture", recreate, ""); w.Code != 201 {
t.Fatal(w.Code, w.Body)
}
if _, err := s.store.GetTask(context.Background(), domain, actor, store.TaskRecreationID(id)); err != nil {
t.Fatal(err)
}
}
func TestTaskCaptureOrphanReceipt(t *testing.T) {
s, token, domain, actor := taskFixture(t)
id := uuid.NewString()
input := map[string]any{"request_id": id, "title": "Original"}
if w := taskRequest(s, token, "POST", "capture", input, ""); w.Code != 201 {
t.Fatal(w.Code, w.Body)
}
// Simulate preexisting corruption, not a supported user deletion operation.
if _, err := s.store.DB.Exec(`DELETE FROM organizer_items WHERE domain_uuid=? AND owner_uuid=? AND uuid=?`, domain, actor, id); err != nil {
t.Fatal(err)
}
for _, title := range []string{"Original", "Changed"} {
input["title"] = title
if w := taskRequest(s, token, "POST", "capture", input, ""); w.Code != 409 || !strings.Contains(w.Body.String(), "capture_missing") {
t.Fatal(w.Code, w.Body)
}
}
input["request_id"], input["replaces_deleted"] = store.TaskRecreationID(id), id
if w := taskRequest(s, token, "POST", "capture", input, ""); w.Code != 409 || !strings.Contains(w.Body.String(), "capture_missing") {
t.Fatal(w.Code, w.Body)
}
}
Loaded 100 of 209 files, more files were not shown because too many files have changed in this diff. Show more