@termix-ssh/plugin-sdk 1.0.0

package/dist/host/types/src/ui/lib/ttl-request-cache.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Short-lived in-memory cache with in-flight request deduplication.
+ * Concurrent callers share one loader promise; failures are not cached.
+ */
+export type TtlRequestCache<T> = {
+    get(loader: () => Promise<T>): Promise<T>;
+    invalidate(): void;
+    peek(): T | null;
+};
+export declare function createTtlRequestCache<T>(ttlMs: number): TtlRequestCache<T>;

package/dist/host/types/src/ui/lib/usage-color.d.ts

@@ -0,0 +1,5 @@
+/** Usage ramp for resource readouts: warning from 75, destructive from 90. */
+/** Text color class for a percentage. */
+export declare function usageColor(percent: number | null): string;
+/** Background class for the same ramp. */
+export declare function usageBarColor(percent: number | null): string;

package/dist/host/types/src/ui/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/host/types/src/ui/lib/visible-interval.d.ts

@@ -0,0 +1,5 @@
+/**
+ * setInterval that pauses while the document is hidden and fires once on resume.
+ * Returns a cleanup function for useEffect.
+ */
+export declare function runVisibleInterval(tick: () => void, intervalMs: number): () => void;

package/dist/host/types/src/ui/lib/widget-title.d.ts

@@ -0,0 +1,8 @@
+import type { LucideIcon } from "lucide-react";
+interface WidgetTitleProps {
+    title: string | null | undefined;
+    icon?: React.ReactElement<LucideIcon>;
+    fallback?: string;
+}
+export declare function WidgetTitle({ title, icon, fallback }: WidgetTitleProps): import("react").JSX.Element;
+export {};

package/dist/host/types/src/ui/lib/ws-auth.d.ts

@@ -0,0 +1 @@
+export declare function websocketAuthProtocols(token: string | null): string[];

package/dist/host/types/src/ui/main-axios.d.ts

@@ -0,0 +1,170 @@
+import { type AxiosInstance } from "axios";
+import { isElectron } from "./lib/electron";
+import type { SSHHost } from "../types/index";
+export interface Role {
+    id: number;
+    name: string;
+    displayName: string;
+    description: string | null;
+    isSystem: boolean;
+    permissions: string[] | string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface UserRole {
+    userId: string;
+    roleId: number;
+    roleName: string;
+    roleDisplayName: string;
+    grantedBy: string;
+    grantedByUsername: string;
+    grantedAt: string;
+}
+export interface AccessRecord {
+    id: number;
+    targetType: "user" | "role";
+    userId: string | null;
+    roleId: number | null;
+    username: string | null;
+    roleName: string | null;
+    roleDisplayName: string | null;
+    grantedBy: string;
+    grantedByUsername: string;
+    permissionLevel: "connect" | "view" | "edit" | "manage";
+    expiresAt: string | null;
+    createdAt: string;
+}
+export type ServerStatus = {
+    status: "online" | "offline";
+    lastChecked: string;
+};
+export type SSHHostWithStatus = SSHHost & {
+    status: "online" | "offline" | "unknown";
+};
+export interface AuthResponse {
+    success?: boolean;
+    is_admin?: boolean;
+    username?: string;
+    userId?: string;
+    is_external?: boolean;
+    totp_enabled?: boolean;
+    requires_totp?: boolean;
+    temp_token?: string;
+    rememberMe?: boolean;
+    token?: string;
+}
+export interface UserInfo {
+    /** Any second factor, kept under its 2.8 name for older clients. */
+    totp_enabled: boolean;
+    /** Admin user list only. */
+    second_factor_enabled?: boolean;
+    userId: string;
+    username: string;
+    is_admin: boolean;
+    /** Signs in through an external login such as SSO or LDAP. */
+    is_external?: boolean;
+    is_dual_auth?: boolean;
+    password_hash?: string;
+    data_unlocked?: boolean;
+    show_donation_modal?: boolean;
+    /** On a desktop linked to a server, the account it is signed in to there. */
+    linked?: LinkedAccountInfo | null;
+}
+export interface LinkedAccountInfo {
+    serverUrl: string;
+    serverName: string | null;
+    username: string | null;
+    isAdmin: boolean;
+    roles: string[];
+    permissions: string[];
+    status: string;
+}
+interface UserCount {
+    count: number;
+}
+export { isElectron };
+export declare function setCookie(name: string, value: string, days?: number): void | Promise<void>;
+export declare function getCookie(name: string): string | undefined;
+export declare function markUserAuthenticated(): void;
+export declare function isCurrentAuthInvalidationError(error: unknown): boolean;
+/** A URL on the main backend, resolved for web, dev proxy and Electron. */
+export declare function getBackendUrl(path: string): string;
+export declare function createRemoteOriginApiInstance(path: string): AxiosInstance;
+/** The linked server's core routes, unprefixed. */
+export declare function getRemoteCoreApi(): AxiosInstance;
+export declare let hostApi: AxiosInstance;
+export declare let sshHostApi: AxiosInstance;
+export declare let authApi: AxiosInstance;
+export declare let rbacApi: AxiosInstance;
+export declare const appReadyPromise: Promise<void>;
+export declare function handleApiError(error: unknown, operation: string): never;
+export { getSSHHosts, createSSHHost, updateSSHHost, bulkImportSSHHosts, importSSHConfigHosts, bulkUpdateSSHHosts, reorderSSHHosts, deleteSSHHost, getSSHHostById, exportSSHHostWithCredentials, exportAllSSHHosts, testProxyConnection, } from "./api/ssh-host-management-api";
+export { getAllServerStatuses, getServerStatusById, refreshServerPolling, getStatusCheckSettings, updateStatusCheckSettings, } from "./api/host-status-api";
+export { getHostSidebarPreferences, saveHostSidebarPreferences, } from "./api/host-sidebar-preferences-api";
+export { getCredentialSidebarPreferences, saveCredentialSidebarPreferences, } from "./api/credential-sidebar-preferences-api";
+export { getUiPreferences, saveUiPreferences } from "./api/ui-preferences-api";
+export { getLogLevel, updateLogLevel, getSessionTimeout, updateSessionTimeout, } from "./api/settings-api";
+export declare function registerUser(username: string, password: string): Promise<Record<string, unknown>>;
+export declare function adminCreateUser(username: string, password: string): Promise<Record<string, unknown>>;
+export declare function loginUser(username: string, password: string, rememberMe?: boolean): Promise<AuthResponse>;
+export declare function requestTrustedProxyLogin(): Promise<{
+    enabled: boolean;
+    success?: boolean;
+    username?: string;
+    userId?: string;
+    is_admin?: boolean;
+    token?: string;
+}>;
+export declare function logoutUser(): Promise<{
+    success: boolean;
+    message: string;
+}>;
+export declare function getUserInfo(): Promise<UserInfo>;
+export declare function dismissDonationModal(): Promise<void>;
+export declare function getCurrentToken(): Promise<string | null>;
+export declare function unlockUserData(password: string): Promise<{
+    success: boolean;
+    message: string;
+}>;
+export declare function getRegistrationAllowed(): Promise<{
+    allowed: boolean;
+}>;
+export declare function getPasswordLoginAllowed(): Promise<{
+    allowed: boolean;
+    /** Turned off by an admin but kept on because nothing else can sign in. */
+    forced?: boolean;
+}>;
+export declare function getSetupRequired(): Promise<{
+    setup_required: boolean;
+}>;
+export type DesktopAutoSessionOutcome = {
+    kind: "success";
+    data: AuthResponse;
+} | {
+    kind: "declined";
+} | {
+    kind: "retry";
+};
+/**
+ * Electron-only, non-iframed local login: exchanges the embedded backend's
+ * auto-provisioned local user for a session without ever showing a login
+ * form. If the local database contains multiple users, the backend
+ * deterministically chooses the admin account, or the earliest registered
+ * account if no admin exists.
+ */
+export declare function requestDesktopAutoSession(): Promise<DesktopAutoSessionOutcome>;
+export declare function getUserCount(): Promise<UserCount>;
+export declare function initiatePasswordReset(username: string): Promise<Record<string, unknown>>;
+export declare function verifyPasswordResetCode(username: string, resetCode: string): Promise<Record<string, unknown>>;
+export declare function completePasswordReset(username: string, tempToken: string, newPassword: string, confirmDataWipe?: boolean): Promise<Record<string, unknown>>;
+export declare function changePassword(oldPassword: string, newPassword: string): Promise<any>;
+export { getUserList, getSessions, revokeSession, revokeAllUserSessions, createApiKey, getApiKeys, deleteApiKey, makeUserAdmin, removeAdminStatus, deleteUser, deleteAccount, updateRegistrationAllowed, getExternalAutoProvision, updateExternalAutoProvision, getSecondFactorAfterExternalLogin, updateSecondFactorAfterExternalLogin, updatePasswordLoginAllowed, getPasswordResetAllowed, updatePasswordResetAllowed, adminResetUserPassword, adminExportUserData, type ApiKey, type CreatedApiKey, } from "./api/user-management-api";
+export { adminGetUserHosts, adminCreateUserHost, adminUpdateUserHost, adminDeleteUserHost, adminGetHostPassword, adminGetUserCredentials, adminGetUserCredentialDetails, adminCreateUserCredential, adminUpdateUserCredential, adminDeleteUserCredential, } from "./api/admin-user-data-api";
+export { getReleasesRSS, getVersionInfo, releaseUrlFrom, getDatabaseHealth, } from "./api/system-status-api";
+export { getCredentials, getCredentialDetails, createCredential, updateCredential, duplicateCredential, deleteCredential, getCredentialHosts, getCredentialFolders, getSSHHostWithCredentials, getHostPassword, applyCredentialToHost, removeCredentialFromHost, migrateHostToCredential, getFoldersWithStats, renameFolder, getSSHFolders, updateFolderMetadata, reorderFolders, deleteAllHostsInFolder, renameCredentialFolder, reorderCredentials, detectKeyType, detectPublicKeyType, validateKeyPair, generatePublicKeyFromPrivate, generateKeyPair, deployCredentialToHost, } from "./api/credentials-api";
+export type { UptimeInfo, RecentActivityItem } from "./api/dashboard-api";
+export { getUptime, getRecentActivity, logActivity, resetRecentActivity, } from "./api/dashboard-api";
+export { linkExternalToPasswordAccount, unlinkExternalFromPasswordAccount, } from "./api/external-account-api";
+export { getRoles, createRole, updateRole, deleteRole, getUserRoles, assignRoleToUser, removeRoleFromUser, shareHost, shareFolder, updateHostAccess, getHostAccess, revokeHostAccess, getHostAuthOverride, setHostAuthOverride, getPermissionsCatalog, getSharedHosts, } from "./api/rbac-api";
+export type { SharePermissionLevel, ShareTarget, PermissionCatalogEntry, PermissionCatalogItem, } from "./api/rbac-api";
+export { getOpenTabs, syncOpenTabs, deleteOpenTab, patchOpenTab, addOpenTab, getActiveSessions, getUserPreferences, saveUserPreferences, type OpenTabRecord, type OpenTabSyncPayload, type OpenTabUpsertPayload, type ActiveSessionInfo, type UserPreferences, } from "./api/open-tabs-api";

package/dist/host/types/src/ui/plugin-host/PluginViewPlaceholder.d.ts

@@ -0,0 +1,13 @@
+import { type ViewKind } from "./view-ownership";
+/**
+ * Stands in for a tab, panel or card whose plugin is not running.
+ *
+ * A saved tab of a plugin that was switched off or removed must neither crash
+ * the shell nor vanish without a word, so it renders this until the plugin is
+ * back, at which point the real view takes over in place.
+ */
+export declare function PluginViewPlaceholder({ kind, viewId, compact, }: {
+    kind: ViewKind;
+    viewId: string;
+    compact?: boolean;
+}): import("react").JSX.Element;

package/dist/host/types/src/ui/plugin-host/app.d.ts

@@ -0,0 +1,18 @@
+import type { PluginManifest, TermixApp } from "@termix-ssh/plugin-sdk/frontend";
+import { type PluginContributions } from "../api/plugins-api";
+export interface PluginAppHandle {
+    app: TermixApp;
+    /** Runs every disposer, newest first, isolating failures. */
+    dispose: () => void;
+}
+/**
+ * Builds the object a plugin's `activate(app)` receives.
+ *
+ * Every registration goes into one bag, so disabling the plugin removes all
+ * of it whatever the plugin's own `deactivate` does. Components are wrapped
+ * in the plugin's scope as they are registered, which is what gives the SDK
+ * hooks their plugin id and keeps a crash inside the plugin's own box.
+ */
+export declare function createPluginApp(pluginId: string, manifest: PluginManifest, contributes: PluginContributions | null, options?: {
+    guest?: boolean;
+}): PluginAppHandle;

package/dist/host/types/src/ui/plugin-host/auth-registry.d.ts

@@ -0,0 +1,50 @@
+import type { ComponentType } from "react";
+import type { LoginMethodUIProps, SecondFactorUIProps } from "@termix-ssh/plugin-sdk/frontend";
+/**
+ * Auth UI plugins contribute.
+ *
+ * SSH auth editors render in the host and credential editors when their auth
+ * type is picked. Login methods render on the login screen for methods the
+ * server reports as enabled; second factors render in the step after a first
+ * login. Either kind may bring an enrolment section for Settings > Security.
+ */
+export interface SshAuthEditorDef {
+    /** The authType value stored on the host. */
+    id: string;
+    pluginId?: string;
+    titleKey: string;
+    hintKey?: string;
+    component?: ComponentType<{
+        form: any;
+        setField: (key: string, value: unknown) => void;
+    }>;
+}
+export interface LoginMethodDef {
+    id: string;
+    pluginId?: string;
+    titleKey: string;
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    component: ComponentType<LoginMethodUIProps>;
+    /** Also drawn under the password form. */
+    placement?: "inline";
+    enrollment?: ComponentType<Record<string, unknown>>;
+}
+export interface SecondFactorDef {
+    id: string;
+    pluginId?: string;
+    titleKey: string;
+    component: ComponentType<SecondFactorUIProps>;
+    enrollment?: ComponentType<Record<string, unknown>>;
+}
+export declare const registerSshAuthEditor: (item: SshAuthEditorDef) => () => void;
+export declare const useSshAuthEditors: () => SshAuthEditorDef[];
+export declare const registerLoginMethod: (item: LoginMethodDef) => () => void;
+export declare const getLoginMethodUI: (id: string) => LoginMethodDef;
+export declare const useLoginMethods: () => LoginMethodDef[];
+export declare const listLoginMethodUIs: () => LoginMethodDef[];
+export declare const registerSecondFactor: (item: SecondFactorDef) => () => void;
+export declare const getSecondFactorUI: (id: string) => SecondFactorDef;
+export declare const useSecondFactors: () => SecondFactorDef[];
+export declare const listSecondFactorUIs: () => SecondFactorDef[];

package/dist/host/types/src/ui/plugin-host/bridge.d.ts

@@ -0,0 +1,26 @@
+import { type PluginHostBridge, type PluginHostRecord } from "@termix-ssh/plugin-sdk/frontend";
+import { createPluginApi } from "../lib/plugin-transport";
+/**
+ * Resolves a permission the way the backend's ctx.rbac does: a short name
+ * belongs to the plugin, while a full id in a core group or another plugin's
+ * namespace is taken as given.
+ */
+export declare function resolvePluginPermission(pluginId: string, permission: string): string;
+/** Test seam: renderWithApp's `api` option stands in for the real client. */
+export declare function setPluginApiForTesting(pluginId: string, client: ReturnType<typeof createPluginApi> | null): void;
+/** Both host shapes the shell holds: its own list and the API's. */
+type ShellHost = Omit<Partial<PluginHostRecord>, "id" | "parentHostId"> & {
+    id: string | number;
+    parentHostId?: string | number | null;
+};
+/**
+ * The shell's host as the SDK types it. Copied field by field, so a core
+ * field reaches plugins only once it is part of PluginHostRecord.
+ */
+export declare function toHostRecord(host: ShellHost): PluginHostRecord;
+/** The host as one plugin sees it: only that plugin's settings. */
+export declare function toPluginHostRecord(host: ShellHost, pluginId: string | null): PluginHostRecord;
+export declare const pluginHostBridge: PluginHostBridge;
+/** Installs the bridge. Idempotent. */
+export declare function installPluginHostBridge(): void;
+export {};

package/dist/host/types/src/ui/plugin-host/component-registry.d.ts

@@ -0,0 +1,24 @@
+import { type ComponentType, type ReactNode } from "react";
+/**
+ * Components a plugin offers other code by id, through app.registerComponent.
+ *
+ * The owner decides what the component is and the caller decides where it
+ * goes: the ssh-terminal plugin offers "terminal.view", and the collab room,
+ * the homepage SSH widget and the file manager render it without importing
+ * the terminal. While the owner is off the id resolves to nothing and the
+ * caller's fallback shows instead.
+ */
+type AnyComponent = ComponentType<Record<string, unknown>>;
+export declare function registerPluginComponent(id: string, component: AnyComponent): () => void;
+/** The component registered under an id, re-rendering when that changes. */
+export declare function usePluginComponent(id: string): AnyComponent | undefined;
+/**
+ * Renders the component another plugin registered under `id`, with the rest
+ * of the props passed through, or `fallback` while nobody has registered it.
+ */
+export declare function PluginComponent({ id, fallback, ...props }: {
+    id: string;
+    fallback?: ReactNode;
+    [prop: string]: unknown;
+}): ReactNode;
+export {};

package/dist/host/types/src/ui/plugin-host/desktop.d.ts

@@ -0,0 +1,7 @@
+/** app.desktop: the server this desktop is linked to, for plugins. */
+type RemoteServerSource = () => string | null | Promise<string | null>;
+/** renderWithApp's stand-in for the linked server. */
+export declare function setRemoteServerUrlForTesting(source: RemoteServerSource | null): void;
+export declare function remoteServerUrl(): Promise<string | null>;
+export declare function onRemoteServerChange(listener: () => void): () => void;
+export {};

package/dist/host/types/src/ui/plugin-host/extension-registry.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Named lists any plugin can add to through app.registerExtension. The plugin
+ * that reads a point decides its id and item shape; core only stores them, so
+ * contributions survive the reader being off and core never learns what a
+ * point is for.
+ */
+export interface RegisteredExtension {
+    id: string;
+    pluginId?: string;
+    [key: string]: unknown;
+}
+export declare function registerExtension(pointId: string, extension: RegisteredExtension): () => void;
+export declare function getExtension(pointId: string, id: string): RegisteredExtension | undefined;
+export declare function listExtensions(pointId: string): RegisteredExtension[];
+export declare function useExtensions(pointId: string): RegisteredExtension[];
+export declare function resetExtensions(): void;

package/dist/host/types/src/ui/plugin-host/host-scope.d.ts

@@ -0,0 +1,26 @@
+type SettingsBag = Record<string, Record<string, unknown> | undefined>;
+type HostLike = {
+    id: string | number;
+    pluginSettings?: SettingsBag;
+};
+/**
+ * A plugin sees only its own host settings. Another plugin's settings reach
+ * it through that plugin's actions or services, never by reading the host,
+ * so a plugin can rename a setting without breaking its neighbours.
+ *
+ * Settings come from the shell's own copy of the host when it has one, so a
+ * host one plugin hands another (through an action or a tab) is re-read for
+ * the receiver instead of arriving with the sender's slice.
+ */
+export declare function isHostLike(value: unknown): value is HostLike;
+export declare function scopeHost<T>(value: T, pluginId: string): T;
+/**
+ * Scopes each argument that is a host, and the `host` / `sshHost` fields of
+ * an argument that is a request object such as `{ host, appTheme }`.
+ */
+export declare function scopeHostArgs<A extends unknown[]>(args: A, pluginId: string): A;
+/** Scopes the host fields of a props, context or request object. */
+export declare function scopeHostFields<T>(value: T, pluginId: string): T;
+/** Wraps a plugin callback so any host it is called with is scoped. */
+export declare function scopeHostCallback<F extends (...args: never[]) => unknown>(fn: F | undefined, pluginId: string): F | undefined;
+export {};

package/dist/host/types/src/ui/plugin-host/loader.d.ts

@@ -0,0 +1,52 @@
+import type { ResourceKey } from "i18next";
+import type { FrontendModule } from "@termix-ssh/plugin-sdk/frontend";
+import { type PluginSummary } from "../api/plugins-api";
+export interface PluginLoaderDeps {
+    fetchPlugins: () => Promise<PluginSummary[]>;
+    importFrontend: (summary: PluginSummary) => Promise<FrontendModule>;
+    loadLocale: (summary: PluginSummary, file: string) => Promise<ResourceKey | null>;
+    /** Adds the plugin stylesheet; returns the element to remove later. */
+    injectCss: (summary: PluginSummary) => HTMLLinkElement | null;
+}
+/** Test seam: swaps how plugins are fetched, imported and localized. */
+export declare function configurePluginLoader(next: Partial<PluginLoaderDeps>): void;
+/**
+ * Enabled plugins in an order where each comes after its dependencies. A
+ * cycle or a missing hard dependency leaves the plugin out, marked blocked.
+ */
+export declare function orderForActivation(summaries: PluginSummary[]): {
+    order: PluginSummary[];
+    blocked: Map<string, string>;
+};
+/**
+ * Fetches plugin state and brings the loaded frontends in line with it. Safe
+ * to call as often as needed; calls run one after another.
+ */
+export declare function syncPlugins(summaries?: PluginSummary[]): Promise<void>;
+/**
+ * The `?view=` names enabled guest plugins serve to anonymous pages, so the
+ * entry point can tell a guest link from a signed-in full-screen view
+ * without knowing any plugin.
+ */
+export declare function fetchGuestViews(): Promise<string[]>;
+/**
+ * Loads the plugins the login screen needs (login methods and second
+ * factors) before anyone has signed in. After sign-in the full runtime
+ * reconciles, keeping these active when their bundle has not changed.
+ */
+export declare function startPreLoginPlugins(options?: {
+    retryFailed?: boolean;
+}): Promise<void>;
+/**
+ * Starts the runtime. Idempotent. `guest` is for anonymous pages (shared
+ * session links): only plugins declaring contributes.guest load, from the
+ * public list, and nothing is refetched on focus.
+ */
+export declare function startPluginRuntime(options?: {
+    guest?: boolean;
+}): Promise<void>;
+/** Deactivates every plugin, on logout. */
+export declare function stopPluginRuntime(): Promise<void>;
+export declare function isPluginFrontendActive(pluginId: string): boolean;
+/** Test seam. */
+export declare function resetPluginLoader(): Promise<void>;

package/dist/host/types/src/ui/plugin-host/plugin-store.d.ts

@@ -0,0 +1,40 @@
+import type { PluginSummary } from "../api/plugins-api";
+/**
+ * What the browser knows about each plugin: the server's summary plus how
+ * far its frontend got.
+ *
+ * `frontend` is separate from the server state on purpose. A plugin can be
+ * enabled and healthy on the server while its bundle failed to import, and
+ * the shell has to show that as failed rather than as missing.
+ */
+export type FrontendState = "none" | "loading" | "active" | "failed" | "blocked" | "inactive";
+export interface PluginRecord {
+    summary: PluginSummary;
+    frontend: FrontendState;
+    error?: string;
+}
+interface StoreState {
+    /** False until the first GET /plugins answers. */
+    loaded: boolean;
+    /**
+     * True once every enabled frontend has been tried at least once. The shell
+     * restores saved tabs only after this, so plugin tabs come back as
+     * themselves rather than as placeholders.
+     */
+    settled: boolean;
+    records: ReadonlyMap<string, PluginRecord>;
+}
+export declare function getPluginStoreState(): StoreState;
+export declare function usePluginStore(): StoreState;
+/** Replaces the summaries, keeping each plugin's frontend state. */
+export declare function setPluginSummaries(summaries: PluginSummary[]): void;
+export declare function markPluginsSettled(): void;
+export declare function setFrontendState(pluginId: string, frontend: FrontendState, error?: string): void;
+export declare function getPluginRecord(pluginId: string): PluginRecord | undefined;
+/** Resolves once plugins have settled; at once if they already have. */
+export declare function settledPromise(): Promise<void>;
+/** Plugin ids known to the server, used to resolve permission namespaces. */
+export declare function knownPluginIds(): string[];
+/** Test seam. */
+export declare function resetPluginStore(): void;
+export {};

package/dist/host/types/src/ui/plugin-host/scope.d.ts

@@ -0,0 +1,20 @@
+import { type ComponentType } from "react";
+/** The plugin whose component is rendering, or null in core UI. */
+export declare function usePluginScope(): string | null;
+/**
+ * Wraps a plugin's component once, at registration, so every place the shell
+ * renders it gets the plugin id for the SDK hooks and an error boundary,
+ * without each call site having to remember.
+ */
+export declare function withPluginScope<P extends object>(pluginId: string, Inner: ComponentType<P>): ComponentType<P>;
+/**
+ * A plugin icon the shell renders inline (rail, tab strip, host row). Small
+ * enough that a broken one should just disappear, not take the row with it.
+ */
+export declare function withIconBoundary<P extends object>(pluginId: string, Icon: ComponentType<P> | undefined): ComponentType<P> | undefined;
+/**
+ * A plugin callback core calls while rendering, such as a host action's
+ * label. A throw is logged and answered with `fallback`, so one plugin
+ * cannot break the host list.
+ */
+export declare function guardCallback<A extends unknown[], R>(pluginId: string, fn: ((...args: A) => R) | undefined, fallback: R): ((...args: A) => R) | undefined;

package/dist/host/types/src/ui/plugin-host/sdk-ui.d.ts

@@ -0,0 +1,99 @@
+/**
+ * @termix-ssh/plugin-sdk/ui: the shell's components, for plugins.
+ *
+ * Everything exported here is public API. A plugin builds its UI from these
+ * so it looks like the rest of the app and picks up theme changes, and it
+ * receives the shell's own instances through the import map, never a copy.
+ *
+ * The list is deliberate. It covers what the bundled plugins use today: the
+ * shadcn primitives, the composites for metrics, connection screens and
+ * settings rows, and the contexts a connection surface needs. Adding to it is
+ * a contract change. Removing from it breaks plugins.
+ */
+export { Alert, AlertDescription, AlertTitle } from "../components/alert";
+export { AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, } from "../components/alert-dialog";
+export { Badge } from "../components/badge";
+export { Button, type ButtonProps } from "../components/button";
+export { Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, } from "../components/card";
+export { Checkbox } from "../components/checkbox";
+export { Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, } from "../components/dialog";
+export { DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, } from "../components/dropdown-menu";
+export { Input } from "../components/input";
+export { Label } from "../components/label";
+export { PasswordInput } from "../components/password-input";
+export { Popover, PopoverAnchor, PopoverContent, PopoverTrigger, } from "../components/popover";
+export { ScrollArea, ScrollBar } from "../components/scroll-area";
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, } from "../components/select";
+export { Select2 } from "../components/select2";
+export { Separator } from "../components/separator";
+export { Skeleton } from "../components/skeleton";
+export { Slider } from "../components/slider";
+export { Switch } from "../components/switch";
+export { Textarea, type TextareaProps } from "../components/textarea";
+export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, } from "../components/tooltip";
+export { FakeSwitch, SectionCard, SettingRow } from "../components/section-card";
+export { MetricCard } from "../components/metric-card";
+export { BarSeries, MiniStat, RadialGauge, Sparkline, StatRow, type BarSeriesItem, type BarSeriesProps, type RadialGaugeProps, type SparklineProps, } from "../components/charts";
+export { LineChart, type LineChartSeries } from "../components/charts/LineChart";
+export { CardGridCanvas, ColumnCountStepper, } from "../components/card-grid/CardGridCanvas";
+export { type GridCardCatalogEntry, type GridColSpan, type GridLayout, type GridSlot, } from "../components/card-grid/types";
+export { ConnectionScreen } from "../components/connection/ConnectionScreen";
+export { type ConnectionStatus } from "../components/connection/connection-status";
+export { FullScreenAppWrapper, type FullScreenAppPhase, } from "../components/FullScreenAppWrapper";
+export { ConnectionLogProvider, useConnectionLog, useOptionalConnectionLog, } from "../ssh/connection-log/ConnectionLogContext";
+export { TOTPDialog, type MFAPromptMode } from "../ssh/dialogs/TOTPDialog";
+export { SSHAuthDialog } from "../ssh/dialogs/SSHAuthDialog";
+export { BrowserSignInDialog } from "../ssh/dialogs/BrowserSignInDialog";
+export { FOLDER_COLORS } from "../lib/theme";
+export { useTabs, useTabsSafe } from "../shell/TabContext";
+export { ActionSlot, ComponentSlot } from "../shell/ActionSlot";
+export { HostFeatureFields, type HostFeatureFieldsProps, } from "../settings/HostPluginSections";
+export { HostDefaultBadge, DefaultsOnly as HostDefaultField, useIsDefaultsEditor, } from "../lib/host-defaults-context";
+export { PluginComponent } from "./component-registry";
+export { PluginViewPlaceholder } from "./PluginViewPlaceholder";
+export { cn } from "../lib/utils";
+export { runAdaptivePolling, getPollingEnvironmentMultiplier, } from "../lib/adaptive-polling";
+export { Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetTitle, SheetTrigger, } from "../components/sheet";
+export { ManagerCardShell, ManagerSearch, type ManagerCardError, } from "../components/manager-card";
+export { useAdaptivePolling } from "../hooks/use-adaptive-polling";
+export { WidgetTitle } from "../lib/widget-title";
+export { runVisibleInterval } from "../lib/visible-interval";
+export { useIsMobile } from "../hooks/use-mobile";
+export { EmptyState } from "../components/empty-state";
+export { PassphraseDialog } from "../ssh/dialogs/PassphraseDialog";
+export { HostKeyVerificationDialog } from "../ssh/dialogs/HostKeyVerificationDialog";
+export { copyToClipboard, readFromClipboard } from "../lib/clipboard";
+export { RobustClipboardProvider } from "../lib/clipboard-provider";
+export { useTheme as useAppTheme } from "../components/theme-provider";
+export { findMatchingKeybinding } from "../lib/keybinding-match";
+export { globalShortcutHandler } from "../lib/global-shortcut-handler";
+export { isMacPlatform, isTabJumpHotkey } from "../lib/tab-jump-hotkey";
+export { type CustomKeybinding, type KeyCombo, type KeybindingAction, type KeybindingActionType, } from "../../types/keybindings";
+export { isElectron } from "../lib/electron";
+export { resolveConnectionOrigin, type ConnectionOrigin, } from "../lib/connection-origin";
+export { pluginWsUrl } from "../lib/plugin-transport";
+export { buildOriginWsUrl, type WebSocketConnectionTarget, } from "../lib/connection-origin";
+export { getBasePath } from "../lib/base-path";
+export type { ConnectionStage } from "../../types/connection-log";
+export { hydrateLocalSharedHostAuth, resolveRemoteHostId, } from "../lib/remote-server-api";
+export { remoteServerUrl as linkedServerUrl } from "./desktop";
+export { getRecentActivity, getUptime, type RecentActivityItem, type UptimeInfo, } from "../api/dashboard-api";
+export { getVersionInfo, getDatabaseHealth, type VersionInfo, } from "../api/system-status-api";
+export { Kbd, KbdKey, KbdSeparator } from "../components/kbd";
+export { ConnectionLogPanel } from "../components/connection/ConnectionLogPanel";
+export type { LogEntry } from "../../types/connection-log";
+export { createFrontendLogger, type LogContext } from "../lib/frontend-logger";
+export { getAdaptiveResourceBudget, markAdaptiveResourceUsed, runAdaptiveBackgroundTask, } from "../lib/adaptive-resource-budget";
+export { getDeviceId } from "../lib/device-id";
+export { createQuickConnectHost } from "../sidebar/quick-connect-host";
+export { BackButton, Facts, GroupHeading, PANEL, PanelSearch, PanelShell, Segmented, ViewToggle, type PanelDensity, type PanelViewMode, } from "../components/panel-layout";
+export { DataView, type DataColumn, type GridColumns, } from "../components/data-view";
+export { TabStrip, type TabStripItem } from "../components/tab-strip";
+export { CardMasonry } from "../components/card-masonry";
+export { Meter, UsagePair } from "../components/meter";
+export { usageBarColor, usageColor } from "../lib/usage-color";
+export { Field, FieldPair, NumberField, Repeater, SecretField, SelectField, SwitchRow, TagInput, TextAreaField, TextField, } from "../components/form-fields";
+export { InlineView, PanePrompt, SurfaceScope, useConfirm, useSurfaceKind, type ConfirmOptions, type EditingWidth, type SurfaceKind, } from "../components/surface/surface-scope";
+export { PROMPT_BUTTON, PROMPT_DESTRUCTIVE_BUTTON, PROMPT_PRIMARY_BUTTON, } from "../components/surface/prompt-styles";
+export { ConnectionGate, useConnectionGate, type ConnectionGateController, type ConnectionGateProps, } from "../components/connection/ConnectionGate";
+export { type ConnectionUnavailable } from "../components/connection/ConnectionScreen";