@walldock/agent 0.1.0

package/dist/startup.js

@@ -0,0 +1,208 @@
+"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.registerStartup = registerStartup;
+exports.unregisterStartup = unregisterStartup;
+exports.startupDescription = startupDescription;
+exports.getGlobalBin = getGlobalBin;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const exec = (0, node_util_1.promisify)(node_child_process_1.execFile);
+// ─── Global bin resolution ────────────────────────────────────────────────────
+async function resolveGlobalBin() {
+    let prefix;
+    try {
+        const { stdout } = await exec('npm', ['prefix', '-g']);
+        prefix = stdout.trim();
+    }
+    catch {
+        throw new Error('Could not determine npm global prefix.\n' +
+            'Make sure npm is installed and run: npm install -g @walldock/agent');
+    }
+    const binName = process.platform === 'win32' ? 'walldock-agent.cmd' : 'walldock-agent';
+    const binPath = process.platform === 'win32'
+        ? path.join(prefix, binName)
+        : path.join(prefix, 'bin', binName);
+    try {
+        await fs.access(binPath);
+    }
+    catch {
+        throw new Error(`walldock-agent is not globally installed at ${binPath}.\n` +
+            'Run: npm install -g @walldock/agent');
+    }
+    return binPath;
+}
+// ─── macOS ───────────────────────────────────────────────────────────────────
+const LAUNCH_AGENTS_DIR = path.join(os.homedir(), 'Library', 'LaunchAgents');
+const PLIST_PATH = path.join(LAUNCH_AGENTS_DIR, 'com.walldock.agent.plist');
+const PLIST_LABEL = 'com.walldock.agent';
+function plistContent(binPath) {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${PLIST_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${binPath}</string>
+    <string>--daemon</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <false/>
+  <key>StandardOutPath</key>
+  <string>${path.join(os.homedir(), 'Library', 'Logs', 'walldock-agent.log')}</string>
+  <key>StandardErrorPath</key>
+  <string>${path.join(os.homedir(), 'Library', 'Logs', 'walldock-agent.log')}</string>
+</dict>
+</plist>
+`;
+}
+async function registerMacOS() {
+    const binPath = await resolveGlobalBin();
+    await fs.mkdir(LAUNCH_AGENTS_DIR, { recursive: true });
+    await fs.writeFile(PLIST_PATH, plistContent(binPath), 'utf8');
+    await exec('launchctl', ['load', '-w', PLIST_PATH]).catch(() => undefined);
+}
+async function unregisterMacOS() {
+    await exec('launchctl', ['unload', PLIST_PATH]).catch(() => undefined);
+    await fs.unlink(PLIST_PATH).catch(() => undefined);
+}
+// ─── Windows ─────────────────────────────────────────────────────────────────
+const REG_KEY = 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run';
+const REG_VALUE = 'WalldockAgent';
+async function registerWindows() {
+    const binPath = await resolveGlobalBin();
+    const cmd = `"${binPath}" --daemon`;
+    await exec('reg', ['add', REG_KEY, '/v', REG_VALUE, '/t', 'REG_SZ', '/d', cmd, '/f']);
+}
+async function unregisterWindows() {
+    await exec('reg', ['delete', REG_KEY, '/v', REG_VALUE, '/f']).catch(() => undefined);
+}
+// ─── Linux ───────────────────────────────────────────────────────────────────
+const SYSTEMD_USER_DIR = path.join(os.homedir(), '.config', 'systemd', 'user');
+const SERVICE_PATH = path.join(SYSTEMD_USER_DIR, 'walldock-agent.service');
+const AUTOSTART_DIR = path.join(os.homedir(), '.config', 'autostart');
+const DESKTOP_PATH = path.join(AUTOSTART_DIR, 'walldock-agent.desktop');
+function serviceContent(binPath) {
+    return `[Unit]
+Description=Walldock Agent
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+ExecStart=${binPath} --daemon
+Restart=on-failure
+RestartSec=10s
+
+[Install]
+WantedBy=default.target
+`;
+}
+function desktopContent(binPath) {
+    return `[Desktop Entry]
+Type=Application
+Name=Walldock Agent
+Exec=${binPath} --daemon
+Hidden=false
+NoDisplay=false
+X-GNOME-Autostart-enabled=true
+`;
+}
+async function systemdAvailable() {
+    try {
+        await exec('systemctl', ['--user', 'status'], { timeout: 3000 });
+        return true;
+    }
+    catch (e) {
+        // exit code 3 means "running but no units loaded" — systemd is present
+        return e.code === 3;
+    }
+}
+async function registerLinux() {
+    const binPath = await resolveGlobalBin();
+    if (await systemdAvailable()) {
+        await fs.mkdir(SYSTEMD_USER_DIR, { recursive: true });
+        await fs.writeFile(SERVICE_PATH, serviceContent(binPath), 'utf8');
+        await exec('systemctl', ['--user', 'daemon-reload']).catch(() => undefined);
+        await exec('systemctl', ['--user', 'enable', '--now', 'walldock-agent.service']).catch(() => undefined);
+        return;
+    }
+    // Fallback: XDG autostart .desktop file
+    await fs.mkdir(AUTOSTART_DIR, { recursive: true });
+    await fs.writeFile(DESKTOP_PATH, desktopContent(binPath), 'utf8');
+}
+async function unregisterLinux() {
+    await exec('systemctl', ['--user', 'disable', '--now', 'walldock-agent.service']).catch(() => undefined);
+    await fs.unlink(SERVICE_PATH).catch(() => undefined);
+    await fs.unlink(DESKTOP_PATH).catch(() => undefined);
+}
+// ─── Public API ──────────────────────────────────────────────────────────────
+async function registerStartup() {
+    if (process.platform === 'darwin')
+        return registerMacOS();
+    if (process.platform === 'win32')
+        return registerWindows();
+    return registerLinux();
+}
+async function unregisterStartup() {
+    if (process.platform === 'darwin')
+        return unregisterMacOS();
+    if (process.platform === 'win32')
+        return unregisterWindows();
+    return unregisterLinux();
+}
+function startupDescription() {
+    if (process.platform === 'darwin')
+        return `LaunchAgent at ${PLIST_PATH}`;
+    if (process.platform === 'win32')
+        return `Registry: ${REG_KEY}\\${REG_VALUE}`;
+    return `systemd user service (or ${DESKTOP_PATH})`;
+}
+/** Returns the resolved global bin path, or null if not globally installed. */
+async function getGlobalBin() {
+    try {
+        return await resolveGlobalBin();
+    }
+    catch {
+        return null;
+    }
+}

package/dist/sync.d.ts

@@ -0,0 +1,32 @@
+import { AgentApi } from './api';
+export interface SyncContext {
+    token: string;
+    deviceId: string;
+}
+export type ConnectionStatus = 'idle' | 'online' | 'error';
+export interface SyncCallbacks {
+    onTick(status: ConnectionStatus, lastSyncAt?: string): void;
+    onLog(msg: string): void;
+}
+export declare class SyncService {
+    private readonly api;
+    private readonly callbacks;
+    private context;
+    private timer;
+    private sse;
+    private tickInFlight;
+    private lastScreensFingerprint;
+    /** Per-process cache: stableId → wallpaperId we successfully applied */
+    private readonly applied;
+    constructor(api: AgentApi, callbacks: SyncCallbacks);
+    start(context: SyncContext): void;
+    stop(): void;
+    syncNow(): Promise<void>;
+    private scheduleNext;
+    private runTick;
+    private doTick;
+    private handlePush;
+    private reportScreensIfChanged;
+    private fetchCommands;
+    private reconcile;
+}

package/dist/sync.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncService = void 0;
+const index_1 = require("./screens/index");
+const index_2 = require("./wallpaper/index");
+const cache_1 = require("./cache");
+const sse_1 = require("./sse");
+const POLL_INTERVAL_MS = 15_000;
+class SyncService {
+    api;
+    callbacks;
+    context = null;
+    timer = null;
+    sse = null;
+    tickInFlight = null;
+    lastScreensFingerprint = null;
+    /** Per-process cache: stableId → wallpaperId we successfully applied */
+    applied = new Map();
+    constructor(api, callbacks) {
+        this.api = api;
+        this.callbacks = callbacks;
+    }
+    start(context) {
+        this.stop();
+        this.context = context;
+        this.lastScreensFingerprint = null;
+        this.applied.clear();
+        const sseUrl = `${this.api.endpoint.replace('/api/graphql', '')}/api/agent/events?token=${encodeURIComponent(context.token)}`;
+        this.sse = (0, sse_1.connectSse)(sseUrl, (type) => {
+            if (type === 'assignment-changed') {
+                void this.handlePush();
+            }
+        }, () => this.callbacks.onLog('SSE connected'));
+        void this.runTick().finally(() => this.scheduleNext());
+    }
+    stop() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        this.sse?.stop();
+        this.sse = null;
+        this.context = null;
+    }
+    async syncNow() {
+        if (this.context)
+            await this.runTick();
+    }
+    scheduleNext() {
+        if (!this.context)
+            return;
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            void this.runTick().finally(() => this.scheduleNext());
+        }, POLL_INTERVAL_MS);
+    }
+    runTick() {
+        if (this.tickInFlight)
+            return this.tickInFlight;
+        const ctx = this.context;
+        if (!ctx)
+            return Promise.resolve();
+        return (this.tickInFlight = this.doTick(ctx));
+    }
+    async doTick(ctx) {
+        try {
+            await this.reportScreensIfChanged(ctx);
+            await this.fetchCommands(ctx);
+            await this.reconcile(ctx);
+        }
+        finally {
+            this.tickInFlight = null;
+        }
+    }
+    async handlePush() {
+        if (this.tickInFlight || !this.context)
+            return;
+        try {
+            await this.reconcile(this.context);
+            this.callbacks.onTick('online', new Date().toISOString());
+        }
+        catch (err) {
+            this.callbacks.onLog(`[sync] push reconcile failed: ${err}`);
+        }
+    }
+    async reportScreensIfChanged(ctx) {
+        const screens = await (0, index_1.listScreens)();
+        if (screens.length === 0)
+            return;
+        const fp = (0, index_1.fingerprintScreens)(screens);
+        if (fp === this.lastScreensFingerprint)
+            return;
+        try {
+            await this.api.reportDeviceScreens(ctx.token, ctx.deviceId, screens);
+            this.lastScreensFingerprint = fp;
+        }
+        catch (err) {
+            this.callbacks.onLog(`[sync] reportScreens failed: ${err}`);
+        }
+    }
+    async fetchCommands(ctx) {
+        try {
+            const commands = await this.api.getDeviceCommands(ctx.token, ctx.deviceId);
+            for (const cmd of commands) {
+                this.callbacks.onLog(`[sync] command ${cmd.type} (${cmd.id})`);
+            }
+            this.callbacks.onTick('online', new Date().toISOString());
+        }
+        catch {
+            this.callbacks.onTick('error');
+        }
+    }
+    async reconcile(ctx) {
+        let assignments;
+        try {
+            assignments = await this.api.getDeviceScreenAssignments(ctx.token, ctx.deviceId);
+        }
+        catch (err) {
+            this.callbacks.onLog(`[sync] getAssignments failed: ${err}`);
+            return;
+        }
+        const screens = await (0, index_1.listScreens)();
+        const keepIds = [...new Set(assignments.map(a => a.wallpaperId).filter((id) => !!id))];
+        await Promise.all(assignments.map(async (assignment) => {
+            if (!assignment.imageUrl || !assignment.wallpaperId)
+                return;
+            if (this.applied.get(assignment.stableId) === assignment.wallpaperId)
+                return;
+            try {
+                const imageUrl = this.api.absoluteImageUrl(assignment.imageUrl);
+                const localPath = await (0, cache_1.ensureWallpaper)(assignment.wallpaperId, imageUrl, assignment.mimeType);
+                await (0, index_2.applyWallpaper)(localPath, assignment.stableId, screens);
+                this.applied.set(assignment.stableId, assignment.wallpaperId);
+                await this.api.acknowledgeApplied(ctx.token, ctx.deviceId, assignment.stableId, assignment.wallpaperId);
+                this.callbacks.onLog(`[sync] applied wallpaper ${assignment.wallpaperId} → ${assignment.stableId}`);
+            }
+            catch (err) {
+                this.callbacks.onLog(`[sync] apply failed for ${assignment.stableId}: ${err}`);
+            }
+        }));
+        await (0, cache_1.pruneCache)(keepIds);
+    }
+}
+exports.SyncService = SyncService;

package/dist/token-storage.d.ts

@@ -0,0 +1,10 @@
+export interface DeviceIdentity {
+    deviceId: string;
+    deviceName: string;
+}
+export declare function getDeviceToken(): Promise<string | null>;
+export declare function setDeviceToken(token: string): Promise<void>;
+export declare function deleteDeviceToken(): Promise<void>;
+export declare function getDeviceIdentity(): Promise<DeviceIdentity | null>;
+export declare function setDeviceIdentity(identity: DeviceIdentity): Promise<void>;
+export declare function clearDeviceIdentity(): Promise<void>;

package/dist/token-storage.js

@@ -0,0 +1,142 @@
+"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.getDeviceToken = getDeviceToken;
+exports.setDeviceToken = setDeviceToken;
+exports.deleteDeviceToken = deleteDeviceToken;
+exports.getDeviceIdentity = getDeviceIdentity;
+exports.setDeviceIdentity = setDeviceIdentity;
+exports.clearDeviceIdentity = clearDeviceIdentity;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const KEYTAR_SERVICE = 'walldock-agent';
+const KEYTAR_ACCOUNT = 'device-token';
+function configDir() {
+    if (process.platform === 'win32') {
+        return path.join(process.env['APPDATA'] ?? os.homedir(), 'walldock');
+    }
+    if (process.platform === 'darwin') {
+        return path.join(os.homedir(), 'Library', 'Application Support', 'walldock');
+    }
+    return path.join(process.env['XDG_CONFIG_HOME'] ?? path.join(os.homedir(), '.config'), 'walldock');
+}
+const CONFIG_FILE = path.join(configDir(), 'auth.json');
+async function readAuthFile() {
+    try {
+        const raw = await fs.readFile(CONFIG_FILE, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+async function writeAuthFile(data) {
+    await fs.mkdir(path.dirname(CONFIG_FILE), { recursive: true });
+    await fs.writeFile(CONFIG_FILE, JSON.stringify(data, null, 2), { mode: 0o600 });
+}
+async function tryKeytar() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        return require('keytar');
+    }
+    catch {
+        return null;
+    }
+}
+async function getDeviceToken() {
+    const keytar = await tryKeytar();
+    if (keytar) {
+        try {
+            const token = await keytar.getPassword(KEYTAR_SERVICE, KEYTAR_ACCOUNT);
+            if (token)
+                return token;
+        }
+        catch {
+            // fall through to file
+        }
+    }
+    const auth = await readAuthFile();
+    return auth.deviceToken ?? null;
+}
+async function setDeviceToken(token) {
+    const keytar = await tryKeytar();
+    if (keytar) {
+        try {
+            await keytar.setPassword(KEYTAR_SERVICE, KEYTAR_ACCOUNT, token);
+            // also write identity file (without token) so offline boot still works
+            const auth = await readAuthFile();
+            delete auth.deviceToken;
+            await writeAuthFile(auth);
+            return;
+        }
+        catch {
+            // fall through to file
+        }
+    }
+    const auth = await readAuthFile();
+    auth.deviceToken = token;
+    await writeAuthFile(auth);
+}
+async function deleteDeviceToken() {
+    const keytar = await tryKeytar();
+    if (keytar) {
+        try {
+            await keytar.deletePassword(KEYTAR_SERVICE, KEYTAR_ACCOUNT);
+        }
+        catch { /* ok */ }
+    }
+    const auth = await readAuthFile();
+    delete auth.deviceToken;
+    await writeAuthFile(auth);
+}
+async function getDeviceIdentity() {
+    const auth = await readAuthFile();
+    if (!auth.deviceId || !auth.deviceName)
+        return null;
+    return { deviceId: auth.deviceId, deviceName: auth.deviceName };
+}
+async function setDeviceIdentity(identity) {
+    const auth = await readAuthFile();
+    auth.deviceId = identity.deviceId;
+    auth.deviceName = identity.deviceName;
+    await writeAuthFile(auth);
+}
+async function clearDeviceIdentity() {
+    const auth = await readAuthFile();
+    delete auth.deviceId;
+    delete auth.deviceName;
+    await writeAuthFile(auth);
+}

package/dist/wallpaper/index.d.ts

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

package/dist/wallpaper/index.js

@@ -0,0 +1,51 @@
+"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.applyWallpaper = applyWallpaper;
+async function applyWallpaper(imagePath, stableId, screens) {
+    const index = screens.findIndex(s => s.stableId === stableId);
+    if (index === -1)
+        throw new Error(`No screen found for stableId ${stableId}`);
+    if (process.platform === 'darwin') {
+        const { setWallpaperMacOS } = await Promise.resolve().then(() => __importStar(require('./macos')));
+        return setWallpaperMacOS(imagePath, index);
+    }
+    if (process.platform === 'win32') {
+        const { setWallpaperWindows } = await Promise.resolve().then(() => __importStar(require('./windows')));
+        return setWallpaperWindows(imagePath, index);
+    }
+    const { setWallpaperLinux } = await Promise.resolve().then(() => __importStar(require('./linux')));
+    return setWallpaperLinux(imagePath, index, screens.length);
+}

package/dist/wallpaper/linux.d.ts

@@ -0,0 +1 @@
+export declare function setWallpaperLinux(imagePath: string, monitorIndex: number, totalMonitors: number): Promise<void>;