Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import * as Predicate from "effect/Predicate";
import * as Schema from "effect/Schema";
import { create } from "zustand";
import { PersistedComposerImageAttachment } from "./composerDraftStore";
import { createMemoryStorage } from "./lib/storage";
export const PROMPT_STASH_STORAGE_KEY = "akeru:prompt-stash:v2";
// The v2 payload lived under the `t3code:` prefix before the rebrand.
const LEGACY_PROMPT_STASH_STORAGE_KEY_V2 = "t3code:prompt-stash:v2";
/**
* v1 bucketed entries into per-provider-instance queues and stored a model
* selection with each prompt. The stash is provider-agnostic now, so the old
* payload is deleted at startup rather than migrated — left behind it would
* silently hold megabytes of the origin's ~5MB localStorage quota forever.
*/
const LEGACY_PROMPT_STASH_STORAGE_KEY = "t3code:prompt-stash:v1";
const PROMPT_STASH_STORAGE_VERSION = 2;
export const MAX_STASH_ENTRIES = 20;
/**
* Budget for an entry's serialized attachment payload. localStorage is a
* ~5MB origin-wide quota shared with the composer draft store, so oversized
* images are dropped (tracked in `droppedImageNames`) rather than persisted.
*
* Sized to hold two images at the per-image compression budget
* (`MAX_STASH_IMAGE_DATA_URL_CHARS`) so a typical before/after screenshot
* pair survives intact.
*/
export const MAX_STASH_ENTRY_ATTACHMENT_CHARS = 2_700_000;
/**
* A stashed prompt carries only what every provider can accept: text and
* image attachments. Deliberately no provider instance or model selection —
* the point of stashing is to move a prompt into a different thread or
* provider, so restoring must never drag the old model choice along.
*/
const StashEntrySchema = Schema.Struct({
id: Schema.String,
createdAt: Schema.String,
prompt: Schema.String,
attachments: Schema.Array(PersistedComposerImageAttachment),
/** Names of images that exceeded the attachment budget and were not saved. */
droppedImageNames: Schema.Array(Schema.String),
/**
* Names of images that could not be decoded or re-encoded at all — a
* distinct failure from exceeding the size budget, so the menu can explain
* which actually happened. Optional: entries written before this field
* existed decode without it.
*/
unreadableImageNames: Schema.optionalKey(Schema.Array(Schema.String)),
/**
* Images still being encoded when the entry was written. The entry is
* persisted before its images so a crash mid-encode cannot lose the prompt;
* this field lets the UI show "N images still saving" until
* `finalizeEntryImages` lands, and flags entries orphaned by a reload.
*/
pendingImageCount: Schema.optionalKey(Schema.Number),
});
export type PromptStashEntry = typeof StashEntrySchema.Type;
const PersistedPromptStashState = Schema.Struct({
entries: Schema.Array(StashEntrySchema),
});
type PersistedPromptStashState = typeof PersistedPromptStashState.Type;
const decodePersistedPromptStashState = Schema.decodeUnknownSync(PersistedPromptStashState);
/**
* `pendingImageCount` only has meaning within the session that wrote it: the
* encode loop that would clear it does not survive a reload. Any entry that
* comes back from storage still pending was orphaned by a closed tab or a
* crash mid-encode, so the count is settled here — otherwise the entry would
* be stuck showing "saving…" and refuse to restore forever.
*
* The images are genuinely gone (they were never written), so they are
* recorded as unreadable to keep the prompt itself restorable.
*/
function clearOrphanedPendingImages(
entries: ReadonlyArray<PromptStashEntry>,
): ReadonlyArray<PromptStashEntry> {
return entries.map((entry) => {
if (!entry.pendingImageCount) return entry;
const lostCount = entry.pendingImageCount;
return {
...entry,
pendingImageCount: 0,
unreadableImageNames: [
...(entry.unreadableImageNames ?? []),
...Array.from(
{ length: lostCount },
(_, index) => `image ${index + 1} (not saved before reload)`,
),
],
};
});
}
/**
* Splits candidate attachments into a persistable set within the entry
* budget plus the names of any that had to be dropped. Attachments are
* admitted in order so the earliest-added images win.
*/
export function partitionStashAttachments(
attachments: ReadonlyArray<PersistedComposerImageAttachment>,
) {
const kept: PersistedComposerImageAttachment[] = [];
const droppedNames: string[] = [];
let usedChars = 0;
for (const attachment of attachments) {
if (usedChars + attachment.dataUrl.length > MAX_STASH_ENTRY_ATTACHMENT_CHARS) {
droppedNames.push(attachment.name);
continue;
}
usedChars += attachment.dataUrl.length;
kept.push(attachment);
}
return { kept, droppedNames };
}
/**
* Reading the `localStorage` property itself can throw `SecurityError` when
* storage is blocked by policy or the page is a sandboxed iframe — so the
* access has to be guarded, not just the get/set calls on it. Otherwise
* importing this module would crash the app at load.
*
* `durable` is false for the in-memory fallback: writes there "succeed" but
* vanish on reload, and callers clear the composer on the strength of a
* successful stash, so they must be told the difference.
*/
function resolveBaseStorage() {
try {
if (typeof localStorage !== "undefined") {
return { storage: localStorage, durable: true };
}
} catch {
// Fall through to the in-memory store.
}
return { storage: createMemoryStorage(), durable: false };
}
const { storage: baseStashStorage, durable: storageIsDurable } = resolveBaseStorage();
/**
* Persists the queue, immediately rather than debounced. Stashing is a
* deliberate, infrequent keystroke — not a per-character autosave — so there
* is nothing to coalesce, and the caller clears the composer on the strength
* of this write landing, which a debounce timer cannot honestly report.
*
* Returns whether the write will survive a reload: false on a quota rejection
* or when only the in-memory fallback is available.
*/
function persistEntries(entries: ReadonlyArray<PromptStashEntry>) {
try {
baseStashStorage.setItem(
PROMPT_STASH_STORAGE_KEY,
JSON.stringify({
version: PROMPT_STASH_STORAGE_VERSION,
state: { entries },
}),
);
return { written: true, durable: storageIsDurable };
} catch (error) {
console.error("[PROMPT-STASH] Could not persist stash (storage quota?).", error);
return { written: false, durable: false };
}
}
/** Reads the persisted queue, settling stale pending counts. */
function readPersistedEntries(): ReadonlyArray<PromptStashEntry> | null {
try {
const raw = baseStashStorage.getItem(PROMPT_STASH_STORAGE_KEY);
if (!Predicate.isString(raw) || raw.length === 0) return null;
const parsed: unknown = JSON.parse(raw);
const state = Predicate.hasProperty(parsed, "state") ? parsed.state : null;
if (!state) return null;
return clearOrphanedPendingImages(decodePersistedPromptStashState(state).entries);
} catch {
return null;
}
}
interface PromptStashStoreState {
entries: ReadonlyArray<PromptStashEntry>;
/**
* Prepends an entry to the queue, evicting the oldest entry past the cap.
* Returns the evicted entry (for messaging) if any.
*/
stashEntry: (entry: PromptStashEntry) => {
evicted: PromptStashEntry | null;
/** False when the write failed outright (e.g. quota); nothing was kept. */
written: boolean;
/**
* False when the write will not survive a reload: either it failed, or it
* landed only in the in-memory fallback because localStorage is blocked.
*/
durable: boolean;
};
/**
* Removes and returns an entry from the queue (restore + delete).
* `durable` is false when the removal could not be persisted, meaning a
* reload would resurrect the entry.
*/
takeEntry: (entryId: string) => { entry: PromptStashEntry | null; durable: boolean };
/**
* Attaches the encoded images to an entry written earlier by `stashEntry`,
* clearing its pending count. Returns attached=false when the entry is gone
* (restored or deleted while encoding was still running) so the caller can
* tell the user their images did not make it.
*/
finalizeEntryImages: (
entryId: string,
images: {
attachments: ReadonlyArray<PersistedComposerImageAttachment>;
droppedImageNames: ReadonlyArray<string>;
unreadableImageNames: ReadonlyArray<string>;
},
) => { attached: boolean; durable: boolean };
}
export const usePromptStashStore = create<PromptStashStoreState>()((set, get) => ({
entries: [],
stashEntry: (entry) => {
const nextEntries = [entry, ...get().entries];
const evicted = nextEntries.length > MAX_STASH_ENTRIES ? (nextEntries.pop() ?? null) : null;
const { written, durable } = persistEntries(nextEntries);
// A rejected write must not leave the entry visible either: the caller
// keeps the composer intact on failure, so a stashed copy would
// duplicate the prompt. Eviction likewise only sticks on success.
if (!written) {
return { evicted: null, written: false, durable: false };
}
set(() => ({ entries: nextEntries }));
return { evicted, written: true, durable };
},
takeEntry: (entryId) => {
const entries = get().entries;
const entry = entries.find((candidate) => candidate.id === entryId) ?? null;
if (!entry) return { entry: null, durable: true };
const nextEntries = entries.filter((candidate) => candidate.id !== entryId);
const { durable } = persistEntries(nextEntries);
set(() => ({ entries: nextEntries }));
return { entry, durable };
},
finalizeEntryImages: (entryId, images) => {
const entries = get().entries;
const index = entries.findIndex((candidate) => candidate.id === entryId);
const existing = index === -1 ? undefined : entries[index];
// Restored or deleted mid-encode: nothing to attach to.
if (!existing) return { attached: false, durable: true };
const nextEntries = [...entries];
nextEntries[index] = {
...existing,
attachments: images.attachments,
droppedImageNames: images.droppedImageNames,
unreadableImageNames: images.unreadableImageNames,
pendingImageCount: 0,
};
const { durable } = persistEntries(nextEntries);
set(() => ({ entries: nextEntries }));
return { attached: true, durable };
},
}));
// Hydrate once at startup. Like the app's other persisted stores, tabs are
// last-write-wins: no cross-tab merging or storage-event syncing.
{
try {
baseStashStorage.removeItem(LEGACY_PROMPT_STASH_STORAGE_KEY);
// Read-through migration for the pre-rebrand v2 payload.
if (baseStashStorage.getItem(PROMPT_STASH_STORAGE_KEY) == null) {
const legacyRaw = baseStashStorage.getItem(LEGACY_PROMPT_STASH_STORAGE_KEY_V2);
if (Predicate.isString(legacyRaw)) {
baseStashStorage.setItem(PROMPT_STASH_STORAGE_KEY, legacyRaw);
}
}
baseStashStorage.removeItem(LEGACY_PROMPT_STASH_STORAGE_KEY_V2);
} catch {
// Purging the v1 payload is best-effort; a storage policy that rejects
// the delete must not take down module init.
}
const persisted = readPersistedEntries();
if (persisted) {
usePromptStashStore.setState({ entries: persisted });
}
}
/**
* Test seam: seeds the persisted payload through the same storage the store
* reads and rehydrates, without needing a real `localStorage` global.
* Pass an empty string to clear.
*/
export function writePromptStashStorageForTest(raw: string): void {
baseStashStorage.setItem(PROMPT_STASH_STORAGE_KEY, raw);
usePromptStashStore.setState({ entries: readPersistedEntries() ?? [] });
}