pi-jev-guard 0.6.0 → 0.6.1

package/extensions/index.ts

@@ -405,7 +405,7 @@ export default function (pi: ExtensionAPI) {
     refs: TwinRef[],
     registry: ModelRegistry,
     persist: boolean,
-  ): { ok: boolean; error?: string; twins?: string[] } {
+  ): { ok: boolean; error?: string; stack?: string; twins?: string[] } {
     const byProvider = new Map<string, string[]>();
     for (const ref of refs) {
       const list = byProvider.get(ref.provider) ?? [];
@@ -443,6 +443,7 @@ export default function (pi: ExtensionAPI) {
           return {
             ok: false,
             error: error instanceof Error ? error.message : String(error),
+            ...(error instanceof Error && error.stack ? { stack: error.stack } : {}),
           };
         }
         overlays.set(providerId, { twinIds: [...twinIds], live });
@@ -466,6 +467,7 @@ export default function (pi: ExtensionAPI) {
       return {
         ok: false,
         error: error instanceof Error ? error.message : String(error),
+        ...(error instanceof Error && error.stack ? { stack: error.stack } : {}),
       };
     }
   }
@@ -483,7 +485,7 @@ export default function (pi: ExtensionAPI) {
     );
     refs.push({ provider: providerId, model: modelId });
     const res = applyTwins(refs, registry, true);
-    if (!res.ok) return { ok: false, error: res.error };
+    if (!res.ok) return { ok: false, error: res.error, ...(res.stack ? { stack: res.stack } : {}) };
     return { ok: true, twin: `${providerId}/${twinIdFor(modelId)}` };
   }
 
@@ -709,6 +711,14 @@ export default function (pi: ExtensionAPI) {
       if (overlays.size === 0) {
         const restored = refreshUpstream(ctx.modelRegistry);
         if (!restored.ok) {
+          try {
+            pi.appendEntry("jev-refresh-upstream-error", {
+              error: restored.error,
+              ...(restored.stack ? { stack: String(restored.stack).slice(0, 4000) } : {}),
+            });
+          } catch {
+            // solo diagnostica
+          }
           if (ctx.hasUI) {
             ctx.ui.notify(`Jev automatic senza guarded: ${restored.error} (diagnostica sola).`, "warning");
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-jev-guard",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "type": "module",
   "description": "Jev validation guard for pi: on-demand tool + automatic provider gate. Dual backend: TypeSafe direct + OpenRouter.",
   "keywords": [

package/src/automatic/overlay.ts

@@ -134,8 +134,11 @@ function stripTwins(models: readonly Model<Api>[]): Model<Api>[] {
  * config restano quelle pubblicate dal proprietario (builtin o altre
  * estensioni come pi-accounts), quindi i loro controlli di ownership e i
  * loro snapshot non vedono mai una "configuration changed" e non armano
- * abort. Rieseguibile: se l'oggetto è già patchato riparte dai metodi
- * originali con la nuova lista twin. Ritorna gli id gemello pubblicati.
+ * abort. Rieseguibile: gli originali sono catturati una sola volta e mai
+ * mutati dopo (niente "adozione" di funzioni altrui: adottare un wrapper
+ * che delega al nostro causava ricorsione infinita). Il record vive anche
+ * su Symbol.for, così sopravvive al /reload che ricarica i moduli.
+ * Ritorna gli id gemello pubblicati.
  */
 export interface PatchDeps {
   /** Id modelli (originali) da gemellare. */
@@ -161,57 +164,175 @@ interface PatchedOriginals {
 }
 
 interface PatchRecord {
-  /** Originali veri (mai i nostri wrapper): evolve con le adozioni. */
+  /** Originali veri (mai i nostri wrapper, mai mutati dopo la cattura). */
   orig: PatchedOriginals;
-  /** I nostri wrapper, per distinguerli dalle riassegnazioni altrui. */
+  /** getModels catturata grezza (per unpatch pulito, senza schermi). */
+  rawGetModels: Provider["getModels"];
+  /** I nostri wrapper correnti. */
   wrapGetModels: Provider["getModels"];
+  /** Base sopra un wrapper legacy pre-marcatura: unpatch best-effort. */
+  legacy?: boolean;
+  legacyGetModels?: Provider["getModels"];
 }
 
 const patchedOriginals = new WeakMap<object, PatchRecord>();
 
-/** True se l'oggetto provider è attualmente patchato da noi. */
+/**
+ * Record oltre il /reload: pi ricarica le estensioni con moduleCache:false,
+ * quindi il WeakMap si azzera ma gli oggetti provider restano patchati con
+ * le closure vecchie. Symbol.for sopravvive tra le generazioni del modulo.
+ */
+const ORIGINALS_KEY = Symbol.for("pi-jev-guard.patch-originals.v1");
+/** Marca i nostri wrapper: mai usati come base. */
+const WRAP_MARK = Symbol.for("pi-jev-guard.wrap.v1");
+/** Guardia di rientranza per getModels (composizione con wrapper altrui). */
+const DEPTH_KEY = Symbol.for("pi-jev-guard.getmodels-depth.v1");
+
+function storedRecord(provider: Provider): PatchRecord | undefined {
+  return patchedOriginals.get(provider)
+    ?? (provider as unknown as Record<symbol, PatchRecord | undefined>)[ORIGINALS_KEY];
+}
+
+function storeRecord(provider: Provider, rec: PatchRecord): void {
+  patchedOriginals.set(provider, rec);
+  (provider as unknown as Record<symbol, PatchRecord>)[ORIGINALS_KEY] = rec;
+}
+
+function clearRecord(provider: Provider): void {
+  patchedOriginals.delete(provider);
+  try {
+    delete (provider as unknown as Record<symbol, unknown>)[ORIGINALS_KEY];
+  } catch {
+    // ignora
+  }
+}
+
+function isOurWrap(fn: unknown): boolean {
+  return typeof fn === "function"
+    && (fn as unknown as Record<symbol, unknown>)[WRAP_MARK] === true;
+}
+
+function markOurWrap<T extends object>(fn: T): T {
+  (fn as Record<symbol, unknown>)[WRAP_MARK] = true;
+  return fn;
+}
+
+function getDepth(provider: Provider): number {
+  const value = (provider as unknown as Record<symbol, unknown>)[DEPTH_KEY];
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+function setDepth(provider: Provider, depth: number): void {
+  (provider as unknown as Record<symbol, unknown>)[DEPTH_KEY] = depth;
+}
+
+function hasTwinIds(models: unknown): boolean {
+  return Array.isArray(models) && models.some(
+    (m) => m !== null && typeof m === "object"
+      && typeof (m as { id?: unknown }).id === "string"
+      && isTwinId((m as { id: string }).id),
+  );
+}
+
+/**
+ * True se l'oggetto provider è attualmente patchato da noi, anche da una
+ * generazione precedente al /reload (record su Symbol, non solo WeakMap).
+ */
 export function isPatched(provider: Provider): boolean {
-  return patchedOriginals.has(provider);
+  if (patchedOriginals.has(provider)) return true;
+  return Boolean(storedRecord(provider)?.orig);
 }
 
 export function patchProvider(provider: Provider, deps: PatchDeps): string[] {
-  const previous = patchedOriginals.get(provider);
-  const rawStream: unknown = previous
-    ? previous.orig.stream
-    : (provider as { stream?: unknown }).stream;
-  const base: PatchedOriginals = previous?.orig ?? {
-    // Raw, mai bind: invocati con this=provider al momento della chiamata.
-    getModels: provider.getModels,
-    stream: typeof rawStream === "function"
-      ? (rawStream as NonNullable<Provider["stream"]>)
-      : undefined,
-    streamSimple: provider.streamSimple,
-    ...(provider.refreshModels
-      ? { refreshModels: provider.refreshModels }
-      : {}),
-    ...(provider.filterModels
-      ? { filterModels: provider.filterModels }
-      : {}),
-  };
   const twinIds = [...deps.twinModelIds];
   const providerId = provider.id;
 
-  // Risoluzione pigra: legge SEMPRE i modelli correnti (nessuna snapshot
-  // che diventa stale dopo refresh altrui o cataloghi dinamici). Se il
-  // proprietario riassegna getModels dopo la patch, la nuova fn viene
-  // adottata come base (i nostri wrapper si riconoscono e non si adottano).
-  function currentBase(): PatchedOriginals {
-    const rec = patchedOriginals.get(provider);
-    const orig = rec?.orig ?? base;
-    const cur = provider.getModels as Provider["getModels"];
-    if (rec && cur !== rec.wrapGetModels && cur !== orig.getModels) {
-      orig.getModels = cur;
+  let rec = storedRecord(provider);
+  if (!rec) {
+    // Prima patch di questo oggetto (in qualsiasi generazione): cattura i
+    // metodi correnti come originali stabili, mai mutati dopo. Se sono un
+    // wrapper legacy (pre-marcatura, con twin), la schermatura sotto evita
+    // che la sua vecchia logica di "adozione" richiami il nuovo wrapper in
+    // ricorsione infinita (Maximum call stack size exceeded).
+    const capturedGetModels = provider.getModels;
+    const rawStream: unknown = (provider as { stream?: unknown }).stream;
+    let legacy = false;
+    try {
+      legacy = !isOurWrap(capturedGetModels) && hasTwinIds(capturedGetModels.call(provider));
+    } catch (error) {
+      if (error instanceof RangeError) {
+        throw new Error(
+          "Jev: catalogo provider in stato inconsistente dopo il reload (stack overflow durante il probe); riavvia pi per continuare.",
+        );
+      }
+      throw error;
     }
-    return orig;
+    // Schermo: durante la chiamata alla base, provider.getModels torna a
+    // essere la fn catturata, così un wrapper legacy vede se stesso e non
+    // adotta il nuovo wrapper. Per basi normali è una chiamata diretta.
+    const shieldedGetModels = (function (this: Provider) {
+      const installed = provider.getModels;
+      provider.getModels = capturedGetModels;
+      try {
+        return (capturedGetModels as Provider["getModels"]).call(provider);
+      } finally {
+        provider.getModels = installed;
+      }
+    }) as Provider["getModels"];
+    const orig: PatchedOriginals = {
+      // Raw, mai bind: invocati con this=provider al momento della chiamata.
+      getModels: shieldedGetModels,
+      stream: typeof rawStream === "function"
+        ? (rawStream as NonNullable<Provider["stream"]>)
+        : undefined,
+      streamSimple: provider.streamSimple,
+      ...(provider.refreshModels
+        ? { refreshModels: provider.refreshModels }
+        : {}),
+      ...(provider.filterModels
+        ? { filterModels: provider.filterModels }
+        : {}),
+    };
+    rec = {
+      orig,
+      rawGetModels: capturedGetModels,
+      wrapGetModels: capturedGetModels, // placeholder, sostituito sotto
+      ...(legacy
+        ? { legacy: true as const, legacyGetModels: capturedGetModels }
+        : {}),
+    };
+  }
+  // Const per le closure: il narrowing di `let` non sopravvive nelle closure.
+  const active: PatchRecord = rec;
+  const orig = active.orig;
+
+  function baseModels(): Model<Api>[] {
+    const out = orig.getModels.call(provider);
+    return Array.isArray(out) ? stripTwins(out) : [];
   }
 
+  // Originali correnti senza mai adottare funzioni altrui come base (la
+  // mutazione dell'originale era la causa della ricorsione infinita: un
+  // wrapper esterno che delega al nostro, adottato come base, richiama noi
+  // in loop). Se il proprietario riassegna getModels (cataloghi dinamici)
+  // o un'altra estensione avvolge lo stesso oggetto, deleghiamo per-chiamata
+  // sotto guardia di rientranza: il giro rientrante usa la base stabile.
   function currentOriginals(): Model<Api>[] {
-    return mergeModelsById(stripTwins(currentBase().getModels.call(provider)), []);
+    const cur = provider.getModels;
+    if (cur === active.wrapGetModels || isOurWrap(cur) || cur === orig.getModels) {
+      return mergeModelsById(baseModels(), []);
+    }
+    if (getDepth(provider) > 0) return mergeModelsById(baseModels(), []);
+    setDepth(provider, getDepth(provider) + 1);
+    try {
+      const out = (cur as Provider["getModels"]).call(provider);
+      return mergeModelsById(stripTwins(Array.isArray(out) ? out : []), []);
+    } catch (error) {
+      if (error instanceof RangeError) return mergeModelsById(baseModels(), []);
+      throw error;
+    } finally {
+      setDepth(provider, getDepth(provider) - 1);
+    }
   }
 
   function resolveTwin(modelId: string): Model<Api> | undefined {
@@ -221,8 +342,7 @@ export function patchProvider(provider: Provider, deps: PatchDeps): string[] {
     return currentOriginals().find((m) => m.id === wanted);
   }
 
-  function twinEntries(): Model<Api>[] {
-    const originals = currentOriginals();
+  function twinEntries(originals: Model<Api>[]): Model<Api>[] {
     const chosen = new Set(twinIds);
     const twins: Model<Api>[] = [];
     const seen = new Set<string>();
@@ -250,7 +370,9 @@ export function patchProvider(provider: Provider, deps: PatchDeps): string[] {
           ? { ...message, model: untwinId(message.model) }
           : message),
     };
-    return base.streamSimple.call(provider, model, originalContext, options);
+    // Solo id originali arrivano qui (il twin è già risolto sopra): anche
+    // sopra una base legacy il forward è un passthrough, mai un gate stantio.
+    return orig.streamSimple.call(provider, model, originalContext, options);
   }
 
   function guardedStreamSimple(
@@ -296,12 +418,15 @@ export function patchProvider(provider: Provider, deps: PatchDeps): string[] {
     });
   }
 
-  const wrapGetModels: Provider["getModels"] = () => [
-    ...currentOriginals().map((m) => ({ ...m })),
-    ...twinEntries(),
-  ];
+  const wrapGetModels = markOurWrap((() => {
+    const originals = currentOriginals();
+    return [
+      ...originals.map((m) => ({ ...m })),
+      ...twinEntries(originals),
+    ];
+  }) as Provider["getModels"]);
   provider.getModels = wrapGetModels;
-  if (base.stream) {
+  if (orig.stream) {
     provider.stream = ((model: any, context: any, options: any) =>
       guardedStreamSimple(
         model as Model<Api>,
@@ -314,9 +439,9 @@ export function patchProvider(provider: Provider, deps: PatchDeps): string[] {
 
   // Forward refresh con persist depurato dai twin: lo store è letto anche
   // dal builtin a overlay assente, che li scambierebbe per modelli normali
-  // (senza gate!). La risoluzione pigra non ha snapshot da ricostruire.
-  if (base.refreshModels) {
-    const upstreamRefresh = base.refreshModels;
+  // (senza gate!). Gli originali sono stabili: niente snapshot da ricostruire.
+  if (orig.refreshModels) {
+    const upstreamRefresh = orig.refreshModels;
     provider.refreshModels = (async (ctx: RefreshModelsContext): Promise<void> => {
       await upstreamRefresh.call(provider, {
         ...ctx,
@@ -343,8 +468,8 @@ export function patchProvider(provider: Provider, deps: PatchDeps): string[] {
 
   // Forward filtro credenziali: si applica agli originali, i twin seguono
   // il destino dell'originale corrispondente.
-  if (base.filterModels) {
-    const upstreamFilter = base.filterModels;
+  if (orig.filterModels) {
+    const upstreamFilter = orig.filterModels;
     provider.filterModels = ((
       models: readonly Model<Api>[],
       credential: Credential | undefined,
@@ -359,27 +484,38 @@ export function patchProvider(provider: Provider, deps: PatchDeps): string[] {
     }) as Provider["filterModels"];
   }
 
-  if (previous) {
-    // Re-patch: i wrapper si ricreano, gli originali veri restano.
-    // Aggiorna il riferimento al wrapper corrente o l'adozione
-    // scambierebbe il nuovo wrapper per una fn altrui.
-    previous.wrapGetModels = wrapGetModels;
-    patchedOriginals.set(provider, previous);
-  } else {
-    patchedOriginals.set(provider, { orig: base, wrapGetModels });
-  }
-  return twinEntries().map((t) => t.id);
+  // Re-patch: i wrapper si ricreano (nuova lista twin/closure), gli
+  // originali stabili restano. Il record è anche su Symbol: sopravvive al
+  // /reload e la nuova generazione riusa gli stessi originali.
+  active.wrapGetModels = wrapGetModels;
+  storeRecord(provider, active);
+  return twinEntries(currentOriginals()).map((t) => t.id);
 }
 
 /**
  * Ripristina i metodi originali. Ritorna false se l'oggetto non era patchato
- * (es. già sostituito dal proprietario: niente da ripristinare).
+ * (es. già sostituito dal proprietario: niente da ripristinare). Sopra una
+ * base legacy (pre-marcatura) il ripristino di getModels è best-effort con
+ * schermatura: i twin spariscono dal catalogo; un riavvio di pi pulisce tutto.
  */
 export function unpatchProvider(provider: Provider): boolean {
-  const rec = patchedOriginals.get(provider);
+  const rec = storedRecord(provider);
   const originals = rec?.orig;
-  if (!originals) return false;
-  provider.getModels = originals.getModels;
+  if (!rec || !originals) return false;
+  if (rec.legacy && rec.legacyGetModels) {
+    const legacyFn = rec.legacyGetModels;
+    provider.getModels = (function (this: Provider) {
+      const installed = provider.getModels;
+      provider.getModels = legacyFn;
+      try {
+        return stripTwins(legacyFn.call(provider));
+      } finally {
+        provider.getModels = installed;
+      }
+    }) as Provider["getModels"];
+  } else {
+    provider.getModels = rec.rawGetModels;
+  }
   if (originals.stream) provider.stream = originals.stream;
   else delete (provider as { stream?: unknown }).stream;
   provider.streamSimple = originals.streamSimple;
@@ -387,6 +523,6 @@ export function unpatchProvider(provider: Provider): boolean {
   else delete (provider as { refreshModels?: unknown }).refreshModels;
   if (originals.filterModels) provider.filterModels = originals.filterModels;
   else delete (provider as { filterModels?: unknown }).filterModels;
-  patchedOriginals.delete(provider);
+  clearRecord(provider);
   return true;
 }

package/src/commands.ts

@@ -40,6 +40,8 @@ export interface TwinStatusView {
 export interface UpstreamResult {
   ok: boolean;
   error?: string;
+  /** Stack per la diagnostica (entry jev-refresh-upstream-error), mai all'utente. */
+  stack?: string;
   twin?: string;
 }