@n42/cli 0.3.8 → 0.3.10

package/dist/assets/copy-light.svg

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+
+<svg
+   width="800px"
+   height="800px"
+   viewBox="0 0 512 512"
+   version="1.1"
+   id="svg8"
+   sodipodi:docname="copy-light.svg"
+   inkscape:version="1.2.2 (b0a8486541, 2022-12-01)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:dc="http://purl.org/dc/elements/1.1/">
+  <sodipodi:namedview
+     id="namedview432"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     showgrid="false"
+     inkscape:zoom="1.28375"
+     inkscape:cx="366.1149"
+     inkscape:cy="400.77897"
+     inkscape:window-width="3440"
+     inkscape:window-height="1371"
+     inkscape:window-x="0"
+     inkscape:window-y="32"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg8" />
+  <defs
+     id="defs12" />
+  <title
+     id="title2">copy</title>
+  <g
+     id="Page-1"
+     stroke="none"
+     stroke-width="1"
+     fill="none"
+     fill-rule="evenodd"
+     transform="translate(0,10.666668)">
+    <g
+       id="copy"
+       fill="#000000"
+       transform="translate(85.333333,42.666667)"
+       style="fill:#6b7280;fill-opacity:1">
+      <path
+         d="M 341.33333,85.333333 V 405.33333 H 85.333333 V 85.333333 Z M 298.66667,128 H 128 v 234.66667 h 170.66667 z m -64,-128 V 42.666667 H 42.666667 V 298.66667 H 0 V 0 Z"
+         id="path4"
+         style="fill:#6b7280;fill-opacity:1" />
+    </g>
+  </g>
+  <metadata
+     id="metadata877">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:title>copy</dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+</svg>

package/dist/assets/curl-modal.js

@@ -0,0 +1,577 @@
+class CurlModal {
+  constructor(opts = {}) {
+    this.opts = {
+      title: "Request",
+      brand: "curl",
+      ...opts,
+    };
+
+    this._active = false;
+    this._controller = null;
+    this._lastFocused = null;
+  }
+
+  async openAndRun(req) {
+    this.open();
+    try {
+      await this.run(req);
+    } catch (e) {
+      // errors already printed by run(); rethrow if you want
+    }
+  }
+
+  open() {
+    if (!this.overlay) {
+      this._ensureDom();
+    }
+    if (this._active) return;
+    this._active = true;
+
+    this._lastFocused = document.activeElement;
+
+    this.overlay.classList.remove("hidden");
+    this.dialog.classList.remove("hidden");
+
+    // Initial focus: close button (per common modal patterns)
+    this.btnClose.focus();
+
+    // prevent background scroll
+    this._prevOverflow = document.documentElement.style.overflow;
+    document.documentElement.style.overflow = "hidden";
+  }
+
+  close() {
+    if (!this._active) return;
+    this._active = false;
+
+    this.abort("Modal closed");
+
+    this.overlay.classList.add("hidden");
+    this.dialog.classList.add("hidden");
+
+    document.documentElement.style.overflow = this._prevOverflow || "";
+
+    // restore focus to trigger
+    if (this._lastFocused && typeof this._lastFocused.focus === "function") {
+      this._lastFocused.focus();
+    }
+  }
+
+  abort(reason = "Aborted") {
+    if (this._controller) {
+      try { this._controller.abort(reason); } catch {}
+    }
+    this._controller = null;
+    this._setBusy(false);
+  }
+
+  async run(req) {
+    const normalized = this._normalizeReq(req);
+    this._resetTerminal();
+
+    this._printLine(`${this.opts.brand} ${this._toCurlArgs(normalized)}`);
+    this._printLine("");
+
+    this._setBusy(true);
+
+    const t0 = performance.now();
+    const controller = new AbortController();
+    this._controller = controller;
+
+    // Timeout: use AbortSignal.timeout() if available; else manual.
+    let timeoutId = null;
+    const timeoutMs = normalized.timeoutMs;
+
+    let signal = controller.signal;
+    if (typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function" && timeoutMs > 0) {
+      // combine signals: abort either manual or timeout
+      signal = this._anySignal([controller.signal, AbortSignal.timeout(timeoutMs)]);
+    } else if (timeoutMs > 0) {
+      timeoutId = setTimeout(() => controller.abort("Timeout"), timeoutMs);
+    }
+
+    try {
+      const fetchInit = {
+        method: normalized.method,
+        headers: normalized.headers,
+        body: normalized.body,
+        signal,
+        credentials: normalized.credentials,
+        redirect: normalized.redirect,
+        cache: "no-store",
+        mode: normalized.mode,
+      };
+
+      this._printLine(`> ${normalized.method} ${normalized.url}`);
+      for (const [k, v] of Object.entries(normalized.headers || {})) {
+        this._printLine(`> ${k}: ${v}`);
+      }
+      if (normalized.body) this._printLine(`> (body ${this._byteLen(normalized.body)} bytes)`);
+      this._printLine("");
+
+      const res = await fetch(normalized.url, fetchInit);
+
+      const dt = (performance.now() - t0);
+      this._printLine(`< HTTP ${res.status} ${res.statusText} (${dt.toFixed(0)} ms)`);
+
+      res.headers.forEach((v, k) => this._printLine(`< ${k}: ${v}`));
+      this._printLine("");
+
+      const { text, truncated, bytesRead } = await this._readTextWithLimit(res, normalized.maxBytes);
+      if (truncated) {
+        this._printLine(`... [truncated after ${bytesRead} bytes (maxBytes=${normalized.maxBytes})] ...`);
+        this._printLine("");
+      }
+      this._printRaw(text);
+
+      this._printLine("");
+      this._printLine(`[done]`);
+      this._setBusy(false);
+      return { status: res.status, headers: res.headers, body: text, truncated };
+    } 
+    catch (err) {
+      const name = err?.name || "Error";
+      const msg = err?.message || String(err);
+
+      //this._printLine("");
+      this._printLine(`[${name}] ${msg}`);
+      this._setBusy(false);
+       
+      return { status: 0, headers: new Headers(), body: "", error: msg };
+    } 
+    finally {
+      if (timeoutId) clearTimeout(timeoutId);
+      this._controller = null;
+    }
+  }
+
+  // ---------------- private ----------------
+
+  _normalizeReq(req) {
+    if (!req || typeof req.url !== "string") throw new Error("Missing url");
+
+    const method = (req.method || "GET").toUpperCase();
+    const headers = { ...(req.headers || {}) };
+
+    // If body is object, default JSON
+    let body = req.body ?? null;
+    if (body && typeof body === "object" && !(body instanceof FormData) && !(body instanceof Blob)) {
+      if (!headers["Content-Type"] && !headers["content-type"]) {
+        headers["Content-Type"] = "application/json";
+      }
+      body = JSON.stringify(body);
+    }
+
+    return {
+      url: req.url,
+      method,
+      headers,
+      body,
+      timeoutMs: Number.isFinite(req.timeoutMs) ? req.timeoutMs : 15000,
+      maxBytes: Number.isFinite(req.maxBytes) ? req.maxBytes : 500_000,
+      credentials: req.credentials || "omit", // set "include" if you need cookies
+      redirect: req.redirect || "follow",
+      mode: req.mode || "cors",
+    };
+  }
+
+  _ensureDom() {
+    if (this.overlay) return;
+
+    const textColor = this.opts.textColor;
+    const terminalTextColor = this.opts.terminalTextColor;
+
+    // Styles (namespaced)
+    const style = document.createElement("style");
+    style.textContent = `
+      .cm-overlay {
+        position: fixed; inset: 0;
+        background: rgba(0,0,0,.55);
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        padding: 24px;
+        z-index: 2147483647;
+      }
+      .cm-overlay.hidden {
+        display: none;
+      }
+      .cm-dialog {
+        width: min(980px, 100%);
+        height: min(720px, 100%);
+        background: #0b0f14;
+        color: ${textColor};
+        border: 1px solid rgba(255,255,255,.12);
+        border-radius: 12px;
+        box-shadow: 0 18px 60px rgba(0,0,0,.55);
+        display: flex;
+        flex-direction: column;
+        overflow: hidden;
+        font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+      }
+      .cm-display.hidden {
+        display: none;
+      }
+      .cm-head {
+        display: flex; align-items: center; gap: 12px;
+        padding: 10px 10px 10px 14px;
+        border-bottom: 1px solid rgba(255,255,255,.10);
+        background: rgba(255,255,255,.03);
+      }
+      .cm-title { 
+        font-weight: 600;
+        font-size: 13px;
+        opacity: .95;
+      }
+      .cm-spacer { flex: 1; }
+      .cm-btn {
+        appearance: none;
+        border: 1px solid rgba(255,255,255,.18);
+        background: rgba(255,255,255,0);
+        color: inherit;
+        padding: 6px 10px;
+        border-radius: 6px;
+        font-size: 12px;
+        cursor: pointer;
+      }
+      .cm-btn:hover {
+        border: 1px solid rgba(255,255,255,.38);
+      }
+      .cm-btn:disabled { opacity: .55; cursor: not-allowed; }
+      .cm-body { 
+        flex: 1; 
+        overflow: auto; 
+        padding: 12px; 
+        
+        scrollbar-color: #323232 #0b0f14;
+        scrollbar-width: thin;
+      }
+      .cm-body::-webkit-scrollbar {
+        width: 10px;
+      }
+      .cm-body::-webkit-scrollbar-track {
+        background: #0b0f14;
+      }
+      .cm-body::-webkit-scrollbar-thumb {
+        background: #323232;
+        border-radius: 6px;
+      }
+      .cm-body::-webkit-scrollbar-thumb:hover {
+        background: #656565;
+      }
+      .cm-term {
+        white-space: pre-wrap;
+        word-break: break-word;
+        color: ${terminalTextColor};
+        line-height: 1.35;
+        font-size: 12px;
+      }
+      .cm-foot {
+        padding: 10px 12px;
+        border-top: 1px solid rgba(255,255,255,.10);
+        display: flex; align-items: center; gap: 10px;
+        background: rgba(255,255,255,.02);
+      }
+      .cm-status { font-size: 12px; opacity: .85; }
+      .cm-kbd {
+        font-size: 11px; opacity: .7;
+        border: 1px solid rgba(255,255,255,.16);
+        padding: 2px 6px;
+        border-radius: 6px;
+      }
+    `;
+    document.head.appendChild(style);
+
+    // Overlay
+    const overlay = document.createElement("div");
+    overlay.className = "cm-overlay";
+    overlay.hidden = true;
+
+    // Dialog
+    const dialog = document.createElement("div");
+    dialog.className = "cm-dialog";
+    dialog.hidden = true;
+    dialog.setAttribute("role", "dialog");
+    dialog.setAttribute("aria-modal", "true"); // per aria-modal guidance
+    dialog.setAttribute("aria-label", this.opts.title);
+
+    // Header
+    const head = document.createElement("div");
+    head.className = "cm-head";
+
+    const title = document.createElement("div");
+    title.className = "cm-title";
+    title.textContent = this.opts.title;
+
+    const spacer = document.createElement("div");
+    spacer.className = "cm-spacer";
+
+    const btnCopy = document.createElement("button");
+    btnCopy.className = "cm-btn";
+    btnCopy.type = "button";
+    btnCopy.textContent = "Copy";
+    btnCopy.addEventListener("click", () => this._copy());
+
+    const btnDownload = document.createElement("button");
+    btnDownload.className = "cm-btn";
+    btnDownload.type = "button";
+    btnDownload.textContent = "Download";
+    btnDownload.addEventListener("click", () => this._download());
+
+    const btnAbort = document.createElement("button");
+    btnAbort.className = "cm-btn";
+    btnAbort.type = "button";
+    btnAbort.textContent = "Cancel";
+    btnAbort.addEventListener("click", () => this.abort("User canceled"));
+
+    const btnClose = document.createElement("button");
+    btnClose.className = "cm-btn";
+    btnClose.type = "button";
+    btnClose.textContent = "Close";
+    btnClose.addEventListener("click", () => this.close());
+
+    head.append(title, spacer, btnCopy, btnDownload, btnClose);
+
+    // Body
+    const body = document.createElement("div");
+    body.className = "cm-body";
+
+    const term = document.createElement("div");
+    term.className = "cm-term";
+    term.setAttribute("role", "log");
+    term.setAttribute("aria-live", "polite");
+
+    body.appendChild(term);
+
+    // Footer
+    const foot = document.createElement("div");
+    foot.className = "cm-foot";
+
+    const status = document.createElement("div");
+    status.className = "cm-status";
+    status.textContent = "Ready";
+
+    const hint = document.createElement("div");
+    hint.className = "cm-spacer";
+    hint.textContent = "";
+
+    const kbdEsc = document.createElement("span");
+    kbdEsc.className = "cm-kbd";
+    kbdEsc.textContent = "ESC";
+
+    const hint2 = document.createElement("div");
+    hint2.style.opacity = ".75";
+    hint2.style.fontSize = "12px";
+    hint2.textContent = "to close";
+
+    foot.append(status, hint, kbdEsc, hint2);
+
+    dialog.append(head, body, foot);
+    overlay.appendChild(dialog);
+    document.body.appendChild(overlay);
+
+    // Store refs
+    this.overlay = overlay;
+    this.dialog = dialog;
+    this.term = term;
+    this.statusEl = status;
+
+    this.btnCopy = btnCopy;
+    this.btnDownload = btnDownload;
+    this.btnAbort = btnAbort;
+    this.btnClose = btnClose;
+
+    // Close when clicking outside (optional)
+    overlay.addEventListener("mousedown", (e) => {
+      if (e.target === overlay) this.close();
+    });
+
+    // Key handling + focus trap
+    document.addEventListener("keydown", (e) => {
+      if (!this._active) return;
+
+      if (e.key === "Escape") {
+        e.preventDefault();
+        this.close();
+        return;
+      }
+
+      if (e.key === "Tab") {
+        this._trapTab(e);
+      }
+    });
+  }
+
+  _trapTab(e) {
+    // Basic focus trap: keep tabbing inside dialog controls.
+    const focusables = this.dialog.querySelectorAll(
+      'button,[href],input,select,textarea,[tabindex]:not([tabindex="-1"])'
+    );
+    const list = Array.from(focusables).filter(el => !el.disabled && el.offsetParent !== null);
+    if (list.length === 0) return;
+
+    const first = list[0];
+    const last = list[list.length - 1];
+    const active = document.activeElement;
+
+    if (e.shiftKey && active === first) {
+      e.preventDefault();
+      last.focus();
+    } else if (!e.shiftKey && active === last) {
+      e.preventDefault();
+      first.focus();
+    }
+  }
+
+  _setBusy(isBusy) {
+    this.btnAbort.disabled = !isBusy;
+    this.statusEl.textContent = isBusy ? "Running…" : "Ready";
+  }
+
+  _resetTerminal() {
+    this.term.textContent = "";
+  }
+
+  _printLine(s) {
+    this.term.textContent += `${s}\n`;
+    this._scrollToBottom();
+  }
+
+  _printRaw(s) {
+    this.term.textContent += s;
+    if (!s.endsWith("\n")) this.term.textContent += "\n";
+    this._scrollToBottom();
+  }
+
+  _scrollToBottom() {
+    const body = this.term.parentElement;
+    body.scrollTop = body.scrollHeight;
+  }
+
+  async _copy() {
+    const text = this.term.textContent || "";
+    try {
+      await navigator.clipboard.writeText(text);
+      this.statusEl.textContent = "Copied";
+    } catch {
+      // fallback
+      const ta = document.createElement("textarea");
+      ta.value = text;
+      ta.style.position = "fixed";
+      ta.style.left = "-9999px";
+      document.body.appendChild(ta);
+      ta.select();
+      try { document.execCommand("copy"); this.statusEl.textContent = "Copied"; }
+      catch { this.statusEl.textContent = "Copy failed"; }
+      ta.remove();
+    }
+    setTimeout(() => (this.statusEl.textContent = "Ready"), 900);
+  }
+
+  _download() {
+    const text = this.term.textContent || "";
+    const blob = new Blob([text], { type: "text/plain;charset=utf-8" });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = `curl-output-${new Date().toISOString().slice(0,19).replace(/[:T]/g,"-")}.txt`;
+    document.body.appendChild(a);
+    a.click();
+    a.remove();
+    URL.revokeObjectURL(url);
+  }
+
+  _toCurlArgs(req) {
+    // Presentational: escapes minimally for display (not execution-safe for all shells).
+    const parts = [];
+    parts.push(`-X ${req.method}`);
+    for (const [k, v] of Object.entries(req.headers || {})) {
+      parts.push(`-H ${this._shQuote(`${k}: ${v}`)}`);
+    }
+    if (req.body) parts.push(`--data ${this._shQuote(typeof req.body === "string" ? req.body : String(req.body))}`);
+    parts.push(this._shQuote(req.url));
+    return parts.join(" ");
+  }
+
+  _shQuote(s) {
+    // single-quote shell style: ' -> '"'"'
+    const str = String(s);
+    return `'${str.replace(/'/g, `'"'"'`)}'`;
+  }
+
+  _byteLen(s) {
+    if (typeof s !== "string") s = String(s);
+    return new TextEncoder().encode(s).length;
+  }
+
+  async _readTextWithLimit(res, maxBytes) {
+    // Reads response body safely with byte limit.
+    // If no stream support, fall back to res.text() then truncate.
+    const bytesLimit = Math.max(0, maxBytes | 0);
+
+    if (!res.body || !res.body.getReader) {
+      const full = await res.text();
+      const enc = new TextEncoder().encode(full);
+      if (enc.length <= bytesLimit) return { text: full, truncated: false, bytesRead: enc.length };
+      // truncate bytes -> decode
+      const cut = enc.slice(0, bytesLimit);
+      return { text: new TextDecoder().decode(cut), truncated: true, bytesRead: bytesLimit };
+    }
+
+    const reader = res.body.getReader();
+    const chunks = [];
+    let bytesRead = 0;
+    let truncated = false;
+
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+
+      if (bytesRead + value.byteLength > bytesLimit) {
+        const allowed = bytesLimit - bytesRead;
+        if (allowed > 0) chunks.push(value.slice(0, allowed));
+        truncated = true;
+        bytesRead = bytesLimit;
+        try { reader.cancel("maxBytes reached"); } catch {}
+        break;
+      }
+
+      chunks.push(value);
+      bytesRead += value.byteLength;
+    }
+
+    const merged = this._concatU8(chunks, bytesRead);
+    const text = new TextDecoder().decode(merged);
+    return { text, truncated, bytesRead };
+  }
+
+  _concatU8(chunks, total) {
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const c of chunks) {
+      out.set(c, offset);
+      offset += c.byteLength;
+      if (offset >= total) break;
+    }
+    return out;
+  }
+
+  _anySignal(signals) {
+    // Combine multiple AbortSignals into one.
+    const controller = new AbortController();
+    const onAbort = (sig) => {
+      if (controller.signal.aborted) return;
+      controller.abort(sig.reason || "Aborted");
+    };
+    for (const sig of signals) {
+      if (!sig) continue;
+      if (sig.aborted) {
+        onAbort(sig);
+        break;
+      }
+      sig.addEventListener("abort", () => onAbort(sig), { once: true });
+    }
+    return controller.signal;
+  }
+}

package/dist/assets/discover.html.template

@@ -4,6 +4,7 @@
     <meta charset="utf-8" />
     <title>Node42</title>
     <link rel="stylesheet" href="../../assets/wrapper-light.css">
+    <link rel="stylesheet" href="../../assets/terminal-light.css">
   </head>
   <body>
     <div id="app-header">
@@ -46,5 +47,6 @@
     </div>
     <script src="../../assets/discover.js" defer></script>
     <script src="../../assets/wrapper.js" defer></script>
+    <script src="../../assets/terminal.js"></script>
   </body>
 </html>