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

package/dist/stream.js

@@ -0,0 +1,348 @@
+import v8 from 'node:v8';
+import vm from 'node:vm';
+import { FRAME_CHUNK_BYTES, FRAME_END, FRAME_MORE } from '@nativescript/cloudflare-protocol';
+import { InputInjector } from './input.js';
+const FPS = 30;
+const MAX_PIXEL_WIDTH = 800;
+/**
+ * Outbound budget. Cloudflare cuts a Durable Object's WebSocket (1006) once
+ * sustained inbound traffic passes roughly 7 to 11 Mbps, so the stream stays
+ * well under that: busy windows get fewer frames, never a dropped connection.
+ */
+const BYTES_PER_SECOND = 600_000;
+const TARGET_FRAME_BYTES = BYTES_PER_SECOND / FPS;
+/** JPEG quality adapts within this range to keep frames near the target size. */
+const QUALITY = { min: 0.35, max: 0.6 };
+/** Unsent bytes past which frames are dropped rather than queued behind a slow link. */
+const MAX_BUFFERED = 1_500_000;
+/** ScreenCaptureKit occasionally never completes a start; it is retried after this long without a frame. */
+const START_TIMEOUT_MS = 4000;
+const START_ATTEMPTS = 3;
+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;
+    quality = QUALITY.max;
+    budget = BYTES_PER_SECOND;
+    budgetAt = 0;
+    framed = false;
+    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 = (e) => {
+            if (process.env.NS_EDGE_DEBUG)
+                console.error(`[ns-edge desktop] stream socket closed: ${e.code} ${e.reason} (${ws.bufferedAmount} bytes unsent, ${this.frames} frames)`);
+            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(attempt = 1) {
+        const window = projectWindow();
+        if (!window)
+            return;
+        this.starting = true;
+        let retry = false;
+        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.framed = false;
+            this.sendSize();
+            const started = new Promise((resolve, reject) => stream.startCaptureWithCompletionHandler((err) => (err ? reject(new Error(err.localizedDescription)) : resolve(true))));
+            let completed;
+            try {
+                completed = await Promise.race([started, new Promise((r) => setTimeout(() => r(false), START_TIMEOUT_MS))]);
+            }
+            catch (err) {
+                if (this.capture?.stream === stream)
+                    this.capture = undefined;
+                throw err;
+            }
+            if (!completed && !this.framed) {
+                if (this.capture?.stream === stream)
+                    this.capture = undefined;
+                stream.stopCaptureWithCompletionHandler(null);
+                retry = attempt < START_ATTEMPTS;
+                if (!retry)
+                    throw new Error(`ScreenCaptureKit did not start after ${START_ATTEMPTS} attempts`);
+                return;
+            }
+            this.onState?.(true, this.viewers);
+        }
+        catch (err) {
+            console.error('[ns-edge desktop] window capture failed:', err.message);
+        }
+        finally {
+            this.starting = false;
+            if (retry && this.viewers > 0)
+                await this.start(attempt + 1);
+        }
+    }
+    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);
+        }
+        const now = performance.now();
+        this.budget = Math.min(BYTES_PER_SECOND, this.budget + ((now - this.budgetAt) * BYTES_PER_SECOND) / 1000);
+        this.budgetAt = now;
+        if (this.budget < 0 || ws.bufferedAmount > MAX_BUFFERED)
+            return;
+        const pixels = CMSampleBufferGetImageBuffer(sampleBuffer);
+        // Frames where nothing changed carry no image.
+        if (!pixels)
+            return;
+        this.framed = true;
+        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);
+        // Chunks are copies: the bytes are backed by the NSData, which is released right after.
+        const bytes = new Uint8Array(interop.bufferFromData(jpeg));
+        for (let at = 0; at < bytes.byteLength; at += FRAME_CHUNK_BYTES) {
+            const payload = bytes.subarray(at, at + FRAME_CHUNK_BYTES);
+            const chunk = new Uint8Array(payload.byteLength + 1);
+            chunk[0] = at + FRAME_CHUNK_BYTES >= bytes.byteLength ? FRAME_END : FRAME_MORE;
+            chunk.set(payload, 1);
+            ws.send(chunk);
+        }
+        this.budget -= bytes.byteLength;
+        this.adaptQuality(bytes.byteLength);
+    }
+    /** Steers JPEG quality so frames stay near the size the budget allows at full frame rate. */
+    adaptQuality(bytes) {
+        const next = bytes > TARGET_FRAME_BYTES * 1.2
+            ? Math.max(QUALITY.min, this.quality - 0.05)
+            : bytes < TARGET_FRAME_BYTES * 0.6
+                ? Math.min(QUALITY.max, this.quality + 0.02)
+                : this.quality;
+        if (next !== this.quality) {
+            this.quality = next;
+            this.options = undefined;
+        }
+    }
+    options;
+    jpegOptions() {
+        return (this.options ??= NSDictionary.dictionaryWithObjectForKey(NSNumber.numberWithDouble(this.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 size in points, not its Retina backing size.
+ * Viewers show it in a side pane, and 2x frames are four times the bytes,
+ * which halves the frame rate on a typical uplink.
+ */
+function applySize(config, window) {
+    const { width, height } = window.frame.size;
+    const scale = Math.min(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.1",
+  "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.2",
+    "@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"
+  }
+}