Вложения файлов со своего сервера доступа пользователя

This commit is contained in:
AidarKC
2026-10-07 11:42:12 +03:00
parent b1c42efa82
commit 7b8e178723
33 changed files with 1960 additions and 496 deletions
+189 -82
View File
@@ -1,5 +1,6 @@
import { openMediaViewer } from '../components/media-viewer.js';
import { buildArweaveDataUrl, validateArweaveTxId, validateSha256Hex } from './arweave-file-service.js';
import { buildArweaveDataUrl, sha256HexFromArrayBuffer, validateArweaveTxId, validateSha256Hex } from './arweave-file-service.js';
import { resolvePublicFileUrl } from './public-file-service.js';
const ATTACH_BLOCK_RE = /^<(?:SHiNE|S):(attach|att);([^>]*)>\n?/u;
export const MAX_MESSAGE_ATTACHMENTS = 10;
@@ -32,30 +33,12 @@ function normalizeName(name) {
return clean || 'file';
}
function normalizePreview(input = {}) {
const previewTxId = String(input.preAr || input.previewAr || input.ar || input.txId || '').trim();
const previewSha256Hex = String(input.preSha256 || input.previewSha256 || input.sha256 || input.sha256Hex || '').trim().toLowerCase();
if (!previewTxId || !previewSha256Hex) return null;
if (!validateArweaveTxId(previewTxId)) return null;
if (!validateSha256Hex(previewSha256Hex)) return null;
return {
ar: previewTxId,
sha256: previewSha256Hex,
};
}
export function normalizeAttachment(input = {}) {
const txId = String(input.ar || input.txId || '').trim();
const sha256Hex = String(input.sha256 || input.sha256Hex || '').trim().toLowerCase();
const size = Number(input.sz || input.size || input.sizeBytes || 0);
const name = normalizeName(input.nm || input.name || input.fileName || 'file');
const preview = normalizePreview(input.preview || {
preAr: input.preAr,
preSha256: input.preSha256,
previewAr: input.previewAr,
previewSha256: input.previewSha256,
});
if (!validateArweaveTxId(txId)) throw new Error('Некорректный Transaction ID Arweave.');
if (txId && !validateArweaveTxId(txId)) throw new Error('Некорректный Transaction ID Arweave.');
if (!validateSha256Hex(sha256Hex)) throw new Error('Некорректный SHA-256 файла.');
if (!Number.isInteger(size) || size <= 0) throw new Error('Некорректный размер файла.');
const out = {
@@ -66,20 +49,14 @@ export function normalizeAttachment(input = {}) {
ar: txId,
uploadedAtMs: Number(input.uploadedAtMs || 0) || Date.now(),
};
if (preview) {
out.v = 2;
out.preview = preview;
}
return out;
}
export function buildAttachmentBlock(attachment) {
const item = normalizeAttachment(attachment);
const encodedName = encodeURIComponent(item.name);
const previewFields = item.preview
? `;preAr=${item.preview.ar};preSha256=${item.preview.sha256}`
: '';
return `<S:att;v=1;nm=${encodedName};sz=${item.size};sha256=${item.sha256};ar=${item.ar}${previewFields}>`;
const arPart = item.ar ? `;ar=${item.ar}` : '';
return `<S:att;v=1;nm=${encodedName};sz=${item.size};sha256=${item.sha256}${arPart}>`;
}
export function composeMessageWithAttachments(text, attachments = []) {
@@ -121,10 +98,6 @@ export function parseMessageAttachments(rawText) {
sz: fields.sz || fields.size,
sha256: fields.sha256,
ar: fields.ar,
preAr: fields.preAr,
preSha256: fields.preSha256,
previewAr: fields.previewAr,
previewSha256: fields.previewSha256,
}));
} catch {
// Битый attach-блок скрываем из UI, но не ломаем отображение текста.
@@ -158,12 +131,38 @@ function isRecentMessage(messageTimestampMs) {
return Date.now() - ts < RECENT_UNAVAILABLE_MS;
}
function createUnavailableBlock(messageTimestampMs) {
function attachmentStorage(item) {
return item?.ar ? 'arweave' : 'server';
}
function buildCurrentServerDebugUrl(item) {
const sha = String(item?.sha256 || '').trim().toLowerCase();
if (!validateSha256Hex(sha)) return '';
return `${window.location.origin.replace(/\/$/, '')}/files/${sha}`;
}
function createUnavailableBlock(messageTimestampMs, storage = 'arweave', detail = null) {
const block = document.createElement('div');
block.className = 'message-attachment-unavailable';
block.textContent = isRecentMessage(messageTimestampMs)
? 'Скорее всего файл недоступен, потому что сообщение было создано недавно и файл ещё не распространился в Arweave. Попробуйте повторить через несколько минут.'
: 'Файл недоступен.';
if (storage === 'server') {
block.textContent = 'Файл недоступен на сервере доступа автора.';
} else {
block.textContent = isRecentMessage(messageTimestampMs)
? 'Скорее всего файл недоступен, потому что сообщение было создано недавно и файл ещё не распространился в Arweave. Попробуйте повторить через несколько минут.'
: 'Файл недоступен.';
}
if (detail) {
const debug = document.createElement('pre');
debug.className = 'message-attachment-debug';
debug.textContent = [
'DEBUG server attachment',
detail.name ? `name: ${detail.name}` : '',
detail.sha256 ? `sha256: ${detail.sha256}` : '',
detail.url ? `url: ${detail.url}` : '',
detail.error ? `error: ${detail.error}` : '',
].filter(Boolean).join('\n');
block.append(debug);
}
return block;
}
@@ -178,10 +177,10 @@ function stopVideos(root) {
});
}
function replaceWithUnavailable(slide, messageTimestampMs) {
function replaceWithUnavailable(slide, messageTimestampMs, storage = 'arweave', detail = null) {
if (!slide || slide.dataset.unavailable === '1') return;
slide.dataset.unavailable = '1';
slide.replaceChildren(createUnavailableBlock(messageTimestampMs));
slide.replaceChildren(createUnavailableBlock(messageTimestampMs, storage, detail));
}
function createFileCard({ item, url, messageTimestampMs, slide }) {
@@ -209,13 +208,13 @@ function createFileCard({ item, url, messageTimestampMs, slide }) {
});
void fetch(url, { method: 'HEAD', cache: 'no-store' })
.then((response) => {
if (!response.ok) replaceWithUnavailable(slide, messageTimestampMs);
if (!response.ok) replaceWithUnavailable(slide, messageTimestampMs, attachmentStorage(item));
})
.catch(() => replaceWithUnavailable(slide, messageTimestampMs));
.catch(() => replaceWithUnavailable(slide, messageTimestampMs, attachmentStorage(item)));
return card;
}
function createMediaSlide({ item, url, kind, messageTimestampMs, slide, previewUrl = '', onOpen }) {
function createMediaSlide({ item, url, kind, messageTimestampMs, slide, onOpen }) {
const frame = document.createElement('div');
frame.className = `message-attachment-media-frame message-attachment-media-frame--${kind}`;
frame.role = 'button';
@@ -251,20 +250,8 @@ function createMediaSlide({ item, url, kind, messageTimestampMs, slide, previewU
img.alt = item.name;
img.loading = 'lazy';
bindImageLayout(img);
img.addEventListener('error', () => replaceWithUnavailable(slide, messageTimestampMs), { once: true });
img.addEventListener('error', () => replaceWithUnavailable(slide, messageTimestampMs, attachmentStorage(item)), { once: true });
frame.append(img);
} else if (previewUrl) {
const img = document.createElement('img');
img.className = 'message-attachment-media';
img.src = previewUrl;
img.alt = `${item.name} preview`;
img.loading = 'lazy';
bindImageLayout(img);
img.addEventListener('error', () => replaceWithUnavailable(slide, messageTimestampMs), { once: true });
const play = document.createElement('span');
play.className = 'message-attachment-play';
play.textContent = '▶';
frame.append(img, play);
} else {
const video = document.createElement('video');
video.className = 'message-attachment-media';
@@ -272,7 +259,7 @@ function createMediaSlide({ item, url, kind, messageTimestampMs, slide, previewU
video.preload = 'metadata';
video.muted = true;
video.playsInline = true;
video.addEventListener('error', () => replaceWithUnavailable(slide, messageTimestampMs), { once: true });
video.addEventListener('error', () => replaceWithUnavailable(slide, messageTimestampMs, attachmentStorage(item)), { once: true });
video.addEventListener('loadeddata', () => frame.classList.add('is-loaded'), { once: true });
const play = document.createElement('span');
play.className = 'message-attachment-play';
@@ -283,7 +270,89 @@ function createMediaSlide({ item, url, kind, messageTimestampMs, slide, previewU
return frame;
}
export function createAttachmentCarouselElement(attachments = [], { gateway = '', messageTimestampMs = 0 } = {}) {
function mimeTypeForAttachment(item, kind) {
const ext = getAttachmentExtension(item?.name);
if (kind === 'image') {
if (ext === 'svg') return 'image/svg+xml';
if (ext === 'jpg' || ext === 'jpeg') return 'image/jpeg';
if (ext === 'png') return 'image/png';
if (ext === 'gif') return 'image/gif';
if (ext === 'webp') return 'image/webp';
if (ext === 'avif') return 'image/avif';
if (ext === 'bmp') return 'image/bmp';
if (ext === 'apng') return 'image/apng';
return 'application/octet-stream';
}
if (kind === 'video') {
if (ext === 'mp4' || ext === 'm4v') return 'video/mp4';
if (ext === 'webm') return 'video/webm';
if (ext === 'ogg' || ext === 'ogv') return 'video/ogg';
if (ext === 'mov') return 'video/quicktime';
if (ext === 'mpeg' || ext === 'mpg') return 'video/mpeg';
if (ext === 'avi') return 'video/x-msvideo';
if (ext === 'mkv') return 'video/x-matroska';
}
return 'application/octet-stream';
}
const attachmentObjectUrls = new Map();
let attachmentObjectUrlObserver = null;
function registerAttachmentObjectUrl(owner, url) {
if (!owner || !url) return;
if (!owner.isConnected) {
URL.revokeObjectURL(url);
return;
}
const urls = attachmentObjectUrls.get(owner) || new Set();
urls.add(url);
attachmentObjectUrls.set(owner, urls);
if (attachmentObjectUrlObserver) return;
attachmentObjectUrlObserver = new MutationObserver(() => {
attachmentObjectUrls.forEach((ownedUrls, element) => {
if (element.isConnected) return;
ownedUrls.forEach((ownedUrl) => URL.revokeObjectURL(ownedUrl));
attachmentObjectUrls.delete(element);
});
if (!attachmentObjectUrls.size) {
attachmentObjectUrlObserver.disconnect();
attachmentObjectUrlObserver = null;
}
});
attachmentObjectUrlObserver.observe(document.documentElement, { childList: true, subtree: true });
}
async function resolveAttachmentDisplayUrl(item, options = {}) {
if (item.ar) {
return { url: buildArweaveDataUrl({ gateway: options.gateway, txId: item.ar }), objectUrl: false };
}
const serverUrl = await resolvePublicFileUrl({
sha256: item.sha256,
authorLogin: options.authorLogin,
solanaEndpoint: options.solanaEndpoint,
fallbackServerLogin: options.fallbackServerLogin,
});
const kind = getAttachmentKind(item);
if (kind === 'file') return { url: serverUrl, objectUrl: false };
// /files хранит только байты и SHA-256. Для media тип задаёт клиент по имени из S:att.
const response = await fetch(serverUrl);
if (!response.ok) throw new Error(`HTTP ${response.status} ${serverUrl}`);
const buffer = await response.arrayBuffer();
const actualSha = await sha256HexFromArrayBuffer(buffer);
if (actualSha !== item.sha256) throw new Error(`SHA-256 скачанного файла не совпал с блокчейном: ${actualSha} != ${item.sha256} (${serverUrl})`);
const blob = new Blob([buffer], { type: mimeTypeForAttachment(item, kind) });
return { url: URL.createObjectURL(blob), sourceUrl: serverUrl, objectUrl: true };
}
export function createAttachmentCarouselElement(attachments = [], {
gateway = '',
messageTimestampMs = 0,
authorLogin = '',
solanaEndpoint = '',
fallbackServerLogin = '',
} = {}) {
const items = (Array.isArray(attachments) ? attachments : [])
.slice(0, MAX_MESSAGE_ATTACHMENTS)
.map((raw) => {
@@ -296,13 +365,16 @@ export function createAttachmentCarouselElement(attachments = [], { gateway = ''
.filter(Boolean);
const wrap = document.createElement('div');
wrap.className = 'message-attachments message-attachment-carousel';
wrap.addEventListener('click', (event) => {
event.stopPropagation();
});
wrap.addEventListener('click', (event) => event.stopPropagation());
if (!items.length) return wrap;
let index = 0;
let pointerStartX = 0;
let renderGeneration = 0;
const resolved = new Map();
const pending = new Map();
const options = { gateway, authorLogin, solanaEndpoint, fallbackServerLogin };
const viewport = document.createElement('div');
viewport.className = 'message-attachment-carousel-viewport';
const slide = document.createElement('div');
@@ -321,27 +393,71 @@ export function createAttachmentCarouselElement(attachments = [], { gateway = ''
counter.className = 'message-attachment-counter';
wrap.classList.toggle('has-single-attachment', items.length <= 1);
// Просмотр на весь экран листает все фото и видео записи, файлы пропускает.
const mediaItems = items
.map((item, i) => ({ i, kind: getAttachmentKind(item), url: buildArweaveDataUrl({ gateway, txId: item.ar }), name: item.name }))
.filter((entry) => entry.kind === 'image' || entry.kind === 'video');
const getResolved = (itemIndex) => {
if (resolved.has(itemIndex)) return Promise.resolve(resolved.get(itemIndex));
if (pending.has(itemIndex)) return pending.get(itemIndex);
const promise = resolveAttachmentDisplayUrl(items[itemIndex], options)
.then((value) => {
resolved.set(itemIndex, value);
pending.delete(itemIndex);
if (value.objectUrl) registerAttachmentObjectUrl(wrap, value.url);
return value;
})
.catch((error) => {
pending.delete(itemIndex);
throw error;
});
pending.set(itemIndex, promise);
return promise;
};
const openViewer = (itemIndex) => {
openMediaViewer(mediaItems, Math.max(0, mediaItems.findIndex((entry) => entry.i === itemIndex)));
const entries = items
.map((item, i) => {
const kind = getAttachmentKind(item);
if (kind !== 'image' && kind !== 'video') return null;
if (item.ar) return { i, kind, url: buildArweaveDataUrl({ gateway, txId: item.ar }), name: item.name };
const cached = resolved.get(i);
return cached ? { i, kind, url: cached.url, name: item.name } : null;
})
.filter(Boolean);
const viewerIndex = Math.max(0, entries.findIndex((entry) => entry.i === itemIndex));
if (entries.length) openMediaViewer(entries, viewerIndex);
};
const render = () => {
const generation = ++renderGeneration;
stopVideos(wrap);
const item = items[index];
const currentIndex = index;
const kind = getAttachmentKind(item);
const url = buildArweaveDataUrl({ gateway, txId: item.ar });
const previewUrl = item.preview?.ar ? buildArweaveDataUrl({ gateway, txId: item.preview.ar }) : '';
viewport.classList.remove('has-landscape-media');
slide.className = 'message-attachment-slide';
slide.dataset.unavailable = '0';
slide.replaceChildren();
slide.append(kind === 'file'
? createFileCard({ item, url, messageTimestampMs, slide })
: createMediaSlide({ item, url, kind, messageTimestampMs, slide, previewUrl, onOpen: () => openViewer(index) }));
const loading = document.createElement('div');
loading.className = 'message-attachment-unavailable';
loading.textContent = 'Загружаем файл…';
slide.append(loading);
void getResolved(currentIndex)
.then(({ url }) => {
if (generation !== renderGeneration || currentIndex !== index || !wrap.isConnected) return;
slide.replaceChildren(kind === 'file'
? createFileCard({ item, url, messageTimestampMs, slide })
: createMediaSlide({ item, url, kind, messageTimestampMs, slide, onOpen: () => openViewer(currentIndex) }));
})
.catch((error) => {
if (generation !== renderGeneration || currentIndex !== index || !wrap.isConnected) return;
replaceWithUnavailable(slide, messageTimestampMs, attachmentStorage(item), {
name: item?.name || '',
sha256: item?.sha256 || '',
url: buildCurrentServerDebugUrl(item) || error?.message?.match(/https?:\/\/\S+/)?.[0] || '',
error: error?.message || String(error || ''),
});
});
prev.hidden = items.length <= 1 || index <= 0;
next.hidden = items.length <= 1 || index >= items.length - 1;
counter.hidden = items.length <= 1;
@@ -355,21 +471,12 @@ export function createAttachmentCarouselElement(attachments = [], { gateway = ''
render();
};
prev.addEventListener('click', (event) => {
event.stopPropagation();
move(-1);
});
next.addEventListener('click', (event) => {
event.stopPropagation();
move(1);
});
viewport.addEventListener('pointerdown', (event) => {
pointerStartX = event.clientX;
});
prev.addEventListener('click', (event) => { event.stopPropagation(); move(-1); });
next.addEventListener('click', (event) => { event.stopPropagation(); move(1); });
viewport.addEventListener('pointerdown', (event) => { pointerStartX = event.clientX; });
viewport.addEventListener('pointerup', (event) => {
const dx = event.clientX - pointerStartX;
if (Math.abs(dx) < 40) return;
move(dx < 0 ? 1 : -1);
if (Math.abs(dx) >= 40) move(dx < 0 ? 1 : -1);
});
viewport.append(slide, prev, next);
+180
View File
@@ -0,0 +1,180 @@
import { importPkcs8Ed25519, signBase64 } from './crypto-utils.js';
import { sha256HexFromArrayBuffer, validateSha256Hex } from './arweave-file-service.js';
import { loadSessionMaterial } from './key-vault.js';
import {
DEFAULT_SHINE_SERVER_HTTP,
resolveShineServerForUserLogin,
} from './shine-server-resolver.js';
const ACCESS_SERVER_CACHE_TTL_MS = 60_000;
const accessServerCache = new Map();
async function publicFileExists(url) {
try {
const response = await fetch(url, { method: 'HEAD', cache: 'no-store' });
return response.ok;
} catch {
return false;
}
}
function wsUrlToHttpBase(wsUrl = '') {
const parsed = new URL(String(wsUrl || ''), window.location.href);
if (parsed.protocol === 'wss:') parsed.protocol = 'https:';
else if (parsed.protocol === 'ws:') parsed.protocol = 'http:';
if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
throw new Error('Не удалось определить HTTP-адрес сервера доступа.');
}
return parsed.origin;
}
function publicFileUrl(serverBase, sha256) {
const cleanSha = String(sha256 || '').trim().toLowerCase();
if (!validateSha256Hex(cleanSha)) throw new Error('Некорректный SHA-256 файла.');
return `${String(serverBase || '').replace(/\/$/, '')}/files/${cleanSha}`;
}
function uploadPreimage({ sessionId, sha256, size, timeMs }) {
return `PUBLIC_FILE_UPLOAD_V1:${sessionId}:${sha256}:${Number(size)}:${Number(timeMs)}`;
}
async function readErrorMessage(response) {
try {
const raw = String(await response.text()).trim();
if (!raw) return '';
try {
const payload = JSON.parse(raw);
return String(payload?.message || payload?.error || raw).trim();
} catch {
return raw;
}
} catch {
return '';
}
}
async function createUploadContext({ login, sessionId, wsUrl }) {
const cleanLogin = String(login || '').trim();
const cleanSessionId = String(sessionId || '').trim();
if (!cleanLogin || !cleanSessionId) throw new Error('Нет активной пользовательской сессии.');
const sessionMaterial = await loadSessionMaterial(cleanLogin);
if (!sessionMaterial?.sessionPrivPkcs8) {
throw new Error('На устройстве нет session key для загрузки файла.');
}
if (sessionMaterial.sessionId && String(sessionMaterial.sessionId) !== cleanSessionId) {
throw new Error('Сохранённый session key относится к другой сессии.');
}
return {
sessionId: cleanSessionId,
serverBase: wsUrlToHttpBase(wsUrl),
privateKey: await importPkcs8Ed25519(sessionMaterial.sessionPrivPkcs8),
};
}
export async function uploadPublicFile({ file, login, sessionId, wsUrl, onStatus = null } = {}) {
if (!(file instanceof File)) throw new Error('Файл не выбран.');
if (Number(file.size || 0) <= 0) throw new Error('Нельзя загрузить пустой файл.');
onStatus?.('Считаем SHA-256…');
const bytes = await file.arrayBuffer();
const sha256 = await sha256HexFromArrayBuffer(bytes);
const context = await createUploadContext({ login, sessionId, wsUrl });
const url = publicFileUrl(context.serverBase, sha256);
onStatus?.('Проверяем, есть ли файл на сервере…');
try {
const existing = await fetch(url, { method: 'HEAD', cache: 'no-store' });
if (existing.ok) {
const storedSize = Number(existing.headers.get('Content-Length') || -1);
if (storedSize < 0 || storedSize === file.size) {
return {
v: 1,
name: String(file.name || 'file'),
size: Number(file.size),
sha256,
ar: '',
uploadedAtMs: Date.now(),
alreadyExists: true,
};
}
}
} catch {
// HEAD — только оптимизация. PUT сам проверит hash и дедупликацию.
}
const timeMs = Date.now();
const signature = await signBase64(context.privateKey, uploadPreimage({
sessionId: context.sessionId,
sha256,
size: file.size,
timeMs,
}));
onStatus?.('Загружаем на сервер доступа…');
let response;
try {
response = await fetch(url, {
method: 'PUT',
headers: {
'Content-Type': 'application/octet-stream',
'X-Shine-Session-Id': context.sessionId,
'X-Shine-Time-Ms': String(timeMs),
'X-Shine-Content-Length': String(file.size),
'X-Shine-Signature': signature,
},
body: bytes,
cache: 'no-store',
});
} catch (error) {
throw new Error(`Не удалось загрузить файл на сервер доступа: ${error?.message || 'network error'}`);
}
if (!response.ok) {
const detail = await readErrorMessage(response);
throw new Error(detail || `Сервер отклонил файл (HTTP ${response.status}).`);
}
let alreadyExists = false;
try {
const payload = await response.clone().json();
alreadyExists = Boolean(payload?.alreadyExists);
} catch {
// Успешного HTTP достаточно.
}
return {
v: 1,
name: String(file.name || 'file'),
size: Number(file.size),
sha256,
ar: '',
uploadedAtMs: Date.now(),
alreadyExists,
};
}
export async function resolvePublicFileUrl({
sha256,
authorLogin,
solanaEndpoint,
fallbackServerLogin = '',
} = {}) {
const currentServerUrl = publicFileUrl(DEFAULT_SHINE_SERVER_HTTP, sha256);
if (await publicFileExists(currentServerUrl)) {
return currentServerUrl;
}
const cleanLogin = String(authorLogin || '').trim().toLowerCase();
if (!cleanLogin) throw new Error('Не указан автор server-вложения.');
const cacheKey = `${cleanLogin}|${String(solanaEndpoint || '').trim()}|${String(fallbackServerLogin || '').trim().toLowerCase()}`;
const cached = accessServerCache.get(cacheKey);
if (cached && Date.now() - cached.atMs < ACCESS_SERVER_CACHE_TTL_MS) {
return publicFileUrl(cached.httpBase, sha256);
}
const resolved = await resolveShineServerForUserLogin({
login: cleanLogin,
solanaEndpoint,
fallbackServerLogin,
});
accessServerCache.set(cacheKey, { atMs: Date.now(), httpBase: resolved.httpBase });
return publicFileUrl(resolved.httpBase, sha256);
}