A one-of-a-kind resume builder that keeps your privacy in mind. Completely secure, customizable, portable, open-source and free forever. Try it out today!
TypeScript agent-skillsaidsh-pluginhacktoberfestjavascriptmcp-serverreactresume-builderself-hostedtypescript
// AI draft of the letter body, streamed over SSE. Ported from startLetterDraft in apps/web/src/features/letters/store.ts.
import type { CoverLetterDraftVersion } from "@reactive-resume/schema/cover-letter/data";
import { ORPCError } from "@orpc/client";
import Storage from "expo-sqlite/kv-store";
import { create } from "zustand";
import { coverLetterDraftVersionSchema } from "@reactive-resume/schema/cover-letter/data";
import { draftForOwner, letterDraftOwnerKey } from "./draft-owner";
import { saveLetter } from "./save";
import { streamClient } from "@/api/client";
import { getAccountScope, getServer } from "@/auth/session";
import { useLetterStore } from "@/draft";
export type DraftVariant = "draft" | "shorter" | "personal";
/**
* A draft kept apart from the letter: streaming, ready to keep, or failed. The body changes only when a draft is
* kept, so a failed or discarded draft leaves the letter as it was. `last` is what Try again repeats.
*/
export type LetterDraft =
| { phase: "idle" }
/** `versions` are the earlier finished drafts, oldest first; `stopped` marks text Stop cut short. */
| {
phase: "streaming" | "ready";
text: string;
aiOperationIds: string[];
revision: number;
operation: string;
versions: CoverLetterDraftVersion[];
stopped?: true;
}
| { phase: "failed"; provider: string | null; error: unknown; versions: CoverLetterDraftVersion[] }
/** What's typed couldn't be saved (offline, error, conflict), so the server would draft from stale links. */
| { phase: "unsaved" };
type LastDraft = {
variant: DraftVariant;
previous?: string | undefined;
previousAiOperationIds?: string[] | undefined;
};
type DraftingState = {
/** The account, server and letter that own this draft. A different letter/account sees idle, never this text. */
owner: string | null;
draft: LetterDraft;
last: LastDraft;
};
const idle: LetterDraft = { phase: "idle" };
/** The most drafts kept side by side: the current one and up to four before it. */
const MAX_DRAFT_VERSIONS = 5;
const asVersions = (value: unknown, sources: unknown) =>
Array.isArray(value)
? value
.flatMap((version, index) => {
const parsed = coverLetterDraftVersionSchema.safeParse(
typeof version === "string"
? { text: version, aiOperationIds: Array.isArray(sources) ? sources[index] : undefined }
: version,
);
return parsed.success ? [parsed.data] : [];
})
.slice(-(MAX_DRAFT_VERSIONS - 1))
: [];
const defaultLast: LastDraft = { variant: "draft" };
/** Storage and in-memory identity are scoped by server, account and letter so drafts cannot cross either boundary. */
export const letterDraftOwner = (id: string) => letterDraftOwnerKey(getServer(), getAccountScope(), id);
/** The draft a screen may render: only when the store belongs to this exact server/account/letter. */
export { draftForOwner };
export const useLetterDrafting = create<DraftingState>()(() => ({ owner: null, draft: idle, last: defaultLast }));
/** The visible draft for one letter; another letter's ready/streaming draft is never returned. */
export function useLetterDraftFor(id: string) {
const owner = letterDraftOwner(id);
return useLetterDrafting((state) => draftForOwner(state, owner, idle));
}
/** What Try again repeats, scoped to the same letter as the visible draft. */
export function useLetterDraftLastFor(id: string) {
const owner = letterDraftOwner(id);
return useLetterDrafting((state) => (state.owner === owner ? state.last : defaultLast));
}
let drafting: AbortController | null = null;
/** Invalidates an in-flight restore when the letter changes, is discarded, or a new draft starts. */
let restoreVersion = 0;
let operationSequence = 0;
const nextOperation = () => `draft-${++operationSequence}`;
/** An unkept draft survives leaving and reopening the editor, so seeing it again costs no second request. */
export async function restoreLetterDraft(id: string) {
const current = useLetterStore.getState().document;
if (!current || current.id !== id) return;
const owner = letterDraftOwner(id);
const revision = current.revision;
const state = useLetterDrafting.getState();
if (state.owner !== owner || (state.draft.phase === "ready" && state.draft.revision !== revision))
useLetterDrafting.setState({ owner, draft: idle, last: defaultLast });
if (useLetterDrafting.getState().draft.phase !== "idle") return;
const request = ++restoreVersion;
try {
const raw = await Storage.getItem(owner);
const value = raw
? (JSON.parse(raw) as {
text?: unknown;
aiOperationIds?: unknown;
variant?: unknown;
revision?: unknown;
versions?: unknown;
versionAiOperationIds?: unknown;
stopped?: unknown;
})
: null;
if (typeof value?.text !== "string" || !value.text.trim()) return;
// A newer restore/discard/leave, another letter, or a changed revision invalidates this read.
const latest = useLetterStore.getState().document;
if (
request !== restoreVersion ||
letterDraftOwner(id) !== owner ||
latest?.id !== id ||
latest.revision !== revision ||
useLetterDrafting.getState().owner !== owner ||
value.revision !== revision
)
return;
const variant =
value.variant === "shorter" || value.variant === "personal" || value.variant === "draft"
? value.variant
: "draft";
useLetterDrafting.setState((currentState) =>
currentState.owner === owner
? {
draft: {
phase: "ready",
text: value.text as string,
aiOperationIds: coverLetterDraftVersionSchema.parse({
text: value.text,
aiOperationIds: value.aiOperationIds,
}).aiOperationIds,
revision,
operation: nextOperation(),
versions: asVersions(value.versions, value.versionAiOperationIds),
...(value.stopped === true ? { stopped: true as const } : {}),
},
last: { variant },
}
: currentState,
);
} catch {
// Unreadable storage leaves the letter as it was; drafting can still start fresh.
}
}
type StoredDraft = {
text: string;
aiOperationIds: string[];
variant: DraftVariant;
revision: number;
versions: CoverLetterDraftVersion[];
stopped?: true;
};
async function storeDraft(owner: string, draft: StoredDraft) {
try {
// Keep text-only versions readable by older app bundles.
await Storage.setItem(
owner,
JSON.stringify({
...draft,
versions: draft.versions.map((version) => version.text),
versionAiOperationIds: draft.versions.map((version) => version.aiOperationIds),
}),
);
} catch {
// Storage full or unavailable: the draft stays in this view.
}
}
async function clearDraft(owner: string) {
try {
await Storage.removeItem(owner);
} catch {
// Nothing to clear.
}
}
/** Streams a draft (or a Shorter / More personal revision of `previous`) into `useLetterDrafting`. */
export async function startLetterDraft(
variant: DraftVariant = "draft",
previous?: string,
previousAiOperationIds: string[] = [],
) {
const letter = useLetterStore.getState().document;
if (!letter) return;
const owner = letterDraftOwner(letter.id);
const operation = nextOperation();
const started = ++restoreVersion;
drafting?.abort();
const controller = new AbortController();
drafting = controller;
let revision = letter.revision;
// A revision keeps what came before it; the oldest drops off past the limit.
const before = useLetterDrafting.getState();
const prior = before.owner === owner ? before.draft : idle;
const versions = (
prior.phase === "ready"
? [...prior.versions, { text: prior.text, aiOperationIds: prior.aiOperationIds }]
: prior.phase === "streaming" || prior.phase === "failed"
? prior.versions
: []
).slice(-(MAX_DRAFT_VERSIONS - 1));
const set = (draft: LetterDraft) => {
if (drafting !== controller || letterDraftOwner(letter.id) !== owner) return;
useLetterDrafting.setState((state) => (state.owner === owner ? { draft } : state));
};
useLetterDrafting.setState({ owner, last: { variant, previous, previousAiOperationIds } });
void clearDraft(owner);
let aiOperationIds = variant === "draft" ? [] : previousAiOperationIds;
set({ phase: "streaming", text: "", aiOperationIds, revision, operation, versions });
try {
// The server drafts from the saved letter's links, so links chosen a moment ago must reach it first.
const saved = await saveLetter(letter.id);
if (controller.signal.aborted) return;
const savedLetter = useLetterStore.getState().document;
if (
!savedLetter ||
savedLetter.id !== letter.id ||
started !== restoreVersion ||
letterDraftOwner(letter.id) !== owner
)
return set(idle);
if (!saved) return set({ phase: "unsaved" });
revision = savedLetter.revision;
const stream = await streamClient.coverLetters.draft(
{ id: letter.id, variant, includeProvenance: true, ...(previous ? { previous } : {}) },
{ signal: controller.signal },
);
let text = "";
for await (const chunk of stream) {
if (typeof chunk !== "string") {
aiOperationIds = [...new Set([...aiOperationIds, chunk.aiOperationId])];
} else text += chunk;
set({ phase: "streaming", text, aiOperationIds, revision, operation, versions });
}
if (!text.trim()) throw new Error("The draft came back empty.");
set({ phase: "ready", text: text.trim(), aiOperationIds, revision, operation, versions });
// A late completion after leave/account/letter change may not persist into the new owner's namespace.
if (
drafting === controller &&
letterDraftOwner(letter.id) === owner &&
started === restoreVersion &&
useLetterDrafting.getState().owner === owner &&
useLetterStore.getState().document?.id === letter.id
)
void storeDraft(owner, { text: text.trim(), aiOperationIds, variant, revision, versions });
} catch (error) {
if (controller.signal.aborted) return;
const data = error instanceof ORPCError ? (error.data as { provider?: unknown } | undefined) : undefined;
set({ phase: "failed", provider: typeof data?.provider === "string" ? data.provider : null, error, versions });
}
}
/** What's left when a run stops or its failure is dismissed: its text when any arrived, else the draft before it. */
function settle(
owner: string,
text: string,
versions: CoverLetterDraftVersion[],
revision: number,
stopped: boolean,
aiOperationIds: string[] = [],
): LetterDraft {
const last = versions.at(-1);
const draft: LetterDraft = text.trim()
? {
phase: "ready",
text: text.trim(),
aiOperationIds,
revision,
operation: nextOperation(),
versions,
...(stopped ? { stopped: true as const } : {}),
}
: last !== undefined
? { phase: "ready", ...last, revision, operation: nextOperation(), versions: versions.slice(0, -1) }
: idle;
if (draft.phase === "ready")
void storeDraft(owner, {
text: draft.text,
aiOperationIds: draft.aiOperationIds,
variant: "draft",
revision,
versions: draft.versions,
...(draft.stopped ? { stopped: true as const } : {}),
});
else void clearDraft(owner);
return draft;
}
/** Stop while drafting: what arrived stays as a draft to review; with nothing yet, the draft before it. */
export function stopLetterDraftKeepingText() {
const letter = useLetterStore.getState().document;
restoreVersion++;
drafting?.abort();
drafting = null;
if (!letter) return;
const owner = letterDraftOwner(letter.id);
useLetterDrafting.setState((state) =>
state.owner === owner && state.draft.phase === "streaming"
? {
...state,
draft: settle(
owner,
state.draft.text,
state.draft.versions,
letter.revision,
true,
state.draft.aiOperationIds,
),
}
: state,
);
}
/** Dismiss on a failed run: back to the draft before it when there was one. */
export function dismissLetterDraftFailure() {
const letter = useLetterStore.getState().document;
if (!letter) return;
const owner = letterDraftOwner(letter.id);
useLetterDrafting.setState((state) =>
state.owner === owner && state.draft.phase === "failed"
? { ...state, draft: settle(owner, "", state.draft.versions, letter.revision, false) }
: state,
);
}
/**
* Leaving the editor stops a stream and clears the phantom streaming/unsaved card; a ready, unkept draft stays for
* this letter's next visit. Another letter/account never inherits either state.
*/
export function stopLetterDraft() {
restoreVersion++;
drafting?.abort();
drafting = null;
useLetterDrafting.setState((state) =>
state.draft.phase === "streaming" && state.owner && state.draft.versions.length
? // Earlier finished versions stay for the next visit; only the half-streamed one goes.
{ ...state, draft: settle(state.owner, "", state.draft.versions, state.draft.revision, false) }
: state.draft.phase === "streaming" || state.draft.phase === "unsaved"
? { ...state, draft: idle }
: state,
);
}
/** Stop, Discard and Dismiss: the letter stays as it was. Clears only the draft owned by the open letter. */
export function discardLetterDraft() {
const id = useLetterStore.getState().document?.id;
restoreVersion++;
drafting?.abort();
drafting = null;
if (id) {
const owner = letterDraftOwner(id);
void clearDraft(owner);
useLetterDrafting.setState((state) => (state.owner === owner ? { ...state, draft: idle } : state));
}
}