@termix-ssh/plugin-sdk 1.0.4 → 1.0.6

package/dist/host/ui.js

@@ -32,6 +32,7 @@ import {
   GroupHeading,
   InlineView,
   KeyRound,
+  LANGUAGES,
   List,
   LoaderCircle,
   Overlay2,
@@ -138,8 +139,8 @@ import {
   useSurfaceKind,
   useTheme,
   verifySecondFactor
-} from "./chunk-RU4E5XLY.js";
-import "./chunk-O2OHNVFX.js";
+} from "./chunk-26DAYAKC.js";
+import "./chunk-DIOJ3KW2.js";
 import {
   TabProvider,
   buildOriginWsUrl,
@@ -178,7 +179,7 @@ import {
   useTabs,
   useTabsSafe,
   verifyPasswordResetCode
-} from "./chunk-F5RZH6HE.js";
+} from "./chunk-NZG6HNQH.js";
 import "./chunk-YC2MAKSP.js";
 
 // src/ui/components/alert.tsx
@@ -1501,7 +1502,7 @@ function Switch2({
     {
       "data-slot": "switch",
       className: cn(
-        "peer data-[state=checked]:bg-primary data-[state=unchecked]:bg-input focus-visible:border-ring focus-visible:ring-ring/50 dark:data-[state=unchecked]:bg-input/80 inline-flex h-[1.15rem] w-8 shrink-0 items-center rounded-full border border-transparent shadow-xs transition-[background-color,border-color,box-shadow,opacity] outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50",
+        "peer relative inline-flex h-5 w-9 shrink-0 cursor-pointer items-center border-2 transition-colors outline-none focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-accent-brand data-[state=checked]:border-accent-brand data-[state=unchecked]:bg-muted data-[state=unchecked]:border-border",
         className
       ),
       ...props,
@@ -1509,9 +1510,7 @@ function Switch2({
         SwitchThumb,
         {
           "data-slot": "switch-thumb",
-          className: cn(
-            "bg-background dark:data-[state=unchecked]:bg-foreground dark:data-[state=checked]:bg-primary-foreground pointer-events-none block size-4 rounded-full ring-0 transition-transform data-[state=checked]:translate-x-[calc(100%-2px)] data-[state=unchecked]:translate-x-0"
-          )
+          className: "pointer-events-none block h-3 w-3 bg-background shadow-sm transition-transform data-[state=checked]:translate-x-4 data-[state=unchecked]:translate-x-0.5"
         }
       )
     }
@@ -2050,16 +2049,21 @@ function MiniStat({
 
 // src/ui/components/charts/LineChart.tsx
 import { useRef, useState as useState4, useEffect as useEffect2, useCallback } from "react";
+
+// src/ui/lib/server-time.ts
+function parseServerTime(ts) {
+  const bare = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}(:\d{2}(\.\d+)?)?$/.test(ts);
+  return new Date(bare ? `${ts.replace(" ", "T")}Z` : ts);
+}
+
+// src/ui/components/charts/LineChart.tsx
 import { jsx as jsx27, jsxs as jsxs17 } from "react/jsx-runtime";
 var Y_LABEL_W = 44;
 var X_LABEL_H = 20;
 var TOP_PAD = 6;
 var TICK_COUNT = 5;
-function parseTs(ts) {
-  return new Date(ts.includes("T") ? ts : ts.replace(" ", "T") + "Z");
-}
 function formatTimestamp(ts, rangeMs) {
-  const d = parseTs(ts);
+  const d = parseServerTime(ts);
   if (rangeMs <= 25 * 60 * 60 * 1e3) {
     return d.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
   }
@@ -2114,7 +2118,7 @@ function LineChart({
   const chartW = Math.max(0, width - Y_LABEL_W);
   const drawH = height - TOP_PAD;
   const svgH = height + X_LABEL_H;
-  const rangeMs = timestamps.length >= 2 ? parseTs(timestamps[timestamps.length - 1]).getTime() - parseTs(timestamps[0]).getTime() : 0;
+  const rangeMs = timestamps.length >= 2 ? parseServerTime(timestamps[timestamps.length - 1]).getTime() - parseServerTime(timestamps[0]).getTime() : 0;
   const yTicks = (() => {
     const [lo, hi] = domain;
     const step = (hi - lo) / (TICK_COUNT - 1);
@@ -2323,6 +2327,10 @@ function useIsMobile() {
     void 0
   );
   React5.useEffect(() => {
+    if (isElectron()) {
+      setIsMobile(false);
+      return;
+    }
     const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`);
     const onChange = () => {
       setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
@@ -4348,12 +4356,15 @@ async function loadNamespaces(summaries) {
     loadedNamespaceVersions.set(summary.id, namespaceVersion(summary));
   }
 }
+function serverServesAssets(summary) {
+  return summary.enabled && (!summary.state || summary.state === "active");
+}
 function namespaceVersion(summary) {
   return `${summary.version}|${summary.assetVersion ?? ""}`;
 }
 async function reconcile(summaries) {
   setPluginSummaries(summaries);
-  await loadNamespaces(summaries);
+  await loadNamespaces(summaries.filter(serverServesAssets));
   const { order, blocked } = orderForActivation(summaries);
   const wanted = new Map(order.map((summary) => [summary.id, summary]));
   for (const id of [...active.keys()].reverse()) {
@@ -4428,6 +4439,13 @@ function syncPlugins(summaries) {
 import.meta.hot?.on("termix:plugins-reloaded", () => {
   if (started) void syncPlugins();
 });
+function installLocaleResolver() {
+  setPluginLocaleResolver((namespace, _language, file) => {
+    const summary = getPluginRecord(namespace)?.summary;
+    if (!summary) return Promise.resolve(null);
+    return currentDeps().loadLocale(summary, file);
+  });
+}
 async function fetchPreLoginPlugins() {
   const response = await fetch(getBackendUrl("/plugins/public-manifest"));
   if (!response.ok) return [];
@@ -4443,11 +4461,7 @@ async function startPreLoginPlugins(options = {}) {
     return;
   }
   if (list.length === 0 || started) return;
-  setPluginLocaleResolver((namespace, _language, file) => {
-    const summary = getPluginRecord(namespace)?.summary;
-    if (!summary) return Promise.resolve(null);
-    return currentDeps().loadLocale(summary, file);
-  });
+  installLocaleResolver();
   await enqueue(async () => {
     if (started) return;
     if (options.retryFailed) {
@@ -4542,43 +4556,6 @@ function removeSilentSigninFromSearch(search) {
 
 // src/ui/auth/Auth.tsx
 import { Fragment as Fragment5, jsx as jsx40, jsxs as jsxs26 } from "react/jsx-runtime";
-var LANGUAGES = [
-  { code: "en", label: "English" },
-  { code: "af", label: "Afrikaans" },
-  { code: "ar", label: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629" },
-  { code: "bn", label: "\u09AC\u09BE\u0982\u09B2\u09BE" },
-  { code: "bg", label: "\u0411\u044A\u043B\u0433\u0430\u0440\u0441\u043A\u0438" },
-  { code: "ca", label: "Catal\xE0" },
-  { code: "zh-CN", label: "\u4E2D\u6587 (\u7B80\u4F53)" },
-  { code: "zh-TW", label: "\u4E2D\u6587 (\u7E41\u9AD4)" },
-  { code: "cs", label: "\u010Ce\u0161tina" },
-  { code: "da", label: "Dansk" },
-  { code: "nl", label: "Nederlands" },
-  { code: "fi", label: "Suomi" },
-  { code: "fr", label: "Fran\xE7ais" },
-  { code: "de", label: "Deutsch" },
-  { code: "el", label: "\u0395\u03BB\u03BB\u03B7\u03BD\u03B9\u03BA\u03AC" },
-  { code: "he", label: "\u05E2\u05D1\u05E8\u05D9\u05EA" },
-  { code: "hi", label: "\u0939\u093F\u0928\u094D\u0926\u0940" },
-  { code: "hu", label: "Magyar" },
-  { code: "id", label: "Indonesia" },
-  { code: "it", label: "Italiano" },
-  { code: "ja", label: "\u65E5\u672C\u8A9E" },
-  { code: "ko", label: "\uD55C\uAD6D\uC5B4" },
-  { code: "no", label: "Norsk" },
-  { code: "pl", label: "Polski" },
-  { code: "pt-PT", label: "Portugu\xEAs (PT)" },
-  { code: "pt-BR", label: "Portugu\xEAs (BR)" },
-  { code: "ro", label: "Rom\xE2n\u0103" },
-  { code: "ru", label: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439" },
-  { code: "sr", label: "\u0421\u0440\u043F\u0441\u043A\u0438" },
-  { code: "es-ES", label: "Espa\xF1ol" },
-  { code: "sv-SE", label: "Svenska" },
-  { code: "th", label: "\u0E44\u0E17\u0E22" },
-  { code: "tr", label: "T\xFCrk\xE7e" },
-  { code: "uk", label: "\u0423\u043A\u0440\u0430\u0457\u043D\u0441\u044C\u043A\u0430" },
-  { code: "vi", label: "Ti\u1EBFng Vi\u1EC7t" }
-];
 function LanguageRow({
   label,
   value,
@@ -5028,6 +5005,10 @@ function Auth({ onLogin }) {
       toast2.error(t2("auth.secondFactorUnavailable"));
       return;
     }
+    if (error?.response?.data?.code === "external_login_required") {
+      toast2.error(t2("auth.externalLoginRequired"));
+      return;
+    }
     toast2.error(
       error?.response?.data?.error || error?.message || t2(fallbackKey)
     );
@@ -30167,8 +30148,396 @@ function PassphraseDialog({
 // src/ui/ssh/dialogs/HostKeyVerificationDialog.tsx
 import { useState as useState18 } from "react";
 import { useTranslation as useTranslation18 } from "react-i18next";
+
+// node_modules/@noble/hashes/_u64.js
+var fromNumH = (n) => n / 2 ** 32 | 0;
+var fromNumL = (n) => n >>> 0;
+function setU64FromNum(view, byteOffset, n, isLE) {
+  const h = fromNumH(n);
+  const l = fromNumL(n);
+  view.setUint32(byteOffset, isLE ? l : h, isLE);
+  view.setUint32(byteOffset + 4, isLE ? h : l, isLE);
+}
+
+// node_modules/@noble/hashes/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
+}
+var atitle = (title) => title ? `"${title}" ` : "";
+function anumber(n, title = "") {
+  if (typeof n !== "number")
+    throw new TypeError(atitle(title) + "expected number, got " + typeof n);
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new RangeError(atitle(title) + "expected integer >= 0, got " + n);
+  return n;
+}
+function abytes(value, length, title = "") {
+  if (isBytes(value) && (length === void 0 || value.length === length))
+    return value;
+  if (length !== void 0)
+    anumber(length, "length");
+  const bytes = isBytes(value);
+  const ofLen = length !== void 0 ? ` of length ${length}` : "";
+  const got = bytes ? `length=${value.length}` : `type=${typeof value}`;
+  const message = atitle(title) + "expected Uint8Array" + ofLen + ", got " + got;
+  if (!bytes)
+    throw new TypeError(message);
+  throw new RangeError(message);
+}
+var aobject = (value, label) => {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    throw new TypeError((label === "object" ? "" : `"${label}" `) + "expected object, got type=" + typeof value);
+};
+var aopts = (value, label) => {
+  aobject(value, label);
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null)
+    throw new TypeError(`"${label}" expected plain object`);
+  if (Object.hasOwn(value, "__proto__"))
+    throw new TypeError(`"${label}.__proto__" is not allowed`);
+};
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("hash was destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("digest() was already called");
+}
+function aoutput(out, instance) {
+  abytes(out, void 0, "output");
+  const min = instance.outputLen;
+  if (!(out.length >= min)) {
+    throw new RangeError('"output" expected length >= ' + min);
+  }
+}
+function clean(...arrays) {
+  for (let i2 = 0; i2 < arrays.length; i2++) {
+    arrays[i2].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift2) {
+  return word << 32 - shift2 | word >>> shift2;
+}
+function checkOpts(defaults3, opts, title = "opts") {
+  aopts(defaults3, "defaults");
+  if (opts !== void 0)
+    aopts(opts, title);
+  const merged = Object.assign(/* @__PURE__ */ Object.create(null), defaults3, opts);
+  return merged;
+}
+function createHasher(hashCons, info = {}) {
+  if (typeof hashCons !== "function")
+    throw new TypeError('"hashCons" expected function, got type=' + typeof hashCons);
+  info = checkOpts({}, info, "info");
+  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+  const tmp = hashCons(void 0);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.canXOF = tmp.canXOF;
+  hashC.create = (opts) => hashCons(opts);
+  Object.assign(hashC, info);
+  return Object.freeze(hashC);
+}
+var oidNist = (suffix) => ({
+  // Current NIST hashAlgs suffixes used here fit in one DER subidentifier octet.
+  // Larger suffix values would need base-128 OID encoding and a different length byte.
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
+});
+
+// node_modules/@noble/hashes/_md.js
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+var HashMD = class {
+  blockLen;
+  outputLen;
+  canXOF = false;
+  padOffset;
+  isLE;
+  // For partial updates less than block size
+  buffer;
+  view;
+  finished = false;
+  length = 0;
+  pos = 0;
+  destroyed = false;
+  constructor(blockLen, outputLen, padOffset, isLE) {
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    abytes(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    let processed = false;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        processed = true;
+        continue;
+      }
+      buffer.set(pos === 0 && take === len ? data : data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+        processed = true;
+      }
+    }
+    this.length += data.length;
+    if (processed)
+      this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    buffer.fill(0, pos);
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      buffer.fill(0);
+    }
+    setU64FromNum(view, blockLen - 8, this.length * 8, isLE);
+    this.process(view, 0);
+    this.roundClean();
+    const oview = out === buffer ? view : createView(out);
+    const len = this.outputLen;
+    const outLen = len / 4;
+    const state = this.get();
+    if (len % 4 || outLen > state.length)
+      throw new Error("invalid outputLen");
+    for (let i2 = 0; i2 < outLen; i2++)
+      oview.setUint32(4 * i2, state[i2], isLE);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneIntoMeta(to) {
+    const { buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (pos)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+};
+var SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// node_modules/@noble/hashes/sha2.js
+var SHA256_K = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+var SHA2_32B = class extends HashMD {
+  // We cannot use array here since array allows indexing by variable
+  // which means optimizer/compiler cannot use registers.
+  // Numeric initializers matter: starting the fields as `undefined` changes
+  // V8's field representation and makes sha256 3x slower (measured).
+  A = 0;
+  B = 0;
+  C = 0;
+  D = 0;
+  E = 0;
+  F = 0;
+  G = 0;
+  H = 0;
+  constructor(outputLen, IV) {
+    super(64, outputLen, 8, false);
+    this.A = IV[0] | 0;
+    this.B = IV[1] | 0;
+    this.C = IV[2] | 0;
+    this.D = IV[3] | 0;
+    this.E = IV[4] | 0;
+    this.F = IV[5] | 0;
+    this.G = IV[6] | 0;
+    this.H = IV[7] | 0;
+  }
+  get() {
+    const { A, B, C: C2, D, E, F, G, H } = this;
+    return [A, B, C2, D, E, F, G, H];
+  }
+  // prettier-ignore
+  set(A, B, C2, D, E, F, G, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C2 | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  _cloneInto(to) {
+    (to ||= new this.constructor()).set(...this.get());
+    return this._cloneIntoMeta(to);
+  }
+  process(view, offset) {
+    for (let i2 = 0; i2 < 16; i2++, offset += 4)
+      SHA256_W[i2] = view.getUint32(offset, false);
+    for (let i2 = 16; i2 < 64; i2++) {
+      const W15 = SHA256_W[i2 - 15];
+      const W2 = SHA256_W[i2 - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i2] = s1 + SHA256_W[i2 - 7] + s0 + SHA256_W[i2 - 16] | 0;
+    }
+    let { A, B, C: C2, D, E, F, G, H } = this;
+    for (let i2 = 0; i2 < 64; i2++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i2] + SHA256_W[i2] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(A, B, C2) | 0;
+      H = G;
+      G = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C2;
+      C2 = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C2 = C2 + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G = G + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C2, D, E, F, G, H);
+  }
+  roundClean() {
+    clean(SHA256_W);
+  }
+  destroy() {
+    this.destroyed = true;
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+};
+var _SHA256 = class extends SHA2_32B {
+  constructor() {
+    super(32, SHA256_IV);
+  }
+};
+var sha256 = /* @__PURE__ */ createHasher(
+  () => new _SHA256(),
+  /* @__PURE__ */ oidNist(1)
+);
+
+// src/ui/lib/host-key-fingerprint.ts
+function hostKeyFingerprint(hex) {
+  if (!hex || hex.length % 2 !== 0 || !/^[0-9a-f]+$/i.test(hex)) return hex;
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i2 = 0; i2 < bytes.length; i2++) {
+    bytes[i2] = parseInt(hex.slice(i2 * 2, i2 * 2 + 2), 16);
+  }
+  let binary = "";
+  for (const byte of sha256(bytes)) binary += String.fromCharCode(byte);
+  return `SHA256:${btoa(binary).replace(/=+$/, "")}`;
+}
+
+// src/ui/ssh/dialogs/HostKeyVerificationDialog.tsx
 import { Fragment as Fragment7, jsx as jsx51, jsxs as jsxs35 } from "react/jsx-runtime";
-var formatFingerprint = (fp) => fp.match(/.{1,2}/g)?.join(":") || fp;
 function FingerprintRow({
   label,
   value,
@@ -30178,8 +30547,8 @@ function FingerprintRow({
   const { t: t2 } = useTranslation18();
   return /* @__PURE__ */ jsxs35("div", { className: "flex flex-col gap-1.5", children: [
     /* @__PURE__ */ jsx51("p", { className: "text-[10px] font-bold uppercase tracking-widest text-muted-foreground", children: label }),
-    /* @__PURE__ */ jsxs35("div", { className: "flex items-center gap-2", children: [
-      /* @__PURE__ */ jsx51("div", { className: "flex-1 bg-muted/50 border border-border p-3 font-mono text-xs break-all", children: formatFingerprint(value) }),
+    /* @__PURE__ */ jsxs35("div", { className: "flex items-stretch gap-2", children: [
+      /* @__PURE__ */ jsx51("div", { className: "flex-1 bg-muted/50 border border-border p-3 font-mono text-xs break-all", children: value }),
       /* @__PURE__ */ jsx51(
         "button",
         {
@@ -30187,7 +30556,7 @@ function FingerprintRow({
           onClick: onCopy,
           title: t2("common.copy"),
           "aria-label": t2("common.copy"),
-          className: `${PROMPT_BUTTON} size-8 shrink-0 px-0`,
+          className: "flex w-11 shrink-0 items-center justify-center border border-border text-muted-foreground transition-colors hover:bg-muted hover:text-foreground focus-visible:ring-1 focus-visible:ring-ring",
           children: copied ? /* @__PURE__ */ jsx51(Check, { className: "size-4 text-accent-brand" }) : /* @__PURE__ */ jsx51(Copy, { className: "size-4" })
         }
       )
@@ -30202,7 +30571,6 @@ function HostKeyVerificationDialog({
   hostname,
   fingerprint,
   oldFingerprint,
-  algorithm,
   onAccept,
   onReject,
   backgroundColor
@@ -30222,6 +30590,8 @@ function HostKeyVerificationDialog({
     }
   };
   const changed = scenario === "changed";
+  const newPrint = hostKeyFingerprint(fingerprint);
+  const oldPrint = hostKeyFingerprint(oldFingerprint || "");
   return /* @__PURE__ */ jsx51(
     PanePrompt,
     {
@@ -30261,18 +30631,18 @@ function HostKeyVerificationDialog({
           FingerprintRow,
           {
             label: t2("hostKey.previousKey"),
-            value: oldFingerprint || "",
+            value: oldPrint,
             copied: copiedOldFingerprint,
-            onCopy: () => copyFingerprint(oldFingerprint || "", true)
+            onCopy: () => copyFingerprint(oldPrint, true)
           }
         ),
         /* @__PURE__ */ jsx51(
           FingerprintRow,
           {
             label: t2("hostKey.newFingerprint"),
-            value: fingerprint,
+            value: newPrint,
             copied: copiedFingerprint,
-            onCopy: () => copyFingerprint(fingerprint)
+            onCopy: () => copyFingerprint(newPrint)
           }
         )
       ] }) : /* @__PURE__ */ jsxs35(Fragment7, { children: [
@@ -30286,10 +30656,10 @@ function HostKeyVerificationDialog({
         /* @__PURE__ */ jsx51(
           FingerprintRow,
           {
-            label: `${t2("hostKey.fingerprint")} (${algorithm.toUpperCase()})`,
-            value: fingerprint,
+            label: t2("hostKey.fingerprint"),
+            value: newPrint,
             copied: copiedFingerprint,
-            onCopy: () => copyFingerprint(fingerprint)
+            onCopy: () => copyFingerprint(newPrint)
           }
         ),
         /* @__PURE__ */ jsx51("p", { className: "text-[10px] text-muted-foreground", children: t2("hostKey.verifyInstructions") })
@@ -31140,7 +31510,7 @@ function gridClass(columns) {
     columns.xl && XL_COLS[columns.xl]
   );
 }
-function DataView({
+function DataView2({
   items,
   view,
   density,
@@ -31899,7 +32269,7 @@ export {
   ConnectionLogPanel,
   ConnectionLogProvider,
   ConnectionScreen,
-  DataView,
+  DataView2 as DataView,
   Dialog,
   DialogClose,
   DialogContent,

package/dist/host/{use-permissions-KIQCJ35M.js → use-permissions-2P2TP6GY.js}

@@ -7,7 +7,7 @@ import {
   resetPermissionsCache,
   setPermissionsForTesting,
   usePermissions
-} from "./chunk-O2OHNVFX.js";
+} from "./chunk-DIOJ3KW2.js";
 import "./chunk-YC2MAKSP.js";
 export {
   hasPermission,

package/dist/host-commands.js

@@ -17,7 +17,7 @@ export function execCommand(client, command, timeoutMs = 30000) {
             if (!settled) {
                 settled = true;
                 cleanup();
-                reject(new Error(`Command timeout after ${timeoutMs}ms: ${command}`));
+                reject(new Error(`Command timeout after ${timeoutMs}ms`));
             }
         }, timeoutMs);
         const cleanup = () => {