@termix-ssh/plugin-sdk 1.0.0

package/dist/host/types/src/ui/sidebar/HostManagerTabs.d.ts

@@ -0,0 +1,65 @@
+import { type ComponentType, type ReactNode } from "react";
+/** Core host editor tabs. Plugins add theirs through registerHostEditorSection. */
+export type CoreHostTabId = "general" | "ssh";
+export type HostTabId = CoreHostTabId | (string & {});
+export type CredentialTabId = "general" | "auth";
+type HostTab = {
+    id: HostTabId;
+    label: string;
+    icon: ReactNode;
+};
+type CredentialTab = {
+    id: CredentialTabId;
+    label: string;
+    icon: ReactNode;
+};
+export interface HostEditorSectionRenderProps {
+    form: any;
+    setField: (key: string, value: unknown) => void;
+    /** Applies several fields at once, against the latest form. */
+    updateForm: (patch: (form: Record<string, unknown>) => Record<string, unknown>) => void;
+    host?: unknown;
+    credentials?: unknown[];
+    adminTargetUserId?: string;
+    protocols: Record<string, boolean>;
+    /** "defaults" in the host defaults editor. */
+    mode?: "host" | "defaults";
+}
+/**
+ * A host editor tab contributed at runtime. "top" tabs sit in the main strip
+ * beside General and SSH; "ssh" tabs sit in the SSH group's second strip.
+ */
+export interface HostEditorSectionDef {
+    id: string;
+    pluginId?: string;
+    group: "top" | "ssh";
+    labelKey: string;
+    /** Already-translated label, used instead of labelKey when set. */
+    label?: string;
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    /** Position among the group's tabs, core ones included. */
+    order?: number;
+    /** Whether to offer the tab for these protocols. Defaults to always. */
+    visible?: (protocols: Record<string, boolean>) => boolean;
+    /** Also offered in the host defaults editor; "only" for nowhere else. */
+    defaults?: boolean | "only";
+    component: ComponentType<HostEditorSectionRenderProps>;
+}
+export declare const registerHostEditorSection: (item: HostEditorSectionDef) => () => void;
+export declare const unregisterHostEditorSection: (id: string) => void;
+export declare const getHostEditorSection: (id: string) => HostEditorSectionDef;
+export declare const hostEditorSectionList: () => HostEditorSectionDef[];
+export declare const useHostEditorSections: () => HostEditorSectionDef[];
+export declare const resetHostEditorSections: () => void;
+/** Whether a tab lives in the SSH group's second strip. */
+export declare function isSshGroupTab(id: string): boolean;
+/**
+ * The main strip. With `protocols`, registered tabs are filtered by their
+ * `visible`; without, every registered top tab is listed.
+ */
+export declare function makeHostTabs(t: (key: string) => string, protocols?: Record<string, boolean>, defaultsMode?: boolean): HostTab[];
+export declare function makeHostSshSubTabs(t: (key: string) => string, protocols?: Record<string, boolean>, defaultsMode?: boolean): HostTab[];
+export declare function makeCredentialTabs(t: (key: string) => string): CredentialTab[];
+export { TabStrip } from "../components/tab-strip";

package/dist/host/types/src/ui/sidebar/host-contributions.d.ts

@@ -0,0 +1,72 @@
+import type { ComponentType } from "react";
+import type { Host } from "../../types/ui-types";
+import type { TabShellCallbacks } from "../shell/tab-registry";
+type Icon = ComponentType<{
+    className?: string;
+    size?: number | string;
+}>;
+/**
+ * What a plugin adds to a host: ways to connect or open a tool, badges on its
+ * row, and entries in its context menu. The host list, quick connect and the
+ * command palette all read these instead of knowing about each protocol.
+ */
+export interface HostActionDef {
+    id: string;
+    pluginId?: string;
+    titleKey: string;
+    icon: Icon;
+    kind: "connect" | "open";
+    priority?: number;
+    tabType?: string;
+    when: (host: Host) => boolean;
+    run?: (host: Host, shell: TabShellCallbacks) => void;
+    tray?: boolean;
+    copyUrlView?: string;
+    /** Where the dashboard's host status list sends a click. */
+    overview?: boolean;
+    /** Offered as a button in Quick Connect, opening tabType. */
+    quickConnect?: boolean;
+    order?: number;
+    /** A label worked out per host, e.g. a single endpoint's name. */
+    label?: (host: Host) => string | undefined;
+    /** Several targets: two or more become a picker, one runs directly. */
+    items?: (host: Host) => {
+        id: string;
+        label: string;
+        run: (host: Host, shell: TabShellCallbacks) => void;
+    }[];
+}
+export interface HostBadgeDef {
+    id: string;
+    pluginId?: string;
+    when: (host: Host) => boolean;
+    component: ComponentType<{
+        host: Host;
+    }>;
+    order?: number;
+}
+export interface HostContextMenuItemDef {
+    id: string;
+    pluginId?: string;
+    titleKey: string;
+    icon?: Icon;
+    when: (host: Host) => boolean;
+    run: (host: Host, shell: TabShellCallbacks) => void;
+    order?: number;
+}
+export declare const registerHostAction: (item: HostActionDef) => () => void;
+export declare const useHostActions: () => HostActionDef[];
+export declare const listHostActions: () => HostActionDef[];
+export declare const registerHostBadge: (item: HostBadgeDef) => () => void;
+export declare const useHostBadges: () => HostBadgeDef[];
+export declare const registerHostContextMenuItem: (item: HostContextMenuItemDef) => () => void;
+export declare const useHostContextMenuItems: () => HostContextMenuItemDef[];
+export declare function hostActionsFor(all: HostActionDef[], host: Host, kind?: HostActionDef["kind"]): HostActionDef[];
+/** The connect action a click on the host should run, by priority. */
+export declare function defaultConnectAction(all: HostActionDef[], host: Host): HostActionDef | undefined;
+export declare function hostBadgesFor(all: HostBadgeDef[], host: Host): HostBadgeDef[];
+export declare function hostMenuItemsFor(all: HostContextMenuItemDef[], host: Host): HostContextMenuItemDef[];
+/** Runs an action, falling back to opening its tab type. */
+export declare function runHostAction(action: HostActionDef, host: Host, shell: TabShellCallbacks): void;
+export declare function resetHostContributions(): void;
+export {};

package/dist/host/types/src/ui/sidebar/host-defaults/catalog.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The keys the host editor can show a default for: core's own, and every
+ * running plugin's host fields that can have one.
+ */
+import { type HostDefaultsLevel } from "../../../types/host-defaults";
+import { type PluginSettingsField, type PluginSummary } from "../../api/plugins-api";
+export interface EditorDefaultKey {
+    fullKey: string;
+    namespace: string;
+    key: string;
+    levels: readonly HostDefaultsLevel[];
+}
+export declare function isDefaultableField(field: PluginSettingsField): boolean;
+export declare function pluginDefaultKeys(plugins: PluginSummary[]): EditorDefaultKey[];
+export declare const CORE_EDITOR_KEYS: EditorDefaultKey[];
+/** Every key, by full key. Refreshed when the plugin list is. */
+export declare function useEditorDefaultKeys(): Map<string, EditorDefaultKey>;

package/dist/host/types/src/ui/sidebar/host-protocols.d.ts

@@ -0,0 +1,49 @@
+import type { ComponentType } from "react";
+type Icon = ComponentType<{
+    className?: string;
+    size?: number | string;
+}>;
+/**
+ * A connection protocol a plugin adds next to SSH. Its on/off
+ * switch and port are the plugin's own host settings, so core reads them
+ * from host.pluginSettings[pluginId] and never knows the protocol by name.
+ */
+export interface HostProtocolDef {
+    id: string;
+    pluginId: string;
+    /** The plugin's boolean host setting that switches the protocol on. */
+    settingKey: string;
+    /** The plugin's number host setting holding the port, if it has one. */
+    portKey?: string;
+    defaultPort: number;
+    titleKey: string;
+    descriptionKey?: string;
+    connectionOriginNoteKey?: string;
+    icon: Icon;
+    order?: number;
+    /** Offer it in Quick Connect, optionally with a domain field. */
+    quickConnect?: {
+        showDomain?: boolean;
+    };
+}
+export declare const registerHostProtocol: (item: HostProtocolDef) => () => void;
+export declare const useHostProtocols: () => HostProtocolDef[];
+export declare const listHostProtocols: () => HostProtocolDef[];
+/** Which protocols are on, keyed by setting key, with SSH as enableSsh. */
+export type HostProtocols = {
+    enableSsh: boolean;
+} & Record<string, boolean>;
+type PluginSettingsBag = Record<string, Record<string, unknown>> | undefined;
+export declare function protocolEnabled(pluginSettings: PluginSettingsBag, protocol: HostProtocolDef): boolean;
+export declare function protocolPort(pluginSettings: PluginSettingsBag, protocol: HostProtocolDef): number;
+export declare function hostProtocolFlags(host: {
+    enableSsh?: boolean;
+    pluginSettings?: PluginSettingsBag;
+} | null, list?: HostProtocolDef[]): HostProtocols;
+/** The protocols a host has switched on, in registration order. */
+export declare function enabledHostProtocols(host: {
+    pluginSettings?: PluginSettingsBag;
+}, list?: HostProtocolDef[]): HostProtocolDef[];
+/** Writes the editor's protocol switches into each owner's host settings. */
+export declare function withProtocolSettings(pluginSettings: Record<string, Record<string, unknown>>, flags: HostProtocols, list?: HostProtocolDef[]): Record<string, Record<string, unknown>>;
+export {};

package/dist/host/types/src/ui/sidebar/quick-connect-host.d.ts

@@ -0,0 +1,21 @@
+import type { SSHHostData } from "../../types";
+import type { Host } from "../../types/ui-types";
+import type { HostProtocolDef } from "./host-protocols";
+import { type HostActionDef } from "./host-contributions";
+type QuickConnectInput = Pick<Host, "ip" | "port" | "username" | "authType" | "password" | "key" | "credentialId"> & {
+    /** A plugin protocol; SSH when omitted. */
+    protocol?: HostProtocolDef;
+    domain?: string;
+    /** Fields a plugin's SSH auth editor filled in. */
+    authFields?: Record<string, unknown>;
+};
+export declare function isQuickConnectHost(host: Pick<Host, "id">): boolean;
+export declare function createQuickConnectHost(input: QuickConnectInput): Host;
+export declare function quickConnectHostToPayload(host: Host): SSHHostData;
+/**
+ * Every way to reach the address: connect actions (terminal, remote desktop)
+ * by priority, then tools that opted into Quick Connect. Only actions that
+ * open a tab work here, since the host is never saved.
+ */
+export declare function quickConnectTargets(all: HostActionDef[], host: Host): HostActionDef[];
+export {};

package/dist/host/types/src/ui/sidebar/rail-items.d.ts

@@ -0,0 +1,103 @@
+import { type LucideIcon } from "lucide-react";
+/**
+ * The one list of navigation destinations.
+ *
+ * This used to be duplicated in four places -- AppRail's button array, the
+ * visibility toggles in UserProfilePanel, AppShell's sidebar title map, and
+ * the mobile bar's own primary/more lists -- which drifted: half the sidebar
+ * titles were hardcoded English, the alerts entry had no visibility toggle,
+ * and the mobile bar ignored hidden tabs entirely. Everything now derives from
+ * here, so adding a destination is a single edit.
+ */
+export interface RailItemDef {
+    /** Matches RailView, or a TabType for entries that open a tab instead. */
+    id: string;
+    icon: LucideIcon;
+    /** i18n key; every label goes through t() so nothing is hardcoded English. */
+    labelKey: string;
+    /** Tab-opening entries rather than sidebar panels. */
+    kind?: "tab";
+    /** Always-available destinations that users cannot hide. */
+    alwaysVisible?: boolean;
+    /** Renders a separator after this item in the rail. */
+    separatorAfter?: boolean;
+    /** The rail band it sits in. Defaults to "tools". */
+    group?: RailGroup;
+    /** Shown on the mobile bottom bar's primary row rather than its More menu. */
+    mobilePrimary?: boolean;
+    /**
+     * Can also open as a full-width tab in the main area, via ctrl/middle-click
+     * or the rail context menu. The id doubles as the TabType.
+     */
+    promotable?: boolean;
+    /**
+     * Can be opened in the right dock. Reference panels only -- editors stay in
+     * the left sidebar, which is the only dock that widens for them.
+     */
+    rightDockable?: boolean;
+    /** Desktop app only. Hidden in the browser build, including its toggle. */
+    electronOnly?: boolean;
+    /** False keeps it out of the Navigation visibility toggles. */
+    hideable?: boolean;
+    /** A plugin item that stays visible in the Simple preset. */
+    simplePreset?: boolean;
+    /** Registered but not shown, e.g. while its feature is switched off. */
+    hidden?: boolean;
+    /** Places a registered item after this id instead of at the end. */
+    after?: string;
+    /** Tie-break among registered items. */
+    order?: number;
+    /** Set for items a plugin registered. */
+    pluginId?: string;
+    /** Role permission the user needs to see it at all, as a full id. */
+    permission?: string;
+    /** "footer" renders it at the bottom of the rail, above the profile. */
+    placement?: "main" | "footer";
+    /** Called as a hook by the rail; a positive number shows as a badge. */
+    useBadge?: () => number | null | undefined;
+}
+/** Things you keep, things you do, and the instance itself. */
+export type RailGroup = "objects" | "tools" | "system";
+export declare const RAIL_GROUP_ORDER: RailGroup[];
+export declare const RAIL_ITEMS: RailItemDef[];
+/** Main rail items split into their bands, in band order, empty bands left out. */
+export declare function groupRailItems(items: RailItemDef[]): {
+    group: RailGroup;
+    items: RailItemDef[];
+}[];
+export declare function registerRailItem(def: RailItemDef): () => void;
+/** Registered items, hidden ones included. */
+export declare const listRegisteredRailItems: () => RailItemDef[];
+/**
+ * Rail items available in the current build. Electron-only destinations are
+ * dropped in the browser build so they never reach the rail, the mobile bar,
+ * or the visibility toggles.
+ */
+export declare function visibleRailItems(): RailItemDef[];
+/**
+ * Drops items gated on a permission the user lacks. Until permissions load,
+ * gated items stay hidden rather than flashing in and out.
+ */
+export declare function permittedRailItems(items: RailItemDef[], permissions: {
+    has: (permission: string) => boolean;
+    loaded: boolean;
+}): RailItemDef[];
+/**
+ * visibleRailItems() as a hook, re-rendering when plugins change it, without
+ * the items the user's permissions hide.
+ */
+export declare function useRailItems(): RailItemDef[];
+/** Places outside the rail that still need a title, like the Settings tab. */
+export declare const RAIL_UTILITY_ITEMS: RailItemDef[];
+/** Ids that may be opened in the right dock. */
+export declare function rightDockableIds(): string[];
+/** Ids that may be opened as a full-width tab: a tab type or a panel to show. */
+export declare function promotableIds(): string[];
+/** Ids a user is allowed to hide from Appearance > Sidebar > Navigation. */
+export declare function hideableRailIds(): string[];
+/** Whether a rail view is one of core's own, rather than a plugin's. */
+export declare function isCoreRailView(id: string): boolean;
+/** Translated label for any rail destination, including registered ones. */
+export declare function railItemLabel(id: string, t: (key: string) => string): string;
+/** Test seam. */
+export declare function resetRegisteredRailItems(): void;

package/dist/host/types/src/ui/ssh/connection-log/ConnectionLogContext.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+import type { LogEntry } from "../../../types/connection-log";
+interface ConnectionLogContextType {
+    logs: LogEntry[];
+    addLog: (entry: Omit<LogEntry, "id" | "timestamp">) => void;
+    setLogs: (entries: Omit<LogEntry, "id" | "timestamp">[]) => void;
+    clearLogs: () => void;
+    isExpanded: boolean;
+    toggleExpanded: () => void;
+    setIsExpanded: React.Dispatch<React.SetStateAction<boolean>>;
+}
+export declare function ConnectionLogProvider({ children, }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+export declare function useConnectionLog(): ConnectionLogContextType;
+export declare function useOptionalConnectionLog(): ConnectionLogContextType;
+export {};

package/dist/host/types/src/ui/ssh/dialogs/BrowserSignInDialog.d.ts

@@ -0,0 +1,18 @@
+interface BrowserSignInDialogProps {
+    isOpen: boolean;
+    /** Who is asking, e.g. the product name of an SSH gateway. */
+    label: string;
+    url: string;
+    /** A code to compare in the browser; "N/A" or empty hides it. */
+    code: string;
+    onContinue: () => void;
+    onCancel: () => void;
+    onOpenUrl: () => void;
+    backgroundColor?: string;
+}
+/**
+ * A keyboard-interactive round finished in a browser: open the URL, compare
+ * the code there, then continue.
+ */
+export declare function BrowserSignInDialog({ isOpen, label, url, code, onContinue, onCancel, onOpenUrl, backgroundColor, }: BrowserSignInDialogProps): import("react").JSX.Element;
+export {};

package/dist/host/types/src/ui/ssh/dialogs/HostKeyVerificationDialog.d.ts

@@ -0,0 +1,17 @@
+interface HostKeyVerificationDialogProps {
+    isOpen: boolean;
+    scenario: "new" | "changed";
+    ip: string;
+    port: number;
+    hostname?: string;
+    fingerprint: string;
+    oldFingerprint?: string;
+    keyType: string;
+    oldKeyType?: string;
+    algorithm: string;
+    onAccept: () => void;
+    onReject: () => void;
+    backgroundColor?: string;
+}
+export declare function HostKeyVerificationDialog({ isOpen, scenario, ip, port, hostname, fingerprint, oldFingerprint, algorithm, onAccept, onReject, backgroundColor, }: HostKeyVerificationDialogProps): import("react").JSX.Element;
+export {};

package/dist/host/types/src/ui/ssh/dialogs/PassphraseDialog.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+interface PassphraseDialogProps {
+    isOpen: boolean;
+    onSubmit: (passphrase: string) => void;
+    onCancel: () => void;
+    hostInfo: {
+        ip: string;
+        port: number;
+        username: string;
+        name?: string;
+    };
+    backgroundColor?: string;
+}
+export declare function PassphraseDialog({ isOpen, onSubmit, onCancel, hostInfo, backgroundColor, }: PassphraseDialogProps): React.JSX.Element;
+export {};

package/dist/host/types/src/ui/ssh/dialogs/SSHAuthDialog.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+interface SSHAuthDialogProps {
+    isOpen: boolean;
+    reason: "no_keyboard" | "auth_failed" | "timeout";
+    onSubmit: (credentials: {
+        password?: string;
+        sshKey?: string;
+        keyPassword?: string;
+    }) => void;
+    onCancel: () => void;
+    hostInfo: {
+        ip: string;
+        port: number;
+        username: string;
+        name?: string;
+    };
+    backgroundColor?: string;
+}
+export declare function SSHAuthDialog({ isOpen, reason, onSubmit, onCancel, hostInfo, backgroundColor, }: SSHAuthDialogProps): React.JSX.Element;
+export {};

package/dist/host/types/src/ui/ssh/dialogs/TOTPDialog.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import type { MFAPromptMode } from "@termix-ssh/plugin-sdk/frontend";
+export type { MFAPromptMode };
+interface TOTPDialogProps {
+    isOpen: boolean;
+    prompt: string;
+    mode?: MFAPromptMode;
+    waiting?: boolean;
+    onSubmit: (code: string) => void;
+    onCancel: () => void;
+    backgroundColor?: string;
+}
+export declare function TOTPDialog({ isOpen, prompt, mode, waiting, onSubmit, onCancel, backgroundColor, }: TOTPDialogProps): React.JSX.Element;

package/dist/host/ui.d.ts

@@ -0,0 +1 @@
+export * from "./types/src/ui/plugin-host/sdk-ui.js";