@desklink/host 0.5.10 → 0.5.11

package/README.md

@@ -104,37 +104,7 @@ The one step no install does for you is [kernel input access](#kernel-input-acce
 and only the portal backend needs it.
 
 macOS arm64 (preview) also has a prebuilt engine. There is no prebuilt engine for other platforms. Another Linux (arm64, musl)
-can [build it from source](#building-from-source). Windows has a source-built transport preview for
-`x86_64-pc-windows-msvc`: static libvpx enables `serve` and consumer-fed H.264
-encoded sources. Native capture, input, clipboard and the agent indicator are
-unavailable. Native Windows desktop capture sessions are not supported yet. Node resolution
-is an opt-in preview for Windows 11 22H2+ x64: set `DESKLINK_WINDOWS=1` and
-point `DESKLINK_ENGINE` at a built `desklink-host.exe`. Windows platform packages
-are not published yet. Without static libvpx, the executable's `capabilities`
-command remains available, but CLI `capabilities` and `bridge` require `serve`.
-The Windows bridge defaults to `--source display` and handles Ctrl+Break;
-consumer-fed video requires `--source encoded`.
-A startup exit `0xC0000135` is reported as `missing-system-library` (a required
-DLL could not load); spawn failures are reported as `engine-spawn-failed` with
-the underlying error. Elevated windows and the secure desktop remain outside
-Windows control support.
-
-On Windows with Visual Studio Build Tools and PowerShell 7, build libvpx with
-`release/build-libvpx-win.ps1 -OutDir <new-build-directory>`, set
-`DESKLINK_VPX_STATIC_DIR` to its `prefix` directory and
-`RUSTFLAGS=-Ctarget-feature=+crt-static`, then run `cargo build --locked --target
-x86_64-pc-windows-msvc --manifest-path engine/Cargo.toml`. The build retains
-libvpx's licence and patent grant in `prefix/THIRD_PARTY_LICENSES.txt`.
-Without that prefix the compile seam still builds and refuses `serve`.
-Hosted Windows CI resolves the opt-in engine through the published Node API
-and completes a `serve` hello/capabilities handshake with clean shutdown; it
-also installs the packed packages into an empty project, checks the installed
-`@desklink/host` tree against its pack manifest, starts the engine from that
-install, and checks Chrome decode and input relay, and DLL
-dependencies. That install proof is installation and startup on a hosted
-machine: the engine still comes from a source build, because Windows platform
-packages are not published, and capture, input, encoding quality, mixed DPI, GPU
-encoding and elevation stay with the dedicated rig lanes.
+can [build it from source](#building-from-source).
 
 ### macOS (preview)
 
@@ -305,7 +275,7 @@ source-coordinate `x`, `y`, `visible`, the cursor image's `hotspot` where
 known, and monotonic `timestamp_us` (the same clock as local frame metadata).
 A compositor without that protocol still captures, cursor hidden, and says so
 in `cursor.limitation`. X11 reports positions even on still
-frames and already captures root pixels without a cursor. macOS, Windows, and consumer-encoded
+frames and already captures root pixels without a cursor. macOS and consumer-encoded
 sources return `cursor-unavailable` for hidden requests. Omitting the option
 preserves existing behavior. See [the cursor protocol](https://github.com/umeranjum17/desklink/blob/main/packages/desktop-host/docs/PROTOCOL.md#cursor-free-capture).
 
@@ -385,7 +355,7 @@ platform". Linux variants are published only after their own qualification; macO
 is published as a default-enabled preview, not as qualified desktop support.
 See [Install and run](#install-and-run) for current support. Another variant,
 such as Linux arm64, needs a real machine to run a real journey first. macOS
-and Windows are separate backends, not separate builds.
+is a separate backend, not a separate build.
 
 ### Building and packing a release
 
@@ -445,19 +415,19 @@ the current platform's host and engine tarballs into an empty project and checks
 
 Publishing is automatic. Merging a version bump to `main` runs
 `.github/workflows/release.yml`: the test, build, build-pack and per-OS engine
-jobs gate a publish job that releases every package whose exact version is not
-yet on npm, in dependency order — the engine platform packages first, then
-`@desklink/host` immediately after the engine packages it pins, then
-`@desklink/axi` gated on the host (not the reverse), then
+jobs gate a publish job (`release/publish-set.sh`) that releases every package
+whose exact version is not yet on npm, in dependency order — the engine
+platform packages first, then `@desklink/host`, then `@desklink/axi`, then
 `@desklink/react-native` — all with `--provenance`. A version lockstep check
 fails the workflow when `@desklink/host`, `@desklink/react-native` and
-`@desklink/axi` disagree, so a half-bump never reaches publish. One package's
-failure never stops the others, but the job ends red and every hold or failure
-names the package and version.
-A dependent waits for a just-published package within npm's own availability
-window, shared through `release/readback-budget.json` with the manual
-`release/publish.mjs` route, so a fresh release publishes in one run instead of
-holding each package until the next re-run.
+`@desklink/axi` disagree, so a half-bump never reaches publish. The publish job
+publishes nothing unless every tarball of the set is present and the registry
+answers for each package.
+Each package then waits until the registry serves the one before it, within a
+30-minute budget that covers npm's processing and CDN lag (shared through
+`release/readback-budget.json` with the manual `release/publish.mjs` route).
+The first failure stops the job with an error naming what is served and what
+is not, so a failed run leaves only a prefix of that order published.
 The workflow uses trusted publishing (OIDC) and no npm token. Re-runs skip
 versions already published.
 

package/engine/Cargo.lock

@@ -536,7 +536,7 @@ checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
 
 [[package]]
 name = "desklink-host"
-version = "0.5.10"
+version = "0.5.11"
 dependencies = [
  "anyhow",
  "ashpd",

package/engine/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "desklink-host"
-version = "0.5.10"
+version = "0.5.11"
 edition = "2021"
 rust-version = "1.97.1"
 license = "Apache-2.0"

package/engine/native/agent_overlay_mac.m

@@ -9,8 +9,8 @@
     NSPoint target, cursor;
     CFTimeInterval clickAt, typeAt, endingAt;
     BOOL positioned;
-    BOOL pointMode, pointVisible;
-    CFTimeInterval pointDeadline;
+    BOOL pointMode, pointVisible, pointDrawnHidden;
+    CFTimeInterval pointDeadline, pointStarted;
     NSString *pointLabel;
 }
 - (void)event:(char)kind x:(double)x y:(double)y;
@@ -24,7 +24,7 @@
 - (void)enablePointMode { pointMode = YES; }
 - (void)pointX:(double)x y:(double)y timeout:(unsigned)timeout label:(NSString *)label {
     cursor = NSMakePoint(x, self.bounds.size.height-y);
-    pointLabel = label; pointVisible = YES;
+    pointLabel = label; pointVisible = YES; pointStarted = CACurrentMediaTime();
     pointDeadline = CACurrentMediaTime() + timeout/1000.0;
     [self setNeedsDisplay:YES];
 }
@@ -43,7 +43,9 @@
 - (void)end { if (pointMode) { [NSApp terminate:nil]; return; } endingAt = CACurrentMediaTime(); }
 - (void)tick {
     if (pointMode) {
-        if (pointVisible && CACurrentMediaTime() >= pointDeadline) { pointVisible = NO; [self setNeedsDisplay:YES]; }
+        if (pointVisible && CACurrentMediaTime() >= pointDeadline) pointVisible = NO;
+        if (pointVisible || !pointDrawnHidden) [self setNeedsDisplay:YES];
+        pointDrawnHidden = !pointVisible;
         return;
     }
     if (endingAt && CACurrentMediaTime() - endingAt > 0.7) { [NSApp terminate:nil]; return; }
@@ -56,17 +58,22 @@
     if (pointMode) {
         if (!pointVisible) return;
         [[NSColor colorWithCalibratedRed:0.30 green:0.62 blue:0.82 alpha:1] set];
-        NSBezierPath *ring = [NSBezierPath bezierPathWithOvalInRect:NSMakeRect(cursor.x-18, cursor.y-18, 36, 36)];
-        ring.lineWidth = 4; [ring stroke];
-        [[NSBezierPath bezierPathWithOvalInRect:NSMakeRect(cursor.x-3,cursor.y-3,6,6)] fill];
+        // 72pt ring with a 1.2s pulse wave growing out of it.
+        NSBezierPath *ring = [NSBezierPath bezierPathWithOvalInRect:NSMakeRect(cursor.x-36, cursor.y-36, 72, 72)];
+        ring.lineWidth = 6; [ring stroke];
+        [[NSBezierPath bezierPathWithOvalInRect:NSMakeRect(cursor.x-6,cursor.y-6,12,12)] fill];
+        double phase = fmod(CACurrentMediaTime() - pointStarted, 1.2) / 1.2, wave = 36 + 18*phase;
+        [[NSColor colorWithCalibratedRed:0.30 green:0.62 blue:0.82 alpha:1-phase] set];
+        NSBezierPath *pulse = [NSBezierPath bezierPathWithOvalInRect:NSMakeRect(cursor.x-wave, cursor.y-wave, 2*wave, 2*wave)];
+        pulse.lineWidth = 6 - 4*phase; [pulse stroke];
         if (pointLabel.length) {
-            NSDictionary *style = @{NSFontAttributeName: [NSFont systemFontOfSize:13], NSForegroundColorAttributeName: NSColor.whiteColor};
+            NSDictionary *style = @{NSFontAttributeName: [NSFont boldSystemFontOfSize:26], NSForegroundColorAttributeName: NSColor.whiteColor};
             NSSize size = [pointLabel sizeWithAttributes:style];
-            CGFloat x = fmax(0, fmin(cursor.x+30, self.bounds.size.width-size.width-16));
-            CGFloat y = fmax(0, fmin(cursor.y-14, self.bounds.size.height-28));
+            CGFloat x = fmax(0, fmin(cursor.x+66, self.bounds.size.width-size.width-24));
+            CGFloat y = fmax(0, fmin(cursor.y-20, self.bounds.size.height-40));
             [[NSColor colorWithCalibratedRed:0.07 green:0.19 blue:0.28 alpha:1] set];
-            [[NSBezierPath bezierPathWithRoundedRect:NSMakeRect(x,y,size.width+16,28) xRadius:4 yRadius:4] fill];
-            [pointLabel drawAtPoint:NSMakePoint(x+8,y+6) withAttributes:style];
+            [[NSBezierPath bezierPathWithRoundedRect:NSMakeRect(x,y,size.width+24,40) xRadius:6 yRadius:6] fill];
+            [pointLabel drawAtPoint:NSMakePoint(x+12,y+(40-size.height)/2) withAttributes:style];
         }
         return;
     }

package/engine/native/agent_overlay_wayland.c

@@ -203,27 +203,30 @@ static FT_Face point_font(FT_Library *library) {
     FcResult result;FcPattern *match=FcFontMatch(NULL,pattern,&result);FcPatternDestroy(pattern);
     FcChar8 *path=NULL;FT_Face face=NULL;
     if(match && FcPatternGetString(match,FC_FILE,0,&path)==FcResultMatch)
-        if(!FT_New_Face(*library,(const char *)path,0,&face))FT_Set_Pixel_Sizes(face,0,13);
+        if(!FT_New_Face(*library,(const char *)path,0,&face))FT_Set_Pixel_Sizes(face,0,26);
     if(match)FcPatternDestroy(match);
     return face;
 }
-static void draw_point(struct Overlay *o,struct Buffer *b,double x,double y,const char *label,FT_Face font,int visible) {
+// 72 logical px ring with a 1.2 s pulse wave growing out of it, and a 40px
+// badge with 26px text. Opaque pixels only, like the X11 cue.
+static void draw_point(struct Overlay *o,struct Buffer *b,double x,double y,const char *label,FT_Face font,int visible,double elapsed) {
     memset(b->pixels,0,b->length);if(!visible)return;
     int w=o->width,h=o->height;
-    for(int py=fmax(0,y-21);py<fmin(h,y+22);py++)for(int px=fmax(0,x-21);px<fmin(w,x+22);px++) {
+    double phase=fmod(elapsed,1.2)/1.2,wave=36+18*phase,wave_half=3-2*phase;
+    for(int py=fmax(0,y-56);py<fmin(h,y+57);py++)for(int px=fmax(0,x-56);px<fmin(w,x+57);px++) {
         double d=hypot(px-x,py-y);
-        if(fabs(d-18)<=2 || d<=3)b->pixels[(size_t)py*w+px]=0xff4c9ed0;
+        if(fabs(d-36)<=3 || d<=6 || fabs(d-wave)<=wave_half)b->pixels[(size_t)py*w+px]=0xff4c9ed0;
     }
     if(!*label)return;
-    int badge_w=16;
+    int badge_w=24;
     for(const char *p=label;*p;p++)if(!FT_Load_Char(font,(unsigned char)*p,FT_LOAD_DEFAULT))badge_w+=font->glyph->advance.x>>6;
-    badge_w=fmin(w,badge_w);int bx=fmax(0,fmin(x+30,w-badge_w)),by=fmax(0,fmin(y-14,h-28));
-    for(int py=by;py<fmin(h,by+28);py++)for(int px=bx;px<bx+badge_w;px++)b->pixels[(size_t)py*w+px]=0xff123047;
-    int pen=bx+8;
+    badge_w=fmin(w,badge_w);int bx=fmax(0,fmin(x+66,w-badge_w)),by=fmax(0,fmin(y-20,h-40));
+    for(int py=by;py<fmin(h,by+40);py++)for(int px=bx;px<bx+badge_w;px++)b->pixels[(size_t)py*w+px]=0xff123047;
+    int pen=bx+12;
     for(const char *p=label;*p;p++)if(!FT_Load_Char(font,(unsigned char)*p,FT_LOAD_RENDER)) {
         FT_GlyphSlot g=font->glyph;
         for(unsigned row=0;row<g->bitmap.rows;row++)for(unsigned col=0;col<g->bitmap.width;col++) {
-            int px=pen+g->bitmap_left+col,py=by+18-g->bitmap_top+row;
+            int px=pen+g->bitmap_left+col,py=by+28-g->bitmap_top+row;
             if(px<0||px>=w||py<0||py>=h)continue;
             unsigned a=g->bitmap.buffer[row*g->bitmap.pitch+col];
             unsigned r=(18*(255-a)+255*a)/255,green=(48*(255-a)+255*a)/255,blue=(71*(255-a)+255*a)/255;
@@ -314,7 +317,7 @@ static int overlay_main(int source_w,int source_h,int point_mode,int origin_know
                         unsigned timeout=0;int offset=0;
                         if(sscanf(pending,"P %lf %lf %u %n",&px,&py,&timeout,&offset)==3 && offset && timeout>=1 && timeout<=120000 && strlen(pending+offset)<=96) {
                             snprintf(label,sizeof(label),"%s",pending+offset);deadline=now()+timeout/1000.0;active=1;dirty=1;
-                            visible=locate(&o,px,py,&x,&y);
+                            visible=locate(&o,px,py,&x,&y);cue_started=now();
                         }
                     }
                     else if(kind=='S')ending=now();
@@ -336,11 +339,11 @@ static int overlay_main(int source_w,int source_h,int point_mode,int origin_know
                 used=0;
             }else if(used<sizeof(pending)-1)pending[used++]=bytes[i];
         }
-        if(point_mode && visible && now()>=deadline){visible=0;dirty=1;}
+        if(point_mode && visible){if(now()>=deadline)visible=0;dirty=1;}
         if(!active || (point_mode&&!dirty))continue;
         if(!point_mode){x+=(tx-x)*0.24;y+=(ty-y)*0.24;}
         for(int i=0;i<2;i++)if(!o.buffers[i].busy) {
-            if(point_mode)draw_point(&o,&o.buffers[i],x,y,label,font,visible);
+            if(point_mode)draw_point(&o,&o.buffers[i],x,y,label,font,visible,now()-cue_started);
             else draw(&o,&o.buffers[i],x,y,click,typed,ending,started,cue_started);
             dirty=0;
             o.buffers[i].busy=1;

package/engine/native/agent_overlay_x11.c

@@ -163,6 +163,50 @@ int desklink_agent_overlay_main(const char *display_name) {
     return 0;
 }
 
+// The ring is 72 logical px across, a 6px band with a pulse wave that grows
+// out from it every PULSE_SECONDS, so the cue reads at a glance. The label is
+// the core "fixed" font drawn at 2x, because a core X server offers nothing larger.
+#define POINT_RING 36
+#define POINT_PULSE_SECONDS 1.2
+#define POINT_BADGE_H 40
+#define POINT_FRAME_SECONDS 0.033
+
+static void point_shape(Display *d, Window window, Pixmap mask, GC shape, int x, int y,
+    int badge_x, int badge_y, int badge_w, double elapsed) {
+    double phase = fmod(elapsed, POINT_PULSE_SECONDS) / POINT_PULSE_SECONDS;
+    int wave = POINT_RING + (int)lround(18*phase), wave_width = 6 - (int)lround(4*phase);
+    XSetForeground(d, shape, 0); XFillRectangle(d, mask, shape, 0, 0, 0xffff, 0xffff);
+    XSetForeground(d, shape, 1);
+    XSetLineAttributes(d, shape, 6, LineSolid, CapRound, JoinRound);
+    XDrawArc(d, mask, shape, x-POINT_RING, y-POINT_RING, 2*POINT_RING, 2*POINT_RING, 0, 360*64);
+    XFillArc(d, mask, shape, x-6, y-6, 12, 12, 0, 360*64);
+    XSetLineAttributes(d, shape, wave_width, LineSolid, CapRound, JoinRound);
+    XDrawArc(d, mask, shape, x-wave, y-wave, 2*wave, 2*wave, 0, 360*64);
+    if (badge_w) XFillRectangle(d, mask, shape, badge_x, badge_y, badge_w, POINT_BADGE_H);
+    XShapeCombineMask(d, window, ShapeBounding, 0, 0, mask, ShapeSet);
+}
+
+// Text is rasterised once at 1x and drawn as 2x2 blocks.
+static void point_text(Display *d, Window window, GC ink, XFontStruct *font, const char *label,
+    int len, int x, int y) {
+    int w = XTextWidth(font, label, len), h = font->ascent + font->descent;
+    Pixmap bits = XCreatePixmap(d, window, w, h, 1);
+    GC gc = XCreateGC(d, bits, 0, NULL);
+    XSetFont(d, gc, font->fid);
+    XSetForeground(d, gc, 0); XFillRectangle(d, bits, gc, 0, 0, w, h);
+    XSetForeground(d, gc, 1); XDrawString(d, bits, gc, 0, font->ascent, label, len);
+    XImage *image = XGetImage(d, bits, 0, 0, w, h, 1, ZPixmap);
+    XRectangle *blocks = malloc(sizeof(XRectangle) * (size_t)w * h);
+    int count = 0;
+    if (image && blocks)
+        for (int row = 0; row < h; row++) for (int col = 0; col < w; col++)
+            if (XGetPixel(image, col, row))
+                blocks[count++] = (XRectangle){(short)(x+2*col), (short)(y+2*row), 2, 2};
+    if (count) XFillRectangles(d, window, ink, blocks, count);
+    free(blocks); if (image) XDestroyImage(image);
+    XFreeGC(d, gc); XFreePixmap(d, bits);
+}
+
 // Point cues are independent of the real cursor. A shaped override-redirect
 // window works without a compositor; an empty input shape passes every event
 // through and mapping it never asks for keyboard focus. It intentionally appears
@@ -185,12 +229,11 @@ int desklink_point_overlay_main(const char *display_name) {
     Pixmap mask = XCreatePixmap(d, root, width, height, 1);
     GC shape = XCreateGC(d, mask, 0, NULL), ink = XCreateGC(d, window, 0, NULL);
     XFontStruct *font = XLoadQueryFont(d, "fixed");
-    if (font) XSetFont(d, ink, font->fid);
-    XSetLineAttributes(d, shape, 4, LineSolid, CapRound, JoinRound);
     fcntl(STDIN_FILENO, F_SETFL, fcntl(STDIN_FILENO, F_GETFL) | O_NONBLOCK);
     puts("READY"); fflush(stdout);
     char pending[512]; size_t used = 0;
-    double deadline = 0;
+    double deadline = 0, started = 0, drawn = 0;
+    int x = 0, y = 0, badge_x = 0, badge_y = 0, badge_w = 0;
     for (;;) {
         char bytes[512]; ssize_t n = read(STDIN_FILENO, bytes, sizeof(bytes));
         if (n == 0) break;
@@ -200,35 +243,41 @@ int desklink_point_overlay_main(const char *display_name) {
             double px, py; unsigned timeout; int offset = 0;
             if (sscanf(pending, "P %lf %lf %u %n", &px, &py, &timeout, &offset) != 3 || !offset) continue;
             const char *label = pending + offset;
-            int x = (int)px, y = (int)py, len = (int)strlen(label);
-            int badge_w = font ? XTextWidth(font, label, len) + 16 : len * 6 + 16;
+            int len = (int)strlen(label);
+            x = (int)px; y = (int)py;
+            int text_w = font ? 2*XTextWidth(font, label, len) : 12*len;
+            badge_w = len ? text_w + 24 : 0;
             if (badge_w > width) badge_w = width;
-            int badge_x = x + 30, badge_y = y - 14;
+            badge_x = x + POINT_RING + 30; badge_y = y - POINT_BADGE_H/2;
             if (badge_x + badge_w > width) badge_x = width - badge_w;
             if (badge_y < 0) badge_y = 0;
-            if (badge_y + 28 > height) badge_y = height - 28;
+            if (badge_y + POINT_BADGE_H > height) badge_y = height - POINT_BADGE_H;
             XUnmapWindow(d, window);
-            XSetForeground(d, shape, 0); XFillRectangle(d, mask, shape, 0, 0, width, height);
-            XSetForeground(d, shape, 1);
-            XDrawArc(d, mask, shape, x-18, y-18, 36, 36, 0, 360*64);
-            XFillArc(d, mask, shape, x-3, y-3, 6, 6, 0, 360*64);
-            if (len) XFillRectangle(d, mask, shape, badge_x, badge_y, badge_w, 28);
-            XShapeCombineMask(d, window, ShapeBounding, 0, 0, mask, ShapeSet);
+            started = now();
+            point_shape(d, window, mask, shape, x, y, badge_x, badge_y, badge_w, 0);
             XMapRaised(d, window);
             XClearWindow(d, window);
             if (len) {
                 XSetForeground(d, ink, 0x123047);
-                XFillRectangle(d, window, ink, badge_x, badge_y, badge_w, 28);
+                XFillRectangle(d, window, ink, badge_x, badge_y, badge_w, POINT_BADGE_H);
                 XSetForeground(d, ink, 0xffffff);
-                XDrawString(d, window, ink, badge_x+8, badge_y+18, label, len);
+                if (font) point_text(d, window, ink, font, label, len, badge_x+12,
+                    badge_y + (POINT_BADGE_H - 2*(font->ascent+font->descent))/2);
             }
             XSync(d, False);
-            deadline = now() + timeout/1000.0;
+            drawn = now();
+            deadline = drawn + timeout/1000.0;
+        }
+        double t = now();
+        if (deadline && t >= deadline) { XUnmapWindow(d, window); XFlush(d); deadline = 0; }
+        else if (deadline && t - drawn >= POINT_FRAME_SECONDS) {
+            point_shape(d, window, mask, shape, x, y, badge_x, badge_y, badge_w, t - started);
+            XFlush(d); drawn = t;
         }
-        if (deadline && now() >= deadline) { XUnmapWindow(d, window); XFlush(d); deadline = 0; }
         usleep(5000);
     }
     XDestroyWindow(d, window); XFreeGC(d, shape); XFreeGC(d, ink);
     XFreePixmap(d, mask); if (font) XFreeFont(d, font); XCloseDisplay(d);
     return 0;
 }
+

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@desklink/host",
-    "version": "0.5.10",
+    "version": "0.5.11",
     "license": "Apache-2.0",
     "repository": {
         "type": "git",
@@ -38,7 +38,7 @@
         "ws": "8.21.3"
     },
     "optionalDependencies": {
-        "@desklink/host-linux-x64-gnu": "0.5.10",
-        "@desklink/host-darwin-arm64": "0.5.10"
+        "@desklink/host-linux-x64-gnu": "0.5.11",
+        "@desklink/host-darwin-arm64": "0.5.11"
     }
 }