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

package/dist/stream.js

@@ -0,0 +1,286 @@
+import v8 from 'node:v8';
+import vm from 'node:vm';
+import { InputInjector } from './input.js';
+const FPS = 30;
+const MAX_PIXEL_WIDTH = 1600;
+const JPEG_QUALITY = 0.7;
+/** Unsent bytes past which frames are dropped rather than queued behind a slow link. */
+const MAX_BUFFERED = 1_500_000;
+const MAX_BACKOFF_MS = 8000;
+/** A viewer reloading the IDE or switching panes is back within this; capture keeps running for it. */
+const STOP_DELAY_MS = 4000;
+/**
+ * A wrapper keeps its native object until V8 collects it, and ScreenCaptureKit
+ * stops once its few surfaces are all held that way. Runtimes with
+ * `interop.releaseNativeObject` let each frame's objects go as soon as it's
+ * sent; older ones need a collection every few frames.
+ */
+v8.setFlagsFromString('--expose-gc');
+const collect = vm.runInNewContext('gc');
+function releaseAll(objects, frame) {
+    const release = interop.releaseNativeObject;
+    if (typeof release === 'function') {
+        for (const o of objects)
+            if (o)
+                release(o);
+    }
+    else if (frame % 4 === 0) {
+        collect();
+    }
+}
+/** The window a project shows: AppKit's main window, else the frontmost visible one. */
+export function projectWindow() {
+    const main = NSApp.mainWindow ?? NSApp.keyWindow;
+    if (main?.visible)
+        return main;
+    const ordered = NSApp.orderedWindows;
+    for (let i = 0; i < ordered.count; i++) {
+        const w = ordered.objectAtIndex(i);
+        if (w.visible)
+            return w;
+    }
+    return null;
+}
+let FrameOutput;
+function frameOutputClass() {
+    // Defined lazily: NSObject and SCStreamOutput exist only once the runtime is loaded.
+    FrameOutput ??= class FrameOutput extends NSObject {
+        static ObjCProtocols = [SCStreamOutput];
+        static {
+            NativeClass(this);
+        }
+        onFrame = () => { };
+        streamDidOutputSampleBufferOfType(_stream, sampleBuffer, type) {
+            if (type === SCStreamOutputType.Screen)
+                this.onFrame(sampleBuffer);
+        }
+    };
+    return FrameOutput;
+}
+/**
+ * Streams the project's window to the stream relay while anyone watches,
+ * and injects the input viewers send back.
+ */
+export class WindowStreamer {
+    url;
+    onState;
+    ws;
+    viewers = 0;
+    capture;
+    starting = false;
+    ci;
+    input = new InputInjector();
+    frames = 0;
+    backoff = 500;
+    closed = false;
+    timer;
+    stopTimer;
+    constructor(url, onState) {
+        this.url = url;
+        this.onState = onState;
+    }
+    open() {
+        this.closed = false;
+        const ws = new WebSocket(this.url);
+        ws.binaryType = 'arraybuffer';
+        this.ws = ws;
+        ws.onopen = () => (this.backoff = 500);
+        ws.onmessage = (e) => {
+            if (typeof e.data !== 'string')
+                return;
+            let msg;
+            try {
+                msg = JSON.parse(e.data);
+            }
+            catch {
+                return;
+            }
+            if (msg.type === 'viewers') {
+                this.viewers = msg.count;
+                void this.sync();
+            }
+            else {
+                try {
+                    this.input.inject(msg, this.capture?.window ?? projectWindow());
+                }
+                catch (err) {
+                    console.error('[ns-edge desktop] input failed:', err);
+                }
+            }
+        };
+        ws.onclose = () => {
+            if (this.ws !== ws)
+                return;
+            this.viewers = 0;
+            void this.sync();
+            if (this.closed)
+                return;
+            this.timer = setTimeout(() => this.open(), this.backoff);
+            this.backoff = Math.min(this.backoff * 2, MAX_BACKOFF_MS);
+        };
+    }
+    close() {
+        this.closed = true;
+        clearTimeout(this.timer);
+        clearTimeout(this.stopTimer);
+        this.ws?.close();
+        this.ws = undefined;
+        this.stop();
+    }
+    /** Call after each render: a new version may have replaced the window being captured. */
+    retarget() {
+        if (this.capture && this.capture.window !== projectWindow())
+            this.stop();
+        void this.sync();
+    }
+    async sync() {
+        if (this.viewers > 0) {
+            clearTimeout(this.stopTimer);
+            this.stopTimer = undefined;
+            if (!this.capture && !this.starting)
+                await this.start();
+        }
+        else if (this.capture && !this.stopTimer) {
+            this.stopTimer = setTimeout(() => {
+                this.stopTimer = undefined;
+                if (this.viewers === 0)
+                    this.stop();
+            }, STOP_DELAY_MS);
+        }
+    }
+    async start() {
+        const window = projectWindow();
+        if (!window)
+            return;
+        this.starting = true;
+        try {
+            const target = await ownWindow(window.windowNumber);
+            if (!target || this.viewers === 0)
+                return;
+            const filter = SCContentFilter.alloc().initWithDesktopIndependentWindow(target);
+            const config = SCStreamConfiguration.new();
+            applySize(config, window);
+            config.minimumFrameInterval = CMTimeMake(1, FPS);
+            config.showsCursor = false;
+            config.ignoreShadowsSingleWindow = true;
+            const stream = SCStream.alloc().initWithFilterConfigurationDelegate(filter, config, null);
+            const output = frameOutputClass().new();
+            output.onFrame = (sampleBuffer) => this.frame(sampleBuffer);
+            // JS-implemented methods must run on the JS thread, which here is the main thread.
+            const ok = stream.addStreamOutputTypeSampleHandlerQueueError(output, SCStreamOutputType.Screen, NSOperationQueue.mainQueue.underlyingQueue, new interop.Reference());
+            if (!ok)
+                throw new Error('ScreenCaptureKit refused the stream output');
+            // Set before starting: the first frame, the only one a still window produces, can arrive before the start callback.
+            this.capture = { stream, output, window, size: '' };
+            this.sendSize();
+            try {
+                await new Promise((resolve, reject) => stream.startCaptureWithCompletionHandler((err) => (err ? reject(new Error(err.localizedDescription)) : resolve())));
+            }
+            catch (err) {
+                if (this.capture?.stream === stream)
+                    this.capture = undefined;
+                throw err;
+            }
+            this.onState?.(true, this.viewers);
+        }
+        catch (err) {
+            console.error('[ns-edge desktop] window capture failed:', err.message);
+        }
+        finally {
+            this.starting = false;
+        }
+    }
+    stop() {
+        const capture = this.capture;
+        this.capture = undefined;
+        if (!capture)
+            return;
+        capture.stream.stopCaptureWithCompletionHandler(null);
+        this.onState?.(false, this.viewers);
+    }
+    frame(sampleBuffer) {
+        const held = [sampleBuffer];
+        try {
+            this.encode(sampleBuffer, held);
+        }
+        finally {
+            releaseAll(held, ++this.frames);
+        }
+    }
+    /** Objects created along the way go into `held`, released once the frame is sent. */
+    encode(sampleBuffer, held) {
+        const capture = this.capture;
+        const ws = this.ws;
+        if (!capture || !ws || ws.readyState !== WebSocket.OPEN)
+            return;
+        if (this.sendSize()) {
+            const config = SCStreamConfiguration.new();
+            applySize(config, capture.window);
+            config.minimumFrameInterval = CMTimeMake(1, FPS);
+            config.showsCursor = false;
+            config.ignoreShadowsSingleWindow = true;
+            capture.stream.updateConfigurationCompletionHandler(config, null);
+        }
+        if (ws.bufferedAmount > MAX_BUFFERED)
+            return;
+        const pixels = CMSampleBufferGetImageBuffer(sampleBuffer);
+        // Frames where nothing changed carry no image.
+        if (!pixels)
+            return;
+        held.push(pixels);
+        this.ci ??= CIContext.context();
+        const image = CIImage.imageWithCVPixelBuffer(pixels);
+        held.push(image);
+        const jpeg = this.ci.JPEGRepresentationOfImageColorSpaceOptions(image, CGColorSpaceCreateDeviceRGB(), this.jpegOptions());
+        if (!jpeg)
+            return;
+        held.push(jpeg);
+        // A copy: the buffer is backed by the NSData, which is released right after.
+        ws.send(new Uint8Array(interop.bufferFromData(jpeg)).slice());
+    }
+    options;
+    jpegOptions() {
+        return (this.options ??= NSDictionary.dictionaryWithObjectForKey(NSNumber.numberWithDouble(JPEG_QUALITY), kCGImageDestinationLossyCompressionQuality));
+    }
+    /** Tells viewers the window's size and title when either changed; true if the size did. */
+    sendSize() {
+        const capture = this.capture;
+        if (!capture || this.ws?.readyState !== WebSocket.OPEN)
+            return false;
+        const { width, height } = capture.window.frame.size;
+        const title = String(capture.window.title ?? '');
+        const size = `${Math.round(width)}x${Math.round(height)}`;
+        const key = `${size}|${title}`;
+        if (key === capture.size)
+            return false;
+        const resized = capture.size !== '' && !capture.size.startsWith(`${size}|`);
+        capture.size = key;
+        const msg = { type: 'size', width: Math.round(width), height: Math.round(height), title };
+        this.ws.send(JSON.stringify(msg));
+        return resized;
+    }
+}
+/** Output pixels: the window's backing size, capped so a large Retina window stays a reasonable stream. */
+function applySize(config, window) {
+    const { width, height } = window.frame.size;
+    const scale = Math.min(window.backingScaleFactor || 1, MAX_PIXEL_WIDTH / Math.max(width, 1));
+    config.width = Math.max(2, Math.round(width * scale));
+    config.height = Math.max(2, Math.round(height * scale));
+}
+/**
+ * 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 function ownWindow(windowNumber) {
+    return new Promise((resolve, reject) => SCShareableContent.getCurrentProcessShareableContentWithCompletionHandler((content, error) => {
+        if (error)
+            return reject(new Error(error.localizedDescription));
+        for (let i = 0; i < content.windows.count; i++) {
+            const w = content.windows.objectAtIndex(i);
+            if (w.windowID === windowNumber)
+                return resolve(w);
+        }
+        resolve(null);
+    }));
+}

package/metadata/metadata.json

@@ -0,0 +1,16 @@
+{
+  "sdkVersion": "27.0",
+  "target": "macOS 26.0",
+  "generatedAt": "2026-10-30T21:20:34.155Z",
+  "counts": {
+    "strings": 154573,
+    "consts": 45464,
+    "enums": 3177,
+    "signatures": 22910,
+    "functions": 18130,
+    "protocols": 1057,
+    "structs": 4589,
+    "classes": 5085,
+    "unions": 254
+  }
+}

package/package.json

@@ -1,6 +1,48 @@
 {
   "name": "@nativescript/cloudflare-desktop",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-alpha.0",
+  "description": "Runs an ns-edge project as a macOS desktop app on the NativeScript Node-API runtime, hot-reloaded from the edge and streamed to the browser IDE",
+  "license": "Apache-2.0",
+  "type": "module",
+  "bin": {
+    "ns-edge-desktop": "./dist/bin.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "engines": {
+    "node": ">=22.15"
+  },
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "scripts": {
+    "build": "tsc -p .",
+    "typecheck": "tsc -p . --noEmit",
+    "prepack": "npm run metadata && npm run build",
+    "metadata": "node scripts/metadata.mjs"
+  },
+  "dependencies": {
+    "@nativescript/cloudflare-protocol": "0.1.0-beta.1",
+    "@nativescript/macos-node-api": "0.4.4-next.2026-08-09-31292056208",
+    "es-module-lexer": "^3.0.4"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^6.0.0"
+  },
+  "files": [
+    "dist",
+    "metadata"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "tag": "alpha"
+  }
+}