Share pending prompt recovery semantics

Generated-By: PostHog Code
Task-Id: 40c57a59-b4e1-4760-8e56-ecd03e9c2f0f

Author: richardsolomou

apps/mobile/src/features/tasks/stores/pendingPromptRecoveryStore.ts

@@ -1,12 +1,14 @@
+import {
+  capPendingPrompts,
+  listPendingPromptsNewestFirst,
+} from "@posthog/core/tasks/pendingPrompts";
 import AsyncStorage from "@react-native-async-storage/async-storage";
 import { create } from "zustand";
 import { createJSONStorage, persist } from "zustand/middleware";
 
 // Persisted (unlike the transient in-memory echo store, whose entries vanish
 // the instant the live SSE copy lands) so a prompt survives the app being
 // killed mid-create and can be recovered on the next launch.
-const MAX_RECOVERABLE_PROMPTS = 20;
-
 export interface RecoverablePrompt {
   promptText: string;
   createdAt: number;
@@ -20,19 +22,6 @@ interface PendingPromptRecoveryState {
   setHasHydrated: (hydrated: boolean) => void;
 }
 
-function capToNewest(
-  byKey: Record<string, RecoverablePrompt>,
-): Record<string, RecoverablePrompt> {
-  const keys = Object.keys(byKey);
-  if (keys.length <= MAX_RECOVERABLE_PROMPTS) return byKey;
-  const kept = keys
-    .sort((a, b) => byKey[b].createdAt - byKey[a].createdAt)
-    .slice(0, MAX_RECOVERABLE_PROMPTS);
-  const trimmed: Record<string, RecoverablePrompt> = {};
-  for (const key of kept) trimmed[key] = byKey[key];
-  return trimmed;
-}
-
 export const usePendingPromptRecoveryStore =
   create<PendingPromptRecoveryState>()(
     persist(
@@ -41,7 +30,7 @@ export const usePendingPromptRecoveryStore =
         hasHydrated: false,
         set: (key, promptText) =>
           set((state) => ({
-            byKey: capToNewest({
+            byKey: capPendingPrompts({
               ...state.byKey,
               [key]: { promptText, createdAt: Date.now() },
             }),
@@ -75,9 +64,9 @@ export const pendingPromptRecoveryStoreApi = {
     usePendingPromptRecoveryStore.getState().clear(key);
   },
   getAllNewestFirst(): { key: string; prompt: RecoverablePrompt }[] {
-    return Object.entries(usePendingPromptRecoveryStore.getState().byKey)
-      .map(([key, prompt]) => ({ key, prompt }))
-      .sort((a, b) => b.prompt.createdAt - a.prompt.createdAt);
+    return listPendingPromptsNewestFirst(
+      usePendingPromptRecoveryStore.getState().byKey,
+    );
   },
   whenHydrated(): Promise<void> {
     if (usePendingPromptRecoveryStore.getState().hasHydrated) {

apps/mobile/src/features/tasks/stores/pendingTaskPromptStore.ts

@@ -1,3 +1,4 @@
+import { buildPendingPromptKey } from "@posthog/core/tasks/pendingPrompts";
 import { create } from "zustand";
 import type { SessionNotificationAttachment } from "../types";
 
@@ -79,8 +80,9 @@ export function generatePendingTaskKey(): string {
     typeof globalThis !== "undefined"
       ? (globalThis as { crypto?: { randomUUID?: () => string } }).crypto
       : undefined;
-  if (cryptoObj?.randomUUID) {
-    return cryptoObj.randomUUID();
-  }
-  return `pending-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+  return buildPendingPromptKey(
+    cryptoObj?.randomUUID?.() ?? null,
+    Date.now(),
+    Math.random().toString(36).slice(2, 10),
+  );
 }

packages/core/src/tasks/pendingPrompts.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildPendingPromptKey,
+  capPendingPrompts,
+  listPendingPromptsNewestFirst,
+  selectNewestPendingPrompt,
+} from "./pendingPrompts";
+
+describe("pending prompts", () => {
+  it("keeps the newest prompts up to the limit", () => {
+    expect(
+      capPendingPrompts(
+        {
+          old: { createdAt: 1 },
+          middle: { createdAt: 2 },
+          newest: { createdAt: 3 },
+        },
+        2,
+      ),
+    ).toEqual({ middle: { createdAt: 2 }, newest: { createdAt: 3 } });
+  });
+
+  it("orders prompts newest first and selects the newest", () => {
+    const prompts = { old: { createdAt: 1 }, new: { createdAt: 2 } };
+    expect(
+      listPendingPromptsNewestFirst(prompts).map(({ key }) => key),
+    ).toEqual(["new", "old"]);
+    expect(selectNewestPendingPrompt(prompts)?.key).toBe("new");
+  });
+
+  it.each([
+    ["uuid", 1, "abc", "uuid"],
+    [null, 123, "abc", "pending-123-abc"],
+  ])("builds a portable pending key", (uuid, timestamp, entropy, expected) => {
+    expect(buildPendingPromptKey(uuid, timestamp, entropy)).toBe(expected);
+  });
+});

packages/core/src/tasks/pendingPrompts.ts

@@ -0,0 +1,47 @@
+export const MAX_RECOVERABLE_PROMPTS = 20;
+
+export interface TimestampedPendingPrompt {
+  createdAt: number;
+}
+
+export interface RecoverablePendingPrompt<
+  TPrompt extends TimestampedPendingPrompt,
+> {
+  key: string;
+  prompt: TPrompt;
+}
+
+export function capPendingPrompts<TPrompt extends TimestampedPendingPrompt>(
+  byKey: Record<string, TPrompt>,
+  limit: number = MAX_RECOVERABLE_PROMPTS,
+): Record<string, TPrompt> {
+  const keys = Object.keys(byKey);
+  if (keys.length <= limit) return byKey;
+
+  const kept = keys
+    .sort((left, right) => byKey[right].createdAt - byKey[left].createdAt)
+    .slice(0, limit);
+  return Object.fromEntries(kept.map((key) => [key, byKey[key]]));
+}
+
+export function listPendingPromptsNewestFirst<
+  TPrompt extends TimestampedPendingPrompt,
+>(byKey: Record<string, TPrompt>): RecoverablePendingPrompt<TPrompt>[] {
+  return Object.entries(byKey)
+    .map(([key, prompt]) => ({ key, prompt }))
+    .sort((left, right) => right.prompt.createdAt - left.prompt.createdAt);
+}
+
+export function selectNewestPendingPrompt<
+  TPrompt extends TimestampedPendingPrompt,
+>(byKey: Record<string, TPrompt>): RecoverablePendingPrompt<TPrompt> | null {
+  return listPendingPromptsNewestFirst(byKey)[0] ?? null;
+}
+
+export function buildPendingPromptKey(
+  randomUuid: string | null,
+  timestamp: number,
+  entropy: string,
+): string {
+  return randomUuid ?? `pending-${timestamp}-${entropy}`;
+}

packages/ui/src/features/task-detail/hooks/useTaskCreation.ts

@@ -31,7 +31,10 @@ import { useConnectivity } from "../../../hooks/useConnectivity";
 import { toast } from "../../../primitives/toast";
 import { track } from "../../../shell/analytics";
 import { logger } from "../../../shell/logger";
-import { pendingTaskPromptStoreApi } from "../../../shell/pendingTaskPromptStore";
+import {
+  generatePendingTaskKey,
+  pendingTaskPromptStoreApi,
+} from "../../../shell/pendingTaskPromptStore";
 import { titleAttachmentStoreApi } from "../../../shell/titleAttachmentStore";
 import { useAuthStateValue } from "../../auth/store";
 import { assertCloudUsageAvailable } from "../../billing/preflightCloudUsage";
@@ -319,7 +322,7 @@ export function useTaskCreation({
 
       const shouldShowPendingView = !onTaskCreated && !!plainPromptText;
       const pendingTaskKey = shouldShowPendingView
-        ? (globalThis.crypto?.randomUUID?.() ?? `pending-${Date.now()}`)
+        ? generatePendingTaskKey()
         : null;
 
       if (pendingTaskKey) {

packages/ui/src/shell/pendingTaskPromptStore.ts

@@ -1,13 +1,8 @@
 import type { UserMessageAttachment } from "@posthog/ui/features/sessions/userMessageTypes";
-import { logger } from "@posthog/ui/shell/logger";
 import { electronStorage } from "@posthog/ui/shell/rendererStorage";
 import { create } from "zustand";
 import { persist } from "zustand/middleware";
 
-const log = logger.scope("pending-task-prompts");
-
-const MAX_PENDING_PROMPTS = 20;
-
 export interface PendingTaskPrompt {
   promptText: string;
   attachments: UserMessageAttachment[];
@@ -16,26 +11,6 @@ export interface PendingTaskPrompt {
 
 export type PendingTaskPromptInput = Omit<PendingTaskPrompt, "createdAt">;
 
-function capToNewest(
-  byKey: Record<string, PendingTaskPrompt>,
-): Record<string, PendingTaskPrompt> {
-  const keys = Object.keys(byKey);
-  if (keys.length <= MAX_PENDING_PROMPTS) {
-    return byKey;
-  }
-  const keptKeys = keys
-    .sort((a, b) => byKey[b].createdAt - byKey[a].createdAt)
-    .slice(0, MAX_PENDING_PROMPTS);
-  log.warn("Dropping oldest unrecovered prompts beyond cap", {
-    dropped: keys.length - keptKeys.length,
-  });
-  const kept: Record<string, PendingTaskPrompt> = {};
-  for (const key of keptKeys) {
-    kept[key] = byKey[key];
-  }
-  return kept;
-}
-
 interface PendingTaskPromptStore {
   byKey: Record<string, PendingTaskPrompt>;
   _hasHydrated: boolean;
@@ -54,7 +29,7 @@ export const usePendingTaskPromptStore = create<PendingTaskPromptStore>()(
       setHasHydrated: (hydrated) => set({ _hasHydrated: hydrated }),
       set: (key, prompt) =>
         set((state) => ({
-          byKey: capToNewest({
+          byKey: capPendingPrompts({
             ...state.byKey,
             [key]: { ...prompt, createdAt: Date.now() },
           }),
@@ -110,9 +85,7 @@ export const pendingTaskPromptStoreApi = {
     usePendingTaskPromptStore.getState().move(fromKey, toKey),
   clear: (key: string) => usePendingTaskPromptStore.getState().clear(key),
   getAllNewestFirst: (): RecoverablePendingPrompt[] =>
-    Object.entries(usePendingTaskPromptStore.getState().byKey)
-      .map(([key, prompt]) => ({ key, prompt }))
-      .sort((a, b) => b.prompt.createdAt - a.prompt.createdAt),
+    listPendingPromptsNewestFirst(usePendingTaskPromptStore.getState().byKey),
   whenHydrated: (): Promise<void> => {
     if (usePendingTaskPromptStore.getState()._hasHydrated) {
       return Promise.resolve();
@@ -128,10 +101,24 @@ export const pendingTaskPromptStoreApi = {
   },
 };
 
+export function generatePendingTaskKey(): string {
+  return buildPendingPromptKey(
+    globalThis.crypto?.randomUUID?.() ?? null,
+    Date.now(),
+    Math.random().toString(36).slice(2, 10),
+  );
+}
+
 export function usePendingTaskPrompt(
   key: string | undefined,
 ): PendingTaskPrompt | undefined {
   return usePendingTaskPromptStore((state) =>
     key ? state.byKey[key] : undefined,
   );
 }
+
+import {
+  buildPendingPromptKey,
+  capPendingPrompts,
+  listPendingPromptsNewestFirst,
+} from "@posthog/core/tasks/pendingPrompts";