@buoy-gg/time-machine 7.0.21 → 7.0.23

package/src/store/timeMachineStore.ts

@@ -28,14 +28,26 @@ import {
 import { objectDiff } from "@buoy-gg/shared-ui/dataViewer";
 import {
   deleteSnapshot,
+  duplicateSnapshot,
   loadIndex,
   loadSnapshot,
+  markSnapshotRestored,
+  readSnapshot,
   renameSnapshot,
+  restoreDeletedSnapshot,
   saveSnapshot,
+  setSnapshotRestoreRoute,
   setSnapshotScope,
+  setSnapshotExclusions,
   type SnapshotMeta,
   type StoredSnapshot,
 } from "./snapshotVault";
+import {
+  captureCurrentRoute,
+  navigateToRoute,
+  savePendingRoute,
+  type RouteRestoreResult,
+} from "./routeRestore";
 
 export const RESTORE_ORDER = ["storage", "redux", "zustand", "jotai", "query"];
 
@@ -49,6 +61,44 @@ export interface RestoreOutcome {
   /** True when a JS reload was scheduled as part of this restore. */
   willReload: boolean;
   results: Record<string, StateSnapshotRestoreResult>;
+  /**
+   * Present when the caller asked to also return to the snapshot's route.
+   * "deferred" means the navigation is queued for the post-reload boot.
+   */
+  route?: RouteRestoreResult;
+}
+
+/**
+ * What to call a capture nobody named. The screen you were on plus the time
+ * is the pair that makes a restore point recognizable an hour later —
+ * "Untitled snapshot" never was, and typing mid-flow is the friction that
+ * produced it.
+ */
+function defaultSnapshotName(route: { pathname: string } | null | undefined): string {
+  const now = new Date();
+  const clock = `${String(now.getHours()).padStart(2, "0")}:${String(
+    now.getMinutes()
+  ).padStart(2, "0")}`;
+  return route ? `${route.pathname} · ${clock}` : `Snapshot · ${clock}`;
+}
+
+/**
+ * Will restoring this point also navigate back to its route? Having a route
+ * means wanting it back unless the point says otherwise — the same rule
+ * `restore` applies, exported so the UI can't drift from it.
+ */
+export function willRestoreRoute(meta: SnapshotMeta): boolean {
+  return !!meta.route && (meta.restoreRoute ?? true);
+}
+
+/** Extra knobs a restore accepts beyond mode + exclusions. */
+export interface RestoreOptions {
+  /**
+   * Also navigate back to the route the snapshot was captured on. Ignored for
+   * snapshots with no captured route (and for baselines, which wipe to the
+   * app's own start route).
+   */
+  restoreRoute?: boolean;
 }
 
 /** Provider capability row as mirrored to a remote dashboard. */
@@ -92,6 +142,23 @@ export interface TimeMachineState {
    * registry, and every operation forwards over the socket.
    */
   remoteProviders: RemoteProviderStatus[] | null;
+  /**
+   * Route capture/restore availability, mirrored from the device's payload
+   * (Buoy Desktop). Null on-device, where the live router is probed directly.
+   */
+  remoteRoute: RouteToolStatus | null;
+  /**
+   * The last deleted record, held in memory so the list can offer an undo.
+   * The vault row is already gone — this is the only copy until it expires.
+   */
+  recentlyDeleted: { stored: StoredSnapshot; at: number } | null;
+}
+
+/** Whether this device can capture and return to routes, and where it is now. */
+export interface RouteToolStatus {
+  available: boolean;
+  /** The route the app is on right now, when one can be read. */
+  current?: string;
 }
 
 type RemoteHandler = (
@@ -119,6 +186,8 @@ class TimeMachineStore {
     lastOutcome: null,
     preview: null,
     remoteProviders: null,
+    remoteRoute: null,
+    recentlyDeleted: null,
   };
   /** Monotonic token — a preview build checks it after every await and
    * abandons itself when a newer build (or clearPreview) supersedes it. */
@@ -166,12 +235,14 @@ class TimeMachineStore {
     busy?: TimeMachineState["busy"];
     lastOutcome?: RestoreOutcome | null;
     providers?: RemoteProviderStatus[];
+    route?: RouteToolStatus;
   }): void {
     this.setState({
       snapshots: payload.snapshots ?? [],
       busy: payload.busy ?? null,
       lastOutcome: payload.lastOutcome ?? null,
       remoteProviders: payload.providers ?? [],
+      remoteRoute: payload.route ?? { available: false },
       hasLoaded: true,
     });
   }
@@ -204,12 +275,15 @@ class TimeMachineStore {
           };
         }
       }
+      // Where the app was when this state was true — restoring can return here.
+      const route = captureCurrentRoute();
       const snapshot: StoredSnapshot = {
         meta: {
           id: nextId(),
-          name: name.trim() || "Untitled snapshot",
+          name: name.trim() || defaultSnapshotName(route),
           createdAt: Date.now(),
           sizeBytes: 0,
+          ...(route ? { route } : {}),
           sources,
         },
         data,
@@ -259,13 +333,15 @@ class TimeMachineStore {
   async restore(
     id: string,
     mode: RestoreMode,
-    excludeKeys?: readonly string[]
+    excludeKeys?: readonly string[],
+    options?: RestoreOptions
   ): Promise<RestoreOutcome> {
     if (remoteHandler) {
       const outcome = (await remoteHandler("restore", {
         id,
         mode,
         excludeKeys,
+        restoreRoute: options?.restoreRoute,
       })) as RestoreOutcome;
       this.setState({ lastOutcome: outcome });
       return outcome;
@@ -321,7 +397,11 @@ class TimeMachineStore {
         return bySource;
       };
 
-      const excludeBySource = splitCompound(excludeKeys ?? []);
+      // No explicit list means "use what the user saved in the preview" —
+      // that is what makes an unchecked item stay unchecked forever, for the
+      // one-tap RESTORE on the list and for MCP alike.
+      const effectiveExcludes = excludeKeys ?? stored.meta.excludedKeys ?? [];
+      const excludeBySource = splitCompound(effectiveExcludes);
       // A saved scope makes this a targeted restore point. An explicit
       // exclusion list from the preview already reflects the scope (the
       // preview seeds its selection from it), so it takes precedence.
@@ -330,6 +410,12 @@ class TimeMachineStore {
           ? splitCompound(stored.meta.scope)
           : null;
 
+      // No prompt any more: the point carries its own answer, and having a
+      // route means wanting it back unless you said otherwise. An explicit
+      // option still wins, so MCP and the desktop can force either way.
+      const wantsRoute =
+        options?.restoreRoute ?? willRestoreRoute(stored.meta);
+
       if (mode === "reload") {
         // Storage only; everything in-memory rebuilds after the reload.
         if (
@@ -343,8 +429,23 @@ class TimeMachineStore {
             includeBySource?.get("storage")
           );
         }
+        // Hand the route to the NEXT boot — this realm is about to die, so the
+        // slot must be written before the reload is armed.
+        if (wantsRoute) {
+          const route = stored.meta.route!;
+          try {
+            await savePendingRoute(route, stored.meta.name);
+            outcome.route = { ...route, status: "deferred" };
+          } catch (e) {
+            outcome.route = { ...route, status: "failed", error: String(e) };
+          }
+        }
         outcome.willReload = this.scheduleReload("buoy time-machine restore");
-        this.setState({ lastOutcome: outcome });
+        // Stamped BEFORE the reload is armed — the JS realm is about to die.
+        this.setState({
+          lastOutcome: outcome,
+          snapshots: await markSnapshotRestored(id, outcome.at, this.state.snapshots),
+        });
         return outcome;
       }
 
@@ -358,7 +459,14 @@ class TimeMachineStore {
           includeBySource?.get(sid)
         );
       }
-      this.setState({ lastOutcome: outcome });
+      // Navigate LAST — the screen we land on should read the restored state.
+      if (wantsRoute) {
+        outcome.route = navigateToRoute(stored.meta.route!);
+      }
+      this.setState({
+        lastOutcome: outcome,
+        snapshots: await markSnapshotRestored(id, outcome.at, this.state.snapshots),
+      });
       return outcome;
     } finally {
       this.setState({ busy: null });
@@ -403,16 +511,78 @@ class TimeMachineStore {
     }
   }
 
+  /**
+   * Delete, holding the whole record in memory so `undoDelete` can put it
+   * back. Swipe-and-tap is deliberate but not recoverable, and those are
+   * different properties — a restore point can represent state that takes
+   * ten minutes and a cooperative backend to rebuild.
+   */
   async delete(id: string): Promise<void> {
     if (remoteHandler) {
       await remoteHandler("delete", { id });
       return;
     }
     await this.ensureLoaded();
+    const stored = await readSnapshot(id);
     const snapshots = await deleteSnapshot(id, this.state.snapshots);
+    this.setState({
+      snapshots,
+      recentlyDeleted: stored ? { stored, at: Date.now() } : null,
+    });
+  }
+
+  /** Put the last deleted point back. No-op once the window has passed. */
+  async undoDelete(): Promise<void> {
+    const held = this.state.recentlyDeleted;
+    if (!held) return;
+    const snapshots = await restoreDeletedSnapshot(
+      held.stored,
+      this.state.snapshots
+    );
+    this.setState({ snapshots, recentlyDeleted: null });
+  }
+
+  /** Drop the undo offer — on timeout, or when the user moves on. */
+  clearRecentlyDeleted(): void {
+    if (this.state.recentlyDeleted) this.setState({ recentlyDeleted: null });
+  }
+
+  /** Turn this point's route restore on or off. */
+  async setRestoreRoute(id: string, restoreRoute: boolean): Promise<void> {
+    if (remoteHandler) {
+      await remoteHandler("setRestoreRoute", { id, restoreRoute });
+      return;
+    }
+    await this.ensureLoaded();
+    const snapshots = await setSnapshotRestoreRoute(
+      id,
+      restoreRoute,
+      this.state.snapshots
+    );
     this.setState({ snapshots });
   }
 
+  /** Copy a point so a variation can start from a known-good base. */
+  async duplicate(id: string): Promise<SnapshotMeta | null> {
+    if (remoteHandler) {
+      const result = (await remoteHandler("duplicate", { id })) as {
+        snapshot: SnapshotMeta;
+      } | null;
+      return result?.snapshot ?? null;
+    }
+    await this.ensureLoaded();
+    const source = this.state.snapshots.find((s) => s.id === id);
+    if (!source) return null;
+    const result = await duplicateSnapshot(
+      id,
+      `${source.name} copy`,
+      this.state.snapshots
+    );
+    if (!result) return null;
+    this.setState({ snapshots: result.metas });
+    return result.meta;
+  }
+
   async rename(id: string, name: string): Promise<void> {
     if (remoteHandler) {
       await remoteHandler("rename", { id, name });
@@ -438,6 +608,25 @@ class TimeMachineStore {
     this.setState({ snapshots });
   }
 
+  /**
+   * Save (or clear with null/empty) the items every later restore of this
+   * snapshot must leave untouched — what the restore preview's checkboxes
+   * write when you save a selection.
+   */
+  async setExclusions(id: string, excludedKeys: string[] | null): Promise<void> {
+    if (remoteHandler) {
+      await remoteHandler("setExclusions", { id, excludedKeys });
+      return;
+    }
+    await this.ensureLoaded();
+    const snapshots = await setSnapshotExclusions(
+      id,
+      excludedKeys,
+      this.state.snapshots
+    );
+    this.setState({ snapshots });
+  }
+
   clearLastOutcome(): void {
     this.setState({ lastOutcome: null });
   }
@@ -686,6 +875,7 @@ export function replaceTimeMachineFromSnapshot(payload: {
   busy?: TimeMachineState["busy"];
   lastOutcome?: RestoreOutcome | null;
   providers?: RemoteProviderStatus[];
+  route?: RouteToolStatus;
 }): void {
   timeMachineStore.replaceFromSnapshot(payload);
 }

package/src/sync/timeMachineSyncAdapter.ts

@@ -23,6 +23,7 @@ import {
   type RestoreMode,
 } from "../store/timeMachineStore";
 import { loadSnapshot } from "../store/snapshotVault";
+import { canNavigate, currentRoute } from "../store/routeRestore";
 
 interface CaptureParams {
   name?: string;
@@ -33,6 +34,8 @@ interface RestoreParams {
   mode?: RestoreMode;
   /** Compound "sourceId::itemKey" strings — items the caller opted out of. */
   excludeKeys?: string[];
+  /** Also navigate back to the route the snapshot was captured on. */
+  restoreRoute?: boolean;
 }
 interface IdParams {
   id: string;
@@ -61,11 +64,24 @@ function providerStatuses() {
 
 function metadata() {
   const { snapshots, busy, lastOutcome } = timeMachineStore.getState();
-  return { snapshots, busy, lastOutcome, providers: providerStatuses() };
+  const current = currentRoute();
+  return {
+    snapshots,
+    busy,
+    lastOutcome,
+    providers: providerStatuses(),
+    // Route capture/restore is a device capability, not a snapshot provider —
+    // a dashboard has no router of its own to probe, so it's mirrored here.
+    route: {
+      available: canNavigate(),
+      ...(current ? { current: current.href } : {}),
+    },
+  };
 }
 
 export const timeMachineSyncAdapter = {
-  version: 1,
+  // v2 adds `route` (device route capability) and `snapshots[].route`.
+  version: 2,
   getSnapshot: () => metadata(),
   subscribe: (onChange: () => void) => {
     const unsubStore = timeMachineStore.subscribe(onChange);
@@ -96,9 +112,16 @@ export const timeMachineSyncAdapter = {
      * persisted storage then reloads the JS bundle (always the path for
      * baseline snapshots). */
     restore: async (params: unknown) => {
-      const { id, mode = "live", excludeKeys } = (params as RestoreParams) ?? {};
+      const {
+        id,
+        mode = "live",
+        excludeKeys,
+        restoreRoute,
+      } = (params as RestoreParams) ?? {};
       if (!id) throw new Error("restore requires a snapshot `id`");
-      return await timeMachineStore.restore(id, mode, excludeKeys);
+      return await timeMachineStore.restore(id, mode, excludeKeys, {
+        restoreRoute,
+      });
     },
 
     delete: async (params: unknown) => {
@@ -115,6 +138,36 @@ export const timeMachineSyncAdapter = {
       return { renamed: true, id, name };
     },
 
+    /**
+     * Save (or clear with null/empty) the items a restore of this snapshot
+     * must leave alone — the persisted form of the preview's checkboxes.
+     */
+    setExclusions: async (params: unknown) => {
+      const { id, excludedKeys } =
+        (params as { id?: string; excludedKeys?: string[] | null }) ?? {};
+      if (!id) throw new Error("setExclusions requires `id`");
+      await timeMachineStore.setExclusions(id, excludedKeys ?? null);
+      return { id, excluded: excludedKeys?.length ?? 0 };
+    },
+
+    /** Turn a restore point's route restore on or off. */
+    setRestoreRoute: async (params: unknown) => {
+      const { id, restoreRoute } =
+        (params as { id?: string; restoreRoute?: boolean }) ?? {};
+      if (!id) throw new Error("setRestoreRoute requires `id`");
+      await timeMachineStore.setRestoreRoute(id, restoreRoute !== false);
+      return { id, restoreRoute: restoreRoute !== false };
+    },
+
+    /** Copy a restore point so a variation can start from a known base. */
+    duplicate: async (params: unknown) => {
+      const { id } = (params as { id?: string }) ?? {};
+      if (!id) throw new Error("duplicate requires `id`");
+      const snapshot = await timeMachineStore.duplicate(id);
+      if (!snapshot) throw new Error(`No snapshot with id "${id}"`);
+      return { snapshot };
+    },
+
     /** Save (or clear with null/empty) a snapshot's targeted-restore scope. */
     setScope: async (params: unknown) => {
       const { id, scope } =

package/src/ui/SwipeActionsRow.tsx

@@ -0,0 +1,199 @@
+/**
+ * Swipe-left-to-reveal-actions wrapper for a grouped-list row.
+ *
+ * Deliberately dependency-free (Animated + PanResponder): the package has no
+ * gesture-handler peer and a devtool must not add one to the host app.
+ *
+ * Gesture contract, in the order the checks matter:
+ *  - The pan only claims the gesture once the finger has moved LEFT past a
+ *    threshold and is travelling more horizontally than vertically, so taps
+ *    still reach the row and vertical drags still scroll the list.
+ *  - Releasing past half the action width latches open; anything less snaps
+ *    shut, so a hesitant swipe never leaves a half-open row.
+ *  - Only one row stays open at a time (module-level latch below) — matching
+ *    iOS, and it means "swipe, then tap an action" can't hit the wrong row.
+ */
+import { useEffect, useRef, type ReactNode } from "react";
+import {
+  Animated,
+  PanResponder,
+  StyleSheet,
+  Text,
+  TouchableOpacity,
+  View,
+  type PanResponderInstance,
+} from "react-native";
+import { tm } from "./tmTheme";
+
+const ACTION_WIDTH = 84;
+/** Horizontal travel before the pan takes the gesture from the scroll view. */
+const CLAIM_THRESHOLD = 8;
+
+/** The one open row, so opening another closes it. */
+let closeOpenRow: (() => void) | null = null;
+
+interface Gesture {
+  pan: PanResponderInstance;
+  /** Closes this row — also the row's identity in the open-row latch. */
+  close: () => void;
+}
+
+/**
+ * Everything gesture-side for one row, built once. Kept out of the component
+ * so it reads as the state machine it is: `open` is the only state, and the
+ * pan handlers are the only writers.
+ */
+function createGesture(
+  translateX: Animated.Value,
+  openWidth: number
+): Gesture {
+  let open = false;
+
+  const settle = (next: boolean) => {
+    open = next;
+    if (next) {
+      if (closeOpenRow && closeOpenRow !== close) closeOpenRow();
+      closeOpenRow = close;
+    } else if (closeOpenRow === close) {
+      closeOpenRow = null;
+    }
+    Animated.spring(translateX, {
+      toValue: next ? -openWidth : 0,
+      useNativeDriver: true,
+      bounciness: 0,
+      speed: 18,
+    }).start();
+  };
+
+  const close = () => settle(false);
+
+  const pan = PanResponder.create({
+    onMoveShouldSetPanResponder: (_e, g) => {
+      const horizontal = Math.abs(g.dx) > Math.abs(g.dy) * 1.5;
+      if (!horizontal) return false;
+      // Left to open; right only matters when there is something to close.
+      return g.dx < -CLAIM_THRESHOLD || (open && g.dx > CLAIM_THRESHOLD);
+    },
+    onPanResponderMove: (_e, g) => {
+      const base = open ? -openWidth : 0;
+      // Clamp: no rubber-banding past the actions, none past closed.
+      translateX.setValue(Math.min(0, Math.max(-openWidth, base + g.dx)));
+    },
+    onPanResponderRelease: (_e, g) => {
+      const resting = (open ? -openWidth : 0) + g.dx;
+      // A fast flick decides on velocity; a slow drag on distance.
+      settle(
+        g.vx < -0.5 ? true : g.vx > 0.5 ? false : resting < -openWidth / 2
+      );
+    },
+    onPanResponderTerminate: () => settle(open),
+  });
+
+  return { pan, close };
+}
+
+export interface SwipeAction {
+  label: string;
+  /** Called after the row closes itself. */
+  onPress: () => void;
+  /** Fill behind the row. Defaults to the neutral action fill. */
+  background?: string;
+  color?: string;
+  testID?: string;
+}
+
+export function SwipeActionsRow({
+  children,
+  actions,
+  testID,
+}: {
+  children: ReactNode;
+  /** Rightmost is the one furthest from the content, iOS-style. */
+  actions: SwipeAction[];
+  testID?: string;
+}) {
+  const openWidth = ACTION_WIDTH * actions.length;
+  const translateX = useRef(new Animated.Value(0)).current;
+  const gestureRef = useRef<Gesture | null>(null);
+  if (gestureRef.current === null)
+    gestureRef.current = createGesture(translateX, openWidth);
+  const { pan, close } = gestureRef.current;
+
+  // A row that unmounts while open (deleted, filtered out, screen changed)
+  // must not leave the latch pointing at a dead closer.
+  useEffect(
+    () => () => {
+      if (closeOpenRow === close) closeOpenRow = null;
+    },
+    [close]
+  );
+
+  return (
+    <View style={styles.clip}>
+      <View style={[styles.actionLayer, { width: openWidth }]}>
+        {actions.map((action) => (
+          <TouchableOpacity
+            key={action.label}
+            style={[
+              styles.action,
+              action.background ? { backgroundColor: action.background } : null,
+            ]}
+            onPress={() => {
+              close();
+              action.onPress();
+            }}
+            accessibilityLabel={action.label}
+            testID={action.testID ?? (testID ? `${testID}-${action.label.toLowerCase()}` : undefined)}
+          >
+            <Text
+              style={[styles.actionText, action.color ? { color: action.color } : null]}
+              numberOfLines={1}
+            >
+              {action.label}
+            </Text>
+          </TouchableOpacity>
+        ))}
+      </View>
+      <Animated.View
+        style={[styles.content, { transform: [{ translateX }] }]}
+        {...pan.panHandlers}
+      >
+        {children}
+      </Animated.View>
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  clip: {
+    overflow: "hidden",
+  },
+  // Own geometry, no percentages: an absoluteFill layer with a `height:
+  // "100%"` child measured against this content-sized parent inflated every
+  // row to several hundred points on iOS/Fabric.
+  actionLayer: {
+    position: "absolute",
+    top: 0,
+    bottom: 0,
+    right: 0,
+    flexDirection: "row",
+  },
+  action: {
+    width: ACTION_WIDTH,
+    height: "100%",
+    backgroundColor: tm.color.fillStrong,
+    alignItems: "center",
+    justifyContent: "center",
+    paddingHorizontal: 6,
+  },
+  actionText: {
+    color: tm.color.label,
+    fontSize: tm.font.footnote,
+    fontWeight: "600",
+    letterSpacing: tm.tracking.control,
+  },
+  // Opaque so the red action never bleeds through the row it sits under.
+  content: {
+    backgroundColor: tm.color.group,
+  },
+});