@termix-ssh/plugin-sdk 1.0.10 → 1.0.12

package/dist/host/types/src/ui/shell/split/split-tree.d.ts

@@ -0,0 +1,89 @@
+import type { LayoutNode, PaneNode, SplitDirection, SplitNode, SplitState } from "../../../types/ui-types";
+/**
+ * The layout of one split tab: a tree where every leaf is a pane holding at
+ * most one tab, and every inner node lays its children out in a row (side by
+ * side) or a column (stacked). All functions here are pure and return a new
+ * state, so the shell can keep the whole thing on the split tab itself.
+ */
+export declare const MAX_PANES = 8;
+/** Smallest share of its parent a pane or group can be dragged down to. */
+export declare const MIN_PANE_SIZE = 10;
+export type { SplitDirection, PaneNode, SplitNode, LayoutNode, SplitState, } from "../../../types/ui-types";
+export type PaneEdge = "left" | "right" | "top" | "bottom";
+export type DropTarget = PaneEdge | "center";
+export type NavDirection = "left" | "right" | "up" | "down";
+export interface PaneRect {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+export declare function createPane(tabId?: string | null): PaneNode;
+export declare function evenSizes(count: number): number[];
+export declare function createSplitNode(direction: SplitDirection, children: LayoutNode[], sizes?: number[]): SplitNode;
+export declare function createSplitState(root: LayoutNode, focusedPaneId?: string): SplitState;
+export declare function listPanes(node: LayoutNode): PaneNode[];
+export declare function paneCount(state: SplitState): number;
+export declare function findPane(state: SplitState, paneId: string): PaneNode | undefined;
+export declare function findPaneByTab(state: SplitState, tabId: string): PaneNode | undefined;
+export declare function emptyPanes(state: SplitState): PaneNode[];
+export declare function tabIdsInSplit(state: SplitState): string[];
+/**
+ * The panes on screen: just the zoomed one, just the focused one when only
+ * one fits (mobile), else all of them.
+ */
+export declare function shownPanes(state: SplitState, onePaneOnly?: boolean): PaneNode[];
+export declare function canAddPane(state: SplitState): boolean;
+/**
+ * Collapses groups with one child, inlines a child group running the same
+ * way as its parent, and rescales sizes. Keeps the tree in the one shape the
+ * rest of the code expects after any edit.
+ */
+export declare function normalizeNode(node: LayoutNode): LayoutNode;
+/**
+ * Adds a pane next to `paneId`, holding `tabId` or empty. Null when the pane
+ * does not exist or the split is full.
+ */
+export declare function splitPane(state: SplitState, paneId: string, edge: PaneEdge, tabId?: string | null): {
+    state: SplitState;
+    paneId: string;
+} | null;
+/** Adds a pane along one outer edge of the whole split. */
+export declare function addPaneAtEdge(state: SplitState, edge: PaneEdge, tabId?: string | null): {
+    state: SplitState;
+    paneId: string;
+} | null;
+/** Removes a pane. Null when it was the last one, so the split should close. */
+export declare function removePane(state: SplitState, paneId: string): SplitState | null;
+/** Puts a tab in a pane (or empties it with null), moving it out of any other pane. */
+export declare function assignTab(state: SplitState, paneId: string, tabId: string | null): SplitState;
+/** Empties whichever pane holds the tab, leaving the pane in place. */
+export declare function clearTab(state: SplitState, tabId: string): SplitState;
+export declare function swapPanes(state: SplitState, firstId: string, secondId: string): SplitState;
+/**
+ * Drops one pane onto another: the center swaps their contents, an edge
+ * moves the dragged pane to that side of the target.
+ */
+export declare function movePane(state: SplitState, fromId: string, toId: string, target: DropTarget): SplitState;
+export declare function focusPane(state: SplitState, paneId: string): SplitState;
+export declare function toggleZoom(state: SplitState, paneId: string): SplitState;
+export declare function resizeSplit(state: SplitState, splitId: string, sizes: number[]): SplitState;
+export declare function equalizeSplit(state: SplitState, splitId: string): SplitState;
+/**
+ * Moves the divider between children `index` and `index + 1` by `delta`
+ * percent, keeping both above MIN_PANE_SIZE.
+ */
+export declare function moveDivider(sizes: number[], index: number, delta: number): number[];
+/**
+ * Repairs a state read from storage or left over after tabs closed: drops
+ * tab ids that no longer exist, keeps each tab in one pane, fixes focus.
+ */
+export declare function normalizeState(state: SplitState, isLiveTab?: (tabId: string) => boolean): SplitState;
+/** Rewrites every pane's tab id, e.g. live ids to saved instance ids and back. */
+export declare function mapTabIds(node: LayoutNode, fn: (tabId: string) => string | null): LayoutNode;
+/**
+ * The pane next to `paneId` in a direction, by on-screen position. Picks the
+ * closest pane that overlaps along the other axis, then the one with the
+ * most overlap, so it works for any tree shape.
+ */
+export declare function neighborPane(paneId: string, direction: NavDirection, rects: Record<string, PaneRect>): string | null;

package/dist/host/types/src/ui/shell/stage/TabStage.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The area tabs show in: the active tab, or the active split's panes, plus
+ * the drop zones for dragging a tab or pane into a split. A layout places it
+ * wherever its main area is. Tabs are never mounted here, only moved in, so
+ * moving or remounting the stage keeps every session alive.
+ */
+export declare function TabStage({ className }: {
+    className?: string;
+}): import("react").JSX.Element;

package/dist/host/types/src/ui/shell/stage/tab-stage-store.d.ts

@@ -0,0 +1,24 @@
+import type { Tab } from "../../../types/ui-types";
+/**
+ * Where tab content lives in the DOM.
+ *
+ * Every tab gets one stable node, created once and kept while the tab lives.
+ * React portals the tab into that node and never changes the portal target,
+ * since changing it remounts the tab (and drops a live terminal). The node is
+ * moved with plain DOM between the stage's normal view and pane elements, or
+ * left detached while no stage is mounted, e.g. while a layout is swapped.
+ */
+export interface TabStageStore {
+    getNode: (tabId: string, ownBackground: boolean) => HTMLDivElement;
+    /** Tab ids in the order their portals render: append only, never reordered. */
+    portalOrder: (tabs: Tab[]) => Tab[];
+    paneEls: Map<string, HTMLDivElement>;
+    setPaneEl: (paneId: string, el: HTMLDivElement | null) => void;
+    normalView: () => HTMLDivElement | null;
+    setNormalView: (el: HTMLDivElement | null) => void;
+    /** Moves every node where it belongs and sets its visibility. */
+    place: (tabs: Tab[], activeTabId: string, paneIdByTabId: Map<string, string>, ownBackground: (tab: Tab) => boolean) => void;
+    subscribe: (listener: () => void) => () => void;
+    version: () => number;
+}
+export declare function createTabStageStore(): TabStageStore;

package/dist/host/types/src/ui/shell/tab-close-guards.d.ts

@@ -0,0 +1,9 @@
+type Guard = () => boolean | Promise<boolean>;
+/**
+ * Lets a tab with no session handle, like Manage, ask before it closes.
+ * Returns the unregister function.
+ */
+export declare function registerTabCloseGuard(tabId: string, guard: Guard): () => void;
+/** Whether the tab may close: true when it has no guard or the guard agrees. */
+export declare function canCloseTab(tabId: string): Promise<boolean>;
+export {};

package/dist/host/types/src/ui/shell/tab-handles.d.ts

@@ -0,0 +1,8 @@
+import { type Ref, type RefObject } from "react";
+/**
+ * A callback ref that fills `ref` and tells the tab bar. The same function
+ * comes back for the same ref, so React never detaches and reattaches it.
+ */
+export declare function trackTabHandle(ref: RefObject<unknown> | undefined): Ref<unknown> | undefined;
+/** Changes whenever any tab's handle attaches or goes away. */
+export declare function useTabHandlesVersion(): number;

package/dist/host/types/src/ui/shell/tabUtils.d.ts

@@ -0,0 +1,15 @@
+import type { Tab, TabType } from "../../types/ui-types";
+import { type TabShellCallbacks } from "./tab-registry";
+/** Download a likely next tab without starting a connection or mounting UI. */
+export declare function preloadTabSurface(type: TabType): void;
+export declare function markTabSurfaceUsed(type: TabType): void;
+export declare function tabIcon(type: TabType): import("react").JSX.Element;
+export interface TabRenderContext {
+    shell: TabShellCallbacks;
+    /** The terminal a panel shown as a tab sends commands to. */
+    panelTargetTab?: Tab;
+    isVisible?: boolean;
+    isFocusedPane?: boolean;
+    inSplit?: boolean;
+}
+export declare function renderTabContent(tab: Tab, context: TabRenderContext): import("react").JSX.Element;

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

@@ -0,0 +1,5 @@
+/**
+ * Enrolment sections login methods and second factors register, such as
+ * adding a passkey or setting up an authenticator app.
+ */
+export declare function AuthEnrollmentSections(): import("react").JSX.Element;

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

@@ -0,0 +1,4 @@
+import type { SSHHostWithStatus } from "../main-axios";
+import type { Host, Credential } from "../../types/ui-types";
+export declare function sshHostToHost(h: SSHHostWithStatus): Host;
+export declare function mapCredentials(res: unknown): Credential[];

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

@@ -34,7 +34,7 @@ export interface HostEditorSectionDef {
     pluginId?: string;
     group: "top" | "ssh";
     labelKey: string;
-    /** Already-translated label, used instead of labelKey when set. */
+    /** Shown when labelKey has no translation. */
     label?: string;
     icon?: ComponentType<{
         className?: string;
@@ -59,7 +59,13 @@ 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 declare function makeHostTabs(t: (key: string, options?: {
+    defaultValue?: string;
+}) => string, protocols?: Record<string, boolean>, defaultsMode?: boolean): HostTab[];
+export declare function makeHostSshSubTabs(t: (key: string, options?: {
+    defaultValue?: string;
+}) => string, protocols?: Record<string, boolean>, defaultsMode?: boolean): HostTab[];
+export declare function makeCredentialTabs(t: (key: string, options?: {
+    defaultValue?: string;
+}) => string): CredentialTab[];
 export { TabStrip } from "../components/tab-strip";

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

@@ -0,0 +1,25 @@
+import type { SSHHostWithStatus } from "../main-axios";
+import type { HostFolder } from "../../types/ui-types";
+/**
+ * Builds the sidebar's host tree from the flat host list returned by the
+ * API, nesting via two independent mechanisms:
+ *
+ * - folder: a " / "-separated string path, split into synthetic HostFolder
+ *   nodes (folders are virtual -- they only exist as this derived tree).
+ * - parentHostId: sub-host nesting, where a real host acts as an
+ *   organizational parent for other real hosts. A host with children stays
+ *   a normal, connectable Host -- it is never wrapped in a synthetic node,
+ *   just given a childHosts array the tree/virtualizer walk into.
+ *
+ * The backend already enforces that folder and parentHostId are mutually
+ * exclusive on write and rejects cycles, but this still defends against
+ * stale/imported/synced data: a missing, inaccessible, or cyclic parent
+ * falls back to folder/root placement rather than being dropped or looping.
+ */
+export declare function buildHostTree(hosts: SSHHostWithStatus[], folderMeta?: Map<string, {
+    color?: string;
+    icon?: string;
+    credentialId?: number | null;
+    sortOrder?: number | null;
+    localOnly?: boolean;
+}>): HostFolder;

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

@@ -0,0 +1,30 @@
+export type FieldGroup = "connection" | "notes" | "tags" | "proxy" | "jumpHosts" | "featureFlags" | "advanced";
+export interface ExportPayload {
+    version?: string;
+    exportedAt?: string;
+    credentials?: Record<string, unknown>[];
+    hosts: Record<string, unknown>[];
+}
+export declare const SECRET_KEYS: string[];
+/**
+ * Keys inside a plugin's JSON host settings that hold secrets, per plugin and
+ * field, from each manifest's `secretKeys`.
+ */
+export type PluginSecretKeys = Record<string, Record<string, string[]>>;
+/** Reads the secret keys the plugins declare in their host settings. */
+export declare function pluginSecretKeys(summaries: Array<{
+    id: string;
+    contributes?: {
+        settings?: {
+            host?: {
+                fields?: Array<{
+                    key: string;
+                    secretKeys?: string[];
+                }>;
+            };
+        };
+    } | null;
+}>): PluginSecretKeys;
+export declare function hostKey(host: Record<string, unknown>): string;
+export declare function buildExportPayload(raw: ExportPayload, selected: Set<string> | null, groups: Set<FieldGroup>, withCredentials: boolean, pluginSecrets?: PluginSecretKeys): ExportPayload;
+export declare function maskSecrets(payload: ExportPayload, pluginSecrets?: PluginSecretKeys): ExportPayload;