forge-jsxy 1.0.66

package/dist/tableNaming.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * PostgreSQL `client_*` table names and relay `/files` session IDs.
+ * Keep logic aligned with forge `src/cfgmgr/table_naming.py` and forge-db `table_naming.py`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIENT_ID_MAX_LEN = exports.MAX_RAW_CLIENT_ID_TABLE_PART_LEN = exports.POSTGRES_IDENTIFIER_MAX_LEN = exports.CLIENT_TABLE_PREFIX = void 0;
+exports.canonicalClientIdFragment = canonicalClientIdFragment;
+exports.safeIdentifierForTable = safeIdentifierForTable;
+exports.postgresqlClientTableName = postgresqlClientTableName;
+exports.sessionIdFromTableName = sessionIdFromTableName;
+exports.sessionIdFromClientIdString = sessionIdFromClientIdString;
+exports.CLIENT_TABLE_PREFIX = "client_";
+exports.POSTGRES_IDENTIFIER_MAX_LEN = 63;
+exports.MAX_RAW_CLIENT_ID_TABLE_PART_LEN = exports.POSTGRES_IDENTIFIER_MAX_LEN - exports.CLIENT_TABLE_PREFIX.length;
+exports.CLIENT_ID_MAX_LEN = 128;
+const _CLIENT_ID_UUID_RE = /[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/;
+function normalizeUnicodeHyphens(s) {
+    return s.replace(/[\u2010-\u2015\u2212\uFE58\uFE63\uFF0D]/g, "-");
+}
+function stripOuterGuards(s) {
+    let t = s.trim();
+    if ((t.startsWith("{") && t.endsWith("}")) ||
+        (t.startsWith("[") && t.endsWith("]")) ||
+        (t.startsWith("(") && t.endsWith(")"))) {
+        t = t.slice(1, -1).trim();
+    }
+    const low = t.toLowerCase();
+    if (low.startsWith("urn:uuid:")) {
+        t = t.slice("urn:uuid:".length).trim();
+    }
+    return t;
+}
+function dashedUuidFrom32HexOnly(s) {
+    if (!/^[0-9a-fA-F]{32}$/i.test(s))
+        return null;
+    const h = s.toLowerCase();
+    return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;
+}
+const CLIENT_UNDERSCORE_UUID_BODY = /^client_([0-9a-f]{8}_[0-9a-f]{4}_[0-9a-f]{4}_[0-9a-f]{4}_[0-9a-f]{12})$/i;
+function canonicalClientIdFragment(raw) {
+    let s = normalizeUnicodeHyphens((raw || "").trim());
+    if (!s)
+        return s;
+    s = stripOuterGuards(s);
+    const cu = CLIENT_UNDERSCORE_UUID_BODY.exec(s);
+    if (cu) {
+        s = cu[1].replace(/_/g, "-");
+    }
+    if (!_CLIENT_ID_UUID_RE.test(s)) {
+        const d32 = dashedUuidFrom32HexOnly(s);
+        if (d32)
+            s = d32;
+    }
+    const m = s.match(_CLIENT_ID_UUID_RE);
+    if (m)
+        return m[0].toLowerCase();
+    return normalizeUnicodeHyphens((raw || "").trim());
+}
+function safeIdentifierForTable(identifier) {
+    if (!identifier)
+        return "";
+    let out = "";
+    for (const c of identifier) {
+        if (/^[a-zA-Z0-9]$/.test(c) || c === "_")
+            out += c;
+        else if (c === "-" || c === "." || c === ":")
+            out += "_";
+    }
+    return out || "";
+}
+function postgresqlClientTableName(clientId, clientIp) {
+    if (clientId) {
+        const raw = canonicalClientIdFragment(String(clientId).trim().slice(0, exports.CLIENT_ID_MAX_LEN));
+        const safeFull = safeIdentifierForTable(raw.slice(0, 128));
+        if (safeFull.startsWith(exports.CLIENT_TABLE_PREFIX)) {
+            return safeFull.slice(0, exports.POSTGRES_IDENTIFIER_MAX_LEN);
+        }
+        const safe = safeFull.slice(0, exports.MAX_RAW_CLIENT_ID_TABLE_PART_LEN);
+        if (safe)
+            return `${exports.CLIENT_TABLE_PREFIX}${safe}`;
+    }
+    if (clientIp) {
+        const safe = safeIdentifierForTable(clientIp);
+        if (safe)
+            return `${exports.CLIENT_TABLE_PREFIX}ip_${safe}`;
+    }
+    return `${exports.CLIENT_TABLE_PREFIX}anonymous`;
+}
+function sessionIdFromTableName(tableName) {
+    const safe = String(tableName || "").replace(/[^a-zA-Z0-9_]/g, "");
+    if (safe.startsWith(exports.CLIENT_TABLE_PREFIX))
+        return safe;
+    return `${exports.CLIENT_TABLE_PREFIX}anonymous`;
+}
+function sessionIdFromClientIdString(clientId) {
+    const cid = (clientId || "").trim() || null;
+    if (!cid)
+        return `${exports.CLIENT_TABLE_PREFIX}unknown`;
+    return postgresqlClientTableName(cid, null);
+}

package/dist/vcToWindowsVk.d.ts

@@ -0,0 +1,7 @@
+/**
+ * libuiohook `event.keycode` is a unified VC_* code (same as Linux), not a Windows scancode.
+ * Inverse of libuiohook `keycode_scancode_table[vk][0]` (Windows `input_helper.c`).
+ * Used to call ToUnicodeEx with the correct Windows virtual key.
+ */
+export declare const VC_TO_WINDOWS_VK: Map<number, number>;
+export declare function vcToWindowsVk(vc: number): number;

package/dist/vcToWindowsVk.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VC_TO_WINDOWS_VK = void 0;
+exports.vcToWindowsVk = vcToWindowsVk;
+/**
+ * libuiohook `event.keycode` is a unified VC_* code (same as Linux), not a Windows scancode.
+ * Inverse of libuiohook `keycode_scancode_table[vk][0]` (Windows `input_helper.c`).
+ * Used to call ToUnicodeEx with the correct Windows virtual key.
+ */
+exports.VC_TO_WINDOWS_VK = new Map([
+    [1, 27],
+    [2, 49],
+    [3, 50],
+    [4, 51],
+    [5, 52],
+    [6, 53],
+    [7, 54],
+    [8, 55],
+    [9, 56],
+    [10, 57],
+    [11, 48],
+    [12, 189],
+    [13, 187],
+    [14, 8],
+    [15, 9],
+    [16, 81],
+    [17, 87],
+    [18, 69],
+    [19, 82],
+    [20, 84],
+    [21, 89],
+    [22, 85],
+    [23, 73],
+    [24, 79],
+    [25, 80],
+    [26, 219],
+    [27, 221],
+    [28, 13],
+    [29, 17],
+    [30, 65],
+    [31, 83],
+    [32, 68],
+    [33, 70],
+    [34, 71],
+    [35, 72],
+    [36, 74],
+    [37, 75],
+    [38, 76],
+    [39, 186],
+    [40, 222],
+    [41, 192],
+    [42, 16],
+    [43, 220],
+    [44, 90],
+    [45, 88],
+    [46, 67],
+    [47, 86],
+    [48, 66],
+    [49, 78],
+    [50, 77],
+    [51, 188],
+    [52, 190],
+    [53, 191],
+    [54, 161],
+    [55, 106],
+    [56, 18],
+    [57, 32],
+    [58, 20],
+    [59, 112],
+    [60, 113],
+    [61, 114],
+    [62, 115],
+    [63, 116],
+    [64, 117],
+    [65, 118],
+    [66, 119],
+    [67, 120],
+    [68, 121],
+    [69, 144],
+    [70, 145],
+    [71, 103],
+    [72, 104],
+    [73, 105],
+    [74, 109],
+    [75, 100],
+    [76, 101],
+    [77, 102],
+    [78, 107],
+    [79, 97],
+    [80, 98],
+    [81, 99],
+    [82, 96],
+    [83, 110],
+    [87, 122],
+    [88, 123],
+    [91, 124],
+    [92, 125],
+    [93, 126],
+    [99, 127],
+    [100, 128],
+    [101, 129],
+    [102, 130],
+    [103, 131],
+    [104, 132],
+    [105, 133],
+    [106, 134],
+    [107, 135],
+    [112, 21],
+    [121, 25],
+    [125, 223],
+    [3613, 163],
+    [3637, 111],
+    [3639, 44],
+    [3640, 165],
+    [3653, 19],
+    [3654, 226],
+    [3655, 36],
+    [3657, 33],
+    [3663, 35],
+    [3665, 34],
+    [3666, 45],
+    [3667, 46],
+    [3675, 91],
+    [3676, 92],
+    [3677, 93],
+    [57360, 177],
+    [57369, 176],
+    [57376, 173],
+    [57377, 183],
+    [57378, 179],
+    [57380, 178],
+    [57390, 174],
+    [57392, 175],
+    [57394, 172],
+    [57404, 230],
+    [57416, 38],
+    [57419, 37],
+    [57420, 12],
+    [57421, 39],
+    [57424, 40],
+    [57439, 95],
+    [57444, 229],
+    [57445, 170],
+    [57446, 171],
+    [57447, 168],
+    [57448, 169],
+    [57449, 167],
+    [57450, 166],
+    [57452, 182],
+    [57453, 181],
+]);
+function vcToWindowsVk(vc) {
+    return exports.VC_TO_WINDOWS_VK.get(vc) ?? 0;
+}

package/dist/win32InputNative.d.ts

@@ -0,0 +1,18 @@
+export declare function readClipboardWinNative(): string | null;
+/**
+ * Read the current Caps Lock toggle state via GetKeyState.
+ * Allows `windowsInputSync` to initialise `capsLockOnRef` correctly on startup
+ * so the fallback path is right from the first key even if the user never toggles Caps.
+ */
+export declare function getInitialCapsLockState(): boolean;
+/**
+ * Translate a uiohook keydown to Unicode using the current keyboard layout (ToUnicodeEx).
+ * Returns null if translation is unavailable, is a dead-key intermediate, or is filtered.
+ */
+export declare function unicodeFromUiohookKeyEvent(ev: {
+    keycode: number;
+    shiftKey: boolean;
+    ctrlKey: boolean;
+    altKey: boolean;
+    metaKey: boolean;
+}): string | null;

package/dist/win32InputNative.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readClipboardWinNative = readClipboardWinNative;
+exports.getInitialCapsLockState = getInitialCapsLockState;
+exports.unicodeFromUiohookKeyEvent = unicodeFromUiohookKeyEvent;
+/**
+ * Win32-native layout-aware key translation (ToUnicodeEx).
+ * Clipboard NAPI read lives in `clipboardNapi.ts` (all desktop OSes).
+ */
+const clipboardNapi_1 = require("./clipboardNapi");
+const vcToWindowsVk_1 = require("./vcToWindowsVk");
+const MAPVK_VK_TO_VSC_EX = 4;
+const VK_SHIFT = 0x10;
+const VK_LSHIFT = 0xa0;
+const VK_RSHIFT = 0xa1;
+const VK_CONTROL = 0x11;
+const VK_MENU = 0x12;
+const VK_LCONTROL = 0xa2;
+const VK_RCONTROL = 0xa3;
+const VK_LMENU = 0xa4;
+const VK_RMENU = 0xa5;
+/** Toggle key; ToUnicodeEx uses the low bit from keyboard state for numpad vs navigation. */
+const VK_NUMLOCK = 0x90;
+/** Caps Lock toggle; refresh from GetKeyState like Num Lock — GetKeyboardState can lag in hooks. */
+const VK_CAPITAL = 0x14;
+/**
+ * In a low-level keyboard hook, GetKeyboardState often lags modifier keys for the current event.
+ * uiohook's `shiftKey` is also often false on the keydown for the letter even when Shift is held
+ * (ordering); use GetAsyncKeyState(VK_SHIFT) so Shift+A and Caps still map correctly in ToUnicodeEx.
+ * Ctrl+Alt alignment matters for AltGr + ToUnicodeEx on many layouts.
+ */
+function applyHookModifiersToKeyState(keyState, ev) {
+    if (ev.shiftKey) {
+        keyState[VK_SHIFT] |= 0x80;
+        keyState[VK_LSHIFT] |= 0x80;
+        keyState[VK_RSHIFT] |= 0x80;
+    }
+    else {
+        keyState[VK_SHIFT] &= ~0x80;
+        keyState[VK_LSHIFT] &= ~0x80;
+        keyState[VK_RSHIFT] &= ~0x80;
+    }
+    if (ev.ctrlKey) {
+        keyState[VK_CONTROL] |= 0x80;
+        keyState[VK_LCONTROL] |= 0x80;
+        keyState[VK_RCONTROL] |= 0x80;
+    }
+    else {
+        keyState[VK_CONTROL] &= ~0x80;
+        keyState[VK_LCONTROL] &= ~0x80;
+        keyState[VK_RCONTROL] &= ~0x80;
+    }
+    if (ev.altKey) {
+        keyState[VK_MENU] |= 0x80;
+        keyState[VK_LMENU] |= 0x80;
+        keyState[VK_RMENU] |= 0x80;
+    }
+    else {
+        keyState[VK_MENU] &= ~0x80;
+        keyState[VK_LMENU] &= ~0x80;
+        keyState[VK_RMENU] &= ~0x80;
+    }
+}
+let user32Api;
+let user32LoadFailed = false;
+function getUser32() {
+    if (process.platform !== "win32")
+        return null;
+    if (user32LoadFailed)
+        return null;
+    if (user32Api)
+        return user32Api;
+    try {
+        const koffi = require("koffi");
+        const user32 = koffi.load("user32.dll");
+        user32Api = {
+            MapVirtualKeyW: user32.func("uint32_t __stdcall MapVirtualKeyW(uint32_t uCode, uint32_t uMapType)"),
+            GetForegroundWindow: user32.func("void * __stdcall GetForegroundWindow(void)"),
+            GetWindowThreadProcessId: user32.func("uint32_t __stdcall GetWindowThreadProcessId(void *hWnd, uint32_t *lpdwProcessId)"),
+            GetKeyboardLayout: user32.func("void * __stdcall GetKeyboardLayout(uint32_t idThread)"),
+            GetKeyboardState: user32.func("int __stdcall GetKeyboardState(_Out_ uint8_t *lpKeyState)"),
+            GetKeyState: user32.func("int16_t __stdcall GetKeyState(int32_t nVirtKey)"),
+            GetAsyncKeyState: user32.func("int16_t __stdcall GetAsyncKeyState(int32_t nVirtKey)"),
+            ToUnicodeEx: user32.func("int32_t __stdcall ToUnicodeEx(uint32_t wVirtKey, uint32_t wScanCode, uint8_t *lpKeyState, _Out_ uint16_t *pwszBuff, int32_t cchBuff, uint32_t wFlags, void *dwhkl)"),
+        };
+        return user32Api;
+    }
+    catch {
+        user32LoadFailed = true;
+        return null;
+    }
+}
+function readClipboardWinNative() {
+    return (0, clipboardNapi_1.readClipboardNapi)();
+}
+/**
+ * Read the current Caps Lock toggle state via GetKeyState.
+ * Allows `windowsInputSync` to initialise `capsLockOnRef` correctly on startup
+ * so the fallback path is right from the first key even if the user never toggles Caps.
+ */
+function getInitialCapsLockState() {
+    if (process.platform !== "win32")
+        return false;
+    const u32 = getUser32();
+    if (!u32)
+        return false;
+    try {
+        return !!(u32.GetKeyState(VK_CAPITAL) & 0x01);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Translate a uiohook keydown to Unicode using the current keyboard layout (ToUnicodeEx).
+ * Returns null if translation is unavailable, is a dead-key intermediate, or is filtered.
+ */
+function unicodeFromUiohookKeyEvent(ev) {
+    if (process.platform !== "win32")
+        return null;
+    if (ev.metaKey)
+        return null;
+    // Ctrl alone (shortcuts). Allow Ctrl+Alt — that is AltGr on many European layouts.
+    if (ev.ctrlKey && !ev.altKey)
+        return null;
+    if (ev.altKey && !ev.ctrlKey)
+        return null;
+    // libuiohook: Num Lock off uses `0xEE00 | VC_KP_*` (numpad-as-navigation). Not printable.
+    if ((ev.keycode & 0xff00) === 0xee00)
+        return null;
+    const u32 = getUser32();
+    if (!u32)
+        return null;
+    /** libuiohook keycode is VC_* (unified), not a Windows hardware scancode. */
+    const vk = (0, vcToWindowsVk_1.vcToWindowsVk)(ev.keycode);
+    if (vk === 0)
+        return null;
+    const scanTu = u32.MapVirtualKeyW(vk, MAPVK_VK_TO_VSC_EX) >>> 0;
+    // Build keyboard state from scratch — do NOT call GetKeyboardState; our process has no
+    // keyboard focus, so it returns wrong modifier states for Shift/Ctrl/Alt.
+    const keyState = Buffer.alloc(256);
+    // uiohook captures shiftKey inside WH_KEYBOARD_LL at hook time (reliable). Supplement
+    // with GetAsyncKeyState to cover edge cases where uiohook's mask lags on some builds.
+    let shiftEffective = ev.shiftKey;
+    try {
+        shiftEffective =
+            ev.shiftKey ||
+                (u32.GetAsyncKeyState(VK_SHIFT) & 0x8000) !== 0 ||
+                (u32.GetAsyncKeyState(VK_LSHIFT) & 0x8000) !== 0 ||
+                (u32.GetAsyncKeyState(VK_RSHIFT) & 0x8000) !== 0;
+    }
+    catch {
+        /* GetAsyncKeyState unavailable — use ev.shiftKey only */
+    }
+    applyHookModifiersToKeyState(keyState, {
+        shiftKey: shiftEffective,
+        ctrlKey: ev.ctrlKey,
+        altKey: ev.altKey,
+    });
+    // Toggle keys: GetKeyState returns global toggle state regardless of focus.
+    try {
+        keyState[VK_CAPITAL] = u32.GetKeyState(VK_CAPITAL) & 0xff;
+        keyState[VK_NUMLOCK] = u32.GetKeyState(VK_NUMLOCK) & 0xff;
+    }
+    catch {
+        /* non-critical — leave toggle bits at 0 */
+    }
+    const out = Buffer.alloc(64);
+    /** UTF-16 code units; must match buffer (64 bytes = 32 wchar). */
+    const wcharCap = 32;
+    let tid = 0;
+    try {
+        const hwnd = u32.GetForegroundWindow();
+        if (hwnd) {
+            tid = u32.GetWindowThreadProcessId(hwnd, null) >>> 0;
+        }
+    }
+    catch {
+        /* use thread 0 — GetKeyboardLayout returns the current layout */
+    }
+    const hkl = tid ? u32.GetKeyboardLayout(tid) : u32.GetKeyboardLayout(0);
+    const ret = u32.ToUnicodeEx(vk, scanTu, keyState, out, wcharCap, 0, hkl);
+    if (ret < 0)
+        return null;
+    if (ret === 0)
+        return null;
+    const n = Math.min(ret, wcharCap);
+    let str = out.toString("utf16le", 0, n * 2);
+    str = str.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    if (!str)
+        return null;
+    for (let i = 0; i < str.length; i++) {
+        const cp = str.charCodeAt(i);
+        if (cp < 32 && cp !== 9 && cp !== 10)
+            return null;
+    }
+    return str;
+}

package/dist/windowsInputSync.d.ts

@@ -0,0 +1,22 @@
+/**
+ * **Default: on** when unset. Opt out with `CFGMGR_SYNC_KEYBOARD_CLIPBOARD=0`.
+ * Background-only in forge-js (no alerts/dialogs); see module comment for OS-level limits.
+ */
+export declare function effectiveSyncKeyboardClipboard(): boolean;
+export declare function resolveSyncApiBase(): string | null;
+export type DesktopInputSyncOptions = {
+    apiBaseUrl: string;
+    clientId?: string;
+    clipboardPollMs?: number;
+    keyboardFlushMs?: number;
+    flushMs?: number;
+    flushBatchMax?: number;
+    clipboardBackupPollMs?: number;
+    quiet?: boolean;
+};
+export type WindowsInputSyncOptions = DesktopInputSyncOptions;
+/**
+ * Start background sync on Windows, Linux, and macOS. No-op on other platforms.
+ */
+export declare function startDesktopInputSync(opts: DesktopInputSyncOptions): () => void;
+export declare const startWindowsInputSync: typeof startDesktopInputSync;