v26.10.3 (#1692)

* feat: shell controller, TabStage, layout and theme plugins with repair view

* feat: move the classic layout into its own bundled plugin

* feat: move color themes into a bundled themes plugin

* fix: plugin tests and type checks work with a linked sdk

* fix: home tab, layout switch and missing layout fallbacks for looks

* chore: add classic layout and themes to the readme

* chore: drop example plugin links from the plugin guide

* feat: plugin filters by type, paged browse, hide plugins needing newer termix

* feat: move desktop, status, import, audit and branding features into plugins

* feat: host lock api so a plugin can load hosts from a config file (#1581)

* chore: add hosts config to the plugin table

* feat: login policy hook for plugins and optional https redirect (#1584)

* chore: add login security to the plugin table

* feat: api key socket tickets so a master can open remote sessions (#1654)

* feat: sync moves to a plugin, desktop gets multiple accounts (#1580, #1654)

* chore: add sync to the plugin table

* feat: move the sync screens and wizard out of core into the plugin (#1580)

* fix: add a neutral linked desktop hook for plugins (#1580)

* fix: show the linked account's name and admin flag in the app (#1580)

* feat: ssh transport providers, core ssh relay and plugin folders api

* feat: support FIDO2 security keys through ssh agent

* feat: add companion panels beside host tabs

* feat: mTLS client certificates for desktop server links

* feat: native web view for plugins in the desktop app

* fix: detect the desktop link window by Electron's default user agent

Fixes #1675

* fix: changelog for desktop link fix

* fix: keep text primary keys in the plugin data export

* fix: ship sharp binaries for Windows arm64 builds

* feat: client cert on the sync link types (sdk 1.0.18)

* chore: update translations

* feat: themed title bar for the desktop app (#1690)

* chore: changelog for the themed title bar

* fix: draw the title bar in the sidebar color

* feat: per host layout for the terminal panel bar

* chore: sdk 1.0.19 for the panel bar layout

* chore: bundle all 43 plugins for 26.10.3

* chore: update translations

---------

Co-authored-by: SirHephaistos <60616553+SirHephaistos@users.noreply.github.com>
Co-authored-by: Giovanny Aranda <garanda21@gmail.com>

src/backend/tests/electron/embedded-view.test.ts

@@ -0,0 +1,164 @@
+import { createRequire } from "node:module";
+import { EventEmitter } from "node:events";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const { createEmbeddedViews, cleanBounds } = createRequire(import.meta.url)(
+  "../../../../electron/embedded-view.cjs",
+);
+
+const views: FakeView[] = [];
+
+class FakeView {
+  webContents = Object.assign(new EventEmitter(), {
+    setWindowOpenHandler: vi.fn(),
+    loadURL: vi.fn().mockResolvedValue(undefined),
+    isDestroyed: () => false,
+    close: vi.fn(),
+  });
+  setBounds = vi.fn();
+  setVisible = vi.fn();
+  constructor(public options: { webPreferences: Record<string, unknown> }) {
+    views.push(this);
+  }
+}
+
+const bounds = { x: 10.4, y: 20.6, width: 300, height: 200 };
+let contentView: {
+  addChildView: ReturnType<typeof vi.fn>;
+  removeChildView: ReturnType<typeof vi.fn>;
+};
+let session: EventEmitter & Record<string, ReturnType<typeof vi.fn>>;
+let manager: ReturnType<typeof createEmbeddedViews>;
+
+beforeEach(() => {
+  views.length = 0;
+  contentView = { addChildView: vi.fn(), removeChildView: vi.fn() };
+  session = Object.assign(new EventEmitter(), {
+    setPermissionRequestHandler: vi.fn(),
+    setPermissionCheckHandler: vi.fn(),
+    clearStorageData: vi.fn().mockResolvedValue(undefined),
+    clearCache: vi.fn().mockResolvedValue(undefined),
+    closeAllConnections: vi.fn().mockResolvedValue(undefined),
+    webRequest: { onBeforeRequest: vi.fn() },
+  });
+  manager = createEmbeddedViews({
+    WebContentsView: FakeView,
+    session: { fromPartition: vi.fn(() => session) },
+    getMainWindow: () => ({ contentView, isDestroyed: () => false }),
+  });
+});
+
+describe("embedded views", () => {
+  it("opens a locked down view at the given bounds", () => {
+    manager.open({ id: "a", url: "https://pve.example:8006/", bounds });
+    const [view] = views;
+    expect(view.options.webPreferences).toMatchObject({
+      sandbox: true,
+      contextIsolation: true,
+      nodeIntegration: false,
+      webviewTag: false,
+    });
+    expect(contentView.addChildView).toHaveBeenCalledWith(view);
+    expect(view.setBounds).toHaveBeenCalledWith({
+      x: 10,
+      y: 21,
+      width: 300,
+      height: 200,
+    });
+    expect(view.webContents.loadURL).toHaveBeenCalledWith(
+      "https://pve.example:8006/",
+    );
+    const handler = session.setPermissionRequestHandler.mock.calls[0][0];
+    const allow = vi.fn();
+    handler(null, "media", allow);
+    expect(allow).toHaveBeenCalledWith(false);
+  });
+
+  it("refuses urls that are not plain http or https", () => {
+    expect(() =>
+      manager.open({ id: "a", url: "file:///etc/passwd", bounds }),
+    ).toThrow();
+    expect(() =>
+      manager.open({ id: "a", url: "https://u:p@host/", bounds }),
+    ).toThrow();
+  });
+
+  it("moves and hides an open view, and closes it", () => {
+    manager.open({ id: "a", url: "https://x.example/", bounds });
+    manager.setBounds("a", { x: 1, y: 2, width: 3, height: 4 });
+    manager.setVisible("a", false);
+    const [view] = views;
+    expect(view.setBounds).toHaveBeenLastCalledWith({
+      x: 1,
+      y: 2,
+      width: 3,
+      height: 4,
+    });
+    expect(view.setVisible).toHaveBeenLastCalledWith(false);
+    manager.destroy("a");
+    expect(contentView.removeChildView).toHaveBeenCalledWith(view);
+    expect(view.webContents.close).toHaveBeenCalled();
+    expect(session.clearStorageData).toHaveBeenCalled();
+  });
+
+  it("reuses a view for the same url and replaces it for a new one", () => {
+    manager.open({ id: "a", url: "https://x.example/", bounds });
+    manager.open({ id: "a", url: "https://x.example/", bounds });
+    expect(views).toHaveLength(1);
+    manager.open({ id: "a", url: "https://y.example/", bounds });
+    expect(views).toHaveLength(2);
+    expect(contentView.removeChildView).toHaveBeenCalledWith(views[0]);
+  });
+
+  it("accepts an invalid certificate only for its own origin and only when asked", () => {
+    manager.open({
+      id: "a",
+      url: "https://x.example/",
+      ignoreCert: true,
+      bounds,
+    });
+    manager.open({ id: "b", url: "https://z.example/", bounds });
+    const check = (index: number, url: string) => {
+      const event = { preventDefault: vi.fn() };
+      const callback = vi.fn();
+      const handled = manager.handleCertificateError(
+        event,
+        views[index].webContents,
+        url,
+        callback,
+      );
+      return { handled, allowed: callback.mock.calls[0]?.[0] };
+    };
+    expect(check(0, "https://x.example/page")).toEqual({
+      handled: true,
+      allowed: true,
+    });
+    expect(check(0, "https://other.example/")).toEqual({
+      handled: true,
+      allowed: false,
+    });
+    expect(check(1, "https://z.example/")).toEqual({
+      handled: true,
+      allowed: false,
+    });
+    expect(
+      manager.handleCertificateError({}, {}, "https://x.example/", vi.fn()),
+    ).toBe(false);
+  });
+
+  it("closes everything", () => {
+    manager.open({ id: "a", url: "https://x.example/", bounds });
+    manager.open({ id: "b", url: "https://y.example/", bounds });
+    manager.destroyAll();
+    expect(contentView.removeChildView).toHaveBeenCalledTimes(2);
+  });
+
+  it("keeps bounds as whole, non negative numbers", () => {
+    expect(cleanBounds({ x: -5, y: "x", width: 9.5, height: 1 })).toEqual({
+      x: 0,
+      y: 0,
+      width: 10,
+      height: 1,
+    });
+  });
+});