npm - @integrity-labs/agt-cli - Versions diffs - 0.28.521 → 0.28.522 - Mend

@integrity-labs/agt-cli 0.28.521 → 0.28.522

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/dist/mcp/slack-channel.js CHANGED Viewed

@@ -32362,6 +32362,11 @@ var MARKUP_BRIDGE_SCRIPT = `<script>(function(){
   var commentEnabled = false; // armed when the viewer may comment (ENG-6847 right-click)
   var editing = null;         // the element currently in edit mode
   var bar = null;             // the Save/Cancel toolbar
+  // ENG-8477: the viewer has explicitly turned editing ON from the shell. Only
+  // then does the bridge look underneath the artefact's own overlays. See the
+  // long note on the window-capture click handler for why this is a mode and
+  // not just always-on.
+  var editMode = false;
   // Element-child indices from <body> down to el. Counts ELEMENT children only
   // (children, not childNodes), matching how the server walks source_html; our
@@ -32416,6 +32421,55 @@ var MARKUP_BRIDGE_SCRIPT = `<script>(function(){
       return null;
     }catch(e){ return null; }
   }
+  // ENG-8477: the topmost element under the pointer that we could actually edit,
+  // looking THROUGH anything the artefact has laid over its own content.
+  //
+  // elementsFromPoint returns the full hit stack, front to back. We walk it from
+  // the front and take the first genuinely editable element, skipping our own
+  // injected UI. An artefact overlay is skipped for free: it is an empty div, so
+  // editable() rejects it on the text check and we keep walking.
+  //
+  // Returns null when there is nothing editable under the pointer at all, which
+  // is the signal to leave the click completely alone.
+  function editableAtPoint(x,y){
+    var stack;
+    try{ stack=document.elementsFromPoint(x,y)||[]; }catch(e){ return null; }
+    for(var i=0;i<stack.length;i++){
+      var el=stack[i];
+      if(!el || el.nodeType!==1) continue;
+      if(el.closest && el.closest('[data-al-noedit]')) continue; // our toolbar, not content
+      if(editable(el)||inlineOnlyEditable(el)) return el;
+    }
+    return null;
+  }
+  // The caret probe (caretRangeFromPoint) reports on the TOPMOST element at the
+  // point, so an overlay swallows it exactly as it swallows the click - it hands
+  // back the overlay div, not the text underneath. Neutralise everything stacked
+  // above the target for the length of the probe, then put it back. The restore
+  // is in a finally and runs before the browser can paint, so nothing flickers
+  // and no artefact state is left modified.
+  // This re-queries elementsFromPoint rather than reusing the caller's stack, so
+  // target is NOT guaranteed to still be in it. Find target's index first and
+  // mute only the prefix in front of it: a not-found target must fall back to the
+  // plain probe, because muting the whole stack would neutralise target and its
+  // ancestors too - a wider style mutation than intended, for a probe whose
+  // result the caller then rejects anyway.
+  function textNodeAtPointThrough(x,y,target){
+    var stack;
+    try{ stack=document.elementsFromPoint(x,y)||[]; }catch(e){ return textNodeAtPoint(x,y); }
+    var cut=-1, i;
+    for(i=0;i<stack.length;i++){ if(stack[i]===target){ cut=i; break; } }
+    if(cut<0) return textNodeAtPoint(x,y);
+    var muted=[];
+    for(i=0;i<cut;i++){
+      muted.push([stack[i], stack[i].style ? stack[i].style.pointerEvents : '']);
+      try{ stack[i].style.pointerEvents='none'; }catch(e){}
+    }
+    try{ return textNodeAtPoint(x,y); }
+    finally{
+      for(i=0;i<muted.length;i++){ try{ muted[i][0].style.pointerEvents=muted[i][1]||''; }catch(e){} }
+    }
+  }
   // Index of a text node among its parent's child TEXT nodes, in order - the same
   // counting the server uses to re-locate it in source_html (ENG-6856).
   function textIndexOf(container, tn){
@@ -32525,6 +32579,105 @@ var MARKUP_BRIDGE_SCRIPT = `<script>(function(){
       e.preventDefault(); e.stopPropagation(); startEditTextNode(tn, el);
     }
   }, true);
+  // ENG-8477: reach content the artefact covers with its OWN overlay.
+  //
+  // A deck built from the canonical template lays two full-viewport click zones
+  // over its slides (.clickzone, position:fixed, z-index:40) to page forward and
+  // back. The template's own comment says it plainly: "the click zones sit above
+  // slide content by design, so any interactive element inside a slide needs
+  // position:relative + a higher z-index to stay clickable". Slide TEXT is not an
+  // interactive element and never gets one.
+  //
+  // So every click a viewer aimed at a paragraph landed on #zone-prev/#zone-next.
+  // The handler above read e.target, got an empty div, editable() rejected it on
+  // the text check, and no editor opened - while the zone's own handler paged the
+  // deck. A single-page artefact has no zones and the identical bridge works
+  // perfectly on it, which is precisely why editing "works in web page formats
+  // but not decks". Verified on real published content, not just the template.
+  //
+  // Why a MODE rather than always-on. One press cannot mean both "page the deck"
+  // and "edit this text". The zones are the deck's primary navigation, so
+  // silently stealing clicks from them would trade one broken gesture for
+  // another. The shell gives an armed viewer an explicit Edit-text toggle; until
+  // they turn it on, every line below is inert and the artefact behaves exactly
+  // as it does today. Anonymous viewers never arm at all.
+  //
+  // Why window + capture. Same phase argument as ENG-8500: the artefact's script
+  // is appended before the bridge, so registration order cannot be won, but the
+  // capture path runs window -> document -> ... -> target and therefore beats a
+  // handler bound to the zone itself no matter when it was registered.
+  // stopImmediatePropagation then keeps the deck from also paging.
+  //
+  // Deliberately general: nothing here knows about .clickzone or any class name.
+  // It fixes any artefact that covers its own content.
+  window.addEventListener('click', function(e){
+    if(!editEnabled || !editMode || editing) return;
+    var sel=document.getSelection(); if(sel && String(sel).trim()) return; // selection => comment flow
+    var t=e.target;
+    // Our own toolbar (Save/Cancel) must keep its clicks.
+    if(t && t.closest && t.closest('[data-al-noedit]')) return;
+    // Already directly on editable content: the document-level handler above
+    // covers it, and duplicating the work here would start the edit twice.
+    if(editable(t)||inlineOnlyEditable(t)) return;
+    var el=editableAtPoint(e.clientX, e.clientY);
+    // Nothing editable under the pointer - leave the click completely alone so
+    // click-to-page still works while the viewer is moving between slides.
+    if(!el) return;
+    // Suppress ONLY once an edit is actually starting. Suppressing up front left
+    // the inline-only fallback below as a dead click: no editor opened AND the
+    // deck could not page, because the event was already stopped.
+    if(editable(el)){ e.preventDefault(); e.stopImmediatePropagation(); startEdit(el); return; }
+    var tn=textNodeAtPointThrough(e.clientX, e.clientY, el);
+    if(tn && tn.parentElement===el && (tn.nodeValue||'').trim()){
+      e.preventDefault(); e.stopImmediatePropagation(); startEditTextNode(tn, el); return;
+    }
+    // An inline-only container whose exact text run we could not resolve (no
+    // caret API, or the point fell between runs). Editing the whole container
+    // would flatten its nested markup, so leave the click to the artefact and
+    // let it page as it normally would.
+  }, true);
+  // ENG-8477: the same deck template pulls focus back to the document on every
+  // pointer press, to keep its arrow keys working when the iframe loses focus:
+  //
+  //   function grabFocus(){ try{ window.focus(); document.body.focus(); }catch(e){} }
+  //   addEventListener('pointerdown', grabFocus);
+  //
+  // A bare addEventListener at artefact top level is window + bubble phase, so a
+  // window CAPTURE listener still gets there first. Without this guard, clicking
+  // into an open editor to place the caret hands focus straight to <body> and the
+  // viewer cannot type - a second, independent breaker that would have survived
+  // the overlay fix on its own.
+  //
+  // Scoped as tightly as it can be: only while an edit is open, and only for a
+  // press that lands inside the editor. A press anywhere else is the viewer
+  // leaving, and the artefact keeps it.
+  window.addEventListener('pointerdown', function(e){
+    if(!editing) return;
+    var t=e.target;
+    if(t!==editing && !(editing.contains && t && t.nodeType && editing.contains(t))) return;
+    e.stopImmediatePropagation();
+  }, true);
+  // ENG-8477: the hover affordance has the same blind spot as the click did -
+  // mouseover reports the overlay, so a viewer in edit mode would get no cue that
+  // slide text can be edited at all. Probing the stack on every mousemove would
+  // be wasteful, so this only runs in edit mode, only when the direct target is
+  // not already editable (that case the mouseover handler above still covers),
+  // and no more than once per ~80ms.
+  var hoverProbeAt=0, hoverEl=null;
+  function clearDeepHover(){
+    if(hoverEl && hoverEl!==editing && hoverEl.__alHover){ try{ hoverEl.style.outline=''; }catch(e){} hoverEl.__alHover=0; }
+    hoverEl=null;
+  }
+  document.addEventListener('mousemove', function(e){
+    if(!editEnabled || !editMode || editing){ clearDeepHover(); return; }
+    var t=e.target;
+    if(editable(t)||inlineOnlyEditable(t)){ clearDeepHover(); return; }
+    var now=Date.now(); if(now-hoverProbeAt<80) return; hoverProbeAt=now;
+    var el=editableAtPoint(e.clientX, e.clientY);
+    if(el===hoverEl) return;
+    clearDeepHover();
+    if(el){ try{ el.style.outline=el.style.outline||'1px dashed rgba(110,231,183,.6)'; }catch(e){} el.__alHover=1; hoverEl=el; }
+  });
   // ENG-8500: while the inline editor is focused, the artefact's OWN keyboard
   // handlers must not see the keystroke.
   //
@@ -32616,6 +32769,13 @@ var MARKUP_BRIDGE_SCRIPT = `<script>(function(){
     var d=e.data; if(!d || d['${MARKUP_CONTROL_MARKER}']!==true) return;
     if(d.type==='enable-edit'){ editEnabled=true; }
     else if(d.type==='enable-comment'){ commentEnabled=true; }
+    // ENG-8477: the viewer toggled Edit text in the shell. Turning it OFF must
+    // also close anything open and drop the hover cue, or the artefact is left
+    // wearing our outlines with no way to clear them.
+    else if(d.type==='set-edit-mode'){
+      editMode = !!d.on;
+      if(!editMode){ if(editing) endEdit(false); clearDeepHover(); }
+    }
     else if(d.type==='edit-result'){
       if(d.ok){ /* republish hot-swaps the iframe; nothing to do */ }
       else { /* leave the (now non-editable) text; the published version is the source of truth */ }

package/dist/mcp/telegram-channel.js CHANGED Viewed

@@ -32688,6 +32688,11 @@ var MARKUP_BRIDGE_SCRIPT = `<script>(function(){
   var commentEnabled = false; // armed when the viewer may comment (ENG-6847 right-click)
   var editing = null;         // the element currently in edit mode
   var bar = null;             // the Save/Cancel toolbar
+  // ENG-8477: the viewer has explicitly turned editing ON from the shell. Only
+  // then does the bridge look underneath the artefact's own overlays. See the
+  // long note on the window-capture click handler for why this is a mode and
+  // not just always-on.
+  var editMode = false;
   // Element-child indices from <body> down to el. Counts ELEMENT children only
   // (children, not childNodes), matching how the server walks source_html; our
@@ -32742,6 +32747,55 @@ var MARKUP_BRIDGE_SCRIPT = `<script>(function(){
       return null;
     }catch(e){ return null; }
   }
+  // ENG-8477: the topmost element under the pointer that we could actually edit,
+  // looking THROUGH anything the artefact has laid over its own content.
+  //
+  // elementsFromPoint returns the full hit stack, front to back. We walk it from
+  // the front and take the first genuinely editable element, skipping our own
+  // injected UI. An artefact overlay is skipped for free: it is an empty div, so
+  // editable() rejects it on the text check and we keep walking.
+  //
+  // Returns null when there is nothing editable under the pointer at all, which
+  // is the signal to leave the click completely alone.
+  function editableAtPoint(x,y){
+    var stack;
+    try{ stack=document.elementsFromPoint(x,y)||[]; }catch(e){ return null; }
+    for(var i=0;i<stack.length;i++){
+      var el=stack[i];
+      if(!el || el.nodeType!==1) continue;
+      if(el.closest && el.closest('[data-al-noedit]')) continue; // our toolbar, not content
+      if(editable(el)||inlineOnlyEditable(el)) return el;
+    }
+    return null;
+  }
+  // The caret probe (caretRangeFromPoint) reports on the TOPMOST element at the
+  // point, so an overlay swallows it exactly as it swallows the click - it hands
+  // back the overlay div, not the text underneath. Neutralise everything stacked
+  // above the target for the length of the probe, then put it back. The restore
+  // is in a finally and runs before the browser can paint, so nothing flickers
+  // and no artefact state is left modified.
+  // This re-queries elementsFromPoint rather than reusing the caller's stack, so
+  // target is NOT guaranteed to still be in it. Find target's index first and
+  // mute only the prefix in front of it: a not-found target must fall back to the
+  // plain probe, because muting the whole stack would neutralise target and its
+  // ancestors too - a wider style mutation than intended, for a probe whose
+  // result the caller then rejects anyway.
+  function textNodeAtPointThrough(x,y,target){
+    var stack;
+    try{ stack=document.elementsFromPoint(x,y)||[]; }catch(e){ return textNodeAtPoint(x,y); }
+    var cut=-1, i;
+    for(i=0;i<stack.length;i++){ if(stack[i]===target){ cut=i; break; } }
+    if(cut<0) return textNodeAtPoint(x,y);
+    var muted=[];
+    for(i=0;i<cut;i++){
+      muted.push([stack[i], stack[i].style ? stack[i].style.pointerEvents : '']);
+      try{ stack[i].style.pointerEvents='none'; }catch(e){}
+    }
+    try{ return textNodeAtPoint(x,y); }
+    finally{
+      for(i=0;i<muted.length;i++){ try{ muted[i][0].style.pointerEvents=muted[i][1]||''; }catch(e){} }
+    }
+  }
   // Index of a text node among its parent's child TEXT nodes, in order - the same
   // counting the server uses to re-locate it in source_html (ENG-6856).
   function textIndexOf(container, tn){
@@ -32851,6 +32905,105 @@ var MARKUP_BRIDGE_SCRIPT = `<script>(function(){
       e.preventDefault(); e.stopPropagation(); startEditTextNode(tn, el);
     }
   }, true);
+  // ENG-8477: reach content the artefact covers with its OWN overlay.
+  //
+  // A deck built from the canonical template lays two full-viewport click zones
+  // over its slides (.clickzone, position:fixed, z-index:40) to page forward and
+  // back. The template's own comment says it plainly: "the click zones sit above
+  // slide content by design, so any interactive element inside a slide needs
+  // position:relative + a higher z-index to stay clickable". Slide TEXT is not an
+  // interactive element and never gets one.
+  //
+  // So every click a viewer aimed at a paragraph landed on #zone-prev/#zone-next.
+  // The handler above read e.target, got an empty div, editable() rejected it on
+  // the text check, and no editor opened - while the zone's own handler paged the
+  // deck. A single-page artefact has no zones and the identical bridge works
+  // perfectly on it, which is precisely why editing "works in web page formats
+  // but not decks". Verified on real published content, not just the template.
+  //
+  // Why a MODE rather than always-on. One press cannot mean both "page the deck"
+  // and "edit this text". The zones are the deck's primary navigation, so
+  // silently stealing clicks from them would trade one broken gesture for
+  // another. The shell gives an armed viewer an explicit Edit-text toggle; until
+  // they turn it on, every line below is inert and the artefact behaves exactly
+  // as it does today. Anonymous viewers never arm at all.
+  //
+  // Why window + capture. Same phase argument as ENG-8500: the artefact's script
+  // is appended before the bridge, so registration order cannot be won, but the
+  // capture path runs window -> document -> ... -> target and therefore beats a
+  // handler bound to the zone itself no matter when it was registered.
+  // stopImmediatePropagation then keeps the deck from also paging.
+  //
+  // Deliberately general: nothing here knows about .clickzone or any class name.
+  // It fixes any artefact that covers its own content.
+  window.addEventListener('click', function(e){
+    if(!editEnabled || !editMode || editing) return;
+    var sel=document.getSelection(); if(sel && String(sel).trim()) return; // selection => comment flow
+    var t=e.target;
+    // Our own toolbar (Save/Cancel) must keep its clicks.
+    if(t && t.closest && t.closest('[data-al-noedit]')) return;
+    // Already directly on editable content: the document-level handler above
+    // covers it, and duplicating the work here would start the edit twice.
+    if(editable(t)||inlineOnlyEditable(t)) return;
+    var el=editableAtPoint(e.clientX, e.clientY);
+    // Nothing editable under the pointer - leave the click completely alone so
+    // click-to-page still works while the viewer is moving between slides.
+    if(!el) return;
+    // Suppress ONLY once an edit is actually starting. Suppressing up front left
+    // the inline-only fallback below as a dead click: no editor opened AND the
+    // deck could not page, because the event was already stopped.
+    if(editable(el)){ e.preventDefault(); e.stopImmediatePropagation(); startEdit(el); return; }
+    var tn=textNodeAtPointThrough(e.clientX, e.clientY, el);
+    if(tn && tn.parentElement===el && (tn.nodeValue||'').trim()){
+      e.preventDefault(); e.stopImmediatePropagation(); startEditTextNode(tn, el); return;
+    }
+    // An inline-only container whose exact text run we could not resolve (no
+    // caret API, or the point fell between runs). Editing the whole container
+    // would flatten its nested markup, so leave the click to the artefact and
+    // let it page as it normally would.
+  }, true);
+  // ENG-8477: the same deck template pulls focus back to the document on every
+  // pointer press, to keep its arrow keys working when the iframe loses focus:
+  //
+  //   function grabFocus(){ try{ window.focus(); document.body.focus(); }catch(e){} }
+  //   addEventListener('pointerdown', grabFocus);
+  //
+  // A bare addEventListener at artefact top level is window + bubble phase, so a
+  // window CAPTURE listener still gets there first. Without this guard, clicking
+  // into an open editor to place the caret hands focus straight to <body> and the
+  // viewer cannot type - a second, independent breaker that would have survived
+  // the overlay fix on its own.
+  //
+  // Scoped as tightly as it can be: only while an edit is open, and only for a
+  // press that lands inside the editor. A press anywhere else is the viewer
+  // leaving, and the artefact keeps it.
+  window.addEventListener('pointerdown', function(e){
+    if(!editing) return;
+    var t=e.target;
+    if(t!==editing && !(editing.contains && t && t.nodeType && editing.contains(t))) return;
+    e.stopImmediatePropagation();
+  }, true);
+  // ENG-8477: the hover affordance has the same blind spot as the click did -
+  // mouseover reports the overlay, so a viewer in edit mode would get no cue that
+  // slide text can be edited at all. Probing the stack on every mousemove would
+  // be wasteful, so this only runs in edit mode, only when the direct target is
+  // not already editable (that case the mouseover handler above still covers),
+  // and no more than once per ~80ms.
+  var hoverProbeAt=0, hoverEl=null;
+  function clearDeepHover(){
+    if(hoverEl && hoverEl!==editing && hoverEl.__alHover){ try{ hoverEl.style.outline=''; }catch(e){} hoverEl.__alHover=0; }
+    hoverEl=null;
+  }
+  document.addEventListener('mousemove', function(e){
+    if(!editEnabled || !editMode || editing){ clearDeepHover(); return; }
+    var t=e.target;
+    if(editable(t)||inlineOnlyEditable(t)){ clearDeepHover(); return; }
+    var now=Date.now(); if(now-hoverProbeAt<80) return; hoverProbeAt=now;
+    var el=editableAtPoint(e.clientX, e.clientY);
+    if(el===hoverEl) return;
+    clearDeepHover();
+    if(el){ try{ el.style.outline=el.style.outline||'1px dashed rgba(110,231,183,.6)'; }catch(e){} el.__alHover=1; hoverEl=el; }
+  });
   // ENG-8500: while the inline editor is focused, the artefact's OWN keyboard
   // handlers must not see the keystroke.
   //
@@ -32942,6 +33095,13 @@ var MARKUP_BRIDGE_SCRIPT = `<script>(function(){
     var d=e.data; if(!d || d['${MARKUP_CONTROL_MARKER}']!==true) return;
     if(d.type==='enable-edit'){ editEnabled=true; }
     else if(d.type==='enable-comment'){ commentEnabled=true; }
+    // ENG-8477: the viewer toggled Edit text in the shell. Turning it OFF must
+    // also close anything open and drop the hover cue, or the artefact is left
+    // wearing our outlines with no way to clear them.
+    else if(d.type==='set-edit-mode'){
+      editMode = !!d.on;
+      if(!editMode){ if(editing) endEdit(false); clearDeepHover(); }
+    }
     else if(d.type==='edit-result'){
       if(d.ok){ /* republish hot-swaps the iframe; nothing to do */ }
       else { /* leave the (now non-editable) text; the published version is the source of truth */ }

package/dist/{persistent-session-DNENZXT4.js → persistent-session-5GMZKV37.js} RENAMED Viewed

@@ -37,7 +37,7 @@ import {
   writeDirectChatSessionState,
   writeEgressAllowlist,
   writePersistentClaudeWrapper
-} from "./chunk-STNEJC5S.js";
+} from "./chunk-4GTDD2I5.js";
 import "./chunk-XWVM4KPK.js";
 export {
   EGRESS_BASELINE_DOMAINS,
@@ -79,4 +79,4 @@ export {
   writeEgressAllowlist,
   writePersistentClaudeWrapper
 };
-//# sourceMappingURL=persistent-session-DNENZXT4.js.map
+//# sourceMappingURL=persistent-session-5GMZKV37.js.map

package/dist/{responsiveness-probe-V7CP5ML3.js → responsiveness-probe-52IZOP2M.js} RENAMED Viewed

@@ -1,6 +1,6 @@
 import {
   paneLogPath
-} from "./chunk-STNEJC5S.js";
+} from "./chunk-4GTDD2I5.js";
 import "./chunk-XWVM4KPK.js";
 // src/lib/responsiveness-probe.ts
@@ -662,4 +662,4 @@ export {
   readAndResetSlackReplyBindingClassifications,
   readAndResetSlackReplyTargetClassifications
 };
-//# sourceMappingURL=responsiveness-probe-V7CP5ML3.js.map
+//# sourceMappingURL=responsiveness-probe-52IZOP2M.js.map

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@integrity-labs/agt-cli",
-  "version": "0.28.521",
+  "version": "0.28.522",
   "description": "Augmented Team CLI — agent provisioning and management",
   "type": "module",
   "engines": {