local-operator-ui 0.25.7 → 0.25.8

package/out/main/index.js

@@ -8125,9 +8125,6 @@ function receiptFor(entry, state, now) {
     expiresAt: now + ACCESS_RESULT_TTL_MS
   };
 }
-function receiptForRequester(results, origin, requester, now) {
-  return Object.values(cleanResults(results, now)).filter((receipt) => receipt.origin === origin && receipt.requester === requester).sort((a, b) => b.decidedAt - a.decidedAt)[0];
-}
 const APPROVALS_FILENAME = "approvals.json";
 function emptyStore() {
   return {
@@ -8244,17 +8241,13 @@ class ApprovalStore {
    * `request_access` → tells the user → `await_access`.
    */
   ensureTopLevelAccess(url, requester) {
-    if (this.originAllowed(url)) return { allowed: true, viaOnceGrant: false };
-    const grant = consumableGrant(
-      this.onceGrants,
-      url.origin,
-      requester,
-      this.now()
-    );
-    if (grant) {
-      delete this.onceGrants[url.origin];
-      this.persistIfChanged();
-      return { allowed: true, viaOnceGrant: true };
+    const authority = this.liveAuthority(url, requester);
+    if (authority) {
+      if (authority.viaOnceGrant) {
+        delete this.onceGrants[url.origin];
+        this.persistIfChanged();
+      }
+      return { allowed: true, viaOnceGrant: authority.viaOnceGrant };
     }
     throw new BridgeCommandError(
       "origin_not_allowed",
@@ -8266,6 +8259,35 @@ class ApprovalStore {
       }
     );
   }
+  /**
+   * The live authority for one origin and requester, WITHOUT consuming it.
+   *
+   * THE SINGLE SOURCE OF TRUTH, and the fix for a shipped consent defect: the
+   * gate and `request_access` used to answer from two different places —
+   * `ensureTopLevelAccess` from the grant, `requestAccess` from a resolved
+   * RECEIPT — and a receipt outlives the grant it was written for (its 15-minute
+   * `ACCESS_RESULT_TTL_MS` against the 10-minute once-grant TTL), so
+   * `request_access` answered `allowed` for a navigation the very next `open`
+   * refused with `origin_not_allowed`, and raised no band while doing it: the
+   * request was dropped without ever being put back to the user. Same pair
+   * after a revocation, where the receipt outlives the grant by however long it
+   * had left to run.
+   *
+   * `originAllowed` is the durable verdict plus the session grants; the second
+   * term is an UNSPENT `once` grant bound to this requester, which the gate
+   * consumes and this does not. Everything else is not authority: a spent grant,
+   * a revoked one, a receipt for either.
+   */
+  liveAuthority(url, requester) {
+    if (this.originAllowed(url)) return { viaOnceGrant: false };
+    const grant = consumableGrant(
+      this.onceGrants,
+      url.origin,
+      requester,
+      this.now()
+    );
+    return grant ? { viaOnceGrant: true } : null;
+  }
   /** Admission is captured once, but revocation remains authoritative while an
    * asynchronous navigation is in flight. A receipt is never transferable. */
   admit(url, requester) {
@@ -8318,29 +8340,24 @@ class ApprovalStore {
    * The rules are `vendor/driver/access-flow.ts`'s, applied to the queue: a repeat
    * request for the same origin by the same requester is idempotent with its
    * original TTL, a request for a different origin REPLACES the live one (with
-   * a tombstone for the displaced requester), and a live deny receipt answers
-   * "denied" without re-prompting until its cool-down expires.
+   * a tombstone for the displaced requester), and a DURABLE denial answers
+   * "denied" without re-prompting, because that is what the button promises —
+   * "Don't allow" says the agent stops asking about this site until the denial is
+   * revoked.
    */
   requestAccess(rawUrl, requester, kind = "async", commandId) {
     const url = safeHttpUrl(rawUrl);
     const now = this.now();
-    if (this.originAllowed(url)) {
+    if (this.liveAuthority(url, requester)) {
       return { origin: url.origin, state: "allowed" };
     }
+    if (this.refusalReason(url) === "denied") {
+      return { origin: url.origin, state: "denied" };
+    }
     const existing = findPending(this.queue, url.origin, requester, kind, now);
     if (existing) {
       return this.entryResponse(existing, "pending");
     }
-    const receipt = receiptForRequester(
-      this.results,
-      url.origin,
-      requester,
-      now
-    );
-    if (receipt && receipt.state !== "superseded") {
-      const state = receipt.state === "denied" ? "denied" : "allowed";
-      return { origin: url.origin, state, entry_id: receipt.entryId };
-    }
     this.sweep(now);
     if (liveQueue(this.queue, now).length >= ACCESS_QUEUE_CAP) {
       throw new BridgeCommandError(
@@ -8396,8 +8413,21 @@ class ApprovalStore {
         hostname: entry.displayAuthority,
         requester: entry.requester,
         requestedAt: entry.requestedAt,
-        expiresAt: entry.expiresAt,
-        ...this.decisionFor(entry) ? { decision: this.decisionFor(entry) } : {}
+        expiresAt: entry.expiresAt
+        /*
+         * NO `decision` TERM, and the removal is the point. The vendored
+         * `accessState()` takes an optional decision so that a LIVE record can read
+         * `allowed`/`denied` before the grant lands, and this host fed it from the
+         * decision receipts — but every arm that writes a receipt removes its entry
+         * from the queue FIRST (`respond` filters, `cancelAccess` splices), entry ids
+         * are minted per entry and nothing here is restored from disk, so a record
+         * with a decision can never be the record this reads. It was unreachable code
+         * carrying the residue of the defect this fix closes, and a reader would
+         * reasonably infer from it that a receipt can still answer. It cannot:
+         * `requestAccess` answers from `liveAuthority` and from a durable verdict, and
+         * the receipts are the store's record of what was decided (swept by TTL)
+         * rather than a reader's source.
+         */
       } : void 0,
       this.tombstones,
       this.originAllowed(url),
@@ -8406,6 +8436,9 @@ class ApprovalStore {
       requester,
       now
     );
+    if (state === "none" && this.refusalReason(url) === "denied") {
+      return { origin: url.origin, state: "denied" };
+    }
     return {
       origin: url.origin,
       state,
@@ -8668,13 +8701,6 @@ class ApprovalStore {
     this.onChanged();
   }
   // ---- internals -----------------------------------------------------------
-  decisionFor(entry) {
-    const receipt = this.results[resultKey(entry.entryId, entry.requester)];
-    if (!receipt) return void 0;
-    if (receipt.state === "denied") return "deny";
-    if (receipt.state === "allowed") return "site";
-    return void 0;
-  }
   /** Replace-don't-queue: the live entry for another origin (or another
    * requester) is displaced, and its requester gets a tombstone so its next poll
    * reads "superseded" rather than the neutral "none". */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-operator-ui",
-  "version": "0.25.7",
+  "version": "0.25.8",
   "productName": "Local Operator",
   "description": "User interface for AI agent assistants that run Python code safely on your device through an intuitive chat interface. Supports local and cloud LLM models with built-in security features.",
   "main": "./out/main/index.js",