npm - @surething/cockpit - Versions diffs - 1.0.244 → 1.0.246 - Mend

@surething/cockpit 1.0.244 → 1.0.246

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 (710) hide show

package/.next-prod/server/chunks/4916.js ADDED Viewed

@@ -0,0 +1,368 @@
+"use strict";exports.id=4916,exports.ids=[4916],exports.modules={66106:(a,b,c)=>{c.d(b,{J4:()=>f,OP:()=>i,Z1:()=>e,qI:()=>h});let d=`
+(function () {
+  if (window.cockpit) return;
+  // Language — parked on <html data-cockpit-lang>, NOT delivered by listener
+  // alone. The host pushes cockpit:language-change once, on the iframe's load
+  // event. Anything registering a listener later misses it forever, and the
+  // widget bundles (/html-lib markdown / json / pdf) are lazily fetched — they
+  // always register after load, so they used to fall back to navigator.language
+  // and disagree with the Cockpit setting until the user toggled it. This script
+  // is injected at the very start of <head>, so it is guaranteed to be listening
+  // first; parking the value turns a one-shot message into order-independent
+  // state any later reader can just read.
+  //
+  // A DEDICATED attribute, not <html lang>: pages ship their own lang="en" (the
+  // built-in file-viewer does), so <html lang> cannot distinguish "the host told
+  // us" from "the document's own default" — reading it would pin every reader to
+  // the page's hardcoded value and silently kill the navigator fallback.
+  var applyLang = function (lang) {
+    if (!lang) return;
+    try {
+      document.documentElement.setAttribute('data-cockpit-lang', lang);
+      document.documentElement.lang = lang;   // keep the document honest for a11y
+    } catch (e) {}
+  };
+  window.addEventListener('message', function (ev) {
+    var d = ev && ev.data;
+    if (d && d.type === 'cockpit:language-change') applyLang(d.lang);
+  });
+  // Theme — OPT-IN. The floating top-right toggle + any .dark class management
+  // happen ONLY when the page declares <meta name="cockpit-theme" content="...">.
+  // Rationale: injection is by file type, not by SDK usage, so plain one-off pages
+  // (notes, reports) with no dark styling used to get a dead button that toggled a
+  // .dark class nothing responds to. Requiring an explicit opt-in marker keeps the
+  // button off those pages, while apps that provide :root/.dark tokens just add the
+  // meta to get a free host-managed toggle — no per-app button code needed.
+  //   content="auto"  → first load with no stored choice follows the OS preference
+  //   content="light" → first load defaults to light (still user-toggleable)
+  //   content="dark"  → first load defaults to dark
+  // The user's explicit toggle is REMEMBERED per app (key namespaced by cockpit-name,
+  // else page path) across reloads, and wins over the content default on next load.
+  // localStorage is SHARED with Cockpit + every other app, hence the namespaced key.
+  // Apps can also drive it programmatically via window.cockpit.toggleTheme().
+  var toggleTheme = function () {};
+  var initTheme = function () {
+  try {
+    var themeMeta = function (n) {
+      var el = document.querySelector('meta[name="' + n + '"]');
+      return el ? el.content : '';
+    };
+    var themeSetting = (themeMeta('cockpit-theme') || '').toLowerCase().trim();
+    if (themeSetting) {
+      var themeKey = 'htmlapp-theme:' + (themeMeta('cockpit-name') || location.pathname);
+      // Store the explicit choice both ways so it round-trips regardless of the
+      // content default (a bare "store only dark" model would lose a user's light
+      // choice under content="auto" on a dark OS).
+      var themeStore = function (d) {
+        try { localStorage.setItem(themeKey, d ? 'dark' : 'light'); } catch (e) {}
+      };
+      var themeBtn = null;
+      var setDark = function (d, persist) {
+        document.documentElement.classList.toggle('dark', !!d);
+        if (persist) themeStore(!!d);
+        if (themeBtn) themeBtn.textContent = d ? '☀️' : '\u{1F319}';
+      };
+      toggleTheme = function () {
+        setDark(!document.documentElement.classList.contains('dark'), true);
+      };
+      // Init: remembered user choice wins; else the content default; "auto" follows OS.
+      var stored = null;
+      try { stored = localStorage.getItem(themeKey); } catch (e) {}
+      var initDark;
+      if (stored === 'dark' || stored === 'light') initDark = stored === 'dark';
+      else if (themeSetting === 'dark') initDark = true;
+      else if (themeSetting === 'auto') initDark = !!(window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches);
+      else initDark = false; // light / unknown
+      setDark(initDark, false);
+      // Follow the Cockpit host theme by default: the console bubble pushes a
+      // THEME_CHANGE on iframe load and ThemeProvider broadcasts it on toggle.
+      // An explicit per-app user choice (stored) always wins over the host.
+      window.addEventListener('message', function (ev) {
+        var d = ev && ev.data;
+        if (!d || d.type !== 'THEME_CHANGE') return;
+        var userChoice = null;
+        try { userChoice = localStorage.getItem(themeKey); } catch (e) {}
+        if (userChoice === 'dark' || userChoice === 'light') return;
+        var hostDark = d.theme === 'dark' || (d.theme === 'system' &&
+          !!(window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches));
+        setDark(hostDark, false);
+      });
+      // The button is DRAGGABLE and snaps to whichever of the 4 viewport corners
+      // it was released nearest to. A fixed corner is unworkable: the host picks
+      // the spot, the app owns the content, and any app with its own top-right
+      // affordance (close button, toolbar, TOC) had it permanently covered with
+      // no escape. The chosen corner is remembered GLOBALLY (not per app) — one
+      // gesture then holds for every HTML app, which is the common case since
+      // apps tend to crowd the same corner.
+      var CORNER_KEY = 'htmlapp-theme-corner';   // 'tl' | 'tr' | 'bl' | 'br'
+      var CORNER_MARGIN = 10;
+      var corner = 'tr';                          // default = the historic position
+      try {
+        var storedCorner = localStorage.getItem(CORNER_KEY);
+        if (storedCorner === 'tl' || storedCorner === 'tr' ||
+            storedCorner === 'bl' || storedCorner === 'br') corner = storedCorner;
+      } catch (e) {}
+      // Only the CORNER is persisted, never pixels: on resize/rotate a remembered
+      // coordinate can land off-screen, while a corner is always re-derivable.
+      var applyCorner = function () {
+        if (!themeBtn) return;
+        var s = themeBtn.style;
+        var atTop = corner.charAt(0) === 't';
+        var atLeft = corner.charAt(1) === 'l';
+        s.top = atTop ? CORNER_MARGIN + 'px' : 'auto';
+        s.bottom = atTop ? 'auto' : CORNER_MARGIN + 'px';
+        s.left = atLeft ? CORNER_MARGIN + 'px' : 'auto';
+        s.right = atLeft ? 'auto' : CORNER_MARGIN + 'px';
+      };
+      var mountThemeBtn = function () {
+        if (themeBtn || !document.body) return;
+        themeBtn = document.createElement('button');
+        themeBtn.type = 'button';
+        themeBtn.setAttribute('aria-label', 'Toggle theme');
+        themeBtn.textContent = document.documentElement.classList.contains('dark') ? '☀️' : '\u{1F319}';
+        // touch-action:none — the drag is pointer-driven, so the browser must not
+        // also treat the gesture as a scroll. Without it a touch-drag inside an
+        // iframe can scroll-chain to the Cockpit shell behind it.
+        themeBtn.style.cssText = 'position:fixed;z-index:2147483647;width:36px;height:36px;' +
+          'border-radius:8px;border:1px solid rgba(128,128,128,.3);background:rgba(128,128,128,.14);' +
+          'color:inherit;cursor:pointer;font-size:14px;line-height:1;display:flex;align-items:center;' +
+          'justify-content:center;padding:0;touch-action:none';
+        applyCorner();
+        var dragging = false;   // past the slop threshold for THIS gesture
+        var didDrag = false;    // a drag happened -> swallow the trailing click
+        var startX = 0, startY = 0, grabX = 0, grabY = 0;
+        themeBtn.addEventListener('pointerdown', function (ev) {
+          if (ev.button) return;                 // primary button / touch / pen only
+          dragging = false;
+          didDrag = false;                       // reset here, so a swallowed click
+                                                 // can never leak into the next press
+          startX = ev.clientX; startY = ev.clientY;
+          var r = themeBtn.getBoundingClientRect();
+          grabX = ev.clientX - r.left; grabY = ev.clientY - r.top;
+          try { themeBtn.setPointerCapture(ev.pointerId); } catch (e) {}
+        });
+        themeBtn.addEventListener('pointermove', function (ev) {
+          if (!themeBtn.hasPointerCapture || !themeBtn.hasPointerCapture(ev.pointerId)) return;
+          if (!dragging) {
+            // Slop before a press becomes a drag: a finger never holds as still as
+            // a mouse, so touch needs the looser threshold or taps turn into drags.
+            var slop = ev.pointerType === 'touch' ? 8 : 5;
+            if (Math.abs(ev.clientX - startX) < slop &&
+                Math.abs(ev.clientY - startY) < slop) return;
+            dragging = true; didDrag = true;
+          }
+          ev.preventDefault();
+          var s = themeBtn.style;
+          s.right = 'auto'; s.bottom = 'auto';   // free-float while held
+          s.left = (ev.clientX - grabX) + 'px';
+          s.top = (ev.clientY - grabY) + 'px';
+        });
+        var endDrag = function (ev) {
+          try { themeBtn.releasePointerCapture(ev.pointerId); } catch (e) {}
+          if (!dragging) return;
+          dragging = false;
+          var r = themeBtn.getBoundingClientRect();
+          corner = ((r.top + r.height / 2) < window.innerHeight / 2 ? 't' : 'b') +
+                   ((r.left + r.width / 2) < window.innerWidth / 2 ? 'l' : 'r');
+          try { localStorage.setItem(CORNER_KEY, corner); } catch (e) {}
+          applyCorner();
+        };
+        themeBtn.addEventListener('pointerup', endDrag);
+        themeBtn.addEventListener('pointercancel', function (ev) {
+          dragging = false;
+          try { themeBtn.releasePointerCapture(ev.pointerId); } catch (e) {}
+          applyCorner();                         // snap back rather than strand it
+        });
+        // Kept as a click handler rather than firing on pointerup so keyboard
+        // activation (Enter/Space on the focused button) still toggles.
+        themeBtn.onclick = function () {
+          if (didDrag) { didDrag = false; return; }
+          toggleTheme();
+        };
+        window.addEventListener('resize', applyCorner);
+        document.body.appendChild(themeBtn);
+      };
+      if (document.body) mountThemeBtn();
+      else window.addEventListener('DOMContentLoaded', mountThemeBtn);
+    }
+  } catch (e) {}
+  };
+  // This script is injected at the START of <head>, BEFORE the page's own
+  // <meta> tags are parsed — reading them synchronously here always misses
+  // them. Defer theme init until the DOM is ready so the opt-in meta is seen.
+  if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', initTheme);
+  else initTheme();
+  var CWD = __CWD__;
+  var WS_URL = __WS_URL__;
+  var ws = null;
+  var ready = false;
+  var queue = [];          // [{ id, s }] — pending frames, drained on open
+  var handlers = {};       // id -> { onStdout, onStderr, onExit, onError, gen }
+  var seq = 0;
+  var gen = 0;             // connection generation; see ensureWs
+  function resolveWsUrl() {
+    if (WS_URL) return WS_URL;
+    var proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
+    return proto + '//' + location.host + '/ws/bash?cwd=' + encodeURIComponent(CWD);
+  }
+  function failAll(reason) {
+    var ids = Object.keys(handlers);
+    for (var i = 0; i < ids.length; i++) {
+      var h = handlers[ids[i]];
+      delete handlers[ids[i]];
+      if (h && h.onError) h.onError(reason);
+    }
+  }
+  /**
+   * Fail only the commands carried by ONE connection. Handlers are tagged with
+   * the generation of the socket that actually wrote them, so a socket that has
+   * been replaced can report its own losses without touching its successor's
+   * in-flight work.
+   */
+  function failGen(g, reason) {
+    var ids = Object.keys(handlers);
+    for (var i = 0; i < ids.length; i++) {
+      var h = handlers[ids[i]];
+      if (!h || h.gen !== g) continue;
+      delete handlers[ids[i]];
+      if (h.onError) h.onError(reason);
+    }
+  }
+  function ensureWs() {
+    if (ws && (ws.readyState === 0 || ws.readyState === 1)) return;
+    // A socket in CLOSING(2) is replaced here rather than waited on, so two
+    // sockets can briefly coexist. Shared state (\`ready\`, \`queue\`) may only
+    // be touched by the CURRENT socket — otherwise a replaced socket's late
+    // onclose flips \`ready\` to false while its successor is already open, and
+    // since the successor's onopen has long since fired nothing ever sets it
+    // back: every later bash() then queues forever with no error at all.
+    var myGen = ++gen;
+    var sock;
+    try { sock = new WebSocket(resolveWsUrl()); }
+    catch (e) { failAll(String(e)); return; }
+    ws = sock;
+    ready = false;
+    sock.onopen = function () {
+      if (ws !== sock) return;
+      ready = true;
+      var q = queue; queue = [];
+      for (var i = 0; i < q.length; i++) {
+        // Re-tag: this socket, not the one queued them, is the carrier.
+        if (handlers[q[i].id]) handlers[q[i].id].gen = myGen;
+        sock.send(q[i].s);
+      }
+    };
+    // NOT generation-guarded: ids are globally unique, so a late frame can only
+    // belong to the command this very socket carried. Dropping it would leave
+    // that command's promise unsettled forever.
+    sock.onmessage = function (ev) {
+      var msg;
+      try { msg = JSON.parse(ev.data); } catch (e) { return; }
+      if (msg.type === 'ping') return;
+      var h = handlers[msg.id];
+      if (!h) return;
+      if (msg.type === 'stdout') { if (h.onStdout) h.onStdout(msg.data); }
+      else if (msg.type === 'stderr') { if (h.onStderr) h.onStderr(msg.data); }
+      else if (msg.type === 'exit') { delete handlers[msg.id]; if (h.onExit) h.onExit(msg.code); }
+      else if (msg.type === 'error') { delete handlers[msg.id]; if (h.onError) h.onError(msg.message); }
+    };
+    sock.onclose = function () {
+      if (ws === sock) {
+        ready = false;
+        // Drop anything still queued and fail it here. These are shell commands
+        // with side effects: letting a later reconnect drain this queue would
+        // re-run them with their handlers already gone, so the output would go
+        // nowhere and the caller would never learn it ran twice.
+        var q = queue; queue = [];
+        for (var i = 0; i < q.length; i++) {
+          var qh = handlers[q[i].id];
+          if (!qh) continue;
+          delete handlers[q[i].id];
+          if (qh.onError) qh.onError('connection closed');
+        }
+      }
+      // Always report THIS connection's own losses, current or replaced — a
+      // replaced socket still owes an answer to whatever it was carrying.
+      failGen(myGen, 'connection closed');
+    };
+    sock.onerror = function () { /* onclose follows */ };
+  }
+  function send(obj) {
+    var s = JSON.stringify(obj);
+    ensureWs();
+    // Tag AFTER ensureWs — it may have opened a new connection, and what
+    // matters is which socket ends up carrying this command.
+    if (obj.id && handlers[obj.id]) handlers[obj.id].gen = gen;
+    if (ready && ws && ws.readyState === 1) ws.send(s);
+    else queue.push({ id: obj.id, s: s });
+  }
+  function run(command, opts) {
+    opts = opts || {};
+    var id = 'c' + (++seq);
+    handlers[id] = {
+      onStdout: opts.onStdout,
+      onStderr: opts.onStderr,
+      onExit: opts.onExit,
+      onError: opts.onError
+    };
+    send({ type: 'exec', id: id, command: command, cwd: opts.cwd || CWD });
+    return id;
+  }
+  function bash(command, opts) {
+    opts = opts || {};
+    if (opts.background) {
+      var id = run(command, {
+        cwd: opts.cwd,
+        onStdout: opts.onOutput,
+        onStderr: opts.onStderr || opts.onOutput,
+        onExit: opts.onExit,
+        onError: opts.onError
+      });
+      return { kill: function () { send({ type: 'kill', id: id }); delete handlers[id]; } };
+    }
+    return new Promise(function (resolve, reject) {
+      var out = '', err = '';
+      run(command, {
+        cwd: opts.cwd,
+        onStdout: function (d) { out += d; },
+        onStderr: function (d) { err += d; },
+        onExit: function (code) { resolve({ stdout: out, stderr: err, exitCode: code }); },
+        onError: function (m) { reject(new Error(m)); }
+      });
+    });
+  }
+  // toggleTheme is reassigned by the deferred initTheme — forward lazily so the
+  // exported function always calls the current implementation, not the no-op.
+  window.cockpit = {
+    cwd: CWD,
+    bash: bash,
+    toggleTheme: function () { toggleTheme(); },
+    // Current host language ('' until the host's first push, so apps can fall
+    // back to navigator themselves). Apps PERCEIVE the language and own their
+    // own strings — this is not an i18n runtime.
+    get lang() {
+      return document.documentElement.getAttribute('data-cockpit-lang') || '';
+    }
+  };
+  window.addEventListener('beforeunload', function () {
+    try { if (ws) ws.close(); } catch (e) {}
+  });
+})();
+`;function e(a){return/^([/\\]|[A-Za-z]:)/.test(a)}function f(a,b){let c,d,f=(c=Math.max(a.lastIndexOf("/"),a.lastIndexOf("\\")))<0?"":0===c?"/":a.slice(0,c);return e(a)?f:b?(d=b.replace(/[/\\]+$/,""),f?`${d}/${f}`:d):f}let g="/apps/local/";function h(a){let b,c=a.startsWith(g)?a.slice(g.length):a.replace(/^\/+/,"");try{b=decodeURIComponent(c)}catch{return null}let d="/"+b;return(d=d.replace(/^\/([A-Za-z]:)/,"$1")).includes("\0")||d.split(/[/\\]/).includes("..")?null:d}function i(a,b){let c=a=>JSON.stringify(a).replace(/</g,"\\u003c"),e="<script>"+d.replaceAll("__CWD__",c(b.cwd)).replaceAll("__WS_URL__",c(b.wsUrl??""))+"<\/script>",f=a.match(/<head[^>]*>/i);if(f&&void 0!==f.index){let b=f.index+f[0].length;return a.slice(0,b)+e+a.slice(b)}let g=a.match(/<html[^>]*>/i);if(g&&void 0!==g.index){let b=g.index+g[0].length;return a.slice(0,b)+e+a.slice(b)}return e+a}},72891:(a,b,c)=>{c.a(a,async(a,d)=>{try{c.d(b,{OZ:()=>o,RL:()=>n,k9:()=>p,ok:()=>l});var e=c(37625),f=c(52693),g=c(18412),h=c(89705),i=c(94506),j=c(770),k=a([i]);i=(k.then?(await k)():k)[0];let l=(a,b=200)=>new Response(JSON.stringify(a),{status:b,headers:{"content-type":"application/json"}}),m=a=>{let b=e.od(a);if(f.Ru(b)){let a=b.value,c=(0,j.Sh)(a);return new Response(JSON.stringify({error:(a=>{let b=a.message;if("string"==typeof b&&b.length>0)return b;let c=a.cause;if(c instanceof Error&&c.message.length>0)return c.message;switch(a._tag){case"ValidationError":return`Invalid ${a.field}: ${a.reason}`;case"NotFoundError":return`${a.resource} not found: ${a.id}`;case"PermissionError":return`Permission denied: ${a.action} on ${a.resource}`;case"DBError":return`${a.db} ${a.op} failed`;case"FSError":return`${a.op} ${a.path} failed`;case"WSError":return`${a.proto} ${a.kind} failed`;case"AgentError":return`${a.provider} ${a.kind} failed`;default:return a._tag}})(a),tag:a._tag}),{status:c,headers:{"content-type":"application/json"}})}return console.error("[handler] uncaught defect:\n"+e.j9(a)),new Response(JSON.stringify({error:"Internal Server Error",tag:"InternalError"}),{status:500,headers:{"content-type":"application/json"}})},n=a=>async b=>{let c=await i.s9.runPromiseExit(a(b));return g.YW(c,{onFailure:a=>m(a),onSuccess:a=>a})},o=a=>async(b,c)=>{let d=await c.params,e=await i.s9.runPromiseExit(a(b,d));return g.YW(e,{onFailure:a=>m(a),onSuccess:a=>a})},p=a=>h.$mh({try:()=>a.json(),catch:()=>new j.yI({field:"body",reason:"invalid JSON"})});d()}catch(a){d(a)}})}};