@avasapp/agent-bridge 0.4.2 → 0.6.0

package/dist/adapters/zustand.cjs

@@ -43,8 +43,7 @@ function toJson(value) {
   return text === void 0 ? null : JSON.parse(text);
 }
 
-// src/adapters/zustand.ts
-var snapshots = /* @__PURE__ */ new WeakMap();
+// src/adapters/store-common.ts
 var isObject = (value) => typeof value === "object" && value !== null;
 function toPath(part) {
   if (typeof part === "string") return part === "" ? [] : part.split(".");
@@ -52,7 +51,7 @@ function toPath(part) {
   if (Array.isArray(part) && part.every((p) => typeof p === "string" || typeof p === "number"))
     return part;
   throw new Error(
-    `A store path is a dotted string or an array of segments, got ${JSON.stringify(part)}`
+    `A path is a dotted string or an array of segments, got ${JSON.stringify(part)}`
   );
 }
 function at(value, path) {
@@ -62,7 +61,7 @@ function at(value, path) {
   );
 }
 var kindOf = (v) => v === null ? "null" : Array.isArray(v) ? "array" : typeof v;
-function readState(state, given) {
+function readState(state, given, tool = "store.get") {
   const args = given.filter((a) => a != null);
   const last = args.at(-1);
   const isOptions = isObject(last) && !Array.isArray(last);
@@ -70,12 +69,12 @@ function readState(state, given) {
   const unknown = Object.keys(options).filter((k) => k !== "pick" && k !== "keys");
   if (unknown.length)
     throw new Error(
-      `Unknown store.get option ${unknown.map((k) => `"${k}"`).join(", ")}. Options: pick, keys`
+      `Unknown ${tool} option ${unknown.map((k) => `"${k}"`).join(", ")}. Options: pick, keys`
     );
   const value = at(state, (isOptions ? args.slice(0, -1) : args).flatMap(toPath));
   if (options.pick !== void 0) {
     if (!Array.isArray(options.pick))
-      throw new Error("store.get pick is an array of paths");
+      throw new Error(`${tool} pick is an array of paths`);
     return Object.fromEntries(
       options.pick.map((p) => [
         Array.isArray(p) ? p.join(".") : String(p),
@@ -87,17 +86,6 @@ function readState(state, given) {
     return isObject(value) ? Object.fromEntries(Object.entries(value).map(([k, v]) => [k, kindOf(v)])) : kindOf(value);
   return value;
 }
-function restore(store, snapshot) {
-  const current = store.getState();
-  if (!isObject(snapshot) || !isObject(current)) {
-    store.setState(snapshot, true);
-    return;
-  }
-  const actions = Object.fromEntries(
-    Object.entries(current).filter(([, v]) => typeof v === "function")
-  );
-  store.setState({ ...snapshot, ...actions }, true);
-}
 var PREVIEW = 200;
 function preview(value) {
   try {
@@ -109,10 +97,11 @@ function preview(value) {
     return "[unserializable]";
   }
 }
-function differences(snapshot, current, show) {
+function differences(snapshot, current, show, only) {
   if (!isObject(snapshot) || !isObject(current)) return {};
   const out = {};
   for (const k of /* @__PURE__ */ new Set([...Object.keys(snapshot), ...Object.keys(current)])) {
+    if (only && !only.has(k)) continue;
     const a = snapshot[k];
     const b = current[k];
     if (typeof a === "function" || typeof b === "function") continue;
@@ -137,6 +126,79 @@ function redactValue(redact, name, value, path, seen = []) {
   ]);
   return Array.isArray(value) ? entries.map(([, v]) => v) : Object.fromEntries(entries);
 }
+
+// src/adapters/zustand.ts
+var HYDRATION_WAIT_MS = 2e3;
+var rev = 0;
+function survivesJson(v, depth = 0) {
+  if (v === null || typeof v === "string" || typeof v === "boolean") return true;
+  if (typeof v === "number") return Number.isFinite(v);
+  if (depth > 50 || !isObject(v)) return false;
+  if (Array.isArray(v)) return v.every((x) => survivesJson(x, depth + 1));
+  const proto = Object.getPrototypeOf(v);
+  if (proto !== Object.prototype && proto !== null) return false;
+  return Object.values(v).every((x) => x === void 0 || survivesJson(x, depth + 1));
+}
+var ok = (v) => v === void 0 || survivesJson(v);
+var has = (x, k) => x[k] !== void 0;
+function persisted(store, state) {
+  try {
+    const partialize = store.persist?.getOptions?.().partialize;
+    const part = partialize ? partialize(state) : state;
+    if (!isObject(part) || Array.isArray(part)) return void 0;
+    const raw = Object.fromEntries(Object.entries(part).filter(([, v]) => typeof v !== "function"));
+    const refused = /* @__PURE__ */ new Set();
+    if (partialize && isObject(state)) {
+      for (const [k, v] of Object.entries(raw)) if (!(k in state) || !Object.is(state[k], v)) refused.add(k);
+    }
+    return { raw, refused };
+  } catch {
+    return void 0;
+  }
+}
+var differs = (a, b) => ok(a) && ok(b) ? !same(a, b) : !Object.is(a, b);
+var json = (v) => JSON.parse(JSON.stringify(v));
+var same = (a, b) => {
+  if (Object.is(a, b)) return true;
+  if (!isObject(a) || !isObject(b) || Array.isArray(a) !== Array.isArray(b)) return false;
+  const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+  return [...keys].every((k) => same(a[k], b[k]));
+};
+async function hydrated(store) {
+  const p = store.persist;
+  if (!p?.hasHydrated || p.hasHydrated()) return true;
+  return new Promise((resolve) => {
+    const off = p.onFinishHydration?.(() => finish(true));
+    const timer = setTimeout(() => finish(false), HYDRATION_WAIT_MS);
+    function finish(ok2) {
+      clearTimeout(timer);
+      off?.();
+      resolve(ok2);
+    }
+  });
+}
+var snapshots = /* @__PURE__ */ new WeakMap();
+var adoptedKeys = /* @__PURE__ */ new WeakMap();
+function restore(store, snapshot, only) {
+  const current = store.getState();
+  if (only && isObject(snapshot) && isObject(current)) {
+    const next = { ...current };
+    for (const k of only) {
+      if (k in snapshot) next[k] = snapshot[k];
+      else delete next[k];
+    }
+    store.setState(next, true);
+    return;
+  }
+  if (!isObject(snapshot) || !isObject(current)) {
+    store.setState(snapshot, true);
+    return;
+  }
+  const actions = Object.fromEntries(
+    Object.entries(current).filter(([, v]) => typeof v === "function")
+  );
+  store.setState({ ...snapshot, ...actions }, true);
+}
 function storeTools(stores, options = {}) {
   const out = (name, value, path = "") => redactValue(options.redact, name, value, path);
   const get = (name) => {
@@ -147,8 +209,26 @@ function storeTools(stores, options = {}) {
       );
     return store;
   };
+  const hidden = (name, k, ...values) => {
+    const { redact } = options;
+    if (!redact) return false;
+    if (typeof redact !== "function")
+      return !!redact[name]?.some((p) => p === k || p.startsWith(`${k}.`) || k.startsWith(`${p}.`));
+    return values.some((v) => !same(redactValue(redact, name, v, k), v));
+  };
   const beforeChange = (store) => {
-    if (!snapshots.has(store)) snapshots.set(store, store.getState());
+    rev += 1;
+    const only = adoptedKeys.get(store);
+    if (only) {
+      const next = { ...store.getState() };
+      const saved = snapshots.get(store);
+      for (const k of only) {
+        if (k in saved) next[k] = saved[k];
+        else delete next[k];
+      }
+      snapshots.set(store, next);
+      adoptedKeys.delete(store);
+    } else if (!snapshots.has(store)) snapshots.set(store, store.getState());
   };
   return {
     "store.list": {
@@ -183,7 +263,12 @@ function storeTools(stores, options = {}) {
           throw new Error(`Store "${name}" has no action "${action}"`);
         beforeChange(store);
         const before = store.getState();
-        const result = await fn(...args);
+        let result;
+        try {
+          result = await fn(...args);
+        } finally {
+          rev += 1;
+        }
         const after = store.getState();
         if (result !== void 0 && result !== before && result !== after) {
           const key = isObject(after) ? Object.keys(after).find((k) => after[k] === result) : void 0;
@@ -203,6 +288,8 @@ function storeTools(stores, options = {}) {
       description: "Keep a store as it is now: drops its pending snapshot, so bridge.restore leaves it alone and the next store.set or store.call snapshots again from this state. Use it after repairing a value that was already wrong when the snapshot was taken. Returns { store, committed } (committed: false when nothing was pending).",
       run: (name) => {
         const store = get(name);
+        rev += 1;
+        adoptedKeys.delete(store);
         return { store: name, committed: snapshots.delete(store) };
       }
     },
@@ -210,6 +297,87 @@ function storeTools(stores, options = {}) {
       maxArgs: 0,
       // Per store, its snapshot against now (secrets redacted), so an agent can
       // tell what a restore will put back before it does.
+      journalRev: () => rev,
+      // Persisted stores only: others are rebuilt from scratch on reload.
+      journal: () => {
+        const out2 = {};
+        for (const [name, store] of Object.entries(stores)) {
+          if (!store.persist || !snapshots.has(store)) continue;
+          const before = persisted(store, snapshots.get(store));
+          const now = persisted(store, store.getState());
+          if (!before || !now) continue;
+          const entry = { original: {}, after: {} };
+          const skipped = [];
+          const only = adoptedKeys.get(store);
+          for (const k of /* @__PURE__ */ new Set([...Object.keys(before.raw), ...Object.keys(now.raw)])) {
+            if (only && !only.has(k)) continue;
+            const a = before.raw[k];
+            const b = now.raw[k];
+            if (!differs(a, b)) continue;
+            if (before.refused.has(k) || now.refused.has(k) || !ok(a) || !ok(b) || hidden(name, k, a, b)) {
+              skipped.push(k);
+              continue;
+            }
+            if (has(before.raw, k)) entry.original[k] = json(a);
+            if (has(now.raw, k)) entry.after[k] = json(b);
+          }
+          if (skipped.length) entry.skipped = skipped;
+          if (skipped.length || Object.keys(entry.original).length || Object.keys(entry.after).length) out2[name] = entry;
+        }
+        return Object.keys(out2).length ? out2 : void 0;
+      },
+      adopt: async (raw) => {
+        const data = isObject(raw) && !Array.isArray(raw) ? raw : {};
+        const result = { adopted: [], already: [], changed: [] };
+        const retry = {};
+        const ready = await Promise.all(
+          Object.keys(data).map((n) => stores[n] ? hydrated(stores[n]) : false)
+        );
+        const names = Object.keys(data);
+        for (const [name, entry] of Object.entries(data)) {
+          const store = stores[name];
+          const skipped = entry?.skipped;
+          if (!isObject(entry) || !isObject(entry.original) || !isObject(entry.after) || skipped !== void 0 && !(Array.isArray(skipped) && skipped.every((k) => typeof k === "string"))) {
+            (result.invalid ?? (result.invalid = [])).push(name);
+            continue;
+          }
+          if (!store || !ready[names.indexOf(name)]) {
+            retry[name] = entry;
+            continue;
+          }
+          for (const k of skipped ?? []) (result.notKept ?? (result.notKept = [])).push(`${name}:${k}`);
+          const now = persisted(store, store.getState());
+          const saved = snapshots.has(store) && !adoptedKeys.has(store) ? persisted(store, snapshots.get(store)) : void 0;
+          const eq = (x, y, k) => has(x, k) === has(y, k) && (!has(x, k) || same(x[k], y[k]));
+          const back = [];
+          for (const k of /* @__PURE__ */ new Set([...Object.keys(entry.original), ...Object.keys(entry.after)])) {
+            const label = `${name}:${k}`;
+            if (!now || now.refused.has(k) || !ok(now.raw[k])) {
+              (result.notKept ?? (result.notKept = [])).push(label);
+              continue;
+            }
+            const savedFake = !!saved && ok(saved.raw[k]) && eq(saved.raw, entry.after, k);
+            if (!savedFake && eq(now.raw, entry.original, k)) result.already.push(label);
+            else if (savedFake || eq(now.raw, entry.after, k)) {
+              back.push(k);
+              result.adopted.push(label);
+            } else result.changed.push(label);
+          }
+          if (back.length) {
+            if (!snapshots.has(store)) adoptedKeys.set(store, /* @__PURE__ */ new Set());
+            const next = { ...snapshots.get(store) ?? store.getState() };
+            for (const k of back) {
+              if (k in entry.original) next[k] = entry.original[k];
+              else delete next[k];
+              adoptedKeys.get(store)?.add(k);
+            }
+            snapshots.set(store, next);
+            rev += 1;
+          }
+        }
+        if (Object.keys(retry).length) result.retry = retry;
+        return result;
+      },
       pending: ({ detail } = {}) => {
         const changed = Object.entries(stores).filter(([, s]) => snapshots.has(s));
         if (!changed.length) return false;
@@ -220,7 +388,8 @@ function storeTools(stores, options = {}) {
             differences(
               snapshots.get(store),
               store.getState(),
-              (key, value) => out(name, value, key)
+              (key, value) => out(name, value, key),
+              adoptedKeys.get(store)
             )
           ])
         );
@@ -228,8 +397,10 @@ function storeTools(stores, options = {}) {
       description: "Undo the agent: put back each store changed with store.set or store.call, to its state at the first of those (store.commit drops a snapshot). Returns their names.",
       run: () => Object.entries(stores).flatMap(([name, store]) => {
         if (!snapshots.has(store)) return [];
-        restore(store, snapshots.get(store));
+        rev += 1;
+        restore(store, snapshots.get(store), adoptedKeys.get(store));
         snapshots.delete(store);
+        adoptedKeys.delete(store);
         return [name];
       })
     }

package/dist/adapters/zustand.d.cts

@@ -1,4 +1,5 @@
-import { T as Tools } from '../types-BmpykP1P.cjs';
+import { T as Tools } from '../types-qlwdcGjt.cjs';
+import { R as Redact } from '../store-common-j0cHHvBr.cjs';
 
 /** Anything with zustand's store shape. */
 type StoreLike = {
@@ -8,24 +9,19 @@ type StoreLike = {
      * syntax, so zustand's overloads (replace: false | true) still fit.
      */
     setState(partial: Record<string, unknown>, replace?: boolean): void;
+    /** Present on stores made with zustand's `persist` middleware. */
+    persist?: {
+        getOptions?: () => {
+            partialize?: (state: never) => unknown;
+        };
+        hasHydrated?: () => boolean;
+        onFinishHydration?: (fn: () => void) => () => void;
+    };
 };
-/**
- * Keeps secrets out of what store.* prints. Either dotted paths per store
- * (`{ auth: ['accessToken', 'user.phone'] }`), or a hook called for the store
- * value and every nested value with its dotted path; what it returns is
- * printed instead.
- *
- * Paths are store paths. A `store.call` result that is a piece of the store's
- * state (same object, e.g. `() => get().user`) is matched by where it lives; a
- * copy or derived value (`() => ({ ...get().user })`) is not, so its paths are
- * matched relative to the result and store paths like `user.phone` won't apply.
- * Use the hook, or don't return secrets from actions.
- */
-type Redact = Record<string, string[]> | ((store: string, path: string, value: unknown) => unknown);
 type StoreToolsOptions = {
     redact?: Redact;
 };
 /** Read, merge into, and call actions on named stores. */
 declare function storeTools(stores: Record<string, StoreLike>, options?: StoreToolsOptions): Tools;
 
-export { type Redact, type StoreLike, type StoreToolsOptions, storeTools };
+export { Redact, type StoreLike, type StoreToolsOptions, storeTools };