mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-17 21:43:06 +00:00
Some checks failed
Publish `librechat-data-provider` to NPM / pack (push) Has been cancelled
Publish `@librechat/data-schemas` to NPM / pack (push) Has been cancelled
Docker Dev Images Build / publish (push) Has been cancelled
Sync Helm Chart Tags / Ignore non-main push (push) Has been cancelled
Sync Helm Chart Tags / Sync chart tags (push) Has been cancelled
Publish `librechat-data-provider` to NPM / publish-npm (push) Has been cancelled
Publish `@librechat/data-schemas` to NPM / publish-npm (push) Has been cancelled
* 📰 fix: Preview Pasted Text Without Blocking Sends
* test: Cover Paste Cleanup and Accessible Preview Text
* fix: Preserve Paste Cleanup Across Upload Races
* test: Pass Paste Identity to Draft Lock Regression
* fix: Consume Paste Replacement Chains and Enforce Upload Limits
* fix: Flatten Pending Paste Edits Onto Their Surviving Source
* fix: Transfer Recovery Ownership While Editing Pending Pastes
* fix: Persist Bounded Paste Snippets and Isolate Replay Drafts
* fix: Type File Sanitization by Its Preview Inputs
* fix: Preserve Pending Uploads Above During-Run Text Limits
* fix: Isolate Historical User Reruns From Live Paste Drafts
* fix: Restore Paste Drafts Before Persisting Composer State
* fix: Expose Paste-Only During-Run Send Controls
* test: Scope Paste Warning Assertion to Toast Viewport
---------
Co-authored-by: Lia <lia@librechat.ai>
1650 lines
64 KiB
TypeScript
1650 lines
64 KiB
TypeScript
import { Constants, LocalStorageKeys, MAX_FILE_TEXT_PREVIEW_LENGTH } from 'librechat-data-provider';
|
|
import { isPasteSubmitted } from './files';
|
|
|
|
export type PendingTextAttachmentDraft = {
|
|
text: string;
|
|
selectionStart: number;
|
|
selectionEnd?: number;
|
|
replacedText?: string;
|
|
sequence?: number;
|
|
/** True when TEXT_DRAFT was written after the selection was already removed. */
|
|
replacedApplied?: boolean;
|
|
anchorBefore?: string;
|
|
anchorAfter?: string;
|
|
};
|
|
|
|
export type FilesDraft = {
|
|
fileIds: string[];
|
|
pendingPastes: Record<string, PendingTextAttachmentDraft>;
|
|
/** Paste-generated attachment ids, kept after `pendingPastes` is consumed so provenance
|
|
* survives reloads without holding the (much larger) paste text indefinitely. */
|
|
pastedTextIds?: string[];
|
|
/** Bounded display text, not the source used by editing or inline submission. */
|
|
textPreviews?: Record<string, string>;
|
|
/** The browser tab that first wrote the draft. Every draft key is reachable from more than
|
|
* one tab (the unsaved-chat key by every default composer, a conversation key by every tab
|
|
* viewing it), so destructive actions read this to leave other tabs' composers alone.
|
|
* Later rewrites, including another tab restoring the same record, keep this owner rather
|
|
* than restamping. Undefined on records older than the stamp. */
|
|
tabId?: string;
|
|
};
|
|
|
|
type StoredPendingTextAttachmentDraft = {
|
|
encodedText: string;
|
|
selectionStart: number;
|
|
selectionEnd?: number;
|
|
encodedReplacedText?: string;
|
|
sequence?: number;
|
|
replacedApplied?: boolean;
|
|
encodedAnchorBefore?: string;
|
|
encodedAnchorAfter?: string;
|
|
};
|
|
|
|
type StoredFilesDraft = {
|
|
fileIds: string[];
|
|
textPreviews?: Record<string, string>;
|
|
pendingPastes: Record<string, StoredPendingTextAttachmentDraft>;
|
|
pastedTextIds?: string[];
|
|
tabId?: string;
|
|
};
|
|
|
|
const newConversationDraftTokens = new Map<number, symbol>();
|
|
const newConversationDraftRevisions = new Map<number, string>();
|
|
const newConversationRevisionKey = (index: number): string => `librechat-new-composer:${index}`;
|
|
|
|
/** Reload preserves the revision; an explicit reset replaces it before any new work starts. */
|
|
export const getNewConversationDraftRevision = (index = 0): string => {
|
|
const current = newConversationDraftRevisions.get(index);
|
|
if (current) return current;
|
|
let revision: string;
|
|
try {
|
|
revision = sessionStorage.getItem(newConversationRevisionKey(index)) || mintTabId();
|
|
// Verify persistence is writable; a blocked reload must not trust an old reset revision.
|
|
sessionStorage.setItem(newConversationRevisionKey(index), revision);
|
|
} catch {
|
|
revision = mintTabId();
|
|
}
|
|
const scopedRevision = `${getBrowserTabId()}:${revision}`;
|
|
newConversationDraftRevisions.set(index, scopedRevision);
|
|
return scopedRevision;
|
|
};
|
|
|
|
/** Per-composer identity so a side-by-side new-chat reset cannot discard another pane's paste recovery. */
|
|
export const getNewConversationDraftToken = (index = 0): symbol => {
|
|
const existing = newConversationDraftTokens.get(index);
|
|
if (existing) {
|
|
return existing;
|
|
}
|
|
const token = Symbol('new-conversation-draft');
|
|
newConversationDraftTokens.set(index, token);
|
|
return token;
|
|
};
|
|
|
|
export const renewNewConversationDraftToken = (index = 0): void => {
|
|
const generation = Symbol('new-conversation-draft');
|
|
newConversationDraftTokens.set(index, generation);
|
|
const revision = mintTabId();
|
|
newConversationDraftRevisions.set(index, `${getBrowserTabId()}:${revision}`);
|
|
try {
|
|
sessionStorage.setItem(newConversationRevisionKey(index), revision);
|
|
} catch {
|
|
// The live revision still fences this document; blocked reloads start a fresh revision.
|
|
}
|
|
const scope = composerDraftScopes.get(index);
|
|
if (scope?.active && scope.conversationId === Constants.NEW_CONVO) {
|
|
composerDraftScopes.set(index, {
|
|
...scope,
|
|
generation,
|
|
route: composerRoute(),
|
|
sourceId: undefined,
|
|
sourcePropPending: false,
|
|
assignedRoute: undefined,
|
|
assignments: new Set(),
|
|
});
|
|
}
|
|
};
|
|
|
|
/** Draft key used while a run is in flight. Extra panes get a suffix so one run cannot migrate another pane's attachments. */
|
|
export const getPendingDraftId = (index = 0): string =>
|
|
index === 0 ? Constants.PENDING_CONVO : `${Constants.PENDING_CONVO}:${index}`;
|
|
|
|
/** Draft key for an idle unsaved chat. Extra panes get a suffix so two new composers do not share FILES_DRAFT. */
|
|
export const getNewConversationDraftId = (index = 0): string =>
|
|
index === 0 ? Constants.NEW_CONVO : `${Constants.NEW_CONVO}:${index}`;
|
|
|
|
export const isNewConversationDraftId = (id?: string | null): boolean =>
|
|
typeof id === 'string' &&
|
|
(id === Constants.NEW_CONVO || id.startsWith(`${Constants.NEW_CONVO}:`));
|
|
|
|
export const isPendingDraftId = (id?: string | null): boolean =>
|
|
typeof id === 'string' &&
|
|
(id === Constants.PENDING_CONVO || id.startsWith(`${Constants.PENDING_CONVO}:`));
|
|
|
|
/** Keys every tab's default composer reaches, rather than one conversation's own draft. These are
|
|
* the records a destructive action has to check an owner for. */
|
|
export const isSharedComposerDraftId = (id?: string | null): boolean =>
|
|
isNewConversationDraftId(id) || isPendingDraftId(id);
|
|
|
|
export const getConversationDraftId = (index = 0, conversationId?: string | null): string =>
|
|
conversationId == null || conversationId === '' || conversationId === Constants.NEW_CONVO
|
|
? getNewConversationDraftId(index)
|
|
: conversationId;
|
|
|
|
export const getComposerDraftId = (
|
|
index = 0,
|
|
conversationId?: string | null,
|
|
isSubmitting = false,
|
|
): string =>
|
|
isSubmitting ? getPendingDraftId(index) : getConversationDraftId(index, conversationId);
|
|
|
|
const getReplacedLength = (pendingPaste: PendingTextAttachmentDraft): number => {
|
|
if (pendingPaste.replacedText != null && pendingPaste.replacedText.length > 0) {
|
|
return pendingPaste.replacedText.length;
|
|
}
|
|
if (pendingPaste.selectionEnd != null) {
|
|
return Math.max(0, pendingPaste.selectionEnd - pendingPaste.selectionStart);
|
|
}
|
|
return 0;
|
|
};
|
|
|
|
const findAnchoredInsertStart = (
|
|
draftText: string,
|
|
before: string,
|
|
after: string,
|
|
): number | null => {
|
|
if (before && after) {
|
|
let insertStart: number | null = null;
|
|
let searchFrom = 0;
|
|
while (searchFrom <= draftText.length) {
|
|
const beforeIndex = draftText.indexOf(before, searchFrom);
|
|
if (beforeIndex < 0) {
|
|
break;
|
|
}
|
|
const candidate = beforeIndex + before.length;
|
|
if (draftText.indexOf(after, candidate) >= 0) {
|
|
insertStart = candidate;
|
|
}
|
|
searchFrom = beforeIndex + 1;
|
|
}
|
|
if (insertStart != null) {
|
|
return insertStart;
|
|
}
|
|
}
|
|
if (before) {
|
|
const beforeIndex = draftText.lastIndexOf(before);
|
|
if (beforeIndex >= 0) {
|
|
return beforeIndex + before.length;
|
|
}
|
|
}
|
|
if (after) {
|
|
const afterIndex = draftText.indexOf(after);
|
|
if (afterIndex >= 0) {
|
|
return afterIndex;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* The offset closest to the original caret where both captured anchors survived the edit intact
|
|
* and still meet. A repeated anchor leaves several such offsets, and the caret is the only
|
|
* evidence left of which one the paste belongs to; the scan opens there, so the first hit is it.
|
|
*/
|
|
const findIntactAnchorJunction = (
|
|
draftText: string,
|
|
before: string,
|
|
after: string,
|
|
): number | null => {
|
|
if (before === '' && after === '') {
|
|
return null;
|
|
}
|
|
const lastJunction = draftText.length - after.length;
|
|
for (let start = before.length; start <= lastJunction; start++) {
|
|
if (!draftText.startsWith(before, start - before.length)) {
|
|
continue;
|
|
}
|
|
if (draftText.startsWith(after, start)) {
|
|
return start;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
export const resolvePendingPasteInsertStart = (
|
|
draftText: string,
|
|
pendingPaste: PendingTextAttachmentDraft,
|
|
): number => {
|
|
const prefix = pendingPaste.anchorBefore;
|
|
const suffix = pendingPaste.anchorAfter;
|
|
if (prefix == null && suffix == null) {
|
|
return Math.min(pendingPaste.selectionStart, draftText.length);
|
|
}
|
|
const before = prefix ?? '';
|
|
const after = suffix ?? '';
|
|
if (draftText === `${before}${after}`) {
|
|
return before.length;
|
|
}
|
|
const intactJunction = findIntactAnchorJunction(draftText, before, after);
|
|
if (intactJunction != null) {
|
|
return intactJunction;
|
|
}
|
|
if (before && draftText.startsWith(before)) {
|
|
return before.length;
|
|
}
|
|
if (after !== '' && draftText.endsWith(after)) {
|
|
return draftText.length - after.length;
|
|
}
|
|
if (after === '' && before && draftText.endsWith(before)) {
|
|
return draftText.length;
|
|
}
|
|
return (
|
|
findAnchoredInsertStart(draftText, before, after) ??
|
|
Math.min(pendingPaste.selectionStart, draftText.length)
|
|
);
|
|
};
|
|
|
|
/** Replay leftover pre-deletion ranges, then insert paste text at rebased or anchored offsets. */
|
|
export const applyPendingPastesToDraft = (
|
|
draftText: string,
|
|
pendingPastes: PendingTextAttachmentDraft[],
|
|
): string => {
|
|
if (pendingPastes.length === 0) {
|
|
return draftText;
|
|
}
|
|
|
|
const ordered = pendingPastes.map((pendingPaste, index) => ({ pendingPaste, index }));
|
|
ordered.sort(
|
|
(a, b) =>
|
|
(a.pendingPaste.sequence ?? a.index) - (b.pendingPaste.sequence ?? b.index) ||
|
|
a.index - b.index,
|
|
);
|
|
|
|
let text = draftText;
|
|
for (const { pendingPaste } of ordered) {
|
|
if (pendingPaste.replacedApplied) {
|
|
continue;
|
|
}
|
|
const replacedText = pendingPaste.replacedText ?? '';
|
|
const start = Math.min(pendingPaste.selectionStart, text.length);
|
|
if (
|
|
replacedText.length > 0 &&
|
|
text.slice(start, start + replacedText.length) === replacedText
|
|
) {
|
|
text = `${text.slice(0, start)}${text.slice(start + replacedText.length)}`;
|
|
}
|
|
}
|
|
|
|
const insertions = ordered.map(({ pendingPaste }, index) => {
|
|
if (pendingPaste.replacedApplied) {
|
|
return {
|
|
text: pendingPaste.text,
|
|
start: resolvePendingPasteInsertStart(draftText, pendingPaste),
|
|
index,
|
|
};
|
|
}
|
|
let start = pendingPaste.selectionStart;
|
|
for (const later of ordered.slice(index + 1)) {
|
|
if (later.pendingPaste.selectionStart < start) {
|
|
start -= getReplacedLength(later.pendingPaste);
|
|
}
|
|
}
|
|
return { text: pendingPaste.text, start: Math.max(0, start), index };
|
|
});
|
|
insertions.sort((a, b) => b.start - a.start || b.index - a.index);
|
|
|
|
for (const insertion of insertions) {
|
|
const start = Math.min(insertion.start, text.length);
|
|
text = `${text.slice(0, start)}${insertion.text}${text.slice(start)}`;
|
|
}
|
|
return text;
|
|
};
|
|
|
|
const getLocalStorageItem = (key: string): string | null => {
|
|
try {
|
|
return localStorage.getItem(key);
|
|
} catch {
|
|
// Privacy-blocked storage must not abort paste/upload recovery.
|
|
return null;
|
|
}
|
|
};
|
|
|
|
const ownershipChanges = new Set<string>();
|
|
const ownershipListeners = new Set<(keys: ReadonlySet<string>) => void>();
|
|
let ownershipNotificationPending = false;
|
|
|
|
const notifyOwnershipChange = (key: string): void => {
|
|
ownershipChanges.add(key);
|
|
if (ownershipNotificationPending) return;
|
|
ownershipNotificationPending = true;
|
|
void Promise.resolve().then(() => {
|
|
ownershipNotificationPending = false;
|
|
const keys = new Set(ownershipChanges);
|
|
ownershipChanges.clear();
|
|
ownershipListeners.forEach((listener) => listener(keys));
|
|
});
|
|
};
|
|
|
|
export const subscribeDraftOwnership = (id: string, onChange: () => void): (() => void) => {
|
|
const draftKey = `${LocalStorageKeys.FILES_DRAFT}${id}`;
|
|
const relevant = (key: string): boolean =>
|
|
key === draftKey || key.startsWith(TAB_PRESENCE_KEY_PREFIX);
|
|
const local = (keys: ReadonlySet<string>) => {
|
|
for (const key of keys) {
|
|
if (!relevant(key)) continue;
|
|
onChange();
|
|
return;
|
|
}
|
|
};
|
|
const external = (event: StorageEvent) => {
|
|
if (event.key == null || relevant(event.key)) onChange();
|
|
};
|
|
ownershipListeners.add(local);
|
|
window.addEventListener('storage', external);
|
|
return () => {
|
|
ownershipListeners.delete(local);
|
|
window.removeEventListener('storage', external);
|
|
};
|
|
};
|
|
|
|
type ComposerDraftScope = {
|
|
conversationId: string;
|
|
draftId: string;
|
|
host?: object;
|
|
registration: object;
|
|
active: boolean;
|
|
generation: symbol;
|
|
answerId: string | null;
|
|
route: string;
|
|
assignedRoute?: string;
|
|
sourceId?: string;
|
|
sourcePropPending?: boolean;
|
|
assignments: Set<(sourceId: string, targetId: string) => void>;
|
|
};
|
|
const composerDraftMigrations = new Set<(fromId: string, toId: string) => void>();
|
|
const composerDraftScopes = new Map<number, ComposerDraftScope>();
|
|
const composerLaunches = new WeakMap<object, { index: number; scope: ComposerDraftScope }>();
|
|
const composerRoute = () => window.location.pathname + window.location.search;
|
|
|
|
const matchesComposerRoute = (scope: ComposerDraftScope): boolean => {
|
|
const route = composerRoute();
|
|
if (!scope.sourcePropPending && scope.assignedRoute === route) {
|
|
scope.route = route;
|
|
}
|
|
return route === scope.route || route === scope.assignedRoute;
|
|
};
|
|
|
|
export const registerComposerDraft = (
|
|
index: number,
|
|
conversationId: string,
|
|
draftId: string,
|
|
host?: object,
|
|
): (() => void) => {
|
|
const previous = composerDraftScopes.get(index);
|
|
const generation = getNewConversationDraftToken(index);
|
|
const answerId = isAskAnswerDraftId(draftId) ? draftId : null;
|
|
const route = composerRoute();
|
|
const scope: ComposerDraftScope =
|
|
host &&
|
|
previous != null &&
|
|
(previous.host === host || (!previous.active && previous.sourceId != null)) &&
|
|
previous.generation === generation &&
|
|
(previous.conversationId === conversationId ||
|
|
(previous.sourcePropPending && previous.sourceId === conversationId)) &&
|
|
previous.answerId === answerId &&
|
|
(previous.route === route || previous.assignedRoute === route)
|
|
? previous
|
|
: {
|
|
conversationId,
|
|
draftId,
|
|
host,
|
|
registration: {},
|
|
generation,
|
|
answerId,
|
|
active: true,
|
|
route,
|
|
assignments: new Set<(sourceId: string, targetId: string) => void>(),
|
|
};
|
|
if (previous && scope !== previous && conversationId === Constants.NEW_CONVO) {
|
|
renewNewConversationDraftToken(index);
|
|
scope.generation = getNewConversationDraftToken(index);
|
|
}
|
|
const registration = {};
|
|
scope.registration = registration;
|
|
scope.host = host;
|
|
scope.active = true;
|
|
scope.draftId = draftId;
|
|
if (scope.conversationId === conversationId) {
|
|
scope.sourcePropPending = false;
|
|
if (scope.assignedRoute === route) scope.route = route;
|
|
}
|
|
composerDraftScopes.set(index, scope);
|
|
return () => {
|
|
const current = composerDraftScopes.get(index);
|
|
if (current?.registration !== registration) return;
|
|
current.active = false;
|
|
void Promise.resolve().then(() => {
|
|
if (composerDraftScopes.get(index) === current && !current.active) {
|
|
if (current.conversationId === Constants.NEW_CONVO) {
|
|
renewNewConversationDraftToken(index);
|
|
}
|
|
composerDraftScopes.delete(index);
|
|
}
|
|
});
|
|
};
|
|
};
|
|
|
|
export const getActiveComposerDraftId = (index: number, conversationId: string): string | null => {
|
|
const scope = composerDraftScopes.get(index);
|
|
return scope?.active && scope.conversationId === conversationId ? scope.draftId : null;
|
|
};
|
|
|
|
const normalizedComposerSearch = (search: string): string => {
|
|
const params = new URLSearchParams(search);
|
|
params.sort();
|
|
return params.toString();
|
|
};
|
|
|
|
/** Only consumed parameters change here; project and navigation changes keep their fence. */
|
|
export const consumeComposerQuery = (
|
|
index: number,
|
|
conversationId: string,
|
|
pathname: string,
|
|
previousSearch: string,
|
|
nextSearch: string,
|
|
): void => {
|
|
const scope = composerDraftScopes.get(index);
|
|
if (
|
|
!scope?.active ||
|
|
scope.generation !== getNewConversationDraftToken(index) ||
|
|
(scope.conversationId !== conversationId && scope.sourceId !== conversationId)
|
|
) {
|
|
return;
|
|
}
|
|
const previous = new URLSearchParams(previousSearch);
|
|
const next = new URLSearchParams(nextSearch);
|
|
if (
|
|
(previous.get('projectId') || null) !== (next.get('projectId') || null) ||
|
|
Array.from(next.keys()).some((key) => key !== 'projectId')
|
|
) {
|
|
return;
|
|
}
|
|
const expectedSearch = normalizedComposerSearch(previousSearch);
|
|
const cleanedSearch = next.toString();
|
|
for (const field of ['route', 'assignedRoute'] as const) {
|
|
const value = scope[field];
|
|
if (value == null) continue;
|
|
const route = new URL(value, window.location.origin);
|
|
if (route.pathname !== pathname || normalizedComposerSearch(route.search) !== expectedSearch) {
|
|
continue;
|
|
}
|
|
scope[field] = pathname + (cleanedSearch ? `?${cleanedSearch}` : '');
|
|
}
|
|
};
|
|
|
|
export const bindComposerLaunch = (
|
|
conversation: object | null | undefined,
|
|
index: number,
|
|
): void => {
|
|
const scope = composerDraftScopes.get(index);
|
|
if (conversation && scope?.active) composerLaunches.set(conversation, { index, scope });
|
|
};
|
|
|
|
/** Only an acknowledged submission may rename a composer; assignment effects run once. */
|
|
export const adoptComposerConversation = (
|
|
conversation: object | null | undefined,
|
|
targetId: string,
|
|
index: number,
|
|
onAssignment?: (sourceId: string, targetId: string) => void,
|
|
): boolean => {
|
|
const launch = conversation ? composerLaunches.get(conversation) : undefined;
|
|
const scope = launch?.scope;
|
|
if (
|
|
!scope ||
|
|
launch?.index !== index ||
|
|
!scope.active ||
|
|
composerDraftScopes.get(index) !== scope ||
|
|
scope.generation !== getNewConversationDraftToken(index) ||
|
|
!targetId ||
|
|
targetId === Constants.NEW_CONVO
|
|
)
|
|
return false;
|
|
if (scope.sourceId === Constants.NEW_CONVO && scope.conversationId === targetId) {
|
|
return matchesComposerRoute(scope);
|
|
}
|
|
if (scope.conversationId !== Constants.NEW_CONVO || composerRoute() !== scope.route) return false;
|
|
const sourceId = scope.conversationId;
|
|
scope.sourceId = sourceId;
|
|
scope.sourcePropPending = true;
|
|
scope.conversationId = targetId;
|
|
const assignedRoute = new URL(scope.route, window.location.origin);
|
|
assignedRoute.pathname = assignedRoute.pathname.replace(
|
|
/\/new$/,
|
|
`/${encodeURIComponent(targetId)}`,
|
|
);
|
|
scope.assignedRoute = assignedRoute.pathname + assignedRoute.search;
|
|
scope.assignments.forEach((listener) => listener(sourceId, targetId));
|
|
onAssignment?.(sourceId, targetId);
|
|
return true;
|
|
};
|
|
|
|
export const resolveComposerConversationId = (conversationId: string): string => {
|
|
let assignedId: string | undefined;
|
|
for (const [index, scope] of composerDraftScopes) {
|
|
if (!scope.active || scope.generation !== getNewConversationDraftToken(index)) continue;
|
|
if (scope.conversationId === conversationId) return conversationId;
|
|
if (scope.sourceId !== conversationId) continue;
|
|
if (assignedId != null) return conversationId;
|
|
assignedId = scope.conversationId;
|
|
}
|
|
return assignedId ?? conversationId;
|
|
};
|
|
|
|
export type CapturedComposerDraft = (() => boolean) & {
|
|
registered: boolean;
|
|
newChatGeneration?: Readonly<{ index: number; revision: string }>;
|
|
conversationId: () => string;
|
|
retainsFile: (fileId: string) => boolean;
|
|
discardFile: (fileId: string) => void;
|
|
onAssignment: (listener: (sourceId: string, targetId: string) => void) => () => void;
|
|
};
|
|
|
|
export const captureComposerDraft = (
|
|
index: number,
|
|
conversationId: string,
|
|
): CapturedComposerDraft => {
|
|
const scope = composerDraftScopes.get(index);
|
|
const generation = getNewConversationDraftToken(index);
|
|
const route = composerRoute();
|
|
return Object.assign(
|
|
() =>
|
|
(!scope ||
|
|
(scope.active &&
|
|
(scope.conversationId === conversationId || scope.sourceId === conversationId))) &&
|
|
composerDraftScopes.get(index) === scope &&
|
|
getNewConversationDraftToken(index) === generation &&
|
|
(scope ? matchesComposerRoute(scope) : composerRoute() === route),
|
|
{
|
|
registered: scope != null,
|
|
newChatGeneration:
|
|
conversationId === Constants.NEW_CONVO
|
|
? { index, revision: getNewConversationDraftRevision(index) }
|
|
: undefined,
|
|
conversationId: () => scope?.conversationId ?? conversationId,
|
|
retainsFile: (fileId: string) => {
|
|
if (!scope || scope.conversationId === Constants.NEW_CONVO) return false;
|
|
const draft = getFilesDraft(scope.draftId);
|
|
return isFilesDraftOwnedByThisTab(draft) && draft.fileIds.includes(fileId);
|
|
},
|
|
discardFile: (fileId: string) => {
|
|
const draftIds = new Set([scope?.draftId ?? getConversationDraftId(index, conversationId)]);
|
|
if (conversationId === Constants.NEW_CONVO) {
|
|
draftIds.add(getNewConversationDraftId(index));
|
|
draftIds.add(getPendingDraftId(index));
|
|
}
|
|
for (const id of draftIds) {
|
|
const draft = getFilesDraft(id);
|
|
if (isFilesDraftOwnedByThisTab(draft) && draft.fileIds.includes(fileId)) {
|
|
removePendingTextAttachmentDraft({ id, fileId, removeFile: true });
|
|
}
|
|
}
|
|
},
|
|
onAssignment: (listener: (sourceId: string, targetId: string) => void) => {
|
|
const migrate = (fromId: string, toId: string) => {
|
|
if (
|
|
scope != null &&
|
|
scope.draftId === fromId &&
|
|
isPendingDraftId(fromId) &&
|
|
scope.conversationId === toId &&
|
|
toId !== Constants.NEW_CONVO
|
|
) {
|
|
scope.draftId = toId;
|
|
}
|
|
};
|
|
scope?.assignments.add(listener);
|
|
composerDraftMigrations.add(migrate);
|
|
return () => {
|
|
scope?.assignments.delete(listener);
|
|
composerDraftMigrations.delete(migrate);
|
|
};
|
|
},
|
|
},
|
|
);
|
|
};
|
|
|
|
const setLocalStorageItem = (key: string, value: string): void => {
|
|
try {
|
|
const changed =
|
|
key.startsWith(LocalStorageKeys.FILES_DRAFT) && localStorage.getItem(key) !== value;
|
|
localStorage.setItem(key, value);
|
|
if (changed) notifyOwnershipChange(key);
|
|
} catch {
|
|
// Quota or disabled storage must not abort paste/upload recovery.
|
|
}
|
|
};
|
|
|
|
const removeLocalStorageItem = (key: string): void => {
|
|
try {
|
|
const changed =
|
|
key.startsWith(LocalStorageKeys.FILES_DRAFT) && localStorage.getItem(key) != null;
|
|
localStorage.removeItem(key);
|
|
if (changed) notifyOwnershipChange(key);
|
|
} catch {
|
|
// Ignore storage failures on cleanup.
|
|
}
|
|
};
|
|
|
|
/** Navigation must clear before another visit can save replacement text under the same key. */
|
|
export const clearDraft = (id?: string | null) => {
|
|
const key = id ?? '';
|
|
if (!mayClearComposerDrafts(key)) {
|
|
return;
|
|
}
|
|
removeLocalStorageItem(`${LocalStorageKeys.TEXT_DRAFT}${key}`);
|
|
};
|
|
|
|
/** Synchronously removes both text and file drafts for a conversation (or NEW_CONVO fallback).
|
|
* A record another live tab owns is left alone, attachment or not: every key here is reachable
|
|
* from more than one tab, and clearing one would take that tab's unsent text and its attachment
|
|
* recovery with it. */
|
|
export const clearAllDrafts = (conversationId?: string | null) => {
|
|
const key = conversationId || Constants.NEW_CONVO;
|
|
if (!mayClearComposerDrafts(key)) {
|
|
return;
|
|
}
|
|
removeLocalStorageItem(`${LocalStorageKeys.TEXT_DRAFT}${key}`);
|
|
removeLocalStorageItem(`${LocalStorageKeys.FILES_DRAFT}${key}`);
|
|
};
|
|
|
|
/** Clears this pane's concrete conversation draft. The idle new-chat key is only removed when the finished run originated as an unsaved chat. Leaves PENDING so unsent during-run attachments can migrate. */
|
|
export const clearComposerDrafts = (
|
|
index = 0,
|
|
conversationId?: string | null,
|
|
options?: { includeNewChatDraft?: boolean },
|
|
): void => {
|
|
const originatedFromNewChat =
|
|
options?.includeNewChatDraft ??
|
|
(conversationId == null ||
|
|
conversationId === '' ||
|
|
conversationId === Constants.NEW_CONVO ||
|
|
isNewConversationDraftId(conversationId));
|
|
const keys = new Set<string>();
|
|
if (originatedFromNewChat) {
|
|
keys.add(getNewConversationDraftId(index));
|
|
}
|
|
if (conversationId != null && conversationId !== '') {
|
|
keys.add(getConversationDraftId(index, conversationId));
|
|
if (conversationId !== Constants.NEW_CONVO && conversationId !== Constants.PENDING_CONVO) {
|
|
keys.add(conversationId);
|
|
}
|
|
}
|
|
for (const key of keys) {
|
|
clearAllDrafts(key);
|
|
}
|
|
};
|
|
|
|
/** Spreading a whole paste into `String.fromCharCode` blows the argument limit, and the paste
|
|
* sizes this recovery exists for are exactly the ones that reach it. */
|
|
const BINARY_STRING_CHUNK = 0x8000;
|
|
|
|
export const encodeBase64 = (plainText: string): string => {
|
|
try {
|
|
const textBytes = new TextEncoder().encode(plainText);
|
|
let binary = '';
|
|
for (let start = 0; start < textBytes.length; start += BINARY_STRING_CHUNK) {
|
|
binary += String.fromCharCode(...textBytes.subarray(start, start + BINARY_STRING_CHUNK));
|
|
}
|
|
return btoa(binary);
|
|
} catch {
|
|
return '';
|
|
}
|
|
};
|
|
|
|
export const decodeBase64 = (base64String: string): string => {
|
|
try {
|
|
const bytes = atob(base64String);
|
|
const uint8Array = new Uint8Array(bytes.length);
|
|
for (let i = 0; i < bytes.length; i++) {
|
|
uint8Array[i] = bytes.charCodeAt(i);
|
|
}
|
|
return new TextDecoder().decode(uint8Array);
|
|
} catch {
|
|
return '';
|
|
}
|
|
};
|
|
|
|
export const getFilesDraft = (id: string): FilesDraft => {
|
|
const storedValue = getLocalStorageItem(`${LocalStorageKeys.FILES_DRAFT}${id}`);
|
|
if (!storedValue) {
|
|
return { fileIds: [], pendingPastes: {} };
|
|
}
|
|
|
|
try {
|
|
const storedDraft = JSON.parse(storedValue) as string[] | StoredFilesDraft;
|
|
if (Array.isArray(storedDraft)) {
|
|
return { fileIds: storedDraft, pendingPastes: {} };
|
|
}
|
|
|
|
const pendingPastes = Object.fromEntries(
|
|
Object.entries(storedDraft.pendingPastes ?? {}).map(
|
|
([fileId, pendingPaste]): [string, PendingTextAttachmentDraft] => [
|
|
fileId,
|
|
{
|
|
text: decodeBase64(pendingPaste.encodedText),
|
|
selectionStart: pendingPaste.selectionStart,
|
|
...(pendingPaste.selectionEnd != null
|
|
? { selectionEnd: pendingPaste.selectionEnd }
|
|
: {}),
|
|
...(pendingPaste.encodedReplacedText
|
|
? { replacedText: decodeBase64(pendingPaste.encodedReplacedText) }
|
|
: {}),
|
|
...(pendingPaste.sequence != null ? { sequence: pendingPaste.sequence } : {}),
|
|
...(pendingPaste.replacedApplied ? { replacedApplied: true } : {}),
|
|
...(pendingPaste.encodedAnchorBefore != null
|
|
? { anchorBefore: decodeBase64(pendingPaste.encodedAnchorBefore) }
|
|
: {}),
|
|
...(pendingPaste.encodedAnchorAfter != null
|
|
? { anchorAfter: decodeBase64(pendingPaste.encodedAnchorAfter) }
|
|
: {}),
|
|
},
|
|
],
|
|
),
|
|
);
|
|
|
|
return {
|
|
fileIds: Array.isArray(storedDraft.fileIds) ? storedDraft.fileIds : [],
|
|
pendingPastes,
|
|
...(storedDraft.textPreviews &&
|
|
typeof storedDraft.textPreviews === 'object' && {
|
|
textPreviews: Object.fromEntries(
|
|
Object.entries(storedDraft.textPreviews)
|
|
.filter((entry): entry is [string, string] => typeof entry[1] === 'string')
|
|
.map(([id, text]) => [id, text.slice(0, MAX_FILE_TEXT_PREVIEW_LENGTH)]),
|
|
),
|
|
}),
|
|
pastedTextIds: Array.isArray(storedDraft.pastedTextIds) ? storedDraft.pastedTextIds : [],
|
|
tabId: typeof storedDraft.tabId === 'string' ? storedDraft.tabId : undefined,
|
|
};
|
|
} catch {
|
|
return { fileIds: [], pendingPastes: {} };
|
|
}
|
|
};
|
|
|
|
const TAB_SESSION_STORAGE_KEY = 'librechat-tab-session';
|
|
|
|
let documentTabId: string | null = null;
|
|
|
|
/** Identifies this browser tab for the session. `sessionStorage` is per-tab and survives that
|
|
* tab's reloads, which is exactly the ownership an unsaved-chat draft needs: the draft key is
|
|
* shared through `localStorage` by every tab's default composer, while the composer that owns
|
|
* the record stays identifiable.
|
|
*
|
|
* One caveat decides the shape below: duplicated and opener-created tabs start with a COPY of
|
|
* the original's `sessionStorage`, so a stored id on its own proves nothing. Reload of the same
|
|
* document legitimately keeps it, and so does Back/Forward after the document was evicted from
|
|
* the back-forward cache (Navigation Timing reports `back_forward`, not `reload`). Every other
|
|
* entry into a document mints a fresh id, because an inherited one would attribute another
|
|
* tab's live drafts to this composer. */
|
|
/** `crypto.randomUUID` is missing on insecure origins and in older webviews, and letting that
|
|
* throw would leave the tab with no identity at all: every draft would be written unowned and
|
|
* every guard here would read another tab's record as its own. The id only has to tell tabs
|
|
* apart, never resist guessing, so any unique-enough value serves. */
|
|
const mintTabId = (): string => {
|
|
if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
|
|
try {
|
|
return crypto.randomUUID();
|
|
} catch {
|
|
// Fall through to the local mint.
|
|
}
|
|
}
|
|
if (typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function') {
|
|
const bytes = crypto.getRandomValues(new Uint8Array(16));
|
|
return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('');
|
|
}
|
|
return `tab-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 12)}`;
|
|
};
|
|
|
|
const resolveBrowserTabId = (): string => {
|
|
try {
|
|
const stored = sessionStorage.getItem(TAB_SESSION_STORAGE_KEY);
|
|
if (documentTabId != null && stored === documentTabId) {
|
|
return documentTabId;
|
|
}
|
|
const navigationType =
|
|
typeof performance.getEntriesByType === 'function'
|
|
? performance.getEntriesByType('navigation')[0]?.type
|
|
: undefined;
|
|
if (
|
|
stored != null &&
|
|
stored !== '' &&
|
|
(navigationType === 'reload' || navigationType === 'back_forward')
|
|
) {
|
|
documentTabId = stored;
|
|
return stored;
|
|
}
|
|
documentTabId = mintTabId();
|
|
sessionStorage.setItem(TAB_SESSION_STORAGE_KEY, documentTabId);
|
|
return documentTabId;
|
|
} catch {
|
|
/** Session storage can be blocked or full while `localStorage` still works. Returning '' here
|
|
* gave the document no identity at all, and every ownership and liveness guard reads '' as
|
|
* unattributed, so tabs would overwrite and destructively clear each other's attachment-backed
|
|
* drafts. An id that lives only for this document still tells the open tabs apart; all that is
|
|
* lost is recognising itself after a reload. */
|
|
documentTabId = documentTabId ?? mintTabId();
|
|
return documentTabId;
|
|
}
|
|
};
|
|
|
|
/** `suspended` marks a document sitting in the back-forward cache: frozen rather than gone.
|
|
* `attachments` is what that tab's composers currently hold, per pane, so cleanup running in one
|
|
* tab can see what another has on screen even when nothing was written to a draft. */
|
|
type TabPresence = {
|
|
seenAt: number;
|
|
suspended?: boolean;
|
|
attachments?: Record<string, string[]>;
|
|
/** Ids this tab held recently, kept for a while after they leave the composer. Sending a
|
|
* message empties the map and clears the draft, so without this a file reattached here and
|
|
* then sent would go unprotected between another tab's retries and be deleted out of the
|
|
* message that now references it. A retry that sees one cancels its record for good, so the
|
|
* window only has to outlast that tab's backoff. */
|
|
recent?: Record<string, number>;
|
|
};
|
|
type StoredTabPresence = {
|
|
seenAt?: number;
|
|
suspended?: boolean;
|
|
attachments?: unknown;
|
|
recent?: unknown;
|
|
};
|
|
|
|
const RECENT_ATTACHMENT_WINDOW_MS = 600_000;
|
|
|
|
/** One key per tab, never a shared map. Two tabs beating at the same time would otherwise read
|
|
* the same registry and write back rival snapshots, and the loser of that race disappears until
|
|
* its next beat, long enough for another tab to treat its live draft as abandoned. */
|
|
const TAB_PRESENCE_KEY_PREFIX = 'librechat-live-tab:';
|
|
const TAB_HEARTBEAT_MS = 10_000;
|
|
/** A hidden tab has its timers throttled to roughly one tick a minute, so the gap between two
|
|
* heartbeats of a perfectly healthy background composer is far wider than the interval asks for.
|
|
* The window has to clear that comfortably, or a backgrounded tab would have its own draft taken
|
|
* away from it. Losing a closed tab's claim a couple of minutes late costs nothing; taking a live
|
|
* tab's draft costs the text it was still writing. */
|
|
const TAB_LIVENESS_WINDOW_MS = 150_000;
|
|
/** A bfcached document's heartbeat is frozen, so the ordinary window would expire a tab that can
|
|
* still be restored with those attachments on screen, and another tab could delete the files
|
|
* underneath it. It gets a far longer grace, comfortably past the point where browsers evict a
|
|
* bfcache entry, but still a bounded one: a claim that never expired is exactly what left drafts
|
|
* stranded under owners that no longer existed. */
|
|
const TAB_SUSPENDED_WINDOW_MS = 1_800_000;
|
|
|
|
const isPresenceLive = (presence: TabPresence, now: number): boolean =>
|
|
now - presence.seenAt <=
|
|
(presence.suspended === true ? TAB_SUSPENDED_WINDOW_MS : TAB_LIVENESS_WINDOW_MS);
|
|
|
|
const toAttachments = (value: unknown): Record<string, string[]> | undefined => {
|
|
if (value == null || typeof value !== 'object' || Array.isArray(value)) {
|
|
return undefined;
|
|
}
|
|
const attachments: Record<string, string[]> = {};
|
|
for (const [pane, ids] of Object.entries(value as Record<string, unknown>)) {
|
|
if (Array.isArray(ids)) {
|
|
attachments[pane] = ids.filter((id): id is string => typeof id === 'string');
|
|
}
|
|
}
|
|
return attachments;
|
|
};
|
|
|
|
const toRecent = (value: unknown): Record<string, number> | undefined => {
|
|
if (value == null || typeof value !== 'object' || Array.isArray(value)) {
|
|
return undefined;
|
|
}
|
|
const recent: Record<string, number> = {};
|
|
for (const [id, seenAt] of Object.entries(value as Record<string, unknown>)) {
|
|
if (typeof seenAt === 'number') {
|
|
recent[id] = seenAt;
|
|
}
|
|
}
|
|
return recent;
|
|
};
|
|
|
|
const readTabPresence = (tabId: string): TabPresence | null => {
|
|
try {
|
|
const raw = localStorage.getItem(`${TAB_PRESENCE_KEY_PREFIX}${tabId}`);
|
|
if (raw == null || raw === '') {
|
|
return null;
|
|
}
|
|
const parsed = JSON.parse(raw) as StoredTabPresence | null;
|
|
if (parsed == null || typeof parsed.seenAt !== 'number') {
|
|
return null;
|
|
}
|
|
return {
|
|
seenAt: parsed.seenAt,
|
|
suspended: parsed.suspended === true,
|
|
attachments: toAttachments(parsed.attachments),
|
|
recent: toRecent(parsed.recent),
|
|
};
|
|
} catch {
|
|
return null;
|
|
}
|
|
};
|
|
|
|
const writeTabPresence = (tabId: string, presence: TabPresence): void => {
|
|
try {
|
|
localStorage.setItem(`${TAB_PRESENCE_KEY_PREFIX}${tabId}`, JSON.stringify(presence));
|
|
} catch {
|
|
// A tab that cannot record a heartbeat reads as gone, which only ever releases its claims.
|
|
}
|
|
};
|
|
|
|
/** Every tab still reporting, dropping the records of those that stopped so the store cannot grow
|
|
* an entry for every tab the browser has ever opened. */
|
|
const readLiveTabs = (): Map<string, TabPresence> => {
|
|
const live = new Map<string, TabPresence>();
|
|
try {
|
|
const now = Date.now();
|
|
const expired: string[] = [];
|
|
for (let i = 0; i < localStorage.length; i++) {
|
|
const key = localStorage.key(i);
|
|
if (key == null || !key.startsWith(TAB_PRESENCE_KEY_PREFIX)) {
|
|
continue;
|
|
}
|
|
const tabId = key.slice(TAB_PRESENCE_KEY_PREFIX.length);
|
|
const presence = readTabPresence(tabId);
|
|
if (presence == null || !isPresenceLive(presence, now)) {
|
|
expired.push(key);
|
|
continue;
|
|
}
|
|
live.set(tabId, presence);
|
|
}
|
|
for (const key of expired) {
|
|
localStorage.removeItem(key);
|
|
if (key !== `${TAB_PRESENCE_KEY_PREFIX}${documentTabId}`) notifyOwnershipChange(key);
|
|
}
|
|
} catch {
|
|
// An unreadable store just means no other tab can be proven live.
|
|
}
|
|
return live;
|
|
};
|
|
|
|
/** Marks this tab as present. Only ever writes this tab's own key, so concurrent beats cannot
|
|
* overwrite one another. */
|
|
const recordTabPresence = (tabId: string, suspended = false): void => {
|
|
/** Read before sweeping, never after. Timers pause while the machine sleeps, so a perfectly
|
|
* live tab can come back with its own record already past the liveness window; letting the
|
|
* sweep reap it first and then rewriting from nothing published an empty presence, and because
|
|
* the file map had not changed there was nothing to make `useAutoSave` republish it. Another
|
|
* tab's retry would then see no claim on chips this one still has on screen. */
|
|
const existing = readTabPresence(tabId);
|
|
/** The beat is the only thing guaranteed to run, so it is where the sweep belongs. Hanging it
|
|
* off cleanup meant a profile that never had a failed deletion accumulated a record for every
|
|
* tab it had ever opened, until the origin quota ran out and draft writes began failing. */
|
|
readLiveTabs();
|
|
writeTabPresence(tabId, {
|
|
seenAt: Date.now(),
|
|
...(suspended ? { suspended: true } : {}),
|
|
...(existing?.attachments != null ? { attachments: existing.attachments } : {}),
|
|
...(existing?.recent != null ? { recent: existing.recent } : {}),
|
|
});
|
|
};
|
|
|
|
/** Publishes what a composer is holding right now, so cleanup in another tab can see attachments
|
|
* that never reached a draft: with draft saving off nothing is written at all, and a reattached
|
|
* file would otherwise look like nobody's. */
|
|
export const publishTabAttachmentIds = (index: number, ids: string[]): void => {
|
|
const tabId = getBrowserTabId();
|
|
if (tabId === '') {
|
|
return;
|
|
}
|
|
const now = Date.now();
|
|
const existing = readTabPresence(tabId);
|
|
const attachments = { ...(existing?.attachments ?? {}) };
|
|
if (ids.length === 0) {
|
|
delete attachments[index];
|
|
} else {
|
|
attachments[index] = ids;
|
|
}
|
|
const recent: Record<string, number> = {};
|
|
for (const [id, seenAt] of Object.entries(existing?.recent ?? {})) {
|
|
if (now - seenAt <= RECENT_ATTACHMENT_WINDOW_MS) {
|
|
recent[id] = seenAt;
|
|
}
|
|
}
|
|
for (const id of ids) {
|
|
recent[id] = now;
|
|
}
|
|
/** Publishing is a user-visible act, so it is proof this tab is running right now. Carrying the
|
|
* old `seenAt` over meant a tab whose timers had been paused past the liveness window published
|
|
* a chip and stayed expired until its next interval tick, long enough for another tab's cleanup
|
|
* to sweep the record and delete the file under the chip that had just appeared. A document
|
|
* publishing attachments is also plainly not frozen in the back-forward cache. */
|
|
writeTabPresence(tabId, {
|
|
seenAt: now,
|
|
...(Object.keys(attachments).length > 0 ? { attachments } : {}),
|
|
...(Object.keys(recent).length > 0 ? { recent } : {}),
|
|
});
|
|
};
|
|
|
|
/** Withdraws attachment ids from this tab's own presence, so a chip that left a composer stops
|
|
* reading as live. A discarded or deleted file otherwise keeps its `recent` entry for the whole
|
|
* window, and the retry sweep reads that as evidence the file was reattached: it cancels its own
|
|
* cleanup and leaves the failed upload orphaned on the server.
|
|
*
|
|
* Strictly this tab's record, never another's. A second tab that reattached the same file and then
|
|
* sent it has an empty composer and an empty draft, so its `recent` entry is the only thing left
|
|
* protecting the file; erasing that here would hand the next retry a file it reads as abandoned
|
|
* and let it delete the upload out of the message that now references it. The withdrawing tab is
|
|
* always the one that published what it is withdrawing, so its own record is all it needs.
|
|
*
|
|
* `index` narrows that further to the one pane doing the withdrawing. One tab holds several
|
|
* composers, and the hook that wins the global deletion pass only knows its own `files` map, so
|
|
* sweeping every pane's entry would erase the evidence of a chip a sibling pane still has on
|
|
* screen. Omitted only by callers that speak for the whole tab. */
|
|
export const removeTabAttachmentPresence = (ids: string[], index?: number): void => {
|
|
if (ids.length === 0) {
|
|
return;
|
|
}
|
|
const tabId = getBrowserTabId();
|
|
if (tabId === '') {
|
|
return;
|
|
}
|
|
const presence = readTabPresence(tabId);
|
|
if (presence == null) {
|
|
return;
|
|
}
|
|
const idSet = new Set(ids);
|
|
let modified = false;
|
|
const attachments = { ...presence.attachments };
|
|
for (const [pane, paneIds] of Object.entries(attachments)) {
|
|
if (index != null && pane !== `${index}`) {
|
|
continue;
|
|
}
|
|
const kept = paneIds.filter((id) => !idSet.has(id));
|
|
if (kept.length === paneIds.length) {
|
|
continue;
|
|
}
|
|
if (kept.length === 0) {
|
|
delete attachments[pane];
|
|
} else {
|
|
attachments[pane] = kept;
|
|
}
|
|
modified = true;
|
|
}
|
|
/** Whatever any pane of this tab still shows stays protected: `recent` is one flat map for the
|
|
* whole tab, so withdrawing an id a sibling pane is still holding would drop the only record of
|
|
* it when draft saving is off. */
|
|
const heldElsewhere = new Set(Object.values(attachments).flat());
|
|
const recent = { ...presence.recent };
|
|
for (const id of idSet) {
|
|
if (recent[id] == null || heldElsewhere.has(id)) {
|
|
continue;
|
|
}
|
|
/** A chip leaving is not evidence the file is unused: this tab may have sent the same file on
|
|
* an earlier message and only now be removing a later reattachment of it. The `recent` entry
|
|
* is the only cross-tab record of that submitted use once the composer and draft have cleared,
|
|
* so an id a submission already consumed keeps its entry and ages out on the ordinary window
|
|
* instead of being withdrawn here. */
|
|
if (isPasteSubmitted(id)) {
|
|
continue;
|
|
}
|
|
delete recent[id];
|
|
modified = true;
|
|
}
|
|
if (!modified) {
|
|
return;
|
|
}
|
|
/** Withdrawing is a user-visible act, so it proves this tab is running right now. A suspended
|
|
* document is not withdrawing anything. Carrying the old `seenAt` over would let the collection
|
|
* sweep remove this record immediately, including claims from sibling panes still on screen. */
|
|
writeTabPresence(tabId, {
|
|
seenAt: Date.now(),
|
|
...(Object.keys(attachments).length > 0 ? { attachments } : {}),
|
|
...(Object.keys(recent).length > 0 ? { recent } : {}),
|
|
});
|
|
};
|
|
|
|
/** Every attachment id a live tab's composers are currently showing, or held recently enough to
|
|
* still count.
|
|
*
|
|
* `excludeOwnPane` is how a discard asks what everyone *else* is holding. It cannot count its own
|
|
* pane, because that pane's chips are precisely what it is discarding, and it cannot count this
|
|
* tab's `recent` either, since that map is flat and cannot say which pane an id came from. Every
|
|
* other pane of this tab does count: side-by-side composers are as independent as separate tabs
|
|
* here, and excluding the whole tab deleted files out from under a sibling pane's live chip.
|
|
* Pass `'tab'` when the caller speaks for the tab as a whole rather than one pane. */
|
|
export const collectLiveAttachmentIds = ({
|
|
excludeOwnPane,
|
|
}: { excludeOwnPane?: number | 'tab' } = {}): Set<string> => {
|
|
const ids = new Set<string>();
|
|
const now = Date.now();
|
|
const ownTabId = excludeOwnPane === undefined ? '' : getBrowserTabId();
|
|
for (const [tabId, presence] of readLiveTabs()) {
|
|
const isOwnTab = ownTabId !== '' && tabId === ownTabId;
|
|
if (isOwnTab && excludeOwnPane === 'tab') {
|
|
continue;
|
|
}
|
|
for (const [pane, paneIds] of Object.entries(presence.attachments ?? {})) {
|
|
if (isOwnTab && pane === `${excludeOwnPane}`) {
|
|
continue;
|
|
}
|
|
for (const id of paneIds) {
|
|
ids.add(id);
|
|
}
|
|
}
|
|
if (isOwnTab) {
|
|
continue;
|
|
}
|
|
for (const [id, seenAt] of Object.entries(presence.recent ?? {})) {
|
|
if (now - seenAt <= RECENT_ATTACHMENT_WINDOW_MS) {
|
|
ids.add(id);
|
|
}
|
|
}
|
|
}
|
|
return ids;
|
|
};
|
|
|
|
let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
|
|
let heartbeatTabId: string | null = null;
|
|
|
|
const startTabHeartbeat = (tabId: string): void => {
|
|
if (heartbeatTabId === tabId || typeof window === 'undefined') {
|
|
return;
|
|
}
|
|
heartbeatTabId = tabId;
|
|
recordTabPresence(tabId);
|
|
if (heartbeatTimer != null) {
|
|
return;
|
|
}
|
|
const beat = (): void => {
|
|
if (heartbeatTabId != null) {
|
|
recordTabPresence(heartbeatTabId);
|
|
}
|
|
};
|
|
heartbeatTimer = setInterval(beat, TAB_HEARTBEAT_MS);
|
|
/** `pagehide` cannot tell a close from a reload, and the id deliberately survives a reload, so
|
|
* releasing the claim here would hand this tab's own draft to another one while the document
|
|
* was still bootstrapping. A closed tab is left to the ordinary window instead, which is what
|
|
* the window is for. `persisted` is the one case worth marking: the document is going into the
|
|
* back-forward cache with a frozen heartbeat, so it is parked for the longer grace and beats
|
|
* normally again on `pageshow`. */
|
|
window.addEventListener('pagehide', (event) => {
|
|
if (heartbeatTabId != null && event.persisted) {
|
|
recordTabPresence(heartbeatTabId, true);
|
|
}
|
|
});
|
|
window.addEventListener('pageshow', beat);
|
|
};
|
|
|
|
export const getBrowserTabId = (): string => {
|
|
const tabId = resolveBrowserTabId();
|
|
if (tabId !== '') {
|
|
startTabHeartbeat(tabId);
|
|
}
|
|
return tabId;
|
|
};
|
|
|
|
/** Whether the tab a claim names is still around to act on it. A closed tab's `sessionStorage`
|
|
* goes with it, so its id can never be presented again: without a liveness view its drafts would
|
|
* stay stamped to an owner that no longer exists, and no tab could restore, update, or clean them
|
|
* up again. */
|
|
export const isTabLive = (tabId?: string | null): boolean => {
|
|
if (tabId == null || tabId === '') {
|
|
return false;
|
|
}
|
|
if (tabId === documentTabId) {
|
|
return true;
|
|
}
|
|
const presence = readTabPresence(tabId);
|
|
return presence != null && isPresenceLive(presence, Date.now());
|
|
};
|
|
|
|
/** Destructive readers skip a record another tab still owns. Untagged legacy drafts are treated
|
|
* as owned so pre-stamp recovery still deletes and clears, and so is a record whose owning tab
|
|
* has since gone away, which is the only way its draft becomes reachable again. */
|
|
export const isFilesDraftOwnedByThisTab = (draft: FilesDraft): boolean =>
|
|
draft.tabId == null || draft.tabId === getBrowserTabId() || !isTabLive(draft.tabId);
|
|
|
|
let filesDraftCache: { id: string; raw: string | null; draft: FilesDraft } | null = null;
|
|
|
|
/** Reads a files draft without re-parsing storage when the record has not changed. Paste text can
|
|
* dominate the draft's size, and consumers re-read per file-map change, not per write. */
|
|
export const getFilesDraftCached = (id: string): FilesDraft => {
|
|
const raw = getLocalStorageItem(`${LocalStorageKeys.FILES_DRAFT}${id}`);
|
|
if (filesDraftCache != null && filesDraftCache.id === id && filesDraftCache.raw === raw) {
|
|
return filesDraftCache.draft;
|
|
}
|
|
const draft = getFilesDraft(id);
|
|
filesDraftCache = { id, raw, draft };
|
|
return draft;
|
|
};
|
|
|
|
/** Adds a paste-generated file id to a draft's persistent provenance record. */
|
|
export const addPastedTextDraftFile = ({ id, fileId }: { id: string; fileId: string }): void => {
|
|
const draft = getFilesDraft(id);
|
|
if (draft.pastedTextIds?.includes(fileId) === true) {
|
|
return;
|
|
}
|
|
setFilesDraft(id, {
|
|
...draft,
|
|
pastedTextIds: [...(draft.pastedTextIds ?? []), fileId],
|
|
});
|
|
};
|
|
|
|
export const setFilesDraft = (id: string, draft: FilesDraft): void => {
|
|
const key = `${LocalStorageKeys.FILES_DRAFT}${id}`;
|
|
const pendingPasteEntries = Object.entries(draft.pendingPastes);
|
|
const previewIds = new Set([...draft.fileIds, ...(draft.pastedTextIds ?? [])]);
|
|
const textPreviews = Object.fromEntries(
|
|
Object.entries({ ...getFilesDraft(id).textPreviews, ...draft.textPreviews })
|
|
.filter(([fileId, text]) => previewIds.has(fileId) && typeof text === 'string')
|
|
.map(([fileId, text]) => [fileId, text.slice(0, MAX_FILE_TEXT_PREVIEW_LENGTH)]),
|
|
);
|
|
const previewFields = Object.keys(textPreviews).length > 0 ? { textPreviews } : {};
|
|
|
|
/** Stamp only the first writer, and only for as long as that writer is still open. A later
|
|
* restore or autosave from another live tab must not steal ownership: that stamp is what keeps
|
|
* Edit / Move back / New Chat from deleting a file the original tab still has attached. Once
|
|
* the owner is gone the claim is worth nothing, so the tab writing now takes it over rather
|
|
* than leaving the record stranded under an id that can never come back. */
|
|
const claimed = draft.tabId ?? getFilesDraft(id).tabId;
|
|
const tabId = (claimed != null && isTabLive(claimed) ? claimed : getBrowserTabId()) || undefined;
|
|
filesDraftCache = null;
|
|
if (
|
|
draft.fileIds.length === 0 &&
|
|
pendingPasteEntries.length === 0 &&
|
|
(draft.pastedTextIds?.length ?? 0) === 0
|
|
) {
|
|
/** Nothing attached, but on a shared key this record is also the only thing saying whose text
|
|
* is stored there, and dropping it leaves that text unowned for another tab to clear.
|
|
* `useAutoSave` rewrites the draft with an empty file map on every reset and every composer
|
|
* mount, so a claim that did not survive this branch barely survived at all. The text itself
|
|
* is the condition, exactly as in `releaseComposerDraftTab`: with none, the claim is residue
|
|
* and the record still goes. */
|
|
const holdsText = (getLocalStorageItem(`${LocalStorageKeys.TEXT_DRAFT}${id}`) ?? '') !== '';
|
|
if (tabId != null && holdsText && isSharedComposerDraftId(id)) {
|
|
setLocalStorageItem(key, JSON.stringify({ fileIds: [], tabId }));
|
|
return;
|
|
}
|
|
removeLocalStorageItem(key);
|
|
return;
|
|
}
|
|
|
|
if (pendingPasteEntries.length === 0) {
|
|
/** Keep the bare array shape when there is nothing to add, so older readers are unaffected. */
|
|
const bareFileIds =
|
|
!draft.pastedTextIds?.length && !tabId && Object.keys(textPreviews).length === 0;
|
|
setLocalStorageItem(
|
|
key,
|
|
JSON.stringify(
|
|
bareFileIds
|
|
? draft.fileIds
|
|
: {
|
|
fileIds: draft.fileIds,
|
|
...previewFields,
|
|
...(draft.pastedTextIds?.length ? { pastedTextIds: draft.pastedTextIds } : {}),
|
|
...(tabId ? { tabId } : {}),
|
|
},
|
|
),
|
|
);
|
|
return;
|
|
}
|
|
|
|
const pendingPastes = Object.fromEntries(
|
|
pendingPasteEntries.map(
|
|
([fileId, pendingPaste]): [string, StoredPendingTextAttachmentDraft] => [
|
|
fileId,
|
|
{
|
|
encodedText: encodeBase64(pendingPaste.text),
|
|
selectionStart: pendingPaste.selectionStart,
|
|
...(pendingPaste.selectionEnd != null &&
|
|
pendingPaste.selectionEnd !== pendingPaste.selectionStart
|
|
? { selectionEnd: pendingPaste.selectionEnd }
|
|
: {}),
|
|
...(pendingPaste.replacedText
|
|
? { encodedReplacedText: encodeBase64(pendingPaste.replacedText) }
|
|
: {}),
|
|
...(pendingPaste.sequence != null ? { sequence: pendingPaste.sequence } : {}),
|
|
...(pendingPaste.replacedApplied ? { replacedApplied: true } : {}),
|
|
...(pendingPaste.anchorBefore != null
|
|
? { encodedAnchorBefore: encodeBase64(pendingPaste.anchorBefore) }
|
|
: {}),
|
|
...(pendingPaste.anchorAfter != null
|
|
? { encodedAnchorAfter: encodeBase64(pendingPaste.anchorAfter) }
|
|
: {}),
|
|
},
|
|
],
|
|
),
|
|
);
|
|
|
|
setLocalStorageItem(
|
|
key,
|
|
JSON.stringify({
|
|
fileIds: draft.fileIds,
|
|
pendingPastes,
|
|
...previewFields,
|
|
...(draft.pastedTextIds?.length ? { pastedTextIds: draft.pastedTextIds } : {}),
|
|
...(tabId ? { tabId } : {}),
|
|
} satisfies StoredFilesDraft),
|
|
);
|
|
};
|
|
|
|
/** Every attachment id any persisted composer draft is holding, across every key and therefore
|
|
* every tab: `localStorage` is shared, so a draft another tab wrote for a conversation this one
|
|
* has never opened is still readable here. Cleanup that only consulted this pane's own keys would
|
|
* delete a file a second tab had reattached somewhere else.
|
|
*
|
|
* `excludeIds` leaves out the keys the caller is itself discarding. Those drafts are the reason
|
|
* the deletion exists, so counting them as protection would cancel every discard; every other
|
|
* key, including this tab's own conversation drafts, still counts. */
|
|
export const collectDraftedAttachmentIds = (excludeIds: string[] = []): Set<string> => {
|
|
const ids = new Set<string>();
|
|
const excluded = new Set(excludeIds);
|
|
try {
|
|
for (let i = 0; i < localStorage.length; i++) {
|
|
const key = localStorage.key(i);
|
|
if (key == null || !key.startsWith(LocalStorageKeys.FILES_DRAFT)) {
|
|
continue;
|
|
}
|
|
const draftId = key.slice(LocalStorageKeys.FILES_DRAFT.length);
|
|
if (excluded.has(draftId)) {
|
|
continue;
|
|
}
|
|
const draft = getFilesDraft(draftId);
|
|
for (const fileId of draft.fileIds) {
|
|
ids.add(fileId);
|
|
}
|
|
for (const pasteId of draft.pastedTextIds ?? []) {
|
|
ids.add(pasteId);
|
|
}
|
|
for (const pendingId of Object.keys(draft.pendingPastes)) {
|
|
ids.add(pendingId);
|
|
}
|
|
}
|
|
} catch {
|
|
// An unreadable store just means no drafted ids to protect beyond the caller's own.
|
|
}
|
|
return ids;
|
|
};
|
|
|
|
/** Every attachment id something other than the caller still claims: any persisted draft outside
|
|
* the keys it is acting on, plus what every other live tab publishes. Every path that deletes an
|
|
* upload has to consult this first, because a second tab or pane can have reattached the same
|
|
* library file, or sent it, and its claim is the only thing standing between that file and the
|
|
* request. One helper rather than a union rebuilt at each deletion site: the guard was missed at
|
|
* three of them precisely because each site assembled it by hand. */
|
|
export const collectForeignAttachmentClaims = (
|
|
excludeDraftIds: string[] = [],
|
|
excludeOwnPane: number | 'tab' = 'tab',
|
|
): Set<string> => {
|
|
const ids = collectDraftedAttachmentIds(excludeDraftIds);
|
|
for (const liveId of collectLiveAttachmentIds({ excludeOwnPane })) {
|
|
ids.add(liveId);
|
|
}
|
|
return ids;
|
|
};
|
|
|
|
const hasDraftAttachments = (draft: FilesDraft): boolean =>
|
|
draft.fileIds.length > 0 ||
|
|
Object.keys(draft.pendingPastes).length > 0 ||
|
|
(draft.pastedTextIds?.length ?? 0) > 0;
|
|
|
|
/** A record another open tab is holding against files it still has on screen. Writing over its
|
|
* text, or clearing it, would destroy a draft this tab could never have restored anyway. */
|
|
const isForeignAttachmentClaim = (draft: FilesDraft, tabId: string): boolean =>
|
|
draft.tabId != null &&
|
|
draft.tabId !== tabId &&
|
|
hasDraftAttachments(draft) &&
|
|
isTabLive(draft.tabId);
|
|
|
|
/** Whether this tab may write the text record behind a draft key. Conversation keys are reachable
|
|
* from every tab viewing that chat and are stamped just like the shared composer ones, so the
|
|
* guard is not limited to those. Only an attachment-backed claim refuses a write: last writer wins
|
|
* for text is deliberate, or the tab that typed last could not restore what it typed. */
|
|
export const mayWriteComposerText = (id: string): boolean => {
|
|
const tabId = getBrowserTabId();
|
|
return tabId === '' || !isForeignAttachmentClaim(getFilesDraftCached(id), tabId);
|
|
};
|
|
|
|
/** Any live tab other than this one has the key stamped, whether or not anything is attached. */
|
|
const isForeignLiveClaim = (draft: FilesDraft, tabId: string): boolean =>
|
|
draft.tabId != null && draft.tabId !== tabId && isTabLive(draft.tabId);
|
|
|
|
/** Whether this tab may destroy what is behind a draft key. Stricter than the write guard on
|
|
* purpose: `claimComposerDraftTab` stamps a key that holds nothing but text, and overwriting that
|
|
* text is a normal race between panes, but deleting another live tab's record is not. Tab A
|
|
* finishing a run that began as an unsaved chat would otherwise clear the shared new-chat key and
|
|
* take tab B's half-written message with it, with no attachment anywhere to refuse it. */
|
|
export const mayClearComposerDrafts = (id: string): boolean => {
|
|
const tabId = getBrowserTabId();
|
|
return tabId === '' || !isForeignLiveClaim(getFilesDraftCached(id), tabId);
|
|
};
|
|
|
|
/** Records which tab a shared composer key belongs to when text is all it holds. The files draft
|
|
* doubles as the ownership record, but it is only written once there is an attachment, so a typed
|
|
* but unattached draft read as unowned and another tab's New Chat cleared it. */
|
|
export const claimComposerDraftTab = (id: string): boolean => {
|
|
/** Reached from every debounced keystroke, so it reads through the cache rather than
|
|
* re-parsing the record each time. */
|
|
const existing = getFilesDraftCached(id);
|
|
const tabId = getBrowserTabId();
|
|
/** Already ours, or storage cannot attribute a tab at all: there is nothing to claim and the
|
|
* write goes ahead. This has to come first, or the owner of an attachment-backed draft would
|
|
* be refused its own key and stop saving what it types. */
|
|
if (existing.tabId === tabId || tabId === '') {
|
|
return true;
|
|
}
|
|
/** A claim with nothing behind it speaks only for text, and the caller is about to overwrite
|
|
* that text on a key every tab writes to: the stamp follows whoever's text is actually stored,
|
|
* or the tab that typed last could not restore what it typed. A claim backed by an attachment
|
|
* stays with its owner while that tab is open, because taking it would let this tab delete
|
|
* files the other one still has on screen. */
|
|
if (isForeignAttachmentClaim(existing, tabId)) {
|
|
return false;
|
|
}
|
|
if (hasDraftAttachments(existing)) {
|
|
setFilesDraft(id, { ...existing, tabId });
|
|
return true;
|
|
}
|
|
/** Nothing but the claim to store. `setFilesDraft` drops an empty record rather than leaving
|
|
* a stub behind, which is right for attachments and wrong for this. */
|
|
filesDraftCache = null;
|
|
setLocalStorageItem(
|
|
`${LocalStorageKeys.FILES_DRAFT}${id}`,
|
|
JSON.stringify({ fileIds: [], tabId }),
|
|
);
|
|
return true;
|
|
};
|
|
|
|
/** Drops a claim with nothing behind it. Once the text is cleared and nothing is attached, the
|
|
* record is pure residue, and leaving it would lock the shared key to a tab that no longer has a
|
|
* draft there: the next tab to type could neither restore its own text nor take the key back. */
|
|
export const releaseComposerDraftTab = (id: string): void => {
|
|
const existing = getFilesDraftCached(id);
|
|
if (
|
|
existing.tabId == null ||
|
|
existing.tabId !== getBrowserTabId() ||
|
|
hasDraftAttachments(existing)
|
|
) {
|
|
return;
|
|
}
|
|
filesDraftCache = null;
|
|
removeLocalStorageItem(`${LocalStorageKeys.FILES_DRAFT}${id}`);
|
|
};
|
|
|
|
/** Moves a text draft between keys, reporting whether there was one to move. */
|
|
export const migrateTextDraft = (fromId: string, toId: string): boolean => {
|
|
const key = `${LocalStorageKeys.TEXT_DRAFT}${fromId}`;
|
|
const draftText = getLocalStorageItem(key);
|
|
removeLocalStorageItem(key);
|
|
if (!draftText) {
|
|
return false;
|
|
}
|
|
|
|
setLocalStorageItem(`${LocalStorageKeys.TEXT_DRAFT}${toId}`, draftText);
|
|
return true;
|
|
};
|
|
|
|
/**
|
|
* Moves a files draft between keys without ever holding two copies: a pending long paste can be
|
|
* most of the storage budget on its own, so writing the destination while the source still exists
|
|
* is what trips quota. Returns the id the record ended up under, so a caller that failed to move
|
|
* it can still recover from the key that kept it.
|
|
*/
|
|
export const migrateFilesDraft = (fromId: string, toId: string): string => {
|
|
const key = `${LocalStorageKeys.FILES_DRAFT}${fromId}`;
|
|
const record = getLocalStorageItem(key);
|
|
if (!record) {
|
|
return toId;
|
|
}
|
|
|
|
removeLocalStorageItem(key);
|
|
try {
|
|
const destinationKey = `${LocalStorageKeys.FILES_DRAFT}${toId}`;
|
|
const changed = getLocalStorageItem(destinationKey) !== record;
|
|
localStorage.setItem(destinationKey, record);
|
|
if (isFilesDraftOwnedByThisTab(getFilesDraft(toId))) {
|
|
composerDraftMigrations.forEach((listener) => listener(fromId, toId));
|
|
}
|
|
if (changed) notifyOwnershipChange(destinationKey);
|
|
return toId;
|
|
} catch {
|
|
/** Storage cannot hold the record even with the source freed, so put it back rather than
|
|
* dropping attachments that recovery can still read from the key it came from. */
|
|
setLocalStorageItem(key, record);
|
|
return fromId;
|
|
}
|
|
};
|
|
|
|
export const setPendingTextAttachmentDraft = ({
|
|
id,
|
|
fileId,
|
|
text,
|
|
selectionStart,
|
|
selectionEnd,
|
|
replacedText,
|
|
replacedApplied,
|
|
anchorBefore,
|
|
anchorAfter,
|
|
}: {
|
|
id: string;
|
|
fileId: string;
|
|
text: string;
|
|
selectionStart: number;
|
|
selectionEnd?: number;
|
|
replacedText?: string;
|
|
replacedApplied?: boolean;
|
|
anchorBefore?: string;
|
|
anchorAfter?: string;
|
|
}): void => {
|
|
const draft = getFilesDraft(id);
|
|
const existing = draft.pendingPastes[fileId];
|
|
const sequence =
|
|
existing?.sequence ??
|
|
Math.max(0, ...Object.values(draft.pendingPastes).map((paste) => paste.sequence ?? 0)) + 1;
|
|
setFilesDraft(id, {
|
|
fileIds: draft.fileIds.includes(fileId) ? draft.fileIds : [...draft.fileIds, fileId],
|
|
pastedTextIds: draft.pastedTextIds,
|
|
pendingPastes: {
|
|
...draft.pendingPastes,
|
|
[fileId]: {
|
|
text,
|
|
selectionStart,
|
|
sequence,
|
|
...(selectionEnd != null ? { selectionEnd } : {}),
|
|
...(replacedText ? { replacedText } : {}),
|
|
...(replacedApplied ? { replacedApplied: true } : {}),
|
|
...(anchorBefore != null ? { anchorBefore } : {}),
|
|
...(anchorAfter != null ? { anchorAfter } : {}),
|
|
},
|
|
},
|
|
});
|
|
};
|
|
|
|
export const removePendingTextAttachmentDraft = ({
|
|
id,
|
|
fileId,
|
|
removeFile = false,
|
|
}: {
|
|
id: string;
|
|
fileId: string;
|
|
removeFile?: boolean;
|
|
}): void => {
|
|
const draft = getFilesDraft(id);
|
|
const pendingPastes = { ...draft.pendingPastes };
|
|
delete pendingPastes[fileId];
|
|
/** `removeFile` means the upload never landed or is gone, so its provenance goes with it.
|
|
* Leaving the id in `pastedTextIds` was enough for `hasDraftAttachments` to read the record as a
|
|
* real attachment claim, and since the file map never changed there was no later render to prune
|
|
* it: the stub then locked every other tab out of the shared composer key with no chip behind
|
|
* it. */
|
|
setFilesDraft(id, {
|
|
fileIds: removeFile
|
|
? draft.fileIds.filter((draftFileId) => draftFileId !== fileId)
|
|
: draft.fileIds,
|
|
pastedTextIds: removeFile
|
|
? draft.pastedTextIds?.filter((pasteId) => pasteId !== fileId)
|
|
: draft.pastedTextIds,
|
|
pendingPastes,
|
|
});
|
|
};
|
|
|
|
export const setDraft = ({ id, value }: { id: string; value?: string }) => {
|
|
const shouldPersist = value != null && value.length > 0;
|
|
if (shouldPersist) {
|
|
/** A refused key belongs to another open tab holding it against attachments it still has.
|
|
* This tab could not restore what it wrote there anyway, so the write would only destroy that
|
|
* tab's text for nothing. */
|
|
if (!mayWriteComposerText(id)) {
|
|
return;
|
|
}
|
|
/** Claim before writing, but only where ownership would not otherwise exist: the shared text
|
|
* record has no per-tab copy, so once the write lands this tab's text is the only text there
|
|
* is and the stamp has to agree. A conversation key is left unstamped unless something is
|
|
* actually attached to it, since tabs are meant to share those. */
|
|
if (isSharedComposerDraftId(id)) {
|
|
claimComposerDraftTab(id);
|
|
}
|
|
setLocalStorageItem(`${LocalStorageKeys.TEXT_DRAFT}${id}`, encodeBase64(value ?? ''));
|
|
return;
|
|
}
|
|
/** Stricter than the write path: an empty composer in this tab must not erase text another open
|
|
* tab is still holding, and a tab that has only typed still holds it. */
|
|
if (!mayClearComposerDrafts(id)) {
|
|
return;
|
|
}
|
|
removeLocalStorageItem(`${LocalStorageKeys.TEXT_DRAFT}${id}`);
|
|
if (isSharedComposerDraftId(id)) {
|
|
releaseComposerDraftTab(id);
|
|
}
|
|
};
|
|
|
|
export const getDraft = (id?: string): string | null =>
|
|
decodeBase64((getLocalStorageItem(`${LocalStorageKeys.TEXT_DRAFT}${id ?? ''}`) ?? '') || '');
|
|
|
|
/** Discards a key's attachments while leaving its text where it is. New Chat deletes the uploads
|
|
* the draft was holding, so restoring those chips would put back a file the server no longer has;
|
|
* a typed message has no such resource behind it, and losing it is what made an unsaved chat the
|
|
* one composer whose draft did not survive leaving and coming back.
|
|
*
|
|
* Written as an empty draft rather than a direct delete so the claim rule lives in one place:
|
|
* `setFilesDraft` keeps a shared key's stamp while text is stored under it and drops the record
|
|
* otherwise, which is also what the autosave write that follows this one has to do. */
|
|
export const clearFilesDraft = (id: string): void => {
|
|
if (!mayClearComposerDrafts(id)) {
|
|
return;
|
|
}
|
|
setFilesDraft(id, { fileIds: [], pendingPastes: {} });
|
|
};
|
|
|
|
/**
|
|
* Draft-key prefix for a live `ask_user_question` answer phase. While the
|
|
* composer doubles as the free-form answer box, its autosave switches to a key
|
|
* derived from the pause's action id — so the conversation's own draft is left
|
|
* untouched and comes back once the question resolves, and a half-typed answer
|
|
* survives reloads/navigation for as long as its question stays live.
|
|
*/
|
|
export const ASK_ANSWER_DRAFT_PREFIX = 'ask-answer:';
|
|
|
|
export const getAskAnswerDraftId = (actionId: string): string =>
|
|
`${ASK_ANSWER_DRAFT_PREFIX}${actionId}`;
|
|
|
|
export const isAskAnswerDraftId = (id?: string | null): boolean =>
|
|
typeof id === 'string' && id.startsWith(ASK_ANSWER_DRAFT_PREFIX);
|