@walldock/agent 0.1.0

package/dist/pid.js

@@ -0,0 +1,77 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runningPid = runningPid;
+exports.acquireLock = acquireLock;
+exports.releaseLock = releaseLock;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const PID_FILE = path.join(os.tmpdir(), 'walldock-agent.pid');
+function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function runningPid() {
+    try {
+        const raw = await fs.readFile(PID_FILE, 'utf8');
+        const pid = parseInt(raw.trim(), 10);
+        if (isNaN(pid))
+            return null;
+        return isAlive(pid) ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Write our PID to the lock file. Throws if another instance is already running.
+ */
+async function acquireLock() {
+    const existing = await runningPid();
+    if (existing !== null) {
+        throw new Error(`Walldock Agent is already running (PID ${existing}).\n` +
+            'Stop the existing instance before starting a new one.');
+    }
+    await fs.writeFile(PID_FILE, String(process.pid), 'utf8');
+}
+async function releaseLock() {
+    await fs.unlink(PID_FILE).catch(() => undefined);
+}

package/dist/screens/index.d.ts

@@ -0,0 +1,12 @@
+export interface Screen {
+    stableId: string;
+    label: string;
+    width: number;
+    height: number;
+    scaleFactor: number;
+    positionX: number;
+    positionY: number;
+    isPrimary: boolean;
+}
+export declare function fingerprintScreens(screens: Screen[]): string;
+export declare function listScreens(): Promise<Screen[]>;

package/dist/screens/index.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fingerprintScreens = fingerprintScreens;
+exports.listScreens = listScreens;
+function fingerprintScreens(screens) {
+    return screens
+        .map(s => `${s.stableId}:${s.width}x${s.height}@${s.scaleFactor}:p=${s.positionX},${s.positionY}:pri=${s.isPrimary ? 1 : 0}`)
+        .sort()
+        .join('|');
+}
+async function listScreens() {
+    try {
+        if (process.platform === 'darwin') {
+            const { listScreensMacOS } = await Promise.resolve().then(() => __importStar(require('./macos')));
+            return await listScreensMacOS();
+        }
+        if (process.platform === 'win32') {
+            const { listScreensWindows } = await Promise.resolve().then(() => __importStar(require('./windows')));
+            return await listScreensWindows();
+        }
+        const { listScreensLinux } = await Promise.resolve().then(() => __importStar(require('./linux')));
+        return await listScreensLinux();
+    }
+    catch (err) {
+        console.warn('[screens] enumeration failed:', err);
+        return [];
+    }
+}

package/dist/screens/linux.d.ts

@@ -0,0 +1,2 @@
+import type { Screen } from './index';
+export declare function listScreensLinux(): Promise<Screen[]>;

package/dist/screens/linux.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listScreensLinux = listScreensLinux;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const stable_id_1 = require("./stable-id");
+const exec = (0, node_util_1.promisify)(node_child_process_1.execFile);
+async function tryExec(cmd, args) {
+    try {
+        const { stdout } = await exec(cmd, args);
+        return stdout;
+    }
+    catch {
+        return null;
+    }
+}
+async function listFromSway() {
+    const out = await tryExec('swaymsg', ['-t', 'get_outputs']);
+    if (!out)
+        return null;
+    try {
+        const outputs = JSON.parse(out);
+        return outputs
+            .filter(o => o.rect.width > 0)
+            .map((o, i) => {
+            const w = Math.round(o.rect.width * (o.scale ?? 1));
+            const h = Math.round(o.rect.height * (o.scale ?? 1));
+            return {
+                stableId: (0, stable_id_1.computeStableScreenId)(o.name, w, h, o.scale ?? 1, o.rect.x, o.rect.y),
+                label: o.name,
+                width: w,
+                height: h,
+                scaleFactor: o.scale ?? 1,
+                positionX: o.rect.x,
+                positionY: o.rect.y,
+                isPrimary: i === 0,
+            };
+        });
+    }
+    catch {
+        return null;
+    }
+}
+async function listFromHyprland() {
+    const out = await tryExec('hyprctl', ['monitors', '-j']);
+    if (!out)
+        return null;
+    try {
+        const monitors = JSON.parse(out);
+        return monitors.map((m, i) => ({
+            stableId: (0, stable_id_1.computeStableScreenId)(m.name, m.width, m.height, m.scale ?? 1, m.x, m.y),
+            label: m.name,
+            width: m.width,
+            height: m.height,
+            scaleFactor: m.scale ?? 1,
+            positionX: m.x,
+            positionY: m.y,
+            isPrimary: i === 0,
+        }));
+    }
+    catch {
+        return null;
+    }
+}
+async function listFromXrandr() {
+    const out = await tryExec('xrandr', ['--query']);
+    if (!out)
+        return null;
+    const screens = [];
+    // Matches lines like: HDMI-1 connected primary 1920x1080+0+0 (...)
+    const re = /^(\S+)\s+connected\s*(primary)?\s*(\d+)x(\d+)\+(-?\d+)\+(-?\d+)/gm;
+    let match;
+    while ((match = re.exec(out)) !== null) {
+        const [, name, primary, ws, hs, xs, ys] = match;
+        const width = parseInt(ws, 10);
+        const height = parseInt(hs, 10);
+        const positionX = parseInt(xs, 10);
+        const positionY = parseInt(ys, 10);
+        const scaleFactor = 1;
+        screens.push({
+            stableId: (0, stable_id_1.computeStableScreenId)(name, width, height, scaleFactor, positionX, positionY),
+            label: name,
+            width,
+            height,
+            scaleFactor,
+            positionX,
+            positionY,
+            isPrimary: primary === 'primary',
+        });
+    }
+    return screens.length > 0 ? screens : null;
+}
+async function listScreensLinux() {
+    if (process.env['SWAYSOCK']) {
+        const s = await listFromSway();
+        if (s)
+            return s;
+    }
+    if (process.env['HYPRLAND_INSTANCE_SIGNATURE']) {
+        const h = await listFromHyprland();
+        if (h)
+            return h;
+    }
+    const x = await listFromXrandr();
+    if (x)
+        return x;
+    // Final fallback: single synthetic screen
+    return [{
+            stableId: (0, stable_id_1.computeStableScreenId)('', 1920, 1080, 1, 0, 0),
+            label: 'Display',
+            width: 1920,
+            height: 1080,
+            scaleFactor: 1,
+            positionX: 0,
+            positionY: 0,
+            isPrimary: true,
+        }];
+}

package/dist/screens/macos.d.ts

@@ -0,0 +1,2 @@
+import type { Screen } from './index';
+export declare function listScreensMacOS(): Promise<Screen[]>;

package/dist/screens/macos.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listScreensMacOS = listScreensMacOS;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const stable_id_1 = require("./stable-id");
+const exec = (0, node_util_1.promisify)(node_child_process_1.execFile);
+// Swift one-liner: NSScreen gives us name, backing scale, frame in points.
+// Physical pixels = points * backingScaleFactor.
+const SWIFT_SCRIPT = `
+import AppKit
+let screens = NSScreen.screens
+for screen in screens {
+  let b = screen.backingScaleFactor
+  let f = screen.frame
+  let name = screen.localizedName
+  let x = Int(f.origin.x)
+  let y = Int(f.origin.y)
+  let w = Int(f.size.width * b)
+  let h = Int(f.size.height * b)
+  let primary = (screen == NSScreen.main) ? 1 : 0
+  print("\\(name)|\\(x)|\\(y)|\\(w)|\\(h)|\\(b)|\\(primary)")
+}
+`.trim();
+async function listScreensMacOS() {
+    const { stdout } = await exec('swift', ['-e', SWIFT_SCRIPT]);
+    const screens = [];
+    for (const line of stdout.trim().split('\n')) {
+        if (!line.trim())
+            continue;
+        const parts = line.split('|');
+        if (parts.length < 7)
+            continue;
+        const [name, xs, ys, ws, hs, scalS, priS] = parts;
+        const positionX = parseInt(xs, 10);
+        const positionY = parseInt(ys, 10);
+        const width = parseInt(ws, 10);
+        const height = parseInt(hs, 10);
+        const scaleFactor = parseFloat(scalS);
+        const isPrimary = priS.trim() === '1';
+        screens.push({
+            stableId: (0, stable_id_1.computeStableScreenId)(name, width, height, scaleFactor, positionX, positionY),
+            label: name,
+            width,
+            height,
+            scaleFactor,
+            positionX,
+            positionY,
+            isPrimary,
+        });
+    }
+    return screens;
+}

package/dist/screens/stable-id.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Replicates the Rust compute_stable_screen_id() function exactly.
+ * SHA-256 of:
+ *   if name empty: "pos:" + posX(i32 LE) + posY(i32 LE)
+ *   else:          "name:" + name(utf8)
+ *   then:          "|res:" + width(u32 LE) + height(u32 LE)
+ *   then:          "|scale:" + scale(f64 LE bits)
+ * Returns first 12 bytes as lowercase hex (24 chars).
+ */
+export declare function computeStableScreenId(name: string, width: number, height: number, scale: number, posX: number, posY: number): string;

package/dist/screens/stable-id.js

@@ -0,0 +1,70 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeStableScreenId = computeStableScreenId;
+const crypto = __importStar(require("node:crypto"));
+/**
+ * Replicates the Rust compute_stable_screen_id() function exactly.
+ * SHA-256 of:
+ *   if name empty: "pos:" + posX(i32 LE) + posY(i32 LE)
+ *   else:          "name:" + name(utf8)
+ *   then:          "|res:" + width(u32 LE) + height(u32 LE)
+ *   then:          "|scale:" + scale(f64 LE bits)
+ * Returns first 12 bytes as lowercase hex (24 chars).
+ */
+function computeStableScreenId(name, width, height, scale, posX, posY) {
+    const hash = crypto.createHash('sha256');
+    if (!name) {
+        const posBuf = Buffer.allocUnsafe(8);
+        posBuf.writeInt32LE(posX, 0);
+        posBuf.writeInt32LE(posY, 4);
+        hash.update(Buffer.from('pos:'));
+        hash.update(posBuf);
+    }
+    else {
+        hash.update(Buffer.from('name:'));
+        hash.update(Buffer.from(name, 'utf8'));
+    }
+    const resBuf = Buffer.allocUnsafe(8);
+    resBuf.writeUInt32LE(width, 0);
+    resBuf.writeUInt32LE(height, 4);
+    hash.update(Buffer.from('|res:'));
+    hash.update(resBuf);
+    const scaleBuf = Buffer.allocUnsafe(8);
+    scaleBuf.writeDoubleLE(scale, 0);
+    hash.update(Buffer.from('|scale:'));
+    hash.update(scaleBuf);
+    return hash.digest().slice(0, 12).toString('hex');
+}

package/dist/screens/windows.d.ts

@@ -0,0 +1,2 @@
+import type { Screen } from './index';
+export declare function listScreensWindows(): Promise<Screen[]>;

package/dist/screens/windows.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listScreensWindows = listScreensWindows;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const stable_id_1 = require("./stable-id");
+const exec = (0, node_util_1.promisify)(node_child_process_1.execFile);
+// PowerShell: enumerate screens with bounds + per-monitor DPI (shcore.dll GetDpiForMonitor).
+// Scale = monitorDpi / 96.  Bounds from Win32 are in physical pixels.
+const PS_SCRIPT = `
+Add-Type @"
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+public class MonitorHelper {
+  [DllImport("user32.dll")] public static extern bool EnumDisplayMonitors(IntPtr hdc, IntPtr clip, MonitorEnumProc cb, IntPtr data);
+  [DllImport("shcore.dll")] public static extern int GetDpiForMonitor(IntPtr hMon, int type, out uint dpiX, out uint dpiY);
+  [DllImport("user32.dll")] public static extern bool GetMonitorInfo(IntPtr hMon, ref MonitorInfo info);
+  [StructLayout(LayoutKind.Sequential)] public struct RECT { public int L,T,R,B; }
+  [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto)]
+  public struct MonitorInfo {
+    public uint Size; public RECT Monitor; public RECT Work; public uint Flags;
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst=32)] public string Device;
+  }
+  public delegate bool MonitorEnumProc(IntPtr hMon, IntPtr hdc, ref RECT rc, IntPtr data);
+  public static List<string> Enumerate() {
+    var results = new List<string>();
+    EnumDisplayMonitors(IntPtr.Zero, IntPtr.Zero, (hMon, hdc, ref rc, data) => {
+      var info = new MonitorInfo(); info.Size = (uint)Marshal.SizeOf(info);
+      GetMonitorInfo(hMon, ref info);
+      uint dx, dy;
+      GetDpiForMonitor(hMon, 0, out dx, out dy);
+      double scale = dx / 96.0;
+      int w = info.Monitor.R - info.Monitor.L;
+      int h = info.Monitor.B - info.Monitor.T;
+      int primary = (info.Flags & 1) != 0 ? 1 : 0;
+      results.Add(info.Device + "|" + info.Monitor.L + "|" + info.Monitor.T + "|" + w + "|" + h + "|" + scale.ToString("F6") + "|" + primary);
+      return true;
+    }, IntPtr.Zero);
+    return results;
+  }
+}
+"@
+[MonitorHelper]::Enumerate() | ForEach-Object { Write-Output $_ }
+`.trim();
+async function listScreensWindows() {
+    const { stdout } = await exec('powershell.exe', ['-NoProfile', '-Command', PS_SCRIPT]);
+    const screens = [];
+    for (const line of stdout.trim().split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        const parts = line.split('|');
+        if (parts.length < 7)
+            continue;
+        const [name, xs, ys, ws, hs, scalS, priS] = parts;
+        const positionX = parseInt(xs, 10);
+        const positionY = parseInt(ys, 10);
+        const width = parseInt(ws, 10);
+        const height = parseInt(hs, 10);
+        const scaleFactor = parseFloat(scalS);
+        const isPrimary = priS.trim() === '1';
+        screens.push({
+            stableId: (0, stable_id_1.computeStableScreenId)(name.trim(), width, height, scaleFactor, positionX, positionY),
+            label: name.trim(),
+            width,
+            height,
+            scaleFactor,
+            positionX,
+            positionY,
+            isPrimary,
+        });
+    }
+    return screens;
+}

package/dist/sse.d.ts

@@ -0,0 +1,8 @@
+export interface SseHandle {
+    stop(): void;
+}
+/**
+ * SSE client backed by fetch + ReadableStream. Reconnects with exponential
+ * back-off. Calls onEvent for each complete "event: … / data: …" block.
+ */
+export declare function connectSse(url: string, onEvent: (type: string, data: string) => void, onConnect?: () => void): SseHandle;

package/dist/sse.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectSse = connectSse;
+const promises_1 = require("node:timers/promises");
+const RECONNECT_DELAY_MS = 5_000;
+const MAX_RECONNECT_DELAY_MS = 60_000;
+/**
+ * SSE client backed by fetch + ReadableStream. Reconnects with exponential
+ * back-off. Calls onEvent for each complete "event: … / data: …" block.
+ */
+function connectSse(url, onEvent, onConnect) {
+    const controller = new AbortController();
+    async function run() {
+        let attempt = 0;
+        while (!controller.signal.aborted) {
+            try {
+                const res = await fetch(url, {
+                    headers: { accept: 'text/event-stream', 'cache-control': 'no-cache' },
+                    signal: controller.signal,
+                });
+                if (!res.ok || !res.body)
+                    throw new Error(`SSE HTTP ${res.status}`);
+                attempt = 0;
+                onConnect?.();
+                const decoder = new TextDecoder();
+                const reader = res.body.getReader();
+                let buffer = '';
+                try {
+                    for (;;) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        buffer += decoder.decode(value, { stream: true });
+                        const blocks = buffer.split(/\n\n/);
+                        buffer = blocks.pop() ?? '';
+                        for (const block of blocks) {
+                            if (!block.trim())
+                                continue;
+                            let type = 'message';
+                            let data = '';
+                            for (const line of block.split('\n')) {
+                                if (line.startsWith('event:'))
+                                    type = line.slice(6).trim();
+                                else if (line.startsWith('data:'))
+                                    data = line.slice(5).trim();
+                            }
+                            onEvent(type, data);
+                        }
+                    }
+                }
+                finally {
+                    reader.releaseLock();
+                }
+            }
+            catch {
+                if (controller.signal.aborted)
+                    return;
+                const delay = Math.min(RECONNECT_DELAY_MS * Math.pow(1.5, attempt), MAX_RECONNECT_DELAY_MS);
+                attempt++;
+                await (0, promises_1.setTimeout)(delay, undefined, { signal: controller.signal }).catch(() => undefined);
+            }
+        }
+    }
+    void run();
+    return { stop() { controller.abort(); } };
+}

package/dist/startup.d.ts

@@ -0,0 +1,5 @@
+export declare function registerStartup(): Promise<void>;
+export declare function unregisterStartup(): Promise<void>;
+export declare function startupDescription(): string;
+/** Returns the resolved global bin path, or null if not globally installed. */
+export declare function getGlobalBin(): Promise<string | null>;