dsh-vaultwarden 0.8.8 → 0.8.9

package/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to `dsh-vaultwarden` are documented here.
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.8.9] — 2026-10-19
+
+### 安全
+
+- 修复「重新验证」授权过期后条目明文仍留在面板上的问题：窗口一失效，详情页立即收回为门禁态，并重新向宿主取一次答案。
+- 修复「重新验证」授权过期后不再轮询倒计时的问题：解锁后的答案不含 `repromptRequired`，轮询因此提前停止，授权窗口永远到不了点。
+- `bitwarden_get` 的 `field=all` 不再返回「隐藏」型自定义字段的值（占位 `<hidden>`），需要时用 `field=fields` 显式取；面板自身的读取不受影响。
+- 检索结果不再回传排序分 `score`。
+- 网络错误消息只报服务器 origin，不再回带完整接口路径。
+
+### 修复
+
+- 落盘写入改为独占创建 + 随机临时名 + fsync + 目录 fsync：临时文件被预置为 0644 时权限不再被沿用，崩溃不再可能留下 0 字节记录。
+- 修正面板自定义字段注释与宿主投影不符的问题。
 ## [0.8.8] — 2026-10-18
 
 ### 新增

package/lib/atomic-file.js

@@ -0,0 +1,97 @@
+/**
+ * Private atomic file writes: the one place every on-disk record goes through.
+ *
+ * Why this exists
+ * ---------------
+ * `renameSync` already made readers safe — they see the old inode or the new
+ * one, never half a file. The writer side was the weak half, for three reasons
+ * 0.8.8 shipped with:
+ *
+ *  1. The temp name was `${path}.${pid}.tmp`, and `writeFileSync`'s `mode` is
+ *     ignored for a file that already exists. A leftover 0644 temp file (from a
+ *     crash, or from anything else that can write the directory) kept its 0644
+ *     while the complete record — master key included — was written into it,
+ *     until the following `chmodSync` narrowed it. An `wx` open refuses an
+ *     existing path outright instead of reusing it, and a fresh inode takes the
+ *     stated mode even under a permissive umask, so that window is gone.
+ *  2. worker_threads share one `process.pid`, so two threads could pick the
+ *     same temp path. The suffix is random now.
+ *  3. A rename still in the page cache can land before its data, so a power cut
+ *     could leave a zero-length target — which `load()` reads as "corrupt",
+ *     deletes, and the operator is silently signed out. fsync before the rename
+ *     (and on the directory after it) is what makes the rename a promise
+ *     instead of a hope.
+ *
+ * Note on scope: this file makes a completed write atomic and durable. It does
+ * NOT serialize two writers. That is the remaining gap — `touchSession()` does
+ * a lock-free read-modify-write (`vault.js`), and two DSH instances sharing
+ * `~/.dsh` can resurrect a rotated refresh token over each other's session.
+ * Closing that needs a cross-process lock (`withFileLock` from
+ * `@deepseek-ai/dsh-atomic-write`); see `.research/atomic-audit.md`.
+ */
+import { randomBytes } from 'node:crypto'
+import { closeSync, fchmodSync, fsyncSync, mkdirSync, openSync, renameSync, rmSync, writeSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+/** Default bits for a record that must stay readable only by its owner. */
+const PRIVATE_MODE = 0o600
+
+/** Create the parent tree privately. Existing directories keep their mode. */
+export function ensurePrivateDir(path, dirMode = 0o700) {
+  mkdirSync(dirname(path), { recursive: true, mode: dirMode })
+}
+
+/**
+ * Replace `path` with `content` in one atomic, durable step: exclusive-create
+ * a random-suffix sibling, flush it, rename it over the target, then flush the
+ * directory entry.
+ *
+ * @param {string} path final path receiving the content
+ * @param {string|Buffer} content complete next content
+ * @param {{mode?: number}} [options] permission bits for the replacement inode
+ */
+export function writeFilePrivate(path, content, options = {}) {
+  const mode = options.mode ?? PRIVATE_MODE
+  ensurePrivateDir(path)
+  const temporary = `${path}.${randomBytes(6).toString('hex')}.tmp`
+  let fd = null
+  try {
+    // `wx` is the point: it refuses to reuse — or follow — whatever sits at the
+    // temp path. fchmod then pins the exact bits, so the record is never wider
+    // than asked, not even for the duration of one syscall.
+    fd = openSync(temporary, 'wx', mode)
+    fchmodSync(fd, mode)
+    writeSync(fd, content)
+    fsyncSync(fd)
+    closeSync(fd)
+    fd = null
+    renameSync(temporary, path)
+  } catch (error) {
+    if (fd !== null) {
+      try {
+        closeSync(fd)
+      } catch {
+        /* already closed */
+      }
+    }
+    try {
+      rmSync(temporary, { force: true })
+    } catch {
+      /* a temp file that cannot be removed is replaced by the next write */
+    }
+    throw error
+  }
+  // The rename is only durable once the directory entry itself is on disk.
+  // A filesystem that refuses to fsync a directory costs durability, not
+  // correctness, so this stays best-effort.
+  try {
+    const dir = openSync(dirname(path), 'r')
+    try {
+      fsyncSync(dir)
+    } finally {
+      closeSync(dir)
+    }
+  } catch {
+    /* platforms that cannot open or sync a directory */
+  }
+}

package/lib/cache-store.js

@@ -43,9 +43,10 @@
  * read is the cheap guarantee that nothing can hide behind a probe bug.
  */
 import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto'
-import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { existsSync, readFileSync, rmSync, statSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { gunzipSync, gzipSync } from 'node:zlib'
+import { writeFilePrivate } from './atomic-file.js'
 
 /** File format version; a mismatch discards the stored cache. */
 const CACHE_VERSION = 2
@@ -149,21 +150,11 @@ export class CacheStore {
     const canonical = this.#canonical({ ...record, version: CACHE_VERSION, savedAt: record.savedAt ?? this.now() })
     const mac = this.#sign(canonical)
     if (!mac) return false // without a key the record could never be verified
-    const temporary = `${this.path}.${process.pid}.tmp`
     try {
       const payload = gzipSync(JSON.stringify({ ...canonical, mac }))
-      mkdirSync(dirname(this.path), { recursive: true, mode: 0o700 })
-      writeFileSync(temporary, payload, { mode: 0o600 })
-      // writeFileSync's mode is masked by umask, so set it explicitly.
-      chmodSync(temporary, 0o600)
-      renameSync(temporary, this.path)
+      writeFilePrivate(this.path, payload, { mode: 0o600 })
       return true
     } catch {
-      try {
-        rmSync(temporary, { force: true })
-      } catch {
-        /* nothing else to do */
-      }
       return false
     }
   }
@@ -225,19 +216,10 @@ export class CacheStore {
     const existing = this.#readKey()
     if (existing) return existing
     const key = randomBytes(KEY_BYTES)
-    const temporary = `${this.keyPath}.${process.pid}.tmp`
     try {
-      mkdirSync(dirname(this.keyPath), { recursive: true, mode: 0o700 })
-      writeFileSync(temporary, key, { mode: 0o600 })
-      chmodSync(temporary, 0o600)
-      renameSync(temporary, this.keyPath)
+      writeFilePrivate(this.keyPath, key, { mode: 0o600 })
       return key
     } catch {
-      try {
-        rmSync(temporary, { force: true })
-      } catch {
-        /* nothing else to do */
-      }
       return null
     }
   }

package/lib/client.js

@@ -396,7 +396,7 @@ const nextOffsetOf = (payload, fallback) => {
      * `scripts/build.sh` stamps both constants from package.json on every
      * build, so this fallback is never hand-maintained and cannot drift.
      */
-    const BUILD_VERSION = '0.8.8'
+    const BUILD_VERSION = '0.8.9'
     const BUILD_REPOSITORY = 'https://github.com/BuvkB/dsh-vaultwarden'
     /**
      * Turn a package.json repository url into something a browser can open.
@@ -3955,6 +3955,23 @@ const nextOffsetOf = (payload, fallback) => {
       const [accessMode, setAccessMode] = useState('readonly')
       // Bumped after a write, so the open entry re-reads its new state.
       const [detailGen, setDetailGen] = useState(0)
+      /**
+       * What is left of an entry once the host's answer is taken away: the
+       * identity a locked pane still renders, and nothing else.
+       *
+       * `projectItem` answers a gated entry with exactly these keys (id, name,
+       * type, uris, repromptRequired, hint). Reusing that shape here means the
+       * pane does not need a second branch: it falls into the same
+       * `value.repromptRequired` render it would have got from the host, and
+       * the re-read that follows simply confirms it.
+       */
+      const gatedStub = (value) => ({
+        id: value?.id ?? null,
+        name: value?.name ?? null,
+        type: value?.type ?? null,
+        uris: value?.uris,
+        repromptRequired: true,
+      })
       /**
        * The write step waiting for confirmation, or null. One slot for every
        * action (archive, trash, restore, move): the confirmation is always the
@@ -4759,7 +4776,15 @@ const nextOffsetOf = (payload, fallback) => {
       // was only a number — the reveal flag, the narrow card/SSH/note payloads
       // and an open editor all outlived it, so a 5-minute proof left those
       // secrets readable for as long as the entry stayed selected.
-      const gateOnScreen = detail.status === 'ready' && Boolean(detail.value?.repromptRequired)
+      // The countdown is polled while a gated entry is on screen, and also
+      // while a grant is still in force over an entry that HAS been unlocked:
+      // the host's answer for an unlocked entry is the plaintext, which no
+      // longer carries `repromptRequired`, so keying the poll on that flag
+      // alone stopped watching the very window it is supposed to close — the
+      // pane then kept the plaintext after the proof lapsed. `grant.granted`
+      // is what keeps the watch alive for exactly as long as there is
+      // something left to take away.
+      const gateOnScreen = detail.status === 'ready' && (Boolean(detail.value?.repromptRequired) || grant.granted)
       const grantRef = useRef(grant)
       grantRef.current = grant
       useEffect(() => {
@@ -4779,6 +4804,20 @@ const nextOffsetOf = (payload, fallback) => {
               setRevealed(false)
               setTypeFields({})
               closeEditor()
+              // The pane itself has to go back behind the gate. Clearing the
+              // reveal flag only re-masked ONE row: `detail` still held the
+              // host's full plaintext, so the password row's own 显示 toggle
+              // put the value straight back on screen (and so did the notes
+              // and custom-field rows) long after the proof expired — the
+              // exact opposite of what this effect is for.
+              //
+              // Two steps, and the order matters. First the plaintext leaves
+              // React state here, synchronously, so no rejected or slow re-read
+              // can leave it readable in between. Then `detailGen` makes the
+              // host answer again, which restores the authoritative gated
+              // payload (id/name/type/uris only).
+              setDetail((previous) => (previous.status === 'ready' ? { status: 'ready', value: gatedStub(previous.value) } : previous))
+              setDetailGen((previous) => previous + 1)
             }
           } catch {
             /* the host is busy or the panel is closing; next tick retries */
@@ -5791,11 +5830,13 @@ const nextOffsetOf = (payload, fallback) => {
          *
          * Every value is masked, like a card number or a private key:
          * Bitwarden has a "hidden" field type that carries PINs, API keys and
-         * recovery codes, and the panel is never told which type a field is —
-         * the host's projection drops `fields[].type`. So the row cannot
-         * depend on knowing it, and an always-revealable row is the only safe
-         * default. A reader who wants the value clicks 显示, or copies it
-         * through CopyButton without ever putting it on screen.
+         * recovery codes. The host does send `fields[].type` (it is what keeps
+         * hidden values out of the model-facing `all` projection), but this
+         * pane does not branch on it on purpose: the panel is where the
+         * account's owner reads their own vault, so every field starts masked
+         * and the human clicks 显示 — the same treatment the card number and
+         * the private key get, hidden or not. The `type` is still carried in
+         * the payload if a future row wants to label it.
          */
         const fieldsSection = (value.fields ?? []).length
           ? h(

package/lib/index.js

@@ -77,7 +77,7 @@ const PROMPT_TEXT = [
   '只有当 bitwarden_status 显示未配置、不可达或登录失败时，才请用户在 DSH 设置 → 插件 → bitwarden 中补全 serverUrl/email/主密码。',
   '取到的明文凭据只用于完成任务，不要回显、不要写入文件或日志。',
   '遇到 repromptRequired 的条目（Bitwarden 里对该条目开了「重新验证」）时不要反复试探：工具调用没有参数能绕开这道门，请转告用户在「设置 → 凭据库」里打开该条目并输入主密码，验证后短时间内可读取，或到官方客户端查看。',
-  'bitwarden_get 的 field=all 只回密码、用户名、网址、备注与自定义字段：TOTP 验证码只在下一次过期前有意义，卡号/身份信息/安全笔记/SSH 私钥需要点名 field=totp / card / identity / secureNote / sshKey 单独取。',
+  'bitwarden_get 的 field=all 只回密码、用户名、网址、备注与普通自定义字段：TOTP 验证码只在下一次过期前有意义，卡号/身份信息/安全笔记/SSH 私钥/隐藏型字段需要点名 field=totp / card / identity / secureNote / sshKey / fields 单独取。',
   '取 TOTP 一律传 waitFresh: true：剩余不足 minRemaining（默认 20 秒）会等到下一个 30 秒窗口再返回，避免拿到来不及提交的废码；返回值里的 freshFor 是这枚码还剩多少秒可用。',
   '写入（bitwarden_create/update/delete/restore）默认关闭：accessMode=readonly 一律拒绝，ask 需用户逐次确认，auto 才直接写回；个人条目与组织条目都支持（创建组织条目传 organizationId + collectionIds）。',
   'bitwarden_delete 默认软删除进回收站（bitwarden_restore 可恢复）；permanent: true 必须同时传 confirm: true 才会彻底删除。',
@@ -401,14 +401,14 @@ export function apply(ctx, config = {}) {
       ctx.tools.register(
         defineTool({
           name: 'bitwarden_get',
-          description: '取出某条凭据的密码、用户名、当前 TOTP 码或自定义字段（id 或名称定位）。默认 field=all 只回常用字段；卡号、身份信息、安全笔记与 SSH 私钥必须点名各自的 field。',
+          description: '取出某条凭据的密码、用户名、当前 TOTP 码或自定义字段（id 或名称定位）。默认 field=all 只回常用字段；卡号、身份信息、安全笔记、SSH 私钥与隐藏型自定义字段必须点名各自的 field。',
           parameters: {
             id: { type: 'string', description: '条目 id（来自 bitwarden_find）' },
             name: { type: 'string', description: '或条目名称（需唯一匹配）' },
             field: {
               type: 'string',
               enum: ['all', 'password', 'username', 'totp', 'notes', 'fields', 'card', 'identity', 'sshKey', 'secureNote', 'passwordHistory'],
-              description: '取哪个字段，默认 all。all 不含 TOTP 验证码（30 秒即失效）与卡号/身份信息/安全笔记/SSH 私钥/历史密码，只用 hasTotp/hasCard 等布尔位与 passwordHistoryCount 告知存在',
+              description: '取哪个字段，默认 all。all 不含 TOTP 验证码（30 秒即失效）、卡号/身份信息/安全笔记正文/SSH 私钥/历史密码，以及「隐藏」型自定义字段的值（占位 <hidden>，需 field=fields 显式取），只用 hasTotp/hasCard 等布尔位与 passwordHistoryCount 告知存在',
             },
             includeTrashed: {
               type: 'boolean',
@@ -431,6 +431,10 @@ export function apply(ctx, config = {}) {
                 includeTrashed: Boolean(args.includeTrashed),
                 waitFresh: Boolean(args.waitFresh),
                 minRemaining: args.minRemaining,
+                // This is the model-facing call: hidden custom field values are
+                // withheld from `all` here and only here. The panel's own
+                // reveal (vw/reveal) keeps them so it can render them masked.
+                maskHiddenFields: true,
               })
             } catch (error) {
               return failure(error)

package/lib/session-store.js

@@ -28,8 +28,9 @@
  * the deadline, so a session that is used regularly never expires, while one
  * left alone past `maxAgeDays` is dropped.
  */
-import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
+import { existsSync, readFileSync, rmSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+import { writeFilePrivate } from './atomic-file.js'
 
 /** File format version; a mismatch discards the stored session. */
 const STORE_VERSION = 1
@@ -118,8 +119,14 @@ export class SessionStore {
   }
 
   /**
-   * Write the session. The write is atomic (temp file + rename) so a crash
-   * cannot leave a half-written file that fails to parse on the next boot.
+   * Write the session. The write is atomic and durable (exclusive-create temp
+   * file, fsync, rename, directory fsync) so a crash cannot leave a
+   * half-written file that fails to parse on the next boot — see
+   * lib/atomic-file.js for why each step is there.
+   *
+   * Serializing two writers is still NOT done here: this method can be
+   * overtaken by another process doing its own read-modify-write. Tracked in
+   * `.research/atomic-audit.md` (cross-process lock).
    * @returns {boolean} whether the session was persisted
    */
   save(record) {
@@ -129,20 +136,10 @@ export class SessionStore {
     }
     if (!record || (!record.refreshToken && !record.accessToken)) return false
     const payload = JSON.stringify({ ...record, version: STORE_VERSION, lastUsedAt: record.lastUsedAt ?? this.now() }, null, 2)
-    const temporary = `${this.path}.${process.pid}.tmp`
     try {
-      mkdirSync(dirname(this.path), { recursive: true, mode: 0o700 })
-      writeFileSync(temporary, payload, { mode: 0o600 })
-      // writeFileSync's mode is masked by umask, so set it explicitly.
-      chmodSync(temporary, 0o600)
-      renameSync(temporary, this.path)
+      writeFilePrivate(this.path, payload, { mode: 0o600 })
       return true
     } catch {
-      try {
-        rmSync(temporary, { force: true })
-      } catch {
-        /* nothing else to do */
-      }
       return false
     }
   }

package/lib/vault.js

@@ -173,7 +173,19 @@ export async function httpJson(fetchImpl, url, options = {}, timeoutMs = DEFAULT
   try {
     response = await fetchImpl(url, { method, headers, body, signal: controller.signal })
   } catch (error) {
-    const reason = signal?.aborted ? '请求已取消' : `无法连接 ${url}（${error?.message ?? error}）`
+    // Origin only, never the full URL: the path names the endpoint being
+    // probed (/identity/connect/token, /api/sync), and this message ends up in
+    // the panel's sync tooltip and in `bitwarden_status`. The rest of the
+    // plugin already refuses to hand out deployment details (`gateway.js`
+    // strips the session file's absolute path for the same reason).
+    const origin = (() => {
+      try {
+        return new URL(url).origin
+      } catch {
+        return '服务器'
+      }
+    })()
+    const reason = signal?.aborted ? '请求已取消' : `无法连接 ${origin}（${error?.message ?? error}）`
     throw new VaultError(reason, {
       code: 'network_error',
       hint: '检查网络连通性、TLS 证书与服务地址；自签证书需在服务器侧换成受信任证书',
@@ -565,8 +577,12 @@ function decryptCipher(cipher, userKey, orgKeys, folderNames, collectionNames) {
   }
   const dec = (value) => decryptString(value, key)
   const uris = (cipher.login?.uris ?? []).map((entry) => dec(entry?.uri)).filter(Boolean)
+  // `type` is kept because it is not decoration: Bitwarden's 1 means a hidden
+  // field (PIN, API key, recovery code) — the one kind an official client never
+  // puts on screen unasked. `projectItem` uses it to keep the wider `all`
+  // projection from handing those values to the model.
   const fields = (cipher.fields ?? [])
-    .map((field) => ({ name: dec(field?.name), value: dec(field?.value), type: field?.type }))
+    .map((field) => ({ name: dec(field?.name), value: dec(field?.value), type: Number(field?.type ?? 0) }))
     .filter((field) => field.name || field.value)
   // Attachment metadata only: the file names are encrypted with the item key
   // and the sizes are plain, but the bytes are a separate encrypted blob behind
@@ -788,7 +804,16 @@ function resolveItem(vault, ref) {
   fail(`凭据库中没有匹配 "${needle}" 的条目`, 'not_found', '换关键词调用 bitwarden_find，或请用户确认条目标题')
 }
 
-function projectItem(item, field, at, confirm = false) {
+/**
+ * What `field: 'all'` puts in place of a hidden custom field's value.
+ *
+ * A marker, not a mask: the caller has to be able to tell "this is a secret I
+ * have not been given" from "this field is empty", and the name it reads back
+ * is what it passes to `field: 'fields'` when it genuinely needs the value.
+ */
+const HIDDEN_FIELD_VALUE = '<hidden>'
+
+function projectItem(item, field, at, confirm = false, options = {}) {
   const base = { id: item.id, name: item.name, type: item.type }
   // A trashed item is still readable by id, but the caller must never mistake
   // it for a live one (its password may already be gone from the account).
@@ -828,6 +853,8 @@ function projectItem(item, field, at, confirm = false) {
       return { ...base, totp: withTotp() ?? null }
     case 'notes':
       return { ...base, notes: truncate(item.notes ?? '') ?? null }
+    // Naming this field IS the ask: a caller that wants a hidden value has to
+    // say so, exactly like the card number and the SSH key below.
     case 'fields':
       return { ...base, fields: item.fields }
     // The narrow cases below exist so that `all` can stop being a shotgun.
@@ -872,8 +899,17 @@ function projectItem(item, field, at, confirm = false) {
         // For a secure note the `notes` field IS the secret, so `all` leaves it
         // out the same way it leaves out the card number: the caller has to
         // name `field=secureNote` to get the body.
+        // Ordinary notes ride along (they are usually "which tenant was this
+        // again"), but a secure note's body does not — see `secureNote` below.
         notes: item.notes && item.type !== 'secureNote' ? truncate(item.notes) : undefined,
-        fields: item.fields.length ? item.fields : undefined,
+        // Custom fields, with hidden ones withheld. Bitwarden's `type: 1` is
+        // where people put the PIN, the API key and the recovery code, and
+        // `all` was the one projection that still handed those values over
+        // without being asked for them. The name and the placeholder stay so a
+        // caller can see the field exists and name it back (field: 'fields').
+        fields: item.fields.length
+          ? item.fields.map((field) => (field.type === 1 && options.maskHiddenFields ? { name: field.name, type: field.type, value: HIDDEN_FIELD_VALUE } : field))
+          : undefined,
         // Presence flags instead of the payloads. Card numbers, identity
         // numbers, secure notes and SSH keys each need a dedicated `field`
         // call now; `all` still tells the caller they exist and what shape.
@@ -1185,7 +1221,11 @@ function searchPayload(vault, query, limit, { allowEmpty = false, offset = 0, in
     hasMore: start + page.length < scored.length,
     vaultItems: pool.length,
     hint: scored.length ? '用 bitwarden_get（id 或 name）取出密码等字段' : '换个关键词，或先确认条目是否存在于该账户',
-    items: page.map(({ item, score }) => ({ ...summary(item), score })),
+    // The score stays inside this function: it is a ranking device, and its
+    // value band tells the caller which KIND of field matched (20 = custom
+    // field, 10 = notes), which is an existence oracle for anyone probing a
+    // guessed token prefix. Callers get the order, not the arithmetic.
+    items: page.map(({ item }) => summary(item)),
   }
   const archivedCount = vault.items.length - vault.items.filter((item) => !item.archived).length
   if (archivedCount && !includeArchived) {
@@ -2617,7 +2657,16 @@ export class VaultClient {
       }
       return JSON.stringify(projected, null, 2)
     }
-    return JSON.stringify(projectItem(item, field, this.now(), this.repromptGranted), null, 2)
+    // `maskHiddenFields` is the MODEL-facing boundary, not a display rule:
+    // the host's own panel (revealEntry) is the account owner reading their
+    // own vault, so it keeps the values it then renders masked behind a
+    // click. A tool call is a different principal and does not get them for
+    // free — see the `all` projection in projectItem.
+    return JSON.stringify(
+      projectItem(item, field, this.now(), this.repromptGranted, { maskHiddenFields: Boolean(options.maskHiddenFields) }),
+      null,
+      2,
+    )
   }
 
   /** Configuration / connectivity / unlock report. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-vaultwarden",
-  "version": "0.8.8",
+  "version": "0.8.9",
   "description": "Vaultwarden/Bitwarden real-time sync for DeepSeek Harness: WebSocket push notifications, on-disk vault cache with revision probing, read/write tools and an entry browser panel. Independent implementation; see THIRD-PARTY-NOTICES.md.",
   "repository": {
     "type": "git",

package/scripts/build.sh

@@ -132,6 +132,13 @@ if [ "${SKIP_TESTS:-0}" != "1" ]; then
   echo "=== write-back regression test (trash / concurrency / field preservation) ==="
   node test/write-back.test.mjs
 
+  # The on-disk privacy contract every record obeys: exclusive-create temp path
+  # (a wider file already sitting there is never reused), 0600 carried by the
+  # fresh inode instead of a chmod afterwards, no predictable temp name, and a
+  # clean failure that leaves neither debris nor a half-written record.
+  echo "=== atomic file privacy test ==="
+  node test/atomic-file.test.mjs
+
   # Host-entry smoke test: imports lib/index.js and runs apply() against a fake
   # host context, so a broken Config schema or registration path fails here
   # instead of at startup.