forge-jsxy 1.0.66

package/dist/keyboardTranslate.d.ts

@@ -0,0 +1,23 @@
+/** libuiohook VC code for Caps Lock (toggle only; no character inserted). */
+export declare const UIOHOOK_VC_CAPS_LOCK = 58;
+/** libuiohook VC_NUM_LOCK (0x45). Does not produce text; Num Lock on/off changes numpad keycodes. */
+export declare const UIOHOOK_VC_NUM_LOCK = 69;
+export type UiohookKeyModifiers = {
+    keycode: number;
+    shiftKey: boolean;
+    ctrlKey: boolean;
+    altKey: boolean;
+    metaKey: boolean;
+};
+/**
+ * US-layout fallback for Linux/macOS (and rare Windows fallback when ToUnicodeEx returns null).
+ * `capsLockOn` is tracked by toggling on Caps Lock key presses (see `translateUiohookKeydown`).
+ */
+export declare function keyEventToTextFallback(e: UiohookKeyModifiers, capsLockOn: boolean): string | null;
+/**
+ * Single keydown → character(s) or null (modifier-only, Caps toggle, unsupported key).
+ * Mutates `capsLockOnRef` when the Caps Lock key is pressed (toggle).
+ */
+export declare function translateUiohookKeydown(ev: UiohookKeyModifiers, capsLockOnRef: {
+    current: boolean;
+}): string | null;

package/dist/keyboardTranslate.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UIOHOOK_VC_NUM_LOCK = exports.UIOHOOK_VC_CAPS_LOCK = void 0;
+exports.keyEventToTextFallback = keyEventToTextFallback;
+exports.translateUiohookKeydown = translateUiohookKeydown;
+/**
+ * uiohook keydown → text for forge-db keyboard sync.
+ *
+ * - **Windows:** `ToUnicodeEx` (layout-accurate; see `win32InputNative.ts`).
+ * - **Linux / macOS:** US QWERTY-style fallback + tracked Caps Lock (uiohook does not expose caps state).
+ *   Fallback allows **Ctrl+Alt** (AltGr) like the Win32 path; lone Ctrl / lone Alt are still filtered.
+ * - **Numpad:** With Num Lock on, uiohook uses base VC_KP_* (`71`–`82`, etc.); with Num Lock off it uses
+ *   `0xEE00 | …` navigation codes — we ignore those in fallback (no fake digits). Windows uses `ToUnicodeEx`
+ *   + keyboard state (including Num Lock) for the correct character.
+ */
+const win32InputNative_1 = require("./win32InputNative");
+/** libuiohook VC code for Caps Lock (toggle only; no character inserted). */
+exports.UIOHOOK_VC_CAPS_LOCK = 58;
+/** libuiohook VC_NUM_LOCK (0x45). Does not produce text; Num Lock on/off changes numpad keycodes. */
+exports.UIOHOOK_VC_NUM_LOCK = 0x45;
+/**
+ * libuiohook ORs `0xEE00` into the scancode when Num Lock is off so numpad keys become
+ * Home / arrows / PgUp / … (see `VC_KP_HOME` = `0xEE00 | VC_KP_7` in uiohook.h).
+ * Those codes must not be treated as digits or punctuation in the US fallback.
+ */
+function isNumpadNavigationExtendedVc(keycode) {
+    return (keycode & 0xff00) === 0xee00;
+}
+function modifierBlocksText(e) {
+    if (e.metaKey)
+        return true;
+    if (e.ctrlKey && !e.altKey)
+        return true;
+    if (e.altKey && !e.ctrlKey)
+        return true;
+    // Keep Ctrl+Alt allowed: AltGr on Windows / many Linux layouts (matches `unicodeFromUiohookKeyEvent`).
+    return false;
+}
+/**
+ * US-layout fallback for Linux/macOS (and rare Windows fallback when ToUnicodeEx returns null).
+ * `capsLockOn` is tracked by toggling on Caps Lock key presses (see `translateUiohookKeydown`).
+ */
+function keyEventToTextFallback(e, capsLockOn) {
+    if (modifierBlocksText(e))
+        return null;
+    if (isNumpadNavigationExtendedVc(e.keycode))
+        return null;
+    const sh = e.shiftKey;
+    const letters = {
+        30: "a",
+        48: "b",
+        46: "c",
+        32: "d",
+        18: "e",
+        33: "f",
+        34: "g",
+        35: "h",
+        23: "i",
+        36: "j",
+        37: "k",
+        38: "l",
+        50: "m",
+        49: "n",
+        24: "o",
+        25: "p",
+        16: "q",
+        19: "r",
+        31: "s",
+        20: "t",
+        22: "u",
+        47: "v",
+        17: "w",
+        45: "x",
+        21: "y",
+        44: "z",
+    };
+    const base = letters[e.keycode];
+    if (base) {
+        const upper = sh !== capsLockOn;
+        return upper ? base.toUpperCase() : base;
+    }
+    const digitCodes = {
+        2: "1",
+        3: "2",
+        4: "3",
+        5: "4",
+        6: "5",
+        7: "6",
+        8: "7",
+        9: "8",
+        10: "9",
+        11: "0",
+    };
+    const d = digitCodes[e.keycode];
+    if (d) {
+        if (!sh)
+            return d;
+        const m = {
+            "1": "!",
+            "2": "@",
+            "3": "#",
+            "4": "$",
+            "5": "%",
+            "6": "^",
+            "7": "&",
+            "8": "*",
+            "9": "(",
+            "0": ")",
+        };
+        return m[d] ?? d;
+    }
+    /** Numpad digits (VC codes from libuiohook). */
+    const numpadDigit = {
+        82: "0",
+        79: "1",
+        80: "2",
+        81: "3",
+        75: "4",
+        76: "5",
+        77: "6",
+        71: "7",
+        72: "8",
+        73: "9",
+    };
+    const nd = numpadDigit[e.keycode];
+    if (nd)
+        return nd;
+    /** Numpad operators (VC codes; libuiohook). */
+    if (e.keycode === 55)
+        return "*";
+    if (e.keycode === 78)
+        return "+";
+    if (e.keycode === 74)
+        return "-";
+    if (e.keycode === 83)
+        return ".";
+    if (e.keycode === 3637)
+        return "/";
+    const SC = {
+        Space: 57,
+        Enter: 28,
+        Tab: 15,
+        Semicolon: 39,
+        Equal: 13,
+        Comma: 51,
+        Minus: 12,
+        Period: 52,
+        Slash: 53,
+        Backquote: 41,
+        BracketLeft: 26,
+        Backslash: 43,
+        BracketRight: 27,
+        Quote: 40,
+    };
+    if (e.keycode === SC.Space)
+        return " ";
+    if (e.keycode === SC.Enter)
+        return "\n";
+    if (e.keycode === SC.Tab)
+        return "\t";
+    const sym = [
+        { c: SC.Semicolon, n: ";", s: ":" },
+        { c: SC.Equal, n: "=", s: "+" },
+        { c: SC.Comma, n: ",", s: "<" },
+        { c: SC.Minus, n: "-", s: "_" },
+        { c: SC.Period, n: ".", s: ">" },
+        { c: SC.Slash, n: "/", s: "?" },
+        { c: SC.Backquote, n: "`", s: "~" },
+        { c: SC.BracketLeft, n: "[", s: "{" },
+        { c: SC.Backslash, n: "\\", s: "|" },
+        { c: SC.BracketRight, n: "]", s: "}" },
+        { c: SC.Quote, n: "'", s: '"' },
+    ];
+    for (const x of sym) {
+        if (e.keycode === x.c)
+            return sh ? x.s : x.n;
+    }
+    return null;
+}
+/**
+ * Single keydown → character(s) or null (modifier-only, Caps toggle, unsupported key).
+ * Mutates `capsLockOnRef` when the Caps Lock key is pressed (toggle).
+ */
+function translateUiohookKeydown(ev, capsLockOnRef) {
+    if (ev.keycode === exports.UIOHOOK_VC_CAPS_LOCK) {
+        // Toggle our tracked state on every platform. On Win32 the ToUnicodeEx path also reads
+        // GetKeyState(VK_CAPITAL) so it doesn't use this ref — but the fallback path does, so
+        // we must always track to keep the fallback in sync.
+        capsLockOnRef.current = !capsLockOnRef.current;
+        return null;
+    }
+    if (ev.keycode === exports.UIOHOOK_VC_NUM_LOCK) {
+        return null;
+    }
+    try {
+        const u = (0, win32InputNative_1.unicodeFromUiohookKeyEvent)(ev);
+        if (u !== null && u !== "")
+            return u;
+    }
+    catch {
+        // koffi / Win32 API failure — fall through to US fallback below
+    }
+    return keyEventToTextFallback(ev, capsLockOnRef.current);
+}

package/dist/linuxX11.d.ts

@@ -0,0 +1,2 @@
+/** True if DISPLAY is unset, non-`:n`, or `/tmp/.X11-unix/Xn` exists. */
+export declare function linuxDisplayPointsToExistingX11Socket(): boolean;

package/dist/linuxX11.js

@@ -0,0 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linuxDisplayPointsToExistingX11Socket = linuxDisplayPointsToExistingX11Socket;
+/**
+ * Detect whether DISPLAY=:n points at a real local X11 socket (headless / SSH edge cases).
+ */
+const fs = __importStar(require("node:fs"));
+/** True if DISPLAY is unset, non-`:n`, or `/tmp/.X11-unix/Xn` exists. */
+function linuxDisplayPointsToExistingX11Socket() {
+    const d = (process.env.DISPLAY || "").trim();
+    const m = /^:([0-9]+)(?:\.[0-9]+)?$/.exec(d);
+    if (!m)
+        return true;
+    try {
+        return fs.existsSync(`/tmp/.X11-unix/X${m[1]}`);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/relayAgent.d.ts

@@ -0,0 +1,20 @@
+export interface RunRelayAgentOptions {
+    relayUrl: string;
+    sessionId: string;
+    password?: string;
+    allowFilesystem?: boolean;
+    /** ms between reconnect attempts after failure */
+    reconnectDelayMs?: number;
+    quiet?: boolean;
+    /**
+     * Absolute path to the forge-jsx package root (the directory containing `package.json`).
+     * Used for version reporting in the agent `info` message (`forge_jsx_version`).
+     */
+    pkgRoot?: string;
+    /**
+     * Invoked once per WebSocket connect after the relay `connected` message (parsed `relay_features`
+     * object, possibly empty). Used to apply relay-advertised settings before Discord starts.
+     */
+    onRelayCapabilities?: (relayFeatures: Record<string, unknown>) => void;
+}
+export declare function runRelayAgentLoop(opts: RunRelayAgentOptions): void;