@nativescript/cloudflare-desktop 0.0.0-stage → 0.1.0-alpha.1

package/dist/input.js

@@ -0,0 +1,162 @@
+import { Modifier } from '@nativescript/cloudflare-protocol';
+/** A press with no release after this long is released where the pointer last was. */
+const GESTURE_TIMEOUT_MS = 5000;
+/** Drag points kept per gesture; enough to replay a drag's path, not every pixel of it. */
+const MAX_DRAG_EVENTS = 120;
+/**
+ * Turns viewer input into AppKit events for one window. Events go through
+ * the app's own queue (`postEvent`), the only path that drives controls'
+ * tracking loops; a direct `sendEvent` or `mouseDown` never presses an
+ * NSButton. Nothing reaches other apps, the real cursor never moves, and no
+ * Accessibility permission is involved.
+ *
+ * A press is held back until its release arrives, then the whole gesture is
+ * posted at once: a control's tracking loop runs synchronously on this
+ * thread from the press until the release, so a release still waiting in a
+ * socket message would never be read. Drags therefore show up when the
+ * pointer is released, and press-and-hold isn't possible.
+ */
+export class InputInjector {
+    pressed = new Set();
+    eventNumber = 0;
+    lastDown = { at: 0, x: 0, y: 0, count: 0 };
+    gesture = null;
+    gestureTimer;
+    lastPointer;
+    inject(input, window) {
+        if (!window)
+            return;
+        // Controls ignore clicks in a window that isn't key, and the host usually
+        // runs behind the developer's other apps. Making the window key doesn't
+        // activate the app, so the developer's own focus stays where it is.
+        if (input.type !== 'wheel' && input.kind === 'down' && NSApp.keyWindow !== window)
+            window.makeKeyWindow();
+        switch (input.type) {
+            case 'pointer':
+                return this.pointer(input, window);
+            case 'wheel':
+                return this.wheel(input, window);
+            case 'key':
+                return this.key(input, window);
+        }
+    }
+    pointer(input, window) {
+        const point = windowPoint(window, input.x, input.y);
+        const flags = modifierFlags(input.modifiers);
+        if (input.kind === 'down')
+            this.pressed.add(input.button);
+        if (input.kind === 'up')
+            this.pressed.delete(input.button);
+        let type;
+        let clickCount = 1;
+        if (input.kind === 'move') {
+            type = this.pressed.has(0) ? NSEventType.LeftMouseDragged : this.pressed.has(2) ? NSEventType.RightMouseDragged : NSEventType.MouseMoved;
+            clickCount = 0;
+        }
+        else {
+            const down = input.kind === 'down';
+            type = input.button === 2 ? (down ? NSEventType.RightMouseDown : NSEventType.RightMouseUp) : down ? NSEventType.LeftMouseDown : NSEventType.LeftMouseUp;
+            clickCount = this.clickCount(down, point);
+        }
+        const event = NSEvent.mouseEventWithTypeLocationModifierFlagsTimestampWindowNumberContextEventNumberClickCountPressure(type, point, flags, uptime(), window.windowNumber, null, this.eventNumber++, clickCount, input.kind === 'down' ? 1 : 0);
+        this.lastPointer = { input, window };
+        if (input.kind === 'down' && !this.gesture) {
+            this.gesture = [event];
+            this.gestureTimer = setTimeout(() => this.release(), GESTURE_TIMEOUT_MS);
+        }
+        else if (this.gesture) {
+            if (input.kind === 'move' && this.gesture.length >= MAX_DRAG_EVENTS)
+                this.gesture.splice(1, 1);
+            this.gesture.push(event);
+            if (input.kind === 'up' && this.pressed.size === 0)
+                this.flush();
+        }
+        else {
+            NSApp.postEventAtStart(event, false);
+        }
+    }
+    flush() {
+        clearTimeout(this.gestureTimer);
+        const events = this.gesture ?? [];
+        this.gesture = null;
+        for (const e of events)
+            NSApp.postEventAtStart(e, false);
+    }
+    /** Ends a gesture whose release never came (the viewer left mid-drag). */
+    release() {
+        const last = this.lastPointer;
+        if (!this.gesture || !last)
+            return this.flush();
+        for (const button of [...this.pressed])
+            this.pointer({ ...last.input, kind: 'up', button }, last.window);
+        this.flush();
+    }
+    /** Double and triple clicks: AppKit reads the count from each event rather than inferring it. */
+    clickCount(down, point) {
+        if (!down)
+            return this.lastDown.count;
+        const now = Date.now();
+        const near = Math.abs(point.x - this.lastDown.x) < 4 && Math.abs(point.y - this.lastDown.y) < 4;
+        const count = near && now - this.lastDown.at < 400 ? this.lastDown.count + 1 : 1;
+        this.lastDown = { at: now, x: point.x, y: point.y, count };
+        return count;
+    }
+    wheel(input, window) {
+        const point = windowPoint(window, input.x, input.y);
+        // NSEvent has no public scroll-wheel constructor; build a CGEvent and wrap it.
+        const cg = CGEventCreateScrollWheelEvent2(null, 0 /* pixels */, 2, Math.round(-input.dy), Math.round(-input.dx), 0);
+        if (!cg)
+            return;
+        const screen = window.convertPointToScreen(point);
+        const mainHeight = NSScreen.screens.objectAtIndex(0).frame.size.height;
+        CGEventSetLocation(cg, { x: screen.x, y: mainHeight - screen.y });
+        CGEventSetIntegerValueField(cg, 91 /* kCGMouseEventWindowUnderMousePointer */, window.windowNumber);
+        CGEventSetIntegerValueField(cg, 92 /* kCGMouseEventWindowUnderMousePointerThatCanHandleThisEvent */, window.windowNumber);
+        const event = NSEvent.eventWithCGEvent(cg);
+        if (event)
+            NSApp.postEventAtStart(event, false);
+    }
+    key(input, window) {
+        const mapped = KEYS[input.code];
+        if (!mapped)
+            return;
+        const [keyCode, base] = mapped;
+        const printable = input.key.length === 1;
+        const characters = printable ? input.key : (SPECIAL_CHARS[input.code] ?? base);
+        const event = NSEvent.keyEventWithTypeLocationModifierFlagsTimestampWindowNumberContextCharactersCharactersIgnoringModifiersIsARepeatKeyCode(input.kind === 'down' ? NSEventType.KeyDown : NSEventType.KeyUp, { x: 0, y: 0 }, modifierFlags(input.modifiers), uptime(), window.windowNumber, null, characters, SPECIAL_CHARS[input.code] ?? base, input.repeat, keyCode);
+        NSApp.postEventAtStart(event, false);
+    }
+}
+/** A frame fraction (0..1 from the top-left, title bar included) as a point in the window's base coordinates. */
+function windowPoint(window, x, y) {
+    const { width, height } = window.frame.size;
+    return { x: clamp(x) * width, y: (1 - clamp(y)) * height };
+}
+const clamp = (v) => (Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : 0);
+const uptime = () => NSProcessInfo.processInfo.systemUptime;
+function modifierFlags(m) {
+    return (m & Modifier.shift ? 1 << 17 : 0) | (m & Modifier.ctrl ? 1 << 18 : 0) | (m & Modifier.alt ? 1 << 19 : 0) | (m & Modifier.meta ? 1 << 20 : 0);
+}
+/** DOM `KeyboardEvent.code` → [macOS virtual key code, character without modifiers] (ANSI layout). */
+const KEYS = {
+    KeyA: [0, 'a'], KeyS: [1, 's'], KeyD: [2, 'd'], KeyF: [3, 'f'], KeyH: [4, 'h'], KeyG: [5, 'g'], KeyZ: [6, 'z'], KeyX: [7, 'x'],
+    KeyC: [8, 'c'], KeyV: [9, 'v'], KeyB: [11, 'b'], KeyQ: [12, 'q'], KeyW: [13, 'w'], KeyE: [14, 'e'], KeyR: [15, 'r'], KeyY: [16, 'y'],
+    KeyT: [17, 't'], Digit1: [18, '1'], Digit2: [19, '2'], Digit3: [20, '3'], Digit4: [21, '4'], Digit6: [22, '6'], Digit5: [23, '5'],
+    Equal: [24, '='], Digit9: [25, '9'], Digit7: [26, '7'], Minus: [27, '-'], Digit8: [28, '8'], Digit0: [29, '0'], BracketRight: [30, ']'],
+    KeyO: [31, 'o'], KeyU: [32, 'u'], BracketLeft: [33, '['], KeyI: [34, 'i'], KeyP: [35, 'p'], Enter: [36, '\r'], KeyL: [37, 'l'],
+    KeyJ: [38, 'j'], Quote: [39, "'"], KeyK: [40, 'k'], Semicolon: [41, ';'], Backslash: [42, '\\'], Comma: [43, ','], Slash: [44, '/'],
+    KeyN: [45, 'n'], KeyM: [46, 'm'], Period: [47, '.'], Tab: [48, '\t'], Space: [49, ' '], Backquote: [50, '`'], Backspace: [51, '\x7f'],
+    Escape: [53, '\x1b'], NumpadEnter: [76, '\x03'],
+    F1: [122, ''], F2: [120, ''], F3: [99, ''], F4: [118, ''], F5: [96, ''], F6: [97, ''], F7: [98, ''], F8: [100, ''], F9: [101, ''],
+    F10: [109, ''], F11: [103, ''], F12: [111, ''],
+    Home: [115, ''], PageUp: [116, ''], Delete: [117, ''], End: [119, ''], PageDown: [121, ''],
+    ArrowLeft: [123, ''], ArrowRight: [124, ''], ArrowDown: [125, ''], ArrowUp: [126, ''],
+};
+/** AppKit's private-use function-key characters (NSUpArrowFunctionKey and friends). */
+const SPECIAL_CHARS = {
+    Enter: '\r', Tab: '\t', Backspace: '\x7f', Escape: '\x1b',
+    ArrowUp: '', ArrowDown: '', ArrowLeft: '', ArrowRight: '',
+    F1: '', F2: '', F3: '', F4: '', F5: '', F6: '', F7: '', F8: '', F9: '',
+    F10: '', F11: '', F12: '',
+    Delete: '', Home: '', End: '', PageUp: '', PageDown: '',
+};

package/dist/loader.d.ts

@@ -0,0 +1,3 @@
+export declare function installLoader(): void;
+/** Fetches every module reachable from `entry` that isn't cached yet; resolves to how many were fetched. */
+export declare function prefetch(entry: string): Promise<number>;

package/dist/loader.js

@@ -0,0 +1,66 @@
+import { registerHooks } from 'node:module';
+import { init, parse } from 'es-module-lexer';
+/**
+ * Remote ES modules for Node. Node's sync loader hooks can't fetch, so an
+ * async walk of the module graph fills this cache first and the hooks serve
+ * from it. Edge module URLs are versioned and immutable: a cached URL never
+ * needs fetching again.
+ */
+const sources = new Map();
+let installed = false;
+const isRemote = (u) => u.startsWith('http://') || u.startsWith('https://');
+const isRelative = (s) => s.startsWith('/') || s.startsWith('./') || s.startsWith('../');
+export function installLoader() {
+    if (installed)
+        return;
+    installed = true;
+    registerHooks({
+        resolve(specifier, context, next) {
+            if (isRemote(specifier))
+                return { url: specifier, format: 'module', shortCircuit: true };
+            if (context.parentURL && isRemote(context.parentURL) && isRelative(specifier)) {
+                return { url: new URL(specifier, context.parentURL).href, format: 'module', shortCircuit: true };
+            }
+            return next(specifier, context);
+        },
+        load(url, context, next) {
+            if (!isRemote(url))
+                return next(url, context);
+            const source = sources.get(url);
+            if (source === undefined)
+                throw new Error(`${url} was imported before it was fetched`);
+            return { format: 'module', source, shortCircuit: true };
+        },
+    });
+}
+/** Fetches every module reachable from `entry` that isn't cached yet; resolves to how many were fetched. */
+export async function prefetch(entry) {
+    await init;
+    const pending = new Map();
+    let fetched = 0;
+    const visit = (url) => {
+        if (sources.has(url))
+            return Promise.resolve();
+        let p = pending.get(url);
+        if (p)
+            return p;
+        p = (async () => {
+            const res = await fetch(url);
+            const source = await res.text();
+            // The edge answers a stale or broken module with a module that throws, so its message reaches the console.
+            if (!res.ok && !source.startsWith('throw '))
+                throw new Error(`${url}: HTTP ${res.status}`);
+            sources.set(url, source);
+            fetched++;
+            const [imports] = parse(source);
+            await Promise.all(imports
+                .map((i) => i.specifier)
+                .filter((s) => !!s && (isRemote(s) || isRelative(s)))
+                .map((s) => visit(new URL(s, url).href)));
+        })();
+        pending.set(url, p);
+        return p;
+    };
+    await visit(entry);
+    return fetched;
+}

package/dist/rpc.d.ts

@@ -0,0 +1,2 @@
+import type { RpcCall } from '@nativescript/cloudflare-protocol';
+export declare function handleRpc(call: RpcCall, allowEval: boolean): Promise<unknown>;

package/dist/rpc.js

@@ -0,0 +1,85 @@
+import { toJsonSafe } from './serialize.js';
+import { ownWindow, projectWindow } from './stream.js';
+const AsyncFunction = Object.getPrototypeOf(async () => { }).constructor;
+export async function handleRpc(call, allowEval) {
+    const window = projectWindow();
+    switch (call.method) {
+        case 'eval': {
+            if (!allowEval)
+                throw new Error('eval is off on this Mac. The developer can restart the host with --allow-eval to allow it.');
+            const fn = new AsyncFunction('window', call.code);
+            return toJsonSafe(await fn(window));
+        }
+        case 'screenshot':
+            if (!window)
+                throw new Error('The project has no visible window');
+            return (await capturedScreenshot(window, call.maxWidth).catch(() => null)) ?? screenshot(window);
+        case 'viewTree':
+            if (!window)
+                throw new Error('The project has no visible window');
+            return viewTree(window.contentView.superview ?? window.contentView, call.depth);
+    }
+}
+/**
+ * The window as composited, through ScreenCaptureKit: Chromium's page,
+ * Liquid Glass and Metal content included.
+ */
+async function capturedScreenshot(window, maxWidth) {
+    const target = await ownWindow(window.windowNumber);
+    if (!target)
+        return null;
+    const filter = SCContentFilter.alloc().initWithDesktopIndependentWindow(target);
+    const config = SCStreamConfiguration.new();
+    const { width, height } = window.frame.size;
+    const scale = Math.min(window.backingScaleFactor || 1, maxWidth / Math.max(width, 1));
+    config.width = Math.max(2, Math.round(width * scale));
+    config.height = Math.max(2, Math.round(height * scale));
+    config.showsCursor = false;
+    config.ignoreShadowsSingleWindow = true;
+    const image = await new Promise((resolve, reject) => SCScreenshotManager.captureImageWithFilterConfigurationCompletionHandler(filter, config, (cg, error) => error ? reject(new Error(error.localizedDescription)) : resolve(cg)));
+    const rep = NSBitmapImageRep.alloc().initWithCGImage(image);
+    const png = rep.representationUsingTypeProperties(NSBitmapImageFileType.PNG, NSDictionary.dictionary());
+    return { png: png.base64EncodedStringWithOptions(0), width: rep.pixelsWide, height: rep.pixelsHigh };
+}
+/**
+ * Draws the window's view hierarchy into a bitmap, title bar included. Needs
+ * no Screen Recording permission, but layers AppKit doesn't draw itself
+ * (Metal, some visual effects) come out blank.
+ */
+function screenshot(window) {
+    const view = window.contentView.superview ?? window.contentView;
+    const rep = view.bitmapImageRepForCachingDisplayInRect(view.bounds);
+    view.cacheDisplayInRectToBitmapImageRep(view.bounds, rep);
+    const width = rep.pixelsWide;
+    const height = rep.pixelsHigh;
+    const png = rep.representationUsingTypeProperties(NSBitmapImageFileType.PNG, NSDictionary.dictionary());
+    return { png: png.base64EncodedStringWithOptions(0), width, height };
+}
+function viewTree(view, depth) {
+    const { width, height } = view.frame.size;
+    const node = { type: String(view.className), size: `${Math.round(width)}x${Math.round(height)}`, visible: !view.hidden };
+    if (view.identifier)
+        node.id = String(view.identifier);
+    const text = textOf(view);
+    if (text)
+        node.text = text.slice(0, 120);
+    if (depth > 0) {
+        const subviews = view.subviews;
+        const children = [];
+        for (let i = 0; i < subviews.count; i++)
+            children.push(viewTree(subviews.objectAtIndex(i), depth - 1));
+        if (children.length)
+            node.children = children;
+    }
+    return node;
+}
+function textOf(view) {
+    for (const selector of ['stringValue', 'title']) {
+        if (view.respondsToSelector(selector)) {
+            const value = view[selector];
+            if (typeof value === 'string' && value)
+                return value;
+        }
+    }
+    return undefined;
+}

package/dist/runtime.d.ts

@@ -0,0 +1,9 @@
+export interface RuntimeOptions {
+    /** A NativeScript.framework binary to load instead of the npm package's. */
+    runtime?: string;
+    /** Metadata (.nsmd) generated from this Mac's SDK. The npm package's built-in metadata lacks ScreenCaptureKit's SCStream. */
+    metadata?: string;
+}
+/** Loads the NativeScript macOS Node-API runtime into this process; every Objective-C API becomes a global. */
+export declare function loadRuntime(options?: RuntimeOptions): Promise<void>;
+export declare function runtimeVersion(): string;

package/dist/runtime.js

@@ -0,0 +1,38 @@
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+const FRAMEWORKS = ['AppKit', 'ScreenCaptureKit', 'CoreMedia', 'CoreVideo', 'CoreImage'];
+/** Loads the NativeScript macOS Node-API runtime into this process; every Objective-C API becomes a global. */
+export async function loadRuntime(options = {}) {
+    options = { ...options, metadata: options.metadata ?? bundledMetadata() };
+    if (options.metadata && !fs.existsSync(options.metadata))
+        throw new Error(`No metadata at ${options.metadata}`);
+    if (options.runtime) {
+        const addon = { exports: {} };
+        process.dlopen(addon, options.runtime);
+        addon.exports.init(options.metadata);
+    }
+    else {
+        if (options.metadata)
+            process.env.METADATA_PATH = options.metadata;
+        await import('@nativescript/macos-node-api');
+    }
+    for (const f of FRAMEWORKS)
+        objc.import(f);
+    // Objects read out of collections are wrapped by classes the runtime has
+    // already bound; touching these globals binds them before any stream lists windows.
+    void [SCWindow, SCRunningApplication, SCDisplay];
+}
+/** Metadata shipped in the package (see scripts/metadata.mjs), if this copy has it. */
+function bundledMetadata() {
+    const file = fileURLToPath(new URL('../metadata/metadata.macos.arm64.nsmd', import.meta.url));
+    return fs.existsSync(file) ? file : undefined;
+}
+export function runtimeVersion() {
+    try {
+        return createRequire(import.meta.url)('@nativescript/macos-node-api/package.json').version;
+    }
+    catch {
+        return 'custom';
+    }
+}

package/dist/serialize.d.ts

@@ -0,0 +1,7 @@
+/**
+ * JSON-safe snapshot of an arbitrary value. Native objects are described by
+ * their string form rather than walked, since enumerating one can run getters
+ * with side effects.
+ */
+export declare function toJsonSafe(value: unknown, depth?: number): unknown;
+export declare function formatArgs(args: unknown[]): string[];

package/dist/serialize.js

@@ -0,0 +1,42 @@
+const MAX_CHARS = 16_000;
+/**
+ * JSON-safe snapshot of an arbitrary value. Native objects are described by
+ * their string form rather than walked, since enumerating one can run getters
+ * with side effects.
+ */
+export function toJsonSafe(value, depth = 4) {
+    const seen = new WeakSet();
+    const walk = (v, d) => {
+        if (v === null || typeof v === 'boolean' || typeof v === 'number' || typeof v === 'string')
+            return v;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'bigint')
+            return v.toString();
+        if (typeof v === 'function')
+            return `[Function ${v.name || 'anonymous'}]`;
+        if (typeof v !== 'object')
+            return String(v);
+        if (seen.has(v))
+            return '[Circular]';
+        seen.add(v);
+        if (v instanceof Error)
+            return { error: v.message, stack: v.stack };
+        if (v instanceof NSObject)
+            return String(v);
+        if (d <= 0)
+            return Array.isArray(v) ? `[Array(${v.length})]` : '[Object]';
+        if (Array.isArray(v))
+            return v.slice(0, 100).map((x) => walk(x, d - 1));
+        const out = {};
+        for (const k of Object.keys(v).slice(0, 100))
+            out[k] = walk(v[k], d - 1);
+        return out;
+    };
+    const result = walk(value, depth);
+    const text = JSON.stringify(result);
+    return text && text.length > MAX_CHARS ? text.slice(0, MAX_CHARS) + '…[truncated]' : result;
+}
+export function formatArgs(args) {
+    return args.map((a) => (typeof a === 'string' ? a : JSON.stringify(toJsonSafe(a, 3)))).map((s) => (s.length > 2000 ? s.slice(0, 2000) + '…' : s));
+}

package/dist/stream.d.ts

@@ -0,0 +1,48 @@
+/** The window a project shows: AppKit's main window, else the frontmost visible one. */
+export declare function projectWindow(): any;
+/**
+ * Streams the project's window to the stream relay while anyone watches,
+ * and injects the input viewers send back.
+ */
+export declare class WindowStreamer {
+    private url;
+    private onState?;
+    private ws?;
+    private viewers;
+    private capture?;
+    private starting;
+    private ci?;
+    private input;
+    private frames;
+    private quality;
+    private budget;
+    private budgetAt;
+    private framed;
+    private backoff;
+    private closed;
+    private timer?;
+    private stopTimer?;
+    constructor(url: string, onState?: ((streaming: boolean, viewers: number) => void) | undefined);
+    open(): void;
+    close(): void;
+    /** Call after each render: a new version may have replaced the window being captured. */
+    retarget(): void;
+    private sync;
+    private start;
+    private stop;
+    private frame;
+    /** Objects created along the way go into `held`, released once the frame is sent. */
+    private encode;
+    /** Steers JPEG quality so frames stay near the size the budget allows at full frame rate. */
+    private adaptQuality;
+    private options?;
+    private jpegOptions;
+    /** Tells viewers the window's size and title when either changed; true if the size did. */
+    private sendSize;
+}
+/**
+ * This process's own windows as ScreenCaptureKit sees them. Only the
+ * current-process listing (macOS 14.4+) includes them: a bare `node` has no
+ * bundle and never appears in the general shareable-content list.
+ */
+export declare function ownWindow(windowNumber: number): Promise<any>;