@termix-ssh/plugin-sdk 1.0.10 → 1.0.12

package/dist/host/{chunk-NZG6HNQH.js → chunk-RUPLD6RF.js}

@@ -1,10 +1,15 @@
 const __termixNoGlob = () => ({});
 import {
   __export,
-  define_import_meta_env_default
-} from "./chunk-YC2MAKSP.js";
+  define_import_meta_env_default,
+  init_define_import_meta_env
+} from "./chunk-YGYBM7SQ.js";
+
+// src/ui/lib/linked-server.ts
+init_define_import_meta_env();
 
 // src/ui/lib/electron.ts
+init_define_import_meta_env();
 function isElectron() {
   if (typeof window === "undefined") return false;
   const win = window;
@@ -13,13 +18,33 @@ function isElectron() {
   const isElectronProp = win.electronAPI?.isElectron === true;
   return hasISElectron || hasElectronAPI || isElectronProp;
 }
+var DEFAULT_LOCAL_BACKEND_PORT = 30001;
+function localBackendPort() {
+  if (typeof window === "undefined") return DEFAULT_LOCAL_BACKEND_PORT;
+  const port = window.electronAPI?.backendPort;
+  return typeof port === "number" && Number.isInteger(port) && port > 0 && port < 65536 ? port : DEFAULT_LOCAL_BACKEND_PORT;
+}
+
+// src/ui/main-axios.ts
+init_define_import_meta_env();
 
 // src/ui/lib/error-message.ts
+init_define_import_meta_env();
 function getErrorMessage(error, fallback = "Unknown error") {
   return error instanceof Error ? error.message : fallback;
 }
 
+// node_modules/axios/index.js
+init_define_import_meta_env();
+
+// node_modules/axios/lib/axios.js
+init_define_import_meta_env();
+
+// node_modules/axios/lib/utils.js
+init_define_import_meta_env();
+
 // node_modules/axios/lib/helpers/bind.js
+init_define_import_meta_env();
 function bind(fn, thisArg) {
   return function wrap() {
     return fn.apply(thisArg, arguments);
@@ -574,7 +599,26 @@ var utils_default = {
   isSafeIterable
 };
 
+// node_modules/axios/lib/core/Axios.js
+init_define_import_meta_env();
+
+// node_modules/axios/lib/helpers/buildURL.js
+init_define_import_meta_env();
+
+// node_modules/axios/lib/helpers/AxiosURLSearchParams.js
+init_define_import_meta_env();
+
+// node_modules/axios/lib/helpers/toFormData.js
+init_define_import_meta_env();
+
+// node_modules/axios/lib/core/AxiosError.js
+init_define_import_meta_env();
+
+// node_modules/axios/lib/core/AxiosHeaders.js
+init_define_import_meta_env();
+
 // node_modules/axios/lib/helpers/parseHeaders.js
+init_define_import_meta_env();
 var ignoreDuplicateOf = utils_default.toObjectSet([
   "age",
   "authorization",
@@ -621,6 +665,7 @@ var parseHeaders_default = (rawHeaders) => {
 };
 
 // node_modules/axios/lib/helpers/sanitizeHeaderValue.js
+init_define_import_meta_env();
 function trimSPorHTAB(str) {
   let start = 0;
   let end = str.length;
@@ -1154,6 +1199,7 @@ AxiosError.ERR_FORM_DATA_DEPTH_EXCEEDED = "ERR_FORM_DATA_DEPTH_EXCEEDED";
 var AxiosError_default = AxiosError;
 
 // node_modules/axios/lib/helpers/null.js
+init_define_import_meta_env();
 var null_default = null;
 
 // node_modules/axios/lib/helpers/toFormData.js
@@ -1364,6 +1410,7 @@ function buildURL(url, params, options) {
 }
 
 // node_modules/axios/lib/core/InterceptorManager.js
+init_define_import_meta_env();
 var $internals2 = /* @__PURE__ */ Symbol("internals");
 function countHandlers(handlers) {
   return handlers ? handlers.length : 0;
@@ -1501,7 +1548,17 @@ var InterceptorManager = class {
 };
 var InterceptorManager_default = InterceptorManager;
 
+// node_modules/axios/lib/core/dispatchRequest.js
+init_define_import_meta_env();
+
+// node_modules/axios/lib/core/transformData.js
+init_define_import_meta_env();
+
+// node_modules/axios/lib/defaults/index.js
+init_define_import_meta_env();
+
 // node_modules/axios/lib/defaults/transitional.js
+init_define_import_meta_env();
 var transitional_default = {
   silentJSONParsing: true,
   forcedJSONParsing: true,
@@ -1511,13 +1568,25 @@ var transitional_default = {
   validateStatusUndefinedResolves: true
 };
 
+// node_modules/axios/lib/helpers/toURLEncodedForm.js
+init_define_import_meta_env();
+
+// node_modules/axios/lib/platform/index.js
+init_define_import_meta_env();
+
+// node_modules/axios/lib/platform/browser/index.js
+init_define_import_meta_env();
+
 // node_modules/axios/lib/platform/browser/classes/URLSearchParams.js
+init_define_import_meta_env();
 var URLSearchParams_default = typeof URLSearchParams !== "undefined" ? URLSearchParams : AxiosURLSearchParams_default;
 
 // node_modules/axios/lib/platform/browser/classes/FormData.js
+init_define_import_meta_env();
 var FormData_default = typeof FormData !== "undefined" ? FormData : null;
 
 // node_modules/axios/lib/platform/browser/classes/Blob.js
+init_define_import_meta_env();
 var Blob_default = typeof Blob !== "undefined" ? Blob : null;
 
 // node_modules/axios/lib/platform/browser/index.js
@@ -1540,6 +1609,7 @@ __export(utils_exports, {
   navigator: () => _navigator,
   origin: () => origin
 });
+init_define_import_meta_env();
 var hasBrowserEnv = typeof window !== "undefined" && typeof document !== "undefined";
 var _navigator = typeof navigator === "object" && navigator || void 0;
 var hasStandardBrowserEnv = hasBrowserEnv && (!_navigator || ["ReactNative", "NativeScript", "NS"].indexOf(_navigator.product) < 0);
@@ -1570,6 +1640,7 @@ function toURLEncodedForm(data, options) {
 }
 
 // node_modules/axios/lib/helpers/formDataToJSON.js
+init_define_import_meta_env();
 var MAX_DEPTH = DEFAULT_FORM_DATA_MAX_DEPTH;
 function throwIfDepthExceeded(index) {
   if (index > MAX_DEPTH) {
@@ -1638,6 +1709,7 @@ function formDataToJSON(formData) {
 var formDataToJSON_default = formDataToJSON;
 
 // node_modules/axios/lib/core/methodList.js
+init_define_import_meta_env();
 var methodList = Object.freeze([
   "get",
   "delete",
@@ -1784,11 +1856,13 @@ function transformData(fns, response) {
 }
 
 // node_modules/axios/lib/cancel/isCancel.js
+init_define_import_meta_env();
 function isCancel(value) {
   return !!(value && value.__CANCEL__);
 }
 
 // node_modules/axios/lib/cancel/CanceledError.js
+init_define_import_meta_env();
 var CanceledError = class extends AxiosError_default {
   /**
    * A `CanceledError` is an object that is thrown when an operation is canceled.
@@ -1807,7 +1881,14 @@ var CanceledError = class extends AxiosError_default {
 };
 var CanceledError_default = CanceledError;
 
+// node_modules/axios/lib/adapters/adapters.js
+init_define_import_meta_env();
+
+// node_modules/axios/lib/adapters/xhr.js
+init_define_import_meta_env();
+
 // node_modules/axios/lib/core/settle.js
+init_define_import_meta_env();
 function settle(resolve, reject, response) {
   const validateStatus2 = response.config.validateStatus;
   if (!response.status || !validateStatus2 || validateStatus2(response.status)) {
@@ -1824,6 +1905,7 @@ function settle(resolve, reject, response) {
 }
 
 // node_modules/axios/lib/helpers/normalizeURLForProtocolCheck.js
+init_define_import_meta_env();
 var urlParserControlCharacters = /[\t\n\r]/g;
 function normalizeURLForProtocolCheck(url) {
   if (typeof url !== "string") {
@@ -1837,12 +1919,17 @@ function normalizeURLForProtocolCheck(url) {
 }
 
 // node_modules/axios/lib/helpers/parseProtocol.js
+init_define_import_meta_env();
 function parseProtocol(url) {
   const match = /^([-+\w]{1,25}):(?:\/\/)?/.exec(url);
   return match && match[1] || "";
 }
 
+// node_modules/axios/lib/helpers/progressEventReducer.js
+init_define_import_meta_env();
+
 // node_modules/axios/lib/helpers/speedometer.js
+init_define_import_meta_env();
 function speedometer(samplesCount, min) {
   samplesCount = samplesCount || 10;
   const bytes = new Array(samplesCount);
@@ -1879,6 +1966,7 @@ function speedometer(samplesCount, min) {
 var speedometer_default = speedometer;
 
 // node_modules/axios/lib/helpers/throttle.js
+init_define_import_meta_env();
 function throttle(fn, freq) {
   let timestamp = 0;
   let threshold = 1e3 / freq;
@@ -1955,7 +2043,11 @@ var progressEventDecorator = (total, throttled) => {
 };
 var asyncDecorator = (fn, scheduler = utils_default.asap) => (...args) => scheduler(() => fn(...args));
 
+// node_modules/axios/lib/helpers/resolveConfig.js
+init_define_import_meta_env();
+
 // node_modules/axios/lib/helpers/isURLSameOrigin.js
+init_define_import_meta_env();
 var isURLSameOrigin_default = platform_default.hasStandardBrowserEnv ? /* @__PURE__ */ ((origin2, isMSIE) => (url) => {
   url = new URL(url, platform_default.origin);
   return origin2.protocol === url.protocol && origin2.host === url.host && (isMSIE || origin2.port === url.port);
@@ -1965,6 +2057,7 @@ var isURLSameOrigin_default = platform_default.hasStandardBrowserEnv ? /* @__PUR
 ) : () => true;
 
 // node_modules/axios/lib/helpers/cookies.js
+init_define_import_meta_env();
 var cookies_default = platform_default.hasStandardBrowserEnv ? (
   // Standard browser envs support document.cookie
   {
@@ -2021,7 +2114,11 @@ var cookies_default = platform_default.hasStandardBrowserEnv ? (
   }
 );
 
+// node_modules/axios/lib/core/buildFullPath.js
+init_define_import_meta_env();
+
 // node_modules/axios/lib/helpers/isAbsoluteURL.js
+init_define_import_meta_env();
 function isAbsoluteURL(url) {
   if (typeof url !== "string") {
     return false;
@@ -2030,6 +2127,7 @@ function isAbsoluteURL(url) {
 }
 
 // node_modules/axios/lib/helpers/combineURLs.js
+init_define_import_meta_env();
 function combineURLs(baseURL, relativeURL) {
   if (!relativeURL) {
     return baseURL;
@@ -2087,6 +2185,7 @@ function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls, config) {
 }
 
 // node_modules/axios/lib/core/mergeConfig.js
+init_define_import_meta_env();
 var headersToObject = (thing) => thing instanceof AxiosHeaders_default ? { ...thing } : thing;
 var ownEnumerableKeys = (thing) => {
   if (Object.getOwnPropertySymbols && Object.getOwnPropertyDescriptor) {
@@ -2215,6 +2314,7 @@ function mergeConfig(config1, config2) {
 }
 
 // node_modules/axios/lib/core/setFormDataHeaders.js
+init_define_import_meta_env();
 var FORM_DATA_CONTENT_HEADERS = ["content-type", "content-length"];
 function setFormDataHeaders(headers, formHeaders, policy) {
   if (policy !== "content-only") {
@@ -2457,7 +2557,11 @@ var xhr_default = isXHRAdapterSupported && function(config) {
   });
 };
 
+// node_modules/axios/lib/adapters/fetch.js
+init_define_import_meta_env();
+
 // node_modules/axios/lib/helpers/composeSignals.js
+init_define_import_meta_env();
 var composeSignals = (signals, timeout) => {
   signals = signals ? signals.filter(Boolean) : [];
   if (!timeout && !signals.length) {
@@ -2507,6 +2611,7 @@ var composeSignals = (signals, timeout) => {
 var composeSignals_default = composeSignals;
 
 // node_modules/axios/lib/helpers/trackStream.js
+init_define_import_meta_env();
 var streamChunk = function* (chunk, chunkSize) {
   let len = chunk.byteLength;
   if (!chunkSize || len < chunkSize) {
@@ -2587,6 +2692,7 @@ var trackStream = (stream, chunkSize, onProgress, onFinish) => {
 };
 
 // node_modules/axios/lib/helpers/estimateDataURLDecodedBytes.js
+init_define_import_meta_env();
 var isHexDigit = (charCode) => charCode >= 48 && charCode <= 57 || charCode >= 65 && charCode <= 70 || charCode >= 97 && charCode <= 102;
 var isPercentEncodedByte = (str, i, len) => i + 2 < len && isHexDigit(str.charCodeAt(i + 1)) && isHexDigit(str.charCodeAt(i + 2));
 var hexValue = (charCode) => charCode <= 57 ? charCode - 48 : (charCode & 223) - 55;
@@ -2687,6 +2793,7 @@ function estimateDataURLDecodedBytes(url) {
 }
 
 // node_modules/axios/lib/env/data.js
+init_define_import_meta_env();
 var VERSION = "1.20.0";
 
 // node_modules/axios/lib/adapters/fetch.js
@@ -3263,6 +3370,7 @@ function dispatchRequest(_config) {
 }
 
 // node_modules/axios/lib/helpers/validator.js
+init_define_import_meta_env();
 var validators = {};
 ["object", "boolean", "number", "function", "string", "symbol"].forEach((type, i) => {
   validators[type] = function validator(thing) {
@@ -3548,6 +3656,7 @@ utils_default.forEach(["post", "put", "patch", "query"], function forEachMethodW
 var Axios_default = Axios;
 
 // node_modules/axios/lib/cancel/CancelToken.js
+init_define_import_meta_env();
 var CancelToken = class _CancelToken {
   constructor(executor) {
     if (typeof executor !== "function") {
@@ -3646,6 +3755,7 @@ var CancelToken = class _CancelToken {
 var CancelToken_default = CancelToken;
 
 // node_modules/axios/lib/helpers/spread.js
+init_define_import_meta_env();
 function spread(callback) {
   return function wrap(arr) {
     return callback.apply(null, arr);
@@ -3653,11 +3763,13 @@ function spread(callback) {
 }
 
 // node_modules/axios/lib/helpers/isAxiosError.js
+init_define_import_meta_env();
 function isAxiosError(payload) {
   return utils_default.isObject(payload) && payload.isAxiosError === true;
 }
 
 // node_modules/axios/lib/helpers/HttpStatusCode.js
+init_define_import_meta_env();
 var HttpStatusCode = {
   Continue: 100,
   SwitchingProtocols: 101,
@@ -3804,6 +3916,7 @@ import { toast } from "sonner";
 import i18n2 from "i18next";
 
 // src/ui/lib/base-path.ts
+init_define_import_meta_env();
 function getBasePath() {
   const runtime = document.querySelector('meta[name="termix-base-path"]')?.content.trim() || window.__TERMIX_BASE_PATH__;
   if (runtime) {
@@ -3814,7 +3927,14 @@ function getBasePath() {
   return base.endsWith("/") ? base.slice(0, -1) : base;
 }
 
+// src/ui/shell/TabContext.tsx
+init_define_import_meta_env();
+
+// src/ui/shell/tab-registry.ts
+init_define_import_meta_env();
+
 // src/ui/lib/registry.ts
+init_define_import_meta_env();
 import { useSyncExternalStore } from "react";
 function createRegistry(sort) {
   const items = /* @__PURE__ */ new Map();
@@ -3865,7 +3985,11 @@ function byOrderThenId(a, b) {
   return (a.order ?? 0) - (b.order ?? 0) || a.id.localeCompare(b.id);
 }
 
+// src/ui/plugin-host/view-ownership.ts
+init_define_import_meta_env();
+
 // src/ui/plugin-host/plugin-store.ts
+init_define_import_meta_env();
 import { useSyncExternalStore as useSyncExternalStore2 } from "react";
 var state = { loaded: false, settled: false, records: /* @__PURE__ */ new Map() };
 var listeners = /* @__PURE__ */ new Set();
@@ -3925,6 +4049,9 @@ function getPluginRecord(pluginId) {
 function knownPluginIds() {
   return [...state.records.keys()];
 }
+function resetPluginStore() {
+  commit({ loaded: false, settled: false, records: /* @__PURE__ */ new Map() });
+}
 
 // src/ui/plugin-host/view-ownership.ts
 function declares(record, kind, id) {
@@ -3934,6 +4061,9 @@ function declares(record, kind, id) {
   if (kind === "panel") {
     return !!contributes.panels?.some((panel) => panel.id === id) || !!contributes.tabs?.some((tab) => tab.id === id);
   }
+  if (kind === "layout") {
+    return !!contributes.layouts?.some((layout) => layout.id === id);
+  }
   return !!contributes.dashboardCards?.some((card) => card.id === id);
 }
 function viewOwner(kind, id) {
@@ -3973,6 +4103,29 @@ var getTabType = registry.get;
 var listTabTypes = registry.list;
 var useTabTypes = registry.useList;
 var resetTabTypes = registry.reset;
+var CORE_PERSISTENT = /* @__PURE__ */ new Set();
+var CORE_SESSION = /* @__PURE__ */ new Set();
+var CORE_HOSTLESS = /* @__PURE__ */ new Set(["dashboard"]);
+function isOwnedButAbsent(type) {
+  return !registry.get(type) && !!viewOwner("tab", type);
+}
+function isPersistentTabType(type) {
+  if (CORE_PERSISTENT.has(type)) return true;
+  const def = registry.get(type);
+  if (def) return !!def.persistent;
+  return isOwnedButAbsent(type);
+}
+function isSessionTabType(type) {
+  return CORE_SESSION.has(type) || !!registry.get(type)?.session;
+}
+function isHostlessTabType(type) {
+  return CORE_HOSTLESS.has(type) || !!registry.get(type)?.hostless;
+}
+function canRestoreTabType(type, host) {
+  const def = registry.get(type);
+  if (!host) return isHostlessTabType(type) || isOwnedButAbsent(type);
+  return def?.restore ? def.restore(host) : true;
+}
 function tabTypeForActivity(activityType) {
   return registry.list().find(
     (def) => def.id === activityType || def.activityTypes?.includes(activityType)
@@ -4262,6 +4415,7 @@ function TabProvider({ children }) {
 }
 
 // src/ui/lib/frontend-logger.ts
+init_define_import_meta_env();
 var FrontendLogger = class {
   serviceName;
   serviceIcon;
@@ -4529,6 +4683,7 @@ function createFrontendLogger(serviceName, serviceIcon = "\u{1F9E9}", serviceCol
 }
 
 // src/ui/lib/db-health-monitor.ts
+init_define_import_meta_env();
 var DatabaseHealthMonitor = class _DatabaseHealthMonitor {
   static instance;
   listeners = /* @__PURE__ */ new Map();
@@ -4602,6 +4757,7 @@ var DatabaseHealthMonitor = class _DatabaseHealthMonitor {
 var dbHealthMonitor = DatabaseHealthMonitor.getInstance();
 
 // src/ui/lib/device-id.ts
+init_define_import_meta_env();
 var DEVICE_ID_STORAGE_KEY = "termixDeviceId";
 var DEVICE_ID_PATTERN = /^[a-f0-9]{64}$/;
 function createDeviceId() {
@@ -4623,10 +4779,18 @@ function getDeviceId() {
   }
 }
 
+// src/ui/api/ssh-host-management-api.ts
+init_define_import_meta_env();
+
+// src/ui/lib/hosts-request-cache.ts
+init_define_import_meta_env();
+
 // src/ui/lib/sync-events.ts
+init_define_import_meta_env();
 var SYNC_CHANGED_EVENT = "termix:sync-changed";
 
 // src/ui/lib/ttl-request-cache.ts
+init_define_import_meta_env();
 function createTtlRequestCache(ttlMs) {
   let cached2 = null;
   let inflight2 = null;
@@ -4685,6 +4849,18 @@ function getCachedSSHHosts(loader) {
   bindInvalidationListeners();
   return hostsCache.get(loader);
 }
+function getCachedServerStatuses(loader) {
+  return statusCache.get(loader);
+}
+function invalidateServerStatusCache() {
+  statusCache.invalidate();
+}
+function getCachedSSHFolders(loader) {
+  return foldersCache.get(loader);
+}
+function invalidateSSHFoldersCache() {
+  foldersCache.invalidate();
+}
 function invalidateHostsAndStatusCaches() {
   hostsCache.invalidate();
   statusCache.invalidate();
@@ -4704,8 +4880,120 @@ async function getSSHHosts() {
     throw handleApiError(error, "fetch SSH hosts");
   }
 }
+async function createSSHHost(hostData) {
+  try {
+    if (hostData.authType === "key" && hostData.key instanceof File) {
+      const formData = new FormData();
+      formData.append("key", hostData.key);
+      const dataWithoutFile = { ...hostData, key: void 0 };
+      formData.append("data", JSON.stringify(dataWithoutFile));
+      const response2 = await sshHostApi.post("/db/host", formData, {
+        headers: { "Content-Type": "multipart/form-data" }
+      });
+      invalidateHostsAndStatusCaches();
+      return response2.data;
+    }
+    const response = await sshHostApi.post("/db/host", hostData);
+    invalidateHostsAndStatusCaches();
+    return response.data;
+  } catch (error) {
+    throw handleApiError(error, "create SSH host");
+  }
+}
+async function updateSSHHost(hostId, hostData) {
+  try {
+    if (hostData.authType === "key" && hostData.key instanceof File) {
+      const formData = new FormData();
+      formData.append("key", hostData.key);
+      const dataWithoutFile = { ...hostData, key: void 0 };
+      formData.append("data", JSON.stringify(dataWithoutFile));
+      const response2 = await sshHostApi.put(`/db/host/${hostId}`, formData, {
+        headers: { "Content-Type": "multipart/form-data" }
+      });
+      invalidateHostsAndStatusCaches();
+      return response2.data;
+    }
+    const response = await sshHostApi.put(`/db/host/${hostId}`, hostData);
+    invalidateHostsAndStatusCaches();
+    return response.data;
+  } catch (error) {
+    throw handleApiError(error, "update SSH host");
+  }
+}
+async function bulkImportSSHHosts(hosts, overwrite = false, credentials) {
+  try {
+    const response = await sshHostApi.post("/bulk-import", {
+      hosts,
+      overwrite,
+      ...credentials ? { credentials } : {}
+    });
+    invalidateHostsAndStatusCaches();
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "bulk import SSH hosts");
+  }
+}
+async function importSSHConfigHosts(content, overwrite = false) {
+  try {
+    const response = await sshHostApi.post("/ssh-config-import", {
+      content,
+      overwrite
+    });
+    invalidateHostsAndStatusCaches();
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "import SSH config hosts");
+  }
+}
+async function bulkUpdateSSHHosts(hostIds, updates) {
+  try {
+    const response = await sshHostApi.patch("/bulk-update", {
+      hostIds,
+      updates
+    });
+    invalidateHostsAndStatusCaches();
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "bulk update SSH hosts");
+  }
+}
+async function reorderSSHHosts(positions) {
+  try {
+    const response = await sshHostApi.put("/reorder", { positions });
+    invalidateHostsAndStatusCaches();
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "reorder SSH hosts");
+  }
+}
+async function deleteSSHHost(hostId) {
+  try {
+    const response = await sshHostApi.delete(`/db/host/${hostId}`);
+    invalidateHostsAndStatusCaches();
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "delete SSH host");
+  }
+}
+async function exportAllSSHHosts(options) {
+  try {
+    const response = await sshHostApi.get(
+      options?.share ? "/db/hosts/export?share=1" : "/db/hosts/export"
+    );
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "export all SSH hosts");
+  }
+}
+
+// src/ui/api/host-status-api.ts
+init_define_import_meta_env();
+
+// src/ui/lib/connection-origin.ts
+init_define_import_meta_env();
 
 // src/ui/lib/ws-auth.ts
+init_define_import_meta_env();
 var JWT_PROTOCOL_PREFIX = "termix.jwt.";
 function websocketAuthProtocols(token) {
   return token ? [`${JWT_PROTOCOL_PREFIX}${token}`] : [];
@@ -4759,7 +5047,416 @@ async function buildOriginWsUrl({
   };
 }
 
+// src/ui/api/host-status-api.ts
+var STATUS_RETRY_SCHEDULE = [
+  { timeoutMs: 2e3, pauseAfterMs: 3e3 },
+  { timeoutMs: 5e3, pauseAfterMs: 5e3 },
+  { timeoutMs: 8e3, pauseAfterMs: null }
+];
+function isTransientStatusError(error) {
+  if (!axios_default.isAxiosError(error)) return false;
+  if (error.response) {
+    return false;
+  }
+  const code = error.code;
+  if (!code) {
+    return true;
+  }
+  return code === "ECONNABORTED" || code === "ETIMEDOUT" || code === "ERR_NETWORK" || code === "ECONNREFUSED" || code === "ECONNRESET";
+}
+async function getAllServerStatuses() {
+  return getCachedServerStatuses(async () => {
+    let lastError = null;
+    let localStatuses = {};
+    let localHostIds = null;
+    let remoteHostsBySyncId = null;
+    if (isElectron()) {
+      const response = await sshHostApi.get("/db/host");
+      const defaultOrigin = await resolveConnectionOrigin({
+        connectionOrigin: null
+      });
+      const hosts = response.data || [];
+      localHostIds = hosts.filter((host) => (host.connectionOrigin ?? defaultOrigin) === "local").map((host) => host.id);
+      remoteHostsBySyncId = new Map(
+        hosts.filter(
+          (host) => (host.connectionOrigin ?? defaultOrigin) === "remote" && !!host.syncId
+        ).map((host) => [host.syncId, host.id])
+      );
+    }
+    for (let i = 0; i < STATUS_RETRY_SCHEDULE.length; i++) {
+      const { timeoutMs, pauseAfterMs } = STATUS_RETRY_SCHEDULE[i];
+      const isFinalAttempt = i === STATUS_RETRY_SCHEDULE.length - 1;
+      try {
+        const response = await sshHostApi.get("/status", {
+          timeout: timeoutMs,
+          ...localHostIds === null ? {} : { params: { hostIds: localHostIds.join(",") } },
+          // Silence per-attempt interceptor logging & health-monitor side
+          // effects on all attempts except the final one, so background
+          // blips don't look like real outages.
+          __silentRetry: !isFinalAttempt
+        });
+        localStatuses = response.data || {};
+        lastError = null;
+        break;
+      } catch (error) {
+        lastError = error;
+        if (!isTransientStatusError(error)) {
+          break;
+        }
+        if (pauseAfterMs === null) {
+          break;
+        }
+        await new Promise((resolve) => setTimeout(resolve, pauseAfterMs));
+      }
+    }
+    if (lastError) handleApiError(lastError, "fetch server statuses");
+    if (remoteHostsBySyncId?.size && await getLinkedSession()) {
+      try {
+        const remoteResult = await getRemoteCoreApi().get(
+          "/sync/v2/host-status",
+          {
+            timeout: 8e3,
+            __silentRetry: true
+          }
+        );
+        const merged = { ...localStatuses };
+        for (const [syncId, status] of Object.entries(
+          remoteResult.data || {}
+        )) {
+          const localId = remoteHostsBySyncId.get(syncId);
+          if (localId !== void 0) merged[localId] = status;
+        }
+        return merged;
+      } catch {
+      }
+    }
+    return localStatuses;
+  });
+}
+async function getStatusCheckSettings() {
+  try {
+    const response = await sshHostApi.get("/status/settings");
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "fetch status check settings");
+  }
+}
+async function updateStatusCheckSettings(settings) {
+  try {
+    await sshHostApi.put("/status/settings", settings);
+  } catch (error) {
+    handleApiError(error, "update status check settings");
+  }
+}
+
+// src/ui/api/host-sidebar-preferences-api.ts
+init_define_import_meta_env();
+
+// src/types/host-sidebar-preferences.ts
+init_define_import_meta_env();
+var HOST_SIDEBAR_PREFS_VERSION = 1;
+var HOST_ROW_FIELD_KEYS = [
+  "showAddress",
+  "showUsername",
+  "showPort",
+  "showPinIcon",
+  "showSharedBadge",
+  "showBadges"
+];
+function defaultHostRowFields() {
+  return {
+    showAddress: true,
+    showUsername: true,
+    showPort: false,
+    showPinIcon: true,
+    showSharedBadge: true,
+    showBadges: true
+  };
+}
+var GROUP_KEYS = [
+  "folder",
+  "tag",
+  "status",
+  "protocol",
+  "auth"
+];
+var SORT_KEYS = [
+  "default",
+  "name-asc",
+  "name-desc",
+  "ip-asc",
+  "ip-desc",
+  "status-online",
+  "status-offline",
+  "manual"
+];
+var DENSITIES = ["comfortable", "compact"];
+var TRAY_TRIGGERS = [
+  "always",
+  "hover",
+  "click",
+  "actionsOnly"
+];
+var HOST_CLICK_BEHAVIORS = [
+  "newTab",
+  "focusExisting",
+  "focusExistingDoubleClickNew"
+];
+var STATUS_COLOR_SCHEMES = ["accent", "status"];
+var FILTER_STATUS = [
+  "online",
+  "offline",
+  "pinned"
+];
+var AUTH_TYPE_PATTERN = /^[a-z][a-z0-9-]{0,63}$/;
+function defaultHostSidebarPreferences() {
+  return {
+    version: HOST_SIDEBAR_PREFS_VERSION,
+    sort: { key: "default", pinnedFirst: false },
+    groupKey: "folder",
+    filters: {
+      status: [],
+      authType: [],
+      protocol: [],
+      features: [],
+      tags: []
+    },
+    openFolders: [],
+    display: {
+      density: "comfortable",
+      showTags: true,
+      trayTrigger: "always",
+      statusColorScheme: "accent",
+      openOnDoubleClick: false,
+      showFolderPaths: true,
+      hostClickBehavior: "newTab",
+      closeOnOpen: false,
+      barActions: {},
+      ...defaultHostRowFields()
+    }
+  };
+}
+var ACTION_ID_PATTERN = /^[a-z0-9][a-z0-9._:-]{0,79}$/;
+function sanitizeBarActions(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return {};
+  const out = {};
+  for (const [id, value] of Object.entries(input)) {
+    if (ACTION_ID_PATTERN.test(id) && typeof value === "boolean") {
+      out[id] = value;
+    }
+  }
+  return out;
+}
+function sanitizeStringArray(input) {
+  if (!Array.isArray(input)) return [];
+  return input.filter((v) => typeof v === "string");
+}
+function sanitizeEnumArray(input, allowed) {
+  if (!Array.isArray(input)) return [];
+  return input.filter((v) => allowed.includes(v));
+}
+function sanitizeHostSidebarPreferences(input) {
+  const defaults2 = defaultHostSidebarPreferences();
+  if (!input || typeof input !== "object") return defaults2;
+  const obj = input;
+  const sortObj = obj.sort ?? {};
+  const sort = {
+    key: SORT_KEYS.includes(sortObj.key) ? sortObj.key : defaults2.sort.key,
+    pinnedFirst: typeof sortObj.pinnedFirst === "boolean" ? sortObj.pinnedFirst : defaults2.sort.pinnedFirst
+  };
+  const groupKey = GROUP_KEYS.includes(obj.groupKey) ? obj.groupKey : defaults2.groupKey;
+  const filtersObj = obj.filters ?? {};
+  const filters = {
+    status: sanitizeEnumArray(filtersObj.status, FILTER_STATUS),
+    authType: sanitizeStringArray(filtersObj.authType).filter(
+      (value) => AUTH_TYPE_PATTERN.test(value)
+    ),
+    protocol: sanitizeStringArray(filtersObj.protocol).filter(
+      (value) => AUTH_TYPE_PATTERN.test(value)
+    ),
+    features: sanitizeStringArray(filtersObj.features).filter(
+      (value) => AUTH_TYPE_PATTERN.test(value)
+    ),
+    tags: sanitizeStringArray(filtersObj.tags)
+  };
+  const openFolders = sanitizeStringArray(obj.openFolders);
+  const displayObj = obj.display ?? {};
+  const rowFields = {};
+  for (const key of HOST_ROW_FIELD_KEYS) {
+    rowFields[key] = typeof displayObj[key] === "boolean" ? displayObj[key] : defaults2.display[key];
+  }
+  const display = {
+    ...rowFields,
+    density: DENSITIES.includes(displayObj.density) ? displayObj.density : defaults2.display.density,
+    showTags: typeof displayObj.showTags === "boolean" ? displayObj.showTags : defaults2.display.showTags,
+    trayTrigger: TRAY_TRIGGERS.includes(
+      displayObj.trayTrigger
+    ) ? displayObj.trayTrigger : defaults2.display.trayTrigger,
+    statusColorScheme: STATUS_COLOR_SCHEMES.includes(
+      displayObj.statusColorScheme
+    ) ? displayObj.statusColorScheme : defaults2.display.statusColorScheme,
+    openOnDoubleClick: typeof displayObj.openOnDoubleClick === "boolean" ? displayObj.openOnDoubleClick : defaults2.display.openOnDoubleClick,
+    showFolderPaths: typeof displayObj.showFolderPaths === "boolean" ? displayObj.showFolderPaths : defaults2.display.showFolderPaths,
+    hostClickBehavior: HOST_CLICK_BEHAVIORS.includes(
+      displayObj.hostClickBehavior
+    ) ? displayObj.hostClickBehavior : defaults2.display.hostClickBehavior,
+    closeOnOpen: typeof displayObj.closeOnOpen === "boolean" ? displayObj.closeOnOpen : defaults2.display.closeOnOpen,
+    barActions: sanitizeBarActions(displayObj.barActions)
+  };
+  return {
+    version: HOST_SIDEBAR_PREFS_VERSION,
+    sort,
+    groupKey,
+    filters,
+    openFolders,
+    display
+  };
+}
+
+// src/ui/api/host-sidebar-preferences-api.ts
+async function getHostSidebarPreferences() {
+  try {
+    const response = await authApi.get("/host-sidebar/preferences");
+    return sanitizeHostSidebarPreferences(response.data?.preferences);
+  } catch (error) {
+    handleApiError(error, "fetch host sidebar preferences");
+    throw error;
+  }
+}
+async function saveHostSidebarPreferences(preferences) {
+  try {
+    await authApi.put("/host-sidebar/preferences", preferences);
+  } catch (error) {
+    handleApiError(error, "save host sidebar preferences");
+    throw error;
+  }
+}
+
+// src/ui/api/credential-sidebar-preferences-api.ts
+init_define_import_meta_env();
+
+// src/types/credential-sidebar-preferences.ts
+init_define_import_meta_env();
+var CREDENTIAL_SIDEBAR_PREFS_VERSION = 1;
+var CREDENTIAL_ROW_FIELD_KEYS = [
+  "showUsername",
+  "showUsageCount",
+  "showTypeBadge",
+  "showPinIcon",
+  "showSharedBadge"
+];
+function defaultCredentialRowFields() {
+  return {
+    showUsername: true,
+    showUsageCount: true,
+    showTypeBadge: true,
+    showPinIcon: true,
+    showSharedBadge: true
+  };
+}
+var SORT_KEYS2 = [
+  "default",
+  "name-asc",
+  "name-desc",
+  "username-asc",
+  "username-desc",
+  "manual"
+];
+var DENSITIES2 = ["comfortable", "compact"];
+var TRAY_TRIGGERS2 = [
+  "always",
+  "hover",
+  "click",
+  "actionsOnly"
+];
+var TYPE_PATTERN = /^[a-z][a-z0-9-]{0,63}$/;
+function defaultCredentialSidebarPreferences() {
+  return {
+    version: CREDENTIAL_SIDEBAR_PREFS_VERSION,
+    sort: { key: "default", pinnedFirst: false },
+    filters: {
+      type: [],
+      tags: []
+    },
+    openFolders: [],
+    display: {
+      density: "comfortable",
+      showTags: true,
+      trayTrigger: "always",
+      ...defaultCredentialRowFields()
+    }
+  };
+}
+function sanitizeStringArray2(input) {
+  if (!Array.isArray(input)) return [];
+  return input.filter((v) => typeof v === "string");
+}
+function sanitizeCredentialSidebarPreferences(input) {
+  const defaults2 = defaultCredentialSidebarPreferences();
+  if (!input || typeof input !== "object") return defaults2;
+  const obj = input;
+  const sortObj = obj.sort ?? {};
+  const sort = {
+    key: SORT_KEYS2.includes(sortObj.key) ? sortObj.key : defaults2.sort.key,
+    pinnedFirst: typeof sortObj.pinnedFirst === "boolean" ? sortObj.pinnedFirst : defaults2.sort.pinnedFirst
+  };
+  const filtersObj = obj.filters ?? {};
+  const filters = {
+    type: sanitizeStringArray2(filtersObj.type).filter(
+      (value) => TYPE_PATTERN.test(value)
+    ),
+    tags: sanitizeStringArray2(filtersObj.tags)
+  };
+  const openFolders = sanitizeStringArray2(obj.openFolders);
+  const displayObj = obj.display ?? {};
+  const rowFields = {};
+  for (const key of CREDENTIAL_ROW_FIELD_KEYS) {
+    rowFields[key] = typeof displayObj[key] === "boolean" ? displayObj[key] : defaults2.display[key];
+  }
+  const display = {
+    ...rowFields,
+    density: DENSITIES2.includes(displayObj.density) ? displayObj.density : defaults2.display.density,
+    showTags: typeof displayObj.showTags === "boolean" ? displayObj.showTags : defaults2.display.showTags,
+    trayTrigger: TRAY_TRIGGERS2.includes(
+      displayObj.trayTrigger
+    ) ? displayObj.trayTrigger : defaults2.display.trayTrigger
+  };
+  return {
+    version: CREDENTIAL_SIDEBAR_PREFS_VERSION,
+    sort,
+    filters,
+    openFolders,
+    display
+  };
+}
+
+// src/ui/api/credential-sidebar-preferences-api.ts
+async function getCredentialSidebarPreferences() {
+  try {
+    const response = await authApi.get("/credential-sidebar/preferences");
+    return sanitizeCredentialSidebarPreferences(response.data?.preferences);
+  } catch (error) {
+    handleApiError(error, "fetch credential sidebar preferences");
+    throw error;
+  }
+}
+async function saveCredentialSidebarPreferences(preferences) {
+  try {
+    await authApi.put("/credential-sidebar/preferences", preferences);
+  } catch (error) {
+    handleApiError(error, "save credential sidebar preferences");
+    throw error;
+  }
+}
+
+// src/ui/api/ui-preferences-api.ts
+init_define_import_meta_env();
+
+// src/types/ui-preferences.ts
+init_define_import_meta_env();
+
 // src/types/onboarding.ts
+init_define_import_meta_env();
 var LEGACY_SEEN = Object.freeze({
   plugins: 1,
   "desktop-sync": 1,
@@ -4894,17 +5591,70 @@ var AREA_SPECS = {
 };
 var UI_AREA_KEYS = Object.keys(AREA_SPECS);
 
-// src/ui/lib/remote-server-api.ts
-async function hydrateLocalSharedHostAuth(host) {
-  return host;
+// src/ui/api/settings-api.ts
+init_define_import_meta_env();
+async function getLogLevel() {
+  try {
+    const response = await authApi.get("/users/log-level");
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "fetch log level");
+  }
 }
-async function getConnectedRemoteApi() {
-  return await getLinkedSession() ? getRemoteCoreApi() : null;
+async function updateLogLevel(level) {
+  try {
+    await authApi.patch("/users/log-level", { level });
+  } catch (error) {
+    handleApiError(error, "update log level");
+  }
 }
-async function resolveRemoteHostId(syncId) {
-  if (!syncId) return null;
-  const api = await getConnectedRemoteApi();
-  if (!api) return null;
+async function getSessionTimeout() {
+  try {
+    const response = await authApi.get("/users/session-timeout");
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "fetch session timeout");
+  }
+}
+async function updateSessionTimeout(timeoutHours) {
+  try {
+    await authApi.patch("/users/session-timeout", { timeoutHours });
+  } catch (error) {
+    handleApiError(error, "update session timeout");
+  }
+}
+async function getBranding() {
+  try {
+    const response = await authApi.get("/users/branding");
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "fetch branding settings");
+  }
+}
+async function updateBranding(update) {
+  try {
+    const response = await authApi.patch("/users/branding", update);
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "update branding settings");
+  }
+}
+
+// src/ui/api/user-management-api.ts
+init_define_import_meta_env();
+
+// src/ui/lib/remote-server-api.ts
+init_define_import_meta_env();
+async function hydrateLocalSharedHostAuth(host) {
+  return host;
+}
+async function getConnectedRemoteApi() {
+  return await getLinkedSession() ? getRemoteCoreApi() : null;
+}
+async function resolveRemoteHostId(syncId) {
+  if (!syncId) return null;
+  const api = await getConnectedRemoteApi();
+  if (!api) return null;
   try {
     const response = await api.get(
       `/sync/v2/hosts/${encodeURIComponent(syncId)}`
@@ -4916,6 +5666,190 @@ async function resolveRemoteHostId(syncId) {
 }
 
 // src/ui/api/user-management-api.ts
+async function getUserList(options = {}) {
+  try {
+    const api = await getConnectedRemoteApi() ?? authApi;
+    const response = await api.get("/users/list", {
+      params: {
+        ...options.search ? { search: options.search } : {},
+        ...options.limit ? { limit: options.limit } : {},
+        ...options.offset ? { offset: options.offset } : {}
+      }
+    });
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "fetch user list");
+  }
+}
+async function getSessions() {
+  try {
+    const response = await authApi.get("/users/sessions");
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "fetch sessions");
+  }
+}
+async function revokeSession(sessionId) {
+  try {
+    const response = await authApi.delete(`/users/sessions/${sessionId}`);
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "revoke session");
+  }
+}
+async function revokeAllUserSessions(userId) {
+  try {
+    const response = await authApi.post("/users/sessions/revoke-all", {
+      targetUserId: userId,
+      exceptCurrent: false
+    });
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "revoke all user sessions");
+  }
+}
+async function createApiKey(name, userId, expiresAt) {
+  try {
+    const response = await authApi.post("/users/api-keys", {
+      name,
+      userId,
+      expiresAt: expiresAt ?? null
+    });
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "create API key");
+  }
+}
+async function getApiKeys() {
+  try {
+    const response = await authApi.get("/users/api-keys");
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "fetch API keys");
+  }
+}
+async function deleteApiKey(keyId) {
+  try {
+    const response = await authApi.delete(`/users/api-keys/${keyId}`);
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "delete API key");
+  }
+}
+async function makeUserAdmin(userId) {
+  try {
+    const response = await authApi.post("/users/make-admin", { userId });
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "make user admin");
+  }
+}
+async function removeAdminStatus(userId) {
+  try {
+    const response = await authApi.post("/users/remove-admin", { userId });
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "remove admin status");
+  }
+}
+async function deleteUser(username, successorUserId) {
+  try {
+    const response = await authApi.delete("/users/delete-user", {
+      data: { username, successorUserId }
+    });
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "delete user");
+  }
+}
+async function deleteAccount(password) {
+  try {
+    const response = await authApi.delete("/users/delete-account", {
+      data: { password }
+    });
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "delete account");
+  }
+}
+async function adminResetUserPassword(userId, newPassword, confirmDataWipe = false) {
+  const response = await authApi.post("/users/admin/reset-password", {
+    userId,
+    newPassword,
+    confirmDataWipe
+  });
+  return response.data;
+}
+async function adminExportUserData(userId) {
+  try {
+    const response = await authApi.get(
+      `/users/admin/export/${encodeURIComponent(userId)}`,
+      { timeout: 12e4 }
+    );
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "export user data");
+  }
+}
+async function updateRegistrationAllowed(allowed) {
+  try {
+    const response = await authApi.patch("/users/registration-allowed", {
+      allowed
+    });
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "update registration allowed");
+  }
+}
+async function getExternalAutoProvision() {
+  try {
+    const response = await authApi.get("/users/external-auto-provision");
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "check OIDC auto-provision status");
+  }
+}
+async function updateExternalAutoProvision(enabled) {
+  try {
+    const response = await authApi.patch("/users/external-auto-provision", {
+      enabled
+    });
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "update OIDC auto-provision");
+  }
+}
+async function getSecondFactorAfterExternalLogin() {
+  try {
+    const response = await authApi.get(
+      "/users/second-factor-after-external-login"
+    );
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "check second factor after external login status");
+  }
+}
+async function updateSecondFactorAfterExternalLogin(enabled) {
+  try {
+    const response = await authApi.patch(
+      "/users/second-factor-after-external-login",
+      { enabled }
+    );
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "update second factor after external login");
+  }
+}
+async function updatePasswordLoginAllowed(allowed) {
+  try {
+    const response = await authApi.patch("/users/password-login-allowed", {
+      allowed
+    });
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "update password login allowed");
+  }
+}
 async function getPasswordResetAllowed() {
   try {
     const response = await authApi.get("/users/password-reset-allowed");
@@ -4924,8 +5858,148 @@ async function getPasswordResetAllowed() {
     handleApiError(error, "get password reset allowed");
   }
 }
+async function updatePasswordResetAllowed(allowed) {
+  try {
+    const response = await authApi.patch("/users/password-reset-allowed", {
+      allowed
+    });
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "update password reset allowed");
+  }
+}
+
+// src/ui/api/admin-user-data-api.ts
+init_define_import_meta_env();
+var ADMIN_TARGET_USER_HEADER = "X-Admin-Target-User";
+function adminHeaders(targetUserId) {
+  return { [ADMIN_TARGET_USER_HEADER]: targetUserId };
+}
+async function adminGetUserHosts(targetUserId) {
+  try {
+    const response = await sshHostApi.get("/db/host", {
+      headers: adminHeaders(targetUserId)
+    });
+    return Array.isArray(response.data) ? response.data : [];
+  } catch (error) {
+    throw handleApiError(error, "fetch user's hosts");
+  }
+}
+async function adminCreateUserHost(targetUserId, hostData) {
+  try {
+    if (hostData.authType === "key" && hostData.key instanceof File) {
+      const formData = new FormData();
+      formData.append("key", hostData.key);
+      const dataWithoutFile = { ...hostData, key: void 0 };
+      formData.append("data", JSON.stringify(dataWithoutFile));
+      const response2 = await sshHostApi.post("/db/host", formData, {
+        headers: {
+          "Content-Type": "multipart/form-data",
+          ...adminHeaders(targetUserId)
+        }
+      });
+      return response2.data;
+    }
+    const response = await sshHostApi.post("/db/host", hostData, {
+      headers: adminHeaders(targetUserId)
+    });
+    return response.data;
+  } catch (error) {
+    throw handleApiError(error, "create host for user");
+  }
+}
+async function adminUpdateUserHost(targetUserId, hostId, hostData) {
+  try {
+    if (hostData.authType === "key" && hostData.key instanceof File) {
+      const formData = new FormData();
+      formData.append("key", hostData.key);
+      const dataWithoutFile = { ...hostData, key: void 0 };
+      formData.append("data", JSON.stringify(dataWithoutFile));
+      const response2 = await sshHostApi.put(`/db/host/${hostId}`, formData, {
+        headers: {
+          "Content-Type": "multipart/form-data",
+          ...adminHeaders(targetUserId)
+        }
+      });
+      return response2.data;
+    }
+    const response = await sshHostApi.put(`/db/host/${hostId}`, hostData, {
+      headers: adminHeaders(targetUserId)
+    });
+    return response.data;
+  } catch (error) {
+    throw handleApiError(error, "update user's host");
+  }
+}
+async function adminDeleteUserHost(targetUserId, hostId) {
+  try {
+    const response = await sshHostApi.delete(`/db/host/${hostId}`, {
+      headers: adminHeaders(targetUserId)
+    });
+    return response.data;
+  } catch (error) {
+    throw handleApiError(error, "delete user's host");
+  }
+}
+async function adminGetHostPassword(targetUserId, hostId, field = "password") {
+  try {
+    const response = await sshHostApi.get(
+      `/db/host/${hostId}/password?field=${field}`,
+      { headers: adminHeaders(targetUserId) }
+    );
+    return response.data?.value || null;
+  } catch {
+    return null;
+  }
+}
+async function adminGetUserCredentials(targetUserId) {
+  try {
+    const response = await authApi.get("/credentials", {
+      headers: adminHeaders(targetUserId)
+    });
+    return response.data;
+  } catch (error) {
+    throw handleApiError(error, "fetch user's credentials");
+  }
+}
+async function adminCreateUserCredential(targetUserId, credentialData) {
+  try {
+    const response = await authApi.post("/credentials", credentialData, {
+      headers: adminHeaders(targetUserId)
+    });
+    return response.data;
+  } catch (error) {
+    throw handleApiError(error, "create credential for user");
+  }
+}
+async function adminUpdateUserCredential(targetUserId, credentialId, credentialData) {
+  try {
+    const response = await authApi.put(
+      `/credentials/${credentialId}`,
+      credentialData,
+      { headers: adminHeaders(targetUserId) }
+    );
+    return response.data;
+  } catch (error) {
+    throw handleApiError(error, "update user's credential");
+  }
+}
+async function adminDeleteUserCredential(targetUserId, credentialId) {
+  try {
+    const response = await authApi.delete(`/credentials/${credentialId}`, {
+      headers: adminHeaders(targetUserId)
+    });
+    return response.data;
+  } catch (error) {
+    throw handleApiError(error, "delete user's credential");
+  }
+}
 
 // src/ui/api/system-status-api.ts
+init_define_import_meta_env();
+function releaseUrlFrom(info) {
+  return info?.latest_release?.html_url ?? "";
+}
 async function getVersionInfo(checkRemote = true) {
   try {
     const response = await authApi.get(
@@ -4936,6 +6010,18 @@ async function getVersionInfo(checkRemote = true) {
     handleApiError(error, "fetch version info");
   }
 }
+async function getUpdateChannel() {
+  const response = await authApi.get("/version/channel");
+  return response.data;
+}
+async function setUpdateChannel(channel) {
+  const response = await authApi.put("/version/channel", { channel });
+  return response.data;
+}
+async function getChannelReleases() {
+  const response = await authApi.get("/version/releases");
+  return response.data;
+}
 async function getDatabaseHealth() {
   try {
     const response = await authApi.get("/health");
@@ -4946,6 +6032,7 @@ async function getDatabaseHealth() {
 }
 
 // src/ui/api/credentials-api.ts
+init_define_import_meta_env();
 async function getCredentials() {
   try {
     const response = await authApi.get("/credentials");
@@ -4954,6 +6041,52 @@ async function getCredentials() {
     throw handleApiError(error, "fetch credentials");
   }
 }
+async function getCredentialDetails(credentialId) {
+  try {
+    const response = await authApi.get(`/credentials/${credentialId}`);
+    return response.data;
+  } catch (error) {
+    throw handleApiError(error, "fetch credential details");
+  }
+}
+async function createCredential(credentialData) {
+  try {
+    const response = await authApi.post("/credentials", credentialData);
+    return response.data;
+  } catch (error) {
+    throw handleApiError(error, "create credential");
+  }
+}
+async function updateCredential(credentialId, credentialData) {
+  try {
+    const response = await authApi.put(
+      `/credentials/${credentialId}`,
+      credentialData
+    );
+    return response.data;
+  } catch (error) {
+    throw handleApiError(error, "update credential");
+  }
+}
+async function duplicateCredential(credentialId, data) {
+  try {
+    const response = await authApi.post(
+      `/credentials/${credentialId}/duplicate`,
+      data
+    );
+    return response.data;
+  } catch (error) {
+    throw handleApiError(error, "duplicate credential");
+  }
+}
+async function deleteCredential(credentialId) {
+  try {
+    const response = await authApi.delete(`/credentials/${credentialId}`);
+    return response.data;
+  } catch (error) {
+    throw handleApiError(error, "delete credential");
+  }
+}
 async function getHostPassword(hostId, field = "password") {
   try {
     const response = await sshHostApi.get(
@@ -4964,8 +6097,167 @@ async function getHostPassword(hostId, field = "password") {
     return null;
   }
 }
+async function renameFolder(oldName, newName) {
+  try {
+    const response = await authApi.put("/host/folders/rename", {
+      oldName,
+      newName
+    });
+    invalidateSSHFoldersCache();
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "rename folder");
+  }
+}
+async function getSSHFolders() {
+  try {
+    sshLogger.info("Fetching SSH folders", {
+      operation: "fetch_ssh_folders"
+    });
+    const folders = await getCachedSSHFolders(async () => {
+      const response = await authApi.get("/host/folders");
+      return response.data;
+    });
+    sshLogger.success("SSH folders fetched successfully", {
+      operation: "fetch_ssh_folders",
+      count: folders.length
+    });
+    return folders;
+  } catch (error) {
+    sshLogger.error("Failed to fetch SSH folders", error, {
+      operation: "fetch_ssh_folders"
+    });
+    handleApiError(error, "fetch SSH folders");
+    throw error;
+  }
+}
+async function updateFolderMetadata(name, color, icon, credentialId, localOnly) {
+  try {
+    sshLogger.info("Updating folder metadata", {
+      operation: "update_folder_metadata",
+      name,
+      color,
+      icon,
+      credentialId
+    });
+    await authApi.put("/host/folders/metadata", {
+      name,
+      color,
+      icon,
+      credentialId,
+      localOnly
+    });
+    invalidateSSHFoldersCache();
+    sshLogger.success("Folder metadata updated successfully", {
+      operation: "update_folder_metadata",
+      name
+    });
+  } catch (error) {
+    sshLogger.error("Failed to update folder metadata", error, {
+      operation: "update_folder_metadata",
+      name
+    });
+    handleApiError(error, "update folder metadata");
+    throw error;
+  }
+}
+async function reorderFolders(positions) {
+  try {
+    const response = await authApi.put("/host/folders/reorder", {
+      positions
+    });
+    invalidateSSHFoldersCache();
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "reorder folders");
+    throw error;
+  }
+}
+async function deleteAllHostsInFolder(folderName) {
+  try {
+    sshLogger.info("Deleting all hosts in folder", {
+      operation: "delete_folder_hosts",
+      folderName
+    });
+    const response = await authApi.delete(
+      `/host/folders/${encodeURIComponent(folderName)}/hosts`
+    );
+    invalidateHostsAndStatusCaches();
+    sshLogger.success("All hosts in folder deleted successfully", {
+      operation: "delete_folder_hosts",
+      folderName,
+      deletedCount: response.data.deletedCount
+    });
+    return response.data;
+  } catch (error) {
+    sshLogger.error("Failed to delete hosts in folder", error, {
+      operation: "delete_folder_hosts",
+      folderName
+    });
+    handleApiError(error, "delete hosts in folder");
+    throw error;
+  }
+}
+async function renameCredentialFolder(oldName, newName) {
+  try {
+    const response = await authApi.put("/credentials/folders/rename", {
+      oldName,
+      newName
+    });
+    invalidateSSHFoldersCache();
+    return response.data;
+  } catch (error) {
+    throw handleApiError(error, "rename credential folder");
+  }
+}
+async function reorderCredentials(positions) {
+  try {
+    const response = await authApi.put("/credentials/reorder", {
+      positions
+    });
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "reorder credentials");
+    throw error;
+  }
+}
+async function generatePublicKeyFromPrivate(privateKey, keyPassword) {
+  try {
+    const response = await authApi.post("/credentials/generate-public-key", {
+      privateKey,
+      keyPassword
+    });
+    return response.data;
+  } catch (error) {
+    throw handleApiError(error, "generate public key from private key");
+  }
+}
+async function generateKeyPair(keyType, keySize, passphrase) {
+  try {
+    const response = await authApi.post("/credentials/generate-key-pair", {
+      keyType,
+      keySize,
+      passphrase
+    });
+    return response.data;
+  } catch (error) {
+    throw handleApiError(error, "generate SSH key pair");
+  }
+}
+async function deployCredentialToHost(credentialId, targetHostId) {
+  try {
+    const response = await authApi.post(
+      `/credentials/${credentialId}/deploy-to-host`,
+      { targetHostId }
+    );
+    return response.data;
+  } catch (error) {
+    throw handleApiError(error, "deploy credential to host");
+  }
+}
 
 // src/ui/api/dashboard-api.ts
+init_define_import_meta_env();
 async function getUptime() {
   try {
     const response = await authApi.get("/dashboard/uptime");
@@ -4996,8 +6288,45 @@ async function logActivity(type, hostId, hostName) {
     throw handleApiError(error, "log activity");
   }
 }
+async function resetRecentActivity() {
+  try {
+    const response = await authApi.delete("/dashboard/activity/reset");
+    return response.data;
+  } catch (error) {
+    throw handleApiError(error, "reset recent activity");
+  }
+}
+
+// src/ui/api/external-account-api.ts
+init_define_import_meta_env();
+async function linkExternalToPasswordAccount(externalUserId, targetUsername) {
+  try {
+    const response = await authApi.post("/users/link-external-to-password", {
+      externalUserId,
+      targetUsername
+    });
+    return response.data;
+  } catch (error) {
+    throw handleApiError(error, "link external account to password account");
+  }
+}
+async function unlinkExternalFromPasswordAccount(userId) {
+  try {
+    const response = await authApi.post(
+      "/users/unlink-external-from-password",
+      { userId }
+    );
+    return response.data;
+  } catch (error) {
+    throw handleApiError(
+      error,
+      "unlink external sign-in from password account"
+    );
+  }
+}
 
 // src/ui/api/rbac-api.ts
+init_define_import_meta_env();
 import i18n from "i18next";
 async function getSharingTarget(hostId, syncId) {
   const api = await getConnectedRemoteApi();
@@ -5038,7 +6367,7 @@ async function updateRole(roleId, roleData) {
   try {
     const response = await rbacApi.put(`/rbac/roles/${roleId}`, roleData);
     if (roleData.permissions) {
-      const { notifyPermissionsChanged } = await import("./use-permissions-2P2TP6GY.js");
+      const { notifyPermissionsChanged } = await import("./use-permissions-6VSHHUMB.js");
       notifyPermissionsChanged();
     }
     return response.data;
@@ -5241,14 +6570,36 @@ async function revokeCredentialAccess(credentialId, accessId) {
 }
 
 // src/ui/api/open-tabs-api.ts
+init_define_import_meta_env();
 function hasPersistableHostId(tab) {
   return tab.hostId == null || Number.isInteger(tab.hostId) && tab.hostId > 0;
 }
 var activeSessionsCache = createTtlRequestCache(2e3);
+async function getOpenTabs() {
+  const response = await authApi.get("/open-tabs");
+  return response.data;
+}
+async function deleteOpenTab(instanceId) {
+  await authApi.delete(`/open-tabs/${instanceId}`);
+}
 async function patchOpenTab(instanceId, updates) {
   if (!hasPersistableHostId(updates)) return;
   await authApi.patch(`/open-tabs/${instanceId}`, updates);
 }
+async function addOpenTab(tab) {
+  if (!hasPersistableHostId(tab)) return;
+  await authApi.post("/open-tabs", tab);
+}
+async function getActiveSessions() {
+  return activeSessionsCache.get(async () => {
+    const response = await authApi.get("/open-tabs/active-sessions");
+    return Array.isArray(response.data) ? response.data : [];
+  });
+}
+async function getSessionTimeoutMinutes() {
+  const response = await authApi.get("/open-tabs/session-timeout");
+  return Number(response.data?.minutes) || 30;
+}
 function parseCustomKeybindings(raw) {
   if (!raw) return [];
   try {
@@ -5265,6 +6616,9 @@ async function getUserPreferences() {
     return response.data;
   });
 }
+async function saveUserPreferences(prefs) {
+  await authApi.put("/user-preferences", prefs);
+}
 
 // src/ui/main-axios.ts
 var TRUST_TOKEN_KEY = "termixTrustToken";
@@ -5575,7 +6929,7 @@ function getApiUrl(path, defaultPort) {
   const devMode = isDev();
   const electronMode = isElectron();
   if (electronMode) {
-    return `http://localhost:${defaultPort}${path}`;
+    return `http://localhost:${localBackendPort()}${path}`;
   } else if (devMode) {
     if (!define_import_meta_env_default.VITE_API_HOST) {
       return `/__termix_api/${defaultPort}${path}`;
@@ -5595,7 +6949,7 @@ function createRemoteOriginApiInstance(path) {
   });
   instance.interceptors.request.use(
     async (config) => {
-      const { getLinkedSession: getLinkedSession2 } = await import("./linked-server-QAKKDBFM.js");
+      const { getLinkedSession: getLinkedSession2 } = await import("./linked-server-B4NEG4MA.js");
       const linked = await getLinkedSession2();
       config.baseURL = linked ? `${linked.serverUrl}${path}` : "http://no-server-configured";
       if (config.headers.set) {
@@ -5784,6 +7138,17 @@ async function registerUser(username, password) {
     handleApiError(error, "register user");
   }
 }
+async function adminCreateUser(username, password) {
+  try {
+    const response = await authApi.post("/users/admin-create", {
+      username,
+      password
+    });
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "admin create user");
+  }
+}
 async function loginUser(username, password, rememberMe = false) {
   try {
     const response = await authApi.post("/users/login", {
@@ -5818,6 +7183,20 @@ async function requestTrustedProxyLogin() {
   if (response.data.success) markUserAuthenticated();
   return response.data;
 }
+async function logoutUser() {
+  try {
+    const response = await authApi.post("/users/logout");
+    clearClientAuthState();
+    userWasAuthenticated = false;
+    authInvalidationHandled = false;
+    return response.data;
+  } catch (error) {
+    clearClientAuthState();
+    userWasAuthenticated = false;
+    authInvalidationHandled = false;
+    handleApiError(error, "logout user");
+  }
+}
 async function getUserInfo() {
   try {
     const response = await authApi.get("/users/me");
@@ -5919,6 +7298,17 @@ async function completePasswordReset(username, tempToken, newPassword, confirmDa
     handleApiError(error, "complete password reset");
   }
 }
+async function changePassword(oldPassword, newPassword) {
+  try {
+    const response = await authApi.post("/users/change-password", {
+      oldPassword,
+      newPassword
+    });
+    return response.data;
+  } catch (error) {
+    handleApiError(error, "change password");
+  }
+}
 
 // src/ui/lib/linked-server.ts
 var CACHE_MS = 6e4;
@@ -5957,7 +7347,9 @@ export {
   setFrontendState,
   getPluginRecord,
   knownPluginIds,
+  resetPluginStore,
   isElectron,
+  localBackendPort,
   createRegistry,
   byOrderThenId,
   manifestDeclares,
@@ -5966,6 +7358,9 @@ export {
   getTabType,
   listTabTypes,
   useTabTypes,
+  isPersistentTabType,
+  isSessionTabType,
+  canRestoreTabType,
   tabTypeForActivity,
   useTabs,
   useTabsSafe,
@@ -5976,24 +7371,107 @@ export {
   dbHealthMonitor,
   getDeviceId,
   SYNC_CHANGED_EVENT,
+  invalidateServerStatusCache,
+  invalidateHostsAndStatusCaches,
   getSSHHosts,
+  createSSHHost,
+  updateSSHHost,
+  bulkImportSSHHosts,
+  importSSHConfigHosts,
+  bulkUpdateSSHHosts,
+  reorderSSHHosts,
+  deleteSSHHost,
+  exportAllSSHHosts,
   websocketAuthProtocols,
   getLinkedSession,
   notifySyncChanged,
   resolveConnectionOrigin,
   buildOriginWsUrl,
+  getAllServerStatuses,
+  getStatusCheckSettings,
+  updateStatusCheckSettings,
+  defaultHostRowFields,
+  defaultHostSidebarPreferences,
+  sanitizeHostSidebarPreferences,
+  getHostSidebarPreferences,
+  saveHostSidebarPreferences,
+  CREDENTIAL_ROW_FIELD_KEYS,
+  defaultCredentialRowFields,
+  defaultCredentialSidebarPreferences,
+  sanitizeCredentialSidebarPreferences,
+  getCredentialSidebarPreferences,
+  saveCredentialSidebarPreferences,
   pluginStepKey,
   PRESETS,
+  UI_AREA_KEYS,
+  getLogLevel,
+  updateLogLevel,
+  getSessionTimeout,
+  updateSessionTimeout,
+  getBranding,
+  updateBranding,
   hydrateLocalSharedHostAuth,
+  getConnectedRemoteApi,
   resolveRemoteHostId,
+  getUserList,
+  getSessions,
+  revokeSession,
+  revokeAllUserSessions,
+  createApiKey,
+  getApiKeys,
+  deleteApiKey,
+  makeUserAdmin,
+  removeAdminStatus,
+  deleteUser,
+  deleteAccount,
+  adminResetUserPassword,
+  adminExportUserData,
+  updateRegistrationAllowed,
+  getExternalAutoProvision,
+  updateExternalAutoProvision,
+  getSecondFactorAfterExternalLogin,
+  updateSecondFactorAfterExternalLogin,
+  updatePasswordLoginAllowed,
   getPasswordResetAllowed,
+  updatePasswordResetAllowed,
+  adminGetUserHosts,
+  adminCreateUserHost,
+  adminUpdateUserHost,
+  adminDeleteUserHost,
+  adminGetHostPassword,
+  adminGetUserCredentials,
+  adminCreateUserCredential,
+  adminUpdateUserCredential,
+  adminDeleteUserCredential,
+  releaseUrlFrom,
   getVersionInfo,
+  getUpdateChannel,
+  setUpdateChannel,
+  getChannelReleases,
   getDatabaseHealth,
   getCredentials,
+  getCredentialDetails,
+  createCredential,
+  updateCredential,
+  duplicateCredential,
+  deleteCredential,
   getHostPassword,
+  renameFolder,
+  getSSHFolders,
+  updateFolderMetadata,
+  reorderFolders,
+  deleteAllHostsInFolder,
+  renameCredentialFolder,
+  reorderCredentials,
+  generatePublicKeyFromPrivate,
+  generateKeyPair,
+  deployCredentialToHost,
   getUptime,
   getRecentActivity,
   logActivity,
+  resetRecentActivity,
+  linkExternalToPasswordAccount,
+  unlinkExternalFromPasswordAccount,
   getRoles,
   createRole,
   updateRole,
@@ -6017,21 +7495,31 @@ export {
   shareCredential,
   getCredentialAccess,
   revokeCredentialAccess,
+  getOpenTabs,
+  deleteOpenTab,
   patchOpenTab,
+  addOpenTab,
+  getActiveSessions,
+  getSessionTimeoutMinutes,
   parseCustomKeybindings,
   getUserPreferences,
+  saveUserPreferences,
   TRUST_TOKEN_KEY,
   setCookie,
   getCookie,
   markUserAuthenticated,
   getBackendUrl,
   createRemoteOriginApiInstance,
+  hostApi,
+  sshHostApi,
   authApi,
   rbacApi,
   handleApiError,
   registerUser,
+  adminCreateUser,
   loginUser,
   requestTrustedProxyLogin,
+  logoutUser,
   getUserInfo,
   getCurrentToken,
   getRegistrationAllowed,
@@ -6040,5 +7528,6 @@ export {
   requestDesktopAutoSession,
   initiatePasswordReset,
   verifyPasswordResetCode,
-  completePasswordReset
+  completePasswordReset,
+  changePassword
 };