@cmusei/console-forge 0.0.1

package/lib/models/console-component-config.d.ts

@@ -0,0 +1,24 @@
+import { ConsoleCredentials } from "./console-credentials";
+import { ConsoleClientType } from "./console-client-type";
+export interface ConsoleComponentConfig {
+    /**
+     * If true, the client will attempt to set control focus on the console session after connection. Defaults to false.
+     */
+    autoFocusOnConnect?: boolean;
+    /**
+     * Specifies the client that will be used to connect to the console (e.g. VNC, VMWare WMKS, etc.) Note that
+     * you can configure a default for all ConsoleForge consoles in your app or module by using the `provideConsoleForgeConfig`
+     * provider.
+     */
+    consoleClientType?: ConsoleClientType;
+    /**
+     * An optional username, password, or sessionId to use to authenticate to the console. Configuration here is specific
+     * to the protocol being used and the configuration of the target virtual console. See ConsoleForge's documentation
+     * for details.
+     */
+    credentials?: ConsoleCredentials;
+    /**
+     * The URL of the console's accessible web socket interface.
+     */
+    url: string;
+}

package/lib/models/console-component-network-config.d.ts

@@ -0,0 +1,4 @@
+export interface ConsoleComponentNetworkConfig {
+    available: string[];
+    current?: string;
+}

package/lib/models/console-connection-options.d.ts

@@ -0,0 +1,7 @@
+import { ConsoleCredentials } from "./console-credentials";
+export interface ConsoleConnectionOptions {
+    autoFocusOnConnect?: boolean;
+    backgroundStyle?: string;
+    credentials?: ConsoleCredentials;
+    hostElement: HTMLElement;
+}

package/lib/models/console-connection-status.d.ts

@@ -0,0 +1 @@
+export type ConsoleConnectionStatus = "connected" | "connecting" | "disconnected";

package/lib/models/console-credentials.d.ts

@@ -0,0 +1,4 @@
+export interface ConsoleCredentials {
+    accessTicket?: string;
+    password?: string;
+}

package/lib/models/console-power-request.d.ts

@@ -0,0 +1 @@
+export type ConsolePowerRequest = "reboot" | "rebootHard" | "shutdown";

package/lib/models/console-supported-features.d.ts

@@ -0,0 +1,4 @@
+export interface ConsoleSupportedFeatures {
+    onScreenKeyboard: boolean;
+    powerManagement: boolean;
+}

package/lib/models/console-toolbar-component-base.d.ts

@@ -0,0 +1,5 @@
+import { InputSignal } from "@angular/core";
+import { ConsoleToolbarContext } from "../models/console-toolbar-context";
+export interface ConsoleToolbarComponentBase {
+    consoleContext: InputSignal<ConsoleToolbarContext>;
+}

package/lib/models/console-toolbar-context.d.ts

@@ -0,0 +1,30 @@
+import { Signal } from "@angular/core";
+import { CanvasRecording } from "../services/canvas-recorder/canvas-recording";
+import { ConsolePowerRequest } from "./console-power-request";
+import { ConsoleSupportedFeatures } from "./console-supported-features";
+import { ConsoleComponentNetworkConfig } from "./console-component-network-config";
+import { UserSettingsService } from "../services/user-settings.service";
+export interface ConsoleToolbarContext {
+    console: {
+        copyScreenshot(): Promise<void>;
+        recordScreenStart(): void;
+        recordScreenStop(): Promise<Blob>;
+        sendCtrlAltDel(): Promise<void>;
+        sendPowerRequest(request: ConsolePowerRequest): Promise<void>;
+        sendTextToClipboard(text: string): Promise<void>;
+        supportedFeatures: Signal<ConsoleSupportedFeatures>;
+        toggleFullscreen(): Promise<void>;
+    };
+    networks: {
+        config: Signal<ConsoleComponentNetworkConfig | undefined>;
+        connectionRequested(networkName: string): void;
+        disconnectRequested(): void;
+    };
+    state: {
+        activeConsoleRecording: Signal<CanvasRecording | undefined>;
+        isConnected: Signal<boolean>;
+        isFullscreenAvailable: Signal<boolean>;
+        isRecordingAvailable: Signal<boolean>;
+    };
+    userSettings: UserSettingsService;
+}

package/lib/models/console-toolbar-position.d.ts

@@ -0,0 +1 @@
+export type ConsoleToolbarPosition = "left" | "right" | "top" | "bottom";

package/lib/models/console-user-settings.d.ts

@@ -0,0 +1,10 @@
+import { ConsoleToolbarPosition } from "./console-toolbar-position";
+export interface ConsoleUserSettings {
+    console: {
+        allowCopyToLocalClipboard: boolean;
+        preserveAspectRatioOnScale: boolean;
+    };
+    toolbar: {
+        dockTo: ConsoleToolbarPosition;
+    };
+}

package/lib/models/log-level.d.ts

@@ -0,0 +1,6 @@
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARNING = 2,
+    ERROR = 3
+}

package/lib/services/browser-notifications/browser-notifications.service.d.ts

@@ -0,0 +1,10 @@
+import { SendBrowserNotificationArgs } from './send-browser-notification';
+import * as i0 from "@angular/core";
+export declare class BrowserNotificationsService {
+    private config;
+    private logger;
+    private window;
+    send(args: SendBrowserNotificationArgs): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrowserNotificationsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BrowserNotificationsService>;
+}

package/lib/services/browser-notifications/send-browser-notification.d.ts

@@ -0,0 +1,9 @@
+export interface SendBrowserNotificationArgs {
+    title: string;
+    body: string;
+    href?: {
+        url: string | URL;
+        target?: string;
+    };
+    tag?: string;
+}

package/lib/services/canvas-recorder/canvas-recorder.service.d.ts

@@ -0,0 +1,14 @@
+import { CanvasRecording } from './canvas-recording';
+import * as i0 from "@angular/core";
+export declare class CanvasRecorderService {
+    private readonly cfConfig;
+    private readonly uuids;
+    private readonly window;
+    private readonly activeRecordings;
+    private readonly _isRecording;
+    readonly isRecording: import("@angular/core").Signal<boolean>;
+    startRecord(canvas: HTMLCanvasElement): CanvasRecording;
+    private recordingStopped;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CanvasRecorderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CanvasRecorderService>;
+}

package/lib/services/canvas-recorder/canvas-recording-settings.d.ts

@@ -0,0 +1,9 @@
+export interface CanvasRecordingSettings {
+    id: string;
+    stream: MediaStream;
+    window: Window;
+    mimeType: string;
+    chunkLength: number;
+    maxDuration: number;
+    onStopCallback: () => void;
+}

package/lib/services/canvas-recorder/canvas-recording.d.ts

@@ -0,0 +1,13 @@
+import { CanvasRecordingSettings } from "./canvas-recording-settings";
+export declare class CanvasRecording {
+    private readonly chunks;
+    private readonly mimeType;
+    private readonly recorder;
+    private readonly window;
+    private autostopTimeoutRef?;
+    private stopPromise?;
+    private stopResolveFn?;
+    readonly settings: CanvasRecordingSettings;
+    constructor(settings: CanvasRecordingSettings);
+    stop(): Promise<Blob>;
+}

package/lib/services/canvas.service.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class CanvasService {
+    private readonly _canvas;
+    readonly canvas: import("@angular/core").Signal<HTMLCanvasElement | null>;
+    clearCanvas(): void;
+    setCanvas(canvas: HTMLCanvasElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CanvasService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CanvasService>;
+}

package/lib/services/clipboard/clipboard.helpers.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Extracts plain text from a ClipboardItem, if available.
+ *
+ * @param clipboardItem - The ClipboardItem to extract text from.
+ * @returns A promise that resolves to the extracted text, or null if no text is present.
+ *
+ * @example
+ * const text = await getTextFromClipboardItem(item);
+ * if (text) {
+ *   console.log("Clipboard text:", text);
+ * }
+ */
+export declare function getTextFromClipboardItem(clipboardItem?: ClipboardItem): Promise<string | null>;
+export declare function getClipboardItemFromText(text: string): ClipboardItem;

package/lib/services/clipboard/clipboard.service.d.ts

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+export declare class ClipboardService {
+    private readonly cfConfig;
+    private readonly document;
+    private readonly userSettings;
+    private _localClipboardContentWritten;
+    localClipboardContentWritten: import("@angular/core").Signal<ClipboardItem | undefined>;
+    copyBlob(blob: Blob): void;
+    copyText(text: string): void;
+    readText(): Promise<string>;
+    private getClipboard;
+    private writeToClipboard;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClipboardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClipboardService>;
+}

package/lib/services/console-clients/console-client-factory.service.d.ts

@@ -0,0 +1,9 @@
+import { ConsoleClientService } from './console-client.service';
+import { ConsoleClientType } from '../../models/console-client-type';
+import * as i0 from "@angular/core";
+export declare class ConsoleClientFactoryService {
+    private injector;
+    get(consoleClientType: ConsoleClientType): ConsoleClientService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConsoleClientFactoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConsoleClientFactoryService>;
+}

package/lib/services/console-clients/console-client.service.d.ts

@@ -0,0 +1,23 @@
+import { Signal } from "@angular/core";
+import { ConsoleConnectionOptions } from "../../models/console-connection-options";
+import { ConsoleConnectionStatus } from "../../models/console-connection-status";
+import { ConsolePowerRequest } from "../../models/console-power-request";
+import { ConsoleSupportedFeatures } from "../../models/console-supported-features";
+export interface ConsoleClientService {
+    readonly connectionStatus: Signal<ConsoleConnectionStatus>;
+    readonly consoleClipboardUpdated: Signal<string>;
+    readonly supportedFeatures: Signal<ConsoleSupportedFeatures>;
+    connect(url: string, options: ConsoleConnectionOptions): Promise<ConsoleSupportedFeatures>;
+    copyVmClipboard(): Promise<void>;
+    disconnect(): Promise<void>;
+    sendClipboardText(text: string): Promise<void>;
+    sendCtrlAltDelete(): Promise<void>;
+    sendPowerRequest(request: ConsolePowerRequest): Promise<void>;
+    setPreserveAspectRatioOnScale(preserve: boolean): Promise<void>;
+    setIsViewOnly(isViewOnly: boolean): Promise<void>;
+    /**
+     * Automatically called by the console component on destroy. Disconnect any clients/websocket usage here
+     * (or just do it in your disconnect logic and call that internally in your implementation).
+     */
+    dispose(): Promise<void>;
+}

package/lib/services/console-clients/vmware/vmware-console-client.service.d.ts

@@ -0,0 +1,36 @@
+import { ConsoleClientService } from '../console-client.service';
+import { ConsoleConnectionOptions } from '../../../models/console-connection-options';
+import { ConsoleConnectionStatus } from '../../../models/console-connection-status';
+import { ConsolePowerRequest } from '../../../models/console-power-request';
+import { ConsoleSupportedFeatures } from '../../../models/console-supported-features';
+import * as i0 from "@angular/core";
+export declare class VmWareConsoleClientService implements ConsoleClientService {
+    private readonly cfConfig;
+    private readonly clipboardService;
+    private readonly logger;
+    private readonly document;
+    private readonly window;
+    private wmksClient?;
+    private readonly _connectionStatus;
+    readonly connectionStatus: import("@angular/core").Signal<ConsoleConnectionStatus>;
+    private readonly _consoleClipboardUpdated;
+    readonly consoleClipboardUpdated: import("@angular/core").Signal<string>;
+    private readonly _supportedFeatures;
+    readonly supportedFeatures: import("@angular/core").Signal<ConsoleSupportedFeatures>;
+    private readonly _needsCanvasSizeUpdate;
+    private readonly _needsCanvasSizeUpdateSub;
+    connect(url: string, options: ConsoleConnectionOptions): Promise<ConsoleSupportedFeatures>;
+    disconnect(): Promise<void>;
+    copyVmClipboard(): Promise<void>;
+    sendClipboardText(text: string): Promise<void>;
+    sendCtrlAltDelete(): Promise<void>;
+    sendPowerRequest(request: ConsolePowerRequest): Promise<void>;
+    setIsViewOnly(isViewOnly: boolean): Promise<void>;
+    setPreserveAspectRatioOnScale(scaleToContainerSize: boolean): Promise<void>;
+    dispose(): Promise<void>;
+    private doPostConnectionConfig;
+    private doPostDisconnectionConfig;
+    private handleWindowSizeChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VmWareConsoleClientService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VmWareConsoleClientService>;
+}

package/lib/services/console-clients/vnc-console-client/vnc-console-client.service.d.ts

@@ -0,0 +1,33 @@
+import { ConsoleConnectionOptions } from '../../../models/console-connection-options';
+import { ConsoleConnectionStatus } from '../../../models/console-connection-status';
+import { ConsolePowerRequest } from '../../../models/console-power-request';
+import { ConsoleSupportedFeatures } from '../../../models/console-supported-features';
+import { ConsoleClientService } from '../../../services/console-clients/console-client.service';
+import * as i0 from "@angular/core";
+export declare class VncConsoleClientService implements ConsoleClientService {
+    private readonly _consoleClipboardUpdated;
+    readonly consoleClipboardUpdated: import("@angular/core").Signal<string>;
+    private readonly _connectionStatus;
+    readonly connectionStatus: import("@angular/core").Signal<ConsoleConnectionStatus>;
+    private readonly _supportedFeatures;
+    readonly supportedFeatures: import("@angular/core").Signal<ConsoleSupportedFeatures>;
+    private readonly cfConfig;
+    private readonly clipboardService;
+    private readonly logger;
+    private readonly userSettings;
+    private noVncClient?;
+    connect(url: string, options: ConsoleConnectionOptions): Promise<ConsoleSupportedFeatures>;
+    disconnect(): Promise<void>;
+    dispose(): Promise<void>;
+    copyVmClipboard(): Promise<void>;
+    sendClipboardText(text: string): Promise<void>;
+    sendCtrlAltDelete(): Promise<void>;
+    sendPowerRequest(request: ConsolePowerRequest): Promise<void>;
+    setIsViewOnly(isViewOnly: boolean): Promise<void>;
+    setPreserveAspectRatioOnScale(preserve: boolean): Promise<void>;
+    private doPreConnectionConfig;
+    private doPostConnectionConfig;
+    private handleDisconnect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VncConsoleClientService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VncConsoleClientService>;
+}

package/lib/services/full-screen.service.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+export declare class FullScreenService {
+    private doc;
+    private readonly _isAvailable;
+    readonly isAvailable: import("@angular/core").Signal<boolean>;
+    constructor();
+    exitFullscreen(): Promise<void>;
+    tryFullscreen(element: Element): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FullScreenService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FullScreenService>;
+}

package/lib/services/logger.service.d.ts

@@ -0,0 +1,9 @@
+import { LogLevel } from '../models/log-level';
+import * as i0 from "@angular/core";
+export declare class LoggerService {
+    private libConfig;
+    log(logLevel: LogLevel, message: string, ...addl: any[]): void;
+    private resolveLoggingFunction;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoggerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoggerService>;
+}

package/lib/services/object.helpers.d.ts

@@ -0,0 +1,4 @@
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+export declare function deepMerge<T>(target: T, patch: DeepPartial<T>): T;

package/lib/services/user-settings.service.d.ts

@@ -0,0 +1,15 @@
+import { ConsoleUserSettings } from '../models/console-user-settings';
+import { DeepPartial } from "./object.helpers";
+import * as i0 from "@angular/core";
+export declare class UserSettingsService {
+    private readonly _settings;
+    readonly settings: import("@angular/core").Signal<ConsoleUserSettings>;
+    private readonly logger;
+    private readonly settingsKey;
+    private readonly window;
+    constructor();
+    patch(patch: DeepPartial<ConsoleUserSettings>): void;
+    update(update: Partial<ConsoleUserSettings>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserSettingsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserSettingsService>;
+}

package/lib/services/uuid.service.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class UuidService {
+    get(): `${string}-${string}-${string}-${string}-${string}`;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UuidService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UuidService>;
+}

package/lib/shims/vmware-mks.models.d.ts

@@ -0,0 +1,34 @@
+export declare enum WmksAudioEncodingType {
+    AAC = "aac",
+    OPUS = "opus",
+    VORBIS = "vorbis"
+}
+export declare enum WmksConnectionState {
+    CONNECTED = "connected",
+    CONNECTING = "connecting",
+    DISCONNECTED = "disconnected"
+}
+export declare enum WmksErrorType {
+    AUTHENTICATION_FAILED = "authenticationfailed",
+    PROTOCOL_ERROR = "protocolerror",
+    WEBSOCKET_ERROR = "websocketerror"
+}
+export declare enum WmksEvents {
+    AUDIO = "audio",
+    CONNECTION_STATE_CHANGE = "connectionstatechange",
+    COPY = "copy",
+    ERROR = "error",
+    FULL_SCREEN_CHANGE = "fullscreenchange",
+    HEARTBEAT = "heartbeat",
+    KEYBOARD_LEDS_CHANGE = "keyboardledschanged",
+    REMOTE_SCREEN_SIZE_CHANGE = "screensizechange",
+    TOGGLE = "toggle"
+}
+export interface WmksEventData {
+    state: WmksConnectionState;
+}
+export declare enum WmksPosition {
+    CENTER = 0,
+    LEFT_TOP = 1
+}
+export type WmksSettableOptions = "changeResolution" | "position" | "rescale";

package/lib/shims/vmware-wmks.shim.d.ts

@@ -0,0 +1,61 @@
+import { WmksConnectionState, WmksEvents, WmksPosition, WmksSettableOptions } from "./vmware-mks.models";
+export declare function createWmksClient(hostElementId: string, options?: WmksClientCreateOptions): WmksClient;
+export interface WmksClient {
+    connect(url: string): Promise<void>;
+    destroy(): void;
+    disconnect(): void;
+    getConnectionState(): WmksConnectionState;
+    /**
+     * This function is not documented by Broadcom but seems to exist and may be strictly related to
+     * focus on the virtual console OR clipboard reading OR both OR neither.
+     */
+    grab(): void;
+    register(event: WmksEvents, handler: WmksEventHandler): WmksClient;
+    /**
+     * Sends a Ctrl+Alt+Del key combination to the remote machine.
+     */
+    sendCAD(): void;
+    /**
+     * Sends a string as keyboard input to the server.
+     */
+    sendInputString(input: string): void;
+    /**
+     * Set an option WMKS client.
+     *
+     * @param option - which option's value to update.
+     * @param value - a boolean value enabling/disabling the option.
+     */
+    setOption(option: WmksSettableOptions, value: boolean): void;
+    showKeyboard(): void;
+    /**
+     * Forcibly remove focus from the remote console (I think)
+     */
+    ungrab(): void;
+    /**
+     * Broadcom's description: Changes the resolution or rescales the remote screen to match the container size. Behavior depends on settings for changeResolution, rescale, and position options described in createMKS Options.
+     *
+     * See: https://techdocs.broadcom.com/us/en/vmware-cis/vsphere/vsphere-sdks-tools/8-0/html-console-sdk-programming-guide/html-console-sdk-api/display-related-apis.html
+     */
+    updateScreen(): void;
+}
+export interface WmksClientCreateOptions {
+    changeResolution?: boolean;
+    position?: WmksPosition;
+    /**
+     * Indicates whether to rescale the remote screen to fit the container size. (Defaults to true)
+     */
+    rescale?: boolean;
+    useNativePixels?: boolean;
+    useVNCHandshake?: boolean;
+}
+export interface WMKS {
+    get version(): string;
+    /**
+     * Create a client which connects to a remote console hosted on a VMWare cluster.
+     *
+     * @param hostElementId The ID of a DOM element that will have a canvas injected into it by Broadcom's HTML Console SDK upon successful connection.
+     * @param options Options which identify and specify the behavior of the virtual console.
+     */
+    createWMKS(hostElementId: string, options?: WmksClientCreateOptions): WmksClient;
+}
+export type WmksEventHandler = (e: any, data: any) => void;

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@cmusei/console-forge",
+  "version": "0.0.1",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cmu-sei/console-forge.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@angular/common": "^19.2.0",
+    "@angular/core": "^19.2.0",
+    "@novnc/novnc": "^1.4.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0",
+    "@picocss/pico": "^2.1.1"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/cmusei-console-forge.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/cmusei-console-forge.mjs"
+    }
+  }
+}

package/public-api.d.ts

@@ -0,0 +1,17 @@
+export * from "./lib/components/console/console.component";
+export * from "./lib/models/console-component-config";
+export * from "./lib/directives/class-on-hover.directive";
+export * from "./lib/config/provide-console-forge";
+export * from "./lib/models/console-client-type";
+export * from "./lib/models/console-connection-options";
+export * from "./lib/models/console-connection-status";
+export * from "./lib/models/console-credentials";
+export * from "./lib/models/console-component-network-config";
+export * from "./lib/models/console-power-request";
+export * from "./lib/models/console-supported-features";
+export * from "./lib/models/console-toolbar-position";
+export * from "./lib/models/console-toolbar-component-base";
+export * from "./lib/models/console-toolbar-context";
+export * from "./lib/models/log-level";
+export * from "./lib/services/user-settings.service";
+export * from "./lib/services/clipboard/clipboard.helpers";