@termix-ssh/plugin-sdk 1.0.0

package/dist/host/chunk-YC2MAKSP.js

@@ -0,0 +1,14 @@
+const __termixNoGlob = () => ({});
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// <define:import.meta.env>
+var define_import_meta_env_default = { DEV: false, PROD: true, MODE: "production", SSR: false, BASE_URL: "/" };
+
+export {
+  __export,
+  define_import_meta_env_default
+};

package/dist/host/linked-server-FZGWQW32.js

@@ -0,0 +1,12 @@
+const __termixNoGlob = () => ({});
+import {
+  SYNC_CHANGED_EVENT,
+  getLinkedSession,
+  notifySyncChanged
+} from "./chunk-F3SDZDDG.js";
+import "./chunk-YC2MAKSP.js";
+export {
+  SYNC_CHANGED_EVENT,
+  getLinkedSession,
+  notifySyncChanged
+};

package/dist/host/rbac-api-6KDMBVDZ.js

@@ -0,0 +1,52 @@
+const __termixNoGlob = () => ({});
+import {
+  assignRoleToUser,
+  createRole,
+  deleteRole,
+  getCredentialAccess,
+  getFolderAccess,
+  getHostAccess,
+  getHostAuthOverride,
+  getMyPermissions,
+  getPermissionsCatalog,
+  getRoleMembers,
+  getRoles,
+  getSharedHosts,
+  getUserRoles,
+  removeRoleFromUser,
+  revokeCredentialAccess,
+  revokeFolderAccess,
+  revokeHostAccess,
+  setHostAuthOverride,
+  shareCredential,
+  shareFolder,
+  shareHost,
+  updateHostAccess,
+  updateRole
+} from "./chunk-F3SDZDDG.js";
+import "./chunk-YC2MAKSP.js";
+export {
+  assignRoleToUser,
+  createRole,
+  deleteRole,
+  getCredentialAccess,
+  getFolderAccess,
+  getHostAccess,
+  getHostAuthOverride,
+  getMyPermissions,
+  getPermissionsCatalog,
+  getRoleMembers,
+  getRoles,
+  getSharedHosts,
+  getUserRoles,
+  removeRoleFromUser,
+  revokeCredentialAccess,
+  revokeFolderAccess,
+  revokeHostAccess,
+  setHostAuthOverride,
+  shareCredential,
+  shareFolder,
+  shareHost,
+  updateHostAccess,
+  updateRole
+};

package/dist/host/testing-host.js

@@ -0,0 +1,414 @@
+const __termixNoGlob = () => ({});
+import {
+  ActionSlot,
+  ComponentSlot,
+  PluginViewPlaceholder,
+  SurfaceScope,
+  ThemeProvider,
+  createPluginApp,
+  getExtension,
+  getHostEditorSection,
+  getLoginMethodUI,
+  getPanel,
+  getRegisteredDashboardCard,
+  getSecondFactorUI,
+  getSettingsComponent,
+  getSlotContributions,
+  hostActionsFor,
+  hostEditorSectionList,
+  i18n_default,
+  installPluginHostBridge,
+  listActions,
+  listExtensions,
+  listHostActions,
+  listHostProtocols,
+  listKeybindingActions,
+  listKeybindingDefaults,
+  listLoginMethodUIs,
+  listPaletteGroups,
+  listPanels,
+  listRegisteredRailItems,
+  listSecondFactorUIs,
+  listSettingsComponents,
+  loadPaletteGroup,
+  notifyShellReady,
+  registeredDashboardCardList,
+  resetShellBridge,
+  setPluginApiForTesting,
+  setRemoteServerUrlForTesting,
+  setShellCallbacks,
+  setShellHosts,
+  setShellLayoutProvider
+} from "./chunk-XH5NXL6Y.js";
+import {
+  setPermissionsForTesting
+} from "./chunk-XGWE7BTJ.js";
+import {
+  getTabType,
+  listTabTypes,
+  setFrontendState,
+  setPluginSummaries
+} from "./chunk-F3SDZDDG.js";
+import "./chunk-YC2MAKSP.js";
+
+// src/ui/plugin-host/testing-host.tsx
+import { render } from "@testing-library/react";
+
+// src/ui/shell/shell-layout.ts
+var CORE_UNSAVED = /* @__PURE__ */ new Set([
+  "dashboard",
+  "host-manager",
+  "settings",
+  "user-profile",
+  "admin-settings",
+  "split-screen"
+]);
+function isUnregisteredPluginTabType(type) {
+  return !CORE_UNSAVED.has(type) && !getTabType(type);
+}
+function opensAsSingleton(type, hasHost) {
+  const def = getTabType(type);
+  return !!def && (!!def.singleton || !!def.hostless && !hasHost);
+}
+function resolveLayoutTabTarget(snapshot, allHosts) {
+  let host;
+  if (snapshot.hostSyncId) {
+    host = allHosts.find((h) => h.syncId === snapshot.hostSyncId);
+    if (!host) return { kind: "skip" };
+  }
+  if (opensAsSingleton(snapshot.type, !!host)) {
+    return { kind: "singleton", host };
+  }
+  if (!host && isUnregisteredPluginTabType(snapshot.type)) {
+    return { kind: "singleton" };
+  }
+  return host ? { kind: "host", host } : { kind: "skip" };
+}
+
+// src/ui/plugin-host/testing-host.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function recordingShell(calls) {
+  const record = (method) => (...args) => {
+    calls.push({ method, args });
+  };
+  return {
+    openTab: record("openTab"),
+    openSingletonTab: record("openSingletonTab"),
+    connectHost: record("connectHost"),
+    closeTab: record("closeTab"),
+    renameTab: record("renameTab"),
+    openRailView: record("openRailView"),
+    closeRailView: record("closeRailView"),
+    openHostEditor: record("openHostEditor"),
+    saveQuickConnect: async (...args) => {
+      calls.push({ method: "saveQuickConnect", args });
+    }
+  };
+}
+function wrap(element) {
+  return render(
+    /* @__PURE__ */ jsx(ThemeProvider, { defaultTheme: "dark", storageKey: "termix-test-theme", children: /* @__PURE__ */ jsx(SurfaceScope, { className: "h-full", children: element }) })
+  ).container;
+}
+function missing(kind, id) {
+  throw new Error(`renderWithApp: nothing registered ${kind} "${id}"`);
+}
+async function renderPlugin(plugin, options = {}) {
+  const pluginId = options.pluginId ?? options.manifest?.id ?? "test-plugin";
+  const manifest = {
+    id: pluginId,
+    name: pluginId,
+    version: "1.0.0",
+    description: "",
+    author: { name: "test" },
+    license: "MIT",
+    category: "Productivity",
+    engine: { termix: ">=2.9.0", api: "1" },
+    capabilities: [],
+    ...options.manifest
+  };
+  installPluginHostBridge();
+  resetShellBridge();
+  setPermissionsForTesting(options.permissions ?? [], options.isAdmin);
+  const hosts = options.hosts ?? [];
+  setShellHosts(hosts);
+  const shellCalls = [];
+  const shell = recordingShell(shellCalls);
+  setShellCallbacks(shell);
+  let layout = options.layout ?? null;
+  const opened = [];
+  setShellLayoutProvider({
+    getLayout: () => layout,
+    applyLayout: async (next, applyOptions) => {
+      shellCalls.push({ method: "applyLayout", args: [next, applyOptions] });
+      layout = next;
+      opened.length = 0;
+      const skipped = [];
+      const tabs = next.tabs ?? [];
+      for (const snapshot of tabs) {
+        const target = resolveLayoutTabTarget(snapshot, hosts);
+        if (target.kind === "skip") {
+          skipped.push(snapshot.hostNameSnapshot || snapshot.label);
+          continue;
+        }
+        opened.push({
+          type: snapshot.type,
+          hostId: "host" in target && target.host ? Number(target.host.id) : void 0,
+          label: snapshot.customLabel ?? snapshot.label
+        });
+      }
+      return { skipped };
+    }
+  });
+  const summary = {
+    id: pluginId,
+    name: manifest.name,
+    version: manifest.version,
+    enabled: true,
+    state: "active",
+    contributes: manifest.contributes ?? null,
+    frontend: true
+  };
+  setPluginSummaries([summary]);
+  if (options.locales) {
+    i18n_default.addResourceBundle(
+      "en",
+      pluginId,
+      options.locales,
+      true,
+      true
+    );
+  }
+  setPluginApiForTesting(
+    pluginId,
+    options.api ?? null
+  );
+  setRemoteServerUrlForTesting(options.remoteServerUrl ?? null);
+  const handle = createPluginApp(pluginId, manifest, summary.contributes, {
+    guest: options.guest
+  });
+  await plugin.activate(handle.app);
+  setFrontendState(pluginId, "active");
+  if (options.ready) notifyShellReady();
+  const mine = (items) => items.filter((item) => item.pluginId === pluginId);
+  const tabRecord = (type, host) => ({
+    id: `${type}-test`,
+    instanceId: `${type}-test`,
+    type,
+    label: type,
+    host,
+    openedAt: 0
+  });
+  return {
+    app: handle.app,
+    shellCalls,
+    registered: {
+      railItems: () => mine(listRegisteredRailItems()).map((item) => ({
+        id: item.id,
+        hidden: item.hidden,
+        permission: item.permission
+      })),
+      tabs: () => mine(listTabTypes()).map((def) => def.id),
+      panels: () => mine(listPanels()).map((panel) => panel.id),
+      hostActions: () => mine(listHostActions()).map((action) => ({
+        id: action.id,
+        tabType: action.tabType
+      })),
+      hostActionsFor: (host) => mine(
+        hostActionsFor(listHostActions(), host)
+      ),
+      hostProtocols: () => mine(listHostProtocols()).map((protocol) => protocol.id),
+      hostEditorSections: () => mine(hostEditorSectionList()).map((section) => section.id),
+      dashboardCards: () => mine(registeredDashboardCardList()).map((card) => card.id),
+      extensions: (pointId) => mine(listExtensions(pointId)).map((extension) => extension.id),
+      settingsComponents: () => listSettingsComponents().filter((key) => key.startsWith(`${pluginId}:`)).map((key) => key.slice(pluginId.length + 1)),
+      slot: (slotId) => mine(getSlotContributions(slotId)).map(
+        (contribution) => contribution.actionId
+      ),
+      actions: () => mine(listActions()).map((action) => action.id),
+      loginMethods: () => mine(listLoginMethodUIs()).map((method) => method.id),
+      secondFactors: () => mine(listSecondFactorUIs()).map((factor) => factor.id),
+      paletteGroups: () => mine(listPaletteGroups()).map((group) => group.id),
+      keybindingActions: () => mine(listKeybindingActions()).map((action) => action.id),
+      keybindingDefaults: () => mine(listKeybindingDefaults()).map((binding) => binding.id)
+    },
+    async loadPaletteGroup(id) {
+      const group = listPaletteGroups().find((entry) => entry.id === id) ?? missing("a palette group", id);
+      return await loadPaletteGroup(group);
+    },
+    renderTab(type, props = {}) {
+      const def = getTabType(type) ?? missing("a tab", type);
+      const Component = def.component;
+      const host = props.host;
+      return wrap(
+        /* @__PURE__ */ jsx(
+          Component,
+          {
+            tab: tabRecord(type, host),
+            host,
+            label: type,
+            isVisible: true,
+            isFocusedPane: true,
+            inSplit: false,
+            handleRef: null,
+            shell,
+            ...props
+          }
+        )
+      );
+    },
+    openedTabs: () => opened.map((tab) => ({ ...tab })),
+    renderOpenedTab(index) {
+      const tab = opened[index] ?? missing("an opened tab at index", index);
+      const def = getTabType(tab.type);
+      if (!def) {
+        return wrap(/* @__PURE__ */ jsx(PluginViewPlaceholder, { kind: "tab", viewId: tab.type }));
+      }
+      const Component = def.component;
+      return wrap(
+        /* @__PURE__ */ jsx(
+          Component,
+          {
+            tab: tabRecord(tab.type),
+            label: tab.label,
+            isVisible: true,
+            isFocusedPane: true,
+            inSplit: false,
+            handleRef: null,
+            shell
+          }
+        )
+      );
+    },
+    renderPanel(id, props = {}) {
+      const panel = getPanel(id) ?? missing("a panel", id);
+      const Component = panel.component;
+      return wrap(
+        /* @__PURE__ */ jsx(
+          Component,
+          {
+            active: true,
+            shell,
+            setEditing: () => {
+            },
+            placement: "left",
+            ...props
+          }
+        )
+      );
+    },
+    renderExtension(pointId, id, component = "view", props = {}) {
+      const extension = getExtension(pointId, id);
+      const Component = extension?.pluginId === pluginId ? extension.components?.[component] : void 0;
+      if (!Component) missing(`an extension "${component}" component`, id);
+      return wrap(/* @__PURE__ */ jsx(Component, { ...props }));
+    },
+    renderDashboardCard(id) {
+      const card = getRegisteredDashboardCard(id) ?? missing("a card", id);
+      const Component = card.component;
+      return wrap(/* @__PURE__ */ jsx(Component, { isVisible: true, shell }));
+    },
+    renderHostEditorSection(id, props = {}) {
+      const section = getHostEditorSection(id) ?? missing("a host editor section", id);
+      const Component = section.component;
+      return wrap(
+        /* @__PURE__ */ jsx(
+          Component,
+          {
+            form: {},
+            setField: () => {
+            },
+            updateForm: () => {
+            },
+            protocols: {},
+            ...props
+          }
+        )
+      );
+    },
+    renderSettingsComponent(componentId, props = {}) {
+      const Component = getSettingsComponent(pluginId, componentId) ?? missing("a settings component", componentId);
+      return wrap(
+        /* @__PURE__ */ jsx(
+          Component,
+          {
+            pluginId,
+            values: {},
+            setValue: () => {
+            },
+            running: true,
+            ...props
+          }
+        )
+      );
+    },
+    renderLoginMethod(id, props = {}) {
+      const method = getLoginMethodUI(id) ?? missing("a login method", id);
+      const Component = method.component;
+      return wrap(
+        /* @__PURE__ */ jsx(
+          Component,
+          {
+            methodId: id,
+            instances: [],
+            rememberMe: false,
+            disabled: false,
+            submit: async () => {
+            },
+            startRedirect: async () => {
+            },
+            complete: async () => {
+            },
+            ...props
+          }
+        )
+      );
+    },
+    renderSecondFactor(id, props = {}) {
+      const factor = getSecondFactorUI(id) ?? missing("a second factor", id);
+      const Component = factor.component;
+      return wrap(
+        /* @__PURE__ */ jsx(
+          Component,
+          {
+            factorId: id,
+            rememberMe: false,
+            disabled: false,
+            verify: async () => {
+            },
+            challenge: async () => null,
+            cancel: () => {
+            },
+            ...props
+          }
+        )
+      );
+    },
+    renderEnrollment(id) {
+      const entry = getSecondFactorUI(id) ?? getLoginMethodUI(id);
+      const Component = entry?.enrollment ?? missing("an enrolment section", id);
+      return wrap(/* @__PURE__ */ jsx(Component, {}));
+    },
+    renderSlot(slotId, props = {}) {
+      return wrap(
+        /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(ActionSlot, { slotId }),
+          /* @__PURE__ */ jsx(ComponentSlot, { slotId, props })
+        ] })
+      );
+    },
+    async deactivate() {
+      try {
+        await plugin.deactivate?.();
+      } finally {
+        handle.dispose();
+        setFrontendState(pluginId, "inactive");
+        setPluginApiForTesting(pluginId, null);
+        setRemoteServerUrlForTesting(null);
+      }
+    }
+  };
+}
+export {
+  renderPlugin
+};

package/dist/host/theme.css

@@ -0,0 +1,91 @@
+/*
+ * The design tokens plugins build against: custom variants, the Tailwind
+ * theme and shared utilities. Core imports it, and the SDK ships a copy that
+ * `termix-plugin build` compiles a plugin's own classes against, so a plugin
+ * class means the same thing wherever it is compiled. Values only; anything
+ * that renders on its own belongs in index.css.
+ */
+
+@custom-variant dark (&:is(.dark *));
+@custom-variant dracula (&:is(.dracula *));
+@custom-variant catppuccin (&:is(.catppuccin *));
+@custom-variant nord (&:is(.nord *));
+@custom-variant solarized (&:is(.solarized *));
+@custom-variant tokyo-night (&:is(.tokyo-night *));
+@custom-variant one-dark (&:is(.one-dark *));
+@custom-variant gruvbox (&:is(.gruvbox *));
+
+@theme inline {
+  --font-heading: var(--font-mono);
+  --font-mono: var(--font-ui, "JetBrains Mono Variable", monospace);
+  --color-accent-brand: var(--accent-brand);
+  --color-sidebar-ring: var(--sidebar-ring);
+  --color-sidebar-border: var(--sidebar-border);
+  --color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
+  --color-sidebar-accent: var(--sidebar-accent);
+  --color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
+  --color-sidebar-primary: var(--sidebar-primary);
+  --color-sidebar-foreground: var(--sidebar-foreground);
+  --color-sidebar: var(--sidebar);
+  --color-chart-5: var(--chart-5);
+  --color-chart-4: var(--chart-4);
+  --color-chart-3: var(--chart-3);
+  --color-chart-2: var(--chart-2);
+  --color-chart-1: var(--chart-1);
+  --color-ring: var(--ring);
+  --color-input: var(--input);
+  --color-border: var(--border);
+  --color-destructive: var(--destructive);
+  --color-accent-foreground: var(--accent-foreground);
+  --color-accent: var(--accent);
+  --color-muted-foreground: var(--muted-foreground);
+  --color-muted: var(--muted);
+  --color-secondary-foreground: var(--secondary-foreground);
+  --color-secondary: var(--secondary);
+  --color-primary-foreground: var(--primary-foreground);
+  --color-primary: var(--primary);
+  --color-popover-foreground: var(--popover-foreground);
+  --color-popover: var(--popover);
+  --color-card-foreground: var(--card-foreground);
+  --color-card: var(--card);
+  --color-foreground: var(--foreground);
+  --color-background: var(--background);
+  --color-surface: var(--surface);
+  --color-surface-dim: var(--surface-dim);
+  --color-warning: var(--warning);
+  --color-terminal-bg: var(--terminal-bg);
+  --color-bg-base: var(--bg-base);
+  --color-border-base: var(--border-base);
+  --color-foreground-secondary: var(--foreground-secondary);
+  --color-canvas: var(--canvas);
+  --color-overlay: var(--overlay);
+  --radius-sm: calc(var(--radius) * 0.6);
+  --radius-md: calc(var(--radius) * 0.8);
+  --radius-lg: var(--radius);
+  --radius-xl: calc(var(--radius) * 1.4);
+  --radius-2xl: calc(var(--radius) * 1.8);
+  --radius-3xl: calc(var(--radius) * 2.2);
+  --radius-4xl: calc(var(--radius) * 2.6);
+}
+
+@utility scrollbar-none {
+  scrollbar-width: none;
+  &::-webkit-scrollbar {
+    display: none;
+  }
+}
+
+@utility thin-scrollbar {
+  scrollbar-width: thin;
+  scrollbar-color: oklch(1 0 0 / 15%) transparent;
+  &::-webkit-scrollbar {
+    width: 4px;
+  }
+  &::-webkit-scrollbar-track {
+    background: transparent;
+  }
+  &::-webkit-scrollbar-thumb {
+    background: oklch(1 0 0 / 15%);
+    border-radius: 2px;
+  }
+}

package/dist/host/types/src/types/auth-protocols.d.ts

@@ -0,0 +1,10 @@
+/** Core's own protocol. Every other one is declared by a plugin. */
+export declare const SSH_AUTH_PROTOCOL = "ssh";
+/** "ssh", or a protocol id a plugin declares in contributes.protocols. */
+export type AuthOverrideProtocol = string;
+export interface HostAuthOverrideState<CredentialId extends number | string = number> {
+    credentialId?: CredentialId;
+    required: boolean;
+    ownerAuthShared: boolean;
+}
+export type HostAuthOverrides<CredentialId extends number | string = number> = Partial<Record<AuthOverrideProtocol, HostAuthOverrideState<CredentialId>>>;

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

@@ -0,0 +1,13 @@
+/**
+ * Where a connection is. Core's SSH pipeline uses the named stages; a plugin
+ * may log its own (such as "guac_ready") and they pass through unchanged.
+ */
+export type ConnectionStage = "dns" | "tcp" | "handshake" | "auth" | "connected" | "connection" | "error" | "proxy" | "jump" | "validation" | (string & {});
+export type LogEntry = {
+    id: string;
+    timestamp: Date;
+    type: "info" | "success" | "warning" | "error";
+    stage: ConnectionStage;
+    message: string;
+    details?: Record<string, unknown> | string;
+};

package/dist/host/types/src/types/credential-sidebar-preferences.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Credential sidebar preferences model. Shared by the frontend sidebar and
+ * the backend preferences endpoint (no framework imports, mirrors
+ * ./host-sidebar-preferences.ts's dependency-free convention). Independent
+ * from HostSidebarPreferences by design — a separate parallel system, not a
+ * shared blob, matching how credentialSortKey/credentialFilterState were
+ * already independently namespaced from hostSortKey/etc. before this port.
+ *
+ * Deliberately smaller than HostSidebarPreferences: no groupKey selector
+ * (folder is the only grouping credentials have, so there's nothing to
+ * pick), no statusColorScheme (credentials have no online/offline concept).
+ */
+export declare const CREDENTIAL_SIDEBAR_PREFS_VERSION = 1;
+export type CredentialSortKey = "default" | "name-asc" | "name-desc" | "username-asc" | "username-desc" | "manual";
+export type CredentialDensity = "comfortable" | "compact";
+export type CredentialTrayTrigger = "always" | "hover" | "click" | "actionsOnly";
+export interface CredentialSidebarFilterState {
+    /** Credential type ids; plugins can add their own. */
+    type: string[];
+    tags: string[];
+}
+export interface CredentialSidebarDisplayPreferences {
+    density: CredentialDensity;
+    showTags: boolean;
+    trayTrigger: CredentialTrayTrigger;
+}
+export interface CredentialSidebarPreferences {
+    version: number;
+    sort: {
+        key: CredentialSortKey;
+        pinnedFirst: boolean;
+    };
+    filters: CredentialSidebarFilterState;
+    openFolders: string[];
+    display: CredentialSidebarDisplayPreferences;
+}
+export declare function defaultCredentialSidebarPreferences(): CredentialSidebarPreferences;
+export declare function sanitizeCredentialSidebarPreferences(input: unknown): CredentialSidebarPreferences;