dscs-server 0.0.1 → 0.1.1

package/dist/sessions.js

@@ -1,8 +1,9 @@
 import { existsSync } from 'node:fs';
-import { assertChain, buildManifest, manifestDigest } from './shared/chain.js';
+import { assertChain, buildManifest, manifestDigest, stableStringify } from './shared/chain.js';
+import { sha256 } from './shared/crypto.js';
 import { SyncError } from './shared/wire.js';
 import { blobPath } from './blobs.js';
-import { DEFAULT_DATASET, bumpRevision, readRevision, withTransaction } from './db.js';
+import { DEFAULT_DATASET, bumpRevision, readAppendRequest, readRevision, withTransaction, writeAppendRequest } from './db.js';
 import { requireLease as requireResourceLease, SYNC_RESOURCE } from './leases.js';
 export const MAX_APPEND_BODY_BYTES = 8 * 1024 * 1024;
 const HASH = /^[0-9a-f]{64}$/u;
@@ -13,6 +14,18 @@ function assertRef(frame, expectedIndex) {
     if (!KEY_ID.test(frame.keyId)) throw new SyncError('bad-request', `帧 ${expectedIndex} 的 keyId 非法`);
     if (!Number.isSafeInteger(frame.bytes) || frame.bytes <= 0) throw new SyncError('bad-request', `帧 ${expectedIndex} 的字节数非法`);
     if (!Number.isSafeInteger(frame.sealedVersion) || frame.sealedVersion < 1) throw new SyncError('bad-request', `帧 ${expectedIndex} 的封帧版本非法`);
+    if (frame.compression === undefined) {
+        if (frame.sealedVersion !== 1 || frame.compressedHash !== undefined) {
+            throw new SyncError('bad-request', `帧 ${expectedIndex} 缺少压缩元数据`);
+        }
+    } else {
+        if (frame.compression !== 'zstd' || frame.sealedVersion < 2) {
+            throw new SyncError('bad-request', `帧 ${expectedIndex} 的压缩元数据非法`);
+        }
+        if (typeof frame.compressedHash !== 'string' || !HASH.test(frame.compressedHash)) {
+            throw new SyncError('bad-request', `帧 ${expectedIndex} 的 compressedHash 非法`);
+        }
+    }
     if (!Number.isSafeInteger(frame.seqFrom) || !Number.isSafeInteger(frame.seqTo)) throw new SyncError('bad-request', `帧 ${expectedIndex} 的 seq 非法`);
 }
 function toChain(frames) {
@@ -24,7 +37,7 @@ function toChain(frames) {
         }));
 }
 function sessionRow(db, sessionId) {
-    return db.handle.prepare('SELECT created_at, format_version, last_seq, frame_count, head_chain_hash, manifest_json, manifest_digest, revision, updated_at, deleted_at FROM sessions WHERE dataset = ? AND session_id = ?').get(DEFAULT_DATASET, sessionId);
+    return db.handle.prepare('SELECT created_at, format_version, last_seq, frame_count, head_chain_hash, manifest_json, manifest_digest, revision, updated_at, deleted_at, compression, stored_bytes FROM sessions WHERE dataset = ? AND session_id = ?').get(DEFAULT_DATASET, sessionId);
 }
 function manifestOf(sessionId, formatVersion, createdAt, updatedAt, frames, tailOpen, safeThroughSeq, workspaceKey) {
     assertChain(toChain(frames));
@@ -50,8 +63,47 @@ function manifestOf(sessionId, formatVersion, createdAt, updatedAt, frames, tail
         headChainHash: frames[frames.length - 1].chainHash
     };
 }
+function compressionOf(value) {
+    return value === 'zstd' || value === 'mixed' ? value : 'none';
+}
+function statsOf(frames) {
+    let compressed = 0;
+    let storedBytes = 0;
+    for (const frame of frames){
+        if (frame.compression === 'zstd') compressed += 1;
+        storedBytes += frame.bytes;
+    }
+    return {
+        compression: compressed === 0 ? 'none' : compressed === frames.length ? 'zstd' : 'mixed',
+        storedBytes
+    };
+}
+function appendRequestHash(input) {
+    return sha256(stableStringify({
+        sessionId: input.sessionId,
+        baseIndex: input.baseIndex,
+        baseChainHash: input.baseChainHash,
+        createdAt: input.createdAt,
+        formatVersion: input.formatVersion,
+        frames: input.frames,
+        tailOpen: input.tailOpen ?? null,
+        safeThroughSeq: input.safeThroughSeq ?? null,
+        workspaceKey: input.workspaceKey ?? null
+    }));
+}
 export function appendFrames(db, dataDir, input, now = Date.now()) {
     return withTransaction(db, ()=>{
+        const idempotencyKey = input.idempotencyKey;
+        const requestHash = idempotencyKey === undefined ? undefined : appendRequestHash(input);
+        if (idempotencyKey !== undefined && requestHash !== undefined) {
+            const existing = readAppendRequest(db, input.deviceId, input.sessionId, idempotencyKey);
+            if (existing !== undefined) {
+                if (existing.requestHash !== requestHash) {
+                    throw new SyncError('conflict', 'Idempotency-Key 已用于不同的 append 请求');
+                }
+                return JSON.parse(existing.resultJson);
+            }
+        }
         requireResourceLease(db, SYNC_RESOURCE, input.deviceId, input.clientId, now);
         const row = sessionRow(db, input.sessionId);
         let combined;
@@ -103,14 +155,16 @@ export function appendFrames(db, dataDir, input, now = Date.now()) {
         input.frames.forEach((frame, offset)=>assertRef(frame, (row === undefined || replacingLifecycle ? 0 : input.baseIndex + 1) + offset));
         const { manifest, digest, headChainHash } = manifestOf(input.sessionId, formatVersion, createdAt, now, combined, input.tailOpen, input.safeThroughSeq, workspaceKey);
         const revision = bumpRevision(db);
-        db.handle.prepare(`INSERT INTO sessions (dataset, session_id, created_at, format_version, last_seq, frame_count, head_chain_hash, manifest_json, manifest_digest, revision, updated_at, deleted_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL)
+        const stats = statsOf(combined);
+        db.handle.prepare(`INSERT INTO sessions (dataset, session_id, created_at, format_version, last_seq, frame_count, head_chain_hash, manifest_json, manifest_digest, revision, updated_at, deleted_at, compression, stored_bytes)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)
                 ON CONFLICT(dataset, session_id) DO UPDATE SET
                   created_at = excluded.created_at, format_version = excluded.format_version, last_seq = excluded.last_seq,
                   frame_count = excluded.frame_count, head_chain_hash = excluded.head_chain_hash,
                   manifest_json = excluded.manifest_json, manifest_digest = excluded.manifest_digest,
-                  revision = excluded.revision, updated_at = excluded.updated_at, deleted_at = NULL`).run(DEFAULT_DATASET, input.sessionId, createdAt, formatVersion, manifest.lastSeq, combined.length, headChainHash, JSON.stringify(manifest), digest, revision, now);
-        return {
+                  revision = excluded.revision, updated_at = excluded.updated_at, deleted_at = NULL,
+                  compression = excluded.compression, stored_bytes = excluded.stored_bytes`).run(DEFAULT_DATASET, input.sessionId, createdAt, formatVersion, manifest.lastSeq, combined.length, headChainHash, JSON.stringify(manifest), digest, revision, now, stats.compression, stats.storedBytes);
+        const summary = {
             sessionId: input.sessionId,
             revision,
             batchCount: combined.length,
@@ -118,8 +172,14 @@ export function appendFrames(db, dataDir, input, now = Date.now()) {
             manifestDigest: digest,
             lastSeq: manifest.lastSeq,
             updatedAt: now,
-            deletedAt: null
+            deletedAt: null,
+            compression: stats.compression,
+            storedBytes: stats.storedBytes
         };
+        if (idempotencyKey !== undefined && requestHash !== undefined) {
+            writeAppendRequest(db, input.deviceId, input.sessionId, idempotencyKey, requestHash, JSON.stringify(summary), now);
+        }
+        return summary;
     });
 }
 export function deleteSession(db, sessionId, deviceId, clientId, createdAt, now = Date.now()) {
@@ -140,7 +200,9 @@ export function deleteSession(db, sessionId, deviceId, clientId, createdAt, now
             manifestDigest: row.manifest_digest,
             lastSeq: row.last_seq,
             updatedAt: now,
-            deletedAt: now
+            deletedAt: now,
+            compression: compressionOf(row.compression),
+            storedBytes: row.stored_bytes
         };
     });
 }
@@ -162,6 +224,95 @@ export function listBatches(db, sessionId, from, limit) {
         revision: row.revision
     };
 }
+const V2_SUMMARY_SELECT = `s.session_id, s.created_at, s.format_version, s.last_seq, s.frame_count,
+  s.head_chain_hash, s.manifest_digest, s.revision, s.updated_at, s.deleted_at,
+  s.compression, s.stored_bytes,
+  json_extract(s.manifest_json, '$.workspaceKey') AS workspace_key,
+  json_extract(s.manifest_json, '$.tailOpen') AS tail_open,
+  json_extract(s.manifest_json, '$.safeThroughSeq') AS safe_through_seq`;
+function mapV2Summary(row) {
+    const safe = typeof row.safe_through_seq === 'number' && Number.isSafeInteger(row.safe_through_seq) ? row.safe_through_seq : row.last_seq;
+    return {
+        sessionId: row.session_id,
+        revision: row.revision,
+        formatVersion: row.format_version,
+        createdAt: row.created_at,
+        batchCount: row.frame_count,
+        lastSeq: row.last_seq,
+        headChainHash: row.head_chain_hash,
+        manifestDigest: row.manifest_digest,
+        workspaceKey: typeof row.workspace_key === 'string' && row.workspace_key !== '' ? row.workspace_key : null,
+        safeThroughSeq: safe,
+        tailOpen: Number(row.tail_open) === 1,
+        updatedAt: row.updated_at,
+        deletedAt: row.deleted_at,
+        compression: compressionOf(row.compression),
+        storedBytes: Number.isSafeInteger(row.stored_bytes) ? row.stored_bytes : 0
+    };
+}
+export function listV2Sessions(db, after, limit) {
+    const rows = db.handle.prepare(`SELECT ${V2_SUMMARY_SELECT}
+              FROM sessions s
+              WHERE s.dataset = ? AND s.deleted_at IS NULL AND s.session_id > ?
+              ORDER BY s.session_id ASC LIMIT ?`).all(DEFAULT_DATASET, after ?? '', limit + 1);
+    const visible = rows.slice(0, limit);
+    const last = visible[visible.length - 1];
+    return {
+        sessions: visible.map(mapV2Summary),
+        nextSessionId: rows.length > limit && last !== undefined ? last.session_id : null
+    };
+}
+export function listV2Changes(db, sinceRevision, sinceTombstone, limit) {
+    const highWater = Math.max(sinceRevision, readRevision(db));
+    const rows = db.handle.prepare(`SELECT ${V2_SUMMARY_SELECT}
+              FROM sessions s
+              WHERE s.dataset = ? AND s.deleted_at IS NULL AND s.revision > ? AND s.revision <= ?
+              ORDER BY s.revision ASC LIMIT ?`).all(DEFAULT_DATASET, sinceRevision, highWater, limit + 1);
+    const tombstoneRows = db.handle.prepare(`SELECT session_id, created_at, deleted_at FROM tombstones
+              WHERE dataset = ? AND (
+                deleted_at > ? OR
+                (deleted_at = ? AND session_id > ?) OR
+                (deleted_at = ? AND session_id = ? AND created_at > ?)
+              )
+              ORDER BY deleted_at ASC, session_id ASC, created_at ASC LIMIT ?`).all(DEFAULT_DATASET, sinceTombstone.deletedAt, sinceTombstone.deletedAt, sinceTombstone.sessionId, sinceTombstone.deletedAt, sinceTombstone.sessionId, sinceTombstone.createdAt, limit + 1);
+    const visible = rows.slice(0, limit);
+    const visibleTombstones = tombstoneRows.slice(0, limit);
+    const last = visible[visible.length - 1];
+    const lastTombstone = visibleTombstones[visibleTombstones.length - 1];
+    const hasMore = rows.length > limit || tombstoneRows.length > limit;
+    return {
+        sessions: visible.map(mapV2Summary),
+        tombstones: visibleTombstones.map((row)=>({
+                sessionId: row.session_id,
+                createdAt: row.created_at,
+                deletedAt: row.deleted_at
+            })),
+        nextRevision: rows.length > limit && last !== undefined ? last.revision : highWater,
+        nextTombstone: lastTombstone === undefined ? sinceTombstone : {
+            deletedAt: lastTombstone.deleted_at,
+            sessionId: lastTombstone.session_id,
+            createdAt: lastTombstone.created_at
+        },
+        hasMore
+    };
+}
+export function getV2SessionSummary(db, sessionId) {
+    const row = db.handle.prepare(`SELECT ${V2_SUMMARY_SELECT}
+              FROM sessions s
+              WHERE s.dataset = ? AND s.session_id = ?`).get(DEFAULT_DATASET, sessionId);
+    return row === undefined ? undefined : mapV2Summary(row);
+}
+export function listV2Batches(db, sessionId, from, limit) {
+    const row = sessionRow(db, sessionId);
+    if (row === undefined) return undefined;
+    const manifest = JSON.parse(row.manifest_json);
+    return {
+        batches: manifest.frames.slice(from, from + limit),
+        batchCount: manifest.frames.length,
+        revision: row.revision,
+        manifestDigest: row.manifest_digest
+    };
+}
 export function adminSessions(db, limit = 500) {
     const rows = db.handle.prepare(`SELECT s.session_id, s.created_at, s.format_version, s.frame_count, s.last_seq, s.head_chain_hash,
                      s.revision, s.updated_at, s.deleted_at,

package/dist/shared/batches.js

@@ -28,14 +28,16 @@ export function headerMetaOf(header, inheritedEventCount) {
 export function headerChainHash(meta) {
     return sha256(stableStringify(meta));
 }
-export function sealHeader(meta, sessionId, sessionKey) {
+export function sealHeader(meta, sessionId, sessionKey, compression = 'none') {
     const plain = Buffer.from(stableStringify(meta), 'utf8');
     return sealFrame(plain, {
         sessionId,
         index: HEADER_INDEX,
         seqFrom: HEADER_SEQ,
         seqTo: HEADER_SEQ
-    }, sessionKey);
+    }, sessionKey, compression === 'zstd' ? {
+        compression: 'zstd'
+    } : {});
 }
 export function openHeader(sealed, ref, sessionId, sessionKey) {
     if (ref.index !== HEADER_INDEX || ref.seqFrom !== HEADER_SEQ || ref.seqTo !== HEADER_SEQ) {
@@ -46,7 +48,13 @@ export function openHeader(sealed, ref, sessionId, sessionKey) {
         index: ref.index,
         seqFrom: ref.seqFrom,
         seqTo: ref.seqTo,
-        chainHash: ref.chainHash
+        chainHash: ref.chainHash,
+        ...ref.compression === undefined ? {} : {
+            compression: ref.compression
+        },
+        ...ref.compressedHash === undefined ? {} : {
+            compressedHash: ref.compressedHash
+        }
     }, sessionKey);
     return parseHeaderMeta(JSON.parse(plain.toString('utf8')));
 }
@@ -108,7 +116,7 @@ export function serializeEventBatch(events) {
 export function eventBatchHash(events) {
     return sha256(serializeEventBatch(events));
 }
-export function sealEventBatchFromText(text, sessionId, index, seqFrom, seqTo, sessionKey) {
+export function sealEventBatchFromText(text, sessionId, index, seqFrom, seqTo, sessionKey, compression = 'none') {
     if (index < 1) throw new Error('事件批次的链下标必须 >= 1');
     if (seqFrom > seqTo) throw new Error('事件批次的 seq 区间非法');
     return sealFrame(Buffer.from(text, 'utf8'), {
@@ -116,15 +124,17 @@ export function sealEventBatchFromText(text, sessionId, index, seqFrom, seqTo, s
         index,
         seqFrom,
         seqTo
-    }, sessionKey);
+    }, sessionKey, compression === 'zstd' ? {
+        compression: 'zstd'
+    } : {});
 }
-export function sealEventBatch(events, sessionId, index, sessionKey) {
+export function sealEventBatch(events, sessionId, index, sessionKey, compression = 'none') {
     if (index < 1) throw new Error('事件批次的链下标必须 >= 1');
     if (events.length === 0) throw new Error('不能封空批次');
     const seqFrom = events[0].seq;
     const seqTo = events[events.length - 1].seq;
     assertContiguous(events, seqFrom, seqTo);
-    return sealEventBatchFromText(serializeEventBatch(events), sessionId, index, seqFrom, seqTo, sessionKey);
+    return sealEventBatchFromText(serializeEventBatch(events), sessionId, index, seqFrom, seqTo, sessionKey, compression);
 }
 export function openEventBatch(sealed, ref, sessionId, sessionKey) {
     const plain = openSealedFrame(sealed, {
@@ -132,7 +142,13 @@ export function openEventBatch(sealed, ref, sessionId, sessionKey) {
         index: ref.index,
         seqFrom: ref.seqFrom,
         seqTo: ref.seqTo,
-        chainHash: ref.chainHash
+        chainHash: ref.chainHash,
+        ...ref.compression === undefined ? {} : {
+            compression: ref.compression
+        },
+        ...ref.compressedHash === undefined ? {} : {
+            compressedHash: ref.compressedHash
+        }
     }, sessionKey);
     const events = parseEvents(JSON.parse(plain.toString('utf8')));
     if (events.length !== ref.seqTo - ref.seqFrom + 1) throw new Error('批次事件数与 seq 区间不符');

package/dist/shared/blob-batch.js

@@ -0,0 +1,85 @@
+import { sha256 } from './crypto.js';
+export const BLOB_BATCH_CONTENT_TYPE = 'application/x-dsh-blob-batch';
+export const BLOB_BATCH_HEADER_BYTES = 12;
+export const BLOB_BATCH_ENTRY_HEADER_BYTES = 40;
+export const MAX_BATCH_BLOBS = 64;
+export const MAX_BATCH_BODY_BYTES = 8 * 1024 * 1024;
+export const MAX_BLOB_BYTES = 32 * 1024 * 1024;
+const MAGIC = Buffer.from('DSHB', 'ascii');
+const VERSION = 1;
+const KIND_TO_CODE = {
+    frame: 1,
+    attachment: 2,
+    vault: 3
+};
+const CODE_TO_KIND = {
+    1: 'frame',
+    2: 'attachment',
+    3: 'vault'
+};
+export function encodeBlobBatch(entries) {
+    if (entries.length < 1 || entries.length > MAX_BATCH_BLOBS) {
+        throw new Error(`批量 blob 条数必须在 1–${MAX_BATCH_BLOBS} 之间`);
+    }
+    let total = BLOB_BATCH_HEADER_BYTES;
+    for (const entry of entries){
+        if (entry.data.length === 0) throw new Error('批量 blob 不能包含空内容');
+        if (entry.data.length > MAX_BLOB_BYTES) throw new Error(`单个 blob 超过上限 ${MAX_BLOB_BYTES} 字节`);
+        total += BLOB_BATCH_ENTRY_HEADER_BYTES + entry.data.length;
+    }
+    if (total > MAX_BATCH_BODY_BYTES) throw new Error(`批量 blob 超过上限 ${MAX_BATCH_BODY_BYTES} 字节`);
+    const output = Buffer.allocUnsafe(total);
+    MAGIC.copy(output, 0);
+    output.writeUInt8(VERSION, 4);
+    output.writeUInt8(0, 5);
+    output.writeUInt16BE(0, 6);
+    output.writeUInt32BE(entries.length, 8);
+    let offset = BLOB_BATCH_HEADER_BYTES;
+    for (const entry of entries){
+        const digest = sha256(entry.data);
+        output.writeUInt8(KIND_TO_CODE[entry.kind], offset);
+        output.fill(0, offset + 1, offset + 4);
+        output.writeUInt32BE(entry.data.length, offset + 4);
+        Buffer.from(digest, 'hex').copy(output, offset + 8);
+        entry.data.copy(output, offset + BLOB_BATCH_ENTRY_HEADER_BYTES);
+        offset += BLOB_BATCH_ENTRY_HEADER_BYTES + entry.data.length;
+    }
+    return output;
+}
+export function decodeBlobBatch(bytes) {
+    if (bytes.length < BLOB_BATCH_HEADER_BYTES) throw new Error('批量 blob 头被截断');
+    if (!bytes.subarray(0, 4).equals(MAGIC)) throw new Error('不是 DSHB 批量 blob');
+    if (bytes.readUInt8(4) !== VERSION) throw new Error(`不支持的批量 blob 版本：${bytes.readUInt8(4)}`);
+    if (bytes.readUInt8(5) !== 0) throw new Error('批量 blob flags 非零');
+    if (bytes.readUInt16BE(6) !== 0) throw new Error('批量 blob reserved 非零');
+    const count = bytes.readUInt32BE(8);
+    if (count < 1 || count > MAX_BATCH_BLOBS) throw new Error(`批量 blob 条数非法：${count}`);
+    const entries = [];
+    let offset = BLOB_BATCH_HEADER_BYTES;
+    for(let index = 0; index < count; index += 1){
+        if (offset + BLOB_BATCH_ENTRY_HEADER_BYTES > bytes.length) throw new Error(`批量 blob 第 ${index} 条头被截断`);
+        const kind = CODE_TO_KIND[bytes.readUInt8(offset)];
+        if (kind === undefined) throw new Error(`批量 blob 第 ${index} 条类别非法`);
+        if (bytes.readUInt8(offset + 1) !== 0 || bytes.readUInt8(offset + 2) !== 0 || bytes.readUInt8(offset + 3) !== 0) {
+            throw new Error(`批量 blob 第 ${index} 条 reserved 非零`);
+        }
+        const length = bytes.readUInt32BE(offset + 4);
+        if (length === 0) throw new Error(`批量 blob 第 ${index} 条为空`);
+        if (length > MAX_BLOB_BYTES) throw new Error(`批量 blob 第 ${index} 条超过单 blob 上限`);
+        const start = offset + BLOB_BATCH_ENTRY_HEADER_BYTES;
+        const end = start + length;
+        if (end > bytes.length) throw new Error(`批量 blob 第 ${index} 条数据被截断`);
+        entries.push({
+            kind,
+            sha256: bytes.subarray(offset + 8, offset + 8 + 32).toString('hex'),
+            data: bytes.subarray(start, end)
+        });
+        offset = end;
+    }
+    if (offset !== bytes.length) throw new Error('批量 blob 尾部有多余字节');
+    if (bytes.length > MAX_BATCH_BODY_BYTES) throw new Error(`批量 blob 超过上限 ${MAX_BATCH_BODY_BYTES} 字节`);
+    return entries;
+}
+
+
+//# sourceURL=blob-batch.ts

package/dist/shared/chain.js

@@ -90,6 +90,15 @@ export function assertManifest(manifest) {
     manifest.frames.forEach((frame, position)=>{
         if (frame.index !== position) throw new Error(`manifest 第 ${position} 条的 index 是 ${frame.index}`);
         if (!HASH_PATTERN.test(frame.chainHash) || !HASH_PATTERN.test(frame.blobSha256)) throw new Error(`manifest 第 ${position} 条的哈希非法`);
+        if (frame.compression === undefined) {
+            if (frame.sealedVersion !== 1 || frame.compressedHash !== undefined) throw new Error(`manifest 第 ${position} 条缺少压缩元数据`);
+        } else {
+            if (frame.compression !== 'zstd') throw new Error(`manifest 第 ${position} 条的压缩方式非法`);
+            if (frame.sealedVersion < 2) throw new Error(`manifest 第 ${position} 条的压缩帧版本非法`);
+            if (frame.compressedHash === undefined || !HASH_PATTERN.test(frame.compressedHash)) {
+                throw new Error(`manifest 第 ${position} 条的 compressedHash 非法`);
+            }
+        }
     });
     const last = manifest.frames[manifest.frames.length - 1];
     if ((last === undefined ? -1 : last.seqTo) !== manifest.lastSeq) throw new Error('manifest 的 lastSeq 与最后一帧不一致');
@@ -129,7 +138,11 @@ export function manifestDigest(manifest) {
                 sealedVersion: frame.sealedVersion,
                 keyId: frame.keyId,
                 seqFrom: frame.seqFrom,
-                seqTo: frame.seqTo
+                seqTo: frame.seqTo,
+                ...frame.compression === undefined ? {} : {
+                    compression: frame.compression,
+                    compressedHash: frame.compressedHash ?? null
+                }
             })),
         deletedAt: manifest.deletedAt ?? null
     }));

package/dist/shared/index.js

@@ -1,4 +1,5 @@
 export * from './batches.js';
+export * from './blob-batch.js';
 export * from './chain.js';
 export * from './crypto.js';
 export * from './frames.js';

package/dist/shared/protocol.js

@@ -1,5 +1,5 @@
-export const API_PREFIX = '/v1';
-export const PROTOCOL_VERSION = 2;
+export const API_PREFIX = '/v2';
+export const PROTOCOL_VERSION = 3;
 export function errorBody(code, message) {
     return {
         ok: false,

package/dist/shared/sealed-frame.js

@@ -1,14 +1,22 @@
+import { zstdCompressSync, zstdDecompressSync } from 'node:zlib';
 import { createCipheriv, createDecipheriv } from 'node:crypto';
 import { deriveSubkey, sha256, TAG_BYTES, KEY_BYTES, NONCE_BYTES } from './crypto.js';
 export const SEALED_MAGIC = Buffer.from('DSHF', 'ascii');
 export const SEALED_VERSION = 1;
+export const SEALED_VERSION_ZSTD = 2;
 export const KEY_ID_BYTES = 8;
 export const SEALED_HEADER_BYTES = 4 + 1 + 1 + KEY_ID_BYTES + NONCE_BYTES;
 const FIXED_NONCE = Buffer.alloc(NONCE_BYTES);
 export function sessionKeyOf(master, sessionId) {
     return deriveSubkey(master, `v1|session:${sessionId}`);
 }
-export function frameKeyOf(sessionKey, chainHash) {
+export function frameKeyOf(sessionKey, chainHash, compression = 'none', compressedHash) {
+    if (compression === 'zstd') {
+        if (compressedHash === undefined || !/^[0-9a-f]{64}$/u.test(compressedHash)) {
+            throw new Error('zstd 帧缺少合法的 compressedHash');
+        }
+        return deriveSubkey(sessionKey, `v2|frame:zstd:${compressedHash}:${chainHash}`);
+    }
     return deriveSubkey(sessionKey, `v1|frame:${chainHash}`);
 }
 export function keyIdOf(sessionKey) {
@@ -34,15 +42,19 @@ function buildAad(header, position) {
         tail
     ]);
 }
-export function sealFrame(plain, position, sessionKey) {
+export function sealFrame(plain, position, sessionKey, options = {}) {
     if (sessionKey.length !== KEY_BYTES) throw new Error(`会话密钥必须是 ${KEY_BYTES} 字节`);
     if (!Number.isSafeInteger(position.index) || position.index < 0) throw new Error('帧下标必须是非负整数');
+    const compression = options.compression ?? 'none';
     const chainHash = sha256(plain);
-    const frameKey = frameKeyOf(sessionKey, chainHash);
+    const payload = compression === 'zstd' ? zstdCompressSync(plain) : plain;
+    const compressedHash = compression === 'zstd' ? sha256(payload) : undefined;
+    const frameKey = frameKeyOf(sessionKey, chainHash, compression, compressedHash);
     const keyId = keyIdOf(sessionKey);
+    const version = compression === 'zstd' ? SEALED_VERSION_ZSTD : SEALED_VERSION;
     const header = Buffer.alloc(SEALED_HEADER_BYTES);
     SEALED_MAGIC.copy(header, 0);
-    header.writeUInt8(SEALED_VERSION, 4);
+    header.writeUInt8(version, 4);
     header.writeUInt8(0, 5);
     keyId.copy(header, 6);
     FIXED_NONCE.copy(header, 14);
@@ -53,7 +65,7 @@ export function sealFrame(plain, position, sessionKey) {
     const cipher = createCipheriv('aes-256-gcm', frameKey, FIXED_NONCE);
     cipher.setAAD(aad);
     const body = Buffer.concat([
-        cipher.update(plain),
+        cipher.update(payload),
         cipher.final()
     ]);
     const bytes = Buffer.concat([
@@ -68,10 +80,14 @@ export function sealFrame(plain, position, sessionKey) {
             chainHash,
             blobSha256: sha256(bytes),
             bytes: bytes.length,
-            sealedVersion: SEALED_VERSION,
+            sealedVersion: version,
             keyId: keyId.toString('hex'),
             seqFrom: position.seqFrom,
-            seqTo: position.seqTo
+            seqTo: position.seqTo,
+            ...compression === 'zstd' ? {
+                compression: 'zstd',
+                compressedHash: compressedHash
+            } : {}
         }
     };
 }
@@ -79,7 +95,9 @@ export function parseSealedHeader(sealed) {
     if (sealed.length < SEALED_HEADER_BYTES + TAG_BYTES) throw new Error('封帧字节被截断');
     if (!sealed.subarray(0, 4).equals(SEALED_MAGIC)) throw new Error('不是 DSHF 封帧');
     const version = sealed.readUInt8(4);
-    if (version !== SEALED_VERSION) throw new Error(`不支持的封帧版本：${version}`);
+    if (version !== SEALED_VERSION && version !== SEALED_VERSION_ZSTD) {
+        throw new Error(`不支持的封帧版本：${version}`);
+    }
     return {
         version,
         flags: sealed.readUInt8(5),
@@ -93,25 +111,44 @@ export function openSealedFrame(sealed, position, sessionKey) {
     if (!header.keyId.equals(expectedKeyId)) {
         throw new Error('封帧的 keyId 与当前密钥不符（请确认各设备同步口令、服务端地址与 salt 一致）');
     }
+    const compression = header.version === SEALED_VERSION_ZSTD ? 'zstd' : 'none';
+    if (compression === 'zstd') {
+        if (position.compression !== 'zstd' || position.compressedHash === undefined) {
+            throw new Error('zstd 封帧缺少压缩元数据');
+        }
+    } else if (position.compression !== undefined || position.compressedHash !== undefined) {
+        throw new Error('未压缩封帧不应带压缩元数据');
+    }
     const headerBytes = sealed.subarray(0, SEALED_HEADER_BYTES);
     const aad = buildAad(headerBytes, position);
     const body = sealed.subarray(SEALED_HEADER_BYTES, sealed.length - TAG_BYTES);
     const tag = sealed.subarray(sealed.length - TAG_BYTES);
-    const frameKey = frameKeyOf(sessionKey, position.chainHash);
+    const frameKey = frameKeyOf(sessionKey, position.chainHash, compression, position.compressedHash);
     const decipher = createDecipheriv('aes-256-gcm', frameKey, header.nonce);
     decipher.setAAD(aad);
     decipher.setAuthTag(tag);
-    let plain;
+    let payload;
     try {
-        plain = Buffer.concat([
+        payload = Buffer.concat([
             decipher.update(body),
             decipher.final()
         ]);
     } catch  {
         throw new Error('封帧认证失败（密文、AAD 或密钥不匹配）');
     }
-    if (sha256(plain) !== position.chainHash) throw new Error('明文哈希与清单不符');
-    return plain;
+    if (compression === 'zstd') {
+        if (sha256(payload) !== position.compressedHash) throw new Error('压缩明文哈希与清单不符');
+        let plain;
+        try {
+            plain = zstdDecompressSync(payload);
+        } catch  {
+            throw new Error('zstd 解压失败');
+        }
+        if (sha256(plain) !== position.chainHash) throw new Error('解压后的明文哈希与清单不符');
+        return plain;
+    }
+    if (sha256(payload) !== position.chainHash) throw new Error('明文哈希与清单不符');
+    return payload;
 }
 
 

package/package.json

@@ -1,16 +1,38 @@
 {
   "name": "dscs-server",
-  "version": "0.0.1",
+  "version": "0.1.1",
   "private": false,
   "type": "module",
   "description": "DSH Session CloudSync self-hosted server.",
   "license": "AGPL-3.0-only",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xfy2412/dsh-session-cloudsync.git",
+    "directory": "packages/server"
+  },
+  "homepage": "https://github.com/xfy2412/dsh-session-cloudsync#readme",
+  "bugs": {
+    "url": "https://github.com/xfy2412/dsh-session-cloudsync/issues"
+  },
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "session",
+    "sync",
+    "self-hosted",
+    "e2ee",
+    "sqlite"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "bin": {
-    "dscs-server": "./dist/index.js"
+    "dscs-server": "dist/index.js"
   },
   "files": [
     "dist",
     "web",
+    "assets",
     "LICENSE",
     "README.md"
   ],