@amoshydra/davison 0.0.1

package/dist-server/services/sonos-controller.js

@@ -0,0 +1,298 @@
+import { Sonos } from 'sonos';
+import { EventEmitter } from 'node:events';
+import dgram from 'node:dgram';
+import os from 'node:os';
+import net from 'node:net';
+import { getMusicLibrary } from './music-discovery.js';
+const SSDP_MULTICAST_ADDR = '239.255.255.250';
+const SSDP_PORT = 1900;
+const SONOS_UPNP_PORT = 1400;
+const SSDP_TIMEOUT = 5000;
+const TCP_SCAN_PORT = 1400;
+const TCP_SCAN_TIMEOUT = 500;
+const TCP_SCAN_RESOLVE_DELAY = 600;
+const MULTICAST_TTL = 4;
+const IGNORED_IFACES = ['wg', 'tun', 'docker', 'br-'];
+function findLanAddress() {
+    const ifaces = os.networkInterfaces();
+    for (const [name, addrs] of Object.entries(ifaces)) {
+        if (!addrs)
+            continue;
+        if (IGNORED_IFACES.some(p => name.startsWith(p)))
+            continue;
+        for (const addr of addrs) {
+            if (addr.family === 'IPv4' && !addr.internal) {
+                return addr.address;
+            }
+        }
+    }
+    return '0.0.0.0';
+}
+function getSubnets() {
+    const subnets = [];
+    const ifaces = os.networkInterfaces();
+    for (const [name, addrs] of Object.entries(ifaces)) {
+        if (!addrs)
+            continue;
+        if (IGNORED_IFACES.some(p => name.startsWith(p)) || name === 'lo')
+            continue;
+        for (const addr of addrs) {
+            if (addr.family === 'IPv4' && !addr.internal && addr.cidr) {
+                subnets.push(addr.cidr);
+            }
+        }
+    }
+    return subnets;
+}
+function normalizeSonosState(state) {
+    const upper = state.toUpperCase();
+    if (upper === 'PLAYING' || upper === 'TRANSITIONING')
+        return 'PLAYING';
+    if (upper === 'PAUSED_PLAYBACK' || upper === 'PAUSED')
+        return 'PAUSED_PLAYBACK';
+    if (upper === 'STOPPED')
+        return 'STOPPED';
+    console.warn('Unknown Sonos state:', state);
+    return 'STOPPED';
+}
+class SonosController extends EventEmitter {
+    devices = new Map();
+    deviceInfo = new Map();
+    selectedDevice = null;
+    discovering = false;
+    async discoverDevices(timeout = SSDP_TIMEOUT) {
+        if (this.discovering) {
+            console.debug('Discovery already in progress');
+            return this.getDevices();
+        }
+        this.discovering = true;
+        try {
+            const lanAddr = findLanAddress();
+            const foundIps = new Set();
+            // SSDP multicast discovery
+            try {
+                await this.ssdpDiscover(foundIps, lanAddr, timeout);
+            }
+            catch (err) {
+                console.warn('SSDP discovery failed:', err);
+            }
+            // Fallback: TCP port scan
+            if (foundIps.size === 0) {
+                try {
+                    await this.tcpScan(foundIps);
+                }
+                catch (err) {
+                    console.warn('TCP scan failed:', err);
+                }
+            }
+            // Build new device map, preserve existing selected device
+            const newDevices = new Map();
+            const newDeviceInfo = new Map();
+            for (const ip of foundIps) {
+                try {
+                    const device = new Sonos(ip);
+                    const desc = await device.deviceDescription();
+                    const id = desc.UUID || device.host;
+                    const name = desc.roomName || desc.displayName || device.host;
+                    const group = name; // simplified; getAllGroups is slow per-device
+                    newDevices.set(id, device);
+                    newDeviceInfo.set(id, { id, name, ip: device.host, model: desc.modelName || '', group });
+                    this.emit('device-found', newDeviceInfo.get(id));
+                }
+                catch (err) {
+                    console.warn(`Failed to register device at ${ip}:`, err);
+                }
+            }
+            this.devices = newDevices;
+            this.deviceInfo = newDeviceInfo;
+            // If previously selected device is gone, clear selection
+            if (this.selectedDevice && !this.devices.has(this.selectedDevice)) {
+                console.warn('Previously selected device no longer available');
+                this.selectedDevice = null;
+            }
+            return this.getDevices();
+        }
+        finally {
+            this.discovering = false;
+        }
+    }
+    ssdpDiscover(foundIps, lanAddr, timeout) {
+        return new Promise((resolve) => {
+            const socket = dgram.createSocket({ type: 'udp4', reuseAddr: true });
+            socket.on('message', (msg, rinfo) => {
+                if (msg.toString().includes('Sonos')) {
+                    foundIps.add(rinfo.address);
+                }
+            });
+            socket.on('error', (err) => {
+                console.warn('SSDP socket error:', err);
+            });
+            try {
+                socket.bind(0, lanAddr, () => {
+                    socket.setMulticastTTL(MULTICAST_TTL);
+                    socket.setMulticastInterface(lanAddr);
+                    socket.setBroadcast(true);
+                    try {
+                        socket.addMembership(SSDP_MULTICAST_ADDR, lanAddr);
+                    }
+                    catch (err) {
+                        console.warn('Failed to join SSDP multicast group:', err);
+                    }
+                    const search = Buffer.from('M-SEARCH * HTTP/1.1\r\n' +
+                        `HOST: ${SSDP_MULTICAST_ADDR}:${SSDP_PORT}\r\n` +
+                        'MAN: "ssdp:discover"\r\n' +
+                        'MX: 3\r\n' +
+                        'ST: urn:schemas-upnp-org:device:ZonePlayer:1\r\n' +
+                        '\r\n');
+                    socket.send(search, 0, search.length, SSDP_PORT, SSDP_MULTICAST_ADDR);
+                    socket.send(search, 0, search.length, SSDP_PORT, '255.255.255.255');
+                });
+            }
+            catch (err) {
+                console.warn('Failed to bind SSDP socket:', err);
+            }
+            setTimeout(() => {
+                try {
+                    socket.close();
+                }
+                catch { /* best effort */ }
+                resolve();
+            }, timeout);
+        });
+    }
+    tcpScan(foundIps) {
+        const subnets = getSubnets();
+        const scanPromises = [];
+        for (const cidr of subnets) {
+            const [base, prefixStr] = cidr.split('/');
+            const prefix = parseInt(prefixStr, 10);
+            if (prefix >= 24) {
+                const parts = base.split('.');
+                const networkPrefix = parts.slice(0, 3).join('.');
+                for (let i = 1; i <= 254; i++) {
+                    const ip = `${networkPrefix}.${i}`;
+                    scanPromises.push(this.tryConnect(ip, foundIps));
+                }
+            }
+        }
+        return Promise.all(scanPromises).then(() => { });
+    }
+    tryConnect(ip, foundIps) {
+        return new Promise((resolve) => {
+            const s = new net.Socket();
+            let resolved = false;
+            const done = () => {
+                if (!resolved) {
+                    resolved = true;
+                    s.destroy();
+                    resolve();
+                }
+            };
+            s.setTimeout(TCP_SCAN_TIMEOUT);
+            s.on('connect', () => {
+                foundIps.add(ip);
+                done();
+            });
+            s.on('error', done);
+            s.on('timeout', done);
+            s.connect(TCP_SCAN_PORT, ip);
+            setTimeout(done, TCP_SCAN_RESOLVE_DELAY);
+        });
+    }
+    getDevices() {
+        return Array.from(this.deviceInfo.values());
+    }
+    selectDevice(id) {
+        if (!this.devices.has(id))
+            return false;
+        this.selectedDevice = id;
+        return true;
+    }
+    hasDevice() {
+        return this.selectedDevice !== null;
+    }
+    getDevice() {
+        if (!this.selectedDevice)
+            return undefined;
+        return this.devices.get(this.selectedDevice);
+    }
+    async getStatus() {
+        const device = this.getDevice();
+        if (!device)
+            return null;
+        try {
+            const [trackInfo, transportInfo, volume, muted] = await Promise.all([
+                device.currentTrack(),
+                device.getCurrentState(),
+                device.getVolume(),
+                device.getMuted(),
+            ]);
+            const sonosTitle = trackInfo?.title || '';
+            const sonosArtist = trackInfo?.artist || '';
+            const library = getMusicLibrary();
+            const matched = library.find(t => t.title === sonosTitle && t.artist === sonosArtist);
+            return {
+                state: normalizeSonosState(transportInfo),
+                track: {
+                    trackId: matched?.id,
+                    title: sonosTitle || 'Unknown',
+                    artist: sonosArtist || 'Unknown',
+                    album: trackInfo?.album || 'Unknown',
+                    albumArt: trackInfo?.albumArtURI || '',
+                    duration: trackInfo?.duration || 0,
+                    position: trackInfo?.position || 0,
+                },
+                volume,
+                muted,
+            };
+        }
+        catch (err) {
+            console.warn('Failed to get Sonos status:', err);
+            return null;
+        }
+    }
+    async play() {
+        await this.getDevice()?.play();
+    }
+    async pause() {
+        await this.getDevice()?.pause();
+    }
+    async stop() {
+        await this.getDevice()?.stop();
+    }
+    async next() {
+        await this.getDevice()?.next();
+    }
+    async previous() {
+        await this.getDevice()?.previous();
+    }
+    async setVolume(volume) {
+        await this.getDevice()?.setVolume(volume);
+    }
+    async getVolume() {
+        return (await this.getDevice()?.getVolume()) ?? 0;
+    }
+    async playUri(uri, title) {
+        const device = this.getDevice();
+        if (!device) {
+            throw new Error('No device selected');
+        }
+        const trackTitle = title || uri.split('/').pop() || 'Music';
+        const escapedTitle = trackTitle.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+        const metadata = `<DIDL-Lite xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:upnp="urn:schemas-upnp-org:metadata-1-0/upnp/" xmlns:r="urn:schemas-rinconnetworks-com:metadata-1-0/" xmlns="urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/"><item id="0" parentID="A:TRACKS" restricted="true"><dc:title>${escapedTitle}</dc:title><upnp:class>object.item.audioItem.musicTrack</upnp:class><desc id="cdudn" nameSpace="urn:schemas-rinconnetworks-com:metadata-1-0/">RINCON_AssociatedZPUDN</desc></item></DIDL-Lite>`;
+        try {
+            await device.setAVTransportURI({ uri, metadata });
+        }
+        catch (err) {
+            console.error(`Failed to play URI on ${device.host}:`, err);
+            throw err;
+        }
+    }
+    async queueUri(uri) {
+        await this.getDevice()?.queue(uri);
+    }
+    async flushQueue() {
+        await this.getDevice()?.flush();
+    }
+}
+export const sonosController = new SonosController();

package/dist-server/services/webdav.js

@@ -0,0 +1,381 @@
+import createServer from 'nephele';
+import { ResourceNotFoundError, BadGatewayError, ForbiddenError } from 'nephele/dist/Errors/index.js';
+import { createReadStream } from 'node:fs';
+import { stat } from 'node:fs/promises';
+import path from 'node:path';
+import { getMusicLibrary } from './music-discovery.js';
+import os from 'node:os';
+import mime from 'mime';
+function buildDirs(tracks) {
+    const roots = [];
+    for (const track of tracks) {
+        const parts = track.relativePath.split('/');
+        const fileName = parts.pop();
+        // Sanitize baseName: replace / with _ for filesystem-safe names
+        const baseName = track.baseName.replace(/\//g, '_');
+        const dirParts = baseName ? [baseName, ...parts] : parts;
+        let level = roots;
+        for (const segment of dirParts) {
+            let dir = level.find(d => d.name === segment);
+            if (!dir) {
+                dir = { name: segment, tracks: [], dirs: [] };
+                level.push(dir);
+            }
+            level = dir.dirs;
+        }
+        level.push({ name: fileName, tracks: [{ filePath: track.filePath, title: track.title }], dirs: [] });
+    }
+    function wrapRootTracks(node) {
+        const trackLeaves = node.dirs.filter(d => d.dirs.length === 0 && d.tracks.length <= 1);
+        const subdirs = node.dirs.filter(d => d.dirs.length > 0 || d.tracks.length > 1);
+        if (trackLeaves.length > 0 && subdirs.length > 0) {
+            node.dirs = [...subdirs, { name: '<root>', tracks: trackLeaves.flatMap(d => d.tracks), dirs: [] }];
+        }
+        for (const sub of node.dirs)
+            wrapRootTracks(sub);
+        node.dirs.sort((a, b) => {
+            const af = a.dirs.length > 0 || a.tracks.length > 1 || a.name === '<root>';
+            const bf = b.dirs.length > 0 || b.tracks.length > 1 || b.name === '<root>';
+            if (af && !bf)
+                return -1;
+            if (!af && bf)
+                return 1;
+            if (a.name === '<root>')
+                return 1;
+            if (b.name === '<root>')
+                return -1;
+            return a.name.localeCompare(b.name);
+        });
+    }
+    for (const r of roots)
+        wrapRootTracks(r);
+    roots.sort((a, b) => {
+        const af = a.dirs.length > 0 || a.tracks.length > 1 || a.name === '<root>';
+        const bf = b.dirs.length > 0 || b.tracks.length > 1 || b.name === '<root>';
+        if (af && !bf)
+            return -1;
+        if (!af && bf)
+            return 1;
+        if (a.name === '<root>')
+            return 1;
+        if (b.name === '<root>')
+            return -1;
+        return a.name.localeCompare(b.name);
+    });
+    return roots;
+}
+// ─── Virtual adapter ───
+function findNode(pathParts, nodes) {
+    if (pathParts.length === 0)
+        return { node: nodes.length > 0 ? { name: '', tracks: [], dirs: nodes } : null, trackIndex: null, realPath: null };
+    const name = pathParts[0];
+    const rest = pathParts.slice(1);
+    for (const n of nodes) {
+        if (n.name === name) {
+            // Leaf track node (single file, no subdirs)
+            if (n.dirs.length === 0 && n.tracks.length === 1) {
+                return { node: null, trackIndex: null, realPath: n.tracks[0].filePath };
+            }
+            // Multi-track leaf node (e.g. <root> group, several loose files)
+            if (rest.length === 0 && n.tracks.length > 0) {
+                return { node: n, trackIndex: null, realPath: null };
+            }
+            if (rest.length === 0)
+                return { node: n, trackIndex: null, realPath: null };
+            if (n.dirs.length > 0)
+                return findNode(rest, n.dirs);
+            if (n.tracks.length > 0) {
+                for (let i = 0; i < n.tracks.length; i++) {
+                    if (rest[0] === path.basename(n.tracks[i].filePath)) {
+                        return { node: n, trackIndex: i, realPath: n.tracks[i].filePath };
+                    }
+                }
+            }
+            return { node: null, trackIndex: null, realPath: null };
+        }
+    }
+    return { node: null, trackIndex: null, realPath: null };
+}
+async function getRealSize(filePath) {
+    try {
+        return (await stat(filePath)).size;
+    }
+    catch {
+        return 0;
+    }
+}
+async function getRealMtime(filePath) {
+    try {
+        return (await stat(filePath)).mtime;
+    }
+    catch {
+        return new Date();
+    }
+}
+// Simple read-only in-memory resource
+function createVirtualResource(adapter, baseUrl, nodePath, node, realPath, isCollection) {
+    let cachedSize;
+    let cachedMtime;
+    async function ensureStats() {
+        if (realPath && cachedSize === undefined) {
+            const s = await stat(realPath);
+            cachedSize = s.size;
+            cachedMtime = s.mtime;
+        }
+    }
+    return {
+        adapter,
+        baseUrl,
+        path: nodePath,
+        collection: isCollection,
+        get absolutePath() { return realPath || nodePath; },
+        async getCanonicalPath() {
+            const segments = nodePath.split('/').filter(Boolean);
+            const p = segments.length > 0 ? '/' + segments.join(path.sep) : '/';
+            return isCollection ? p.replace(/\/?$/, '/') : p;
+        },
+        async getCanonicalUrl() {
+            const segments = nodePath.split('/').filter(Boolean);
+            const relPath = segments.length > 0 ? segments.join('/') + (isCollection ? '/' : '') : '';
+            return new URL(relPath, baseUrl);
+        },
+        async isCollection() { return isCollection; },
+        async exists() { return node !== null || realPath !== null; },
+        async getSize() {
+            if (realPath) {
+                await ensureStats();
+                return cachedSize || 0;
+            }
+            return 0;
+        },
+        async getLength() { return this.getSize(); },
+        async getModificationTime() {
+            if (realPath) {
+                await ensureStats();
+                return cachedMtime || new Date();
+            }
+            return new Date();
+        },
+        async getCreationTime() {
+            if (realPath) {
+                await ensureStats();
+                return cachedMtime || new Date();
+            }
+            return new Date();
+        },
+        async getEtag() {
+            const { createHash } = await import('node:crypto');
+            return createHash('md5').update(nodePath).digest('hex');
+        },
+        async getContentType() {
+            if (realPath)
+                return mime.getType(realPath) || 'application/octet-stream';
+            return 'httpd/unix-directory';
+        },
+        async getMediaType() { return this.getContentType(); },
+        async getStream(range) {
+            if (!realPath) {
+                const { Readable } = await import('node:stream');
+                return Readable.from([]);
+            }
+            if (range) {
+                return createReadStream(realPath, { start: range.start, end: range.end });
+            }
+            return createReadStream(realPath);
+        },
+        async getInternalMembers() {
+            if (!isCollection || !node)
+                return [];
+            const members = [];
+            // Subdirectories and track leaf nodes (sorted by buildDirs)
+            for (const dir of node.dirs) {
+                // Leaf track nodes (in dirs array from buildDirs) are files, not directories
+                if (dir.tracks.length === 1 && dir.dirs.length === 0) {
+                    const filePath = dir.tracks[0].filePath;
+                    const fileName = path.basename(filePath);
+                    members.push(createVirtualResource(adapter, baseUrl, `${nodePath}/${fileName}`, null, filePath, false));
+                }
+                else {
+                    members.push(createVirtualResource(adapter, baseUrl, `${nodePath}/${dir.name}/`, dir, null, true));
+                }
+            }
+            // Tracks at this level
+            for (let i = 0; i < node.tracks.length; i++) {
+                const fileName = path.basename(node.tracks[i].filePath);
+                members.push(createVirtualResource(adapter, baseUrl, `${nodePath}/${fileName}`, null, node.tracks[i].filePath, false));
+            }
+            return members;
+        },
+        async readMetadataFile() { return {}; },
+        async writeMetadataFile() { },
+        async delete() { throw new ForbiddenError('Forbidden'); },
+        async setProperty() { },
+        async removeProperty() { },
+        getProperties() {
+            const resolve = async (name) => {
+                switch (name) {
+                    case 'getcontentlength':
+                        return String(isCollection ? 0 : (realPath ? await getRealSize(realPath) : 0));
+                    case 'getlastmodified': {
+                        const d = await getRealMtime(realPath || '');
+                        return d.toUTCString();
+                    }
+                    case 'creationdate': {
+                        const d = await getRealMtime(realPath || '');
+                        return d.toISOString();
+                    }
+                    case 'getcontenttype':
+                        if (realPath)
+                            return mime.getType(realPath) || 'application/octet-stream';
+                        return 'httpd/unix-directory';
+                    case 'getetag': {
+                        const { createHash } = await import('node:crypto');
+                        return createHash('md5').update(nodePath).digest('hex');
+                    }
+                    case 'resourcetype':
+                        return isCollection ? { collection: {} } : undefined;
+                    case 'displayname':
+                        return nodePath.split('/').filter(Boolean).pop() || '/';
+                    case 'supportedlock':
+                        return undefined;
+                    default:
+                        return undefined;
+                }
+            };
+            // Standard live property names
+            const liveNames = [
+                'creationdate', 'getcontentlength', 'getcontenttype',
+                'getetag', 'getlastmodified', 'resourcetype', 'supportedlock',
+                'displayname',
+            ];
+            return {
+                get: resolve,
+                getByUser: async (name) => resolve(name),
+                getAllByUser: async () => {
+                    const out = {};
+                    for (const name of liveNames) {
+                        const v = await resolve(name);
+                        if (v !== undefined)
+                            out[name] = v;
+                    }
+                    return out;
+                },
+                listByUser: async () => liveNames,
+                listLiveByUser: async () => liveNames,
+                listDeadByUser: async () => [],
+                getAll: async () => {
+                    const out = {};
+                    for (const name of liveNames) {
+                        const v = await resolve(name);
+                        if (v !== undefined)
+                            out[name] = v;
+                    }
+                    return out;
+                },
+                list: async () => liveNames,
+                listLive: async () => liveNames,
+                listDead: async () => [],
+                set: async () => { },
+                setByUser: async () => { },
+                remove: async () => { },
+                removeByUser: async () => { },
+                runInstructions: async () => undefined,
+                runInstructionsByUser: async () => undefined,
+            };
+        },
+        getLocks() { return []; },
+        getLocksByUser() { return []; },
+        addLock() { },
+        removeLock() { },
+        removeLocksByUser() { },
+        cleanLocks() { },
+    };
+}
+// ─── Nephele Adapter ───
+class VirtualAdapter {
+    tree;
+    rootNode;
+    constructor(tree) {
+        this.tree = tree;
+        this.rootNode = { name: '', tracks: [], dirs: tree };
+    }
+    urlToRelativePath(url, baseUrl) {
+        const urlPath = decodeURIComponent(url.pathname).replace(/\/?$/, '/');
+        const basePath = decodeURIComponent(baseUrl.pathname).replace(/\/?$/, '/');
+        if (!urlPath.startsWith(basePath))
+            return null;
+        const rel = urlPath.substring(basePath.length).replace(/\/$/, '');
+        return '/' + rel;
+    }
+    urlToAbsolutePath(url, baseUrl) {
+        const rel = this.urlToRelativePath(url, baseUrl);
+        if (rel == null)
+            return null;
+        return rel;
+    }
+    async getUid() { return os.userInfo().uid; }
+    async getGid() { return os.userInfo().gid; }
+    async getGids() { return [os.userInfo().gid]; }
+    async getComplianceClasses() { return []; }
+    async getAllowedMethods() { return []; }
+    async getOptionsResponseCacheControl() { return 'max-age=604800'; }
+    async isAuthorized() { return true; }
+    getMethod(method) {
+        // Standard HTTP methods are handled by Nephele's built-in routes (GET, HEAD,
+        // PUT, DELETE, COPY, MOVE, MKCOL, LOCK, UNLOCK, OPTIONS, PROPFIND, PROPPATCH).
+        // This fallback is only for unrecognized methods.
+        const err = new Error('Method not supported: ' + method);
+        err.statusCode = 405;
+        throw err;
+    }
+    async getResource(url, baseUrl) {
+        const relPath = this.urlToRelativePath(url, baseUrl);
+        if (relPath == null)
+            throw new BadGatewayError('Bad Gateway');
+        const parts = relPath.split('/').filter(Boolean);
+        if (parts.length === 0) {
+            // Root node
+            return createVirtualResource(this, baseUrl, '/', this.rootNode, null, true);
+        }
+        const { node, trackIndex, realPath } = findNode(parts, this.tree);
+        if (!node && !realPath)
+            throw new ResourceNotFoundError('Resource not found');
+        const isCollection = !realPath;
+        const nodePath = '/' + parts.join('/');
+        if (realPath) {
+            return createVirtualResource(this, baseUrl, nodePath, null, realPath, false);
+        }
+        if (node && node.tracks.length === 1 && node.dirs.length === 0) {
+            return createVirtualResource(this, baseUrl, nodePath, null, node.tracks[0].filePath, false);
+        }
+        // Handle multi-track nodes: find track by filename in URL
+        if (node && node.tracks.length > 1) {
+            const fileName = parts[parts.length - 1];
+            const matched = node.tracks.find(t => path.basename(t.filePath) === fileName);
+            if (matched) {
+                return createVirtualResource(this, baseUrl, nodePath, null, matched.filePath, false);
+            }
+        }
+        return createVirtualResource(this, baseUrl, nodePath + '/', node, null, true);
+    }
+    async newResource() { throw new ForbiddenError('Forbidden'); }
+    async newCollection() { throw new ForbiddenError('Forbidden'); }
+}
+// ─── Server setup ───
+let _webdavApp = null;
+export function initWebdav() {
+    if (_webdavApp)
+        return _webdavApp;
+    const tracks = getMusicLibrary();
+    const tree = buildDirs(tracks);
+    const adapter = new VirtualAdapter(tree);
+    class NoAuth {
+        async authenticate() { return { username: 'sonos' }; }
+        async cleanAuthentication() { }
+    }
+    _webdavApp = createServer({
+        adapter: adapter,
+        authenticator: new NoAuth(),
+    });
+    return _webdavApp;
+}