SHA256
905 lines
28 KiB
JavaScript
905 lines
28 KiB
JavaScript
import { AuthService } from './services/auth-service.js';
|
|
import { listStoredMessages, putStoredMessage, deleteStoredMessage, clearStoredMessages } from './services/message-store.js';
|
|
import { SOLANA_ENDPOINT_DEFAULT } from './solana-programs.js';
|
|
import {
|
|
DEFAULT_SHINE_SERVER_HTTP,
|
|
DEFAULT_SHINE_SERVER_LOGIN,
|
|
DEFAULT_SHINE_SERVER_WS,
|
|
resolveShineServerByServerLogin,
|
|
} from './services/shine-server-resolver.js';
|
|
|
|
const clone = (value) => JSON.parse(JSON.stringify(value));
|
|
const SESSION_STORAGE_KEY = 'shine-ui-current-session-v1';
|
|
const REACTIONS_STORAGE_KEY = 'shine-ui-message-reactions-v2';
|
|
const WEB_PUSH_SUBSCRIPTION_KEY = 'shine-ui-webpush-subscription-v1';
|
|
const ENTRY_SETTINGS_STORAGE_KEY = 'shine-ui-entry-settings-v1';
|
|
const CHANNEL_NOTIFY_KEY = 'shine-channels-notify-v1';
|
|
const CHANNELS_DEMO_KEY = 'shine-channels-demo';
|
|
const CREATE_CHANNEL_FLASH_KEY = 'shine-channels-create-success';
|
|
const MAX_APP_LOG_ENTRIES = 500;
|
|
const INVALID_SESSION_CODES = new Set([
|
|
'NOT_AUTHENTICATED',
|
|
'SESSION_NOT_FOUND',
|
|
'SESSION_KEY_NOT_ACTUAL',
|
|
'SESSION_OF_ANOTHER_USER',
|
|
]);
|
|
|
|
function readLocalWsOverrideUrl() {
|
|
try {
|
|
const params = new URLSearchParams(window.location.search);
|
|
|
|
const explicitWsUrl = String(params.get('wsUrl') || '').trim();
|
|
if (explicitWsUrl) {
|
|
if (explicitWsUrl.startsWith('ws://') || explicitWsUrl.startsWith('wss://')) {
|
|
try {
|
|
const parsed = new URL(explicitWsUrl);
|
|
if (!parsed.pathname || parsed.pathname === '/') parsed.pathname = '/ws';
|
|
return parsed.toString();
|
|
} catch {
|
|
return explicitWsUrl;
|
|
}
|
|
}
|
|
if (explicitWsUrl.startsWith('http://') || explicitWsUrl.startsWith('https://')) {
|
|
try {
|
|
const parsed = new URL(explicitWsUrl);
|
|
parsed.protocol = parsed.protocol === 'https:' ? 'wss:' : 'ws:';
|
|
if (!parsed.pathname || parsed.pathname === '/') parsed.pathname = '/ws';
|
|
return parsed.toString();
|
|
} catch {
|
|
return `${explicitWsUrl.replace(/^http/, 'ws').replace(/\/$/, '')}/ws`;
|
|
}
|
|
}
|
|
return '';
|
|
}
|
|
|
|
const value = params.get('localWsPort');
|
|
const asNum = Number(value);
|
|
if (!Number.isFinite(asNum)) return '';
|
|
const port = Math.trunc(asNum);
|
|
if (port <= 0 || port > 65535) return '';
|
|
const isHttpsPage = window.location.protocol === 'https:';
|
|
const forceInsecureLocal = params.get('allowInsecureLocalWs') === '1';
|
|
const scheme = (isHttpsPage && !forceInsecureLocal) ? 'wss' : 'ws';
|
|
return `${scheme}://localhost:${port}/ws`;
|
|
} catch {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
function inferTunnelWsUrl() {
|
|
try {
|
|
const host = String(window.location.host || '').toLowerCase();
|
|
const isTunnelHost = (
|
|
host.endsWith('.ngrok-free.dev') ||
|
|
host.endsWith('.ngrok.io') ||
|
|
host.endsWith('.trycloudflare.com')
|
|
);
|
|
if (!isTunnelHost) return '';
|
|
const scheme = window.location.protocol === 'https:' ? 'wss' : 'ws';
|
|
return `${scheme}://${window.location.host}/ws`;
|
|
} catch {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
const LOCAL_WS_OVERRIDE_URL = readLocalWsOverrideUrl() || inferTunnelWsUrl();
|
|
const DEFAULT_SOLANA_SERVER = SOLANA_ENDPOINT_DEFAULT;
|
|
const DEFAULT_SHINE_SERVER = DEFAULT_SHINE_SERVER_WS;
|
|
const DEFAULT_SHINE_SERVER_LOGIN_VALUE = DEFAULT_SHINE_SERVER_LOGIN;
|
|
const DEFAULT_SHINE_SERVER_HTTP_VALUE = DEFAULT_SHINE_SERVER_HTTP;
|
|
const DEFAULT_ARWEAVE_SERVER = 'https://arweave.net';
|
|
const DEFAULT_CALL_PREFLIGHT_TIMEOUT_MS = 6000;
|
|
const DEFAULT_OPENAI_BASE_URL = 'https://api.openai.com/v1';
|
|
|
|
function normalizeToolsSettings(rawTools) {
|
|
const source = rawTools && typeof rawTools === 'object' ? rawTools : {};
|
|
const stt = source.speechToText && typeof source.speechToText === 'object' ? source.speechToText : {};
|
|
const tts = source.textToSpeech && typeof source.textToSpeech === 'object' ? source.textToSpeech : {};
|
|
return {
|
|
speechToText: {
|
|
provider: String(stt.provider || 'openai'),
|
|
baseUrl: String(stt.baseUrl || DEFAULT_OPENAI_BASE_URL),
|
|
apiKey: String(stt.apiKey || ''),
|
|
quality: String(stt.quality || 'medium'),
|
|
model: String(stt.model || ''),
|
|
},
|
|
textToSpeech: {
|
|
provider: String(tts.provider || 'openai'),
|
|
quality: String(tts.quality || 'medium'),
|
|
voice: String(tts.voice || ''),
|
|
piperBaseUrl: String(tts.piperBaseUrl || 'http://127.0.0.1:5000'),
|
|
externalBaseUrl: String(tts.externalBaseUrl || ''),
|
|
apiKey: String(tts.apiKey || ''),
|
|
model: String(tts.model || ''),
|
|
},
|
|
};
|
|
}
|
|
|
|
function loadStoredSession() {
|
|
try {
|
|
const raw = localStorage.getItem(SESSION_STORAGE_KEY);
|
|
if (!raw) return null;
|
|
return JSON.parse(raw);
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function loadStoredReactions() {
|
|
try {
|
|
const raw = localStorage.getItem(REACTIONS_STORAGE_KEY);
|
|
if (!raw) return {};
|
|
const parsed = JSON.parse(raw);
|
|
if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return {};
|
|
return parsed;
|
|
} catch {
|
|
return {};
|
|
}
|
|
}
|
|
|
|
function persistStoredReactions(reactions) {
|
|
try {
|
|
localStorage.setItem(REACTIONS_STORAGE_KEY, JSON.stringify(reactions || {}));
|
|
} catch {
|
|
// ignore storage errors
|
|
}
|
|
}
|
|
|
|
function persistSession(session) {
|
|
try {
|
|
localStorage.setItem(SESSION_STORAGE_KEY, JSON.stringify(session));
|
|
} catch {
|
|
// ignore quota/storage errors for prototype
|
|
}
|
|
}
|
|
|
|
function clearStoredSession() {
|
|
try {
|
|
localStorage.removeItem(SESSION_STORAGE_KEY);
|
|
} catch {
|
|
// ignore
|
|
}
|
|
}
|
|
|
|
function loadStoredEntrySettings() {
|
|
try {
|
|
const raw = localStorage.getItem(ENTRY_SETTINGS_STORAGE_KEY);
|
|
if (!raw) return null;
|
|
const parsed = JSON.parse(raw);
|
|
if (!parsed || typeof parsed !== 'object') return null;
|
|
return parsed;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function persistEntrySettings(settings) {
|
|
try {
|
|
const payload = {
|
|
language: String(settings?.language || 'ru'),
|
|
solanaServer: String(settings?.solanaServer || DEFAULT_SOLANA_SERVER),
|
|
shineServer: String(settings?.shineServer || DEFAULT_SHINE_SERVER),
|
|
shineServerLogin: String(settings?.shineServerLogin || DEFAULT_SHINE_SERVER_LOGIN_VALUE),
|
|
shineServerHttp: String(settings?.shineServerHttp || DEFAULT_SHINE_SERVER_HTTP_VALUE),
|
|
arweaveServer: String(settings?.arweaveServer || DEFAULT_ARWEAVE_SERVER),
|
|
callPreflightTimeoutMs: Math.max(1000, Math.min(20000, Number(settings?.callPreflightTimeoutMs || DEFAULT_CALL_PREFLIGHT_TIMEOUT_MS) || DEFAULT_CALL_PREFLIGHT_TIMEOUT_MS)),
|
|
statuses: {
|
|
solanaServer: String(settings?.statuses?.solanaServer || 'idle'),
|
|
shineServerLogin: String(settings?.statuses?.shineServerLogin || settings?.statuses?.shineServer || 'idle'),
|
|
arweaveServer: String(settings?.statuses?.arweaveServer || 'idle'),
|
|
},
|
|
tools: normalizeToolsSettings(settings?.tools),
|
|
};
|
|
localStorage.setItem(ENTRY_SETTINGS_STORAGE_KEY, JSON.stringify(payload));
|
|
} catch {
|
|
// ignore storage errors
|
|
}
|
|
}
|
|
|
|
export function clearBrowserClientData() {
|
|
const localKeys = [
|
|
SESSION_STORAGE_KEY,
|
|
REACTIONS_STORAGE_KEY,
|
|
WEB_PUSH_SUBSCRIPTION_KEY,
|
|
CHANNEL_NOTIFY_KEY,
|
|
CHANNELS_DEMO_KEY,
|
|
];
|
|
localKeys.forEach((key) => {
|
|
try {
|
|
localStorage.removeItem(key);
|
|
} catch {
|
|
// ignore
|
|
}
|
|
});
|
|
|
|
try {
|
|
sessionStorage.removeItem(CREATE_CHANNEL_FLASH_KEY);
|
|
} catch {
|
|
// ignore
|
|
}
|
|
}
|
|
|
|
function createInitialState({ withStoredSession = true } = {}) {
|
|
const storedSession = withStoredSession ? loadStoredSession() : null;
|
|
const storedReactions = loadStoredReactions();
|
|
const storedEntrySettings = loadStoredEntrySettings();
|
|
const initialShineServer = LOCAL_WS_OVERRIDE_URL || DEFAULT_SHINE_SERVER;
|
|
|
|
return {
|
|
chats: {},
|
|
contacts: [],
|
|
appLog: [],
|
|
incomingDedup: {},
|
|
knownMessageKeys: {},
|
|
outgoingTempSeq: 1,
|
|
notificationsTab: 'replies',
|
|
pageLabelCollapsed: false,
|
|
session: {
|
|
isAuthorized: false,
|
|
login: storedSession?.login || '',
|
|
sessionId: storedSession?.sessionId || '',
|
|
storagePwdInMemory: '',
|
|
},
|
|
startHint: '',
|
|
entrySettings: {
|
|
language: String(storedEntrySettings?.language || 'ru'),
|
|
solanaServer: String(storedEntrySettings?.solanaServer || DEFAULT_SOLANA_SERVER),
|
|
shineServer: String(LOCAL_WS_OVERRIDE_URL || storedEntrySettings?.shineServer || initialShineServer),
|
|
shineServerLogin: String(storedEntrySettings?.shineServerLogin || DEFAULT_SHINE_SERVER_LOGIN_VALUE),
|
|
shineServerHttp: String(storedEntrySettings?.shineServerHttp || DEFAULT_SHINE_SERVER_HTTP_VALUE),
|
|
arweaveServer: String(storedEntrySettings?.arweaveServer || DEFAULT_ARWEAVE_SERVER),
|
|
callPreflightTimeoutMs: Math.max(1000, Math.min(20000, Number(storedEntrySettings?.callPreflightTimeoutMs || DEFAULT_CALL_PREFLIGHT_TIMEOUT_MS) || DEFAULT_CALL_PREFLIGHT_TIMEOUT_MS)),
|
|
statuses: {
|
|
solanaServer: String(storedEntrySettings?.statuses?.solanaServer || 'idle'),
|
|
shineServerLogin: String(storedEntrySettings?.statuses?.shineServerLogin || storedEntrySettings?.statuses?.shineServer || 'idle'),
|
|
arweaveServer: String(storedEntrySettings?.statuses?.arweaveServer || 'idle'),
|
|
},
|
|
tools: normalizeToolsSettings(storedEntrySettings?.tools),
|
|
},
|
|
registrationDraft: {
|
|
flowType: '',
|
|
login: '',
|
|
password: '',
|
|
sessionId: '',
|
|
storagePwd: '',
|
|
pendingKeyBundle: null,
|
|
pendingSessionMaterial: null,
|
|
preGeneratedKeyBundle: null,
|
|
},
|
|
loginDraft: {
|
|
login: storedSession?.login || '',
|
|
password: '',
|
|
},
|
|
registrationPayment: {
|
|
walletAddress: '',
|
|
balanceSOL: '0.0000',
|
|
},
|
|
keyStorage: {
|
|
rootKey: 'Ключ root хранится в зашифрованном виде',
|
|
blockchainKey: 'Ключ blockchain хранится в зашифрованном виде',
|
|
deviceKey: 'Ключ device хранится в зашифрованном виде',
|
|
saveRoot: false,
|
|
saveBlockchain: true,
|
|
saveDevice: true,
|
|
},
|
|
deviceConnect: {
|
|
root: true,
|
|
blockchain: true,
|
|
device: true,
|
|
},
|
|
authUi: {
|
|
busy: false,
|
|
error: '',
|
|
info: '',
|
|
},
|
|
authReturnHash: '',
|
|
sessions: [],
|
|
channelsFeed: null,
|
|
channelsIndex: {},
|
|
localChannelPosts: {},
|
|
messageReactions: storedReactions,
|
|
};
|
|
}
|
|
|
|
export const state = createInitialState();
|
|
|
|
export const authService = new AuthService(state.entrySettings.shineServer);
|
|
let onSessionReset = null;
|
|
let onSessionAuthorized = null;
|
|
|
|
function parseMessageTimeFromKey(rawKey) {
|
|
const value = String(rawKey || '').trim();
|
|
if (!value) return 0;
|
|
const parts = value.split('|');
|
|
if (parts.length < 4) return 0;
|
|
const timeMs = Number(parts[2] || 0);
|
|
if (!Number.isFinite(timeMs) || timeMs <= 0) return 0;
|
|
return Math.trunc(timeMs);
|
|
}
|
|
|
|
function resolveChatMessageTimeMs(row) {
|
|
const fromBaseKey = parseMessageTimeFromKey(row?.baseKey);
|
|
if (fromBaseKey > 0) return fromBaseKey;
|
|
|
|
const fromMessageKey = parseMessageTimeFromKey(row?.messageKey);
|
|
if (fromMessageKey > 0) return fromMessageKey;
|
|
|
|
const fromCreatedAt = Number(row?.createdAtMs || row?.ts || 0);
|
|
if (Number.isFinite(fromCreatedAt) && fromCreatedAt > 0) return Math.trunc(fromCreatedAt);
|
|
|
|
const tempId = String(row?.tempId || '').trim();
|
|
if (tempId.startsWith('tmp-')) {
|
|
const parts = tempId.split('-');
|
|
const ts = Number(parts[1] || 0);
|
|
if (Number.isFinite(ts) && ts > 0) return Math.trunc(ts);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
function stableMessageOrderKey(row) {
|
|
const key = String(row?.messageKey || '').trim();
|
|
if (key) return `mk:${key}`;
|
|
const tmp = String(row?.tempId || '').trim();
|
|
if (tmp) return `tmp:${tmp}`;
|
|
const base = String(row?.baseKey || '').trim();
|
|
if (base) return `bk:${base}`;
|
|
const text = String(row?.text || '').trim();
|
|
return `txt:${text}`;
|
|
}
|
|
|
|
function sortChatMessagesInPlace(chatId) {
|
|
const list = getChatMessages(chatId);
|
|
list.sort((a, b) => {
|
|
const ta = resolveChatMessageTimeMs(a);
|
|
const tb = resolveChatMessageTimeMs(b);
|
|
if (ta !== tb) return ta - tb;
|
|
|
|
const ka = stableMessageOrderKey(a);
|
|
const kb = stableMessageOrderKey(b);
|
|
const byKey = ka.localeCompare(kb, 'ru');
|
|
if (byKey !== 0) return byKey;
|
|
|
|
if ((a?.from || '') !== (b?.from || '')) {
|
|
return (a?.from === 'in') ? -1 : 1;
|
|
}
|
|
return 0;
|
|
});
|
|
}
|
|
|
|
function persistMessageRecord(chatId, row) {
|
|
if (!chatId || !row?.messageKey) return;
|
|
const resolvedTs = resolveChatMessageTimeMs(row);
|
|
void putStoredMessage({
|
|
messageKey: row.messageKey,
|
|
chatId,
|
|
from: row.from || 'in',
|
|
text: String(row.text || ''),
|
|
baseKey: String(row.baseKey || ''),
|
|
messageType: Number(row.messageType || 0),
|
|
rawBlobB64: String(row.rawBlobB64 || ''),
|
|
revisionTimeMs: Number(row.revisionTimeMs || 0),
|
|
unread: Boolean(row.unread),
|
|
firstTick: Boolean(row.firstTick),
|
|
secondTick: Boolean(row.secondTick),
|
|
readReceiptSent: Boolean(row.readReceiptSent),
|
|
refBaseKey: String(row.refBaseKey || ''),
|
|
ts: resolvedTs > 0 ? resolvedTs : Date.now(),
|
|
}).catch(() => {});
|
|
}
|
|
|
|
function removeStoredMessageRecord(messageKey) {
|
|
if (!messageKey) return;
|
|
void deleteStoredMessage(messageKey).catch(() => {});
|
|
}
|
|
|
|
export async function hydrateMessagesFromStore() {
|
|
try {
|
|
const rows = await listStoredMessages();
|
|
const touchedChats = new Set();
|
|
rows
|
|
.sort((a, b) => Number(a?.ts || 0) - Number(b?.ts || 0))
|
|
.forEach((row) => {
|
|
const chatId = String(row?.chatId || '').trim();
|
|
const messageKey = String(row?.messageKey || '').trim();
|
|
if (!chatId || !messageKey) return;
|
|
if (state.knownMessageKeys[messageKey]) return;
|
|
state.knownMessageKeys[messageKey] = true;
|
|
touchedChats.add(chatId);
|
|
getChatMessages(chatId).push({
|
|
from: row.from === 'out' ? 'out' : 'in',
|
|
text: String(row.text || ''),
|
|
messageKey,
|
|
baseKey: String(row.baseKey || ''),
|
|
messageType: Number(row.messageType || 0),
|
|
rawBlobB64: String(row.rawBlobB64 || ''),
|
|
revisionTimeMs: Number(row.revisionTimeMs || 0),
|
|
unread: Boolean(row.unread),
|
|
firstTick: Boolean(row.firstTick),
|
|
secondTick: Boolean(row.secondTick),
|
|
readReceiptSent: Boolean(row.readReceiptSent),
|
|
refBaseKey: String(row.refBaseKey || ''),
|
|
createdAtMs: Number(row.ts || 0),
|
|
});
|
|
});
|
|
touchedChats.forEach((chatId) => sortChatMessagesInPlace(chatId));
|
|
} catch {
|
|
// ignore broken storage
|
|
}
|
|
}
|
|
|
|
export function getChatMessages(chatId) {
|
|
if (!state.chats[chatId]) {
|
|
state.chats[chatId] = [];
|
|
}
|
|
return state.chats[chatId];
|
|
}
|
|
|
|
export function addChatMessage(chatId, text) {
|
|
const message = text.trim();
|
|
if (!message) return;
|
|
getChatMessages(chatId).push({
|
|
from: 'out',
|
|
text: message,
|
|
firstTick: false,
|
|
secondTick: false,
|
|
unread: false,
|
|
createdAtMs: Date.now(),
|
|
});
|
|
sortChatMessagesInPlace(chatId);
|
|
}
|
|
|
|
export function addSystemChatMessage(chatId, text, { from = 'out', kind = 'system' } = {}) {
|
|
const message = String(text || '').trim();
|
|
if (!message) return;
|
|
getChatMessages(chatId).push({
|
|
from: from === 'in' ? 'in' : 'out',
|
|
text: message,
|
|
kind: String(kind || 'system'),
|
|
unread: from === 'in',
|
|
firstTick: from !== 'in',
|
|
secondTick: false,
|
|
createdAtMs: Date.now(),
|
|
});
|
|
sortChatMessagesInPlace(chatId);
|
|
}
|
|
|
|
|
|
export function addIncomingMessage(chatId, text, messageId = '') {
|
|
const msg = text?.trim();
|
|
if (!msg) return false;
|
|
if (messageId && state.incomingDedup[messageId]) return false;
|
|
if (messageId) state.incomingDedup[messageId] = true;
|
|
getChatMessages(chatId).push({
|
|
from: 'in',
|
|
text: msg,
|
|
messageId,
|
|
unread: true,
|
|
createdAtMs: Date.now(),
|
|
});
|
|
sortChatMessagesInPlace(chatId);
|
|
return true;
|
|
}
|
|
|
|
export function addOutgoingPendingMessage(chatId, text) {
|
|
const msg = String(text || '').trim();
|
|
if (!msg) return null;
|
|
const tempId = `tmp-${Date.now()}-${state.outgoingTempSeq++}`;
|
|
getChatMessages(chatId).push({
|
|
from: 'out',
|
|
text: msg,
|
|
tempId,
|
|
firstTick: false,
|
|
secondTick: false,
|
|
unread: false,
|
|
createdAtMs: Date.now(),
|
|
});
|
|
sortChatMessagesInPlace(chatId);
|
|
return tempId;
|
|
}
|
|
|
|
export function markOutgoingSent(tempId, { messageKey = '', baseKey = '' } = {}) {
|
|
if (!tempId) return;
|
|
const keys = Object.keys(state.chats || {});
|
|
keys.forEach((chatId) => {
|
|
const list = getChatMessages(chatId);
|
|
const row = list.find((item) => item?.tempId === tempId);
|
|
if (!row) return;
|
|
row.firstTick = true;
|
|
row.messageKey = messageKey || row.messageKey || '';
|
|
row.baseKey = baseKey || row.baseKey || '';
|
|
if (messageKey) {
|
|
state.knownMessageKeys[messageKey] = true;
|
|
persistMessageRecord(chatId, row);
|
|
}
|
|
sortChatMessagesInPlace(chatId);
|
|
});
|
|
}
|
|
|
|
export function markOutgoingReadByBaseKey(baseKey) {
|
|
if (!baseKey) return;
|
|
const keys = Object.keys(state.chats || {});
|
|
keys.forEach((chatId) => {
|
|
const list = getChatMessages(chatId);
|
|
list.forEach((row) => {
|
|
if (row?.from !== 'out') return;
|
|
if (row.baseKey === baseKey) {
|
|
row.secondTick = true;
|
|
persistMessageRecord(chatId, row);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
export function markIncomingReadByBaseKey(baseKey) {
|
|
if (!baseKey) return;
|
|
const keys = Object.keys(state.chats || {});
|
|
keys.forEach((chatId) => {
|
|
const list = getChatMessages(chatId);
|
|
list.forEach((row) => {
|
|
if (row?.from !== 'in') return;
|
|
if (row.baseKey === baseKey) {
|
|
row.unread = false;
|
|
row.readReceiptSent = true;
|
|
persistMessageRecord(chatId, row);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
export function markReadReceiptSentByBaseKey(baseKey) {
|
|
if (!baseKey) return;
|
|
const keys = Object.keys(state.chats || {});
|
|
keys.forEach((chatId) => {
|
|
const list = getChatMessages(chatId);
|
|
list.forEach((row) => {
|
|
if (row?.from !== 'in') return;
|
|
if (row.baseKey === baseKey) {
|
|
row.readReceiptSent = true;
|
|
persistMessageRecord(chatId, row);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
export function addSignedMessageToChat({
|
|
chatId,
|
|
messageKey,
|
|
baseKey = '',
|
|
from = 'in',
|
|
text = '',
|
|
messageType = 1,
|
|
unread = false,
|
|
rawBlobB64 = '',
|
|
refBaseKey = '',
|
|
revisionTimeMs = 0,
|
|
deleted = false,
|
|
} = {}) {
|
|
const id = String(messageKey || '').trim();
|
|
if (!chatId || !id) return false;
|
|
const list = getChatMessages(chatId);
|
|
const existingIndex = list.findIndex((row) => String(row?.messageKey || '').trim() === id);
|
|
const existing = existingIndex >= 0 ? list[existingIndex] : null;
|
|
|
|
if (deleted) {
|
|
if (existingIndex >= 0) {
|
|
list.splice(existingIndex, 1);
|
|
removeStoredMessageRecord(id);
|
|
sortChatMessagesInPlace(chatId);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
state.knownMessageKeys[id] = true;
|
|
const row = existing || {};
|
|
row.from = from === 'out' ? 'out' : 'in';
|
|
row.text = String(text || '');
|
|
row.messageKey = id;
|
|
row.baseKey = String(baseKey || '');
|
|
row.messageType = Number(messageType || 0);
|
|
row.rawBlobB64 = String(rawBlobB64 || '');
|
|
row.revisionTimeMs = Number(revisionTimeMs || 0);
|
|
row.unread = row.from === 'in' ? Boolean(unread) : false;
|
|
row.refBaseKey = String(refBaseKey || '');
|
|
row.firstTick = row.from === 'out';
|
|
row.secondTick = Boolean(existing?.secondTick);
|
|
row.readReceiptSent = Boolean(existing?.readReceiptSent);
|
|
|
|
if (existingIndex < 0) {
|
|
list.push(row);
|
|
}
|
|
sortChatMessagesInPlace(chatId);
|
|
persistMessageRecord(chatId, row);
|
|
return true;
|
|
}
|
|
|
|
export function markChatRead(chatId) {
|
|
const list = getChatMessages(chatId);
|
|
list.forEach((row) => {
|
|
if (row?.from === 'in') {
|
|
row.unread = false;
|
|
persistMessageRecord(chatId, row);
|
|
}
|
|
});
|
|
}
|
|
|
|
export function setContacts(list) {
|
|
state.contacts = Array.isArray(list) ? [...list] : [];
|
|
}
|
|
|
|
function toText(value) {
|
|
if (typeof value === 'string') return value;
|
|
if (value == null) return '';
|
|
try {
|
|
return JSON.stringify(value);
|
|
} catch {
|
|
return String(value);
|
|
}
|
|
}
|
|
|
|
export function addAppLogEntry({
|
|
level = 'info',
|
|
source = 'ui',
|
|
message = '',
|
|
details = '',
|
|
} = {}) {
|
|
const cleanMessage = String(message || '').trim();
|
|
if (!cleanMessage) return;
|
|
const cleanLevel = String(level || 'info').trim().toLowerCase();
|
|
const normalizedLevel = (cleanLevel === 'error' || cleanLevel === 'warn') ? cleanLevel : 'info';
|
|
|
|
state.appLog.push({
|
|
id: `${Date.now()}-${Math.random().toString(16).slice(2, 10)}`,
|
|
ts: Date.now(),
|
|
level: normalizedLevel,
|
|
source: String(source || 'ui').trim() || 'ui',
|
|
message: cleanMessage,
|
|
details: toText(details),
|
|
});
|
|
|
|
if (state.appLog.length > MAX_APP_LOG_ENTRIES) {
|
|
state.appLog.splice(0, state.appLog.length - MAX_APP_LOG_ENTRIES);
|
|
}
|
|
}
|
|
|
|
export function getAppLogEntries() {
|
|
return [...state.appLog];
|
|
}
|
|
|
|
export function clearAppLogEntries() {
|
|
state.appLog = [];
|
|
}
|
|
|
|
export function togglePageLabel() {
|
|
state.pageLabelCollapsed = !state.pageLabelCollapsed;
|
|
}
|
|
|
|
export function ensureChat(chatId) {
|
|
return getChatMessages(chatId);
|
|
}
|
|
|
|
export function checkServerAvailability(address) {
|
|
const normalized = String(address || '').trim().toLowerCase();
|
|
if (!normalized) return 'unavailable';
|
|
return /^(https?:\/\/|wss?:\/\/)/i.test(normalized) ? 'available' : 'unavailable';
|
|
}
|
|
|
|
export async function saveEntrySettings(nextSettings) {
|
|
const nextSolanaServer = String(nextSettings?.solanaServer || state.entrySettings.solanaServer || DEFAULT_SOLANA_SERVER);
|
|
const nextShineServerLogin = String(nextSettings?.shineServerLogin || state.entrySettings.shineServerLogin || DEFAULT_SHINE_SERVER_LOGIN_VALUE).trim().toLowerCase()
|
|
|| DEFAULT_SHINE_SERVER_LOGIN_VALUE;
|
|
let forcedShineServer = LOCAL_WS_OVERRIDE_URL || '';
|
|
let resolvedShineServerHttp = String(state.entrySettings.shineServerHttp || DEFAULT_SHINE_SERVER_HTTP_VALUE).trim() || DEFAULT_SHINE_SERVER_HTTP_VALUE;
|
|
|
|
if (!forcedShineServer) {
|
|
const resolved = await resolveShineServerByServerLogin({
|
|
serverLogin: nextShineServerLogin,
|
|
solanaEndpoint: nextSolanaServer,
|
|
});
|
|
forcedShineServer = resolved.wsUrl;
|
|
resolvedShineServerHttp = resolved.httpBase;
|
|
}
|
|
|
|
state.entrySettings = {
|
|
...state.entrySettings,
|
|
...nextSettings,
|
|
solanaServer: nextSolanaServer,
|
|
shineServer: forcedShineServer,
|
|
shineServerLogin: nextShineServerLogin,
|
|
shineServerHttp: resolvedShineServerHttp,
|
|
statuses: {
|
|
...state.entrySettings.statuses,
|
|
...(nextSettings.statuses || {}),
|
|
},
|
|
tools: normalizeToolsSettings(nextSettings.tools || state.entrySettings.tools),
|
|
};
|
|
persistEntrySettings(state.entrySettings);
|
|
await authService.reconnect(state.entrySettings.shineServer);
|
|
state.startHint = `Настройки входа сохранены. SHiNE: ${state.entrySettings.shineServerHttp}`;
|
|
}
|
|
|
|
export function clearStartHint() {
|
|
state.startHint = '';
|
|
}
|
|
|
|
export function setAuthBusy(flag) {
|
|
state.authUi.busy = flag;
|
|
}
|
|
|
|
export function setAuthError(message) {
|
|
state.authUi.error = message || '';
|
|
}
|
|
|
|
export function setAuthInfo(message) {
|
|
state.authUi.info = message || '';
|
|
}
|
|
|
|
export function clearAuthMessages() {
|
|
state.authUi.error = '';
|
|
state.authUi.info = '';
|
|
}
|
|
|
|
export function authorizeSession({
|
|
login = state.session.login,
|
|
sessionId = state.session.sessionId,
|
|
storagePwd = state.session.storagePwdInMemory,
|
|
} = {}) {
|
|
state.session.isAuthorized = true;
|
|
state.session.login = login;
|
|
state.session.sessionId = sessionId;
|
|
state.session.storagePwdInMemory = storagePwd;
|
|
persistSession({
|
|
isAuthorized: true,
|
|
login,
|
|
sessionId,
|
|
});
|
|
state.startHint = '';
|
|
if (onSessionAuthorized) {
|
|
onSessionAuthorized();
|
|
}
|
|
}
|
|
|
|
export function setSessionResetHandler(handler) {
|
|
onSessionReset = typeof handler === 'function' ? handler : null;
|
|
}
|
|
|
|
export function setSessionAuthorizedHandler(handler) {
|
|
onSessionAuthorized = typeof handler === 'function' ? handler : null;
|
|
}
|
|
|
|
export function isSessionInvalidError(error) {
|
|
return INVALID_SESSION_CODES.has(error?.code);
|
|
}
|
|
|
|
export async function refreshSessions() {
|
|
state.sessions = await authService.listSessions();
|
|
return state.sessions;
|
|
}
|
|
|
|
function resetStateForSignedOut() {
|
|
const next = createInitialState({ withStoredSession: false });
|
|
state.chats = next.chats;
|
|
state.contacts = next.contacts;
|
|
state.appLog = next.appLog;
|
|
state.incomingDedup = next.incomingDedup;
|
|
state.knownMessageKeys = next.knownMessageKeys;
|
|
state.outgoingTempSeq = next.outgoingTempSeq;
|
|
state.notificationsTab = next.notificationsTab;
|
|
state.pageLabelCollapsed = next.pageLabelCollapsed;
|
|
state.session = next.session;
|
|
state.startHint = next.startHint;
|
|
state.entrySettings = next.entrySettings;
|
|
state.registrationDraft = next.registrationDraft;
|
|
state.loginDraft = next.loginDraft;
|
|
state.registrationPayment = next.registrationPayment;
|
|
state.keyStorage = next.keyStorage;
|
|
state.deviceConnect = next.deviceConnect;
|
|
state.authUi = next.authUi;
|
|
state.sessions = next.sessions;
|
|
state.channelsFeed = next.channelsFeed;
|
|
state.channelsIndex = next.channelsIndex;
|
|
state.localChannelPosts = next.localChannelPosts;
|
|
state.messageReactions = next.messageReactions;
|
|
}
|
|
|
|
async function tryCloseCurrentSessionOnServer() {
|
|
const currentSessionId = String(state.session.sessionId || '').trim();
|
|
if (!state.session.isAuthorized || !currentSessionId) return;
|
|
|
|
try {
|
|
await authService.closeSession(currentSessionId);
|
|
} catch (error) {
|
|
addAppLogEntry({
|
|
level: 'warn',
|
|
source: 'session',
|
|
message: 'Не удалось завершить текущую сессию на сервере',
|
|
details: { sessionId: currentSessionId, error: error?.message || 'unknown' },
|
|
});
|
|
}
|
|
}
|
|
|
|
export async function terminateCurrentSession({ infoMessage = '', closeServerSession = false } = {}) {
|
|
if (closeServerSession) {
|
|
await tryCloseCurrentSessionOnServer();
|
|
}
|
|
|
|
clearStoredSession();
|
|
resetStateForSignedOut();
|
|
await clearStoredMessages().catch(() => {});
|
|
authService.close();
|
|
if (infoMessage) {
|
|
state.startHint = infoMessage;
|
|
}
|
|
try {
|
|
await authService.reconnect(state.entrySettings.shineServer);
|
|
} catch {
|
|
// ignore reconnect errors on sign out
|
|
}
|
|
if (onSessionReset) {
|
|
onSessionReset();
|
|
}
|
|
}
|
|
|
|
export async function closeCurrentSessionAndSignOut({ infoMessage = '' } = {}) {
|
|
await terminateCurrentSession({ infoMessage, closeServerSession: true });
|
|
}
|
|
|
|
export function refreshRegistrationBalance() {
|
|
const next = (0.005 + Math.random() * 0.03).toFixed(4);
|
|
state.registrationPayment.balanceSOL = next;
|
|
return next;
|
|
}
|
|
|
|
export function setChannelsFeed(feed, index) {
|
|
state.channelsFeed = feed || null;
|
|
state.channelsIndex = index || {};
|
|
}
|
|
|
|
export function getLocalChannelPosts(channelId) {
|
|
if (!channelId) return [];
|
|
if (!state.localChannelPosts[channelId]) {
|
|
state.localChannelPosts[channelId] = [];
|
|
}
|
|
return state.localChannelPosts[channelId];
|
|
}
|
|
|
|
export function addLocalChannelPost(channelId, post) {
|
|
if (!channelId) return;
|
|
const text = post?.body?.trim();
|
|
if (!text) return;
|
|
|
|
getLocalChannelPosts(channelId).push({
|
|
title: post.title || `${state.session.login || 'Вы'} • сейчас`,
|
|
body: text,
|
|
});
|
|
}
|
|
|
|
function makeMessageReactionKey(messageRef, login = state.session.login) {
|
|
const bch = String(messageRef?.blockchainName || '').trim();
|
|
const blockNumber = Number(messageRef?.blockNumber);
|
|
const blockHash = String(messageRef?.blockHash || '').trim().toLowerCase();
|
|
const cleanLogin = String(login || '').trim().toLowerCase();
|
|
if (!cleanLogin || !bch || !Number.isFinite(blockNumber) || blockNumber < 0 || !blockHash) return '';
|
|
return `${cleanLogin}|${bch}|${blockNumber}|${blockHash}`;
|
|
}
|
|
|
|
export function getMessageReactionState(messageRef) {
|
|
const key = makeMessageReactionKey(messageRef);
|
|
if (!key) return '';
|
|
return state.messageReactions[key] || '';
|
|
}
|
|
|
|
export function setMessageReactionState(messageRef, nextState) {
|
|
const key = makeMessageReactionKey(messageRef);
|
|
if (!key) return;
|
|
const normalized = String(nextState || '').trim().toLowerCase();
|
|
if (normalized === 'liked' || normalized === 'unliked') {
|
|
state.messageReactions[key] = normalized;
|
|
persistStoredReactions(state.messageReactions);
|
|
return;
|
|
}
|
|
delete state.messageReactions[key];
|
|
persistStoredReactions(state.messageReactions);
|
|
}
|