From 63aa94fec26b05b4b99acf99e3772e1e922da48b Mon Sep 17 00:00:00 2001 From: KnowSky404 Date: Sat, 31 Oct 2026 15:16:19 +0800 Subject: [PATCH 1/4] fix(workspace): add explicit device reset recovery --- AGENTS.md | 16 +- docs/wiki/Changelog.md | 10 + docs/wiki/Changelog.zh-CN.md | 7 + docs/wiki/User-Guide.md | 24 +- docs/wiki/User-Guide.zh-CN.md | 17 +- docs/workspace-v2-operations.md | 35 ++ docs/workspace-v2-operations.zh-CN.md | 26 +- e2e/workspace-reset.spec.ts | 502 ++++++++++++++++++ src/lib/i18n.ts | 18 + src/lib/workspace-browser-session-v2.test.ts | 68 +++ src/lib/workspace-browser-session-v2.ts | 31 +- src/lib/workspace-cloud-session.test.ts | 25 + src/lib/workspace-cloud-session.ts | 6 +- src/lib/workspace-events.ts | 1 + .../workspace-mutation-sync-browser.test.ts | 45 +- src/lib/workspace-mutation-sync-browser.ts | 18 +- src/lib/workspace-persistence-browser.test.ts | 176 ++++++ src/lib/workspace-persistence-browser.ts | 37 ++ .../workspace-persistence-dispatcher.test.ts | 79 +++ src/lib/workspace-persistence-dispatcher.ts | 13 + src/lib/workspace-persistence.test.ts | 438 +++++++++++++++ src/lib/workspace-persistence.ts | 167 ++++-- src/lib/workspace-settings-controller.test.ts | 102 ++++ src/lib/workspace-settings-controller.ts | 81 ++- src/routes/+layout.svelte | 6 + src/routes/auth/+page.svelte | 179 ++++++- src/routes/auth/page-source.test.ts | 36 ++ 27 files changed, 2089 insertions(+), 74 deletions(-) create mode 100644 e2e/workspace-reset.spec.ts diff --git a/AGENTS.md b/AGENTS.md index b24cd70..b268395 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -174,9 +174,17 @@ GitHub authentication remains outside that database: an explicit reconcile. Rebind and repair transactions must reject changing an active binding to another Gist. Preserve historical orphan queues without restoring Workspace switching. +- A user-confirmed **Reset this device** is a separate recovery operation. It + atomically clears the current binding, cached business snapshot, and complete + active queue, while preserving historical orphan queues, quarantined evidence, + and the monotonic fencing counter. It must reject changed state and an active + dispatcher lease. Reset never writes to GitHub; only a subsequent explicit + connection may run unbound discovery or initialize an empty Workspace. - Cloud refresh uses compare-and-swap checks so a concurrent edit cannot be - silently discarded. Abandoning active pending work requires confirmation to - discard the complete queue and reload the latest original cloud document. + silently discarded. Ordinary cloud reload requires confirmation before + discarding the complete active queue and loading the latest original document. + Stale reads or dispatchers must not restore a binding abandoned by device reset, + including when cross-tab notifications are unavailable. - One dispatcher owns a persisted lease with an owner ID, monotonically allocated fencing token, expiry, and heartbeat. Web Locks and BroadcastChannel are optional coordination aids, not correctness boundaries. @@ -207,7 +215,9 @@ GitHub authentication remains outside that database: preview and confirmation. Unbound setup may inspect an explicit original Gist ID; ambiguous discovery requires that ID. Bound startup and reconnection must read only the original Gist, never choose or create another one. Legacy checks - require an explicit ID and do not create a Gist. + require an explicit ID and do not create a Gist. A deliberate device reset may + remove the binding before a new connection; it must prevent legacy storage from + restoring the abandoned binding or uploading the old cache. - `workspace.migrate` is an internal, source-hash-checked browser mutation. It preserves the original Gist, output bytes, filenames, and publication metadata; it does not regenerate or republish outputs. Pending/repair evidence must be diff --git a/docs/wiki/Changelog.md b/docs/wiki/Changelog.md index 0e1df5f..b7cab96 100644 --- a/docs/wiki/Changelog.md +++ b/docs/wiki/Changelog.md @@ -8,6 +8,16 @@ production deployment and real-provider acceptance require separate evidence. ## Unreleased +### 2026-10-31 - Explicit device reset and fresh connection + +- Added a confirmed Settings recovery action for devices whose original Gist was + deleted or is inaccessible, including signed-out and cloud-error states. +- Reset atomically removes the current binding, cached business data, and complete + active queue; preserves historical queues and quarantined evidence; and rejects + active delivery or concurrent changes. Stale tabs cannot restore the old binding. +- Kept reset local: authentication clears only after storage commits, and a + separate connection loads cloud data or initializes an empty Workspace. + ### 2026-10-28 - Primer interface and interaction system - Unified the six routes around the approved GitHub-style concepts: white/dark diff --git a/docs/wiki/Changelog.zh-CN.md b/docs/wiki/Changelog.zh-CN.md index 281291d..21b0d2f 100644 --- a/docs/wiki/Changelog.zh-CN.md +++ b/docs/wiki/Changelog.zh-CN.md @@ -7,6 +7,13 @@ ## 未发布 +### 2026-10-31 - 显式设备重置与重新连接 + +- 在设置中增加需确认的恢复入口,支持原 Gist 已删除或不可访问、退出登录和云端加载失败的场景。 +- 以事务清除当前绑定、本机业务缓存和当前完整队列;保留历史队列与隔离证据, + 正在发送或并发变化时拒绝重置,旧标签页不能恢复已放弃的绑定。 +- 重置仅作用于本地,存储提交后才清除认证;用户再次连接时才加载云端或初始化空工作区。 + ### 2026-10-28 - Primer 界面与交互系统 - 按已确认的 GitHub 风格概念稿统一六个页面:明暗主画布、更清楚的页面标题、 diff --git a/docs/wiki/User-Guide.md b/docs/wiki/User-Guide.md index a49a31c..702ff33 100644 --- a/docs/wiki/User-Guide.md +++ b/docs/wiki/User-Guide.md @@ -28,7 +28,7 @@ empty Workspace, then recent resources and confirmed publication metadata. | Page | Purpose | | --- | --- | -| `/auth` | Connection, token, delivery status, cloud reload, migration, and diagnostics | +| `/auth` | Connection, token, delivery status, cloud reload, device reset, migration, and diagnostics | | `/nodes` | Nodes and subscriptions, tags, search, filters, and batch import | | `/aggregate` | Rule editing, preview ordering, publish targets, and publication | | `/exports` | sing-box configuration preview, copy, download, and publication | @@ -82,6 +82,28 @@ they do not export business data or credentials. There is no browser business JSON backup/restore, local overwrite/merge, manual push, or Workspace switching. For operator procedures, see [operations and repair](../workspace-v2-operations.md). +## Start again after removing your Gist + +Disconnect removes your token but keeps this device's Workspace binding and +pending changes. Reconnecting still reads the original Gist, even when it is +unavailable. A GitHub 404 can also mean the token cannot access it. + +If you deliberately deleted the original Gist or want to abandon this device's +current connection, open Settings and choose **Reset this device**. The control +is available while signed out or when cloud loading fails. Close other SubMan +tabs, then review the confirmation: reset removes the current binding, cached +business data, and the complete current pending queue. Unconfirmed changes in +that queue will be lost. Historical queues and quarantined recovery evidence +remain available in Sync recovery; existing cloud files are unchanged. + +After a successful reset, enter your token and choose **Connect** again. SubMan +finds existing cloud data or, if none exists, initializes an empty private +Workspace. Reset itself never creates or deletes a Gist or uploads an old cache. +The local reset affects other SubMan tabs on the same site. If delivery is active, +wait for it to finish and retry; if state changes during confirmation, review the +new state before trying again. A failed storage transaction does not report a +successful reset or clear authentication. + ## Backend automation The public API supports health and node CRUD/by-key updates. Start with the diff --git a/docs/wiki/User-Guide.zh-CN.md b/docs/wiki/User-Guide.zh-CN.md index b6d1eeb..8dc2c64 100644 --- a/docs/wiki/User-Guide.zh-CN.md +++ b/docs/wiki/User-Guide.zh-CN.md @@ -22,7 +22,7 @@ SubMan 查找描述为 `SubMan-Data`、包含权威文档 `subman.json` 的私 | 页面 | 用途 | | --- | --- | -| `/auth` | 连接、Token、发送状态、云端重载、迁移和诊断 | +| `/auth` | 连接、Token、发送状态、云端重载、设备重置、迁移和诊断 | | `/nodes` | 节点与订阅、标签、搜索、过滤、批量导入 | | `/aggregate` | 规则编辑、预览排序、发布目标与发布 | | `/exports` | sing-box 配置预览、复制、下载和发布 | @@ -63,6 +63,21 @@ SubMan 查找描述为 `SubMan-Data`、包含权威文档 `subman.json` 的私 浏览器不提供业务 JSON 备份/恢复、本地覆盖/合并、手动推送或工作区切换。 操作人员的修复步骤见[运维与恢复](../workspace-v2-operations.zh-CN.md)。 +## 删除 Gist 后重新开始 + +断开连接只清除 Token,保留此设备的工作区绑定和待确认变更。重新连接仍会读取原 Gist, +不会因其不可用而自动换一个。GitHub 返回 404 也可能表示 Token 无权访问它。 + +如果已主动删除原 Gist,或决定放弃此设备当前的连接,可在设置中选择**重置此设备**。 +退出登录或云端加载失败时也能使用这个入口。先关闭其他 SubMan 标签页,再检查确认说明: +重置会清除当前绑定、本机业务缓存和当前完整待发送队列,队列中尚未确认的变更会丢失。 +历史队列与已隔离的修复证据仍保留在“同步恢复”中,已有云端文件不变。 + +重置成功后,重新输入 Token 并点击**连接**。SubMan 会查找已有云端数据;不存在时, +初始化空的私有工作区。重置本身不会创建或删除 Gist,也不会上传旧缓存。 +本地重置会影响同一站点的其他 SubMan 标签页。若有变更正在发送,等待其结束后重试; +若确认期间状态发生变化,应重新检查后再操作。存储事务失败时不会报告重置成功或清除认证。 + ## 后端自动化 公共 API 支持健康检查和节点 CRUD/按外部键更新。参阅 diff --git a/docs/workspace-v2-operations.md b/docs/workspace-v2-operations.md index 101429f..ef57658 100644 --- a/docs/workspace-v2-operations.md +++ b/docs/workspace-v2-operations.md @@ -15,6 +15,8 @@ rollback for the Workspace Schema V2 coordinator. - The browser has one cloud binding, with no Workspace list or switching. Both rebind and queue-repair transactions reject replacing an active binding with another Gist, including competing browser tabs and legacy recovery paths. + A confirmed device reset may explicitly remove the binding before a separate + fresh connection; it never selects or creates a replacement Gist itself. - Startup loads the latest cloud document before enabling business pages. Login and token replacement retain the existing Gist identity; a failed lookup must never fall through to another Gist or create a new one. An ambiguous initial @@ -276,6 +278,39 @@ discarded; timestamps never authorize overwrite and remote tombstones stay protected. Logout clears authentication and stops delivery without deleting the binding, cache, pending mutation identities, or recovery evidence. +## Device Reset After An Unavailable Gist + +Ordinary reconnect remains pinned to the original Gist. A 404 does not prove +deletion: it may also reflect missing access. First check the token and original +Gist if recovery is intended. If the user deliberately removed it or chooses to +abandon the current local connection, Settings offers **Reset this device** even +without authentication or a successful cloud load. + +The user must confirm loss of the current cached business snapshot and complete +active queue. Close other SubMan tabs before confirming. In one +`WorkspacePersistence` transaction, reset compares the inspected binding, +snapshot, and active queue, rejects an unexpired active dispatcher lease, clears +that binding and complete queue, and writes an empty unbound snapshot. It retains +historical orphan queues, quarantine metadata and inaccessible raw evidence, and +the monotonically allocated fencing counter. It records completed migration so +legacy localStorage cannot restore the abandoned binding or cache. + +The initiating tab clears authentication only after the transaction commits. +Other same-origin tabs refresh their persistent state; delayed cloud reads, +captured queue heads, and delivery acknowledgements cannot restore the old +binding. Persisted compare-and-swap and fencing checks enforce this even when +cross-tab notifications are unavailable. An active-delivery or concurrent-change +rejection requires waiting or refreshing and a new confirmation; unavailable or +failed storage remains fail-closed without a success report. + +Reset sends no GitHub or coordinator mutation requests, deletes no cloud files, +and does not reconnect automatically. The user subsequently enters a token and +chooses **Connect**. Unbound discovery then loads existing cloud data or creates +an empty private bootstrap Gist and initializes it through the coordinator. The +discarded browser cache is never uploaded as business authority. Safe historical +queue evidence remains in Sync recovery and is never automatically rebound or +delivered. + ## Leases, Retry, And Upstream Failures Each Workspace dispatcher acquires a persisted lease with a random owner ID, diff --git a/docs/workspace-v2-operations.zh-CN.md b/docs/workspace-v2-operations.zh-CN.md index a1680de..aa94f5a 100644 --- a/docs/workspace-v2-operations.zh-CN.md +++ b/docs/workspace-v2-operations.zh-CN.md @@ -11,7 +11,8 @@ - 所有能改变配置的浏览器和 Server API mutation 经过协调器;公共 API 契约不变, 浏览器 mutation 是内部协议,页面/API 不直接 PATCH 配置。 - 浏览器只绑定一个云端 Gist,没有工作区列表/切换。重绑和队列修复事务也拒绝替换已有绑定, - 包括跨标签页与旧恢复路径。 + 包括跨标签页与旧恢复路径。用户确认的设备重置可先明确移除绑定,再单独重新连接; + 重置本身不选择或新建替代 Gist。 - 启动先读取最新云端再开放业务编辑;登录/替换 token 保留原 ID。 原 Gist 查询失败不能另选/新建;初次发现多份候选必须填写原 ID。 - `subman-workspace` IndexedDB v1 通过 `WorkspacePersistence` 在同一事务中保存缓存、 @@ -180,6 +181,29 @@ Token 不进入该数据库。默认 sessionStorage;明确选择 Remember toke domain conflict/修复证据继续阻塞;时间戳不赋予覆盖权,墓碑仍有效。 退出登录只清认证并停止发送,不删绑定、缓存、mutation 身份或证据。 +## 原 Gist 不可用时重置设备 + +普通重新连接继续锁定原 Gist。404 不能证明它已删除,也可能是缺少访问权限; +若希望恢复原数据,应先检查 Token 和原 Gist。用户主动删除原 Gist,或决定放弃当前本地连接时, +可在设置中选择**重置此设备**,无需先登录或成功加载云端。 + +用户必须确认丢弃当前本机业务缓存和完整当前队列,建议先关闭其他 SubMan 标签页。 +重置通过一个 `WorkspacePersistence` 事务比较已检查的 binding、snapshot 和当前 queue, +拒绝尚未到期的当前 dispatcher 租约,然后清除当前绑定与完整队列,并写入空的未绑定快照。 +历史 orphan 队列、隔离元数据与不可直接访问的原始证据、单调分配的 fencing 计数继续保留。 +迁移状态标记为完成,避免旧 localStorage 重新恢复已放弃的绑定或缓存。 + +发起重置的标签页仅在事务提交后清除认证;同源其他标签页重读持久状态。 +延迟返回的云端读取、已捕获的队列头和发送回执不得恢复旧绑定,即使跨标签页通知不可用, +持久 compare-and-swap 与 fencing 校验也必须保证这一点。 +发送中或并发变化导致拒绝时,应等待或刷新后重新确认;存储不可用或失败时保持关闭编辑, +不报告成功。 + +重置不发送 GitHub 或协调器 mutation 请求,不删除云端文件,也不自动重新连接。 +用户随后重新输入 Token 并点击**连接**,未绑定发现流程才会加载已有云端数据, +或创建空的私有 bootstrap Gist 并由协调器完成初始化;已丢弃的浏览器缓存不会成为上传来源。 +历史队列的安全证据仍可在“同步恢复”中查看,不会自动重绑或发送。 + ## 租约、重试和上游故障 dispatcher 持久租约含随机 owner、单调 fencing token、到期和 heartbeat; diff --git a/e2e/workspace-reset.spec.ts b/e2e/workspace-reset.spec.ts new file mode 100644 index 0000000..1984d77 --- /dev/null +++ b/e2e/workspace-reset.spec.ts @@ -0,0 +1,502 @@ +import { type BrowserContext, expect, type Page, test } from "@playwright/test"; +import { seedUiWorkspace } from "./ui-workspace-fixture"; + +type JsonRecord = Record; + +const GIST_ID = "accessibility-cloud"; +const WORKSPACE_ID = `gist:${GIST_ID}`; +const ORPHAN_ID = "gist:retained-previous"; +const NEW_GIST_ID = "new-empty-workspace"; +const NOW = "2026-10-23T10:00:00.000Z"; + +async function readRecord(page: Page): Promise { + return page.evaluate( + () => + new Promise((resolve, reject) => { + const request = indexedDB.open("subman-workspace", 1); + request.onerror = () => reject(request.error); + request.onsuccess = () => { + const database = request.result; + const transaction = database.transaction( + "workspace-state", + "readonly", + ); + const read = transaction.objectStore("workspace-state").get("root"); + read.onsuccess = () => resolve(read.result); + read.onerror = () => reject(read.error); + transaction.oncomplete = () => database.close(); + }; + }), + ); +} + +async function seedResetWorkspace(page: Page, context: BrowserContext) { + await seedUiWorkspace(page, context); + await page.evaluate( + async ({ workspaceId, orphanId, now }) => { + const database = await new Promise((resolve, reject) => { + const request = indexedDB.open("subman-workspace", 1); + request.onsuccess = () => resolve(request.result); + request.onerror = () => reject(request.error); + }); + await new Promise((resolve, reject) => { + const transaction = database.transaction( + "workspace-state", + "readwrite", + ); + const store = transaction.objectStore("workspace-state"); + const read = store.get("root"); + read.onsuccess = () => { + const record = read.result; + const queue = (id: string, mutationId: string) => { + const mutation = { + mutationId, + workspaceId: id, + expectedRevision: 0, + source: "browser", + createdAt: now, + kind: "node.delete", + payload: { id: "accessibility-node" }, + }; + return { + workspaceId: id, + mutations: [mutation], + delivery: { + retry: { attempt: 0, nextAttemptAt: null, lastErrorCode: null }, + blocked: { + mutationId, + kind: mutation.kind, + code: "mutation_recovery_failed", + disposition: "operator-repair", + messageKey: "workspace.operator-repair", + createdAt: now, + blockedAt: now, + }, + deadLetters: [], + }, + }; + }; + record.workspaces = { + [workspaceId]: queue( + workspaceId, + "a0000000-0000-4000-8000-000000000001", + ), + [orphanId]: queue(orphanId, "a0000000-0000-4000-8000-000000000002"), + }; + record.quarantines = [ + { + id: "retained-evidence", + source: "queue:retained-previous", + reason: "queue-corruption", + bytes: 2, + createdAt: now, + }, + ]; + record.quarantinePayloads = { "retained-evidence": "{}" }; + record.nextFencingToken = 40; + store.put(record, "root"); + }; + transaction.oncomplete = () => resolve(); + transaction.onerror = () => reject(transaction.error); + transaction.onabort = () => reject(transaction.error); + }); + database.close(); + }, + { workspaceId: WORKSPACE_ID, orphanId: ORPHAN_ID, now: NOW }, + ); +} + +async function mockDeletedCloud(context: BrowserContext) { + const requests: Array<{ method: string; path: string; body?: JsonRecord }> = + []; + let files: Record = {}; + await context.route("https://api.github.com/**", async (route) => { + const request = route.request(); + const path = new URL(request.url()).pathname; + const method = request.method(); + const body = method === "POST" ? request.postDataJSON() : undefined; + requests.push({ method, path, body }); + if (path === `/gists/${GIST_ID}`) { + await route.fulfill({ status: 404, json: { message: "Not Found" } }); + return; + } + if (method === "GET" && path === "/gists") { + await route.fulfill({ json: [] }); + return; + } + if (method === "POST" && path === "/gists") { + files = body?.files as Record; + } + if ( + (method === "POST" && path === "/gists") || + (method === "GET" && path === `/gists/${NEW_GIST_ID}`) + ) { + await route.fulfill({ + json: { + id: NEW_GIST_ID, + owner: { login: "e2e" }, + description: "SubMan-Data", + updated_at: NOW, + html_url: `https://gist.github.com/e2e/${NEW_GIST_ID}`, + files: Object.fromEntries( + Object.entries(files).map(([filename, file]) => [ + filename, + { + filename, + raw_url: `https://gist.githubusercontent.com/e2e/${NEW_GIST_ID}/raw/${filename}`, + size: new TextEncoder().encode(file.content).byteLength, + content: file.content, + truncated: false, + }, + ]), + ), + }, + }); + return; + } + await route.abort("blockedbyclient"); + }); + await context.route("**/api/workspaces/**/mutations", async (route) => { + const request = route.request(); + const mutation = request.postDataJSON(); + requests.push({ + method: request.method(), + path: new URL(request.url()).pathname, + body: mutation, + }); + const document = { + version: 2, + schemaVersion: 2, + workspaceId: mutation.workspaceId, + revision: mutation.expectedRevision + 1, + updatedAt: mutation.createdAt, + lastMutationId: mutation.mutationId, + data: mutation.payload.data, + tombstones: { + nodes: [], + subscriptions: [], + aggregates: [], + publishTargets: [], + clientExports: [], + }, + }; + files = { "subman.json": { content: JSON.stringify(document) } }; + await route.fulfill({ + json: { + status: "committed", + mutationId: mutation.mutationId, + workspaceId: mutation.workspaceId, + committedRevision: document.revision, + committedAt: document.updatedAt, + receipt: { kind: mutation.kind }, + document, + }, + }); + }); + return requests; +} + +test("canceling device reset preserves the unavailable binding, current queue, and credentials", async ({ + page, + context, +}) => { + await seedResetWorkspace(page, context); + const requests = await mockDeletedCloud(context); + await page.goto("/auth"); + const action = page.getByTestId("device-reset-action"); + await expect(action).toBeEnabled(); + await expect(page.getByTestId("total-queue-count")).toHaveText("2"); + const before = await readRecord(page); + await action.click(); + const dialog = page.getByRole("dialog", { + name: "Reset this device", + exact: true, + }); + await expect(dialog).toContainText("Cloud data is preserved."); + await dialog.getByRole("button", { name: "Cancel", exact: true }).click(); + await expect(dialog).toHaveCount(0); + expect(await readRecord(page)).toEqual(before); + expect( + await page.evaluate(() => sessionStorage.getItem("subman:auth:session:v2")), + ).toContain("fixture-accessibility-token"); + expect(requests.filter((request) => request.method !== "GET")).toEqual([]); +}); + +test("explicit reset clears only the current Workspace and permits fresh empty initialization", async ({ + page, + context, +}) => { + await seedResetWorkspace(page, context); + const requests = await mockDeletedCloud(context); + await page.goto("/auth"); + await expect(page.getByTestId("device-reset-action")).toBeEnabled(); + await page.getByRole("button", { name: "Disconnect", exact: true }).click(); + await page + .getByLabel("Personal access token", { exact: true }) + .fill("fixture-reconnect-token"); + await page.getByRole("button", { name: "Connect", exact: true }).click(); + await expect(page.getByTestId("workspace-connection-notice")).toBeVisible(); + expect( + requests.every((request) => request.path === `/gists/${GIST_ID}`), + ).toBe(true); + const before = await readRecord(page); + await page.getByTestId("device-reset-action").click(); + await page + .getByRole("dialog", { name: "Reset this device", exact: true }) + .getByRole("button", { name: "Reset this device", exact: true }) + .click(); + await expect(page.getByTestId("device-reset-notice")).toHaveText( + "Device reset. Connect again to load cloud data or create an empty Workspace.", + ); + const reset = await readRecord(page); + expect(reset.binding).toBeNull(); + expect((reset.snapshot as JsonRecord).activeGistId).toBeNull(); + expect((reset.snapshot as JsonRecord).nodes).toEqual([]); + expect((reset.workspaces as JsonRecord)[WORKSPACE_ID]).toBeUndefined(); + expect((reset.workspaces as JsonRecord)[ORPHAN_ID]).toEqual( + (before.workspaces as JsonRecord)[ORPHAN_ID], + ); + expect(reset.quarantines).toEqual(before.quarantines); + expect(reset.quarantinePayloads).toEqual(before.quarantinePayloads); + expect(reset.nextFencingToken).toBe(before.nextFencingToken); + expect(requests.filter((request) => request.method !== "GET")).toEqual([]); + await page.reload(); + await expect( + page.getByLabel("Workspace Gist ID (optional)", { exact: true }), + ).toBeVisible(); + await expect( + page.getByLabel("Personal access token", { exact: true }), + ).toHaveValue(""); + expect((await readRecord(page)).binding).toBeNull(); + await page + .getByLabel("Personal access token", { exact: true }) + .fill("fixture-new-token"); + await page.getByRole("button", { name: "Connect", exact: true }).click(); + await expect( + page.getByText("Cloud data loaded.", { exact: true }), + ).toBeVisible(); + const initialized = await readRecord(page); + expect((initialized.binding as JsonRecord).gistId).toBe(NEW_GIST_ID); + expect((initialized.snapshot as JsonRecord).nodes).toEqual([]); + expect((initialized.workspaces as JsonRecord)[ORPHAN_ID]).toEqual( + (before.workspaces as JsonRecord)[ORPHAN_ID], + ); + const create = requests.filter( + (request) => request.method === "POST" && request.path === "/gists", + ); + expect(create).toHaveLength(1); + expect(Object.keys(create[0].body?.files as JsonRecord)).toEqual([ + "subman.bootstrap.json", + ]); + const mutations = requests.filter((request) => + request.path.includes("/mutations"), + ); + expect(mutations).toHaveLength(1); + expect(mutations[0].body?.workspaceId).toBe(`gist:${NEW_GIST_ID}`); + expect(mutations[0].body?.kind).toBe("workspace.reconcile"); + expect((mutations[0].body?.payload as JsonRecord).data).toEqual({ + nodes: [], + subscriptions: [], + aggregates: [], + publishTargets: [], + clientExports: [], + }); + expect( + requests.some( + (request) => request.method === "PATCH" || request.method === "DELETE", + ), + ).toBe(false); +}); + +test("signed-out mobile Chinese settings can reset an unavailable Workspace", async ({ + page, + context, +}) => { + await page.setViewportSize({ width: 390, height: 844 }); + await seedResetWorkspace(page, context); + const requests = await mockDeletedCloud(context); + await page.evaluate(() => { + sessionStorage.removeItem("subman:auth:session:v2"); + localStorage.setItem("subman:locale:v1", "zh-CN"); + }); + await page.goto("/auth"); + const action = page.getByTestId("device-reset-action"); + await expect(action).toHaveText("重置此设备"); + await expect(action).toBeEnabled(); + await expect(page.getByTestId("total-queue-count")).toHaveText("2"); + await action.click(); + const dialog = page.getByRole("dialog", { name: "重置此设备", exact: true }); + await expect(dialog).toContainText("全部未确认变更"); + await dialog.getByRole("button", { name: "重置此设备", exact: true }).click(); + await expect(page.getByTestId("device-reset-notice")).toHaveText( + "此设备已重置。请重新连接,以加载云端数据或创建空工作区。", + ); + await expect( + page.getByRole("button", { name: "连接", exact: true }), + ).toBeVisible(); + expect((await readRecord(page)).binding).toBeNull(); + expect( + await page.evaluate( + () => document.documentElement.scrollWidth <= innerWidth, + ), + ).toBe(true); + expect(requests).toEqual([]); +}); + +test("active delivery prevents reset and preserves the current browser record", async ({ + page, + context, +}) => { + await seedResetWorkspace(page, context); + const requests = await mockDeletedCloud(context); + await page.evaluate(async (workspaceId) => { + sessionStorage.removeItem("subman:auth:session:v2"); + const database = await new Promise((resolve, reject) => { + const request = indexedDB.open("subman-workspace", 1); + request.onsuccess = () => resolve(request.result); + request.onerror = () => reject(request.error); + }); + await new Promise((resolve, reject) => { + const transaction = database.transaction("workspace-state", "readwrite"); + const store = transaction.objectStore("workspace-state"); + const read = store.get("root"); + read.onsuccess = () => { + const record = read.result; + const name = `dispatcher:${workspaceId}`; + record.leases[name] = { + name, + ownerId: "another-browser-context", + fencingToken: 39, + expiresAt: Date.now() + 60_000, + heartbeatAt: Date.now(), + }; + store.put(record, "root"); + }; + transaction.oncomplete = () => resolve(); + transaction.onerror = () => reject(transaction.error); + }); + database.close(); + }, WORKSPACE_ID); + await page.goto("/auth"); + await expect(page.getByTestId("total-queue-count")).toHaveText("2"); + const before = await readRecord(page); + await page.getByTestId("device-reset-action").click(); + await page + .getByRole("dialog", { name: "Reset this device", exact: true }) + .getByRole("button", { name: "Reset this device", exact: true }) + .click(); + await expect(page.getByTestId("device-reset-notice")).toHaveText( + "Cloud delivery is active. Wait for it to finish before resetting this device.", + ); + expect(await readRecord(page)).toEqual(before); + expect(requests).toEqual([]); +}); + +test("device reset removes cached business state in another open tab", async ({ + page, + context, +}) => { + await seedUiWorkspace(page, context); + const writes: string[] = []; + context.on("request", (request) => { + if (request.method() !== "GET") writes.push(request.url()); + }); + await page.goto("/auth"); + await expect(page.locator(".app-header-link-connected")).toBeVisible(); + const peer = await context.newPage(); + await peer.goto("/__e2e_seed__"); + await peer.evaluate((now) => { + sessionStorage.setItem( + "subman:auth:session:v2", + JSON.stringify({ + version: 2, + token: "fixture-peer-token", + lastLoginAt: now, + }), + ); + }, NOW); + await peer.goto("/nodes"); + await expect( + peer.getByRole("button", { name: "Accessibility Node", exact: true }), + ).toBeVisible(); + await page.getByTestId("device-reset-action").click(); + await page + .getByRole("dialog", { name: "Reset this device", exact: true }) + .getByRole("button", { name: "Reset this device", exact: true }) + .click(); + await expect(page.getByTestId("device-reset-notice")).toHaveText( + "Device reset. Connect again to load cloud data or create an empty Workspace.", + ); + await expect( + peer.getByRole("button", { name: "Accessibility Node", exact: true }), + ).toHaveCount(0); + await expect( + peer.getByRole("button", { name: "Edit node", exact: true }), + ).toHaveCount(0); + const peerRecord = await readRecord(peer); + expect(peerRecord.binding).toBeNull(); + expect((peerRecord.snapshot as JsonRecord).nodes).toEqual([]); + expect(writes).toEqual([]); + await peer.close(); +}); + +test("reset remains reachable when browser persistence initialization fails", async ({ + page, + context, +}) => { + await seedResetWorkspace(page, context); + const requests = await mockDeletedCloud(context); + await context.addInitScript(() => { + Object.defineProperty(window, "indexedDB", { + configurable: true, + value: undefined, + }); + }); + await page.goto("/auth"); + const action = page.getByTestId("device-reset-action"); + await expect(action).toBeEnabled(); + await action.click(); + await expect(page.getByTestId("device-reset-notice")).toHaveText( + "Device reset could not be confirmed. Check browser storage access, reload Settings, and review the connection before retrying.", + ); + await expect(page.getByRole("dialog")).toHaveCount(0); + expect( + await page.evaluate(() => sessionStorage.getItem("subman:auth:session:v2")), + ).toContain("fixture-accessibility-token"); + expect(requests).toEqual([]); +}); + +test("a token storage failure does not report a committed device reset as rejected", async ({ + page, + context, +}) => { + await seedResetWorkspace(page, context); + const requests = await mockDeletedCloud(context); + await page.goto("/auth"); + await expect(page.getByTestId("total-queue-count")).toHaveText("2"); + await page.evaluate(() => { + const removeItem = Storage.prototype.removeItem; + Storage.prototype.removeItem = function (key: string) { + if (key === "subman:auth:v2" || key === "subman:auth:session:v2") { + throw new DOMException("Fixture denied token removal", "SecurityError"); + } + removeItem.call(this, key); + }; + }); + await page.getByTestId("device-reset-action").click(); + await page + .getByRole("dialog", { name: "Reset this device", exact: true }) + .getByRole("button", { name: "Reset this device", exact: true }) + .click(); + await expect(page.getByTestId("device-reset-notice")).toHaveText( + "Device reset completed, but saved token removal could not be confirmed. Check browser storage access before reconnecting.", + ); + expect((await readRecord(page)).binding).toBeNull(); + await expect( + page.getByLabel("Personal access token", { exact: true }), + ).toBeVisible(); + expect( + await page.evaluate(() => sessionStorage.getItem("subman:auth:session:v2")), + ).toContain("fixture-accessibility-token"); + expect(requests.filter((request) => request.method !== "GET")).toEqual([]); +}); diff --git a/src/lib/i18n.ts b/src/lib/i18n.ts index a871441..7dcc955 100644 --- a/src/lib/i18n.ts +++ b/src/lib/i18n.ts @@ -7,6 +7,23 @@ const STORAGE_KEY = "subman:locale:v1"; const DEFAULT_LOCALE: Locale = "en"; const zhCN: Record = { + "Reset this device": "重置此设备", + "If the original Gist was deleted or this browser cannot reconnect, reset its Workspace connection and start setup again.": + "如果原 Gist 已删除,或此浏览器无法重新连接,可重置此设备的工作区连接后重新设置。", + "Reset removes this browser's Workspace connection and cached data and discards unconfirmed changes. Cloud data is preserved. Close other SubMan tabs first.": + "重置会移除此浏览器的工作区连接和缓存,并丢弃未确认的变更,云端数据会保留。请先关闭其他 SubMan 标签页。", + "Reset this browser's Workspace connection and cached data, and discard all unconfirmed changes? Cloud data is preserved. Close other SubMan tabs before continuing.": + "是否重置此浏览器的工作区连接和缓存,并丢弃全部未确认变更?云端数据会保留。请先关闭其他 SubMan 标签页再继续。", + "Device reset. Connect again to load cloud data or create an empty Workspace.": + "此设备已重置。请重新连接,以加载云端数据或创建空工作区。", + "Device reset completed, but saved token removal could not be confirmed. Check browser storage access before reconnecting.": + "设备重置已完成,但无法确认已保存的 Token 是否移除。请检查浏览器存储权限后再重新连接。", + "Cloud delivery is active. Wait for it to finish before resetting this device.": + "当前仍在发送云端变更,请等待发送结束后再重置此设备。", + "Workspace changed while reset was being confirmed. Review its current state and try again.": + "确认重置期间工作区已发生变化。请查看当前状态后重试。", + "Device reset could not be confirmed. Check browser storage access, reload Settings, and review the connection before retrying.": + "无法确认设备重置结果。请检查浏览器存储权限、重新加载设置,并查看连接状态后再重试。", "Save a target, then publish the rule output to its file.": "保存目标后,可将规则输出发布到对应文件。", "Manage nodes and subscription sources.": "管理节点与订阅来源。", @@ -25,6 +42,7 @@ const zhCN: Record = { "e.g. domestic, bypass": "例如 domestic, bypass", Settings: "设置", + Connect: "连接", Title: "名称", Actions: "操作", Kind: "类型", diff --git a/src/lib/workspace-browser-session-v2.test.ts b/src/lib/workspace-browser-session-v2.test.ts index 30482da..af30373 100644 --- a/src/lib/workspace-browser-session-v2.test.ts +++ b/src/lib/workspace-browser-session-v2.test.ts @@ -24,6 +24,7 @@ import { } from "$lib/workspace-mutation"; import { InMemoryWorkspacePersistence, + WorkspaceConcurrentUpdateError, type WorkspacePersistenceRecord, workspaceDispatcherLeaseName, } from "$lib/workspace-persistence"; @@ -269,6 +270,73 @@ async function seed( } describe("browser Workspace V2 session", () => { + for (const previouslyBound of [false, true]) { + it(`does not restore a reset device during ${previouslyBound ? "bound" : "unbound"} compatibility snapshot acceptance`, async () => { + class ResetBeforeSnapshotCommit extends InMemoryWorkspacePersistence { + resetBeforeCommit = false; + async resetBeforeWrite() { + if (!this.resetBeforeCommit) return; + this.resetBeforeCommit = false; + const record = await this.read(); + await this.resetWorkspace({ + expected: { + snapshot: record.snapshot, + binding: record.binding, + queue: record.workspaces["gist:gist-1"] ?? null, + }, + }); + } + override async repairWorkspaceQueue( + input: Parameters< + InMemoryWorkspacePersistence["repairWorkspaceQueue"] + >[0], + ) { + await this.resetBeforeWrite(); + return super.repairWorkspaceQueue(input); + } + override async discardWorkspaceQueue( + input: Parameters< + InMemoryWorkspacePersistence["discardWorkspaceQueue"] + >[0], + ) { + await this.resetBeforeWrite(); + return super.discardWorkspaceQueue(input); + } + } + const persistence = new ResetBeforeSnapshotCommit(); + const before = document(); + if (previouslyBound) + await persistence.rebindWorkspace({ + snapshot: stateFor(before), + binding: createWorkspaceV2LocalState("gist-1", { baseline: before }), + }); + persistence.resetBeforeCommit = true; + let published = false; + let failure: unknown; + try { + const remote = document(2); + await persistBrowserWorkspaceSnapshot( + { origin: "v2", document: remote, state: stateFor(remote) }, + "gist-1", + "automatic", + { + persistence, + getState: () => stateFor(before), + setState: () => { + published = true; + }, + }, + ); + } catch (error) { + failure = error; + } + expect(failure instanceof WorkspaceConcurrentUpdateError).toBe(true); + expect(published).toBe(false); + expect((await persistence.read()).binding).toBeNull(); + expect((await persistence.read()).snapshot?.nodes).toEqual([]); + }); + } + it("retains a migration request durably and reuses its ID on retry", async () => { class PeerAfterRepairPersistence extends InMemoryWorkspacePersistence { override async repairWorkspaceQueue( diff --git a/src/lib/workspace-browser-session-v2.ts b/src/lib/workspace-browser-session-v2.ts index 0ed3aab..13dcb6b 100644 --- a/src/lib/workspace-browser-session-v2.ts +++ b/src/lib/workspace-browser-session-v2.ts @@ -30,6 +30,7 @@ import { WorkspaceConcurrentUpdateError, type WorkspaceMutationDraft, type WorkspacePersistenceRecord, + type WorkspaceResetExpectation, } from "$lib/workspace-persistence"; import { getBrowserWorkspacePersistence, @@ -697,14 +698,25 @@ export async function persistBrowserWorkspaceSnapshot( snapshot.document, gistId, ); + const expected = { + snapshot: record.snapshot, + binding: record.binding, + queue: record.workspaces[binding.workspaceId] ?? null, + }; if (record.binding?.workspaceId === binding.workspaceId) { await persistence.discardWorkspaceQueue({ workspaceId: binding.workspaceId, snapshot: state, binding, + expected, }); } else { - await persistence.rebindWorkspace({ snapshot: state, binding }); + await persistence.repairWorkspaceQueue({ + snapshot: state, + binding, + mutations: [], + expected, + }); } publishState(dependencies, state); await readPersistence(dependencies, persistence); @@ -721,6 +733,7 @@ async function reconcileBrowserWorkspaceInternal( replacePending?: boolean; migrationSourceSha256?: string; migrationMutationId?: string; + expected?: WorkspaceResetExpectation; }, dependencies: BrowserWorkspaceSessionDependencies = {}, ): Promise { @@ -843,7 +856,16 @@ async function reconcileBrowserWorkspaceInternal( ); let rebindError: unknown = null; try { - await persistence.rebindWorkspace({ snapshot: state, binding }); + await persistence.repairWorkspaceQueue({ + snapshot: state, + binding, + mutations: [], + expected: { + snapshot: record.snapshot, + binding: record.binding, + queue: record.workspaces[workspaceId] ?? null, + }, + }); } catch (error) { rebindError = error; } @@ -913,7 +935,7 @@ async function reconcileBrowserWorkspaceInternal( snapshot: state, binding, mutations: [mutation], - expected: { + expected: input.expected ?? { snapshot: record.snapshot, binding: record.binding, queue: record.workspaces[workspaceId] ?? null, @@ -954,6 +976,7 @@ export async function migrateBrowserWorkspace( gistId: string; snapshot: BrowserWorkspaceSnapshot; retryMutationId?: string; + expected?: WorkspaceResetExpectation; }, dependencies: BrowserWorkspaceSessionDependencies = {}, ): Promise { @@ -969,6 +992,7 @@ export async function migrateBrowserWorkspace( syncMode: "automatic", migrationSourceSha256: input.snapshot.legacySourceSha256, migrationMutationId: input.retryMutationId, + expected: input.expected, }, dependencies, ); @@ -985,6 +1009,7 @@ export async function reconcileBrowserWorkspace( resolvedState: AppState; syncMode: Exclude; replacePending?: boolean; + expected?: WorkspaceResetExpectation; }, dependencies: BrowserWorkspaceSessionDependencies = {}, ): Promise { diff --git a/src/lib/workspace-cloud-session.test.ts b/src/lib/workspace-cloud-session.test.ts index 6400c09..271ea31 100644 --- a/src/lib/workspace-cloud-session.test.ts +++ b/src/lib/workspace-cloud-session.test.ts @@ -144,6 +144,31 @@ function deferred() { } describe("cloud Workspace session", () => { + it("does not restore a binding when a pre-reset cloud read completes without a peer event", async () => { + const store = persistence(); + const readStarted = deferred(); + const remote = deferred(); + const session = setup(store, async () => { + readStarted.resolve(); + return remote.promise; + }); + const loading = session.refreshCloudWorkspace("fixture-token"); + await readStarted.promise; + const before = await store.read(); + await store.resetWorkspace({ + expected: { + snapshot: before.snapshot, + binding: before.binding, + queue: before.workspaces[WORKSPACE_ID] ?? null, + }, + }); + remote.resolve(snapshot(document(2, [node("old-cloud-response")]))); + expect(await loading).toBe(false); + expect((await store.read()).binding).toBeNull(); + expect((await store.read()).snapshot?.nodes).toEqual([]); + expect(session.status().phase).not.toBe("ready"); + }); + it("revalidates only the saved cloud Gist and replaces the browser cache", async () => { const store = persistence(); const calls: string[] = []; diff --git a/src/lib/workspace-cloud-session.ts b/src/lib/workspace-cloud-session.ts index 4bf1f9a..58cd139 100644 --- a/src/lib/workspace-cloud-session.ts +++ b/src/lib/workspace-cloud-session.ts @@ -136,7 +136,11 @@ export function createCloudWorkspaceSession( setStatus({ phase: "error", message: MIGRATION_MESSAGE }); return false; } - await controller.refreshCloud(snapshot, gistId); + await controller.refreshCloud(snapshot, gistId, { + snapshot: view.record.snapshot, + binding: view.record.binding, + queue: view.record.workspaces[workspaceId] ?? null, + }); if (!isCurrent()) return false; setStatus({ phase: "ready", message: null }); return true; diff --git a/src/lib/workspace-events.ts b/src/lib/workspace-events.ts index 3690ae1..d3b5f80 100644 --- a/src/lib/workspace-events.ts +++ b/src/lib/workspace-events.ts @@ -6,6 +6,7 @@ const FALLBACK_EVENT = "subman:workspace-message"; export type WorkspaceEvent = { type: | "reset" + | "device-reset" | "paused-conflict" | "mutation-queue-changed" | "workspace-v2-committed"; diff --git a/src/lib/workspace-mutation-sync-browser.test.ts b/src/lib/workspace-mutation-sync-browser.test.ts index e8d880f..d5a50f1 100644 --- a/src/lib/workspace-mutation-sync-browser.test.ts +++ b/src/lib/workspace-mutation-sync-browser.test.ts @@ -742,7 +742,9 @@ describe("browser Workspace mutation scheduler", () => { } }); - it("refreshes persisted state for queue, commit, and conflict wake events before scheduling", async () => { + it("refreshes persisted state for queue, commit, conflict, and device reset wake events before scheduling", async () => { + const statusModule = await import("$lib/workspace-sync-status"); + const { get } = await import("svelte/store"); const [workspaceData, persistenceModule, stateModule, sync] = await Promise.all([ import("$lib/workspace-data"), @@ -750,21 +752,28 @@ describe("browser Workspace mutation scheduler", () => { import("$lib/workspace-v2-state"), import("$lib/workspace-mutation-sync-browser"), ]); - const snapshots = ["queue", "commit", "conflict"].map((name, index) => ({ - ...stateModule.hydrateAppStateFromWorkspaceDocument( - workspaceData.createDefaultWorkspaceState(NOW), - document(1), - GIST_ID, - ), - lastUpdated: `${NOW}:${index}:${name}`, - })); + const snapshots = ["queue", "commit", "conflict", "reset"].map( + (name, index) => ({ + ...(name === "reset" + ? workspaceData.createDefaultWorkspaceState(NOW) + : stateModule.hydrateAppStateFromWorkspaceDocument( + workspaceData.createDefaultWorkspaceState(NOW), + document(1), + GIST_ID, + )), + lastUpdated: `${NOW}:${index}:${name}`, + }), + ); const records = snapshots.map((snapshot, index) => { const record = persistenceModule.createEmptyWorkspacePersistenceRecord(); record.snapshot = snapshot; - record.binding = stateModule.createWorkspaceV2LocalState(GIST_ID, { - baseline: document(1), - syncMode: index === 2 ? "paused-conflict" : "automatic", - }); + record.binding = + index === 3 + ? null + : stateModule.createWorkspaceV2LocalState(GIST_ID, { + baseline: document(1), + syncMode: index === 2 ? "paused-conflict" : "automatic", + }); return record; }); const persistence = new persistenceModule.InMemoryWorkspacePersistence( @@ -810,10 +819,18 @@ describe("browser Workspace mutation scheduler", () => { gistId: GIST_ID, fileName: "subman.json", }, + { type: "device-reset", gistId: null, fileName: null }, ]; try { for (const [index, event] of wakeEvents.entries()) { + if (event.type === "device-reset") { + statusModule.workspaceSyncStatus.set({ + ...statusModule.defaultWorkspaceSyncStatus, + phase: "operator-repair-required", + repairRequired: true, + }); + } eventListener(event); for ( let attempt = 0; @@ -825,6 +842,8 @@ describe("browser Workspace mutation scheduler", () => { } expect(seen).toEqual(snapshots.map((snapshot) => snapshot.lastUpdated)); expect(state).toEqual(snapshots.at(-1)); + expect(get(statusModule.workspaceSyncStatus).phase).toBe("disconnected"); + expect(get(statusModule.workspaceSyncStatus).repairRequired).toBe(false); } finally { stop(); } diff --git a/src/lib/workspace-mutation-sync-browser.ts b/src/lib/workspace-mutation-sync-browser.ts index 1b328b5..129de32 100644 --- a/src/lib/workspace-mutation-sync-browser.ts +++ b/src/lib/workspace-mutation-sync-browser.ts @@ -23,6 +23,7 @@ import { } from "$lib/workspace-persistence"; import { getBrowserWorkspacePersistence, + invalidateBrowserWorkspacePersistenceCache, refreshBrowserWorkspacePersistence, } from "$lib/workspace-persistence-browser"; import { dispatchPersistedWorkspaceMutation } from "$lib/workspace-persistence-dispatcher"; @@ -434,12 +435,20 @@ function startPersistenceWorkspaceMutationSync( } schedule(); }); - const refreshForWorkspaceEvent = async (): Promise => { + const refreshForWorkspaceEvent = async ( + deviceReset = false, + ): Promise => { try { const record = await refresh(); lastRecord = record; if (stopped) return; hydrate(record); + if (deviceReset) { + dispatchWorkspaceSyncEvent({ + type: "WORKSPACE_DISCONNECTED", + queue: deriveWorkspaceQueueMetrics(record), + }); + } reportContext(record); reportPersistedBlock(record); schedule(); @@ -449,12 +458,15 @@ function startPersistenceWorkspaceMutationSync( }; const eventsUnsub = (options.subscribeEvents ?? subscribeWorkspaceEvents)( (event) => { + if (event.type === "device-reset") + invalidateBrowserWorkspacePersistenceCache(); if ( event.type === "mutation-queue-changed" || event.type === "workspace-v2-committed" || - event.type === "paused-conflict" + event.type === "paused-conflict" || + event.type === "device-reset" ) { - void refreshForWorkspaceEvent(); + void refreshForWorkspaceEvent(event.type === "device-reset"); } }, ); diff --git a/src/lib/workspace-persistence-browser.test.ts b/src/lib/workspace-persistence-browser.test.ts index 8afa792..9ab96cd 100644 --- a/src/lib/workspace-persistence-browser.test.ts +++ b/src/lib/workspace-persistence-browser.test.ts @@ -15,7 +15,9 @@ import { getBrowserWorkspacePersistenceRecord, getBrowserWorkspaceQueueMetrics, initializeBrowserWorkspacePersistence, + invalidateBrowserWorkspacePersistenceCache, refreshBrowserWorkspacePersistence, + resetBrowserWorkspacePersistence, setBrowserWorkspacePersistenceForTest, } from "$lib/workspace-persistence-browser"; import { @@ -153,6 +155,180 @@ class DefiniteCommitFailurePersistence extends ControllableReadFailurePersistenc } } +test("device reset replaces browser caches and cached initialization with its committed record", async () => { + const record = createEmptyWorkspacePersistenceRecord(); + record.snapshot = hydrateAppStateFromWorkspaceDocument( + createDefaultWorkspaceState(NOW), + workspaceDocument(), + GIST_ID, + ); + record.binding = createWorkspaceV2LocalState(GIST_ID, { + baseline: workspaceDocument(), + }); + const persistence = new InMemoryWorkspacePersistence(record); + setBrowserWorkspacePersistenceForTest(persistence); + try { + const before = await initializeBrowserWorkspacePersistence({ + storage: new MemoryStorage(), + }); + const reset = await resetBrowserWorkspacePersistence({ + snapshot: before.snapshot, + binding: before.binding, + queue: null, + }); + expect(reset.snapshot?.activeGistId).toBeNull(); + expect(getBrowserWorkspacePersistenceRecord()).toEqual(reset); + expect(await initializeBrowserWorkspacePersistence()).toEqual(reset); + } finally { + setBrowserWorkspacePersistenceForTest(null); + } +}); + +test("a cache read started before reset cannot restore the old browser binding", async () => { + let started!: () => void; + let release!: () => void; + const reading = new Promise((resolve) => { + started = resolve; + }); + const gate = new Promise((resolve) => { + release = resolve; + }); + class DelayedReadPersistence extends InMemoryWorkspacePersistence { + delayNextRead = false; + override async read() { + const record = await super.read(); + if (this.delayNextRead) { + this.delayNextRead = false; + started(); + await gate; + } + return record; + } + } + const record = createEmptyWorkspacePersistenceRecord(); + record.snapshot = hydrateAppStateFromWorkspaceDocument( + createDefaultWorkspaceState(NOW), + workspaceDocument(), + GIST_ID, + ); + record.binding = createWorkspaceV2LocalState(GIST_ID, { + baseline: workspaceDocument(), + }); + const persistence = new DelayedReadPersistence(record); + setBrowserWorkspacePersistenceForTest(persistence); + try { + const before = await initializeBrowserWorkspacePersistence({ + storage: new MemoryStorage(), + }); + persistence.delayNextRead = true; + const pendingRead = refreshBrowserWorkspacePersistence(); + await reading; + const reset = await resetBrowserWorkspacePersistence({ + snapshot: before.snapshot, + binding: before.binding, + queue: null, + }); + release(); + expect(await pendingRead).toEqual(reset); + expect(getBrowserWorkspacePersistenceRecord()?.binding).toBeNull(); + } finally { + release(); + setBrowserWorkspacePersistenceForTest(null); + } +}); + +test("peer reset invalidation prevents an older refresh from replacing a fresh reset cache", async () => { + let started!: () => void; + let release!: () => void; + const reading = new Promise((resolve) => { + started = resolve; + }); + const gate = new Promise((resolve) => { + release = resolve; + }); + class DelayedPeerRead extends InMemoryWorkspacePersistence { + delayNextRead = false; + override async read() { + const record = await super.read(); + if (this.delayNextRead) { + this.delayNextRead = false; + started(); + await gate; + } + return record; + } + } + const record = createEmptyWorkspacePersistenceRecord(); + record.snapshot = hydrateAppStateFromWorkspaceDocument( + createDefaultWorkspaceState(NOW), + workspaceDocument(), + GIST_ID, + ); + record.binding = createWorkspaceV2LocalState(GIST_ID, { + baseline: workspaceDocument(), + }); + const persistence = new DelayedPeerRead(record); + setBrowserWorkspacePersistenceForTest(persistence); + try { + const before = await initializeBrowserWorkspacePersistence({ + storage: new MemoryStorage(), + }); + persistence.delayNextRead = true; + const pending = refreshBrowserWorkspacePersistence(); + await reading; + const reset = await persistence.resetWorkspace({ + expected: { + snapshot: before.snapshot, + binding: before.binding, + queue: null, + }, + }); + invalidateBrowserWorkspacePersistenceCache(); + expect(await refreshBrowserWorkspacePersistence()).toEqual(reset); + release(); + expect(await pending).toEqual(reset); + expect(getBrowserWorkspacePersistenceRecord()?.binding).toBeNull(); + } finally { + release(); + setBrowserWorkspacePersistenceForTest(null); + } +}); + +test("reset removes obsolete business keys without making cleanup failure a rejected reset", async () => { + const persistence = new InMemoryWorkspacePersistence(); + const storage = new MemoryStorage(); + setBrowserWorkspacePersistenceForTest(persistence); + try { + const before = await initializeBrowserWorkspacePersistence({ storage }); + const keys = [ + "subman:state:v1", + "subman:workspace-state:v2", + "subman:workspace-mutation-queue:v1", + ]; + for (const key of keys) storage.setItem(key, "obsolete-state"); + await resetBrowserWorkspacePersistence( + { snapshot: before.snapshot, binding: before.binding, queue: null }, + { storage }, + ); + for (const key of keys) expect(storage.getItem(key)).toBeNull(); + const current = await persistence.read(); + const reset = await resetBrowserWorkspacePersistence( + { snapshot: current.snapshot, binding: current.binding, queue: null }, + { + storage: { + removeItem: () => { + throw new Error("Storage unavailable"); + }, + }, + }, + ); + expect(reset.binding).toBeNull(); + expect(getBrowserWorkspacePersistenceRecord()).toEqual(reset); + } finally { + setBrowserWorkspacePersistenceForTest(null); + } +}); + test("browser persistence initializes once, hydrates, and exposes a stable adapter", async () => { const record = createEmptyWorkspacePersistenceRecord(); record.snapshot = createDefaultWorkspaceState(NOW); diff --git a/src/lib/workspace-persistence-browser.ts b/src/lib/workspace-persistence-browser.ts index 2d6d595..3af2287 100644 --- a/src/lib/workspace-persistence-browser.ts +++ b/src/lib/workspace-persistence-browser.ts @@ -7,6 +7,9 @@ import type { WorkspaceMutation } from "$lib/workspace-mutation"; import { type BrowserWorkspacePersistence, IndexedDbWorkspacePersistence, + LEGACY_APP_STATE_KEY, + LEGACY_MUTATION_QUEUE_KEY, + LEGACY_WORKSPACE_STATE_KEY, migrateLegacyWorkspacePersistence, validateWorkspacePersistenceRecord, WorkspaceConcurrentUpdateError, @@ -14,6 +17,7 @@ import { WorkspacePersistenceError, type WorkspacePersistenceRecord, WorkspaceQueueRecoveryError, + type WorkspaceResetExpectation, } from "$lib/workspace-persistence"; import { deriveWorkspaceQueueMetrics } from "$lib/workspace-queue-metrics"; import { @@ -39,6 +43,7 @@ let productionPersistence: IndexedDbWorkspacePersistence | null = null; let persistenceOverride: BrowserWorkspacePersistence | null = null; let initializePromise: Promise | null = null; let currentRecord: WorkspacePersistenceRecord | null = null; +let recordGeneration = 0; function persistence(): BrowserWorkspacePersistence { if (persistenceOverride) return persistenceOverride; @@ -89,7 +94,9 @@ function emptyQueueMetrics(): WorkspaceQueueMetrics { } async function readAndCache(): Promise { + const generation = recordGeneration; const publicRecord = await persistence().read(); + if (generation !== recordGeneration) return readAndCache(); const record = validateWorkspacePersistenceRecord({ ...publicRecord, quarantinePayloads: {}, @@ -161,6 +168,36 @@ export function setBrowserWorkspacePersistenceForTest( persistenceOverride = override; initializePromise = null; currentRecord = null; + recordGeneration += 1; +} + +export async function resetBrowserWorkspacePersistence( + expected: WorkspaceResetExpectation, + options: { storage?: Pick } = {}, +): Promise { + const record = await persistence().resetWorkspace({ expected }); + recordGeneration += 1; + currentRecord = record; + initializePromise = Promise.resolve(record); + try { + const storage = + options.storage ?? + (typeof localStorage === "undefined" ? null : localStorage); + for (const key of [ + LEGACY_APP_STATE_KEY, + LEGACY_WORKSPACE_STATE_KEY, + LEGACY_MUTATION_QUEUE_KEY, + ]) { + storage?.removeItem(key); + } + } catch { + // Confirmed migration prevents re-import even when obsolete key cleanup fails. + } + return structuredClone(record); +} + +export function invalidateBrowserWorkspacePersistenceCache(): void { + recordGeneration += 1; } export async function initializeBrowserWorkspacePersistence( diff --git a/src/lib/workspace-persistence-dispatcher.test.ts b/src/lib/workspace-persistence-dispatcher.test.ts index f465c5a..976f98e 100644 --- a/src/lib/workspace-persistence-dispatcher.test.ts +++ b/src/lib/workspace-persistence-dispatcher.test.ts @@ -183,6 +183,85 @@ async function waitUntil( } describe("persistence-backed Workspace dispatcher", () => { + it("does not submit a captured head after reset precedes lease acquisition", async () => { + const persistence = client(backend(), () => NOW_MS); + const initial = await persistence.read(); + let submitted = 0; + const resetBeforeLease = new Proxy(persistence, { + get(target, property) { + if (property === "acquireLease") + return async ( + input: Parameters[0], + ) => { + await target.resetWorkspace({ + expected: { + snapshot: initial.snapshot, + binding: initial.binding, + queue: initial.workspaces[WORKSPACE_ID] ?? null, + }, + }); + return target.acquireLease(input); + }; + const value = Reflect.get(target, property); + return typeof value === "function" ? value.bind(target) : value; + }, + }) as BrowserWorkspacePersistence; + expect( + await dispatchPersistedWorkspaceMutation({ + persistence: resetBeforeLease, + githubToken: "token", + ownerId: "tab-a", + now: () => NOW_MS, + submit: async () => { + submitted += 1; + return committed(); + }, + }), + ).toEqual({ status: "stale" }); + expect(submitted).toBe(0); + expect((await persistence.read()).binding).toBeNull(); + }); + + it("does not submit a captured head discarded before lease acquisition", async () => { + const persistence = client(backend(), () => NOW_MS); + const initial = await persistence.read(); + if (!initial.binding || !initial.snapshot) + throw new Error("Expected bound fixture"); + const initialSnapshot = initial.snapshot; + const initialBinding = initial.binding; + let submitted = 0; + const discardBeforeLease = new Proxy(persistence, { + get(target, property) { + if (property === "acquireLease") + return async ( + input: Parameters[0], + ) => { + await target.discardWorkspaceQueue({ + workspaceId: WORKSPACE_ID, + snapshot: initialSnapshot, + binding: initialBinding, + }); + return target.acquireLease(input); + }; + const value = Reflect.get(target, property); + return typeof value === "function" ? value.bind(target) : value; + }, + }) as BrowserWorkspacePersistence; + expect( + await dispatchPersistedWorkspaceMutation({ + persistence: discardBeforeLease, + githubToken: "token", + ownerId: "tab-a", + now: () => NOW_MS, + submit: async () => { + submitted += 1; + return committed(); + }, + }), + ).toEqual({ status: "stale" }); + expect(submitted).toBe(0); + }); + it("commits the head and replays the remaining optimistic queue", async () => { const second = mutation(MUTATION_ID_2, 1, NOW_2); const shared = backend(seededRecord({ mutations: [mutation(), second] })); diff --git a/src/lib/workspace-persistence-dispatcher.ts b/src/lib/workspace-persistence-dispatcher.ts index 6361d8f..97ef513 100644 --- a/src/lib/workspace-persistence-dispatcher.ts +++ b/src/lib/workspace-persistence-dispatcher.ts @@ -226,6 +226,19 @@ export async function dispatchPersistedWorkspaceMutation( ); try { + if (!(await renewFence())) return { status: "stale" }; + const beforeSubmission = await options.persistence.read(); + const activeQueue = beforeSubmission.workspaces[binding.workspaceId]; + if ( + JSON.stringify(beforeSubmission.binding) !== JSON.stringify(binding) || + JSON.stringify(activeQueue?.mutations[0]) !== JSON.stringify(mutation) || + activeQueue?.delivery.blocked || + (activeQueue?.delivery.retry.nextAttemptAt !== null && + activeQueue?.delivery.retry.nextAttemptAt !== undefined && + activeQueue.delivery.retry.nextAttemptAt > now()) + ) { + return { status: "stale" }; + } if (!(await renewFence())) return { status: "stale" }; const submissionOptions: WorkspaceMutationSubmissionOptions = { mutation, diff --git a/src/lib/workspace-persistence.test.ts b/src/lib/workspace-persistence.test.ts index 0b1c782..2845cd6 100644 --- a/src/lib/workspace-persistence.test.ts +++ b/src/lib/workspace-persistence.test.ts @@ -1,5 +1,6 @@ import { describe, expect, it } from "bun:test"; import type { AppState } from "$lib/models"; +import { createDefaultWorkspaceState } from "$lib/workspace-data"; import type { WorkspaceDocumentV2 } from "$lib/workspace-document"; import type { WorkspaceMutation } from "$lib/workspace-mutation"; import { @@ -9,6 +10,7 @@ import { IndexedDbWorkspacePersistenceBackend, InMemoryWorkspacePersistence, InMemoryWorkspacePersistenceBackend, + inspectWorkspacePersistenceRecord, LEGACY_APP_STATE_KEY, LEGACY_MUTATION_QUEUE_KEY, LEGACY_WORKSPACE_STATE_KEY, @@ -1262,6 +1264,442 @@ describe("queue inspection and repair", () => { return record; } + function resetExpected(record: WorkspacePersistenceRecord) { + const workspaceId = + record.binding?.workspaceId ?? + (record.snapshot?.activeGistId + ? `gist:${record.snapshot.activeGistId}` + : null); + return { + snapshot: record.snapshot, + binding: record.binding, + queue: workspaceId ? (record.workspaces[workspaceId] ?? null) : null, + }; + } + + it("resets the complete active queue and retains historical recovery evidence", async () => { + const record = seededRecord(); + record.workspaces[WORKSPACE_ID].mutations.push(mutation(MUTATION_ID_3, 1)); + record.workspaces[WORKSPACE_ID].delivery.blocked = { + mutationId: MUTATION_ID, + kind: "node.delete", + code: "mutation_recovery_failed", + disposition: "operator-repair", + messageKey: "workspace.operator-repair", + createdAt: NOW, + blockedAt: NOW, + }; + record.workspaces[WORKSPACE_ID].delivery.deadLetters.push({ + ...record.workspaces[WORKSPACE_ID].delivery.blocked, + mutationId: "b0000000-0000-4000-8000-000000000004", + payloadBytes: 15, + }); + record.quarantines.push({ + id: "reset-retained", + source: "legacy", + reason: "invalid-legacy-snapshot", + bytes: 9, + createdAt: NOW, + }); + record.nextFencingToken = 17; + const retained = { + ...record, + quarantinePayloads: { "reset-retained": "raw-data!" }, + }; + const persistence = new InMemoryWorkspacePersistence(retained, () => + Date.parse(NOW_2), + ); + const before = await persistence.read(); + const result = await persistence.resetWorkspace({ + expected: resetExpected(before), + }); + expect(result.snapshot).toEqual(createDefaultWorkspaceState(NOW_2)); + expect(result.binding).toBeNull(); + expect(result.workspaces[WORKSPACE_ID]).toBe(undefined); + expect(result.workspaces[OTHER_WORKSPACE_ID]).toEqual( + before.workspaces[OTHER_WORKSPACE_ID], + ); + expect(result.quarantines).toEqual(before.quarantines); + expect( + await persistence.readQuarantinePayloadForRepair("reset-retained"), + ).toBe("raw-data!"); + expect(result.nextFencingToken).toBe(17); + expect(result.migration.phase).toBe("confirmed"); + expect(result.migration.cleanupCompletedAt).toBe(NOW_2); + expect("quarantinePayloads" in result).toBe(false); + expect(await persistence.read()).toEqual(result); + }); + + it("inspects durable records without reading again and preserves explicit unbound inspection", async () => { + const persistence = new InMemoryWorkspacePersistence(seededRecord()); + const record = await persistence.read(); + expect(inspectWorkspacePersistenceRecord(record)).toEqual( + await persistence.inspectQueues(WORKSPACE_ID), + ); + expect(inspectWorkspacePersistenceRecord(record, null)).toEqual( + await persistence.inspectQueues(null), + ); + expect(inspectWorkspacePersistenceRecord(record).activeWorkspaceId).toBe( + WORKSPACE_ID, + ); + expect( + inspectWorkspacePersistenceRecord(record, null).activeWorkspaceId, + ).toBeNull(); + expect( + JSON.stringify(inspectWorkspacePersistenceRecord(record)), + ).not.toContain("node-1"); + }); + + it("forgets a snapshot-only connection and clears its whole historical active queue", async () => { + const record = seededRecord(); + record.binding = null; + const persistence = new InMemoryWorkspacePersistence(record, () => + Date.parse(NOW_2), + ); + const result = await persistence.resetWorkspace({ + expected: resetExpected(await persistence.read()), + }); + expect(result.binding).toBeNull(); + expect(result.snapshot).toEqual(createDefaultWorkspaceState(NOW_2)); + expect(result.workspaces[WORKSPACE_ID]).toBe(undefined); + expect(result.workspaces[OTHER_WORKSPACE_ID]).toEqual( + record.workspaces[OTHER_WORKSPACE_ID], + ); + }); + + it("retains completed migration evidence and unrelated dispatcher leases", async () => { + const record = seededRecord(); + record.migration = { + version: 1, + phase: "confirmed", + startedAt: NOW, + copiedAt: NOW, + validatedAt: NOW, + confirmedAt: NOW, + updatedAt: NOW, + cleanupCompletedAt: NOW, + }; + const orphanLease = workspaceDispatcherLeaseName(OTHER_WORKSPACE_ID); + record.leases[orphanLease] = { + name: orphanLease, + ownerId: "historical-owner", + fencingToken: 12, + expiresAt: Date.parse(NOW_2) + 100, + heartbeatAt: Date.parse(NOW), + }; + record.nextFencingToken = 13; + const persistence = new InMemoryWorkspacePersistence(record, () => + Date.parse(NOW_2), + ); + const result = await persistence.resetWorkspace({ + expected: resetExpected(await persistence.read()), + }); + expect(result.migration).toEqual(record.migration); + expect(result.leases[orphanLease]).toEqual(record.leases[orphanLease]); + expect(result.nextFencingToken).toBe(13); + }); + + it("rolls back every reset component at each pre-commit failure", async () => { + for (const point of [ + "before-transaction", + "after-snapshot", + "after-binding", + "after-queue", + "before-commit", + ] as const) { + const persistence = new InMemoryWorkspacePersistence(seededRecord()); + const before = await persistence.read(); + persistence.setFault(point); + expect( + ( + await captureError( + persistence.resetWorkspace({ expected: resetExpected(before) }), + ) + ).code, + ).toBe("transaction-aborted"); + expect(await persistence.read()).toEqual(before); + } + }); + + it("distinguishes repeated empty resets in one millisecond and rejects pre-reset discovery", async () => { + const record = createEmptyWorkspacePersistenceRecord(); + record.snapshot = createDefaultWorkspaceState(NOW); + const persistence = new InMemoryWorkspacePersistence(record, () => + Date.parse(NOW), + ); + const first = await persistence.resetWorkspace({ + expected: resetExpected(record), + }); + const expected = resetExpected(first); + const second = await persistence.resetWorkspace({ expected }); + expect(Date.parse(second.snapshot?.lastUpdated ?? "")).toBeGreaterThan( + Date.parse(first.snapshot?.lastUpdated ?? ""), + ); + expect( + JSON.stringify(second.snapshot) === JSON.stringify(first.snapshot), + ).toBe(false); + const error = await captureError( + persistence.repairWorkspaceQueue({ + snapshot: committedSnapshot(), + binding: binding(), + mutations: [], + expected, + }), + ); + expect(error instanceof WorkspaceConcurrentUpdateError).toBe(true); + expect(await persistence.read()).toEqual(second); + }); + + it("keeps reset snapshots strictly advancing when the clock moves backward", async () => { + const record = createEmptyWorkspacePersistenceRecord(); + record.snapshot = createDefaultWorkspaceState(NOW); + let clock = Date.parse(NOW_2); + const persistence = new InMemoryWorkspacePersistence(record, () => clock); + const first = await persistence.resetWorkspace({ + expected: resetExpected(record), + }); + clock = Date.parse(NOW) - 1000; + const second = await persistence.resetWorkspace({ + expected: resetExpected(first), + }); + expect(Date.parse(second.snapshot?.lastUpdated ?? "")).toBeGreaterThan( + Date.parse(first.snapshot?.lastUpdated ?? ""), + ); + expect(second.binding).toBeNull(); + }); + + it("rejects non-finite or unrepresentable reset timestamps without changing state", async () => { + for (const clock of [ + Number.NaN, + Number.POSITIVE_INFINITY, + Number.MAX_VALUE, + ]) { + const record = createEmptyWorkspacePersistenceRecord(); + record.snapshot = createDefaultWorkspaceState(NOW); + const persistence = new InMemoryWorkspacePersistence(record, () => clock); + const before = await persistence.read(); + const error = await captureError( + persistence.resetWorkspace({ expected: resetExpected(record) }), + ); + expect(error.code).toBe("corrupt-data"); + expect(await persistence.read()).toEqual(before); + } + const record = createEmptyWorkspacePersistenceRecord(); + record.snapshot = createDefaultWorkspaceState("9999-12-31T23:59:59.999Z"); + const persistence = new InMemoryWorkspacePersistence(record, () => + Date.parse(NOW), + ); + const before = await persistence.read(); + const error = await captureError( + persistence.resetWorkspace({ expected: resetExpected(record) }), + ); + expect(error.code).toBe("corrupt-data"); + expect(await persistence.read()).toEqual(before); + }); + + it("preserves an edit made after reset confirmation was prepared", async () => { + const persistence = manualPersistence(); + const inspected = await persistence.read(); + await persistence.commitLocalAction({ + snapshot: snapshot("newer-edit"), + binding: manualBinding(), + }); + const before = await persistence.read(); + expect( + (await captureError( + persistence.resetWorkspace({ expected: resetExpected(inspected) }), + )) instanceof WorkspaceConcurrentUpdateError, + ).toBe(true); + expect(await persistence.read()).toEqual(before); + }); + + it("preserves mutations appended after reset confirmation was prepared", async () => { + const persistence = automaticPersistence(); + const inspected = await persistence.read(); + await persistence.commitAutomaticAction({ + snapshot: committedSnapshot(), + binding: binding(), + mutation: mutationDraft(reconcileMutation()), + }); + const before = await persistence.read(); + expect( + (await captureError( + persistence.resetWorkspace({ expected: resetExpected(inspected) }), + )) instanceof WorkspaceConcurrentUpdateError, + ).toBe(true); + expect(await persistence.read()).toEqual(before); + }); + + it("preserves cloud confirmation arriving after reset confirmation was prepared", async () => { + const persistence = automaticPersistence(); + await persistence.commitAutomaticAction({ + snapshot: committedSnapshot(), + binding: binding(), + mutation: mutationDraft(reconcileMutation()), + }); + const inspected = await persistence.read(); + const fence = await acquireFence(persistence); + await persistence.commitDeliverySuccess({ + snapshot: committedSnapshot(), + binding: binding(1), + mutationId: MUTATION_ID, + fence, + }); + const before = await persistence.read(); + expect( + (await captureError( + persistence.resetWorkspace({ expected: resetExpected(inspected) }), + )) instanceof WorkspaceConcurrentUpdateError, + ).toBe(true); + expect(await persistence.read()).toEqual(before); + }); + + it("waits for active delivery and invalidates expired dispatcher fences during reset", async () => { + let now = Date.parse(NOW); + const persistence = automaticPersistence(() => now); + await persistence.commitAutomaticAction({ + snapshot: committedSnapshot(), + binding: binding(), + mutation: mutationDraft(reconcileMutation()), + }); + const fence = await acquireFence( + persistence, + WORKSPACE_ID, + "reset-owner", + now, + ); + const inspected = await persistence.read(); + const busy = await captureError( + persistence.resetWorkspace({ expected: resetExpected(inspected) }), + ); + expect(busy instanceof WorkspaceConcurrentUpdateError).toBe(true); + expect(busy.message).toBe( + "Cloud delivery is active. Wait for it to finish before resetting this device.", + ); + expect(await persistence.read()).toEqual(inspected); + now += 101; + const result = await persistence.resetWorkspace({ + expected: resetExpected(inspected), + }); + expect(result.leases[workspaceDispatcherLeaseName(WORKSPACE_ID)]).toBe( + undefined, + ); + expect(result.nextFencingToken).toBe(inspected.nextFencingToken); + expect( + await persistence.renewLease({ + name: workspaceDispatcherLeaseName(WORKSPACE_ID), + ...fence, + now, + ttlMs: 100, + }), + ).toBeNull(); + expect( + ( + await captureError( + persistence.commitDeliverySuccess({ + snapshot: committedSnapshot(), + binding: binding(1), + mutationId: MUTATION_ID, + fence, + }), + ) + ).code, + ).toBe("corrupt-data"); + expect(await persistence.read()).toEqual(result); + expect( + (await captureError( + persistence.commitAutomaticAction({ + snapshot: committedSnapshot(), + binding: binding(), + mutation: mutationDraft(reconcileMutation(MUTATION_ID_2)), + }), + )) instanceof WorkspaceConcurrentUpdateError, + ).toBe(true); + expect(await persistence.read()).toEqual(result); + }); + + it("allows a fresh Gist binding only after an explicit reset", async () => { + const persistence = automaticPersistence(); + const next = { + snapshot: committedSnapshot(OTHER_GIST_ID), + binding: binding(0, OTHER_GIST_ID), + }; + expect((await captureError(persistence.rebindWorkspace(next))).code).toBe( + "workspace_binding_locked", + ); + await persistence.resetWorkspace({ + expected: resetExpected(await persistence.read()), + }); + await persistence.rebindWorkspace(next); + expect((await persistence.read()).binding?.gistId).toBe(OTHER_GIST_ID); + }); + + it("does not resurrect legacy data after a reset", async () => { + const storage = new MemoryStorage(); + seedLegacy(storage); + const persistence = automaticPersistence(); + const reset = await persistence.resetWorkspace({ + expected: resetExpected(await persistence.read()), + }); + await migrateLegacyWorkspacePersistence(persistence, storage, { + now: () => NOW_2, + }); + expect(await persistence.read()).toEqual(reset); + expect((await persistence.read()).binding).toBeNull(); + }); + + it("returns durable reset state without requiring a later backend read", async () => { + const initial = seededRecord(); + const shared = new InMemoryWorkspacePersistenceBackend(initial); + const noReads = new Proxy(shared, { + get(target, property) { + if (property === "read") + return async () => { + throw new Error("post-commit read unavailable"); + }; + const value = Reflect.get(target, property); + return typeof value === "function" ? value.bind(target) : value; + }, + }); + const persistence = new TransactionalWorkspacePersistence(noReads, () => + Date.parse(NOW_2), + ); + const result = await persistence.resetWorkspace({ + expected: resetExpected(initial), + }); + expect(result.snapshot).toEqual(createDefaultWorkspaceState(NOW_2)); + expect(result.binding).toBeNull(); + expect(result.workspaces[WORKSPACE_ID]).toBe(undefined); + }); + + it("serializes IndexedDB resets and preserves actionable concurrency errors", async () => { + const factory = new DeterministicIdbFactory() as unknown as IDBFactory; + const first = new TransactionalWorkspacePersistence( + new IndexedDbWorkspacePersistenceBackend(factory, "reset-cas"), + ); + const second = new TransactionalWorkspacePersistence( + new IndexedDbWorkspacePersistenceBackend(factory, "reset-cas"), + ); + await first.rebindWorkspace({ + snapshot: committedSnapshot(), + binding: binding(), + }); + const expected = resetExpected(await first.read()); + const results = await Promise.allSettled([ + first.resetWorkspace({ expected }), + second.resetWorkspace({ expected }), + ]); + expect(results.map((result) => result.status)).toEqual([ + "fulfilled", + "rejected", + ]); + expect( + results[1].status === "rejected" && + results[1].reason instanceof WorkspaceConcurrentUpdateError, + ).toBe(true); + expect((await second.read()).binding).toBeNull(); + }); + it("reports active, total, orphan, blocked, and dead-letter counts", async () => { const persistence = new InMemoryWorkspacePersistence(seededRecord()); const activeFence = await acquireFence(persistence); diff --git a/src/lib/workspace-persistence.ts b/src/lib/workspace-persistence.ts index 18f8e48..21ec5d7 100644 --- a/src/lib/workspace-persistence.ts +++ b/src/lib/workspace-persistence.ts @@ -1,4 +1,5 @@ import type { AppState, GistFile, GistMeta } from "$lib/models"; +import { createDefaultWorkspaceState } from "$lib/workspace-data"; import { canonicalizeWorkspaceData, validateWorkspaceData, @@ -172,6 +173,12 @@ export type WorkspacePersistenceRecord = { nextFencingToken: number; }; +export type WorkspaceResetExpectation = { + snapshot: AppState | null; + binding: WorkspaceV2LocalState | null; + queue: PersistedWorkspaceQueue | null; +}; + type WorkspacePersistenceRoot = WorkspacePersistenceRecord & { quarantinePayloads: Record; }; @@ -271,6 +278,9 @@ export interface BrowserWorkspacePersistence { inspectQueues( activeWorkspaceId?: string | null, ): Promise; + resetWorkspace(input: { + expected: WorkspaceResetExpectation; + }): Promise; discardWorkspaceQueue(input: { workspaceId: string; snapshot?: AppState; @@ -1414,6 +1424,43 @@ function validateRetryInput( return validateRetry(value); } +export function inspectWorkspacePersistenceRecord( + record: WorkspacePersistenceRecord, + activeWorkspaceId?: string | null, +): WorkspaceQueueInspection { + const active = + activeWorkspaceId === undefined + ? (record.binding?.workspaceId ?? null) + : activeWorkspaceId; + const identity = + active === null ? null : canonicalWorkspaceId(active, "activeWorkspaceId"); + const metrics = deriveWorkspaceQueueMetrics(record, identity); + const workspaces = Object.values(record.workspaces) + .filter( + (queue) => + queue.mutations.length > 0 || + queue.delivery.blocked !== null || + queue.delivery.deadLetters.length > 0, + ) + .sort((a, b) => a.workspaceId.localeCompare(b.workspaceId)) + .map((queue) => ({ + workspaceId: queue.workspaceId, + active: queue.workspaceId === identity, + mutations: queue.mutations.map((mutation) => ({ + mutationId: mutation.mutationId, + workspaceId: mutation.workspaceId, + expectedRevision: mutation.expectedRevision, + createdAt: mutation.createdAt, + kind: mutation.kind, + payloadBytes: payloadBytes(mutation), + })), + retry: { ...queue.delivery.retry }, + blocked: queue.delivery.blocked ? { ...queue.delivery.blocked } : null, + deadLetters: queue.delivery.deadLetters.map((entry) => ({ ...entry })), + })); + return { activeWorkspaceId: identity, ...metrics, workspaces }; +} + export class TransactionalWorkspacePersistence implements BrowserWorkspacePersistence { @@ -1907,42 +1954,89 @@ export class TransactionalWorkspacePersistence async inspectQueues( activeWorkspaceId: string | null = null, ): Promise { - if (activeWorkspaceId !== null) { - activeWorkspaceId = canonicalWorkspaceId( - activeWorkspaceId, - "activeWorkspaceId", - ); - } const record = await this.read(); - const metrics = deriveWorkspaceQueueMetrics(record, activeWorkspaceId); - const workspaces = Object.values(record.workspaces) - .filter( - (queue) => - queue.mutations.length > 0 || - queue.delivery.blocked !== null || - queue.delivery.deadLetters.length > 0, - ) - .sort((a, b) => a.workspaceId.localeCompare(b.workspaceId)) - .map((queue) => ({ - workspaceId: queue.workspaceId, - active: queue.workspaceId === activeWorkspaceId, - mutations: queue.mutations.map((mutation) => ({ - mutationId: mutation.mutationId, - workspaceId: mutation.workspaceId, - expectedRevision: mutation.expectedRevision, - createdAt: mutation.createdAt, - kind: mutation.kind, - payloadBytes: payloadBytes(mutation), - })), - retry: queue.delivery.retry, - blocked: queue.delivery.blocked, - deadLetters: queue.delivery.deadLetters, - })); - return { - activeWorkspaceId, - ...metrics, - workspaces, - }; + return inspectWorkspacePersistenceRecord(record, activeWorkspaceId); + } + + async resetWorkspace(input: { + expected: WorkspaceResetExpectation; + }): Promise { + return this.backend.transact((draft, checkpoint) => { + const workspaceId = + draft.binding?.workspaceId ?? + (draft.snapshot?.activeGistId + ? canonicalWorkspaceId( + `gist:${draft.snapshot.activeGistId}`, + "workspaceId", + ) + : null); + if ( + !workspaceBindingsEqual(draft.binding, input.expected.binding) || + !persistenceValuesEqual(draft.snapshot, input.expected.snapshot) || + !persistenceValuesEqual( + workspaceId ? (draft.workspaces[workspaceId] ?? null) : null, + input.expected.queue, + ) + ) { + throw new WorkspaceConcurrentUpdateError(); + } + const now = this.nowMs(); + const lease = workspaceId + ? draft.leases[workspaceDispatcherLeaseName(workspaceId)] + : null; + if (lease && lease.expiresAt > now) { + throw new WorkspaceConcurrentUpdateError( + "Cloud delivery is active. Wait for it to finish before resetting this device.", + ); + } + const previousTime = Date.parse(draft.snapshot?.lastUpdated ?? ""); + const resetTime = Math.max( + now, + Number.isFinite(previousTime) ? previousTime + 1 : now, + ); + let resetAt: string; + try { + if (!Number.isFinite(now)) throw new RangeError("Invalid reset clock"); + resetAt = canonicalTimestamp( + new Date(resetTime).toISOString(), + "reset.timestamp", + ); + } catch (error) { + throw corrupt("Workspace reset timestamp is invalid", error); + } + draft.snapshot = createDefaultWorkspaceState(resetAt); + checkpoint("after-snapshot"); + draft.binding = null; + checkpoint("after-binding"); + if (workspaceId) { + delete draft.workspaces[workspaceId]; + delete draft.leases[workspaceDispatcherLeaseName(workspaceId)]; + } + if (draft.migration.cleanupCompletedAt === null) { + const completedAt = [ + resetAt, + draft.migration.confirmedAt, + draft.migration.validatedAt, + draft.migration.copiedAt, + draft.migration.startedAt, + ] + .filter((value): value is string => value !== null) + .sort() + .at(-1) as string; + draft.migration = { + version: 1, + phase: "confirmed", + startedAt: draft.migration.startedAt ?? completedAt, + copiedAt: draft.migration.copiedAt ?? completedAt, + validatedAt: draft.migration.validatedAt ?? completedAt, + confirmedAt: draft.migration.confirmedAt ?? completedAt, + updatedAt: completedAt, + cleanupCompletedAt: completedAt, + }; + } + checkpoint("after-queue"); + return publicWorkspacePersistenceRecord(draft); + }); } async discardWorkspaceQueue(input: { @@ -2563,7 +2657,8 @@ export class IndexedDbWorkspacePersistenceBackend } catch (error) { completed = true; reject( - error instanceof WorkspaceBindingLockedError + error instanceof WorkspaceBindingLockedError || + error instanceof WorkspaceConcurrentUpdateError ? error : normalizeError(error, "transaction-aborted"), ); diff --git a/src/lib/workspace-settings-controller.test.ts b/src/lib/workspace-settings-controller.test.ts index e1608da..2e9ba7e 100644 --- a/src/lib/workspace-settings-controller.test.ts +++ b/src/lib/workspace-settings-controller.test.ts @@ -143,6 +143,108 @@ async function expectRejection( } describe("Workspace settings controller", () => { + it("returns a committed reset even when state hydration and sync presentation fail", async () => { + const persistence = queuedPersistence(); + const setup = createWorkspaceSettingsController({ + persistence, + getState: () => state(), + setState: () => { + throw new Error("Hydration failed"); + }, + dispatchSyncEvent: () => { + throw new Error("Presentation failed"); + }, + }); + await setup.initialize(); + const expected = await setup.prepareDeviceReset(); + const result = await setup.resetDevice(expected); + expect(result.record.binding).toBeNull(); + expect((await persistence.read()).snapshot?.nodes).toEqual([]); + }); + + it("resets the current device only after persistence commits and returns a durable view", async () => { + const persistence = queuedPersistence(); + let requests = 0; + const setup = controller(persistence, state(), async () => { + requests += 1; + throw new Error("Reset must not access cloud data"); + }); + await setup.controller.initialize(); + const expected = await setup.controller.prepareDeviceReset(); + const reset = await setup.controller.resetDevice(expected); + expect(reset.record.binding).toBeNull(); + expect(reset.record.snapshot?.activeGistId).toBeNull(); + expect(reset.inspection.activeQueueCount).toBe(0); + expect(setup.state()).toEqual(reset.record.snapshot); + expect(setup.controller.binding()).toBeNull(); + expect(setup.events.at(-1)?.type).toBe("WORKSPACE_DISCONNECTED"); + expect(requests).toBe(0); + }); + + it("keeps device memory and authentication context unchanged when reset fails", async () => { + const persistence = queuedPersistence(); + const setup = controller(persistence); + await setup.controller.initialize(); + const expected = await setup.controller.prepareDeviceReset(); + const before = setup.state(); + persistence.setFault("before-commit"); + await captureError(setup.controller.resetDevice(expected)); + expect(setup.state()).toEqual(before); + expect(setup.controller.binding()).toEqual(expected.binding); + expect(setup.events).toEqual([]); + }); + + it("rejects a connection whose cloud read started before the device was reset", async () => { + const persistence = queuedPersistence(); + const setup = controller(persistence); + await setup.controller.initialize(); + const expected = await setup.controller.prepareDeviceReset(); + await setup.controller.resetDevice(expected); + const afterReset = await persistence.read(); + const failure = await captureError( + setup.controller.connect({ + token: "fixture-token", + gistId: GIST_ID, + created: false, + snapshot: { origin: "v2", document: document(), state: state() }, + previousBinding: expected.binding, + expected, + }), + ); + expect(failure instanceof WorkspaceConcurrentUpdateError).toBe(true); + expect(await persistence.read()).toEqual(afterReset); + expect(setup.state().activeGistId).toBeNull(); + }); + + it("rejects bootstrap initialization captured before reset without submitting it", async () => { + const persistence = new InMemoryWorkspacePersistence(); + let requests = 0; + const setup = controller( + persistence, + createDefaultWorkspaceState(NOW), + async () => { + requests += 1; + throw new Error("Stale initialization must not submit"); + }, + ); + await setup.controller.initialize(); + const expected = await setup.controller.prepareDeviceReset(); + await setup.controller.resetDevice(expected); + const failure = await captureError( + setup.controller.connect({ + token: "fixture-token", + gistId: GIST_ID, + created: true, + snapshot: { origin: "bootstrap", document: document(), state: state() }, + previousBinding: null, + expected, + }), + ); + expect(failure instanceof WorkspaceConcurrentUpdateError).toBe(true); + expect(requests).toBe(0); + expect((await persistence.read()).binding).toBeNull(); + }); + for (const action of [ "connect", "migrate", diff --git a/src/lib/workspace-settings-controller.ts b/src/lib/workspace-settings-controller.ts index 61cc647..2103083 100644 --- a/src/lib/workspace-settings-controller.ts +++ b/src/lib/workspace-settings-controller.ts @@ -9,6 +9,7 @@ import { import { getWorkspaceBusinessData, WORKSPACE_FILE } from "$lib/workspace-data"; import { exportWorkspaceDiagnosticsFromPersistence } from "$lib/workspace-diagnostics"; import type { WorkspaceDocumentV2 } from "$lib/workspace-document"; +import { broadcastWorkspaceEvent } from "$lib/workspace-events"; import { requireWorkspaceIdentity, withWorkspaceBinding, @@ -22,15 +23,18 @@ import { parseWorkspaceMutation } from "$lib/workspace-mutation"; import type { WorkspaceOperationResult } from "$lib/workspace-operation-result"; import { type BrowserWorkspacePersistence, + inspectWorkspacePersistenceRecord, WorkspaceBindingLockedError, WorkspaceConcurrentUpdateError, type WorkspacePersistenceRecord, type WorkspaceQueueInspection, + type WorkspaceResetExpectation, } from "$lib/workspace-persistence"; import { getBrowserWorkspacePersistence, initializeBrowserWorkspacePersistence, refreshBrowserWorkspacePersistence, + resetBrowserWorkspacePersistence, } from "$lib/workspace-persistence-browser"; import { discardInspectedWorkspaceQueue, @@ -123,6 +127,66 @@ export function createWorkspaceSettingsController( return view; } + function resetExpectation( + record: WorkspacePersistenceRecord, + ): WorkspaceResetExpectation { + const workspaceId = + record.binding?.workspaceId ?? + (record.snapshot?.activeGistId + ? `gist:${record.snapshot.activeGistId}` + : null); + return structuredClone({ + snapshot: record.snapshot, + binding: record.binding, + queue: workspaceId ? (record.workspaces[workspaceId] ?? null) : null, + }); + } + + function requireExpectedRecord( + record: WorkspacePersistenceRecord, + expected: WorkspaceResetExpectation, + ): void { + if (JSON.stringify(resetExpectation(record)) !== JSON.stringify(expected)) { + throw new WorkspaceConcurrentUpdateError(); + } + } + + async function prepareDeviceReset(): Promise { + return resetExpectation(await readRecord()); + } + + async function resetDevice( + expected: WorkspaceResetExpectation, + ): Promise { + const record = dependencies.persistence + ? await dependencies.persistence.resetWorkspace({ expected }) + : await resetBrowserWorkspacePersistence(expected); + view = { record, inspection: inspectWorkspacePersistenceRecord(record) }; + try { + if (record.snapshot) dependencies.setState(record.snapshot); + } catch { + // Hydration failure cannot undo the committed reset. + } + try { + dispatch({ + type: "WORKSPACE_DISCONNECTED", + queue: deriveWorkspaceQueueMetrics(record), + }); + } catch { + // Presentation failure cannot turn the reset into a rejected transaction. + } + try { + broadcastWorkspaceEvent({ + type: "device-reset", + gistId: null, + fileName: null, + }); + } catch { + // The committed record remains authoritative when peer notification fails. + } + return structuredClone(view); + } + async function requireBoundWorkspace( gistId: string, ): Promise { @@ -371,8 +435,10 @@ export function createWorkspaceSettingsController( async function refreshCloud( snapshot: BrowserWorkspaceSnapshot, gistId: string, + expected?: WorkspaceResetExpectation, ): Promise { const current = await requireBoundWorkspace(gistId); + if (expected) requireExpectedRecord(current.record, expected); if (snapshot.origin !== "v2") { throw new Error("Upgrade this Workspace to continue."); } @@ -397,7 +463,7 @@ export function createWorkspaceSettingsController( snapshot: state, binding: nextBinding, mutations: [], - expected: { + expected: expected ?? { snapshot: current.record.snapshot, binding: current.record.binding, queue: current.record.workspaces[nextBinding.workspaceId] ?? null, @@ -416,6 +482,7 @@ export function createWorkspaceSettingsController( resolvedState: AppState; syncMode: "automatic" | "manual"; replacePending?: boolean; + expected?: WorkspaceResetExpectation; }): Promise { await requireBoundWorkspace(input.gistId); const result = await reconcileBrowserWorkspace( @@ -432,6 +499,7 @@ export function createWorkspaceSettingsController( created: boolean; snapshot: BrowserWorkspaceSnapshot; previousBinding: WorkspaceV2LocalState | null; + expected?: WorkspaceResetExpectation; }): Promise< | { status: "created" | "synced"; @@ -441,6 +509,7 @@ export function createWorkspaceSettingsController( | { status: "migration-required" } > { const current = await requireBoundWorkspace(input.gistId); + if (input.expected) requireExpectedRecord(current.record, input.expected); if (input.snapshot.origin === "v1") return { status: "migration-required" }; requireIdleCloudQueue(current.record, input.gistId); if (input.created || input.snapshot.origin === "bootstrap") { @@ -454,6 +523,7 @@ export function createWorkspaceSettingsController( input.gistId, ), syncMode: "automatic", + expected: input.expected ?? resetExpectation(current.record), }); if (operation.status === "remote-committed") { dispatchPersistedState("WORKSPACE_BOUND"); @@ -461,7 +531,11 @@ export function createWorkspaceSettingsController( return { status: "created", operation }; } - await refreshCloud(input.snapshot, input.gistId); + await refreshCloud( + input.snapshot, + input.gistId, + input.expected ?? resetExpectation(current.record), + ); return { status: "synced", operation: null }; } @@ -470,6 +544,7 @@ export function createWorkspaceSettingsController( gistId: string; snapshot: BrowserWorkspaceSnapshot; retryMutationId?: string; + expected?: WorkspaceResetExpectation; }): Promise { await requireBoundWorkspace(input.gistId); const operation = await migrateBrowserWorkspace( @@ -776,6 +851,8 @@ export function createWorkspaceSettingsController( return { initialize, + prepareDeviceReset, + resetDevice, refresh, currentView, binding, diff --git a/src/routes/+layout.svelte b/src/routes/+layout.svelte index bd377b5..7ef9a55 100644 --- a/src/routes/+layout.svelte +++ b/src/routes/+layout.svelte @@ -47,6 +47,7 @@ import { import { workspaceCloudStatus } from "$lib/workspace-cloud-status"; import { subscribeWorkspaceEvents } from "$lib/workspace-events"; import { startWorkspaceMutationSync } from "$lib/workspace-mutation-sync-browser"; +import { invalidateBrowserWorkspacePersistenceCache } from "$lib/workspace-persistence-browser"; import { workspaceSyncStatus } from "$lib/workspace-sync-status"; const PROJECT_GITHUB_URL = "https://github.com/KnowSky404/SubMan"; @@ -240,6 +241,11 @@ onMount(() => { const stopThemeSync = startThemeSync(); const stopUiMotion = watchMotionPreference(); const stopWorkspaceEvents = subscribeWorkspaceEvents((event) => { + if (event.type === "device-reset") { + cancelCloudWorkspaceLoad(); + invalidateBrowserWorkspacePersistenceCache(); + return; + } if (event.type !== "workspace-v2-committed" || !currentToken) return; if (get(workspaceCloudStatus).phase === "error") { void refreshCloudWorkspace(currentToken); diff --git a/src/routes/auth/+page.svelte b/src/routes/auth/+page.svelte index a1c34de..cfb3375 100644 --- a/src/routes/auth/+page.svelte +++ b/src/routes/auth/+page.svelte @@ -16,7 +16,12 @@ import { trash, } from "$lib/octicons"; import { appState } from "$lib/stores/app"; -import { authState, clearAuth, setToken } from "$lib/stores/auth"; +import { + authState, + clearAuth, + defaultAuthState, + setToken, +} from "$lib/stores/auth"; import { requestConfirm } from "$lib/stores/confirm"; import { showToast } from "$lib/stores/toast"; import { cn } from "$lib/utils/cn"; @@ -37,6 +42,7 @@ import { workspaceCloudStatus } from "$lib/workspace-cloud-status"; import { subscribeWorkspaceEvents } from "$lib/workspace-events"; import { presentWorkspaceOperation } from "$lib/workspace-operation-presenter"; import type { WorkspaceOperationResult } from "$lib/workspace-operation-result"; +import type { WorkspaceResetExpectation } from "$lib/workspace-persistence"; import { createWorkspaceSettingsController, type WorkspaceSettingsView, @@ -58,11 +64,13 @@ let queueResult: { type: "success" | "info" | "error"; message: string; } | null = null; +let resetNotice: { type: "info" | "error"; message: string } | null = null; let pendingMigration: { token: string; gist: GistMeta; snapshot: BrowserWorkspaceSnapshot; remember: boolean; + expected: WorkspaceResetExpectation; mutationId?: string; } | null = null; const workspaceController = createWorkspaceSettingsController({ @@ -79,6 +87,20 @@ $: migrationQueued = Boolean( async function refreshView() { view = await workspaceController.refresh(); } +function connectionExpectation( + record: WorkspaceSettingsView["record"], +): WorkspaceResetExpectation { + const workspaceId = + record.binding?.workspaceId ?? + (record.snapshot?.activeGistId + ? `gist:${record.snapshot.activeGistId}` + : null); + return structuredClone({ + snapshot: record.snapshot, + binding: record.binding, + queue: workspaceId ? (record.workspaces[workspaceId] ?? null) : null, + }); +} function errorMessage(error: unknown): string { const message = error instanceof Error ? error.message : ""; if (message.includes("migration_backup_conflict")) @@ -103,6 +125,26 @@ function errorMessage(error: unknown): string { : "Cloud data could not be loaded. Check your connection and retry.", ); } +function resetErrorMessage(error: unknown): string { + const message = error instanceof Error ? error.message : ""; + if ( + message === + "Cloud delivery is active. Wait for it to finish before resetting this device." + ) + return $t(message); + if ( + typeof error === "object" && + error !== null && + "code" in error && + error.code === "concurrent-update" + ) + return $t( + "Workspace changed while reset was being confirmed. Review its current state and try again.", + ); + return $t( + "Device reset could not be confirmed. Check browser storage access, reload Settings, and review the connection before retrying.", + ); +} function showOperation( result: WorkspaceOperationResult, remoteCommittedMessageKey?: string, @@ -118,14 +160,16 @@ function showOperation( } onMount(() => { rememberToken = $authState.persistence === "persistent"; + const revision = connectionRevision; void workspaceController .initialize() .then(async (initial) => { + if (revision !== connectionRevision) return; view = initial; const gistId = initial.record.binding?.gistId ?? $appState.activeGistId; const token = $authState.token; - const revision = connectionRevision; if (!gistId || !token) return; + const expected = connectionExpectation(initial.record); try { const gist = await getGist(token, gistId); const snapshot = await readBrowserWorkspaceSnapshot( @@ -138,15 +182,27 @@ onMount(() => { token === $authState.token && snapshot.origin === "v1" ) - pendingMigration = { token, gist, snapshot, remember: rememberToken }; + pendingMigration = { + token, + gist, + snapshot, + remember: rememberToken, + expected, + }; } catch { // The shared cloud session owns connection feedback. } }) .catch((error) => { + if (revision !== connectionRevision) return; notice = { type: "error", message: errorMessage(error) }; }); - return subscribeWorkspaceEvents(() => { + return subscribeWorkspaceEvents((event) => { + if (event.type === "device-reset") { + connectionRevision += 1; + cancelCloudWorkspaceLoad(); + pendingMigration = null; + } void refreshView().catch(() => undefined); }); }); @@ -155,15 +211,22 @@ async function connectGist( gist: GistMeta, created: boolean, remember: boolean, + expected?: WorkspaceResetExpectation, ) { const revision = connectionRevision; + const observed = + expected ?? + connectionExpectation((await workspaceController.refresh()).record); + if (revision !== connectionRevision) return; const snapshot = await readBrowserWorkspaceSnapshot(token, gist, $appState); if (revision !== connectionRevision) return; const previousBinding = workspaceController.binding(); if (previousBinding?.gistId === gist.id && snapshot.origin === "v2") { setToken(token, { remember }); await refreshCloudWorkspace(token); + if (revision !== connectionRevision) return; await refreshView(); + if (revision !== connectionRevision) return; if ($workspaceCloudStatus.phase === "ready") { tokenInput = ""; showToast($t("Cloud data loaded."), "success"); @@ -176,13 +239,15 @@ async function connectGist( created, snapshot, previousBinding, + expected: observed, }); if (revision !== connectionRevision) return; if (result.status === "migration-required") { - pendingMigration = { token, gist, snapshot, remember }; + pendingMigration = { token, gist, snapshot, remember, expected: observed }; return; } await refreshView(); + if (revision !== connectionRevision) return; clearLegacyWorkspaceSyncState(); setToken(token, { remember }); tokenInput = ""; @@ -205,11 +270,15 @@ async function connectGist( async function handleTokenSave() { const token = (tokenInput || $authState.token || "").trim(); if (!token || workspaceBusy) return; - connectionRevision += 1; + const revision = ++connectionRevision; workspaceBusy = true; notice = null; try { await refreshView(); + if (revision !== connectionRevision) return; + const expected = connectionExpectation( + (view as WorkspaceSettingsView).record, + ); const gistId = view?.record.binding?.gistId ?? $appState.activeGistId ?? @@ -217,6 +286,7 @@ async function handleTokenSave() { if (gistId && !/^[a-zA-Z0-9_-]{1,64}$/.test(gistId)) throw new Error("Enter a Gist ID, not a URL."); const discovery = await discoverWorkspaceGist(token, gistId || null); + if (revision !== connectionRevision) return; if (discovery.status === "ambiguous") { notice = { type: "info", @@ -230,8 +300,16 @@ async function handleTokenSave() { discovery.status === "found" ? { gist: discovery.gist, created: false } : await ensureWorkspaceBootstrapGist(token); - await connectGist(token, target.gist, target.created, rememberToken); + if (revision !== connectionRevision) return; + await connectGist( + token, + target.gist, + target.created, + rememberToken, + expected, + ); } catch (error) { + if (revision !== connectionRevision) return; notice = { type: "error", message: errorMessage(error) }; } finally { workspaceBusy = false; @@ -263,14 +341,21 @@ async function handleLegacyWorkspaceCheck() { $appState.activeGistId ) return; - connectionRevision += 1; + const revision = ++connectionRevision; workspaceBusy = true; legacyCheckResult = null; try { if (!/^[a-zA-Z0-9_-]{1,64}$/.test(gistId)) throw new Error("Enter a Gist ID, not a URL."); + await refreshView(); + if (revision !== connectionRevision) return; + const expected = connectionExpectation( + (view as WorkspaceSettingsView).record, + ); const gist = await getGist(token, gistId); + if (revision !== connectionRevision) return; const candidate = await classifyWorkspaceCandidate(token, gist); + if (revision !== connectionRevision) return; if (candidate.kind === "invalid") throw new Error( "This Gist is not a valid Workspace. Check its description is SubMan-Data and it contains a valid subman.json.", @@ -285,8 +370,9 @@ async function handleLegacyWorkspaceCheck() { }; return; } - await connectGist(token, gist, false, rememberToken); + await connectGist(token, gist, false, rememberToken, expected); } catch (error) { + if (revision !== connectionRevision) return; legacyCheckResult = { type: "error", message: errorMessage(error) }; } finally { workspaceBusy = false; @@ -294,6 +380,7 @@ async function handleLegacyWorkspaceCheck() { } async function handleLegacyMigration() { if (!pendingMigration || workspaceBusy) return; + const revision = connectionRevision; workspaceBusy = true; try { const migration = pendingMigration; @@ -302,10 +389,13 @@ async function handleLegacyMigration() { gistId: migration.gist.id, snapshot: migration.snapshot, retryMutationId: migration.mutationId, + expected: migration.expected, }); + if (revision !== connectionRevision) return; if (result.mutationId) migration.mutationId = result.mutationId; setToken(migration.token, { remember: migration.remember }); await refreshView(); + if (revision !== connectionRevision) return; if ( showOperation( result, @@ -316,6 +406,7 @@ async function handleLegacyMigration() { workspaceCloudStatus.set({ phase: "ready", message: null }); } } catch (error) { + if (revision !== connectionRevision) return; notice = { type: "error", message: errorMessage(error) }; } finally { workspaceBusy = false; @@ -323,16 +414,26 @@ async function handleLegacyMigration() { } async function handleRecheckMigration() { if (!pendingMigration || workspaceBusy) return; + const revision = connectionRevision; workspaceBusy = true; try { const migration = pendingMigration; + await refreshView(); + if (revision !== connectionRevision) return; + const expected = connectionExpectation( + (view as WorkspaceSettingsView).record, + ); + const gist = await getGist(migration.token, migration.gist.id); + if (revision !== connectionRevision) return; await connectGist( migration.token, - await getGist(migration.token, migration.gist.id), + gist, false, migration.remember, + expected, ); } catch (error) { + if (revision !== connectionRevision) return; notice = { type: "error", message: errorMessage(error) }; } finally { workspaceBusy = false; @@ -376,6 +477,53 @@ async function handleReloadCloud() { workspaceBusy = false; } } +async function handleDeviceReset() { + if (workspaceBusy) return; + workspaceBusy = true; + resetNotice = null; + try { + const expected = await workspaceController.prepareDeviceReset(); + const confirmed = await requestConfirm({ + title: $t("Reset this device"), + message: $t( + "Reset this browser's Workspace connection and cached data, and discard all unconfirmed changes? Cloud data is preserved. Close other SubMan tabs before continuing.", + ), + confirmText: $t("Reset this device"), + danger: true, + }); + if (!confirmed) return; + connectionRevision += 1; + cancelCloudWorkspaceLoad(); + view = await workspaceController.resetDevice(expected); + let tokenCleared = true; + try { + clearAuth(); + } catch { + authState.set({ ...defaultAuthState }); + tokenCleared = false; + } + pendingMigration = null; + tokenInput = ""; + rememberToken = false; + gistIdInput = ""; + legacyGistIdInput = ""; + notice = null; + legacyCheckResult = null; + queueResult = null; + resetNotice = { + type: tokenCleared ? "info" : "error", + message: $t( + tokenCleared + ? "Device reset. Connect again to load cloud data or create an empty Workspace." + : "Device reset completed, but saved token removal could not be confirmed. Check browser storage access before reconnecting.", + ), + }; + } catch (error) { + resetNotice = { type: "error", message: resetErrorMessage(error) }; + } finally { + workspaceBusy = false; + } +} async function handleQueueDiscard(workspaceId: string) { if (workspaceId === view?.record.binding?.workspaceId) { await handleReloadCloud(); @@ -517,4 +665,15 @@ async function handleDiagnosticsExport() {
+
+
+

{$t("Reset this device")}

+

{$t("If the original Gist was deleted or this browser cannot reconnect, reset its Workspace connection and start setup again.")}

+
+
+

{$t("Reset removes this browser's Workspace connection and cached data and discards unconfirmed changes. Cloud data is preserved. Close other SubMan tabs first.")}

+ {#if resetNotice}

{resetNotice.message}

{/if} + +
+
diff --git a/src/routes/auth/page-source.test.ts b/src/routes/auth/page-source.test.ts index 86f9dba..f24f0d7 100644 --- a/src/routes/auth/page-source.test.ts +++ b/src/routes/auth/page-source.test.ts @@ -84,3 +84,39 @@ test("repair tooling retains safe diagnostics and complete historical queues", ( ); expect(authPageSource).not.toContain(".remove(mutation.mutationId)"); }); + +test("device reset is a separately confirmed local recovery action", () => { + const handler = authPageSource.slice( + authPageSource.indexOf("async function handleDeviceReset()"), + authPageSource.indexOf("async function handleQueueDiscard("), + ); + expect(authPageSource).toContain('data-testid="device-reset"'); + expect(authPageSource).toContain('data-testid="device-reset-action"'); + expect(handler).toContain("workspaceController.prepareDeviceReset()"); + expect( + handler.indexOf("workspaceController.prepareDeviceReset()"), + ).toBeLessThan(handler.indexOf("await requestConfirm(")); + expect( + handler.indexOf("workspaceController.resetDevice(expected)"), + ).toBeGreaterThan(handler.indexOf("if (!confirmed) return")); + expect(handler.indexOf("clearAuth()")).toBeGreaterThan( + handler.indexOf("workspaceController.resetDevice(expected)"), + ); + expect(handler).toContain("cancelCloudWorkspaceLoad()"); + expect(handler).not.toContain("ensureWorkspaceBootstrapGist"); + expect(handler).not.toContain("refreshCloudWorkspace"); + expect(handler).not.toContain("localStorage.clear()"); +}); + +test("connection discovery captures its persistent state before network reads", () => { + const handler = authPageSource.slice( + authPageSource.indexOf("async function handleTokenSave()"), + authPageSource.indexOf("async function handleSync()"), + ); + expect(handler.indexOf("connectionExpectation(")).toBeGreaterThan(-1); + expect(handler.indexOf("connectionExpectation(")).toBeLessThan( + handler.indexOf("discoverWorkspaceGist("), + ); + expect(handler).toMatch(/rememberToken,\s+expected/); + expect(authPageSource).toContain("expected?: WorkspaceResetExpectation"); +}); From 53e1dd5a028115b852bd93a7453495b75add97f5 Mon Sep 17 00:00:00 2001 From: KnowSky404 Date: Sat, 31 Oct 2026 14:53:09 +0800 Subject: [PATCH 2/4] fix(gists): make cloud file viewer read-only --- docs/wiki/Changelog.md | 9 ++ docs/wiki/Changelog.zh-CN.md | 7 ++ docs/wiki/User-Guide.md | 9 +- docs/wiki/User-Guide.zh-CN.md | 7 +- e2e/gists-readonly.spec.ts | 136 +++++++++++++++++++++++ e2e/ui-workspace-fixture.ts | 13 +++ src/lib/i18n.ts | 4 +- src/lib/workspace-file-inventory.test.ts | 8 -- src/lib/workspace-file-inventory.ts | 5 - src/routes/gists/+page.svelte | 113 +------------------ src/routes/gists/page-source.test.ts | 25 ++--- 11 files changed, 194 insertions(+), 142 deletions(-) create mode 100644 e2e/gists-readonly.spec.ts diff --git a/docs/wiki/Changelog.md b/docs/wiki/Changelog.md index b7cab96..6b3527b 100644 --- a/docs/wiki/Changelog.md +++ b/docs/wiki/Changelog.md @@ -18,6 +18,15 @@ production deployment and real-provider acceptance require separate evidence. - Kept reset local: authentication clears only after storage commits, and a separate connection loads cloud data or initializes an empty Workspace. +### 2026-10-31 - Read-only Gist file viewer + +- Made Gists read-only for every file kind, removing output deletion and stale + bootstrap marker cleanup controls and handlers. Kept refresh, file links, + link copying, file classification, and bootstrap warnings. +- Added English and Chinese guidance to manage publications in Aggregation or + Client Exports, with browser coverage for viewing and refreshing files without + submitting cloud mutations. Existing repair states still require diagnosis. + ### 2026-10-28 - Primer interface and interaction system - Unified the six routes around the approved GitHub-style concepts: white/dark diff --git a/docs/wiki/Changelog.zh-CN.md b/docs/wiki/Changelog.zh-CN.md index 21b0d2f..d0dcbb4 100644 --- a/docs/wiki/Changelog.zh-CN.md +++ b/docs/wiki/Changelog.zh-CN.md @@ -14,6 +14,13 @@ 正在发送或并发变化时拒绝重置,旧标签页不能恢复已放弃的绑定。 - 重置仅作用于本地,存储提交后才清除认证;用户再次连接时才加载云端或初始化空工作区。 +### 2026-10-31 - Gists 文件页面改为只读 + +- 所有类型的 Gist 文件均只读,移除输出删除和过期引导标记清理按钮及处理逻辑; + 保留刷新、文件链接、复制链接、文件分类和引导状态提示。 +- 增加中英文说明,引导到聚合或客户端导出页面管理发布,并通过浏览器测试验证 + 查看和刷新文件不会提交云端变更。已有修复状态仍需单独排查。 + ### 2026-10-28 - Primer 界面与交互系统 - 按已确认的 GitHub 风格概念稿统一六个页面:明暗主画布、更清楚的页面标题、 diff --git a/docs/wiki/User-Guide.md b/docs/wiki/User-Guide.md index 702ff33..9b08d08 100644 --- a/docs/wiki/User-Guide.md +++ b/docs/wiki/User-Guide.md @@ -32,7 +32,7 @@ empty Workspace, then recent resources and confirmed publication metadata. | `/nodes` | Nodes and subscriptions, tags, search, filters, and batch import | | `/aggregate` | Rule editing, preview ordering, publish targets, and publication | | `/exports` | sing-box configuration preview, copy, download, and publication | -| `/gists` | Output files, raw links, and cleanup | +| `/gists` | Read-only cloud file list, raw links, and link copying | Import one URI per line or paste base64 subscription content. Preview and resolve duplicates before adding. Aggregates select nodes and subscriptions, @@ -58,8 +58,11 @@ a file creates a new URL; review the cleanup result before removing the old file Node edits do not automatically republish existing aggregate or sing-box files. Configuration and outputs are committed together through the coordinator. -`subman.json`, `subman.v1.backup.json`, and `subman.bootstrap.json` are reserved; -they cannot be outputs or be removed in the file manager. +The Gists page is read-only for all files, including managed outputs, external +files, and bootstrap markers. Use Aggregation or Client Exports to manage +publications; file preview, link copying, and refresh remain available in Gists. +`subman.json`, `subman.v1.backup.json`, and `subman.bootstrap.json` are reserved +and cannot be outputs. ## Delivery and recovery diff --git a/docs/wiki/User-Guide.zh-CN.md b/docs/wiki/User-Guide.zh-CN.md index 8dc2c64..20d75a8 100644 --- a/docs/wiki/User-Guide.zh-CN.md +++ b/docs/wiki/User-Guide.zh-CN.md @@ -26,7 +26,7 @@ SubMan 查找描述为 `SubMan-Data`、包含权威文档 `subman.json` 的私 | `/nodes` | 节点与订阅、标签、搜索、过滤、批量导入 | | `/aggregate` | 规则编辑、预览排序、发布目标与发布 | | `/exports` | sing-box 配置预览、复制、下载和发布 | -| `/gists` | 输出文件、原始链接和清理 | +| `/gists` | 只读云端文件列表、查看与复制原始链接 | 每行粘贴一个 URI,也可导入 base64 订阅内容;预览并处理重复项后再添加。 聚合规则可选择节点和订阅、排除标签、过滤协议、正则重命名、添加地区旗帜, @@ -46,8 +46,9 @@ SubMan 查找描述为 `SubMan-Data`、包含权威文档 `subman.json` 的私 同一 Gist 和文件名可保持原始订阅 URL 稳定;重命名会产生新 URL,删除旧文件前先查看清理结果。 修改节点后不会自动重新发布现有聚合或 sing-box 文件。 -配置与输出由协调器一并提交。`subman.json`、`subman.v1.backup.json` 和 -`subman.bootstrap.json` 为保留文件,不可用作输出,也不能通过文件管理器删除。 +配置与输出由协调器一并提交。Gists 页面中的所有文件均为只读,包括托管输出、外部文件 +和引导标记。请在聚合或客户端导出页面管理发布;Gists 保留查看文件、复制链接和刷新功能。 +`subman.json`、`subman.v1.backup.json` 和 `subman.bootstrap.json` 为保留文件,不可用作输出。 ## 发送与恢复 diff --git a/e2e/gists-readonly.spec.ts b/e2e/gists-readonly.spec.ts new file mode 100644 index 0000000..e78adbf --- /dev/null +++ b/e2e/gists-readonly.spec.ts @@ -0,0 +1,136 @@ +import { expect, test } from "@playwright/test"; +import { defaultUiData, seedUiWorkspace } from "./ui-workspace-fixture"; + +const gistUrl = "https://api.github.com/gists/accessibility-cloud"; +const rawUrl = + "https://gist.githubusercontent.com/e2e/accessibility-cloud/raw/nodes.txt"; + +for (const variant of [ + { name: "desktop English", width: 1280, height: 900, locale: "en" }, + { name: "mobile Chinese", width: 390, height: 844, locale: "zh-CN" }, +]) { + test(`Gists stays read-only while viewing and refreshing all file kinds (${variant.name})`, async ({ + page, + context, + }) => { + await page.setViewportSize(variant); + const errors: string[] = []; + const writes: string[] = []; + page.on("pageerror", (error) => errors.push(error.message)); + page.on("console", (message) => { + if (message.type() === "error") errors.push(message.text()); + }); + context.on("request", (request) => { + if ( + request.method() !== "GET" && + (request.url().startsWith("https://api.github.com/") || + request.url().includes("/api/workspaces/")) + ) { + writes.push(`${request.method()} ${request.url()}`); + } + }); + await context.route("**/api/workspaces/**", (route) => route.abort()); + const data = structuredClone(defaultUiData); + const now = "2026-10-23T10:00:00.000Z"; + data.aggregates.push({ + id: "readonly-rule", + name: "Read-only rule", + nodeIds: [data.nodes[0].id], + subscriptionIds: [], + excludeTagIds: [], + renameMap: {}, + allowedTypes: [], + updatedAt: now, + }); + data.publishTargets.push({ + id: "readonly-target", + name: "Published output", + ruleId: "readonly-rule", + fileName: "nodes.txt", + description: "", + isPublic: false, + lastPublishedAt: now, + lastPublishedUrl: rawUrl, + lastPublishTransitionAt: null, + lastPublishTransitionFromFileName: null, + lastPublishTransitionToFileName: null, + lastPublishTransitionOutcome: null, + updatedAt: now, + }); + const files = { + "nodes.txt": data.nodes[0].raw, + "notes.txt": "External file", + "subman.v1.backup.json": "Historical backup", + "subman.bootstrap.json": JSON.stringify({ version: 1 }), + }; + await seedUiWorkspace(page, context, data, files); + await page.evaluate((locale) => { + localStorage.setItem("subman:locale:v1", locale); + }, variant.locale); + await page.goto("/gists"); + await expect(page).toHaveURL(/\/gists$/); + await expect(page).toHaveTitle("Gists - SubMan"); + await expect(page.locator(".app-header-link-connected")).toBeVisible(); + const main = page.getByRole("main"); + await expect(main.getByRole("heading", { name: "Gists" })).toBeVisible(); + await expect( + main.getByText(variant.locale === "en" ? "Read-only" : "只读", { + exact: true, + }), + ).toBeVisible(); + await expect(main.locator(".gh-box-row")).toHaveCount(5); + await expect( + main.getByText(variant.locale === "en" ? "Stale marker" : "过期标记", { + exact: true, + }), + ).toBeVisible(); + await expect( + main.getByRole("button", { name: /Delete|Edit|Clean Up|删除|编辑|清理/ }), + ).toHaveCount(0); + await expect(main.getByRole("button")).toHaveCount(6); + const output = main.locator(".gh-box-row").filter({ hasText: "nodes.txt" }); + await expect(output.locator(".gh-label")).toHaveText( + variant.locale === "en" ? "Managed Output" : "受管输出", + ); + await expect(output.getByRole("link").first()).toHaveAttribute( + "href", + rawUrl, + ); + await page.evaluate(() => { + Object.defineProperty(navigator, "clipboard", { + configurable: true, + value: { + writeText: async (value: string) => { + document.documentElement.dataset.copiedUrl = value; + }, + }, + }); + }); + const copy = output.getByRole("button", { + name: variant.locale === "en" ? "Copy Raw URL" : "复制原始链接", + exact: true, + }); + await copy.click(); + await expect(copy).toHaveAttribute("data-feedback", "copied"); + await expect(page.locator("html")).toHaveAttribute( + "data-copied-url", + rawUrl, + ); + await Promise.all([ + page.waitForResponse(gistUrl), + main + .getByRole("button", { + name: variant.locale === "en" ? "Refresh" : "刷新", + exact: true, + }) + .click(), + ]); + await expect(main.locator(".gh-box-row")).toHaveCount(5); + await expect(main.getByRole("button")).toHaveCount(6); + expect( + await page.evaluate(() => document.documentElement.scrollWidth), + ).toBeLessThanOrEqual(variant.width); + expect(writes).toEqual([]); + expect(errors).toEqual([]); + }); +} diff --git a/e2e/ui-workspace-fixture.ts b/e2e/ui-workspace-fixture.ts index 2f39364..9645539 100644 --- a/e2e/ui-workspace-fixture.ts +++ b/e2e/ui-workspace-fixture.ts @@ -29,6 +29,7 @@ export async function seedUiWorkspace( page: Page, context: BrowserContext, data: UiWorkspaceData = structuredClone(defaultUiData), + extraFiles: Record = {}, ) { const now = "2026-10-23T10:00:00.000Z"; const gistId = "accessibility-cloud"; @@ -65,6 +66,18 @@ export async function seedUiWorkspace( updated_at: now, html_url: `https://gist.github.com/e2e/${gistId}`, files: { + ...Object.fromEntries( + Object.entries(extraFiles).map(([filename, content]) => [ + filename, + { + filename, + raw_url: `https://gist.githubusercontent.com/e2e/${gistId}/raw/${filename}`, + size: new TextEncoder().encode(content).byteLength, + content, + truncated: false, + }, + ]), + ), "subman.json": { filename: "subman.json", raw_url: `https://gist.githubusercontent.com/e2e/${gistId}/raw/subman.json`, diff --git a/src/lib/i18n.ts b/src/lib/i18n.ts index 7dcc955..0f300be 100644 --- a/src/lib/i18n.ts +++ b/src/lib/i18n.ts @@ -30,7 +30,9 @@ const zhCN: Record = { "Combine sources, preview rules, and publish output.": "组合来源、预览规则并发布输出。", "Generate and publish client configurations.": "生成并发布客户端配置。", - "Files in your connected cloud Workspace.": "查看已连接云端工作区的文件。", + "Read-only cloud files. Manage publications in Aggregation or Client Exports.": + "云端文件仅供查看。请在聚合或客户端导出页面管理发布。", + "Read-only": "只读", "Manage your GitHub connection and appearance.": "管理 GitHub 连接与界面偏好。", "Your resources and confirmed publications.": "查看资源与已确认的发布记录。", diff --git a/src/lib/workspace-file-inventory.test.ts b/src/lib/workspace-file-inventory.test.ts index d063c60..39b4ade 100644 --- a/src/lib/workspace-file-inventory.test.ts +++ b/src/lib/workspace-file-inventory.test.ts @@ -1,6 +1,5 @@ import { describe, expect, it } from "bun:test"; import { - canDeleteWorkspaceFile, classifyWorkspaceFile, getWorkspaceBootstrapStatus, } from "$lib/workspace-file-inventory"; @@ -35,11 +34,4 @@ describe("Workspace file inventory", () => { getWorkspaceBootstrapStatus(["subman.bootstrap.json", "notes.txt"]), ).toBe("invalid"); }); - - it("allows ordinary deletion only for non-reserved files", () => { - expect(canDeleteWorkspaceFile("nodes.txt")).toBe(true); - expect(canDeleteWorkspaceFile("subman.json")).toBe(false); - expect(canDeleteWorkspaceFile("subman.v1.backup.json")).toBe(false); - expect(canDeleteWorkspaceFile("subman.bootstrap.json")).toBe(false); - }); }); diff --git a/src/lib/workspace-file-inventory.ts b/src/lib/workspace-file-inventory.ts index 3119de5..3fdeeda 100644 --- a/src/lib/workspace-file-inventory.ts +++ b/src/lib/workspace-file-inventory.ts @@ -2,7 +2,6 @@ import type { WorkspaceData } from "$lib/workspace-document"; import { WORKSPACE_BOOTSTRAP_FILE_NAME, WORKSPACE_FILE_NAME, - WORKSPACE_RESERVED_FILE_NAMES, WORKSPACE_V1_BACKUP_FILE_NAME, } from "$lib/workspace-document"; @@ -31,10 +30,6 @@ export function classifyWorkspaceFile( return "external-file"; } -export function canDeleteWorkspaceFile(fileName: string): boolean { - return !WORKSPACE_RESERVED_FILE_NAMES.has(fileName); -} - export function getWorkspaceBootstrapStatus( fileNames: readonly string[], ): "incomplete" | "stale" | "invalid" | null { diff --git a/src/routes/gists/+page.svelte b/src/routes/gists/+page.svelte index b3b7d61..6ef17e8 100644 --- a/src/routes/gists/+page.svelte +++ b/src/routes/gists/+page.svelte @@ -3,7 +3,6 @@ import { onMount } from "svelte"; import { tooltip } from "$lib/actions/tooltip"; import CopyButton from "$lib/components/CopyButton.svelte"; import Octicon from "$lib/components/Octicon.svelte"; -import OperationFeedback from "$lib/components/OperationFeedback.svelte"; import PageHeader from "$lib/components/PageHeader.svelte"; import { getGist } from "$lib/gist"; import { t } from "$lib/i18n"; @@ -11,37 +10,22 @@ import type { GistMeta } from "$lib/models"; import { alert, code, - copy, - database, file as fileIcon, linkExternal, shieldCheck, sync, - trash, } from "$lib/octicons"; import { appState } from "$lib/stores/app"; import { authState } from "$lib/stores/auth"; -import { requestConfirm } from "$lib/stores/confirm"; import { showToast } from "$lib/stores/toast"; import { cn } from "$lib/utils/cn"; -import { submitBrowserWorkspaceMutation } from "$lib/workspace-browser-session-v2"; +import { WORKSPACE_RESERVED_FILE_NAMES } from "$lib/workspace-document"; import { - WORKSPACE_BOOTSTRAP_FILE_NAME, - WORKSPACE_RESERVED_FILE_NAMES, -} from "$lib/workspace-document"; -import { - canDeleteWorkspaceFile, classifyWorkspaceFile, getWorkspaceBootstrapStatus, type WorkspaceFileKind, } from "$lib/workspace-file-inventory"; import { requireWorkspaceIdentity } from "$lib/workspace-identity"; -import { - presentWorkspaceOperation, - type WorkspaceOperationPresentation, - type WorkspaceOperationPresentationOptions, -} from "$lib/workspace-operation-presenter"; -import type { WorkspaceOperationResult } from "$lib/workspace-operation-result"; import { getBrowserWorkspaceBinding, initializeBrowserWorkspacePersistence, @@ -49,8 +33,6 @@ import { let workspace: GistMeta | null = null; let loading = false; -let operationFeedback: WorkspaceOperationPresentation | null = null; -let deleting = false; $: workspaceFileCount = workspace?.files.length ?? 0; $: bootstrapStatus = getWorkspaceBootstrapStatus( workspace?.files.map((file) => file.filename) ?? [], @@ -63,20 +45,6 @@ function setStatus( showToast(message, type); } -function showWorkspaceResult( - result: WorkspaceOperationResult, - options: WorkspaceOperationPresentationOptions = {}, -) { - const presentation = presentWorkspaceOperation(result, options); - operationFeedback = presentation; - if (presentation.remoteCommitted) - setStatus( - $t(presentation.messageKey, presentation.messageParams), - presentation.tone, - ); - return presentation; -} - function fileKindLabel(kind: WorkspaceFileKind): string { switch (kind) { case "workspace-config": @@ -132,72 +100,6 @@ async function refreshWorkspace() { onMount(() => { if ($authState.token) void refreshWorkspace(); }); - -async function deleteFile(filename: string) { - const token = $authState.token; - const gistId = $appState.activeGistId; - if (!token || !gistId || !canDeleteWorkspaceFile(filename)) return; - - const confirmed = await requestConfirm({ - title: $t("Delete File"), - message: $t("Delete {filename} forever?", { filename }), - confirmText: $t("Delete"), - danger: true, - }); - if (!confirmed) return; - - deleting = true; - try { - const result = await submitBrowserWorkspaceMutation({ - token, - kind: "output.delete", - payload: { fileName: filename }, - }); - const presentation = showWorkspaceResult(result, { - remoteCommittedMessageKey: "Deleted file successfully", - }); - if (presentation.remoteCommitted) await refreshWorkspace(); - } catch (err) { - setStatus($t("Delete failed"), "error"); - } finally { - deleting = false; - } -} - -async function cleanupBootstrapMarker() { - const token = $authState.token; - const gistId = $appState.activeGistId; - if (!token || !gistId || bootstrapStatus !== "stale") return; - const confirmed = await requestConfirm({ - title: $t("Clean Up Bootstrap Marker"), - message: $t( - "Remove the stale bootstrap marker? Workspace config and the immutable V1 backup will be preserved.", - ), - confirmText: $t("Remove Stale Marker"), - danger: true, - }); - if (!confirmed) return; - - deleting = true; - try { - const result = await submitBrowserWorkspaceMutation({ - token, - kind: "workspace.bootstrap.cleanup", - payload: {}, - }); - const presentation = showWorkspaceResult(result, { - remoteCommittedMessageKey: "Stale bootstrap marker removed", - }); - if (presentation.remoteCommitted) await refreshWorkspace(); - } catch (error) { - setStatus( - workspaceFailureMessage(error, "Bootstrap cleanup failed"), - "error", - ); - } finally { - deleting = false; - } -} @@ -205,7 +107,7 @@ async function cleanupBootstrapMarker() {
- + {#if $appState.activeGistId} {/if} @@ -214,7 +116,6 @@ async function cleanupBootstrapMarker() { {loading ? $t("Refreshing...") : $t("Refresh")} -
@@ -225,9 +126,7 @@ async function cleanupBootstrapMarker() {

{bootstrapStatus === "stale" ? $t("Stale marker") : bootstrapStatus === "incomplete" ? $t("Initialization incomplete") : $t("Invalid bootstrap workspace")}

{bootstrapStatus === "stale" ? $t("The Workspace is valid, but its bootstrap marker was not removed.") : bootstrapStatus === "incomplete" ? $t("Resume setup to create the Workspace configuration atomically.") : $t("Bootstrap initialization requires the marker to be the only file.")}

- {#if bootstrapStatus === "stale"} - - {:else if bootstrapStatus === "incomplete"} + {#if bootstrapStatus === "incomplete"} {$t("Settings")} {/if}
@@ -239,6 +138,7 @@ async function cleanupBootstrapMarker() { {$t("Repository Files")}
+ {$t("Read-only")} {workspaceFileCount}
@@ -304,11 +204,6 @@ async function cleanupBootstrapMarker() { {/if} - {#if canDeleteWorkspaceFile(gistFile.filename)} - - {:else if gistFile.filename === WORKSPACE_BOOTSTRAP_FILE_NAME && bootstrapStatus === "stale"} - - {/if} diff --git a/src/routes/gists/page-source.test.ts b/src/routes/gists/page-source.test.ts index 164a84d..481ad5a 100644 --- a/src/routes/gists/page-source.test.ts +++ b/src/routes/gists/page-source.test.ts @@ -39,10 +39,13 @@ test("gists page shows an explicit loading state while workspace files load", () ); }); -test("gists output deletion is submitted through the Workspace coordinator", () => { - expect(gistsPageSource).toContain("submitBrowserWorkspaceMutation"); - expect(gistsPageSource).toContain('kind: "output.delete"'); - expect(gistsPageSource).not.toContain("deleteWorkspaceOutputFile"); +test("gists page is a read-only file viewer without mutation or confirmation handlers", () => { + expect(gistsPageSource).toContain('$t("Read-only")'); + expect(gistsPageSource).not.toContain("submitBrowserWorkspaceMutation"); + expect(gistsPageSource).not.toContain("requestConfirm"); + expect(gistsPageSource).not.toContain("deleteFile"); + expect(gistsPageSource).not.toContain("cleanupBootstrapMarker"); + expect(gistsPageSource).not.toContain("canDeleteWorkspaceFile"); }); test("gists reads use the authoritative Workspace binding", () => { @@ -62,21 +65,18 @@ test("gists page uses only the transactional browser persistence boundary", () = expect(gistsPageSource).not.toContain("WorkspaceMutationQueue"); expect(gistsPageSource).not.toContain("mutationDependencies"); expect(gistsPageSource).toContain("getBrowserWorkspaceBinding"); - expect(gistsPageSource).toContain("submitBrowserWorkspaceMutation("); + expect(gistsPageSource).toContain("initializeBrowserWorkspacePersistence()"); }); -test("gists page protects every reserved Workspace file", () => { - expect(gistsPageSource).toContain("canDeleteWorkspaceFile(filename)"); - expect(gistsPageSource).toContain( - "canDeleteWorkspaceFile(gistFile.filename)", - ); +test("gists page labels reserved, managed, and external files", () => { + expect(gistsPageSource).toContain("WORKSPACE_RESERVED_FILE_NAMES.has"); expect(gistsPageSource).toContain("V1 Migration Backup"); expect(gistsPageSource).toContain("Bootstrap Marker"); expect(gistsPageSource).toContain("Managed Output"); expect(gistsPageSource).toContain("External File"); }); -test("gists page sends incomplete setup to Settings and coordinates stale marker cleanup", () => { +test("gists page keeps bootstrap warnings and sends incomplete setup to Settings", () => { expect(gistsPageSource).toContain('bootstrapStatus === "stale"'); expect(gistsPageSource).toContain('$t("Initialization incomplete")'); expect(gistsPageSource).not.toContain("resumeBootstrapInitialization"); @@ -84,8 +84,7 @@ test("gists page sends incomplete setup to Settings and coordinates stale marker expect(gistsPageSource).not.toContain("current local business data"); expect(gistsPageSource).toContain('href="/auth"'); expect(gistsPageSource).toContain("requireWorkspaceIdentity"); - expect(gistsPageSource).toContain('kind: "workspace.bootstrap.cleanup"'); - expect(gistsPageSource).toContain("requestConfirm({"); + expect(gistsPageSource).not.toContain('kind: "workspace.bootstrap.cleanup"'); expect(gistsPageSource).toContain("migration_backup_conflict"); expect(gistsPageSource).toContain("invalid_bootstrap_marker"); }); From d0339c3d02ff6ded1781657c61aee95562436172 Mon Sep 17 00:00:00 2001 From: KnowSky404 Date: Sat, 31 Oct 2026 15:20:30 +0800 Subject: [PATCH 3/4] test(workspace): drain peer connections before teardown --- e2e/workspace-reset.spec.ts | 2 ++ 1 file changed, 2 insertions(+) diff --git a/e2e/workspace-reset.spec.ts b/e2e/workspace-reset.spec.ts index 1984d77..3a5228e 100644 --- a/e2e/workspace-reset.spec.ts +++ b/e2e/workspace-reset.spec.ts @@ -437,6 +437,8 @@ test("device reset removes cached business state in another open tab", async ({ expect(peerRecord.binding).toBeNull(); expect((peerRecord.snapshot as JsonRecord).nodes).toEqual([]); expect(writes).toEqual([]); + // Drain connections before closing the peer in the local Worker harness. + await peer.waitForLoadState("networkidle"); await peer.close(); }); From f526632a665390d748bec1b1e663e6d341241490 Mon Sep 17 00:00:00 2001 From: KnowSky404 Date: Sat, 31 Oct 2026 15:32:52 +0800 Subject: [PATCH 4/4] fix(workspace): retry concurrent cloud loads once --- docs/wiki/Changelog.md | 2 + docs/wiki/Changelog.zh-CN.md | 2 + src/lib/workspace-cloud-session.test.ts | 132 ++++++++++++++++++++++++ src/lib/workspace-cloud-session.ts | 131 +++++++++++++---------- 4 files changed, 213 insertions(+), 54 deletions(-) diff --git a/docs/wiki/Changelog.md b/docs/wiki/Changelog.md index 6b3527b..dd62c36 100644 --- a/docs/wiki/Changelog.md +++ b/docs/wiki/Changelog.md @@ -17,6 +17,8 @@ production deployment and real-provider acceptance require separate evidence. active delivery or concurrent changes. Stale tabs cannot restore the old binding. - Kept reset local: authentication clears only after storage commits, and a separate connection loads cloud data or initializes an empty Workspace. +- Retry a concurrent cloud load once against the original Workspace when another + tab updates local delivery state; a reset or changed binding still stops stale loads. ### 2026-10-31 - Read-only Gist file viewer diff --git a/docs/wiki/Changelog.zh-CN.md b/docs/wiki/Changelog.zh-CN.md index d0dcbb4..1223980 100644 --- a/docs/wiki/Changelog.zh-CN.md +++ b/docs/wiki/Changelog.zh-CN.md @@ -13,6 +13,8 @@ - 以事务清除当前绑定、本机业务缓存和当前完整队列;保留历史队列与隔离证据, 正在发送或并发变化时拒绝重置,旧标签页不能恢复已放弃的绑定。 - 重置仅作用于本地,存储提交后才清除认证;用户再次连接时才加载云端或初始化空工作区。 +- 并行打开多个标签页时,本机发送状态的正常并发更新会触发一次原工作区的云端重读; + 重置或绑定变化仍会阻止旧加载恢复数据。 ### 2026-10-31 - Gists 文件页面改为只读 diff --git a/src/lib/workspace-cloud-session.test.ts b/src/lib/workspace-cloud-session.test.ts index 271ea31..adc4040 100644 --- a/src/lib/workspace-cloud-session.test.ts +++ b/src/lib/workspace-cloud-session.test.ts @@ -144,11 +144,102 @@ function deferred() { } describe("cloud Workspace session", () => { + it("retries a concurrent peer refresh of the same Gist with a fresh cloud read", async () => { + const store = persistence(); + const firstStarted = deferred(); + const secondStarted = deferred(); + const firstResponse = deferred(); + const secondResponse = deferred(); + let reads = 0; + let writes = 0; + const targets: string[] = []; + const noWrites: typeof fetch = async () => { + writes += 1; + throw new Error("Refreshing peer caches must not write cloud data"); + }; + const first = setup( + store, + async (_token, gistId) => { + reads += 1; + targets.push(gistId); + firstStarted.resolve(); + return firstResponse.promise; + }, + noWrites, + ); + let secondReads = 0; + const second = setup( + store, + async (_token, gistId) => { + reads += 1; + secondReads += 1; + targets.push(gistId); + secondStarted.resolve(); + return secondReads === 1 + ? secondResponse.promise + : snapshot(document(1, [node("fresh-peer-retry")])); + }, + noWrites, + ); + const firstLoad = first.refreshCloudWorkspace("fixture-token"); + const secondLoad = second.refreshCloudWorkspace("fixture-token"); + await Promise.all([firstStarted.promise, secondStarted.promise]); + firstResponse.resolve(snapshot()); + expect(await firstLoad).toBe(true); + secondResponse.resolve(snapshot()); + expect(await secondLoad).toBe(true); + expect(first.status().phase).toBe("ready"); + expect(second.status().phase).toBe("ready"); + expect(reads).toBe(3); + expect(targets).toEqual([GIST_ID, GIST_ID, GIST_ID]); + expect(writes).toBe(0); + expect(second.state().nodes.map((item) => item.id)).toEqual([ + "fresh-peer-retry", + ]); + expect((await store.read()).workspaces[WORKSPACE_ID]?.mutations).toEqual( + [], + ); + }); + + it("bounds concurrent cloud refresh retries to one fresh attempt", async () => { + const store = persistence(); + let reads = 0; + let writes = 0; + const targets: string[] = []; + const session = setup( + store, + async (_token, gistId) => { + reads += 1; + targets.push(gistId); + const peerDocument = document(reads, [node(`peer-${reads}`)]); + await store.rebindWorkspace({ + snapshot: state(peerDocument), + binding: createWorkspaceV2LocalState(GIST_ID, { + baseline: peerDocument, + }), + }); + return snapshot(peerDocument); + }, + async () => { + writes += 1; + throw new Error("Contended refresh must not publish"); + }, + ); + expect(await session.refreshCloudWorkspace("fixture-token")).toBe(false); + expect(reads).toBe(2); + expect(targets).toEqual([GIST_ID, GIST_ID]); + expect(writes).toBe(0); + expect(session.status().phase).toBe("error"); + expect((await store.read()).binding?.revision).toBe(2); + }); + it("does not restore a binding when a pre-reset cloud read completes without a peer event", async () => { const store = persistence(); const readStarted = deferred(); const remote = deferred(); + let reads = 0; const session = setup(store, async () => { + reads += 1; readStarted.resolve(); return remote.promise; }); @@ -167,6 +258,47 @@ describe("cloud Workspace session", () => { expect((await store.read()).binding).toBeNull(); expect((await store.read()).snapshot?.nodes).toEqual([]); expect(session.status().phase).not.toBe("ready"); + expect(reads).toBe(1); + }); + + it("does not retry or follow a different Gist after the original connection changes", async () => { + const store = persistence(); + const readStarted = deferred(); + const remote = deferred(); + const targets: string[] = []; + const session = setup(store, async (_token, gistId) => { + targets.push(gistId); + readStarted.resolve(); + return remote.promise; + }); + const loading = session.refreshCloudWorkspace("fixture-token"); + await readStarted.promise; + const before = await store.read(); + await store.resetWorkspace({ + expected: { + snapshot: before.snapshot, + binding: before.binding, + queue: null, + }, + }); + const otherGistId = "different-cloud-gist"; + const otherDocument = { ...document(), workspaceId: `gist:${otherGistId}` }; + await store.rebindWorkspace({ + snapshot: hydrateAppStateFromWorkspaceDocument( + createDefaultWorkspaceState(NOW), + otherDocument, + otherGistId, + ), + binding: createWorkspaceV2LocalState(otherGistId, { + baseline: otherDocument, + }), + }); + const changed = await store.read(); + remote.resolve(snapshot(document(2))); + expect(await loading).toBe(false); + expect(targets).toEqual([GIST_ID]); + expect(await store.read()).toEqual(changed); + expect(session.status().phase).not.toBe("ready"); }); it("revalidates only the saved cloud Gist and replaces the browser cache", async () => { diff --git a/src/lib/workspace-cloud-session.ts b/src/lib/workspace-cloud-session.ts index 58cd139..8cfb24f 100644 --- a/src/lib/workspace-cloud-session.ts +++ b/src/lib/workspace-cloud-session.ts @@ -10,7 +10,10 @@ import { type WorkspaceCloudStatus, workspaceCloudStatus, } from "$lib/workspace-cloud-status"; -import type { BrowserWorkspacePersistence } from "$lib/workspace-persistence"; +import { + type BrowserWorkspacePersistence, + WorkspaceConcurrentUpdateError, +} from "$lib/workspace-persistence"; import { getBrowserWorkspacePersistence } from "$lib/workspace-persistence-browser"; import { createWorkspaceSettingsController } from "$lib/workspace-settings-controller"; @@ -88,62 +91,82 @@ export function createCloudWorkspaceSession( const workspaceId = `gist:${gistId}`; const persistence = dependencies.persistence ?? getBrowserWorkspacePersistence(); - const queue = view.record.workspaces[workspaceId]; - if (queue?.mutations.length) { - if (view.record.binding?.syncMode !== "automatic") { - setStatus({ phase: "error", message: RETAINED_CHANGES_MESSAGE }); - return false; - } - if (queue.delivery.blocked?.disposition === "auth-required") { - await persistence.resumeWorkspaceAfterAuth(workspaceId); + for (let attempt = 0; attempt < 2; attempt += 1) { + try { + const queue = view.record.workspaces[workspaceId]; + if (queue?.mutations.length) { + if (view.record.binding?.syncMode !== "automatic") { + setStatus({ phase: "error", message: RETAINED_CHANGES_MESSAGE }); + return false; + } + if (queue.delivery.blocked?.disposition === "auth-required") { + await persistence.resumeWorkspaceAfterAuth(workspaceId); + if (!isCurrent()) return false; + } + const target = queue.mutations.at(-1); + if (!target) throw new Error(PENDING_MESSAGE); + const result = await commitQueuedBrowserWorkspaceMutation( + { token, mutationId: target.mutationId }, + { + persistence, + getState: dependencies.getState, + setState: publishState, + fetchImpl: deliverWithCurrentSession, + }, + ); + if (!isCurrent()) return false; + if (result.status !== "remote-committed") { + setStatus({ phase: "error", message: PENDING_MESSAGE }); + return false; + } + view = await controller.refresh(); + if (!isCurrent()) return false; + if (view.record.binding?.workspaceId !== workspaceId) { + throw new Error(LOAD_FAILED_MESSAGE); + } + } + const readCloudSnapshot = + dependencies.readCloudSnapshot ?? + (async (currentToken, currentGistId, current) => { + const gist = await getGist(currentToken, currentGistId); + return readBrowserWorkspaceSnapshot(currentToken, gist, current); + }); + const snapshot = await readCloudSnapshot( + token, + gistId, + dependencies.getState(), + ); if (!isCurrent()) return false; - } - const target = queue.mutations.at(-1); - if (!target) throw new Error(PENDING_MESSAGE); - const result = await commitQueuedBrowserWorkspaceMutation( - { token, mutationId: target.mutationId }, - { - persistence, - getState: dependencies.getState, - setState: publishState, - fetchImpl: deliverWithCurrentSession, - }, - ); - if (!isCurrent()) return false; - if (result.status !== "remote-committed") { - setStatus({ phase: "error", message: PENDING_MESSAGE }); - return false; - } - view = await controller.refresh(); - if (!isCurrent()) return false; - if (view.record.binding?.workspaceId !== workspaceId) { - throw new Error(LOAD_FAILED_MESSAGE); + if (snapshot.origin !== "v2") { + setStatus({ phase: "error", message: MIGRATION_MESSAGE }); + return false; + } + await controller.refreshCloud(snapshot, gistId, { + snapshot: view.record.snapshot, + binding: view.record.binding, + queue: view.record.workspaces[workspaceId] ?? null, + }); + if (!isCurrent()) return false; + setStatus({ phase: "ready", message: null }); + return true; + } catch (error) { + if ( + !(error instanceof WorkspaceConcurrentUpdateError) || + attempt !== 0 || + !isCurrent() + ) { + throw error; + } + view = await controller.refresh(); + if ( + !isCurrent() || + view.record.binding?.workspaceId !== workspaceId + ) { + throw error; + } } } - const readCloudSnapshot = - dependencies.readCloudSnapshot ?? - (async (currentToken, currentGistId, current) => { - const gist = await getGist(currentToken, currentGistId); - return readBrowserWorkspaceSnapshot(currentToken, gist, current); - }); - const snapshot = await readCloudSnapshot( - token, - gistId, - dependencies.getState(), - ); - if (!isCurrent()) return false; - if (snapshot.origin !== "v2") { - setStatus({ phase: "error", message: MIGRATION_MESSAGE }); - return false; - } - await controller.refreshCloud(snapshot, gistId, { - snapshot: view.record.snapshot, - binding: view.record.binding, - queue: view.record.workspaces[workspaceId] ?? null, - }); - if (!isCurrent()) return false; - setStatus({ phase: "ready", message: null }); - return true; + throw new Error(LOAD_FAILED_MESSAGE); } catch { if (isCurrent()) { setStatus({ phase: "error", message: LOAD_FAILED_MESSAGE });