@termix-ssh/plugin-sdk 1.0.11 → 1.0.13

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

@@ -0,0 +1,28 @@
+import { type LayoutNode, type SplitState } from "./split-tree";
+/** Starting layouts offered in the layout picker. Any pane can be split further. */
+export type SplitPresetId = "columns-2" | "rows-2" | "columns-3" | "main-left-3" | "main-bottom-3" | "grid-4" | "grid-5" | "grid-6";
+export interface SplitPreset {
+    id: SplitPresetId;
+    titleKey: string;
+    panes: number;
+}
+export declare const SPLIT_PRESETS: SplitPreset[];
+type Sizes = {
+    outer?: number[];
+    inner?: number[][];
+};
+/**
+ * Builds a preset's tree, filling panes in reading order from `tabIds`.
+ * `sizes` lets the legacy mapping keep the user's divider positions.
+ */
+export declare function buildPreset(id: SplitPresetId, tabIds?: (string | null)[], sizes?: Sizes): LayoutNode;
+/**
+ * Re-lays an existing split out as a preset, keeping its tabs in reading
+ * order. Tabs past the preset's pane count drop out of the split.
+ */
+export declare function applyPreset(state: SplitState, id: SplitPresetId): SplitState;
+/** Split modes from before the layout tree, still found in storage and old workspaces. */
+export type LegacySplitMode = "2-way" | "2-way-horizontal" | "3-way" | "3-way-horizontal" | "4-way" | "5-way" | "6-way";
+/** Maps an old fixed-mode split onto the tree, keeping sizes where they fit. */
+export declare function fromLegacyConfig(mode: string, paneTabIds: (string | null)[], rowSizes?: unknown, rowColSizes?: unknown): LayoutNode | null;
+export {};

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

@@ -0,0 +1,95 @@
+import type { LayoutNode, SplitState, Tab } from "../../../types/ui-types";
+import { type SplitPresetId } from "./split-presets";
+/**
+ * Split tabs as they live in the shell's tab list. A split tab owns its
+ * layout tree; every tab shown in one of its panes carries parentSplitTabId
+ * so the tab bar hides it. These keep the two in step.
+ */
+export declare const SPLIT_TAB_TYPE = "split-screen";
+export type SplitTab = Tab & {
+    split: SplitState;
+};
+export declare function isSplitTab(tab: Tab | undefined | null): tab is SplitTab;
+/** Tabs a pane may hold: anything but the dashboard and other splits. */
+export declare function canJoinSplit(tab: Tab | undefined | null): boolean;
+export declare function splitTabOf(tabs: Tab[], tabId: string): SplitTab | undefined;
+/**
+ * Makes parentSplitTabId match the trees. Pane tab ids that no longer exist
+ * are emptied, and a tab claimed by two splits stays with the first.
+ */
+export declare function syncSplitChildren(tabs: Tab[]): Tab[];
+/**
+ * Applies `fn` to one split's state. Returning null closes the split and
+ * sends its tabs back to the tab bar.
+ */
+export declare function updateSplit(tabs: Tab[], splitTabId: string, fn: (state: SplitState) => SplitState | null): Tab[];
+export declare function makeSplitTab(instanceId: string, label: string, split: SplitState, openedAt?: number): SplitTab;
+/** Adds a split tab, taking its tabs out of any other split. */
+export declare function addSplitTab(tabs: Tab[], splitTab: SplitTab): Tab[];
+/** Removes a split tab. Its tabs go back to the tab bar. */
+export declare function closeSplitTab(tabs: Tab[], splitTabId: string): Tab[];
+/**
+ * Removes a closed tab. A pane that held it stays, empty and focused, so the
+ * next thing the user opens can go straight into it.
+ */
+export declare function removeTab(tabs: Tab[], tabId: string): Tab[];
+/** Puts a tab in a pane of a split and focuses that pane. */
+export declare function placeTabInPane(tabs: Tab[], splitTabId: string, paneId: string, tabId: string): Tab[];
+/** What the tab bar asks the shell to do with splits. */
+export type TabSplitAction = {
+    kind: "split";
+    tabId: string;
+    edge: "right" | "bottom";
+} | {
+    kind: "addToPane";
+    tabId: string;
+    splitTabId: string;
+    paneId: string;
+} | {
+    kind: "addPane";
+    tabId: string;
+    splitTabId: string;
+    edge: "right" | "bottom";
+} | {
+    kind: "unsplit";
+    splitTabId: string;
+} | {
+    kind: "splitActive";
+    edge: "right" | "bottom";
+} | {
+    kind: "preset";
+    presetId: SplitPresetId;
+};
+/** The lowest N not already used by a "Split N" style label. */
+export declare function nextSplitNumber(tabs: Tab[], labelFor: (n: number) => string): number;
+export interface SplitPaneSummary {
+    id: string;
+    /** 1-based, in reading order. */
+    index: number;
+    tabId: string | null;
+    /** The tab's label, or null for an empty pane. */
+    label: string | null;
+}
+export interface SplitSummary {
+    id: string;
+    label: string;
+    panes: SplitPaneSummary[];
+    full: boolean;
+}
+export declare function summarizeSplits(tabs: Tab[], maxPanes: number): SplitSummary[];
+/** Saved in localStorage; pane tab ids are tab instanceIds, which survive a reload. */
+export type PersistedSplitTab = {
+    version: 2;
+    instanceId: string;
+    label: string;
+    root: LayoutNode;
+    focusedPaneId: string;
+};
+export declare function serializeSplitTabs(tabs: Tab[]): PersistedSplitTab[];
+/**
+ * Rebuilds a saved split's tree with live tab ids. `resolve` maps whatever
+ * the save used (instanceIds, workspace slotIds) to a live tab id. Null when
+ * the entry is unreadable or none of its tabs came back.
+ */
+export declare function restoreSplitState(entry: unknown, resolve: (savedId: string) => string | null): SplitState | null;
+export declare function restoreSplitTabs(persisted: unknown[], tabs: Tab[], openedAt?: number): Tab[];

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

@@ -0,0 +1,30 @@
+import type { SplitSummary } from "./split-tabs";
+/**
+ * Lets menus outside the shell (the host list) offer "Open in split" without
+ * threading split state through every sidebar component. The shell publishes
+ * its splits here and registers how to aim the next opened tab at a pane.
+ */
+export type SplitOpenTarget = {
+    kind: "pane";
+    splitTabId: string;
+    paneId: string;
+} | {
+    kind: "newPane";
+    splitTabId: string;
+}
+/** A new split holding the active tab and the opened one. */
+ | {
+    kind: "newSplit";
+};
+export interface SplitTargetsSnapshot {
+    splits: SplitSummary[];
+    /** The active tab can start a new split. */
+    canStartSplit: boolean;
+}
+type Opener = (target: SplitOpenTarget, open: () => void) => void;
+export declare function publishSplitTargets(next: SplitTargetsSnapshot): void;
+export declare function setSplitOpener(next: Opener): () => void;
+/** Runs `open` so whatever tab it opens lands in `target`. */
+export declare function openInSplit(target: SplitOpenTarget, open: () => void): void;
+export declare function useSplitTargets(): SplitTargetsSnapshot;
+export {};

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/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-contributions.d.ts

@@ -45,6 +45,10 @@ export interface HostBadgeDef {
     }>;
     order?: number;
 }
+/** The dot or stripe on a host row that shows its status. */
+export type HostStatusIndicatorDef = HostBadgeDef;
+/** A button in the host editor's toolbar. */
+export type HostEditorToolbarItemDef = HostBadgeDef;
 export interface HostContextMenuItemDef {
     id: string;
     pluginId?: string;
@@ -61,12 +65,18 @@ export declare function actionOrder(action: HostActionDef): number;
 export declare const listHostActions: () => HostActionDef[];
 export declare const registerHostBadge: (item: HostBadgeDef) => () => void;
 export declare const useHostBadges: () => HostBadgeDef[];
+export declare const registerHostStatusIndicator: (item: HostBadgeDef) => () => void;
+export declare const useHostStatusIndicators: () => HostBadgeDef[];
+export declare const registerHostEditorToolbarItem: (item: HostBadgeDef) => () => void;
+export declare const useHostEditorToolbarItems: () => 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 hostStatusIndicatorsFor(all: HostStatusIndicatorDef[], host: Host): HostStatusIndicatorDef[];
+export declare function hostEditorToolbarItemsFor(all: HostEditorToolbarItemDef[], host: Host): HostEditorToolbarItemDef[];
 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;