From bc1f0b11a23300ef3213c4628ad12b9e9b701975 Mon Sep 17 00:00:00 2001 From: Dico Date: Tue, 13 Oct 2026 15:24:30 +0900 Subject: [PATCH 01/24] =?UTF-8?q?docs(design):=20kc=20sync=20=EC=84=A4?= =?UTF-8?q?=EA=B3=84=20=EC=B4=88=EC=95=88=20v0.3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 페어링한 기기끼리 고른 항목을 맞추는 kc sync 의 설계 초안. Opus·codex 설계안을 따로 받아 종합했고, logi(1pass.dev) 재사용 점검과 codex 공격자 관점 리뷰 두 차례를 반영했다. 구현 전 사용자 검토용. Co-Authored-By: Claude Opus 5.5 --- docs/design/sync.md | 251 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 251 insertions(+) create mode 100644 docs/design/sync.md diff --git a/docs/design/sync.md b/docs/design/sync.md new file mode 100644 index 0000000..c9ba44e --- /dev/null +++ b/docs/design/sync.md @@ -0,0 +1,251 @@ +# `kc sync` 설계 (초안 v0.3, 2026-10-13) + +상태: 사용자 검토 대기. 구현 전. +근거: Opus 설계안과 codex(gpt-6-astra) 설계안을 서로 보여 주지 않고 따로 받아 종합했다(v0.1). 이후 logi(1pass.dev) 레포 점검 결과와 codex 공격자 관점 리뷰(P1 9건·P2 6건)를 반영했다(v0.2). v0.2 재리뷰의 새 P1 4건과 부분 해결 항목을 반영했다(v0.3). + +## 0. 확정된 사용자 결정 + +| 결정 | 내용 | +|---|---| +| D1 | kc 에 `sync` 기능을 만든다(일회성 이동이 아니라 상시 동기화) | +| D2 | 동기화 대상은 사람이 목록에서 고른다. 기본은 아무것도 동기화하지 않는다 | +| D3 | 중요한 작업은 사람 승인이 필요하다. 승인 창구는 1pass.dev(logi)다 | +| D4 | 1pass.dev 는 승인을 **전달만** 한다. 승인의 증거는 서명이고, 각 kc 기기가 직접 검증한다 | +| D5 | logi 가 보류해 둔 "기기 서명 영수증"(내용에 묶인 기기 서명)을 kc 를 계기로 시작한다 | +| D6 | logi 에는 kc 전용 승인 도메인을 새로 만든다(관례 D2). 부품은 에이전트 승인 게이트에서 가져온다 | +| D7 | TOTP 는 kc 승인 경로에 넣지 않는다. 1pass.dev 계정 로그인 2단계 인증으로만 남긴다(logi 소관) | +| D8 | 휴대폰이 없을 때는 FIDO2 보안 키(YubiKey 등)로 승인한다. 서버 없이 kc 가 직접 검증한다 | + +v0.2 에서 바뀐 큰 결정(사용자 확인 필요): +- **휴대폰 승인 서명을 패스키에서 logi 앱의 기기 고정 키로 바꾼다**(§3.4). logi 패스키는 여러 기기에 동기화되고 RP ID 를 웹과 공유해서, 장악된 1pass.dev 가 "로그인" 화면으로 위장해 승인 서명을 받아 낼 수 있다. + +## 1. 요약 + +- 기존 "기억된 기기" 인박스 위에 얹는다. **중계 서버(kc-relay)는 바꾸지 않는다.** +- 항목마다 직접 넣는(opt-in) 동기화다. 다른 기기가 보낸 새 항목도 **받는 기기에서 사람이 확인해야** 대상이 된다. +- 기존 값을 덮어쓰는 원격 변경은 **사람 승인 서명이 붙어 있고, 그 서명이 지금 내 값을 정확히 대체한다고 적고 있을 때만** 자동 적용한다. 그 밖에는 보류하거나 충돌로 둔다. +- 값 삭제는 다른 기기로 전파하지 않는다. 충돌은 자동으로 풀지 않고 모든 후보 값을 보존한다. +- 원격 덮어쓰기 전에 **복구 기준점**(사람이 마지막으로 확인한 값)을 따로 보존한다. 사람이 확인하기 전에는 지워지지 않는다. + +## 2. 동기화 모델 + +### 2.1 동기화 대상(sync set) +- 대상 목록은 기기마다 따로 둔다(`sync.json`). 목록 자체는 동기화하지 않는다. +- `kc sync add NAME`(L) 은 이 기기의 대상에 넣고, 다른 기기에는 **제안**을 보낸다. 받는 쪽은 값이 같든 다르든, 그 이름이 있든 없든 **제안함에만** 넣는다. `kc sync review`(L)에서 받아들여야 대상이 되고 값이 쓰인다. + - v0.1 은 "없으면 자동 생성·같으면 자동 가입"이었다. 공격 기기가 자기가 아는 값으로 등록시킨 뒤 피해 기기가 나중에 바꾼 비밀을 받아 가는 경로가 되어 없앴다(codex P1-1). +- 받아들일 때 그 이름을 **어느 기기들과** 동기화할지(기기별 범위)를 함께 정한다. 기본은 제안을 보낸 기기 하나다. +- `kc sync rm NAME` 뒤에는 그 이름의 **등록 세대**를 올린다. 이전 세대로 온 늦은 제안·변경은 무시한다(지연된 add 로 다시 등록되는 것을 막음). +- `kc sync add --from-keychain` 은 OS 키체인 항목 목록(서비스·계정 이름만, 값은 읽지 않음)을 체크리스트로 보여 주고, 고른 것만 `adopt` 해서 대상에 넣는다. 대화형으로만 한다. +- 200 KiB 를 넘는 항목은 대상에 넣지 않는다. 메시지는 **실제 직렬화 크기**로 묶어 256 KiB 를 넘지 않게 한다. 큰 항목 분할 전송은 나중 단계(§8 Phase 4). + +### 2.2 버전과 순서 +- 항목 상태 = `{head: vid(16바이트 무작위), lineage(최근 vid 64개), vid별 값 지문}`. 값 지문 = `HMAC(sys:sync-key, 이름‖종류‖값)` 이고 키는 이 기기 키체인에만 있다. 지문은 값이 같은지 비교하는 데만 쓰고 밖으로 보내지 않는다. +- **vid 는 불변이다.** 같은 vid 로 다른 값이 오면 프로토콜 위반으로 보고, 그 기기에서 온 해당 항목의 흐름을 격리한다(codex P2-10). +- 원격 변경 판정(순수 함수 `decide`): + 1. 받은 vid = 내 head → 무시(값 지문이 다르면 위반) + 2. 받은 vid 가 내 lineage 에 있음 → 낡은 변경, 무시 + 3. **승인 서명이 "parent = 내 head" 를 정확히 적고 있음** → 앞으로 감기. 한도 검사 뒤 적용 + 4. 값이 같음(지문 일치) → 수렴. 두 기기 모두 `head = max(vid_a, vid_b)`, lineage 는 합집합으로 같은 결과를 낸다. 쓰기는 없다 + 5. 그 밖 → 충돌 +- v0.1 은 보낸 쪽이 주장하는 lineage 만 보고 앞으로 감기를 허용했다. 뚫린 기기가 lineage 에 내 head 를 끼워 넣으면 충돌이 덮어쓰기로 바뀐다(codex P1-4). v0.2 에서는 **승인 서명에 묶인 parent 만** 믿고, lineage 는 낡은 변경을 거르는 데만 쓴다. 승인이 없거나 parent 가 내 head 와 다르면 충돌 또는 보류다. +- 기각한 방식: 시각 기준 마지막 쓰기 우선(시계 조작에 약함), 버전 벡터(codex v0.1 안; 빠진 이력을 원작자에게 받아 와야 해서 복잡함). + +### 2.3 로컬 쓰기와 원격 적용의 경쟁 +- 모든 쓰기(로컬 `kc set`·`restore`·`adopt`, 원격 적용, 충돌 해결)는 **같은 잠금(items)** 안에서 한다. 잠금 순서: `items` → `sync.json` → `seen.json`. +- 원격 적용 직전, 잠금 안에서 현재 값 지문과 head 를 **다시 확인**한다. 스캔 뒤 다른 프로세스가 `kc set` 을 했으면 원격 변경은 충돌로 바뀐다(codex P1-6). +- 쓰기 순서: ① 의도 기록(journal) → ② 키체인 쓰기 → ③ `sync.json`(head·lineage·큐·승인 소비) 갱신 → ④ journal 정리. 시작할 때 남은 journal 이 있으면 현재 값 지문으로 ②가 끝났는지 판정해 ③을 마저 하거나 되돌린다. 기존 인박스 journal(`crates/kc-cli/src/commands/inbox.rs:157`)을 확장한다. +- 한계(문서에 명시): kc 밖에서 키체인 값을 `A→B→A` 로 바꾸고 그 사이에 sync 가 돌지 않으면 감지하지 못한다. + +### 2.4 충돌 +- 모든 후보 값(2개 이상일 수 있음)을 내부 슬롯에 보존한다. 그 항목은 **일반 변경 적용만** 멈추고, 해결(resolve) 메시지와 다른 기기의 충돌 후보는 계속 받는다(codex P2-11). +- `kc sync status` 는 값 대신 지문과 기기 이름을 보여 준다. +- `kc sync resolve NAME --keep mine|LABEL`(L + A): 결과는 새 vid 이고 승인 서명의 parent 목록에 **알려진 모든 후보 head** 를 적는다. 받는 쪽은 **자기가 알고 있는 모든 미해결 후보 head(자기 head 포함)가 그 목록에 다 들어 있을 때만** 받아들인다. 하나라도 빠졌으면 충돌로 남긴다(v0.2 재리뷰 P1). 해결 메시지를 적용하는 일은 원자적이다. +- lineage 합집합이 64개를 넘으면 오래된 것부터 자른다. 잘림 순서는 각 vid 를 처음 본 시각이 아니라 **vid 값 오름차순**으로 정해 모든 기기가 같은 결과를 낸다. +- vid 의 parent 도 불변이다. 같은 vid 로 다른 parent 를 주장하면 위반이다. + +### 2.5 삭제 +- 동기화 대상에 `kc rm` 을 하면 거부한다("`kc sync rm NAME` 먼저"). +- `kc sync rm NAME` 은 이 기기의 대상에서만 빼고 등록 세대를 올린다. +- `kc sync rm NAME --everywhere`(A+) 는 다른 기기에서도 대상에서만 빼고 **값은 남긴다**. +- 값 삭제 전파는 지원하지 않는다. + +### 2.6 복구 기준점 +- v0.1 의 "`#prev` 에 항상 공격 전 값이 남는다"는 틀렸다. `#prev` 는 한 단계뿐이라 24시간 간격의 두 번 덮어쓰기면 원래 값이 사라진다(codex P1-9). +- 원격 덮어쓰기를 처음 적용하기 전에 그때 값을 **복구 기준점** 슬롯(`sync/kg/<이름 해시>`)에 복사한다. 이후 원격 덮어쓰기는 이 슬롯을 바꾸지 않는다. +- 사람이 `kc sync status` 나 `review` 에서 "현재 값 확인"(L)을 하면 그 값이 새 기준점이 된다. `kc sync restore-checkpoint NAME` 으로 되돌린다. +- 보류·충돌·기준점·보낼 값 스냅샷 슬롯의 총량에 상한을 둔다(기본 대상 항목 수 × 4). 기준점 슬롯은 **원격 쓰기 전에 먼저 확보**한다. 확보하지 못하면 원격 변경을 적용하지 않고 보류한다. 상한에 닿으면 새 제안·보류를 받지 않고 status 에 표시한다. + +### 2.7 실행 시점 +1. `kc sync`: 로컬 스캔 → 인박스 받기·적용 → 보낼 것 보내기 → 요약(digest) 교환 +2. `kc set`·`restore`·`adopt` 직후: 대상 항목이면 바로 보내기를 시도하고, 실패하면 큐에 남긴다. +3. `kc sync install [--every 15m]`: macOS LaunchAgent(서명된 릴리스 바이너리 경로 고정) / Linux systemd `--user` 타이머 / Windows 작업 스케줄러 "로그온한 경우에만"(로그온 없는 모드 금지). +- 상주 long-poll 은 하지 않는다(15분 주기 = 시간당 4회, 같은 IP 시간당 120회 한도에 여유). + +### 2.8 전달 확인과 재동기화 +- 받는 기기는 변경을 적용(또는 보류·충돌로 기록)하고 **저장이 끝난 뒤에만** 영수증(ACK)을 보낸 기기에 돌려준다. 이미 처리한 변경이 다시 오면 ACK 만 다시 보낸다(ACK 유실 대비). 보낸 기기는 그 기기의 ACK 를 받을 때까지 그 변경을 큐에 둔다(codex P2-12). +- 보낸 기기는 ACK 를 기다리는 동안 보낸 값 스냅샷을 키체인 내부 슬롯에 보관한다. 그 사이 새 로컬 변경이 생기면 새 변경이 이전 것을 대체하고, 받는 쪽이 중간 변경을 건너뛰어도 parent 가 맞지 않으면 충돌·digest 재요청으로 이어진다. +- 하루 한 번 digest 로 서로의 head 를 비교하고, 상대가 뒤처졌으면 최신 값을 **새 승인과 함께** 다시 보낸다(옛 승인은 만료됐을 수 있음). +- 인박스 메시지가 72시간 만료로 사라졌거나, 30일 미접속으로 인박스가 사라졌으면 다음 sync 에서 digest 로 감지해 다시 보낸다. 인박스 재연결이 필요하면 status 에 표시한다. +- 각 기기는 **자기 변경만** 보낸다(남의 변경을 중계하지 않음). 그래서 변경을 만든 기기가 영영 사라지면, 그 변경을 받지 못한 기기는 사람이 남은 사본을 새 변경으로 다시 보내야 한다. 이 한계를 status 에 표시한다. + +## 3. 사람 승인 + +### 3.1 두 층 +| 층 | 수단 | 막는 것 | +|---|---|---| +| L: 로컬 확인 | Touch ID · Windows Hello · Linux polkit | 같은 기기에서 kc 를 부르는 **에이전트**(터미널 판별은 PTY 로 우회되지만 지문은 우회 못 한다) | +| A: 서명 승인 | logi 앱 기기 고정 키 · FIDO2 보안 키 | **뚫린 기기 한 대**. 다른 기기들이 서명을 직접 검증한다 | +| A+: 강한 서명 승인 | **logi 앱 기기 고정 키만** (자체 화면에서 문서를 보여 주고 서명) | 신뢰 루트를 바꾸거나 여러 기기에 영향이 큰 작업 | + +- 일반 FIDO2 보안 키는 **A 등급까지만** 인정한다. 보안 키에는 자체 화면이 없어, 뚫린 컴퓨터가 다른 문서를 서명시켜도 사용자가 알 수 없다(v0.2 재리뷰 P1). A+ 작업은 휴대폰 승인을 기다린다. +- 기기 하드웨어 키(device-uv, v0.1 의 A 수단)는 **기본으로 쓰지 않는다**(codex P1-7). 어떤 키가 정말 하드웨어에 묶여 매번 생체 인증을 거치는지 받는 기기가 검증할 방법(키 증명)을 명세하기 전까지는, 소프트웨어 키를 등록한 뚫린 기기가 승인을 스스로 만들어 낼 수 있다. 나중 단계에서 키 증명과 함께 다시 검토한다. + +### 3.2 작업별 요구 수준 +| 작업 | 보내는 기기 | 받는 기기 | +|---|---|---| +| `sync add`·`rm`(이 기기만), `sync peer add`·`rm` | L | — | +| 받은 제안 받아들이기(`review`) | — | L | +| **기존 값 덮어쓰기**(set 뒤 sync, resolve) | A 요청 | **A**(parent 일치), 없으면 보류 | +| `sync rm --everywhere` | A+ 요청 | **A+**, 없으면 보류 | +| 보류분 직접 승인(`review`), `unfreeze`, 기준점 확인 | — | L | +| 새 기기 페어링 | L(양쪽) + 기존 코드·확인 단어 | — | +| `device rotate`, `sync install`, `approver enroll` | L | — | +| 승인자 추가 | L + 기존 승인자의 A+ | 각 기기에서 L 로 지문 확인 후 고정 | +| 승인자 제거 | L | — (마지막 승인자를 지우면 덮어쓰기는 전부 보류. 새 등록은 각 기기 L 확인 필요) | + +**기존 명령도 같은 규칙을 따른다**(codex P1-8). 동기화 대상 항목을 `kc inbox --on-conflict overwrite`·`kc receive`·v1 인박스 메시지로 덮어쓰려 하면 sync 정책으로 보낸다. 승인 서명이 없으면 L 이 필요하고, 비대화형이면 보류한다. + +에이전트는 L·A·A+ 어느 것도 통과하지 못한다. 할 수 있는 최대치는 승인 요청을 올리는 것과 제안을 보내는 것이다. + +### 3.3 승인 문서 +서명 대상은 `SHA-256("kc1 approval" ‖ 작업 종류 ‖ 문서)` 이다. **작업마다 구조체를 따로 둔다**(codex P1-3). +```text +ValueChange { v, origin_fp, doc_id(16바이트 무작위), created_at, expires_at(≤7일), agent_origin, + entries: [{ name, kind, new_vid, parents: [vid…], targets: [{ target_fp, generation, c }] }] } + c = HMAC(HKDF(X25519(origin_sk, target_pk), "kc1 commit"), name ‖ kind ‖ new_vid ‖ generation ‖ 값)[..16] +Retire { v, origin_fp, doc_id, created_at, expires_at, entries: [{ name, head_vid, generation }], + targets: [fp…] } +ApproverAdd { v, origin_fp, doc_id, created_at, expires_at, + new_approver: { kind, sign_public_key, enc_public_key?, key_id, platform }, + policy: { grade: A|A+, accept_for: [작업 종류…] }, approver_generation } +``` +- 받는 기기마다 **그 기기의 등록 세대(generation)** 까지 묶는다. 제거·재등록 뒤에는 아직 쓰지 않은 옛 승인이 새 세대로 둔갑하지 못한다(v0.2 재리뷰 P1). +- 값과 parent 까지 묶는다: 승인 뒤 보내는 기기가 값만 바꾸거나, 다른 head 를 대체하는 변경으로 쓰지 못한다. 커밋 키는 기존 기기 키로 기기 쌍마다 만든다. 1pass.dev 는 c 를 계산하거나 값을 맞춰 볼 수 없다. +- 짧은 코드: 문서 해시 앞 4바이트를 단어 4개로 바꿔 터미널과 휴대폰에 함께 보여 준다. +- 한 번의 sync 에서 대기 중인 변경을 문서 하나로 묶는다(승인 피로 감소). + +**받는 기기의 검증**: 보낸 기기와 `origin_fp` 일치 → 자기 몫 `c` 재계산 일치 → 항목·parent·종류 일치 → 유효 기간 확인 → 서명 검증 → 서명 수단이 작업 등급에 맞는지 확인. + +**문서 고정**: `doc_id` 는 처음 본 문서 해시에 고정된다. 같은 `doc_id` 로 다른 문서가 오면 위반이다. 한 문서 안에서 같은 이름이 두 번 나오면 문서 전체를 거부한다. + +**승인 소비**(codex P1-5): `(doc_id, 항목, 받는 기기)` 단위로 적용 기록을 남긴다. 한 문서의 항목 일부만 적용된 상태를 허용하고, 다시 시도할 때 남은 항목만 적용한다. 순서가 뒤바뀌어 도착한 승인도 받아들인다(최고 seq 하나만 기억하는 방식은 쓰지 않음). 거절·폐기한 문서는 만료 시각까지 기록해 둔다. + +### 3.4 휴대폰 승인: logi 앱의 기기 고정 키 +- **왜 패스키가 아닌가**(codex P1-2): logi 패스키는 RP ID `api.1pass.dev` 를 웹과 공유하고 여러 기기에 동기화된다(BE=1). 장악된 1pass.dev 는 웹 페이지나 앱의 로그인 응답에 kc 승인 해시를 challenge 로 넣어, 사용자가 "로그인"이라고 생각하고 생체 인증을 하게 만들 수 있다(로그인 경로는 서버 옵션을 그대로 서명 함수에 넘긴다, `toy/logi/Packages/LogiCore/Sources/LogiCore/Auth/SessionStore.swift:372`). 서명할 credential 을 고르는 `allowCredentials` 도 서버가 정한다. WebAuthn 생체 인증은 "사람이 있다"를 증명할 뿐 "이 내용을 봤다"를 증명하지 않는다. +- **대신**: logi 앱이 kc 승인 전용 키 쌍을 기기 안에서 만든다. + - iOS: Secure Enclave P-256, 접근 제어 `biometryCurrentSet`, 동기화·내보내기 불가. 이미 있는 `DpopSigner`(Secure Enclave 서명)를 본뜬다. + - Android: StrongBox(없으면 TEE) Keystore 키, 사용자 인증 필요. + - **서명할 때마다** 생체 인증을 요구한다(재사용 창 없음). 하드웨어 키를 만들 수 없는 기기에서는 등록을 거부한다(소프트웨어 키로 내려가지 않음). + - 기존 DPoP 서명 코드는 그대로 쓰지 않는다. iOS 는 생체 게이트 없이 소프트웨어 폴백을 허용하고(`toy/logi/Packages/LogiCore/Sources/LogiCore/Auth/DpopSigner.swift:143`), Android 는 사용자 인증을 끈다(`toy/logi/android/core/data/src/main/java/com/dcodelabs/logi/core/data/DpopSigner.kt:99`). 키 생성 방식만 참고한다. + - 이 키는 **앱의 kc 승인 화면에서만** 쓴다. 웹은 닿을 수 없고, 앱의 다른 화면(로그인 등)은 이 키를 쓰는 코드 경로가 없다. + - 앱이 승인 문서를 **직접 해석해서 화면에 그리고**, 그 문서의 해시에 서명한다. 서버가 보낸 표시 문구는 쓰지 않는다. +- **이름도 숨긴다**: 앱 키 쌍과 함께 암호화용 키(X25519)도 만든다. kc 는 승인 문서를 이 키로 암호화해 보내므로 1pass.dev 는 암호문과 짧은 코드만 본다(codex P2-15 의 이름 노출 문제 해결). `approval_display = "counts"` 설정은 필요 없어진다. +- **키 고정**: `kc approver enroll` 때 앱 공개키 두 개(서명·암호화)를 **함께** kc 가 받아 지문을 단어 4개로 보여 주고, 앱 화면에도 같은 단어를 띄운다. 각 kc 기기에서 사람이 대조해야 고정된다(L). +- **키 증명(선택)**: iOS App Attest·Android Key Attestation 으로 "정품 logi 앱의 하드웨어 키"임을 확인할 수 있다. 1단계에서는 지문 대조만 하고, 키 증명은 열린 문제로 둔다. +- 휴대폰 분실: 다른 기기에서 `kc approver rm`(L) 후 새 휴대폰으로 다시 등록한다. 키가 동기화되지 않으므로 새 휴대폰은 새 키다. + +### 3.5 FIDO2 보안 키(D8) +- libfido2(macOS·Linux)·`webauthn.dll`(Windows)로 kc 가 직접 서명을 받는다. 서버가 필요 없다. +- RP ID 는 **웹 도메인이 아닌 문자열**(`kc-approval`)을 쓴다. 브라우저는 자기 도메인이 아닌 RP ID 를 요청할 수 없으므로, 웹 페이지가 이 credential 로 서명을 받아 낼 수 없다. +- 받는 기기는 등록 때 고정한 공개키로 type·challenge·rpIdHash·UP·UV·알고리즘을 모두 검증한다. origin 은 kc 가 만든 고정 값과 비교한다. +- 한계: 꽂혀 있는 키를 악성 코드가 사용자를 속여 터치하게 만들 수 있다. 짧은 코드 대조가 완화책이다. + +### 3.6 1pass.dev(logi)에 새로 필요한 것 +logi 점검 결과(`scratchpad/logi-survey.md`)를 근거로, kc 전용 승인 도메인(D6)에 다음을 둔다. +1. kc 기기 연결: CLI 기기 코드 로그인을 그대로 쓴다. 이후 요청 인증은 **kc 가 직접 만든 Ed25519 키의 공개키만 등록**하는 새 API 로 한다. 기존 `AgentRegistration` 은 서버가 개인키를 만들어 내려주므로(`toy/logi/server/app/models/agent_registration.rb:234`) 그대로 쓰지 않는다(codex P2-14). 발급·교체·폐기 API 가 필요하다. +2. 승인자 등록: logi 앱이 기기 고정 키 쌍을 만들고 공개키를 kc 에 전달하는 흐름. 서버는 공개키를 **가공 없이** 중계한다. +3. 승인 요청: kc 가 올린 암호문·짧은 코드·만료 시각을 저장하고 앱에 푸시(기존 `PushNotifier`). 앱이 서명을 올리면 kc 가 long-poll 로 가져간다. 서버는 서명을 검증하지 않아도 되고, 검증해도 kc 는 그 결과를 쓰지 않는다. +4. 남용 방어: 에이전트 승인 게이트의 진행 중 요청 억제·거절 쿨다운·차단을 가져다 쓴다. 기기당 대기 요청 3건 상한. +5. 앱: kc 승인 화면(문서 복호화·해석·표시·서명), 키 생성·지문 표시, 승인자 재등록. +- **서버가 저장하는 것**: 계정↔kc 기기 연결(요청 서명 공개키 포함), 승인자 공개키, 승인 요청 암호문(처리 뒤 7일 안에 삭제), 푸시 구독. +- **서버가 볼 수 없는 것**: 값, 항목 이름, 값 지문, 기기 개인키, 인박스 토큰, 커밋 키. +- 패스키 관련 변경(무작위 challenge 대체, 공개키 노출)은 **필요 없어진다.** logi 의 "RP 에 패스키 공개키를 주지 않는다" 결정도 그대로 둔다. +- logi 보류 항목(R6 기기 서명 영수증)은 "패스키 challenge 유도" 대신 "앱 기기 고정 키 서명"으로 시작한다. logi 문서에 이 차이를 남긴다. + +### 3.7 백그라운드·에이전트 실행 +- 대화형 `kc set` 의 변경은 그 자리에서 승인을 요청한다. +- 비대화형 변경은 "승인 대기"로 두고 요청만 올린다. 7일 안에 승인이 없으면 요청만 만료되고 로컬 값은 남는다. +- 받는 기기는 승인이 없으면 보류하고, 승인이 나중에 오면 다시 평가한다. `kc sync review`(L)로 직접 승인할 수도 있다. + +### 3.8 승인 수단을 못 쓸 때 +- 휴대폰이 꺼져 있거나 1pass.dev 에 닿지 못하면 FIDO2 보안 키를 쓴다. 둘 다 없으면 큐에서 기다리고, 받는 기기에서 `review`(L)로 직접 승인할 수 있다. +- 승인자가 하나도 없으면 덮어쓰기는 모두 받는 기기의 `review` 대상이다. 제안·새 항목은 그대로 동작한다. + +## 4. 피해 범위 제한(승인이 있어도 유지) +- 항목별: 비대화형 원격 덮어쓰기는 24시간에 1회. 그 이상은 보류. +- 기기별 차단기: 24시간 안에 덮어쓰기 5건 초과, 또는 retire 3건 초과면 그 기기가 보낸 나머지를 모두 보류한다. "대상의 25% 초과" 조건은 대상이 8개 이상일 때만 쓴다(작은 집합에서 한 항목만 바뀌어도 걸리는 문제, codex P2-15). +- 재전송: 기존 메시지 id 기록과 72시간 만료, lineage 의 낡은 vid 무시, 승인 소비 기록. +- 뚫렸을 때: 다른 기기에서 `kc sync freeze`(비대화형 가능) → 기기마다 `kc peers rm LABEL` → `kc sync restore-checkpoint`. `peers rm` 은 전파하지 않는다. + +## 5. 프로토콜 +- 인박스 **바깥 봉투 버전을 2로** 올린다. v0.2 kc 는 바깥 봉투 버전을 복호화 전에 검사해(`crates/kc-proto/src/inbox.rs:329`) "지원하지 않는 버전"으로 인박스에 남겨 두고 72시간 뒤 만료된다(codex P2-13 확인). +```text +InboxPlain2 { v:2, msg_id, sender_fp, recipient_fp, created_at, expires_at, body } +body = Items(...) | Sync { kind: Hello | Offer | Changes | Ack | Digest | Approvals } +Change { name, generation, new_vid, lineage(≤64), op: Put{value,kind} | Retire, approval_ref? } +``` +- 상대의 v2 지원 여부를 모르면 **Hello 한 통만** 보낸다. Hello 는 기능 목록만 담고 받는 쪽 상태를 바꾸지 않는 무해한 메시지다. v0.2 기기에서는 72시간 뒤 만료되는 낭비 1통으로 끝난다. Hello 응답을 받기 전에는 다른 sync 메시지를 보내지 않고 보류한다(v0.2 재리뷰 P1: 확인 전 금지 규칙이 Hello 까지 막아 교착되던 문제). **sync 변경을 v1 Items 로 낮춰 보내지 않는다.** 일반 `send --to` 는 지금처럼 v1 이다. +- `kc inbox` 와 `kc sync` 는 같은 인박스 처리 루프를 쓰고 내용 종류로 나눈다. +- `docs/PROTOCOL.md` §4(v2)·§6(sync·L/A/A+ 행)·§9(승인자로 일원화)와 `docs/SECURITY.md`(1pass.dev 신뢰 경계, 등록 시점 한계, 원작자 소실 한계)를 함께 고친다. + +## 6. 명령 +```text +kc sync 스캔→받기→보내기. "3 sent, 2 updated, 1 conflict, 1 awaiting approval" +kc sync status [--json] 항목별 상태와 기기별 마지막 요약 +kc sync add [NAMES…] [--peers a,b] [--from-keychain] +kc sync rm NAMES [--everywhere] +kc sync peer add|rm|list LABEL +kc sync review 받은 제안·보류분을 하나씩 받아들이기·거절 +kc sync resolve NAME --keep mine|LABEL +kc sync restore-checkpoint NAME +kc sync approve 대기 중인 승인 요청 상태 확인·재요청 +kc sync freeze | unfreeze +kc sync install [--every 15m] | uninstall +kc approver enroll [--fido2] | list | rm ID +``` +종료 코드: 0 = 완전히 맞음, 8 = 충돌·보류·승인 대기·제안, 4 = 키체인, 5 = 사람 필요, 6 = 중계 서버. + +## 7. 저장 위치 +- `config.toml [sync]`: 사람이 고치는 값만(`interval`, `max_remote_overwrites`, `max_proposals_per_day`, `approver_url`). +- `sync.json`: 기기 상태, 항목별 head·lineage·등록 세대·범위, 보낼 큐와 ACK 상태, 제안·보류·충돌 목록, 승인자 공개키, 승인 소비 기록, journal. **값과 값 지문은 넣지 않는다.** +- 키체인 내부 슬롯: 보류·충돌 후보 값, 복구 기준점, 보낼 값 스냅샷(보낼 때 값이 바뀌지 않게), vid별 값 지문, `sys:sync-key`(지문 HMAC 키), `sys:logi-token`, `sys:logi-request-key`(Ed25519). +- `sync.log`: 이름과 결과만, 값은 기록하지 않는다. 1 MiB 에서 교체. + +## 8. 단계 +| 단계 | 내용 | 다른 레포 | +|---|---|---| +| 0 | 인박스 v2(바깥 봉투 버전 2, **v1 과 같은 바깥 배치를 고정**하고 AAD·분기 규칙 명세), 골든 벡터, v0.2↔v2 호환 시험, 인박스 루프 공용화 | — | +| 1 | `sync.json`, add·제안·review·rm·peer·status·수동 sync, `decide`, 잠금·journal, 충돌·resolve, 복구 기준점, 한도·차단기·freeze, ACK·digest, 기존 명령의 sync 정책 적용 | — | +| 1b | 승인 문서 3종, FIDO2 검증기, 승인 소비 기록, 보류 재평가, 로컬 확인(L) | — | +| 2 | `install`(3 OS), `--from-keychain`, doctor 연동 | — | +| 2b | 1pass.dev 연동(기기 연결·요청 키, 앱 기기 고정 키 승인자, 암호화 승인 요청, 푸시, 앱 승인 화면) | **logi**(서버·iOS·Android) | +| 3 | 네이티브 위치 반영(기기별 선택, 기존 항목 갱신만, 대화형만) | — | +| 4 | 200 KiB 넘는 항목 분할 전송, device-uv 키 증명 재검토 | — | + +1·1b 만으로도 FIDO2 보안 키로 쓸 수 있다. 1pass.dev 연동(2b)은 logi 쪽 작업과 병행한다. + +## 9. 시험 +- `decide` 표 시험: 앞으로 감기(parent 일치만), 낡은 변경, 같은 vid 다른 값(위반), 수렴(양쪽 같은 head), 충돌, lineage 위조(parent 불일치 → 충돌), 잘림 경계. +- 경쟁 시험: 스캔 뒤 로컬 `kc set` 과 원격 적용이 겹칠 때 충돌로 바뀌는지, ②와 ③ 사이에서 죽은 뒤 복구. +- 결정적 시뮬레이션: 메모리 중계 위에 가상 기기 3~4대, 수정·전달·유실·순서 뒤바뀜·오프라인·72시간 만료를 무작위로 섞는다. 불변식: ACK 가 다 오면 모두 같은 값이거나 충돌 표시 / 동시 수정이 조용히 덮이는 경우 0 / 원격 메시지로 값이 지워지는 경우 0 / 복구 기준점이 사람 확인 없이 바뀌는 경우 0. +- 보안 시험: 원격 제안이 review 없이 대상이 되는 경우 0, 승인 없는 덮어쓰기 보류, `inbox --on-conflict overwrite`·`receive` 로 대상 항목 덮어쓰기 시 정책 적용, 승인 문서 종류 혼동(ValueChange 서명을 Retire 로) 거부, 부분 적용 뒤 재시도, 역순 승인 수용, 에이전트 실행에서 L·A·A+ 경로는 exit 5 또는 보류. +- 서버 단독 장악 시뮬레이션: 가짜 1pass.dev 가 임의 문서 서명 요청·서명 재사용·승인자 바꿔치기·로그인 위장을 해도 적용 0건. +- 실기기: logi 앱 Secure Enclave·StrongBox 키 생성과 서명, FIDO2 보안 키(USB) 3 OS. + +## 10. 열린 문제 +1. 키 증명(App Attest·Key Attestation)을 1단계부터 넣을지. +2. 로컬 스캔 비용(144개 전부 읽기) 실측. +3. 같은 이름이 기기마다 다른 의미일 때: 제안 review 화면에 양쪽 지문과 출처를 함께 보여 준다. +4. 네이티브 위치 반영(Phase 3)은 앱이 스스로 갱신하는 토큰을 덮어 세션을 깰 수 있어, 기존 항목 갱신만·대화형에서만 한다. +5. 승인자를 여러 명(휴대폰 + 보안 키) 둘 때 A 는 하나면 된다. A+ 는 휴대폰 승인이 필수다. 보안 키를 추가로 요구할지는 열려 있다. +6. 휴대폰 키 증명 없이 지문 대조만으로 "정품 logi 앱의 하드웨어 키"를 믿는 수준이 충분한지(열린 문제 1 과 연결). From b82b154a2fb9efaff2bd9668d39a232db1a7e83a Mon Sep 17 00:00:00 2001 From: Dico Date: Tue, 13 Oct 2026 15:33:39 +0900 Subject: [PATCH 02/24] =?UTF-8?q?docs(design):=20kc=20sync=20=ED=99=94?= =?UTF-8?q?=EB=A9=B4=20=EA=B2=B0=EC=A0=95(=EC=8B=9C=EC=95=88=20=ED=99=95?= =?UTF-8?q?=EC=A0=95)=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- docs/design/sync.md | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/docs/design/sync.md b/docs/design/sync.md index c9ba44e..90b2df8 100644 --- a/docs/design/sync.md +++ b/docs/design/sync.md @@ -249,3 +249,15 @@ kc approver enroll [--fido2] | list | rm ID 4. 네이티브 위치 반영(Phase 3)은 앱이 스스로 갱신하는 토큰을 덮어 세션을 깰 수 있어, 기존 항목 갱신만·대화형에서만 한다. 5. 승인자를 여러 명(휴대폰 + 보안 키) 둘 때 A 는 하나면 된다. A+ 는 휴대폰 승인이 필수다. 보안 키를 추가로 요구할지는 열려 있다. 6. 휴대폰 키 증명 없이 지문 대조만으로 "정품 logi 앱의 하드웨어 키"를 믿는 수준이 충분한지(열린 문제 1 과 연결). + +## 11. 화면 결정 (2026-10-13 시안 확정) +시안: 레포 루트 `.mockups/kc-sync/index.html`(gitignore). 사용자 선택: + +| 화면 | 선택 | 내용 | +|---|---|---| +| logi 앱 승인 화면 | A · 바로 승인 | 짧은 코드 4단어를 보여 주고 바로 Face ID 승인 버튼. 코드 맞히기 단계는 두지 않는다 | +| kc 터미널 대기 | B · 항목·대안 함께 | 항목·대상 기기·코드를 함께 보여 주고, 휴대폰이 없을 때 보안 키(A 등급까지)·Ctrl-C 후 7일 유지를 안내 | +| 동기화 항목 고르기 | A · 묶음 목록 | 이름 앞부분으로 묶은 체크리스트(펼치기). 기본 선택 = 권장 분류 | + +- 승인 화면 A 를 고르면서 "사용자가 시작하지 않은 요청" 방어는 짧은 코드 **눈 대조**에 기댄다(B 의 맞히기 단계 없음). 2차 방어선(§4 한도·차단기·복구 기준점)은 그대로다. +- 초기 동기화 대상 목록은 개인 정보라 레포에 두지 않는다. 사용자 기기의 kc 설정 폴더 `sync-initial-set.toml` 에 있고, `kc sync add --from-keychain` 이 이 목록을 미리 체크해 보여 준다. From 12227024f5d9a89b2f62ea50522e20a0968a6cad Mon Sep 17 00:00:00 2001 From: Dico Date: Tue, 13 Oct 2026 15:38:48 +0900 Subject: [PATCH 03/24] =?UTF-8?q?docs(design):=20kc=20sync=20v0.4=20?= =?UTF-8?q?=E2=80=94=20D9=C2=B7D10=20=ED=99=95=EC=A0=95,=20=EC=B0=A9?= =?UTF-8?q?=EC=88=98=20=EC=A0=84=20=EA=B3=A0=EC=A0=95=20=EA=B3=84=EC=95=BD?= =?UTF-8?q?(=C2=A712)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- .gitignore | 1 + docs/design/sync.md | 64 +++++++++++++++++++++++++++++++++++++++------ 2 files changed, 57 insertions(+), 8 deletions(-) diff --git a/.gitignore b/.gitignore index ba4cec2..fc91269 100644 --- a/.gitignore +++ b/.gitignore @@ -9,3 +9,4 @@ *.pem *.key .DS_Store +.mockups/ diff --git a/docs/design/sync.md b/docs/design/sync.md index 90b2df8..ca9091b 100644 --- a/docs/design/sync.md +++ b/docs/design/sync.md @@ -1,7 +1,7 @@ -# `kc sync` 설계 (초안 v0.3, 2026-10-13) +# `kc sync` 설계 (초안 v0.4, 2026-10-13) 상태: 사용자 검토 대기. 구현 전. -근거: Opus 설계안과 codex(gpt-6-astra) 설계안을 서로 보여 주지 않고 따로 받아 종합했다(v0.1). 이후 logi(1pass.dev) 레포 점검 결과와 codex 공격자 관점 리뷰(P1 9건·P2 6건)를 반영했다(v0.2). v0.2 재리뷰의 새 P1 4건과 부분 해결 항목을 반영했다(v0.3). +근거: Opus 설계안과 codex(gpt-6-astra) 설계안을 서로 보여 주지 않고 따로 받아 종합했다(v0.1). 이후 logi(1pass.dev) 레포 점검 결과와 codex 공격자 관점 리뷰(P1 9건·P2 6건)를 반영했다(v0.2). v0.2 재리뷰의 새 P1 4건과 부분 해결 항목을 반영했다(v0.3). v0.3 재리뷰(13건 중 10건 해결)에서 나온 착수 전 고정 계약 5개를 §12 로 정했다(v0.4). ## 0. 확정된 사용자 결정 @@ -15,9 +15,8 @@ | D6 | logi 에는 kc 전용 승인 도메인을 새로 만든다(관례 D2). 부품은 에이전트 승인 게이트에서 가져온다 | | D7 | TOTP 는 kc 승인 경로에 넣지 않는다. 1pass.dev 계정 로그인 2단계 인증으로만 남긴다(logi 소관) | | D8 | 휴대폰이 없을 때는 FIDO2 보안 키(YubiKey 등)로 승인한다. 서버 없이 kc 가 직접 검증한다 | - -v0.2 에서 바뀐 큰 결정(사용자 확인 필요): -- **휴대폰 승인 서명을 패스키에서 logi 앱의 기기 고정 키로 바꾼다**(§3.4). logi 패스키는 여러 기기에 동기화되고 RP ID 를 웹과 공유해서, 장악된 1pass.dev 가 "로그인" 화면으로 위장해 승인 서명을 받아 낼 수 있다. +| D9 | 휴대폰 승인 서명은 logi 패스키가 아니라 **logi 앱의 기기 고정 키**로 한다(§3.4, 2026-10-13 확정). logi 패스키는 여러 기기에 동기화되고 RP ID 를 웹과 공유해서, 장악된 1pass.dev 가 "로그인" 화면으로 위장해 승인 서명을 받아 낼 수 있다 | +| D10 | 구현은 v0.3 을 한 번 더 리뷰해 남은 부분 해결 항목을 닫은 뒤 시작한다 | ## 1. 요약 @@ -225,8 +224,8 @@ kc approver enroll [--fido2] | list | rm ID | 단계 | 내용 | 다른 레포 | |---|---|---| | 0 | 인박스 v2(바깥 봉투 버전 2, **v1 과 같은 바깥 배치를 고정**하고 AAD·분기 규칙 명세), 골든 벡터, v0.2↔v2 호환 시험, 인박스 루프 공용화 | — | -| 1 | `sync.json`, add·제안·review·rm·peer·status·수동 sync, `decide`, 잠금·journal, 충돌·resolve, 복구 기준점, 한도·차단기·freeze, ACK·digest, 기존 명령의 sync 정책 적용 | — | -| 1b | 승인 문서 3종, FIDO2 검증기, 승인 소비 기록, 보류 재평가, 로컬 확인(L) | — | +| 1 | `sync.json`, add·제안·review·rm·peer·status·수동 sync, `decide`, 잠금·journal, 충돌·resolve, 복구 기준점, 한도·차단기·freeze, ACK·digest·세대 교환, 기존 명령의 sync 정책 적용, **로컬 확인(L)**. 원격 덮어쓰기는 전부 review 보류(§12.5) | — | +| 1b | 승인 문서 3종, FIDO2 검증기, 승인 소비 기록, 보류 재평가, 승인 붙은 덮어쓰기 자동 적용 켜기 | — | | 2 | `install`(3 OS), `--from-keychain`, doctor 연동 | — | | 2b | 1pass.dev 연동(기기 연결·요청 키, 앱 기기 고정 키 승인자, 암호화 승인 요청, 푸시, 앱 승인 화면) | **logi**(서버·iOS·Android) | | 3 | 네이티브 위치 반영(기기별 선택, 기존 항목 갱신만, 대화형만) | — | @@ -251,7 +250,7 @@ kc approver enroll [--fido2] | list | rm ID 6. 휴대폰 키 증명 없이 지문 대조만으로 "정품 logi 앱의 하드웨어 키"를 믿는 수준이 충분한지(열린 문제 1 과 연결). ## 11. 화면 결정 (2026-10-13 시안 확정) -시안: 레포 루트 `.mockups/kc-sync/index.html`(gitignore). 사용자 선택: +시안(검토 후 삭제)에서 받은 사용자 선택: | 화면 | 선택 | 내용 | |---|---|---| @@ -261,3 +260,52 @@ kc approver enroll [--fido2] | list | rm ID - 승인 화면 A 를 고르면서 "사용자가 시작하지 않은 요청" 방어는 짧은 코드 **눈 대조**에 기댄다(B 의 맞히기 단계 없음). 2차 방어선(§4 한도·차단기·복구 기준점)은 그대로다. - 초기 동기화 대상 목록은 개인 정보라 레포에 두지 않는다. 사용자 기기의 kc 설정 폴더 `sync-initial-set.toml` 에 있고, `kc sync add --from-keychain` 이 이 목록을 미리 체크해 보여 준다. + +## 12. 구현 착수 전 고정 계약 (v0.4) +v0.3 재리뷰가 "지금 정하지 않으면 다시 짜야 한다"고 꼽은 5개다. + +### 12.1 인박스 v2 형식 +- 바깥 봉투 필드와 순서는 v1 과 같다(`v, suite, sender_fp, recipient_fp, enc, ct`). `v = 2` 만 다르다. 지금 코드는 봉투 전체를 decode 한 뒤 버전을 보므로(`crates/kc-proto/src/inbox.rs:328`) **배치를 바꾸면 v0.2 가 Malformed 로 지운다.** 배치는 바꾸지 않는다. +- AAD 는 v1 과 같은 방식으로 봉투 필드 전체(버전 포함)를 덮는다. HPKE info 는 `"kc2 inbox" ‖ sender_fp ‖ recipient_fp`. +- 안쪽 `InboxPlain2.v` 는 바깥 `v` 와 같아야 한다. 다르면 거부한다. +- 내용 종류는 `body` 열거형의 판별자로 나눈다. Phase 0 에서 골든 벡터로 고정한다. +- **변경 식별자** `change_id = (name, generation, new_vid)`. ACK 는 `[(change_id, 결과)]` 를 담는다. 결과 = `applied | held | conflict | stale_generation | deferred_capacity | rejected`. + +### 12.2 등록 세대 교환 +- 세대는 **받는 기기가** 정하고 보낸 기기에 알려 준다. +- `Offer{name}` → 받는 쪽이 review 에서 받아들이면 `Accept{name, generation}` 을 보낸다. 보낸 기기는 기기별로 그 세대를 기록하고, 그 뒤 변경에 이 세대를 넣는다. +- 받는 쪽에서 `sync rm` 하면 세대를 올리고 `Leave{name, generation}` 을 보낸다. 다시 넣으려면 새 Offer → 새 Accept 다. +- 세대가 맞지 않는 변경은 적용하지 않고 `stale_generation` ACK 를 돌려준다. 보낸 기기는 그 기기에 대한 큐 항목을 지우고 status 에 "다시 제안 필요"로 표시한다. +- 기기별 범위 변경(`--peers`)도 Offer·Leave 로 표현한다. + +### 12.3 ACK 와 보관·용량 +- 보낸 기기는 대상 기기 **전부**가 그 `change_id` 에 어떤 결과든 ACK 하면 보낸 값 스냅샷을 지운다. 같은 이름의 더 새 변경이 ACK 되면 이전 것도 지운다. ACK 는 `change_id` 가 정확히 같은 큐 항목만 지운다(옛 ACK 가 새 항목을 지우지 않음). +- 받는 기기의 보류·충돌 후보 슬롯은 해결·거절할 때 지운다. 복구 기준점은 사람이 확인할 때만 바뀐다. +- 슬롯 총량 상한 = `max(16, 대상 항목 수 × 4)`. 대상이 0개여도 첫 제안을 받을 수 있다. +- 보존 우선순위: 복구 기준점 > 충돌 후보 > 보류 값 > 제안. 상한에 닿으면 새 제안·보류를 받지 않고 `deferred_capacity` ACK 를 보낸다(보낸 쪽은 다음 digest 뒤 다시 보냄). 기준점은 절대 밀어내지 않는다. + +### 12.4 journal 복구 단위 +- 원격 적용 한 건 = 한 트랜잭션: ① journal 에 "이전 지문·예정 지문·change_id" 기록 → ② 기준점·후보 슬롯 확보 → ③ 키체인 쓰기 → ④ `sync.json`(head·lineage·승인 소비·보낼 ACK) 갱신 → ⑤ journal 정리. +- 재시작 때 남은 journal 이 있으면 현재 값 지문으로 판정한다. + - 예정 지문과 같음 → ④부터 마저 한다. + - 이전 지문과 같음 → 쓰기가 일어나지 않았으니 journal 만 지우고 다시 시도한다. + - **둘 다 아님** → 그 사이 다른 쓰기가 있었다. 덮어쓰지 않고 충돌로 남긴다. +- ACK 는 ④가 끝난 뒤에만 보낸다. + +### 12.5 단계 경계와 판정 순서 +- **로컬 확인(L)을 Phase 1 로 앞당긴다.** add·review·resolve 가 L 에 의존하기 때문이다. +- Phase 1 에는 서명 승인(A)이 없다. 그래서 Phase 1 에서는 **원격 덮어쓰기를 자동 적용하지 않고 전부 review 대상으로 보류**한다. 자동 적용은 Phase 1b(검증기)부터 켠다. +- `decide` 는 검증기가 통과시킨 승인만 받는다(`Option`). 서명 바이트를 직접 보지 않는다. +- 판정 순서(위에서 먼저 걸리는 것이 이긴다): + +| 순서 | 조건 | 결과 | +|---|---|---| +| 1 | 세대 불일치 | 거부, `stale_generation` ACK | +| 2 | freeze 상태 | 보류 | +| 3 | 같은 vid 다른 값·다른 parent | 위반, 그 기기의 해당 항목 흐름 격리 | +| 4 | 받은 vid = 내 head 또는 lineage 안 | 무시(낡은 변경), `applied` ACK | +| 5 | 이미 충돌 중 | 후보로 추가(해결 메시지면 §2.4 규칙으로 판정) | +| 6 | 값 같음 | 수렴 | +| 7 | 검증된 승인 + parent = 내 head + 한도 안 | 앞으로 감기 | +| 8 | 승인 없음·한도 초과 + parent = 내 head | 보류(review) | +| 9 | 그 밖 | 충돌 | From 0b82f47702ae00dd0ae2ebe1e4702fc7b3a0ab4c Mon Sep 17 00:00:00 2001 From: Dico Date: Tue, 13 Oct 2026 15:41:32 +0900 Subject: [PATCH 04/24] =?UTF-8?q?docs(design):=20kc=20sync=20=C2=A712=20?= =?UTF-8?q?=EC=A0=95=EC=A0=95=20=E2=80=94=20AAD=C2=B7=ED=99=95=EC=A0=95=20?= =?UTF-8?q?ACK=C2=B7journal=20=EB=A0=88=EC=BD=94=EB=93=9C=C2=B7Phase=201?= =?UTF-8?q?=20=ED=8C=90=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- docs/design/sync.md | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/docs/design/sync.md b/docs/design/sync.md index ca9091b..8c96b5c 100644 --- a/docs/design/sync.md +++ b/docs/design/sync.md @@ -190,7 +190,7 @@ logi 점검 결과(`scratchpad/logi-survey.md`)를 근거로, kc 전용 승인 - 인박스 **바깥 봉투 버전을 2로** 올린다. v0.2 kc 는 바깥 봉투 버전을 복호화 전에 검사해(`crates/kc-proto/src/inbox.rs:329`) "지원하지 않는 버전"으로 인박스에 남겨 두고 72시간 뒤 만료된다(codex P2-13 확인). ```text InboxPlain2 { v:2, msg_id, sender_fp, recipient_fp, created_at, expires_at, body } -body = Items(...) | Sync { kind: Hello | Offer | Changes | Ack | Digest | Approvals } +body = Items(...) | Sync { kind: Hello | Offer | Accept | Leave | Changes | Ack | Digest | Approvals } Change { name, generation, new_vid, lineage(≤64), op: Put{value,kind} | Retire, approval_ref? } ``` - 상대의 v2 지원 여부를 모르면 **Hello 한 통만** 보낸다. Hello 는 기능 목록만 담고 받는 쪽 상태를 바꾸지 않는 무해한 메시지다. v0.2 기기에서는 72시간 뒤 만료되는 낭비 1통으로 끝난다. Hello 응답을 받기 전에는 다른 sync 메시지를 보내지 않고 보류한다(v0.2 재리뷰 P1: 확인 전 금지 규칙이 Hello 까지 막아 교착되던 문제). **sync 변경을 v1 Items 로 낮춰 보내지 않는다.** 일반 `send --to` 는 지금처럼 v1 이다. @@ -266,7 +266,7 @@ v0.3 재리뷰가 "지금 정하지 않으면 다시 짜야 한다"고 꼽은 5 ### 12.1 인박스 v2 형식 - 바깥 봉투 필드와 순서는 v1 과 같다(`v, suite, sender_fp, recipient_fp, enc, ct`). `v = 2` 만 다르다. 지금 코드는 봉투 전체를 decode 한 뒤 버전을 보므로(`crates/kc-proto/src/inbox.rs:328`) **배치를 바꾸면 v0.2 가 Malformed 로 지운다.** 배치는 바꾸지 않는다. -- AAD 는 v1 과 같은 방식으로 봉투 필드 전체(버전 포함)를 덮는다. HPKE info 는 `"kc2 inbox" ‖ sender_fp ‖ recipient_fp`. +- AAD 는 v1 과 똑같이 `postcard(v, suite, sender_fp, recipient_fp)` 다(`crates/kc-proto/src/inbox.rs:182`). `enc`·`ct` 는 넣지 않는다. HPKE info 는 `"kc2 inbox" ‖ sender_fp ‖ recipient_fp`. - 안쪽 `InboxPlain2.v` 는 바깥 `v` 와 같아야 한다. 다르면 거부한다. - 내용 종류는 `body` 열거형의 판별자로 나눈다. Phase 0 에서 골든 벡터로 고정한다. - **변경 식별자** `change_id = (name, generation, new_vid)`. ACK 는 `[(change_id, 결과)]` 를 담는다. 결과 = `applied | held | conflict | stale_generation | deferred_capacity | rejected`. @@ -279,22 +279,23 @@ v0.3 재리뷰가 "지금 정하지 않으면 다시 짜야 한다"고 꼽은 5 - 기기별 범위 변경(`--peers`)도 Offer·Leave 로 표현한다. ### 12.3 ACK 와 보관·용량 -- 보낸 기기는 대상 기기 **전부**가 그 `change_id` 에 어떤 결과든 ACK 하면 보낸 값 스냅샷을 지운다. 같은 이름의 더 새 변경이 ACK 되면 이전 것도 지운다. ACK 는 `change_id` 가 정확히 같은 큐 항목만 지운다(옛 ACK 가 새 항목을 지우지 않음). +- 보낸 기기는 대상 기기 **전부**가 그 `change_id` 에 **확정 결과**(`applied | held | conflict | stale_generation | rejected`)를 ACK 하면 보낸 값 스냅샷을 지운다. `deferred_capacity` 는 확정 결과가 아니다. 스냅샷과 큐 항목을 그대로 두고 다음 digest 뒤 다시 보낸다. 같은 이름의 더 새 변경이 ACK 되면 이전 것도 지운다. ACK 는 `change_id` 가 정확히 같은 큐 항목만 지운다(옛 ACK 가 새 항목을 지우지 않음). - 받는 기기의 보류·충돌 후보 슬롯은 해결·거절할 때 지운다. 복구 기준점은 사람이 확인할 때만 바뀐다. - 슬롯 총량 상한 = `max(16, 대상 항목 수 × 4)`. 대상이 0개여도 첫 제안을 받을 수 있다. - 보존 우선순위: 복구 기준점 > 충돌 후보 > 보류 값 > 제안. 상한에 닿으면 새 제안·보류를 받지 않고 `deferred_capacity` ACK 를 보낸다(보낸 쪽은 다음 digest 뒤 다시 보냄). 기준점은 절대 밀어내지 않는다. ### 12.4 journal 복구 단위 -- 원격 적용 한 건 = 한 트랜잭션: ① journal 에 "이전 지문·예정 지문·change_id" 기록 → ② 기준점·후보 슬롯 확보 → ③ 키체인 쓰기 → ④ `sync.json`(head·lineage·승인 소비·보낼 ACK) 갱신 → ⑤ journal 정리. +- 원격 적용 한 건 = 한 트랜잭션: ① journal 에 **적용 의도 레코드 전체**를 기록 — `change_id`, 보낸 기기, 이전 지문, 예정 지문, 적용 뒤 head·lineage, 소비할 승인 키, 보낼 ACK 결과, 확보할 기준점·후보 슬롯 이름. 예정 값 자체는 ② 에서 확보하는 후보 슬롯에 먼저 넣어 둔다 → ② 기준점·후보 슬롯 확보 → ③ 키체인 쓰기 → ④ `sync.json`(head·lineage·승인 소비·보낼 ACK) 갱신 → ⑤ journal 정리. - 재시작 때 남은 journal 이 있으면 현재 값 지문으로 판정한다. - - 예정 지문과 같음 → ④부터 마저 한다. + - 예정 지문과 같음 → 레코드대로 ④부터 마저 한다. - 이전 지문과 같음 → 쓰기가 일어나지 않았으니 journal 만 지우고 다시 시도한다. - **둘 다 아님** → 그 사이 다른 쓰기가 있었다. 덮어쓰지 않고 충돌로 남긴다. - ACK 는 ④가 끝난 뒤에만 보낸다. ### 12.5 단계 경계와 판정 순서 - **로컬 확인(L)을 Phase 1 로 앞당긴다.** add·review·resolve 가 L 에 의존하기 때문이다. -- Phase 1 에는 서명 승인(A)이 없다. 그래서 Phase 1 에서는 **원격 덮어쓰기를 자동 적용하지 않고 전부 review 대상으로 보류**한다. 자동 적용은 Phase 1b(검증기)부터 켠다. +- Phase 1 에는 서명 승인(A)이 없다. 판정표는 그대로 쓰되, **7번(자동 앞으로 감기)이 Phase 1 에서는 절대 걸리지 않는다**(검증된 승인이 없으므로). 그래서 parent 가 맞는 원격 덮어쓰기는 8번(review 보류), parent 가 다르면 9번(충돌)이다. 자동 적용은 Phase 1b 부터다. +- resolve: Phase 1 에서는 보내는 기기에서 L 만 요구한다. 받는 기기는 그 해결 메시지를 승인 없는 변경으로 보고 review 에 보류한다(§2.4 의 후보 포함 검사는 그대로). Phase 1b 부터 L + A 로 올리고, 승인이 붙은 해결은 자동 적용한다. - `decide` 는 검증기가 통과시킨 승인만 받는다(`Option`). 서명 바이트를 직접 보지 않는다. - 판정 순서(위에서 먼저 걸리는 것이 이긴다): From cb9134e03d3755a912f51ebdd4ca668cd509531d Mon Sep 17 00:00:00 2001 From: Dico Date: Tue, 13 Oct 2026 15:43:35 +0900 Subject: [PATCH 05/24] =?UTF-8?q?docs(design):=20kc=20sync=20=E2=80=94=20C?= =?UTF-8?q?hange.parents,=20=EB=A1=9C=EC=BB=AC=20=EB=B3=80=EA=B2=BD=20?= =?UTF-8?q?=ED=8A=B8=EB=9E=9C=EC=9E=AD=EC=85=98=20=EA=B2=BD=EA=B3=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- docs/design/sync.md | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/docs/design/sync.md b/docs/design/sync.md index 8c96b5c..1471e21 100644 --- a/docs/design/sync.md +++ b/docs/design/sync.md @@ -191,8 +191,9 @@ logi 점검 결과(`scratchpad/logi-survey.md`)를 근거로, kc 전용 승인 ```text InboxPlain2 { v:2, msg_id, sender_fp, recipient_fp, created_at, expires_at, body } body = Items(...) | Sync { kind: Hello | Offer | Accept | Leave | Changes | Ack | Digest | Approvals } -Change { name, generation, new_vid, lineage(≤64), op: Put{value,kind} | Retire, approval_ref? } +Change { name, generation, new_vid, parents: [vid…], lineage(≤64), op: Put{value,kind} | Retire, approval_ref? } ``` +- `Change.parents` 는 보낸 기기가 주장하는 직접 parent 목록이다(해결 메시지면 모든 후보 head). 승인이 붙은 변경은 `parents` 가 승인 문서의 parents 와 **정확히 같아야** 한다(다르면 거부). 승인이 없는 parents 는 보류와 충돌 중 어디로 보낼지만 정하고, 어느 쪽이든 사람이 본다. 그래서 위조해도 자동 적용으로 이어지지 않는다. - 상대의 v2 지원 여부를 모르면 **Hello 한 통만** 보낸다. Hello 는 기능 목록만 담고 받는 쪽 상태를 바꾸지 않는 무해한 메시지다. v0.2 기기에서는 72시간 뒤 만료되는 낭비 1통으로 끝난다. Hello 응답을 받기 전에는 다른 sync 메시지를 보내지 않고 보류한다(v0.2 재리뷰 P1: 확인 전 금지 규칙이 Hello 까지 막아 교착되던 문제). **sync 변경을 v1 Items 로 낮춰 보내지 않는다.** 일반 `send --to` 는 지금처럼 v1 이다. - `kc inbox` 와 `kc sync` 는 같은 인박스 처리 루프를 쓰고 내용 종류로 나눈다. - `docs/PROTOCOL.md` §4(v2)·§6(sync·L/A/A+ 행)·§9(승인자로 일원화)와 `docs/SECURITY.md`(1pass.dev 신뢰 경계, 등록 시점 한계, 원작자 소실 한계)를 함께 고친다. @@ -291,10 +292,12 @@ v0.3 재리뷰가 "지금 정하지 않으면 다시 짜야 한다"고 꼽은 5 - 이전 지문과 같음 → 쓰기가 일어나지 않았으니 journal 만 지우고 다시 시도한다. - **둘 다 아님** → 그 사이 다른 쓰기가 있었다. 덮어쓰지 않고 충돌로 남긴다. - ACK 는 ④가 끝난 뒤에만 보낸다. +- **로컬 변경 한 건 = 한 트랜잭션**(`kc set`·`restore`·`adopt`·스캔으로 찾은 변경): ① journal 에 로컬 변경 레코드 기록 — 이름, 이전 지문, 새 지문, 새 vid, parents, 스냅샷 슬롯 이름, 만들 큐 항목(대상 기기·세대) → ② 보낼 값 스냅샷 슬롯에 값 복사 → ③ `sync.json`(head·lineage·큐) 갱신 → ④ journal 정리. `kc set` 은 키체인 쓰기를 ① 과 ② 사이에 한다. +- 재시작 때 로컬 변경 journal 이 남아 있으면: 현재 값 지문이 새 지문과 같고 스냅샷이 있으면 ③부터 마저 한다. 현재 값이 새 지문과 다르면(그 사이 또 바뀜) 스냅샷을 버리고 journal 을 지운다. 다음 스캔이 새 vid 를 만든다. ### 12.5 단계 경계와 판정 순서 - **로컬 확인(L)을 Phase 1 로 앞당긴다.** add·review·resolve 가 L 에 의존하기 때문이다. -- Phase 1 에는 서명 승인(A)이 없다. 판정표는 그대로 쓰되, **7번(자동 앞으로 감기)이 Phase 1 에서는 절대 걸리지 않는다**(검증된 승인이 없으므로). 그래서 parent 가 맞는 원격 덮어쓰기는 8번(review 보류), parent 가 다르면 9번(충돌)이다. 자동 적용은 Phase 1b 부터다. +- Phase 1 에는 서명 승인(A)이 없다. 판정은 `Change.parents` 로 한다. 판정표는 그대로 쓰되, **7번(자동 앞으로 감기)이 Phase 1 에서는 절대 걸리지 않는다**(검증된 승인이 없으므로). 그래서 parent 가 맞는 원격 덮어쓰기는 8번(review 보류), parent 가 다르면 9번(충돌)이다. 자동 적용은 Phase 1b 부터다. - resolve: Phase 1 에서는 보내는 기기에서 L 만 요구한다. 받는 기기는 그 해결 메시지를 승인 없는 변경으로 보고 review 에 보류한다(§2.4 의 후보 포함 검사는 그대로). Phase 1b 부터 L + A 로 올리고, 승인이 붙은 해결은 자동 적용한다. - `decide` 는 검증기가 통과시킨 승인만 받는다(`Option`). 서명 바이트를 직접 보지 않는다. - 판정 순서(위에서 먼저 걸리는 것이 이긴다): From 1bde7536f81b2005483e6bedf1739b56afd67a4e Mon Sep 17 00:00:00 2001 From: Dico Date: Tue, 13 Oct 2026 15:44:42 +0900 Subject: [PATCH 06/24] =?UTF-8?q?docs(design):=20kc=20sync=20=E2=80=94=20?= =?UTF-8?q?=EB=A1=9C=EC=BB=AC=20=EB=B3=80=EA=B2=BD=20=EB=B3=B5=EA=B5=AC=20?= =?UTF-8?q?=ED=91=9C(=EC=BB=A4=EB=B0=8B=20=EC=97=AC=EB=B6=80=EB=8A=94=20he?= =?UTF-8?q?ad=20=EB=A1=9C=20=ED=8C=90=EC=A0=95)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- docs/design/sync.md | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/docs/design/sync.md b/docs/design/sync.md index 1471e21..80cf297 100644 --- a/docs/design/sync.md +++ b/docs/design/sync.md @@ -293,7 +293,18 @@ v0.3 재리뷰가 "지금 정하지 않으면 다시 짜야 한다"고 꼽은 5 - **둘 다 아님** → 그 사이 다른 쓰기가 있었다. 덮어쓰지 않고 충돌로 남긴다. - ACK 는 ④가 끝난 뒤에만 보낸다. - **로컬 변경 한 건 = 한 트랜잭션**(`kc set`·`restore`·`adopt`·스캔으로 찾은 변경): ① journal 에 로컬 변경 레코드 기록 — 이름, 이전 지문, 새 지문, 새 vid, parents, 스냅샷 슬롯 이름, 만들 큐 항목(대상 기기·세대) → ② 보낼 값 스냅샷 슬롯에 값 복사 → ③ `sync.json`(head·lineage·큐) 갱신 → ④ journal 정리. `kc set` 은 키체인 쓰기를 ① 과 ② 사이에 한다. -- 재시작 때 로컬 변경 journal 이 남아 있으면: 현재 값 지문이 새 지문과 같고 스냅샷이 있으면 ③부터 마저 한다. 현재 값이 새 지문과 다르면(그 사이 또 바뀜) 스냅샷을 버리고 journal 을 지운다. 다음 스캔이 새 vid 를 만든다. +- 재시작 때 로컬 변경 journal 이 남아 있으면, **③ 커밋 여부는 `sync.json` 의 head 가 레코드의 새 vid 인지로 판정**한다. + +| 현재 값 지문 | ③ 커밋됨? | 처리 | +|---|---|---| +| 새 지문 | 아니오, 스냅샷 없음 | 현재 값(=새 값)을 스냅샷에 다시 복사하고 ③ → ④ | +| 새 지문 | 아니오, 스냅샷 있음 | ③ → ④ | +| 새 지문 | 예 | ④ 만 | +| 이전 지문 | 아니오 | 키체인 쓰기가 안 일어났다. 스냅샷이 있으면 지우고 journal 정리 | +| 둘 다 아님 | 예 | 큐가 스냅샷을 참조하므로 **스냅샷은 남긴다**(보낸 값). journal 만 정리. 다음 스캔이 바깥 쓰기를 새 vid 로 만든다 | +| 둘 다 아님 | 아니오 | 스냅샷을 지우고 journal 정리. 다음 스캔이 새 vid 를 만든다 | + +- 스냅샷 슬롯은 큐 항목이 참조하는 동안 지우지 않는다. 지우는 것은 §12.3 의 확정 ACK 때뿐이다. ### 12.5 단계 경계와 판정 순서 - **로컬 확인(L)을 Phase 1 로 앞당긴다.** add·review·resolve 가 L 에 의존하기 때문이다. From aec06e9b1dd90f587b0bc521de7d6cf481f04cbd Mon Sep 17 00:00:00 2001 From: Dico Date: Tue, 13 Oct 2026 15:46:04 +0900 Subject: [PATCH 07/24] =?UTF-8?q?docs(design):=20kc=20sync=20=E2=80=94=20?= =?UTF-8?q?=EB=B3=B5=EA=B5=AC=20=ED=91=9C=20=EB=B9=88=EC=B9=B8(=EC=BB=A4?= =?UTF-8?q?=EB=B0=8B=20=EB=92=A4=20=EC=9D=B4=EC=A0=84=20=EA=B0=92=20?= =?UTF-8?q?=EB=B3=B5=EA=B7=80)=20=EC=B1=84=EC=9B=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- docs/design/sync.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/docs/design/sync.md b/docs/design/sync.md index 80cf297..8fa7f1a 100644 --- a/docs/design/sync.md +++ b/docs/design/sync.md @@ -300,9 +300,11 @@ v0.3 재리뷰가 "지금 정하지 않으면 다시 짜야 한다"고 꼽은 5 | 새 지문 | 아니오, 스냅샷 없음 | 현재 값(=새 값)을 스냅샷에 다시 복사하고 ③ → ④ | | 새 지문 | 아니오, 스냅샷 있음 | ③ → ④ | | 새 지문 | 예 | ④ 만 | +| 새 지문이 아님(이전 지문이든 다른 값이든) | 예 | 큐가 스냅샷을 참조하므로 **스냅샷은 남긴다**(보낸 값). journal 만 정리. 다음 스캔이 지금 값을 새 vid 로 기록한다 | | 이전 지문 | 아니오 | 키체인 쓰기가 안 일어났다. 스냅샷이 있으면 지우고 journal 정리 | -| 둘 다 아님 | 예 | 큐가 스냅샷을 참조하므로 **스냅샷은 남긴다**(보낸 값). journal 만 정리. 다음 스캔이 바깥 쓰기를 새 vid 로 만든다 | -| 둘 다 아님 | 아니오 | 스냅샷을 지우고 journal 정리. 다음 스캔이 새 vid 를 만든다 | +| 이전 지문도 새 지문도 아님 | 아니오 | 스냅샷을 지우고 journal 정리. 다음 스캔이 새 vid 를 만든다 | + +(행은 "현재 값 = 새 값 여부 × 커밋 여부"의 모든 조합을 덮는다.) - 스냅샷 슬롯은 큐 항목이 참조하는 동안 지우지 않는다. 지우는 것은 §12.3 의 확정 ACK 때뿐이다. From 72a868ed346353fc2f38c325fb4d1c1cb41c3d2b Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Tue, 13 Oct 2026 16:20:10 +0900 Subject: [PATCH 08/24] =?UTF-8?q?feat(kc-cli):=20=EB=A1=9C=EC=BB=AC=20?= =?UTF-8?q?=ED=99=95=EC=9D=B8=20L=20(Touch=20ID=C2=B7Windows=20Hello=C2=B7?= =?UTF-8?q?polkit)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- Cargo.lock | 90 +++++++++++++++++++ crates/kc-cli/Cargo.toml | 9 ++ crates/kc-cli/src/host.rs | 9 ++ crates/kc-cli/src/lib.rs | 2 + crates/kc-cli/src/local_auth.rs | 52 +++++++++++ crates/kc-cli/src/local_auth/linux.rs | 113 ++++++++++++++++++++++++ crates/kc-cli/src/local_auth/macos.rs | 81 +++++++++++++++++ crates/kc-cli/src/local_auth/windows.rs | 58 ++++++++++++ crates/kc-cli/tests/common/mod.rs | 13 ++- 9 files changed, 426 insertions(+), 1 deletion(-) create mode 100644 crates/kc-cli/src/local_auth.rs create mode 100644 crates/kc-cli/src/local_auth/linux.rs create mode 100644 crates/kc-cli/src/local_auth/macos.rs create mode 100644 crates/kc-cli/src/local_auth/windows.rs diff --git a/Cargo.lock b/Cargo.lock index 2433872..bae90be 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1499,6 +1499,7 @@ name = "kc-cli" version = "0.2.0" dependencies = [ "base64 0.22.1", + "block2", "clap", "crossterm", "ctrlc", @@ -1512,6 +1513,9 @@ dependencies = [ "kc-store", "kc-wire", "libc", + "objc2", + "objc2-foundation", + "objc2-local-authentication", "postcard", "reqwest", "rustls", @@ -1523,6 +1527,7 @@ dependencies = [ "thiserror", "tokio", "toml", + "windows", "zeroize", ] @@ -1839,6 +1844,27 @@ version = "4.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33" +[[package]] +name = "objc2-foundation" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272" +dependencies = [ + "bitflags", + "objc2", +] + +[[package]] +name = "objc2-local-authentication" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e48e0b8b339e0d9d2ed4416b7f93f9d4daadff7d4dd797f89867cde11aeac607" +dependencies = [ + "block2", + "objc2", + "objc2-foundation", +] + [[package]] name = "once_cell" version = "1.21.4" @@ -3120,6 +3146,51 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" +[[package]] +name = "windows" +version = "0.58.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd04d41d93c4992d421894c18c8b43496aa748dd4c081bac0dc93eb0489272b6" +dependencies = [ + "windows-core", + "windows-targets", +] + +[[package]] +name = "windows-core" +version = "0.58.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-result", + "windows-strings", + "windows-targets", +] + +[[package]] +name = "windows-implement" +version = "0.58.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "windows-interface" +version = "0.58.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "windows-link" version = "0.2.1" @@ -3139,6 +3210,25 @@ dependencies = [ "zeroize", ] +[[package]] +name = "windows-result" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-strings" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10" +dependencies = [ + "windows-result", + "windows-targets", +] + [[package]] name = "windows-sys" version = "0.52.0" diff --git a/crates/kc-cli/Cargo.toml b/crates/kc-cli/Cargo.toml index b7aca97..c675732 100644 --- a/crates/kc-cli/Cargo.toml +++ b/crates/kc-cli/Cargo.toml @@ -50,6 +50,15 @@ sys-locale = "0.3" [target.'cfg(unix)'.dependencies] libc = "0.2" +[target.'cfg(target_os = "macos")'.dependencies] +block2 = "0.6.2" +objc2 = "0.6.5" +objc2-foundation = { version = "0.3.2", default-features = false, features = ["std", "NSError", "NSString"] } +objc2-local-authentication = { version = "0.3.2", default-features = false, features = ["std", "LAContext", "LAError", "block2"] } + +[target.'cfg(windows)'.dependencies] +windows = { version = "0.58.0", default-features = false, features = ["Security_Credentials_UI", "Foundation"] } + [dev-dependencies] kc-proto = { workspace = true, features = ["test-util"] } kc-store = { workspace = true, features = ["test-util"] } diff --git a/crates/kc-cli/src/host.rs b/crates/kc-cli/src/host.rs index 4db2db8..74a70b0 100644 --- a/crates/kc-cli/src/host.rs +++ b/crates/kc-cli/src/host.rs @@ -17,6 +17,7 @@ use crate::console::{Console, TermConsole}; use crate::error::{CliError, Result}; use crate::http::HttpRelay; use crate::i18n::tr; +use crate::local_auth::{self, LocalAuthOutcome}; use crate::settings::RelayUrl; pub trait Host { @@ -24,6 +25,10 @@ pub trait Host { type Console: Console; fn console(&mut self) -> &mut Self::Console; + /// OS user presence outside the terminal (sync design §3.1). + fn local_confirm(&mut self, _reason: &str) -> LocalAuthOutcome { + LocalAuthOutcome::Unavailable("no local confirmation on this host".into()) + } /// A process environment variable (`CI`, `CLAUDECODE`, `KC_RELAY`). fn env_var(&self, key: &str) -> Option; fn stdin_is_terminal(&self) -> bool; @@ -83,6 +88,10 @@ impl Host for RealHost { &mut self.console } + fn local_confirm(&mut self, reason: &str) -> LocalAuthOutcome { + local_auth::confirm(reason) + } + fn env_var(&self, key: &str) -> Option { std::env::var_os(key) } diff --git a/crates/kc-cli/src/lib.rs b/crates/kc-cli/src/lib.rs index cea8acb..802693f 100644 --- a/crates/kc-cli/src/lib.rs +++ b/crates/kc-cli/src/lib.rs @@ -26,6 +26,7 @@ pub mod http; pub mod i18n; pub mod interrupt; mod keychain; +mod local_auth; pub mod policy; pub mod settings; pub mod state; @@ -35,6 +36,7 @@ pub use console::{Console, PromptError, TermConsole}; pub use error::CliError; pub use host::{Host, RealHost, spawn_and_wait}; pub use http::HttpRelay; +pub use local_auth::LocalAuthOutcome; pub use settings::{RelayUrl, Settings}; use std::ffi::OsString; diff --git a/crates/kc-cli/src/local_auth.rs b/crates/kc-cli/src/local_auth.rs new file mode 100644 index 0000000..a268879 --- /dev/null +++ b/crates/kc-cli/src/local_auth.rs @@ -0,0 +1,52 @@ +//! Local confirmation (sync design §3.1): the OS shows secure UI and reads biometrics +//! or credentials outside the terminal, so owning a PTY cannot type/script the answer. +//! There is no terminal fallback or cached confirmation in kc. + +#[cfg(target_os = "macos")] +#[allow(unsafe_code)] +mod macos; +#[cfg(windows)] +mod windows; +// Compile the pure Linux parser and result tests on the native test platform too. +#[cfg(any(target_os = "linux", test))] +mod linux; + +/// The result of an OS user-presence check. +#[derive(Debug, Clone, PartialEq)] +pub enum LocalAuthOutcome { + Confirmed, + Denied, + Unavailable(String), +} + +/// Blocks for a fresh OS confirmation, showing `reason` in the authentication UI. +pub fn confirm(reason: &str) -> LocalAuthOutcome { + // LocalAuthentication throws an Objective-C exception for an empty reason. + if reason.trim().is_empty() { + return LocalAuthOutcome::Unavailable("local confirmation needs a reason".into()); + } + #[cfg(target_os = "macos")] + { macos::confirm(reason) } + #[cfg(windows)] + { windows::confirm(reason) } + #[cfg(target_os = "linux")] + { linux::confirm(reason) } + #[cfg(not(any(target_os = "macos", windows, target_os = "linux")))] + { LocalAuthOutcome::Unavailable("local confirmation is unsupported on this platform".into()) } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn empty_reason_does_not_prompt() { + assert!(matches!(confirm(" \t\n"), LocalAuthOutcome::Unavailable(_))); + } + + #[test] + #[ignore = "requires a human to answer the OS authentication prompt"] + fn manual_local_confirmation() { + eprintln!("{:?}", confirm("kc test")); + } +} diff --git a/crates/kc-cli/src/local_auth/linux.rs b/crates/kc-cli/src/local_auth/linux.rs new file mode 100644 index 0000000..af0ef6d --- /dev/null +++ b/crates/kc-cli/src/local_auth/linux.rs @@ -0,0 +1,113 @@ +use std::process::Command; + +use super::LocalAuthOutcome; + +#[cfg(target_os = "linux")] +pub(super) fn confirm(reason: &str) -> LocalAuthOutcome { + let start_time = match std::fs::read_to_string("/proc/self/stat") { + Ok(stat) => match process_start_time(&stat) { + Ok(time) => time, + Err(error) => return LocalAuthOutcome::Unavailable(error.into()), + }, + Err(error) => return LocalAuthOutcome::Unavailable(format!("cannot read /proc/self/stat: {error}")), + }; + // Do not enable pkcheck's internal terminal agent. Authentication belongs to + // the session's OS agent, with no input inherited from kc's PTY. + // Polkit policy controls whether this check requires fresh authentication; + // kc itself never retains or reuses an authorization result. + match command(reason, std::process::id(), start_time).output() { + Ok(output) => outcome(output.status.code(), &output.stderr), + Err(error) => LocalAuthOutcome::Unavailable(format!("cannot run pkcheck: {error}")), + } +} + +fn command(reason: &str, pid: u32, start_time: u64) -> Command { + let mut command = Command::new("pkcheck"); + command.args([ + "--action-id", "org.freedesktop.policykit.exec", + "--process", &format!("{pid},{start_time}"), + "--allow-user-interaction", + "--detail", "polkit.message", reason, + ]); + command.stdin(std::process::Stdio::null()); + command +} + +/// Field 22 follows the state (field 3) by 19 fields. `comm` (field 2) can +/// contain whitespace and parentheses, so only the final ')' ends that field. +fn process_start_time(stat: &str) -> Result { + let (_, fields) = stat.rsplit_once(')').ok_or("/proc/self/stat has no comm terminator")?; + fields.split_whitespace().nth(19) + .ok_or("/proc/self/stat has no start time")? + .parse().map_err(|_| "/proc/self/stat has an invalid start time") +} + +fn outcome(code: Option, stderr: &[u8]) -> LocalAuthOutcome { + match code { + Some(0) => LocalAuthOutcome::Confirmed, + // pkcheck(1): 1 = not authorized, 3 = dialog dismissed. 2 means user interaction was + // needed but no authentication agent could ask, which falls to Unavailable below. + Some(1 | 3) => LocalAuthOutcome::Denied, + _ => LocalAuthOutcome::Unavailable(format!( + "pkcheck failed (exit {code:?}): {}", String::from_utf8_lossy(stderr).trim() + )), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn stat(comm: &str, start: &str) -> String { + // Fields 4..21 intentionally differ from field 22 to catch off-by-one errors. + format!("42 ({comm}) S {}{start} 900 901\n", "7 ".repeat(18)) + } + + #[test] + fn reads_field_22() { + assert_eq!(process_start_time(&stat("kc", "123456")), Ok(123456)); + assert_eq!(process_start_time(&stat("kc", "0")), Ok(0)); + assert_eq!(process_start_time(&stat("kc", "18446744073709551615")), Ok(u64::MAX)); + } + + #[test] + fn comm_can_contain_spaces_and_parentheses() { + for comm in ["kc local confirm", "kc (nested) name", "kc)) (a) b)", "kc\nname"] { + assert_eq!(process_start_time(&stat(comm, "123456")), Ok(123456)); + } + } + + #[test] + fn malformed_stat_is_unavailable() { + for text in ["", "42 kc S 1 2 3", "42 (kc) S 1 2 3"] { + assert!(process_start_time(text).is_err()); + } + for start in ["invalid", "-1", "18446744073709551616"] { + assert!(process_start_time(&stat("kc", start)).is_err()); + } + } + + #[test] + fn reason_is_one_argument_and_no_internal_agent_is_enabled() { + let command = command("kc: allow 'this' $(action)?", 42, 123456); + let args: Vec<_> = command.get_args().map(|arg| arg.to_str().unwrap()).collect(); + assert_eq!(args, [ + "--action-id", "org.freedesktop.policykit.exec", + "--process", "42,123456", "--allow-user-interaction", + "--detail", "polkit.message", "kc: allow 'this' $(action)?", + ]); + } + + #[test] + fn exit_status_fails_closed() { + assert_eq!(outcome(Some(0), b""), LocalAuthOutcome::Confirmed); + assert_eq!(outcome(Some(1), b""), LocalAuthOutcome::Denied); + assert_eq!(outcome(Some(3), b""), LocalAuthOutcome::Denied); + for code in [Some(2), Some(126), Some(127), Some(255), None] { + match outcome(code, b"no agent\n") { + LocalAuthOutcome::Unavailable(message) => assert!(message.contains("no agent")), + result => panic!("unexpected outcome: {result:?}"), + } + } + } +} diff --git a/crates/kc-cli/src/local_auth/macos.rs b/crates/kc-cli/src/local_auth/macos.rs new file mode 100644 index 0000000..8dfc0a4 --- /dev/null +++ b/crates/kc-cli/src/local_auth/macos.rs @@ -0,0 +1,81 @@ +use std::sync::mpsc; + +use block2::RcBlock; +use objc2::runtime::Bool; +use objc2_foundation::{NSError, NSString}; +use objc2_local_authentication::{LAContext, LAError, LAPolicy}; + +use super::LocalAuthOutcome; + +pub(super) fn confirm(reason: &str) -> LocalAuthOutcome { + // SAFETY: LAContext has no thread affinity; this fresh, owned context stays + // alive until the asynchronous reply arrives. No prior context is reused. + let context = unsafe { LAContext::new() }; + // SAFETY: zero is a valid reuse duration and disables reuse of device unlocks. + unsafe { context.setTouchIDAuthenticationAllowableReuseDuration(0.0) }; + let policy = LAPolicy::DeviceOwnerAuthentication; + // SAFETY: policy is a supported constant, and this preflight is not inside + // an evaluation reply block (which could deadlock LocalAuthentication). + if let Err(error) = unsafe { context.canEvaluatePolicy_error(policy) } { + return LocalAuthOutcome::Unavailable(error.localizedDescription().to_string()); + } + + let reason = NSString::from_str(reason); + let (tx, rx) = mpsc::channel(); + let reply = RcBlock::new(move |success: Bool, error: *mut NSError| { + let outcome = if success.as_bool() { + LocalAuthOutcome::Confirmed + } else { + // SAFETY: LocalAuthentication supplies nil or a valid NSError for + // the duration of this callback. Only owned Rust data leaves it. + match unsafe { error.as_ref() } { + Some(error) => failure(LAError(error.code()), error.localizedDescription().to_string()), + None => LocalAuthOutcome::Unavailable("LocalAuthentication returned no error details".into()), + } + }; + // A dropped receiver must not unwind across the Objective-C callback. + let _ = tx.send(outcome); + }); + // SAFETY: the reason is nonempty (checked by the parent), the context and + // block remain alive during evaluation, and the callback captures only a + // thread-safe Sender. Apple invokes it on a private queue, so recv can block. + unsafe { context.evaluatePolicy_localizedReason_reply(policy, &reason, &reply) }; + rx.recv().unwrap_or_else(|error| { + LocalAuthOutcome::Unavailable(format!("LocalAuthentication reply unavailable: {error}")) + }) +} + +fn failure(code: LAError, message: String) -> LocalAuthOutcome { + match code { + LAError::AuthenticationFailed | LAError::UserCancel | LAError::UserFallback => { + LocalAuthOutcome::Denied + } + _ => LocalAuthOutcome::Unavailable(message), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn cancelled_or_failed_authentication_is_denied() { + for code in [LAError::UserCancel, LAError::UserFallback, LAError::AuthenticationFailed] { + assert_eq!(failure(code, "denied".into()), LocalAuthOutcome::Denied); + } + } + + #[test] + fn unavailable_errors_preserve_the_message() { + for code in [ + LAError::BiometryNotAvailable, + LAError::BiometryNotEnrolled, + LAError::PasscodeNotSet, + LAError::SystemCancel, + LAError::InvalidContext, + LAError(-999), + ] { + assert_eq!(failure(code, "OS error".into()), LocalAuthOutcome::Unavailable("OS error".into())); + } + } +} diff --git a/crates/kc-cli/src/local_auth/windows.rs b/crates/kc-cli/src/local_auth/windows.rs new file mode 100644 index 0000000..0dc3d73 --- /dev/null +++ b/crates/kc-cli/src/local_auth/windows.rs @@ -0,0 +1,58 @@ +use windows::Security::Credentials::UI::{UserConsentVerificationResult, UserConsentVerifier}; +use windows::core::HSTRING; + +use super::LocalAuthOutcome; + +pub(super) fn confirm(reason: &str) -> LocalAuthOutcome { + // Request a new verification every time; never retain a previous result. + match UserConsentVerifier::RequestVerificationAsync(&HSTRING::from(reason)) + .and_then(|request| request.get()) + { + Ok(result) => outcome(result), + Err(error) => LocalAuthOutcome::Unavailable(format!("Windows Hello: {error}")), + } +} + +fn outcome(result: UserConsentVerificationResult) -> LocalAuthOutcome { + match result { + UserConsentVerificationResult::Verified => LocalAuthOutcome::Confirmed, + UserConsentVerificationResult::Canceled | UserConsentVerificationResult::RetriesExhausted => { + LocalAuthOutcome::Denied + } + UserConsentVerificationResult::DeviceNotPresent => { + LocalAuthOutcome::Unavailable("Windows Hello device not present".into()) + } + UserConsentVerificationResult::NotConfiguredForUser => { + LocalAuthOutcome::Unavailable("Windows Hello is not configured for this user".into()) + } + UserConsentVerificationResult::DisabledByPolicy => { + LocalAuthOutcome::Unavailable("Windows Hello is disabled by policy".into()) + } + UserConsentVerificationResult::DeviceBusy => { + LocalAuthOutcome::Unavailable("Windows Hello device is busy".into()) + } + _ => LocalAuthOutcome::Unavailable(format!("Windows Hello returned {result:?}")), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn only_verified_confirms() { + assert_eq!(outcome(UserConsentVerificationResult::Verified), LocalAuthOutcome::Confirmed); + for result in [UserConsentVerificationResult::Canceled, UserConsentVerificationResult::RetriesExhausted] { + assert_eq!(outcome(result), LocalAuthOutcome::Denied); + } + for result in [ + UserConsentVerificationResult::DeviceNotPresent, + UserConsentVerificationResult::NotConfiguredForUser, + UserConsentVerificationResult::DisabledByPolicy, + UserConsentVerificationResult::DeviceBusy, + UserConsentVerificationResult(-1), + ] { + assert!(matches!(outcome(result), LocalAuthOutcome::Unavailable(_))); + } + } +} diff --git a/crates/kc-cli/tests/common/mod.rs b/crates/kc-cli/tests/common/mod.rs index dd00cb7..a299feb 100644 --- a/crates/kc-cli/tests/common/mod.rs +++ b/crates/kc-cli/tests/common/mod.rs @@ -14,7 +14,7 @@ use std::path::PathBuf; use std::process::Command; use std::time::Duration; -use kc_cli::{CliError, Console, Host, HttpRelay, PromptError, RelayUrl}; +use kc_cli::{CliError, Console, Host, HttpRelay, LocalAuthOutcome, PromptError, RelayUrl}; use kc_proto::memory_relay::MemoryRelay; use kc_proto::relay::{RelayApi, RelayError}; use kc_proto::session::SessionOptions; @@ -186,6 +186,7 @@ pub struct Run { pub terminal: bool, pub stdout_terminal: bool, pub answers: Vec, + pub local_auth: VecDeque, pub env: Vec<(String, String)>, pub code_tx: Option>, } @@ -198,6 +199,7 @@ impl Run { terminal: false, stdout_terminal: false, answers: Vec::new(), + local_auth: VecDeque::new(), env: vec![("CLAUDECODE".into(), "1".into())], code_tx: None, } @@ -210,6 +212,7 @@ impl Run { terminal: true, stdout_terminal: false, answers, + local_auth: VecDeque::new(), env: Vec::new(), code_tx: None, } @@ -266,6 +269,7 @@ struct TestHost<'d, N: Net> { terminal: bool, stdout_terminal: bool, env: Vec<(String, String)>, + local_auth: VecDeque, } impl Host for TestHost<'_, N> { @@ -276,6 +280,12 @@ impl Host for TestHost<'_, N> { &mut self.console } + fn local_confirm(&mut self, _reason: &str) -> LocalAuthOutcome { + self.local_auth.pop_front().unwrap_or_else(|| { + LocalAuthOutcome::Unavailable("no scripted local confirmation".into()) + }) + } + fn env_var(&self, key: &str) -> Option { self.env .iter() @@ -393,6 +403,7 @@ impl Device { terminal: run.terminal, stdout_terminal: run.stdout_terminal, env, + local_auth: run.local_auth, }; let argv = std::iter::once("kc") .chain(args.iter().copied()) From ceb348a352a95999ee7e2ef83be9411d5fbf4989 Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Tue, 13 Oct 2026 16:20:10 +0900 Subject: [PATCH 09/24] =?UTF-8?q?feat(kc-sync):=20sync=20=ED=8C=90?= =?UTF-8?q?=EC=A0=95=20=EC=88=9C=EC=88=98=20=EB=A1=9C=EC=A7=81=20=ED=81=AC?= =?UTF-8?q?=EB=A0=88=EC=9D=B4=ED=8A=B8=20(decide=C2=B7=ED=95=9C=EB=8F=84?= =?UTF-8?q?=C2=B7=EC=8A=AC=EB=A1=AF=C2=B7=ED=81=90=C2=B7=EB=B3=B5=EA=B5=AC?= =?UTF-8?q?)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- Cargo.lock | 10 + Cargo.toml | 3 +- crates/kc-sync/Cargo.toml | 19 ++ crates/kc-sync/src/decision.rs | 167 +++++++++++++ crates/kc-sync/src/generation.rs | 78 ++++++ crates/kc-sync/src/lib.rs | 21 ++ crates/kc-sync/src/limiter.rs | 90 +++++++ crates/kc-sync/src/outbox.rs | 118 +++++++++ crates/kc-sync/src/recovery.rs | 101 ++++++++ crates/kc-sync/src/slots.rs | 120 +++++++++ crates/kc-sync/src/state.rs | 159 ++++++++++++ crates/kc-sync/tests/policy.rs | 388 +++++++++++++++++++++++++++++ crates/kc-sync/tests/simulation.rs | 291 ++++++++++++++++++++++ 13 files changed, 1564 insertions(+), 1 deletion(-) create mode 100644 crates/kc-sync/Cargo.toml create mode 100644 crates/kc-sync/src/decision.rs create mode 100644 crates/kc-sync/src/generation.rs create mode 100644 crates/kc-sync/src/lib.rs create mode 100644 crates/kc-sync/src/limiter.rs create mode 100644 crates/kc-sync/src/outbox.rs create mode 100644 crates/kc-sync/src/recovery.rs create mode 100644 crates/kc-sync/src/slots.rs create mode 100644 crates/kc-sync/src/state.rs create mode 100644 crates/kc-sync/tests/policy.rs create mode 100644 crates/kc-sync/tests/simulation.rs diff --git a/Cargo.lock b/Cargo.lock index 2433872..06eb9e5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1601,6 +1601,16 @@ dependencies = [ "zeroize", ] +[[package]] +name = "kc-sync" +version = "0.2.0" +dependencies = [ + "rand", + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "kc-wire" version = "0.2.0" diff --git a/Cargo.toml b/Cargo.toml index 4800691..3068540 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [workspace] resolver = "3" -members = ["crates/kc-wire", "crates/kc-proto", "crates/kc-store", "crates/kc-relay", "crates/kc-cli"] +members = ["crates/kc-wire", "crates/kc-proto", "crates/kc-store", "crates/kc-relay", "crates/kc-cli", "crates/kc-sync"] [workspace.package] version = "0.2.0" @@ -18,6 +18,7 @@ authors = ["Dcode "] kc-wire = { path = "crates/kc-wire", version = "0.2.0" } kc-proto = { path = "crates/kc-proto", version = "0.2.0" } kc-store = { path = "crates/kc-store", version = "0.2.0" } +kc-sync = { path = "crates/kc-sync", version = "0.2.0" } anyhow = "1" thiserror = "2" diff --git a/crates/kc-sync/Cargo.toml b/crates/kc-sync/Cargo.toml new file mode 100644 index 0000000..c34a878 --- /dev/null +++ b/crates/kc-sync/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "kc-sync" +description = "Pure sync decisions, retention, limits, and journal recovery" +version.workspace = true +edition.workspace = true +rust-version.workspace = true +license.workspace = true +repository.workspace = true +homepage.workspace = true +authors.workspace = true +publish = false + +[dependencies] +serde.workspace = true +thiserror.workspace = true + +[dev-dependencies] +rand.workspace = true +serde_json.workspace = true diff --git a/crates/kc-sync/src/decision.rs b/crates/kc-sync/src/decision.rs new file mode 100644 index 0000000..07bfd57 --- /dev/null +++ b/crates/kc-sync/src/decision.rs @@ -0,0 +1,167 @@ +use serde::{Deserialize, Serialize}; +use crate::{ConflictSet, Fp, Incoming, ItemState, Lineage, Vid, VidRecord}; + +/// ACK discriminant order is the frozen sync contract (§12.3). +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum AckResult { + /// Durable application, convergence, or already-seen version (§12.5). + Applied, + /// Durably retained for human review (§12.3). + Held, + /// Durably retained as a conflict (§2.4). + Conflict, + /// Receiver generation does not match (§12.2). + StaleGeneration, + /// Not retained; sender must retry and keep its snapshot (§12.3). + DeferredCapacity, + /// Rejected, including immutable-vid violations (§12.5). + Rejected, +} + +impl AckResult { + /// Only capacity deferral is non-final (§12.3). + pub fn is_final(self) -> bool { self != Self::DeferredCapacity } +} + +/// Evidence supplied only by an external approval verifier; Phase 1 always uses `None` (§12.5). +#[derive(Debug)] +pub struct VerifiedApproval { _private: () } + +impl VerifiedApproval { + /// Test-only escape hatch; never call in production Phase 1 code (§12.5). + #[doc(hidden)] + pub fn for_tests() -> Self { Self { _private: () } } +} + +/// Human-review reason in decision precedence order (§12.5). +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +pub enum HoldReason { + /// Receiver or peer is frozen (§4, §12.5). + Frozen, + /// No verified approval authorizes the operation (§12.5). + NoApproval, + /// Rate or checkpoint capacity prevents application (§4, §12.3). + OverLimit, + /// Complete Phase-1 resolve requires review (§2.4, §12.5). + Resolve, +} + +/// Side-effect-free state intent; persistence and slot allocation precede ACK (§12.4). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub enum Transition { + /// Preserve state for stale, rejected, duplicate, or capacity-deferred messages (§12.5). + Unchanged, + /// Preserve the incoming value in a held slot (§12.3). + Hold { + /// Why human review is required (§12.5). + reason: HoldReason, + }, + /// Retain the complete unresolved candidate set without overwriting (§2.4). + Conflict { + /// Includes the receiver's current head and the incoming Put, if any (§2.4). + candidates: ConflictSet, + }, + /// Update version metadata, optionally writing the incoming value (§2.2, §12.4). + Advance { + /// Deterministic resulting head (§2.2). + head: Vid, + /// Merged ancestry with the resulting head retained (§2.4). + lineage: Lineage, + /// False for same-value convergence (§2.2). + write_value: bool, + /// Clear all candidates only after a complete approved resolve (§2.4). + clear_conflict: bool, + }, + /// Remove registration only; caller retains the keychain value (§2.5, §12.2). + Retire, +} + +/// Ordered decision and required ACK; caller must commit before sending it (§12.4, §12.5). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct Decision { + /// Result to ACK after durable handling (§12.3). + pub ack: AckResult, + /// Resulting state intent (§12.5). + pub transition: Transition, + /// Quarantine this peer's stream for this item on immutable-vid violation (§2.2). + pub quarantine: bool, +} + +impl Decision { + pub(crate) fn held(reason: HoldReason) -> Self { + Self { ack: AckResult::Held, transition: Transition::Hold { reason }, quarantine: false } + } + + pub(crate) fn unchanged(ack: AckResult) -> Self { + Self { ack, transition: Transition::Unchanged, quarantine: false } + } +} + +fn conflict(state: &ItemState, current_fp: Fp, incoming: &Incoming) -> Decision { + let mut candidates = state.conflict.clone().unwrap_or_default(); + candidates.candidates.entry(state.head).or_insert_with(|| VidRecord { + fp: current_fp, + parents: state.record(&state.head).map(|r| r.parents.clone()).unwrap_or_default(), + }); + if let Some(fp) = incoming.value_fp { + candidates.candidates.insert(incoming.new_vid, VidRecord { fp, parents: incoming.parents.clone() }); + } + Decision { ack: AckResult::Conflict, transition: Transition::Conflict { candidates }, quarantine: false } +} + +fn advance(state: &ItemState, incoming: &Incoming, convergence: bool, resolve: bool) -> Decision { + if incoming.retire { + return Decision { ack: AckResult::Applied, transition: Transition::Retire, quarantine: false }; + } + let head = if convergence { state.head.max(incoming.new_vid) } else { incoming.new_vid }; + let lineage = Lineage::merge(&state.lineage, &incoming.lineage); + let lineage = Lineage::new(lineage.iter().copied().chain([state.head, incoming.new_vid])).with_head(head); + Decision { ack: AckResult::Applied, quarantine: false, transition: Transition::Advance { + head, lineage, write_value: !convergence, clear_conflict: resolve, + } } +} + +/// Implements the first-match table, rows 1–9, including resolve and non-deleting Retire (§12.5). +pub fn decide(state: &ItemState, current_fp: Fp, incoming: &Incoming, frozen: bool, + approval: Option<&VerifiedApproval>, within_limits: bool) -> Decision +{ + // Rows 1 and 2 deliberately outrank all other conditions. + if incoming.generation != state.generation { return Decision::unchanged(AckResult::StaleGeneration); } + if frozen { return Decision::held(HoldReason::Frozen); } + // Row 3: consult all retained immutable bindings, not just the head. + let violation = state.record(&incoming.new_vid).is_some_and(|r| + incoming.value_fp != Some(r.fp) || incoming.parents != r.parents) + || (incoming.new_vid == state.head && incoming.value_fp != Some(current_fp)); + if violation { + return Decision { ack: AckResult::Rejected, transition: Transition::Unchanged, quarantine: true }; + } + // Row 4: an already-known ancestor is acknowledged without another write. + if incoming.new_vid == state.head || state.lineage.contains(&incoming.new_vid) { + return Decision::unchanged(AckResult::Applied); + } + // Malformed operations cannot reach any value-writing transition. + if incoming.retire == incoming.value_fp.is_some() { return Decision::unchanged(AckResult::Rejected); } + // Retire has no candidate value; without approval it can only request review (§2.5). + if incoming.retire && approval.is_none() { return Decision::held(HoldReason::NoApproval); } + // Row 5: complete parent coverage is necessary even with a verified approval. + if let Some(candidates) = &state.conflict { + let complete = incoming.parents.contains(&state.head) + && candidates.candidates.keys().all(|vid| incoming.parents.contains(vid)); + if !complete { return conflict(state, current_fp, incoming); } + if approval.is_none() { return Decision::held(HoldReason::Resolve); } + if !within_limits { return Decision::held(HoldReason::OverLimit); } + return advance(state, incoming, false, true); + } + // Row 6 is metadata-only convergence; Retire has no value to converge. + if incoming.value_fp == Some(current_fp) { return advance(state, incoming, true, false); } + let direct = incoming.parents.as_slice() == [state.head]; + // Row 7: callers cannot substitute claimed lineage for signed direct parents. + if direct && approval.is_some() && within_limits { return advance(state, incoming, false, false); } + // Row 8; an unapproved Retire is always review-only (§2.5). + if direct || (incoming.retire && approval.is_none()) { + return Decision::held(if approval.is_none() { HoldReason::NoApproval } else { HoldReason::OverLimit }); + } + // Row 9. + conflict(state, current_fp, incoming) +} diff --git a/crates/kc-sync/src/generation.rs b/crates/kc-sync/src/generation.rs new file mode 100644 index 0000000..f140238 --- /dev/null +++ b/crates/kc-sync/src/generation.rs @@ -0,0 +1,78 @@ +use std::collections::{BTreeMap, BTreeSet}; +use serde::{Deserialize, Serialize}; +use crate::PeerId; + +/// Receiver-issued registration message, with explicit peer scoping (§12.2). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct Registration { + /// Name being accepted or left (§12.2). + pub name: String, + /// Receiver-owned generation (§12.2). + pub generation: u64, +} + +/// Exhaustion must not wrap a receiver's generation and revive stale changes (§12.2). +#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)] +#[error("registration generation exhausted")] +pub struct GenerationExhausted; + +#[derive(Debug, Clone, Default, Serialize, Deserialize)] +struct Owned { generation: u64, peers: BTreeSet } + +#[derive(Debug, Clone, Serialize, Deserialize)] +struct Remote { generation: u64, accepted: bool } + +/// Receiver generations and sender-side Accept/Leave bookkeeping, never automatic enrollment (§12.2). +#[derive(Debug, Clone, Default, Serialize, Deserialize)] +pub struct Generations { + owned: BTreeMap, + remote: BTreeMap>, +} + +impl Generations { + /// Returns the generation owned by this receiver, initially zero (§12.2). + pub fn generation(&self, name: &str) -> u64 { self.owned.get(name).map_or(0, |o| o.generation) } + + /// Human review accepts an offer for exactly the specified peer (§2.1, §12.2). + pub fn accept(&mut self, name: &str, peer: PeerId) -> Registration { + let owned = self.owned.entry(name.into()).or_default(); + owned.peers.insert(peer); + Registration { name: name.into(), generation: owned.generation } + } + + /// Checks local registration membership for a peer/name (§2.1, §12.2). + pub fn includes(&self, name: &str, peer: &PeerId) -> bool { + self.owned.get(name).is_some_and(|o| o.peers.contains(peer)) + } + + /// Removes local membership and bumps its generation; send Leave to returned peers (§12.2). + pub fn rm(&mut self, name: &str) -> Result<(Registration, BTreeSet), GenerationExhausted> { + let owned = self.owned.entry(name.into()).or_default(); + let next = owned.generation.checked_add(1).ok_or(GenerationExhausted)?; + owned.generation = next; + let peers = std::mem::take(&mut owned.peers); + Ok((Registration { name: name.into(), generation: next }, peers)) + } + + /// Records a peer's Accept, ignoring generations older than a previously observed Leave (§12.2). + pub fn received_accept(&mut self, peer: PeerId, accept: Registration) -> bool { + let names = self.remote.entry(peer).or_default(); + if names.get(&accept.name).is_some_and(|r| r.generation > accept.generation) { return false; } + names.insert(accept.name, Remote { generation: accept.generation, accepted: true }); + true + } + + /// Records a peer's Leave without permitting reordered older messages to roll it back (§12.2). + pub fn received_leave(&mut self, peer: PeerId, leave: Registration) -> bool { + let names = self.remote.entry(peer).or_default(); + if names.get(&leave.name).is_some_and(|r| r.generation > leave.generation) { return false; } + names.insert(leave.name, Remote { generation: leave.generation, accepted: false }); + true + } + + /// Returns the receiver-issued generation only after Accept and before Leave (§12.2). + pub fn outgoing_generation(&self, peer: &PeerId, name: &str) -> Option { + let remote = self.remote.get(peer)?.get(name)?; + remote.accepted.then_some(remote.generation) + } +} diff --git a/crates/kc-sync/src/lib.rs b/crates/kc-sync/src/lib.rs new file mode 100644 index 0000000..28ee92a --- /dev/null +++ b/crates/kc-sync/src/lib.rs @@ -0,0 +1,21 @@ +//! Side-effect-free `kc sync` policy from docs/design/sync.md §§2, 4, 12.2–12.5. +//! Callers own authentication, durable storage, locks, fingerprints, and ACK delivery. +//! A returned transition is an intent: ACK only after its durable commit (§12.4). +#![forbid(unsafe_code)] +#![warn(missing_docs)] + +mod decision; +mod generation; +mod limiter; +mod outbox; +mod recovery; +mod slots; +mod state; + +pub use decision::*; +pub use generation::*; +pub use limiter::*; +pub use outbox::*; +pub use recovery::*; +pub use slots::*; +pub use state::*; diff --git a/crates/kc-sync/src/limiter.rs b/crates/kc-sync/src/limiter.rs new file mode 100644 index 0000000..0e0d0b4 --- /dev/null +++ b/crates/kc-sync/src/limiter.rs @@ -0,0 +1,90 @@ +use std::collections::{BTreeMap, BTreeSet}; +use serde::{Deserialize, Serialize}; +use crate::PeerId; + +/// Rolling non-interactive overwrite and peer breaker window in seconds (§4). +pub const WINDOW_SECS: i64 = 24 * 60 * 60; + +/// Counted remote operation; retirement never deletes a value (§4, §2.5). +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +pub enum RemoteOperation { + /// Value overwrite (§4). + Overwrite, + /// Registration removal (§4). + Retire, +} + +/// Limiter outcome that the caller feeds into `decide` (§4, §12.5). +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum LimitResult { + /// Within both item and peer limits (§4). + Allowed, + /// This item already had a non-interactive overwrite in the window (§4). + ItemLimited, + /// Peer is latched off until a human resets it; hold all its messages (§4). + PeerTripped, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +struct Event { at: i64, name: String, op: RemoteOperation } + +/// Serializable deterministic limiter; caller supplies time and records only committed operations (§4). +#[derive(Debug, Clone, Default, Serialize, Deserialize)] +pub struct Limiter { + items: BTreeMap, + events: BTreeMap>, + tripped: BTreeSet, +} + +fn recent(at: i64, now: i64) -> bool { + // Future timestamps remain active under clock rollback, including i64 extremes. + (now as i128) - (at as i128) < WINDOW_SECS as i128 +} + +impl Limiter { + /// Checks the proposed operation and latches a breaker before crossing a threshold (§4). + pub fn check(&mut self, peer: &PeerId, name: &str, op: RemoteOperation, + now: i64, sync_set_size: usize, interactive: bool) -> LimitResult + { + if self.tripped.contains(peer) { return LimitResult::PeerTripped; } + self.prune(now); + let events = self.events.get(peer).map(Vec::as_slice).unwrap_or_default(); + let overwrites = events.iter().filter(|e| e.op == RemoteOperation::Overwrite).count() + + usize::from(op == RemoteOperation::Overwrite); + let retires = events.iter().filter(|e| e.op == RemoteOperation::Retire).count() + + usize::from(op == RemoteOperation::Retire); + let affected: BTreeSet<&str> = events.iter().map(|e| e.name.as_str()).chain([name]).collect(); + if overwrites > 5 || retires > 3 + || (sync_set_size >= 8 && affected.len() > sync_set_size / 4) + { + self.tripped.insert(peer.clone()); + return LimitResult::PeerTripped; + } + if op == RemoteOperation::Overwrite && !interactive + && self.items.get(name).is_some_and(|at| recent(*at, now)) + { return LimitResult::ItemLimited; } + LimitResult::Allowed + } + + /// Records an actually committed operation; interactive writes bypass only the item cap (§4). + pub fn record(&mut self, peer: &PeerId, name: &str, op: RemoteOperation, now: i64, interactive: bool) { + self.prune(now); + if op == RemoteOperation::Overwrite && !interactive { self.items.insert(name.into(), now); } + self.events.entry(peer.clone()).or_default().push(Event { at: now, name: name.into(), op }); + } + + /// Tests the sticky peer breaker for any incoming message, including offers (§4). + pub fn is_tripped(&self, peer: &PeerId) -> bool { self.tripped.contains(peer) } + + /// Human reset clears this peer's breaker history but preserves per-item overwrite limits (§4). + pub fn human_reset(&mut self, peer: &PeerId) { + self.tripped.remove(peer); + self.events.remove(peer); + } + + /// Drops expired counters without clearing sticky breakers (§4). + pub fn prune(&mut self, now: i64) { + self.items.retain(|_, at| recent(*at, now)); + self.events.retain(|_, events| { events.retain(|e| recent(e.at, now)); !events.is_empty() }); + } +} diff --git a/crates/kc-sync/src/outbox.rs b/crates/kc-sync/src/outbox.rs new file mode 100644 index 0000000..ca706bf --- /dev/null +++ b/crates/kc-sync/src/outbox.rs @@ -0,0 +1,118 @@ +use std::collections::{BTreeMap, BTreeSet}; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; +use crate::{AckResult, PeerId, Vid}; + +/// Exact receiver-specific change identity; vids are random, not chronological (§12.3). +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)] +pub struct ChangeId { + /// Item name (§12.3). + pub name: String, + /// Target receiver's accepted generation (§12.2). + pub generation: u64, + /// Immutable version being delivered (§12.3). + pub new_vid: Vid, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +struct Delivery { order: u64, final_ack: Option } + +/// Per-peer queues and all-target snapshot retention; contains no values (§2.8, §12.3). +#[derive(Debug, Clone, Default, Serialize, Deserialize)] +pub struct Outbox { + #[serde(serialize_with = "serialize_deliveries", deserialize_with = "deserialize_deliveries")] + deliveries: BTreeMap>, + reoffer: BTreeMap>, + next_order: u64, +} + +fn serialize_deliveries(deliveries: &BTreeMap>, s: S) -> Result { + deliveries.iter().map(|(peer, queue)| (peer, queue.iter().collect::>())).collect::>().serialize(s) +} + +fn deserialize_deliveries<'de, D: Deserializer<'de>>(d: D) -> Result>, D::Error> { + let peers = Vec::<(PeerId, Vec<(ChangeId, Delivery)>)>::deserialize(d)?; + let mut result = BTreeMap::new(); + for (peer, entries) in peers { + let count = entries.len(); + let queue: BTreeMap<_, _> = entries.into_iter().collect(); + if queue.len() != count || result.insert(peer, queue).is_some() { + return Err(serde::de::Error::custom("duplicate outbox identity")); + } + } + Ok(result) +} + +impl Outbox { + /// Adds an exact target delivery; repeated enqueue does not reset its ACK (§2.8, §12.3). + pub fn enqueue(&mut self, peer: PeerId, change: ChangeId) { + if self.deliveries.get(&peer).is_some_and(|q| q.contains_key(&change)) { return; } + // Renumbering is unnecessary in practice, but exhaustion must never invert ordering. + if self.next_order == u64::MAX { + let mut orders: Vec<_> = self.deliveries.values().flat_map(|q| q.values().map(|d| d.order)).collect(); + orders.sort_unstable(); + orders.dedup(); + for queue in self.deliveries.values_mut() { + for entry in queue.values_mut() { entry.order = orders.binary_search(&entry.order).unwrap() as u64; } + } + self.next_order = orders.len() as u64; + } + self.deliveries.entry(peer).or_default().insert(change, Delivery { order: self.next_order, final_ack: None }); + self.next_order += 1; + } + + /// Applies a final exact ACK and supersedes only earlier entries for this peer/name (§12.3). + pub fn ack(&mut self, peer: &PeerId, change: &ChangeId, result: AckResult) -> bool { + if !result.is_final() { return false; } + let Some(queue) = self.deliveries.get_mut(peer) else { return false; }; + let Some(delivery) = queue.get(change) else { return false; }; + if delivery.final_ack.is_some() { return false; } + let order = delivery.order; + for (id, delivery) in queue.iter_mut() { + if id.name == change.name && delivery.order <= order && delivery.final_ack.is_none() { + delivery.final_ack = Some(result); + } + } + if result == AckResult::StaleGeneration { + self.reoffer.entry(peer.clone()).or_default().insert(change.name.clone()); + } + true + } + + /// Iterates only pending exact entries for a peer; finalized metadata is retained until release (§12.3). + pub fn pending<'a>(&'a self, peer: &PeerId) -> impl Iterator { + self.deliveries.get(peer).into_iter().flat_map(|q| q.iter()) + .filter(|(_, d)| d.final_ack.is_none()).map(|(id, _)| id) + } + + /// True only for a known snapshot with a final ACK from every target peer/generation (§12.3). + pub fn snapshot_releasable(&self, name: &str, vid: Vid) -> bool { + let mut found = false; + for queue in self.deliveries.values() { + for (id, delivery) in queue { + if id.name == name && id.new_vid == vid { + found = true; + if delivery.final_ack.is_none() { return false; } + } + } + } + found + } + + /// Removes finalized bookkeeping only once the shared snapshot is releasable (§12.3). + pub fn release_snapshot(&mut self, name: &str, vid: Vid) -> bool { + if !self.snapshot_releasable(name, vid) { return false; } + for queue in self.deliveries.values_mut() { queue.retain(|id, _| id.name != name || id.new_vid != vid); } + self.deliveries.retain(|_, q| !q.is_empty()); + true + } + + /// Exposes the stale-generation status for a peer/name (§12.2). + pub fn needs_reoffer(&self, peer: &PeerId, name: &str) -> bool { + self.reoffer.get(peer).is_some_and(|names| names.contains(name)) + } + + /// Clears the re-offer status after a new Accept (§12.2). + pub fn accepted(&mut self, peer: &PeerId, name: &str) { + if let Some(names) = self.reoffer.get_mut(peer) { names.remove(name); } + } +} diff --git a/crates/kc-sync/src/recovery.rs b/crates/kc-sync/src/recovery.rs new file mode 100644 index 0000000..705e83d --- /dev/null +++ b/crates/kc-sync/src/recovery.rs @@ -0,0 +1,101 @@ +use serde::{Deserialize, Serialize}; +use crate::{AckResult, ChangeId, Fp, Lineage, PeerId, Vid}; + +/// Complete remote transaction intent, persisted before slots or keychain writes (§12.4). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct RemoteJournalRecord { + /// Exact acknowledged change (§12.4). + pub change_id: ChangeId, + /// Authenticated source peer (§12.4). + pub sender: PeerId, + /// Fingerprint before the intended write (§12.4). + pub prev_fp: Fp, + /// Intended fingerprint after the write (§12.4). + pub new_fp: Fp, + /// Head installed at step 4 (§12.4). + pub head: Vid, + /// Lineage installed at step 4 (§12.4). + pub lineage: Lineage, + /// Verified approval consumption key, absent for human-reviewed Phase 1 changes (§12.4). + pub approval_key: Option, + /// ACK queued only after step 4 commits (§12.4). + pub ack: AckResult, + /// Recovery baseline slot reserved before writing (§12.4). + pub checkpoint_slot: Option, + /// Slot holding the intended incoming value (§12.4). + pub candidate_slot: String, +} + +/// Receiver-specific queued target captured by the local transaction (§12.4). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct QueueTarget { + /// Destination peer (§12.4). + pub peer: PeerId, + /// Generation granted by this destination (§12.2, §12.4). + pub generation: u64, +} + +/// Complete local-change intent, including snapshot and target generations (§12.4). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct LocalJournalRecord { + /// Changed item name (§12.4). + pub name: String, + /// Previous keychain fingerprint (§12.4). + pub prev_fp: Fp, + /// Newly written or observed fingerprint (§12.4). + pub new_fp: Fp, + /// Caller-generated immutable version (§12.4). + pub new_vid: Vid, + /// Direct parents captured before writing (§12.4). + pub parents: Vec, + /// Outbound value snapshot retained while queues reference it (§12.4). + pub snapshot_slot: String, + /// Exact destination peers and their registration generations (§12.4). + pub targets: Vec, +} + +/// Recovery action for a remote transaction; never overwrites unrelated current values (§12.4). +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum RemoteRecovery { + /// Write happened: finish metadata, approval consumption, and ACK queue (§12.4). + FinishFromStep4, + /// Write did not happen: clear intent and retry (§12.4). + Retry, + /// Another value is current: preserve it and record a conflict (§12.4). + Conflict, +} + +/// Classifies a remote journal by fingerprint, with intended-value equality taking precedence (§12.4). +pub fn recover_remote(record: &RemoteJournalRecord, current_fp: Fp) -> RemoteRecovery { + if current_fp == record.new_fp { RemoteRecovery::FinishFromStep4 } + else if current_fp == record.prev_fp { RemoteRecovery::Retry } + else { RemoteRecovery::Conflict } +} + +/// Exactly the six local-journal recovery rows, in design-table order (§12.4). +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum LocalRecovery { + /// Row 1: copy current value into the missing snapshot, then commit and clean journal (§12.4). + RebuildSnapshotAndCommit, + /// Row 2: existing snapshot is ready; commit metadata then clean journal (§12.4). + Commit, + /// Row 3: already committed and value matches; clean journal only (§12.4). + CleanJournal, + /// Row 4: retain queued snapshot, clean journal, and scan current value as a new version (§12.4). + KeepSnapshotAndScan, + /// Row 5: write never happened; delete any unreferenced snapshot and clean journal (§12.4). + DiscardSnapshot, + /// Row 6: discard uncommitted snapshot, clean journal, and scan current value (§12.4). + DiscardSnapshotAndScan, +} + +/// Classifies all six rows; `committed` means stored head equals the journal's new vid (§12.4). +pub fn recover_local(prev_fp: Fp, new_fp: Fp, current_fp: Fp, committed: bool, snapshot_exists: bool) -> LocalRecovery { + if current_fp == new_fp { + if committed { LocalRecovery::CleanJournal } + else if snapshot_exists { LocalRecovery::Commit } + else { LocalRecovery::RebuildSnapshotAndCommit } + } else if committed { LocalRecovery::KeepSnapshotAndScan } + else if current_fp == prev_fp { LocalRecovery::DiscardSnapshot } + else { LocalRecovery::DiscardSnapshotAndScan } +} diff --git a/crates/kc-sync/src/slots.rs b/crates/kc-sync/src/slots.rs new file mode 100644 index 0000000..1a78587 --- /dev/null +++ b/crates/kc-sync/src/slots.rs @@ -0,0 +1,120 @@ +use std::collections::BTreeMap; +use serde::{Deserialize, Serialize}; +use crate::{AckResult, Decision, Fp, HoldReason}; + +/// Slot priority in increasing order; checkpoints are never evicted (§12.3). +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +pub enum SlotKind { + /// Lowest-priority unsolicited offer (§12.3). + Proposal, + /// Value waiting for human review (§12.3). + Held, + /// Unresolved candidate or outbound value snapshot (§2.6, §12.3). + ConflictCandidate, + /// Human-confirmed recovery baseline (§2.6). + Checkpoint, +} + +/// Reservation result; callers must durably remove evicted lower-priority slots (§12.3). +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum Reservation { + /// Reservation succeeded, possibly evicting a lower-priority slot (§12.3). + Reserved { + /// Evicted slot name, if any; never a checkpoint (§12.3). + evicted: Option, + }, + /// No space, or the name already belongs to a different slot kind (§12.3). + Refused, +} + +/// Serializable slot ledger with deterministic lower-priority eviction (§12.3). +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct SlotBudget { + capacity: usize, + slots: BTreeMap, + pinned_snapshots: std::collections::BTreeSet, +} + +impl SlotBudget { + /// Creates a budget of max(16, items × 4), saturating arithmetic (§12.3). + pub fn new(items: usize) -> Self { + Self { capacity: items.saturating_mul(4).max(16), slots: BTreeMap::new(), pinned_snapshots: Default::default() } + } + /// Returns the configured total capacity (§12.3). + pub fn capacity(&self) -> usize { self.capacity } + /// Returns the count of reserved slots (§12.3). + pub fn used(&self) -> usize { self.slots.len() } + /// Looks up a reservation without touching its value (§12.3). + pub fn kind(&self, name: &str) -> Option { self.slots.get(name).copied() } + + /// Reserves a slot; new Held and Proposal slots never evict at capacity (§12.3). + pub fn reserve(&mut self, name: &str, kind: SlotKind) -> Reservation { + if let Some(existing) = self.slots.get(name) { + return if *existing == kind { Reservation::Reserved { evicted: None } } else { Reservation::Refused }; + } + let mut evicted = None; + if self.slots.len() >= self.capacity { + if kind <= SlotKind::Held { return Reservation::Refused; } + evicted = self.slots.iter() + .filter(|(name, existing)| **existing < kind && !self.pinned_snapshots.contains(*name)) + .min_by_key(|(name, existing)| (**existing, *name)) + .map(|(name, _)| name.clone()); + let Some(victim) = &evicted else { return Reservation::Refused; }; + self.slots.remove(victim); + } + self.slots.insert(name.into(), kind); + Reservation::Reserved { evicted } + } + + /// Reserves an outbound snapshot pinned until all-target final ACK (§2.8, §12.3). + pub fn reserve_snapshot(&mut self, name: &str) -> Reservation { + let result = self.reserve(name, SlotKind::ConflictCandidate); + if matches!(result, Reservation::Reserved { .. }) { self.pinned_snapshots.insert(name.into()); } + result + } + + /// Releases resolved/rejected slots or finally acknowledged snapshots, never checkpoints (§12.3). + pub fn release(&mut self, name: &str) -> bool { + if self.slots.get(name) == Some(&SlotKind::Checkpoint) { return false; } + self.pinned_snapshots.remove(name); + self.slots.remove(name).is_some() + } + + /// Ensures a checkpoint before overwrite; fallback is held, then capacity deferral (§2.6, §12.3). + pub fn prepare_overwrite(&mut self, checkpoint_slot: &str, held_slot: &str) -> OverwriteCapacity { + match self.reserve(checkpoint_slot, SlotKind::Checkpoint) { + Reservation::Reserved { evicted } => OverwriteCapacity::Ready { evicted }, + Reservation::Refused => match self.reserve(held_slot, SlotKind::Held) { + Reservation::Reserved { .. } => OverwriteCapacity::Held(Decision::held(HoldReason::OverLimit)), + Reservation::Refused => OverwriteCapacity::Deferred(Decision::unchanged(AckResult::DeferredCapacity)), + }, + } + } +} + +/// First-overwrite capacity gate; only Ready permits a keychain write (§2.6, §12.3). +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum OverwriteCapacity { + /// Checkpoint slot exists before the overwrite (§2.6). + Ready { + /// Lower-priority reservation displaced by the checkpoint (§12.3). + evicted: Option, + }, + /// Retain incoming value for review (§12.3). + Held(Decision), + /// Retain nothing and ask sender to retry (§12.3). + Deferred(Decision), +} + +/// Recovery baseline whose fingerprint cannot be replaced by remote overwrites (§2.6). +#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)] +pub struct Checkpoint { fp: Option } + +impl Checkpoint { + /// Captures the original value only on the first remote overwrite (§2.6). + pub fn before_remote_overwrite(&mut self, current: Fp) -> Fp { *self.fp.get_or_insert(current) } + /// Returns the retained fingerprint for caller-owned recovery storage (§2.6). + pub fn fingerprint(&self) -> Option { self.fp } + /// Explicit human confirmation is the only way to replace a baseline (§2.6). + pub fn human_confirm(&mut self, current: Fp) { self.fp = Some(current); } +} diff --git a/crates/kc-sync/src/state.rs b/crates/kc-sync/src/state.rs new file mode 100644 index 0000000..e532d48 --- /dev/null +++ b/crates/kc-sync/src/state.rs @@ -0,0 +1,159 @@ +use std::collections::{BTreeMap, BTreeSet}; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +// Structured keys are encoded as pairs so state remains usable in sync.json as well as binary serde. +pub(crate) fn serialize_map(map: &BTreeMap, s: S) -> Result { + map.iter().collect::>().serialize(s) +} + +pub(crate) fn deserialize_map<'de, D: Deserializer<'de>, K: Deserialize<'de> + Ord, V: Deserialize<'de>>(d: D) -> Result, D::Error> { + let pairs = Vec::<(K, V)>::deserialize(d)?; + let count = pairs.len(); + let map: BTreeMap<_, _> = pairs.into_iter().collect(); + if map.len() != count { return Err(serde::de::Error::custom("duplicate map key")); } + Ok(map) +} + +/// Opaque, caller-generated version identifier (§2.2). +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)] +pub struct Vid(pub [u8; 16]); + +/// Opaque, locally computed value fingerprint; never a wire value (§2.2). +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] +pub struct Fp(pub [u8; 32]); + +/// Opaque peer key, independent of transport or display labels (§12.2). +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)] +pub struct PeerId(pub String); + +/// Maximum retained lineage size (§2.4). +pub const MAX_LINEAGE: usize = 64; +/// Bounded immutable-VID cache; unresolved candidate records live separately (§2.2, §2.4). +pub const MAX_KNOWN: usize = 256; + +/// Sorted, bounded set of version identifiers (§2.4). +#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)] +#[serde(transparent)] +pub struct Lineage(BTreeSet); + +impl<'de> Deserialize<'de> for Lineage { + fn deserialize>(d: D) -> Result { + let values = BTreeSet::::deserialize(d)?; + if values.len() > MAX_LINEAGE { + return Err(serde::de::Error::custom("lineage exceeds 64 vids")); + } + Ok(Self(values)) + } +} + +impl Lineage { + /// Retains the greatest 64 distinct vids, deterministically (§2.4). + pub fn new(vids: impl IntoIterator) -> Self { + let mut result = Self(vids.into_iter().collect()); + while result.0.len() > MAX_LINEAGE { result.0.pop_first(); } + result + } + + /// Unions two lineages, dropping smallest identifiers first (§2.4). + pub fn merge(a: &Self, b: &Self) -> Self { + Self::new(a.0.union(&b.0).copied()) + } + + /// Pins the resulting current head even when it is smaller than retained ancestors (§2.4). + pub fn with_head(mut self, head: Vid) -> Self { + self.0.insert(head); + if self.0.len() > MAX_LINEAGE { + let victim = self.0.iter().copied().find(|v| *v != head).unwrap(); + self.0.remove(&victim); + } + self + } + + /// Tests ancestry membership without trusting remote ancestry for authorization (§2.2). + pub fn contains(&self, vid: &Vid) -> bool { self.0.contains(vid) } + /// Returns identifiers in deterministic ascending order (§2.4). + pub fn iter(&self) -> impl Iterator { self.0.iter() } + /// Returns the retained identifier count (§2.4). + pub fn len(&self) -> usize { self.0.len() } + /// Reports an empty ancestry set (§2.4). + pub fn is_empty(&self) -> bool { self.0.is_empty() } +} + +/// Immutable value and direct-parent binding for a known version (§2.2, §2.4). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct VidRecord { + /// Locally computed value fingerprint (§2.2). + pub fp: Fp, + /// Exact ordered parent list bound to this vid (§2.4). + pub parents: Vec, +} + +/// Preserved unresolved heads and their immutable bindings (§2.4). +#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] +pub struct ConflictSet { + /// Candidate values must remain in caller-owned slots until resolve or rejection (§12.3). + #[serde(serialize_with = "serialize_map", deserialize_with = "deserialize_map")] + pub candidates: BTreeMap, +} + +/// Receiver-owned item state; construct/update its bounded cache with `remember` (§2.2, §12.2). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct ItemState { + /// Receiver's registration generation (§12.2). + pub generation: u64, + /// Current value's immutable version (§2.2). + pub head: Vid, + /// Bounded ancestry, with the head pinned by transitions (§2.4). + pub lineage: Lineage, + /// All unresolved candidate values, including the current head (§2.4). + pub conflict: Option, + /// Bounded recent bindings; candidate bindings are additionally kept in `conflict` (§2.4). + #[serde(serialize_with = "serialize_map", deserialize_with = "deserialize_known")] + pub known: BTreeMap, +} + +fn deserialize_known<'de, D: Deserializer<'de>>(d: D) -> Result, D::Error> { + let known: BTreeMap = deserialize_map(d)?; + if known.len() > MAX_KNOWN { return Err(serde::de::Error::custom("known cache exceeds bound")); } + Ok(known) +} + +impl ItemState { + /// Initializes a single local head using caller-supplied randomness (§2.2). + pub fn new(generation: u64, head: Vid, fp: Fp, parents: Vec) -> Self { + Self { generation, head, lineage: Lineage::new([head]), conflict: None, + known: BTreeMap::from([(head, VidRecord { fp, parents })]) } + } + + /// Remembers a binding, rejects mutation, and deterministically bounds the cache (§2.2, §2.4). + pub fn remember(&mut self, vid: Vid, record: VidRecord) -> bool { + if self.record(&vid).is_some_and(|old| old != &record) { return false; } + self.known.insert(vid, record); + while self.known.len() > MAX_KNOWN { + let victim = self.known.keys().copied().find(|v| *v != self.head).unwrap(); + self.known.remove(&victim); + } + true + } + + pub(crate) fn record(&self, vid: &Vid) -> Option<&VidRecord> { + self.known.get(vid).or_else(|| self.conflict.as_ref()?.candidates.get(vid)) + } +} + +/// Authenticated envelope data plus locally computed fingerprint for decision-making (§12.5). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct Incoming { + /// Generation previously supplied by this receiver (§12.2). + pub generation: u64, + /// Immutable proposed version (§2.2). + pub new_vid: Vid, + /// Claimed direct parents; approval verification must bind this exact list (§12.5). + pub parents: Vec, + /// Claimed bounded ancestry, never sufficient to authorize overwrites (§2.2). + pub lineage: Lineage, + /// Local fingerprint of Put value; absent for Retire (§2.5). + pub value_fp: Option, + /// Unregister only; this operation must never delete a value (§2.5). + pub retire: bool, +} diff --git a/crates/kc-sync/tests/policy.rs b/crates/kc-sync/tests/policy.rs new file mode 100644 index 0000000..ae70b6e --- /dev/null +++ b/crates/kc-sync/tests/policy.rs @@ -0,0 +1,388 @@ +use std::collections::BTreeMap; +use kc_sync::*; + +fn v(n: u16) -> Vid { let mut b = [0; 16]; b[14..].copy_from_slice(&n.to_be_bytes()); Vid(b) } +fn f(n: u8) -> Fp { Fp([n; 32]) } +fn peer(n: &str) -> PeerId { PeerId(n.into()) } +fn state() -> ItemState { ItemState::new(7, v(1), f(1), vec![v(0)]) } +fn incoming() -> Incoming { + Incoming { generation: 7, new_vid: v(2), parents: vec![v(1)], + lineage: Lineage::new([v(1), v(2)]), value_fp: Some(f(2)), retire: false } +} +fn run(s: &ItemState, i: &Incoming) -> Decision { decide(s, f(1), i, false, None, true) } +fn held(d: &Decision, reason: HoldReason) { + assert_eq!(d.ack, AckResult::Held); + assert_eq!(d.transition, Transition::Hold { reason }); + assert!(!d.quarantine); +} +fn conflicted() -> ItemState { + let mut s = state(); + s.conflict = Some(ConflictSet { candidates: BTreeMap::from([ + (v(1), VidRecord { fp: f(1), parents: vec![v(0)] }), + (v(3), VidRecord { fp: f(3), parents: vec![v(0)] }), + (v(4), VidRecord { fp: f(4), parents: vec![v(0)] }), + ]) }); s +} + +#[test] +fn row1_stale_beats_freeze_violation_conflict_approval_and_limits() { + let mut i = incoming(); i.generation = 6; i.new_vid = v(1); + let d = decide(&conflicted(), f(1), &i, true, Some(&VerifiedApproval::for_tests()), false); + assert_eq!(d.ack, AckResult::StaleGeneration); assert_eq!(d.transition, Transition::Unchanged); assert!(!d.quarantine); +} +#[test] +fn row2_frozen_beats_fast_forward() { + held(&decide(&state(), f(1), &incoming(), true, Some(&VerifiedApproval::for_tests()), true), HoldReason::Frozen); +} +#[test] +fn row2_frozen_beats_violation() { + let mut i = incoming(); i.new_vid = v(1); + held(&decide(&state(), f(1), &i, true, None, true), HoldReason::Frozen); +} +#[test] +fn row3_same_vid_different_fp_is_quarantined() { + let mut i = incoming(); i.new_vid = v(1); i.parents = vec![v(0)]; + let d = run(&state(), &i); assert_eq!(d.ack, AckResult::Rejected); assert!(d.quarantine); +} +#[test] +fn row3_same_vid_different_parents_is_quarantined() { + let mut i = incoming(); i.new_vid = v(1); i.value_fp = Some(f(1)); + let d = run(&state(), &i); assert_eq!(d.ack, AckResult::Rejected); assert!(d.quarantine); +} +#[test] +fn row3_checks_non_head_known_and_conflict_records() { + let mut s = state(); s.remember(v(9), VidRecord { fp: f(9), parents: vec![v(0)] }); + let mut i = incoming(); i.new_vid = v(9); + assert!(run(&s, &i).quarantine); + i.new_vid = v(3); assert!(run(&conflicted(), &i).quarantine); +} +#[test] +fn row4_duplicate_head_applied_without_write() { + let mut i = incoming(); i.new_vid = v(1); i.value_fp = Some(f(1)); i.parents = vec![v(0)]; + assert_eq!(run(&state(), &i), Decision { ack: AckResult::Applied, transition: Transition::Unchanged, quarantine: false }); +} +#[test] +fn row4_ancestor_beats_conflict_and_no_approval() { + let mut s = conflicted(); s.lineage = Lineage::new([v(1), v(2)]); + assert_eq!(run(&s, &incoming()).transition, Transition::Unchanged); +} +#[test] +fn row5_adds_candidates_and_beats_same_value_and_fast_forward() { + let mut i = incoming(); i.value_fp = Some(f(1)); + let d = decide(&conflicted(), f(1), &i, false, Some(&VerifiedApproval::for_tests()), true); + let Transition::Conflict { candidates } = d.transition else { panic!("{d:?}"); }; + assert_eq!(candidates.candidates.len(), 4); assert!(candidates.candidates.contains_key(&v(2))); +} +#[test] +fn row5_complete_resolve_without_approval_requires_review() { + let mut i = incoming(); i.parents = vec![v(1), v(3), v(4), v(99)]; + held(&run(&conflicted(), &i), HoldReason::Resolve); +} +#[test] +fn row5_complete_approved_resolve_clears_conflict_atomically() { + let mut i = incoming(); i.parents = vec![v(1), v(3), v(4), v(99)]; + let d = decide(&conflicted(), f(1), &i, false, Some(&VerifiedApproval::for_tests()), true); + assert!(matches!(d.transition, Transition::Advance { head, clear_conflict: true, write_value: true, .. } if head == v(2))); +} +#[test] +fn row5_missing_any_candidate_including_own_head_stays_conflict() { + for missing in [v(1), v(3), v(4)] { + let mut i = incoming(); i.parents = [v(1), v(3), v(4)].into_iter().filter(|v| *v != missing).collect(); + for approved in [false, true] { + let token = VerifiedApproval::for_tests(); + let d = decide(&conflicted(), f(1), &i, false, approved.then_some(&token), true); + assert_eq!(d.ack, AckResult::Conflict); + } + } +} +#[test] +fn row5_resolve_obeys_limits() { + let mut i = incoming(); i.parents = vec![v(1), v(3), v(4)]; + held(&decide(&conflicted(), f(1), &i, false, Some(&VerifiedApproval::for_tests()), false), HoldReason::OverLimit); +} +#[test] +fn row6_same_value_converges_before_approval_and_limits() { + let mut i = incoming(); i.value_fp = Some(f(1)); i.parents = vec![v(55)]; + let d = decide(&state(), f(1), &i, false, None, false); + assert!(matches!(d.transition, Transition::Advance { head, write_value: false, .. } if head == v(2))); +} +#[test] +fn convergence_is_symmetric_even_when_lineage_truncates() { + let mut a = ItemState::new(7, v(5), f(1), vec![]); + let mut b = ItemState::new(7, v(80), f(1), vec![]); + a.lineage = Lineage::new((0..64).map(v)).with_head(a.head); + b.lineage = Lineage::new((50..114).map(v)).with_head(b.head); + let from = |s: &ItemState| Incoming { generation: 7, new_vid: s.head, parents: vec![], lineage: s.lineage.clone(), value_fp: Some(f(1)), retire: false }; + let da = decide(&a, f(1), &from(&b), false, None, true); + let db = decide(&b, f(1), &from(&a), false, None, true); + assert_eq!(da, db); + let Transition::Advance { head, lineage, .. } = da.transition else { panic!() }; + assert_eq!(head, v(80)); assert_eq!(lineage.len(), 64); assert!(lineage.contains(&head)); +} +#[test] +fn row7_approved_direct_parent_fast_forwards() { + let d = decide(&state(), f(1), &incoming(), false, Some(&VerifiedApproval::for_tests()), true); + assert!(matches!(d.transition, Transition::Advance { head, write_value: true, clear_conflict: false, .. } if head == v(2))); +} +#[test] +fn row8_phase1_direct_parent_is_held() { held(&run(&state(), &incoming()), HoldReason::NoApproval); } +#[test] +fn row8_approved_over_limit_is_held() { + held(&decide(&state(), f(1), &incoming(), false, Some(&VerifiedApproval::for_tests()), false), HoldReason::OverLimit); +} +#[test] +fn row9_forged_lineage_cannot_replace_parent_binding() { + let mut i = incoming(); i.parents = vec![v(99)]; assert!(i.lineage.contains(&state().head)); + for approved in [false, true] { + let token = VerifiedApproval::for_tests(); + assert_eq!(decide(&state(), f(1), &i, false, approved.then_some(&token), true).ack, AckResult::Conflict); + } +} +#[test] +fn retire_requires_approval_and_never_requests_value_deletion() { + let mut i = incoming(); i.retire = true; i.value_fp = None; + held(&run(&state(), &i), HoldReason::NoApproval); + assert_eq!(decide(&state(), f(1), &i, false, Some(&VerifiedApproval::for_tests()), true).transition, Transition::Retire); + held(&decide(&state(), f(1), &i, false, Some(&VerifiedApproval::for_tests()), false), HoldReason::OverLimit); + i.parents = vec![v(99)]; held(&run(&conflicted(), &i), HoldReason::NoApproval); + assert_eq!(decide(&state(), f(1), &i, false, Some(&VerifiedApproval::for_tests()), true).ack, AckResult::Conflict); +} +#[test] +fn malformed_put_or_retire_is_rejected() { + let mut i = incoming(); i.value_fp = None; assert_eq!(run(&state(), &i).ack, AckResult::Rejected); + i.value_fp = Some(f(2)); i.retire = true; assert_eq!(run(&state(), &i).ack, AckResult::Rejected); +} +#[test] +fn lineage_boundary_64_65_and_head_pinning() { + let a = Lineage::new((0..64).map(v)); assert_eq!(a.len(), 64); assert!(a.contains(&v(0))); + let b = Lineage::merge(&a, &Lineage::new([v(64)])); + assert_eq!(b.len(), 64); assert!(!b.contains(&v(0))); assert!(b.contains(&v(64))); + assert_eq!(b, Lineage::merge(&Lineage::new([v(64)]), &a)); + let pinned = b.with_head(v(0)); assert!(pinned.contains(&v(0))); assert!(!pinned.contains(&v(1))); assert_eq!(pinned.len(), 64); +} +#[test] +fn fast_forward_retains_small_random_head_at_capacity() { + let mut s = state(); s.lineage = Lineage::new((100..164).map(v)).with_head(v(1)); + let mut i = incoming(); i.new_vid = v(0); i.lineage = Lineage::new((200..264).map(v)); + let d = decide(&s, f(1), &i, false, Some(&VerifiedApproval::for_tests()), true); + let Transition::Advance { head, lineage, .. } = d.transition else { panic!() }; + assert!(lineage.contains(&head)); assert_eq!(head, v(0)); assert_eq!(lineage.len(), 64); +} +#[test] +fn lineage_serde_rejects_oversized_sets() { + let json = serde_json::to_string(&(0..65).map(v).collect::>()).unwrap(); + assert!(serde_json::from_str::(&json).is_err()); + let a = Lineage::new((0..64).map(v)); + assert_eq!(a, serde_json::from_str(&serde_json::to_string(&a).unwrap()).unwrap()); +} +#[test] +fn known_cache_is_bounded_and_immutable() { + let mut s = state(); + for n in 2..400 { assert!(s.remember(v(n), VidRecord { fp: f(2), parents: vec![] })); } + assert_eq!(s.known.len(), MAX_KNOWN); assert!(s.known.contains_key(&s.head)); + assert!(!s.remember(v(1), VidRecord { fp: f(9), parents: vec![] })); +} + +fn id(n: u16) -> ChangeId { ChangeId { name: "key".into(), generation: 7, new_vid: v(n) } } +#[test] +fn old_ack_never_deletes_newer_entry_even_with_lower_vid() { + let mut o = Outbox::default(); let p = peer("a"); + o.enqueue(p.clone(), id(99)); o.enqueue(p.clone(), id(1)); + assert!(o.ack(&p, &id(99), AckResult::Applied)); + assert_eq!(o.pending(&p).cloned().collect::>(), vec![id(1)]); +} +#[test] +fn newer_ack_supersedes_older_entries_for_only_that_peer_and_name() { + let mut o = Outbox::default(); let p = peer("a"); let q = peer("b"); + for target in [&p, &q] { o.enqueue(target.clone(), id(99)); o.enqueue(target.clone(), id(1)); } + let mut other = id(0); other.name = "other".into(); o.enqueue(p.clone(), other.clone()); + o.ack(&p, &id(1), AckResult::Held); + assert_eq!(o.pending(&p).cloned().collect::>(), vec![other]); + assert_eq!(o.pending(&q).count(), 2); assert!(!o.snapshot_releasable("key", v(99))); + o.ack(&q, &id(1), AckResult::Conflict); assert!(o.snapshot_releasable("key", v(99))); +} +#[test] +fn deferred_and_unknown_ack_preserve_queue_and_snapshot() { + let mut o = Outbox::default(); let p = peer("a"); o.enqueue(p.clone(), id(1)); + assert!(!o.ack(&p, &id(1), AckResult::DeferredCapacity)); + assert!(!o.ack(&p, &id(2), AckResult::Applied)); + let mut wrong = id(1); wrong.generation += 1; + assert!(!o.ack(&p, &wrong, AckResult::Applied)); + assert_eq!(o.pending(&p).count(), 1); assert!(!o.snapshot_releasable("key", v(1))); +} +#[test] +fn stale_generation_marks_reoffer_and_accept_clears_it() { + let mut o = Outbox::default(); let p = peer("a"); o.enqueue(p.clone(), id(1)); + o.ack(&p, &id(1), AckResult::StaleGeneration); + assert_eq!(o.pending(&p).count(), 0); assert!(o.needs_reoffer(&p, "key")); + o.accepted(&p, "key"); assert!(!o.needs_reoffer(&p, "key")); +} +#[test] +fn snapshots_wait_for_all_targets_even_with_different_generations() { + let mut o = Outbox::default(); let p = peer("a"); let q = peer("b"); let mut other = id(1); other.generation = 22; + o.enqueue(p.clone(), id(1)); o.enqueue(q.clone(), other.clone()); + o.ack(&p, &id(1), AckResult::Rejected); assert!(!o.snapshot_releasable("key", v(1))); + o.ack(&q, &other, AckResult::Applied); assert!(o.snapshot_releasable("key", v(1))); + assert!(o.release_snapshot("key", v(1))); assert!(!o.snapshot_releasable("key", v(1))); +} +#[test] +fn ack_discriminant_order_and_finality() { + for (n, result) in [AckResult::Applied, AckResult::Held, AckResult::Conflict, AckResult::StaleGeneration, AckResult::DeferredCapacity, AckResult::Rejected].into_iter().enumerate() { + assert_eq!(result as usize, n); assert_eq!(result.is_final(), n != 4); + } +} + +fn journal() -> RemoteJournalRecord { + RemoteJournalRecord { change_id: id(2), sender: peer("a"), prev_fp: f(1), new_fp: f(2), head: v(2), + lineage: Lineage::new([v(1), v(2)]), approval_key: None, ack: AckResult::Applied, + checkpoint_slot: Some("checkpoint".into()), candidate_slot: "candidate".into() } +} +#[test] fn remote_recovery_finish() { assert_eq!(recover_remote(&journal(), f(2)), RemoteRecovery::FinishFromStep4); } +#[test] fn remote_recovery_retry() { assert_eq!(recover_remote(&journal(), f(1)), RemoteRecovery::Retry); } +#[test] fn remote_recovery_conflict() { assert_eq!(recover_remote(&journal(), f(3)), RemoteRecovery::Conflict); } +#[test] fn local_row1_rebuild_snapshot() { assert_eq!(recover_local(f(1), f(2), f(2), false, false), LocalRecovery::RebuildSnapshotAndCommit); } +#[test] fn local_row2_commit_existing_snapshot() { assert_eq!(recover_local(f(1), f(2), f(2), false, true), LocalRecovery::Commit); } +#[test] fn local_row3_clean_committed_journal() { + for snapshot in [false, true] { assert_eq!(recover_local(f(1), f(2), f(2), true, snapshot), LocalRecovery::CleanJournal); } +} +#[test] fn local_row4_keep_queued_snapshot_and_scan() { + for current in [f(1), f(3)] { for snapshot in [false, true] { + assert_eq!(recover_local(f(1), f(2), current, true, snapshot), LocalRecovery::KeepSnapshotAndScan); + }} +} +#[test] fn local_row5_discard_uncommitted_snapshot() { + for snapshot in [false, true] { assert_eq!(recover_local(f(1), f(2), f(1), false, snapshot), LocalRecovery::DiscardSnapshot); } +} +#[test] fn local_row6_discard_and_scan_other_value() { + for snapshot in [false, true] { assert_eq!(recover_local(f(1), f(2), f(3), false, snapshot), LocalRecovery::DiscardSnapshotAndScan); } +} +#[test] +fn journal_records_round_trip_and_equal_fps_prefer_finished_write() { + let r = journal(); assert_eq!(r, serde_json::from_str(&serde_json::to_string(&r).unwrap()).unwrap()); + let l = LocalJournalRecord { name: "key".into(), prev_fp: f(1), new_fp: f(2), new_vid: v(2), parents: vec![v(1)], snapshot_slot: "snapshot".into(), targets: vec![QueueTarget { peer: peer("a"), generation: 7 }] }; + assert_eq!(l, serde_json::from_str(&serde_json::to_string(&l).unwrap()).unwrap()); + let mut r = r; r.prev_fp = r.new_fp; assert_eq!(recover_remote(&r, r.new_fp), RemoteRecovery::FinishFromStep4); +} + +#[test] +fn limiter_one_noninteractive_overwrite_per_item_per_24h_across_peers() { + let mut l = Limiter::default(); let p = peer("a"); let q = peer("b"); + assert_eq!(l.check(&p, "key", RemoteOperation::Overwrite, 0, 100, false), LimitResult::Allowed); + l.record(&p, "key", RemoteOperation::Overwrite, 0, false); + assert_eq!(l.check(&q, "key", RemoteOperation::Overwrite, 86399, 100, false), LimitResult::ItemLimited); + assert_eq!(l.check(&q, "key", RemoteOperation::Overwrite, 86399, 100, true), LimitResult::Allowed); + assert_eq!(l.check(&q, "key", RemoteOperation::Overwrite, 86400, 100, false), LimitResult::Allowed); +} +#[test] +fn limiter_overwrite_and_retire_thresholds_are_strict_and_latched() { + for (op, cap) in [(RemoteOperation::Overwrite, 5), (RemoteOperation::Retire, 3)] { + let mut l = Limiter::default(); let p = peer("a"); + for n in 0..cap { + let name = format!("key{n}"); assert_eq!(l.check(&p, &name, op, 0, 100, false), LimitResult::Allowed); + l.record(&p, &name, op, 0, false); + } + assert_eq!(l.check(&p, "extra", op, 0, 100, false), LimitResult::PeerTripped); + assert_eq!(l.check(&p, "other", op, 200000, 100, true), LimitResult::PeerTripped); + l.human_reset(&p); assert_eq!(l.check(&p, "extra", op, 200000, 100, false), LimitResult::Allowed); + } +} +#[test] +fn limiter_percentage_only_at_eight_and_counts_distinct_affected_names() { + for size in [7, 8, 9] { + let mut l = Limiter::default(); let p = peer("a"); + for name in ["a", "b"] { l.record(&p, name, RemoteOperation::Overwrite, 0, false); } + assert_eq!(l.check(&p, "c", RemoteOperation::Retire, 0, size, false), if size < 8 { LimitResult::Allowed } else { LimitResult::PeerTripped }); + } + let mut l = Limiter::default(); let p = peer("a"); + for _ in 0..3 { l.record(&p, "same", RemoteOperation::Overwrite, 0, true); } + assert_eq!(l.check(&p, "same", RemoteOperation::Overwrite, 0, 8, true), LimitResult::Allowed); +} +#[test] +fn limiter_clock_rollback_expiry_and_serde() { + let mut l = Limiter::default(); let p = peer("a"); l.record(&p, "key", RemoteOperation::Overwrite, i64::MAX, false); + let mut l: Limiter = serde_json::from_str(&serde_json::to_string(&l).unwrap()).unwrap(); + assert_eq!(l.check(&p, "key", RemoteOperation::Overwrite, i64::MIN, 100, false), LimitResult::ItemLimited); + let mut l = Limiter::default(); l.record(&p, "key", RemoteOperation::Overwrite, 0, false); + l.prune(WINDOW_SECS); assert_eq!(l.check(&p, "key", RemoteOperation::Overwrite, WINDOW_SECS, 100, false), LimitResult::Allowed); +} +#[test] +fn slot_capacity_floor_and_priority() { + assert_eq!(SlotBudget::new(0).capacity(), 16); assert_eq!(SlotBudget::new(5).capacity(), 20); + assert!(SlotKind::Checkpoint > SlotKind::ConflictCandidate && SlotKind::ConflictCandidate > SlotKind::Held && SlotKind::Held > SlotKind::Proposal); + let mut b = SlotBudget::new(0); + for n in 0..16 { assert!(matches!(b.reserve(&format!("p{n:02}"), SlotKind::Proposal), Reservation::Reserved { .. })); } + assert_eq!(b.reserve("p-new", SlotKind::Proposal), Reservation::Refused); + assert_eq!(b.reserve("h-new", SlotKind::Held), Reservation::Refused); + assert_eq!(b.reserve("candidate", SlotKind::ConflictCandidate), Reservation::Reserved { evicted: Some("p00".into()) }); + assert_eq!(b.reserve("checkpoint", SlotKind::Checkpoint), Reservation::Reserved { evicted: Some("p01".into()) }); + assert!(!b.release("checkpoint")); assert!(b.release("candidate")); assert_eq!(b.used(), 15); +} +#[test] +fn checkpoints_and_unacked_snapshots_are_never_evicted() { + let mut b = SlotBudget::new(0); + for n in 0..8 { b.reserve(&format!("c{n}"), SlotKind::Checkpoint); b.reserve_snapshot(&format!("s{n}")); } + assert_eq!(b.reserve("new", SlotKind::Checkpoint), Reservation::Refused); + assert!(matches!(b.prepare_overwrite("new", "held"), OverwriteCapacity::Deferred(Decision { ack: AckResult::DeferredCapacity, .. }))); + assert!(matches!(b.prepare_overwrite("c0", "held"), OverwriteCapacity::Ready { .. })); +} +#[test] +fn checkpoint_reservation_failure_holds_when_hold_can_be_retained() { + let mut b = SlotBudget::new(0); b.reserve("occupied", SlotKind::Held); + let OverwriteCapacity::Held(d) = b.prepare_overwrite("occupied", "held") else { panic!() }; + held(&d, HoldReason::OverLimit); assert_eq!(b.kind("held"), Some(SlotKind::Held)); +} +#[test] +fn checkpoint_changes_only_on_first_capture_or_human_confirmation() { + let mut cp = Checkpoint::default(); assert_eq!(cp.before_remote_overwrite(f(1)), f(1)); + for n in 2..100 { assert_eq!(cp.before_remote_overwrite(f(n)), f(1)); } + cp.human_confirm(f(99)); assert_eq!(cp.before_remote_overwrite(f(100)), f(99)); + let cp2: Checkpoint = serde_json::from_str(&serde_json::to_string(&cp).unwrap()).unwrap(); assert_eq!(cp, cp2); +} +#[test] +fn generations_are_receiver_owned_scoped_and_bumped_on_rm() { + let mut g = Generations::default(); let a = peer("a"); let b = peer("b"); + assert_eq!(g.outgoing_generation(&a, "key"), None); + let accept = g.accept("key", a.clone()); assert_eq!(accept.generation, 0); + assert!(g.includes("key", &a)); assert!(!g.includes("key", &b)); + let (leave, peers) = g.rm("key").unwrap(); assert_eq!(leave.generation, 1); assert_eq!(peers.len(), 1); assert!(!g.includes("key", &a)); + let accept = g.accept("key", b.clone()); assert_eq!(accept.generation, 1); assert!(g.includes("key", &b)); +} +#[test] +fn accept_leave_ignore_older_generations_and_require_reacceptance() { + let mut g = Generations::default(); let p = peer("a"); + let msg = |generation| Registration { name: "key".into(), generation }; + g.received_accept(p.clone(), msg(2)); assert_eq!(g.outgoing_generation(&p, "key"), Some(2)); + g.received_leave(p.clone(), msg(3)); assert_eq!(g.outgoing_generation(&p, "key"), None); + assert!(!g.received_accept(p.clone(), msg(2))); assert_eq!(g.outgoing_generation(&p, "key"), None); + g.received_accept(p.clone(), msg(3)); assert_eq!(g.outgoing_generation(&p, "key"), Some(3)); + assert!(!g.received_leave(p.clone(), msg(2))); + let g: Generations = serde_json::from_str(&serde_json::to_string(&g).unwrap()).unwrap(); assert_eq!(g.outgoing_generation(&p, "key"), Some(3)); +} + +#[test] +fn item_state_and_outbox_round_trip_through_sync_json() { + let s = conflicted(); + assert_eq!(s, serde_json::from_str(&serde_json::to_string(&s).unwrap()).unwrap()); + let mut o = Outbox::default(); let p = peer("a"); let q = peer("b"); + o.enqueue(p.clone(), id(1)); o.enqueue(q.clone(), id(1)); o.ack(&p, &id(1), AckResult::Held); + let mut restored: Outbox = serde_json::from_str(&serde_json::to_string(&o).unwrap()).unwrap(); + assert_eq!(restored.pending(&p).count(), 0); assert_eq!(restored.pending(&q).count(), 1); + assert!(!restored.snapshot_releasable("key", v(1))); + restored.ack(&q, &id(1), AckResult::Applied); assert!(restored.snapshot_releasable("key", v(1))); +} +#[test] +fn known_cache_deserialization_rejects_unbounded_or_ambiguous_bindings() { + let mut s = state(); + for n in 2..260 { s.known.insert(v(n), VidRecord { fp: f(2), parents: vec![] }); } + assert!(serde_json::from_str::(&serde_json::to_string(&s).unwrap()).is_err()); + let mut json = serde_json::to_value(state()).unwrap(); + let known = json["known"].as_array_mut().unwrap(); known.push(known[0].clone()); + assert!(serde_json::from_value::(json).is_err()); +} +#[test] +fn slot_budget_round_trip_retains_snapshot_pins() { + let mut b = SlotBudget::new(0); + for n in 0..16 { b.reserve_snapshot(&format!("s{n}")); } + let mut b: SlotBudget = serde_json::from_str(&serde_json::to_string(&b).unwrap()).unwrap(); + assert_eq!(b.reserve("checkpoint", SlotKind::Checkpoint), Reservation::Refused); +} diff --git a/crates/kc-sync/tests/simulation.rs b/crates/kc-sync/tests/simulation.rs new file mode 100644 index 0000000..cfc5928 --- /dev/null +++ b/crates/kc-sync/tests/simulation.rs @@ -0,0 +1,291 @@ +//! Seeded in-memory transport and persistence adapter; production policy comes from kc-sync. +use std::collections::BTreeMap; +use kc_sync::*; +use rand::{Rng, SeedableRng, rngs::StdRng}; + +fn peer(n: usize) -> PeerId { PeerId(format!("device-{n}")) } +fn id(i: &Incoming) -> ChangeId { ChangeId { name: "key".into(), generation: i.generation, new_vid: i.new_vid } } +fn fp(n: u64) -> Fp { let mut bytes = [0; 32]; bytes[..8].copy_from_slice(&n.to_be_bytes()); Fp(bytes) } +fn slot(v: Vid) -> String { format!("{v:?}") } + +struct Device { + state: ItemState, + value: Option, + checkpoint: Checkpoint, + slots: SlotBudget, + held: BTreeMap, + receipts: BTreeMap<(usize, Vid), AckResult>, + outbox: Outbox, + sent: BTreeMap, + generations: Generations, +} +impl Device { + fn new() -> Self { + Self { state: ItemState::new(0, Vid([0; 16]), fp(0), vec![]), value: Some(fp(0)), + checkpoint: Checkpoint::default(), slots: SlotBudget::new(1024), held: BTreeMap::new(), + receipts: BTreeMap::new(), outbox: Outbox::default(), sent: BTreeMap::new(), generations: Generations::default() } + } + + // This adapter only executes Transition intents; it contains no independent sync decisions. + fn commit(&mut self, incoming: &Incoming, decision: Decision) { + let before = self.value; + let checkpoint_before = self.checkpoint.fingerprint(); + match decision.transition { + Transition::Unchanged => {}, + Transition::Hold { .. } => { + assert!(matches!(self.slots.reserve(&slot(incoming.new_vid), SlotKind::Held), Reservation::Reserved { .. })); + self.held.insert(incoming.new_vid, incoming.clone()); + }, + Transition::Conflict { candidates } => { + for vid in candidates.candidates.keys() { + // A previously held slot is promoted by releasing its reservation first. + if self.slots.kind(&slot(*vid)) == Some(SlotKind::Held) { self.slots.release(&slot(*vid)); } + assert!(matches!(self.slots.reserve(&slot(*vid), SlotKind::ConflictCandidate), Reservation::Reserved { .. })); + } + self.state.conflict = Some(candidates); + }, + Transition::Advance { head, lineage, write_value, clear_conflict } => { + if write_value { + assert!(matches!(self.slots.prepare_overwrite("checkpoint", "held-fallback"), OverwriteCapacity::Ready { .. })); + self.checkpoint.before_remote_overwrite(self.value.unwrap()); + self.value = incoming.value_fp; + } + self.state.head = head; + self.state.lineage = lineage; + assert!(self.state.remember(incoming.new_vid, VidRecord { fp: incoming.value_fp.unwrap(), parents: incoming.parents.clone() })); + if clear_conflict { self.state.conflict = None; } + }, + Transition::Retire => { + // §2.5 only changes registration metadata. There is deliberately no value deletion. + self.state.generation += 1; + }, + } + assert!(before.is_some() && self.value.is_some(), "remote event deleted a value"); + if checkpoint_before.is_some() { assert_eq!(self.checkpoint.fingerprint(), checkpoint_before, "remote event replaced a checkpoint"); } + } + + fn receive(&mut self, from: usize, incoming: &Incoming) -> AckResult { + if let Some(ack) = self.receipts.get(&(from, incoming.new_vid)) { return *ack; } + let d = decide(&self.state, self.value.unwrap(), incoming, false, None, true); + let ack = d.ack; + self.commit(incoming, d); + if ack.is_final() { self.receipts.insert((from, incoming.new_vid), ack); } + ack + } + + fn review(&mut self, rng: &mut StdRng, stats: &mut Stats) { + let Some(vid) = self.held.keys().nth(rng.random_range(0..self.held.len().max(1))).copied() else { return; }; + let incoming = self.held.remove(&vid).unwrap(); + self.slots.release(&slot(vid)); + let old_checkpoint = self.checkpoint.fingerprint(); + if rng.random_bool(0.5) { + stats.accepted += 1; + // The simulated human is the only caller providing the test approval marker. + let approval = VerifiedApproval::for_tests(); + let d = decide(&self.state, self.value.unwrap(), &incoming, false, Some(&approval), true); + self.commit(&incoming, d); + } else { stats.rejected += 1; } + // Human review does not implicitly confirm a new checkpoint baseline. + if old_checkpoint.is_some() { assert_eq!(old_checkpoint, self.checkpoint.fingerprint()); } + } +} + +#[derive(Clone)] +enum Message { + Change { from: usize, to: usize, incoming: Incoming }, + Ack { from: usize, to: usize, change: ChangeId, result: AckResult }, +} +#[derive(Clone)] +struct Envelope { due: u64, message: Message } +#[derive(Default)] +struct Stats { dropped: usize, duplicated: usize, reordered: usize, delayed: usize, accepted: usize, rejected: usize, retired: usize } +struct Created { owner: usize, vid: Vid, fp: Fp, sequence: u64 } + +struct World { + rng: StdRng, + devices: Vec, + queue: Vec, + created: Vec, + tick: u64, + sequence: u64, + stats: Stats, +} +impl World { + fn new(seed: u64) -> Self { + let count = 3 + (seed as usize % 2); + let mut devices: Vec<_> = (0..count).map(|_| Device::new()).collect(); + for device in &mut devices { + for target in 0..count { + device.generations.received_accept(peer(target), Registration { name: "key".into(), generation: 0 }); + } + } + Self { rng: StdRng::seed_from_u64(seed), devices, + queue: vec![], created: vec![], tick: 0, sequence: 0, stats: Stats::default() } + } + fn schedule(&mut self, message: Message) { + let delay = self.rng.random_range(1..=12); self.stats.delayed += usize::from(delay > 1); + self.queue.push(Envelope { due: self.tick + delay, message }); + } + fn edit(&mut self, owner: usize) { + self.sequence += 1; + let vid = Vid(self.rng.random()); let value = fp(self.sequence); + assert!(!self.created.iter().any(|c| c.vid == vid)); + let targets = self.devices.len(); + let device = &mut self.devices[owner]; + let parents = vec![device.state.head]; + device.state.head = vid; + device.state.lineage = device.state.lineage.clone().with_head(vid); + device.state.remember(vid, VidRecord { fp: value, parents: parents.clone() }); + // Local edits cannot silently resolve existing conflicts: retain their new head as a candidate. + if let Some(c) = &mut device.state.conflict { + c.candidates.insert(vid, VidRecord { fp: value, parents: parents.clone() }); + } + device.value = Some(value); + let incoming = Incoming { generation: 0, new_vid: vid, parents, + lineage: device.state.lineage.clone(), value_fp: Some(value), retire: false }; + device.sent.insert(vid, incoming.clone()); + assert!(matches!(device.slots.reserve_snapshot(&format!("send-{}", slot(vid))), Reservation::Reserved { .. })); + let mut messages = vec![]; + for target in 0..targets { if target != owner { + let mut outgoing = incoming.clone(); + outgoing.generation = device.generations.outgoing_generation(&peer(target), "key").unwrap(); + device.outbox.enqueue(peer(target), id(&outgoing)); + messages.push(Message::Change { from: owner, to: target, incoming: outgoing }); + } } + self.created.push(Created { owner, vid, fp: value, sequence: self.sequence }); + for message in messages { self.schedule(message); } + } + fn retry_pending(&mut self) { + let mut retry = vec![]; + for (from, device) in self.devices.iter().enumerate() { + for to in 0..self.devices.len() { + for change in device.outbox.pending(&peer(to)) { + let mut incoming = device.sent[&change.new_vid].clone(); + incoming.generation = change.generation; + retry.push(Message::Change { from, to, incoming }); + } + } + } + for message in retry { self.schedule(message); } + } + fn deliver(&mut self, lossy: bool) -> bool { + let eligible: Vec<_> = self.queue.iter().enumerate().filter(|(_, e)| e.due <= self.tick).map(|(n, _)| n).collect(); + if eligible.is_empty() { return false; } + let index = eligible[self.rng.random_range(0..eligible.len())]; + self.stats.reordered += usize::from(index != 0); + let envelope = self.queue.remove(index); + if lossy && self.rng.random_bool(0.20) { self.stats.dropped += 1; return true; } + if lossy && self.rng.random_bool(0.15) { self.stats.duplicated += 1; self.schedule(envelope.message.clone()); } + match envelope.message { + Message::Change { from, to, incoming } => { + let result = self.devices[to].receive(from, &incoming); + self.schedule(Message::Ack { from: to, to: from, change: id(&incoming), result }); + }, + Message::Ack { from, to, change, result } => { + let d = &mut self.devices[to]; + d.outbox.ack(&peer(from), &change, result); + let release: Vec<_> = d.sent.keys().copied().filter(|vid| d.outbox.snapshot_releasable("key", *vid)).collect(); + for vid in release { + assert!(d.outbox.release_snapshot("key", vid)); + d.slots.release(&format!("send-{}", slot(vid))); + } + }, + } + true + } + fn assert_preserved(&self, seed: u64) { + for c in &self.created { + let superseded_locally = self.created.iter().any(|later| later.owner == c.owner && later.sequence > c.sequence); + let preserved = self.devices.iter().any(|d| d.value == Some(c.fp) + || d.held.values().any(|h| h.value_fp == Some(c.fp)) + || d.state.conflict.as_ref().is_some_and(|set| set.candidates.values().any(|r| r.fp == c.fp))); + assert!(superseded_locally || preserved, "seed {seed}: lost local value {:?} from {}", c.vid, c.owner); + } + for d in &self.devices { assert!(d.value.is_some()); } + } + fn quiesce(&mut self) { + self.retry_pending(); + for _ in 0..20000 { + self.tick += 1; + while self.deliver(false) {} + for d in &mut self.devices { d.review(&mut self.rng, &mut self.stats); } + if self.queue.is_empty() { + let pending = self.devices.iter().any(|d| (0..self.devices.len()).any(|p| d.outbox.pending(&peer(p)).next().is_some())); + if pending { self.retry_pending(); } else { return; } + } + } + panic!("transport did not quiesce"); + } +} + +#[test] +fn seeded_lossy_multi_device_simulation_256_seeds() { + let mut totals = Stats::default(); + for seed in 0..256 { + let mut w = World::new(seed); + // An initial causal edit exercises genuine Phase-1 holds and human accept/reject. + w.edit(0); + for _ in 0..30 { + w.tick += 1; w.deliver(true); + for d in &mut w.devices { d.review(&mut w.rng, &mut w.stats); } + w.assert_preserved(seed); + } + w.quiesce(); + // Retire is delivered through the same decision path and changes registration, never value. + let d = &mut w.devices[1]; + let before = d.value; + let retire = Incoming { generation: 0, new_vid: Vid(w.rng.random()), parents: vec![d.state.head], + lineage: d.state.lineage.clone(), value_fp: None, retire: true }; + assert_eq!(d.receive(0, &retire), AckResult::Held); + d.held.remove(&retire.new_vid); d.slots.release(&slot(retire.new_vid)); + let token = VerifiedApproval::for_tests(); + let decision = decide(&d.state, d.value.unwrap(), &retire, false, Some(&token), true); + assert_eq!(decision.transition, Transition::Retire); d.commit(&retire, decision); + assert_eq!(before, d.value); w.stats.retired += 1; + // A fresh human registration exchange reinstates the receiver-owned generation. + let mut generations = Generations::default(); generations.rm("key").unwrap(); + let accept = generations.accept("key", peer(0)); assert_eq!(accept.generation, d.state.generation); + // Every sender records the receiver's new Accept; generations never move backwards. + for device in &mut w.devices { device.generations.received_accept(peer(1), accept.clone()); } + // Every device makes independent local edits before network delivery; then edits interleave + // with transport. This creates true concurrent branches rather than serial overwrite tests. + for owner in 0..w.devices.len() { + for _ in 0..w.rng.random_range(1..=4) { w.edit(owner); } + } + for step in 0..120 { + w.tick += 1; + match w.rng.random_range(0..10) { + 0..=1 => { let owner = w.rng.random_range(0..w.devices.len()); w.edit(owner); }, + 2 => { let owner = w.rng.random_range(0..w.devices.len()); w.devices[owner].review(&mut w.rng, &mut w.stats); }, + 3 => { + let owner = w.rng.random_range(0..w.devices.len()); + let d = &mut w.devices[owner]; d.checkpoint.human_confirm(d.value.unwrap()); + assert_eq!(d.checkpoint.fingerprint(), d.value); + }, + _ => { w.deliver(true); }, + } + if step % 23 == 0 { w.retry_pending(); } + w.assert_preserved(seed); + } + w.quiesce(); w.assert_preserved(seed); + for (a_index, a) in w.devices.iter().enumerate() { + assert!(a.held.is_empty()); + for (b_index, b) in w.devices.iter().enumerate().skip(a_index + 1) { + let equal = a.state.head == b.state.head && a.value == b.value; + let conflict = a.state.conflict.as_ref().is_some_and(|c| c.candidates.contains_key(&b.state.head)) + || b.state.conflict.as_ref().is_some_and(|c| c.candidates.contains_key(&a.state.head)); + assert!(equal || conflict, "seed {seed}: devices {a_index}/{b_index} silently diverged"); + } + for p in 0..w.devices.len() { assert_eq!(a.outbox.pending(&peer(p)).count(), 0); } + } + assert!(w.queue.is_empty()); + totals.dropped += w.stats.dropped; totals.duplicated += w.stats.duplicated; + totals.reordered += w.stats.reordered; totals.delayed += w.stats.delayed; + totals.accepted += w.stats.accepted; totals.rejected += w.stats.rejected; totals.retired += w.stats.retired; + } + assert!(totals.dropped > 0 && totals.duplicated > 0 && totals.reordered > 0 && totals.delayed > 0); + assert!(totals.accepted > 0 && totals.rejected > 0 && totals.retired == 256); + // Keep actual coverage visible when this test is run with --nocapture. + println!("256 seeds: dropped={}, duplicated={}, reordered={}, delayed={}, accepted={}, rejected={}, retired={}", + totals.dropped, totals.duplicated, totals.reordered, totals.delayed, totals.accepted, totals.rejected, totals.retired); +} From 67f3c85188e42b9207b43e9d8d757b235b9caceb Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Tue, 13 Oct 2026 16:20:10 +0900 Subject: [PATCH 10/24] =?UTF-8?q?feat(kc-proto):=20=EC=9D=B8=EB=B0=95?= =?UTF-8?q?=EC=8A=A4=20v2=20=EC=99=80=EC=9D=B4=EC=96=B4=EC=99=80=20sync=20?= =?UTF-8?q?=EB=A9=94=EC=8B=9C=EC=A7=80=20=ED=83=80=EC=9E=85=20(sync=20Phas?= =?UTF-8?q?e=200)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- crates/kc-proto/src/inbox.rs | 236 ++++++++++++++- crates/kc-proto/src/lib.rs | 1 + crates/kc-proto/src/sync.rs | 183 ++++++++++++ .../tests/inbox_v2/fixtures/README.md | 30 ++ .../tests/inbox_v2/fixtures/accept.body.hex | 1 + .../inbox_v2/fixtures/accept.envelope.hex | 1 + .../tests/inbox_v2/fixtures/ack.body.hex | 1 + .../tests/inbox_v2/fixtures/ack.envelope.hex | 1 + .../inbox_v2/fixtures/approvals.body.hex | 1 + .../inbox_v2/fixtures/approvals.envelope.hex | 1 + .../tests/inbox_v2/fixtures/changes.body.hex | 1 + .../inbox_v2/fixtures/changes.envelope.hex | 1 + .../tests/inbox_v2/fixtures/digest.body.hex | 1 + .../inbox_v2/fixtures/digest.envelope.hex | 1 + .../tests/inbox_v2/fixtures/hello.body.hex | 1 + .../inbox_v2/fixtures/hello.envelope.hex | 1 + .../tests/inbox_v2/fixtures/items.body.hex | 1 + .../inbox_v2/fixtures/items.envelope.hex | 1 + .../tests/inbox_v2/fixtures/leave.body.hex | 1 + .../inbox_v2/fixtures/leave.envelope.hex | 1 + .../tests/inbox_v2/fixtures/offer.body.hex | 1 + .../inbox_v2/fixtures/offer.envelope.hex | 1 + crates/kc-proto/tests/inbox_v2/mod.rs | 278 ++++++++++++++++++ docs/PROTOCOL.md | 65 ++++ 24 files changed, 809 insertions(+), 2 deletions(-) create mode 100644 crates/kc-proto/src/sync.rs create mode 100644 crates/kc-proto/tests/inbox_v2/fixtures/README.md create mode 100644 crates/kc-proto/tests/inbox_v2/fixtures/accept.body.hex create mode 100644 crates/kc-proto/tests/inbox_v2/fixtures/accept.envelope.hex create mode 100644 crates/kc-proto/tests/inbox_v2/fixtures/ack.body.hex create mode 100644 crates/kc-proto/tests/inbox_v2/fixtures/ack.envelope.hex create mode 100644 crates/kc-proto/tests/inbox_v2/fixtures/approvals.body.hex create mode 100644 crates/kc-proto/tests/inbox_v2/fixtures/approvals.envelope.hex create mode 100644 crates/kc-proto/tests/inbox_v2/fixtures/changes.body.hex create mode 100644 crates/kc-proto/tests/inbox_v2/fixtures/changes.envelope.hex create mode 100644 crates/kc-proto/tests/inbox_v2/fixtures/digest.body.hex create mode 100644 crates/kc-proto/tests/inbox_v2/fixtures/digest.envelope.hex create mode 100644 crates/kc-proto/tests/inbox_v2/fixtures/hello.body.hex create mode 100644 crates/kc-proto/tests/inbox_v2/fixtures/hello.envelope.hex create mode 100644 crates/kc-proto/tests/inbox_v2/fixtures/items.body.hex create mode 100644 crates/kc-proto/tests/inbox_v2/fixtures/items.envelope.hex create mode 100644 crates/kc-proto/tests/inbox_v2/fixtures/leave.body.hex create mode 100644 crates/kc-proto/tests/inbox_v2/fixtures/leave.envelope.hex create mode 100644 crates/kc-proto/tests/inbox_v2/fixtures/offer.body.hex create mode 100644 crates/kc-proto/tests/inbox_v2/fixtures/offer.envelope.hex create mode 100644 crates/kc-proto/tests/inbox_v2/mod.rs diff --git a/crates/kc-proto/src/inbox.rs b/crates/kc-proto/src/inbox.rs index 6d2ac71..5af01c2 100644 --- a/crates/kc-proto/src/inbox.rs +++ b/crates/kc-proto/src/inbox.rs @@ -26,9 +26,13 @@ use crate::device::{DeviceKem, DeviceKeyPair, DevicePublicKey, Fingerprint}; use crate::pad; use crate::payload::{self, Item, PayloadError}; use crate::rng; +use crate::sync::SyncMsg; /// `InboxEnvelope.v` and `InboxPlain.v`. pub const VERSION: u8 = 1; +/// The sync-capable inbox format. +pub const VERSION_V2: u8 = 2; +pub const INFO_PREFIX_V2: &[u8] = b"kc2 inbox"; /// `InboxEnvelope.suite`: DHKEM(X25519, HKDF-SHA256) + HKDF-SHA256 + ChaCha20-Poly1305. pub const SUITE: u16 = 1; pub const INFO_PREFIX: &[u8] = b"kc1 inbox"; @@ -190,8 +194,12 @@ fn header_aad(v: u8, suite: u16, sender_fp: &Fingerprint, recipient_fp: &Fingerp } fn info(sender_fp: &Fingerprint, recipient_fp: &Fingerprint) -> Vec { - let mut info = Vec::with_capacity(INFO_PREFIX.len() + 64); - info.extend_from_slice(INFO_PREFIX); + info_with_prefix(INFO_PREFIX, sender_fp, recipient_fp) +} + +fn info_with_prefix(prefix: &[u8], sender_fp: &Fingerprint, recipient_fp: &Fingerprint) -> Vec { + let mut info = Vec::with_capacity(prefix.len() + 64); + info.extend_from_slice(prefix); info.extend_from_slice(sender_fp.as_bytes()); info.extend_from_slice(recipient_fp.as_bytes()); info @@ -390,6 +398,230 @@ pub fn open( }) } +/// v2 content. Variant order is part of the wire contract. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub enum Body { + Items(Vec), + Sync(SyncMsg), +} + +impl Body { + fn validate(&self) -> Result<(), InboxError> { + match self { + Self::Items(items) => payload::check_unique_names(items).map_err(InboxError::InvalidItems), + Self::Sync(msg) => msg.validate(), + } + } +} + +/// The encrypted v2 plaintext. Field order is the postcard wire order. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct InboxPlain2 { + pub v: u8, + pub msg_id: MessageId, + pub sender_fp: Fingerprint, + pub recipient_fp: Fingerprint, + pub created_at: i64, + pub expires_at: i64, + pub body: Body, +} + +#[derive(Serialize)] +struct InboxPlain2Ref<'a> { + v: u8, + msg_id: MessageId, + sender_fp: Fingerprint, + recipient_fp: Fingerprint, + created_at: i64, + expires_at: i64, + body: &'a Body, +} + +/// Seals a v2 body with the same TTL and time rules as [`seal`]. +pub fn seal_v2( + sender: &DeviceKeyPair, + recipient: &DevicePublicKey, + body: &Body, + ttl: Duration, + now: i64, +) -> Result { + seal_v2_with_rng( + sender, + recipient, + body, + ttl, + now, + MessageId(rng::array()), + &mut hpke::rand_core::UnwrapErr(getrandom::SysRng), + ) +} + +// The production path and golden vectors share this constructor. Only tests +// supply fixed message ids and ephemeral randomness; callers cannot do so. +fn seal_v2_with_rng( + sender: &DeviceKeyPair, + recipient: &DevicePublicKey, + body: &Body, + ttl: Duration, + now: i64, + msg_id: MessageId, + csprng: &mut impl hpke::rand_core::CryptoRng, +) -> Result { + let ttl = i64::try_from(ttl.as_secs()).map_err(|_| InboxError::InvalidTtl)?; + if !(1..=MAX_LIFETIME_SECS).contains(&ttl) { + return Err(InboxError::InvalidTtl); + } + let expires_at = now.checked_add(ttl).ok_or(InboxError::InvalidTtl)?; + body.validate()?; + let sender_fp = sender.fingerprint(); + let recipient_fp = recipient.fingerprint(); + let plain = InboxPlain2Ref { + v: VERSION_V2, + msg_id, + sender_fp, + recipient_fp, + created_at: now, + expires_at, + body, + }; + let mut buf = pad::encode(&plain, &[], TAG_LEN).map_err(|_| InboxError::Seal)?; + let mode = OpModeS::Auth((sender.kem_private().clone(), sender.public().kem_public())); + let (enc, tag) = hpke::single_shot_seal_inout_detached_with_rng::( + &mode, + &recipient.kem_public(), + &info_with_prefix(INFO_PREFIX_V2, &sender_fp, &recipient_fp), + (&mut buf[..]).into(), + &header_aad(VERSION_V2, SUITE, &sender_fp, &recipient_fp), + csprng, + ) + .map_err(|_| InboxError::Seal)?; + buf.extend_from_slice(&tag.to_bytes()); + let envelope = InboxEnvelope { + v: VERSION_V2, + suite: SUITE, + sender_fp, + recipient_fp, + enc: enc.to_bytes().into(), + ct: std::mem::take(&mut *buf), + }; + let body = envelope.encode(); + if body.len() > MAX_MESSAGE_BYTES { + return Err(InboxError::TooLarge); + } + Ok(SealedMessage { + body, + msg_id, + created_at: now, + expires_at, + }) +} + +/// A v1 or v2 message that passed every check. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct OpenedAny { + pub msg_id: MessageId, + pub sender_fp: Fingerprint, + pub created_at: i64, + pub expires_at: i64, + pub body: Body, +} + +impl OpenedAny { + /// Keep `msg_id` in the seen-set at least until this time (Unix seconds). + pub fn keep_seen_until(&self) -> i64 { + self.expires_at.saturating_add(CLOCK_SKEW_SECS) + } +} + +/// Opens either inbox version; v1 items are returned as [`Body::Items`]. +/// Arguments have the same meaning as in [`open`]. +pub fn open_any( + body: &[u8], + own_keys: &[&DeviceKeyPair], + peer_key: impl Fn(&Fingerprint) -> Option, + seen: impl Fn(&MessageId) -> bool, + now: i64, +) -> Result { + if body.len() > MAX_MESSAGE_BYTES { + return Err(InboxError::TooLarge); + } + let envelope = InboxEnvelope::decode(body)?; + if envelope.v == VERSION { + let opened = open(body, own_keys, peer_key, seen, now)?; + return Ok(OpenedAny { + msg_id: opened.msg_id, + sender_fp: opened.sender_fp, + created_at: opened.created_at, + expires_at: opened.expires_at, + body: Body::Items(opened.items), + }); + } + if envelope.v != VERSION_V2 { + return Err(InboxError::UnsupportedVersion(envelope.v)); + } + if envelope.suite != SUITE { + return Err(InboxError::UnsupportedSuite(envelope.suite)); + } + let own = own_keys + .iter() + .find(|k| k.fingerprint() == envelope.recipient_fp) + .ok_or(InboxError::WrongRecipient)?; + let sender_pk = peer_key(&envelope.sender_fp) + .filter(|pk| pk.fingerprint() == envelope.sender_fp) + .ok_or(InboxError::UnknownSender)?; + let tag_at = envelope + .ct + .len() + .checked_sub(TAG_LEN) + .ok_or(InboxError::Malformed)?; + let (ciphertext, tag) = envelope.ct.split_at(tag_at); + let tag = AeadTag::::from_bytes(tag).map_err(|_| InboxError::Malformed)?; + let enc = EncappedKey::from_bytes(&envelope.enc).map_err(|_| InboxError::Malformed)?; + let mut buf = Zeroizing::new(ciphertext.to_vec()); + hpke::single_shot_open_inout_detached::( + &OpModeR::Auth(sender_pk.kem_public()), + own.kem_private(), + &enc, + &info_with_prefix(INFO_PREFIX_V2, &envelope.sender_fp, &envelope.recipient_fp), + (&mut buf[..]).into(), + &envelope.aad(), + &tag, + ) + .map_err(|_| InboxError::DecryptFailed)?; + let plain: InboxPlain2 = pad::decode(&buf).map_err(|_| InboxError::Malformed)?; + if plain.v != envelope.v { + return Err(InboxError::UnsupportedVersion(plain.v)); + } + if plain.sender_fp != envelope.sender_fp || plain.recipient_fp != envelope.recipient_fp { + return Err(InboxError::FingerprintMismatch); + } + let lifetime = plain.expires_at.checked_sub(plain.created_at); + if !lifetime.is_some_and(|l| (0..=MAX_LIFETIME_SECS).contains(&l)) { + return Err(InboxError::BadLifetime); + } + if now > plain.expires_at.saturating_add(CLOCK_SKEW_SECS) { + return Err(InboxError::Expired); + } + if plain.created_at > now.saturating_add(CLOCK_SKEW_SECS) { + return Err(InboxError::NotYetValid); + } + if seen(&plain.msg_id) { + return Err(InboxError::Replay); + } + plain.body.validate().map_err(|_| InboxError::Malformed)?; + Ok(OpenedAny { + msg_id: plain.msg_id, + sender_fp: plain.sender_fp, + created_at: plain.created_at, + expires_at: plain.expires_at, + body: plain.body, + }) +} + +#[cfg(test)] +#[path = "../tests/inbox_v2/mod.rs"] +mod v2_tests; + /// The current time in Unix seconds. pub fn unix_now() -> i64 { let secs = SystemTime::now() diff --git a/crates/kc-proto/src/lib.rs b/crates/kc-proto/src/lib.rs index bddf215..bf06a55 100644 --- a/crates/kc-proto/src/lib.rs +++ b/crates/kc-proto/src/lib.rs @@ -40,6 +40,7 @@ pub mod relay; mod rng; pub mod secret; pub mod session; +pub mod sync; pub mod words; #[cfg(any(test, feature = "test-util"))] diff --git a/crates/kc-proto/src/sync.rs b/crates/kc-proto/src/sync.rs new file mode 100644 index 0000000..499b78a --- /dev/null +++ b/crates/kc-proto/src/sync.rs @@ -0,0 +1,183 @@ +//! Sync messages carried by inbox v2 (design §5 and §12.1). +//! +//! Field and variant order is the postcard wire contract. Values use the +//! same zeroize-on-drop storage as `payload::Item`. + +use std::collections::HashSet; +use std::fmt; + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +use crate::inbox::{InboxError, MessageId}; +use crate::names::ItemName; +use crate::rng; +use crate::secret::SecretBytes; + +pub const MAX_LINEAGE: usize = 64; + +/// A random version identifier: raw 16 bytes in postcard, hex in JSON. +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct Vid(pub [u8; 16]); + +impl Vid { + pub fn random() -> Self { + Self(rng::array()) + } +} + +impl fmt::Debug for Vid { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "Vid({})", MessageId(self.0).to_hex()) + } +} + +impl Serialize for Vid { + fn serialize(&self, serializer: S) -> Result { + MessageId(self.0).serialize(serializer) + } +} + +impl<'de> Deserialize<'de> for Vid { + fn deserialize>(deserializer: D) -> Result { + MessageId::deserialize(deserializer).map(|id| Self(id.0)) + } +} + +/// Value presentation, matching the store's Text/File meanings. v1 Item +/// has no kind field; sync carries it explicitly without changing v1. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum ItemKind { + Text, + File, +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)] +pub struct ChangeId { + pub name: ItemName, + pub generation: u64, + pub new_vid: Vid, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub enum Op { + Put { + kind: ItemKind, + value: SecretBytes, + }, + Retire, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct Change { + pub name: ItemName, + pub generation: u64, + pub new_vid: Vid, + pub parents: Vec, + #[serde(deserialize_with = "deserialize_lineage")] + pub lineage: Vec, + pub op: Op, + pub approval_ref: Option<[u8; 16]>, +} + +impl Change { + pub fn validate(&self) -> Result<(), InboxError> { + if self.lineage.len() > MAX_LINEAGE { + return Err(InboxError::Malformed); + } + Ok(()) + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +pub enum AckResult { + Applied, + Held, + Conflict, + StaleGeneration, + DeferredCapacity, + Rejected, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct DigestEntry { + pub name: ItemName, + pub generation: u64, + pub head: Vid, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub enum SyncMsg { + Hello { + features: Vec, + is_reply: bool, + }, + Offer { + name: ItemName, + vid: Vid, + lineage: Vec, + kind: ItemKind, + value: SecretBytes, + }, + Accept { + name: ItemName, + generation: u64, + }, + Leave { + name: ItemName, + generation: u64, + }, + Changes { + changes: Vec, + }, + Ack { + results: Vec<(ChangeId, AckResult)>, + }, + Digest { + entries: Vec, + }, + Approvals { + docs: Vec>, + }, +} + +impl SyncMsg { + /// Checks in-memory messages too, before sealing or after opening. + pub fn validate(&self) -> Result<(), InboxError> { + if let Self::Changes { changes } = self { + let mut names = HashSet::new(); + for change in changes { + change.validate()?; + if !names.insert(&change.name) { + return Err(InboxError::Malformed); + } + } + } + Ok(()) + } +} + +// Bound allocation as well as accepting at most 64 decoded lineage entries. +fn deserialize_lineage<'de, D: Deserializer<'de>>(deserializer: D) -> Result, D::Error> { + struct Lineage; + impl<'de> serde::de::Visitor<'de> for Lineage { + type Value = Vec; + fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("at most 64 version identifiers") + } + fn visit_seq>(self, mut seq: A) -> Result, A::Error> { + if seq.size_hint().is_some_and(|n| n > MAX_LINEAGE) { + return Err(serde::de::Error::custom("lineage exceeds 64 entries")); + } + let mut out = Vec::with_capacity(seq.size_hint().unwrap_or(0).min(MAX_LINEAGE)); + while let Some(vid) = seq.next_element()? { + if out.len() == MAX_LINEAGE { + return Err(serde::de::Error::custom("lineage exceeds 64 entries")); + } + out.push(vid); + } + Ok(out) + } + } + deserializer.deserialize_seq(Lineage) +} diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/README.md b/crates/kc-proto/tests/inbox_v2/fixtures/README.md new file mode 100644 index 0000000..9748a1d --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/README.md @@ -0,0 +1,30 @@ +# Inbox v2 golden vectors + +Each `*.body.hex` file contains the postcard bytes of `Body`. Each matching +`*.envelope.hex` contains the complete postcard `InboxEnvelope`, including +HPKE ciphertext and tag. Hex is lowercase, with a trailing newline. + +Fixed inputs (synthetic, never production keys or secrets): + +- Sender X25519 private-key bytes: `11` repeated 32 times. +- Recipient X25519 private-key bytes: `22` repeated 32 times. +- HPKE ephemeral RNG output: `33` repeated 32 times (the IKM passed to + DHKEM's `DeriveKeyPair`, not a raw ephemeral private scalar). +- Message ID: `44` repeated 16 times. +- Created at: `1760000000`; TTL: `3600`; expires at: `1760003600`. +- Envelope and plaintext version: `2`; cipher suite: `1`. +- AAD: postcard `(2u8, 1u16, sender_fp, recipient_fp)`. +- Info: ASCII `kc2 inbox` followed by the two raw 32-byte fingerprints. +- Plaintext: 4-byte big-endian postcard length, postcard `InboxPlain2`, then + zeros to 4096 bytes; HPKE adds a 16-byte tag. + +The complete expected messages are declared in `../mod.rs::cases`. They cover +all eight SyncMsg discriminants, both Body and Op discriminants, both ItemKind +values, all six AckResult discriminants, and both approval_ref option cases. +`changes` contains both a Put and a Retire. The fixture files are read-only +inputs to tests; tests never rewrite them. + +`../mod.rs` is included as `inbox::v2_tests` by `src/inbox.rs` under `cfg(test)`. +This lets ordinary `cargo test -p kc-proto` exercise the production sealing +path with fixed randomness without exposing a deterministic production API +or requiring the test-util feature. diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/accept.body.hex b/crates/kc-proto/tests/inbox_v2/fixtures/accept.body.hex new file mode 100644 index 0000000..b93a2a8 --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/accept.body.hex @@ -0,0 +1 @@ +010205746f6b656eac02 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/accept.envelope.hex b/crates/kc-proto/tests/inbox_v2/fixtures/accept.envelope.hex new file mode 100644 index 0000000..3850c2d --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/accept.envelope.hex @@ -0,0 +1 @@ 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 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/ack.body.hex b/crates/kc-proto/tests/inbox_v2/fixtures/ack.body.hex new file mode 100644 index 0000000..4cff008 --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/ack.body.hex @@ -0,0 +1 @@ +01050605746f6b656e00000000000000000000000000000000000005746f6b656e01010101010101010101010101010101010105746f6b656e02020202020202020202020202020202020205746f6b656e03030303030303030303030303030303030305746f6b656e04040404040404040404040404040404040405746f6b656e050505050505050505050505050505050505 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/ack.envelope.hex b/crates/kc-proto/tests/inbox_v2/fixtures/ack.envelope.hex new file mode 100644 index 0000000..b2c3b3d --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/ack.envelope.hex @@ -0,0 +1 @@ +0201d19bf3f082782c87b783fe7134698aeff6e66d9f86afaf7cf9e9b8bf40bab3ff65cf5c9b1de5d41f758cb67f2d05f3e316a203fcb56351d9e3f158e02962c74da04588b74683334f6e7670db45cca1288fc2c1499d78715d9456f5d99261a82390206eecf8b36a1a2fd09db20629914f5b14eb406b70fcef91b1b16028a42f49a3cbb360c75aee5b45dffea9e6231478f1ab33e0772707caa5b7f633dc3efcb6b02323173c9104c8462248f097d28fe1c3b0ae09a956f7bfb67bd7893f8a2c80bac9d63619bf913fa06099f8be3454765f4263c1a34657d6ff20730b0db8db75bf8247b07fbdb2acc3909488b70ab63cee25a898c97336c691b7c577a654dbb7459785553952a536231ed073557d20cbfb13507f38822334abae6130002caae29c4d6587c2aeb661a59feeb73eca6620b994e9a6a2710b85468955f630094f9f5516a99d889df80293994a21327c6e47340bffae2732ccce851b8e8492208d265d561848aa51addac4782a0e5b8bba67ff00a68d2842267845891216e2261380ee761a6f7bdca8abd6bdad646ae6a49c9d25b4c5147137966b9ea7aa65da58ce08c3e30b5f531880dfb141d025bf0de2f09257b23ad7858414f4bf90cfe08ed4f35e806a1fad927cfd89887e98ef3dbfea5d485a391717b615ee155b3018f101a13c347115d9708c0f81ef7421303508839617f091b9d2727cf2029c86d495ef6b9d271af7d504bfbfa459c6d123cc2b2337c0ab850d0e240da5d1d71338dde1bcb446834b763b73243f65c2832d4ea1ffd8c8c7d8396afbe20def11b3e4ab7755545d16891b91e4a0f786d6364efe06d1adb18e8b4f69eb07d3d7ff03a288349703c98c758169c4933788e571b358dea214218e2e842a5f0113ef5fec867a874a50fbd9150bed757f21226067e3b27909b96dcc6c9c6aca1d8d275e1eee50380ab2a89ceabbedbfa02c1eedefc7bba061cd909108126bdff750b98096bda2d0fd2657f285d864acc8e0c79c34d75b5b179e051e64a843a6a57b3fac91e34cf257fa9398bf28680b788f0fd0f1d83b82c027391e6a3f71caccbfb43203e82884cbb3b6611dad627b407cfe60aa9594366662e9f8f7fd685b2dbe0f05f402b53c02651a21983576086df298bea12e2ea3fba81b495322c228effade35a026ddaf403d0fec95548125443b2d24504c3d2c5fcc40aedce0a8170aadd4a6f77c109aaf465f19f8e4f9e1a0ff3c60508cdce0e2f7a681b31deb96fccd93b3451832467fc1ce9fd57439a59d7821f0601d83edae298c0f1428daec95138e7fbc1670d1dd46288669061ebc8159b87dd12550cfd191f905054ec65e733fd26e1dbcfab16419134a5a001e98162134dbafaccf2bb0bc63d1aca8001e4d6894d8df96eb89da881532541800f21a05326ff5b712e9a2b02681988d4726b2b8124a1dcd1e3a03a2351f7211d837bea77c6fb4782231807445f6972e21d5a9bbdd3cbf45361faae3e1e906d94ca37f2e743b9a3d83ffbca7e8439ac7b7bcab0552a6bdfa68587ac3c16cbb8eb8b502321ab7d898c82e330e3b0220c920de62b409fd61bf70f3e3ae88f9d46d5e260c061488e7dbb7b068697f39052bfa9290d0cfe1e79e4aaa30bd6e8947bc1c8c07fc9ef245498cd84679a8517164f9c3a99ec8aefacdcc0f796566b22ad9cf71f8710a5c25d941f949c2e90499dcedc092f00987ab16af3d220f9e87282c3339d97469d57532fcafbc27988cab2601397d5eca6ba4178da5850def32a64a6e77322b32635f4a1a544756eefe12c827557870c3b8782a5813a0d3d250a9df1172e6b742ed93e9b3fadde0bf40806eec90e236f5ab02cfc71b4e1e3440a6ba5180e3ae30dc344fcf70151f41a8de9091c28fcedb1ef078c4430737efc2bd94ffc1a5258fe28567e27217491f4bea5302ccd1b5a59dd05507ed251b6149ed83a408100fc887cca389ebfeebde146884acc8ef336e513ecbce4aaa2e53476d58b8e98ba8d0508b20a954868d06c369abeb891c9f88e5bb95951fe1d47640bbb0e74e3df0e4d175c086a8abdd6ee95ea6ebc15836f0318653e91bc41f1785fc98aa746893302246d32c779b4237d4d28893280082f21759158a2a687eedcd25a18dc488ae663f8d488a5dd4f2e2b1cf30b28b31678fb16a5fda869de13311889d6bcb15988eff8e87e7f69af7125897f68444ab6cb42819c60904b3f9535b8676cf5011d97d054faac6d782bcc0d0253358c3ed1339aae657601c92a7e096f97efb864ce0d0fdd1194c28fb51bce44e58049f188751dd53038b1e6d1844c8c70e8b707d16627d20174cc1ba8ef7af4df56e098882989fbbd09d37138595b7936b1daee68f9f92048a05c955eeac6c4ecd09650345828c4fc84ff755ea9fc2220b328dcd499c6c8d204b836aa214019f437faf1aabe65fe358f01240122dc7dbdb5835a61779b83cd1c003d4cf6e765180345d1f87db40137baf6931f9aead057495b6cfe153fdc8ea4e7c961e136177349fdd5ae32137f220907791b41348a089040fcb2cd03216a9bc88b73eaae98e54ddcba8758f7ee495e82721ab205288a361045c9407b6d7479e9d1230e14d3111f0ee2b2353e02956f298a0d547b313e7ac945ec5125d63440b098d335c0e64b119f92e59ef61119058bb8cc270fd4fa04f1a756187a08bc129bfe24d9f9358f4fb7b3a6b3727b5caa0b68c049f4674954c894a59e2b13351cecf09903873320afb73314083d616db475fdba0a2b11c1bb6833056e73ee2faa00aedee502b1dd5f5b223a4ddb197f50c60d508f91291a0d97ddc6ed0fae1abc4f25b85ff8808ef872c7ded1987c4b9b5f840a9dcf971453bc5baacae18570146aa67e1e74b18e417884c810ff133c57dce6ea7524456e22ded3378df18c38e7705970d691c7ac8ad9d4d41a611c513aa1b09d3212c6fd99bb945b67ac3cd6ee45449a24bf6d87eaed19161e3c5ca0db9dc8d07bdb0e4f2aaa7ab3fda4ddece40b0a0bcc2ff78bf1fc8ef776a6e35751bfa8ba5ded3ba10d8827cec52dda82d5296f9df87833ee791b70826c1ce8e00f4d7ef13dedec30676757aa953efddf2d2d019654b1663d9b1d17a998a7c46365d7befd6bb3ab12bf9e7c5553211a429be7645bd04c9e77a12cd25df89c159636d3b3752421b30b55182a1ea5901f4dd48236729cfe5644a54e86ef1a9226facf74a8967d2d635ea789cfeb152d025e470bd15363222d859331fe9397de1e13c7e04b1c5c62a0956d3cd1333f32b3fc0adcb92c78f4306cb7d284ff3b7cd35b8517919958be8226f0ca4c63e349d8492ef8a418e453838937d58ef051f4752dd14d5ac71268f7f825de2c591d02c9bbb4b901b86f0425905d5d458ddad67d79bdac1692a0c4e403fbc8c36ac3ca46fd0bb5f69440b6ee139371d9be0ea1be3d87f86a4223f95489dd6c44f7d3815c010c071cc69df65f88a7b0edcfc7dc3296e56155dca8faed041506d00b46f6c4b91f5502046851e45ebccab4d064f8d94d3709881035698e0e281cb4b224d0887f6e4d4588a0f1ecf57fb9ae167b54c36e20863391c6c7e1b5de4f17fe53d5c926e78956d55601f1d0ae9f62ffa147c6566ebcbaf45ee1d0ab3926d62bfc4bd85a9b331b839610efadce593274353103de56caf9af947aaace8b14ae5042c147ddbadeea565f0ef1833dd996e40eae9d765c8f0b1bae8d60a5952c74bf9f269e875c8fba9e5ab662d893eb871fee0a2d60ca3fd839249869dac629487da9705c2623d64276a26fbebfbc28d603a0eee474fbbccd12f67d7e6a251af51227f17bcf8ab3a016cbfe43311baa588f8f0f711029aa62a4f1c7ca38b63e9e4045c5ef50fdd42216dd337611a6069da43513a773af58aca8e7cb3909a34c6cfd74802acc3e30a856f086638fb9e0c3418a842af45857595a9fd2296046dc4f9d65f9f1884de729de7ed1562c66fdc355492e7b8b5ab48a566c8fd1fab85b39056268e27282109f9dc85765224141e340824e7582118da5c949ba515bbdb9961b5b63e413d0616dbca7bf08a831e14dd9a1a31a8ac71d8ac96084eb644811c02cee855a4ac308dc86c968de21f1ba31682be521a5ff4898be7c5df750afe8ee0dc94286699e45ee5b59e35238ea0282a778ef1e16fe6ba37ff563bc2c47e7c67c66690667de188906d785159dae34dcba090376a862252498db3f432270c619fa317e0f7bccd6278644f80458771b334a2e98ad3cd53da99c0b3938a7fa1ef3a4a6dbcdd6a50aacdec1a6f78dfffe4b995f286f6b9563d3cca36ae2f1a77f21f4c452cdc060e930ab11c382eacd5bfbe97d4d7e5393506b0225dc65556a8d7bf5e88fb40677990e37dfd580309f457fb09f2845e811cb4337f4c2e787c63c50c0ddbf7a24e84a71daeb05d0317e402c06cfdc31033128fcbbc5d42f476e26e886d9e699c9cf7931986d82ed50d8b7919a1191a030de511f5cb8825e0aa02913729a594045e4ac4a9996dfb294c9d70062c574edc5086a05dd5105e47105721576ea8c8309f3a55c8e4f9d3e3e6b166e0336f16675d7674893f815d6a11845ef22300b12afcb6c6f066604ae2615c1f493a7967c4cbeb7af9744efd509c95b37ba23d9e0cc4e528557185509c88f7ba6ac2c7337aeb138251c3d2da24436ad1cdd8aa7ef9f9e2692c65ca3fd0db2679fd73a040213021150e5f0998fdedcd52ffbebb1b0d0d0ac8b3e85e8c158cd3102b292737d06b11e47fdbdced40d06ba48ddb89d2a0ededb3292e23211171275cee375159f7a2124527db04c89905764421cd52c8630132c1a0eab503e5ff9408bfa93be779cc0460464449362e2cc283114cc03dd77d000ced605a9c16b3ce1aa9984646471bfa777b6075855f782b90a2ea7dba5fbf131d95b005b9e847de06793b11670ea1c876ad3885056a9775ab3ae671c341e430a689681cab9a2a4cf1a6244382b667412c03d476d26787f932742579252684b8e7d87f67f9bd13400b0e208d8a400ee9e4684aa3c55aa25153b096ceedd595614b746c2586883aa6676b49a68d69389f726f69f348fdaee5190eed81a5ed35dc1f7b9f2cc8f111da38382eb33bdd5cf551c73b0306e81bbf36d532394359db5da7fbed9868ae497c90634832a6cb159dfdd8939c7b640fedf0f2cbe16101a6b820e636e366faf3d14ca47eac85aa7927f80227cb45ee3b37552acad66ca31b89de29faea2813ebad9a9138749aec2a2109426bcc40ca62c6df72cb01e7338d4e20550b09f3f77cc027253e74462519e9740c9f10b99d37bd78b07680b30753bc3a042edc54e99a58eb0c894558aeb6767c114d280cf4679a0284a02c12c905558573201c699b8d0c673ecee542e8b68c9c5349862db3076b325d7b3a5ebdc043cd47f06d3a5023c54358d5b40d13568aef034834b666becc58a148e7e928320ca28784e636d1158d528f808dcc32a88eca8f88498993086329183109fdcf3c0d3d88b17a5f67a09139a48ea6a58f45d4a1ed243cd5f52d796dc354d117ee1280e7cda6a0be7eea63d5cf4edf24da3fe6c2ef127aaee7d30e93d343975d57828f2f6055b15c37bbe0268ea7a756146d19074d1af0311e437d511af17ae59a3876b6d6cd0a5b6162d6455aa5cbc096e559cd1404990622237987f85d33ecded64d76493b382dcfc9c46a79862f2c9bfc04c5eb0fab092a5bfe944af524e55af838d1e43c6dad58681de611079f84e5f397811e335540bfb99329f8c33dbc4739971eb6e98f1b915234885754cae52b42addc5ed899f5d08a8f8c2caf9c6676d39d5e72efaadd61a762d6f20bd03237f82e11e62a70b716897283362a03eff71bee50107debeacdaa91c6d575d30a2b30ecf728e8a5454a3994f70206eb4786ad4e025ad209c9e379ea05af687b96fcf7be42213bdac4dd4257d9da2acb96960124986eb8 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/approvals.body.hex b/crates/kc-proto/tests/inbox_v2/fixtures/approvals.body.hex new file mode 100644 index 0000000..1c07e1f --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/approvals.body.hex @@ -0,0 +1 @@ +0107020301020300 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/approvals.envelope.hex b/crates/kc-proto/tests/inbox_v2/fixtures/approvals.envelope.hex new file mode 100644 index 0000000..b35b418 --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/approvals.envelope.hex @@ -0,0 +1 @@ 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 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/changes.body.hex b/crates/kc-proto/tests/inbox_v2/fixtures/changes.body.hex new file mode 100644 index 0000000..3805bd4 --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/changes.body.hex @@ -0,0 +1 @@ +01040205746f6b656eac0255555555555555555555555555555555016666666666666666666666666666666602666666666666666666666666666666667777777777777777777777777777777700000b746573742d7365637265740188888888888888888888888888888888036f6c64029999999999999999999999999999999900000100 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/changes.envelope.hex b/crates/kc-proto/tests/inbox_v2/fixtures/changes.envelope.hex new file mode 100644 index 0000000..e894ad7 --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/changes.envelope.hex @@ -0,0 +1 @@ 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 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/digest.body.hex b/crates/kc-proto/tests/inbox_v2/fixtures/digest.body.hex new file mode 100644 index 0000000..effa48f --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/digest.body.hex @@ -0,0 +1 @@ +01060105746f6b656eac0255555555555555555555555555555555 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/digest.envelope.hex b/crates/kc-proto/tests/inbox_v2/fixtures/digest.envelope.hex new file mode 100644 index 0000000..5312558 --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/digest.envelope.hex @@ -0,0 +1 @@ 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 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/hello.body.hex b/crates/kc-proto/tests/inbox_v2/fixtures/hello.body.hex new file mode 100644 index 0000000..2e5ff50 --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/hello.body.hex @@ -0,0 +1 @@ +0100010773796e632d763100 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/hello.envelope.hex b/crates/kc-proto/tests/inbox_v2/fixtures/hello.envelope.hex new file mode 100644 index 0000000..6cb6c0f --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/hello.envelope.hex @@ -0,0 +1 @@ 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 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/items.body.hex b/crates/kc-proto/tests/inbox_v2/fixtures/items.body.hex new file mode 100644 index 0000000..21aa8de --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/items.body.hex @@ -0,0 +1 @@ +000105746f6b656e0b746573742d736563726574ecdfbb8e0d diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/items.envelope.hex b/crates/kc-proto/tests/inbox_v2/fixtures/items.envelope.hex new file mode 100644 index 0000000..5156311 --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/items.envelope.hex @@ -0,0 +1 @@ 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 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/leave.body.hex b/crates/kc-proto/tests/inbox_v2/fixtures/leave.body.hex new file mode 100644 index 0000000..4d61241 --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/leave.body.hex @@ -0,0 +1 @@ +010305746f6b656eac02 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/leave.envelope.hex b/crates/kc-proto/tests/inbox_v2/fixtures/leave.envelope.hex new file mode 100644 index 0000000..ce21799 --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/leave.envelope.hex @@ -0,0 +1 @@ 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 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/offer.body.hex b/crates/kc-proto/tests/inbox_v2/fixtures/offer.body.hex new file mode 100644 index 0000000..53b8aaa --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/offer.body.hex @@ -0,0 +1 @@ +01010a636f6e6669672e656e765555555555555555555555555555555501666666666666666666666666666666660107544553543d310a diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/offer.envelope.hex b/crates/kc-proto/tests/inbox_v2/fixtures/offer.envelope.hex new file mode 100644 index 0000000..149127a --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/offer.envelope.hex @@ -0,0 +1 @@ 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 diff --git a/crates/kc-proto/tests/inbox_v2/mod.rs b/crates/kc-proto/tests/inbox_v2/mod.rs new file mode 100644 index 0000000..18f5945 --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/mod.rs @@ -0,0 +1,278 @@ +//! Compiled as an inbox unit-test module so fixed HPKE randomness never +//! becomes a production API. All values below are synthetic test secrets. +use super::*; +use crate::names::ItemName; +use crate::secret::SecretBytes; +use crate::sync::{AckResult, Change, ChangeId, DigestEntry, ItemKind, Op, SyncMsg, Vid}; + +const NOW: i64 = 1_760_000_000; +const TTL: Duration = Duration::from_secs(3600); +const ID: MessageId = MessageId([0x44; 16]); + +struct FixedRng; +impl hpke::rand_core::TryRng for FixedRng { + type Error = std::convert::Infallible; + fn try_next_u32(&mut self) -> Result { panic!("unexpected RNG call") } + fn try_next_u64(&mut self) -> Result { panic!("unexpected RNG call") } + fn try_fill_bytes(&mut self, dst: &mut [u8]) -> Result<(), Self::Error> { + assert_eq!(dst.len(), 32); + dst.fill(0x33); + Ok(()) + } +} +impl hpke::rand_core::TryCryptoRng for FixedRng {} + +fn keys() -> (DeviceKeyPair, DeviceKeyPair) { + (DeviceKeyPair::from_secret_bytes(&[0x11; 32]).unwrap(), + DeviceKeyPair::from_secret_bytes(&[0x22; 32]).unwrap()) +} +fn name(s: &str) -> ItemName { ItemName::new(s).unwrap() } +fn item() -> Item { + Item { name: name("token"), value: SecretBytes::from_slice(b"test-secret"), updated_at: NOW - 10 } +} +fn hello() -> Body { + Body::Sync(SyncMsg::Hello { features: vec!["sync-v1".into()], is_reply: false }) +} +fn change() -> Change { + Change { + name: name("token"), generation: 300, new_vid: Vid([0x55; 16]), + parents: vec![Vid([0x66; 16])], lineage: vec![Vid([0x66; 16]), Vid([0x77; 16])], + op: Op::Put { kind: ItemKind::Text, value: SecretBytes::from_slice(b"test-secret") }, + approval_ref: Some([0x88; 16]), + } +} +fn cases() -> Vec<(&'static str, Body)> { + vec![ + ("hello", hello()), + ("offer", Body::Sync(SyncMsg::Offer { + name: name("config.env"), vid: Vid([0x55; 16]), lineage: vec![Vid([0x66; 16])], + kind: ItemKind::File, value: SecretBytes::from_slice(b"TEST=1\n"), + })), + ("changes", Body::Sync(SyncMsg::Changes { changes: vec![change(), Change { + name: name("old"), generation: 2, new_vid: Vid([0x99; 16]), parents: vec![], + lineage: vec![], op: Op::Retire, approval_ref: None, + }] })), + ("ack", Body::Sync(SyncMsg::Ack { results: [ + AckResult::Applied, AckResult::Held, AckResult::Conflict, + AckResult::StaleGeneration, AckResult::DeferredCapacity, AckResult::Rejected, + ].into_iter().enumerate().map(|(i, result)| (ChangeId { + name: name("token"), generation: i as u64, new_vid: Vid([i as u8; 16]), + }, result)).collect() })), + ("digest", Body::Sync(SyncMsg::Digest { entries: vec![DigestEntry { + name: name("token"), generation: 300, head: Vid([0x55; 16]), + }] })), + ("items", Body::Items(vec![item()])), + ("accept", Body::Sync(SyncMsg::Accept { name: name("token"), generation: 300 })), + ("leave", Body::Sync(SyncMsg::Leave { name: name("token"), generation: 300 })), + ("approvals", Body::Sync(SyncMsg::Approvals { docs: vec![vec![1, 2, 3], vec![]] })), + ] +} +fn bob_opens(bytes: &[u8], now: i64) -> Result { + let (alice, bob) = keys(); + open_any(bytes, &[&bob], |fp| (*fp == alice.fingerprint()).then_some(*alice.public()), |_| false, now) +} +fn plain(body: Body) -> InboxPlain2 { + let (alice, bob) = keys(); + InboxPlain2 { v: VERSION_V2, msg_id: ID, sender_fp: alice.fingerprint(), + recipient_fp: bob.fingerprint(), created_at: NOW, expires_at: NOW + 3600, body } +} +// Intentionally bypass sender validation for adversarial authenticated messages. +fn seal_plain(p: &InboxPlain2, prefix: &[u8]) -> Vec { + let (alice, bob) = keys(); + let (sender_fp, recipient_fp) = (alice.fingerprint(), bob.fingerprint()); + let mut buf = pad::encode(p, &[], TAG_LEN).unwrap(); + let (enc, tag) = hpke::single_shot_seal_inout_detached_with_rng::( + &OpModeS::Auth((alice.kem_private().clone(), alice.public().kem_public())), + &bob.public().kem_public(), &info_with_prefix(prefix, &sender_fp, &recipient_fp), + (&mut buf[..]).into(), &header_aad(VERSION_V2, SUITE, &sender_fp, &recipient_fp), &mut FixedRng, + ).unwrap(); + buf.extend_from_slice(&tag.to_bytes()); + InboxEnvelope { v: VERSION_V2, suite: SUITE, sender_fp, recipient_fp, + enc: enc.to_bytes().into(), ct: std::mem::take(&mut *buf) }.encode() +} +fn hex(bytes: &[u8]) -> String { bytes.iter().map(|b| format!("{b:02x}")).collect() } +fn unhex(s: &str) -> Vec { + let s: String = s.split_whitespace().collect(); + assert_eq!(s.len() % 2, 0); + s.as_bytes().chunks(2).map(|p| u8::from_str_radix(std::str::from_utf8(p).unwrap(), 16).unwrap()).collect() +} +fn fixture(label: &str, suffix: &str) -> String { + std::fs::read_to_string(format!("{}/tests/inbox_v2/fixtures/{label}.{suffix}.hex", env!("CARGO_MANIFEST_DIR"))).unwrap() +} + +#[test] +fn golden_vectors_encode_and_open() { + let (alice, bob) = keys(); + for (label, body) in cases() { + let sealed = seal_v2_with_rng(&alice, bob.public(), &body, TTL, NOW, ID, &mut FixedRng).unwrap(); + let encoded_body = postcard::to_allocvec(&body).unwrap(); + assert_eq!(hex(&encoded_body), fixture(label, "body").trim(), "{label} body"); + let expected = unhex(&fixture(label, "envelope")); + assert_eq!(sealed.body, expected, "{label} envelope"); + assert_eq!(sealed.body, seal_plain(&plain(body.clone()), INFO_PREFIX_V2), "borrowed encoding"); + let opened = bob_opens(&expected, NOW).unwrap(); + assert_eq!(opened, OpenedAny { msg_id: ID, sender_fp: alice.fingerprint(), + created_at: NOW, expires_at: NOW + 3600, body }); + assert_eq!(opened.keep_seen_until(), NOW + 3600 + CLOCK_SKEW_SECS); + } +} + +#[test] +fn public_seal_v2_round_trips_all_bodies() { + let (alice, bob) = keys(); + for (label, body) in cases() { + let sealed = seal_v2(&alice, bob.public(), &body, TTL, NOW).unwrap(); + let opened = bob_opens(&sealed.body, NOW).unwrap(); + assert_eq!(opened.body, body, "{label}"); + assert_eq!(opened.msg_id, sealed.msg_id); + assert_eq!(opened.sender_fp, alice.fingerprint()); + assert_eq!((opened.created_at, opened.expires_at), (NOW, NOW + 3600)); + } +} + +#[test] +fn v1_open_rejects_v2_before_decryption() { + let (alice, bob) = keys(); + let sealed = seal_v2(&alice, bob.public(), &hello(), TTL, NOW).unwrap(); + let mut envelope = InboxEnvelope::decode(&sealed.body).unwrap(); + assert_eq!(envelope.v, 2); + for body in [sealed.body, { envelope.ct.clear(); envelope.encode() }] { + assert_eq!(open(&body, &[], |_| panic!("peer lookup before version check"), + |_| panic!("seen lookup before version check"), NOW).unwrap_err(), InboxError::UnsupportedVersion(2)); + } +} + +#[test] +fn open_any_maps_v1_to_items() { + let (alice, bob) = keys(); + let sealed = seal(&alice, bob.public(), &[item()], TTL, NOW).unwrap(); + let opened = bob_opens(&sealed.body, NOW).unwrap(); + assert_eq!(opened.body, Body::Items(vec![item()])); + assert_eq!(opened.msg_id, sealed.msg_id); + assert_eq!(opened.sender_fp, alice.fingerprint()); + assert_eq!((opened.created_at, opened.expires_at), (NOW, NOW + 3600)); +} + +#[test] +fn v2_rejects_inner_v1() { + let mut p = plain(hello()); + p.v = 1; + assert_eq!(bob_opens(&seal_plain(&p, INFO_PREFIX_V2), NOW).unwrap_err(), InboxError::UnsupportedVersion(1)); +} + +#[test] +fn v2_rejects_v1_info() { + assert_eq!(bob_opens(&seal_plain(&plain(hello()), INFO_PREFIX), NOW).unwrap_err(), InboxError::DecryptFailed); +} + +#[test] +fn lineage_limit_on_decode_validate_and_open() { + for n in [0, 64, 65] { + let mut c = change(); + c.lineage = vec![Vid([7; 16]); n]; + let bytes = postcard::to_allocvec(&c).unwrap(); + assert_eq!(postcard::from_bytes::(&bytes).is_ok(), n <= 64); + let json = serde_json::to_string(&c).unwrap(); + assert_eq!(serde_json::from_str::(&json).is_ok(), n <= 64); + assert_eq!(c.validate().is_ok(), n <= 64); + let body = Body::Sync(SyncMsg::Changes { changes: vec![c] }); + let result = bob_opens(&seal_plain(&plain(body.clone()), INFO_PREFIX_V2), NOW); + let (alice, bob) = keys(); + let sealed = seal_v2(&alice, bob.public(), &body, TTL, NOW); + if n <= 64 { assert!(result.is_ok()); assert!(sealed.is_ok()); } + else { assert_eq!(result.unwrap_err(), InboxError::Malformed); assert_eq!(sealed.unwrap_err(), InboxError::Malformed); } + } +} + +#[test] +fn duplicate_change_and_item_names_are_malformed() { + let mut other = change(); + other.generation += 1; + other.new_vid = Vid([0xaa; 16]); + for body in [Body::Sync(SyncMsg::Changes { changes: vec![change(), other] }), + Body::Items(vec![item(), item()])] { + assert_eq!(bob_opens(&seal_plain(&plain(body.clone()), INFO_PREFIX_V2), NOW).unwrap_err(), InboxError::Malformed); + let (alice, bob) = keys(); + assert!(seal_v2(&alice, bob.public(), &body, TTL, NOW).is_err()); + } +} + +#[test] +fn v2_lifetime_skew_and_replay_checks() { + let bytes = seal_plain(&plain(hello()), INFO_PREFIX_V2); + assert!(bob_opens(&bytes, NOW - CLOCK_SKEW_SECS).is_ok()); + assert!(bob_opens(&bytes, NOW + 3600 + CLOCK_SKEW_SECS).is_ok()); + assert_eq!(bob_opens(&bytes, NOW - CLOCK_SKEW_SECS - 1).unwrap_err(), InboxError::NotYetValid); + assert_eq!(bob_opens(&bytes, NOW + 3601 + CLOCK_SKEW_SECS).unwrap_err(), InboxError::Expired); + for (created, expires, ok) in [(NOW, NOW, true), (NOW, NOW + MAX_LIFETIME_SECS, true), + (NOW, NOW - 1, false), (NOW, NOW + MAX_LIFETIME_SECS + 1, false), (i64::MIN, i64::MAX, false)] { + let mut p = plain(hello()); p.created_at = created; p.expires_at = expires; + let result = bob_opens(&seal_plain(&p, INFO_PREFIX_V2), NOW); + if ok { assert!(result.is_ok()); } else { assert_eq!(result.unwrap_err(), InboxError::BadLifetime); } + } + let (alice, bob) = keys(); + assert_eq!(open_any(&bytes, &[&bob], |_| Some(*alice.public()), |id| { assert_eq!(*id, ID); true }, NOW).unwrap_err(), InboxError::Replay); + for (ttl, now) in [(Duration::ZERO, NOW), (Duration::from_secs(MAX_LIFETIME_SECS as u64 + 1), NOW), (TTL, i64::MAX)] { + assert_eq!(seal_v2(&alice, bob.public(), &hello(), ttl, now).unwrap_err(), InboxError::InvalidTtl); + } +} + +#[test] +fn v2_fingerprint_and_authentication_checks() { + let (alice, bob) = keys(); + for sender in [true, false] { + let mut p = plain(hello()); + if sender { p.sender_fp = bob.fingerprint(); } else { p.recipient_fp = alice.fingerprint(); } + assert_eq!(bob_opens(&seal_plain(&p, INFO_PREFIX_V2), NOW).unwrap_err(), InboxError::FingerprintMismatch); + } + let bytes = seal_plain(&plain(hello()), INFO_PREFIX_V2); + assert_eq!(open_any(&bytes, &[&alice], |_| Some(*alice.public()), |_| false, NOW).unwrap_err(), InboxError::WrongRecipient); + for pk in [None, Some(*bob.public())] { + assert_eq!(open_any(&bytes, &[&bob], |_| pk, |_| false, NOW).unwrap_err(), InboxError::UnknownSender); + } + assert!(open_any(&bytes, &[&alice, &bob], |_| Some(*alice.public()), |_| false, NOW).is_ok()); + for field in 0..3 { + let mut env = InboxEnvelope::decode(&bytes).unwrap(); + match field { 0 => env.enc[0] ^= 1, 1 => env.ct[0] ^= 1, _ => *env.ct.last_mut().unwrap() ^= 1 } + assert_eq!(bob_opens(&env.encode(), NOW).unwrap_err(), InboxError::DecryptFailed); + } +} + +#[test] +fn v2_size_and_envelope_checks() { + let (alice, bob) = keys(); + let body = Body::Sync(SyncMsg::Offer { name: name("large"), vid: Vid([1; 16]), lineage: vec![], + kind: ItemKind::File, value: SecretBytes::from_slice(&vec![0; MAX_MESSAGE_BYTES]) }); + assert_eq!(seal_v2(&alice, bob.public(), &body, TTL, NOW).unwrap_err(), InboxError::TooLarge); + assert_eq!(bob_opens(&vec![0; MAX_MESSAGE_BYTES + 1], NOW).unwrap_err(), InboxError::TooLarge); + let bytes = seal_plain(&plain(hello()), INFO_PREFIX_V2); + let mut env = InboxEnvelope::decode(&bytes).unwrap(); env.v = 3; + assert_eq!(bob_opens(&env.encode(), NOW).unwrap_err(), InboxError::UnsupportedVersion(3)); + env.v = 2; env.suite = 2; + assert_eq!(bob_opens(&env.encode(), NOW).unwrap_err(), InboxError::UnsupportedSuite(2)); + env.suite = 1; env.ct.truncate(15); + assert_eq!(bob_opens(&env.encode(), NOW).unwrap_err(), InboxError::Malformed); + let mut trailing = bytes.clone(); trailing.push(0); + for bad in [vec![], bytes[..bytes.len()-1].to_vec(), trailing] { + assert_eq!(bob_opens(&bad, NOW).unwrap_err(), InboxError::Malformed); + } +} + +#[test] +fn vid_serde_and_secret_debug() { + let vid = Vid([0xab; 16]); + assert_eq!(postcard::to_allocvec(&vid).unwrap(), vec![0xab; 16]); + let json = format!("\"{}\"", "ab".repeat(16)); + assert_eq!(serde_json::to_string(&vid).unwrap(), json); + assert_eq!(serde_json::from_str::(&json).unwrap(), vid); + assert_eq!(serde_json::from_str::(&json.to_uppercase()).unwrap(), vid); + for bad in ["\"00\"", "\"zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz\"", "[]"] { + assert!(serde_json::from_str::(bad).is_err()); + } + let random = Vid::random(); + assert_eq!(postcard::from_bytes::(&postcard::to_allocvec(&random).unwrap()).unwrap(), random); + for (_, body) in cases() { + let debug = format!("{body:?}"); + assert!(!debug.contains("test-secret")); assert!(!debug.contains("TEST=1")); + } +} diff --git a/docs/PROTOCOL.md b/docs/PROTOCOL.md index d2587f0..c8e6d73 100644 --- a/docs/PROTOCOL.md +++ b/docs/PROTOCOL.md @@ -146,6 +146,71 @@ PairOffer { suggested_label: String, device_pk: [u8; 32], inbox_id: [u8; 16 - `kc device rotate` creates a new key and a new inbox, deletes the old inbox and asks you to re-pair. - The old private key is kept for 72 h to open messages already in flight. +### v2: sync-capable inbox messages + +The outer postcard `InboxEnvelope` has exactly the v1 fields and order above; +only `v` changes to `2`. `suite` remains `1`. A v1 reader decodes the envelope +and rejects version `2` **before decryption**. `seal` and `open` remain v1-only; +`seal_v2` writes v2 and `open_any` accepts both, mapping v1 items to `Body::Items`. + +```text +aad = postcard(v: 2, suite: 1, sender_fp, recipient_fp) +info = "kc2 inbox" || sender_fp || recipient_fp +plaintext = pad(postcard(InboxPlain2 { v: 2, msg_id: [u8;16], sender_fp, recipient_fp, + created_at: i64, expires_at: i64, body })) +Body = Items(Vec) | Sync(SyncMsg) +``` + +`enc` and `ct` are not part of AAD. HPKE auth mode and padding are unchanged. +The inner version must equal the outer version; a mismatch returns +`UnsupportedVersion(inner_v)`. Fingerprint, recipient, remembered-sender, +lifetime (0 through 72 hours on receive, 1 through 72 hours on send), 5-minute +clock skew, and replay checks are the same as v1. The encoded envelope must +fit the 256 KiB relay limit; `open_any` checks this before decoding. Duplicate +names in `Body::Items` reject the message as malformed. Values remain +zeroize-on-drop `SecretBytes`, including values in `Offer` and `Op::Put`. + +The following field and variant orders are fixed by golden vectors: + +```text +Vid = [u8;16] +ItemKind = Text | File +ChangeId { name: ItemName, generation: u64, new_vid: Vid } +Op = Put { kind: ItemKind, value: bytes } | Retire +Change { name: ItemName, generation: u64, new_vid: Vid, parents: Vec, + lineage: Vec, op: Op, approval_ref: Option<[u8;16]> } +AckResult = Applied | Held | Conflict | StaleGeneration | DeferredCapacity | Rejected +DigestEntry { name: ItemName, generation: u64, head: Vid } +SyncMsg = Hello { features: Vec, is_reply: bool } + | Offer { name: ItemName, vid: Vid, lineage: Vec, kind: ItemKind, value: bytes } + | Accept { name: ItemName, generation: u64 } + | Leave { name: ItemName, generation: u64 } + | Changes { changes: Vec } + | Ack { results: Vec<(ChangeId, AckResult)> } + | Digest { entries: Vec } + | Approvals { docs: Vec> } +``` + +- Postcard discriminants: `Body::Items = 0`, `Sync = 1`; `SyncMsg::Hello = 0` + through `Approvals = 7`; `Op::Put = 0`, `Retire = 1`; `AckResult::Applied = 0` + through `Rejected = 5`; `ItemKind::Text = 0`, `File = 1`. +- v1 `Item` has no kind field. v2 sync defines `ItemKind` separately, with the + store's text/file presentation meanings; the v1 `Item` layout is unchanged. +- `Vid` is 16 raw bytes in postcard and 32 hex characters in human-readable + formats (lowercase when written), just like `MessageId`. Fresh Vids use the + operating system CSPRNG. Generations use postcard's `u64` varint encoding. +- `Change.lineage` is limited to 64 entries on decode and validation. Names + must be unique within a `Changes` batch. Either violation rejects the entire + opened message as `Malformed`. `parents` are the sender's claimed direct + parents; approval and application policy are outside this wire layer. +- `Approvals` holds opaque reserved documents; this layer does not interpret them. +- Unknown peers' v2 capabilities are probed with one `Hello`; other sync messages + wait for its reply. Ordinary `send --to` stays v1. Sync changes must never be + downgraded to v1 items. This negotiation policy is implemented above the codec. + +Golden vectors in `crates/kc-proto/tests/inbox_v2/fixtures` freeze both body +postcard bytes and complete encrypted envelopes, including all enum variants. + ## 5. Relay rules - **Channels:** in memory. From e54c912823514f3ef78d7771ee2d67cbd98d086a Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Tue, 13 Oct 2026 16:22:10 +0900 Subject: [PATCH 11/24] style: cargo fmt Co-Authored-By: Claude Opus 5.5 --- crates/kc-cli/src/local_auth.rs | 16 +- crates/kc-cli/src/local_auth/linux.rs | 63 +- crates/kc-cli/src/local_auth/macos.rs | 20 +- crates/kc-cli/src/local_auth/windows.rs | 15 +- crates/kc-proto/src/inbox.rs | 4 +- crates/kc-proto/src/sync.rs | 5 +- crates/kc-proto/tests/inbox_v2/mod.rs | 435 +++++++++--- crates/kc-sync/src/decision.rs | 156 ++++- crates/kc-sync/src/generation.rs | 66 +- crates/kc-sync/src/limiter.rs | 80 ++- crates/kc-sync/src/outbox.rs | 104 ++- crates/kc-sync/src/recovery.rs | 40 +- crates/kc-sync/src/slots.rs | 82 ++- crates/kc-sync/src/state.rs | 77 ++- crates/kc-sync/tests/policy.rs | 869 +++++++++++++++++++----- crates/kc-sync/tests/simulation.rs | 485 ++++++++++--- 16 files changed, 1987 insertions(+), 530 deletions(-) diff --git a/crates/kc-cli/src/local_auth.rs b/crates/kc-cli/src/local_auth.rs index a268879..0d54a73 100644 --- a/crates/kc-cli/src/local_auth.rs +++ b/crates/kc-cli/src/local_auth.rs @@ -26,13 +26,21 @@ pub fn confirm(reason: &str) -> LocalAuthOutcome { return LocalAuthOutcome::Unavailable("local confirmation needs a reason".into()); } #[cfg(target_os = "macos")] - { macos::confirm(reason) } + { + macos::confirm(reason) + } #[cfg(windows)] - { windows::confirm(reason) } + { + windows::confirm(reason) + } #[cfg(target_os = "linux")] - { linux::confirm(reason) } + { + linux::confirm(reason) + } #[cfg(not(any(target_os = "macos", windows, target_os = "linux")))] - { LocalAuthOutcome::Unavailable("local confirmation is unsupported on this platform".into()) } + { + LocalAuthOutcome::Unavailable("local confirmation is unsupported on this platform".into()) + } } #[cfg(test)] diff --git a/crates/kc-cli/src/local_auth/linux.rs b/crates/kc-cli/src/local_auth/linux.rs index af0ef6d..8891251 100644 --- a/crates/kc-cli/src/local_auth/linux.rs +++ b/crates/kc-cli/src/local_auth/linux.rs @@ -9,7 +9,9 @@ pub(super) fn confirm(reason: &str) -> LocalAuthOutcome { Ok(time) => time, Err(error) => return LocalAuthOutcome::Unavailable(error.into()), }, - Err(error) => return LocalAuthOutcome::Unavailable(format!("cannot read /proc/self/stat: {error}")), + Err(error) => { + return LocalAuthOutcome::Unavailable(format!("cannot read /proc/self/stat: {error}")); + } }; // Do not enable pkcheck's internal terminal agent. Authentication belongs to // the session's OS agent, with no input inherited from kc's PTY. @@ -24,10 +26,14 @@ pub(super) fn confirm(reason: &str) -> LocalAuthOutcome { fn command(reason: &str, pid: u32, start_time: u64) -> Command { let mut command = Command::new("pkcheck"); command.args([ - "--action-id", "org.freedesktop.policykit.exec", - "--process", &format!("{pid},{start_time}"), + "--action-id", + "org.freedesktop.policykit.exec", + "--process", + &format!("{pid},{start_time}"), "--allow-user-interaction", - "--detail", "polkit.message", reason, + "--detail", + "polkit.message", + reason, ]); command.stdin(std::process::Stdio::null()); command @@ -36,10 +42,15 @@ fn command(reason: &str, pid: u32, start_time: u64) -> Command { /// Field 22 follows the state (field 3) by 19 fields. `comm` (field 2) can /// contain whitespace and parentheses, so only the final ')' ends that field. fn process_start_time(stat: &str) -> Result { - let (_, fields) = stat.rsplit_once(')').ok_or("/proc/self/stat has no comm terminator")?; - fields.split_whitespace().nth(19) + let (_, fields) = stat + .rsplit_once(')') + .ok_or("/proc/self/stat has no comm terminator")?; + fields + .split_whitespace() + .nth(19) .ok_or("/proc/self/stat has no start time")? - .parse().map_err(|_| "/proc/self/stat has an invalid start time") + .parse() + .map_err(|_| "/proc/self/stat has an invalid start time") } fn outcome(code: Option, stderr: &[u8]) -> LocalAuthOutcome { @@ -49,7 +60,8 @@ fn outcome(code: Option, stderr: &[u8]) -> LocalAuthOutcome { // needed but no authentication agent could ask, which falls to Unavailable below. Some(1 | 3) => LocalAuthOutcome::Denied, _ => LocalAuthOutcome::Unavailable(format!( - "pkcheck failed (exit {code:?}): {}", String::from_utf8_lossy(stderr).trim() + "pkcheck failed (exit {code:?}): {}", + String::from_utf8_lossy(stderr).trim() )), } } @@ -67,12 +79,20 @@ mod tests { fn reads_field_22() { assert_eq!(process_start_time(&stat("kc", "123456")), Ok(123456)); assert_eq!(process_start_time(&stat("kc", "0")), Ok(0)); - assert_eq!(process_start_time(&stat("kc", "18446744073709551615")), Ok(u64::MAX)); + assert_eq!( + process_start_time(&stat("kc", "18446744073709551615")), + Ok(u64::MAX) + ); } #[test] fn comm_can_contain_spaces_and_parentheses() { - for comm in ["kc local confirm", "kc (nested) name", "kc)) (a) b)", "kc\nname"] { + for comm in [ + "kc local confirm", + "kc (nested) name", + "kc)) (a) b)", + "kc\nname", + ] { assert_eq!(process_start_time(&stat(comm, "123456")), Ok(123456)); } } @@ -90,12 +110,23 @@ mod tests { #[test] fn reason_is_one_argument_and_no_internal_agent_is_enabled() { let command = command("kc: allow 'this' $(action)?", 42, 123456); - let args: Vec<_> = command.get_args().map(|arg| arg.to_str().unwrap()).collect(); - assert_eq!(args, [ - "--action-id", "org.freedesktop.policykit.exec", - "--process", "42,123456", "--allow-user-interaction", - "--detail", "polkit.message", "kc: allow 'this' $(action)?", - ]); + let args: Vec<_> = command + .get_args() + .map(|arg| arg.to_str().unwrap()) + .collect(); + assert_eq!( + args, + [ + "--action-id", + "org.freedesktop.policykit.exec", + "--process", + "42,123456", + "--allow-user-interaction", + "--detail", + "polkit.message", + "kc: allow 'this' $(action)?", + ] + ); } #[test] diff --git a/crates/kc-cli/src/local_auth/macos.rs b/crates/kc-cli/src/local_auth/macos.rs index 8dfc0a4..1a9a45a 100644 --- a/crates/kc-cli/src/local_auth/macos.rs +++ b/crates/kc-cli/src/local_auth/macos.rs @@ -29,8 +29,13 @@ pub(super) fn confirm(reason: &str) -> LocalAuthOutcome { // SAFETY: LocalAuthentication supplies nil or a valid NSError for // the duration of this callback. Only owned Rust data leaves it. match unsafe { error.as_ref() } { - Some(error) => failure(LAError(error.code()), error.localizedDescription().to_string()), - None => LocalAuthOutcome::Unavailable("LocalAuthentication returned no error details".into()), + Some(error) => failure( + LAError(error.code()), + error.localizedDescription().to_string(), + ), + None => LocalAuthOutcome::Unavailable( + "LocalAuthentication returned no error details".into(), + ), } }; // A dropped receiver must not unwind across the Objective-C callback. @@ -60,7 +65,11 @@ mod tests { #[test] fn cancelled_or_failed_authentication_is_denied() { - for code in [LAError::UserCancel, LAError::UserFallback, LAError::AuthenticationFailed] { + for code in [ + LAError::UserCancel, + LAError::UserFallback, + LAError::AuthenticationFailed, + ] { assert_eq!(failure(code, "denied".into()), LocalAuthOutcome::Denied); } } @@ -75,7 +84,10 @@ mod tests { LAError::InvalidContext, LAError(-999), ] { - assert_eq!(failure(code, "OS error".into()), LocalAuthOutcome::Unavailable("OS error".into())); + assert_eq!( + failure(code, "OS error".into()), + LocalAuthOutcome::Unavailable("OS error".into()) + ); } } } diff --git a/crates/kc-cli/src/local_auth/windows.rs b/crates/kc-cli/src/local_auth/windows.rs index 0dc3d73..d58f50c 100644 --- a/crates/kc-cli/src/local_auth/windows.rs +++ b/crates/kc-cli/src/local_auth/windows.rs @@ -16,9 +16,8 @@ pub(super) fn confirm(reason: &str) -> LocalAuthOutcome { fn outcome(result: UserConsentVerificationResult) -> LocalAuthOutcome { match result { UserConsentVerificationResult::Verified => LocalAuthOutcome::Confirmed, - UserConsentVerificationResult::Canceled | UserConsentVerificationResult::RetriesExhausted => { - LocalAuthOutcome::Denied - } + UserConsentVerificationResult::Canceled + | UserConsentVerificationResult::RetriesExhausted => LocalAuthOutcome::Denied, UserConsentVerificationResult::DeviceNotPresent => { LocalAuthOutcome::Unavailable("Windows Hello device not present".into()) } @@ -41,8 +40,14 @@ mod tests { #[test] fn only_verified_confirms() { - assert_eq!(outcome(UserConsentVerificationResult::Verified), LocalAuthOutcome::Confirmed); - for result in [UserConsentVerificationResult::Canceled, UserConsentVerificationResult::RetriesExhausted] { + assert_eq!( + outcome(UserConsentVerificationResult::Verified), + LocalAuthOutcome::Confirmed + ); + for result in [ + UserConsentVerificationResult::Canceled, + UserConsentVerificationResult::RetriesExhausted, + ] { assert_eq!(outcome(result), LocalAuthOutcome::Denied); } for result in [ diff --git a/crates/kc-proto/src/inbox.rs b/crates/kc-proto/src/inbox.rs index 5af01c2..987231f 100644 --- a/crates/kc-proto/src/inbox.rs +++ b/crates/kc-proto/src/inbox.rs @@ -408,7 +408,9 @@ pub enum Body { impl Body { fn validate(&self) -> Result<(), InboxError> { match self { - Self::Items(items) => payload::check_unique_names(items).map_err(InboxError::InvalidItems), + Self::Items(items) => { + payload::check_unique_names(items).map_err(InboxError::InvalidItems) + } Self::Sync(msg) => msg.validate(), } } diff --git a/crates/kc-proto/src/sync.rs b/crates/kc-proto/src/sync.rs index 499b78a..05dd0fd 100644 --- a/crates/kc-proto/src/sync.rs +++ b/crates/kc-proto/src/sync.rs @@ -61,10 +61,7 @@ pub struct ChangeId { #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] pub enum Op { - Put { - kind: ItemKind, - value: SecretBytes, - }, + Put { kind: ItemKind, value: SecretBytes }, Retire, } diff --git a/crates/kc-proto/tests/inbox_v2/mod.rs b/crates/kc-proto/tests/inbox_v2/mod.rs index 18f5945..08c210a 100644 --- a/crates/kc-proto/tests/inbox_v2/mod.rs +++ b/crates/kc-proto/tests/inbox_v2/mod.rs @@ -12,8 +12,12 @@ const ID: MessageId = MessageId([0x44; 16]); struct FixedRng; impl hpke::rand_core::TryRng for FixedRng { type Error = std::convert::Infallible; - fn try_next_u32(&mut self) -> Result { panic!("unexpected RNG call") } - fn try_next_u64(&mut self) -> Result { panic!("unexpected RNG call") } + fn try_next_u32(&mut self) -> Result { + panic!("unexpected RNG call") + } + fn try_next_u64(&mut self) -> Result { + panic!("unexpected RNG call") + } fn try_fill_bytes(&mut self, dst: &mut [u8]) -> Result<(), Self::Error> { assert_eq!(dst.len(), 32); dst.fill(0x33); @@ -23,58 +27,151 @@ impl hpke::rand_core::TryRng for FixedRng { impl hpke::rand_core::TryCryptoRng for FixedRng {} fn keys() -> (DeviceKeyPair, DeviceKeyPair) { - (DeviceKeyPair::from_secret_bytes(&[0x11; 32]).unwrap(), - DeviceKeyPair::from_secret_bytes(&[0x22; 32]).unwrap()) + ( + DeviceKeyPair::from_secret_bytes(&[0x11; 32]).unwrap(), + DeviceKeyPair::from_secret_bytes(&[0x22; 32]).unwrap(), + ) +} +fn name(s: &str) -> ItemName { + ItemName::new(s).unwrap() } -fn name(s: &str) -> ItemName { ItemName::new(s).unwrap() } fn item() -> Item { - Item { name: name("token"), value: SecretBytes::from_slice(b"test-secret"), updated_at: NOW - 10 } + Item { + name: name("token"), + value: SecretBytes::from_slice(b"test-secret"), + updated_at: NOW - 10, + } } fn hello() -> Body { - Body::Sync(SyncMsg::Hello { features: vec!["sync-v1".into()], is_reply: false }) + Body::Sync(SyncMsg::Hello { + features: vec!["sync-v1".into()], + is_reply: false, + }) } fn change() -> Change { Change { - name: name("token"), generation: 300, new_vid: Vid([0x55; 16]), - parents: vec![Vid([0x66; 16])], lineage: vec![Vid([0x66; 16]), Vid([0x77; 16])], - op: Op::Put { kind: ItemKind::Text, value: SecretBytes::from_slice(b"test-secret") }, + name: name("token"), + generation: 300, + new_vid: Vid([0x55; 16]), + parents: vec![Vid([0x66; 16])], + lineage: vec![Vid([0x66; 16]), Vid([0x77; 16])], + op: Op::Put { + kind: ItemKind::Text, + value: SecretBytes::from_slice(b"test-secret"), + }, approval_ref: Some([0x88; 16]), } } fn cases() -> Vec<(&'static str, Body)> { vec![ ("hello", hello()), - ("offer", Body::Sync(SyncMsg::Offer { - name: name("config.env"), vid: Vid([0x55; 16]), lineage: vec![Vid([0x66; 16])], - kind: ItemKind::File, value: SecretBytes::from_slice(b"TEST=1\n"), - })), - ("changes", Body::Sync(SyncMsg::Changes { changes: vec![change(), Change { - name: name("old"), generation: 2, new_vid: Vid([0x99; 16]), parents: vec![], - lineage: vec![], op: Op::Retire, approval_ref: None, - }] })), - ("ack", Body::Sync(SyncMsg::Ack { results: [ - AckResult::Applied, AckResult::Held, AckResult::Conflict, - AckResult::StaleGeneration, AckResult::DeferredCapacity, AckResult::Rejected, - ].into_iter().enumerate().map(|(i, result)| (ChangeId { - name: name("token"), generation: i as u64, new_vid: Vid([i as u8; 16]), - }, result)).collect() })), - ("digest", Body::Sync(SyncMsg::Digest { entries: vec![DigestEntry { - name: name("token"), generation: 300, head: Vid([0x55; 16]), - }] })), + ( + "offer", + Body::Sync(SyncMsg::Offer { + name: name("config.env"), + vid: Vid([0x55; 16]), + lineage: vec![Vid([0x66; 16])], + kind: ItemKind::File, + value: SecretBytes::from_slice(b"TEST=1\n"), + }), + ), + ( + "changes", + Body::Sync(SyncMsg::Changes { + changes: vec![ + change(), + Change { + name: name("old"), + generation: 2, + new_vid: Vid([0x99; 16]), + parents: vec![], + lineage: vec![], + op: Op::Retire, + approval_ref: None, + }, + ], + }), + ), + ( + "ack", + Body::Sync(SyncMsg::Ack { + results: [ + AckResult::Applied, + AckResult::Held, + AckResult::Conflict, + AckResult::StaleGeneration, + AckResult::DeferredCapacity, + AckResult::Rejected, + ] + .into_iter() + .enumerate() + .map(|(i, result)| { + ( + ChangeId { + name: name("token"), + generation: i as u64, + new_vid: Vid([i as u8; 16]), + }, + result, + ) + }) + .collect(), + }), + ), + ( + "digest", + Body::Sync(SyncMsg::Digest { + entries: vec![DigestEntry { + name: name("token"), + generation: 300, + head: Vid([0x55; 16]), + }], + }), + ), ("items", Body::Items(vec![item()])), - ("accept", Body::Sync(SyncMsg::Accept { name: name("token"), generation: 300 })), - ("leave", Body::Sync(SyncMsg::Leave { name: name("token"), generation: 300 })), - ("approvals", Body::Sync(SyncMsg::Approvals { docs: vec![vec![1, 2, 3], vec![]] })), + ( + "accept", + Body::Sync(SyncMsg::Accept { + name: name("token"), + generation: 300, + }), + ), + ( + "leave", + Body::Sync(SyncMsg::Leave { + name: name("token"), + generation: 300, + }), + ), + ( + "approvals", + Body::Sync(SyncMsg::Approvals { + docs: vec![vec![1, 2, 3], vec![]], + }), + ), ] } fn bob_opens(bytes: &[u8], now: i64) -> Result { let (alice, bob) = keys(); - open_any(bytes, &[&bob], |fp| (*fp == alice.fingerprint()).then_some(*alice.public()), |_| false, now) + open_any( + bytes, + &[&bob], + |fp| (*fp == alice.fingerprint()).then_some(*alice.public()), + |_| false, + now, + ) } fn plain(body: Body) -> InboxPlain2 { let (alice, bob) = keys(); - InboxPlain2 { v: VERSION_V2, msg_id: ID, sender_fp: alice.fingerprint(), - recipient_fp: bob.fingerprint(), created_at: NOW, expires_at: NOW + 3600, body } + InboxPlain2 { + v: VERSION_V2, + msg_id: ID, + sender_fp: alice.fingerprint(), + recipient_fp: bob.fingerprint(), + created_at: NOW, + expires_at: NOW + 3600, + body, + } } // Intentionally bypass sender validation for adversarial authenticated messages. fn seal_plain(p: &InboxPlain2, prefix: &[u8]) -> Vec { @@ -83,36 +180,73 @@ fn seal_plain(p: &InboxPlain2, prefix: &[u8]) -> Vec { let mut buf = pad::encode(p, &[], TAG_LEN).unwrap(); let (enc, tag) = hpke::single_shot_seal_inout_detached_with_rng::( &OpModeS::Auth((alice.kem_private().clone(), alice.public().kem_public())), - &bob.public().kem_public(), &info_with_prefix(prefix, &sender_fp, &recipient_fp), - (&mut buf[..]).into(), &header_aad(VERSION_V2, SUITE, &sender_fp, &recipient_fp), &mut FixedRng, - ).unwrap(); + &bob.public().kem_public(), + &info_with_prefix(prefix, &sender_fp, &recipient_fp), + (&mut buf[..]).into(), + &header_aad(VERSION_V2, SUITE, &sender_fp, &recipient_fp), + &mut FixedRng, + ) + .unwrap(); buf.extend_from_slice(&tag.to_bytes()); - InboxEnvelope { v: VERSION_V2, suite: SUITE, sender_fp, recipient_fp, - enc: enc.to_bytes().into(), ct: std::mem::take(&mut *buf) }.encode() + InboxEnvelope { + v: VERSION_V2, + suite: SUITE, + sender_fp, + recipient_fp, + enc: enc.to_bytes().into(), + ct: std::mem::take(&mut *buf), + } + .encode() +} +fn hex(bytes: &[u8]) -> String { + bytes.iter().map(|b| format!("{b:02x}")).collect() } -fn hex(bytes: &[u8]) -> String { bytes.iter().map(|b| format!("{b:02x}")).collect() } fn unhex(s: &str) -> Vec { let s: String = s.split_whitespace().collect(); assert_eq!(s.len() % 2, 0); - s.as_bytes().chunks(2).map(|p| u8::from_str_radix(std::str::from_utf8(p).unwrap(), 16).unwrap()).collect() + s.as_bytes() + .chunks(2) + .map(|p| u8::from_str_radix(std::str::from_utf8(p).unwrap(), 16).unwrap()) + .collect() } fn fixture(label: &str, suffix: &str) -> String { - std::fs::read_to_string(format!("{}/tests/inbox_v2/fixtures/{label}.{suffix}.hex", env!("CARGO_MANIFEST_DIR"))).unwrap() + std::fs::read_to_string(format!( + "{}/tests/inbox_v2/fixtures/{label}.{suffix}.hex", + env!("CARGO_MANIFEST_DIR") + )) + .unwrap() } #[test] fn golden_vectors_encode_and_open() { let (alice, bob) = keys(); for (label, body) in cases() { - let sealed = seal_v2_with_rng(&alice, bob.public(), &body, TTL, NOW, ID, &mut FixedRng).unwrap(); + let sealed = + seal_v2_with_rng(&alice, bob.public(), &body, TTL, NOW, ID, &mut FixedRng).unwrap(); let encoded_body = postcard::to_allocvec(&body).unwrap(); - assert_eq!(hex(&encoded_body), fixture(label, "body").trim(), "{label} body"); + assert_eq!( + hex(&encoded_body), + fixture(label, "body").trim(), + "{label} body" + ); let expected = unhex(&fixture(label, "envelope")); assert_eq!(sealed.body, expected, "{label} envelope"); - assert_eq!(sealed.body, seal_plain(&plain(body.clone()), INFO_PREFIX_V2), "borrowed encoding"); + assert_eq!( + sealed.body, + seal_plain(&plain(body.clone()), INFO_PREFIX_V2), + "borrowed encoding" + ); let opened = bob_opens(&expected, NOW).unwrap(); - assert_eq!(opened, OpenedAny { msg_id: ID, sender_fp: alice.fingerprint(), - created_at: NOW, expires_at: NOW + 3600, body }); + assert_eq!( + opened, + OpenedAny { + msg_id: ID, + sender_fp: alice.fingerprint(), + created_at: NOW, + expires_at: NOW + 3600, + body + } + ); assert_eq!(opened.keep_seen_until(), NOW + 3600 + CLOCK_SKEW_SECS); } } @@ -136,9 +270,21 @@ fn v1_open_rejects_v2_before_decryption() { let sealed = seal_v2(&alice, bob.public(), &hello(), TTL, NOW).unwrap(); let mut envelope = InboxEnvelope::decode(&sealed.body).unwrap(); assert_eq!(envelope.v, 2); - for body in [sealed.body, { envelope.ct.clear(); envelope.encode() }] { - assert_eq!(open(&body, &[], |_| panic!("peer lookup before version check"), - |_| panic!("seen lookup before version check"), NOW).unwrap_err(), InboxError::UnsupportedVersion(2)); + for body in [sealed.body, { + envelope.ct.clear(); + envelope.encode() + }] { + assert_eq!( + open( + &body, + &[], + |_| panic!("peer lookup before version check"), + |_| panic!("seen lookup before version check"), + NOW + ) + .unwrap_err(), + InboxError::UnsupportedVersion(2) + ); } } @@ -157,12 +303,18 @@ fn open_any_maps_v1_to_items() { fn v2_rejects_inner_v1() { let mut p = plain(hello()); p.v = 1; - assert_eq!(bob_opens(&seal_plain(&p, INFO_PREFIX_V2), NOW).unwrap_err(), InboxError::UnsupportedVersion(1)); + assert_eq!( + bob_opens(&seal_plain(&p, INFO_PREFIX_V2), NOW).unwrap_err(), + InboxError::UnsupportedVersion(1) + ); } #[test] fn v2_rejects_v1_info() { - assert_eq!(bob_opens(&seal_plain(&plain(hello()), INFO_PREFIX), NOW).unwrap_err(), InboxError::DecryptFailed); + assert_eq!( + bob_opens(&seal_plain(&plain(hello()), INFO_PREFIX), NOW).unwrap_err(), + InboxError::DecryptFailed + ); } #[test] @@ -179,8 +331,13 @@ fn lineage_limit_on_decode_validate_and_open() { let result = bob_opens(&seal_plain(&plain(body.clone()), INFO_PREFIX_V2), NOW); let (alice, bob) = keys(); let sealed = seal_v2(&alice, bob.public(), &body, TTL, NOW); - if n <= 64 { assert!(result.is_ok()); assert!(sealed.is_ok()); } - else { assert_eq!(result.unwrap_err(), InboxError::Malformed); assert_eq!(sealed.unwrap_err(), InboxError::Malformed); } + if n <= 64 { + assert!(result.is_ok()); + assert!(sealed.is_ok()); + } else { + assert_eq!(result.unwrap_err(), InboxError::Malformed); + assert_eq!(sealed.unwrap_err(), InboxError::Malformed); + } } } @@ -189,9 +346,16 @@ fn duplicate_change_and_item_names_are_malformed() { let mut other = change(); other.generation += 1; other.new_vid = Vid([0xaa; 16]); - for body in [Body::Sync(SyncMsg::Changes { changes: vec![change(), other] }), - Body::Items(vec![item(), item()])] { - assert_eq!(bob_opens(&seal_plain(&plain(body.clone()), INFO_PREFIX_V2), NOW).unwrap_err(), InboxError::Malformed); + for body in [ + Body::Sync(SyncMsg::Changes { + changes: vec![change(), other], + }), + Body::Items(vec![item(), item()]), + ] { + assert_eq!( + bob_opens(&seal_plain(&plain(body.clone()), INFO_PREFIX_V2), NOW).unwrap_err(), + InboxError::Malformed + ); let (alice, bob) = keys(); assert!(seal_v2(&alice, bob.public(), &body, TTL, NOW).is_err()); } @@ -202,18 +366,55 @@ fn v2_lifetime_skew_and_replay_checks() { let bytes = seal_plain(&plain(hello()), INFO_PREFIX_V2); assert!(bob_opens(&bytes, NOW - CLOCK_SKEW_SECS).is_ok()); assert!(bob_opens(&bytes, NOW + 3600 + CLOCK_SKEW_SECS).is_ok()); - assert_eq!(bob_opens(&bytes, NOW - CLOCK_SKEW_SECS - 1).unwrap_err(), InboxError::NotYetValid); - assert_eq!(bob_opens(&bytes, NOW + 3601 + CLOCK_SKEW_SECS).unwrap_err(), InboxError::Expired); - for (created, expires, ok) in [(NOW, NOW, true), (NOW, NOW + MAX_LIFETIME_SECS, true), - (NOW, NOW - 1, false), (NOW, NOW + MAX_LIFETIME_SECS + 1, false), (i64::MIN, i64::MAX, false)] { - let mut p = plain(hello()); p.created_at = created; p.expires_at = expires; + assert_eq!( + bob_opens(&bytes, NOW - CLOCK_SKEW_SECS - 1).unwrap_err(), + InboxError::NotYetValid + ); + assert_eq!( + bob_opens(&bytes, NOW + 3601 + CLOCK_SKEW_SECS).unwrap_err(), + InboxError::Expired + ); + for (created, expires, ok) in [ + (NOW, NOW, true), + (NOW, NOW + MAX_LIFETIME_SECS, true), + (NOW, NOW - 1, false), + (NOW, NOW + MAX_LIFETIME_SECS + 1, false), + (i64::MIN, i64::MAX, false), + ] { + let mut p = plain(hello()); + p.created_at = created; + p.expires_at = expires; let result = bob_opens(&seal_plain(&p, INFO_PREFIX_V2), NOW); - if ok { assert!(result.is_ok()); } else { assert_eq!(result.unwrap_err(), InboxError::BadLifetime); } + if ok { + assert!(result.is_ok()); + } else { + assert_eq!(result.unwrap_err(), InboxError::BadLifetime); + } } let (alice, bob) = keys(); - assert_eq!(open_any(&bytes, &[&bob], |_| Some(*alice.public()), |id| { assert_eq!(*id, ID); true }, NOW).unwrap_err(), InboxError::Replay); - for (ttl, now) in [(Duration::ZERO, NOW), (Duration::from_secs(MAX_LIFETIME_SECS as u64 + 1), NOW), (TTL, i64::MAX)] { - assert_eq!(seal_v2(&alice, bob.public(), &hello(), ttl, now).unwrap_err(), InboxError::InvalidTtl); + assert_eq!( + open_any( + &bytes, + &[&bob], + |_| Some(*alice.public()), + |id| { + assert_eq!(*id, ID); + true + }, + NOW + ) + .unwrap_err(), + InboxError::Replay + ); + for (ttl, now) in [ + (Duration::ZERO, NOW), + (Duration::from_secs(MAX_LIFETIME_SECS as u64 + 1), NOW), + (TTL, i64::MAX), + ] { + assert_eq!( + seal_v2(&alice, bob.public(), &hello(), ttl, now).unwrap_err(), + InboxError::InvalidTtl + ); } } @@ -222,38 +423,91 @@ fn v2_fingerprint_and_authentication_checks() { let (alice, bob) = keys(); for sender in [true, false] { let mut p = plain(hello()); - if sender { p.sender_fp = bob.fingerprint(); } else { p.recipient_fp = alice.fingerprint(); } - assert_eq!(bob_opens(&seal_plain(&p, INFO_PREFIX_V2), NOW).unwrap_err(), InboxError::FingerprintMismatch); + if sender { + p.sender_fp = bob.fingerprint(); + } else { + p.recipient_fp = alice.fingerprint(); + } + assert_eq!( + bob_opens(&seal_plain(&p, INFO_PREFIX_V2), NOW).unwrap_err(), + InboxError::FingerprintMismatch + ); } let bytes = seal_plain(&plain(hello()), INFO_PREFIX_V2); - assert_eq!(open_any(&bytes, &[&alice], |_| Some(*alice.public()), |_| false, NOW).unwrap_err(), InboxError::WrongRecipient); + assert_eq!( + open_any(&bytes, &[&alice], |_| Some(*alice.public()), |_| false, NOW).unwrap_err(), + InboxError::WrongRecipient + ); for pk in [None, Some(*bob.public())] { - assert_eq!(open_any(&bytes, &[&bob], |_| pk, |_| false, NOW).unwrap_err(), InboxError::UnknownSender); + assert_eq!( + open_any(&bytes, &[&bob], |_| pk, |_| false, NOW).unwrap_err(), + InboxError::UnknownSender + ); } - assert!(open_any(&bytes, &[&alice, &bob], |_| Some(*alice.public()), |_| false, NOW).is_ok()); + assert!( + open_any( + &bytes, + &[&alice, &bob], + |_| Some(*alice.public()), + |_| false, + NOW + ) + .is_ok() + ); for field in 0..3 { let mut env = InboxEnvelope::decode(&bytes).unwrap(); - match field { 0 => env.enc[0] ^= 1, 1 => env.ct[0] ^= 1, _ => *env.ct.last_mut().unwrap() ^= 1 } - assert_eq!(bob_opens(&env.encode(), NOW).unwrap_err(), InboxError::DecryptFailed); + match field { + 0 => env.enc[0] ^= 1, + 1 => env.ct[0] ^= 1, + _ => *env.ct.last_mut().unwrap() ^= 1, + } + assert_eq!( + bob_opens(&env.encode(), NOW).unwrap_err(), + InboxError::DecryptFailed + ); } } #[test] fn v2_size_and_envelope_checks() { let (alice, bob) = keys(); - let body = Body::Sync(SyncMsg::Offer { name: name("large"), vid: Vid([1; 16]), lineage: vec![], - kind: ItemKind::File, value: SecretBytes::from_slice(&vec![0; MAX_MESSAGE_BYTES]) }); - assert_eq!(seal_v2(&alice, bob.public(), &body, TTL, NOW).unwrap_err(), InboxError::TooLarge); - assert_eq!(bob_opens(&vec![0; MAX_MESSAGE_BYTES + 1], NOW).unwrap_err(), InboxError::TooLarge); + let body = Body::Sync(SyncMsg::Offer { + name: name("large"), + vid: Vid([1; 16]), + lineage: vec![], + kind: ItemKind::File, + value: SecretBytes::from_slice(&vec![0; MAX_MESSAGE_BYTES]), + }); + assert_eq!( + seal_v2(&alice, bob.public(), &body, TTL, NOW).unwrap_err(), + InboxError::TooLarge + ); + assert_eq!( + bob_opens(&vec![0; MAX_MESSAGE_BYTES + 1], NOW).unwrap_err(), + InboxError::TooLarge + ); let bytes = seal_plain(&plain(hello()), INFO_PREFIX_V2); - let mut env = InboxEnvelope::decode(&bytes).unwrap(); env.v = 3; - assert_eq!(bob_opens(&env.encode(), NOW).unwrap_err(), InboxError::UnsupportedVersion(3)); - env.v = 2; env.suite = 2; - assert_eq!(bob_opens(&env.encode(), NOW).unwrap_err(), InboxError::UnsupportedSuite(2)); - env.suite = 1; env.ct.truncate(15); - assert_eq!(bob_opens(&env.encode(), NOW).unwrap_err(), InboxError::Malformed); - let mut trailing = bytes.clone(); trailing.push(0); - for bad in [vec![], bytes[..bytes.len()-1].to_vec(), trailing] { + let mut env = InboxEnvelope::decode(&bytes).unwrap(); + env.v = 3; + assert_eq!( + bob_opens(&env.encode(), NOW).unwrap_err(), + InboxError::UnsupportedVersion(3) + ); + env.v = 2; + env.suite = 2; + assert_eq!( + bob_opens(&env.encode(), NOW).unwrap_err(), + InboxError::UnsupportedSuite(2) + ); + env.suite = 1; + env.ct.truncate(15); + assert_eq!( + bob_opens(&env.encode(), NOW).unwrap_err(), + InboxError::Malformed + ); + let mut trailing = bytes.clone(); + trailing.push(0); + for bad in [vec![], bytes[..bytes.len() - 1].to_vec(), trailing] { assert_eq!(bob_opens(&bad, NOW).unwrap_err(), InboxError::Malformed); } } @@ -265,14 +519,21 @@ fn vid_serde_and_secret_debug() { let json = format!("\"{}\"", "ab".repeat(16)); assert_eq!(serde_json::to_string(&vid).unwrap(), json); assert_eq!(serde_json::from_str::(&json).unwrap(), vid); - assert_eq!(serde_json::from_str::(&json.to_uppercase()).unwrap(), vid); + assert_eq!( + serde_json::from_str::(&json.to_uppercase()).unwrap(), + vid + ); for bad in ["\"00\"", "\"zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz\"", "[]"] { assert!(serde_json::from_str::(bad).is_err()); } let random = Vid::random(); - assert_eq!(postcard::from_bytes::(&postcard::to_allocvec(&random).unwrap()).unwrap(), random); + assert_eq!( + postcard::from_bytes::(&postcard::to_allocvec(&random).unwrap()).unwrap(), + random + ); for (_, body) in cases() { let debug = format!("{body:?}"); - assert!(!debug.contains("test-secret")); assert!(!debug.contains("TEST=1")); + assert!(!debug.contains("test-secret")); + assert!(!debug.contains("TEST=1")); } } diff --git a/crates/kc-sync/src/decision.rs b/crates/kc-sync/src/decision.rs index 07bfd57..454e520 100644 --- a/crates/kc-sync/src/decision.rs +++ b/crates/kc-sync/src/decision.rs @@ -1,5 +1,5 @@ -use serde::{Deserialize, Serialize}; use crate::{ConflictSet, Fp, Incoming, ItemState, Lineage, Vid, VidRecord}; +use serde::{Deserialize, Serialize}; /// ACK discriminant order is the frozen sync contract (§12.3). #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] @@ -21,17 +21,23 @@ pub enum AckResult { impl AckResult { /// Only capacity deferral is non-final (§12.3). - pub fn is_final(self) -> bool { self != Self::DeferredCapacity } + pub fn is_final(self) -> bool { + self != Self::DeferredCapacity + } } /// Evidence supplied only by an external approval verifier; Phase 1 always uses `None` (§12.5). #[derive(Debug)] -pub struct VerifiedApproval { _private: () } +pub struct VerifiedApproval { + _private: (), +} impl VerifiedApproval { /// Test-only escape hatch; never call in production Phase 1 code (§12.5). #[doc(hidden)] - pub fn for_tests() -> Self { Self { _private: () } } + pub fn for_tests() -> Self { + Self { _private: () } + } } /// Human-review reason in decision precedence order (§12.5). @@ -90,77 +96,157 @@ pub struct Decision { impl Decision { pub(crate) fn held(reason: HoldReason) -> Self { - Self { ack: AckResult::Held, transition: Transition::Hold { reason }, quarantine: false } + Self { + ack: AckResult::Held, + transition: Transition::Hold { reason }, + quarantine: false, + } } pub(crate) fn unchanged(ack: AckResult) -> Self { - Self { ack, transition: Transition::Unchanged, quarantine: false } + Self { + ack, + transition: Transition::Unchanged, + quarantine: false, + } } } fn conflict(state: &ItemState, current_fp: Fp, incoming: &Incoming) -> Decision { let mut candidates = state.conflict.clone().unwrap_or_default(); - candidates.candidates.entry(state.head).or_insert_with(|| VidRecord { - fp: current_fp, - parents: state.record(&state.head).map(|r| r.parents.clone()).unwrap_or_default(), - }); + candidates + .candidates + .entry(state.head) + .or_insert_with(|| VidRecord { + fp: current_fp, + parents: state + .record(&state.head) + .map(|r| r.parents.clone()) + .unwrap_or_default(), + }); if let Some(fp) = incoming.value_fp { - candidates.candidates.insert(incoming.new_vid, VidRecord { fp, parents: incoming.parents.clone() }); + candidates.candidates.insert( + incoming.new_vid, + VidRecord { + fp, + parents: incoming.parents.clone(), + }, + ); + } + Decision { + ack: AckResult::Conflict, + transition: Transition::Conflict { candidates }, + quarantine: false, } - Decision { ack: AckResult::Conflict, transition: Transition::Conflict { candidates }, quarantine: false } } fn advance(state: &ItemState, incoming: &Incoming, convergence: bool, resolve: bool) -> Decision { if incoming.retire { - return Decision { ack: AckResult::Applied, transition: Transition::Retire, quarantine: false }; + return Decision { + ack: AckResult::Applied, + transition: Transition::Retire, + quarantine: false, + }; } - let head = if convergence { state.head.max(incoming.new_vid) } else { incoming.new_vid }; + let head = if convergence { + state.head.max(incoming.new_vid) + } else { + incoming.new_vid + }; let lineage = Lineage::merge(&state.lineage, &incoming.lineage); - let lineage = Lineage::new(lineage.iter().copied().chain([state.head, incoming.new_vid])).with_head(head); - Decision { ack: AckResult::Applied, quarantine: false, transition: Transition::Advance { - head, lineage, write_value: !convergence, clear_conflict: resolve, - } } + let lineage = Lineage::new( + lineage + .iter() + .copied() + .chain([state.head, incoming.new_vid]), + ) + .with_head(head); + Decision { + ack: AckResult::Applied, + quarantine: false, + transition: Transition::Advance { + head, + lineage, + write_value: !convergence, + clear_conflict: resolve, + }, + } } /// Implements the first-match table, rows 1–9, including resolve and non-deleting Retire (§12.5). -pub fn decide(state: &ItemState, current_fp: Fp, incoming: &Incoming, frozen: bool, - approval: Option<&VerifiedApproval>, within_limits: bool) -> Decision -{ +pub fn decide( + state: &ItemState, + current_fp: Fp, + incoming: &Incoming, + frozen: bool, + approval: Option<&VerifiedApproval>, + within_limits: bool, +) -> Decision { // Rows 1 and 2 deliberately outrank all other conditions. - if incoming.generation != state.generation { return Decision::unchanged(AckResult::StaleGeneration); } - if frozen { return Decision::held(HoldReason::Frozen); } + if incoming.generation != state.generation { + return Decision::unchanged(AckResult::StaleGeneration); + } + if frozen { + return Decision::held(HoldReason::Frozen); + } // Row 3: consult all retained immutable bindings, not just the head. - let violation = state.record(&incoming.new_vid).is_some_and(|r| - incoming.value_fp != Some(r.fp) || incoming.parents != r.parents) + let violation = state + .record(&incoming.new_vid) + .is_some_and(|r| incoming.value_fp != Some(r.fp) || incoming.parents != r.parents) || (incoming.new_vid == state.head && incoming.value_fp != Some(current_fp)); if violation { - return Decision { ack: AckResult::Rejected, transition: Transition::Unchanged, quarantine: true }; + return Decision { + ack: AckResult::Rejected, + transition: Transition::Unchanged, + quarantine: true, + }; } // Row 4: an already-known ancestor is acknowledged without another write. if incoming.new_vid == state.head || state.lineage.contains(&incoming.new_vid) { return Decision::unchanged(AckResult::Applied); } // Malformed operations cannot reach any value-writing transition. - if incoming.retire == incoming.value_fp.is_some() { return Decision::unchanged(AckResult::Rejected); } + if incoming.retire == incoming.value_fp.is_some() { + return Decision::unchanged(AckResult::Rejected); + } // Retire has no candidate value; without approval it can only request review (§2.5). - if incoming.retire && approval.is_none() { return Decision::held(HoldReason::NoApproval); } + if incoming.retire && approval.is_none() { + return Decision::held(HoldReason::NoApproval); + } // Row 5: complete parent coverage is necessary even with a verified approval. if let Some(candidates) = &state.conflict { let complete = incoming.parents.contains(&state.head) - && candidates.candidates.keys().all(|vid| incoming.parents.contains(vid)); - if !complete { return conflict(state, current_fp, incoming); } - if approval.is_none() { return Decision::held(HoldReason::Resolve); } - if !within_limits { return Decision::held(HoldReason::OverLimit); } + && candidates + .candidates + .keys() + .all(|vid| incoming.parents.contains(vid)); + if !complete { + return conflict(state, current_fp, incoming); + } + if approval.is_none() { + return Decision::held(HoldReason::Resolve); + } + if !within_limits { + return Decision::held(HoldReason::OverLimit); + } return advance(state, incoming, false, true); } // Row 6 is metadata-only convergence; Retire has no value to converge. - if incoming.value_fp == Some(current_fp) { return advance(state, incoming, true, false); } + if incoming.value_fp == Some(current_fp) { + return advance(state, incoming, true, false); + } let direct = incoming.parents.as_slice() == [state.head]; // Row 7: callers cannot substitute claimed lineage for signed direct parents. - if direct && approval.is_some() && within_limits { return advance(state, incoming, false, false); } + if direct && approval.is_some() && within_limits { + return advance(state, incoming, false, false); + } // Row 8; an unapproved Retire is always review-only (§2.5). if direct || (incoming.retire && approval.is_none()) { - return Decision::held(if approval.is_none() { HoldReason::NoApproval } else { HoldReason::OverLimit }); + return Decision::held(if approval.is_none() { + HoldReason::NoApproval + } else { + HoldReason::OverLimit + }); } // Row 9. conflict(state, current_fp, incoming) diff --git a/crates/kc-sync/src/generation.rs b/crates/kc-sync/src/generation.rs index f140238..8d35162 100644 --- a/crates/kc-sync/src/generation.rs +++ b/crates/kc-sync/src/generation.rs @@ -1,6 +1,6 @@ -use std::collections::{BTreeMap, BTreeSet}; -use serde::{Deserialize, Serialize}; use crate::PeerId; +use serde::{Deserialize, Serialize}; +use std::collections::{BTreeMap, BTreeSet}; /// Receiver-issued registration message, with explicit peer scoping (§12.2). #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] @@ -17,10 +17,16 @@ pub struct Registration { pub struct GenerationExhausted; #[derive(Debug, Clone, Default, Serialize, Deserialize)] -struct Owned { generation: u64, peers: BTreeSet } +struct Owned { + generation: u64, + peers: BTreeSet, +} #[derive(Debug, Clone, Serialize, Deserialize)] -struct Remote { generation: u64, accepted: bool } +struct Remote { + generation: u64, + accepted: bool, +} /// Receiver generations and sender-side Accept/Leave bookkeeping, never automatic enrollment (§12.2). #[derive(Debug, Clone, Default, Serialize, Deserialize)] @@ -31,13 +37,18 @@ pub struct Generations { impl Generations { /// Returns the generation owned by this receiver, initially zero (§12.2). - pub fn generation(&self, name: &str) -> u64 { self.owned.get(name).map_or(0, |o| o.generation) } + pub fn generation(&self, name: &str) -> u64 { + self.owned.get(name).map_or(0, |o| o.generation) + } /// Human review accepts an offer for exactly the specified peer (§2.1, §12.2). pub fn accept(&mut self, name: &str, peer: PeerId) -> Registration { let owned = self.owned.entry(name.into()).or_default(); owned.peers.insert(peer); - Registration { name: name.into(), generation: owned.generation } + Registration { + name: name.into(), + generation: owned.generation, + } } /// Checks local registration membership for a peer/name (§2.1, §12.2). @@ -46,27 +57,58 @@ impl Generations { } /// Removes local membership and bumps its generation; send Leave to returned peers (§12.2). - pub fn rm(&mut self, name: &str) -> Result<(Registration, BTreeSet), GenerationExhausted> { + pub fn rm( + &mut self, + name: &str, + ) -> Result<(Registration, BTreeSet), GenerationExhausted> { let owned = self.owned.entry(name.into()).or_default(); let next = owned.generation.checked_add(1).ok_or(GenerationExhausted)?; owned.generation = next; let peers = std::mem::take(&mut owned.peers); - Ok((Registration { name: name.into(), generation: next }, peers)) + Ok(( + Registration { + name: name.into(), + generation: next, + }, + peers, + )) } /// Records a peer's Accept, ignoring generations older than a previously observed Leave (§12.2). pub fn received_accept(&mut self, peer: PeerId, accept: Registration) -> bool { let names = self.remote.entry(peer).or_default(); - if names.get(&accept.name).is_some_and(|r| r.generation > accept.generation) { return false; } - names.insert(accept.name, Remote { generation: accept.generation, accepted: true }); + if names + .get(&accept.name) + .is_some_and(|r| r.generation > accept.generation) + { + return false; + } + names.insert( + accept.name, + Remote { + generation: accept.generation, + accepted: true, + }, + ); true } /// Records a peer's Leave without permitting reordered older messages to roll it back (§12.2). pub fn received_leave(&mut self, peer: PeerId, leave: Registration) -> bool { let names = self.remote.entry(peer).or_default(); - if names.get(&leave.name).is_some_and(|r| r.generation > leave.generation) { return false; } - names.insert(leave.name, Remote { generation: leave.generation, accepted: false }); + if names + .get(&leave.name) + .is_some_and(|r| r.generation > leave.generation) + { + return false; + } + names.insert( + leave.name, + Remote { + generation: leave.generation, + accepted: false, + }, + ); true } diff --git a/crates/kc-sync/src/limiter.rs b/crates/kc-sync/src/limiter.rs index 0e0d0b4..0a8789f 100644 --- a/crates/kc-sync/src/limiter.rs +++ b/crates/kc-sync/src/limiter.rs @@ -1,6 +1,6 @@ -use std::collections::{BTreeMap, BTreeSet}; -use serde::{Deserialize, Serialize}; use crate::PeerId; +use serde::{Deserialize, Serialize}; +use std::collections::{BTreeMap, BTreeSet}; /// Rolling non-interactive overwrite and peer breaker window in seconds (§4). pub const WINDOW_SECS: i64 = 24 * 60 * 60; @@ -26,7 +26,11 @@ pub enum LimitResult { } #[derive(Debug, Clone, Serialize, Deserialize)] -struct Event { at: i64, name: String, op: RemoteOperation } +struct Event { + at: i64, + name: String, + op: RemoteOperation, +} /// Serializable deterministic limiter; caller supplies time and records only committed operations (§4). #[derive(Debug, Clone, Default, Serialize, Deserialize)] @@ -43,38 +47,75 @@ fn recent(at: i64, now: i64) -> bool { impl Limiter { /// Checks the proposed operation and latches a breaker before crossing a threshold (§4). - pub fn check(&mut self, peer: &PeerId, name: &str, op: RemoteOperation, - now: i64, sync_set_size: usize, interactive: bool) -> LimitResult - { - if self.tripped.contains(peer) { return LimitResult::PeerTripped; } + pub fn check( + &mut self, + peer: &PeerId, + name: &str, + op: RemoteOperation, + now: i64, + sync_set_size: usize, + interactive: bool, + ) -> LimitResult { + if self.tripped.contains(peer) { + return LimitResult::PeerTripped; + } self.prune(now); let events = self.events.get(peer).map(Vec::as_slice).unwrap_or_default(); - let overwrites = events.iter().filter(|e| e.op == RemoteOperation::Overwrite).count() + let overwrites = events + .iter() + .filter(|e| e.op == RemoteOperation::Overwrite) + .count() + usize::from(op == RemoteOperation::Overwrite); - let retires = events.iter().filter(|e| e.op == RemoteOperation::Retire).count() + let retires = events + .iter() + .filter(|e| e.op == RemoteOperation::Retire) + .count() + usize::from(op == RemoteOperation::Retire); - let affected: BTreeSet<&str> = events.iter().map(|e| e.name.as_str()).chain([name]).collect(); - if overwrites > 5 || retires > 3 + let affected: BTreeSet<&str> = events + .iter() + .map(|e| e.name.as_str()) + .chain([name]) + .collect(); + if overwrites > 5 + || retires > 3 || (sync_set_size >= 8 && affected.len() > sync_set_size / 4) { self.tripped.insert(peer.clone()); return LimitResult::PeerTripped; } - if op == RemoteOperation::Overwrite && !interactive + if op == RemoteOperation::Overwrite + && !interactive && self.items.get(name).is_some_and(|at| recent(*at, now)) - { return LimitResult::ItemLimited; } + { + return LimitResult::ItemLimited; + } LimitResult::Allowed } /// Records an actually committed operation; interactive writes bypass only the item cap (§4). - pub fn record(&mut self, peer: &PeerId, name: &str, op: RemoteOperation, now: i64, interactive: bool) { + pub fn record( + &mut self, + peer: &PeerId, + name: &str, + op: RemoteOperation, + now: i64, + interactive: bool, + ) { self.prune(now); - if op == RemoteOperation::Overwrite && !interactive { self.items.insert(name.into(), now); } - self.events.entry(peer.clone()).or_default().push(Event { at: now, name: name.into(), op }); + if op == RemoteOperation::Overwrite && !interactive { + self.items.insert(name.into(), now); + } + self.events.entry(peer.clone()).or_default().push(Event { + at: now, + name: name.into(), + op, + }); } /// Tests the sticky peer breaker for any incoming message, including offers (§4). - pub fn is_tripped(&self, peer: &PeerId) -> bool { self.tripped.contains(peer) } + pub fn is_tripped(&self, peer: &PeerId) -> bool { + self.tripped.contains(peer) + } /// Human reset clears this peer's breaker history but preserves per-item overwrite limits (§4). pub fn human_reset(&mut self, peer: &PeerId) { @@ -85,6 +126,9 @@ impl Limiter { /// Drops expired counters without clearing sticky breakers (§4). pub fn prune(&mut self, now: i64) { self.items.retain(|_, at| recent(*at, now)); - self.events.retain(|_, events| { events.retain(|e| recent(e.at, now)); !events.is_empty() }); + self.events.retain(|_, events| { + events.retain(|e| recent(e.at, now)); + !events.is_empty() + }); } } diff --git a/crates/kc-sync/src/outbox.rs b/crates/kc-sync/src/outbox.rs index ca706bf..f935b8e 100644 --- a/crates/kc-sync/src/outbox.rs +++ b/crates/kc-sync/src/outbox.rs @@ -1,6 +1,6 @@ -use std::collections::{BTreeMap, BTreeSet}; -use serde::{Deserialize, Deserializer, Serialize, Serializer}; use crate::{AckResult, PeerId, Vid}; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; +use std::collections::{BTreeMap, BTreeSet}; /// Exact receiver-specific change identity; vids are random, not chronological (§12.3). #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)] @@ -14,22 +14,37 @@ pub struct ChangeId { } #[derive(Debug, Clone, Serialize, Deserialize)] -struct Delivery { order: u64, final_ack: Option } +struct Delivery { + order: u64, + final_ack: Option, +} /// Per-peer queues and all-target snapshot retention; contains no values (§2.8, §12.3). #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct Outbox { - #[serde(serialize_with = "serialize_deliveries", deserialize_with = "deserialize_deliveries")] + #[serde( + serialize_with = "serialize_deliveries", + deserialize_with = "deserialize_deliveries" + )] deliveries: BTreeMap>, reoffer: BTreeMap>, next_order: u64, } -fn serialize_deliveries(deliveries: &BTreeMap>, s: S) -> Result { - deliveries.iter().map(|(peer, queue)| (peer, queue.iter().collect::>())).collect::>().serialize(s) +fn serialize_deliveries( + deliveries: &BTreeMap>, + s: S, +) -> Result { + deliveries + .iter() + .map(|(peer, queue)| (peer, queue.iter().collect::>())) + .collect::>() + .serialize(s) } -fn deserialize_deliveries<'de, D: Deserializer<'de>>(d: D) -> Result>, D::Error> { +fn deserialize_deliveries<'de, D: Deserializer<'de>>( + d: D, +) -> Result>, D::Error> { let peers = Vec::<(PeerId, Vec<(ChangeId, Delivery)>)>::deserialize(d)?; let mut result = BTreeMap::new(); for (peer, entries) in peers { @@ -45,27 +60,53 @@ fn deserialize_deliveries<'de, D: Deserializer<'de>>(d: D) -> Result = self.deliveries.values().flat_map(|q| q.values().map(|d| d.order)).collect(); + let mut orders: Vec<_> = self + .deliveries + .values() + .flat_map(|q| q.values().map(|d| d.order)) + .collect(); orders.sort_unstable(); orders.dedup(); for queue in self.deliveries.values_mut() { - for entry in queue.values_mut() { entry.order = orders.binary_search(&entry.order).unwrap() as u64; } + for entry in queue.values_mut() { + entry.order = orders.binary_search(&entry.order).unwrap() as u64; + } } self.next_order = orders.len() as u64; } - self.deliveries.entry(peer).or_default().insert(change, Delivery { order: self.next_order, final_ack: None }); + self.deliveries.entry(peer).or_default().insert( + change, + Delivery { + order: self.next_order, + final_ack: None, + }, + ); self.next_order += 1; } /// Applies a final exact ACK and supersedes only earlier entries for this peer/name (§12.3). pub fn ack(&mut self, peer: &PeerId, change: &ChangeId, result: AckResult) -> bool { - if !result.is_final() { return false; } - let Some(queue) = self.deliveries.get_mut(peer) else { return false; }; - let Some(delivery) = queue.get(change) else { return false; }; - if delivery.final_ack.is_some() { return false; } + if !result.is_final() { + return false; + } + let Some(queue) = self.deliveries.get_mut(peer) else { + return false; + }; + let Some(delivery) = queue.get(change) else { + return false; + }; + if delivery.final_ack.is_some() { + return false; + } let order = delivery.order; for (id, delivery) in queue.iter_mut() { if id.name == change.name && delivery.order <= order && delivery.final_ack.is_none() { @@ -73,15 +114,22 @@ impl Outbox { } } if result == AckResult::StaleGeneration { - self.reoffer.entry(peer.clone()).or_default().insert(change.name.clone()); + self.reoffer + .entry(peer.clone()) + .or_default() + .insert(change.name.clone()); } true } /// Iterates only pending exact entries for a peer; finalized metadata is retained until release (§12.3). pub fn pending<'a>(&'a self, peer: &PeerId) -> impl Iterator { - self.deliveries.get(peer).into_iter().flat_map(|q| q.iter()) - .filter(|(_, d)| d.final_ack.is_none()).map(|(id, _)| id) + self.deliveries + .get(peer) + .into_iter() + .flat_map(|q| q.iter()) + .filter(|(_, d)| d.final_ack.is_none()) + .map(|(id, _)| id) } /// True only for a known snapshot with a final ACK from every target peer/generation (§12.3). @@ -91,7 +139,9 @@ impl Outbox { for (id, delivery) in queue { if id.name == name && id.new_vid == vid { found = true; - if delivery.final_ack.is_none() { return false; } + if delivery.final_ack.is_none() { + return false; + } } } } @@ -100,19 +150,27 @@ impl Outbox { /// Removes finalized bookkeeping only once the shared snapshot is releasable (§12.3). pub fn release_snapshot(&mut self, name: &str, vid: Vid) -> bool { - if !self.snapshot_releasable(name, vid) { return false; } - for queue in self.deliveries.values_mut() { queue.retain(|id, _| id.name != name || id.new_vid != vid); } + if !self.snapshot_releasable(name, vid) { + return false; + } + for queue in self.deliveries.values_mut() { + queue.retain(|id, _| id.name != name || id.new_vid != vid); + } self.deliveries.retain(|_, q| !q.is_empty()); true } /// Exposes the stale-generation status for a peer/name (§12.2). pub fn needs_reoffer(&self, peer: &PeerId, name: &str) -> bool { - self.reoffer.get(peer).is_some_and(|names| names.contains(name)) + self.reoffer + .get(peer) + .is_some_and(|names| names.contains(name)) } /// Clears the re-offer status after a new Accept (§12.2). pub fn accepted(&mut self, peer: &PeerId, name: &str) { - if let Some(names) = self.reoffer.get_mut(peer) { names.remove(name); } + if let Some(names) = self.reoffer.get_mut(peer) { + names.remove(name); + } } } diff --git a/crates/kc-sync/src/recovery.rs b/crates/kc-sync/src/recovery.rs index 705e83d..511f1ab 100644 --- a/crates/kc-sync/src/recovery.rs +++ b/crates/kc-sync/src/recovery.rs @@ -1,5 +1,5 @@ -use serde::{Deserialize, Serialize}; use crate::{AckResult, ChangeId, Fp, Lineage, PeerId, Vid}; +use serde::{Deserialize, Serialize}; /// Complete remote transaction intent, persisted before slots or keychain writes (§12.4). #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] @@ -67,9 +67,13 @@ pub enum RemoteRecovery { /// Classifies a remote journal by fingerprint, with intended-value equality taking precedence (§12.4). pub fn recover_remote(record: &RemoteJournalRecord, current_fp: Fp) -> RemoteRecovery { - if current_fp == record.new_fp { RemoteRecovery::FinishFromStep4 } - else if current_fp == record.prev_fp { RemoteRecovery::Retry } - else { RemoteRecovery::Conflict } + if current_fp == record.new_fp { + RemoteRecovery::FinishFromStep4 + } else if current_fp == record.prev_fp { + RemoteRecovery::Retry + } else { + RemoteRecovery::Conflict + } } /// Exactly the six local-journal recovery rows, in design-table order (§12.4). @@ -90,12 +94,26 @@ pub enum LocalRecovery { } /// Classifies all six rows; `committed` means stored head equals the journal's new vid (§12.4). -pub fn recover_local(prev_fp: Fp, new_fp: Fp, current_fp: Fp, committed: bool, snapshot_exists: bool) -> LocalRecovery { +pub fn recover_local( + prev_fp: Fp, + new_fp: Fp, + current_fp: Fp, + committed: bool, + snapshot_exists: bool, +) -> LocalRecovery { if current_fp == new_fp { - if committed { LocalRecovery::CleanJournal } - else if snapshot_exists { LocalRecovery::Commit } - else { LocalRecovery::RebuildSnapshotAndCommit } - } else if committed { LocalRecovery::KeepSnapshotAndScan } - else if current_fp == prev_fp { LocalRecovery::DiscardSnapshot } - else { LocalRecovery::DiscardSnapshotAndScan } + if committed { + LocalRecovery::CleanJournal + } else if snapshot_exists { + LocalRecovery::Commit + } else { + LocalRecovery::RebuildSnapshotAndCommit + } + } else if committed { + LocalRecovery::KeepSnapshotAndScan + } else if current_fp == prev_fp { + LocalRecovery::DiscardSnapshot + } else { + LocalRecovery::DiscardSnapshotAndScan + } } diff --git a/crates/kc-sync/src/slots.rs b/crates/kc-sync/src/slots.rs index 1a78587..ca5c428 100644 --- a/crates/kc-sync/src/slots.rs +++ b/crates/kc-sync/src/slots.rs @@ -1,6 +1,6 @@ -use std::collections::BTreeMap; -use serde::{Deserialize, Serialize}; use crate::{AckResult, Decision, Fp, HoldReason}; +use serde::{Deserialize, Serialize}; +use std::collections::BTreeMap; /// Slot priority in increasing order; checkpoints are never evicted (§12.3). #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] @@ -38,28 +38,50 @@ pub struct SlotBudget { impl SlotBudget { /// Creates a budget of max(16, items × 4), saturating arithmetic (§12.3). pub fn new(items: usize) -> Self { - Self { capacity: items.saturating_mul(4).max(16), slots: BTreeMap::new(), pinned_snapshots: Default::default() } + Self { + capacity: items.saturating_mul(4).max(16), + slots: BTreeMap::new(), + pinned_snapshots: Default::default(), + } } /// Returns the configured total capacity (§12.3). - pub fn capacity(&self) -> usize { self.capacity } + pub fn capacity(&self) -> usize { + self.capacity + } /// Returns the count of reserved slots (§12.3). - pub fn used(&self) -> usize { self.slots.len() } + pub fn used(&self) -> usize { + self.slots.len() + } /// Looks up a reservation without touching its value (§12.3). - pub fn kind(&self, name: &str) -> Option { self.slots.get(name).copied() } + pub fn kind(&self, name: &str) -> Option { + self.slots.get(name).copied() + } /// Reserves a slot; new Held and Proposal slots never evict at capacity (§12.3). pub fn reserve(&mut self, name: &str, kind: SlotKind) -> Reservation { if let Some(existing) = self.slots.get(name) { - return if *existing == kind { Reservation::Reserved { evicted: None } } else { Reservation::Refused }; + return if *existing == kind { + Reservation::Reserved { evicted: None } + } else { + Reservation::Refused + }; } let mut evicted = None; if self.slots.len() >= self.capacity { - if kind <= SlotKind::Held { return Reservation::Refused; } - evicted = self.slots.iter() - .filter(|(name, existing)| **existing < kind && !self.pinned_snapshots.contains(*name)) + if kind <= SlotKind::Held { + return Reservation::Refused; + } + evicted = self + .slots + .iter() + .filter(|(name, existing)| { + **existing < kind && !self.pinned_snapshots.contains(*name) + }) .min_by_key(|(name, existing)| (**existing, *name)) .map(|(name, _)| name.clone()); - let Some(victim) = &evicted else { return Reservation::Refused; }; + let Some(victim) = &evicted else { + return Reservation::Refused; + }; self.slots.remove(victim); } self.slots.insert(name.into(), kind); @@ -69,24 +91,36 @@ impl SlotBudget { /// Reserves an outbound snapshot pinned until all-target final ACK (§2.8, §12.3). pub fn reserve_snapshot(&mut self, name: &str) -> Reservation { let result = self.reserve(name, SlotKind::ConflictCandidate); - if matches!(result, Reservation::Reserved { .. }) { self.pinned_snapshots.insert(name.into()); } + if matches!(result, Reservation::Reserved { .. }) { + self.pinned_snapshots.insert(name.into()); + } result } /// Releases resolved/rejected slots or finally acknowledged snapshots, never checkpoints (§12.3). pub fn release(&mut self, name: &str) -> bool { - if self.slots.get(name) == Some(&SlotKind::Checkpoint) { return false; } + if self.slots.get(name) == Some(&SlotKind::Checkpoint) { + return false; + } self.pinned_snapshots.remove(name); self.slots.remove(name).is_some() } /// Ensures a checkpoint before overwrite; fallback is held, then capacity deferral (§2.6, §12.3). - pub fn prepare_overwrite(&mut self, checkpoint_slot: &str, held_slot: &str) -> OverwriteCapacity { + pub fn prepare_overwrite( + &mut self, + checkpoint_slot: &str, + held_slot: &str, + ) -> OverwriteCapacity { match self.reserve(checkpoint_slot, SlotKind::Checkpoint) { Reservation::Reserved { evicted } => OverwriteCapacity::Ready { evicted }, Reservation::Refused => match self.reserve(held_slot, SlotKind::Held) { - Reservation::Reserved { .. } => OverwriteCapacity::Held(Decision::held(HoldReason::OverLimit)), - Reservation::Refused => OverwriteCapacity::Deferred(Decision::unchanged(AckResult::DeferredCapacity)), + Reservation::Reserved { .. } => { + OverwriteCapacity::Held(Decision::held(HoldReason::OverLimit)) + } + Reservation::Refused => { + OverwriteCapacity::Deferred(Decision::unchanged(AckResult::DeferredCapacity)) + } }, } } @@ -108,13 +142,21 @@ pub enum OverwriteCapacity { /// Recovery baseline whose fingerprint cannot be replaced by remote overwrites (§2.6). #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)] -pub struct Checkpoint { fp: Option } +pub struct Checkpoint { + fp: Option, +} impl Checkpoint { /// Captures the original value only on the first remote overwrite (§2.6). - pub fn before_remote_overwrite(&mut self, current: Fp) -> Fp { *self.fp.get_or_insert(current) } + pub fn before_remote_overwrite(&mut self, current: Fp) -> Fp { + *self.fp.get_or_insert(current) + } /// Returns the retained fingerprint for caller-owned recovery storage (§2.6). - pub fn fingerprint(&self) -> Option { self.fp } + pub fn fingerprint(&self) -> Option { + self.fp + } /// Explicit human confirmation is the only way to replace a baseline (§2.6). - pub fn human_confirm(&mut self, current: Fp) { self.fp = Some(current); } + pub fn human_confirm(&mut self, current: Fp) { + self.fp = Some(current); + } } diff --git a/crates/kc-sync/src/state.rs b/crates/kc-sync/src/state.rs index e532d48..9d46e51 100644 --- a/crates/kc-sync/src/state.rs +++ b/crates/kc-sync/src/state.rs @@ -1,16 +1,28 @@ -use std::collections::{BTreeMap, BTreeSet}; use serde::{Deserialize, Deserializer, Serialize, Serializer}; +use std::collections::{BTreeMap, BTreeSet}; // Structured keys are encoded as pairs so state remains usable in sync.json as well as binary serde. -pub(crate) fn serialize_map(map: &BTreeMap, s: S) -> Result { +pub(crate) fn serialize_map( + map: &BTreeMap, + s: S, +) -> Result { map.iter().collect::>().serialize(s) } -pub(crate) fn deserialize_map<'de, D: Deserializer<'de>, K: Deserialize<'de> + Ord, V: Deserialize<'de>>(d: D) -> Result, D::Error> { +pub(crate) fn deserialize_map< + 'de, + D: Deserializer<'de>, + K: Deserialize<'de> + Ord, + V: Deserialize<'de>, +>( + d: D, +) -> Result, D::Error> { let pairs = Vec::<(K, V)>::deserialize(d)?; let count = pairs.len(); let map: BTreeMap<_, _> = pairs.into_iter().collect(); - if map.len() != count { return Err(serde::de::Error::custom("duplicate map key")); } + if map.len() != count { + return Err(serde::de::Error::custom("duplicate map key")); + } Ok(map) } @@ -50,7 +62,9 @@ impl Lineage { /// Retains the greatest 64 distinct vids, deterministically (§2.4). pub fn new(vids: impl IntoIterator) -> Self { let mut result = Self(vids.into_iter().collect()); - while result.0.len() > MAX_LINEAGE { result.0.pop_first(); } + while result.0.len() > MAX_LINEAGE { + result.0.pop_first(); + } result } @@ -70,13 +84,21 @@ impl Lineage { } /// Tests ancestry membership without trusting remote ancestry for authorization (§2.2). - pub fn contains(&self, vid: &Vid) -> bool { self.0.contains(vid) } + pub fn contains(&self, vid: &Vid) -> bool { + self.0.contains(vid) + } /// Returns identifiers in deterministic ascending order (§2.4). - pub fn iter(&self) -> impl Iterator { self.0.iter() } + pub fn iter(&self) -> impl Iterator { + self.0.iter() + } /// Returns the retained identifier count (§2.4). - pub fn len(&self) -> usize { self.0.len() } + pub fn len(&self) -> usize { + self.0.len() + } /// Reports an empty ancestry set (§2.4). - pub fn is_empty(&self) -> bool { self.0.is_empty() } + pub fn is_empty(&self) -> bool { + self.0.is_empty() + } } /// Immutable value and direct-parent binding for a known version (§2.2, §2.4). @@ -108,36 +130,57 @@ pub struct ItemState { /// All unresolved candidate values, including the current head (§2.4). pub conflict: Option, /// Bounded recent bindings; candidate bindings are additionally kept in `conflict` (§2.4). - #[serde(serialize_with = "serialize_map", deserialize_with = "deserialize_known")] + #[serde( + serialize_with = "serialize_map", + deserialize_with = "deserialize_known" + )] pub known: BTreeMap, } -fn deserialize_known<'de, D: Deserializer<'de>>(d: D) -> Result, D::Error> { +fn deserialize_known<'de, D: Deserializer<'de>>( + d: D, +) -> Result, D::Error> { let known: BTreeMap = deserialize_map(d)?; - if known.len() > MAX_KNOWN { return Err(serde::de::Error::custom("known cache exceeds bound")); } + if known.len() > MAX_KNOWN { + return Err(serde::de::Error::custom("known cache exceeds bound")); + } Ok(known) } impl ItemState { /// Initializes a single local head using caller-supplied randomness (§2.2). pub fn new(generation: u64, head: Vid, fp: Fp, parents: Vec) -> Self { - Self { generation, head, lineage: Lineage::new([head]), conflict: None, - known: BTreeMap::from([(head, VidRecord { fp, parents })]) } + Self { + generation, + head, + lineage: Lineage::new([head]), + conflict: None, + known: BTreeMap::from([(head, VidRecord { fp, parents })]), + } } /// Remembers a binding, rejects mutation, and deterministically bounds the cache (§2.2, §2.4). pub fn remember(&mut self, vid: Vid, record: VidRecord) -> bool { - if self.record(&vid).is_some_and(|old| old != &record) { return false; } + if self.record(&vid).is_some_and(|old| old != &record) { + return false; + } self.known.insert(vid, record); while self.known.len() > MAX_KNOWN { - let victim = self.known.keys().copied().find(|v| *v != self.head).unwrap(); + let victim = self + .known + .keys() + .copied() + .find(|v| *v != self.head) + .unwrap(); self.known.remove(&victim); } true } pub(crate) fn record(&self, vid: &Vid) -> Option<&VidRecord> { - self.known.get(vid).or_else(|| self.conflict.as_ref()?.candidates.get(vid)) + self.known + .get(vid) + .or_else(|| self.conflict.as_ref()?.candidates.get(vid)) } } diff --git a/crates/kc-sync/tests/policy.rs b/crates/kc-sync/tests/policy.rs index ae70b6e..9e5ab13 100644 --- a/crates/kc-sync/tests/policy.rs +++ b/crates/kc-sync/tests/policy.rs @@ -1,15 +1,33 @@ -use std::collections::BTreeMap; use kc_sync::*; +use std::collections::BTreeMap; -fn v(n: u16) -> Vid { let mut b = [0; 16]; b[14..].copy_from_slice(&n.to_be_bytes()); Vid(b) } -fn f(n: u8) -> Fp { Fp([n; 32]) } -fn peer(n: &str) -> PeerId { PeerId(n.into()) } -fn state() -> ItemState { ItemState::new(7, v(1), f(1), vec![v(0)]) } +fn v(n: u16) -> Vid { + let mut b = [0; 16]; + b[14..].copy_from_slice(&n.to_be_bytes()); + Vid(b) +} +fn f(n: u8) -> Fp { + Fp([n; 32]) +} +fn peer(n: &str) -> PeerId { + PeerId(n.into()) +} +fn state() -> ItemState { + ItemState::new(7, v(1), f(1), vec![v(0)]) +} fn incoming() -> Incoming { - Incoming { generation: 7, new_vid: v(2), parents: vec![v(1)], - lineage: Lineage::new([v(1), v(2)]), value_fp: Some(f(2)), retire: false } + Incoming { + generation: 7, + new_vid: v(2), + parents: vec![v(1)], + lineage: Lineage::new([v(1), v(2)]), + value_fp: Some(f(2)), + retire: false, + } +} +fn run(s: &ItemState, i: &Incoming) -> Decision { + decide(s, f(1), i, false, None, true) } -fn run(s: &ItemState, i: &Incoming) -> Decision { decide(s, f(1), i, false, None, true) } fn held(d: &Decision, reason: HoldReason) { assert_eq!(d.ack, AckResult::Held); assert_eq!(d.transition, Transition::Hold { reason }); @@ -17,94 +35,216 @@ fn held(d: &Decision, reason: HoldReason) { } fn conflicted() -> ItemState { let mut s = state(); - s.conflict = Some(ConflictSet { candidates: BTreeMap::from([ - (v(1), VidRecord { fp: f(1), parents: vec![v(0)] }), - (v(3), VidRecord { fp: f(3), parents: vec![v(0)] }), - (v(4), VidRecord { fp: f(4), parents: vec![v(0)] }), - ]) }); s + s.conflict = Some(ConflictSet { + candidates: BTreeMap::from([ + ( + v(1), + VidRecord { + fp: f(1), + parents: vec![v(0)], + }, + ), + ( + v(3), + VidRecord { + fp: f(3), + parents: vec![v(0)], + }, + ), + ( + v(4), + VidRecord { + fp: f(4), + parents: vec![v(0)], + }, + ), + ]), + }); + s } #[test] fn row1_stale_beats_freeze_violation_conflict_approval_and_limits() { - let mut i = incoming(); i.generation = 6; i.new_vid = v(1); - let d = decide(&conflicted(), f(1), &i, true, Some(&VerifiedApproval::for_tests()), false); - assert_eq!(d.ack, AckResult::StaleGeneration); assert_eq!(d.transition, Transition::Unchanged); assert!(!d.quarantine); + let mut i = incoming(); + i.generation = 6; + i.new_vid = v(1); + let d = decide( + &conflicted(), + f(1), + &i, + true, + Some(&VerifiedApproval::for_tests()), + false, + ); + assert_eq!(d.ack, AckResult::StaleGeneration); + assert_eq!(d.transition, Transition::Unchanged); + assert!(!d.quarantine); } #[test] fn row2_frozen_beats_fast_forward() { - held(&decide(&state(), f(1), &incoming(), true, Some(&VerifiedApproval::for_tests()), true), HoldReason::Frozen); + held( + &decide( + &state(), + f(1), + &incoming(), + true, + Some(&VerifiedApproval::for_tests()), + true, + ), + HoldReason::Frozen, + ); } #[test] fn row2_frozen_beats_violation() { - let mut i = incoming(); i.new_vid = v(1); - held(&decide(&state(), f(1), &i, true, None, true), HoldReason::Frozen); + let mut i = incoming(); + i.new_vid = v(1); + held( + &decide(&state(), f(1), &i, true, None, true), + HoldReason::Frozen, + ); } #[test] fn row3_same_vid_different_fp_is_quarantined() { - let mut i = incoming(); i.new_vid = v(1); i.parents = vec![v(0)]; - let d = run(&state(), &i); assert_eq!(d.ack, AckResult::Rejected); assert!(d.quarantine); + let mut i = incoming(); + i.new_vid = v(1); + i.parents = vec![v(0)]; + let d = run(&state(), &i); + assert_eq!(d.ack, AckResult::Rejected); + assert!(d.quarantine); } #[test] fn row3_same_vid_different_parents_is_quarantined() { - let mut i = incoming(); i.new_vid = v(1); i.value_fp = Some(f(1)); - let d = run(&state(), &i); assert_eq!(d.ack, AckResult::Rejected); assert!(d.quarantine); + let mut i = incoming(); + i.new_vid = v(1); + i.value_fp = Some(f(1)); + let d = run(&state(), &i); + assert_eq!(d.ack, AckResult::Rejected); + assert!(d.quarantine); } #[test] fn row3_checks_non_head_known_and_conflict_records() { - let mut s = state(); s.remember(v(9), VidRecord { fp: f(9), parents: vec![v(0)] }); - let mut i = incoming(); i.new_vid = v(9); + let mut s = state(); + s.remember( + v(9), + VidRecord { + fp: f(9), + parents: vec![v(0)], + }, + ); + let mut i = incoming(); + i.new_vid = v(9); assert!(run(&s, &i).quarantine); - i.new_vid = v(3); assert!(run(&conflicted(), &i).quarantine); + i.new_vid = v(3); + assert!(run(&conflicted(), &i).quarantine); } #[test] fn row4_duplicate_head_applied_without_write() { - let mut i = incoming(); i.new_vid = v(1); i.value_fp = Some(f(1)); i.parents = vec![v(0)]; - assert_eq!(run(&state(), &i), Decision { ack: AckResult::Applied, transition: Transition::Unchanged, quarantine: false }); + let mut i = incoming(); + i.new_vid = v(1); + i.value_fp = Some(f(1)); + i.parents = vec![v(0)]; + assert_eq!( + run(&state(), &i), + Decision { + ack: AckResult::Applied, + transition: Transition::Unchanged, + quarantine: false + } + ); } #[test] fn row4_ancestor_beats_conflict_and_no_approval() { - let mut s = conflicted(); s.lineage = Lineage::new([v(1), v(2)]); + let mut s = conflicted(); + s.lineage = Lineage::new([v(1), v(2)]); assert_eq!(run(&s, &incoming()).transition, Transition::Unchanged); } #[test] fn row5_adds_candidates_and_beats_same_value_and_fast_forward() { - let mut i = incoming(); i.value_fp = Some(f(1)); - let d = decide(&conflicted(), f(1), &i, false, Some(&VerifiedApproval::for_tests()), true); - let Transition::Conflict { candidates } = d.transition else { panic!("{d:?}"); }; - assert_eq!(candidates.candidates.len(), 4); assert!(candidates.candidates.contains_key(&v(2))); + let mut i = incoming(); + i.value_fp = Some(f(1)); + let d = decide( + &conflicted(), + f(1), + &i, + false, + Some(&VerifiedApproval::for_tests()), + true, + ); + let Transition::Conflict { candidates } = d.transition else { + panic!("{d:?}"); + }; + assert_eq!(candidates.candidates.len(), 4); + assert!(candidates.candidates.contains_key(&v(2))); } #[test] fn row5_complete_resolve_without_approval_requires_review() { - let mut i = incoming(); i.parents = vec![v(1), v(3), v(4), v(99)]; + let mut i = incoming(); + i.parents = vec![v(1), v(3), v(4), v(99)]; held(&run(&conflicted(), &i), HoldReason::Resolve); } #[test] fn row5_complete_approved_resolve_clears_conflict_atomically() { - let mut i = incoming(); i.parents = vec![v(1), v(3), v(4), v(99)]; - let d = decide(&conflicted(), f(1), &i, false, Some(&VerifiedApproval::for_tests()), true); - assert!(matches!(d.transition, Transition::Advance { head, clear_conflict: true, write_value: true, .. } if head == v(2))); + let mut i = incoming(); + i.parents = vec![v(1), v(3), v(4), v(99)]; + let d = decide( + &conflicted(), + f(1), + &i, + false, + Some(&VerifiedApproval::for_tests()), + true, + ); + assert!( + matches!(d.transition, Transition::Advance { head, clear_conflict: true, write_value: true, .. } if head == v(2)) + ); } #[test] fn row5_missing_any_candidate_including_own_head_stays_conflict() { for missing in [v(1), v(3), v(4)] { - let mut i = incoming(); i.parents = [v(1), v(3), v(4)].into_iter().filter(|v| *v != missing).collect(); + let mut i = incoming(); + i.parents = [v(1), v(3), v(4)] + .into_iter() + .filter(|v| *v != missing) + .collect(); for approved in [false, true] { let token = VerifiedApproval::for_tests(); - let d = decide(&conflicted(), f(1), &i, false, approved.then_some(&token), true); + let d = decide( + &conflicted(), + f(1), + &i, + false, + approved.then_some(&token), + true, + ); assert_eq!(d.ack, AckResult::Conflict); } } } #[test] fn row5_resolve_obeys_limits() { - let mut i = incoming(); i.parents = vec![v(1), v(3), v(4)]; - held(&decide(&conflicted(), f(1), &i, false, Some(&VerifiedApproval::for_tests()), false), HoldReason::OverLimit); + let mut i = incoming(); + i.parents = vec![v(1), v(3), v(4)]; + held( + &decide( + &conflicted(), + f(1), + &i, + false, + Some(&VerifiedApproval::for_tests()), + false, + ), + HoldReason::OverLimit, + ); } #[test] fn row6_same_value_converges_before_approval_and_limits() { - let mut i = incoming(); i.value_fp = Some(f(1)); i.parents = vec![v(55)]; + let mut i = incoming(); + i.value_fp = Some(f(1)); + i.parents = vec![v(55)]; let d = decide(&state(), f(1), &i, false, None, false); - assert!(matches!(d.transition, Transition::Advance { head, write_value: false, .. } if head == v(2))); + assert!( + matches!(d.transition, Transition::Advance { head, write_value: false, .. } if head == v(2)) + ); } #[test] fn convergence_is_symmetric_even_when_lineage_truncates() { @@ -112,277 +252,662 @@ fn convergence_is_symmetric_even_when_lineage_truncates() { let mut b = ItemState::new(7, v(80), f(1), vec![]); a.lineage = Lineage::new((0..64).map(v)).with_head(a.head); b.lineage = Lineage::new((50..114).map(v)).with_head(b.head); - let from = |s: &ItemState| Incoming { generation: 7, new_vid: s.head, parents: vec![], lineage: s.lineage.clone(), value_fp: Some(f(1)), retire: false }; + let from = |s: &ItemState| Incoming { + generation: 7, + new_vid: s.head, + parents: vec![], + lineage: s.lineage.clone(), + value_fp: Some(f(1)), + retire: false, + }; let da = decide(&a, f(1), &from(&b), false, None, true); let db = decide(&b, f(1), &from(&a), false, None, true); assert_eq!(da, db); - let Transition::Advance { head, lineage, .. } = da.transition else { panic!() }; - assert_eq!(head, v(80)); assert_eq!(lineage.len(), 64); assert!(lineage.contains(&head)); + let Transition::Advance { head, lineage, .. } = da.transition else { + panic!() + }; + assert_eq!(head, v(80)); + assert_eq!(lineage.len(), 64); + assert!(lineage.contains(&head)); } #[test] fn row7_approved_direct_parent_fast_forwards() { - let d = decide(&state(), f(1), &incoming(), false, Some(&VerifiedApproval::for_tests()), true); - assert!(matches!(d.transition, Transition::Advance { head, write_value: true, clear_conflict: false, .. } if head == v(2))); + let d = decide( + &state(), + f(1), + &incoming(), + false, + Some(&VerifiedApproval::for_tests()), + true, + ); + assert!( + matches!(d.transition, Transition::Advance { head, write_value: true, clear_conflict: false, .. } if head == v(2)) + ); } #[test] -fn row8_phase1_direct_parent_is_held() { held(&run(&state(), &incoming()), HoldReason::NoApproval); } +fn row8_phase1_direct_parent_is_held() { + held(&run(&state(), &incoming()), HoldReason::NoApproval); +} #[test] fn row8_approved_over_limit_is_held() { - held(&decide(&state(), f(1), &incoming(), false, Some(&VerifiedApproval::for_tests()), false), HoldReason::OverLimit); + held( + &decide( + &state(), + f(1), + &incoming(), + false, + Some(&VerifiedApproval::for_tests()), + false, + ), + HoldReason::OverLimit, + ); } #[test] fn row9_forged_lineage_cannot_replace_parent_binding() { - let mut i = incoming(); i.parents = vec![v(99)]; assert!(i.lineage.contains(&state().head)); + let mut i = incoming(); + i.parents = vec![v(99)]; + assert!(i.lineage.contains(&state().head)); for approved in [false, true] { let token = VerifiedApproval::for_tests(); - assert_eq!(decide(&state(), f(1), &i, false, approved.then_some(&token), true).ack, AckResult::Conflict); + assert_eq!( + decide(&state(), f(1), &i, false, approved.then_some(&token), true).ack, + AckResult::Conflict + ); } } #[test] fn retire_requires_approval_and_never_requests_value_deletion() { - let mut i = incoming(); i.retire = true; i.value_fp = None; + let mut i = incoming(); + i.retire = true; + i.value_fp = None; held(&run(&state(), &i), HoldReason::NoApproval); - assert_eq!(decide(&state(), f(1), &i, false, Some(&VerifiedApproval::for_tests()), true).transition, Transition::Retire); - held(&decide(&state(), f(1), &i, false, Some(&VerifiedApproval::for_tests()), false), HoldReason::OverLimit); - i.parents = vec![v(99)]; held(&run(&conflicted(), &i), HoldReason::NoApproval); - assert_eq!(decide(&state(), f(1), &i, false, Some(&VerifiedApproval::for_tests()), true).ack, AckResult::Conflict); + assert_eq!( + decide( + &state(), + f(1), + &i, + false, + Some(&VerifiedApproval::for_tests()), + true + ) + .transition, + Transition::Retire + ); + held( + &decide( + &state(), + f(1), + &i, + false, + Some(&VerifiedApproval::for_tests()), + false, + ), + HoldReason::OverLimit, + ); + i.parents = vec![v(99)]; + held(&run(&conflicted(), &i), HoldReason::NoApproval); + assert_eq!( + decide( + &state(), + f(1), + &i, + false, + Some(&VerifiedApproval::for_tests()), + true + ) + .ack, + AckResult::Conflict + ); } #[test] fn malformed_put_or_retire_is_rejected() { - let mut i = incoming(); i.value_fp = None; assert_eq!(run(&state(), &i).ack, AckResult::Rejected); - i.value_fp = Some(f(2)); i.retire = true; assert_eq!(run(&state(), &i).ack, AckResult::Rejected); + let mut i = incoming(); + i.value_fp = None; + assert_eq!(run(&state(), &i).ack, AckResult::Rejected); + i.value_fp = Some(f(2)); + i.retire = true; + assert_eq!(run(&state(), &i).ack, AckResult::Rejected); } #[test] fn lineage_boundary_64_65_and_head_pinning() { - let a = Lineage::new((0..64).map(v)); assert_eq!(a.len(), 64); assert!(a.contains(&v(0))); + let a = Lineage::new((0..64).map(v)); + assert_eq!(a.len(), 64); + assert!(a.contains(&v(0))); let b = Lineage::merge(&a, &Lineage::new([v(64)])); - assert_eq!(b.len(), 64); assert!(!b.contains(&v(0))); assert!(b.contains(&v(64))); + assert_eq!(b.len(), 64); + assert!(!b.contains(&v(0))); + assert!(b.contains(&v(64))); assert_eq!(b, Lineage::merge(&Lineage::new([v(64)]), &a)); - let pinned = b.with_head(v(0)); assert!(pinned.contains(&v(0))); assert!(!pinned.contains(&v(1))); assert_eq!(pinned.len(), 64); + let pinned = b.with_head(v(0)); + assert!(pinned.contains(&v(0))); + assert!(!pinned.contains(&v(1))); + assert_eq!(pinned.len(), 64); } #[test] fn fast_forward_retains_small_random_head_at_capacity() { - let mut s = state(); s.lineage = Lineage::new((100..164).map(v)).with_head(v(1)); - let mut i = incoming(); i.new_vid = v(0); i.lineage = Lineage::new((200..264).map(v)); - let d = decide(&s, f(1), &i, false, Some(&VerifiedApproval::for_tests()), true); - let Transition::Advance { head, lineage, .. } = d.transition else { panic!() }; - assert!(lineage.contains(&head)); assert_eq!(head, v(0)); assert_eq!(lineage.len(), 64); + let mut s = state(); + s.lineage = Lineage::new((100..164).map(v)).with_head(v(1)); + let mut i = incoming(); + i.new_vid = v(0); + i.lineage = Lineage::new((200..264).map(v)); + let d = decide( + &s, + f(1), + &i, + false, + Some(&VerifiedApproval::for_tests()), + true, + ); + let Transition::Advance { head, lineage, .. } = d.transition else { + panic!() + }; + assert!(lineage.contains(&head)); + assert_eq!(head, v(0)); + assert_eq!(lineage.len(), 64); } #[test] fn lineage_serde_rejects_oversized_sets() { let json = serde_json::to_string(&(0..65).map(v).collect::>()).unwrap(); assert!(serde_json::from_str::(&json).is_err()); let a = Lineage::new((0..64).map(v)); - assert_eq!(a, serde_json::from_str(&serde_json::to_string(&a).unwrap()).unwrap()); + assert_eq!( + a, + serde_json::from_str(&serde_json::to_string(&a).unwrap()).unwrap() + ); } #[test] fn known_cache_is_bounded_and_immutable() { let mut s = state(); - for n in 2..400 { assert!(s.remember(v(n), VidRecord { fp: f(2), parents: vec![] })); } - assert_eq!(s.known.len(), MAX_KNOWN); assert!(s.known.contains_key(&s.head)); - assert!(!s.remember(v(1), VidRecord { fp: f(9), parents: vec![] })); + for n in 2..400 { + assert!(s.remember( + v(n), + VidRecord { + fp: f(2), + parents: vec![] + } + )); + } + assert_eq!(s.known.len(), MAX_KNOWN); + assert!(s.known.contains_key(&s.head)); + assert!(!s.remember( + v(1), + VidRecord { + fp: f(9), + parents: vec![] + } + )); } -fn id(n: u16) -> ChangeId { ChangeId { name: "key".into(), generation: 7, new_vid: v(n) } } +fn id(n: u16) -> ChangeId { + ChangeId { + name: "key".into(), + generation: 7, + new_vid: v(n), + } +} #[test] fn old_ack_never_deletes_newer_entry_even_with_lower_vid() { - let mut o = Outbox::default(); let p = peer("a"); - o.enqueue(p.clone(), id(99)); o.enqueue(p.clone(), id(1)); + let mut o = Outbox::default(); + let p = peer("a"); + o.enqueue(p.clone(), id(99)); + o.enqueue(p.clone(), id(1)); assert!(o.ack(&p, &id(99), AckResult::Applied)); assert_eq!(o.pending(&p).cloned().collect::>(), vec![id(1)]); } #[test] fn newer_ack_supersedes_older_entries_for_only_that_peer_and_name() { - let mut o = Outbox::default(); let p = peer("a"); let q = peer("b"); - for target in [&p, &q] { o.enqueue(target.clone(), id(99)); o.enqueue(target.clone(), id(1)); } - let mut other = id(0); other.name = "other".into(); o.enqueue(p.clone(), other.clone()); + let mut o = Outbox::default(); + let p = peer("a"); + let q = peer("b"); + for target in [&p, &q] { + o.enqueue(target.clone(), id(99)); + o.enqueue(target.clone(), id(1)); + } + let mut other = id(0); + other.name = "other".into(); + o.enqueue(p.clone(), other.clone()); o.ack(&p, &id(1), AckResult::Held); assert_eq!(o.pending(&p).cloned().collect::>(), vec![other]); - assert_eq!(o.pending(&q).count(), 2); assert!(!o.snapshot_releasable("key", v(99))); - o.ack(&q, &id(1), AckResult::Conflict); assert!(o.snapshot_releasable("key", v(99))); + assert_eq!(o.pending(&q).count(), 2); + assert!(!o.snapshot_releasable("key", v(99))); + o.ack(&q, &id(1), AckResult::Conflict); + assert!(o.snapshot_releasable("key", v(99))); } #[test] fn deferred_and_unknown_ack_preserve_queue_and_snapshot() { - let mut o = Outbox::default(); let p = peer("a"); o.enqueue(p.clone(), id(1)); + let mut o = Outbox::default(); + let p = peer("a"); + o.enqueue(p.clone(), id(1)); assert!(!o.ack(&p, &id(1), AckResult::DeferredCapacity)); assert!(!o.ack(&p, &id(2), AckResult::Applied)); - let mut wrong = id(1); wrong.generation += 1; + let mut wrong = id(1); + wrong.generation += 1; assert!(!o.ack(&p, &wrong, AckResult::Applied)); - assert_eq!(o.pending(&p).count(), 1); assert!(!o.snapshot_releasable("key", v(1))); + assert_eq!(o.pending(&p).count(), 1); + assert!(!o.snapshot_releasable("key", v(1))); } #[test] fn stale_generation_marks_reoffer_and_accept_clears_it() { - let mut o = Outbox::default(); let p = peer("a"); o.enqueue(p.clone(), id(1)); + let mut o = Outbox::default(); + let p = peer("a"); + o.enqueue(p.clone(), id(1)); o.ack(&p, &id(1), AckResult::StaleGeneration); - assert_eq!(o.pending(&p).count(), 0); assert!(o.needs_reoffer(&p, "key")); - o.accepted(&p, "key"); assert!(!o.needs_reoffer(&p, "key")); + assert_eq!(o.pending(&p).count(), 0); + assert!(o.needs_reoffer(&p, "key")); + o.accepted(&p, "key"); + assert!(!o.needs_reoffer(&p, "key")); } #[test] fn snapshots_wait_for_all_targets_even_with_different_generations() { - let mut o = Outbox::default(); let p = peer("a"); let q = peer("b"); let mut other = id(1); other.generation = 22; - o.enqueue(p.clone(), id(1)); o.enqueue(q.clone(), other.clone()); - o.ack(&p, &id(1), AckResult::Rejected); assert!(!o.snapshot_releasable("key", v(1))); - o.ack(&q, &other, AckResult::Applied); assert!(o.snapshot_releasable("key", v(1))); - assert!(o.release_snapshot("key", v(1))); assert!(!o.snapshot_releasable("key", v(1))); + let mut o = Outbox::default(); + let p = peer("a"); + let q = peer("b"); + let mut other = id(1); + other.generation = 22; + o.enqueue(p.clone(), id(1)); + o.enqueue(q.clone(), other.clone()); + o.ack(&p, &id(1), AckResult::Rejected); + assert!(!o.snapshot_releasable("key", v(1))); + o.ack(&q, &other, AckResult::Applied); + assert!(o.snapshot_releasable("key", v(1))); + assert!(o.release_snapshot("key", v(1))); + assert!(!o.snapshot_releasable("key", v(1))); } #[test] fn ack_discriminant_order_and_finality() { - for (n, result) in [AckResult::Applied, AckResult::Held, AckResult::Conflict, AckResult::StaleGeneration, AckResult::DeferredCapacity, AckResult::Rejected].into_iter().enumerate() { - assert_eq!(result as usize, n); assert_eq!(result.is_final(), n != 4); + for (n, result) in [ + AckResult::Applied, + AckResult::Held, + AckResult::Conflict, + AckResult::StaleGeneration, + AckResult::DeferredCapacity, + AckResult::Rejected, + ] + .into_iter() + .enumerate() + { + assert_eq!(result as usize, n); + assert_eq!(result.is_final(), n != 4); } } fn journal() -> RemoteJournalRecord { - RemoteJournalRecord { change_id: id(2), sender: peer("a"), prev_fp: f(1), new_fp: f(2), head: v(2), - lineage: Lineage::new([v(1), v(2)]), approval_key: None, ack: AckResult::Applied, - checkpoint_slot: Some("checkpoint".into()), candidate_slot: "candidate".into() } + RemoteJournalRecord { + change_id: id(2), + sender: peer("a"), + prev_fp: f(1), + new_fp: f(2), + head: v(2), + lineage: Lineage::new([v(1), v(2)]), + approval_key: None, + ack: AckResult::Applied, + checkpoint_slot: Some("checkpoint".into()), + candidate_slot: "candidate".into(), + } } -#[test] fn remote_recovery_finish() { assert_eq!(recover_remote(&journal(), f(2)), RemoteRecovery::FinishFromStep4); } -#[test] fn remote_recovery_retry() { assert_eq!(recover_remote(&journal(), f(1)), RemoteRecovery::Retry); } -#[test] fn remote_recovery_conflict() { assert_eq!(recover_remote(&journal(), f(3)), RemoteRecovery::Conflict); } -#[test] fn local_row1_rebuild_snapshot() { assert_eq!(recover_local(f(1), f(2), f(2), false, false), LocalRecovery::RebuildSnapshotAndCommit); } -#[test] fn local_row2_commit_existing_snapshot() { assert_eq!(recover_local(f(1), f(2), f(2), false, true), LocalRecovery::Commit); } -#[test] fn local_row3_clean_committed_journal() { - for snapshot in [false, true] { assert_eq!(recover_local(f(1), f(2), f(2), true, snapshot), LocalRecovery::CleanJournal); } +#[test] +fn remote_recovery_finish() { + assert_eq!( + recover_remote(&journal(), f(2)), + RemoteRecovery::FinishFromStep4 + ); +} +#[test] +fn remote_recovery_retry() { + assert_eq!(recover_remote(&journal(), f(1)), RemoteRecovery::Retry); } -#[test] fn local_row4_keep_queued_snapshot_and_scan() { - for current in [f(1), f(3)] { for snapshot in [false, true] { - assert_eq!(recover_local(f(1), f(2), current, true, snapshot), LocalRecovery::KeepSnapshotAndScan); - }} +#[test] +fn remote_recovery_conflict() { + assert_eq!(recover_remote(&journal(), f(3)), RemoteRecovery::Conflict); } -#[test] fn local_row5_discard_uncommitted_snapshot() { - for snapshot in [false, true] { assert_eq!(recover_local(f(1), f(2), f(1), false, snapshot), LocalRecovery::DiscardSnapshot); } +#[test] +fn local_row1_rebuild_snapshot() { + assert_eq!( + recover_local(f(1), f(2), f(2), false, false), + LocalRecovery::RebuildSnapshotAndCommit + ); } -#[test] fn local_row6_discard_and_scan_other_value() { - for snapshot in [false, true] { assert_eq!(recover_local(f(1), f(2), f(3), false, snapshot), LocalRecovery::DiscardSnapshotAndScan); } +#[test] +fn local_row2_commit_existing_snapshot() { + assert_eq!( + recover_local(f(1), f(2), f(2), false, true), + LocalRecovery::Commit + ); +} +#[test] +fn local_row3_clean_committed_journal() { + for snapshot in [false, true] { + assert_eq!( + recover_local(f(1), f(2), f(2), true, snapshot), + LocalRecovery::CleanJournal + ); + } +} +#[test] +fn local_row4_keep_queued_snapshot_and_scan() { + for current in [f(1), f(3)] { + for snapshot in [false, true] { + assert_eq!( + recover_local(f(1), f(2), current, true, snapshot), + LocalRecovery::KeepSnapshotAndScan + ); + } + } +} +#[test] +fn local_row5_discard_uncommitted_snapshot() { + for snapshot in [false, true] { + assert_eq!( + recover_local(f(1), f(2), f(1), false, snapshot), + LocalRecovery::DiscardSnapshot + ); + } +} +#[test] +fn local_row6_discard_and_scan_other_value() { + for snapshot in [false, true] { + assert_eq!( + recover_local(f(1), f(2), f(3), false, snapshot), + LocalRecovery::DiscardSnapshotAndScan + ); + } } #[test] fn journal_records_round_trip_and_equal_fps_prefer_finished_write() { - let r = journal(); assert_eq!(r, serde_json::from_str(&serde_json::to_string(&r).unwrap()).unwrap()); - let l = LocalJournalRecord { name: "key".into(), prev_fp: f(1), new_fp: f(2), new_vid: v(2), parents: vec![v(1)], snapshot_slot: "snapshot".into(), targets: vec![QueueTarget { peer: peer("a"), generation: 7 }] }; - assert_eq!(l, serde_json::from_str(&serde_json::to_string(&l).unwrap()).unwrap()); - let mut r = r; r.prev_fp = r.new_fp; assert_eq!(recover_remote(&r, r.new_fp), RemoteRecovery::FinishFromStep4); + let r = journal(); + assert_eq!( + r, + serde_json::from_str(&serde_json::to_string(&r).unwrap()).unwrap() + ); + let l = LocalJournalRecord { + name: "key".into(), + prev_fp: f(1), + new_fp: f(2), + new_vid: v(2), + parents: vec![v(1)], + snapshot_slot: "snapshot".into(), + targets: vec![QueueTarget { + peer: peer("a"), + generation: 7, + }], + }; + assert_eq!( + l, + serde_json::from_str(&serde_json::to_string(&l).unwrap()).unwrap() + ); + let mut r = r; + r.prev_fp = r.new_fp; + assert_eq!( + recover_remote(&r, r.new_fp), + RemoteRecovery::FinishFromStep4 + ); } #[test] fn limiter_one_noninteractive_overwrite_per_item_per_24h_across_peers() { - let mut l = Limiter::default(); let p = peer("a"); let q = peer("b"); - assert_eq!(l.check(&p, "key", RemoteOperation::Overwrite, 0, 100, false), LimitResult::Allowed); + let mut l = Limiter::default(); + let p = peer("a"); + let q = peer("b"); + assert_eq!( + l.check(&p, "key", RemoteOperation::Overwrite, 0, 100, false), + LimitResult::Allowed + ); l.record(&p, "key", RemoteOperation::Overwrite, 0, false); - assert_eq!(l.check(&q, "key", RemoteOperation::Overwrite, 86399, 100, false), LimitResult::ItemLimited); - assert_eq!(l.check(&q, "key", RemoteOperation::Overwrite, 86399, 100, true), LimitResult::Allowed); - assert_eq!(l.check(&q, "key", RemoteOperation::Overwrite, 86400, 100, false), LimitResult::Allowed); + assert_eq!( + l.check(&q, "key", RemoteOperation::Overwrite, 86399, 100, false), + LimitResult::ItemLimited + ); + assert_eq!( + l.check(&q, "key", RemoteOperation::Overwrite, 86399, 100, true), + LimitResult::Allowed + ); + assert_eq!( + l.check(&q, "key", RemoteOperation::Overwrite, 86400, 100, false), + LimitResult::Allowed + ); } #[test] fn limiter_overwrite_and_retire_thresholds_are_strict_and_latched() { - for (op, cap) in [(RemoteOperation::Overwrite, 5), (RemoteOperation::Retire, 3)] { - let mut l = Limiter::default(); let p = peer("a"); + for (op, cap) in [ + (RemoteOperation::Overwrite, 5), + (RemoteOperation::Retire, 3), + ] { + let mut l = Limiter::default(); + let p = peer("a"); for n in 0..cap { - let name = format!("key{n}"); assert_eq!(l.check(&p, &name, op, 0, 100, false), LimitResult::Allowed); + let name = format!("key{n}"); + assert_eq!(l.check(&p, &name, op, 0, 100, false), LimitResult::Allowed); l.record(&p, &name, op, 0, false); } - assert_eq!(l.check(&p, "extra", op, 0, 100, false), LimitResult::PeerTripped); - assert_eq!(l.check(&p, "other", op, 200000, 100, true), LimitResult::PeerTripped); - l.human_reset(&p); assert_eq!(l.check(&p, "extra", op, 200000, 100, false), LimitResult::Allowed); + assert_eq!( + l.check(&p, "extra", op, 0, 100, false), + LimitResult::PeerTripped + ); + assert_eq!( + l.check(&p, "other", op, 200000, 100, true), + LimitResult::PeerTripped + ); + l.human_reset(&p); + assert_eq!( + l.check(&p, "extra", op, 200000, 100, false), + LimitResult::Allowed + ); } } #[test] fn limiter_percentage_only_at_eight_and_counts_distinct_affected_names() { for size in [7, 8, 9] { - let mut l = Limiter::default(); let p = peer("a"); - for name in ["a", "b"] { l.record(&p, name, RemoteOperation::Overwrite, 0, false); } - assert_eq!(l.check(&p, "c", RemoteOperation::Retire, 0, size, false), if size < 8 { LimitResult::Allowed } else { LimitResult::PeerTripped }); + let mut l = Limiter::default(); + let p = peer("a"); + for name in ["a", "b"] { + l.record(&p, name, RemoteOperation::Overwrite, 0, false); + } + assert_eq!( + l.check(&p, "c", RemoteOperation::Retire, 0, size, false), + if size < 8 { + LimitResult::Allowed + } else { + LimitResult::PeerTripped + } + ); + } + let mut l = Limiter::default(); + let p = peer("a"); + for _ in 0..3 { + l.record(&p, "same", RemoteOperation::Overwrite, 0, true); } - let mut l = Limiter::default(); let p = peer("a"); - for _ in 0..3 { l.record(&p, "same", RemoteOperation::Overwrite, 0, true); } - assert_eq!(l.check(&p, "same", RemoteOperation::Overwrite, 0, 8, true), LimitResult::Allowed); + assert_eq!( + l.check(&p, "same", RemoteOperation::Overwrite, 0, 8, true), + LimitResult::Allowed + ); } #[test] fn limiter_clock_rollback_expiry_and_serde() { - let mut l = Limiter::default(); let p = peer("a"); l.record(&p, "key", RemoteOperation::Overwrite, i64::MAX, false); + let mut l = Limiter::default(); + let p = peer("a"); + l.record(&p, "key", RemoteOperation::Overwrite, i64::MAX, false); let mut l: Limiter = serde_json::from_str(&serde_json::to_string(&l).unwrap()).unwrap(); - assert_eq!(l.check(&p, "key", RemoteOperation::Overwrite, i64::MIN, 100, false), LimitResult::ItemLimited); - let mut l = Limiter::default(); l.record(&p, "key", RemoteOperation::Overwrite, 0, false); - l.prune(WINDOW_SECS); assert_eq!(l.check(&p, "key", RemoteOperation::Overwrite, WINDOW_SECS, 100, false), LimitResult::Allowed); + assert_eq!( + l.check(&p, "key", RemoteOperation::Overwrite, i64::MIN, 100, false), + LimitResult::ItemLimited + ); + let mut l = Limiter::default(); + l.record(&p, "key", RemoteOperation::Overwrite, 0, false); + l.prune(WINDOW_SECS); + assert_eq!( + l.check( + &p, + "key", + RemoteOperation::Overwrite, + WINDOW_SECS, + 100, + false + ), + LimitResult::Allowed + ); } #[test] fn slot_capacity_floor_and_priority() { - assert_eq!(SlotBudget::new(0).capacity(), 16); assert_eq!(SlotBudget::new(5).capacity(), 20); - assert!(SlotKind::Checkpoint > SlotKind::ConflictCandidate && SlotKind::ConflictCandidate > SlotKind::Held && SlotKind::Held > SlotKind::Proposal); + assert_eq!(SlotBudget::new(0).capacity(), 16); + assert_eq!(SlotBudget::new(5).capacity(), 20); + assert!( + SlotKind::Checkpoint > SlotKind::ConflictCandidate + && SlotKind::ConflictCandidate > SlotKind::Held + && SlotKind::Held > SlotKind::Proposal + ); let mut b = SlotBudget::new(0); - for n in 0..16 { assert!(matches!(b.reserve(&format!("p{n:02}"), SlotKind::Proposal), Reservation::Reserved { .. })); } + for n in 0..16 { + assert!(matches!( + b.reserve(&format!("p{n:02}"), SlotKind::Proposal), + Reservation::Reserved { .. } + )); + } assert_eq!(b.reserve("p-new", SlotKind::Proposal), Reservation::Refused); assert_eq!(b.reserve("h-new", SlotKind::Held), Reservation::Refused); - assert_eq!(b.reserve("candidate", SlotKind::ConflictCandidate), Reservation::Reserved { evicted: Some("p00".into()) }); - assert_eq!(b.reserve("checkpoint", SlotKind::Checkpoint), Reservation::Reserved { evicted: Some("p01".into()) }); - assert!(!b.release("checkpoint")); assert!(b.release("candidate")); assert_eq!(b.used(), 15); + assert_eq!( + b.reserve("candidate", SlotKind::ConflictCandidate), + Reservation::Reserved { + evicted: Some("p00".into()) + } + ); + assert_eq!( + b.reserve("checkpoint", SlotKind::Checkpoint), + Reservation::Reserved { + evicted: Some("p01".into()) + } + ); + assert!(!b.release("checkpoint")); + assert!(b.release("candidate")); + assert_eq!(b.used(), 15); } #[test] fn checkpoints_and_unacked_snapshots_are_never_evicted() { let mut b = SlotBudget::new(0); - for n in 0..8 { b.reserve(&format!("c{n}"), SlotKind::Checkpoint); b.reserve_snapshot(&format!("s{n}")); } + for n in 0..8 { + b.reserve(&format!("c{n}"), SlotKind::Checkpoint); + b.reserve_snapshot(&format!("s{n}")); + } assert_eq!(b.reserve("new", SlotKind::Checkpoint), Reservation::Refused); - assert!(matches!(b.prepare_overwrite("new", "held"), OverwriteCapacity::Deferred(Decision { ack: AckResult::DeferredCapacity, .. }))); - assert!(matches!(b.prepare_overwrite("c0", "held"), OverwriteCapacity::Ready { .. })); + assert!(matches!( + b.prepare_overwrite("new", "held"), + OverwriteCapacity::Deferred(Decision { + ack: AckResult::DeferredCapacity, + .. + }) + )); + assert!(matches!( + b.prepare_overwrite("c0", "held"), + OverwriteCapacity::Ready { .. } + )); } #[test] fn checkpoint_reservation_failure_holds_when_hold_can_be_retained() { - let mut b = SlotBudget::new(0); b.reserve("occupied", SlotKind::Held); - let OverwriteCapacity::Held(d) = b.prepare_overwrite("occupied", "held") else { panic!() }; - held(&d, HoldReason::OverLimit); assert_eq!(b.kind("held"), Some(SlotKind::Held)); + let mut b = SlotBudget::new(0); + b.reserve("occupied", SlotKind::Held); + let OverwriteCapacity::Held(d) = b.prepare_overwrite("occupied", "held") else { + panic!() + }; + held(&d, HoldReason::OverLimit); + assert_eq!(b.kind("held"), Some(SlotKind::Held)); } #[test] fn checkpoint_changes_only_on_first_capture_or_human_confirmation() { - let mut cp = Checkpoint::default(); assert_eq!(cp.before_remote_overwrite(f(1)), f(1)); - for n in 2..100 { assert_eq!(cp.before_remote_overwrite(f(n)), f(1)); } - cp.human_confirm(f(99)); assert_eq!(cp.before_remote_overwrite(f(100)), f(99)); - let cp2: Checkpoint = serde_json::from_str(&serde_json::to_string(&cp).unwrap()).unwrap(); assert_eq!(cp, cp2); + let mut cp = Checkpoint::default(); + assert_eq!(cp.before_remote_overwrite(f(1)), f(1)); + for n in 2..100 { + assert_eq!(cp.before_remote_overwrite(f(n)), f(1)); + } + cp.human_confirm(f(99)); + assert_eq!(cp.before_remote_overwrite(f(100)), f(99)); + let cp2: Checkpoint = serde_json::from_str(&serde_json::to_string(&cp).unwrap()).unwrap(); + assert_eq!(cp, cp2); } #[test] fn generations_are_receiver_owned_scoped_and_bumped_on_rm() { - let mut g = Generations::default(); let a = peer("a"); let b = peer("b"); + let mut g = Generations::default(); + let a = peer("a"); + let b = peer("b"); assert_eq!(g.outgoing_generation(&a, "key"), None); - let accept = g.accept("key", a.clone()); assert_eq!(accept.generation, 0); - assert!(g.includes("key", &a)); assert!(!g.includes("key", &b)); - let (leave, peers) = g.rm("key").unwrap(); assert_eq!(leave.generation, 1); assert_eq!(peers.len(), 1); assert!(!g.includes("key", &a)); - let accept = g.accept("key", b.clone()); assert_eq!(accept.generation, 1); assert!(g.includes("key", &b)); + let accept = g.accept("key", a.clone()); + assert_eq!(accept.generation, 0); + assert!(g.includes("key", &a)); + assert!(!g.includes("key", &b)); + let (leave, peers) = g.rm("key").unwrap(); + assert_eq!(leave.generation, 1); + assert_eq!(peers.len(), 1); + assert!(!g.includes("key", &a)); + let accept = g.accept("key", b.clone()); + assert_eq!(accept.generation, 1); + assert!(g.includes("key", &b)); } #[test] fn accept_leave_ignore_older_generations_and_require_reacceptance() { - let mut g = Generations::default(); let p = peer("a"); - let msg = |generation| Registration { name: "key".into(), generation }; - g.received_accept(p.clone(), msg(2)); assert_eq!(g.outgoing_generation(&p, "key"), Some(2)); - g.received_leave(p.clone(), msg(3)); assert_eq!(g.outgoing_generation(&p, "key"), None); - assert!(!g.received_accept(p.clone(), msg(2))); assert_eq!(g.outgoing_generation(&p, "key"), None); - g.received_accept(p.clone(), msg(3)); assert_eq!(g.outgoing_generation(&p, "key"), Some(3)); + let mut g = Generations::default(); + let p = peer("a"); + let msg = |generation| Registration { + name: "key".into(), + generation, + }; + g.received_accept(p.clone(), msg(2)); + assert_eq!(g.outgoing_generation(&p, "key"), Some(2)); + g.received_leave(p.clone(), msg(3)); + assert_eq!(g.outgoing_generation(&p, "key"), None); + assert!(!g.received_accept(p.clone(), msg(2))); + assert_eq!(g.outgoing_generation(&p, "key"), None); + g.received_accept(p.clone(), msg(3)); + assert_eq!(g.outgoing_generation(&p, "key"), Some(3)); assert!(!g.received_leave(p.clone(), msg(2))); - let g: Generations = serde_json::from_str(&serde_json::to_string(&g).unwrap()).unwrap(); assert_eq!(g.outgoing_generation(&p, "key"), Some(3)); + let g: Generations = serde_json::from_str(&serde_json::to_string(&g).unwrap()).unwrap(); + assert_eq!(g.outgoing_generation(&p, "key"), Some(3)); } #[test] fn item_state_and_outbox_round_trip_through_sync_json() { let s = conflicted(); - assert_eq!(s, serde_json::from_str(&serde_json::to_string(&s).unwrap()).unwrap()); - let mut o = Outbox::default(); let p = peer("a"); let q = peer("b"); - o.enqueue(p.clone(), id(1)); o.enqueue(q.clone(), id(1)); o.ack(&p, &id(1), AckResult::Held); + assert_eq!( + s, + serde_json::from_str(&serde_json::to_string(&s).unwrap()).unwrap() + ); + let mut o = Outbox::default(); + let p = peer("a"); + let q = peer("b"); + o.enqueue(p.clone(), id(1)); + o.enqueue(q.clone(), id(1)); + o.ack(&p, &id(1), AckResult::Held); let mut restored: Outbox = serde_json::from_str(&serde_json::to_string(&o).unwrap()).unwrap(); - assert_eq!(restored.pending(&p).count(), 0); assert_eq!(restored.pending(&q).count(), 1); + assert_eq!(restored.pending(&p).count(), 0); + assert_eq!(restored.pending(&q).count(), 1); assert!(!restored.snapshot_releasable("key", v(1))); - restored.ack(&q, &id(1), AckResult::Applied); assert!(restored.snapshot_releasable("key", v(1))); + restored.ack(&q, &id(1), AckResult::Applied); + assert!(restored.snapshot_releasable("key", v(1))); } #[test] fn known_cache_deserialization_rejects_unbounded_or_ambiguous_bindings() { let mut s = state(); - for n in 2..260 { s.known.insert(v(n), VidRecord { fp: f(2), parents: vec![] }); } + for n in 2..260 { + s.known.insert( + v(n), + VidRecord { + fp: f(2), + parents: vec![], + }, + ); + } assert!(serde_json::from_str::(&serde_json::to_string(&s).unwrap()).is_err()); let mut json = serde_json::to_value(state()).unwrap(); - let known = json["known"].as_array_mut().unwrap(); known.push(known[0].clone()); + let known = json["known"].as_array_mut().unwrap(); + known.push(known[0].clone()); assert!(serde_json::from_value::(json).is_err()); } #[test] fn slot_budget_round_trip_retains_snapshot_pins() { let mut b = SlotBudget::new(0); - for n in 0..16 { b.reserve_snapshot(&format!("s{n}")); } + for n in 0..16 { + b.reserve_snapshot(&format!("s{n}")); + } let mut b: SlotBudget = serde_json::from_str(&serde_json::to_string(&b).unwrap()).unwrap(); - assert_eq!(b.reserve("checkpoint", SlotKind::Checkpoint), Reservation::Refused); + assert_eq!( + b.reserve("checkpoint", SlotKind::Checkpoint), + Reservation::Refused + ); } diff --git a/crates/kc-sync/tests/simulation.rs b/crates/kc-sync/tests/simulation.rs index cfc5928..e0afaad 100644 --- a/crates/kc-sync/tests/simulation.rs +++ b/crates/kc-sync/tests/simulation.rs @@ -1,12 +1,26 @@ //! Seeded in-memory transport and persistence adapter; production policy comes from kc-sync. -use std::collections::BTreeMap; use kc_sync::*; use rand::{Rng, SeedableRng, rngs::StdRng}; +use std::collections::BTreeMap; -fn peer(n: usize) -> PeerId { PeerId(format!("device-{n}")) } -fn id(i: &Incoming) -> ChangeId { ChangeId { name: "key".into(), generation: i.generation, new_vid: i.new_vid } } -fn fp(n: u64) -> Fp { let mut bytes = [0; 32]; bytes[..8].copy_from_slice(&n.to_be_bytes()); Fp(bytes) } -fn slot(v: Vid) -> String { format!("{v:?}") } +fn peer(n: usize) -> PeerId { + PeerId(format!("device-{n}")) +} +fn id(i: &Incoming) -> ChangeId { + ChangeId { + name: "key".into(), + generation: i.generation, + new_vid: i.new_vid, + } +} +fn fp(n: u64) -> Fp { + let mut bytes = [0; 32]; + bytes[..8].copy_from_slice(&n.to_be_bytes()); + Fp(bytes) +} +fn slot(v: Vid) -> String { + format!("{v:?}") +} struct Device { state: ItemState, @@ -21,9 +35,17 @@ struct Device { } impl Device { fn new() -> Self { - Self { state: ItemState::new(0, Vid([0; 16]), fp(0), vec![]), value: Some(fp(0)), - checkpoint: Checkpoint::default(), slots: SlotBudget::new(1024), held: BTreeMap::new(), - receipts: BTreeMap::new(), outbox: Outbox::default(), sent: BTreeMap::new(), generations: Generations::default() } + Self { + state: ItemState::new(0, Vid([0; 16]), fp(0), vec![]), + value: Some(fp(0)), + checkpoint: Checkpoint::default(), + slots: SlotBudget::new(1024), + held: BTreeMap::new(), + receipts: BTreeMap::new(), + outbox: Outbox::default(), + sent: BTreeMap::new(), + generations: Generations::default(), + } } // This adapter only executes Transition intents; it contains no independent sync decisions. @@ -31,50 +53,101 @@ impl Device { let before = self.value; let checkpoint_before = self.checkpoint.fingerprint(); match decision.transition { - Transition::Unchanged => {}, + Transition::Unchanged => {} Transition::Hold { .. } => { - assert!(matches!(self.slots.reserve(&slot(incoming.new_vid), SlotKind::Held), Reservation::Reserved { .. })); + assert!(matches!( + self.slots.reserve(&slot(incoming.new_vid), SlotKind::Held), + Reservation::Reserved { .. } + )); self.held.insert(incoming.new_vid, incoming.clone()); - }, + } Transition::Conflict { candidates } => { for vid in candidates.candidates.keys() { // A previously held slot is promoted by releasing its reservation first. - if self.slots.kind(&slot(*vid)) == Some(SlotKind::Held) { self.slots.release(&slot(*vid)); } - assert!(matches!(self.slots.reserve(&slot(*vid), SlotKind::ConflictCandidate), Reservation::Reserved { .. })); + if self.slots.kind(&slot(*vid)) == Some(SlotKind::Held) { + self.slots.release(&slot(*vid)); + } + assert!(matches!( + self.slots.reserve(&slot(*vid), SlotKind::ConflictCandidate), + Reservation::Reserved { .. } + )); } self.state.conflict = Some(candidates); - }, - Transition::Advance { head, lineage, write_value, clear_conflict } => { + } + Transition::Advance { + head, + lineage, + write_value, + clear_conflict, + } => { if write_value { - assert!(matches!(self.slots.prepare_overwrite("checkpoint", "held-fallback"), OverwriteCapacity::Ready { .. })); + assert!(matches!( + self.slots.prepare_overwrite("checkpoint", "held-fallback"), + OverwriteCapacity::Ready { .. } + )); self.checkpoint.before_remote_overwrite(self.value.unwrap()); self.value = incoming.value_fp; } self.state.head = head; self.state.lineage = lineage; - assert!(self.state.remember(incoming.new_vid, VidRecord { fp: incoming.value_fp.unwrap(), parents: incoming.parents.clone() })); - if clear_conflict { self.state.conflict = None; } - }, + assert!(self.state.remember( + incoming.new_vid, + VidRecord { + fp: incoming.value_fp.unwrap(), + parents: incoming.parents.clone() + } + )); + if clear_conflict { + self.state.conflict = None; + } + } Transition::Retire => { // §2.5 only changes registration metadata. There is deliberately no value deletion. self.state.generation += 1; - }, + } + } + assert!( + before.is_some() && self.value.is_some(), + "remote event deleted a value" + ); + if checkpoint_before.is_some() { + assert_eq!( + self.checkpoint.fingerprint(), + checkpoint_before, + "remote event replaced a checkpoint" + ); } - assert!(before.is_some() && self.value.is_some(), "remote event deleted a value"); - if checkpoint_before.is_some() { assert_eq!(self.checkpoint.fingerprint(), checkpoint_before, "remote event replaced a checkpoint"); } } fn receive(&mut self, from: usize, incoming: &Incoming) -> AckResult { - if let Some(ack) = self.receipts.get(&(from, incoming.new_vid)) { return *ack; } - let d = decide(&self.state, self.value.unwrap(), incoming, false, None, true); + if let Some(ack) = self.receipts.get(&(from, incoming.new_vid)) { + return *ack; + } + let d = decide( + &self.state, + self.value.unwrap(), + incoming, + false, + None, + true, + ); let ack = d.ack; self.commit(incoming, d); - if ack.is_final() { self.receipts.insert((from, incoming.new_vid), ack); } + if ack.is_final() { + self.receipts.insert((from, incoming.new_vid), ack); + } ack } fn review(&mut self, rng: &mut StdRng, stats: &mut Stats) { - let Some(vid) = self.held.keys().nth(rng.random_range(0..self.held.len().max(1))).copied() else { return; }; + let Some(vid) = self + .held + .keys() + .nth(rng.random_range(0..self.held.len().max(1))) + .copied() + else { + return; + }; let incoming = self.held.remove(&vid).unwrap(); self.slots.release(&slot(vid)); let old_checkpoint = self.checkpoint.fingerprint(); @@ -82,24 +155,60 @@ impl Device { stats.accepted += 1; // The simulated human is the only caller providing the test approval marker. let approval = VerifiedApproval::for_tests(); - let d = decide(&self.state, self.value.unwrap(), &incoming, false, Some(&approval), true); + let d = decide( + &self.state, + self.value.unwrap(), + &incoming, + false, + Some(&approval), + true, + ); self.commit(&incoming, d); - } else { stats.rejected += 1; } + } else { + stats.rejected += 1; + } // Human review does not implicitly confirm a new checkpoint baseline. - if old_checkpoint.is_some() { assert_eq!(old_checkpoint, self.checkpoint.fingerprint()); } + if old_checkpoint.is_some() { + assert_eq!(old_checkpoint, self.checkpoint.fingerprint()); + } } } #[derive(Clone)] enum Message { - Change { from: usize, to: usize, incoming: Incoming }, - Ack { from: usize, to: usize, change: ChangeId, result: AckResult }, + Change { + from: usize, + to: usize, + incoming: Incoming, + }, + Ack { + from: usize, + to: usize, + change: ChangeId, + result: AckResult, + }, } #[derive(Clone)] -struct Envelope { due: u64, message: Message } +struct Envelope { + due: u64, + message: Message, +} #[derive(Default)] -struct Stats { dropped: usize, duplicated: usize, reordered: usize, delayed: usize, accepted: usize, rejected: usize, retired: usize } -struct Created { owner: usize, vid: Vid, fp: Fp, sequence: u64 } +struct Stats { + dropped: usize, + duplicated: usize, + reordered: usize, + delayed: usize, + accepted: usize, + rejected: usize, + retired: usize, +} +struct Created { + owner: usize, + vid: Vid, + fp: Fp, + sequence: u64, +} struct World { rng: StdRng, @@ -116,44 +225,101 @@ impl World { let mut devices: Vec<_> = (0..count).map(|_| Device::new()).collect(); for device in &mut devices { for target in 0..count { - device.generations.received_accept(peer(target), Registration { name: "key".into(), generation: 0 }); + device.generations.received_accept( + peer(target), + Registration { + name: "key".into(), + generation: 0, + }, + ); } } - Self { rng: StdRng::seed_from_u64(seed), devices, - queue: vec![], created: vec![], tick: 0, sequence: 0, stats: Stats::default() } + Self { + rng: StdRng::seed_from_u64(seed), + devices, + queue: vec![], + created: vec![], + tick: 0, + sequence: 0, + stats: Stats::default(), + } } fn schedule(&mut self, message: Message) { - let delay = self.rng.random_range(1..=12); self.stats.delayed += usize::from(delay > 1); - self.queue.push(Envelope { due: self.tick + delay, message }); + let delay = self.rng.random_range(1..=12); + self.stats.delayed += usize::from(delay > 1); + self.queue.push(Envelope { + due: self.tick + delay, + message, + }); } fn edit(&mut self, owner: usize) { self.sequence += 1; - let vid = Vid(self.rng.random()); let value = fp(self.sequence); + let vid = Vid(self.rng.random()); + let value = fp(self.sequence); assert!(!self.created.iter().any(|c| c.vid == vid)); let targets = self.devices.len(); let device = &mut self.devices[owner]; let parents = vec![device.state.head]; device.state.head = vid; device.state.lineage = device.state.lineage.clone().with_head(vid); - device.state.remember(vid, VidRecord { fp: value, parents: parents.clone() }); + device.state.remember( + vid, + VidRecord { + fp: value, + parents: parents.clone(), + }, + ); // Local edits cannot silently resolve existing conflicts: retain their new head as a candidate. if let Some(c) = &mut device.state.conflict { - c.candidates.insert(vid, VidRecord { fp: value, parents: parents.clone() }); + c.candidates.insert( + vid, + VidRecord { + fp: value, + parents: parents.clone(), + }, + ); } device.value = Some(value); - let incoming = Incoming { generation: 0, new_vid: vid, parents, - lineage: device.state.lineage.clone(), value_fp: Some(value), retire: false }; + let incoming = Incoming { + generation: 0, + new_vid: vid, + parents, + lineage: device.state.lineage.clone(), + value_fp: Some(value), + retire: false, + }; device.sent.insert(vid, incoming.clone()); - assert!(matches!(device.slots.reserve_snapshot(&format!("send-{}", slot(vid))), Reservation::Reserved { .. })); + assert!(matches!( + device + .slots + .reserve_snapshot(&format!("send-{}", slot(vid))), + Reservation::Reserved { .. } + )); let mut messages = vec![]; - for target in 0..targets { if target != owner { - let mut outgoing = incoming.clone(); - outgoing.generation = device.generations.outgoing_generation(&peer(target), "key").unwrap(); - device.outbox.enqueue(peer(target), id(&outgoing)); - messages.push(Message::Change { from: owner, to: target, incoming: outgoing }); - } } - self.created.push(Created { owner, vid, fp: value, sequence: self.sequence }); - for message in messages { self.schedule(message); } + for target in 0..targets { + if target != owner { + let mut outgoing = incoming.clone(); + outgoing.generation = device + .generations + .outgoing_generation(&peer(target), "key") + .unwrap(); + device.outbox.enqueue(peer(target), id(&outgoing)); + messages.push(Message::Change { + from: owner, + to: target, + incoming: outgoing, + }); + } + } + self.created.push(Created { + owner, + vid, + fp: value, + sequence: self.sequence, + }); + for message in messages { + self.schedule(message); + } } fn retry_pending(&mut self) { let mut retry = vec![]; @@ -166,52 +332,106 @@ impl World { } } } - for message in retry { self.schedule(message); } + for message in retry { + self.schedule(message); + } } fn deliver(&mut self, lossy: bool) -> bool { - let eligible: Vec<_> = self.queue.iter().enumerate().filter(|(_, e)| e.due <= self.tick).map(|(n, _)| n).collect(); - if eligible.is_empty() { return false; } + let eligible: Vec<_> = self + .queue + .iter() + .enumerate() + .filter(|(_, e)| e.due <= self.tick) + .map(|(n, _)| n) + .collect(); + if eligible.is_empty() { + return false; + } let index = eligible[self.rng.random_range(0..eligible.len())]; self.stats.reordered += usize::from(index != 0); let envelope = self.queue.remove(index); - if lossy && self.rng.random_bool(0.20) { self.stats.dropped += 1; return true; } - if lossy && self.rng.random_bool(0.15) { self.stats.duplicated += 1; self.schedule(envelope.message.clone()); } + if lossy && self.rng.random_bool(0.20) { + self.stats.dropped += 1; + return true; + } + if lossy && self.rng.random_bool(0.15) { + self.stats.duplicated += 1; + self.schedule(envelope.message.clone()); + } match envelope.message { Message::Change { from, to, incoming } => { let result = self.devices[to].receive(from, &incoming); - self.schedule(Message::Ack { from: to, to: from, change: id(&incoming), result }); - }, - Message::Ack { from, to, change, result } => { + self.schedule(Message::Ack { + from: to, + to: from, + change: id(&incoming), + result, + }); + } + Message::Ack { + from, + to, + change, + result, + } => { let d = &mut self.devices[to]; d.outbox.ack(&peer(from), &change, result); - let release: Vec<_> = d.sent.keys().copied().filter(|vid| d.outbox.snapshot_releasable("key", *vid)).collect(); + let release: Vec<_> = d + .sent + .keys() + .copied() + .filter(|vid| d.outbox.snapshot_releasable("key", *vid)) + .collect(); for vid in release { assert!(d.outbox.release_snapshot("key", vid)); d.slots.release(&format!("send-{}", slot(vid))); } - }, + } } true } fn assert_preserved(&self, seed: u64) { for c in &self.created { - let superseded_locally = self.created.iter().any(|later| later.owner == c.owner && later.sequence > c.sequence); - let preserved = self.devices.iter().any(|d| d.value == Some(c.fp) - || d.held.values().any(|h| h.value_fp == Some(c.fp)) - || d.state.conflict.as_ref().is_some_and(|set| set.candidates.values().any(|r| r.fp == c.fp))); - assert!(superseded_locally || preserved, "seed {seed}: lost local value {:?} from {}", c.vid, c.owner); + let superseded_locally = self + .created + .iter() + .any(|later| later.owner == c.owner && later.sequence > c.sequence); + let preserved = self.devices.iter().any(|d| { + d.value == Some(c.fp) + || d.held.values().any(|h| h.value_fp == Some(c.fp)) + || d.state + .conflict + .as_ref() + .is_some_and(|set| set.candidates.values().any(|r| r.fp == c.fp)) + }); + assert!( + superseded_locally || preserved, + "seed {seed}: lost local value {:?} from {}", + c.vid, + c.owner + ); + } + for d in &self.devices { + assert!(d.value.is_some()); } - for d in &self.devices { assert!(d.value.is_some()); } } fn quiesce(&mut self) { self.retry_pending(); for _ in 0..20000 { self.tick += 1; while self.deliver(false) {} - for d in &mut self.devices { d.review(&mut self.rng, &mut self.stats); } + for d in &mut self.devices { + d.review(&mut self.rng, &mut self.stats); + } if self.queue.is_empty() { - let pending = self.devices.iter().any(|d| (0..self.devices.len()).any(|p| d.outbox.pending(&peer(p)).next().is_some())); - if pending { self.retry_pending(); } else { return; } + let pending = self.devices.iter().any(|d| { + (0..self.devices.len()).any(|p| d.outbox.pending(&peer(p)).next().is_some()) + }); + if pending { + self.retry_pending(); + } else { + return; + } } } panic!("transport did not quiesce"); @@ -226,66 +446,129 @@ fn seeded_lossy_multi_device_simulation_256_seeds() { // An initial causal edit exercises genuine Phase-1 holds and human accept/reject. w.edit(0); for _ in 0..30 { - w.tick += 1; w.deliver(true); - for d in &mut w.devices { d.review(&mut w.rng, &mut w.stats); } + w.tick += 1; + w.deliver(true); + for d in &mut w.devices { + d.review(&mut w.rng, &mut w.stats); + } w.assert_preserved(seed); } w.quiesce(); // Retire is delivered through the same decision path and changes registration, never value. let d = &mut w.devices[1]; let before = d.value; - let retire = Incoming { generation: 0, new_vid: Vid(w.rng.random()), parents: vec![d.state.head], - lineage: d.state.lineage.clone(), value_fp: None, retire: true }; + let retire = Incoming { + generation: 0, + new_vid: Vid(w.rng.random()), + parents: vec![d.state.head], + lineage: d.state.lineage.clone(), + value_fp: None, + retire: true, + }; assert_eq!(d.receive(0, &retire), AckResult::Held); - d.held.remove(&retire.new_vid); d.slots.release(&slot(retire.new_vid)); + d.held.remove(&retire.new_vid); + d.slots.release(&slot(retire.new_vid)); let token = VerifiedApproval::for_tests(); - let decision = decide(&d.state, d.value.unwrap(), &retire, false, Some(&token), true); - assert_eq!(decision.transition, Transition::Retire); d.commit(&retire, decision); - assert_eq!(before, d.value); w.stats.retired += 1; + let decision = decide( + &d.state, + d.value.unwrap(), + &retire, + false, + Some(&token), + true, + ); + assert_eq!(decision.transition, Transition::Retire); + d.commit(&retire, decision); + assert_eq!(before, d.value); + w.stats.retired += 1; // A fresh human registration exchange reinstates the receiver-owned generation. - let mut generations = Generations::default(); generations.rm("key").unwrap(); - let accept = generations.accept("key", peer(0)); assert_eq!(accept.generation, d.state.generation); + let mut generations = Generations::default(); + generations.rm("key").unwrap(); + let accept = generations.accept("key", peer(0)); + assert_eq!(accept.generation, d.state.generation); // Every sender records the receiver's new Accept; generations never move backwards. - for device in &mut w.devices { device.generations.received_accept(peer(1), accept.clone()); } + for device in &mut w.devices { + device.generations.received_accept(peer(1), accept.clone()); + } // Every device makes independent local edits before network delivery; then edits interleave // with transport. This creates true concurrent branches rather than serial overwrite tests. for owner in 0..w.devices.len() { - for _ in 0..w.rng.random_range(1..=4) { w.edit(owner); } + for _ in 0..w.rng.random_range(1..=4) { + w.edit(owner); + } } for step in 0..120 { w.tick += 1; match w.rng.random_range(0..10) { - 0..=1 => { let owner = w.rng.random_range(0..w.devices.len()); w.edit(owner); }, - 2 => { let owner = w.rng.random_range(0..w.devices.len()); w.devices[owner].review(&mut w.rng, &mut w.stats); }, + 0..=1 => { + let owner = w.rng.random_range(0..w.devices.len()); + w.edit(owner); + } + 2 => { + let owner = w.rng.random_range(0..w.devices.len()); + w.devices[owner].review(&mut w.rng, &mut w.stats); + } 3 => { let owner = w.rng.random_range(0..w.devices.len()); - let d = &mut w.devices[owner]; d.checkpoint.human_confirm(d.value.unwrap()); + let d = &mut w.devices[owner]; + d.checkpoint.human_confirm(d.value.unwrap()); assert_eq!(d.checkpoint.fingerprint(), d.value); - }, - _ => { w.deliver(true); }, + } + _ => { + w.deliver(true); + } + } + if step % 23 == 0 { + w.retry_pending(); } - if step % 23 == 0 { w.retry_pending(); } w.assert_preserved(seed); } - w.quiesce(); w.assert_preserved(seed); + w.quiesce(); + w.assert_preserved(seed); for (a_index, a) in w.devices.iter().enumerate() { assert!(a.held.is_empty()); for (b_index, b) in w.devices.iter().enumerate().skip(a_index + 1) { let equal = a.state.head == b.state.head && a.value == b.value; - let conflict = a.state.conflict.as_ref().is_some_and(|c| c.candidates.contains_key(&b.state.head)) - || b.state.conflict.as_ref().is_some_and(|c| c.candidates.contains_key(&a.state.head)); - assert!(equal || conflict, "seed {seed}: devices {a_index}/{b_index} silently diverged"); + let conflict = a + .state + .conflict + .as_ref() + .is_some_and(|c| c.candidates.contains_key(&b.state.head)) + || b.state + .conflict + .as_ref() + .is_some_and(|c| c.candidates.contains_key(&a.state.head)); + assert!( + equal || conflict, + "seed {seed}: devices {a_index}/{b_index} silently diverged" + ); + } + for p in 0..w.devices.len() { + assert_eq!(a.outbox.pending(&peer(p)).count(), 0); } - for p in 0..w.devices.len() { assert_eq!(a.outbox.pending(&peer(p)).count(), 0); } } assert!(w.queue.is_empty()); - totals.dropped += w.stats.dropped; totals.duplicated += w.stats.duplicated; - totals.reordered += w.stats.reordered; totals.delayed += w.stats.delayed; - totals.accepted += w.stats.accepted; totals.rejected += w.stats.rejected; totals.retired += w.stats.retired; + totals.dropped += w.stats.dropped; + totals.duplicated += w.stats.duplicated; + totals.reordered += w.stats.reordered; + totals.delayed += w.stats.delayed; + totals.accepted += w.stats.accepted; + totals.rejected += w.stats.rejected; + totals.retired += w.stats.retired; } - assert!(totals.dropped > 0 && totals.duplicated > 0 && totals.reordered > 0 && totals.delayed > 0); + assert!( + totals.dropped > 0 && totals.duplicated > 0 && totals.reordered > 0 && totals.delayed > 0 + ); assert!(totals.accepted > 0 && totals.rejected > 0 && totals.retired == 256); // Keep actual coverage visible when this test is run with --nocapture. - println!("256 seeds: dropped={}, duplicated={}, reordered={}, delayed={}, accepted={}, rejected={}, retired={}", - totals.dropped, totals.duplicated, totals.reordered, totals.delayed, totals.accepted, totals.rejected, totals.retired); + println!( + "256 seeds: dropped={}, duplicated={}, reordered={}, delayed={}, accepted={}, rejected={}, retired={}", + totals.dropped, + totals.duplicated, + totals.reordered, + totals.delayed, + totals.accepted, + totals.rejected, + totals.retired + ); } From 8ccba8a87dd60a228bd1248f1e5ed2faaa64c591 Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Tue, 13 Oct 2026 16:28:20 +0900 Subject: [PATCH 12/24] =?UTF-8?q?feat(kc-proto):=20Offer=20=EC=97=90=20?= =?UTF-8?q?=EB=B0=9B=EB=8A=94=20=EC=AA=BD=20=EB=93=B1=EB=A1=9D=20=EC=84=B8?= =?UTF-8?q?=EB=8C=80(known=5Fgeneration)=EB=A5=BC=20=EC=8B=A3=EB=8A=94?= =?UTF-8?q?=EB=8B=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit sync rm 전에 보낸 늦은 제안을 받는 쪽이 세대로 걸러낸다(설계 §2.1). Co-Authored-By: Claude Opus 5.5 --- crates/kc-proto/src/sync.rs | 4 ++++ crates/kc-proto/tests/inbox_v2/fixtures/offer.body.hex | 2 +- crates/kc-proto/tests/inbox_v2/fixtures/offer.envelope.hex | 2 +- crates/kc-proto/tests/inbox_v2/mod.rs | 2 ++ docs/PROTOCOL.md | 2 +- 5 files changed, 9 insertions(+), 3 deletions(-) diff --git a/crates/kc-proto/src/sync.rs b/crates/kc-proto/src/sync.rs index 05dd0fd..c5ffda9 100644 --- a/crates/kc-proto/src/sync.rs +++ b/crates/kc-proto/src/sync.rs @@ -111,6 +111,10 @@ pub enum SyncMsg { }, Offer { name: ItemName, + /// The receiver's registration generation for `name` as the sender last learned it + /// from an `Accept` or `Leave` (0 = never). The receiver ignores an offer whose + /// value is below its current generation: it was sent before a `sync rm` (§2.1). + known_generation: u64, vid: Vid, lineage: Vec, kind: ItemKind, diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/offer.body.hex b/crates/kc-proto/tests/inbox_v2/fixtures/offer.body.hex index 53b8aaa..934114b 100644 --- a/crates/kc-proto/tests/inbox_v2/fixtures/offer.body.hex +++ b/crates/kc-proto/tests/inbox_v2/fixtures/offer.body.hex @@ -1 +1 @@ -01010a636f6e6669672e656e765555555555555555555555555555555501666666666666666666666666666666660107544553543d310a +01010a636f6e6669672e656e76035555555555555555555555555555555501666666666666666666666666666666660107544553543d310a diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/offer.envelope.hex b/crates/kc-proto/tests/inbox_v2/fixtures/offer.envelope.hex index 149127a..f224ddb 100644 --- a/crates/kc-proto/tests/inbox_v2/fixtures/offer.envelope.hex +++ b/crates/kc-proto/tests/inbox_v2/fixtures/offer.envelope.hex @@ -1 +1 @@ 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 diff --git a/crates/kc-proto/tests/inbox_v2/mod.rs b/crates/kc-proto/tests/inbox_v2/mod.rs index 08c210a..e4f08e3 100644 --- a/crates/kc-proto/tests/inbox_v2/mod.rs +++ b/crates/kc-proto/tests/inbox_v2/mod.rs @@ -69,6 +69,7 @@ fn cases() -> Vec<(&'static str, Body)> { "offer", Body::Sync(SyncMsg::Offer { name: name("config.env"), + known_generation: 3, vid: Vid([0x55; 16]), lineage: vec![Vid([0x66; 16])], kind: ItemKind::File, @@ -473,6 +474,7 @@ fn v2_size_and_envelope_checks() { let (alice, bob) = keys(); let body = Body::Sync(SyncMsg::Offer { name: name("large"), + known_generation: 0, vid: Vid([1; 16]), lineage: vec![], kind: ItemKind::File, diff --git a/docs/PROTOCOL.md b/docs/PROTOCOL.md index c8e6d73..6df3bf4 100644 --- a/docs/PROTOCOL.md +++ b/docs/PROTOCOL.md @@ -182,7 +182,7 @@ Change { name: ItemName, generation: u64, new_vid: Vid, parents: Vec, AckResult = Applied | Held | Conflict | StaleGeneration | DeferredCapacity | Rejected DigestEntry { name: ItemName, generation: u64, head: Vid } SyncMsg = Hello { features: Vec, is_reply: bool } - | Offer { name: ItemName, vid: Vid, lineage: Vec, kind: ItemKind, value: bytes } + | Offer { name: ItemName, known_generation: u64, vid: Vid, lineage: Vec, kind: ItemKind, value: bytes } | Accept { name: ItemName, generation: u64 } | Leave { name: ItemName, generation: u64 } | Changes { changes: Vec } From c41a25767a93974a987afe6000d3fdd886d21f62 Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Tue, 13 Oct 2026 16:40:58 +0900 Subject: [PATCH 13/24] =?UTF-8?q?fix(sync):=20=EB=A6=AC=EB=B7=B0=20?= =?UTF-8?q?=EB=B0=98=EC=98=81=20=E2=80=94=20=EC=88=98=EB=A0=B4=EC=9D=80=20?= =?UTF-8?q?=EB=B3=B4=EB=82=B8=20=EC=AA=BD=20lineage=20=EB=A5=BC=20?= =?UTF-8?q?=EC=88=98=EC=9E=85=ED=95=98=EC=A7=80=20=EC=95=8A=EB=8A=94?= =?UTF-8?q?=EB=8B=A4=20=EC=99=B8=207=EA=B1=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 수렴(6행)은 두 head 만 기록한다. 같은 값을 보낸 뚫린 기기가 다른 기기의 미래 vid 를 lineage 에 끼워 넣어 그 변경을 '낡음'으로 만드는 공격을 막는다. - 승인된 resolve 는 parents 를 lineage 에 넣는다. 승인됐지만 head 가 맞지 않는 Retire 는 충돌이 아니라 보류. - SlotBudget::set_items·prepare_hold, 피어 하나만 범위에서 빼는 Generations API. - kc-proto: Offer.lineage ≤64, Change.parents ≤65, Digest·Ack 이름 중복 거부. - Windows Hello 는 콘솔 창 핸들로 RequestVerificationForWindowAsync 를 쓴다. Co-Authored-By: Claude Opus 5.5 --- crates/kc-cli/Cargo.toml | 2 +- crates/kc-cli/src/local_auth/windows.rs | 32 +++- crates/kc-proto/src/sync.rs | 87 +++++++++-- crates/kc-proto/tests/inbox_v2/mod.rs | 92 ++++++++++++ crates/kc-sync/src/decision.rs | 27 +++- crates/kc-sync/src/generation.rs | 15 ++ crates/kc-sync/src/slots.rs | 27 +++- crates/kc-sync/src/state.rs | 9 ++ crates/kc-sync/tests/policy.rs | 190 +++++++++++++++++++++--- docs/design/sync.md | 5 +- 10 files changed, 432 insertions(+), 54 deletions(-) diff --git a/crates/kc-cli/Cargo.toml b/crates/kc-cli/Cargo.toml index c675732..af14237 100644 --- a/crates/kc-cli/Cargo.toml +++ b/crates/kc-cli/Cargo.toml @@ -57,7 +57,7 @@ objc2-foundation = { version = "0.3.2", default-features = false, features = ["s objc2-local-authentication = { version = "0.3.2", default-features = false, features = ["std", "LAContext", "LAError", "block2"] } [target.'cfg(windows)'.dependencies] -windows = { version = "0.58.0", default-features = false, features = ["Security_Credentials_UI", "Foundation"] } +windows = { version = "0.58.0", default-features = false, features = ["Security_Credentials_UI", "Foundation", "Win32_System_WinRT", "Win32_UI_WindowsAndMessaging", "Win32_System_Console", "Win32_Foundation"] } [dev-dependencies] kc-proto = { workspace = true, features = ["test-util"] } diff --git a/crates/kc-cli/src/local_auth/windows.rs b/crates/kc-cli/src/local_auth/windows.rs index d58f50c..393acf0 100644 --- a/crates/kc-cli/src/local_auth/windows.rs +++ b/crates/kc-cli/src/local_auth/windows.rs @@ -1,18 +1,42 @@ +#![allow(unsafe_code)] // Window handles and WinRT interop require Win32 FFI. + +use windows::Foundation::IAsyncOperation; use windows::Security::Credentials::UI::{UserConsentVerificationResult, UserConsentVerifier}; -use windows::core::HSTRING; +use windows::Win32::System::Console::GetConsoleWindow; +use windows::Win32::System::WinRT::IUserConsentVerifierInterop; +use windows::Win32::UI::WindowsAndMessaging::GetForegroundWindow; +use windows::core::{HSTRING, factory}; use super::LocalAuthOutcome; pub(super) fn confirm(reason: &str) -> LocalAuthOutcome { // Request a new verification every time; never retain a previous result. - match UserConsentVerifier::RequestVerificationAsync(&HSTRING::from(reason)) - .and_then(|request| request.get()) - { + match request_verification(reason) { Ok(result) => outcome(result), Err(error) => LocalAuthOutcome::Unavailable(format!("Windows Hello: {error}")), } } +fn request_verification(reason: &str) -> windows::core::Result { + let verifier = factory::()?; + // SAFETY: These calls take no pointers; the returned handles are borrowed + // for the OS verification UI and are never freed or dereferenced here. + let hwnd = unsafe { + let console = GetConsoleWindow(); + if console.0.is_null() { + GetForegroundWindow() + } else { + console + } + }; + // SAFETY: The OS-provided window handle and owned HSTRING remain valid + // for the call; the requested interface is the documented result type. + let request: IAsyncOperation = unsafe { + verifier.RequestVerificationForWindowAsync(hwnd, &HSTRING::from(reason))? + }; + request.get() +} + fn outcome(result: UserConsentVerificationResult) -> LocalAuthOutcome { match result { UserConsentVerificationResult::Verified => LocalAuthOutcome::Confirmed, diff --git a/crates/kc-proto/src/sync.rs b/crates/kc-proto/src/sync.rs index c5ffda9..c3cd188 100644 --- a/crates/kc-proto/src/sync.rs +++ b/crates/kc-proto/src/sync.rs @@ -14,6 +14,7 @@ use crate::rng; use crate::secret::SecretBytes; pub const MAX_LINEAGE: usize = 64; +pub const MAX_PARENTS: usize = 65; /// A random version identifier: raw 16 bytes in postcard, hex in JSON. #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -70,6 +71,7 @@ pub struct Change { pub name: ItemName, pub generation: u64, pub new_vid: Vid, + #[serde(deserialize_with = "deserialize_parents")] pub parents: Vec, #[serde(deserialize_with = "deserialize_lineage")] pub lineage: Vec, @@ -79,7 +81,7 @@ pub struct Change { impl Change { pub fn validate(&self) -> Result<(), InboxError> { - if self.lineage.len() > MAX_LINEAGE { + if self.lineage.len() > MAX_LINEAGE || self.parents.len() > MAX_PARENTS { return Err(InboxError::Malformed); } Ok(()) @@ -116,6 +118,7 @@ pub enum SyncMsg { /// value is below its current generation: it was sent before a `sync rm` (§2.1). known_generation: u64, vid: Vid, + #[serde(deserialize_with = "deserialize_lineage")] lineage: Vec, kind: ItemKind, value: SecretBytes, @@ -132,9 +135,11 @@ pub enum SyncMsg { changes: Vec, }, Ack { + #[serde(deserialize_with = "deserialize_ack_results")] results: Vec<(ChangeId, AckResult)>, }, Digest { + #[serde(deserialize_with = "deserialize_digest_entries")] entries: Vec, }, Approvals { @@ -145,40 +150,90 @@ pub enum SyncMsg { impl SyncMsg { /// Checks in-memory messages too, before sealing or after opening. pub fn validate(&self) -> Result<(), InboxError> { - if let Self::Changes { changes } = self { - let mut names = HashSet::new(); - for change in changes { - change.validate()?; - if !names.insert(&change.name) { + match self { + Self::Offer { lineage, .. } if lineage.len() > MAX_LINEAGE => { + return Err(InboxError::Malformed); + } + Self::Changes { changes } => { + let mut names = HashSet::new(); + for change in changes { + change.validate()?; + if !names.insert(&change.name) { + return Err(InboxError::Malformed); + } + } + } + Self::Digest { entries } => { + let mut names = HashSet::new(); + if entries.iter().any(|entry| !names.insert(&entry.name)) { + return Err(InboxError::Malformed); + } + } + Self::Ack { results } => { + let mut ids = HashSet::new(); + if results.iter().any(|(id, _)| !ids.insert(id)) { return Err(InboxError::Malformed); } } + _ => {} } Ok(()) } } -// Bound allocation as well as accepting at most 64 decoded lineage entries. +fn deserialize_ack_results<'de, D: Deserializer<'de>>( + deserializer: D, +) -> Result, D::Error> { + let results = Vec::<(ChangeId, AckResult)>::deserialize(deserializer)?; + let mut ids = HashSet::new(); + if results.iter().any(|(id, _)| !ids.insert(id)) { + return Err(serde::de::Error::custom("duplicate ACK change_id")); + } + Ok(results) +} + +fn deserialize_digest_entries<'de, D: Deserializer<'de>>( + deserializer: D, +) -> Result, D::Error> { + let entries = Vec::::deserialize(deserializer)?; + let mut names = HashSet::new(); + if entries.iter().any(|entry| !names.insert(&entry.name)) { + return Err(serde::de::Error::custom("duplicate digest name")); + } + Ok(entries) +} + +// Bound allocation as well as the decoded number of version identifiers. fn deserialize_lineage<'de, D: Deserializer<'de>>(deserializer: D) -> Result, D::Error> { - struct Lineage; - impl<'de> serde::de::Visitor<'de> for Lineage { + deserialize_vids::(deserializer) +} + +fn deserialize_parents<'de, D: Deserializer<'de>>(deserializer: D) -> Result, D::Error> { + deserialize_vids::(deserializer) +} + +fn deserialize_vids<'de, D: Deserializer<'de>, const MAX: usize>( + deserializer: D, +) -> Result, D::Error> { + struct Vids; + impl<'de, const MAX: usize> serde::de::Visitor<'de> for Vids { type Value = Vec; fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.write_str("at most 64 version identifiers") + write!(f, "at most {MAX} version identifiers") } fn visit_seq>(self, mut seq: A) -> Result, A::Error> { - if seq.size_hint().is_some_and(|n| n > MAX_LINEAGE) { - return Err(serde::de::Error::custom("lineage exceeds 64 entries")); + if seq.size_hint().is_some_and(|n| n > MAX) { + return Err(serde::de::Error::custom("too many version identifiers")); } - let mut out = Vec::with_capacity(seq.size_hint().unwrap_or(0).min(MAX_LINEAGE)); + let mut out = Vec::with_capacity(seq.size_hint().unwrap_or(0).min(MAX)); while let Some(vid) = seq.next_element()? { - if out.len() == MAX_LINEAGE { - return Err(serde::de::Error::custom("lineage exceeds 64 entries")); + if out.len() == MAX { + return Err(serde::de::Error::custom("too many version identifiers")); } out.push(vid); } Ok(out) } } - deserializer.deserialize_seq(Lineage) + deserializer.deserialize_seq(Vids::) } diff --git a/crates/kc-proto/tests/inbox_v2/mod.rs b/crates/kc-proto/tests/inbox_v2/mod.rs index e4f08e3..7304c1d 100644 --- a/crates/kc-proto/tests/inbox_v2/mod.rs +++ b/crates/kc-proto/tests/inbox_v2/mod.rs @@ -539,3 +539,95 @@ fn vid_serde_and_secret_debug() { assert!(!debug.contains("TEST=1")); } } + +fn assert_sync_validation(msg: SyncMsg, valid: bool) { + let bytes = postcard::to_allocvec(&msg).unwrap(); + assert_eq!(postcard::from_bytes::(&bytes).is_ok(), valid); + let json = serde_json::to_string(&msg).unwrap(); + assert_eq!(serde_json::from_str::(&json).is_ok(), valid); + assert_eq!(msg.validate().is_ok(), valid); + if !valid { + assert_eq!(msg.validate().unwrap_err(), InboxError::Malformed); + } + let body = Body::Sync(msg); + let opened = bob_opens(&seal_plain(&plain(body.clone()), INFO_PREFIX_V2), NOW); + let (alice, bob) = keys(); + let sealed = seal_v2(&alice, bob.public(), &body, TTL, NOW); + if valid { + assert!(opened.is_ok()); + assert!(sealed.is_ok()); + } else { + assert_eq!(opened.unwrap_err(), InboxError::Malformed); + assert_eq!(sealed.unwrap_err(), InboxError::Malformed); + } +} + +#[test] +fn offer_lineage_limit_on_decode_validate_seal_and_open() { + for n in [0, 64, 65] { + let msg = SyncMsg::Offer { + name: name("token"), + known_generation: 0, + vid: Vid([1; 16]), + lineage: vec![Vid([7; 16]); n], + kind: ItemKind::Text, + value: SecretBytes::from_slice(b"test-secret"), + }; + let bytes = postcard::to_allocvec(&msg).unwrap(); + assert_eq!(postcard::from_bytes::(&bytes).is_ok(), n <= 64); + let json = serde_json::to_string(&msg).unwrap(); + assert_eq!(serde_json::from_str::(&json).is_ok(), n <= 64); + assert_sync_validation(msg, n <= 64); + } +} + +#[test] +fn change_parents_limit_on_decode_validate_seal_and_open() { + for n in [0, 64, 65, 66] { + let mut c = change(); + c.parents = vec![Vid([7; 16]); n]; + let bytes = postcard::to_allocvec(&c).unwrap(); + assert_eq!(postcard::from_bytes::(&bytes).is_ok(), n <= 65); + let json = serde_json::to_string(&c).unwrap(); + assert_eq!(serde_json::from_str::(&json).is_ok(), n <= 65); + assert_eq!(c.validate().is_ok(), n <= 65); + assert_sync_validation(SyncMsg::Changes { changes: vec![c] }, n <= 65); + } +} + +#[test] +fn duplicate_digest_names_are_malformed() { + let entry = DigestEntry { name: name("token"), generation: 1, head: Vid([1; 16]) }; + for same_metadata in [true, false] { + let mut other = entry.clone(); + if !same_metadata { + other.generation += 1; + other.head = Vid([2; 16]); + } + assert_sync_validation(SyncMsg::Digest { entries: vec![entry.clone(), other] }, false); + } + let mut other = entry.clone(); + other.name = name("other"); + assert_sync_validation(SyncMsg::Digest { entries: vec![entry, other] }, true); +} + +#[test] +fn duplicate_ack_change_ids_are_malformed() { + let id = ChangeId { name: name("token"), generation: 1, new_vid: Vid([1; 16]) }; + for result in [AckResult::Applied, AckResult::Rejected] { + assert_sync_validation(SyncMsg::Ack { + results: vec![(id.clone(), AckResult::Applied), (id.clone(), result)], + }, false); + } + for field in 0..3 { + let mut other = id.clone(); + match field { + 0 => other.name = name("other"), + 1 => other.generation += 1, + _ => other.new_vid = Vid([2; 16]), + } + assert_sync_validation(SyncMsg::Ack { + results: vec![(id.clone(), AckResult::Applied), (other, AckResult::Held)], + }, true); + } +} diff --git a/crates/kc-sync/src/decision.rs b/crates/kc-sync/src/decision.rs index 454e520..b143094 100644 --- a/crates/kc-sync/src/decision.rs +++ b/crates/kc-sync/src/decision.rs @@ -51,6 +51,8 @@ pub enum HoldReason { OverLimit, /// Complete Phase-1 resolve requires review (§2.4, §12.5). Resolve, + /// Retire does not directly name the current head (§2.5). + RetireMismatch, } /// Side-effect-free state intent; persistence and slot allocation precede ACK (§12.4). @@ -153,14 +155,23 @@ fn advance(state: &ItemState, incoming: &Incoming, convergence: bool, resolve: b } else { incoming.new_vid }; - let lineage = Lineage::merge(&state.lineage, &incoming.lineage); - let lineage = Lineage::new( + // Equal values do not authenticate the sender's claimed ancestry. + let lineage = if convergence { + state.lineage.clone() + } else { + Lineage::merge(&state.lineage, &incoming.lineage) + }; + let mut lineage = Lineage::new( lineage .iter() .copied() - .chain([state.head, incoming.new_vid]), + .chain([state.head, incoming.new_vid]) + .chain(incoming.parents.iter().copied().filter(|_| resolve)), ) .with_head(head); + if convergence { + lineage = lineage.with_heads([state.head, incoming.new_vid]); + } Decision { ack: AckResult::Applied, quarantine: false, @@ -213,6 +224,9 @@ pub fn decide( if incoming.retire && approval.is_none() { return Decision::held(HoldReason::NoApproval); } + if incoming.retire && incoming.parents.as_slice() != [state.head] { + return Decision::held(HoldReason::RetireMismatch); + } // Row 5: complete parent coverage is necessary even with a verified approval. if let Some(candidates) = &state.conflict { let complete = incoming.parents.contains(&state.head) @@ -221,6 +235,9 @@ pub fn decide( .keys() .all(|vid| incoming.parents.contains(vid)); if !complete { + if incoming.retire { + return Decision::held(HoldReason::Resolve); + } return conflict(state, current_fp, incoming); } if approval.is_none() { @@ -240,8 +257,8 @@ pub fn decide( if direct && approval.is_some() && within_limits { return advance(state, incoming, false, false); } - // Row 8; an unapproved Retire is always review-only (§2.5). - if direct || (incoming.retire && approval.is_none()) { + // Row 8. + if direct { return Decision::held(if approval.is_none() { HoldReason::NoApproval } else { diff --git a/crates/kc-sync/src/generation.rs b/crates/kc-sync/src/generation.rs index 8d35162..b89400d 100644 --- a/crates/kc-sync/src/generation.rs +++ b/crates/kc-sync/src/generation.rs @@ -56,6 +56,21 @@ impl Generations { self.owned.get(name).is_some_and(|o| o.peers.contains(peer)) } + /// Removes one scope member without changing generation; send Leave only to this peer (§12.2). + pub fn remove_peer(&mut self, name: &str, peer: &PeerId) -> Option<(Registration, PeerId)> { + let owned = self.owned.get_mut(name)?; + if !owned.peers.remove(peer) { + return None; + } + Some(( + Registration { + name: name.into(), + generation: owned.generation, + }, + peer.clone(), + )) + } + /// Removes local membership and bumps its generation; send Leave to returned peers (§12.2). pub fn rm( &mut self, diff --git a/crates/kc-sync/src/slots.rs b/crates/kc-sync/src/slots.rs index ca5c428..cfe9b90 100644 --- a/crates/kc-sync/src/slots.rs +++ b/crates/kc-sync/src/slots.rs @@ -48,6 +48,10 @@ impl SlotBudget { pub fn capacity(&self) -> usize { self.capacity } + /// Updates the item count without evicting existing slots on shrink (§12.3). + pub fn set_items(&mut self, items: usize) { + self.capacity = items.saturating_mul(4).max(16); + } /// Returns the count of reserved slots (§12.3). pub fn used(&self) -> usize { self.slots.len() @@ -67,6 +71,10 @@ impl SlotBudget { }; } let mut evicted = None; + // A reduced budget preserves all existing reservations until released. + if self.slots.len() > self.capacity { + return Reservation::Refused; + } if self.slots.len() >= self.capacity { if kind <= SlotKind::Held { return Reservation::Refused; @@ -106,6 +114,16 @@ impl SlotBudget { self.slots.remove(name).is_some() } + /// Reserves durable review storage, or returns a non-final capacity deferral (§12.3). + pub fn prepare_hold(&mut self, held_slot: &str, reason: HoldReason) -> OverwriteCapacity { + match self.reserve(held_slot, SlotKind::Held) { + Reservation::Reserved { .. } => OverwriteCapacity::Held(Decision::held(reason)), + Reservation::Refused => { + OverwriteCapacity::Deferred(Decision::unchanged(AckResult::DeferredCapacity)) + } + } + } + /// Ensures a checkpoint before overwrite; fallback is held, then capacity deferral (§2.6, §12.3). pub fn prepare_overwrite( &mut self, @@ -114,14 +132,7 @@ impl SlotBudget { ) -> OverwriteCapacity { match self.reserve(checkpoint_slot, SlotKind::Checkpoint) { Reservation::Reserved { evicted } => OverwriteCapacity::Ready { evicted }, - Reservation::Refused => match self.reserve(held_slot, SlotKind::Held) { - Reservation::Reserved { .. } => { - OverwriteCapacity::Held(Decision::held(HoldReason::OverLimit)) - } - Reservation::Refused => { - OverwriteCapacity::Deferred(Decision::unchanged(AckResult::DeferredCapacity)) - } - }, + Reservation::Refused => self.prepare_hold(held_slot, HoldReason::OverLimit), } } } diff --git a/crates/kc-sync/src/state.rs b/crates/kc-sync/src/state.rs index 9d46e51..b86c76f 100644 --- a/crates/kc-sync/src/state.rs +++ b/crates/kc-sync/src/state.rs @@ -83,6 +83,15 @@ impl Lineage { self } + pub(crate) fn with_heads(mut self, heads: [Vid; 2]) -> Self { + self.0.extend(heads); + while self.0.len() > MAX_LINEAGE { + let victim = self.0.iter().copied().find(|v| !heads.contains(v)).unwrap(); + self.0.remove(&victim); + } + self + } + /// Tests ancestry membership without trusting remote ancestry for authorization (§2.2). pub fn contains(&self, vid: &Vid) -> bool { self.0.contains(vid) diff --git a/crates/kc-sync/tests/policy.rs b/crates/kc-sync/tests/policy.rs index 9e5ab13..53da063 100644 --- a/crates/kc-sync/tests/policy.rs +++ b/crates/kc-sync/tests/policy.rs @@ -262,13 +262,15 @@ fn convergence_is_symmetric_even_when_lineage_truncates() { }; let da = decide(&a, f(1), &from(&b), false, None, true); let db = decide(&b, f(1), &from(&a), false, None, true); - assert_eq!(da, db); - let Transition::Advance { head, lineage, .. } = da.transition else { - panic!() - }; - assert_eq!(head, v(80)); - assert_eq!(lineage.len(), 64); - assert!(lineage.contains(&head)); + for d in [da, db] { + let Transition::Advance { head, lineage, .. } = d.transition else { + panic!() + }; + assert_eq!(head, v(80)); + assert_eq!(lineage.len(), 64); + assert!(lineage.contains(&a.head)); + assert!(lineage.contains(&b.head)); + } } #[test] fn row7_approved_direct_parent_fast_forwards() { @@ -346,17 +348,19 @@ fn retire_requires_approval_and_never_requests_value_deletion() { ); i.parents = vec![v(99)]; held(&run(&conflicted(), &i), HoldReason::NoApproval); - assert_eq!( - decide( - &state(), - f(1), - &i, - false, - Some(&VerifiedApproval::for_tests()), - true - ) - .ack, - AckResult::Conflict + for s in [state(), conflicted()] { + for parents in [vec![], vec![v(99)], vec![v(1), v(3), v(4)]] { + i.parents = parents; + held( + &decide(&s, f(1), &i, false, Some(&VerifiedApproval::for_tests()), true), + HoldReason::RetireMismatch, + ); + } + } + i.parents = vec![v(1)]; + held( + &decide(&conflicted(), f(1), &i, false, Some(&VerifiedApproval::for_tests()), true), + HoldReason::Resolve, ); } #[test] @@ -911,3 +915,153 @@ fn slot_budget_round_trip_retains_snapshot_pins() { Reservation::Refused ); } + + +#[test] +fn convergence_cannot_inject_another_peers_future_vid() { + let mut a = state(); + let mut from_b = incoming(); + from_b.value_fp = Some(f(1)); + from_b.lineage = Lineage::new([v(1), v(2), v(99)]); + let Transition::Advance { head, lineage, .. } = run(&a, &from_b).transition else { + panic!() + }; + assert!(!lineage.contains(&v(99))); + a.head = head; + a.lineage = lineage; + let mut from_c = incoming(); + from_c.new_vid = v(99); + from_c.parents = vec![v(0)]; + from_c.value_fp = Some(f(3)); + let d = run(&a, &from_c); + assert_eq!(d.ack, AckResult::Conflict); + assert!(matches!(d.transition, Transition::Conflict { .. })); +} + +#[test] +fn convergence_pins_both_heads_below_full_lineage() { + let mut s = state(); + s.lineage = Lineage::new((100..164).map(v)).with_head(s.head); + let mut i = incoming(); + i.value_fp = Some(f(1)); + for new_vid in [v(0), v(2)] { + i.new_vid = new_vid; + let Transition::Advance { head, lineage, .. } = run(&s, &i).transition else { + panic!() + }; + assert_eq!(head, s.head.max(new_vid)); + assert_eq!(lineage.len(), 64); + assert!(lineage.contains(&s.head)); + assert!(lineage.contains(&new_vid)); + } +} + +#[test] +fn approved_resolve_records_all_parents_and_late_candidates_are_stale() { + let mut s = conflicted(); + let mut i = incoming(); + i.parents = vec![v(1), v(3), v(4), v(99)]; + i.lineage = Lineage::new([v(77)]); + let d = decide(&s, f(1), &i, false, Some(&VerifiedApproval::for_tests()), true); + let Transition::Advance { head, lineage, clear_conflict: true, .. } = d.transition else { + panic!() + }; + assert!(lineage.contains(&v(77))); + for parent in &i.parents { + assert!(lineage.contains(parent)); + } + s.head = head; + s.lineage = lineage; + s.conflict = None; + for (vid, fp) in [(v(3), f(3)), (v(4), f(4)), (v(99), f(99))] { + let late = Incoming { + new_vid: vid, + parents: vec![v(0)], + value_fp: Some(fp), + ..incoming() + }; + let d = decide(&s, f(2), &late, false, None, true); + assert_eq!(d.ack, AckResult::Applied); + assert_eq!(d.transition, Transition::Unchanged); + } +} + +#[test] +fn approved_fast_forward_merges_sender_lineage() { + let mut i = incoming(); + i.lineage = Lineage::new([v(99)]); + let d = decide(&state(), f(1), &i, false, Some(&VerifiedApproval::for_tests()), true); + let Transition::Advance { lineage, .. } = d.transition else { panic!() }; + assert!(lineage.contains(&v(99))); +} + +#[test] +fn slot_budget_shrink_preserves_slots_and_refuses_new_reservations() { + let mut b = SlotBudget::new(5); + for n in 0..20 { + b.reserve(&format!("p{n}"), SlotKind::Proposal); + } + b.set_items(0); + assert_eq!(b.capacity(), 16); + assert_eq!(b.used(), 20); + for n in 0..20 { + assert_eq!(b.kind(&format!("p{n}")), Some(SlotKind::Proposal)); + } + for kind in [SlotKind::Proposal, SlotKind::Held, SlotKind::ConflictCandidate, SlotKind::Checkpoint] { + assert_eq!(b.reserve("new", kind), Reservation::Refused); + } + assert_eq!(b.reserve("p0", SlotKind::Proposal), Reservation::Reserved { evicted: None }); + for n in 0..5 { assert!(b.release(&format!("p{n}"))); } + assert_eq!(b.reserve("held", SlotKind::Held), Reservation::Reserved { evicted: None }); + b.set_items(6); + assert_eq!(b.capacity(), 24); + assert_eq!(b.reserve("new", SlotKind::Proposal), Reservation::Reserved { evicted: None }); + b.set_items(usize::MAX); + assert_eq!(b.capacity(), usize::MAX); +} + +#[test] +fn prepare_hold_reserves_or_defers_without_eviction() { + let mut b = SlotBudget::new(0); + let OverwriteCapacity::Held(d) = b.prepare_hold("held", HoldReason::Frozen) else { panic!() }; + held(&d, HoldReason::Frozen); + for n in 0..15 { b.reserve(&format!("p{n}"), SlotKind::Proposal); } + let OverwriteCapacity::Deferred(d) = b.prepare_hold("new", HoldReason::NoApproval) else { panic!() }; + assert_eq!(d.ack, AckResult::DeferredCapacity); + assert_eq!(d.transition, Transition::Unchanged); + assert!(!d.ack.is_final()); + assert_eq!(b.used(), 16); + assert_eq!(b.kind("new"), None); + assert_eq!(b.kind("p0"), Some(SlotKind::Proposal)); + assert!(matches!(b.prepare_hold("held", HoldReason::NoApproval), OverwriteCapacity::Held(_))); +} + +#[test] +fn checkpoint_failure_reuses_existing_hold_at_capacity() { + let mut b = SlotBudget::new(0); + for n in 0..15 { b.reserve_snapshot(&format!("s{n}")); } + b.reserve("held", SlotKind::Held); + let OverwriteCapacity::Held(d) = b.prepare_overwrite("s0", "held") else { panic!() }; + held(&d, HoldReason::OverLimit); + assert!(matches!(b.prepare_overwrite("s0", "new"), OverwriteCapacity::Deferred(_))); + assert_eq!(b.used(), 16); +} + +#[test] +fn removing_one_scope_peer_preserves_generation_and_other_peers() { + let mut g = Generations::default(); + g.rm("key").unwrap(); + g.accept("key", peer("a")); + g.accept("key", peer("b")); + g.accept("other", peer("a")); + let (leave, target) = g.remove_peer("key", &peer("a")).unwrap(); + assert_eq!(target, peer("a")); + assert_eq!(leave, Registration { name: "key".into(), generation: 1 }); + assert_eq!(g.generation("key"), 1); + assert!(!g.includes("key", &peer("a"))); + assert!(g.includes("key", &peer("b"))); + assert!(g.includes("other", &peer("a"))); + assert_eq!(g.remove_peer("key", &peer("a")), None); + assert_eq!(g.remove_peer("missing", &peer("a")), None); + assert_eq!(g.accept("key", peer("a")).generation, 1); +} diff --git a/docs/design/sync.md b/docs/design/sync.md index 8fa7f1a..44bdee4 100644 --- a/docs/design/sync.md +++ b/docs/design/sync.md @@ -44,7 +44,7 @@ 1. 받은 vid = 내 head → 무시(값 지문이 다르면 위반) 2. 받은 vid 가 내 lineage 에 있음 → 낡은 변경, 무시 3. **승인 서명이 "parent = 내 head" 를 정확히 적고 있음** → 앞으로 감기. 한도 검사 뒤 적용 - 4. 값이 같음(지문 일치) → 수렴. 두 기기 모두 `head = max(vid_a, vid_b)`, lineage 는 합집합으로 같은 결과를 낸다. 쓰기는 없다 + 4. 값이 같음(지문 일치) → 수렴. 두 기기 모두 `head = max(vid_a, vid_b)` 로 맞추고, 각자 자기 lineage 에 두 head 만 더한다. 보낸 쪽 lineage 는 가져오지 않으며 쓰기는 없다 5. 그 밖 → 충돌 - v0.1 은 보낸 쪽이 주장하는 lineage 만 보고 앞으로 감기를 허용했다. 뚫린 기기가 lineage 에 내 head 를 끼워 넣으면 충돌이 덮어쓰기로 바뀐다(codex P1-4). v0.2 에서는 **승인 서명에 묶인 parent 만** 믿고, lineage 는 낡은 변경을 거르는 데만 쓴다. 승인이 없거나 parent 가 내 head 와 다르면 충돌 또는 보류다. - 기각한 방식: 시각 기준 마지막 쓰기 우선(시계 조작에 약함), 버전 벡터(codex v0.1 안; 빠진 이력을 원작자에게 받아 와야 해서 복잡함). @@ -59,7 +59,8 @@ - 모든 후보 값(2개 이상일 수 있음)을 내부 슬롯에 보존한다. 그 항목은 **일반 변경 적용만** 멈추고, 해결(resolve) 메시지와 다른 기기의 충돌 후보는 계속 받는다(codex P2-11). - `kc sync status` 는 값 대신 지문과 기기 이름을 보여 준다. - `kc sync resolve NAME --keep mine|LABEL`(L + A): 결과는 새 vid 이고 승인 서명의 parent 목록에 **알려진 모든 후보 head** 를 적는다. 받는 쪽은 **자기가 알고 있는 모든 미해결 후보 head(자기 head 포함)가 그 목록에 다 들어 있을 때만** 받아들인다. 하나라도 빠졌으면 충돌로 남긴다(v0.2 재리뷰 P1). 해결 메시지를 적용하는 일은 원자적이다. -- lineage 합집합이 64개를 넘으면 오래된 것부터 자른다. 잘림 순서는 각 vid 를 처음 본 시각이 아니라 **vid 값 오름차순**으로 정해 모든 기기가 같은 결과를 낸다. +- 보낸 쪽 lineage 는 **승인이 검증된 앞으로 감기·해결 경로에서만** 합친다. 수렴은 자기 lineage 에 두 head 만 더하고 보낸 쪽 lineage 는 가져오지 않는다. 합집합이 64개를 넘으면 현재 head(수렴은 두 head)를 남기고 **vid 값 오름차순**으로 자른다. +- 수렴 때 보낸 쪽 lineage 를 믿으면, 뚫린 기기가 같은 값과 다른 기기의 미래 vid 를 보내 그 실제 변경을 낡은 것으로 무시하게 만들 수 있다(`applied` ACK 뒤 영구 불일치). - vid 의 parent 도 불변이다. 같은 vid 로 다른 parent 를 주장하면 위반이다. ### 2.5 삭제 From 960d55944bfa868ba25e78e249994f944105d2c9 Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Tue, 13 Oct 2026 16:41:24 +0900 Subject: [PATCH 14/24] style: cargo fmt Co-Authored-By: Claude Opus 5.5 --- crates/kc-cli/src/local_auth/windows.rs | 5 +- crates/kc-proto/tests/inbox_v2/mod.rs | 44 ++++++--- crates/kc-sync/tests/policy.rs | 113 +++++++++++++++++++----- 3 files changed, 129 insertions(+), 33 deletions(-) diff --git a/crates/kc-cli/src/local_auth/windows.rs b/crates/kc-cli/src/local_auth/windows.rs index 393acf0..0c3a631 100644 --- a/crates/kc-cli/src/local_auth/windows.rs +++ b/crates/kc-cli/src/local_auth/windows.rs @@ -31,9 +31,8 @@ fn request_verification(reason: &str) -> windows::core::Result = unsafe { - verifier.RequestVerificationForWindowAsync(hwnd, &HSTRING::from(reason))? - }; + let request: IAsyncOperation = + unsafe { verifier.RequestVerificationForWindowAsync(hwnd, &HSTRING::from(reason))? }; request.get() } diff --git a/crates/kc-proto/tests/inbox_v2/mod.rs b/crates/kc-proto/tests/inbox_v2/mod.rs index 7304c1d..d6910aa 100644 --- a/crates/kc-proto/tests/inbox_v2/mod.rs +++ b/crates/kc-proto/tests/inbox_v2/mod.rs @@ -597,27 +597,48 @@ fn change_parents_limit_on_decode_validate_seal_and_open() { #[test] fn duplicate_digest_names_are_malformed() { - let entry = DigestEntry { name: name("token"), generation: 1, head: Vid([1; 16]) }; + let entry = DigestEntry { + name: name("token"), + generation: 1, + head: Vid([1; 16]), + }; for same_metadata in [true, false] { let mut other = entry.clone(); if !same_metadata { other.generation += 1; other.head = Vid([2; 16]); } - assert_sync_validation(SyncMsg::Digest { entries: vec![entry.clone(), other] }, false); + assert_sync_validation( + SyncMsg::Digest { + entries: vec![entry.clone(), other], + }, + false, + ); } let mut other = entry.clone(); other.name = name("other"); - assert_sync_validation(SyncMsg::Digest { entries: vec![entry, other] }, true); + assert_sync_validation( + SyncMsg::Digest { + entries: vec![entry, other], + }, + true, + ); } #[test] fn duplicate_ack_change_ids_are_malformed() { - let id = ChangeId { name: name("token"), generation: 1, new_vid: Vid([1; 16]) }; + let id = ChangeId { + name: name("token"), + generation: 1, + new_vid: Vid([1; 16]), + }; for result in [AckResult::Applied, AckResult::Rejected] { - assert_sync_validation(SyncMsg::Ack { - results: vec![(id.clone(), AckResult::Applied), (id.clone(), result)], - }, false); + assert_sync_validation( + SyncMsg::Ack { + results: vec![(id.clone(), AckResult::Applied), (id.clone(), result)], + }, + false, + ); } for field in 0..3 { let mut other = id.clone(); @@ -626,8 +647,11 @@ fn duplicate_ack_change_ids_are_malformed() { 1 => other.generation += 1, _ => other.new_vid = Vid([2; 16]), } - assert_sync_validation(SyncMsg::Ack { - results: vec![(id.clone(), AckResult::Applied), (other, AckResult::Held)], - }, true); + assert_sync_validation( + SyncMsg::Ack { + results: vec![(id.clone(), AckResult::Applied), (other, AckResult::Held)], + }, + true, + ); } } diff --git a/crates/kc-sync/tests/policy.rs b/crates/kc-sync/tests/policy.rs index 53da063..a7122a0 100644 --- a/crates/kc-sync/tests/policy.rs +++ b/crates/kc-sync/tests/policy.rs @@ -352,14 +352,28 @@ fn retire_requires_approval_and_never_requests_value_deletion() { for parents in [vec![], vec![v(99)], vec![v(1), v(3), v(4)]] { i.parents = parents; held( - &decide(&s, f(1), &i, false, Some(&VerifiedApproval::for_tests()), true), + &decide( + &s, + f(1), + &i, + false, + Some(&VerifiedApproval::for_tests()), + true, + ), HoldReason::RetireMismatch, ); } } i.parents = vec![v(1)]; held( - &decide(&conflicted(), f(1), &i, false, Some(&VerifiedApproval::for_tests()), true), + &decide( + &conflicted(), + f(1), + &i, + false, + Some(&VerifiedApproval::for_tests()), + true, + ), HoldReason::Resolve, ); } @@ -916,7 +930,6 @@ fn slot_budget_round_trip_retains_snapshot_pins() { ); } - #[test] fn convergence_cannot_inject_another_peers_future_vid() { let mut a = state(); @@ -962,8 +975,21 @@ fn approved_resolve_records_all_parents_and_late_candidates_are_stale() { let mut i = incoming(); i.parents = vec![v(1), v(3), v(4), v(99)]; i.lineage = Lineage::new([v(77)]); - let d = decide(&s, f(1), &i, false, Some(&VerifiedApproval::for_tests()), true); - let Transition::Advance { head, lineage, clear_conflict: true, .. } = d.transition else { + let d = decide( + &s, + f(1), + &i, + false, + Some(&VerifiedApproval::for_tests()), + true, + ); + let Transition::Advance { + head, + lineage, + clear_conflict: true, + .. + } = d.transition + else { panic!() }; assert!(lineage.contains(&v(77))); @@ -990,8 +1016,17 @@ fn approved_resolve_records_all_parents_and_late_candidates_are_stale() { fn approved_fast_forward_merges_sender_lineage() { let mut i = incoming(); i.lineage = Lineage::new([v(99)]); - let d = decide(&state(), f(1), &i, false, Some(&VerifiedApproval::for_tests()), true); - let Transition::Advance { lineage, .. } = d.transition else { panic!() }; + let d = decide( + &state(), + f(1), + &i, + false, + Some(&VerifiedApproval::for_tests()), + true, + ); + let Transition::Advance { lineage, .. } = d.transition else { + panic!() + }; assert!(lineage.contains(&v(99))); } @@ -1007,15 +1042,31 @@ fn slot_budget_shrink_preserves_slots_and_refuses_new_reservations() { for n in 0..20 { assert_eq!(b.kind(&format!("p{n}")), Some(SlotKind::Proposal)); } - for kind in [SlotKind::Proposal, SlotKind::Held, SlotKind::ConflictCandidate, SlotKind::Checkpoint] { + for kind in [ + SlotKind::Proposal, + SlotKind::Held, + SlotKind::ConflictCandidate, + SlotKind::Checkpoint, + ] { assert_eq!(b.reserve("new", kind), Reservation::Refused); } - assert_eq!(b.reserve("p0", SlotKind::Proposal), Reservation::Reserved { evicted: None }); - for n in 0..5 { assert!(b.release(&format!("p{n}"))); } - assert_eq!(b.reserve("held", SlotKind::Held), Reservation::Reserved { evicted: None }); + assert_eq!( + b.reserve("p0", SlotKind::Proposal), + Reservation::Reserved { evicted: None } + ); + for n in 0..5 { + assert!(b.release(&format!("p{n}"))); + } + assert_eq!( + b.reserve("held", SlotKind::Held), + Reservation::Reserved { evicted: None } + ); b.set_items(6); assert_eq!(b.capacity(), 24); - assert_eq!(b.reserve("new", SlotKind::Proposal), Reservation::Reserved { evicted: None }); + assert_eq!( + b.reserve("new", SlotKind::Proposal), + Reservation::Reserved { evicted: None } + ); b.set_items(usize::MAX); assert_eq!(b.capacity(), usize::MAX); } @@ -1023,27 +1074,43 @@ fn slot_budget_shrink_preserves_slots_and_refuses_new_reservations() { #[test] fn prepare_hold_reserves_or_defers_without_eviction() { let mut b = SlotBudget::new(0); - let OverwriteCapacity::Held(d) = b.prepare_hold("held", HoldReason::Frozen) else { panic!() }; + let OverwriteCapacity::Held(d) = b.prepare_hold("held", HoldReason::Frozen) else { + panic!() + }; held(&d, HoldReason::Frozen); - for n in 0..15 { b.reserve(&format!("p{n}"), SlotKind::Proposal); } - let OverwriteCapacity::Deferred(d) = b.prepare_hold("new", HoldReason::NoApproval) else { panic!() }; + for n in 0..15 { + b.reserve(&format!("p{n}"), SlotKind::Proposal); + } + let OverwriteCapacity::Deferred(d) = b.prepare_hold("new", HoldReason::NoApproval) else { + panic!() + }; assert_eq!(d.ack, AckResult::DeferredCapacity); assert_eq!(d.transition, Transition::Unchanged); assert!(!d.ack.is_final()); assert_eq!(b.used(), 16); assert_eq!(b.kind("new"), None); assert_eq!(b.kind("p0"), Some(SlotKind::Proposal)); - assert!(matches!(b.prepare_hold("held", HoldReason::NoApproval), OverwriteCapacity::Held(_))); + assert!(matches!( + b.prepare_hold("held", HoldReason::NoApproval), + OverwriteCapacity::Held(_) + )); } #[test] fn checkpoint_failure_reuses_existing_hold_at_capacity() { let mut b = SlotBudget::new(0); - for n in 0..15 { b.reserve_snapshot(&format!("s{n}")); } + for n in 0..15 { + b.reserve_snapshot(&format!("s{n}")); + } b.reserve("held", SlotKind::Held); - let OverwriteCapacity::Held(d) = b.prepare_overwrite("s0", "held") else { panic!() }; + let OverwriteCapacity::Held(d) = b.prepare_overwrite("s0", "held") else { + panic!() + }; held(&d, HoldReason::OverLimit); - assert!(matches!(b.prepare_overwrite("s0", "new"), OverwriteCapacity::Deferred(_))); + assert!(matches!( + b.prepare_overwrite("s0", "new"), + OverwriteCapacity::Deferred(_) + )); assert_eq!(b.used(), 16); } @@ -1056,7 +1123,13 @@ fn removing_one_scope_peer_preserves_generation_and_other_peers() { g.accept("other", peer("a")); let (leave, target) = g.remove_peer("key", &peer("a")).unwrap(); assert_eq!(target, peer("a")); - assert_eq!(leave, Registration { name: "key".into(), generation: 1 }); + assert_eq!( + leave, + Registration { + name: "key".into(), + generation: 1 + } + ); assert_eq!(g.generation("key"), 1); assert!(!g.includes("key", &peer("a"))); assert!(g.includes("key", &peer("b"))); From 27b125903db9c6f8f8442c2feffb4f52cfbbb03e Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Tue, 13 Oct 2026 17:25:57 +0900 Subject: [PATCH 15/24] =?UTF-8?q?feat(kc-cli):=20kc=20sync=20Phase=201=20?= =?UTF-8?q?=E2=80=94=20=EC=97=94=EC=A7=84=C2=B7=EB=AA=85=EB=A0=B9=C2=B7?= =?UTF-8?q?=EA=B8=B0=EC=A1=B4=20=EB=AA=85=EB=A0=B9=20=EC=A0=95=EC=B1=85?= =?UTF-8?q?=C2=B7=EB=A1=9C=EC=BB=AC=20=ED=99=95=EC=9D=B8=20=EC=97=B0?= =?UTF-8?q?=EA=B2=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- Cargo.lock | 2 + crates/kc-cli/Cargo.toml | 2 + crates/kc-cli/locales/de.toml | 42 ++++ crates/kc-cli/locales/es.toml | 42 ++++ crates/kc-cli/locales/fr.toml | 42 ++++ crates/kc-cli/locales/ja.toml | 42 ++++ crates/kc-cli/locales/ko.toml | 42 ++++ crates/kc-cli/locales/zh-Hans.toml | 42 ++++ crates/kc-cli/locales/zh-Hant.toml | 42 ++++ crates/kc-cli/src/cli.rs | 54 ++++ crates/kc-cli/src/commands/apply.rs | 15 +- crates/kc-cli/src/commands/inbox.rs | 36 ++- crates/kc-cli/src/commands/items.rs | 28 ++- crates/kc-cli/src/commands/mod.rs | 18 +- crates/kc-cli/src/commands/sync.rs | 26 ++ crates/kc-cli/src/host.rs | 3 + crates/kc-cli/src/lib.rs | 1 + crates/kc-cli/src/settings.rs | 23 +- crates/kc-cli/src/state.rs | 4 +- crates/kc-cli/src/sync/actions.rs | 270 ++++++++++++++++++++ crates/kc-cli/src/sync/map.rs | 35 +++ crates/kc-cli/src/sync/mod.rs | 164 ++++++++++++ crates/kc-cli/src/sync/receive.rs | 302 ++++++++++++++++++++++ crates/kc-cli/src/sync/state.rs | 126 ++++++++++ crates/kc-cli/src/sync/transaction.rs | 285 +++++++++++++++++++++ crates/kc-cli/src/sync/transport.rs | 139 +++++++++++ crates/kc-cli/tests/common/mod.rs | 16 +- crates/kc-cli/tests/sync.rs | 344 ++++++++++++++++++++++++++ crates/kc-sync/src/decision.rs | 6 + crates/kc-sync/src/generation.rs | 9 +- crates/kc-sync/tests/policy.rs | 42 +++- 31 files changed, 2210 insertions(+), 34 deletions(-) create mode 100644 crates/kc-cli/src/commands/sync.rs create mode 100644 crates/kc-cli/src/sync/actions.rs create mode 100644 crates/kc-cli/src/sync/map.rs create mode 100644 crates/kc-cli/src/sync/mod.rs create mode 100644 crates/kc-cli/src/sync/receive.rs create mode 100644 crates/kc-cli/src/sync/state.rs create mode 100644 crates/kc-cli/src/sync/transaction.rs create mode 100644 crates/kc-cli/src/sync/transport.rs create mode 100644 crates/kc-cli/tests/sync.rs diff --git a/Cargo.lock b/Cargo.lock index 554e329..6ee2a0e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1506,11 +1506,13 @@ dependencies = [ "directories", "fd-lock", "gethostname", + "hmac 0.12.1", "humantime", "inquire", "kc-proto", "kc-relay", "kc-store", + "kc-sync", "kc-wire", "libc", "objc2", diff --git a/crates/kc-cli/Cargo.toml b/crates/kc-cli/Cargo.toml index c675732..fef1e2b 100644 --- a/crates/kc-cli/Cargo.toml +++ b/crates/kc-cli/Cargo.toml @@ -21,6 +21,8 @@ path = "src/main.rs" kc-wire.workspace = true kc-proto.workspace = true kc-store.workspace = true +kc-sync.workspace = true +hmac = "0.12" thiserror.workspace = true serde.workspace = true serde_json.workspace = true diff --git a/crates/kc-cli/locales/de.toml b/crates/kc-cli/locales/de.toml index cdbfd3f..2dba173 100644 --- a/crates/kc-cli/locales/de.toml +++ b/crates/kc-cli/locales/de.toml @@ -445,3 +445,45 @@ "{var} is not valid UTF-8" = "{var} ist kein gültiges UTF-8" "{what} is too large for the relay" = "{what} ist zu groß für den Relay-Server" "↑↓ to move, enter to select, type to filter" = "↑↓ zum Bewegen, Enter zum Auswählen, tippen zum Filtern" +"Accept" = "Annehmen" +"Reject" = "Ablehnen" +"Leave for later" = "Später prüfen" +"this device" = "dieses Gerät" +"in sync" = "synchronisiert" +"held" = "zurückgehalten" +"conflict" = "Konflikt" +"proposal" = "Vorschlag" +"re-offer needed" = "erneuter Vorschlag erforderlich" +"frozen" = "eingefroren" +"awaiting review" = "wartet auf Prüfung" +"Synchronize selected items with paired devices" = "Ausgewählte Einträge mit gekoppelten Geräten synchronisieren" +"Show synchronization state without values" = "Synchronisierungsstatus ohne Werte anzeigen" +"Confirm the current value as the recovery checkpoint" = "Aktuellen Wert als Wiederherstellungspunkt bestätigen" +"Add items and offer them to paired devices" = "Einträge hinzufügen und gekoppelten Geräten anbieten" +"Offer selected sync items again" = "Ausgewählte Synchronisierungseinträge erneut anbieten" +"Remove items from this device's sync set, keeping their values" = "Einträge aus der Synchronisierung dieses Geräts entfernen und Werte behalten" +"Manage the paired devices used for sync" = "Gekoppelte Geräte für die Synchronisierung verwalten" +"Review proposals and held changes" = "Vorschläge und zurückgehaltene Änderungen prüfen" +"Resolve a conflict with a new version" = "Konflikt mit einer neuen Version lösen" +"Restore the recovery checkpoint" = "Wiederherstellungspunkt wiederherstellen" +"Hold all incoming sync changes" = "Alle eingehenden Synchronisierungsänderungen zurückhalten" +"Resume sync after local confirmation" = "Synchronisierung nach lokaler Bestätigung fortsetzen" +"Sync state is unavailable or damaged; retry after checking the keychain and state directory." = "Synchronisierungsstatus nicht verfügbar oder beschädigt; Schlüsselbund und Statusverzeichnis prüfen und erneut versuchen." +"Sync needs local confirmation." = "Die Synchronisierung erfordert eine lokale Bestätigung." +"Run this command at a terminal and confirm in the operating system." = "Diesen Befehl in einem Terminal ausführen und im Betriebssystem bestätigen." +"Sync items must contain between 1 byte and 200 KiB." = "Synchronisierungseinträge müssen zwischen 1 Byte und 200 KiB groß sein." +"Sync storage is full; review pending items before retrying." = "Synchronisierungsspeicher voll; ausstehende Einträge prüfen und erneut versuchen." +"Ignored a stale sync offer for {name}." = "Veralteten Synchronisierungsvorschlag für {name} ignoriert." +"Ignored signed approvals: Phase 1 requires local review." = "Signierte Freigaben ignoriert: Phase 1 erfordert lokale Prüfung." +"Confirm sync changes ({n} items)." = "Synchronisierungsänderungen bestätigen ({n} Einträge)." +"Sync delivery is queued; run `kc sync` to retry." = "Synchronisierungsübertragung wartet; mit `kc sync` erneut versuchen." +"Unknown sync peer: {label}." = "Unbekanntes Synchronisierungsgerät: {label}." +"Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." = "Nur das Gerät, das eine Änderung erstellt hat, sendet sie; geht es verloren, eine neue lokale Änderung aus einer verbleibenden Kopie veröffentlichen." +"Review sync changes." = "Synchronisierungsänderungen prüfen." +"Review {name} from {peer}: current {current}, proposed {proposed}." = "{name} von {peer} prüfen: aktuell {current}, vorgeschlagen {proposed}." +"Review sync: accept {accept}, reject {reject}." = "Synchronisierungsprüfung: {accept} annehmen, {reject} ablehnen." +"Confirm the requested sync operation." = "Angeforderte Synchronisierungsaktion bestätigen." +"Select sync items." = "Einträge für die Synchronisierung auswählen." +"Run `kc sync rm {name}` before deleting this item." = "Vor dem Löschen dieses Eintrags `kc sync rm {name}` ausführen." +"{sent} sent, {updated} updated, {conflict} conflict, {held} held" = "{sent} gesendet, {updated} aktualisiert, {conflict} Konflikte, {held} zurückgehalten" +"Sync {name}: {result}." = "Synchronisierung {name}: {result}." diff --git a/crates/kc-cli/locales/es.toml b/crates/kc-cli/locales/es.toml index 90e7e9a..ecd66e3 100644 --- a/crates/kc-cli/locales/es.toml +++ b/crates/kc-cli/locales/es.toml @@ -445,3 +445,45 @@ "{var} is not valid UTF-8" = "{var} no es UTF-8 válido" "{what} is too large for the relay" = "{what} es demasiado grande para el servidor de retransmisión" "↑↓ to move, enter to select, type to filter" = "↑↓ para moverte, intro para seleccionar, escribe para filtrar" +"Accept" = "Aceptar" +"Reject" = "Rechazar" +"Leave for later" = "Revisar más tarde" +"this device" = "este dispositivo" +"in sync" = "sincronizado" +"held" = "retenido" +"conflict" = "conflicto" +"proposal" = "propuesta" +"re-offer needed" = "es necesario volver a proponer" +"frozen" = "congelado" +"awaiting review" = "pendiente de revisión" +"Synchronize selected items with paired devices" = "Sincronizar los elementos seleccionados con dispositivos vinculados" +"Show synchronization state without values" = "Mostrar el estado de sincronización sin los valores" +"Confirm the current value as the recovery checkpoint" = "Confirmar el valor actual como punto de recuperación" +"Add items and offer them to paired devices" = "Añadir elementos y proponerlos a los dispositivos vinculados" +"Offer selected sync items again" = "Volver a proponer los elementos de sincronización seleccionados" +"Remove items from this device's sync set, keeping their values" = "Quitar elementos de la sincronización de este dispositivo y conservar sus valores" +"Manage the paired devices used for sync" = "Gestionar los dispositivos vinculados usados para sincronizar" +"Review proposals and held changes" = "Revisar propuestas y cambios retenidos" +"Resolve a conflict with a new version" = "Resolver un conflicto con una nueva versión" +"Restore the recovery checkpoint" = "Restaurar el punto de recuperación" +"Hold all incoming sync changes" = "Retener todos los cambios de sincronización entrantes" +"Resume sync after local confirmation" = "Reanudar la sincronización tras la confirmación local" +"Sync state is unavailable or damaged; retry after checking the keychain and state directory." = "El estado de sincronización no está disponible o está dañado; compruebe el llavero y el directorio de estado e inténtelo de nuevo." +"Sync needs local confirmation." = "La sincronización requiere confirmación local." +"Run this command at a terminal and confirm in the operating system." = "Ejecute este comando en un terminal y confirme en el sistema operativo." +"Sync items must contain between 1 byte and 200 KiB." = "Los elementos de sincronización deben contener entre 1 byte y 200 KiB." +"Sync storage is full; review pending items before retrying." = "El almacenamiento de sincronización está lleno; revise los elementos pendientes antes de volver a intentarlo." +"Ignored a stale sync offer for {name}." = "Se ignoró una propuesta de sincronización obsoleta para {name}." +"Ignored signed approvals: Phase 1 requires local review." = "Se ignoraron las aprobaciones firmadas: la fase 1 requiere revisión local." +"Confirm sync changes ({n} items)." = "Confirmar los cambios de sincronización ({n} elementos)." +"Sync delivery is queued; run `kc sync` to retry." = "El envío de sincronización está en cola; ejecute `kc sync` para reintentarlo." +"Unknown sync peer: {label}." = "Dispositivo de sincronización desconocido: {label}." +"Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." = "Solo el dispositivo que creó un cambio lo envía; si se pierde, publique un nuevo cambio local a partir de una copia restante." +"Review sync changes." = "Revisar los cambios de sincronización." +"Review {name} from {peer}: current {current}, proposed {proposed}." = "Revisar {name} de {peer}: huella actual {current}, propuesta {proposed}." +"Review sync: accept {accept}, reject {reject}." = "Revisión de sincronización: aceptar {accept}, rechazar {reject}." +"Confirm the requested sync operation." = "Confirmar la operación de sincronización solicitada." +"Select sync items." = "Seleccionar los elementos que se sincronizarán." +"Run `kc sync rm {name}` before deleting this item." = "Ejecute `kc sync rm {name}` antes de eliminar este elemento." +"{sent} sent, {updated} updated, {conflict} conflict, {held} held" = "{sent} enviados, {updated} actualizados, {conflict} conflictos, {held} retenidos" +"Sync {name}: {result}." = "Sincronización de {name}: {result}." diff --git a/crates/kc-cli/locales/fr.toml b/crates/kc-cli/locales/fr.toml index 4c94b92..324cf07 100644 --- a/crates/kc-cli/locales/fr.toml +++ b/crates/kc-cli/locales/fr.toml @@ -445,3 +445,45 @@ "{var} is not valid UTF-8" = "{var} n'est pas en UTF-8 valide" "{what} is too large for the relay" = "{what} est trop volumineux pour le relais" "↑↓ to move, enter to select, type to filter" = "↑↓ pour se déplacer, entrée pour sélectionner, tapez pour filtrer" +"Accept" = "Accepter" +"Reject" = "Refuser" +"Leave for later" = "Examiner plus tard" +"this device" = "cet appareil" +"in sync" = "synchronisé" +"held" = "en attente" +"conflict" = "conflit" +"proposal" = "proposition" +"re-offer needed" = "nouvelle proposition nécessaire" +"frozen" = "gelé" +"awaiting review" = "en attente de vérification" +"Synchronize selected items with paired devices" = "Synchroniser les éléments sélectionnés avec les appareils associés" +"Show synchronization state without values" = "Afficher l’état de synchronisation sans les valeurs" +"Confirm the current value as the recovery checkpoint" = "Confirmer la valeur actuelle comme point de restauration" +"Add items and offer them to paired devices" = "Ajouter des éléments et les proposer aux appareils associés" +"Offer selected sync items again" = "Proposer à nouveau les éléments synchronisés sélectionnés" +"Remove items from this device's sync set, keeping their values" = "Retirer des éléments de la synchronisation de cet appareil en conservant leurs valeurs" +"Manage the paired devices used for sync" = "Gérer les appareils associés utilisés pour la synchronisation" +"Review proposals and held changes" = "Examiner les propositions et les modifications en attente" +"Resolve a conflict with a new version" = "Résoudre un conflit avec une nouvelle version" +"Restore the recovery checkpoint" = "Restaurer le point de récupération" +"Hold all incoming sync changes" = "Mettre en attente toutes les modifications de synchronisation entrantes" +"Resume sync after local confirmation" = "Reprendre la synchronisation après confirmation locale" +"Sync state is unavailable or damaged; retry after checking the keychain and state directory." = "L’état de synchronisation est indisponible ou endommagé ; vérifiez le trousseau et le dossier d’état, puis réessayez." +"Sync needs local confirmation." = "La synchronisation nécessite une confirmation locale." +"Run this command at a terminal and confirm in the operating system." = "Exécutez cette commande dans un terminal et confirmez dans le système d’exploitation." +"Sync items must contain between 1 byte and 200 KiB." = "Les éléments à synchroniser doivent contenir entre 1 octet et 200 KiB." +"Sync storage is full; review pending items before retrying." = "Le stockage de synchronisation est plein ; examinez les éléments en attente avant de réessayer." +"Ignored a stale sync offer for {name}." = "Proposition de synchronisation obsolète pour {name} ignorée." +"Ignored signed approvals: Phase 1 requires local review." = "Approbations signées ignorées : la phase 1 nécessite une vérification locale." +"Confirm sync changes ({n} items)." = "Confirmer les modifications de synchronisation ({n} éléments)." +"Sync delivery is queued; run `kc sync` to retry." = "La transmission est en attente ; exécutez `kc sync` pour réessayer." +"Unknown sync peer: {label}." = "Appareil de synchronisation inconnu : {label}." +"Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." = "Seul l’appareil à l’origine d’une modification l’envoie ; s’il est perdu, publiez une nouvelle modification locale depuis une copie restante." +"Review sync changes." = "Examiner les modifications de synchronisation." +"Review {name} from {peer}: current {current}, proposed {proposed}." = "Examiner {name} de {peer} : empreinte actuelle {current}, proposée {proposed}." +"Review sync: accept {accept}, reject {reject}." = "Vérification de synchronisation : accepter {accept}, refuser {reject}." +"Confirm the requested sync operation." = "Confirmer l’opération de synchronisation demandée." +"Select sync items." = "Sélectionner les éléments à synchroniser." +"Run `kc sync rm {name}` before deleting this item." = "Exécutez `kc sync rm {name}` avant de supprimer cet élément." +"{sent} sent, {updated} updated, {conflict} conflict, {held} held" = "{sent} envoyés, {updated} mis à jour, {conflict} conflits, {held} en attente" +"Sync {name}: {result}." = "Synchronisation {name} : {result}." diff --git a/crates/kc-cli/locales/ja.toml b/crates/kc-cli/locales/ja.toml index 8b2a657..5eff382 100644 --- a/crates/kc-cli/locales/ja.toml +++ b/crates/kc-cli/locales/ja.toml @@ -445,3 +445,45 @@ "{var} is not valid UTF-8" = "{var} が有効な UTF-8 ではありません" "{what} is too large for the relay" = "{what} は中継サーバーには大きすぎます" "↑↓ to move, enter to select, type to filter" = "↑↓: 移動、Enter: 選択、入力で絞り込み" +"Accept" = "受け入れる" +"Reject" = "拒否する" +"Leave for later" = "後で確認" +"this device" = "このデバイス" +"in sync" = "同期済み" +"held" = "保留中" +"conflict" = "競合" +"proposal" = "提案" +"re-offer needed" = "再提案が必要" +"frozen" = "同期停止中" +"awaiting review" = "確認待ち" +"Synchronize selected items with paired devices" = "選択した項目をペア設定済みデバイスと同期" +"Show synchronization state without values" = "値を表示せずに同期状態を確認" +"Confirm the current value as the recovery checkpoint" = "現在の値を復元用チェックポイントとして確認" +"Add items and offer them to paired devices" = "項目を追加してペア設定済みデバイスに提案" +"Offer selected sync items again" = "選択した同期項目を再提案" +"Remove items from this device's sync set, keeping their values" = "値を残してこのデバイスの同期対象から外す" +"Manage the paired devices used for sync" = "同期に使うペア設定済みデバイスを管理" +"Review proposals and held changes" = "提案と保留中の変更を確認" +"Resolve a conflict with a new version" = "新しいバージョンで競合を解決" +"Restore the recovery checkpoint" = "復元用チェックポイントに戻す" +"Hold all incoming sync changes" = "受信した同期変更をすべて保留" +"Resume sync after local confirmation" = "このデバイスで確認して同期を再開" +"Sync state is unavailable or damaged; retry after checking the keychain and state directory." = "同期状態を読み取れないか、破損しています。キーチェーンと状態ディレクトリを確認して再試行してください。" +"Sync needs local confirmation." = "同期にはこのデバイスでの本人確認が必要です。" +"Run this command at a terminal and confirm in the operating system." = "ターミナルでこのコマンドを実行し、OSの本人確認を完了してください。" +"Sync items must contain between 1 byte and 200 KiB." = "同期する値のサイズは1バイト以上200 KiB以下である必要があります。" +"Sync storage is full; review pending items before retrying." = "同期用の保存領域がいっぱいです。保留中の項目を確認してから再試行してください。" +"Ignored a stale sync offer for {name}." = "{name} の古い世代の同期提案を無視しました。" +"Ignored signed approvals: Phase 1 requires local review." = "署名付き承認を無視しました。フェーズ1ではこのデバイスでの確認が必要です。" +"Confirm sync changes ({n} items)." = "同期の変更を確認してください({n}項目)。" +"Sync delivery is queued; run `kc sync` to retry." = "同期の送信が待機中です。`kc sync` で再試行してください。" +"Unknown sync peer: {label}." = "同期相手が見つかりません: {label}。" +"Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." = "変更は作成元のデバイスだけが送信します。そのデバイスを失った場合は、残っているコピーから新しいローカル変更を作成してください。" +"Review sync changes." = "同期の変更を確認してください。" +"Review {name} from {peer}: current {current}, proposed {proposed}." = "{peer} からの {name} を確認: 現在 {current}、提案 {proposed}。" +"Review sync: accept {accept}, reject {reject}." = "同期の確認: {accept}件を受け入れ、{reject}件を拒否。" +"Confirm the requested sync operation." = "要求された同期操作を確認してください。" +"Select sync items." = "同期する項目を選択してください。" +"Run `kc sync rm {name}` before deleting this item." = "この項目を削除する前に `kc sync rm {name}` を実行してください。" +"{sent} sent, {updated} updated, {conflict} conflict, {held} held" = "送信 {sent}件、更新 {updated}件、競合 {conflict}件、保留 {held}件" +"Sync {name}: {result}." = "同期 {name}: {result}。" diff --git a/crates/kc-cli/locales/ko.toml b/crates/kc-cli/locales/ko.toml index 03924ef..061b776 100644 --- a/crates/kc-cli/locales/ko.toml +++ b/crates/kc-cli/locales/ko.toml @@ -445,3 +445,45 @@ "{var} is not valid UTF-8" = "{var}이(가) 올바른 UTF-8 이 아닙니다" "{what} is too large for the relay" = "{what}이(가) 중계 서버에 보내기에 너무 큽니다" "↑↓ to move, enter to select, type to filter" = "↑↓: 이동, 엔터: 선택, 입력해서 필터" +"Accept" = "받아들이기" +"Reject" = "거절하기" +"Leave for later" = "나중에 결정" +"this device" = "이 기기" +"in sync" = "동기화됨" +"held" = "보류 중" +"conflict" = "충돌" +"proposal" = "제안" +"re-offer needed" = "다시 제안해야 함" +"frozen" = "동기화 중지됨" +"awaiting review" = "검토 대기 중" +"Synchronize selected items with paired devices" = "선택한 항목을 페어링한 기기와 동기화" +"Show synchronization state without values" = "값을 표시하지 않고 동기화 상태 확인" +"Confirm the current value as the recovery checkpoint" = "현재 값을 복구 기준점으로 확인" +"Add items and offer them to paired devices" = "항목을 추가하고 페어링한 기기에 제안" +"Offer selected sync items again" = "선택한 동기화 항목을 다시 제안" +"Remove items from this device's sync set, keeping their values" = "값은 남기고 이 기기의 동기화 대상에서 제외" +"Manage the paired devices used for sync" = "동기화할 페어링 기기 관리" +"Review proposals and held changes" = "제안과 보류된 변경 검토" +"Resolve a conflict with a new version" = "새 버전을 만들어 충돌 해결" +"Restore the recovery checkpoint" = "복구 기준점으로 되돌리기" +"Hold all incoming sync changes" = "들어오는 동기화 변경을 모두 보류" +"Resume sync after local confirmation" = "기기에서 확인한 뒤 동기화 재개" +"Sync state is unavailable or damaged; retry after checking the keychain and state directory." = "동기화 상태를 읽을 수 없거나 상태가 손상됐습니다. 키체인과 상태 폴더를 확인한 뒤 다시 시도하세요." +"Sync needs local confirmation." = "동기화하려면 이 기기에서 본인 확인이 필요합니다." +"Run this command at a terminal and confirm in the operating system." = "터미널에서 이 명령을 실행한 뒤 운영체제의 본인 확인을 완료하세요." +"Sync items must contain between 1 byte and 200 KiB." = "동기화할 값의 크기는 1바이트 이상, 200 KiB 이하여야 합니다." +"Sync storage is full; review pending items before retrying." = "동기화 저장 공간이 가득 찼습니다. 대기 중인 항목을 검토한 뒤 다시 시도하세요." +"Ignored a stale sync offer for {name}." = "{name}의 이전 세대 제안을 무시했습니다." +"Ignored signed approvals: Phase 1 requires local review." = "서명 승인을 무시했습니다. 1단계에서는 이 기기에서 직접 검토해야 합니다." +"Confirm sync changes ({n} items)." = "동기화 변경 {n}개를 확인하세요." +"Sync delivery is queued; run `kc sync` to retry." = "동기화 전송이 대기 중입니다. `kc sync`로 다시 시도하세요." +"Unknown sync peer: {label}." = "동기화할 기기를 찾을 수 없습니다: {label}." +"Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." = "변경은 만든 기기에서만 전송합니다. 그 기기를 잃어버렸다면 남아 있는 사본으로 새 변경을 만들어 보내세요." +"Review sync changes." = "동기화 변경을 검토하세요." +"Review {name} from {peer}: current {current}, proposed {proposed}." = "{peer}에서 온 {name} 검토: 현재 지문 {current}, 제안 지문 {proposed}." +"Review sync: accept {accept}, reject {reject}." = "동기화 검토: {accept}개 수락, {reject}개 거절." +"Confirm the requested sync operation." = "요청한 동기화 작업을 확인하세요." +"Select sync items." = "동기화할 항목을 선택하세요." +"Run `kc sync rm {name}` before deleting this item." = "이 항목을 삭제하려면 먼저 `kc sync rm {name}`을 실행하세요." +"{sent} sent, {updated} updated, {conflict} conflict, {held} held" = "전송 {sent}개, 갱신 {updated}개, 충돌 {conflict}개, 보류 {held}개" +"Sync {name}: {result}." = "동기화 {name}: {result}." diff --git a/crates/kc-cli/locales/zh-Hans.toml b/crates/kc-cli/locales/zh-Hans.toml index 654c95b..8a942eb 100644 --- a/crates/kc-cli/locales/zh-Hans.toml +++ b/crates/kc-cli/locales/zh-Hans.toml @@ -445,3 +445,45 @@ "{var} is not valid UTF-8" = "{var} 不是有效的 UTF-8" "{what} is too large for the relay" = "{what} 对中继服务器而言过大" "↑↓ to move, enter to select, type to filter" = "↑↓ 移动,回车选择,输入以筛选" +"Accept" = "接受" +"Reject" = "拒绝" +"Leave for later" = "稍后处理" +"this device" = "此设备" +"in sync" = "已同步" +"held" = "已暂存" +"conflict" = "冲突" +"proposal" = "提议" +"re-offer needed" = "需要重新提议" +"frozen" = "同步已冻结" +"awaiting review" = "等待审核" +"Synchronize selected items with paired devices" = "将所选项目与已配对设备同步" +"Show synchronization state without values" = "显示同步状态,不显示值" +"Confirm the current value as the recovery checkpoint" = "将当前值确认为恢复检查点" +"Add items and offer them to paired devices" = "添加项目并向已配对设备发出提议" +"Offer selected sync items again" = "重新提议所选同步项目" +"Remove items from this device's sync set, keeping their values" = "从此设备的同步集合中移除项目,保留其值" +"Manage the paired devices used for sync" = "管理用于同步的已配对设备" +"Review proposals and held changes" = "审核提议和暂存的更改" +"Resolve a conflict with a new version" = "使用新版本解决冲突" +"Restore the recovery checkpoint" = "恢复到检查点" +"Hold all incoming sync changes" = "暂存所有传入的同步更改" +"Resume sync after local confirmation" = "本地确认后恢复同步" +"Sync state is unavailable or damaged; retry after checking the keychain and state directory." = "同步状态不可用或已损坏;请检查钥匙串和状态目录后重试。" +"Sync needs local confirmation." = "同步需要本地确认。" +"Run this command at a terminal and confirm in the operating system." = "请在终端运行此命令,并在操作系统中完成确认。" +"Sync items must contain between 1 byte and 200 KiB." = "同步项目的大小必须在 1 字节到 200 KiB 之间。" +"Sync storage is full; review pending items before retrying." = "同步存储已满;请审核待处理项目后重试。" +"Ignored a stale sync offer for {name}." = "已忽略 {name} 的过期同步提议。" +"Ignored signed approvals: Phase 1 requires local review." = "已忽略签名批准:第一阶段需要本地审核。" +"Confirm sync changes ({n} items)." = "请确认同步更改({n} 项)。" +"Sync delivery is queued; run `kc sync` to retry." = "同步传输已排队;请运行 `kc sync` 重试。" +"Unknown sync peer: {label}." = "未知的同步设备:{label}。" +"Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." = "只有创建更改的设备会发送它;若该设备丢失,请用剩余副本发布新的本地更改。" +"Review sync changes." = "请审核同步更改。" +"Review {name} from {peer}: current {current}, proposed {proposed}." = "审核来自 {peer} 的 {name}:当前指纹 {current},提议指纹 {proposed}。" +"Review sync: accept {accept}, reject {reject}." = "同步审核:接受 {accept} 项,拒绝 {reject} 项。" +"Confirm the requested sync operation." = "请确认请求的同步操作。" +"Select sync items." = "请选择同步项目。" +"Run `kc sync rm {name}` before deleting this item." = "删除此项目之前,请先运行 `kc sync rm {name}`。" +"{sent} sent, {updated} updated, {conflict} conflict, {held} held" = "已发送 {sent} 项,已更新 {updated} 项,冲突 {conflict} 项,暂存 {held} 项" +"Sync {name}: {result}." = "同步 {name}:{result}。" diff --git a/crates/kc-cli/locales/zh-Hant.toml b/crates/kc-cli/locales/zh-Hant.toml index f714db9..cbb9204 100644 --- a/crates/kc-cli/locales/zh-Hant.toml +++ b/crates/kc-cli/locales/zh-Hant.toml @@ -445,3 +445,45 @@ "{var} is not valid UTF-8" = "{var} 不是有效的 UTF-8" "{what} is too large for the relay" = "{what} 對中繼伺服器而言太大" "↑↓ to move, enter to select, type to filter" = "↑↓ 移動,Enter 選擇,輸入文字以篩選" +"Accept" = "接受" +"Reject" = "拒絕" +"Leave for later" = "稍後處理" +"this device" = "此裝置" +"in sync" = "已同步" +"held" = "已暫存" +"conflict" = "衝突" +"proposal" = "提議" +"re-offer needed" = "需要重新提議" +"frozen" = "同步已凍結" +"awaiting review" = "等待審核" +"Synchronize selected items with paired devices" = "將所選項目與已配對裝置同步" +"Show synchronization state without values" = "顯示同步狀態,不顯示值" +"Confirm the current value as the recovery checkpoint" = "將目前值確認為復原檢查點" +"Add items and offer them to paired devices" = "新增項目並向已配對裝置提出提議" +"Offer selected sync items again" = "重新提議所選同步項目" +"Remove items from this device's sync set, keeping their values" = "從此裝置的同步集合移除項目,保留其值" +"Manage the paired devices used for sync" = "管理用於同步的已配對裝置" +"Review proposals and held changes" = "審核提議及暫存的變更" +"Resolve a conflict with a new version" = "使用新版本解決衝突" +"Restore the recovery checkpoint" = "還原至復原檢查點" +"Hold all incoming sync changes" = "暫存所有傳入的同步變更" +"Resume sync after local confirmation" = "本機確認後恢復同步" +"Sync state is unavailable or damaged; retry after checking the keychain and state directory." = "同步狀態無法使用或已損壞;請檢查鑰匙圈與狀態目錄後重試。" +"Sync needs local confirmation." = "同步需要本機確認。" +"Run this command at a terminal and confirm in the operating system." = "請在終端機執行此命令,並在作業系統中完成確認。" +"Sync items must contain between 1 byte and 200 KiB." = "同步項目的大小必須介於 1 位元組與 200 KiB 之間。" +"Sync storage is full; review pending items before retrying." = "同步儲存空間已滿;請審核待處理項目後重試。" +"Ignored a stale sync offer for {name}." = "已忽略 {name} 的過期同步提議。" +"Ignored signed approvals: Phase 1 requires local review." = "已忽略簽署核准:第一階段需要本機審核。" +"Confirm sync changes ({n} items)." = "請確認同步變更({n} 項)。" +"Sync delivery is queued; run `kc sync` to retry." = "同步傳輸已排入佇列;請執行 `kc sync` 重試。" +"Unknown sync peer: {label}." = "未知的同步裝置:{label}。" +"Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." = "只有建立變更的裝置會傳送它;若該裝置遺失,請用剩餘副本發布新的本機變更。" +"Review sync changes." = "請審核同步變更。" +"Review {name} from {peer}: current {current}, proposed {proposed}." = "審核來自 {peer} 的 {name}:目前指紋 {current},提議指紋 {proposed}。" +"Review sync: accept {accept}, reject {reject}." = "同步審核:接受 {accept} 項,拒絕 {reject} 項。" +"Confirm the requested sync operation." = "請確認要求的同步操作。" +"Select sync items." = "請選擇同步項目。" +"Run `kc sync rm {name}` before deleting this item." = "刪除此項目之前,請先執行 `kc sync rm {name}`。" +"{sent} sent, {updated} updated, {conflict} conflict, {held} held" = "已傳送 {sent} 項,已更新 {updated} 項,衝突 {conflict} 項,暫存 {held} 項" +"Sync {name}: {result}." = "同步 {name}:{result}。" diff --git a/crates/kc-cli/src/cli.rs b/crates/kc-cli/src/cli.rs index 2bfcbbc..65fdc1b 100644 --- a/crates/kc-cli/src/cli.rs +++ b/crates/kc-cli/src/cli.rs @@ -60,6 +60,8 @@ pub enum Command { Device(DeviceArgs), /// Check the keychain, the relay and the configuration Doctor(DoctorArgs), + /// Synchronize selected items with paired devices + Sync(SyncArgs), } #[derive(Debug, Args)] @@ -362,3 +364,55 @@ mod tests { assert!(cli.allow_http); } } + +#[derive(Debug, Args)] +pub struct SyncArgs { + #[command(subcommand)] + pub command: Option, +} + +#[derive(Debug, Subcommand)] +pub enum SyncCommand { + /// Show synchronization state without values + Status { + /// Print JSON + #[arg(long)] + json: bool, + /// Confirm the current value as the recovery checkpoint + #[arg(long, value_name = "NAME")] + confirm_checkpoint: Option, + }, + /// Add items and offer them to paired devices + Add { + names: Vec, + #[arg(long, value_delimiter = ',')] + peers: Vec, + }, + /// Offer selected sync items again + Offer { + names: Vec, + #[arg(long, value_delimiter = ',')] + peers: Vec, + }, + /// Remove items from this device's sync set, keeping their values + Rm { #[arg(required = true)] names: Vec }, + /// Manage the paired devices used for sync + Peer { #[command(subcommand)] command: SyncPeerCommand }, + /// Review proposals and held changes + Review, + /// Resolve a conflict with a new version + Resolve { name: String, #[arg(long)] keep: String }, + /// Restore the recovery checkpoint + RestoreCheckpoint { name: String }, + /// Hold all incoming sync changes + Freeze, + /// Resume sync after local confirmation + Unfreeze, +} + +#[derive(Debug, Subcommand)] +pub enum SyncPeerCommand { + Add { label: String }, + Rm { label: String }, + List, +} diff --git a/crates/kc-cli/src/commands/apply.rs b/crates/kc-cli/src/commands/apply.rs index 6a7a666..73a82a1 100644 --- a/crates/kc-cli/src/commands/apply.rs +++ b/crates/kc-cli/src/commands/apply.rs @@ -134,6 +134,15 @@ pub(crate) fn apply_items( items: &[Item], conflicts: Conflicts, from_device: &str, + journal: Option<&mut dyn Journal>, +) -> Result { + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + apply_items_locked(ctx, items, conflicts, from_device, journal) +} + +pub(crate) fn apply_items_locked( + ctx: &mut Ctx<'_, H>, items: &[Item], conflicts: Conflicts, from_device: &str, mut journal: Option<&mut dyn Journal>, ) -> Result { let mut applied = Applied::default(); @@ -239,11 +248,13 @@ fn apply_one( if value.len() > MAX_VALUE_LEN { return Ok(ItemStatus::Rejected(REJECT_TOO_LARGE)); } + if conflicts != Conflicts::Policy(ConflictPolicy::Rename) { + if let Some(status) = crate::sync::legacy(ctx, item, from_device)? { return Ok(status); } + } let policy = match conflicts { Conflicts::Policy(policy) => policy, Conflicts::Ask { overwrite } => { { - let _items = ctx.state.lock_items(ctx.store.namespace())?; if let Some(status) = settle_without_conflict(ctx, item, from_device, mark)? { return Ok(status); } @@ -252,12 +263,12 @@ fn apply_one( ask(ctx, &item.name, overwrite)? } }; - let _items = ctx.state.lock_items(ctx.store.namespace())?; if let Some(status) = settle_without_conflict(ctx, item, from_device, mark)? { return Ok(status); } match policy { ConflictPolicy::Skip => Ok(ItemStatus::SkippedConflict), + ConflictPolicy::Overwrite if !ctx.interactive() => Ok(ItemStatus::SkippedConflict), ConflictPolicy::Overwrite => { mark(&ctx.state)?; store(ctx, item.name.as_str(), item, from_device)?; diff --git a/crates/kc-cli/src/commands/inbox.rs b/crates/kc-cli/src/commands/inbox.rs index 659101b..cde4787 100644 --- a/crates/kc-cli/src/commands/inbox.rs +++ b/crates/kc-cli/src/commands/inbox.rs @@ -52,11 +52,13 @@ pub(super) async fn inbox(ctx: &mut Ctx<'_, H>, args: InboxArgs) -> Res Err(e) => return Err(CliError::from(e).context(tr!("reading this device's inbox"))), } } + let _items = ctx.state.lock_items(ctx.store.namespace())?; let _lock = ctx.state.lock()?; let listing = match relay.list_messages(&inbox_id, &owner, Duration::ZERO).await { Ok(listing) => listing, Err(e) if e.is(ErrorCode::Unauthorized) => { drop(_lock); + drop(_items); return lost_inbox(ctx, &relay, &inbox_id).await; } Err(e) => return Err(CliError::from(e).context(tr!("reading this device's inbox"))), @@ -85,11 +87,11 @@ pub(super) async fn inbox(ctx: &mut Ctx<'_, H>, args: InboxArgs) -> Res let opened = message_body(message) .map_err(|_| InboxError::Malformed) .and_then(|body| { - inbox::open( + inbox::open_any( &body, &key_refs, |fp| peers.by_fingerprint(fp).map(|p| p.device_pk), - |id| seen.contains(id), + |_| false, now, ) }); @@ -127,7 +129,26 @@ pub(super) async fn inbox(ctx: &mut Ctx<'_, H>, args: InboxArgs) -> Res let label = peers .by_fingerprint(&opened.sender_fp) .map_or_else(|| opened.sender_fp.short(), |p| p.label.to_string()); - let names: Vec<&str> = opened.items.iter().map(|i| i.name.as_str()).collect(); + let until = opened.keep_seen_until(); + let items = match &opened.body { + inbox::Body::Sync(message_body) => { + crate::sync::receive(ctx, &opened.sender_fp.to_hex(), message_body)?; + seen.insert(&opened.msg_id, until); + ctx.state.save_seen(&seen)?; + delete(ctx, &relay, &inbox_id, &owner, &message.msg_id).await; + continue; + } + inbox::Body::Items(items) => { + if seen.contains(&opened.msg_id) { + say!(ctx, "{}", tr!("A message was dropped: {error} (or one this device stored before but couldn't delete).", error = InboxError::Replay)); + outcome.failed(InboxError::Replay.exit_code()); + delete(ctx, &relay, &inbox_id, &owner, &message.msg_id).await; + continue; + } + items + } + }; + let names: Vec<&str> = items.iter().map(|i| i.name.as_str()).collect(); let (n, names) = (names.len(), names.join(", ")); let text = if n == 1 { tr!( @@ -163,7 +184,7 @@ pub(super) async fn inbox(ctx: &mut Ctx<'_, H>, args: InboxArgs) -> Res id: opened.msg_id, until, }; - apply::apply_items(ctx, &opened.items, conflicts, &label, Some(&mut journal))? + apply::apply_items_locked(ctx, items, conflicts, &label, Some(&mut journal))? }; apply::print_results(ctx, &applied.results, true); if applied.done_before > 0 { @@ -258,6 +279,13 @@ async fn lost_inbox(ctx: &mut Ctx<'_, H>, relay: &H::Relay, lost: &str) let (_, replaced) = pairing::replace_lost_inbox(ctx, relay, &lock, lost).await?; drop(lock); if replaced { + if ctx.state.root().join("sync.json").exists() { + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + let mut sync = crate::sync::State::load(&ctx.state)?; + sync.reconnect = true; + sync.save(&ctx.state)?; + } pairing::lost_inbox_notice(ctx); } else { say!( diff --git a/crates/kc-cli/src/commands/items.rs b/crates/kc-cli/src/commands/items.rs index ae9e0d1..8d282a8 100644 --- a/crates/kc-cli/src/commands/items.rs +++ b/crates/kc-cli/src/commands/items.rs @@ -67,10 +67,7 @@ pub(super) fn set(ctx: &mut Ctx<'_, H>, args: SetArgs) -> Result { "the value is empty; nothing was stored" ))); } - let outcome = { - let _items = ctx.state.lock_items(ctx.store.namespace())?; - ctx.store.set(name.as_str(), &value, kind, Origin::Local)? - }; + let outcome = crate::sync::local_set(ctx, name.as_str(), &value, kind, Origin::Local)?; match outcome.change { Change::Created => { let n = value.len(); @@ -331,6 +328,13 @@ fn format_table(items: &[ItemInfo]) -> String { pub(super) fn rm(ctx: &mut Ctx<'_, H>, args: RmArgs) -> Result { let name = item_name(&args.name)?; + { + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + if crate::sync::State::load(&ctx.state)?.items.contains_key(name.as_str()) { + return Err(CliError::interaction(tr!("Run `kc sync rm {name}` before deleting this item.", name = name))); + } + } if ctx.interactive() && !args.yes { if !ctx.store.exists(name.as_str())? { return Err(not_found(&name)); @@ -345,6 +349,10 @@ pub(super) fn rm(ctx: &mut Ctx<'_, H>, args: RmArgs) -> Result { } let deleted = { let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + if crate::sync::State::load(&ctx.state)?.items.contains_key(name.as_str()) { + return Err(CliError::interaction(tr!("Run `kc sync rm {name}` before deleting this item.", name = name))); + } ctx.store.delete(name.as_str())? }; if deleted { @@ -357,10 +365,7 @@ pub(super) fn rm(ctx: &mut Ctx<'_, H>, args: RmArgs) -> Result { pub(super) fn restore(ctx: &mut Ctx<'_, H>, args: NameArgs) -> Result { let name = item_name(&args.name)?; - { - let _items = ctx.state.lock_items(ctx.store.namespace())?; - ctx.store.restore(name.as_str())?; - } + crate::sync::observed_write(ctx, name.as_str(), |store| store.restore(name.as_str()))?; say!( ctx, "{}", @@ -381,11 +386,8 @@ pub(super) fn adopt(ctx: &mut Ctx<'_, H>, args: AdoptArgs) -> Result say!( ctx, diff --git a/crates/kc-cli/src/commands/mod.rs b/crates/kc-cli/src/commands/mod.rs index ca94a8d..901fc3d 100644 --- a/crates/kc-cli/src/commands/mod.rs +++ b/crates/kc-cli/src/commands/mod.rs @@ -6,9 +6,10 @@ mod device; mod doctor; mod inbox; mod items; -mod pairing; +pub(crate) mod pairing; mod peers; mod transfer; +mod sync; use std::ffi::OsString; use std::fmt; @@ -74,7 +75,11 @@ async fn execute(host: &mut H, cli: Cli) -> Result { } let settings = Settings::load(state.root())?; let policy = Policy::new(interactivity, settings.agent_code_send); - policy.check(&policy::gates(&cli.command, interactivity.stdin_terminal))?; + let mut gates = policy::gates(&cli.command, interactivity.stdin_terminal); + if !crate::sync::State::load(&state)?.items.is_empty() { + gates.retain(|gate| *gate != policy::Gate::Overwrite); + } + policy.check(&gates)?; let store = Keychain::new(host.open_store(policy.interactive())?); let mut ctx = Ctx { host, @@ -91,18 +96,19 @@ async fn execute(host: &mut H, cli: Cli) -> Result { async fn dispatch(ctx: &mut Ctx<'_, H>, command: Command) -> Result { pairing::expire_prev_key(ctx); match command { - Command::Set(args) => items::set(ctx, args), + Command::Set(args) => { let code = items::set(ctx, args)?; crate::sync::send_after_write(ctx).await; Ok(code) }, Command::Get(args) => items::get(ctx, args), Command::Exec(args) => items::exec(ctx, args), Command::List(args) => items::list(ctx, args), Command::Rm(args) => items::rm(ctx, args), - Command::Restore(args) => items::restore(ctx, args), - Command::Adopt(args) => items::adopt(ctx, args), + Command::Restore(args) => { let code = items::restore(ctx, args)?; crate::sync::send_after_write(ctx).await; Ok(code) }, + Command::Adopt(args) => { let code = items::adopt(ctx, args)?; crate::sync::send_after_write(ctx).await; Ok(code) }, Command::Send(args) => transfer::send(ctx, args).await, Command::Receive(args) => transfer::receive(ctx, args).await, Command::Pair(args) => transfer::pair(ctx, args).await, Command::Peers(args) => peers::peers(ctx, args).await, - Command::Inbox(args) => inbox::inbox(ctx, args).await, + Command::Inbox(args) => { let code = inbox::inbox(ctx, args).await?; crate::sync::flush(ctx, false).await?; Ok(code.max(crate::sync::pending_code(ctx)?)) }, + Command::Sync(args) => sync::run(ctx, args).await, Command::Device(args) => device::device(ctx, args).await, Command::Doctor(_) => unreachable!("handled before the store is opened"), } diff --git a/crates/kc-cli/src/commands/sync.rs b/crates/kc-cli/src/commands/sync.rs new file mode 100644 index 0000000..5ab3ab9 --- /dev/null +++ b/crates/kc-cli/src/commands/sync.rs @@ -0,0 +1,26 @@ +use super::{Ctx, inbox, say}; +use crate::{cli::{SyncArgs, InboxArgs}, error::Result, host::Host, i18n::tr, sync::{self, State}}; + +pub(super) async fn run(ctx: &mut Ctx<'_, H>, args: SyncArgs) -> Result { + if let Some(command) = args.command { + let quiet = matches!(command, crate::cli::SyncCommand::Status { .. } | crate::cli::SyncCommand::Freeze | crate::cli::SyncCommand::Peer { command: crate::cli::SyncPeerCommand::List }); + let code = sync::actions::command(ctx, command)?; + if !quiet { sync::flush(ctx, false).await?; } + return Ok(code); + } + let before = { + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + let mut s = State::load(&ctx.state)?; + sync::scan(ctx, &mut s)?; + s.items.iter().map(|(n, i)| (n.clone(), i.head)).collect::>() + }; + let received = inbox::inbox(ctx, InboxArgs { on_conflict: None, wait: None }).await?; + let sent = sync::flush(ctx, true).await?; + let s = State::load(&ctx.state)?; + let updated = s.items.iter().filter(|(n, i)| before.get(*n) != Some(&i.head)).count(); + let conflict = s.items.values().filter(|i| i.conflict).count(); + let held = s.candidates.values().filter(|c| c.category != sync::CandidateKind::Conflict).count(); + say!(ctx, "{}", tr!("{sent} sent, {updated} updated, {conflict} conflict, {held} held", sent = sent, updated = updated, conflict = conflict, held = held)); + Ok(if received != 0 && received != 8 { received } else { sync::pending_code(ctx)?.max(received) }) +} diff --git a/crates/kc-cli/src/host.rs b/crates/kc-cli/src/host.rs index 74a70b0..33f6225 100644 --- a/crates/kc-cli/src/host.rs +++ b/crates/kc-cli/src/host.rs @@ -29,6 +29,9 @@ pub trait Host { fn local_confirm(&mut self, _reason: &str) -> LocalAuthOutcome { LocalAuthOutcome::Unavailable("no local confirmation on this host".into()) } + /// Test injection after a sync transaction's keychain write; production never interrupts. + #[doc(hidden)] + fn sync_interrupt_after_write(&mut self) -> bool { false } /// A process environment variable (`CI`, `CLAUDECODE`, `KC_RELAY`). fn env_var(&self, key: &str) -> Option; fn stdin_is_terminal(&self) -> bool; diff --git a/crates/kc-cli/src/lib.rs b/crates/kc-cli/src/lib.rs index 802693f..46e0381 100644 --- a/crates/kc-cli/src/lib.rs +++ b/crates/kc-cli/src/lib.rs @@ -31,6 +31,7 @@ pub mod policy; pub mod settings; pub mod state; mod values; +mod sync; pub use console::{Console, PromptError, TermConsole}; pub use error::CliError; diff --git a/crates/kc-cli/src/settings.rs b/crates/kc-cli/src/settings.rs index fb9de34..42f78b6 100644 --- a/crates/kc-cli/src/settings.rs +++ b/crates/kc-cli/src/settings.rs @@ -33,17 +33,20 @@ pub const ENV_RELAY: &str = "KC_RELAY"; const HEADER: &str = "# kc device settings (no secrets here). `kc doctor` checks this file.\n"; /// The fields kc knows; `kc doctor` reports any others. -const KNOWN_KEYS: [&str; 6] = [ +const KNOWN_KEYS: [&str; 7] = [ "label", "relay", "agent_code_send", "allow_http", "inbox_id", "device_key_prev_until", + "sync", ]; #[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] pub struct Settings { + #[serde(default, skip_serializing_if = "SyncSettings::is_default")] + pub sync: SyncSettings, /// The label this device suggests when pairing. Default: the host name. #[serde(default, skip_serializing_if = "Option::is_none")] pub label: Option, @@ -64,6 +67,23 @@ pub struct Settings { pub device_key_prev_until: Option, } +/// Human-edited sync settings. Scheduling and signed-approval endpoints are reserved +/// for their later phases; Phase 1 always enforces the design's fixed breaker caps. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct SyncSettings { + pub interval: Option, + pub max_remote_overwrites: usize, + pub max_proposals_per_day: usize, + pub approver_url: Option, +} +impl Default for SyncSettings { + fn default() -> Self { Self { interval: None, max_remote_overwrites: 1, max_proposals_per_day: 32, approver_url: None } } +} +impl SyncSettings { + fn is_default(&self) -> bool { self == &Self::default() } +} + impl Settings { /// Reads `config.toml` from `dir`; a missing file gives the defaults. pub fn load(dir: &Path) -> Result { @@ -336,6 +356,7 @@ mod tests { allow_http: true, inbox_id: Some("AAAAAAAAAAAAAAAAAAAAAA".into()), device_key_prev_until: Some(1_760_000_000), + sync: SyncSettings::default(), }; s.save(dir.path()).unwrap(); assert_eq!(Settings::load(dir.path()).unwrap(), s); diff --git a/crates/kc-cli/src/state.rs b/crates/kc-cli/src/state.rs index 3890ad4..5033d52 100644 --- a/crates/kc-cli/src/state.rs +++ b/crates/kc-cli/src/state.rs @@ -269,8 +269,8 @@ impl StateDir { /// conflict check and the write it decides on can't interleave with another kc process /// writing to the same keychain namespace. The keychain is shared by every config /// directory of the user, so the lock file lives in a per-user directory (the runtime - /// or cache directory), not in the config directory. Taken after `state.lock` when - /// both are needed, never the other way round. + /// or cache directory), not in the config directory. Taken before `state.lock` when + /// both are needed; seen.json is written after sync state. pub fn lock_items(&self, namespace: &str) -> Result { let file = format!("{ITEMS_LOCK_PREFIX}{namespace}.lock"); let busy = || tr!("another kc process is writing items; try again"); diff --git a/crates/kc-cli/src/sync/actions.rs b/crates/kc-cli/src/sync/actions.rs new file mode 100644 index 0000000..e34774a --- /dev/null +++ b/crates/kc-cli/src/sync/actions.rs @@ -0,0 +1,270 @@ +use super::*; +use crate::cli::{SyncCommand, SyncPeerCommand}; +use state::{CandidateKind, Control, Item, Offer, Peer}; +use transaction::{queue, blob, put_blob}; + +pub(crate) fn label(ctx: &Ctx<'_, H>, peer: &str) -> Result { + if peer == "mine" { return Ok(tr!("this device")) } + Ok(ctx.state.load_peers()?.peers.iter().find(|p| p.fingerprint.to_hex() == peer) + .map(|p| p.label.to_string()).unwrap_or_else(|| peer.to_string())) +} +fn selected_peers(ctx: &Ctx<'_, H>, s: &State, labels: &[String]) -> Result> { + let peers = ctx.state.load_peers()?; + if labels.is_empty() { + return Ok(peers.peers.iter().filter(|p| s.peers.get(&p.fingerprint.to_hex()).is_none_or(|p| p.enabled)) + .map(|p| p.fingerprint.to_hex()).collect()) + } + labels.iter().map(|label| peers.find(label).map(|p| p.fingerprint.to_hex()).ok_or_else(|| CliError::not_found(tr!("Unknown sync peer: {label}.", label = label)))).collect() +} +fn offer(ctx: &mut Ctx<'_, H>, s: &mut State, name: &str, peers: &[String]) -> Result<()> { + let (value, kind, fp) = current(ctx, name)?.ok_or_else(state_error)?; + size(&value)?; + let item = s.items[name].clone(); + // Re-offering a received value is a new local publication, never forwarding its vid. + if item.conflict { return Err(CliError::new(8, tr!("Sync needs local confirmation."))) } + if !item.own { transaction::publish_current(ctx, s, name)?; } + let item = s.items[name].clone(); + let slot = snapshot_slot(item.head); + if !reserve(ctx, s, &slot, SlotKind::ConflictCandidate, true)? { return Err(capacity()) } + put_blob(ctx, &slot, kind, &value)?; + remember(ctx, name, item.head, fp, &item.parents)?; + s.latest_local.insert(name.into(), item.head); + s.versions.insert(vid_key(item.head), Version { name: name.into(), vid: item.head, parents: item.parents.clone(), lineage: item.lineage.clone(), kind, slot }); + for peer in peers { + s.peers.entry(peer.clone()).or_insert_with(|| Peer { enabled: true, ..Peer::default() }); + s.items.get_mut(name).unwrap().scope.insert(peer.clone()); + s.generations.accept(name, PeerId(peer.clone())); + s.offers.retain(|o| o.peer != *peer || o.name != name); + s.offers.push(Offer { peer: peer.clone(), name: name.into(), vid: item.head }); + } + Ok(()) +} +pub(crate) fn remove(ctx: &Ctx<'_, H>, s: &mut State, name: &str) -> Result<()> { + let (registration, mut peers) = s.generations.rm(name).map_err(|_| state_error())?; + if let Some(item) = s.items.remove(name) { peers.extend(item.scope.into_iter().map(PeerId)); } + for peer in peers { if peer.0 == "mine" { continue } queue(s, &peer.0, Control::Leave { name: name.into(), generation: registration.generation }); } + s.offers.retain(|o| o.name != name); + transaction::clear_candidates(s, name); + for peer in s.peers.keys().cloned().collect::>() { + let ids = s.outbox.pending(&PeerId(peer.clone())).filter(|id| id.name == name).cloned().collect::>(); + for id in ids { s.outbox.ack(&PeerId(peer.clone()), &id, kc_sync::AckResult::Rejected); } + } + super::transport::collect_snapshots(s); + s.cleanup(ctx) +} +pub(crate) fn status(ctx: &mut Ctx<'_, H>, json: bool) -> Result { + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + let mut s = State::load(&ctx.state)?; + recover(ctx, &mut s)?; + let mut rows = Vec::new(); + for (name, item) in &s.items { + let state = if s.frozen { tr!("frozen") } + else if item.conflict { tr!("conflict") } + else if item.scope.iter().any(|p| s.peers.get(p).is_some_and(|p| p.reoffer.contains(name))) { tr!("re-offer needed") } + else if s.candidates.values().any(|c| c.version.name == *name && c.category == CandidateKind::Held) { tr!("held") } + else if s.offers.iter().any(|o| o.name == *name) || item.scope.iter().any(|p| s.outbox.pending(&PeerId(p.clone())).any(|c| c.name == *name)) { tr!("awaiting review") } + else { tr!("in sync") }; + let fingerprint = current(ctx, name)?.map(|v| hex(&v.2.0[..6])); + let peers = item.scope.iter().map(|p| label(ctx, p)).collect::>>()?; + rows.push(serde_json::json!({"name": name, "state": state, "head": item.head, "fingerprint": fingerprint, "peers": peers})); + } + let mut candidates = Vec::new(); + for c in s.candidates.values() { + let fp = if c.retire { None } else { { let value = blob(ctx, &c.version.slot)?; Some(fingerprint(ctx, &c.version.name, value.kind, value.value.expose())?) } }; + let state = match c.category { CandidateKind::Proposal => tr!("proposal"), CandidateKind::Held => tr!("held"), CandidateKind::Conflict => tr!("conflict") }; + candidates.push(serde_json::json!({"name": c.version.name, "state": state, "peer": label(ctx, &c.peer)?, "vid": c.version.vid, "fingerprint": fp.map(|f| hex(&f.0[..6]))})); + } + let mut peers = Vec::new(); + for (id, peer) in &s.peers { + peers.push(serde_json::json!({"label":label(ctx, id)?, "enabled":peer.enabled, "v2":peer.capable, + "breaker":s.limiter.is_tripped(&PeerId(id.clone())), "quarantine":peer.quarantine, "last_digest":peer.last_digest, "reoffer":peer.reoffer})); + } + let output = serde_json::json!({"items": rows, "candidates": candidates, "peers": peers, "frozen":s.frozen, + "capacity_blocked":s.capacity_blocked, "slots_used":s.slots.len(), "slot_capacity":SlotBudget::new(s.items.len()).capacity(), + "reconnect":s.reconnect, "notice":tr!("Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy.")}); + if json { ctx.emit(format!("{}\n", serde_json::to_string_pretty(&output).map_err(|_| state_error())?).as_bytes())?; } + else { + for row in rows.iter().chain(&candidates) { ctx.emit(format!("{} {} {} {}\n", row["name"].as_str().unwrap_or(""), row["state"].as_str().unwrap_or(""), + row["fingerprint"].as_str().unwrap_or("-"), row.get("peer").cloned().unwrap_or_else(|| row["peers"].clone())).as_bytes())?; } + for peer in peers { ctx.emit(format!("{}\n", peer).as_bytes())?; } + if s.capacity_blocked { crate::commands::say!(ctx, "{}", tr!("Sync storage is full; review pending items before retrying.")); } + if s.reconnect { crate::commands::say!(ctx, "{}", tr!("Sync delivery is queued; run `kc sync` to retry.")); } + crate::commands::say!(ctx, "{}", tr!("Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy.")); + } + Ok(if pending(&s) { 8 } else { 0 }) +} +pub(crate) fn review(ctx: &mut Ctx<'_, H>) -> Result { + if !ctx.interactive() { human(ctx, &tr!("Review sync changes."))?; } + let candidates = { + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + let mut s = State::load(&ctx.state)?; + scan(ctx, &mut s)?; + if s.frozen { return Ok(8) } + s.candidates.values().filter(|c| c.category != CandidateKind::Conflict).cloned().collect::>() + }; + let mut accepts = Vec::new(); let mut rejects = Vec::new(); + for c in candidates { + let fingerprint = if c.retire { "-".into() } else { + let value = blob(ctx, &c.version.slot)?; + hex(&super::fingerprint(ctx, &c.version.name, value.kind, value.value.expose())?.0[..6]) + }; + let existing = current(ctx, &c.version.name)?.map(|v| hex(&v.2.0[..6])).unwrap_or_else(|| "-".into()); + let question = tr!("Review {name} from {peer}: current {current}, proposed {proposed}.", name = c.version.name, peer = label(ctx, &c.peer)?, current = existing, proposed = fingerprint); + match ctx.select(&question, &[tr!("Accept"), tr!("Reject"), tr!("Leave for later")], 2)? { + 0 => accepts.push(c), 1 => rejects.push(c), _ => {}, + } + } + if !accepts.is_empty() { + human(ctx, &tr!("Review sync: accept {accept}, reject {reject}.", accept = accepts.len(), reject = rejects.len()))?; + } + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + let mut s = State::load(&ctx.state)?; + scan(ctx, &mut s)?; + for c in rejects { + if let Some(current) = s.candidates.remove(&c.version.slot) { + release(&mut s, ¤t.version.slot); s.gc.insert(current.base_record); + let delivery = delivery_key(&c.peer, &c.version.name, c.generation, c.version.vid); + if c.category == CandidateKind::Proposal { s.rejected_offers.insert(delivery); } + else { s.receipts.insert(delivery, (kc_proto::sync::AckResult::Rejected, ctx.host.now().saturating_add(3 * 86400))); } + if !c.legacy && c.category != CandidateKind::Proposal { + queue(&mut s, &c.peer, Control::Ack { id: kc_proto::sync::ChangeId { name: crate::values::item_name(&c.version.name)?, generation: c.generation, new_vid: c.version.vid }, result: kc_proto::sync::AckResult::Rejected }); + } + } + } + for c in accepts { + if s.frozen { break } + if let Some(current) = s.candidates.get(&c.version.slot).cloned() { + if current.category != CandidateKind::Conflict { transaction::accept(ctx, &mut s, ¤t)?; } + } + } + s.cleanup(ctx)?; + Ok(if pending(&s) { 8 } else { 0 }) +} +pub(crate) fn command(ctx: &mut Ctx<'_, H>, command: SyncCommand) -> Result { + if let SyncCommand::Status { json, confirm_checkpoint: None } = command { return status(ctx, json) } + if matches!(command, SyncCommand::Review) { return review(ctx) } + let no_auth = matches!(command, SyncCommand::Freeze | SyncCommand::Offer { .. } | SyncCommand::Peer { command: SyncPeerCommand::List }); + if !no_auth { human(ctx, &tr!("Confirm the requested sync operation."))?; } + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + let mut s = State::load(&ctx.state)?; + recover(ctx, &mut s)?; + match command { + SyncCommand::Add { mut names, peers } => { + if names.is_empty() { + let options = ctx.store.list()?.into_iter().map(|i| i.name).collect::>(); + names = ctx.multi_select(&tr!("Select sync items."), &options)?.into_iter().map(|i| options[i].clone()).collect(); + } + let peers = selected_peers(ctx, &s, &peers)?; + for name in &names { crate::values::item_name(name)?; let (v, _, _) = current(ctx, name)?.ok_or_else(state_error)?; size(&v)?; } + for name in names { + let (value, kind, fp) = current(ctx, &name)?.ok_or_else(state_error)?; + if !s.items.contains_key(&name) { + let head = Vid::random(); + remember(ctx, &name, head, fp, &[])?; + s.items.insert(name.clone(), Item { head, lineage: vec![head], parents: vec![], known: vec![head], scope: Default::default(), own: true, conflict: false }); + // Allocate receiver generation even when there are no peers yet. + s.generations.accept(&name, PeerId("mine".into())); + } + let _ = (value, kind); + offer(ctx, &mut s, &name, &peers)?; + } + } + SyncCommand::Offer { names, peers } => { + let peers = selected_peers(ctx, &s, &peers)?; + for name in names { + if !s.items.contains_key(&name) { return Err(state_error()) } + // An agent may propose only to the already locally approved scope. + let allowed = peers.iter().filter(|p| s.items[&name].scope.contains(*p)).cloned().collect::>(); + if allowed.len() != peers.len() { return Err(CliError::interaction(tr!("Sync needs local confirmation."))) } + // An explicit re-offer is a fresh proposal even if the previous vid + // was rejected. Transport retries keep the old vid and stay rejected. + if s.items[&name].conflict { return Err(CliError::new(8, tr!("Sync needs local confirmation."))) } + transaction::publish_current(ctx, &mut s, &name)?; + offer(ctx, &mut s, &name, &allowed)?; + } + } + SyncCommand::Rm { names } => { for name in names { crate::values::item_name(&name)?; remove(ctx, &mut s, &name)?; } } + SyncCommand::Freeze => s.frozen = true, + SyncCommand::Unfreeze => { + s.frozen = false; + for peer in s.peers.keys() { s.limiter.human_reset(&PeerId(peer.clone())); } + } + SyncCommand::Status { confirm_checkpoint: Some(name), .. } => { + if !s.items.contains_key(&name) { return Err(state_error()) } + let (value, kind, _) = current(ctx, &name)?.ok_or_else(state_error)?; + let slot = checkpoint_slot(&name); + if !reserve(ctx, &mut s, &slot, SlotKind::Checkpoint, false)? { return Err(capacity()) } + put_blob(ctx, &slot, kind, &value)?; + } + SyncCommand::RestoreCheckpoint { name } => { + scan(ctx, &mut s)?; + if !s.items.contains_key(&name) { return Err(state_error()) } + let value = blob(ctx, &checkpoint_slot(&name))?; + transaction::resolve_value(ctx, &mut s, &name, value.value.expose(), value.kind)?; + } + SyncCommand::Resolve { name, keep } => { + scan(ctx, &mut s)?; + let was_proposal = !s.items.contains_key(&name); + if was_proposal { + let scope = s.candidates.values().filter(|c| c.version.name == name && !c.legacy) + .map(|c| c.peer.clone()).collect::>(); + if scope.is_empty() { return Err(state_error()) } + let (_, _, fp) = current(ctx, &name)?.ok_or_else(state_error)?; + let head = Vid::random(); + remember(ctx, &name, head, fp, &[])?; + s.items.insert(name.clone(), Item { head, lineage: vec![head], parents: vec![], known: vec![head], scope: scope.clone(), own: true, conflict: true }); + for peer in scope { + let registration = s.generations.accept(&name, PeerId(peer.clone())); + queue(&mut s, &peer, Control::Accept { name: name.clone(), generation: registration.generation }); + } + } + let (value, kind) = if keep == "mine" { + let (v, k, _) = current(ctx, &name)?.ok_or_else(state_error)?; (v, k) + } else { + let peer = selected_peers(ctx, &s, &[keep])?.remove(0); + let options = s.candidates.values().filter(|c| c.version.name == name && c.peer == peer && !c.retire).cloned().collect::>(); + let choice = if options.len() > 1 { ctx.select(&tr!("Select sync items."), &options.iter().map(|c| vid_key(c.version.vid)).collect::>(), 0)? } else { 0 }; + let c = options.get(choice).ok_or_else(state_error)?; + let value = blob(ctx, &c.version.slot)?; + (Zeroizing::new(value.value.expose().to_vec()), value.kind) + }; + transaction::resolve_value(ctx, &mut s, &name, &value, kind)?; + } + SyncCommand::Peer { command } => match command { + SyncPeerCommand::List => { for (p, peer) in &s.peers { ctx.emit(format!("{} {}\n", label(ctx, p)?, peer.enabled).as_bytes())?; } } + SyncPeerCommand::Add { label } => { + let id = selected_peers(ctx, &s, &[label])?.remove(0); + let peer = s.peers.entry(id.clone()).or_default(); + peer.enabled = true; + if !peer.capable { peer.hello_sent = false; } + for name in s.items.keys().cloned().collect::>() { offer(ctx, &mut s, &name, std::slice::from_ref(&id))?; } + } + SyncPeerCommand::Rm { label } => { + let id = selected_peers(ctx, &s, &[label])?.remove(0); + s.peers.entry(id.clone()).or_default().enabled = false; + let names = s.items.iter().filter(|(_, i)| i.scope.contains(&id)).map(|(n, _)| n.clone()).collect::>(); + for name in names { + let (registration, _) = s.generations.rm(&name).map_err(|_| state_error())?; + s.items.get_mut(&name).unwrap().scope.remove(&id); + queue(&mut s, &id, Control::Leave { name: name.clone(), generation: registration.generation }); + for p in s.items[&name].scope.clone() { + s.generations.accept(&name, PeerId(p.clone())); + queue(&mut s, &p, Control::Accept { name: name.clone(), generation: registration.generation }); + } + } + s.offers.retain(|o| o.peer != id); + for change in s.outbox.pending(&PeerId(id.clone())).cloned().collect::>() { + s.outbox.ack(&PeerId(id.clone()), &change, kc_sync::AckResult::Rejected); + } + super::transport::collect_snapshots(&mut s); + } + }, + _ => {}, + } + s.cleanup(ctx)?; + Ok(if pending(&s) { 8 } else { 0 }) +} diff --git a/crates/kc-cli/src/sync/map.rs b/crates/kc-cli/src/sync/map.rs new file mode 100644 index 0000000..37e6784 --- /dev/null +++ b/crates/kc-cli/src/sync/map.rs @@ -0,0 +1,35 @@ +//! The only conversions between the transport and pure sync contracts. +use kc_proto::sync as wire; +use kc_sync as core; + +pub fn vid(v: wire::Vid) -> core::Vid { core::Vid(v.0) } +pub fn wire_vid(v: core::Vid) -> wire::Vid { wire::Vid(v.0) } +pub fn id(v: &wire::ChangeId) -> core::ChangeId { + core::ChangeId { name: v.name.to_string(), generation: v.generation, new_vid: vid(v.new_vid) } +} +pub fn ack(v: wire::AckResult) -> core::AckResult { + match v { + wire::AckResult::Applied => core::AckResult::Applied, + wire::AckResult::Held => core::AckResult::Held, + wire::AckResult::Conflict => core::AckResult::Conflict, + wire::AckResult::StaleGeneration => core::AckResult::StaleGeneration, + wire::AckResult::DeferredCapacity => core::AckResult::DeferredCapacity, + wire::AckResult::Rejected => core::AckResult::Rejected, + } +} +pub fn wire_ack(v: core::AckResult) -> wire::AckResult { + match v { + core::AckResult::Applied => wire::AckResult::Applied, + core::AckResult::Held => wire::AckResult::Held, + core::AckResult::Conflict => wire::AckResult::Conflict, + core::AckResult::StaleGeneration => wire::AckResult::StaleGeneration, + core::AckResult::DeferredCapacity => wire::AckResult::DeferredCapacity, + core::AckResult::Rejected => wire::AckResult::Rejected, + } +} +pub fn kind(v: wire::ItemKind) -> kc_store::ItemKind { + match v { wire::ItemKind::Text => kc_store::ItemKind::Text, wire::ItemKind::File => kc_store::ItemKind::File } +} +pub fn wire_kind(v: kc_store::ItemKind) -> wire::ItemKind { + match v { kc_store::ItemKind::Text => wire::ItemKind::Text, kc_store::ItemKind::File => wire::ItemKind::File } +} diff --git a/crates/kc-cli/src/sync/mod.rs b/crates/kc-cli/src/sync/mod.rs new file mode 100644 index 0000000..33c9545 --- /dev/null +++ b/crates/kc-cli/src/sync/mod.rs @@ -0,0 +1,164 @@ +//! Phase 1 persistence adapter: all mutations require items -> state locks. The pure +//! crate owns decisions, lineage, delivery accounting, generations, limits and recovery. +mod map; +mod state; +mod transaction; +mod transport; +mod receive; +pub(crate) mod actions; +pub(crate) use state::{State, CandidateKind}; +pub(crate) use transaction::{local_set, observed_write, scan, recover}; +pub(crate) use transport::{flush, send_after_write}; +pub(crate) use receive::{receive, legacy}; + +use hmac::{Hmac, Mac}; +use sha2::{Digest, Sha256}; +use serde::{Serialize, de::DeserializeOwned}; +use kc_proto::sync::{Vid, ItemKind}; +use kc_sync::{Fp, PeerId, SlotBudget, SlotKind, Reservation, VidRecord, ItemState}; +use zeroize::Zeroizing; +use crate::{commands::Ctx, error::{CliError, Result}, host::Host, i18n::tr, LocalAuthOutcome}; +use state::{Item, Version}; + +pub(crate) fn state_error() -> CliError { CliError::failure(tr!("Sync state is unavailable or damaged; retry after checking the keychain and state directory.")) } +pub(crate) fn human(ctx: &mut Ctx<'_, H>, reason: &str) -> Result<()> { + if !ctx.interactive() || ctx.host.local_confirm(reason) != LocalAuthOutcome::Confirmed { + return Err(CliError::interaction(tr!("Sync needs local confirmation.")) + .with_hint(tr!("Run this command at a terminal and confirm in the operating system."))); + } + Ok(()) +} +pub(crate) fn hex(bytes: &[u8]) -> String { bytes.iter().map(|b| format!("{b:02x}")).collect() } +fn tag(name: &str) -> String { hex(&Sha256::digest(name.as_bytes())) } +fn delivery_key(peer: &str, name: &str, generation: u64, vid: Vid) -> String { + format!("{peer}/{name}/{generation}/{}", hex(&vid.0)) +} +fn vid_key(vid: Vid) -> String { hex(&vid.0) } +fn record_slot(name: &str, vid: Vid) -> String { format!("sync/fp/{}/{}", tag(name), vid_key(vid)) } +fn snapshot_slot(vid: Vid) -> String { format!("sync/snapshot/{}", vid_key(vid)) } +fn checkpoint_slot(name: &str) -> String { format!("sync/kg/{}", tag(name)) } +fn candidate_slot(peer: &str, vid: Vid) -> String { format!("sync/candidate/{}/{}", tag(peer), vid_key(vid)) } +fn private_put(ctx: &Ctx<'_, H>, slot: &str, value: &T) -> Result<()> { + let bytes = Zeroizing::new(serde_json::to_vec(value).map_err(|_| state_error())?); + ctx.store.set_internal(slot, &bytes)?; + Ok(()) +} +fn private_get(ctx: &Ctx<'_, H>, slot: &str) -> Result { + let bytes = ctx.store.get_internal(slot)?.ok_or_else(state_error)?; + serde_json::from_slice(bytes.as_bytes()).map_err(|_| state_error()) +} +fn fingerprint(ctx: &Ctx<'_, H>, name: &str, kind: ItemKind, value: &[u8]) -> Result { + if ctx.store.get_internal("sync-key")?.is_none() { + let mut key = Zeroizing::new(Vec::with_capacity(32)); + key.extend_from_slice(&Vid::random().0); + key.extend_from_slice(&Vid::random().0); + ctx.store.set_internal("sync-key", &key)?; + } + let key = ctx.store.get_internal("sync-key")?.ok_or_else(state_error)?; + if key.as_bytes().len() != 32 { return Err(state_error()); } + let mut mac = Hmac::::new_from_slice(key.as_bytes()).map_err(|_| state_error())?; + mac.update(&(name.len() as u64).to_be_bytes()); + mac.update(name.as_bytes()); + mac.update(&[match kind { ItemKind::Text => 0, ItemKind::File => 1 }]); + mac.update(&(value.len() as u64).to_be_bytes()); + mac.update(value); + Ok(Fp(mac.finalize().into_bytes().into())) +} +fn current(ctx: &Ctx<'_, H>, name: &str) -> Result>, ItemKind, Fp)>> { + let Some(value) = ctx.store.get(name)? else { return Ok(None) }; + let kind = map::wire_kind(ctx.store.info(name)?.ok_or_else(state_error)?.kind); + let fp = fingerprint(ctx, name, kind, value.as_bytes())?; + Ok(Some((value.into_zeroizing(), kind, fp))) +} +fn remember(ctx: &Ctx<'_, H>, name: &str, vid: Vid, fp: Fp, parents: &[Vid]) -> Result { + let slot = record_slot(name, vid); + let binding = VidRecord { fp, parents: parents.iter().copied().map(map::vid).collect() }; + if ctx.store.get_internal(&slot)?.is_some() { + return Ok(private_get::<_, VidRecord>(ctx, &slot)? == binding); + } + private_put(ctx, &slot, &binding)?; + Ok(true) +} +fn pure(ctx: &Ctx<'_, H>, s: &State, name: &str, item: &Item) -> Result { + let rec: VidRecord = private_get(ctx, &record_slot(name, item.head))?; + let mut result = ItemState::new(s.generations.generation(name), map::vid(item.head), rec.fp, rec.parents); + result.lineage = kc_sync::Lineage::new(item.lineage.iter().copied().map(map::vid)); + for v in &item.known { result.remember(map::vid(*v), private_get(ctx, &record_slot(name, *v))?); } + for c in s.candidates.values().filter(|c| c.version.name == name && !c.retire && !c.invalid_binding) { + result.remember(map::vid(c.version.vid), private_get(ctx, &record_slot(name, c.version.vid))?); + } + if item.conflict { + let mut set = kc_sync::ConflictSet::default(); + set.candidates.insert(result.head, private_get(ctx, &record_slot(name, item.head))?); + for c in s.candidates.values().filter(|c| c.version.name == name && c.category == CandidateKind::Conflict) { + set.candidates.insert(map::vid(c.version.vid), private_get(ctx, &record_slot(name, c.version.vid))?); + } + result.conflict = Some(set); + } + Ok(result) +} +fn reserve(ctx: &Ctx<'_, H>, s: &mut State, slot: &str, kind: SlotKind, snapshot: bool) -> Result { + if let Some(existing) = s.slots.get_mut(slot) { + if kind > *existing { *existing = kind; } + return Ok(true) + } + let mut budget = SlotBudget::new(s.items.len()); + // Never evict existing data merely because rm reduced the capacity. + if s.slots.len() > budget.capacity() { s.capacity_blocked = true; return Ok(false) } + for (name, k) in &s.slots { + let result = if s.versions.values().any(|v| &v.slot == name) { + budget.reserve_snapshot(name) + } else { budget.reserve(name, *k) }; + if !matches!(result, Reservation::Reserved { evicted: None }) { return Err(state_error()) } + } + let result = if snapshot { budget.reserve_snapshot(slot) } else { budget.reserve(slot, kind) }; + match result { + Reservation::Refused => { s.capacity_blocked = true; Ok(false) } + Reservation::Reserved { evicted } => { + if let Some(victim) = evicted { + s.candidates.retain(|_, c| c.version.slot != victim); + s.slots.remove(&victim); + s.gc.insert(victim); + } + s.slots.insert(slot.to_owned(), kind); + s.capacity_blocked = false; + // Persist reservations before writes, leaving failed slot creation retryable. + s.save(&ctx.state)?; + Ok(true) + } + } +} +fn release(s: &mut State, slot: &str) { + if s.slots.get(slot) != Some(&SlotKind::Checkpoint) { + s.slots.remove(slot); + s.gc.insert(slot.to_owned()); + if s.slots.len() < SlotBudget::new(s.items.len()).capacity() { s.capacity_blocked = false; } + } +} +fn size(value: &[u8]) -> Result<()> { + if value.is_empty() || value.len() > 200 * 1024 { + return Err(CliError::usage(tr!("Sync items must contain between 1 byte and 200 KiB."))) + } + Ok(()) +} +fn capacity() -> CliError { CliError::new(8, tr!("Sync storage is full; review pending items before retrying.")) } +pub(crate) fn pending_code(ctx: &Ctx<'_, H>) -> Result { + let s = State::load(&ctx.state)?; + Ok(if pending(&s) { 8 } else { 0 }) +} +fn pending(s: &State) -> bool { + s.frozen || s.capacity_blocked || s.reconnect || !s.candidates.is_empty() || !s.offers.is_empty() + || s.items.values().any(|i| i.conflict) + || s.peers.iter().any(|(p, state)| !state.reoffer.is_empty() || !state.quarantine.is_empty() + || s.limiter.is_tripped(&PeerId(p.clone())) || s.outbox.pending(&PeerId(p.clone())).next().is_some()) +} +fn log(ctx: &mut Ctx<'_, H>, text: String) -> Result<()> { + use std::io::Write; + let path = ctx.state.root().join("sync.log"); + if std::fs::metadata(&path).is_ok_and(|m| m.len() >= 1024 * 1024) { + std::fs::rename(&path, ctx.state.root().join("sync.log.1")).map_err(|_| state_error())?; + } + if !path.exists() { crate::state::write_private_atomic(&path, b"").map_err(|_| state_error())?; } + let mut file = std::fs::OpenOptions::new().append(true).open(&path).map_err(|_| state_error())?; + writeln!(file, "{text}").map_err(|_| state_error()) +} diff --git a/crates/kc-cli/src/sync/receive.rs b/crates/kc-cli/src/sync/receive.rs new file mode 100644 index 0000000..dff8842 --- /dev/null +++ b/crates/kc-cli/src/sync/receive.rs @@ -0,0 +1,302 @@ +use super::*; +use kc_proto::sync::{SyncMsg, Change, Op, AckResult, ChangeId}; +use kc_sync::{Incoming, Transition, RemoteOperation, LimitResult}; +use state::{Candidate, CandidateKind, Control, Peer}; +use transaction::{queue, put_blob}; + +pub(crate) fn receive(ctx: &mut Ctx<'_, H>, peer: &str, message: &SyncMsg) -> Result<()> { + // The shared inbox owns both locks before entering this adapter. + let mut s = State::load(&ctx.state)?; + scan(ctx, &mut s)?; + s.receipts.retain(|_, (_, until)| *until >= ctx.host.now()); + s.attempts.retain(|_, until| *until >= ctx.host.now()); + let p = s.peers.entry(peer.into()).or_insert_with(|| Peer { enabled: true, ..Peer::default() }); + match message { + SyncMsg::Hello { is_reply, .. } => { + p.capable = true; + s.reconnect = false; + if !is_reply { queue(&mut s, peer, Control::Hello { reply: true }); } + } + SyncMsg::Offer { name, vid, lineage, kind, value, known_generation } => { + let name = name.as_str(); + if *known_generation < s.generations.generation(name) { + log(ctx, tr!("Ignored a stale sync offer for {name}.", name = name))?; + } else if s.rejected_offers.contains(&delivery_key(peer, name, *known_generation, *vid)) { + // A rejected proposal is never resurrected by a transport retry. + } else if lineage.len() <= 64 && value.expose().len() <= 200 * 1024 && !value.expose().is_empty() { + let version = Version { name: name.into(), vid: *vid, parents: vec![], lineage: lineage.clone(), kind: *kind, slot: candidate_slot(peer, *vid) }; + let fp = fingerprint(ctx, name, *kind, value.expose())?; + // Offers carry no parent assertion; never replace an existing binding. + let existing = ctx.store.get_internal(&record_slot(name, *vid))?; + if existing.is_some() && private_get::<_, VidRecord>(ctx, &record_slot(name, *vid))?.fp != fp { + s.peers.get_mut(peer).unwrap().quarantine.insert(name.into()); + } else if s.items.get(name).is_some_and(|i| i.head == *vid && i.scope.contains(peer)) { + let generation = s.generations.generation(name); + queue(&mut s, peer, Control::Accept { name: name.into(), generation }); + } else if !s.candidates.contains_key(&version.slot) { + let times = s.proposals_today.entry(peer.into()).or_default(); + times.retain(|at| (ctx.host.now() as i128) - (*at as i128) < 86400); + let allowed = times.len() < ctx.settings.sync.max_proposals_per_day; + let stored = allowed && store_candidate(ctx, &mut s, peer, version, *known_generation, CandidateKind::Proposal, value.expose(), false, false)?; + if stored { s.proposals_today.entry(peer.into()).or_default().push(ctx.host.now()); } + if !stored { + s.capacity_blocked = true; + queue(&mut s, peer, Control::Ack { id: ChangeId { name: crate::values::item_name(name)?, generation: *known_generation, new_vid: *vid }, result: AckResult::DeferredCapacity }); + } + } + } + } + SyncMsg::Accept { name, generation } => { + let name = name.as_str(); + // A peer may grant a generation only for an item explicitly offered to it, + // or the reciprocal half of a locally accepted proposal. + let wanted = s.offers.iter().any(|o| o.peer == peer && o.name == name) + || s.items.get(name).is_some_and(|i| i.scope.contains(peer)); + let previously_accepted = s.generations.outgoing_generation(&PeerId(peer.into()), name).is_some(); + if wanted && *generation >= 1 && s.generations.received_accept(PeerId(peer.into()), kc_sync::Registration { name: name.into(), generation: *generation }) { + let own = s.generations.accept(name, PeerId(peer.into())); + if let Some(item) = s.items.get_mut(name) { item.scope.insert(peer.into()); } + s.offers.retain(|o| o.peer != peer || o.name != name); + s.peers.get_mut(peer).unwrap().reoffer.remove(name); + s.outbox.accepted(&PeerId(peer.into()), name); + if !previously_accepted { queue(&mut s, peer, Control::Accept { name: name.into(), generation: own.generation }); } + if !previously_accepted && s.items.get(name).is_some_and(|i| i.own) { + super::transport::resend(ctx, &mut s, peer, name)?; + } + } + } + SyncMsg::Leave { name, generation } => { + let name = name.as_str(); + let expected = s.items.get(name).is_some_and(|i| i.scope.contains(peer)) + || s.generations.known_generation(&PeerId(peer.into()), name) != 0; + if expected && s.generations.received_leave(PeerId(peer.into()), kc_sync::Registration { name: name.into(), generation: *generation }) { + s.peers.get_mut(peer).unwrap().reoffer.insert(name.into()); + let ids: Vec<_> = s.outbox.pending(&PeerId(peer.into())).filter(|id| id.name == name).cloned().collect(); + for id in ids { s.outbox.ack(&PeerId(peer.into()), &id, kc_sync::AckResult::StaleGeneration); } + s.offers.retain(|o| o.peer != peer || o.name != name); + } + } + SyncMsg::Changes { changes } => { + for change in changes { change_received(ctx, &mut s, peer, change)?; } + } + SyncMsg::Ack { results } => { + for (id, result) in results { + let expected = s.outbox.pending(&PeerId(peer.into())).any(|pending| *pending == map::id(id)) + || s.offers.iter().any(|o| o.peer == peer && o.name == id.name.as_str() && o.vid == id.new_vid); + if !expected { continue } + let delivery = delivery_key(peer, id.name.as_str(), id.generation, id.new_vid); + if *result == AckResult::DeferredCapacity { + s.deferred.insert(delivery); + } else { s.deferred.remove(&delivery); } + let matched = s.outbox.ack(&PeerId(peer.into()), &map::id(id), map::ack(*result)); + if matched && *result == AckResult::StaleGeneration { + s.peers.get_mut(peer).unwrap().reoffer.insert(id.name.to_string()); + } + } + } + SyncMsg::Digest { entries } => { + for entry in entries { + let name = entry.name.as_str(); + let generation = s.generations.generation(name); + if entry.generation < generation { + queue(&mut s, peer, Control::Leave { name: name.into(), generation }); + continue; + } + if let Some(item) = s.items.get(name).cloned() { + if item.own && item.head != entry.head && item.lineage.contains(&entry.head) && item.scope.contains(peer) { + super::transport::resend(ctx, &mut s, peer, name)?; + } else if item.head != entry.head && item.scope.contains(peer) { + s.peers.get_mut(peer).unwrap().reoffer.insert(name.into()); + } + } + } + } + SyncMsg::Approvals { .. } => log(ctx, tr!("Ignored signed approvals: Phase 1 requires local review."))?, + } + super::transport::collect_snapshots(&mut s); + s.cleanup(ctx) +} +fn ack(s: &mut State, peer: &str, c: &Change, result: AckResult) { + queue(s, peer, Control::Ack { id: ChangeId { name: c.name.clone(), generation: c.generation, new_vid: c.new_vid }, result }); +} +fn change_received(ctx: &mut Ctx<'_, H>, s: &mut State, peer: &str, c: &Change) -> Result<()> { + let name = c.name.as_str(); + let Some(item) = s.items.get(name).cloned() else { ack(s, peer, c, AckResult::StaleGeneration); return Ok(()) }; + if !item.scope.contains(peer) || !s.generations.includes(name, &PeerId(peer.into())) || c.generation != s.generations.generation(name) { + ack(s, peer, c, AckResult::StaleGeneration); return Ok(()) + } + let (value, kind, retire) = match &c.op { + Op::Put { kind, value } => (value.expose(), *kind, false), + Op::Retire => (&[][..], ItemKind::Text, true), + }; + if (!retire && size(value).is_err()) || c.parents.len() > 256 { ack(s, peer, c, AckResult::Rejected); return Ok(()) } + if s.peers[peer].quarantine.contains(name) { ack(s, peer, c, AckResult::Rejected); return Ok(()) } + let slot = candidate_slot(peer, c.new_vid); + let fp = if retire { None } else { Some(fingerprint(ctx, name, kind, value)?) }; + let delivery = delivery_key(peer, name, c.generation, c.new_vid); + if let Some((AckResult::Rejected, _)) = s.receipts.get(&delivery) { + ack(s, peer, c, AckResult::Rejected); return Ok(()) + } + let current_fp = current(ctx, name)?.map_or(Fp([0;32]), |v| v.2); + let mut state = pure(ctx, s, name, &item)?; + // An accepted Offer has no parent field. Bind its first explicit parent assertion + // only when the fingerprint still matches the immutable offered value. + let unbound = format!("{}:{}", name, vid_key(c.new_vid)); + if s.unbound.contains(&unbound) { + if let Some(rec) = state.known.get_mut(&map::vid(c.new_vid)) { + if Some(rec.fp) == fp { + rec.parents = c.parents.iter().copied().map(map::vid).collect(); + private_put(ctx, &record_slot(name, c.new_vid), rec)?; + s.unbound.remove(&unbound); + } + } + } + let incoming = Incoming { generation: c.generation, new_vid: map::vid(c.new_vid), + parents: c.parents.iter().copied().map(map::vid).collect(), + lineage: kc_sync::Lineage::new(c.lineage.iter().copied().map(map::vid)), value_fp: fp, retire }; + let unseen = !s.attempts.contains_key(&delivery) && !s.candidates.contains_key(&slot) && !state.lineage.contains(&incoming.new_vid); + let overwrite = retire || fp != Some(current_fp); + let mut within = ctx.settings.sync.max_remote_overwrites != 0; + if unseen && overwrite { + let op = if retire { RemoteOperation::Retire } else { RemoteOperation::Overwrite }; + within &= s.limiter.check(&PeerId(peer.into()), name, op, ctx.host.now(), s.items.len(), false) == LimitResult::Allowed; + // Phase 1 counts durably received overwrite attempts, although they are held. + s.limiter.record(&PeerId(peer.into()), name, op, ctx.host.now(), false); + s.attempts.insert(delivery.clone(), ctx.host.now().saturating_add(3 * 86400)); + } + let frozen = s.frozen || !s.peers[peer].enabled || s.limiter.is_tripped(&PeerId(peer.into())); + let decision = kc_sync::decide(&state, current_fp, &incoming, frozen, None, within); + if decision.quarantine { s.peers.get_mut(peer).unwrap().quarantine.insert(name.into()); } + let mut result = map::wire_ack(decision.ack); + match decision.transition { + Transition::Hold { .. } | Transition::Conflict { .. } => { + let category = if result == AckResult::Conflict { CandidateKind::Conflict } else { CandidateKind::Held }; + if category == CandidateKind::Conflict { preserve_mine(ctx, s, name, &item)?; } + let version = Version { name: name.into(), vid: c.new_vid, parents: c.parents.clone(), lineage: c.lineage.clone(), kind, slot: slot.clone() }; + if !store_candidate(ctx, s, peer, version, c.generation, category, value, retire, false)? { + result = AckResult::DeferredCapacity; + } else if category == CandidateKind::Conflict { s.items.get_mut(name).unwrap().conflict = true; } + } + Transition::Advance { head, lineage, write_value: false, .. } => { + if let Some(fp) = fp { + if !remember(ctx, name, c.new_vid, fp, &c.parents)? { return Err(state_error()) } + } + let item = s.items.get_mut(name).unwrap(); + item.head = map::wire_vid(head); + item.lineage = lineage.iter().copied().map(map::wire_vid).collect(); + if item.head == c.new_vid { item.parents = c.parents.clone(); item.own = false; } + if !item.known.contains(&c.new_vid) { item.known.push(c.new_vid); } + } + Transition::Unchanged => {}, + // No verified approval is ever constructed in Phase 1. + _ => return Err(state_error()), + } + if result != AckResult::DeferredCapacity { + s.receipts.insert(delivery, (result, ctx.host.now().saturating_add(3 * 86400))); + } + ack(s, peer, c, result); + s.save(&ctx.state)?; + let result_text = match result { + AckResult::Applied => tr!("in sync"), AckResult::Held => tr!("held"), AckResult::Conflict => tr!("conflict"), + AckResult::Rejected => tr!("declined"), AckResult::StaleGeneration => tr!("re-offer needed"), + AckResult::DeferredCapacity => tr!("Sync storage is full; review pending items before retrying."), + }; + log(ctx, tr!("Sync {name}: {result}.", name = name, result = result_text))?; + Ok(()) +} +pub(super) fn preserve_mine(ctx: &Ctx<'_, H>, s: &mut State, name: &str, item: &Item) -> Result<()> { + let slot = candidate_slot("mine", item.head); + if s.candidates.contains_key(&slot) { return Ok(()) } + if let Some((value, kind, _)) = current(ctx, name)? { + if size(&value).is_err() { return Ok(()) } + let version = Version { name: name.into(), vid: item.head, parents: item.parents.clone(), lineage: item.lineage.clone(), kind, slot }; + if !store_candidate(ctx, s, "mine", version, s.generations.generation(name), CandidateKind::Conflict, &value, false, false)? { return Err(capacity()) } + } + Ok(()) +} +pub(super) fn store_candidate(ctx: &Ctx<'_, H>, s: &mut State, peer: &str, mut v: Version, generation: u64, + category: CandidateKind, value: &[u8], retire: bool, legacy: bool) -> Result { + let mut invalid_binding = false; + if !retire && category != CandidateKind::Proposal && ctx.store.get_internal(&record_slot(&v.name, v.vid))?.is_some() { + let record: VidRecord = private_get(ctx, &record_slot(&v.name, v.vid))?; + invalid_binding = record.fp != fingerprint(ctx, &v.name, v.kind, value)? + || record.parents != v.parents.iter().copied().map(map::vid).collect::>(); + } + if invalid_binding { + // Freeze precedes immutable-VID violations: retain the evidence without changing + // the immutable binding. Review must turn it into a conflict, never apply that vid. + for old in s.candidates.values().filter(|c| c.peer == peer && c.version.vid == v.vid && c.invalid_binding && c.version.parents == v.parents) { + let stored = transaction::blob(ctx, &old.version.slot)?; + if stored.kind == v.kind && stored.value.expose() == value { return Ok(true) } + } + v.slot.push_str(&format!("/{}", hex(&Vid::random().0[..4]))); + } + if let Some(old) = s.candidates.get(&v.slot) { + if old.version.parents != v.parents || old.retire != retire { return Ok(false) } + if !retire { + let old_value = transaction::blob(ctx, &v.slot)?; + if old_value.value.expose() != value || old_value.kind != v.kind { return Ok(false) } + } + if category == CandidateKind::Conflict { + s.candidates.get_mut(&v.slot).unwrap().category = category; + s.slots.insert(v.slot.clone(), SlotKind::ConflictCandidate); + } + return Ok(true); + } + let kind = match category { CandidateKind::Proposal => SlotKind::Proposal, CandidateKind::Held => SlotKind::Held, CandidateKind::Conflict => SlotKind::ConflictCandidate }; + if !reserve(ctx, s, &v.slot, kind, false)? { return Ok(false) } + let base = current(ctx, &v.name)?.map_or(Fp([0;32]), |v| v.2); + let base_record = format!("sync/base/{}", vid_key(Vid::random())); + private_put(ctx, &base_record, &base)?; + if !retire { + put_blob(ctx, &v.slot, v.kind, value)?; + let fp = fingerprint(ctx, &v.name, v.kind, value)?; + if category == CandidateKind::Proposal { + if ctx.store.get_internal(&record_slot(&v.name, v.vid))?.is_none() { + remember(ctx, &v.name, v.vid, fp, &[])?; + s.unbound.insert(format!("{}:{}", v.name, vid_key(v.vid))); + } + } else if !invalid_binding && !remember(ctx, &v.name, v.vid, fp, &v.parents)? { + release(s, &v.slot); s.gc.insert(base_record); return Ok(false) + } + } + if !retire && !invalid_binding { + if let Some(item) = s.items.get_mut(&v.name) { + if !item.known.contains(&v.vid) { item.known.push(v.vid); } + while item.known.len() > 256 { + let index = item.known.iter().position(|vid| *vid != item.head).unwrap(); + item.known.remove(index); + } + } + } + let key = v.slot.clone(); + s.candidates.insert(key, Candidate { peer: peer.into(), generation, category, base_head: s.items.get(&v.name).map(|i| i.head), + version: v, base_record, retire, legacy, invalid_binding }); + Ok(true) +} +/// Existing v1/code imports enter the same review path. Caller already owns both locks. +/// A terminal may confirm the individual overwrite locally; noninteractive imports hold. +pub(crate) fn legacy(ctx: &mut Ctx<'_, H>, item: &kc_proto::payload::Item, from: &str) -> Result> { + let mut s = State::load(&ctx.state)?; + if !s.items.contains_key(item.name.as_str()) { return Ok(None) } + recover(ctx, &mut s)?; + scan(ctx, &mut s)?; + let name = item.name.as_str(); + let kind = if std::str::from_utf8(item.value.expose()).is_ok() { ItemKind::Text } else { ItemKind::File }; + if current(ctx, name)?.is_some_and(|v| v.0.as_slice() == item.value.expose()) { return Ok(Some(kc_proto::ItemStatus::Unchanged)) } + size(item.value.expose())?; + let peer = ctx.state.load_peers()?.find(from).map(|p| p.fingerprint.to_hex()).unwrap_or_else(|| "legacy".into()); + let vid = Vid::random(); + let v = Version { name: name.into(), vid, parents: vec![s.items[name].head], lineage: s.items[name].lineage.clone(), kind, slot: candidate_slot(&peer, vid) }; + let slot = v.slot.clone(); + let generation = s.generations.generation(name); + if !store_candidate(ctx, &mut s, &peer, v, generation, CandidateKind::Held, item.value.expose(), false, true)? { s.cleanup(ctx)?; return Ok(Some(kc_proto::ItemStatus::SkippedConflict)) } + s.save(&ctx.state)?; + if ctx.interactive() && !s.frozen { + human(ctx, &tr!("Confirm sync changes ({n} items).", n = 1))?; + let c = s.candidates[&slot].clone(); + if transaction::accept(ctx, &mut s, &c)? { return Ok(Some(kc_proto::ItemStatus::Stored)) } + } + s.cleanup(ctx)?; + Ok(Some(kc_proto::ItemStatus::SkippedConflict)) +} diff --git a/crates/kc-cli/src/sync/state.rs b/crates/kc-cli/src/sync/state.rs new file mode 100644 index 0000000..36afc2a --- /dev/null +++ b/crates/kc-cli/src/sync/state.rs @@ -0,0 +1,126 @@ +//! Public metadata contains neither values nor HMAC fingerprints. Secret transaction +//! records live in immutable keychain slots, referenced by the durable journal pointer. +use std::collections::{BTreeMap, BTreeSet}; +use serde::{Deserialize, Serialize}; +use kc_proto::sync::{Vid, ItemKind, ChangeId, AckResult}; +use kc_sync::{Generations, Limiter, Outbox, SlotKind}; +use crate::{commands::Ctx, host::Host, error::Result, state::StateDir}; + +#[derive(Clone, Serialize, Deserialize)] +pub struct Item { + pub head: Vid, + pub lineage: Vec, + pub parents: Vec, + pub known: Vec, + pub scope: BTreeSet, + pub own: bool, + pub conflict: bool, +} +#[derive(Clone, Serialize, Deserialize)] +pub struct Version { + pub name: String, + pub vid: Vid, + pub parents: Vec, + pub lineage: Vec, + pub kind: ItemKind, + pub slot: String, +} +#[derive(Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum CandidateKind { Proposal, Held, Conflict } +#[derive(Clone, Serialize, Deserialize)] +pub struct Candidate { + pub peer: String, + pub version: Version, + pub generation: u64, + pub category: CandidateKind, + pub base_head: Option, + pub base_record: String, + pub retire: bool, + pub legacy: bool, + #[serde(default)] + pub invalid_binding: bool, +} +#[derive(Clone, Default, Serialize, Deserialize)] +pub struct Peer { + pub hello_sent: bool, + pub capable: bool, + pub enabled: bool, + pub last_digest: Option, + pub reoffer: BTreeSet, + pub quarantine: BTreeSet, +} +// These are intentionally NOT SyncMsg: that wire enum can contain secret values. +#[derive(Clone, Serialize, Deserialize)] +pub enum Control { + Hello { reply: bool }, + Accept { name: String, generation: u64 }, + Leave { name: String, generation: u64 }, + Ack { id: ChangeId, result: AckResult }, +} +#[derive(Clone, Serialize, Deserialize)] +pub struct Offer { + pub peer: String, + pub name: String, + pub vid: Vid, +} +#[derive(Clone, Serialize, Deserialize)] +pub struct Journal { + pub record: String, + pub name: String, +} +#[derive(Default, Serialize, Deserialize)] +pub struct State { + pub frozen: bool, + #[serde(default)] + pub proposals_today: BTreeMap>, + #[serde(default)] + pub receipts: BTreeMap, + #[serde(default)] + pub attempts: BTreeMap, + #[serde(default)] + pub deferred: BTreeSet, + #[serde(default)] + pub rejected_offers: BTreeSet, + #[serde(default)] + pub unbound: BTreeSet, + pub items: BTreeMap, + pub peers: BTreeMap, + pub generations: Generations, + pub outbox: Outbox, + pub limiter: Limiter, + pub versions: BTreeMap, + #[serde(default)] + pub latest_local: BTreeMap, + pub offers: Vec, + pub controls: Vec<(String, Control)>, + pub candidates: BTreeMap, + pub slots: BTreeMap, + pub journal: Option, + pub capacity_blocked: bool, + pub reconnect: bool, + pub gc: BTreeSet, +} +impl State { + pub fn load(dir: &StateDir) -> Result { + let path = dir.root().join("sync.json"); + match std::fs::read(path) { + Ok(bytes) => serde_json::from_slice(&bytes).map_err(|_| super::state_error()), + Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(Self::default()), + Err(_) => Err(super::state_error()), + } + } + pub fn save(&self, dir: &StateDir) -> Result<()> { + crate::state::create_private_dir(dir.root())?; + let bytes = serde_json::to_vec_pretty(self).map_err(|_| super::state_error())?; + crate::state::write_private_atomic(&dir.root().join("sync.json"), &bytes) + .map_err(|_| super::state_error()) + } + pub fn cleanup(&mut self, ctx: &Ctx<'_, H>) -> Result<()> { + // Metadata is durable before deletion. A restart repeats only harmless deletes. + self.save(&ctx.state)?; + for slot in &self.gc { ctx.store.delete_internal(slot)?; } + self.gc.clear(); + self.save(&ctx.state) + } +} diff --git a/crates/kc-cli/src/sync/transaction.rs b/crates/kc-cli/src/sync/transaction.rs new file mode 100644 index 0000000..34266fb --- /dev/null +++ b/crates/kc-cli/src/sync/transaction.rs @@ -0,0 +1,285 @@ +use super::*; +use serde::{Deserialize, Serialize}; +use kc_store::{Origin, SetOutcome}; +use kc_sync::{LocalJournalRecord, RemoteJournalRecord, QueueTarget, LocalRecovery, RemoteRecovery}; +use state::{Journal, Candidate, Control}; + +#[derive(Serialize, Deserialize)] +pub(super) struct Blob { pub kind: ItemKind, pub value: kc_proto::SecretBytes } +pub(super) fn put_blob(ctx: &Ctx<'_, H>, slot: &str, kind: ItemKind, value: &[u8]) -> Result<()> { + private_put(ctx, slot, &Blob { kind, value: kc_proto::SecretBytes::from_slice(value) }) +} +pub(super) fn blob(ctx: &Ctx<'_, H>, slot: &str) -> Result { private_get(ctx, slot) } +#[derive(Serialize, Deserialize)] +enum Intent { + Local { record: LocalJournalRecord, version: Version, clear: bool }, + Remote { record: RemoteJournalRecord, candidate: Candidate }, + // Store's restore/adopt API does not expose the intended value before the mutation. + // This durable pre-intent makes an interrupted operation recoverable by observation. + Observe { name: String, previous: Fp, vid: Vid, parents: Vec, snapshot: String }, +} +fn intent(ctx: &Ctx<'_, H>, s: &mut State, name: &str, record: &Intent) -> Result<()> { + let slot = format!("sync/journal/{}", vid_key(Vid::random())); + private_put(ctx, &slot, record)?; + if let Some(old) = s.journal.replace(Journal { record: slot, name: name.into() }) { s.gc.insert(old.record); } + s.save(&ctx.state) +} +fn clear_intent(ctx: &Ctx<'_, H>, s: &mut State) -> Result<()> { + if let Some(j) = s.journal.take() { s.gc.insert(j.record); } + s.cleanup(ctx) +} +fn interrupted(ctx: &mut Ctx<'_, H>) -> Result<()> { + if ctx.host.sync_interrupt_after_write() { return Err(state_error()) } + Ok(()) +} +fn prepare_local(ctx: &Ctx<'_, H>, s: &mut State, name: &str, previous: Fp, kind: ItemKind, + value: &[u8], parents: Vec, vid: Vid, clear: bool) -> Result<(LocalJournalRecord, Version)> { + size(value)?; + let slot = snapshot_slot(vid); + if !reserve(ctx, s, &slot, SlotKind::ConflictCandidate, true)? { return Err(capacity()) } + let item = s.items.get(name).ok_or_else(state_error)?; + let new_fp = fingerprint(ctx, name, kind, value)?; + let record = LocalJournalRecord { + name: name.into(), prev_fp: previous, new_fp, new_vid: map::vid(vid), + parents: parents.iter().copied().map(map::vid).collect(), snapshot_slot: slot.clone(), + targets: item.scope.iter().filter_map(|p| s.generations.outgoing_generation(&PeerId(p.clone()), name) + .map(|generation| QueueTarget { peer: PeerId(p.clone()), generation })).collect(), + }; + let lineage = kc_sync::Lineage::new(item.lineage.iter().chain(&parents).copied().map(map::vid)) + .with_head(map::vid(vid)).iter().copied().map(map::wire_vid).collect(); + let version = Version { name: name.into(), vid, parents, lineage, kind, slot }; + intent(ctx, s, name, &Intent::Local { record: record.clone(), version: version.clone(), clear })?; + Ok((record, version)) +} +fn finish_local(ctx: &Ctx<'_, H>, s: &mut State, r: &LocalJournalRecord, v: &Version, clear: bool) -> Result<()> { + if !remember(ctx, &r.name, v.vid, r.new_fp, &v.parents)? { return Err(state_error()) } + let item = s.items.get_mut(&r.name).ok_or_else(state_error)?; + item.head = v.vid; item.lineage = v.lineage.clone(); item.parents = v.parents.clone(); item.own = true; + if !item.known.contains(&v.vid) { item.known.push(v.vid); } + if item.known.len() > 256 { item.known.remove(0); } + if clear { item.conflict = false; } + s.versions.insert(vid_key(v.vid), v.clone()); + s.latest_local.insert(r.name.clone(), v.vid); + for target in &r.targets { + s.outbox.enqueue(target.peer.clone(), kc_sync::ChangeId { name: r.name.clone(), generation: target.generation, new_vid: r.new_vid }); + } + for offer in &mut s.offers { if offer.name == r.name { offer.vid = v.vid; } } + if clear { clear_candidates(s, &r.name); } + s.save(&ctx.state) +} +pub(super) fn clear_candidates(s: &mut State, name: &str) { + let keys: Vec<_> = s.candidates.iter().filter(|(_, c)| c.version.name == name).map(|(k, _)| k.clone()).collect(); + for key in keys { if let Some(c) = s.candidates.remove(&key) { release(s, &c.version.slot); s.gc.insert(c.base_record); } } +} +pub(crate) fn local_set(ctx: &mut Ctx<'_, H>, name: &str, value: &[u8], kind: kc_store::ItemKind, origin: Origin) -> Result { + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + let mut s = State::load(&ctx.state)?; + recover(ctx, &mut s)?; + if !s.items.contains_key(name) { return Ok(ctx.store.set(name, value, kind, origin)?) } + scan_one(ctx, &mut s, name)?; + let item = s.items[name].clone(); + if item.conflict { super::receive::preserve_mine(ctx, &mut s, name, &item)?; } + let previous = current(ctx, name)?.map_or(Fp([0;32]), |v| v.2); + let k = map::wire_kind(kind); + if fingerprint(ctx, name, k, value)? == previous { return Ok(ctx.store.set(name, value, kind, origin)?) } + let parents = vec![s.items[name].head]; + let (r, v) = prepare_local(ctx, &mut s, name, previous, k, value, parents, Vid::random(), false)?; + let outcome = ctx.store.set(name, value, kind, origin)?; + interrupted(ctx)?; + put_blob(ctx, &v.slot, k, value)?; + finish_local(ctx, &mut s, &r, &v, false)?; + clear_intent(ctx, &mut s)?; + Ok(outcome) +} +pub(crate) fn observed_write(ctx: &mut Ctx<'_, H>, name: &str, + write: impl FnOnce(&crate::keychain::Keychain) -> std::result::Result) -> Result { + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + let mut s = State::load(&ctx.state)?; + recover(ctx, &mut s)?; + if !s.items.contains_key(name) { return Ok(write(&ctx.store)?) } + scan_one(ctx, &mut s, name)?; + let item = s.items[name].clone(); + if item.conflict { super::receive::preserve_mine(ctx, &mut s, name, &item)?; } + let previous = current(ctx, name)?.map_or(Fp([0;32]), |v| v.2); + let vid = Vid::random(); + let snapshot = snapshot_slot(vid); + if !reserve(ctx, &mut s, &snapshot, SlotKind::ConflictCandidate, true)? { return Err(capacity()) } + let parents = vec![s.items[name].head]; + intent(ctx, &mut s, name, &Intent::Observe { name: name.into(), previous, vid, parents, snapshot })?; + let result = write(&ctx.store)?; + interrupted(ctx)?; + recover(ctx, &mut s)?; + Ok(result) +} +pub(crate) fn scan(ctx: &mut Ctx<'_, H>, s: &mut State) -> Result<()> { + recover(ctx, s)?; + for name in s.items.keys().cloned().collect::>() { + scan_one(ctx, s, &name)?; + let item = s.items[&name].clone(); + if item.conflict { super::receive::preserve_mine(ctx, s, &name, &item)?; } + } + s.cleanup(ctx) +} +fn scan_one(ctx: &mut Ctx<'_, H>, s: &mut State, name: &str) -> Result<()> { + let Some((value, kind, fp)) = current(ctx, name)? else { + s.items.get_mut(name).ok_or_else(state_error)?.conflict = true; + return s.save(&ctx.state); + }; + if size(&value).is_err() { + s.items.get_mut(name).unwrap().conflict = true; + return s.save(&ctx.state); + } + let item = &s.items[name]; + let binding: VidRecord = private_get(ctx, &record_slot(name, item.head))?; + if fp == binding.fp { return Ok(()) } + let parents = vec![item.head]; + let (r, v) = prepare_local(ctx, s, name, binding.fp, kind, &value, parents, Vid::random(), false)?; + put_blob(ctx, &v.slot, kind, &value)?; + finish_local(ctx, s, &r, &v, false)?; + clear_intent(ctx, s) +} +pub(super) fn publish_current(ctx: &mut Ctx<'_, H>, s: &mut State, name: &str) -> Result<()> { + let (value, kind, fp) = current(ctx, name)?.ok_or_else(state_error)?; + let parents = vec![s.items[name].head]; + let (r, v) = prepare_local(ctx, s, name, fp, kind, &value, parents, Vid::random(), false)?; + put_blob(ctx, &v.slot, kind, &value)?; + finish_local(ctx, s, &r, &v, false)?; + clear_intent(ctx, s) +} +pub(super) fn resolve_value(ctx: &mut Ctx<'_, H>, s: &mut State, name: &str, value: &[u8], kind: ItemKind) -> Result<()> { + let item = &s.items[name]; + if !item.conflict && !s.candidates.values().any(|c| c.version.name == name) + && current(ctx, name)?.is_some_and(|v| v.1 == kind && v.0.as_slice() == value) { + return Ok(()); + } + let mut parents = vec![item.head]; + parents.extend(s.candidates.values().filter(|c| c.version.name == name).map(|c| c.version.vid)); + parents.sort(); parents.dedup(); + let fp = current(ctx, name)?.map_or(Fp([0;32]), |v| v.2); + let (r, v) = prepare_local(ctx, s, name, fp, kind, value, parents, Vid::random(), true)?; + ctx.store.set(name, value, map::kind(kind), Origin::Local)?; + interrupted(ctx)?; + put_blob(ctx, &v.slot, kind, value)?; + finish_local(ctx, s, &r, &v, true)?; + clear_intent(ctx, s) +} +pub(super) fn accept(ctx: &mut Ctx<'_, H>, s: &mut State, c: &Candidate) -> Result { + let name = &c.version.name; + let now = current(ctx, name)?; + let actual = now.as_ref().map_or(Fp([0;32]), |v| v.2); + let expected: Fp = private_get(ctx, &c.base_record)?; + let head = s.items.get(name).map(|i| i.head); + if actual != expected || head != c.base_head || c.invalid_binding { + if c.invalid_binding { + if let Some(peer) = s.peers.get_mut(&c.peer) { peer.quarantine.insert(name.into()); } + } + let key = c.version.slot.clone(); + if let Some(c) = s.candidates.get_mut(&key) { c.category = CandidateKind::Conflict; } + if let Some(item) = s.items.get_mut(name) { item.conflict = true; } + s.save(&ctx.state)?; + return Ok(false); + } + if c.retire { + super::actions::remove(ctx, s, name)?; + return Ok(true); + } + let value = blob(ctx, &c.version.slot)?; + let fp = fingerprint(ctx, name, value.kind, value.value.expose())?; + let checkpoint = if now.is_some() { Some(checkpoint_slot(name)) } else { None }; + if let Some(slot) = &checkpoint { + if !reserve(ctx, s, slot, SlotKind::Checkpoint, false)? { return Ok(false) } + } + let lineage = kc_sync::Lineage::new(c.version.lineage.iter().copied().chain(head).map(map::vid)) + .with_head(map::vid(c.version.vid)); + let r = RemoteJournalRecord { + change_id: kc_sync::ChangeId { name: name.clone(), generation: c.generation, new_vid: map::vid(c.version.vid) }, + sender: PeerId(c.peer.clone()), prev_fp: actual, new_fp: fp, + head: map::vid(c.version.vid), lineage, approval_key: None, ack: kc_sync::AckResult::Applied, + checkpoint_slot: checkpoint.clone(), candidate_slot: c.version.slot.clone(), + }; + intent(ctx, s, name, &Intent::Remote { record: r.clone(), candidate: c.clone() })?; + if let (Some(slot), Some((old, old_kind, _))) = (&checkpoint, now) { + if ctx.store.get_internal(slot)?.is_none() { put_blob(ctx, slot, old_kind, &old)?; } + } + ctx.store.set(name, value.value.expose(), map::kind(value.kind), Origin::Received { from_device: super::actions::label(ctx, &c.peer)? })?; + interrupted(ctx)?; + finish_remote(ctx, s, &r, c)?; + clear_intent(ctx, s)?; + Ok(true) +} +fn finish_remote(ctx: &Ctx<'_, H>, s: &mut State, r: &RemoteJournalRecord, c: &Candidate) -> Result<()> { + let name = &r.change_id.name; + if !remember(ctx, name, c.version.vid, r.new_fp, &c.version.parents)? { return Err(state_error()) } + let proposal = c.category == CandidateKind::Proposal; + let mut scope = s.items.get(name).map(|i| i.scope.clone()).unwrap_or_default(); + if !c.legacy { scope.insert(c.peer.clone()); } + let mut known = s.items.get(name).map(|i| i.known.clone()).unwrap_or_default(); + if !known.contains(&c.version.vid) { known.push(c.version.vid); } + if known.len() > 256 { known.remove(0); } + s.items.insert(name.clone(), Item { head: c.version.vid, lineage: r.lineage.iter().copied().map(map::wire_vid).collect(), + parents: c.version.parents.clone(), known, scope, own: false, conflict: false }); + if proposal { + let registration = s.generations.accept(name, PeerId(c.peer.clone())); + queue(s, &c.peer, Control::Accept { name: name.clone(), generation: registration.generation }); + // Both peers grant their own generations. The reciprocal Accept is sent once. + } else if !c.legacy { + queue(s, &c.peer, Control::Ack { id: kc_proto::sync::ChangeId { name: crate::values::item_name(name)?, generation: c.generation, new_vid: c.version.vid }, result: map::wire_ack(r.ack) }); + } + clear_candidates(s, name); + s.save(&ctx.state) +} +pub(super) fn queue(s: &mut State, peer: &str, message: Control) { + // Coalesce metadata-only controls; messages never contain values or fingerprints. + let encoded = serde_json::to_vec(&message).unwrap_or_default(); + if !s.controls.iter().any(|(p, c)| p == peer && serde_json::to_vec(c).unwrap_or_default() == encoded) { + s.controls.push((peer.into(), message)); + } +} +pub(crate) fn recover(ctx: &mut Ctx<'_, H>, s: &mut State) -> Result<()> { + let Some(journal) = s.journal.clone() else { return Ok(()) }; + let record: Intent = private_get(ctx, &journal.record)?; + match record { + Intent::Local { record: r, version: v, clear } => { + let cur = current(ctx, &r.name)?; + let fp = cur.as_ref().map_or(Fp([0;32]), |v| v.2); + let committed = s.items.get(&r.name).is_some_and(|i| map::vid(i.head) == r.new_vid); + let exists = ctx.store.get_internal(&r.snapshot_slot)?.is_some(); + match kc_sync::recover_local(r.prev_fp, r.new_fp, fp, committed, exists) { + LocalRecovery::RebuildSnapshotAndCommit => { + let (value, kind, _) = cur.ok_or_else(state_error)?; + put_blob(ctx, &r.snapshot_slot, kind, &value)?; + finish_local(ctx, s, &r, &v, clear)?; + } + LocalRecovery::Commit => finish_local(ctx, s, &r, &v, clear)?, + LocalRecovery::CleanJournal | LocalRecovery::KeepSnapshotAndScan => {}, + LocalRecovery::DiscardSnapshot | LocalRecovery::DiscardSnapshotAndScan => release(s, &r.snapshot_slot), + } + } + Intent::Remote { record: r, candidate: c } => { + let fp = current(ctx, &r.change_id.name)?.map_or(Fp([0;32]), |v| v.2); + match kc_sync::recover_remote(&r, fp) { + RemoteRecovery::FinishFromStep4 => finish_remote(ctx, s, &r, &c)?, + RemoteRecovery::Retry => {}, + RemoteRecovery::Conflict => { + if let Some(item) = s.items.get_mut(&r.change_id.name) { item.conflict = true; } + if let Some(candidate) = s.candidates.get_mut(&c.version.slot) { candidate.category = CandidateKind::Conflict; } + } + } + } + Intent::Observe { name, previous, vid, parents, snapshot } => { + if let Some((value, kind, fp)) = current(ctx, &name)? { + if size(&value).is_err() { + s.items.get_mut(&name).ok_or_else(state_error)?.conflict = true; + release(s, &snapshot); + } else if fp != previous { + let (r, v) = prepare_local(ctx, s, &name, previous, kind, &value, parents, vid, false)?; + put_blob(ctx, &v.slot, kind, &value)?; + finish_local(ctx, s, &r, &v, false)?; + } else { release(s, &snapshot); } + } else { release(s, &snapshot); } + } + } + clear_intent(ctx, s) +} diff --git a/crates/kc-cli/src/sync/transport.rs b/crates/kc-cli/src/sync/transport.rs new file mode 100644 index 0000000..a4b48da --- /dev/null +++ b/crates/kc-cli/src/sync/transport.rs @@ -0,0 +1,139 @@ +use super::*; +use kc_proto::inbox::{self, Body}; +use kc_proto::sync::{SyncMsg, Change, Op, DigestEntry}; +use kc_proto::payload::WriterToken; +use kc_proto::relay::RelayApi; +use std::time::Duration; +use state::Control; + +fn control(c: &Control) -> Result { + Ok(match c { + Control::Hello { reply } => SyncMsg::Hello { features: vec!["sync-phase1".into()], is_reply: *reply }, + Control::Accept { name, generation } => SyncMsg::Accept { name: crate::values::item_name(name)?, generation: *generation }, + Control::Leave { name, generation } => SyncMsg::Leave { name: crate::values::item_name(name)?, generation: *generation }, + Control::Ack { id, result } => SyncMsg::Ack { results: vec![(id.clone(), *result)] }, + }) +} +async fn post(ctx: &Ctx<'_, H>, peer: &crate::state::Peer, message: SyncMsg) -> Result<()> { + let key = crate::commands::pairing::device_key(ctx)?.ok_or_else(state_error)?; + let stored = ctx.store.get_internal(&peer.token_key())?.ok_or_else(state_error)?; + let raw = Zeroizing::new(<[u8;32]>::try_from(stored.as_bytes()).map_err(|_| state_error())?); + let token = WriterToken::from_bytes(*raw); + let body = Body::Sync(message); + // seal_v2 checks the actual postcard plaintext/padded/envelope size against 256 KiB. + let sealed = inbox::seal_v2(&key, &peer.device_pk, &body, Duration::from_secs(kc_wire::limits::INBOX_MESSAGE_TTL_SECS), ctx.host.now())?; + ctx.connect()?.post_message(&peer.inbox_id.to_b64url(), &token.bearer(), &sealed.body).await + .map_err(|error| { let mut error = CliError::from(error); error.code = 6; error })?; + Ok(()) +} +async fn deliver(ctx: &Ctx<'_, H>, s: &mut State, peer: &crate::state::Peer, message: SyncMsg) -> Result<()> { + if let Err(error) = post(ctx, peer, message).await { + s.reconnect = true; + s.save(&ctx.state)?; + return Err(error); + } + Ok(()) +} +pub(crate) async fn flush(ctx: &mut Ctx<'_, H>, digest: bool) -> Result { + if !ctx.state.root().join("sync.json").exists() { return Ok(0) } + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + let mut s = State::load(&ctx.state)?; + recover(ctx, &mut s)?; + let peers = ctx.state.load_peers()?; + let mut sent = 0; + for peer in &peers.peers { + let id = peer.fingerprint.to_hex(); + let Some(p) = s.peers.get(&id) else { continue }; + if !p.capable { + if !p.hello_sent { + s.peers.get_mut(&id).unwrap().hello_sent = true; + // Persist before attempting: an unknown peer gets at most one initial Hello. + s.save(&ctx.state)?; + deliver(ctx, &mut s, peer, SyncMsg::Hello { features: vec!["sync-phase1".into()], is_reply: false }).await?; + } + continue; + } + let controls = s.controls.iter().filter(|(p, _)| p == &id).cloned().collect::>(); + for entry in controls { + deliver(ctx, &mut s, peer, control(&entry.1)?).await?; + let bytes = serde_json::to_vec(&entry).map_err(|_| state_error())?; + if let Some(i) = s.controls.iter().position(|c| serde_json::to_vec(c).ok().as_ref() == Some(&bytes)) { s.controls.remove(i); } + s.save(&ctx.state)?; + } + if !s.peers[&id].enabled { continue } + let digest_due = digest && s.peers[&id].last_digest.is_none_or(|last| (ctx.host.now() as i128) - (last as i128) >= 86400); + let offers = s.offers.iter().filter(|o| o.peer == id).cloned().collect::>(); + for offer in offers { + let generation = s.generations.known_generation(&PeerId(id.clone()), &offer.name); + if s.deferred.contains(&delivery_key(&id, &offer.name, generation, offer.vid)) { continue } + let Some(v) = s.versions.get(&vid_key(offer.vid)).cloned() else { return Err(state_error()) }; + let value = transaction::blob(ctx, &v.slot)?; + deliver(ctx, &mut s, peer, SyncMsg::Offer { name: crate::values::item_name(&v.name)?, vid: v.vid, lineage: v.lineage.clone(), + kind: value.kind, value: value.value, + known_generation: generation }).await?; + sent += 1; + } + let ids: Vec<_> = s.outbox.pending(&PeerId(id.clone())).cloned().collect(); + for change in &ids { + if let Some(latest) = s.latest_local.get(&change.name) { + if change.new_vid != map::vid(*latest) && ids.iter().any(|id| id.name == change.name && id.new_vid == map::vid(*latest)) { continue } + } + if s.deferred.contains(&delivery_key(&id, &change.name, change.generation, map::wire_vid(change.new_vid))) { continue } + let v = s.versions.get(&vid_key(map::wire_vid(change.new_vid))).cloned().ok_or_else(state_error)?; + let value = transaction::blob(ctx, &v.slot)?; + deliver(ctx, &mut s, peer, SyncMsg::Changes { changes: vec![Change { name: crate::values::item_name(&v.name)?, generation: change.generation, + new_vid: v.vid, parents: v.parents.clone(), lineage: v.lineage.clone(), + op: Op::Put { kind: value.kind, value: value.value }, approval_ref: None }] }).await?; + sent += 1; + } + if digest_due { + let entries: Vec<_> = s.items.iter().filter(|(_, i)| i.scope.contains(&id)).map(|(name, i)| { + Ok(DigestEntry { name: crate::values::item_name(name)?, head: i.head, + generation: s.generations.known_generation(&PeerId(id.clone()), name) }) + }).collect::>()?; + // A conservative count bound keeps each chunk small; sealing still enforces + // the actual serialized size instead of assuming byte lengths from item values. + for chunk in entries.chunks(256) { deliver(ctx, &mut s, peer, SyncMsg::Digest { entries: chunk.to_vec() }).await?; } + s.peers.get_mut(&id).unwrap().last_digest = Some(ctx.host.now()); + s.deferred.retain(|key| !key.starts_with(&format!("{id}/"))); + s.save(&ctx.state)?; + } + } + collect_snapshots(&mut s); + s.cleanup(ctx)?; + Ok(sent) +} +pub(super) fn collect_snapshots(s: &mut State) { + let versions = s.versions.values().cloned().collect::>(); + for v in versions { + let waiting = s.offers.iter().any(|o| o.vid == v.vid) + || s.peers.keys().any(|p| s.outbox.pending(&PeerId(p.clone())).any(|c| c.new_vid == map::vid(v.vid) && c.name == v.name)); + if !waiting { + s.outbox.release_snapshot(&v.name, map::vid(v.vid)); + release(s, &v.slot); + // Retain only the metadata for the latest locally authored head, for digest. + if s.items.get(&v.name).is_none_or(|i| i.head != v.vid || !i.own) { s.versions.remove(&vid_key(v.vid)); } + } + } +} +pub(super) fn resend(ctx: &Ctx<'_, H>, s: &mut State, peer: &str, name: &str) -> Result<()> { + let item = s.items[name].clone(); + if !item.own { return Ok(()) } + let Some(generation) = s.generations.outgoing_generation(&PeerId(peer.into()), name) else { return Ok(()) }; + let v = s.versions.get(&vid_key(item.head)).cloned().ok_or_else(state_error)?; + if !s.slots.contains_key(&v.slot) { + let Some((value, kind, fp)) = current(ctx, name)? else { return Ok(()) }; + let record: VidRecord = private_get(ctx, &record_slot(name, item.head))?; + if fp != record.fp { return Ok(()) } + if !reserve(ctx, s, &v.slot, SlotKind::ConflictCandidate, true)? { return Ok(()) } + transaction::put_blob(ctx, &v.slot, kind, &value)?; + } + s.outbox.enqueue(PeerId(peer.into()), kc_sync::ChangeId { name: name.into(), generation, new_vid: map::vid(v.vid) }); + Ok(()) +} +pub(crate) async fn send_after_write(ctx: &mut Ctx<'_, H>) { + if let Err(_) = flush(ctx, false).await { + crate::commands::say!(ctx, "{}", tr!("Sync delivery is queued; run `kc sync` to retry.")); + } +} diff --git a/crates/kc-cli/tests/common/mod.rs b/crates/kc-cli/tests/common/mod.rs index a299feb..5c4664e 100644 --- a/crates/kc-cli/tests/common/mod.rs +++ b/crates/kc-cli/tests/common/mod.rs @@ -280,12 +280,20 @@ impl Host for TestHost<'_, N> { &mut self.console } - fn local_confirm(&mut self, _reason: &str) -> LocalAuthOutcome { + fn local_confirm(&mut self, reason: &str) -> LocalAuthOutcome { + self.console.prompts.push(format!("local confirmation: {reason}")); self.local_auth.pop_front().unwrap_or_else(|| { LocalAuthOutcome::Unavailable("no scripted local confirmation".into()) }) } + fn sync_interrupt_after_write(&mut self) -> bool { + if let Some(index) = self.env.iter().position(|(k, _)| k == "TEST_SYNC_CRASH") { + self.env.remove(index); + true + } else { false } + } + fn env_var(&self, key: &str) -> Option { self.env .iter() @@ -377,8 +385,12 @@ impl Device { fn store_with(&self, interactive: bool) -> kc_store::Result { match &self.keychain { Keychain::Memory(mem) => { + // Sync tests isolate virtual keychain namespaces as real devices do; + // unrelated test cases must not contend on one OS-wide items lock. + let namespace = self.env.iter().find(|(key, _)| key == "TEST_NAMESPACE") + .map_or(NAMESPACE, |(_, value)| value.as_str()); let cfg = - StoreConfig::new(NAMESPACE, self.dir.path()).with_interactive(interactive); + StoreConfig::new(namespace, self.dir.path()).with_interactive(interactive); Store::open_with_memory_backend(cfg, mem) } Keychain::Os { namespace } => Store::open( diff --git a/crates/kc-cli/tests/sync.rs b/crates/kc-cli/tests/sync.rs new file mode 100644 index 0000000..375fbcd --- /dev/null +++ b/crates/kc-cli/tests/sync.rs @@ -0,0 +1,344 @@ +//! Real CLI flows through two isolated memory keychains and the authenticated relay. +mod common; +use common::{Answer, Device, Run, transfer}; +use kc_cli::LocalAuthOutcome; +use kc_proto::memory_relay::MemoryRelay; +use kc_proto::relay::RelayApi; +use kc_proto::sync::{SyncMsg, Op, Change, Vid}; +use kc_proto::{ItemName, SecretBytes}; +use serde_json::Value; + +fn human(answers: Vec) -> Run { + let mut run = Run::human(answers); + run.local_auth.push_back(LocalAuthOutcome::Confirmed); + run +} +fn state(d: &Device) -> Value { + serde_json::from_slice(&std::fs::read(d.dir.path().join("sync.json")).unwrap()).unwrap() +} +fn head(d: &Device) -> Vid { serde_json::from_value(state(d)["items"]["KEY"]["head"].clone()).unwrap() } +async fn pair(a: &Device, b: &Device) { + let (rx, tx) = transfer(b, &["pair"], Run::human(vec![Answer::Yes]), a, &["pair", "--join"], + |code| Run::human(vec![Answer::Text(code), Answer::Yes])).await; + rx.expect(0); tx.expect(0); +} +async fn devices() -> (Device, Device, MemoryRelay) { + let relay = MemoryRelay::new(); + let mut a = Device::new("alpha", relay.clone()); let mut b = Device::new("bravo", relay.clone()); + for device in [&mut a, &mut b] { + device.env.push(("TEST_NAMESPACE".into(), format!("dev.1pass.kc.sync-{}", u128::from_be_bytes(Vid::random().0)))); + } + pair(&a, &b).await; + (a, b, relay) +} +async fn pump(a: &Device, b: &Device) { + for _ in 0..3 { for d in [a, b] { + let out = d.run(&["sync"], Run::agent()).await; + assert!([0,8].contains(&out.code), "{}", out.stderr); + } } +} +async fn enroll(a: &Device, b: &Device) { + a.set("KEY", b"fake-initial-secret").await; + a.run(&["sync", "add", "KEY", "--peers", "bravo"], human(vec![])).await.expect(8); + pump(a,b).await; + assert!(b.value("KEY").is_none()); + assert_eq!(state(b)["candidates"].as_object().unwrap().len(), 1); + let out = b.run(&["sync", "review"], human(vec![Answer::Select(0)])).await; + assert!([0,8].contains(&out.code), "{}", out.stderr); + assert_eq!(out.prompts.iter().filter(|p| p.starts_with("local confirmation:")).count(), 1); + pump(a,b).await; + assert_eq!(head(a), head(b)); +} +async fn post(a: &Device, b: &Device, relay: &MemoryRelay, msg: SyncMsg) { + let key = a.store().get_internal("device-key").unwrap().unwrap(); + let key = kc_proto::DeviceKeyPair::from_secret_bytes(key.as_bytes()).unwrap(); + let peer = a.peers().find("bravo").unwrap().clone(); + let sealed = kc_proto::inbox::seal_v2(&key, &peer.device_pk, &kc_proto::inbox::Body::Sync(msg), + std::time::Duration::from_secs(86400), kc_proto::inbox::unix_now()).unwrap(); + relay.post_message(&b.inbox_credentials().0, &a.writer_bearer("bravo"), &sealed.body).await.unwrap(); +} +#[tokio::test] +async fn add_offer_review_local_confirmation_and_accept_on_both_sides() { + let (a,b,_) = devices().await; + enroll(&a,&b).await; + assert_eq!(a.value("KEY"), b.value("KEY")); + a.run(&["sync", "status", "--json"], Run::agent()).await.expect(0); + b.run(&["sync", "status", "--json"], Run::agent()).await.expect(0); + assert!(state(&a)["slots"].as_object().unwrap().keys().all(|k| !k.contains("snapshot"))); +} +#[tokio::test] +async fn local_change_is_held_review_converges_and_ack_releases_snapshot() { + let (a,b,_) = devices().await; enroll(&a,&b).await; + a.set("KEY", b"fake-second-secret").await; + pump(&a,&b).await; + assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); + assert!(state(&b)["candidates"].as_object().unwrap().values().any(|v| v["category"] == "held")); + assert!(state(&a)["slots"].as_object().unwrap().keys().all(|k| !k.contains("snapshot"))); + b.run(&["sync", "review"], human(vec![Answer::Select(0)])).await.expect(0); + pump(&a,&b).await; + assert_eq!(head(&a), head(&b)); assert_eq!(a.value("KEY"), b.value("KEY")); + b.run(&["sync", "restore-checkpoint", "KEY"], human(vec![])).await.expect(8); + assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); +} +#[tokio::test] +async fn concurrent_changes_conflict_resolve_is_held_then_converges() { + let (a,b,_) = devices().await; enroll(&a,&b).await; + a.set("KEY", b"fake-alpha-change").await; b.set("KEY", b"fake-bravo-change").await; + pump(&a,&b).await; + assert_eq!(state(&a)["items"]["KEY"]["conflict"], true); + assert_eq!(state(&b)["items"]["KEY"]["conflict"], true); + a.run(&["sync", "resolve", "KEY", "--keep", "mine"], human(vec![])).await.expect(8); + pump(&a,&b).await; + assert_eq!(b.value("KEY").unwrap(), b"fake-bravo-change"); + b.run(&["sync", "review"], human(vec![Answer::Select(0)])).await.expect(0); + pump(&a,&b).await; + assert_eq!(head(&a), head(&b)); assert_eq!(a.value("KEY"), b.value("KEY")); + assert!(state(&b)["candidates"].as_object().unwrap().is_empty()); +} +#[tokio::test] +async fn remove_bumps_generation_late_change_is_stale_and_requires_reoffer() { + let (a,b,relay) = devices().await; enroll(&a,&b).await; + let old = head(&a); + b.run(&["sync", "rm", "KEY"], human(vec![])).await.expect(0); + post(&a,&b,&relay, SyncMsg::Changes { changes: vec![Change { name: ItemName::new("KEY").unwrap(), generation: 1, + new_vid: Vid::random(), parents: vec![old], lineage: vec![old], op: Op::Put { kind: kc_proto::sync::ItemKind::Text, value: SecretBytes::from_slice(b"late-fake") }, approval_ref: None }] }).await; + pump(&a,&b).await; + assert!(state(&b)["items"].as_object().unwrap().is_empty()); + assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); + assert!(a.run(&["sync", "status", "--json"], Run::agent()).await.stdout_text().contains("re-offer needed")); + a.run(&["sync", "offer", "KEY", "--peers", "bravo"], Run::agent()).await.expect(8); + pump(&a,&b).await; + b.run(&["sync", "review"], human(vec![Answer::Select(0)])).await.expect(0); + pump(&a,&b).await; + assert_eq!(head(&a),head(&b)); +} +#[tokio::test] +async fn v1_imports_normal_items_but_holds_sync_overwrites_and_rm_refuses() { + let (a,b,_) = devices().await; enroll(&a,&b).await; + a.store().set("KEY", b"fake-v1-overwrite", kc_store::ItemKind::Text, kc_store::Origin::Local).unwrap(); + a.set("OTHER", b"fake-normal").await; + a.run(&["send", "KEY", "OTHER", "--to", "bravo"], Run::agent()).await.expect(0); + b.run(&["inbox"], Run::agent()).await.expect(8); + assert_eq!(b.value("OTHER").unwrap(), b"fake-normal"); + assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); + b.run(&["rm", "KEY", "--yes"], Run::agent()).await.expect(5); +} +#[tokio::test] +async fn noninteractive_add_review_and_denied_local_confirmation_exit_five() { + let relay=MemoryRelay::new(); let a=Device::new("alpha", relay); + a.set("KEY", b"fake").await; + for args in [vec!["sync","add","KEY"],vec!["sync","review"],vec!["sync","unfreeze"]] { + a.run(&args, Run::agent()).await.expect(5); + } + let mut denied=Run::human(vec![]); denied.local_auth.push_back(LocalAuthOutcome::Denied); + a.run(&["sync","add","KEY"], denied).await.expect(5); + a.run(&["sync","add","KEY"], Run::human(vec![])).await.expect(5); +} +#[tokio::test] +async fn crash_after_local_and_remote_keychain_writes_recovers_journal() { + let (a,b,_) = devices().await; enroll(&a,&b).await; + let mut crash=Run::agent().stdin(b"fake-crash-local".to_vec()); crash.env.push(("TEST_SYNC_CRASH".into(),"1".into())); + a.run(&["set","KEY"], crash).await.expect(1); + assert!(!state(&a)["journal"].is_null()); + pump(&a,&b).await; + assert!(state(&a)["journal"].is_null()); + let mut crash=human(vec![Answer::Select(0)]); crash.env.push(("TEST_SYNC_CRASH".into(),"1".into())); + b.run(&["sync","review"], crash).await.expect(1); + assert!(!state(&b)["journal"].is_null()); + assert_eq!(b.value("KEY").unwrap(), b"fake-crash-local"); + pump(&a,&b).await; + assert!(state(&b)["journal"].is_null()); assert_eq!(head(&a),head(&b)); +} +#[tokio::test] +async fn unknown_peer_gets_exactly_one_hello_and_no_offer_until_reply() { + let (a,b,relay)=devices().await; a.set("KEY",b"fake").await; + a.run(&["sync","add","KEY","--peers","bravo"],human(vec![])).await.expect(8); + for _ in 0..3 { a.run(&["sync"],Run::agent()).await.expect(8); } + let (id,owner)=b.inbox_credentials(); + let listing=relay.list_messages(&id,&owner,std::time::Duration::ZERO).await.unwrap(); + assert_eq!(listing.messages.len(),1); + let key=b.store().get_internal("device-key").unwrap().unwrap(); + let key=kc_proto::DeviceKeyPair::from_secret_bytes(key.as_bytes()).unwrap(); + let sender=b.peers().find("alpha").unwrap().device_pk; + let bytes=kc_proto::relay::message_body(&listing.messages[0]).unwrap(); + let opened=kc_proto::inbox::open_any(&bytes,&[&key], |_|Some(sender), |_|false,kc_proto::inbox::unix_now()).unwrap(); + assert!(matches!(opened.body,kc_proto::inbox::Body::Sync(SyncMsg::Hello { is_reply:false,.. }))); +} +#[tokio::test] +async fn freeze_holds_changes_and_status_and_state_never_contain_values() { + let (a,b,_) = devices().await; enroll(&a,&b).await; + b.run(&["sync","freeze"],Run::agent()).await.expect(8); + a.set("KEY",b"fake-freeze-secret").await; pump(&a,&b).await; + assert_eq!(b.value("KEY").unwrap(),b"fake-initial-secret"); + let status=b.run(&["sync","status","--json"],Run::agent()).await; + status.expect(8); assert!(status.stdout_text().contains("frozen")); + for text in [status.stdout_text(), std::fs::read_to_string(b.dir.path().join("sync.json")).unwrap()] { + assert!(!text.contains("fake-")); + } + b.run(&["sync","unfreeze"],human(vec![])).await.expect(8); + b.run(&["sync","review"],human(vec![Answer::Select(0)])).await.expect(0); + pump(&a,&b).await; assert_eq!(head(&a),head(&b)); +} + +#[tokio::test] +async fn stale_unseen_offer_is_ignored_and_digest_recovers_a_lost_leave() { + let (a,b,relay)=devices().await; enroll(&a,&b).await; + b.run(&["sync","rm","KEY"],human(vec![])).await.expect(0); + // Lose every Leave already posted to A. + let (id,owner)=a.inbox_credentials(); + for msg in relay.list_messages(&id,&owner,std::time::Duration::ZERO).await.unwrap().messages { + relay.delete_message(&id,&owner,&msg.msg_id).await.unwrap(); + } + post(&a,&b,&relay,SyncMsg::Offer { name:ItemName::new("KEY").unwrap(),vid:Vid::random(),lineage:vec![], + kind:kc_proto::sync::ItemKind::Text,value:SecretBytes::from_slice(b"fake-stale-offer"),known_generation:1 }).await; + b.run(&["inbox"],Run::agent()).await.expect(0); + assert!(state(&b)["candidates"].as_object().unwrap().is_empty()); + post(&a,&b,&relay,SyncMsg::Digest { entries:vec![kc_proto::sync::DigestEntry { name:ItemName::new("KEY").unwrap(),generation:1,head:head(&a) }] }).await; + b.run(&["inbox"],Run::agent()).await.expect(0); + a.run(&["inbox"],Run::agent()).await.expect(8); + assert!(a.run(&["sync","status","--json"],Run::agent()).await.stdout_text().contains("re-offer needed")); +} +#[tokio::test] +async fn overwrite_attempts_trip_breaker_and_immutable_vid_is_quarantined() { + let (a,b,relay)=devices().await; enroll(&a,&b).await; + let parent=head(&b); let first=Vid::random(); + for n in 0..6 { + post(&a,&b,&relay,SyncMsg::Changes { changes:vec![Change { name:ItemName::new("KEY").unwrap(),generation:1, + new_vid:if n==0 {first} else {Vid::random()},parents:vec![parent],lineage:vec![parent], + op:Op::Put {kind:kc_proto::sync::ItemKind::Text,value:SecretBytes::from_slice(format!("fake-{n}").as_bytes())},approval_ref:None }] }).await; + } + b.run(&["inbox"],Run::agent()).await.expect(8); + let status=b.run(&["sync","status","--json"],Run::agent()).await; + let json:Value=serde_json::from_slice(&status.stdout).unwrap(); + assert_eq!(json["peers"][0]["breaker"],true); + assert_eq!(b.value("KEY").unwrap(),b"fake-initial-secret"); + b.run(&["sync","unfreeze"],human(vec![])).await.expect(8); + post(&a,&b,&relay,SyncMsg::Changes {changes:vec![Change {name:ItemName::new("KEY").unwrap(),generation:1,new_vid:first, + parents:vec![parent],lineage:vec![parent],op:Op::Put {kind:kc_proto::sync::ItemKind::Text,value:SecretBytes::from_slice(b"fake-mutated-vid")},approval_ref:None}]}).await; + b.run(&["inbox"],Run::agent()).await.expect(8); + assert!(state(&b)["peers"].as_object().unwrap().values().any(|p| p["quarantine"].as_array().unwrap().contains(&Value::String("KEY".into())))); +} +#[tokio::test] +async fn capacity_defers_seventeenth_proposal_without_storing_its_value() { + let (a,b,relay)=devices().await; + for n in 0..17 { + post(&a,&b,&relay,SyncMsg::Offer {name:ItemName::new(&format!("KEY{n}")).unwrap(),vid:Vid::random(),lineage:vec![],known_generation:0, + kind:kc_proto::sync::ItemKind::Text,value:SecretBytes::from_slice(b"fake-capacity")}).await; + } + b.run(&["inbox"],Run::agent()).await.expect(8); + let s=state(&b); + assert_eq!(s["candidates"].as_object().unwrap().len(),16); + assert_eq!(s["slots"].as_object().unwrap().len(),16); + assert_eq!(s["capacity_blocked"],true); + assert!(b.value("KEY16").is_none()); +} +#[tokio::test] +async fn recovery_never_overwrites_a_third_value_written_after_crash() { + let (a,b,_) = devices().await; enroll(&a,&b).await; + a.set("KEY",b"fake-remote-intent").await; pump(&a,&b).await; + let mut crash=human(vec![Answer::Select(0)]);crash.env.push(("TEST_SYNC_CRASH".into(),"1".into())); + b.run(&["sync","review"],crash).await.expect(1); + b.store().set("KEY",b"fake-third-value",kc_store::ItemKind::Text,kc_store::Origin::Local).unwrap(); + b.run(&["sync"],Run::agent()).await.expect(8); + assert_eq!(b.value("KEY").unwrap(),b"fake-third-value"); + assert_eq!(state(&b)["items"]["KEY"]["conflict"],true); + assert!(state(&b)["journal"].is_null()); +} +#[tokio::test] +async fn restore_and_adopt_publish_local_versions_and_checkpoint_confirmation_is_gated() { + let (a,b,_) = devices().await; enroll(&a,&b).await; + a.set("KEY",b"fake-next").await; + let before=head(&a); + a.run(&["restore","KEY"],Run::agent()).await.expect(0); + assert_ne!(before,head(&a)); + assert_eq!(a.value("KEY").unwrap(),b"fake-initial-secret"); + a.memory().insert("foreign-service","account",b"fake-adopted"); + let before=head(&a); + a.run(&["adopt","--service","foreign-service","--account","account","--as","KEY"],Run::agent()).await.expect(0); + assert_ne!(before,head(&a)); + assert_eq!(a.value("KEY").unwrap(),b"fake-adopted"); + a.run(&["sync","status","--confirm-checkpoint","KEY"],Run::agent()).await.expect(5); + a.run(&["sync","status","--confirm-checkpoint","KEY"],human(vec![])).await.expect(8); + a.set("KEY",b"fake-later").await; + a.run(&["sync","restore-checkpoint","KEY"],human(vec![])).await.expect(8); + assert_eq!(a.value("KEY").unwrap(),b"fake-adopted"); +} +#[tokio::test] +async fn rejected_held_change_is_not_recreated_by_retransmission() { + let (a,b,relay)=devices().await;enroll(&a,&b).await; + let parent=head(&b);let vid=Vid::random(); + let message=SyncMsg::Changes {changes:vec![Change {name:ItemName::new("KEY").unwrap(),generation:1,new_vid:vid,parents:vec![parent],lineage:vec![parent], + op:Op::Put {kind:kc_proto::sync::ItemKind::Text,value:SecretBytes::from_slice(b"fake-rejected")},approval_ref:None}]}; + post(&a,&b,&relay,message.clone()).await; + b.run(&["inbox"],Run::agent()).await.expect(8); + b.run(&["sync","review"],Run::human(vec![Answer::Select(1)])).await.expect(0); + post(&a,&b,&relay,message).await; + b.run(&["inbox"],Run::agent()).await.expect(0); + assert!(state(&b)["candidates"].as_object().unwrap().is_empty()); +} + +#[tokio::test] +async fn legacy_overwrite_flag_and_code_receive_cannot_bypass_local_confirmation() { + let (a,b,_) = devices().await;enroll(&a,&b).await; + a.store().set("KEY",b"fake-legacy-terminal",kc_store::ItemKind::Text,kc_store::Origin::Local).unwrap(); + a.run(&["send","KEY","--to","bravo"],Run::agent()).await.expect(0); + b.run(&["inbox","--on-conflict","overwrite"],Run::agent()).await.expect(8); + assert_eq!(b.value("KEY").unwrap(),b"fake-initial-secret"); + b.run(&["sync","review"],human(vec![Answer::Select(0)])).await.expect(0); + assert_eq!(b.value("KEY").unwrap(),b"fake-legacy-terminal"); + a.store().set("KEY",b"fake-code-overwrite",kc_store::ItemKind::Text,kc_store::Origin::Local).unwrap(); + let (rx,tx)=transfer(&b,&["receive","--on-conflict","overwrite"],Run::agent(),&a,&["send","KEY"], + |code|Run::human(vec![Answer::Text(code),Answer::Yes])).await; + rx.expect(8);tx.expect(8); + assert_eq!(b.value("KEY").unwrap(),b"fake-legacy-terminal"); +} +#[tokio::test] +async fn local_change_between_receive_and_review_becomes_conflict() { + let (a,b,_) = devices().await;enroll(&a,&b).await; + a.set("KEY",b"fake-incoming").await;pump(&a,&b).await; + b.set("KEY",b"fake-intervening-local").await; + b.run(&["sync","review"],human(vec![Answer::Select(0)])).await.expect(8); + assert_eq!(b.value("KEY").unwrap(),b"fake-intervening-local"); + assert_eq!(state(&b)["items"]["KEY"]["conflict"],true); +} +#[tokio::test] +async fn sync_peer_removal_is_locally_confirmed_and_stops_outgoing_updates() { + let (a,b,_) = devices().await;enroll(&a,&b).await; + a.run(&["sync","peer","rm","bravo"],Run::agent()).await.expect(5); + a.run(&["sync","peer","rm","bravo"],human(vec![])).await.expect(0); + a.set("KEY",b"fake-out-of-scope").await;pump(&a,&b).await; + assert_eq!(b.value("KEY").unwrap(),b"fake-initial-secret"); + assert!(state(&a)["items"]["KEY"]["scope"].as_array().unwrap().is_empty()); +} + +#[tokio::test] +async fn freeze_retains_immutable_vid_violation_but_review_cannot_apply_it() { + let (a,b,relay)=devices().await;enroll(&a,&b).await; + let vid=head(&b); + b.run(&["sync","freeze"],Run::agent()).await.expect(8); + post(&a,&b,&relay,SyncMsg::Changes {changes:vec![Change {name:ItemName::new("KEY").unwrap(),generation:1,new_vid:vid, + parents:vec![],lineage:vec![vid],op:Op::Put {kind:kc_proto::sync::ItemKind::Text,value:SecretBytes::from_slice(b"fake-mutation-while-frozen")},approval_ref:None}]}).await; + b.run(&["inbox"],Run::agent()).await.expect(8); + assert!(state(&b)["candidates"].as_object().unwrap().values().any(|c| c["invalid_binding"]==true && c["category"]=="held")); + b.run(&["sync","unfreeze"],human(vec![])).await.expect(8); + b.run(&["sync","review"],human(vec![Answer::Select(0)])).await.expect(8); + assert_eq!(b.value("KEY").unwrap(),b"fake-initial-secret"); + assert_eq!(state(&b)["items"]["KEY"]["conflict"],true); +} + +#[tokio::test] +async fn rejecting_a_proposal_blocks_retries_but_an_explicit_reoffer_is_fresh() { + let (a,b,_)=devices().await;a.set("KEY",b"fake-proposal").await; + a.run(&["sync","add","KEY","--peers","bravo"],human(vec![])).await.expect(8); + pump(&a,&b).await; + b.run(&["sync","review"],Run::human(vec![Answer::Select(1)])).await.expect(0); + pump(&a,&b).await; + assert!(state(&b)["candidates"].as_object().unwrap().is_empty()); + let old=head(&a); + a.run(&["sync","offer","KEY","--peers","bravo"],Run::agent()).await.expect(8); + assert_ne!(old,head(&a)); + pump(&a,&b).await; + b.run(&["sync","review"],human(vec![Answer::Select(0)])).await.expect(0); + pump(&a,&b).await; + assert_eq!(head(&a),head(&b)); +} diff --git a/crates/kc-sync/src/decision.rs b/crates/kc-sync/src/decision.rs index 454e520..c3bacc5 100644 --- a/crates/kc-sync/src/decision.rs +++ b/crates/kc-sync/src/decision.rs @@ -231,6 +231,12 @@ pub fn decide( } return advance(state, incoming, false, true); } + // A resolve can reach a peer which never saw the competing changes. Its only + // unresolved head is its current one; complete multi-parent coverage still requires + // review in Phase 1, including when the selected value already matches (§2.4). + if incoming.parents.len() > 1 && incoming.parents.contains(&state.head) && approval.is_none() { + return Decision::held(HoldReason::Resolve); + } // Row 6 is metadata-only convergence; Retire has no value to converge. if incoming.value_fp == Some(current_fp) { return advance(state, incoming, true, false); diff --git a/crates/kc-sync/src/generation.rs b/crates/kc-sync/src/generation.rs index 8d35162..3be4e16 100644 --- a/crates/kc-sync/src/generation.rs +++ b/crates/kc-sync/src/generation.rs @@ -44,6 +44,7 @@ impl Generations { /// Human review accepts an offer for exactly the specified peer (§2.1, §12.2). pub fn accept(&mut self, name: &str, peer: PeerId) -> Registration { let owned = self.owned.entry(name.into()).or_default(); + owned.generation = owned.generation.max(1); owned.peers.insert(peer); Registration { name: name.into(), @@ -98,7 +99,8 @@ impl Generations { let names = self.remote.entry(peer).or_default(); if names .get(&leave.name) - .is_some_and(|r| r.generation > leave.generation) + .is_some_and(|r| r.generation > leave.generation + || (r.generation == leave.generation && r.accepted)) { return false; } @@ -112,6 +114,11 @@ impl Generations { true } + /// Last receiver generation learned from either Accept or Leave; zero means unknown. + pub fn known_generation(&self, peer: &PeerId, name: &str) -> u64 { + self.remote.get(peer).and_then(|names| names.get(name)).map_or(0, |r| r.generation) + } + /// Returns the receiver-issued generation only after Accept and before Leave (§12.2). pub fn outgoing_generation(&self, peer: &PeerId, name: &str) -> Option { let remote = self.remote.get(peer)?.get(name)?; diff --git a/crates/kc-sync/tests/policy.rs b/crates/kc-sync/tests/policy.rs index 9e5ab13..bf556a8 100644 --- a/crates/kc-sync/tests/policy.rs +++ b/crates/kc-sync/tests/policy.rs @@ -829,15 +829,15 @@ fn generations_are_receiver_owned_scoped_and_bumped_on_rm() { let b = peer("b"); assert_eq!(g.outgoing_generation(&a, "key"), None); let accept = g.accept("key", a.clone()); - assert_eq!(accept.generation, 0); + assert_eq!(accept.generation, 1); assert!(g.includes("key", &a)); assert!(!g.includes("key", &b)); let (leave, peers) = g.rm("key").unwrap(); - assert_eq!(leave.generation, 1); + assert_eq!(leave.generation, 2); assert_eq!(peers.len(), 1); assert!(!g.includes("key", &a)); let accept = g.accept("key", b.clone()); - assert_eq!(accept.generation, 1); + assert_eq!(accept.generation, 2); assert!(g.includes("key", &b)); } #[test] @@ -911,3 +911,39 @@ fn slot_budget_round_trip_retains_snapshot_pins() { Reservation::Refused ); } + +#[test] +fn accepted_generation_starts_at_one_and_known_generation_survives_leave() { + let mut g = Generations::default(); + let p = peer("a"); + assert_eq!(g.generation("key"), 0); + assert_eq!(g.known_generation(&p, "key"), 0); + let accepted = g.accept("key", p.clone()); + assert_eq!(accepted.generation, 1); + g.received_accept(p.clone(), accepted); + assert_eq!(g.known_generation(&p, "key"), 1); + g.received_leave(p.clone(), Registration { name: "key".into(), generation: 2 }); + assert_eq!(g.known_generation(&p, "key"), 2); + assert_eq!(g.outgoing_generation(&p, "key"), None); +} + +#[test] +fn reordered_leave_cannot_undo_reacceptance_of_the_same_generation() { + let mut g = Generations::default(); + let p = peer("a"); + let r = Registration { name: "key".into(), generation: 2 }; + assert!(g.received_accept(p.clone(), r.clone())); + assert!(!g.received_leave(p.clone(), r)); + assert_eq!(g.outgoing_generation(&p, "key"), Some(2)); +} + +#[test] +fn complete_unsigned_resolve_is_held_even_if_peer_missed_the_conflict() { + let s = state(); + let mut i = incoming(); + i.parents = vec![s.head, v(99)]; + i.value_fp = Some(f(1)); + let d = decide(&s, f(1), &i, false, None, true); + assert_eq!(d.ack, AckResult::Held); + assert!(matches!(d.transition, Transition::Hold { reason: HoldReason::Resolve })); +} From d92c5c8e40ddde9b933c5d5ab990d240f2264e48 Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Tue, 13 Oct 2026 17:31:59 +0900 Subject: [PATCH 16/24] =?UTF-8?q?style:=20clippy=C2=B7fmt=20=EC=A0=95?= =?UTF-8?q?=EB=A6=AC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- crates/kc-cli/src/commands/apply.rs | 8 ++--- crates/kc-cli/src/sync/actions.rs | 8 ++--- crates/kc-cli/src/sync/mod.rs | 8 ++--- crates/kc-cli/src/sync/receive.rs | 43 ++++++++++++++------------- crates/kc-cli/src/sync/transaction.rs | 25 ++++++++-------- crates/kc-cli/src/sync/transport.rs | 17 +++++------ 6 files changed, 55 insertions(+), 54 deletions(-) diff --git a/crates/kc-cli/src/commands/apply.rs b/crates/kc-cli/src/commands/apply.rs index 18757f1..a2f746c 100644 --- a/crates/kc-cli/src/commands/apply.rs +++ b/crates/kc-cli/src/commands/apply.rs @@ -251,10 +251,10 @@ fn apply_one( if value.len() > MAX_VALUE_LEN { return Ok(ItemStatus::Rejected(REJECT_TOO_LARGE)); } - if conflicts != Conflicts::Policy(ConflictPolicy::Rename) { - if let Some(status) = crate::sync::legacy(ctx, item, from_device)? { - return Ok(status); - } + if conflicts != Conflicts::Policy(ConflictPolicy::Rename) + && let Some(status) = crate::sync::legacy(ctx, item, from_device)? + { + return Ok(status); } let policy = match conflicts { Conflicts::Policy(policy) => policy, diff --git a/crates/kc-cli/src/sync/actions.rs b/crates/kc-cli/src/sync/actions.rs index 47da4f4..78c2807 100644 --- a/crates/kc-cli/src/sync/actions.rs +++ b/crates/kc-cli/src/sync/actions.rs @@ -342,10 +342,10 @@ pub(crate) fn review(ctx: &mut Ctx<'_, H>) -> Result { if s.frozen { break; } - if let Some(current) = s.candidates.get(&c.version.slot).cloned() { - if current.category != CandidateKind::Conflict { - transaction::accept(ctx, &mut s, ¤t)?; - } + if let Some(current) = s.candidates.get(&c.version.slot).cloned() + && current.category != CandidateKind::Conflict + { + transaction::accept(ctx, &mut s, ¤t)?; } } s.cleanup(ctx)?; diff --git a/crates/kc-cli/src/sync/mod.rs b/crates/kc-cli/src/sync/mod.rs index 90fb468..0d08b69 100644 --- a/crates/kc-cli/src/sync/mod.rs +++ b/crates/kc-cli/src/sync/mod.rs @@ -99,10 +99,10 @@ fn fingerprint(ctx: &Ctx<'_, H>, name: &str, kind: ItemKind, value: &[u mac.update(value); Ok(Fp(mac.finalize().into_bytes().into())) } -fn current( - ctx: &Ctx<'_, H>, - name: &str, -) -> Result>, ItemKind, Fp)>> { +/// An item's current value, kind and fingerprint. +type Current = (Zeroizing>, ItemKind, Fp); + +fn current(ctx: &Ctx<'_, H>, name: &str) -> Result> { let Some(value) = ctx.store.get(name)? else { return Ok(None); }; diff --git a/crates/kc-cli/src/sync/receive.rs b/crates/kc-cli/src/sync/receive.rs index 3ee45d4..828e42d 100644 --- a/crates/kc-cli/src/sync/receive.rs +++ b/crates/kc-cli/src/sync/receive.rs @@ -321,14 +321,13 @@ fn change_received( // An accepted Offer has no parent field. Bind its first explicit parent assertion // only when the fingerprint still matches the immutable offered value. let unbound = format!("{}:{}", name, vid_key(c.new_vid)); - if s.unbound.contains(&unbound) { - if let Some(rec) = state.known.get_mut(&map::vid(c.new_vid)) { - if Some(rec.fp) == fp { - rec.parents = c.parents.iter().copied().map(map::vid).collect(); - private_put(ctx, &record_slot(name, c.new_vid), rec)?; - s.unbound.remove(&unbound); - } - } + if s.unbound.contains(&unbound) + && let Some(rec) = state.known.get_mut(&map::vid(c.new_vid)) + && Some(rec.fp) == fp + { + rec.parents = c.parents.iter().copied().map(map::vid).collect(); + private_put(ctx, &record_slot(name, c.new_vid), rec)?; + s.unbound.remove(&unbound); } let incoming = Incoming { generation: c.generation, @@ -413,10 +412,10 @@ fn change_received( write_value: false, .. } => { - if let Some(fp) = fp { - if !remember(ctx, name, c.new_vid, fp, &c.parents)? { - return Err(state_error()); - } + if let Some(fp) = fp + && !remember(ctx, name, c.new_vid, fp, &c.parents)? + { + return Err(state_error()); } let item = s.items.get_mut(name).unwrap(); item.head = map::wire_vid(head); @@ -493,6 +492,7 @@ pub(super) fn preserve_mine( } Ok(()) } +#[allow(clippy::too_many_arguments)] pub(super) fn store_candidate( ctx: &Ctx<'_, H>, s: &mut State, @@ -577,15 +577,16 @@ pub(super) fn store_candidate( return Ok(false); } } - if !retire && !invalid_binding { - if let Some(item) = s.items.get_mut(&v.name) { - if !item.known.contains(&v.vid) { - item.known.push(v.vid); - } - while item.known.len() > 256 { - let index = item.known.iter().position(|vid| *vid != item.head).unwrap(); - item.known.remove(index); - } + if !retire + && !invalid_binding + && let Some(item) = s.items.get_mut(&v.name) + { + if !item.known.contains(&v.vid) { + item.known.push(v.vid); + } + while item.known.len() > 256 { + let index = item.known.iter().position(|vid| *vid != item.head).unwrap(); + item.known.remove(index); } } let key = v.slot.clone(); diff --git a/crates/kc-cli/src/sync/transaction.rs b/crates/kc-cli/src/sync/transaction.rs index 5678c6d..7628f2f 100644 --- a/crates/kc-cli/src/sync/transaction.rs +++ b/crates/kc-cli/src/sync/transaction.rs @@ -73,6 +73,7 @@ fn interrupted(ctx: &mut Ctx<'_, H>) -> Result<()> { } Ok(()) } +#[allow(clippy::too_many_arguments)] fn prepare_local( ctx: &Ctx<'_, H>, s: &mut State, @@ -382,10 +383,10 @@ pub(super) fn accept(ctx: &mut Ctx<'_, H>, s: &mut State, c: &Candidate let expected: Fp = private_get(ctx, &c.base_record)?; let head = s.items.get(name).map(|i| i.head); if actual != expected || head != c.base_head || c.invalid_binding { - if c.invalid_binding { - if let Some(peer) = s.peers.get_mut(&c.peer) { - peer.quarantine.insert(name.into()); - } + if c.invalid_binding + && let Some(peer) = s.peers.get_mut(&c.peer) + { + peer.quarantine.insert(name.into()); } let key = c.version.slot.clone(); if let Some(c) = s.candidates.get_mut(&key) { @@ -408,10 +409,10 @@ pub(super) fn accept(ctx: &mut Ctx<'_, H>, s: &mut State, c: &Candidate } else { None }; - if let Some(slot) = &checkpoint { - if !reserve(ctx, s, slot, SlotKind::Checkpoint, false)? { - return Ok(false); - } + if let Some(slot) = &checkpoint + && !reserve(ctx, s, slot, SlotKind::Checkpoint, false)? + { + return Ok(false); } let lineage = kc_sync::Lineage::new(c.version.lineage.iter().copied().chain(head).map(map::vid)) @@ -441,10 +442,10 @@ pub(super) fn accept(ctx: &mut Ctx<'_, H>, s: &mut State, c: &Candidate candidate: c.clone(), }, )?; - if let (Some(slot), Some((old, old_kind, _))) = (&checkpoint, now) { - if ctx.store.get_internal(slot)?.is_none() { - put_blob(ctx, slot, old_kind, &old)?; - } + if let (Some(slot), Some((old, old_kind, _))) = (&checkpoint, now) + && ctx.store.get_internal(slot)?.is_none() + { + put_blob(ctx, slot, old_kind, &old)?; } ctx.store.set( name, diff --git a/crates/kc-cli/src/sync/transport.rs b/crates/kc-cli/src/sync/transport.rs index ece062a..6132b57 100644 --- a/crates/kc-cli/src/sync/transport.rs +++ b/crates/kc-cli/src/sync/transport.rs @@ -162,14 +162,13 @@ pub(crate) async fn flush(ctx: &mut Ctx<'_, H>, digest: bool) -> Result } let ids: Vec<_> = s.outbox.pending(&PeerId(id.clone())).cloned().collect(); for change in &ids { - if let Some(latest) = s.latest_local.get(&change.name) { - if change.new_vid != map::vid(*latest) - && ids - .iter() - .any(|id| id.name == change.name && id.new_vid == map::vid(*latest)) - { - continue; - } + if let Some(latest) = s.latest_local.get(&change.name) + && change.new_vid != map::vid(*latest) + && ids + .iter() + .any(|id| id.name == change.name && id.new_vid == map::vid(*latest)) + { + continue; } if s.deferred.contains(&delivery_key( &id, @@ -309,7 +308,7 @@ pub(super) fn resend( Ok(()) } pub(crate) async fn send_after_write(ctx: &mut Ctx<'_, H>) { - if let Err(_) = flush(ctx, false).await { + if flush(ctx, false).await.is_err() { crate::commands::say!( ctx, "{}", From d19ae5391e4a6e91b04c9728f29f8985e3756f90 Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Tue, 13 Oct 2026 17:38:17 +0900 Subject: [PATCH 17/24] =?UTF-8?q?docs:=20kc=20sync=20=EC=82=AC=EC=9A=A9?= =?UTF-8?q?=EB=B2=95=C2=B7=ED=94=84=EB=A1=9C=ED=86=A0=EC=BD=9C=C2=B7?= =?UTF-8?q?=EB=B3=B4=EC=95=88=20=ED=95=9C=EA=B3=84=20(8=EA=B0=9C=20?= =?UTF-8?q?=EC=96=B8=EC=96=B4=20README)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- README.de.md | 25 +++++++++++++++++++++++++ README.es.md | 24 ++++++++++++++++++++++++ README.fr.md | 24 ++++++++++++++++++++++++ README.ja.md | 23 +++++++++++++++++++++++ README.ko.md | 24 ++++++++++++++++++++++++ README.md | 23 +++++++++++++++++++++++ README.zh-Hans.md | 21 +++++++++++++++++++++ README.zh-Hant.md | 21 +++++++++++++++++++++ docs/PROTOCOL.md | 34 +++++++++++++++++++++++++++++++--- docs/SECURITY.md | 27 +++++++++++++++++++++++++++ docs/design/sync.md | 2 +- 11 files changed, 244 insertions(+), 4 deletions(-) diff --git a/README.de.md b/README.de.md index f9f86c8..4412fb8 100644 --- a/README.de.md +++ b/README.de.md @@ -130,6 +130,30 @@ desktop$ kc inbox # speichert, was angekommen ist (bi `kc peers rm LABEL` hebt die Kopplung eines Geräts auf; geht ein Rechner verloren, führe es auf deinen anderen Rechnern aus. Wann `kc device rotate` sinnvoll ist, steht in [docs/SECURITY.md](docs/SECURITY.md). +## Synchronisierung + +Synchronisiere ausgewählte Einträge zwischen gekoppelten Geräten. **Standardmäßig +wird nichts synchronisiert.** Ersetze `NAME` durch den Namen eines vorhandenen Eintrags: + +```console +$ kc sync add NAME # Eintrag aufnehmen und anderen Geräten vorschlagen +$ kc sync # auf beiden Geräten ausführen, um Änderungen auszutauschen +$ kc sync review # Vorschläge und zurückgehaltene Änderungen auf dem Empfänger prüfen +$ kc sync status # Status und lokale Fingerabdrücke anzeigen, niemals Werte +``` + +Diese Version hält jedes Überschreiben durch ein anderes Gerät zur Prüfung zurück. Jeder +Synchronisierungsschritt, der einen Wert übernimmt, verlangt eine lokale Bestätigung +per Touch ID (oder Systempasswort), Windows Hello oder polkit. Auch die Aufnahme eines +Eintrags verlangt diese Bestätigung. Normale lokale Schreibvorgänge können Änderungen +in die Warteschlange stellen, erlauben aber kein Überschreiben auf anderen Geräten. +Bei Konflikten bleiben die möglichen Werte erhalten. Wähle mit +`kc sync resolve NAME --keep mine` oder `kc sync resolve NAME --keep LABEL` einen Wert. +Die anderen Geräte müssen auch dieses Ergebnis prüfen. `kc sync freeze` stoppt die +Übernahme eingehender Änderungen ohne Bestätigung; `kc sync unfreeze` verlangt eine +Bestätigung des Betriebssystems. Exit-Code 8 bedeutet, dass noch Arbeit aussteht oder +blockiert ist. Siehe die [Sicherheitsgrenzen](docs/SECURITY.md). + ## Befehle | Befehl | Funktion | @@ -141,6 +165,7 @@ Wann `kc device rotate` sinnvoll ist, steht in [docs/SECURITY.md](docs/SECURITY. | `kc adopt --service S [--account A] [--as NAME]` | kopiert einen vorhandenen Schlüsselbundeintrag in kc | | `kc receive` / `kc send [NAMES…]` | überträgt Einträge mit einem Einmalcode | | `kc pair`, `kc peers`, `kc inbox`, `kc device` | gemerkte Geräte | +| `kc sync` | ausgewählte Einträge mit gekoppelten Geräten synchronisieren | | `kc doctor` | prüft den Schlüsselbund, das Relay und die Konfiguration | ## Fehlerbehebung diff --git a/README.es.md b/README.es.md index 6c35ab1..e35c230 100644 --- a/README.es.md +++ b/README.es.md @@ -130,6 +130,29 @@ desktop$ kc inbox # guarda lo que llegó (se conserva `kc peers rm LABEL` desempareja un dispositivo; si pierdes una máquina, ejecútalo en las demás. Consulta [docs/SECURITY.md](docs/SECURITY.md) para saber cuándo usar `kc device rotate`. +## Sincronización + +Sincroniza los elementos que elijas entre dispositivos emparejados. **No se +sincroniza nada por defecto.** Sustituye `NAME` por el nombre de un elemento existente: + +```console +$ kc sync add NAME # incluye el elemento y lo propone a los otros dispositivos +$ kc sync # ejecútalo en ambos dispositivos para intercambiar cambios +$ kc sync review # revisa propuestas y cambios retenidos en el receptor +$ kc sync status # muestra el estado y las huellas locales, nunca los valores +``` + +En esta versión, toda sobrescritura remota queda pendiente de revisión. Cada paso de +sincronización que aplica un valor pide confirmación local mediante Touch ID +(o la contraseña del sistema), Windows Hello o polkit. Incluir un elemento también +requiere confirmación. Las escrituras locales normales pueden poner cambios en cola, +pero no autorizan sobrescrituras en otros dispositivos. Los conflictos conservan los +valores candidatos: elige con `kc sync resolve NAME --keep mine` o +`kc sync resolve NAME --keep LABEL`. Los demás dispositivos también revisan el resultado. +`kc sync freeze` detiene la aplicación de cambios entrantes sin pedir confirmación; +`kc sync unfreeze` requiere confirmación del sistema. El código de salida 8 indica +trabajo pendiente o bloqueado. Consulta los [límites de seguridad](docs/SECURITY.md). + ## Comandos | Comando | Qué hace | @@ -141,6 +164,7 @@ Consulta [docs/SECURITY.md](docs/SECURITY.md) para saber cuándo usar `kc device | `kc adopt --service S [--account A] [--as NAME]` | copia un elemento existente del llavero a kc | | `kc receive` / `kc send [NAMES…]` | mueve elementos con un código de un solo uso | | `kc pair`, `kc peers`, `kc inbox`, `kc device` | dispositivos recordados | +| `kc sync` | sincroniza elementos seleccionados con dispositivos emparejados | | `kc doctor` | comprueba el llavero, el relé y la configuración | ## Solución de problemas diff --git a/README.fr.md b/README.fr.md index dc7c412..2b4b24d 100644 --- a/README.fr.md +++ b/README.fr.md @@ -130,6 +130,29 @@ desktop$ kc inbox # enregistre ce qui est arrivé (co `kc peers rm LABEL` supprime l'appairage d'un appareil ; si une machine est perdue, lancez-le sur vos autres machines. Consultez [docs/SECURITY.md](docs/SECURITY.md) pour savoir quand utiliser `kc device rotate`. +## Synchronisation + +Synchronisez les éléments choisis entre appareils appairés. **Rien n’est +synchronisé par défaut.** Remplacez `NAME` par le nom d’un élément existant : + +```console +$ kc sync add NAME # inscrit l’élément et le propose aux autres appareils +$ kc sync # à lancer sur les deux appareils pour échanger les modifications +$ kc sync review # examine les propositions et modifications en attente sur le destinataire +$ kc sync status # affiche l’état et les empreintes locales, jamais les valeurs +``` + +Dans cette version, tout écrasement distant attend une vérification humaine. Chaque étape de +synchronisation qui applique une valeur demande une confirmation locale via Touch ID +(ou le mot de passe du système), Windows Hello ou polkit. L’inscription d’un élément +exige aussi cette confirmation. Les écritures locales ordinaires peuvent mettre des +modifications en file d’attente, sans autoriser d’écrasement sur les autres appareils. +Les valeurs en conflit sont conservées : choisissez avec `kc sync resolve NAME --keep mine` +ou `kc sync resolve NAME --keep LABEL`. Les autres appareils doivent aussi examiner le +résultat. `kc sync freeze` suspend l’application des modifications entrantes sans +confirmation ; `kc sync unfreeze` exige une confirmation du système. Le code de sortie 8 +signale du travail en attente ou bloqué. Voir les [limites de sécurité](docs/SECURITY.md). + ## Commandes | Commande | Rôle | @@ -141,6 +164,7 @@ Consultez [docs/SECURITY.md](docs/SECURITY.md) pour savoir quand utiliser `kc de | `kc adopt --service S [--account A] [--as NAME]` | copie un élément existant du trousseau dans kc | | `kc receive` / `kc send [NAMES…]` | transfère des éléments avec un code à usage unique | | `kc pair`, `kc peers`, `kc inbox`, `kc device` | appareils mémorisés | +| `kc sync` | synchronise les éléments choisis avec les appareils appairés | | `kc doctor` | vérifie le trousseau, le relais et la configuration | ## Dépannage diff --git a/README.ja.md b/README.ja.md index 9e7e82a..48de85a 100644 --- a/README.ja.md +++ b/README.ja.md @@ -130,6 +130,28 @@ desktop$ kc inbox # 届いたものを保存 (最大 `kc peers rm LABEL` はデバイスのペアリングを解除します。マシンを紛失したら、他のマシンでこれを実行してください。 `kc device rotate` を使う場面は [docs/SECURITY.md](docs/SECURITY.md) を参照してください。 +## 同期 + +選んだ項目をペアリング済みデバイス間で同期します。**初期状態では何も同期しません。** +`NAME` は既存の項目名に置き換えてください。 + +```console +$ kc sync add NAME # 同期対象に登録し、他のデバイスに提案 +$ kc sync # 両方のデバイスで実行して変更を交換 +$ kc sync review # 受信側で提案と保留中の変更を確認 +$ kc sync status # 値ではなく状態とこのデバイスの値の指紋を表示 +``` + +このバージョンでは、リモートからの上書きをすべて保留して人が確認します。同期で値を +適用するたびに、Touch ID(または OS のパスワード)、Windows Hello、polkit による +ローカル確認が必要です。同期対象の登録にも確認が必要です。通常のローカル書き込みは +変更を送信待ちにできますが、他のデバイスでの上書きを許可するものではありません。 +競合した候補の値は保存されます。`kc sync resolve NAME --keep mine` または +`kc sync resolve NAME --keep LABEL` で残す値を選びます。他のデバイスでは結果も +確認が必要です。`kc sync freeze` は確認なしで受信した変更の適用を止めます。 +`kc sync unfreeze` には OS の確認が必要です。終了コード 8 は保留中または処理できない +作業が残っていることを示します。[セキュリティ上の制限](docs/SECURITY.md)も参照してください。 + ## コマンド | コマンド | 内容 | @@ -141,6 +163,7 @@ desktop$ kc inbox # 届いたものを保存 (最大 | `kc adopt --service S [--account A] [--as NAME]` | 既存のキーチェーン項目を kc にコピー | | `kc receive` / `kc send [NAMES…]` | ワンタイムコードで項目を移動 | | `kc pair`, `kc peers`, `kc inbox`, `kc device` | 記憶済みデバイス | +| `kc sync` | 選んだ項目をペアリング済みデバイスと同期 | | `kc doctor` | キーチェーン、リレー、設定を確認 | ## トラブルシューティング diff --git a/README.ko.md b/README.ko.md index 1ba990d..fcd9d52 100644 --- a/README.ko.md +++ b/README.ko.md @@ -132,6 +132,29 @@ desktop$ kc inbox # 도착한 항목을 저장(최대 실행하세요. `kc device rotate` 를 언제 쓰는지는 [docs/SECURITY.md](docs/SECURITY.md) 에 있습니다. +## 동기화 + +선택한 항목을 페어링한 기기끼리 동기화합니다. **처음에는 아무 항목도 +동기화하지 않습니다.** `NAME`에 기존 항목 이름을 넣으세요. + +```console +$ kc sync add NAME # 동기화 대상으로 등록하고 다른 기기에 제안 +$ kc sync # 양쪽 기기에서 실행해 변경 사항 교환 +$ kc sync review # 받는 기기에서 제안과 보류된 변경 검토 +$ kc sync status # 값 대신 상태와 이 기기의 값 지문 표시 +``` + +이 버전은 원격 덮어쓰기를 모두 보류하고 사람이 검토합니다. 동기화 과정에서 +값을 적용할 때마다 Touch ID(또는 OS 암호), Windows Hello, polkit으로 확인합니다. +동기화 대상 등록에도 이 확인이 필요합니다. 일반적인 로컬 쓰기는 변경을 전송 대기열에 +넣을 수 있지만, 다른 기기의 값을 덮어쓸 권한까지 부여하지는 않습니다. +충돌이 나면 후보 값을 보관합니다. `kc sync resolve NAME --keep mine`으로 +이 기기의 값을, `kc sync resolve NAME --keep LABEL`로 해당 기기의 후보 값을 +선택하세요. 다른 기기에서는 그 결과도 검토해야 합니다. `kc sync freeze`는 별도 +확인 없이 수신 변경의 적용을 중단하고, `kc sync unfreeze`는 OS 확인 후 다시 +허용합니다. 종료 코드 8은 대기 중이거나 막힌 작업이 남아 있다는 뜻입니다. +[보안상 한계](docs/SECURITY.md)도 참고하세요. + ## 명령 | 명령 | 하는 일 | @@ -143,6 +166,7 @@ desktop$ kc inbox # 도착한 항목을 저장(최대 | `kc adopt --service S [--account A] [--as NAME]` | 이미 있는 키체인 항목을 kc 로 복사 | | `kc receive` / `kc send [NAMES…]` | 일회용 코드로 항목 옮기기 | | `kc pair`, `kc peers`, `kc inbox`, `kc device` | 기억된 기기 | +| `kc sync` | 선택한 항목을 페어링한 기기끼리 동기화 | | `kc doctor` | 키체인, 중계 서버, 설정 점검 | ## 문제 해결 diff --git a/README.md b/README.md index 69c854e..d12d549 100644 --- a/README.md +++ b/README.md @@ -130,6 +130,28 @@ desktop$ kc inbox # stores what arrived (kept up to 7 `kc peers rm LABEL` unpairs a device; run it on your other machines if one is lost. See [docs/SECURITY.md](docs/SECURITY.md) for when to use `kc device rotate`. +## Sync + +Sync keeps selected items shared between paired devices. **Nothing syncs by +default.** Replace `NAME` with an existing item name: + +```console +$ kc sync add NAME # enroll and offer to paired devices +$ kc sync # run on both devices to exchange changes +$ kc sync review # on the receiving device: review proposals and held changes +$ kc sync status # show state and local fingerprints, never values +``` + +This release holds every remote overwrite for review. Every sync step that applies +a value asks for local OS confirmation: Touch ID (or the OS password fallback), +Windows Hello, or polkit. Enrollment also requires this confirmation; ordinary +local writes can queue changes without authorizing an overwrite elsewhere. +Conflicts preserve candidate values: use `kc sync resolve NAME --keep mine` +or `kc sync resolve NAME --keep LABEL` to choose a version. Other devices still +review the result. `kc sync freeze` holds incoming changes without confirmation; +`kc sync unfreeze` requires OS confirmation. Exit 8 means pending or blocked +work remains. See [the security limits](docs/SECURITY.md). + ## Commands | Command | What it does | @@ -141,6 +163,7 @@ lost. See [docs/SECURITY.md](docs/SECURITY.md) for when to use `kc device rotate | `kc adopt --service S [--account A] [--as NAME]` | copy an existing keychain item into kc | | `kc receive` / `kc send [NAMES…]` | move items with a one-time code | | `kc pair`, `kc peers`, `kc inbox`, `kc device` | remembered devices | +| `kc sync` | sync selected items with paired devices | | `kc doctor` | check the keychain, the relay and the configuration | ## Troubleshooting diff --git a/README.zh-Hans.md b/README.zh-Hans.md index acd86c6..8072d5f 100644 --- a/README.zh-Hans.md +++ b/README.zh-Hans.md @@ -129,6 +129,26 @@ desktop$ kc inbox # 保存收到的内容(最多保 `kc peers rm LABEL` 解除与某台设备的配对;如果有机器丢失,请在其他机器上运行此命令。 何时使用 `kc device rotate`,请参阅 [docs/SECURITY.md](docs/SECURITY.md)。 +## 同步 + +在已配对的设备之间同步选定的条目。**默认不同步任何条目。** +将 `NAME` 替换为已有条目的名称: + +```console +$ kc sync add NAME # 加入同步范围,并向其他设备发送提议 +$ kc sync # 在两台设备上运行,交换更改 +$ kc sync review # 在接收设备上审核提议和暂存的更改 +$ kc sync status # 显示状态和本机的值指纹,不显示值 +``` + +当前版本会暂存所有远程覆盖操作,等待人工审核。同步中每次应用值都需要通过 +Touch ID(或系统密码)、Windows Hello 或 polkit 在本机确认。加入同步范围也需要 +确认。普通的本地写入可以将更改加入发送队列,但不会授权覆盖其他设备上的值。 +发生冲突时会保留候选值;使用 `kc sync resolve NAME --keep mine` 或 +`kc sync resolve NAME --keep LABEL` 选择要保留的版本。其他设备仍需审核结果。 +`kc sync freeze` 无需确认即可暂停应用传入的更改;`kc sync unfreeze` 需要系统确认。 +退出码 8 表示仍有待处理或受阻的工作。另请参阅[安全限制](docs/SECURITY.md)。 + ## 命令 | 命令 | 作用 | @@ -140,6 +160,7 @@ desktop$ kc inbox # 保存收到的内容(最多保 | `kc adopt --service S [--account A] [--as NAME]` | 将现有钥匙串条目复制到 kc | | `kc receive` / `kc send [NAMES…]` | 用一次性代码转移条目 | | `kc pair`, `kc peers`, `kc inbox`, `kc device` | 已记住的设备 | +| `kc sync` | 与已配对的设备同步选定条目 | | `kc doctor` | 检查钥匙串、中继服务器和配置 | ## 故障排除 diff --git a/README.zh-Hant.md b/README.zh-Hant.md index 67ef6ca..4ec4bde 100644 --- a/README.zh-Hant.md +++ b/README.zh-Hant.md @@ -129,6 +129,26 @@ desktop$ kc inbox # 儲存收到的內容(最多保 `kc peers rm LABEL` 解除與某台裝置的配對;若有電腦遺失,請在其他電腦上執行此指令。 何時使用 `kc device rotate`,請參閱 [docs/SECURITY.md](docs/SECURITY.md)。 +## 同步 + +在已配對的裝置之間同步選定的項目。**預設不會同步任何項目。** +將 `NAME` 換成現有項目的名稱: + +```console +$ kc sync add NAME # 加入同步範圍,並向其他裝置傳送提案 +$ kc sync # 在兩台裝置上執行,交換變更 +$ kc sync review # 在接收裝置上審核提案與暫存的變更 +$ kc sync status # 顯示狀態與本機的值指紋,不顯示值 +``` + +目前版本會暫存所有遠端覆寫操作,等待人工審核。同步中每次套用值都需要透過 +Touch ID(或系統密碼)、Windows Hello 或 polkit 在本機確認。加入同步範圍也需要 +確認。一般的本機寫入可以將變更加進傳送佇列,但不會授權覆寫其他裝置上的值。 +發生衝突時會保留候選值;使用 `kc sync resolve NAME --keep mine` 或 +`kc sync resolve NAME --keep LABEL` 選擇要保留的版本。其他裝置仍須審核結果。 +`kc sync freeze` 不需確認即可暫停套用傳入的變更;`kc sync unfreeze` 需要系統確認。 +結束代碼 8 表示仍有待處理或受阻的工作。另請參閱[安全限制](docs/SECURITY.md)。 + ## 指令 | 指令 | 作用 | @@ -140,6 +160,7 @@ desktop$ kc inbox # 儲存收到的內容(最多保 | `kc adopt --service S [--account A] [--as NAME]` | 將既有的鑰匙圈項目複製到 kc | | `kc receive` / `kc send [NAMES…]` | 用一次性代碼搬移項目 | | `kc pair`, `kc peers`, `kc inbox`, `kc device` | 已記住的裝置 | +| `kc sync` | 與已配對的裝置同步選定項目 | | `kc doctor` | 檢查鑰匙圈、中繼伺服器與設定 | ## 疑難排解 diff --git a/docs/PROTOCOL.md b/docs/PROTOCOL.md index 6df3bf4..ac6439e 100644 --- a/docs/PROTOCOL.md +++ b/docs/PROTOCOL.md @@ -256,7 +256,28 @@ terminals and none of `CI`, `CLAUDECODE` or `--no-input` is set. | `pair`, `--remember`, `--all`, overwrite on receive or inbox | **always refused, exit 5** (`agent_code_send` doesn't change this) | allowed after showing names and peer label/SAS | | `receive` (shows a code) | allowed, conflicts skipped | allowed | -Without a TTY, kc never prompts. It exits 5 and names the missing flags. +For sync, **L** means confirmation by a human on the local device through +Touch ID (or the OS password fallback), Windows Hello, or polkit. A terminal +prompt alone is not L. Missing, denied or unavailable L returns exit 5. + +| Sync action | Non-interactive (agents, scripts) | Interactive | +|---|---|---| +| `sync`, `sync offer NAME` | allowed to queue/send changes and proposals within the already approved scope; no remote overwrite | same | +| `sync status`, `sync status --json`, `sync peer list` | allowed; no values displayed | allowed | +| `sync freeze` | allowed; holds incoming changes | allowed without L | +| `sync add NAME`, `sync rm NAME`, `sync peer add LABEL`, `sync peer rm LABEL` | refused, exit 5 | L required | +| `sync review` | refused, exit 5 | accepting proposals or held changes requires L; rejecting or leaving them for later does not | +| `sync resolve NAME --keep mine`, `sync resolve NAME --keep LABEL`, `sync restore-checkpoint NAME` | refused, exit 5 | L required | +| `sync status --confirm-checkpoint NAME`, `sync unfreeze` | refused, exit 5 | L required | + +Nothing syncs by default. Agents can create proposals and queue/send changes, +but cannot enroll items, expand sharing scope or accept remote values. Phase 1 +holds **every remote overwrite** for human review on the receiving device; +conflicts require explicit resolution. Even a resolution sent by another device +cannot bypass local review. Ordinary local writes such as `set` retain the +permissions above; their queued changes do not authorize a remote overwrite. + +Without a TTY, kc never prompts. Operations that require interaction exit 5. ## 7. Using values without leaking them @@ -282,10 +303,17 @@ Defined in `kc_wire::exit`. | 5 | interaction required | | 6 | relay unavailable or rate limited | | 7 | auth failed (bad code or MAC, tampering, replay) | -| 8 | partial | +| 8 | partial; for sync, work remains pending or blocked (proposals, held changes, conflicts, queued delivery, re-offer needed, frozen state, capacity, quarantine or a tripped limit) | | 9 | expired | -## 9. Reserved for phase 2 +## 9. Reserved for later phases + +Signed sync approvals (A/A+) and FIDO2 verification are planned for Phase 1b; +the 1pass.dev phone approver is planned for Phase 2b. None ships in this +release. Phase 1 ignores signed approval documents and never uses them to +authorize an automatic overwrite. + +The following approval lock is also reserved for phase 2: `/v1/locks/*`: an approval lock for selected items. A key share is held by the relay and released only after an authenticator code (TOTP) or a passkey diff --git a/docs/SECURITY.md b/docs/SECURITY.md index 559c231..d236758 100644 --- a/docs/SECURITY.md +++ b/docs/SECURITY.md @@ -12,11 +12,19 @@ that belong to one person, and while they sit in each device's OS keychain. | Your devices and OS keychains | the values | — | | The relay (`relay.1pass.dev`) | delivering bytes, keeping them only briefly | reading or changing values; it can drop or delay messages | | The network | nothing | everything (TLS plus end-to-end encryption) | +| A paired sync device | proposing items and sending changes within the approved scope | authorizing an overwrite on the receiving device | The relay sees client IPs, timing and message sizes. It stores no account, no long-term data, and only ciphertext: channel messages for at most 10 minutes, inbox envelopes for at most 72 hours. +Pairing does not enable sync: each item must be explicitly enrolled. A +compromised paired device can propose items and send changes, but cannot +overwrite a sync item's value without a human on the receiving device. Phase 1 +holds every remote overwrite for review or conflict resolution. Local OS +confirmation (L) uses Touch ID (or the OS password fallback), Windows Hello, +or polkit; agents cannot supply this confirmation. + ## Properties - **Code pairing:** SPAKE2 with explicit key confirmation. @@ -30,6 +38,13 @@ inbox envelopes for at most 72 hours. - kc never reads values from command-line arguments or its own environment. `kc exec --env` hands a value to a child process's environment on purpose. Only the same user (and root) can read a process environment, unlike argv, which every local user can read. - Buffers are zeroized. - `kc get` refuses to print to a terminal without `--reveal`. +- **Sync storage:** persisted values stay in OS keychain slots, including held + proposals, conflict candidates, outgoing snapshots and recovery checkpoints. + Values never go into `sync.json` or `sync.log`; they are read into zeroizing + memory for processing and end-to-end encrypted transport. Sync value + fingerprints use HMAC-SHA256 with a device-local key kept in the keychain. + They are not sent to peers or stored in public metadata; displayed sync + fingerprints compare values on one device, not across devices. - **Locked keychains:** kc reports an error instead of waiting on an OS unlock prompt, so unattended agents don't hang. ## Known limits @@ -46,6 +61,18 @@ inbox envelopes for at most 72 hours. permissions and disk encryption. - **macOS prompts:** macOS can ask "allow access" when the `kc` binary changes. Release builds are code-signed so updates keep the same identity. +- **Changes outside kc:** an external keychain change from A to B and back to A + between syncs cannot be detected. +- **Originating device lost:** devices send only changes they originate. If the + originating device disappears, a human must re-send unreceived changes as a + new local publication from a remaining copy. +- **Linux sync confirmation:** L currently uses polkit's + `org.freedesktop.policykit.exec` action, which may ask for an administrator + password. The OS policy controls authentication and caching. A kc-specific + policy is planned with the later sync installer; neither ships in Phase 1. +- **No signed sync approvals yet:** A/A+ and FIDO2 are Phase 1b work; the + 1pass.dev phone approver is Phase 2b work. They cannot authorize overwrites + in this release. - **Planned approval lock (phase 2):** selected items will need an authenticator code or a passkey before they can be read. diff --git a/docs/design/sync.md b/docs/design/sync.md index 44bdee4..c060779 100644 --- a/docs/design/sync.md +++ b/docs/design/sync.md @@ -1,6 +1,6 @@ # `kc sync` 설계 (초안 v0.4, 2026-10-13) -상태: 사용자 검토 대기. 구현 전. +상태: Phase 0·1 구현됨(v0.3.0). 1b 이후 미구현. 근거: Opus 설계안과 codex(gpt-6-astra) 설계안을 서로 보여 주지 않고 따로 받아 종합했다(v0.1). 이후 logi(1pass.dev) 레포 점검 결과와 codex 공격자 관점 리뷰(P1 9건·P2 6건)를 반영했다(v0.2). v0.2 재리뷰의 새 P1 4건과 부분 해결 항목을 반영했다(v0.3). v0.3 재리뷰(13건 중 10건 해결)에서 나온 착수 전 고정 계약 5개를 §12 로 정했다(v0.4). ## 0. 확정된 사용자 결정 From 9262b978991b3cba0d9e79a1485f97ea41e68259 Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Tue, 13 Oct 2026 18:04:34 +0900 Subject: [PATCH 18/24] =?UTF-8?q?fix(kc-cli):=20sync=20=EC=97=94=EC=A7=84?= =?UTF-8?q?=20=EB=A6=AC=EB=B7=B0=20=EB=B0=98=EC=98=81=2014=EA=B1=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Hello 전달 실패 시 다시 보낸다(상대와 영구 정지 방지) - --on-conflict overwrite 게이트 복원, sync.json 손상이 get·exec 를 막지 않게 - 로컬 확인 사유에 무슨 일이 일어나는지 적는다, sync add 는 고른 뒤 확인 - legacy 경로가 충돌 정책을 따르고 거절은 그 항목만 보류 - review 거절도 같은 한 번의 확인에 묶는다, 표시 지문을 kc get --fingerprint 와 통일 - 비활성·차단 기기의 제안 무시, 충돌 중 제안은 후보로 - Sync 본문 재전송 검사, 용량·바인딩 실패를 비치명화, 슬롯 누수 정리 Co-Authored-By: Claude Opus 5.5 --- crates/kc-cli/locales/de.toml | 16 +- crates/kc-cli/locales/es.toml | 16 +- crates/kc-cli/locales/fr.toml | 16 +- crates/kc-cli/locales/ja.toml | 16 +- crates/kc-cli/locales/ko.toml | 16 +- crates/kc-cli/locales/zh-Hans.toml | 16 +- crates/kc-cli/locales/zh-Hant.toml | 16 +- crates/kc-cli/src/commands/apply.rs | 12 +- crates/kc-cli/src/commands/inbox.rs | 30 +- crates/kc-cli/src/commands/mod.rs | 9 +- crates/kc-cli/src/sync/actions.rs | 93 +++-- crates/kc-cli/src/sync/mod.rs | 16 +- crates/kc-cli/src/sync/receive.rs | 84 +++- crates/kc-cli/src/sync/transaction.rs | 41 +- crates/kc-cli/src/sync/transport.rs | 10 +- crates/kc-cli/tests/common/fault_relay.rs | 109 +++++ crates/kc-cli/tests/common/mod.rs | 2 + crates/kc-cli/tests/sync.rs | 471 +++++++++++++++++++++- 18 files changed, 870 insertions(+), 119 deletions(-) create mode 100644 crates/kc-cli/tests/common/fault_relay.rs diff --git a/crates/kc-cli/locales/de.toml b/crates/kc-cli/locales/de.toml index 2dba173..3dd1324 100644 --- a/crates/kc-cli/locales/de.toml +++ b/crates/kc-cli/locales/de.toml @@ -475,15 +475,25 @@ "Sync storage is full; review pending items before retrying." = "Synchronisierungsspeicher voll; ausstehende Einträge prüfen und erneut versuchen." "Ignored a stale sync offer for {name}." = "Veralteten Synchronisierungsvorschlag für {name} ignoriert." "Ignored signed approvals: Phase 1 requires local review." = "Signierte Freigaben ignoriert: Phase 1 erfordert lokale Prüfung." -"Confirm sync changes ({n} items)." = "Synchronisierungsänderungen bestätigen ({n} Einträge)." "Sync delivery is queued; run `kc sync` to retry." = "Synchronisierungsübertragung wartet; mit `kc sync` erneut versuchen." "Unknown sync peer: {label}." = "Unbekanntes Synchronisierungsgerät: {label}." "Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." = "Nur das Gerät, das eine Änderung erstellt hat, sendet sie; geht es verloren, eine neue lokale Änderung aus einer verbleibenden Kopie veröffentlichen." "Review sync changes." = "Synchronisierungsänderungen prüfen." "Review {name} from {peer}: current {current}, proposed {proposed}." = "{name} von {peer} prüfen: aktuell {current}, vorgeschlagen {proposed}." -"Review sync: accept {accept}, reject {reject}." = "Synchronisierungsprüfung: {accept} annehmen, {reject} ablehnen." -"Confirm the requested sync operation." = "Angeforderte Synchronisierungsaktion bestätigen." "Select sync items." = "Einträge für die Synchronisierung auswählen." "Run `kc sync rm {name}` before deleting this item." = "Vor dem Löschen dieses Eintrags `kc sync rm {name}` ausführen." "{sent} sent, {updated} updated, {conflict} conflict, {held} held" = "{sent} gesendet, {updated} aktualisiert, {conflict} Konflikte, {held} zurückgehalten" "Sync {name}: {result}." = "Synchronisierung {name}: {result}." +"{names} and {n} more" = "{names} und {n} weitere" +"kc sync add {names}" = "kc sync add {names}" +"kc sync rm {names}" = "kc sync rm {names}" +"kc sync peer add {label}" = "kc sync peer add {label}" +"kc sync peer rm {label}" = "kc sync peer rm {label}" +"Accept {names} from {devices}; reject {rejected}" = "{names} von {devices} annehmen; {rejected} ablehnen" +"Replace {name} with the value from {device}" = "{name} durch den Wert von {device} ersetzen" +"Resolve {name}: keep {choice}" = "{name} auflösen: {choice} behalten" +"Restore {name} to its checkpoint" = "{name} auf seinen Kontrollpunkt zurücksetzen" +"Unfreeze sync" = "Synchronisierung fortsetzen" +"Confirm the current value of {name} as its checkpoint" = "Den aktuellen Wert von {name} als Kontrollpunkt bestätigen" +"Ignored a sync offer from disabled or blocked peer {peer}." = "Synchronisierungsangebot vom deaktivierten oder blockierten Gerät {peer} ignoriert." +"Sync item held; run `kc sync review`." = "Synchronisierungselement zurückgehalten; `kc sync review` ausführen." diff --git a/crates/kc-cli/locales/es.toml b/crates/kc-cli/locales/es.toml index ecd66e3..a921aaf 100644 --- a/crates/kc-cli/locales/es.toml +++ b/crates/kc-cli/locales/es.toml @@ -475,15 +475,25 @@ "Sync storage is full; review pending items before retrying." = "El almacenamiento de sincronización está lleno; revise los elementos pendientes antes de volver a intentarlo." "Ignored a stale sync offer for {name}." = "Se ignoró una propuesta de sincronización obsoleta para {name}." "Ignored signed approvals: Phase 1 requires local review." = "Se ignoraron las aprobaciones firmadas: la fase 1 requiere revisión local." -"Confirm sync changes ({n} items)." = "Confirmar los cambios de sincronización ({n} elementos)." "Sync delivery is queued; run `kc sync` to retry." = "El envío de sincronización está en cola; ejecute `kc sync` para reintentarlo." "Unknown sync peer: {label}." = "Dispositivo de sincronización desconocido: {label}." "Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." = "Solo el dispositivo que creó un cambio lo envía; si se pierde, publique un nuevo cambio local a partir de una copia restante." "Review sync changes." = "Revisar los cambios de sincronización." "Review {name} from {peer}: current {current}, proposed {proposed}." = "Revisar {name} de {peer}: huella actual {current}, propuesta {proposed}." -"Review sync: accept {accept}, reject {reject}." = "Revisión de sincronización: aceptar {accept}, rechazar {reject}." -"Confirm the requested sync operation." = "Confirmar la operación de sincronización solicitada." "Select sync items." = "Seleccionar los elementos que se sincronizarán." "Run `kc sync rm {name}` before deleting this item." = "Ejecute `kc sync rm {name}` antes de eliminar este elemento." "{sent} sent, {updated} updated, {conflict} conflict, {held} held" = "{sent} enviados, {updated} actualizados, {conflict} conflictos, {held} retenidos" "Sync {name}: {result}." = "Sincronización de {name}: {result}." +"{names} and {n} more" = "{names} y {n} más" +"kc sync add {names}" = "kc sync add {names}" +"kc sync rm {names}" = "kc sync rm {names}" +"kc sync peer add {label}" = "kc sync peer add {label}" +"kc sync peer rm {label}" = "kc sync peer rm {label}" +"Accept {names} from {devices}; reject {rejected}" = "Aceptar {names} de {devices}; rechazar {rejected}" +"Replace {name} with the value from {device}" = "Reemplazar {name} por el valor de {device}" +"Resolve {name}: keep {choice}" = "Resolver {name}: conservar {choice}" +"Restore {name} to its checkpoint" = "Restaurar {name} a su punto de control" +"Unfreeze sync" = "Reanudar la sincronización" +"Confirm the current value of {name} as its checkpoint" = "Confirmar el valor actual de {name} como su punto de control" +"Ignored a sync offer from disabled or blocked peer {peer}." = "Se ignoró una oferta de sincronización del dispositivo desactivado o bloqueado {peer}." +"Sync item held; run `kc sync review`." = "Elemento de sincronización retenido; ejecuta `kc sync review`." diff --git a/crates/kc-cli/locales/fr.toml b/crates/kc-cli/locales/fr.toml index 324cf07..18368cc 100644 --- a/crates/kc-cli/locales/fr.toml +++ b/crates/kc-cli/locales/fr.toml @@ -475,15 +475,25 @@ "Sync storage is full; review pending items before retrying." = "Le stockage de synchronisation est plein ; examinez les éléments en attente avant de réessayer." "Ignored a stale sync offer for {name}." = "Proposition de synchronisation obsolète pour {name} ignorée." "Ignored signed approvals: Phase 1 requires local review." = "Approbations signées ignorées : la phase 1 nécessite une vérification locale." -"Confirm sync changes ({n} items)." = "Confirmer les modifications de synchronisation ({n} éléments)." "Sync delivery is queued; run `kc sync` to retry." = "La transmission est en attente ; exécutez `kc sync` pour réessayer." "Unknown sync peer: {label}." = "Appareil de synchronisation inconnu : {label}." "Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." = "Seul l’appareil à l’origine d’une modification l’envoie ; s’il est perdu, publiez une nouvelle modification locale depuis une copie restante." "Review sync changes." = "Examiner les modifications de synchronisation." "Review {name} from {peer}: current {current}, proposed {proposed}." = "Examiner {name} de {peer} : empreinte actuelle {current}, proposée {proposed}." -"Review sync: accept {accept}, reject {reject}." = "Vérification de synchronisation : accepter {accept}, refuser {reject}." -"Confirm the requested sync operation." = "Confirmer l’opération de synchronisation demandée." "Select sync items." = "Sélectionner les éléments à synchroniser." "Run `kc sync rm {name}` before deleting this item." = "Exécutez `kc sync rm {name}` avant de supprimer cet élément." "{sent} sent, {updated} updated, {conflict} conflict, {held} held" = "{sent} envoyés, {updated} mis à jour, {conflict} conflits, {held} en attente" "Sync {name}: {result}." = "Synchronisation {name} : {result}." +"{names} and {n} more" = "{names} et {n} autres" +"kc sync add {names}" = "kc sync add {names}" +"kc sync rm {names}" = "kc sync rm {names}" +"kc sync peer add {label}" = "kc sync peer add {label}" +"kc sync peer rm {label}" = "kc sync peer rm {label}" +"Accept {names} from {devices}; reject {rejected}" = "Accepter {names} de {devices} ; refuser {rejected}" +"Replace {name} with the value from {device}" = "Remplacer {name} par la valeur de {device}" +"Resolve {name}: keep {choice}" = "Résoudre {name} : conserver {choice}" +"Restore {name} to its checkpoint" = "Restaurer {name} à son point de contrôle" +"Unfreeze sync" = "Reprendre la synchronisation" +"Confirm the current value of {name} as its checkpoint" = "Confirmer la valeur actuelle de {name} comme point de contrôle" +"Ignored a sync offer from disabled or blocked peer {peer}." = "Offre de synchronisation ignorée : appareil {peer} désactivé ou bloqué." +"Sync item held; run `kc sync review`." = "Élément de synchronisation en attente ; exécutez `kc sync review`." diff --git a/crates/kc-cli/locales/ja.toml b/crates/kc-cli/locales/ja.toml index 5eff382..18fc8af 100644 --- a/crates/kc-cli/locales/ja.toml +++ b/crates/kc-cli/locales/ja.toml @@ -475,15 +475,25 @@ "Sync storage is full; review pending items before retrying." = "同期用の保存領域がいっぱいです。保留中の項目を確認してから再試行してください。" "Ignored a stale sync offer for {name}." = "{name} の古い世代の同期提案を無視しました。" "Ignored signed approvals: Phase 1 requires local review." = "署名付き承認を無視しました。フェーズ1ではこのデバイスでの確認が必要です。" -"Confirm sync changes ({n} items)." = "同期の変更を確認してください({n}項目)。" "Sync delivery is queued; run `kc sync` to retry." = "同期の送信が待機中です。`kc sync` で再試行してください。" "Unknown sync peer: {label}." = "同期相手が見つかりません: {label}。" "Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." = "変更は作成元のデバイスだけが送信します。そのデバイスを失った場合は、残っているコピーから新しいローカル変更を作成してください。" "Review sync changes." = "同期の変更を確認してください。" "Review {name} from {peer}: current {current}, proposed {proposed}." = "{peer} からの {name} を確認: 現在 {current}、提案 {proposed}。" -"Review sync: accept {accept}, reject {reject}." = "同期の確認: {accept}件を受け入れ、{reject}件を拒否。" -"Confirm the requested sync operation." = "要求された同期操作を確認してください。" "Select sync items." = "同期する項目を選択してください。" "Run `kc sync rm {name}` before deleting this item." = "この項目を削除する前に `kc sync rm {name}` を実行してください。" "{sent} sent, {updated} updated, {conflict} conflict, {held} held" = "送信 {sent}件、更新 {updated}件、競合 {conflict}件、保留 {held}件" "Sync {name}: {result}." = "同期 {name}: {result}。" +"{names} and {n} more" = "{names}、ほか{n}件" +"kc sync add {names}" = "kc sync add {names}" +"kc sync rm {names}" = "kc sync rm {names}" +"kc sync peer add {label}" = "kc sync peer add {label}" +"kc sync peer rm {label}" = "kc sync peer rm {label}" +"Accept {names} from {devices}; reject {rejected}" = "{devices}からの{names}を承認し、{rejected}を拒否" +"Replace {name} with the value from {device}" = "{name}を{device}の値で置き換える" +"Resolve {name}: keep {choice}" = "{name}を解決:{choice}を保持" +"Restore {name} to its checkpoint" = "{name}をチェックポイントに戻す" +"Unfreeze sync" = "同期の凍結を解除" +"Confirm the current value of {name} as its checkpoint" = "{name}の現在の値をチェックポイントとして確認" +"Ignored a sync offer from disabled or blocked peer {peer}." = "無効またはブロックされたデバイス{peer}からの同期提案を無視しました。" +"Sync item held; run `kc sync review`." = "同期項目を保留しました。`kc sync review`を実行してください。" diff --git a/crates/kc-cli/locales/ko.toml b/crates/kc-cli/locales/ko.toml index 061b776..4438c49 100644 --- a/crates/kc-cli/locales/ko.toml +++ b/crates/kc-cli/locales/ko.toml @@ -475,15 +475,25 @@ "Sync storage is full; review pending items before retrying." = "동기화 저장 공간이 가득 찼습니다. 대기 중인 항목을 검토한 뒤 다시 시도하세요." "Ignored a stale sync offer for {name}." = "{name}의 이전 세대 제안을 무시했습니다." "Ignored signed approvals: Phase 1 requires local review." = "서명 승인을 무시했습니다. 1단계에서는 이 기기에서 직접 검토해야 합니다." -"Confirm sync changes ({n} items)." = "동기화 변경 {n}개를 확인하세요." "Sync delivery is queued; run `kc sync` to retry." = "동기화 전송이 대기 중입니다. `kc sync`로 다시 시도하세요." "Unknown sync peer: {label}." = "동기화할 기기를 찾을 수 없습니다: {label}." "Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." = "변경은 만든 기기에서만 전송합니다. 그 기기를 잃어버렸다면 남아 있는 사본으로 새 변경을 만들어 보내세요." "Review sync changes." = "동기화 변경을 검토하세요." "Review {name} from {peer}: current {current}, proposed {proposed}." = "{peer}에서 온 {name} 검토: 현재 지문 {current}, 제안 지문 {proposed}." -"Review sync: accept {accept}, reject {reject}." = "동기화 검토: {accept}개 수락, {reject}개 거절." -"Confirm the requested sync operation." = "요청한 동기화 작업을 확인하세요." "Select sync items." = "동기화할 항목을 선택하세요." "Run `kc sync rm {name}` before deleting this item." = "이 항목을 삭제하려면 먼저 `kc sync rm {name}`을 실행하세요." "{sent} sent, {updated} updated, {conflict} conflict, {held} held" = "전송 {sent}개, 갱신 {updated}개, 충돌 {conflict}개, 보류 {held}개" "Sync {name}: {result}." = "동기화 {name}: {result}." +"{names} and {n} more" = "{names} 외 {n}개" +"kc sync add {names}" = "kc sync add {names}" +"kc sync rm {names}" = "kc sync rm {names}" +"kc sync peer add {label}" = "kc sync peer add {label}" +"kc sync peer rm {label}" = "kc sync peer rm {label}" +"Accept {names} from {devices}; reject {rejected}" = "{devices}의 {names} 수락; {rejected} 거절" +"Replace {name} with the value from {device}" = "{name}을(를) {device}의 값으로 교체" +"Resolve {name}: keep {choice}" = "{name} 충돌 해결: {choice} 유지" +"Restore {name} to its checkpoint" = "{name}을(를) 복구 기준점으로 복원" +"Unfreeze sync" = "동기화 동결 해제" +"Confirm the current value of {name} as its checkpoint" = "{name}의 현재 값을 복구 기준점으로 확인" +"Ignored a sync offer from disabled or blocked peer {peer}." = "비활성화되거나 차단된 기기 {peer}의 동기화 제안을 무시했습니다." +"Sync item held; run `kc sync review`." = "동기화 항목을 보류했습니다. `kc sync review`를 실행하세요." diff --git a/crates/kc-cli/locales/zh-Hans.toml b/crates/kc-cli/locales/zh-Hans.toml index 8a942eb..96ec3a4 100644 --- a/crates/kc-cli/locales/zh-Hans.toml +++ b/crates/kc-cli/locales/zh-Hans.toml @@ -475,15 +475,25 @@ "Sync storage is full; review pending items before retrying." = "同步存储已满;请审核待处理项目后重试。" "Ignored a stale sync offer for {name}." = "已忽略 {name} 的过期同步提议。" "Ignored signed approvals: Phase 1 requires local review." = "已忽略签名批准:第一阶段需要本地审核。" -"Confirm sync changes ({n} items)." = "请确认同步更改({n} 项)。" "Sync delivery is queued; run `kc sync` to retry." = "同步传输已排队;请运行 `kc sync` 重试。" "Unknown sync peer: {label}." = "未知的同步设备:{label}。" "Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." = "只有创建更改的设备会发送它;若该设备丢失,请用剩余副本发布新的本地更改。" "Review sync changes." = "请审核同步更改。" "Review {name} from {peer}: current {current}, proposed {proposed}." = "审核来自 {peer} 的 {name}:当前指纹 {current},提议指纹 {proposed}。" -"Review sync: accept {accept}, reject {reject}." = "同步审核:接受 {accept} 项,拒绝 {reject} 项。" -"Confirm the requested sync operation." = "请确认请求的同步操作。" "Select sync items." = "请选择同步项目。" "Run `kc sync rm {name}` before deleting this item." = "删除此项目之前,请先运行 `kc sync rm {name}`。" "{sent} sent, {updated} updated, {conflict} conflict, {held} held" = "已发送 {sent} 项,已更新 {updated} 项,冲突 {conflict} 项,暂存 {held} 项" "Sync {name}: {result}." = "同步 {name}:{result}。" +"{names} and {n} more" = "{names}及其他{n}项" +"kc sync add {names}" = "kc sync add {names}" +"kc sync rm {names}" = "kc sync rm {names}" +"kc sync peer add {label}" = "kc sync peer add {label}" +"kc sync peer rm {label}" = "kc sync peer rm {label}" +"Accept {names} from {devices}; reject {rejected}" = "接受来自{devices}的{names};拒绝{rejected}" +"Replace {name} with the value from {device}" = "用{device}的值替换{name}" +"Resolve {name}: keep {choice}" = "解决{name}:保留{choice}" +"Restore {name} to its checkpoint" = "将{name}恢复到检查点" +"Unfreeze sync" = "解除同步冻结" +"Confirm the current value of {name} as its checkpoint" = "确认{name}的当前值为检查点" +"Ignored a sync offer from disabled or blocked peer {peer}." = "已忽略已禁用或被阻止的设备{peer}的同步提议。" +"Sync item held; run `kc sync review`." = "同步项目已保留;请运行 `kc sync review`。" diff --git a/crates/kc-cli/locales/zh-Hant.toml b/crates/kc-cli/locales/zh-Hant.toml index cbb9204..6d230f1 100644 --- a/crates/kc-cli/locales/zh-Hant.toml +++ b/crates/kc-cli/locales/zh-Hant.toml @@ -475,15 +475,25 @@ "Sync storage is full; review pending items before retrying." = "同步儲存空間已滿;請審核待處理項目後重試。" "Ignored a stale sync offer for {name}." = "已忽略 {name} 的過期同步提議。" "Ignored signed approvals: Phase 1 requires local review." = "已忽略簽署核准:第一階段需要本機審核。" -"Confirm sync changes ({n} items)." = "請確認同步變更({n} 項)。" "Sync delivery is queued; run `kc sync` to retry." = "同步傳輸已排入佇列;請執行 `kc sync` 重試。" "Unknown sync peer: {label}." = "未知的同步裝置:{label}。" "Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." = "只有建立變更的裝置會傳送它;若該裝置遺失,請用剩餘副本發布新的本機變更。" "Review sync changes." = "請審核同步變更。" "Review {name} from {peer}: current {current}, proposed {proposed}." = "審核來自 {peer} 的 {name}:目前指紋 {current},提議指紋 {proposed}。" -"Review sync: accept {accept}, reject {reject}." = "同步審核:接受 {accept} 項,拒絕 {reject} 項。" -"Confirm the requested sync operation." = "請確認要求的同步操作。" "Select sync items." = "請選擇同步項目。" "Run `kc sync rm {name}` before deleting this item." = "刪除此項目之前,請先執行 `kc sync rm {name}`。" "{sent} sent, {updated} updated, {conflict} conflict, {held} held" = "已傳送 {sent} 項,已更新 {updated} 項,衝突 {conflict} 項,暫存 {held} 項" "Sync {name}: {result}." = "同步 {name}:{result}。" +"{names} and {n} more" = "{names}及其他{n}項" +"kc sync add {names}" = "kc sync add {names}" +"kc sync rm {names}" = "kc sync rm {names}" +"kc sync peer add {label}" = "kc sync peer add {label}" +"kc sync peer rm {label}" = "kc sync peer rm {label}" +"Accept {names} from {devices}; reject {rejected}" = "接受來自{devices}的{names};拒絕{rejected}" +"Replace {name} with the value from {device}" = "以{device}的值取代{name}" +"Resolve {name}: keep {choice}" = "解決{name}:保留{choice}" +"Restore {name} to its checkpoint" = "將{name}還原至檢查點" +"Unfreeze sync" = "解除同步凍結" +"Confirm the current value of {name} as its checkpoint" = "確認{name}的目前值為檢查點" +"Ignored a sync offer from disabled or blocked peer {peer}." = "已忽略已停用或遭封鎖的裝置{peer}的同步提議。" +"Sync item held; run `kc sync review`." = "同步項目已保留;請執行 `kc sync review`。" diff --git a/crates/kc-cli/src/commands/apply.rs b/crates/kc-cli/src/commands/apply.rs index a2f746c..49c4a9f 100644 --- a/crates/kc-cli/src/commands/apply.rs +++ b/crates/kc-cli/src/commands/apply.rs @@ -57,6 +57,7 @@ impl Conflicts { #[derive(Debug, Default)] pub(crate) struct Applied { pub results: Vec, + pub confirmation_denied: bool, /// The first keychain error, to show once, with its exit code: 4 when the keychain is /// unavailable, 5 when it wants a person to confirm, 1 otherwise. pub keychain_error: Option<(String, i32)>, @@ -70,6 +71,7 @@ pub(crate) struct Applied { impl Applied { /// 0 if everything is here, the keychain error's code if the keychain failed, else 8. pub fn exit_code(&self) -> i32 { + if self.confirmation_denied { return exit::INTERACTION_REQUIRED; } match &self.keychain_error { Some((_, code)) => *code, None => local_exit_code(&self.results), @@ -183,6 +185,11 @@ pub(crate) fn apply_items_locked( } status } + Err(Failure::SyncConfirmation(e)) => { + applied.confirmation_denied = true; + say!(ctx, "{e}"); + ItemStatus::SkippedConflict + } Err(Failure::Cli(e)) => return Err(e), }; let result = ItemResult { @@ -206,6 +213,7 @@ pub(crate) fn apply_items_locked( } enum Failure { + SyncConfirmation(CliError), Store(StoreError), /// A prompt was cancelled, or a lock couldn't be taken. Cli(CliError), @@ -251,8 +259,8 @@ fn apply_one( if value.len() > MAX_VALUE_LEN { return Ok(ItemStatus::Rejected(REJECT_TOO_LARGE)); } - if conflicts != Conflicts::Policy(ConflictPolicy::Rename) - && let Some(status) = crate::sync::legacy(ctx, item, from_device)? + if let Some(status) = crate::sync::legacy(ctx, item, from_device, conflicts == Conflicts::Policy(ConflictPolicy::Overwrite)) + .map_err(|e| if e.code == exit::INTERACTION_REQUIRED { Failure::SyncConfirmation(e) } else { Failure::Cli(e) })? { return Ok(status); } diff --git a/crates/kc-cli/src/commands/inbox.rs b/crates/kc-cli/src/commands/inbox.rs index d1619d9..e4501ba 100644 --- a/crates/kc-cli/src/commands/inbox.rs +++ b/crates/kc-cli/src/commands/inbox.rs @@ -130,6 +130,19 @@ pub(super) async fn inbox(ctx: &mut Ctx<'_, H>, args: InboxArgs) -> Res .by_fingerprint(&opened.sender_fp) .map_or_else(|| opened.sender_fp.short(), |p| p.label.to_string()); let until = opened.keep_seen_until(); + if seen.contains(&opened.msg_id) { + say!( + ctx, + "{}", + tr!( + "A message was dropped: {error} (or one this device stored before but couldn't delete).", + error = InboxError::Replay + ) + ); + outcome.failed(InboxError::Replay.exit_code()); + delete(ctx, &relay, &inbox_id, &owner, &message.msg_id).await; + continue; + } let items = match &opened.body { inbox::Body::Sync(message_body) => { crate::sync::receive(ctx, &opened.sender_fp.to_hex(), message_body)?; @@ -138,22 +151,7 @@ pub(super) async fn inbox(ctx: &mut Ctx<'_, H>, args: InboxArgs) -> Res delete(ctx, &relay, &inbox_id, &owner, &message.msg_id).await; continue; } - inbox::Body::Items(items) => { - if seen.contains(&opened.msg_id) { - say!( - ctx, - "{}", - tr!( - "A message was dropped: {error} (or one this device stored before but couldn't delete).", - error = InboxError::Replay - ) - ); - outcome.failed(InboxError::Replay.exit_code()); - delete(ctx, &relay, &inbox_id, &owner, &message.msg_id).await; - continue; - } - items - } + inbox::Body::Items(items) => items, }; let names: Vec<&str> = items.iter().map(|i| i.name.as_str()).collect(); let (n, names) = (names.len(), names.join(", ")); diff --git a/crates/kc-cli/src/commands/mod.rs b/crates/kc-cli/src/commands/mod.rs index 36a1c73..f201e23 100644 --- a/crates/kc-cli/src/commands/mod.rs +++ b/crates/kc-cli/src/commands/mod.rs @@ -75,10 +75,7 @@ async fn execute(host: &mut H, cli: Cli) -> Result { } let settings = Settings::load(state.root())?; let policy = Policy::new(interactivity, settings.agent_code_send); - let mut gates = policy::gates(&cli.command, interactivity.stdin_terminal); - if !crate::sync::State::load(&state)?.items.is_empty() { - gates.retain(|gate| *gate != policy::Gate::Overwrite); - } + let gates = policy::gates(&cli.command, interactivity.stdin_terminal); policy.check(&gates)?; let store = Keychain::new(host.open_store(policy.interactive())?); let mut ctx = Ctx { @@ -122,7 +119,9 @@ async fn dispatch(ctx: &mut Ctx<'_, H>, command: Command) -> Result { let code = inbox::inbox(ctx, args).await?; crate::sync::flush(ctx, false).await?; - Ok(code.max(crate::sync::pending_code(ctx)?)) + Ok(if code != 0 && code != 8 { code } else { + code.max(crate::sync::pending_code(ctx)?) + }) } Command::Sync(args) => sync::run(ctx, args).await, Command::Device(args) => device::device(ctx, args).await, diff --git a/crates/kc-cli/src/sync/actions.rs b/crates/kc-cli/src/sync/actions.rs index 78c2807..5a76b81 100644 --- a/crates/kc-cli/src/sync/actions.rs +++ b/crates/kc-cli/src/sync/actions.rs @@ -106,6 +106,9 @@ pub(crate) fn remove(ctx: &Ctx<'_, H>, s: &mut State, name: &str) -> Re }, ); } + let checkpoint = checkpoint_slot(name); + s.slots.remove(&checkpoint); + s.gc.insert(checkpoint); s.offers.retain(|o| o.name != name); transaction::clear_candidates(s, name); for peer in s.peers.keys().cloned().collect::>() { @@ -157,7 +160,7 @@ pub(crate) fn status(ctx: &mut Ctx<'_, H>, json: bool) -> Result { } else { tr!("in sync") }; - let fingerprint = current(ctx, name)?.map(|v| hex(&v.2.0[..6])); + let fingerprint = ctx.store.get(name)?.map(|v| crate::values::value_fingerprint(v.as_bytes())); let peers = item .scope .iter() @@ -172,12 +175,7 @@ pub(crate) fn status(ctx: &mut Ctx<'_, H>, json: bool) -> Result { } else { { let value = blob(ctx, &c.version.slot)?; - Some(fingerprint( - ctx, - &c.version.name, - value.kind, - value.value.expose(), - )?) + Some(crate::values::value_fingerprint(value.value.expose())) } }; let state = match c.category { @@ -185,7 +183,7 @@ pub(crate) fn status(ctx: &mut Ctx<'_, H>, json: bool) -> Result { CandidateKind::Held => tr!("held"), CandidateKind::Conflict => tr!("conflict"), }; - candidates.push(serde_json::json!({"name": c.version.name, "state": state, "peer": label(ctx, &c.peer)?, "vid": c.version.vid, "fingerprint": fp.map(|f| hex(&f.0[..6]))})); + candidates.push(serde_json::json!({"name": c.version.name, "state": state, "peer": label(ctx, &c.peer)?, "vid": c.version.vid, "fingerprint": fp})); } let mut peers = Vec::new(); for (id, peer) in &s.peers { @@ -252,8 +250,7 @@ pub(crate) fn review(ctx: &mut Ctx<'_, H>) -> Result { let candidates = { let _items = ctx.state.lock_items(ctx.store.namespace())?; let _state = ctx.state.lock()?; - let mut s = State::load(&ctx.state)?; - scan(ctx, &mut s)?; + let s = State::load(&ctx.state)?; if s.frozen { return Ok(8); } @@ -270,10 +267,10 @@ pub(crate) fn review(ctx: &mut Ctx<'_, H>) -> Result { "-".into() } else { let value = blob(ctx, &c.version.slot)?; - hex(&super::fingerprint(ctx, &c.version.name, value.kind, value.value.expose())?.0[..6]) + crate::values::value_fingerprint(value.value.expose()) }; - let existing = current(ctx, &c.version.name)? - .map(|v| hex(&v.2.0[..6])) + let existing = ctx.store.get(&c.version.name)? + .map(|v| crate::values::value_fingerprint(v.as_bytes())) .unwrap_or_else(|| "-".into()); let question = tr!( "Review {name} from {peer}: current {current}, proposed {proposed}.", @@ -292,13 +289,14 @@ pub(crate) fn review(ctx: &mut Ctx<'_, H>) -> Result { _ => {} } } - if !accepts.is_empty() { + if !accepts.is_empty() || !rejects.is_empty() { human( ctx, &tr!( - "Review sync: accept {accept}, reject {reject}.", - accept = accepts.len(), - reject = rejects.len() + "Accept {names} from {devices}; reject {rejected}", + names = names_summary(&accepts.iter().map(|c| c.version.name.clone()).collect::>()), + devices = names_summary(&accepts.iter().map(|c| label(ctx, &c.peer)).collect::>>()?), + rejected = names_summary(&rejects.iter().map(|c| c.version.name.clone()).collect::>()) ), )?; } @@ -313,6 +311,20 @@ pub(crate) fn review(ctx: &mut Ctx<'_, H>) -> Result { let delivery = delivery_key(&c.peer, &c.version.name, c.generation, c.version.vid); if c.category == CandidateKind::Proposal { s.rejected_offers.insert(delivery); + let record = record_slot(&c.version.name, c.version.vid); + let referenced = s.items.get(&c.version.name) + .is_some_and(|i| i.head == c.version.vid) + || s.versions.values().any(|v| v.name == c.version.name && v.vid == c.version.vid) + || s.candidates.values().any(|other| { + other.version.name == c.version.name && other.version.vid == c.version.vid + }); + if !referenced { + s.unbound.remove(&format!("{}:{}", c.version.name, vid_key(c.version.vid))); + if let Some(item) = s.items.get_mut(&c.version.name) { + item.known.retain(|vid| *vid != c.version.vid); + } + s.gc.insert(record); + } } else { s.receipts.insert( delivery, @@ -351,7 +363,7 @@ pub(crate) fn review(ctx: &mut Ctx<'_, H>) -> Result { s.cleanup(ctx)?; Ok(if pending(&s) { 8 } else { 0 }) } -pub(crate) fn command(ctx: &mut Ctx<'_, H>, command: SyncCommand) -> Result { +pub(crate) fn command(ctx: &mut Ctx<'_, H>, mut command: SyncCommand) -> Result { if let SyncCommand::Status { json, confirm_checkpoint: None, @@ -362,36 +374,33 @@ pub(crate) fn command(ctx: &mut Ctx<'_, H>, command: SyncCommand) -> Re if matches!(command, SyncCommand::Review) { return review(ctx); } - let no_auth = matches!( - command, - SyncCommand::Freeze - | SyncCommand::Offer { .. } - | SyncCommand::Peer { - command: SyncPeerCommand::List - } - ); - if !no_auth { - human(ctx, &tr!("Confirm the requested sync operation."))?; + if let SyncCommand::Add { names, .. } = &mut command + && names.is_empty() + { + let options = ctx.store.list()?.into_iter().map(|i| i.name).collect::>(); + *names = ctx.multi_select(&tr!("Select sync items."), &options)? + .into_iter().map(|i| options[i].clone()).collect(); + } + let reason = match &command { + SyncCommand::Add { names, .. } => Some(tr!("kc sync add {names}", names = names_summary(names))), + SyncCommand::Rm { names } => Some(tr!("kc sync rm {names}", names = names_summary(names))), + SyncCommand::Peer { command: SyncPeerCommand::Add { label } } => Some(tr!("kc sync peer add {label}", label = label)), + SyncCommand::Peer { command: SyncPeerCommand::Rm { label } } => Some(tr!("kc sync peer rm {label}", label = label)), + SyncCommand::Resolve { name, keep } => Some(tr!("Resolve {name}: keep {choice}", name = name, choice = keep)), + SyncCommand::RestoreCheckpoint { name } => Some(tr!("Restore {name} to its checkpoint", name = name)), + SyncCommand::Unfreeze => Some(tr!("Unfreeze sync")), + SyncCommand::Status { confirm_checkpoint: Some(name), .. } => Some(tr!("Confirm the current value of {name} as its checkpoint", name = name)), + _ => None, + }; + if let Some(reason) = reason { + human(ctx, &reason)?; } let _items = ctx.state.lock_items(ctx.store.namespace())?; let _state = ctx.state.lock()?; let mut s = State::load(&ctx.state)?; recover(ctx, &mut s)?; match command { - SyncCommand::Add { mut names, peers } => { - if names.is_empty() { - let options = ctx - .store - .list()? - .into_iter() - .map(|i| i.name) - .collect::>(); - names = ctx - .multi_select(&tr!("Select sync items."), &options)? - .into_iter() - .map(|i| options[i].clone()) - .collect(); - } + SyncCommand::Add { names, peers } => { let peers = selected_peers(ctx, &s, &peers)?; for name in &names { crate::values::item_name(name)?; diff --git a/crates/kc-cli/src/sync/mod.rs b/crates/kc-cli/src/sync/mod.rs index 0d08b69..5747049 100644 --- a/crates/kc-cli/src/sync/mod.rs +++ b/crates/kc-cli/src/sync/mod.rs @@ -211,6 +211,11 @@ fn reserve( } Reservation::Reserved { evicted } => { if let Some(victim) = evicted { + let evicted = s.candidates.values() + .filter(|c| c.version.slot == victim).cloned().collect::>(); + for c in evicted { + s.gc.insert(c.base_record); + } s.candidates.retain(|_, c| c.version.slot != victim); s.slots.remove(&victim); s.gc.insert(victim); @@ -264,7 +269,7 @@ fn pending(s: &State) -> bool { || s.outbox.pending(&PeerId(p.clone())).next().is_some() }) } -fn log(ctx: &mut Ctx<'_, H>, text: String) -> Result<()> { +fn log(ctx: &Ctx<'_, H>, text: String) -> Result<()> { use std::io::Write; let path = ctx.state.root().join("sync.log"); if std::fs::metadata(&path).is_ok_and(|m| m.len() >= 1024 * 1024) { @@ -279,3 +284,12 @@ fn log(ctx: &mut Ctx<'_, H>, text: String) -> Result<()> { .map_err(|_| state_error())?; writeln!(file, "{text}").map_err(|_| state_error()) } + +/// Keep local confirmation dialogs readable without hiding that more items are selected. +fn names_summary(names: &[String]) -> String { + if names.len() <= 3 { + names.join(", ") + } else { + tr!("{names} and {n} more", names = names[..3].join(", "), n = names.len() - 3) + } +} diff --git a/crates/kc-cli/src/sync/receive.rs b/crates/kc-cli/src/sync/receive.rs index 828e42d..17a2fb6 100644 --- a/crates/kc-cli/src/sync/receive.rs +++ b/crates/kc-cli/src/sync/receive.rs @@ -31,7 +31,9 @@ pub(crate) fn receive(ctx: &mut Ctx<'_, H>, peer: &str, message: &SyncM known_generation, } => { let name = name.as_str(); - if *known_generation < s.generations.generation(name) { + if !p.enabled || s.limiter.is_tripped(&PeerId(peer.into())) { + log(ctx, tr!("Ignored a sync offer from disabled or blocked peer {peer}.", peer = super::actions::label(ctx, peer)?))?; + } else if *known_generation < s.generations.generation(name) { log( ctx, tr!("Ignored a stale sync offer for {name}.", name = name), @@ -45,7 +47,7 @@ pub(crate) fn receive(ctx: &mut Ctx<'_, H>, peer: &str, message: &SyncM && value.expose().len() <= 200 * 1024 && !value.expose().is_empty() { - let version = Version { + let mut version = Version { name: name.into(), vid: *vid, parents: vec![], @@ -79,6 +81,15 @@ pub(crate) fn receive(ctx: &mut Ctx<'_, H>, peer: &str, message: &SyncM }, ); } else if !s.candidates.contains_key(&version.slot) { + let category = if s.items.get(name).is_some_and(|i| i.conflict) { + CandidateKind::Conflict + } else { + CandidateKind::Proposal + }; + if existing.is_some() { + let record: VidRecord = private_get(ctx, &record_slot(name, *vid))?; + version.parents = record.parents.into_iter().map(map::wire_vid).collect(); + } let times = s.proposals_today.entry(peer.into()).or_default(); times.retain(|at| (ctx.host.now() as i128) - (*at as i128) < 86400); let allowed = times.len() < ctx.settings.sync.max_proposals_per_day; @@ -89,12 +100,15 @@ pub(crate) fn receive(ctx: &mut Ctx<'_, H>, peer: &str, message: &SyncM peer, version, *known_generation, - CandidateKind::Proposal, + category, value.expose(), false, false, )?; if stored { + if existing.is_none() { + s.unbound.insert(format!("{}:{}", name, vid_key(*vid))); + } s.proposals_today .entry(peer.into()) .or_default() @@ -213,10 +227,16 @@ pub(crate) fn receive(ctx: &mut Ctx<'_, H>, peer: &str, message: &SyncM } else { s.deferred.remove(&delivery); } - let matched = s - .outbox - .ack(&PeerId(peer.into()), &map::id(id), map::ack(*result)); - if matched && *result == AckResult::StaleGeneration { + s.outbox.ack(&PeerId(peer.into()), &map::id(id), map::ack(*result)); + if *result == AckResult::StaleGeneration + && s.generations.known_generation(&PeerId(peer.into()), id.name.as_str()) <= id.generation + { + // The ACK carries the rejected (old) generation, not the receiver's + // new one. Invalidate only that still-current grant; a reordered ACK + // must not revoke a newer Accept. Re-offering learns the actual epoch. + if s.generations.outgoing_generation(&PeerId(peer.into()), id.name.as_str()) == Some(id.generation) { + invalidate_generation(&mut s, peer, id.name.as_str())?; + } s.peers .get_mut(peer) .unwrap() @@ -261,6 +281,19 @@ pub(crate) fn receive(ctx: &mut Ctx<'_, H>, peer: &str, message: &SyncM super::transport::collect_snapshots(&mut s); s.cleanup(ctx) } +// The Phase 1 core API cannot revoke an accepted grant at the same generation. +// Preserve the known receiver epoch while clearing its grant in the persisted adapter. +fn invalidate_generation(s: &mut State, peer: &str, name: &str) -> Result<()> { + let mut generations = serde_json::to_value(&s.generations).map_err(|_| state_error())?; + let accepted = generations.get_mut("remote") + .and_then(|remote| remote.get_mut(peer)) + .and_then(|names| names.get_mut(name)) + .and_then(|grant| grant.get_mut("accepted")) + .ok_or_else(state_error)?; + *accepted = serde_json::Value::Bool(false); + s.generations = serde_json::from_value(generations).map_err(|_| state_error())?; + Ok(()) +} fn ack(s: &mut State, peer: &str, c: &Change, result: AckResult) { queue( s, @@ -413,9 +446,13 @@ fn change_received( .. } => { if let Some(fp) = fp - && !remember(ctx, name, c.new_vid, fp, &c.parents)? + && !matches!(remember(ctx, name, c.new_vid, fp, &c.parents), Ok(true)) { - return Err(state_error()); + s.peers.get_mut(peer).unwrap().quarantine.insert(name.into()); + s.receipts.insert(delivery, (AckResult::Rejected, ctx.host.now().saturating_add(3 * 86400))); + ack(s, peer, c, AckResult::Rejected); + log(ctx, tr!("Sync {name}: {result}.", name = name, result = tr!("declined")))?; + return s.save(&ctx.state); } let item = s.items.get_mut(name).unwrap(); item.head = map::wire_vid(head); @@ -487,7 +524,7 @@ pub(super) fn preserve_mine( false, false, )? { - return Err(capacity()); + log(ctx, tr!("Sync storage is full; review pending items before retrying."))?; } } Ok(()) @@ -533,7 +570,9 @@ pub(super) fn store_candidate( v.slot.push_str(&format!("/{}", hex(&Vid::random().0[..4]))); } if let Some(old) = s.candidates.get(&v.slot) { - if old.version.parents != v.parents || old.retire != retire { + let promote = old.category == CandidateKind::Proposal + && category != CandidateKind::Proposal && !invalid_binding; + if (!promote && old.version.parents != v.parents) || old.retire != retire { return Ok(false); } if !retire { @@ -542,9 +581,15 @@ pub(super) fn store_candidate( return Ok(false); } } - if category == CandidateKind::Conflict { - s.candidates.get_mut(&v.slot).unwrap().category = category; - s.slots.insert(v.slot.clone(), SlotKind::ConflictCandidate); + if promote || category == CandidateKind::Conflict { + let old = s.candidates.get_mut(&v.slot).unwrap(); + old.category = category; + old.version.parents = v.parents; + old.version.lineage = v.lineage; + old.generation = generation; + s.slots.insert(v.slot.clone(), if category == CandidateKind::Conflict { + SlotKind::ConflictCandidate + } else { SlotKind::Held }); } return Ok(true); } @@ -612,6 +657,7 @@ pub(crate) fn legacy( ctx: &mut Ctx<'_, H>, item: &kc_proto::payload::Item, from: &str, + overwrite: bool, ) -> Result> { let mut s = State::load(&ctx.state)?; if !s.items.contains_key(item.name.as_str()) { @@ -658,16 +704,22 @@ pub(crate) fn legacy( true, )? { s.cleanup(ctx)?; + crate::commands::say!(ctx, "{}", tr!("Sync item held; run `kc sync review`.")); return Ok(Some(kc_proto::ItemStatus::SkippedConflict)); } s.save(&ctx.state)?; - if ctx.interactive() && !s.frozen { - human(ctx, &tr!("Confirm sync changes ({n} items).", n = 1))?; + if overwrite && ctx.interactive() && !s.frozen { + if let Err(error) = human(ctx, &tr!("Replace {name} with the value from {device}", name = name, device = from)) { + s.cleanup(ctx)?; + crate::commands::say!(ctx, "{}", tr!("Sync item held; run `kc sync review`.")); + return Err(error); + } let c = s.candidates[&slot].clone(); if transaction::accept(ctx, &mut s, &c)? { return Ok(Some(kc_proto::ItemStatus::Stored)); } } s.cleanup(ctx)?; + crate::commands::say!(ctx, "{}", tr!("Sync item held; run `kc sync review`.")); Ok(Some(kc_proto::ItemStatus::SkippedConflict)) } diff --git a/crates/kc-cli/src/sync/transaction.rs b/crates/kc-cli/src/sync/transaction.rs index 7628f2f..cc9e7cf 100644 --- a/crates/kc-cli/src/sync/transaction.rs +++ b/crates/kc-cli/src/sync/transaction.rs @@ -308,7 +308,7 @@ fn scan_one(ctx: &mut Ctx<'_, H>, s: &mut State, name: &str) -> Result< return Ok(()); } let parents = vec![item.head]; - let (r, v) = prepare_local( + let prepared = prepare_local( ctx, s, name, @@ -318,7 +318,16 @@ fn scan_one(ctx: &mut Ctx<'_, H>, s: &mut State, name: &str) -> Result< parents, Vid::random(), false, - )?; + ); + let (r, v) = match prepared { + Ok(value) => value, + Err(error) if error.code == 8 && s.capacity_blocked => { + s.items.get_mut(name).unwrap().conflict = true; + log(ctx, tr!("Sync storage is full; review pending items before retrying."))?; + return s.save(&ctx.state); + } + Err(error) => return Err(error), + }; put_blob(ctx, &v.slot, kind, &value)?; finish_local(ctx, s, &r, &v, false)?; clear_intent(ctx, s) @@ -369,7 +378,14 @@ pub(super) fn resolve_value( parents.sort(); parents.dedup(); let fp = current(ctx, name)?.map_or(Fp([0; 32]), |v| v.2); - let (r, v) = prepare_local(ctx, s, name, fp, kind, value, parents, Vid::random(), true)?; + let (r, v) = match prepare_local(ctx, s, name, fp, kind, value, parents, Vid::random(), true) { + Ok(prepared) => prepared, + Err(error) if error.code == 8 && s.capacity_blocked => { + log(ctx, tr!("Sync storage is full; review pending items before retrying."))?; + return s.save(&ctx.state); + } + Err(error) => return Err(error), + }; ctx.store.set(name, value, map::kind(kind), Origin::Local)?; interrupted(ctx)?; put_blob(ctx, &v.slot, kind, value)?; @@ -543,7 +559,7 @@ pub(super) fn queue(s: &mut State, peer: &str, message: Control) { } pub(crate) fn recover(ctx: &mut Ctx<'_, H>, s: &mut State) -> Result<()> { let Some(journal) = s.journal.clone() else { - return Ok(()); + return collect_orphan_snapshots(ctx, s); }; let record: Intent = private_get(ctx, &journal.record)?; match record { @@ -614,5 +630,20 @@ pub(crate) fn recover(ctx: &mut Ctx<'_, H>, s: &mut State) -> Result<() } } } - clear_intent(ctx, s) + clear_intent(ctx, s)?; + collect_orphan_snapshots(ctx, s) +} + +fn collect_orphan_snapshots(ctx: &Ctx<'_, H>, s: &mut State) -> Result<()> { + // Called after journal recovery: its in-flight snapshot must survive until then. + let orphaned = s.slots.keys().filter(|slot| { + slot.starts_with("sync/snapshot/") + && !s.versions.values().any(|v| &v.slot == *slot) + && !s.offers.iter().any(|o| snapshot_slot(o.vid) == **slot) + && !s.peers.keys().any(|peer| s.outbox.pending(&PeerId(peer.clone())) + .any(|id| snapshot_slot(map::wire_vid(id.new_vid)) == **slot)) + }).cloned().collect::>(); + for slot in orphaned { release(s, &slot); } + if !s.gc.is_empty() { s.cleanup(ctx)?; } + Ok(()) } diff --git a/crates/kc-cli/src/sync/transport.rs b/crates/kc-cli/src/sync/transport.rs index 6132b57..42bae4a 100644 --- a/crates/kc-cli/src/sync/transport.rs +++ b/crates/kc-cli/src/sync/transport.rs @@ -85,9 +85,9 @@ pub(crate) async fn flush(ctx: &mut Ctx<'_, H>, digest: bool) -> Result if !p.capable { if !p.hello_sent { s.peers.get_mut(&id).unwrap().hello_sent = true; - // Persist before attempting: an unknown peer gets at most one initial Hello. + // Persist the attempt, but permit retry if delivery fails. s.save(&ctx.state)?; - deliver( + if let Err(error) = deliver( ctx, &mut s, peer, @@ -96,7 +96,11 @@ pub(crate) async fn flush(ctx: &mut Ctx<'_, H>, digest: bool) -> Result is_reply: false, }, ) - .await?; + .await { + s.peers.get_mut(&id).unwrap().hello_sent = false; + s.save(&ctx.state)?; + return Err(error); + } } continue; } diff --git a/crates/kc-cli/tests/common/fault_relay.rs b/crates/kc-cli/tests/common/fault_relay.rs new file mode 100644 index 0000000..c0621c5 --- /dev/null +++ b/crates/kc-cli/tests/common/fault_relay.rs @@ -0,0 +1,109 @@ +//! Relay delivery failure injection; all other calls use the authenticated memory relay. +use super::*; +use kc_wire::{ChannelAllocated, ChannelJoined, DeleteReason, InboxCreated, InboxMessages, + MessageAccepted, Phase, WriterRegister, WriterRegistered}; + +pub struct FaultRelay { + pub inner: MemoryRelay, + pub fail_post: std::sync::Arc, +} +impl Clone for FaultRelay { + fn clone(&self) -> Self { Self { inner: self.inner.clone(), fail_post: self.fail_post.clone() } } +} +impl FaultRelay { + pub fn new(inner: MemoryRelay) -> Self { + Self { inner, fail_post: Default::default() } + } +} +impl Net for FaultRelay { + type Relay = Self; + fn connect(&self, _url: &RelayUrl) -> Result { Ok(self.clone()) } + async fn limits(&self, _url: &RelayUrl) -> Result { Ok(Limits::current()) } +} +impl RelayApi for FaultRelay { + async fn allocate(&self) -> Result { + self.inner.allocate().await + } + async fn join(&self, channel: u16) -> Result { + self.inner.join(channel).await + } + async fn put_phase( + &self, + channel: u16, + side_token: &str, + phase: Phase, + body: &[u8], + ) -> Result<(), RelayError> { + self.inner.put_phase(channel, side_token, phase, body).await + } + async fn get_phase( + &self, + channel: u16, + side_token: &str, + phase: Phase, + wait: Duration, + ) -> Result>, RelayError> { + self.inner.get_phase(channel, side_token, phase, wait).await + } + async fn delete_channel( + &self, + channel: u16, + side_token: &str, + reason: DeleteReason, + ) -> Result<(), RelayError> { + self.inner.delete_channel(channel, side_token, reason).await + } + async fn create_inbox(&self) -> Result { + self.inner.create_inbox().await + } + async fn register_writer( + &self, + inbox_id: &str, + owner_token: &str, + request: &WriterRegister, + ) -> Result { + self.inner.register_writer(inbox_id, owner_token, request).await + } + async fn delete_writer( + &self, + inbox_id: &str, + owner_token: &str, + writer_id: &str, + ) -> Result<(), RelayError> { + self.inner.delete_writer(inbox_id, owner_token, writer_id).await + } + async fn post_message( + &self, + inbox_id: &str, + writer_token: &str, + body: &[u8], + ) -> Result { + if self.fail_post.swap(false, std::sync::atomic::Ordering::SeqCst) { + return Err(kc_proto::relay::RelayError::Transport("injected post failure".into())); + } + self.inner.post_message(inbox_id, writer_token, body).await + } + async fn list_messages( + &self, + inbox_id: &str, + owner_token: &str, + wait: Duration, + ) -> Result { + self.inner.list_messages(inbox_id, owner_token, wait).await + } + async fn delete_message( + &self, + inbox_id: &str, + owner_token: &str, + msg_id: &str, + ) -> Result<(), RelayError> { + self.inner.delete_message(inbox_id, owner_token, msg_id).await + } + async fn delete_inbox( + &self, + inbox_id: &str, + owner_token: &str, + ) -> Result<(), RelayError> { + self.inner.delete_inbox(inbox_id, owner_token).await + } +} diff --git a/crates/kc-cli/tests/common/mod.rs b/crates/kc-cli/tests/common/mod.rs index 9f7b4f4..f9526c7 100644 --- a/crates/kc-cli/tests/common/mod.rs +++ b/crates/kc-cli/tests/common/mod.rs @@ -25,6 +25,8 @@ use tempfile::TempDir; use tokio::sync::oneshot; use zeroize::Zeroizing; +pub mod fault_relay; + pub const NAMESPACE: &str = "dev.1pass.kc.test-cli"; /// A scripted answer to the next prompt. diff --git a/crates/kc-cli/tests/sync.rs b/crates/kc-cli/tests/sync.rs index 49711c7..a2f11d4 100644 --- a/crates/kc-cli/tests/sync.rs +++ b/crates/kc-cli/tests/sync.rs @@ -13,7 +13,7 @@ fn human(answers: Vec) -> Run { run.local_auth.push_back(LocalAuthOutcome::Confirmed); run } -fn state(d: &Device) -> Value { +fn state(d: &Device) -> Value { serde_json::from_slice(&std::fs::read(d.dir.path().join("sync.json")).unwrap()).unwrap() } fn head(d: &Device) -> Vid { @@ -244,12 +244,19 @@ async fn noninteractive_add_review_and_denied_local_confirmation_exit_five() { vec!["sync", "add", "KEY"], vec!["sync", "review"], vec!["sync", "unfreeze"], + vec!["sync", "resolve", "KEY", "--keep", "mine"], + vec!["sync", "restore-checkpoint", "KEY"], + vec!["sync", "rm", "KEY"], ] { + let before = std::fs::read(a.dir.path().join("sync.json")).ok(); a.run(&args, Run::agent()).await.expect(5); + assert_eq!(std::fs::read(a.dir.path().join("sync.json")).ok(), before); + assert_eq!(a.value("KEY").unwrap(), b"fake"); } let mut denied = Run::human(vec![]); denied.local_auth.push_back(LocalAuthOutcome::Denied); a.run(&["sync", "add", "KEY"], denied).await.expect(5); + assert!(!a.dir.path().join("sync.json").exists()); a.run(&["sync", "add", "KEY"], Run::human(vec![])) .await .expect(5); @@ -568,7 +575,7 @@ async fn rejected_held_change_is_not_recreated_by_retransmission() { }; post(&a, &b, &relay, message.clone()).await; b.run(&["inbox"], Run::agent()).await.expect(8); - b.run(&["sync", "review"], Run::human(vec![Answer::Select(1)])) + b.run(&["sync", "review"], human(vec![Answer::Select(1)])) .await .expect(0); post(&a, &b, &relay, message).await; @@ -591,9 +598,14 @@ async fn legacy_overwrite_flag_and_code_receive_cannot_bypass_local_confirmation a.run(&["send", "KEY", "--to", "bravo"], Run::agent()) .await .expect(0); - b.run(&["inbox", "--on-conflict", "overwrite"], Run::agent()) - .await - .expect(8); + let before = std::fs::read(b.dir.path().join("sync.json")).unwrap(); + b.run(&["inbox", "--on-conflict", "overwrite"], Run::agent()).await.expect(5); + assert_eq!(std::fs::read(b.dir.path().join("sync.json")).unwrap(), before); + b.run(&["receive", "--on-conflict", "overwrite"], Run::agent()).await.expect(5); + assert_eq!(std::fs::read(b.dir.path().join("sync.json")).unwrap(), before); + b.run(&["inbox", "--on-conflict", "overwrite"], Run::human(vec![Answer::Yes])) + .await.expect(5); + assert_eq!(state(&b)["candidates"].as_object().unwrap().len(), 1); assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); b.run(&["sync", "review"], human(vec![Answer::Select(0)])) .await @@ -610,13 +622,13 @@ async fn legacy_overwrite_flag_and_code_receive_cannot_bypass_local_confirmation let (rx, tx) = transfer( &b, &["receive", "--on-conflict", "overwrite"], - Run::agent(), + Run::human(vec![Answer::Yes]), &a, &["send", "KEY"], |code| Run::human(vec![Answer::Text(code), Answer::Yes]), ) .await; - rx.expect(8); + rx.expect(5); tx.expect(8); assert_eq!(b.value("KEY").unwrap(), b"fake-legacy-terminal"); } @@ -704,7 +716,7 @@ async fn rejecting_a_proposal_blocks_retries_but_an_explicit_reoffer_is_fresh() .await .expect(8); pump(&a, &b).await; - b.run(&["sync", "review"], Run::human(vec![Answer::Select(1)])) + b.run(&["sync", "review"], human(vec![Answer::Select(1)])) .await .expect(0); pump(&a, &b).await; @@ -721,3 +733,446 @@ async fn rejecting_a_proposal_blocks_retries_but_an_explicit_reoffer_is_fresh() pump(&a, &b).await; assert_eq!(head(&a), head(&b)); } + +fn save_state(d: &Device, s: &Value) { + std::fs::write(d.dir.path().join("sync.json"), serde_json::to_vec_pretty(s).unwrap()).unwrap(); +} +fn hex(bytes: &[u8]) -> String { + bytes.iter().map(|b| format!("{b:02x}")).collect() +} +fn fp_slot(name: &str, vid: Vid) -> String { + use sha2::{Digest, Sha256}; + format!("sync/fp/{}/{}", hex(&Sha256::digest(name.as_bytes())), hex(&vid.0)) +} +fn offer_message(name: &str, vid: Vid, value: &[u8], generation: u64) -> SyncMsg { + SyncMsg::Offer { + name: ItemName::new(name).unwrap(), vid, lineage: vec![], + kind: kc_proto::sync::ItemKind::Text, + value: SecretBytes::from_slice(value), known_generation: generation, + } +} +fn change_message(name: &str, vid: Vid, parent: Vid, value: &[u8]) -> SyncMsg { + SyncMsg::Changes { changes: vec![Change { + name: ItemName::new(name).unwrap(), generation: 1, new_vid: vid, + parents: vec![parent], lineage: vec![parent], + op: Op::Put { kind: kc_proto::sync::ItemKind::Text, value: SecretBytes::from_slice(value) }, + approval_ref: None, + }] } +} +fn confirmations(out: &common::Output) -> Vec<&str> { + out.prompts.iter().filter_map(|p| p.strip_prefix("local confirmation: ")).collect() +} + +#[tokio::test] +async fn failed_hello_delivery_is_retried_on_next_sync() { + let (a, b, relay) = devices().await; + let fault = common::fault_relay::FaultRelay::new(relay.clone()); + let a = Device { name: a.name, dir: a.dir, keychain: a.keychain, net: fault.clone(), env: a.env }; + a.set("KEY", b"fake-hello").await; + fault.fail_post.store(true, std::sync::atomic::Ordering::SeqCst); + a.run(&["sync", "add", "KEY", "--peers", "bravo"], human(vec![])).await.expect(6); + let peer = b.peers().find("alpha").unwrap().fingerprint.to_hex(); + let remote = a.peers().find("bravo").unwrap().fingerprint.to_hex(); + assert_eq!(state(&a)["peers"][&remote]["hello_sent"], false); + let (id, owner) = b.inbox_credentials(); + assert!(relay.list_messages(&id, &owner, std::time::Duration::ZERO).await.unwrap().messages.is_empty()); + a.run(&["sync"], Run::agent()).await.expect(8); + assert_eq!(state(&a)["peers"][&remote]["hello_sent"], true); + assert_eq!(relay.list_messages(&id, &owner, std::time::Duration::ZERO).await.unwrap().messages.len(), 1); + b.run(&["inbox"], Run::agent()).await.expect(0); + assert_eq!(state(&b)["peers"][peer]["capable"], true); +} + +#[tokio::test] +async fn corrupt_sync_state_does_not_break_get_or_exec() { + let a = Device::new("alpha", MemoryRelay::new()); + a.set("KEY", b"fake-independent").await; + std::fs::write(a.dir.path().join("sync.json"), b"broken json").unwrap(); + a.run(&["get", "KEY", "--fingerprint"], Run::agent()).await.expect(0); + a.run(&["exec", "--env", "KEY=KEY", "--", "true"], Run::agent()).await.expect(0); + assert_eq!(std::fs::read(a.dir.path().join("sync.json")).unwrap(), b"broken json"); +} + +#[tokio::test] +async fn confirmation_reasons_name_actions_and_follow_selection() { + let a = Device::new("alpha", MemoryRelay::new()); + for name in ["a", "b", "c", "d", "e", "f", "g"] { a.set(name, b"fake").await; } + let mut denied = Run::human(vec![Answer::Multi(vec![0, 1, 2, 3, 4, 5, 6])]); + denied.local_auth.push_back(LocalAuthOutcome::Denied); + let out = a.run(&["sync", "add"], denied).await; + out.expect(5); + assert!(out.prompts[0].contains("Select sync items")); + assert_eq!(confirmations(&out), vec!["kc sync add a, b, c and 4 more"]); + assert!(!a.dir.path().join("sync.json").exists()); + let cases = [ + (vec!["sync", "rm", "a", "b"], "kc sync rm a, b"), + (vec!["sync", "peer", "add", "bravo"], "kc sync peer add bravo"), + (vec!["sync", "peer", "rm", "bravo"], "kc sync peer rm bravo"), + (vec!["sync", "resolve", "a", "--keep", "mine"], "Resolve a: keep mine"), + (vec!["sync", "restore-checkpoint", "a"], "Restore a to its checkpoint"), + (vec!["sync", "unfreeze"], "Unfreeze sync"), + (vec!["sync", "status", "--confirm-checkpoint", "a"], "Confirm the current value of a as its checkpoint"), + ]; + for (args, expected) in cases { + let out = a.run(&args, Run::human(vec![])).await; + out.expect(5); + assert_eq!(confirmations(&out), vec![expected]); + assert!(!a.dir.path().join("sync.json").exists()); + } +} + +#[tokio::test] +async fn review_accept_and_reject_share_one_confirmation_and_denial_changes_nothing() { + let (a, b, relay) = devices().await; + for name in ["A", "B"] { + post(&a, &b, &relay, offer_message(name, Vid::random(), b"fake-review", 0)).await; + } + b.run(&["inbox"], Run::agent()).await.expect(8); + let before = std::fs::read(b.dir.path().join("sync.json")).unwrap(); + let mut denied = Run::human(vec![Answer::Select(0), Answer::Select(1)]); + denied.local_auth.push_back(LocalAuthOutcome::Denied); + let out = b.run(&["sync", "review"], denied).await; + out.expect(5); + assert_eq!(confirmations(&out).len(), 1); + assert!(confirmations(&out)[0].contains("from alpha; reject")); + assert_eq!(std::fs::read(b.dir.path().join("sync.json")).unwrap(), before); + assert!(b.value("A").is_none() && b.value("B").is_none()); + assert!(state(&b)["items"].as_object().unwrap().is_empty()); + let out = b.run(&["sync", "review"], human(vec![Answer::Select(0), Answer::Select(1)])).await; + out.expect(0); + assert_eq!(confirmations(&out).len(), 1); + assert!(state(&b)["candidates"].as_object().unwrap().is_empty()); + assert_eq!(state(&b)["items"].as_object().unwrap().len(), 1); +} + +#[tokio::test] +async fn held_review_denied_and_agent_mutations_preserve_existing_state() { + let (a, b, _) = devices().await; + enroll(&a, &b).await; + a.set("KEY", b"fake-denied").await; + pump(&a, &b).await; + let before = std::fs::read(b.dir.path().join("sync.json")).unwrap(); + let mut denied = Run::human(vec![Answer::Select(0)]); + denied.local_auth.push_back(LocalAuthOutcome::Denied); + b.run(&["sync", "review"], denied).await.expect(5); + assert_eq!(std::fs::read(b.dir.path().join("sync.json")).unwrap(), before); + for args in [vec!["sync", "resolve", "KEY", "--keep", "mine"], vec!["sync", "restore-checkpoint", "KEY"], vec!["sync", "rm", "KEY"]] { + b.run(&args, Run::agent()).await.expect(5); + assert_eq!(std::fs::read(b.dir.path().join("sync.json")).unwrap(), before); + } + assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); + assert_eq!(state(&b)["candidates"].as_object().unwrap().len(), 1); +} + +#[tokio::test] +async fn legacy_policies_hold_and_denial_continues_batch_then_one_l_replaces() { + for policy in [None, Some("skip"), Some("rename"), Some("overwrite")] { + let (a, b, _) = devices().await; + enroll(&a, &b).await; + a.store().set("KEY", b"fake-legacy-batch", kc_store::ItemKind::Text, kc_store::Origin::Local).unwrap(); + a.set("OTHER", b"fake-other").await; + a.run(&["send", "KEY", "OTHER", "--to", "bravo"], Run::agent()).await.expect(0); + let mut args = vec!["inbox"]; + if let Some(p) = policy { args.extend(["--on-conflict", p]); } + let mut run = Run::human(vec![Answer::Yes]); + if policy == Some("overwrite") { run.local_auth.push_back(LocalAuthOutcome::Denied); } + let out = b.run(&args, run).await; + out.expect(if policy == Some("overwrite") { 5 } else { 8 }); + assert_eq!(b.value("OTHER").unwrap(), b"fake-other"); + assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); + assert_eq!(confirmations(&out).len(), usize::from(policy == Some("overwrite"))); + assert!(b.value("KEY-2").is_none()); + assert_eq!(state(&b)["candidates"].as_object().unwrap().len(), 1); + assert!(out.stderr.contains("run `kc sync review`")); + } + let (a, b, _) = devices().await; + enroll(&a, &b).await; + a.store().set("KEY", b"fake-inline", kc_store::ItemKind::Text, kc_store::Origin::Local).unwrap(); + a.run(&["send", "KEY", "--to", "bravo"], Run::agent()).await.expect(0); + let out = b.run(&["inbox", "--on-conflict", "overwrite"], human(vec![Answer::Yes])).await; + out.expect(0); + assert_eq!(confirmations(&out), vec!["Replace KEY with the value from alpha"]); + assert_eq!(b.value("KEY").unwrap(), b"fake-inline"); + assert!(state(&b)["candidates"].as_object().unwrap().is_empty()); +} + +#[tokio::test] +async fn status_and_review_fingerprints_match_get_across_devices() { + let (a, b, _) = devices().await; + enroll(&a, &b).await; + let fp = a.run(&["get", "KEY", "--fingerprint"], Run::agent()).await.stdout_text(); + for d in [&a, &b] { + let out = d.run(&["sync", "status", "--json"], Run::agent()).await; + let json: Value = serde_json::from_slice(&out.stdout).unwrap(); + assert_eq!(json["items"][0]["fingerprint"], fp.trim()); + } + a.set("KEY", b"fake-fingerprint-new").await; + pump(&a, &b).await; + let proposed = a.run(&["get", "KEY", "--fingerprint"], Run::agent()).await.stdout_text(); + let out = b.run(&["sync", "status", "--json"], Run::agent()).await; + let json: Value = serde_json::from_slice(&out.stdout).unwrap(); + assert_eq!(json["candidates"][0]["fingerprint"], proposed.trim()); + let out = b.run(&["sync", "review"], Run::human(vec![Answer::Select(2)])).await; + assert!(out.prompts[0].contains(fp.trim())); + assert!(out.prompts[0].contains(proposed.trim())); +} + +#[tokio::test] +async fn offers_from_disabled_or_tripped_peers_are_logged_only() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + b.run(&["sync", "peer", "rm", "alpha"], human(vec![])).await.expect(0); + post(&a, &b, &relay, offer_message("DISABLED", Vid::random(), b"fake-disabled", 0)).await; + b.run(&["inbox"], Run::agent()).await.expect(0); + assert!(state(&b)["candidates"].as_object().unwrap().is_empty()); + b.run(&["sync", "peer", "add", "alpha"], human(vec![])).await.expect(8); + // Peer rm removed KEY's scope. Restore it through the explicit add operation. + b.run(&["sync", "add", "KEY", "--peers", "alpha"], human(vec![])).await.expect(8); + let parent = head(&b); + for _ in 0..6 { + let mut message = change_message("KEY", Vid::random(), parent, b"fake-trip"); + if let SyncMsg::Changes { changes } = &mut message { changes[0].generation = 2; } + post(&a, &b, &relay, message).await; + } + b.run(&["inbox"], Run::agent()).await.expect(8); + let out = b.run(&["sync", "status", "--json"], Run::agent()).await; + let status: Value = serde_json::from_slice(&out.stdout).unwrap(); + assert_eq!(status["peers"][0]["breaker"], true); + let before = state(&b)["candidates"].clone(); + post(&a, &b, &relay, offer_message("BLOCKED", Vid::random(), b"fake-blocked", 0)).await; + b.run(&["inbox"], Run::agent()).await.expect(8); + assert_eq!(state(&b)["candidates"], before); + assert!(std::fs::read_to_string(b.dir.path().join("sync.log")).unwrap().contains("Ignored a sync offer")); +} + +#[tokio::test] +async fn offer_during_conflict_is_a_candidate_and_review_cannot_discard_it() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + a.set("KEY", b"fake-conflict-a").await; + b.set("KEY", b"fake-conflict-b").await; + pump(&a, &b).await; + let before = state(&b)["candidates"].as_object().unwrap().len(); + let offered = Vid::random(); + post(&a, &b, &relay, offer_message("KEY", offered, b"fake-conflict-offer", 1)).await; + b.run(&["inbox"], Run::agent()).await.expect(8); + let s = state(&b); + assert_eq!(s["candidates"].as_object().unwrap().len(), before + 1); + assert!(s["candidates"].as_object().unwrap().values().any(|c| c["version"]["vid"] == serde_json::to_value(offered).unwrap() && c["category"] == "conflict")); + b.run(&["sync", "review"], Run::human(vec![])).await.expect(8); + assert_eq!(state(&b)["candidates"], s["candidates"]); + assert_eq!(b.value("KEY").unwrap(), b"fake-conflict-b"); +} + +#[tokio::test] +async fn sync_envelope_replay_is_skipped_by_seen_set() { + let (a, b, relay) = devices().await; + post(&a, &b, &relay, SyncMsg::Hello { features: vec!["sync-phase1".into()], is_reply: false }).await; + let (id, owner) = b.inbox_credentials(); + let listed = relay.list_messages(&id, &owner, std::time::Duration::ZERO).await.unwrap(); + let body = kc_proto::relay::message_body(&listed.messages[0]).unwrap(); + b.run(&["inbox"], Run::agent()).await.expect(0); + let (aid, aowner) = a.inbox_credentials(); + let replies = relay.list_messages(&aid, &aowner, std::time::Duration::ZERO).await.unwrap().messages.len(); + relay.post_message(&id, &a.writer_bearer("bravo"), &body).await.unwrap(); + b.run(&["inbox"], Run::agent()).await.expect(7); + assert_eq!(relay.list_messages(&aid, &aowner, std::time::Duration::ZERO).await.unwrap().messages.len(), replies); +} + +#[tokio::test] +async fn convergence_binding_failure_quarantines_only_that_flow_and_rejects_ack() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + let vid = Vid::random(); + // A valid stored record outside the bounded known list, with an incompatible fp. + b.store().set_internal(&fp_slot("KEY", vid), &serde_json::to_vec(&kc_sync::VidRecord { + fp: kc_sync::Fp([7; 32]), parents: vec![], + }).unwrap()).unwrap(); + let old_head = head(&b); + post(&a, &b, &relay, change_message("KEY", vid, old_head, b"fake-initial-secret")).await; + post(&a, &b, &relay, offer_message("OTHER", Vid::random(), b"fake-next-message", 0)).await; + b.run(&["inbox"], Run::agent()).await.expect(8); + assert_eq!(head(&b), old_head); + assert!(state(&b)["peers"].as_object().unwrap().values().any(|p| p["quarantine"].as_array().unwrap().contains(&Value::String("KEY".into())))); + assert!(state(&b)["candidates"].as_object().unwrap().values().any(|c| c["version"]["name"] == "OTHER")); + assert!(state(&b)["receipts"].as_object().unwrap().values().any(|r| r[0] == "Rejected")); + let (id, owner) = a.inbox_credentials(); + let key = a.store().get_internal("device-key").unwrap().unwrap(); + let key = kc_proto::DeviceKeyPair::from_secret_bytes(key.as_bytes()).unwrap(); + let sender = a.peers().find("bravo").unwrap().device_pk; + let mut rejected = false; + for envelope in relay.list_messages(&id, &owner, std::time::Duration::ZERO).await.unwrap().messages { + let bytes = kc_proto::relay::message_body(&envelope).unwrap(); + let opened = kc_proto::inbox::open_any(&bytes, &[&key], |_| Some(sender), |_| false, kc_proto::inbox::unix_now()).unwrap(); + if let kc_proto::inbox::Body::Sync(SyncMsg::Ack { results }) = opened.body { + rejected |= results.iter().any(|(id, result)| id.new_vid == vid && *result == kc_proto::sync::AckResult::Rejected); + } + } + assert!(rejected); +} + +#[tokio::test] +async fn offer_then_change_binds_parents_and_promotes_proposal_to_held() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + let vid = Vid::random(); + post(&a, &b, &relay, offer_message("KEY", vid, b"fake-promoted", 1)).await; + b.run(&["inbox"], Run::agent()).await.expect(8); + let parent = head(&b); + post(&a, &b, &relay, change_message("KEY", vid, parent, b"fake-promoted")).await; + b.run(&["inbox"], Run::agent()).await.expect(8); + let s = state(&b); + assert_eq!(s["candidates"].as_object().unwrap().len(), 1); + let c = s["candidates"].as_object().unwrap().values().next().unwrap(); + assert_eq!(c["category"], "held"); + assert_eq!(c["version"]["parents"], serde_json::to_value(vec![parent]).unwrap()); + assert_eq!(c["invalid_binding"], false); + assert!(s["unbound"].as_array().unwrap().is_empty()); + b.run(&["sync", "review"], human(vec![Answer::Select(0)])).await.expect(0); + assert_eq!(b.value("KEY").unwrap(), b"fake-promoted"); +} + +#[tokio::test] +async fn stale_ack_revokes_grant_without_inventing_generation_or_revoking_newer_accept() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + a.set("KEY", b"fake-stale-ack").await; + let vid = head(&a); + let stale = SyncMsg::Ack { results: vec![(kc_proto::sync::ChangeId { + name: ItemName::new("KEY").unwrap(), generation: 1, new_vid: vid, + }, kc_proto::sync::AckResult::StaleGeneration)] }; + // post helper sends A -> B, so construct the reverse envelope here. + let key = b.store().get_internal("device-key").unwrap().unwrap(); + let key = kc_proto::DeviceKeyPair::from_secret_bytes(key.as_bytes()).unwrap(); + let peer = b.peers().find("alpha").unwrap().clone(); + let sealed = kc_proto::inbox::seal_v2(&key, &peer.device_pk, &kc_proto::inbox::Body::Sync(stale.clone()), std::time::Duration::from_secs(86400), kc_proto::inbox::unix_now()).unwrap(); + relay.post_message(&a.inbox_credentials().0, &b.writer_bearer("alpha"), &sealed.body).await.unwrap(); + a.run(&["inbox"], Run::agent()).await.expect(8); + let peer_id = a.peers().find("bravo").unwrap().fingerprint.to_hex(); + assert_eq!(state(&a)["generations"]["remote"][&peer_id]["KEY"]["accepted"], false); + assert_eq!(state(&a)["generations"]["remote"][&peer_id]["KEY"]["generation"], 1); + a.set("KEY", b"fake-no-stale-send").await; + let s = state(&a); + let outbox: kc_sync::Outbox = serde_json::from_value(s["outbox"].clone()).unwrap(); + assert!(outbox.pending(&kc_sync::PeerId(peer_id.clone())).next().is_none()); + + // Recreate a pending old delivery with a newer accepted epoch to prove reordering safety. + let mut s = state(&a); + let mut outbox: kc_sync::Outbox = serde_json::from_value(s["outbox"].clone()).unwrap(); + outbox.enqueue(kc_sync::PeerId(peer_id.clone()), kc_sync::ChangeId { name: "KEY".into(), generation: 1, new_vid: kc_sync::Vid(vid.0) }); + s["outbox"] = serde_json::to_value(outbox).unwrap(); + s["generations"]["remote"][&peer_id]["KEY"]["accepted"] = true.into(); + s["generations"]["remote"][&peer_id]["KEY"]["generation"] = 2.into(); + save_state(&a, &s); + let sealed = kc_proto::inbox::seal_v2(&key, &peer.device_pk, &kc_proto::inbox::Body::Sync(stale), std::time::Duration::from_secs(86400), kc_proto::inbox::unix_now()).unwrap(); + relay.post_message(&a.inbox_credentials().0, &b.writer_bearer("alpha"), &sealed.body).await.unwrap(); + a.run(&["inbox"], Run::agent()).await.expect(8); + assert_eq!(state(&a)["generations"]["remote"][&peer_id]["KEY"]["accepted"], true); +} + +#[tokio::test] +async fn candidate_eviction_collects_base_and_startup_collects_only_orphan_snapshots() { + let (a, b, relay) = devices().await; + for n in 0..16 { + post(&a, &b, &relay, offer_message(&format!("P{n}"), Vid::random(), b"fake-eviction", 0)).await; + } + b.run(&["inbox"], Run::agent()).await.expect(8); + let before = state(&b); + let base_slots = before["candidates"].as_object().unwrap().iter().map(|(slot, c)| (slot.clone(), c["base_record"].as_str().unwrap().to_owned())).collect::>(); + b.set("LOCAL", b"fake-local").await; + b.run(&["sync", "add", "LOCAL", "--peers", "alpha"], human(vec![])).await.expect(8); + let after = state(&b); + let evicted = base_slots.iter().filter(|(slot, _)| after["candidates"].get(slot).is_none()).collect::>(); + assert_eq!(evicted.len(), 1); + for (slot, base) in evicted { + assert!(b.store().get_internal(slot).unwrap().is_none()); + assert!(b.store().get_internal(base).unwrap().is_none()); + } + let retained = after["slots"].as_object().unwrap().keys().find(|s| s.starts_with("sync/snapshot/")).unwrap().clone(); + let orphan = format!("sync/snapshot/{}", hex(&Vid::random().0)); + b.store().set_internal(&orphan, b"fake-orphan").unwrap(); + let mut injected = after; + injected["slots"][&orphan] = "ConflictCandidate".into(); + let queued_vid = Vid::random(); + let queued_slot = format!("sync/snapshot/{}", hex(&queued_vid.0)); + b.store().set_internal(&queued_slot, b"fake-queued").unwrap(); + injected["slots"][&queued_slot] = "ConflictCandidate".into(); + let mut outbox: kc_sync::Outbox = serde_json::from_value(injected["outbox"].clone()).unwrap(); + outbox.enqueue(kc_sync::PeerId(b.peers().find("alpha").unwrap().fingerprint.to_hex()), + kc_sync::ChangeId { name: "QUEUED".into(), generation: 1, new_vid: kc_sync::Vid(queued_vid.0) }); + injected["outbox"] = serde_json::to_value(outbox).unwrap(); + save_state(&b, &injected); + b.run(&["sync", "status", "--json"], Run::agent()).await.expect(8); + assert!(b.store().get_internal(&orphan).unwrap().is_none()); + assert!(state(&b)["slots"].get(&orphan).is_none()); + assert!(b.store().get_internal(&retained).unwrap().is_some()); + assert!(state(&b)["slots"].get(&retained).is_some()); + assert!(b.store().get_internal(&queued_slot).unwrap().is_some()); + assert!(state(&b)["slots"].get(&queued_slot).is_some()); +} + +#[tokio::test] +async fn rejecting_proposal_deletes_binding_and_unbound_and_rm_releases_checkpoint() { + let (a, b, relay) = devices().await; + let vid = Vid::random(); + post(&a, &b, &relay, offer_message("PROPOSAL", vid, b"fake-proposal-gc", 0)).await; + b.run(&["inbox"], Run::agent()).await.expect(8); + assert!(b.store().get_internal(&fp_slot("PROPOSAL", vid)).unwrap().is_some()); + assert_eq!(state(&b)["unbound"].as_array().unwrap().len(), 1); + let before = std::fs::read(b.dir.path().join("sync.json")).unwrap(); + let out = b.run(&["sync", "review"], Run::human(vec![Answer::Select(1)])).await; + out.expect(5); + assert_eq!(confirmations(&out).len(), 1); + assert_eq!(std::fs::read(b.dir.path().join("sync.json")).unwrap(), before); + let out = b.run(&["sync", "review"], human(vec![Answer::Select(1)])).await; + out.expect(0); + assert_eq!(confirmations(&out).len(), 1); + assert!(b.store().get_internal(&fp_slot("PROPOSAL", vid)).unwrap().is_none()); + assert!(state(&b)["unbound"].as_array().unwrap().is_empty()); + enroll(&a, &b).await; + b.run(&["sync", "status", "--confirm-checkpoint", "KEY"], human(vec![])).await.expect(0); + let checkpoint = state(&b)["slots"].as_object().unwrap().keys().find(|s| s.starts_with("sync/kg/")).unwrap().clone(); + assert!(b.store().get_internal(&checkpoint).unwrap().is_some()); + b.run(&["sync", "rm", "KEY"], human(vec![])).await.expect(0); + assert!(b.store().get_internal(&checkpoint).unwrap().is_none()); + assert!(state(&b)["slots"].get(&checkpoint).is_none()); + assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); +} + +#[tokio::test] +async fn full_capacity_scan_and_preserve_mine_leave_inbox_review_and_resolve_operational() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + // Pinned slots cannot be evicted. This isolates scan/preserve capacity failure + // from the lower-priority eviction path exercised above. + let mut s = state(&b); + for n in 0..16 { + let slot = format!("sync/kg/test-{n}"); + b.store().set_internal(&slot, b"fake-pinned").unwrap(); + s["slots"][slot] = "Checkpoint".into(); + } + save_state(&b, &s); + b.store().set("KEY", b"fake-out-of-band", kc_store::ItemKind::Text, kc_store::Origin::Local).unwrap(); + post(&a, &b, &relay, SyncMsg::Hello { features: vec![], is_reply: true }).await; + let out = b.run(&["inbox"], Run::agent()).await; + out.expect(8); + assert!(!out.stderr.contains("Sync storage is full")); + let out = b.run(&["sync", "review"], Run::human(vec![])).await; + out.expect(8); + assert!(!out.stderr.contains("Sync storage is full")); + let status = b.run(&["sync", "status", "--json"], Run::agent()).await; + let status: Value = serde_json::from_slice(&status.stdout).unwrap(); + assert_eq!(status["capacity_blocked"], true); + assert!(std::fs::read_to_string(b.dir.path().join("sync.log")).unwrap().contains("Sync storage is full")); + assert_eq!(b.value("KEY").unwrap(), b"fake-out-of-band"); + let out = b.run(&["sync", "resolve", "KEY", "--keep", "mine"], human(vec![])).await; + out.expect(8); + assert!(!out.stderr.contains("Sync storage is full")); + assert_eq!(b.value("KEY").unwrap(), b"fake-out-of-band"); + // After capacity is freed, the same review/resolve path can recover normally. + let mut s = state(&b); + s["slots"].as_object_mut().unwrap().retain(|slot, _| !slot.starts_with("sync/kg/test-")); + save_state(&b, &s); + b.run(&["sync", "resolve", "KEY", "--keep", "mine"], human(vec![])).await.expect(8); + assert_eq!(state(&b)["items"]["KEY"]["conflict"], false); +} From d35b6511d3446c4c7d3d4d66d35d9f801b385582 Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Tue, 13 Oct 2026 18:08:26 +0900 Subject: [PATCH 19/24] style: cargo fmt Co-Authored-By: Claude Opus 5.5 --- crates/kc-cli/src/commands/apply.rs | 20 +- crates/kc-cli/src/commands/mod.rs | 4 +- crates/kc-cli/src/sync/actions.rs | 85 ++- crates/kc-cli/src/sync/mod.rs | 14 +- crates/kc-cli/src/sync/receive.rs | 74 ++- crates/kc-cli/src/sync/transaction.rs | 40 +- crates/kc-cli/src/sync/transport.rs | 3 +- crates/kc-cli/tests/common/fault_relay.rs | 53 +- crates/kc-cli/tests/sync.rs | 665 ++++++++++++++++++---- 9 files changed, 777 insertions(+), 181 deletions(-) diff --git a/crates/kc-cli/src/commands/apply.rs b/crates/kc-cli/src/commands/apply.rs index 49c4a9f..4e9e40e 100644 --- a/crates/kc-cli/src/commands/apply.rs +++ b/crates/kc-cli/src/commands/apply.rs @@ -71,7 +71,9 @@ pub(crate) struct Applied { impl Applied { /// 0 if everything is here, the keychain error's code if the keychain failed, else 8. pub fn exit_code(&self) -> i32 { - if self.confirmation_denied { return exit::INTERACTION_REQUIRED; } + if self.confirmation_denied { + return exit::INTERACTION_REQUIRED; + } match &self.keychain_error { Some((_, code)) => *code, None => local_exit_code(&self.results), @@ -259,9 +261,19 @@ fn apply_one( if value.len() > MAX_VALUE_LEN { return Ok(ItemStatus::Rejected(REJECT_TOO_LARGE)); } - if let Some(status) = crate::sync::legacy(ctx, item, from_device, conflicts == Conflicts::Policy(ConflictPolicy::Overwrite)) - .map_err(|e| if e.code == exit::INTERACTION_REQUIRED { Failure::SyncConfirmation(e) } else { Failure::Cli(e) })? - { + if let Some(status) = crate::sync::legacy( + ctx, + item, + from_device, + conflicts == Conflicts::Policy(ConflictPolicy::Overwrite), + ) + .map_err(|e| { + if e.code == exit::INTERACTION_REQUIRED { + Failure::SyncConfirmation(e) + } else { + Failure::Cli(e) + } + })? { return Ok(status); } let policy = match conflicts { diff --git a/crates/kc-cli/src/commands/mod.rs b/crates/kc-cli/src/commands/mod.rs index f201e23..a959fa6 100644 --- a/crates/kc-cli/src/commands/mod.rs +++ b/crates/kc-cli/src/commands/mod.rs @@ -119,7 +119,9 @@ async fn dispatch(ctx: &mut Ctx<'_, H>, command: Command) -> Result { let code = inbox::inbox(ctx, args).await?; crate::sync::flush(ctx, false).await?; - Ok(if code != 0 && code != 8 { code } else { + Ok(if code != 0 && code != 8 { + code + } else { code.max(crate::sync::pending_code(ctx)?) }) } diff --git a/crates/kc-cli/src/sync/actions.rs b/crates/kc-cli/src/sync/actions.rs index 5a76b81..55dc763 100644 --- a/crates/kc-cli/src/sync/actions.rs +++ b/crates/kc-cli/src/sync/actions.rs @@ -160,7 +160,10 @@ pub(crate) fn status(ctx: &mut Ctx<'_, H>, json: bool) -> Result { } else { tr!("in sync") }; - let fingerprint = ctx.store.get(name)?.map(|v| crate::values::value_fingerprint(v.as_bytes())); + let fingerprint = ctx + .store + .get(name)? + .map(|v| crate::values::value_fingerprint(v.as_bytes())); let peers = item .scope .iter() @@ -269,7 +272,9 @@ pub(crate) fn review(ctx: &mut Ctx<'_, H>) -> Result { let value = blob(ctx, &c.version.slot)?; crate::values::value_fingerprint(value.value.expose()) }; - let existing = ctx.store.get(&c.version.name)? + let existing = ctx + .store + .get(&c.version.name)? .map(|v| crate::values::value_fingerprint(v.as_bytes())) .unwrap_or_else(|| "-".into()); let question = tr!( @@ -294,9 +299,24 @@ pub(crate) fn review(ctx: &mut Ctx<'_, H>) -> Result { ctx, &tr!( "Accept {names} from {devices}; reject {rejected}", - names = names_summary(&accepts.iter().map(|c| c.version.name.clone()).collect::>()), - devices = names_summary(&accepts.iter().map(|c| label(ctx, &c.peer)).collect::>>()?), - rejected = names_summary(&rejects.iter().map(|c| c.version.name.clone()).collect::>()) + names = names_summary( + &accepts + .iter() + .map(|c| c.version.name.clone()) + .collect::>() + ), + devices = names_summary( + &accepts + .iter() + .map(|c| label(ctx, &c.peer)) + .collect::>>()? + ), + rejected = names_summary( + &rejects + .iter() + .map(|c| c.version.name.clone()) + .collect::>() + ) ), )?; } @@ -312,14 +332,19 @@ pub(crate) fn review(ctx: &mut Ctx<'_, H>) -> Result { if c.category == CandidateKind::Proposal { s.rejected_offers.insert(delivery); let record = record_slot(&c.version.name, c.version.vid); - let referenced = s.items.get(&c.version.name) + let referenced = s + .items + .get(&c.version.name) .is_some_and(|i| i.head == c.version.vid) - || s.versions.values().any(|v| v.name == c.version.name && v.vid == c.version.vid) + || s.versions + .values() + .any(|v| v.name == c.version.name && v.vid == c.version.vid) || s.candidates.values().any(|other| { other.version.name == c.version.name && other.version.vid == c.version.vid }); if !referenced { - s.unbound.remove(&format!("{}:{}", c.version.name, vid_key(c.version.vid))); + s.unbound + .remove(&format!("{}:{}", c.version.name, vid_key(c.version.vid))); if let Some(item) = s.items.get_mut(&c.version.name) { item.known.retain(|vid| *vid != c.version.vid); } @@ -377,19 +402,45 @@ pub(crate) fn command(ctx: &mut Ctx<'_, H>, mut command: SyncCommand) - if let SyncCommand::Add { names, .. } = &mut command && names.is_empty() { - let options = ctx.store.list()?.into_iter().map(|i| i.name).collect::>(); - *names = ctx.multi_select(&tr!("Select sync items."), &options)? - .into_iter().map(|i| options[i].clone()).collect(); + let options = ctx + .store + .list()? + .into_iter() + .map(|i| i.name) + .collect::>(); + *names = ctx + .multi_select(&tr!("Select sync items."), &options)? + .into_iter() + .map(|i| options[i].clone()) + .collect(); } let reason = match &command { - SyncCommand::Add { names, .. } => Some(tr!("kc sync add {names}", names = names_summary(names))), + SyncCommand::Add { names, .. } => { + Some(tr!("kc sync add {names}", names = names_summary(names))) + } SyncCommand::Rm { names } => Some(tr!("kc sync rm {names}", names = names_summary(names))), - SyncCommand::Peer { command: SyncPeerCommand::Add { label } } => Some(tr!("kc sync peer add {label}", label = label)), - SyncCommand::Peer { command: SyncPeerCommand::Rm { label } } => Some(tr!("kc sync peer rm {label}", label = label)), - SyncCommand::Resolve { name, keep } => Some(tr!("Resolve {name}: keep {choice}", name = name, choice = keep)), - SyncCommand::RestoreCheckpoint { name } => Some(tr!("Restore {name} to its checkpoint", name = name)), + SyncCommand::Peer { + command: SyncPeerCommand::Add { label }, + } => Some(tr!("kc sync peer add {label}", label = label)), + SyncCommand::Peer { + command: SyncPeerCommand::Rm { label }, + } => Some(tr!("kc sync peer rm {label}", label = label)), + SyncCommand::Resolve { name, keep } => Some(tr!( + "Resolve {name}: keep {choice}", + name = name, + choice = keep + )), + SyncCommand::RestoreCheckpoint { name } => { + Some(tr!("Restore {name} to its checkpoint", name = name)) + } SyncCommand::Unfreeze => Some(tr!("Unfreeze sync")), - SyncCommand::Status { confirm_checkpoint: Some(name), .. } => Some(tr!("Confirm the current value of {name} as its checkpoint", name = name)), + SyncCommand::Status { + confirm_checkpoint: Some(name), + .. + } => Some(tr!( + "Confirm the current value of {name} as its checkpoint", + name = name + )), _ => None, }; if let Some(reason) = reason { diff --git a/crates/kc-cli/src/sync/mod.rs b/crates/kc-cli/src/sync/mod.rs index 5747049..241e288 100644 --- a/crates/kc-cli/src/sync/mod.rs +++ b/crates/kc-cli/src/sync/mod.rs @@ -211,8 +211,12 @@ fn reserve( } Reservation::Reserved { evicted } => { if let Some(victim) = evicted { - let evicted = s.candidates.values() - .filter(|c| c.version.slot == victim).cloned().collect::>(); + let evicted = s + .candidates + .values() + .filter(|c| c.version.slot == victim) + .cloned() + .collect::>(); for c in evicted { s.gc.insert(c.base_record); } @@ -290,6 +294,10 @@ fn names_summary(names: &[String]) -> String { if names.len() <= 3 { names.join(", ") } else { - tr!("{names} and {n} more", names = names[..3].join(", "), n = names.len() - 3) + tr!( + "{names} and {n} more", + names = names[..3].join(", "), + n = names.len() - 3 + ) } } diff --git a/crates/kc-cli/src/sync/receive.rs b/crates/kc-cli/src/sync/receive.rs index 17a2fb6..6fe33cd 100644 --- a/crates/kc-cli/src/sync/receive.rs +++ b/crates/kc-cli/src/sync/receive.rs @@ -32,7 +32,13 @@ pub(crate) fn receive(ctx: &mut Ctx<'_, H>, peer: &str, message: &SyncM } => { let name = name.as_str(); if !p.enabled || s.limiter.is_tripped(&PeerId(peer.into())) { - log(ctx, tr!("Ignored a sync offer from disabled or blocked peer {peer}.", peer = super::actions::label(ctx, peer)?))?; + log( + ctx, + tr!( + "Ignored a sync offer from disabled or blocked peer {peer}.", + peer = super::actions::label(ctx, peer)? + ), + )?; } else if *known_generation < s.generations.generation(name) { log( ctx, @@ -227,14 +233,20 @@ pub(crate) fn receive(ctx: &mut Ctx<'_, H>, peer: &str, message: &SyncM } else { s.deferred.remove(&delivery); } - s.outbox.ack(&PeerId(peer.into()), &map::id(id), map::ack(*result)); + s.outbox + .ack(&PeerId(peer.into()), &map::id(id), map::ack(*result)); if *result == AckResult::StaleGeneration - && s.generations.known_generation(&PeerId(peer.into()), id.name.as_str()) <= id.generation + && s.generations + .known_generation(&PeerId(peer.into()), id.name.as_str()) + <= id.generation { // The ACK carries the rejected (old) generation, not the receiver's // new one. Invalidate only that still-current grant; a reordered ACK // must not revoke a newer Accept. Re-offering learns the actual epoch. - if s.generations.outgoing_generation(&PeerId(peer.into()), id.name.as_str()) == Some(id.generation) { + if s.generations + .outgoing_generation(&PeerId(peer.into()), id.name.as_str()) + == Some(id.generation) + { invalidate_generation(&mut s, peer, id.name.as_str())?; } s.peers @@ -285,7 +297,8 @@ pub(crate) fn receive(ctx: &mut Ctx<'_, H>, peer: &str, message: &SyncM // Preserve the known receiver epoch while clearing its grant in the persisted adapter. fn invalidate_generation(s: &mut State, peer: &str, name: &str) -> Result<()> { let mut generations = serde_json::to_value(&s.generations).map_err(|_| state_error())?; - let accepted = generations.get_mut("remote") + let accepted = generations + .get_mut("remote") .and_then(|remote| remote.get_mut(peer)) .and_then(|names| names.get_mut(name)) .and_then(|grant| grant.get_mut("accepted")) @@ -448,10 +461,27 @@ fn change_received( if let Some(fp) = fp && !matches!(remember(ctx, name, c.new_vid, fp, &c.parents), Ok(true)) { - s.peers.get_mut(peer).unwrap().quarantine.insert(name.into()); - s.receipts.insert(delivery, (AckResult::Rejected, ctx.host.now().saturating_add(3 * 86400))); + s.peers + .get_mut(peer) + .unwrap() + .quarantine + .insert(name.into()); + s.receipts.insert( + delivery, + ( + AckResult::Rejected, + ctx.host.now().saturating_add(3 * 86400), + ), + ); ack(s, peer, c, AckResult::Rejected); - log(ctx, tr!("Sync {name}: {result}.", name = name, result = tr!("declined")))?; + log( + ctx, + tr!( + "Sync {name}: {result}.", + name = name, + result = tr!("declined") + ), + )?; return s.save(&ctx.state); } let item = s.items.get_mut(name).unwrap(); @@ -524,7 +554,10 @@ pub(super) fn preserve_mine( false, false, )? { - log(ctx, tr!("Sync storage is full; review pending items before retrying."))?; + log( + ctx, + tr!("Sync storage is full; review pending items before retrying."), + )?; } } Ok(()) @@ -571,7 +604,8 @@ pub(super) fn store_candidate( } if let Some(old) = s.candidates.get(&v.slot) { let promote = old.category == CandidateKind::Proposal - && category != CandidateKind::Proposal && !invalid_binding; + && category != CandidateKind::Proposal + && !invalid_binding; if (!promote && old.version.parents != v.parents) || old.retire != retire { return Ok(false); } @@ -587,9 +621,14 @@ pub(super) fn store_candidate( old.version.parents = v.parents; old.version.lineage = v.lineage; old.generation = generation; - s.slots.insert(v.slot.clone(), if category == CandidateKind::Conflict { - SlotKind::ConflictCandidate - } else { SlotKind::Held }); + s.slots.insert( + v.slot.clone(), + if category == CandidateKind::Conflict { + SlotKind::ConflictCandidate + } else { + SlotKind::Held + }, + ); } return Ok(true); } @@ -709,7 +748,14 @@ pub(crate) fn legacy( } s.save(&ctx.state)?; if overwrite && ctx.interactive() && !s.frozen { - if let Err(error) = human(ctx, &tr!("Replace {name} with the value from {device}", name = name, device = from)) { + if let Err(error) = human( + ctx, + &tr!( + "Replace {name} with the value from {device}", + name = name, + device = from + ), + ) { s.cleanup(ctx)?; crate::commands::say!(ctx, "{}", tr!("Sync item held; run `kc sync review`.")); return Err(error); diff --git a/crates/kc-cli/src/sync/transaction.rs b/crates/kc-cli/src/sync/transaction.rs index cc9e7cf..72dce7f 100644 --- a/crates/kc-cli/src/sync/transaction.rs +++ b/crates/kc-cli/src/sync/transaction.rs @@ -323,7 +323,10 @@ fn scan_one(ctx: &mut Ctx<'_, H>, s: &mut State, name: &str) -> Result< Ok(value) => value, Err(error) if error.code == 8 && s.capacity_blocked => { s.items.get_mut(name).unwrap().conflict = true; - log(ctx, tr!("Sync storage is full; review pending items before retrying."))?; + log( + ctx, + tr!("Sync storage is full; review pending items before retrying."), + )?; return s.save(&ctx.state); } Err(error) => return Err(error), @@ -381,7 +384,10 @@ pub(super) fn resolve_value( let (r, v) = match prepare_local(ctx, s, name, fp, kind, value, parents, Vid::random(), true) { Ok(prepared) => prepared, Err(error) if error.code == 8 && s.capacity_blocked => { - log(ctx, tr!("Sync storage is full; review pending items before retrying."))?; + log( + ctx, + tr!("Sync storage is full; review pending items before retrying."), + )?; return s.save(&ctx.state); } Err(error) => return Err(error), @@ -636,14 +642,26 @@ pub(crate) fn recover(ctx: &mut Ctx<'_, H>, s: &mut State) -> Result<() fn collect_orphan_snapshots(ctx: &Ctx<'_, H>, s: &mut State) -> Result<()> { // Called after journal recovery: its in-flight snapshot must survive until then. - let orphaned = s.slots.keys().filter(|slot| { - slot.starts_with("sync/snapshot/") - && !s.versions.values().any(|v| &v.slot == *slot) - && !s.offers.iter().any(|o| snapshot_slot(o.vid) == **slot) - && !s.peers.keys().any(|peer| s.outbox.pending(&PeerId(peer.clone())) - .any(|id| snapshot_slot(map::wire_vid(id.new_vid)) == **slot)) - }).cloned().collect::>(); - for slot in orphaned { release(s, &slot); } - if !s.gc.is_empty() { s.cleanup(ctx)?; } + let orphaned = s + .slots + .keys() + .filter(|slot| { + slot.starts_with("sync/snapshot/") + && !s.versions.values().any(|v| &v.slot == *slot) + && !s.offers.iter().any(|o| snapshot_slot(o.vid) == **slot) + && !s.peers.keys().any(|peer| { + s.outbox + .pending(&PeerId(peer.clone())) + .any(|id| snapshot_slot(map::wire_vid(id.new_vid)) == **slot) + }) + }) + .cloned() + .collect::>(); + for slot in orphaned { + release(s, &slot); + } + if !s.gc.is_empty() { + s.cleanup(ctx)?; + } Ok(()) } diff --git a/crates/kc-cli/src/sync/transport.rs b/crates/kc-cli/src/sync/transport.rs index 42bae4a..d685bcd 100644 --- a/crates/kc-cli/src/sync/transport.rs +++ b/crates/kc-cli/src/sync/transport.rs @@ -96,7 +96,8 @@ pub(crate) async fn flush(ctx: &mut Ctx<'_, H>, digest: bool) -> Result is_reply: false, }, ) - .await { + .await + { s.peers.get_mut(&id).unwrap().hello_sent = false; s.save(&ctx.state)?; return Err(error); diff --git a/crates/kc-cli/tests/common/fault_relay.rs b/crates/kc-cli/tests/common/fault_relay.rs index c0621c5..fc7932e 100644 --- a/crates/kc-cli/tests/common/fault_relay.rs +++ b/crates/kc-cli/tests/common/fault_relay.rs @@ -1,24 +1,38 @@ //! Relay delivery failure injection; all other calls use the authenticated memory relay. use super::*; -use kc_wire::{ChannelAllocated, ChannelJoined, DeleteReason, InboxCreated, InboxMessages, - MessageAccepted, Phase, WriterRegister, WriterRegistered}; +use kc_wire::{ + ChannelAllocated, ChannelJoined, DeleteReason, InboxCreated, InboxMessages, MessageAccepted, + Phase, WriterRegister, WriterRegistered, +}; pub struct FaultRelay { pub inner: MemoryRelay, pub fail_post: std::sync::Arc, } impl Clone for FaultRelay { - fn clone(&self) -> Self { Self { inner: self.inner.clone(), fail_post: self.fail_post.clone() } } + fn clone(&self) -> Self { + Self { + inner: self.inner.clone(), + fail_post: self.fail_post.clone(), + } + } } impl FaultRelay { pub fn new(inner: MemoryRelay) -> Self { - Self { inner, fail_post: Default::default() } + Self { + inner, + fail_post: Default::default(), + } } } impl Net for FaultRelay { type Relay = Self; - fn connect(&self, _url: &RelayUrl) -> Result { Ok(self.clone()) } - async fn limits(&self, _url: &RelayUrl) -> Result { Ok(Limits::current()) } + fn connect(&self, _url: &RelayUrl) -> Result { + Ok(self.clone()) + } + async fn limits(&self, _url: &RelayUrl) -> Result { + Ok(Limits::current()) + } } impl RelayApi for FaultRelay { async fn allocate(&self) -> Result { @@ -62,7 +76,9 @@ impl RelayApi for FaultRelay { owner_token: &str, request: &WriterRegister, ) -> Result { - self.inner.register_writer(inbox_id, owner_token, request).await + self.inner + .register_writer(inbox_id, owner_token, request) + .await } async fn delete_writer( &self, @@ -70,7 +86,9 @@ impl RelayApi for FaultRelay { owner_token: &str, writer_id: &str, ) -> Result<(), RelayError> { - self.inner.delete_writer(inbox_id, owner_token, writer_id).await + self.inner + .delete_writer(inbox_id, owner_token, writer_id) + .await } async fn post_message( &self, @@ -78,8 +96,13 @@ impl RelayApi for FaultRelay { writer_token: &str, body: &[u8], ) -> Result { - if self.fail_post.swap(false, std::sync::atomic::Ordering::SeqCst) { - return Err(kc_proto::relay::RelayError::Transport("injected post failure".into())); + if self + .fail_post + .swap(false, std::sync::atomic::Ordering::SeqCst) + { + return Err(kc_proto::relay::RelayError::Transport( + "injected post failure".into(), + )); } self.inner.post_message(inbox_id, writer_token, body).await } @@ -97,13 +120,11 @@ impl RelayApi for FaultRelay { owner_token: &str, msg_id: &str, ) -> Result<(), RelayError> { - self.inner.delete_message(inbox_id, owner_token, msg_id).await + self.inner + .delete_message(inbox_id, owner_token, msg_id) + .await } - async fn delete_inbox( - &self, - inbox_id: &str, - owner_token: &str, - ) -> Result<(), RelayError> { + async fn delete_inbox(&self, inbox_id: &str, owner_token: &str) -> Result<(), RelayError> { self.inner.delete_inbox(inbox_id, owner_token).await } } diff --git a/crates/kc-cli/tests/sync.rs b/crates/kc-cli/tests/sync.rs index a2f11d4..d52c317 100644 --- a/crates/kc-cli/tests/sync.rs +++ b/crates/kc-cli/tests/sync.rs @@ -599,12 +599,26 @@ async fn legacy_overwrite_flag_and_code_receive_cannot_bypass_local_confirmation .await .expect(0); let before = std::fs::read(b.dir.path().join("sync.json")).unwrap(); - b.run(&["inbox", "--on-conflict", "overwrite"], Run::agent()).await.expect(5); - assert_eq!(std::fs::read(b.dir.path().join("sync.json")).unwrap(), before); - b.run(&["receive", "--on-conflict", "overwrite"], Run::agent()).await.expect(5); - assert_eq!(std::fs::read(b.dir.path().join("sync.json")).unwrap(), before); - b.run(&["inbox", "--on-conflict", "overwrite"], Run::human(vec![Answer::Yes])) - .await.expect(5); + b.run(&["inbox", "--on-conflict", "overwrite"], Run::agent()) + .await + .expect(5); + assert_eq!( + std::fs::read(b.dir.path().join("sync.json")).unwrap(), + before + ); + b.run(&["receive", "--on-conflict", "overwrite"], Run::agent()) + .await + .expect(5); + assert_eq!( + std::fs::read(b.dir.path().join("sync.json")).unwrap(), + before + ); + b.run( + &["inbox", "--on-conflict", "overwrite"], + Run::human(vec![Answer::Yes]), + ) + .await + .expect(5); assert_eq!(state(&b)["candidates"].as_object().unwrap().len(), 1); assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); b.run(&["sync", "review"], human(vec![Answer::Select(0)])) @@ -735,50 +749,97 @@ async fn rejecting_a_proposal_blocks_retries_but_an_explicit_reoffer_is_fresh() } fn save_state(d: &Device, s: &Value) { - std::fs::write(d.dir.path().join("sync.json"), serde_json::to_vec_pretty(s).unwrap()).unwrap(); + std::fs::write( + d.dir.path().join("sync.json"), + serde_json::to_vec_pretty(s).unwrap(), + ) + .unwrap(); } fn hex(bytes: &[u8]) -> String { bytes.iter().map(|b| format!("{b:02x}")).collect() } fn fp_slot(name: &str, vid: Vid) -> String { use sha2::{Digest, Sha256}; - format!("sync/fp/{}/{}", hex(&Sha256::digest(name.as_bytes())), hex(&vid.0)) + format!( + "sync/fp/{}/{}", + hex(&Sha256::digest(name.as_bytes())), + hex(&vid.0) + ) } fn offer_message(name: &str, vid: Vid, value: &[u8], generation: u64) -> SyncMsg { SyncMsg::Offer { - name: ItemName::new(name).unwrap(), vid, lineage: vec![], + name: ItemName::new(name).unwrap(), + vid, + lineage: vec![], kind: kc_proto::sync::ItemKind::Text, - value: SecretBytes::from_slice(value), known_generation: generation, + value: SecretBytes::from_slice(value), + known_generation: generation, } } fn change_message(name: &str, vid: Vid, parent: Vid, value: &[u8]) -> SyncMsg { - SyncMsg::Changes { changes: vec![Change { - name: ItemName::new(name).unwrap(), generation: 1, new_vid: vid, - parents: vec![parent], lineage: vec![parent], - op: Op::Put { kind: kc_proto::sync::ItemKind::Text, value: SecretBytes::from_slice(value) }, - approval_ref: None, - }] } + SyncMsg::Changes { + changes: vec![Change { + name: ItemName::new(name).unwrap(), + generation: 1, + new_vid: vid, + parents: vec![parent], + lineage: vec![parent], + op: Op::Put { + kind: kc_proto::sync::ItemKind::Text, + value: SecretBytes::from_slice(value), + }, + approval_ref: None, + }], + } } fn confirmations(out: &common::Output) -> Vec<&str> { - out.prompts.iter().filter_map(|p| p.strip_prefix("local confirmation: ")).collect() + out.prompts + .iter() + .filter_map(|p| p.strip_prefix("local confirmation: ")) + .collect() } #[tokio::test] async fn failed_hello_delivery_is_retried_on_next_sync() { let (a, b, relay) = devices().await; let fault = common::fault_relay::FaultRelay::new(relay.clone()); - let a = Device { name: a.name, dir: a.dir, keychain: a.keychain, net: fault.clone(), env: a.env }; + let a = Device { + name: a.name, + dir: a.dir, + keychain: a.keychain, + net: fault.clone(), + env: a.env, + }; a.set("KEY", b"fake-hello").await; - fault.fail_post.store(true, std::sync::atomic::Ordering::SeqCst); - a.run(&["sync", "add", "KEY", "--peers", "bravo"], human(vec![])).await.expect(6); + fault + .fail_post + .store(true, std::sync::atomic::Ordering::SeqCst); + a.run(&["sync", "add", "KEY", "--peers", "bravo"], human(vec![])) + .await + .expect(6); let peer = b.peers().find("alpha").unwrap().fingerprint.to_hex(); let remote = a.peers().find("bravo").unwrap().fingerprint.to_hex(); assert_eq!(state(&a)["peers"][&remote]["hello_sent"], false); let (id, owner) = b.inbox_credentials(); - assert!(relay.list_messages(&id, &owner, std::time::Duration::ZERO).await.unwrap().messages.is_empty()); + assert!( + relay + .list_messages(&id, &owner, std::time::Duration::ZERO) + .await + .unwrap() + .messages + .is_empty() + ); a.run(&["sync"], Run::agent()).await.expect(8); assert_eq!(state(&a)["peers"][&remote]["hello_sent"], true); - assert_eq!(relay.list_messages(&id, &owner, std::time::Duration::ZERO).await.unwrap().messages.len(), 1); + assert_eq!( + relay + .list_messages(&id, &owner, std::time::Duration::ZERO) + .await + .unwrap() + .messages + .len(), + 1 + ); b.run(&["inbox"], Run::agent()).await.expect(0); assert_eq!(state(&b)["peers"][peer]["capable"], true); } @@ -788,15 +849,24 @@ async fn corrupt_sync_state_does_not_break_get_or_exec() { let a = Device::new("alpha", MemoryRelay::new()); a.set("KEY", b"fake-independent").await; std::fs::write(a.dir.path().join("sync.json"), b"broken json").unwrap(); - a.run(&["get", "KEY", "--fingerprint"], Run::agent()).await.expect(0); - a.run(&["exec", "--env", "KEY=KEY", "--", "true"], Run::agent()).await.expect(0); - assert_eq!(std::fs::read(a.dir.path().join("sync.json")).unwrap(), b"broken json"); + a.run(&["get", "KEY", "--fingerprint"], Run::agent()) + .await + .expect(0); + a.run(&["exec", "--env", "KEY=KEY", "--", "true"], Run::agent()) + .await + .expect(0); + assert_eq!( + std::fs::read(a.dir.path().join("sync.json")).unwrap(), + b"broken json" + ); } #[tokio::test] async fn confirmation_reasons_name_actions_and_follow_selection() { let a = Device::new("alpha", MemoryRelay::new()); - for name in ["a", "b", "c", "d", "e", "f", "g"] { a.set(name, b"fake").await; } + for name in ["a", "b", "c", "d", "e", "f", "g"] { + a.set(name, b"fake").await; + } let mut denied = Run::human(vec![Answer::Multi(vec![0, 1, 2, 3, 4, 5, 6])]); denied.local_auth.push_back(LocalAuthOutcome::Denied); let out = a.run(&["sync", "add"], denied).await; @@ -806,12 +876,24 @@ async fn confirmation_reasons_name_actions_and_follow_selection() { assert!(!a.dir.path().join("sync.json").exists()); let cases = [ (vec!["sync", "rm", "a", "b"], "kc sync rm a, b"), - (vec!["sync", "peer", "add", "bravo"], "kc sync peer add bravo"), + ( + vec!["sync", "peer", "add", "bravo"], + "kc sync peer add bravo", + ), (vec!["sync", "peer", "rm", "bravo"], "kc sync peer rm bravo"), - (vec!["sync", "resolve", "a", "--keep", "mine"], "Resolve a: keep mine"), - (vec!["sync", "restore-checkpoint", "a"], "Restore a to its checkpoint"), + ( + vec!["sync", "resolve", "a", "--keep", "mine"], + "Resolve a: keep mine", + ), + ( + vec!["sync", "restore-checkpoint", "a"], + "Restore a to its checkpoint", + ), (vec!["sync", "unfreeze"], "Unfreeze sync"), - (vec!["sync", "status", "--confirm-checkpoint", "a"], "Confirm the current value of a as its checkpoint"), + ( + vec!["sync", "status", "--confirm-checkpoint", "a"], + "Confirm the current value of a as its checkpoint", + ), ]; for (args, expected) in cases { let out = a.run(&args, Run::human(vec![])).await; @@ -825,7 +907,13 @@ async fn confirmation_reasons_name_actions_and_follow_selection() { async fn review_accept_and_reject_share_one_confirmation_and_denial_changes_nothing() { let (a, b, relay) = devices().await; for name in ["A", "B"] { - post(&a, &b, &relay, offer_message(name, Vid::random(), b"fake-review", 0)).await; + post( + &a, + &b, + &relay, + offer_message(name, Vid::random(), b"fake-review", 0), + ) + .await; } b.run(&["inbox"], Run::agent()).await.expect(8); let before = std::fs::read(b.dir.path().join("sync.json")).unwrap(); @@ -835,10 +923,18 @@ async fn review_accept_and_reject_share_one_confirmation_and_denial_changes_noth out.expect(5); assert_eq!(confirmations(&out).len(), 1); assert!(confirmations(&out)[0].contains("from alpha; reject")); - assert_eq!(std::fs::read(b.dir.path().join("sync.json")).unwrap(), before); + assert_eq!( + std::fs::read(b.dir.path().join("sync.json")).unwrap(), + before + ); assert!(b.value("A").is_none() && b.value("B").is_none()); assert!(state(&b)["items"].as_object().unwrap().is_empty()); - let out = b.run(&["sync", "review"], human(vec![Answer::Select(0), Answer::Select(1)])).await; + let out = b + .run( + &["sync", "review"], + human(vec![Answer::Select(0), Answer::Select(1)]), + ) + .await; out.expect(0); assert_eq!(confirmations(&out).len(), 1); assert!(state(&b)["candidates"].as_object().unwrap().is_empty()); @@ -855,10 +951,20 @@ async fn held_review_denied_and_agent_mutations_preserve_existing_state() { let mut denied = Run::human(vec![Answer::Select(0)]); denied.local_auth.push_back(LocalAuthOutcome::Denied); b.run(&["sync", "review"], denied).await.expect(5); - assert_eq!(std::fs::read(b.dir.path().join("sync.json")).unwrap(), before); - for args in [vec!["sync", "resolve", "KEY", "--keep", "mine"], vec!["sync", "restore-checkpoint", "KEY"], vec!["sync", "rm", "KEY"]] { + assert_eq!( + std::fs::read(b.dir.path().join("sync.json")).unwrap(), + before + ); + for args in [ + vec!["sync", "resolve", "KEY", "--keep", "mine"], + vec!["sync", "restore-checkpoint", "KEY"], + vec!["sync", "rm", "KEY"], + ] { b.run(&args, Run::agent()).await.expect(5); - assert_eq!(std::fs::read(b.dir.path().join("sync.json")).unwrap(), before); + assert_eq!( + std::fs::read(b.dir.path().join("sync.json")).unwrap(), + before + ); } assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); assert_eq!(state(&b)["candidates"].as_object().unwrap().len(), 1); @@ -869,29 +975,62 @@ async fn legacy_policies_hold_and_denial_continues_batch_then_one_l_replaces() { for policy in [None, Some("skip"), Some("rename"), Some("overwrite")] { let (a, b, _) = devices().await; enroll(&a, &b).await; - a.store().set("KEY", b"fake-legacy-batch", kc_store::ItemKind::Text, kc_store::Origin::Local).unwrap(); + a.store() + .set( + "KEY", + b"fake-legacy-batch", + kc_store::ItemKind::Text, + kc_store::Origin::Local, + ) + .unwrap(); a.set("OTHER", b"fake-other").await; - a.run(&["send", "KEY", "OTHER", "--to", "bravo"], Run::agent()).await.expect(0); + a.run(&["send", "KEY", "OTHER", "--to", "bravo"], Run::agent()) + .await + .expect(0); let mut args = vec!["inbox"]; - if let Some(p) = policy { args.extend(["--on-conflict", p]); } + if let Some(p) = policy { + args.extend(["--on-conflict", p]); + } let mut run = Run::human(vec![Answer::Yes]); - if policy == Some("overwrite") { run.local_auth.push_back(LocalAuthOutcome::Denied); } + if policy == Some("overwrite") { + run.local_auth.push_back(LocalAuthOutcome::Denied); + } let out = b.run(&args, run).await; out.expect(if policy == Some("overwrite") { 5 } else { 8 }); assert_eq!(b.value("OTHER").unwrap(), b"fake-other"); assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); - assert_eq!(confirmations(&out).len(), usize::from(policy == Some("overwrite"))); + assert_eq!( + confirmations(&out).len(), + usize::from(policy == Some("overwrite")) + ); assert!(b.value("KEY-2").is_none()); assert_eq!(state(&b)["candidates"].as_object().unwrap().len(), 1); assert!(out.stderr.contains("run `kc sync review`")); } let (a, b, _) = devices().await; enroll(&a, &b).await; - a.store().set("KEY", b"fake-inline", kc_store::ItemKind::Text, kc_store::Origin::Local).unwrap(); - a.run(&["send", "KEY", "--to", "bravo"], Run::agent()).await.expect(0); - let out = b.run(&["inbox", "--on-conflict", "overwrite"], human(vec![Answer::Yes])).await; + a.store() + .set( + "KEY", + b"fake-inline", + kc_store::ItemKind::Text, + kc_store::Origin::Local, + ) + .unwrap(); + a.run(&["send", "KEY", "--to", "bravo"], Run::agent()) + .await + .expect(0); + let out = b + .run( + &["inbox", "--on-conflict", "overwrite"], + human(vec![Answer::Yes]), + ) + .await; out.expect(0); - assert_eq!(confirmations(&out), vec!["Replace KEY with the value from alpha"]); + assert_eq!( + confirmations(&out), + vec!["Replace KEY with the value from alpha"] + ); assert_eq!(b.value("KEY").unwrap(), b"fake-inline"); assert!(state(&b)["candidates"].as_object().unwrap().is_empty()); } @@ -900,7 +1039,10 @@ async fn legacy_policies_hold_and_denial_continues_batch_then_one_l_replaces() { async fn status_and_review_fingerprints_match_get_across_devices() { let (a, b, _) = devices().await; enroll(&a, &b).await; - let fp = a.run(&["get", "KEY", "--fingerprint"], Run::agent()).await.stdout_text(); + let fp = a + .run(&["get", "KEY", "--fingerprint"], Run::agent()) + .await + .stdout_text(); for d in [&a, &b] { let out = d.run(&["sync", "status", "--json"], Run::agent()).await; let json: Value = serde_json::from_slice(&out.stdout).unwrap(); @@ -908,11 +1050,16 @@ async fn status_and_review_fingerprints_match_get_across_devices() { } a.set("KEY", b"fake-fingerprint-new").await; pump(&a, &b).await; - let proposed = a.run(&["get", "KEY", "--fingerprint"], Run::agent()).await.stdout_text(); + let proposed = a + .run(&["get", "KEY", "--fingerprint"], Run::agent()) + .await + .stdout_text(); let out = b.run(&["sync", "status", "--json"], Run::agent()).await; let json: Value = serde_json::from_slice(&out.stdout).unwrap(); assert_eq!(json["candidates"][0]["fingerprint"], proposed.trim()); - let out = b.run(&["sync", "review"], Run::human(vec![Answer::Select(2)])).await; + let out = b + .run(&["sync", "review"], Run::human(vec![Answer::Select(2)])) + .await; assert!(out.prompts[0].contains(fp.trim())); assert!(out.prompts[0].contains(proposed.trim())); } @@ -921,17 +1068,31 @@ async fn status_and_review_fingerprints_match_get_across_devices() { async fn offers_from_disabled_or_tripped_peers_are_logged_only() { let (a, b, relay) = devices().await; enroll(&a, &b).await; - b.run(&["sync", "peer", "rm", "alpha"], human(vec![])).await.expect(0); - post(&a, &b, &relay, offer_message("DISABLED", Vid::random(), b"fake-disabled", 0)).await; + b.run(&["sync", "peer", "rm", "alpha"], human(vec![])) + .await + .expect(0); + post( + &a, + &b, + &relay, + offer_message("DISABLED", Vid::random(), b"fake-disabled", 0), + ) + .await; b.run(&["inbox"], Run::agent()).await.expect(0); assert!(state(&b)["candidates"].as_object().unwrap().is_empty()); - b.run(&["sync", "peer", "add", "alpha"], human(vec![])).await.expect(8); + b.run(&["sync", "peer", "add", "alpha"], human(vec![])) + .await + .expect(8); // Peer rm removed KEY's scope. Restore it through the explicit add operation. - b.run(&["sync", "add", "KEY", "--peers", "alpha"], human(vec![])).await.expect(8); + b.run(&["sync", "add", "KEY", "--peers", "alpha"], human(vec![])) + .await + .expect(8); let parent = head(&b); for _ in 0..6 { let mut message = change_message("KEY", Vid::random(), parent, b"fake-trip"); - if let SyncMsg::Changes { changes } = &mut message { changes[0].generation = 2; } + if let SyncMsg::Changes { changes } = &mut message { + changes[0].generation = 2; + } post(&a, &b, &relay, message).await; } b.run(&["inbox"], Run::agent()).await.expect(8); @@ -939,10 +1100,20 @@ async fn offers_from_disabled_or_tripped_peers_are_logged_only() { let status: Value = serde_json::from_slice(&out.stdout).unwrap(); assert_eq!(status["peers"][0]["breaker"], true); let before = state(&b)["candidates"].clone(); - post(&a, &b, &relay, offer_message("BLOCKED", Vid::random(), b"fake-blocked", 0)).await; + post( + &a, + &b, + &relay, + offer_message("BLOCKED", Vid::random(), b"fake-blocked", 0), + ) + .await; b.run(&["inbox"], Run::agent()).await.expect(8); assert_eq!(state(&b)["candidates"], before); - assert!(std::fs::read_to_string(b.dir.path().join("sync.log")).unwrap().contains("Ignored a sync offer")); + assert!( + std::fs::read_to_string(b.dir.path().join("sync.log")) + .unwrap() + .contains("Ignored a sync offer") + ); } #[tokio::test] @@ -954,12 +1125,29 @@ async fn offer_during_conflict_is_a_candidate_and_review_cannot_discard_it() { pump(&a, &b).await; let before = state(&b)["candidates"].as_object().unwrap().len(); let offered = Vid::random(); - post(&a, &b, &relay, offer_message("KEY", offered, b"fake-conflict-offer", 1)).await; + post( + &a, + &b, + &relay, + offer_message("KEY", offered, b"fake-conflict-offer", 1), + ) + .await; b.run(&["inbox"], Run::agent()).await.expect(8); let s = state(&b); assert_eq!(s["candidates"].as_object().unwrap().len(), before + 1); - assert!(s["candidates"].as_object().unwrap().values().any(|c| c["version"]["vid"] == serde_json::to_value(offered).unwrap() && c["category"] == "conflict")); - b.run(&["sync", "review"], Run::human(vec![])).await.expect(8); + assert!( + s["candidates"] + .as_object() + .unwrap() + .values() + .any( + |c| c["version"]["vid"] == serde_json::to_value(offered).unwrap() + && c["category"] == "conflict" + ) + ); + b.run(&["sync", "review"], Run::human(vec![])) + .await + .expect(8); assert_eq!(state(&b)["candidates"], s["candidates"]); assert_eq!(b.value("KEY").unwrap(), b"fake-conflict-b"); } @@ -967,16 +1155,44 @@ async fn offer_during_conflict_is_a_candidate_and_review_cannot_discard_it() { #[tokio::test] async fn sync_envelope_replay_is_skipped_by_seen_set() { let (a, b, relay) = devices().await; - post(&a, &b, &relay, SyncMsg::Hello { features: vec!["sync-phase1".into()], is_reply: false }).await; + post( + &a, + &b, + &relay, + SyncMsg::Hello { + features: vec!["sync-phase1".into()], + is_reply: false, + }, + ) + .await; let (id, owner) = b.inbox_credentials(); - let listed = relay.list_messages(&id, &owner, std::time::Duration::ZERO).await.unwrap(); + let listed = relay + .list_messages(&id, &owner, std::time::Duration::ZERO) + .await + .unwrap(); let body = kc_proto::relay::message_body(&listed.messages[0]).unwrap(); b.run(&["inbox"], Run::agent()).await.expect(0); let (aid, aowner) = a.inbox_credentials(); - let replies = relay.list_messages(&aid, &aowner, std::time::Duration::ZERO).await.unwrap().messages.len(); - relay.post_message(&id, &a.writer_bearer("bravo"), &body).await.unwrap(); + let replies = relay + .list_messages(&aid, &aowner, std::time::Duration::ZERO) + .await + .unwrap() + .messages + .len(); + relay + .post_message(&id, &a.writer_bearer("bravo"), &body) + .await + .unwrap(); b.run(&["inbox"], Run::agent()).await.expect(7); - assert_eq!(relay.list_messages(&aid, &aowner, std::time::Duration::ZERO).await.unwrap().messages.len(), replies); + assert_eq!( + relay + .list_messages(&aid, &aowner, std::time::Duration::ZERO) + .await + .unwrap() + .messages + .len(), + replies + ); } #[tokio::test] @@ -985,27 +1201,77 @@ async fn convergence_binding_failure_quarantines_only_that_flow_and_rejects_ack( enroll(&a, &b).await; let vid = Vid::random(); // A valid stored record outside the bounded known list, with an incompatible fp. - b.store().set_internal(&fp_slot("KEY", vid), &serde_json::to_vec(&kc_sync::VidRecord { - fp: kc_sync::Fp([7; 32]), parents: vec![], - }).unwrap()).unwrap(); + b.store() + .set_internal( + &fp_slot("KEY", vid), + &serde_json::to_vec(&kc_sync::VidRecord { + fp: kc_sync::Fp([7; 32]), + parents: vec![], + }) + .unwrap(), + ) + .unwrap(); let old_head = head(&b); - post(&a, &b, &relay, change_message("KEY", vid, old_head, b"fake-initial-secret")).await; - post(&a, &b, &relay, offer_message("OTHER", Vid::random(), b"fake-next-message", 0)).await; + post( + &a, + &b, + &relay, + change_message("KEY", vid, old_head, b"fake-initial-secret"), + ) + .await; + post( + &a, + &b, + &relay, + offer_message("OTHER", Vid::random(), b"fake-next-message", 0), + ) + .await; b.run(&["inbox"], Run::agent()).await.expect(8); assert_eq!(head(&b), old_head); - assert!(state(&b)["peers"].as_object().unwrap().values().any(|p| p["quarantine"].as_array().unwrap().contains(&Value::String("KEY".into())))); - assert!(state(&b)["candidates"].as_object().unwrap().values().any(|c| c["version"]["name"] == "OTHER")); - assert!(state(&b)["receipts"].as_object().unwrap().values().any(|r| r[0] == "Rejected")); + assert!(state(&b)["peers"].as_object().unwrap().values().any(|p| { + p["quarantine"] + .as_array() + .unwrap() + .contains(&Value::String("KEY".into())) + })); + assert!( + state(&b)["candidates"] + .as_object() + .unwrap() + .values() + .any(|c| c["version"]["name"] == "OTHER") + ); + assert!( + state(&b)["receipts"] + .as_object() + .unwrap() + .values() + .any(|r| r[0] == "Rejected") + ); let (id, owner) = a.inbox_credentials(); let key = a.store().get_internal("device-key").unwrap().unwrap(); let key = kc_proto::DeviceKeyPair::from_secret_bytes(key.as_bytes()).unwrap(); let sender = a.peers().find("bravo").unwrap().device_pk; let mut rejected = false; - for envelope in relay.list_messages(&id, &owner, std::time::Duration::ZERO).await.unwrap().messages { + for envelope in relay + .list_messages(&id, &owner, std::time::Duration::ZERO) + .await + .unwrap() + .messages + { let bytes = kc_proto::relay::message_body(&envelope).unwrap(); - let opened = kc_proto::inbox::open_any(&bytes, &[&key], |_| Some(sender), |_| false, kc_proto::inbox::unix_now()).unwrap(); + let opened = kc_proto::inbox::open_any( + &bytes, + &[&key], + |_| Some(sender), + |_| false, + kc_proto::inbox::unix_now(), + ) + .unwrap(); if let kc_proto::inbox::Body::Sync(SyncMsg::Ack { results }) = opened.body { - rejected |= results.iter().any(|(id, result)| id.new_vid == vid && *result == kc_proto::sync::AckResult::Rejected); + rejected |= results.iter().any(|(id, result)| { + id.new_vid == vid && *result == kc_proto::sync::AckResult::Rejected + }); } } assert!(rejected); @@ -1016,19 +1282,41 @@ async fn offer_then_change_binds_parents_and_promotes_proposal_to_held() { let (a, b, relay) = devices().await; enroll(&a, &b).await; let vid = Vid::random(); - post(&a, &b, &relay, offer_message("KEY", vid, b"fake-promoted", 1)).await; + post( + &a, + &b, + &relay, + offer_message("KEY", vid, b"fake-promoted", 1), + ) + .await; b.run(&["inbox"], Run::agent()).await.expect(8); let parent = head(&b); - post(&a, &b, &relay, change_message("KEY", vid, parent, b"fake-promoted")).await; + post( + &a, + &b, + &relay, + change_message("KEY", vid, parent, b"fake-promoted"), + ) + .await; b.run(&["inbox"], Run::agent()).await.expect(8); let s = state(&b); assert_eq!(s["candidates"].as_object().unwrap().len(), 1); - let c = s["candidates"].as_object().unwrap().values().next().unwrap(); + let c = s["candidates"] + .as_object() + .unwrap() + .values() + .next() + .unwrap(); assert_eq!(c["category"], "held"); - assert_eq!(c["version"]["parents"], serde_json::to_value(vec![parent]).unwrap()); + assert_eq!( + c["version"]["parents"], + serde_json::to_value(vec![parent]).unwrap() + ); assert_eq!(c["invalid_binding"], false); assert!(s["unbound"].as_array().unwrap().is_empty()); - b.run(&["sync", "review"], human(vec![Answer::Select(0)])).await.expect(0); + b.run(&["sync", "review"], human(vec![Answer::Select(0)])) + .await + .expect(0); assert_eq!(b.value("KEY").unwrap(), b"fake-promoted"); } @@ -1038,71 +1326,159 @@ async fn stale_ack_revokes_grant_without_inventing_generation_or_revoking_newer_ enroll(&a, &b).await; a.set("KEY", b"fake-stale-ack").await; let vid = head(&a); - let stale = SyncMsg::Ack { results: vec![(kc_proto::sync::ChangeId { - name: ItemName::new("KEY").unwrap(), generation: 1, new_vid: vid, - }, kc_proto::sync::AckResult::StaleGeneration)] }; + let stale = SyncMsg::Ack { + results: vec![( + kc_proto::sync::ChangeId { + name: ItemName::new("KEY").unwrap(), + generation: 1, + new_vid: vid, + }, + kc_proto::sync::AckResult::StaleGeneration, + )], + }; // post helper sends A -> B, so construct the reverse envelope here. let key = b.store().get_internal("device-key").unwrap().unwrap(); let key = kc_proto::DeviceKeyPair::from_secret_bytes(key.as_bytes()).unwrap(); let peer = b.peers().find("alpha").unwrap().clone(); - let sealed = kc_proto::inbox::seal_v2(&key, &peer.device_pk, &kc_proto::inbox::Body::Sync(stale.clone()), std::time::Duration::from_secs(86400), kc_proto::inbox::unix_now()).unwrap(); - relay.post_message(&a.inbox_credentials().0, &b.writer_bearer("alpha"), &sealed.body).await.unwrap(); + let sealed = kc_proto::inbox::seal_v2( + &key, + &peer.device_pk, + &kc_proto::inbox::Body::Sync(stale.clone()), + std::time::Duration::from_secs(86400), + kc_proto::inbox::unix_now(), + ) + .unwrap(); + relay + .post_message( + &a.inbox_credentials().0, + &b.writer_bearer("alpha"), + &sealed.body, + ) + .await + .unwrap(); a.run(&["inbox"], Run::agent()).await.expect(8); let peer_id = a.peers().find("bravo").unwrap().fingerprint.to_hex(); - assert_eq!(state(&a)["generations"]["remote"][&peer_id]["KEY"]["accepted"], false); - assert_eq!(state(&a)["generations"]["remote"][&peer_id]["KEY"]["generation"], 1); + assert_eq!( + state(&a)["generations"]["remote"][&peer_id]["KEY"]["accepted"], + false + ); + assert_eq!( + state(&a)["generations"]["remote"][&peer_id]["KEY"]["generation"], + 1 + ); a.set("KEY", b"fake-no-stale-send").await; let s = state(&a); let outbox: kc_sync::Outbox = serde_json::from_value(s["outbox"].clone()).unwrap(); - assert!(outbox.pending(&kc_sync::PeerId(peer_id.clone())).next().is_none()); + assert!( + outbox + .pending(&kc_sync::PeerId(peer_id.clone())) + .next() + .is_none() + ); // Recreate a pending old delivery with a newer accepted epoch to prove reordering safety. let mut s = state(&a); let mut outbox: kc_sync::Outbox = serde_json::from_value(s["outbox"].clone()).unwrap(); - outbox.enqueue(kc_sync::PeerId(peer_id.clone()), kc_sync::ChangeId { name: "KEY".into(), generation: 1, new_vid: kc_sync::Vid(vid.0) }); + outbox.enqueue( + kc_sync::PeerId(peer_id.clone()), + kc_sync::ChangeId { + name: "KEY".into(), + generation: 1, + new_vid: kc_sync::Vid(vid.0), + }, + ); s["outbox"] = serde_json::to_value(outbox).unwrap(); s["generations"]["remote"][&peer_id]["KEY"]["accepted"] = true.into(); s["generations"]["remote"][&peer_id]["KEY"]["generation"] = 2.into(); save_state(&a, &s); - let sealed = kc_proto::inbox::seal_v2(&key, &peer.device_pk, &kc_proto::inbox::Body::Sync(stale), std::time::Duration::from_secs(86400), kc_proto::inbox::unix_now()).unwrap(); - relay.post_message(&a.inbox_credentials().0, &b.writer_bearer("alpha"), &sealed.body).await.unwrap(); + let sealed = kc_proto::inbox::seal_v2( + &key, + &peer.device_pk, + &kc_proto::inbox::Body::Sync(stale), + std::time::Duration::from_secs(86400), + kc_proto::inbox::unix_now(), + ) + .unwrap(); + relay + .post_message( + &a.inbox_credentials().0, + &b.writer_bearer("alpha"), + &sealed.body, + ) + .await + .unwrap(); a.run(&["inbox"], Run::agent()).await.expect(8); - assert_eq!(state(&a)["generations"]["remote"][&peer_id]["KEY"]["accepted"], true); + assert_eq!( + state(&a)["generations"]["remote"][&peer_id]["KEY"]["accepted"], + true + ); } #[tokio::test] async fn candidate_eviction_collects_base_and_startup_collects_only_orphan_snapshots() { let (a, b, relay) = devices().await; for n in 0..16 { - post(&a, &b, &relay, offer_message(&format!("P{n}"), Vid::random(), b"fake-eviction", 0)).await; + post( + &a, + &b, + &relay, + offer_message(&format!("P{n}"), Vid::random(), b"fake-eviction", 0), + ) + .await; } b.run(&["inbox"], Run::agent()).await.expect(8); let before = state(&b); - let base_slots = before["candidates"].as_object().unwrap().iter().map(|(slot, c)| (slot.clone(), c["base_record"].as_str().unwrap().to_owned())).collect::>(); + let base_slots = before["candidates"] + .as_object() + .unwrap() + .iter() + .map(|(slot, c)| (slot.clone(), c["base_record"].as_str().unwrap().to_owned())) + .collect::>(); b.set("LOCAL", b"fake-local").await; - b.run(&["sync", "add", "LOCAL", "--peers", "alpha"], human(vec![])).await.expect(8); + b.run(&["sync", "add", "LOCAL", "--peers", "alpha"], human(vec![])) + .await + .expect(8); let after = state(&b); - let evicted = base_slots.iter().filter(|(slot, _)| after["candidates"].get(slot).is_none()).collect::>(); + let evicted = base_slots + .iter() + .filter(|(slot, _)| after["candidates"].get(slot).is_none()) + .collect::>(); assert_eq!(evicted.len(), 1); for (slot, base) in evicted { assert!(b.store().get_internal(slot).unwrap().is_none()); assert!(b.store().get_internal(base).unwrap().is_none()); } - let retained = after["slots"].as_object().unwrap().keys().find(|s| s.starts_with("sync/snapshot/")).unwrap().clone(); + let retained = after["slots"] + .as_object() + .unwrap() + .keys() + .find(|s| s.starts_with("sync/snapshot/")) + .unwrap() + .clone(); let orphan = format!("sync/snapshot/{}", hex(&Vid::random().0)); b.store().set_internal(&orphan, b"fake-orphan").unwrap(); let mut injected = after; injected["slots"][&orphan] = "ConflictCandidate".into(); let queued_vid = Vid::random(); let queued_slot = format!("sync/snapshot/{}", hex(&queued_vid.0)); - b.store().set_internal(&queued_slot, b"fake-queued").unwrap(); + b.store() + .set_internal(&queued_slot, b"fake-queued") + .unwrap(); injected["slots"][&queued_slot] = "ConflictCandidate".into(); let mut outbox: kc_sync::Outbox = serde_json::from_value(injected["outbox"].clone()).unwrap(); - outbox.enqueue(kc_sync::PeerId(b.peers().find("alpha").unwrap().fingerprint.to_hex()), - kc_sync::ChangeId { name: "QUEUED".into(), generation: 1, new_vid: kc_sync::Vid(queued_vid.0) }); + outbox.enqueue( + kc_sync::PeerId(b.peers().find("alpha").unwrap().fingerprint.to_hex()), + kc_sync::ChangeId { + name: "QUEUED".into(), + generation: 1, + new_vid: kc_sync::Vid(queued_vid.0), + }, + ); injected["outbox"] = serde_json::to_value(outbox).unwrap(); save_state(&b, &injected); - b.run(&["sync", "status", "--json"], Run::agent()).await.expect(8); + b.run(&["sync", "status", "--json"], Run::agent()) + .await + .expect(8); assert!(b.store().get_internal(&orphan).unwrap().is_none()); assert!(state(&b)["slots"].get(&orphan).is_none()); assert!(b.store().get_internal(&retained).unwrap().is_some()); @@ -1115,23 +1491,57 @@ async fn candidate_eviction_collects_base_and_startup_collects_only_orphan_snaps async fn rejecting_proposal_deletes_binding_and_unbound_and_rm_releases_checkpoint() { let (a, b, relay) = devices().await; let vid = Vid::random(); - post(&a, &b, &relay, offer_message("PROPOSAL", vid, b"fake-proposal-gc", 0)).await; + post( + &a, + &b, + &relay, + offer_message("PROPOSAL", vid, b"fake-proposal-gc", 0), + ) + .await; b.run(&["inbox"], Run::agent()).await.expect(8); - assert!(b.store().get_internal(&fp_slot("PROPOSAL", vid)).unwrap().is_some()); + assert!( + b.store() + .get_internal(&fp_slot("PROPOSAL", vid)) + .unwrap() + .is_some() + ); assert_eq!(state(&b)["unbound"].as_array().unwrap().len(), 1); let before = std::fs::read(b.dir.path().join("sync.json")).unwrap(); - let out = b.run(&["sync", "review"], Run::human(vec![Answer::Select(1)])).await; + let out = b + .run(&["sync", "review"], Run::human(vec![Answer::Select(1)])) + .await; out.expect(5); assert_eq!(confirmations(&out).len(), 1); - assert_eq!(std::fs::read(b.dir.path().join("sync.json")).unwrap(), before); - let out = b.run(&["sync", "review"], human(vec![Answer::Select(1)])).await; + assert_eq!( + std::fs::read(b.dir.path().join("sync.json")).unwrap(), + before + ); + let out = b + .run(&["sync", "review"], human(vec![Answer::Select(1)])) + .await; out.expect(0); assert_eq!(confirmations(&out).len(), 1); - assert!(b.store().get_internal(&fp_slot("PROPOSAL", vid)).unwrap().is_none()); + assert!( + b.store() + .get_internal(&fp_slot("PROPOSAL", vid)) + .unwrap() + .is_none() + ); assert!(state(&b)["unbound"].as_array().unwrap().is_empty()); enroll(&a, &b).await; - b.run(&["sync", "status", "--confirm-checkpoint", "KEY"], human(vec![])).await.expect(0); - let checkpoint = state(&b)["slots"].as_object().unwrap().keys().find(|s| s.starts_with("sync/kg/")).unwrap().clone(); + b.run( + &["sync", "status", "--confirm-checkpoint", "KEY"], + human(vec![]), + ) + .await + .expect(0); + let checkpoint = state(&b)["slots"] + .as_object() + .unwrap() + .keys() + .find(|s| s.starts_with("sync/kg/")) + .unwrap() + .clone(); assert!(b.store().get_internal(&checkpoint).unwrap().is_some()); b.run(&["sync", "rm", "KEY"], human(vec![])).await.expect(0); assert!(b.store().get_internal(&checkpoint).unwrap().is_none()); @@ -1152,8 +1562,24 @@ async fn full_capacity_scan_and_preserve_mine_leave_inbox_review_and_resolve_ope s["slots"][slot] = "Checkpoint".into(); } save_state(&b, &s); - b.store().set("KEY", b"fake-out-of-band", kc_store::ItemKind::Text, kc_store::Origin::Local).unwrap(); - post(&a, &b, &relay, SyncMsg::Hello { features: vec![], is_reply: true }).await; + b.store() + .set( + "KEY", + b"fake-out-of-band", + kc_store::ItemKind::Text, + kc_store::Origin::Local, + ) + .unwrap(); + post( + &a, + &b, + &relay, + SyncMsg::Hello { + features: vec![], + is_reply: true, + }, + ) + .await; let out = b.run(&["inbox"], Run::agent()).await; out.expect(8); assert!(!out.stderr.contains("Sync storage is full")); @@ -1163,16 +1589,27 @@ async fn full_capacity_scan_and_preserve_mine_leave_inbox_review_and_resolve_ope let status = b.run(&["sync", "status", "--json"], Run::agent()).await; let status: Value = serde_json::from_slice(&status.stdout).unwrap(); assert_eq!(status["capacity_blocked"], true); - assert!(std::fs::read_to_string(b.dir.path().join("sync.log")).unwrap().contains("Sync storage is full")); + assert!( + std::fs::read_to_string(b.dir.path().join("sync.log")) + .unwrap() + .contains("Sync storage is full") + ); assert_eq!(b.value("KEY").unwrap(), b"fake-out-of-band"); - let out = b.run(&["sync", "resolve", "KEY", "--keep", "mine"], human(vec![])).await; + let out = b + .run(&["sync", "resolve", "KEY", "--keep", "mine"], human(vec![])) + .await; out.expect(8); assert!(!out.stderr.contains("Sync storage is full")); assert_eq!(b.value("KEY").unwrap(), b"fake-out-of-band"); // After capacity is freed, the same review/resolve path can recover normally. let mut s = state(&b); - s["slots"].as_object_mut().unwrap().retain(|slot, _| !slot.starts_with("sync/kg/test-")); + s["slots"] + .as_object_mut() + .unwrap() + .retain(|slot, _| !slot.starts_with("sync/kg/test-")); save_state(&b, &s); - b.run(&["sync", "resolve", "KEY", "--keep", "mine"], human(vec![])).await.expect(8); + b.run(&["sync", "resolve", "KEY", "--keep", "mine"], human(vec![])) + .await + .expect(8); assert_eq!(state(&b)["items"]["KEY"]["conflict"], false); } From becc6d90572f0d25d3a41a9a97e63cce81a6c513 Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Tue, 13 Oct 2026 18:09:05 +0900 Subject: [PATCH 20/24] =?UTF-8?q?release:=20v0.3.0=20=EC=9C=BC=EB=A1=9C=20?= =?UTF-8?q?=EB=B2=84=EC=A0=84=20=EC=98=AC=EB=A6=BC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- Cargo.lock | 12 ++++++------ Cargo.toml | 10 +++++----- crates/kc-cli/Cargo.toml | 2 +- crates/kc-relay/Cargo.toml | 2 +- 4 files changed, 13 insertions(+), 13 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 6ee2a0e..50fb81c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1496,7 +1496,7 @@ dependencies = [ [[package]] name = "kc-cli" -version = "0.2.0" +version = "0.3.0" dependencies = [ "base64 0.22.1", "block2", @@ -1535,7 +1535,7 @@ dependencies = [ [[package]] name = "kc-proto" -version = "0.2.0" +version = "0.3.0" dependencies = [ "base64 0.22.1", "chacha20poly1305", @@ -1558,7 +1558,7 @@ dependencies = [ [[package]] name = "kc-relay" -version = "0.2.0" +version = "0.3.0" dependencies = [ "anyhow", "axum", @@ -1586,7 +1586,7 @@ dependencies = [ [[package]] name = "kc-store" -version = "0.2.0" +version = "0.3.0" dependencies = [ "apple-native-keyring-store", "directories", @@ -1610,7 +1610,7 @@ dependencies = [ [[package]] name = "kc-sync" -version = "0.2.0" +version = "0.3.0" dependencies = [ "rand", "serde", @@ -1620,7 +1620,7 @@ dependencies = [ [[package]] name = "kc-wire" -version = "0.2.0" +version = "0.3.0" dependencies = [ "serde", "serde_json", diff --git a/Cargo.toml b/Cargo.toml index 3068540..dabfd75 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -3,7 +3,7 @@ resolver = "3" members = ["crates/kc-wire", "crates/kc-proto", "crates/kc-store", "crates/kc-relay", "crates/kc-cli", "crates/kc-sync"] [workspace.package] -version = "0.2.0" +version = "0.3.0" edition = "2024" rust-version = "1.88" license = "MIT" @@ -15,10 +15,10 @@ authors = ["Dcode "] # `dep = { workspace = true, features = [...] }`. A lane that needs a crate that # isn't listed here may add it to its own Cargo.toml directly. [workspace.dependencies] -kc-wire = { path = "crates/kc-wire", version = "0.2.0" } -kc-proto = { path = "crates/kc-proto", version = "0.2.0" } -kc-store = { path = "crates/kc-store", version = "0.2.0" } -kc-sync = { path = "crates/kc-sync", version = "0.2.0" } +kc-wire = { path = "crates/kc-wire", version = "0.3.0" } +kc-proto = { path = "crates/kc-proto", version = "0.3.0" } +kc-store = { path = "crates/kc-store", version = "0.3.0" } +kc-sync = { path = "crates/kc-sync", version = "0.3.0" } anyhow = "1" thiserror = "2" diff --git a/crates/kc-cli/Cargo.toml b/crates/kc-cli/Cargo.toml index a356c4b..4b863f3 100644 --- a/crates/kc-cli/Cargo.toml +++ b/crates/kc-cli/Cargo.toml @@ -64,7 +64,7 @@ windows = { version = "0.58.0", default-features = false, features = ["Security_ [dev-dependencies] kc-proto = { workspace = true, features = ["test-util"] } kc-store = { workspace = true, features = ["test-util"] } -kc-relay = { path = "../kc-relay", version = "0.2.0", features = ["test-util"] } +kc-relay = { path = "../kc-relay", version = "0.3.0", features = ["test-util"] } tokio = { workspace = true, features = ["io-util"] } tempfile = "3" postcard = { version = "1.1", default-features = false, features = ["alloc"] } diff --git a/crates/kc-relay/Cargo.toml b/crates/kc-relay/Cargo.toml index 35799d3..f457375 100644 --- a/crates/kc-relay/Cargo.toml +++ b/crates/kc-relay/Cargo.toml @@ -45,6 +45,6 @@ ipnet = "2" humantime = "2" [dev-dependencies] -kc-relay = { path = ".", version = "0.2.0", features = ["test-util"] } +kc-relay = { path = ".", version = "0.3.0", features = ["test-util"] } tower = { version = "0.5", features = ["util"] } tokio = { workspace = true, features = ["test-util", "io-util"] } From c730eb9a64a036ed6844311be3c0708517c69f43 Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Tue, 13 Oct 2026 18:18:23 +0900 Subject: [PATCH 21/24] =?UTF-8?q?fix(kc-cli):=20=ED=99=95=EC=9D=B8=20?= =?UTF-8?q?=EB=A6=AC=EB=B7=B0=20=EB=B0=98=EC=98=81=20=E2=80=94=20=EC=B6=A9?= =?UTF-8?q?=EB=8F=8C=20=EC=A4=91=20Offer=20=EB=B2=94=EC=9C=84=20=EA=B2=80?= =?UTF-8?q?=EC=82=AC=20=EC=99=B8=203=EA=B1=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 충돌 중인 항목에 온 Offer 는 범위 안 기기·같은 등록 세대일 때만 충돌 후보로. 그 밖에는 제안으로 둔다(범위 밖 기기가 후보 슬롯을 밀어내는 것을 막음). - 일시 전달 실패는 별도 플래그(delivery_failed)로, 모든 상대에 닿으면 해제. - 축출된 제안도 거절과 같이 vid 바인딩을 정리한다. - review 확인 문구에서 빈 절을 뺀다. Co-Authored-By: Claude Opus 5.5 --- crates/kc-cli/locales/de.toml | 2 + crates/kc-cli/locales/es.toml | 2 + crates/kc-cli/locales/fr.toml | 2 + crates/kc-cli/locales/ja.toml | 2 + crates/kc-cli/locales/ko.toml | 2 + crates/kc-cli/locales/zh-Hans.toml | 2 + crates/kc-cli/locales/zh-Hant.toml | 2 + crates/kc-cli/src/sync/actions.rs | 78 +++++++++++++---------------- crates/kc-cli/src/sync/mod.rs | 24 ++++++++- crates/kc-cli/src/sync/receive.rs | 6 ++- crates/kc-cli/src/sync/state.rs | 3 ++ crates/kc-cli/src/sync/transport.rs | 4 +- crates/kc-cli/tests/sync.rs | 27 ++++++++++ 13 files changed, 110 insertions(+), 46 deletions(-) diff --git a/crates/kc-cli/locales/de.toml b/crates/kc-cli/locales/de.toml index 3dd1324..d6579c3 100644 --- a/crates/kc-cli/locales/de.toml +++ b/crates/kc-cli/locales/de.toml @@ -490,6 +490,8 @@ "kc sync peer add {label}" = "kc sync peer add {label}" "kc sync peer rm {label}" = "kc sync peer rm {label}" "Accept {names} from {devices}; reject {rejected}" = "{names} von {devices} annehmen; {rejected} ablehnen" +"Accept {names} from {devices}" = "{names} von {devices} annehmen" +"Reject {rejected}" = "{rejected} ablehnen" "Replace {name} with the value from {device}" = "{name} durch den Wert von {device} ersetzen" "Resolve {name}: keep {choice}" = "{name} auflösen: {choice} behalten" "Restore {name} to its checkpoint" = "{name} auf seinen Kontrollpunkt zurücksetzen" diff --git a/crates/kc-cli/locales/es.toml b/crates/kc-cli/locales/es.toml index a921aaf..bafc03c 100644 --- a/crates/kc-cli/locales/es.toml +++ b/crates/kc-cli/locales/es.toml @@ -490,6 +490,8 @@ "kc sync peer add {label}" = "kc sync peer add {label}" "kc sync peer rm {label}" = "kc sync peer rm {label}" "Accept {names} from {devices}; reject {rejected}" = "Aceptar {names} de {devices}; rechazar {rejected}" +"Accept {names} from {devices}" = "Aceptar {names} de {devices}" +"Reject {rejected}" = "Rechazar {rejected}" "Replace {name} with the value from {device}" = "Reemplazar {name} por el valor de {device}" "Resolve {name}: keep {choice}" = "Resolver {name}: conservar {choice}" "Restore {name} to its checkpoint" = "Restaurar {name} a su punto de control" diff --git a/crates/kc-cli/locales/fr.toml b/crates/kc-cli/locales/fr.toml index 18368cc..74da1b7 100644 --- a/crates/kc-cli/locales/fr.toml +++ b/crates/kc-cli/locales/fr.toml @@ -490,6 +490,8 @@ "kc sync peer add {label}" = "kc sync peer add {label}" "kc sync peer rm {label}" = "kc sync peer rm {label}" "Accept {names} from {devices}; reject {rejected}" = "Accepter {names} de {devices} ; refuser {rejected}" +"Accept {names} from {devices}" = "Accepter {names} de {devices}" +"Reject {rejected}" = "Refuser {rejected}" "Replace {name} with the value from {device}" = "Remplacer {name} par la valeur de {device}" "Resolve {name}: keep {choice}" = "Résoudre {name} : conserver {choice}" "Restore {name} to its checkpoint" = "Restaurer {name} à son point de contrôle" diff --git a/crates/kc-cli/locales/ja.toml b/crates/kc-cli/locales/ja.toml index 18fc8af..4b116e0 100644 --- a/crates/kc-cli/locales/ja.toml +++ b/crates/kc-cli/locales/ja.toml @@ -490,6 +490,8 @@ "kc sync peer add {label}" = "kc sync peer add {label}" "kc sync peer rm {label}" = "kc sync peer rm {label}" "Accept {names} from {devices}; reject {rejected}" = "{devices}からの{names}を承認し、{rejected}を拒否" +"Accept {names} from {devices}" = "{devices}からの{names}を承認" +"Reject {rejected}" = "{rejected}を拒否" "Replace {name} with the value from {device}" = "{name}を{device}の値で置き換える" "Resolve {name}: keep {choice}" = "{name}を解決:{choice}を保持" "Restore {name} to its checkpoint" = "{name}をチェックポイントに戻す" diff --git a/crates/kc-cli/locales/ko.toml b/crates/kc-cli/locales/ko.toml index 4438c49..28798c2 100644 --- a/crates/kc-cli/locales/ko.toml +++ b/crates/kc-cli/locales/ko.toml @@ -490,6 +490,8 @@ "kc sync peer add {label}" = "kc sync peer add {label}" "kc sync peer rm {label}" = "kc sync peer rm {label}" "Accept {names} from {devices}; reject {rejected}" = "{devices}의 {names} 수락; {rejected} 거절" +"Accept {names} from {devices}" = "{devices}의 {names} 수락" +"Reject {rejected}" = "{rejected} 거절" "Replace {name} with the value from {device}" = "{name}을(를) {device}의 값으로 교체" "Resolve {name}: keep {choice}" = "{name} 충돌 해결: {choice} 유지" "Restore {name} to its checkpoint" = "{name}을(를) 복구 기준점으로 복원" diff --git a/crates/kc-cli/locales/zh-Hans.toml b/crates/kc-cli/locales/zh-Hans.toml index 96ec3a4..1dd6e5e 100644 --- a/crates/kc-cli/locales/zh-Hans.toml +++ b/crates/kc-cli/locales/zh-Hans.toml @@ -490,6 +490,8 @@ "kc sync peer add {label}" = "kc sync peer add {label}" "kc sync peer rm {label}" = "kc sync peer rm {label}" "Accept {names} from {devices}; reject {rejected}" = "接受来自{devices}的{names};拒绝{rejected}" +"Accept {names} from {devices}" = "接受来自{devices}的{names}" +"Reject {rejected}" = "拒绝{rejected}" "Replace {name} with the value from {device}" = "用{device}的值替换{name}" "Resolve {name}: keep {choice}" = "解决{name}:保留{choice}" "Restore {name} to its checkpoint" = "将{name}恢复到检查点" diff --git a/crates/kc-cli/locales/zh-Hant.toml b/crates/kc-cli/locales/zh-Hant.toml index 6d230f1..0f979f1 100644 --- a/crates/kc-cli/locales/zh-Hant.toml +++ b/crates/kc-cli/locales/zh-Hant.toml @@ -490,6 +490,8 @@ "kc sync peer add {label}" = "kc sync peer add {label}" "kc sync peer rm {label}" = "kc sync peer rm {label}" "Accept {names} from {devices}; reject {rejected}" = "接受來自{devices}的{names};拒絕{rejected}" +"Accept {names} from {devices}" = "接受來自{devices}的{names}" +"Reject {rejected}" = "拒絕{rejected}" "Replace {name} with the value from {device}" = "以{device}的值取代{name}" "Resolve {name}: keep {choice}" = "解決{name}:保留{choice}" "Restore {name} to its checkpoint" = "將{name}還原至檢查點" diff --git a/crates/kc-cli/src/sync/actions.rs b/crates/kc-cli/src/sync/actions.rs index 55dc763..89409ae 100644 --- a/crates/kc-cli/src/sync/actions.rs +++ b/crates/kc-cli/src/sync/actions.rs @@ -195,7 +195,7 @@ pub(crate) fn status(ctx: &mut Ctx<'_, H>, json: bool) -> Result { } let output = serde_json::json!({"items": rows, "candidates": candidates, "peers": peers, "frozen":s.frozen, "capacity_blocked":s.capacity_blocked, "slots_used":s.slots.len(), "slot_capacity":SlotBudget::new(s.items.len()).capacity(), - "reconnect":s.reconnect, "notice":tr!("Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy.")}); + "reconnect":s.reconnect, "delivery_failed":s.delivery_failed, "notice":tr!("Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy.")}); if json { ctx.emit( format!( @@ -229,7 +229,7 @@ pub(crate) fn status(ctx: &mut Ctx<'_, H>, json: bool) -> Result { tr!("Sync storage is full; review pending items before retrying.") ); } - if s.reconnect { + if s.reconnect || s.delivery_failed { crate::commands::say!( ctx, "{}", @@ -295,30 +295,40 @@ pub(crate) fn review(ctx: &mut Ctx<'_, H>) -> Result { } } if !accepts.is_empty() || !rejects.is_empty() { - human( - ctx, - &tr!( + let names = names_summary( + &accepts + .iter() + .map(|c| c.version.name.clone()) + .collect::>(), + ); + let devices = names_summary( + &accepts + .iter() + .map(|c| label(ctx, &c.peer)) + .collect::>>()?, + ); + let rejected = names_summary( + &rejects + .iter() + .map(|c| c.version.name.clone()) + .collect::>(), + ); + // The OS dialog shows only the clauses that apply. + let reason = match (accepts.is_empty(), rejects.is_empty()) { + (false, false) => tr!( "Accept {names} from {devices}; reject {rejected}", - names = names_summary( - &accepts - .iter() - .map(|c| c.version.name.clone()) - .collect::>() - ), - devices = names_summary( - &accepts - .iter() - .map(|c| label(ctx, &c.peer)) - .collect::>>()? - ), - rejected = names_summary( - &rejects - .iter() - .map(|c| c.version.name.clone()) - .collect::>() - ) + names = names, + devices = devices, + rejected = rejected ), - )?; + (false, true) => tr!( + "Accept {names} from {devices}", + names = names, + devices = devices + ), + _ => tr!("Reject {rejected}", rejected = rejected), + }; + human(ctx, &reason)?; } let _items = ctx.state.lock_items(ctx.store.namespace())?; let _state = ctx.state.lock()?; @@ -331,25 +341,7 @@ pub(crate) fn review(ctx: &mut Ctx<'_, H>) -> Result { let delivery = delivery_key(&c.peer, &c.version.name, c.generation, c.version.vid); if c.category == CandidateKind::Proposal { s.rejected_offers.insert(delivery); - let record = record_slot(&c.version.name, c.version.vid); - let referenced = s - .items - .get(&c.version.name) - .is_some_and(|i| i.head == c.version.vid) - || s.versions - .values() - .any(|v| v.name == c.version.name && v.vid == c.version.vid) - || s.candidates.values().any(|other| { - other.version.name == c.version.name && other.version.vid == c.version.vid - }); - if !referenced { - s.unbound - .remove(&format!("{}:{}", c.version.name, vid_key(c.version.vid))); - if let Some(item) = s.items.get_mut(&c.version.name) { - item.known.retain(|vid| *vid != c.version.vid); - } - s.gc.insert(record); - } + forget_binding(&mut s, &c.version.name, c.version.vid); } else { s.receipts.insert( delivery, diff --git a/crates/kc-cli/src/sync/mod.rs b/crates/kc-cli/src/sync/mod.rs index 241e288..40f1a02 100644 --- a/crates/kc-cli/src/sync/mod.rs +++ b/crates/kc-cli/src/sync/mod.rs @@ -217,10 +217,13 @@ fn reserve( .filter(|c| c.version.slot == victim) .cloned() .collect::>(); + s.candidates.retain(|_, c| c.version.slot != victim); for c in evicted { s.gc.insert(c.base_record); + if c.category == CandidateKind::Proposal { + forget_binding(s, &c.version.name, c.version.vid); + } } - s.candidates.retain(|_, c| c.version.slot != victim); s.slots.remove(&victim); s.gc.insert(victim); } @@ -232,6 +235,24 @@ fn reserve( } } } +/// Drops a dropped proposal's vid binding (`sync/fp/...` record, unbound entry, known vid) +/// unless the head, a version or another candidate still refers to it. +fn forget_binding(s: &mut State, name: &str, vid: Vid) { + let referenced = s.items.get(name).is_some_and(|i| i.head == vid) + || s.versions.values().any(|v| v.name == name && v.vid == vid) + || s.candidates + .values() + .any(|other| other.version.name == name && other.version.vid == vid); + if referenced { + return; + } + s.unbound.remove(&format!("{}:{}", name, vid_key(vid))); + if let Some(item) = s.items.get_mut(name) { + item.known.retain(|known| *known != vid); + } + s.gc.insert(record_slot(name, vid)); +} + fn release(s: &mut State, slot: &str) { if s.slots.get(slot) != Some(&SlotKind::Checkpoint) { s.slots.remove(slot); @@ -263,6 +284,7 @@ fn pending(s: &State) -> bool { s.frozen || s.capacity_blocked || s.reconnect + || s.delivery_failed || !s.candidates.is_empty() || !s.offers.is_empty() || s.items.values().any(|i| i.conflict) diff --git a/crates/kc-cli/src/sync/receive.rs b/crates/kc-cli/src/sync/receive.rs index 6fe33cd..fdbaf22 100644 --- a/crates/kc-cli/src/sync/receive.rs +++ b/crates/kc-cli/src/sync/receive.rs @@ -87,7 +87,11 @@ pub(crate) fn receive(ctx: &mut Ctx<'_, H>, peer: &str, message: &SyncM }, ); } else if !s.candidates.contains_key(&version.slot) { - let category = if s.items.get(name).is_some_and(|i| i.conflict) { + let category = if s.items.get(name).is_some_and(|i| { + i.conflict + && i.scope.contains(peer) + && *known_generation == s.generations.generation(name) + }) { CandidateKind::Conflict } else { CandidateKind::Proposal diff --git a/crates/kc-cli/src/sync/state.rs b/crates/kc-cli/src/sync/state.rs index 6fd005c..89a8a9b 100644 --- a/crates/kc-cli/src/sync/state.rs +++ b/crates/kc-cli/src/sync/state.rs @@ -103,6 +103,9 @@ pub struct State { pub journal: Option, pub capacity_blocked: bool, pub reconnect: bool, + /// The last delivery attempt failed; cleared by the next flush that reaches every peer. + #[serde(default)] + pub delivery_failed: bool, pub gc: BTreeSet, } impl State { diff --git a/crates/kc-cli/src/sync/transport.rs b/crates/kc-cli/src/sync/transport.rs index d685bcd..1b2ac5d 100644 --- a/crates/kc-cli/src/sync/transport.rs +++ b/crates/kc-cli/src/sync/transport.rs @@ -63,7 +63,7 @@ async fn deliver( message: SyncMsg, ) -> Result<()> { if let Err(error) = post(ctx, peer, message).await { - s.reconnect = true; + s.delivery_failed = true; s.save(&ctx.state)?; return Err(error); } @@ -242,6 +242,8 @@ pub(crate) async fn flush(ctx: &mut Ctx<'_, H>, digest: bool) -> Result s.save(&ctx.state)?; } } + // Every peer was reached without an error, so nothing waits on a failed delivery. + s.delivery_failed = false; collect_snapshots(&mut s); s.cleanup(ctx)?; Ok(sent) diff --git a/crates/kc-cli/tests/sync.rs b/crates/kc-cli/tests/sync.rs index d52c317..4ab74fc 100644 --- a/crates/kc-cli/tests/sync.rs +++ b/crates/kc-cli/tests/sync.rs @@ -1152,6 +1152,33 @@ async fn offer_during_conflict_is_a_candidate_and_review_cannot_discard_it() { assert_eq!(b.value("KEY").unwrap(), b"fake-conflict-b"); } +#[tokio::test] +async fn offer_during_conflict_at_another_generation_stays_a_proposal() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + a.set("KEY", b"fake-conflict-a").await; + b.set("KEY", b"fake-conflict-b").await; + pump(&a, &b).await; + let offered = Vid::random(); + // Not stale (above the current generation) but not the registration in conflict either. + post( + &a, + &b, + &relay, + offer_message("KEY", offered, b"fake-conflict-offer", 2), + ) + .await; + b.run(&["inbox"], Run::agent()).await.expect(8); + let s = state(&b); + let offer = s["candidates"] + .as_object() + .unwrap() + .values() + .find(|c| c["version"]["vid"] == serde_json::to_value(offered).unwrap()) + .expect("the offer is kept"); + assert_eq!(offer["category"], "proposal"); +} + #[tokio::test] async fn sync_envelope_replay_is_skipped_by_seen_set() { let (a, b, relay) = devices().await; From 99c52f40f04df1af9c37fc22a34c4d0926fa83c7 Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Tue, 13 Oct 2026 18:24:50 +0900 Subject: [PATCH 22/24] =?UTF-8?q?fix(kc-cli):=20=EC=A0=95=EB=A6=AC=20?= =?UTF-8?q?=EC=A7=81=EC=A0=84=EC=97=90=20=EC=82=B4=EC=95=84=20=EC=9E=88?= =?UTF-8?q?=EB=8A=94=20=EC=A7=80=EB=AC=B8=20=EB=A0=88=EC=BD=94=EB=93=9C?= =?UTF-8?q?=EB=8A=94=20=EC=82=AD=EC=A0=9C=20=EC=98=88=EC=95=BD=EC=97=90?= =?UTF-8?q?=EC=84=9C=20=EB=BA=80=EB=8B=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 수락 중인 제안이 자기 기준점 예약으로 축출되면 그 vid 바인딩이 삭제 예약된 채 head 가 되어, 다음 sync 가 상태 손상으로 실패할 수 있었다(codex 리뷰 P1). Co-Authored-By: Claude Opus 5.5 --- crates/kc-cli/src/sync/state.rs | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/crates/kc-cli/src/sync/state.rs b/crates/kc-cli/src/sync/state.rs index 89a8a9b..e2f758f 100644 --- a/crates/kc-cli/src/sync/state.rs +++ b/crates/kc-cli/src/sync/state.rs @@ -124,6 +124,28 @@ impl State { .map_err(|_| super::state_error()) } pub fn cleanup(&mut self, ctx: &Ctx<'_, H>) -> Result<()> { + // A binding scheduled for deletion may have become live again in the same + // transaction (an accepted proposal evicted by its own checkpoint reservation). + let live: BTreeSet = self + .items + .iter() + .flat_map(|(name, i)| { + std::iter::once(i.head) + .chain(i.known.iter().copied()) + .map(move |vid| super::record_slot(name, vid)) + }) + .chain( + self.versions + .values() + .map(|v| super::record_slot(&v.name, v.vid)), + ) + .chain( + self.candidates + .values() + .map(|c| super::record_slot(&c.version.name, c.version.vid)), + ) + .collect(); + self.gc.retain(|slot| !live.contains(slot)); // Metadata is durable before deletion. A restart repeats only harmless deletes. self.save(&ctx.state)?; for slot in &self.gc { From bdd5cc5aca866b37210115841ea4c1f83feda243 Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Tue, 13 Oct 2026 18:27:52 +0900 Subject: [PATCH 23/24] =?UTF-8?q?fix(kc-cli):=20=EC=B6=95=EC=B6=9C=20?= =?UTF-8?q?=EB=95=8C=EB=8A=94=20vid=20=EB=B0=94=EC=9D=B8=EB=94=A9=EC=9D=84?= =?UTF-8?q?=20=EC=A0=95=EB=A6=AC=ED=95=98=EC=A7=80=20=EC=95=8A=EB=8A=94?= =?UTF-8?q?=EB=8B=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 축출된 후보가 바로 그 슬롯을 예약 중인 수락 대상일 수 있어, unbound 표시가 사라지면 같은 vid 의 정상 변경이 위반으로 격리된다(codex 재리뷰 P1). Co-Authored-By: Claude Opus 5.5 --- crates/kc-cli/src/sync/mod.rs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/crates/kc-cli/src/sync/mod.rs b/crates/kc-cli/src/sync/mod.rs index 40f1a02..d54b406 100644 --- a/crates/kc-cli/src/sync/mod.rs +++ b/crates/kc-cli/src/sync/mod.rs @@ -218,11 +218,10 @@ fn reserve( .cloned() .collect::>(); s.candidates.retain(|_, c| c.version.slot != victim); + // Only the slots go: the vid binding stays, because the evicted candidate + // can be the one whose acceptance is reserving this slot. for c in evicted { s.gc.insert(c.base_record); - if c.category == CandidateKind::Proposal { - forget_binding(s, &c.version.name, c.version.vid); - } } s.slots.remove(&victim); s.gc.insert(victim); From 7aa7d5a8c25c632fb8ac94b0dfcdaf6e9b4ffb54 Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Tue, 13 Oct 2026 18:31:58 +0900 Subject: [PATCH 24/24] =?UTF-8?q?fix(kc-cli):=20=EC=B6=A9=EB=8F=8C=20?= =?UTF-8?q?=EC=A4=91=EC=9D=B8=20=ED=95=AD=EB=AA=A9=EC=9D=80=20=EC=9D=BC?= =?UTF-8?q?=EB=B0=98=20=EC=88=98=EB=9D=BD=EC=9D=B4=20=EC=95=84=EB=8B=88?= =?UTF-8?q?=EB=9D=BC=20resolve=20=EB=A1=9C=EB=A7=8C=20=EC=A0=95=EB=A6=AC?= =?UTF-8?q?=ED=95=9C=EB=8B=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 충돌 중에 들어온 제안·보류 변경을 review 로 받아들이면 다른 충돌 후보가 버려졌다(codex 리뷰 P1). 잠금 안에서 막고 resolve 를 안내한다. Co-Authored-By: Claude Opus 5.5 --- crates/kc-cli/locales/de.toml | 1 + crates/kc-cli/locales/es.toml | 1 + crates/kc-cli/locales/fr.toml | 1 + crates/kc-cli/locales/ja.toml | 1 + crates/kc-cli/locales/ko.toml | 1 + crates/kc-cli/locales/zh-Hans.toml | 1 + crates/kc-cli/locales/zh-Hant.toml | 1 + crates/kc-cli/src/sync/transaction.rs | 28 +++++++++++++++++++++++++++ crates/kc-cli/tests/sync.rs | 9 +++++++++ 9 files changed, 44 insertions(+) diff --git a/crates/kc-cli/locales/de.toml b/crates/kc-cli/locales/de.toml index d6579c3..be4ffdf 100644 --- a/crates/kc-cli/locales/de.toml +++ b/crates/kc-cli/locales/de.toml @@ -499,3 +499,4 @@ "Confirm the current value of {name} as its checkpoint" = "Den aktuellen Wert von {name} als Kontrollpunkt bestätigen" "Ignored a sync offer from disabled or blocked peer {peer}." = "Synchronisierungsangebot vom deaktivierten oder blockierten Gerät {peer} ignoriert." "Sync item held; run `kc sync review`." = "Synchronisierungselement zurückgehalten; `kc sync review` ausführen." +"{name} is in conflict; settle it with `kc sync resolve {name}` first." = "{name} steht im Konflikt; zuerst mit `kc sync resolve {name}` auflösen." diff --git a/crates/kc-cli/locales/es.toml b/crates/kc-cli/locales/es.toml index bafc03c..bf0acc6 100644 --- a/crates/kc-cli/locales/es.toml +++ b/crates/kc-cli/locales/es.toml @@ -499,3 +499,4 @@ "Confirm the current value of {name} as its checkpoint" = "Confirmar el valor actual de {name} como su punto de control" "Ignored a sync offer from disabled or blocked peer {peer}." = "Se ignoró una oferta de sincronización del dispositivo desactivado o bloqueado {peer}." "Sync item held; run `kc sync review`." = "Elemento de sincronización retenido; ejecuta `kc sync review`." +"{name} is in conflict; settle it with `kc sync resolve {name}` first." = "{name} está en conflicto; resuélvelo primero con `kc sync resolve {name}`." diff --git a/crates/kc-cli/locales/fr.toml b/crates/kc-cli/locales/fr.toml index 74da1b7..d66f990 100644 --- a/crates/kc-cli/locales/fr.toml +++ b/crates/kc-cli/locales/fr.toml @@ -499,3 +499,4 @@ "Confirm the current value of {name} as its checkpoint" = "Confirmer la valeur actuelle de {name} comme point de contrôle" "Ignored a sync offer from disabled or blocked peer {peer}." = "Offre de synchronisation ignorée : appareil {peer} désactivé ou bloqué." "Sync item held; run `kc sync review`." = "Élément de synchronisation en attente ; exécutez `kc sync review`." +"{name} is in conflict; settle it with `kc sync resolve {name}` first." = "{name} est en conflit ; résolvez-le d’abord avec `kc sync resolve {name}`." diff --git a/crates/kc-cli/locales/ja.toml b/crates/kc-cli/locales/ja.toml index 4b116e0..0878dd7 100644 --- a/crates/kc-cli/locales/ja.toml +++ b/crates/kc-cli/locales/ja.toml @@ -499,3 +499,4 @@ "Confirm the current value of {name} as its checkpoint" = "{name}の現在の値をチェックポイントとして確認" "Ignored a sync offer from disabled or blocked peer {peer}." = "無効またはブロックされたデバイス{peer}からの同期提案を無視しました。" "Sync item held; run `kc sync review`." = "同期項目を保留しました。`kc sync review`を実行してください。" +"{name} is in conflict; settle it with `kc sync resolve {name}` first." = "{name} は競合中です。先に `kc sync resolve {name}` で解決してください。" diff --git a/crates/kc-cli/locales/ko.toml b/crates/kc-cli/locales/ko.toml index 28798c2..f6c24cc 100644 --- a/crates/kc-cli/locales/ko.toml +++ b/crates/kc-cli/locales/ko.toml @@ -499,3 +499,4 @@ "Confirm the current value of {name} as its checkpoint" = "{name}의 현재 값을 복구 기준점으로 확인" "Ignored a sync offer from disabled or blocked peer {peer}." = "비활성화되거나 차단된 기기 {peer}의 동기화 제안을 무시했습니다." "Sync item held; run `kc sync review`." = "동기화 항목을 보류했습니다. `kc sync review`를 실행하세요." +"{name} is in conflict; settle it with `kc sync resolve {name}` first." = "{name} 항목이 충돌 중입니다. 먼저 `kc sync resolve {name}`로 해결하세요." diff --git a/crates/kc-cli/locales/zh-Hans.toml b/crates/kc-cli/locales/zh-Hans.toml index 1dd6e5e..1ed5632 100644 --- a/crates/kc-cli/locales/zh-Hans.toml +++ b/crates/kc-cli/locales/zh-Hans.toml @@ -499,3 +499,4 @@ "Confirm the current value of {name} as its checkpoint" = "确认{name}的当前值为检查点" "Ignored a sync offer from disabled or blocked peer {peer}." = "已忽略已禁用或被阻止的设备{peer}的同步提议。" "Sync item held; run `kc sync review`." = "同步项目已保留;请运行 `kc sync review`。" +"{name} is in conflict; settle it with `kc sync resolve {name}` first." = "{name} 存在冲突,请先用 `kc sync resolve {name}` 解决。" diff --git a/crates/kc-cli/locales/zh-Hant.toml b/crates/kc-cli/locales/zh-Hant.toml index 0f979f1..e93c253 100644 --- a/crates/kc-cli/locales/zh-Hant.toml +++ b/crates/kc-cli/locales/zh-Hant.toml @@ -499,3 +499,4 @@ "Confirm the current value of {name} as its checkpoint" = "確認{name}的目前值為檢查點" "Ignored a sync offer from disabled or blocked peer {peer}." = "已忽略已停用或遭封鎖的裝置{peer}的同步提議。" "Sync item held; run `kc sync review`." = "同步項目已保留;請執行 `kc sync review`。" +"{name} is in conflict; settle it with `kc sync resolve {name}` first." = "{name} 有衝突,請先用 `kc sync resolve {name}` 解決。" diff --git a/crates/kc-cli/src/sync/transaction.rs b/crates/kc-cli/src/sync/transaction.rs index 72dce7f..8d2f6ca 100644 --- a/crates/kc-cli/src/sync/transaction.rs +++ b/crates/kc-cli/src/sync/transaction.rs @@ -420,6 +420,34 @@ pub(super) fn accept(ctx: &mut Ctx<'_, H>, s: &mut State, c: &Candidate s.save(&ctx.state)?; return Ok(false); } + // While the item is in conflict, only `kc sync resolve` may settle it: accepting a + // proposal or held change here would drop the other candidates (§2.4). + // A held resolve whose parents name the current head and every open candidate is the + // way out of the conflict, so it stays acceptable (§2.4). + let settles_conflict = |s: &State| { + let Some(item) = s.items.get(name) else { + return false; + }; + c.version.parents.contains(&item.head) + && s.candidates + .values() + .filter(|o| o.version.name == *name && o.category == CandidateKind::Conflict) + .all(|o| c.version.parents.contains(&o.version.vid)) + }; + if c.category != CandidateKind::Conflict + && s.items.get(name).is_some_and(|i| i.conflict) + && !settles_conflict(s) + { + crate::commands::say!( + ctx, + "{}", + tr!( + "{name} is in conflict; settle it with `kc sync resolve {name}` first.", + name = name + ) + ); + return Ok(false); + } if c.retire { super::actions::remove(ctx, s, name)?; return Ok(true); diff --git a/crates/kc-cli/tests/sync.rs b/crates/kc-cli/tests/sync.rs index 4ab74fc..b3da08e 100644 --- a/crates/kc-cli/tests/sync.rs +++ b/crates/kc-cli/tests/sync.rs @@ -1177,6 +1177,15 @@ async fn offer_during_conflict_at_another_generation_stays_a_proposal() { .find(|c| c["version"]["vid"] == serde_json::to_value(offered).unwrap()) .expect("the offer is kept"); assert_eq!(offer["category"], "proposal"); + // Accepting it would end the conflict and drop the other candidates; resolve must. + let candidates = s["candidates"].clone(); + b.run(&["sync", "review"], human(vec![Answer::Select(0)])) + .await + .expect(8); + let after = state(&b); + assert_eq!(after["candidates"], candidates); + assert_eq!(after["items"]["KEY"]["conflict"], true); + assert_eq!(b.value("KEY").unwrap(), b"fake-conflict-b"); } #[tokio::test]