@hienlh/ppm 0.17.38 → 0.17.40

package/src/web/components/terminal/terminal-finish-login.tsx

@@ -0,0 +1,75 @@
+/**
+ * Completes a CLI login that was started here and signed in on another device.
+ *
+ * The CLI is listening on a loopback port of the machine PPM runs on, but the
+ * browser that signed in was redirected to *its own* loopback address, so the
+ * result never arrived. Typing into the terminal will not help either — the CLI
+ * is holding it open, waiting. The server shares a host with the CLI, so it
+ * makes the call on the browser's behalf.
+ */
+import { useState } from "react";
+import { Loader2, LogIn } from "lucide-react";
+import { api } from "@/lib/api-client";
+import { isDeliverableCallback } from "@/lib/oauth-loopback-url";
+import { toast } from "sonner";
+
+interface TerminalFinishLoginProps {
+  onDone: () => void;
+}
+
+export function TerminalFinishLogin({ onDone }: TerminalFinishLoginProps) {
+  const [url, setUrl] = useState("");
+  const [sending, setSending] = useState(false);
+
+  const trimmed = url.trim();
+  const ready = !sending && isDeliverableCallback(trimmed);
+
+  const send = async () => {
+    setSending(true);
+    try {
+      await api.post("/api/loopback/callback", { url: trimmed });
+      toast.success("Sent to the waiting command", { duration: 2000 });
+      setUrl("");
+      onDone();
+    } catch (e) {
+      toast.error((e as Error).message, { duration: 4000 });
+    } finally {
+      setSending(false);
+    }
+  };
+
+  return (
+    <div className="shrink-0 border-t border-border px-3 py-3">
+      <p className="pb-2 text-[11px] leading-snug text-text-secondary">
+        Finished signing in and landed on a page that would not load? Paste that address here —
+        the machine will deliver it to the command still waiting.
+      </p>
+      <div className="flex items-center gap-2">
+        <input
+          value={url}
+          onChange={(e) => setUrl(e.target.value)}
+          inputMode="url"
+          autoCapitalize="off"
+          autoCorrect="off"
+          spellCheck={false}
+          placeholder="http://127.0.0.1:54132/oauth/callback?code=…"
+          aria-label="Callback address"
+          className="h-11 min-w-0 flex-1 rounded-lg border border-border bg-surface px-3 font-mono text-xs text-foreground placeholder:text-text-subtle"
+        />
+        <button
+          onClick={() => void send()}
+          disabled={!ready}
+          aria-label="Finish login"
+          className="flex size-11 shrink-0 items-center justify-center rounded-lg bg-primary text-primary-foreground disabled:opacity-40 active:opacity-80 transition-opacity"
+        >
+          {sending ? <Loader2 className="size-4 animate-spin" /> : <LogIn className="size-4" />}
+        </button>
+      </div>
+      {trimmed !== "" && !isDeliverableCallback(trimmed) && (
+        <p className="pt-1.5 text-[11px] text-error">
+          Needs to be the http://127.0.0.1:… address the sign-in redirected to.
+        </p>
+      )}
+    </div>
+  );
+}

package/src/web/components/terminal/terminal-links-sheet.tsx

@@ -4,10 +4,15 @@
  * xterm resolves a link from a mouse hover and opens it on mouseup, so a touch
  * device can never activate one — and without touch selection the URL cannot be
  * copied out either. This sheet is the touch path to both.
+ *
+ * It also carries the way out of a login started here but finished on another
+ * device: see TerminalFinishLogin.
  */
 import { ExternalLink, Copy, Link2Off } from "lucide-react";
 import { BottomSheet } from "@/components/ui/mobile-bottom-sheet";
 import { copyToClipboard } from "@/lib/clipboard";
+import { loopbackRedirectPort } from "@/lib/oauth-loopback-url";
+import { TerminalFinishLogin } from "./terminal-finish-login";
 import { toast } from "sonner";
 
 interface TerminalLinksSheetProps {
@@ -23,6 +28,10 @@ export function TerminalLinksSheet({ open, onClose, urls }: TerminalLinksSheetPr
     onClose();
   };
 
+  // Ports any listed login will redirect back to. Their presence is what makes
+  // the finish-login step relevant, so it stays hidden the rest of the time.
+  const loopbackPorts = [...new Set(urls.map(loopbackRedirectPort).filter((p): p is string => !!p))];
+
   return (
     // Above the mobile dock sheet (z-60) this is opened from, or it renders
     // behind the dock and cannot be reached at all.
@@ -31,36 +40,50 @@ export function TerminalLinksSheet({ open, onClose, urls }: TerminalLinksSheetPr
         {urls.length > 0 ? `Links in terminal (${urls.length})` : "Links in terminal"}
       </div>
 
-      {urls.length === 0 ? (
-        <div className="flex flex-col items-center gap-2 px-4 py-8 text-center text-sm text-text-secondary">
-          <Link2Off className="size-5 text-text-subtle" />
-          No links found in the visible scrollback.
-        </div>
-      ) : (
-        <div className="flex-1 min-h-0 overflow-y-auto px-2 pb-2">
-          {urls.map((url) => (
-            <div key={url} className="flex items-stretch gap-1">
-              <a
-                href={url}
-                target="_blank"
-                rel="noreferrer noopener"
-                onClick={onClose}
-                className="flex min-h-11 flex-1 min-w-0 items-center gap-2 rounded-lg px-3 py-2 text-sm text-foreground active:bg-accent transition-colors"
-              >
-                <ExternalLink className="size-4 shrink-0 text-text-subtle" />
-                <span className="min-w-0 flex-1 truncate text-left font-mono text-xs">{url}</span>
-              </a>
-              <button
-                onClick={() => void handleCopy(url)}
-                aria-label={`Copy ${url}`}
-                className="flex size-11 shrink-0 items-center justify-center rounded-lg text-text-secondary active:bg-accent transition-colors"
-              >
-                <Copy className="size-4" />
-              </button>
-            </div>
-          ))}
-        </div>
-      )}
+      <div className="flex-1 min-h-0 overflow-y-auto px-2 pb-2">
+        {urls.length === 0 ? (
+          <div className="flex flex-col items-center gap-2 px-4 py-8 text-center text-sm text-text-secondary">
+            <Link2Off className="size-5 text-text-subtle" />
+            No links found in the visible scrollback.
+          </div>
+        ) : (
+          urls.map((url) => {
+            const port = loopbackRedirectPort(url);
+            return (
+              <div key={url}>
+                <div className="flex items-stretch gap-1">
+                  <a
+                    href={url}
+                    target="_blank"
+                    rel="noreferrer noopener"
+                    onClick={onClose}
+                    className="flex min-h-11 flex-1 min-w-0 items-center gap-2 rounded-lg px-3 py-2 text-sm text-foreground active:bg-accent transition-colors"
+                  >
+                    <ExternalLink className="size-4 shrink-0 text-text-subtle" />
+                    <span className="min-w-0 flex-1 truncate text-left font-mono text-xs">{url}</span>
+                  </a>
+                  <button
+                    onClick={() => void handleCopy(url)}
+                    aria-label={`Copy ${url}`}
+                    className="flex size-11 shrink-0 items-center justify-center rounded-lg text-text-secondary active:bg-accent transition-colors"
+                  >
+                    <Copy className="size-4" />
+                  </button>
+                </div>
+                {port && (
+                  <p className="px-3 pb-2 text-[11px] leading-snug text-text-secondary">
+                    Signing in here sends you back to port {port} <strong>on the machine</strong>,
+                    not this device — so the terminal keeps waiting. Afterwards, paste the address
+                    bar below to finish it.
+                  </p>
+                )}
+              </div>
+            );
+          })
+        )}
+      </div>
+
+      {loopbackPorts.length > 0 && <TerminalFinishLogin onDone={onClose} />}
     </BottomSheet>
   );
 }

package/src/web/components/ui/mobile-bottom-sheet.tsx

@@ -6,10 +6,11 @@
  * Also exports context-menu-specific sub-components (BottomSheetItem, etc.)
  * used by adaptive-context-menu.tsx.
  */
-import { createContext, useContext, useEffect, useState, type ReactNode } from "react";
+import { createContext, useContext, type ReactNode } from "react";
 import { createPortal } from "react-dom";
 import { cn } from "@/lib/utils";
 import { useSwipeToDismiss } from "@/hooks/use-swipe-to-dismiss";
+import { useVisualViewport } from "@/hooks/use-visual-viewport";
 
 /* ------------------------------------------------------------------ */
 /*  Core BottomSheet — reusable everywhere                             */
@@ -33,44 +34,46 @@ export function BottomSheet({ open, onClose, children, className, zIndex = 50 }:
   const { dragY, swipeHandlers, dragStyle, backdropOpacity, isDragging } =
     useSwipeToDismiss(onClose);
 
-  // Follow the visual viewport so the panel rides above the on-screen keyboard.
-  // A `fixed inset-0` container is anchored to the layout viewport, which does
-  // not shrink when the keyboard opens — so `bottom-0` would sit behind it.
-  // Constraining the container to the visual viewport keeps the panel visible.
-  const [vv, setVv] = useState<{ top: number; height: number } | null>(null);
-  useEffect(() => {
-    const viewport = window.visualViewport;
-    if (!open || !viewport) return;
-    const update = () => setVv({ top: viewport.offsetTop, height: viewport.height });
-    update();
-    viewport.addEventListener("resize", update);
-    viewport.addEventListener("scroll", update);
-    return () => {
-      viewport.removeEventListener("resize", update);
-      viewport.removeEventListener("scroll", update);
-    };
-  }, [open]);
+  // Keyboard-aware geometry. The backdrop deliberately keeps covering the whole
+  // layout viewport while only the panel tracks the keyboard: if the two ever
+  // disagree by a few pixels, the seam shows as dimmed backdrop rather than a
+  // strip of untouched page.
+  const insets = useVisualViewport(open);
 
   if (!open) return null;
 
-  // When tracking the visual viewport, pin the container to it (top + height,
-  // bottom auto) instead of the full-page inset-0 default.
-  const containerStyle = vv
-    ? { zIndex, top: `${vv.top}px`, height: `${vv.height}px`, bottom: "auto" as const }
-    : { zIndex };
+  // The panel keeps its footing on the bottom of the screen and only its
+  // *contents* are lifted clear of the keyboard, by padding. Moving the panel
+  // itself is what left a hole: the keyboard's height can only be estimated, and
+  // an estimate that is short drags the panel's background up with it, exposing
+  // the page. Padding an anchored panel degrades instead — a bad estimate puts
+  // the toolbar slightly off, over a background that still reaches the bottom.
+  //
+  // `--sheet-vh` is what is visible and `--sheet-kb` what the keyboard covers,
+  // so a panel can ask for "the visible area" and still span to the screen edge.
+  const frameStyle = {
+    zIndex,
+    "--sheet-vh": insets ? `${insets.height}px` : "100dvh",
+    "--sheet-kb": insets ? `${insets.keyboardInset}px` : "0px",
+  } as React.CSSProperties;
 
   return createPortal(
-    <div className="fixed inset-0" style={containerStyle} onClick={onClose}>
+    <div className="fixed inset-0" style={frameStyle} onClick={onClose}>
       {/* Backdrop */}
       <div
         className="absolute inset-0 bg-black/40 animate-in fade-in-0 duration-200"
         style={isDragging ? { opacity: backdropOpacity } : undefined}
       />
-      {/* Panel */}
+      {/* Panel. Padding does double duty: it clears the home indicator when the
+          keyboard is down, and the keyboard itself when it is up. A panel sized
+          in `--sheet-vh` must add `--sheet-kb` back, since the padding is inside
+          that height. */}
       <div
         className={cn(
           "absolute bottom-0 left-0 right-0 rounded-t-2xl bg-popover text-popover-foreground border-t border-border",
-          "pb-[max(0.5rem,env(safe-area-inset-bottom))]",
+          insets?.keyboardOpen
+            ? "pb-[var(--sheet-kb,0px)]"
+            : "pb-[max(0.5rem,env(safe-area-inset-bottom))]",
           !isDragging && "animate-in slide-in-from-bottom duration-200",
           className,
         )}

package/src/web/hooks/use-chat.ts

@@ -829,18 +829,19 @@ export function useChat(sessionId: string | null, providerId = "claude", project
 
     if (sessionId && projectName) {
       setMessagesLoading(true);
-      fetch(`${projectUrl(projectName)}/chat/sessions/${sessionId}/messages?providerId=${providerId}`, {
-        headers: { Authorization: `Bearer ${getAuthToken()}` },
-      })
-        .then((r) => r.json())
-        .then((json: any) => {
+      // Via api.get, not raw fetch: the loading screen is gated on this settling,
+      // and a stalled request would otherwise hold the transcript hostage until
+      // a page reload.
+      api
+        .get<any>(
+          `${projectUrl(projectName)}/chat/sessions/${sessionId}/messages?providerId=${providerId}`,
+        )
+        .then((data: any) => {
           if (cancelled) return;
           // Tolerate the pre-versionMap shape (a bare array): a browser running a
           // cached bundle from before the upgrade would otherwise render an empty
           // history with no error.
-          const payload = json.ok
-            ? (Array.isArray(json.data) ? { messages: json.data, versionMap: {} } : json.data)
-            : null;
+          const payload = Array.isArray(data) ? { messages: data, versionMap: {} } : data;
           let history: ChatMessage[] = Array.isArray(payload?.messages) ? payload.messages : [];
           if (payload?.versionMap) setVersionMap(payload.versionMap);
           // If a live turn_events replay already owns the active (unfinished) turn,

package/src/web/hooks/use-terminal.ts

@@ -44,6 +44,8 @@ const URL_TRAILING_PUNCT = /[).,;:'"\]}>]+$/;
 const URL_PATTERN = /\bhttps?:\/\/[^\s<>"'`]+/g;
 /** Cap the scan so a 50k-line scrollback never blocks the tap that triggered it. */
 const URL_SCAN_MAX_ROWS = 5000;
+/** Quiet period before refitting to a new container size, in ms. */
+const RESIZE_SETTLE_MS = 100;
 
 const RESIZE_PREFIX = "\x01RESIZE:";
 const PING_MSG = "\x01PING";
@@ -363,16 +365,24 @@ export function useTerminal(
     };
     document.addEventListener("visibilitychange", onVisibility);
 
-    // ResizeObserver for auto-fit — skip when tab is hidden (0 dimensions)
+    // ResizeObserver for auto-fit — skip when tab is hidden (0 dimensions).
+    // Debounced: an on-screen keyboard resizes the container many times as it
+    // slides, and refitting on each one sends the shell a burst of size changes
+    // that it answers by redrawing, so the output visibly churns. One fit once
+    // the size settles gives the same result without the churn.
+    let fitTimer: ReturnType<typeof setTimeout> | null = null;
     const resizeObserver = new ResizeObserver((entries) => {
       const entry = entries[0];
       if (!entry || entry.contentRect.width === 0 || entry.contentRect.height === 0) return;
-      try {
-        fitAddon.fit();
-        sendResize();
-      } catch {
-        // Ignore fit errors during teardown
-      }
+      if (fitTimer) clearTimeout(fitTimer);
+      fitTimer = setTimeout(() => {
+        try {
+          fitAddon.fit();
+          sendResize();
+        } catch {
+          // Ignore fit errors during teardown
+        }
+      }, RESIZE_SETTLE_MS);
     });
     resizeObserver.observe(container);
 
@@ -384,6 +394,7 @@ export function useTerminal(
 
     return () => {
       unsubTheme();
+      if (fitTimer) clearTimeout(fitTimer);
       resizeObserver.disconnect();
       clearInterval(heartbeatInterval);
       document.removeEventListener("visibilitychange", onVisibility);

package/src/web/hooks/use-usage.ts

@@ -1,5 +1,5 @@
 import { useState, useCallback, useEffect, useRef } from "react";
-import { getAuthToken, projectUrl } from "@/lib/api-client";
+import { api, projectUrl } from "@/lib/api-client";
 import type { UsageInfo } from "../../types/chat";
 
 const POLL_INTERVAL = 120_000; // read cache every 2min
@@ -22,15 +22,16 @@ export function useUsage(projectName: string, providerId = "claude"): UseUsageRe
     if (!projectName) return;
     setUsageLoading(true);
     const qs = forceRefresh ? "&refresh=1" : "";
-    fetch(`${projectUrl(projectName)}/chat/usage?providerId=${providerId}${qs}`, {
-      headers: { Authorization: `Bearer ${getAuthToken()}` },
-    })
-      .then((r) => r.json())
-      .then((json: any) => {
-        if (json.ok && json.data) {
-          setUsageInfo((prev) => ({ ...prev, ...json.data }));
-          if (json.data.lastFetchedAt) setLastFetchedAt(json.data.lastFetchedAt);
-        }
+    // Via api.get, not raw fetch: the toolbar's loading state is gated on this
+    // settling, and a raw fetch has no timeout to stop it stalling forever.
+    api
+      .get<(UsageInfo & { lastFetchedAt?: string }) | null>(
+        `${projectUrl(projectName)}/chat/usage?providerId=${providerId}${qs}`,
+      )
+      .then((data) => {
+        if (!data) return;
+        setUsageInfo((prev) => ({ ...prev, ...data }));
+        if (data.lastFetchedAt) setLastFetchedAt(data.lastFetchedAt);
       })
       .catch(() => {})
       .finally(() => setUsageLoading(false));

package/src/web/hooks/use-visual-viewport.ts

@@ -0,0 +1,83 @@
+/**
+ * Measures the part of the screen the user can actually see, and how much of it
+ * the on-screen keyboard is occupying.
+ *
+ * `vh`/`dvh` units and a `fixed` element both resolve against the layout
+ * viewport, which does not shrink when a keyboard opens — so anything anchored
+ * to the bottom ends up behind it. Only `visualViewport` reports the truth.
+ *
+ * Updates are applied on the frame they arrive rather than after a settle
+ * delay: iOS emits intermediate sizes throughout the keyboard's slide and its
+ * final event can land before the layout has finished moving, so deferring is
+ * what leaves geometry stale — visibly, as a strip of untouched page below a
+ * panel that should be flush with the keyboard.
+ */
+import { useEffect, useState } from "react";
+
+export interface ViewportInsets {
+  /** Height of the visible area, in px. */
+  height: number;
+  /**
+   * Roughly how much the keyboard covers, in px.
+   *
+   * Approximate on purpose: `innerHeight` on iOS counts space behind browser
+   * chrome, so this can be off by a bar's height. Use it to inset content, never
+   * to place a background — an inset that is slightly wrong shifts content a
+   * little, whereas a background placed the same way leaves a visible hole.
+   */
+  keyboardInset: number;
+  /** Whether the missing height is big enough to be a keyboard, not browser chrome. */
+  keyboardOpen: boolean;
+}
+
+/** Below this, the missing height is a collapsed address bar, not a keyboard. */
+const KEYBOARD_MIN_INSET = 120;
+
+function measure(viewport: VisualViewport): ViewportInsets {
+  const inset = Math.max(0, window.innerHeight - viewport.height - viewport.offsetTop);
+  return {
+    height: viewport.height,
+    keyboardInset: inset,
+    keyboardOpen: inset >= KEYBOARD_MIN_INSET,
+  };
+}
+
+/** Live viewport insets, or null when unsupported or while `active` is false. */
+export function useVisualViewport(active: boolean): ViewportInsets | null {
+  const [insets, setInsets] = useState<ViewportInsets | null>(null);
+
+  useEffect(() => {
+    const viewport = window.visualViewport;
+    if (!active || !viewport) {
+      setInsets(null);
+      return;
+    }
+
+    // Several resize/scroll events can fire per frame; one read per frame is
+    // enough and keeps React from rendering the same geometry repeatedly.
+    let frame: number | null = null;
+    const update = () => {
+      frame = null;
+      setInsets((prev) => {
+        const next = measure(viewport);
+        return prev && prev.height === next.height && prev.keyboardInset === next.keyboardInset
+          ? prev
+          : next;
+      });
+    };
+    const schedule = () => {
+      if (frame === null) frame = requestAnimationFrame(update);
+    };
+
+    update();
+    viewport.addEventListener("resize", schedule);
+    viewport.addEventListener("scroll", schedule);
+    return () => {
+      if (frame !== null) cancelAnimationFrame(frame);
+      viewport.removeEventListener("resize", schedule);
+      viewport.removeEventListener("scroll", schedule);
+    };
+  }, [active]);
+
+  return insets;
+}

package/src/web/lib/api-client.ts

@@ -14,7 +14,7 @@ function warnOnAuditFailure(res: Response): void {
 }
 
 /** GETs currently awaiting a response, keyed by absolute URL. See ApiClient.get. */
-const pendingGets = new Map<string, Promise<unknown>>();
+const pendingGets = new Map<string, { promise: Promise<unknown>; startedAt: number }>();
 
 /**
  * How long a GET may wait for response headers. Browsers do not time a stalled
@@ -64,6 +64,11 @@ export class ApiClient {
    * other on a single tab open. This is in-flight sharing only, NOT a response
    * cache: the entry is dropped as soon as it settles, so nothing goes stale.
    *
+   * Sharing is also capped in time. The response timer stops once headers
+   * arrive, so a request that stalls midway through its body never settles —
+   * and an unsettled entry must not hold back every later caller of that URL.
+   * Past that window a new caller starts its own request instead.
+   *
    * Requests carrying an AbortSignal opt out — one caller aborting must not cancel
    * another's request.
    */
@@ -71,12 +76,18 @@ export class ApiClient {
     if (options?.signal) return this.rawGet<T>(path, options.signal);
 
     const key = `${this.baseUrl}${path}`;
-    const inFlight = pendingGets.get(key);
-    if (inFlight) return inFlight as Promise<T>;
+    const entry = pendingGets.get(key);
+    if (entry && Date.now() - entry.startedAt < this.responseTimeoutMs) {
+      return entry.promise as Promise<T>;
+    }
 
-    const p = this.rawGet<T>(path).finally(() => pendingGets.delete(key));
-    pendingGets.set(key, p);
-    return p;
+    const promise = this.rawGet<T>(path).finally(() => {
+      // Drop only our own entry — an abandoned request settling late must not
+      // evict the newer one that replaced it.
+      if (pendingGets.get(key)?.promise === promise) pendingGets.delete(key);
+    });
+    pendingGets.set(key, { promise, startedAt: Date.now() });
+    return promise;
   }
 
   private async rawGet<T>(path: string, signal?: AbortSignal): Promise<T> {

package/src/web/lib/oauth-loopback-url.ts

@@ -0,0 +1,55 @@
+/**
+ * Recognises OAuth authorization URLs that hand their result back to a port on
+ * the machine running the CLI, rather than to whatever device opened them.
+ *
+ * This is what strands a login started from a phone: the sign-in succeeds, the
+ * browser is redirected to 127.0.0.1:<port>, and on the phone that address is
+ * the phone itself — so the CLI waiting on the real machine never hears back.
+ */
+
+const LOOPBACK_HOSTNAMES = new Set(["localhost", "::1"]);
+
+/** Whether a hostname addresses the machine the browser is running on. */
+export function isLoopbackHostname(hostname: string): boolean {
+  const host = hostname.replace(/^\[|\]$/g, "").toLowerCase();
+  if (LOOPBACK_HOSTNAMES.has(host)) return true;
+  return /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(host);
+}
+
+/**
+ * The loopback port an authorization URL will redirect back to, or null when it
+ * redirects somewhere reachable from any device.
+ */
+export function loopbackRedirectPort(url: string): string | null {
+  let parsed: URL;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return null;
+  }
+  // `redirect_uri` is the OAuth 2.0 name; some tools still send `redirectUri`.
+  const redirect =
+    parsed.searchParams.get("redirect_uri") ?? parsed.searchParams.get("redirectUri");
+  if (!redirect) return null;
+
+  try {
+    const target = new URL(redirect);
+    if (!isLoopbackHostname(target.hostname)) return null;
+    return target.port || (target.protocol === "https:" ? "443" : "80");
+  } catch {
+    return null;
+  }
+}
+
+/** Whether a pasted string is a callback this machine could deliver. */
+export function isDeliverableCallback(url: string): boolean {
+  try {
+    const parsed = new URL(url.trim());
+    return (
+      (parsed.protocol === "http:" || parsed.protocol === "https:") &&
+      isLoopbackHostname(parsed.hostname)
+    );
+  } catch {
+    return false;
+  }
+}

package/dist/web/assets/api-client-BwMdPtp6.js

@@ -1 +0,0 @@
-import"./vendor-markdown-CKTlmXbz.js";import"./vendor-ui-DMRGWRuc.js";import{i as e,n as t}from"./api-client-BgM59GxL.js";export{t as api,e as projectUrl};

package/dist/web/assets/api-settings-D2fY0GUc.js

@@ -1 +0,0 @@
-import"./vendor-markdown-CKTlmXbz.js";import"./vendor-ui-DMRGWRuc.js";import"./api-client-BgM59GxL.js";import{v as e}from"./api-settings-D108koFG.js";export{e as updateDeviceName};