sliftutils 1.7.9 → 1.7.11

package/storage/remoteStorage/dist/storageController.ts.cache

@@ -0,0 +1,500 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.RemoteStorageController = exports.STORAGE_ACCESS_DENIED = exports.STORAGE_NOT_AUTHENTICATED = exports.STORAGE_AUTH_PURPOSE = exports.REMOTE_STORAGE_CLASS_GUID = void 0;
+module.allowclient = true;
+const SocketFunction_1 = require("socket-function/SocketFunction");
+const nodeCache_1 = require("socket-function/src/nodeCache");
+const callHTTPHandler_1 = require("socket-function/src/callHTTPHandler");
+const callManager_1 = require("socket-function/src/callManager");
+const RequireController_1 = require("socket-function/require/RequireController");
+const misc_1 = require("socket-function/src/misc");
+const certs_1 = require("../../misc/https/certs");
+const IArchives_1 = require("../IArchives");
+const remoteConfig_1 = require("./remoteConfig");
+const storageServerState_1 = require("./storageServerState");
+// The remote storage server's API. Authentication uses certs.ts machine identities: a client
+// proves it owns its machine key by signing a timestamped token (bound to this server, so tokens
+// can't be replayed elsewhere), and the server then trusts that connection as that machineId.
+// Access to an account is granted to specific machineIds, via a command line command run on the
+// storage machine (see storageServer.ts).
+//
+// There is no bucket-creation API: a bucket exists iff its routing config (ROUTING_FILE) exists,
+// and writing that file creates or reconfigures the bucket (see storageServerState.ts). Reads of
+// nonexistent buckets return undefined / empty, same as reads of nonexistent files.
+exports.REMOTE_STORAGE_CLASS_GUID = "RemoteStorageController-b7e42a91";
+exports.STORAGE_AUTH_PURPOSE = "remoteStorage-auth-1";
+// Error markers, so clients can identify these failures inside error messages
+exports.STORAGE_NOT_AUTHENTICATED = "REMOTE_STORAGE_NOT_AUTHENTICATED_cf2f7b1e";
+exports.STORAGE_ACCESS_DENIED = "REMOTE_STORAGE_ACCESS_DENIED_9d81a4c0";
+const AUTH_TIME_WINDOW = misc_1.timeInMinute * 10;
+const MAX_SESSIONS = 100 * 1000;
+const MAX_REQUESTS_PER_IP = 50;
+// callerNodeId -> authenticated machineId. Connections are long-lived websockets, so a session
+// lasts until the connection drops (clients re-authenticate on reconnect).
+const sessions = new Map();
+const CONTENT_TYPES = {
+    html: "text/html", js: "text/javascript", css: "text/css", json: "application/json",
+    txt: "text/plain", png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif",
+    svg: "image/svg+xml", webp: "image/webp", mp4: "video/mp4", webm: "video/webm",
+    mp3: "audio/mpeg", wav: "audio/wav", pdf: "application/pdf",
+};
+function assertValidName(value, kind) {
+    if (!/^[\w-]{1,64}$/.test(value)) {
+        throw new Error(`Invalid ${kind} ${JSON.stringify(value)}, expected 1-64 characters of letters/numbers/underscore/dash`);
+    }
+}
+function assertValidPath(path) {
+    if (Buffer.from(path, "utf8").length > 1000) {
+        throw new Error(`Path too long: ${path.length} characters > 1000. Path: ${path.slice(0, 200)}`);
+    }
+    if (!path || path.startsWith("/") || path.endsWith("/") || path.includes("//") || path.includes("\\") || path.includes("\x00")) {
+        throw new Error(`Invalid path ${JSON.stringify(path.slice(0, 200))}, paths cannot be empty, start or end with /, or contain //, backslashes, or null characters`);
+    }
+    // Paths are one-to-one with files on disk, so . and .. segments would escape the store folder
+    if (path.split("/").some(part => part === "." || part === "..")) {
+        throw new Error(`Invalid path ${JSON.stringify(path.slice(0, 200))}, paths cannot contain . or .. segments`);
+    }
+}
+function getCallerMachineId() {
+    let caller = SocketFunction_1.SocketFunction.getCaller();
+    let machineId = sessions.get(caller.nodeId);
+    if (!machineId) {
+        throw new Error(`${exports.STORAGE_NOT_AUTHENTICATED} Call authenticate first (connection ${caller.nodeId})`);
+    }
+    return machineId;
+}
+function getCallerIP() {
+    return (0, nodeCache_1.getNodeIdIP)(SocketFunction_1.SocketFunction.getCaller().nodeId);
+}
+function isAdmin(machineId) {
+    return machineId === (0, certs_1.getOwnMachineId)((0, storageServerState_1.getStorageServerConfig)().rootDomain);
+}
+function requireAdmin() {
+    let machineId = getCallerMachineId();
+    if (!isAdmin(machineId)) {
+        throw new Error(`${exports.STORAGE_ACCESS_DENIED} Admin commands must be run from the storage machine itself (caller machine ${machineId})`);
+    }
+    return machineId;
+}
+async function requireAccess(account) {
+    assertValidName(account, "account");
+    let machineId = getCallerMachineId();
+    if (isAdmin(machineId))
+        return machineId;
+    let trust = await (0, storageServerState_1.getTrust)();
+    let trusted = await trust.get(`${account}|${machineId}`);
+    if (!trusted) {
+        let { domain, port } = (0, storageServerState_1.getStorageServerConfig)();
+        throw new Error(`${exports.STORAGE_ACCESS_DENIED} Machine ${machineId} has no access to account ${JSON.stringify(account)}. Visit https://${domain}:${port}/${account} for access instructions.`);
+    }
+    return machineId;
+}
+// A single command, runnable from anywhere, that sshes into the storage machine and runs the
+// grantAccess CLI there
+function getGrantAccessCommand(requestId) {
+    let { sshTarget, serverCommand } = (0, storageServerState_1.getStorageServerConfig)();
+    return `ssh ${sshTarget} '${serverCommand} --requestId ${requestId}'`;
+}
+async function getBucket(account, bucketName) {
+    assertValidName(account, "account");
+    assertValidName(bucketName, "bucket name");
+    return await (0, storageServerState_1.getLoadedBucket)(account, bucketName);
+}
+class RemoteStorageControllerBase {
+    // Latency measurement (see SourceWrapper's pinging); no auth, it measures the transport
+    async ping() { }
+    // Proves the caller owns the machine key for the machineId in its certificate. The signature
+    // must be fresh and bound to this server, so it cannot be replayed to (or from) other servers.
+    async authenticate(token) {
+        let { domain, port } = (0, storageServerState_1.getStorageServerConfig)();
+        let caller = SocketFunction_1.SocketFunction.getCaller();
+        if (Math.abs(Date.now() - token.time) > AUTH_TIME_WINDOW) {
+            throw new Error(`Auth token time is too far from the server time (token ${token.time}, server ${Date.now()}, allowed drift ${AUTH_TIME_WINDOW}ms)`);
+        }
+        (0, certs_1.verify)(token.certPem, token.signature, {
+            purpose: exports.STORAGE_AUTH_PURPOSE,
+            time: token.time,
+            server: `${domain}:${port}`,
+        });
+        let machineId = (0, certs_1.getCommonName)(token.certPem).split(".")[0];
+        if (!(0, certs_1.verifyMachineIdForPublicKey)({ machineId, publicKey: (0, certs_1.getPublicIdentifier)(token.certPem) })) {
+            throw new Error(`Certificate common name ${JSON.stringify((0, certs_1.getCommonName)(token.certPem))} does not match its public key`);
+        }
+        sessions.set(caller.nodeId, machineId);
+        while (sessions.size > MAX_SESSIONS) {
+            let oldest = sessions.keys().next().value;
+            if (oldest === undefined)
+                break;
+            sessions.delete(oldest);
+        }
+        return { machineId, ip: getCallerIP() };
+    }
+    // Records that the calling machine wants access to an account. Requests are kept per requesting
+    // IP, so the storage machine's admin can list them with --listAccess <ip> and grant one.
+    async requestAccess(account) {
+        assertValidName(account, "account");
+        let machineId = getCallerMachineId();
+        let ip = getCallerIP();
+        let requestsStorage = await (0, storageServerState_1.getRequests)();
+        let requests = await requestsStorage.get(ip) || [];
+        let existing = requests.find(x => x.account === account && x.machineId === machineId);
+        if (existing) {
+            existing.time = Date.now();
+        }
+        else {
+            existing = {
+                requestId: Math.random().toString(36).slice(2, 10),
+                account,
+                machineId,
+                ip,
+                time: Date.now(),
+            };
+            requests.push(existing);
+        }
+        while (requests.length > MAX_REQUESTS_PER_IP)
+            requests.shift();
+        await requestsStorage.set(ip, requests);
+        return { machineId, ip, requestId: existing.requestId, grantAccessCommand: getGrantAccessCommand(existing.requestId) };
+    }
+    async getAccessState(account) {
+        assertValidName(account, "account");
+        let machineId = getCallerMachineId();
+        let ip = getCallerIP();
+        let trust = await (0, storageServerState_1.getTrust)();
+        let hasAccess = isAdmin(machineId) || !!await trust.get(`${account}|${machineId}`);
+        let result = { machineId, ip, hasAccess };
+        if (!hasAccess) {
+            let requests = await (0, storageServerState_1.getRequests)();
+            let ownRequest = (await requests.get(ip) || []).find(x => x.account === account && x.machineId === machineId);
+            if (ownRequest) {
+                result.grantAccessCommand = getGrantAccessCommand(ownRequest.requestId);
+            }
+            return result;
+        }
+        let trustedMachines = [];
+        for (let key of await trust.getKeys()) {
+            if (!key.startsWith(`${account}|`))
+                continue;
+            let record = await trust.get(key);
+            if (record)
+                trustedMachines.push(record);
+        }
+        result.trustedMachines = trustedMachines;
+        return result;
+    }
+    // Callable by any machine that has access to `account`. Returns pending access requests for the
+    // account that come from EXACTLY `ip`. Callers must type in an IP explicitly — the server never
+    // volunteers a list of requesting IPs, so a trusted user can't accidentally approve a random
+    // request from a machine they didn't mean to trust.
+    async listRequestsForIP(account, ip) {
+        let requests = await (0, storageServerState_1.getRequests)();
+        return (await requests.get(ip) || []).filter(x => x.account === account);
+    }
+    // Callable by any machine that has access to the request's account (or by the storage-machine
+    // admin). Grants the requested access; the caller must supply the specific requestId, which they
+    // only get by explicitly looking up requests for a specific IP.
+    async grantAccess(requestId) {
+        // Must capture in the synchronous phase — SocketFunction.getCaller() only works before any await.
+        let callerMachineId = getCallerMachineId();
+        let trust = await (0, storageServerState_1.getTrust)();
+        let requests = await (0, storageServerState_1.getRequests)();
+        for (let ip of await requests.getKeys()) {
+            for (let request of await requests.get(ip) || []) {
+                if (request.requestId !== requestId)
+                    continue;
+                if (!isAdmin(callerMachineId) && !await trust.get(`${request.account}|${callerMachineId}`)) {
+                    throw new Error(`${exports.STORAGE_ACCESS_DENIED} Machine ${callerMachineId} has no access to account ${JSON.stringify(request.account)}`);
+                }
+                let record = {
+                    account: request.account,
+                    machineId: request.machineId,
+                    ip: request.ip,
+                    time: Date.now(),
+                };
+                await trust.set(`${request.account}|${request.machineId}`, record);
+                return record;
+            }
+        }
+        throw new Error(`No access request found with id ${JSON.stringify(requestId)}. It may have already been granted or expired.`);
+    }
+    // Admin (must be run from the storage machine itself, which shares the server's machineId).
+    // Only returns requests for the given IP, so you cannot accidentally grant a request from an
+    // IP you didn't explicitly type in.
+    async adminListRequests(ip) {
+        let requests = await (0, storageServerState_1.getRequests)();
+        return await requests.get(ip) || [];
+    }
+    async adminGrantAccess(requestId) {
+        let trust = await (0, storageServerState_1.getTrust)();
+        let requests = await (0, storageServerState_1.getRequests)();
+        for (let ip of await requests.getKeys()) {
+            for (let request of await requests.get(ip) || []) {
+                if (request.requestId !== requestId)
+                    continue;
+                let record = {
+                    account: request.account,
+                    machineId: request.machineId,
+                    ip: request.ip,
+                    time: Date.now(),
+                };
+                await trust.set(`${request.account}|${request.machineId}`, record);
+                return record;
+            }
+        }
+        throw new Error(`No access request found with id ${JSON.stringify(requestId)}. It may have already been granted or expired.`);
+    }
+    async get(account, bucketName, path, range) {
+        let result = await this.get2(account, bucketName, path, range);
+        return result && result.data || undefined;
+    }
+    async get2(account, bucketName, path, range) {
+        assertValidPath(path);
+        let bucket = await getBucket(account, bucketName);
+        if (!bucket)
+            return undefined;
+        return await bucket.store.get2(path, { range });
+    }
+    async set(account, bucketName, path, data, lastModified) {
+        assertValidName(bucketName, "bucket name");
+        assertValidPath(path);
+        // Handles bucket creation (writes of ROUTING_FILE), reconfiguration, fast mode, and
+        // immutability — see storageServerState.ts
+        await (0, storageServerState_1.writeBucketFile)(account, bucketName, path, Buffer.from(data), { lastModified });
+    }
+    async del(account, bucketName, path) {
+        assertValidName(bucketName, "bucket name");
+        assertValidPath(path);
+        await (0, storageServerState_1.deleteBucketFile)(account, bucketName, path);
+    }
+    async getInfo(account, bucketName, path) {
+        assertValidPath(path);
+        let bucket = await getBucket(account, bucketName);
+        if (!bucket)
+            return undefined;
+        return await bucket.store.getInfo(path);
+    }
+    async findInfo(account, bucketName, prefix, config) {
+        let bucket = await getBucket(account, bucketName);
+        if (!bucket)
+            return [];
+        return await bucket.store.findInfo(prefix, config);
+    }
+    // Fast (served from the store's BulkDatabase2 index, not a scan) — see IArchives.getChangesAfter
+    async getChangesAfter(account, bucketName, time) {
+        let bucket = await getBucket(account, bucketName);
+        if (!bucket)
+            return [];
+        if (!bucket.store.getChangesAfter) {
+            throw new Error(`Bucket ${account}/${bucketName} does not support getChangesAfter (rawDisk buckets have no index)`);
+        }
+        return await bucket.store.getChangesAfter(time);
+    }
+    async getArchivesConfig(account, bucketName) {
+        var _a, _b;
+        let bucket = await getBucket(account, bucketName);
+        // Missing buckets say true, matching what they become once created (the default store type)
+        let progress = (_b = bucket === null || bucket === void 0 ? void 0 : (_a = bucket.store).getSyncProgress) === null || _b === void 0 ? void 0 : _b.call(_a);
+        return {
+            supportsChangesAfter: !bucket || !!bucket.store.getChangesAfter,
+            remoteConfig: bucket === null || bucket === void 0 ? void 0 : bucket.routing,
+            index: progress === null || progress === void 0 ? void 0 : progress.index,
+            indexSources: progress === null || progress === void 0 ? void 0 : progress.sources,
+            readerDiskLimit: progress === null || progress === void 0 ? void 0 : progress.readerDiskLimit,
+            syncing: progress === null || progress === void 0 ? void 0 : progress.syncing,
+        };
+    }
+    /** Walks the whole index for exact totals (overall and per holding source) - more expensive
+     *  than the maintained counters that getArchivesConfig returns, but immune to counter drift. */
+    async getIndexInfo(account, bucketName) {
+        let bucket = await getBucket(account, bucketName);
+        if (!bucket || !bucket.store.computeIndexTotals)
+            return undefined;
+        return await bucket.store.computeIndexTotals();
+    }
+    async getSyncStatus(account, bucketName) {
+        let bucket = await getBucket(account, bucketName);
+        if (!bucket)
+            return { allScansComplete: true, indexSize: 0, sources: [] };
+        if (!bucket.store.getSyncStatus) {
+            throw new Error(`Bucket ${account}/${bucketName} does not support getSyncStatus (rawDisk buckets have no synchronization)`);
+        }
+        return await bucket.store.getSyncStatus();
+    }
+    async startLargeFile(account, bucketName, path) {
+        (0, storageServerState_1.assertWritesAllowed)();
+        // Validates now, so the upload doesn't fail at the end
+        assertValidPath(path);
+        let bucket = await getBucket(account, bucketName);
+        if (!bucket) {
+            throw new Error(`Bucket ${account}/${bucketName} does not exist. Write its routing config to ${JSON.stringify(remoteConfig_1.ROUTING_FILE)} to create it.`);
+        }
+        await (0, storageServerState_1.assertMutable)(bucket, path, Date.now());
+        let id = await bucket.store.startLargeUpload();
+        largeUploadInfo.set(id, { account, bucketName, path });
+        return id;
+    }
+    async uploadPart(uploadId, data) {
+        (0, storageServerState_1.assertWritesAllowed)();
+        let info = largeUploadInfo.get(uploadId);
+        if (!info)
+            throw new Error(`Unknown large upload ${uploadId}`);
+        let bucket = await getBucket(info.account, info.bucketName);
+        if (!bucket)
+            throw new Error(`Bucket ${info.account}/${info.bucketName} no longer exists`);
+        await bucket.store.appendLargeUpload(uploadId, Buffer.from(data));
+    }
+    async finishLargeFile(uploadId) {
+        (0, storageServerState_1.assertWritesAllowed)();
+        let info = largeUploadInfo.get(uploadId);
+        if (!info)
+            throw new Error(`Unknown large upload ${uploadId}`);
+        largeUploadInfo.delete(uploadId);
+        let bucket = await getBucket(info.account, info.bucketName);
+        if (!bucket)
+            throw new Error(`Bucket ${info.account}/${info.bucketName} no longer exists`);
+        await bucket.store.finishLargeUpload(uploadId, info.path);
+    }
+    async cancelLargeFile(uploadId) {
+        let info = largeUploadInfo.get(uploadId);
+        if (!info)
+            return;
+        largeUploadInfo.delete(uploadId);
+        let bucket = await getBucket(info.account, info.bucketName);
+        if (!bucket)
+            return;
+        await bucket.store.cancelLargeUpload(uploadId);
+    }
+    // The server's single default HTTP route. /file/<account>/<bucketName>/<path> serves files from
+    // public buckets over plain GETs (see IArchives.getURL); every other path serves the access
+    // page (via RequireController.requireHTML — the path is the account name, see accessPage.tsx).
+    async httpEntry(config) {
+        var _a, _b;
+        // Both are keyed by the current call and must be captured synchronously, before any await
+        let caller = SocketFunction_1.SocketFunction.getCaller();
+        let request = (0, callHTTPHandler_1.getCurrentHTTPRequest)();
+        let pathname = new URL((request === null || request === void 0 ? void 0 : request.url) || "/", "https://localhost").pathname;
+        if (!pathname.startsWith("/file/")) {
+            return await (0, callManager_1.performLocalCall)({
+                caller,
+                call: { nodeId: caller.nodeId, classGuid: RequireController_1.RequireController._classGuid, functionName: "requireHTML", args: [config] },
+            });
+        }
+        let parts = pathname.split("/").filter(x => x).map(decodeURIComponent);
+        let account = parts[1];
+        let bucketName = parts[2];
+        let filePath = parts.slice(3).join("/");
+        if (!account || !bucketName || !filePath) {
+            return (0, callHTTPHandler_1.setHTTPResultHeaders)(Buffer.from(""), { status: "404" });
+        }
+        assertValidName(account, "account");
+        assertValidName(bucketName, "bucket name");
+        assertValidPath(filePath);
+        let bucket = await (0, storageServerState_1.getLoadedBucket)(account, bucketName);
+        if (!bucket) {
+            return (0, callHTTPHandler_1.setHTTPResultHeaders)(Buffer.from(""), { status: "404" });
+        }
+        if (!((_a = bucket.self) === null || _a === void 0 ? void 0 : _a.public)) {
+            throw new Error(`Bucket ${account}/${bucketName} is not public, so its files cannot be read over plain URLs`);
+        }
+        // The index answers existence + write time + size without touching any data, so
+        // If-Modified-Since and range validation cost nothing
+        let info = await bucket.store.getInfo(filePath);
+        if (!info || !info.size) {
+            return (0, callHTTPHandler_1.setHTTPResultHeaders)(Buffer.from(""), { status: "404" });
+        }
+        let ext = filePath.split(".").pop() || "";
+        let headers = {
+            "Content-Type": CONTENT_TYPES[ext.toLowerCase()] || "application/octet-stream",
+            "Last-Modified": new Date(info.writeTime).toUTCString(),
+            "Accept-Ranges": "bytes",
+        };
+        if ((_b = bucket.self) === null || _b === void 0 ? void 0 : _b.immutable) {
+            headers["Cache-Control"] = `max-age=${IArchives_1.IMMUTABLE_CACHE_TIME / 1000}`;
+        }
+        let ifModifiedSince = request === null || request === void 0 ? void 0 : request.headers["if-modified-since"];
+        if (typeof ifModifiedSince === "string") {
+            let since = new Date(ifModifiedSince).getTime();
+            // Last-Modified is served at 1 second resolution, so compare at that resolution
+            if (since && Math.floor(info.writeTime / 1000) * 1000 <= since) {
+                return (0, callHTTPHandler_1.setHTTPResultHeaders)(Buffer.from(""), { ...headers, status: "304" });
+            }
+        }
+        let range;
+        let rangeHeader = request === null || request === void 0 ? void 0 : request.headers["range"];
+        if (typeof rangeHeader === "string") {
+            // Single-range form only (bytes=start-end / start- / -suffix); anything else serves the full file
+            let match = /^bytes=(\d*)-(\d*)$/.exec(rangeHeader.trim());
+            if (match && (match[1] || match[2])) {
+                let start;
+                let endInclusive = info.size - 1;
+                if (!match[1]) {
+                    start = Math.max(0, info.size - +match[2]);
+                }
+                else {
+                    start = +match[1];
+                    if (match[2]) {
+                        endInclusive = Math.min(+match[2], info.size - 1);
+                    }
+                }
+                if (start >= info.size || start > endInclusive) {
+                    return (0, callHTTPHandler_1.setHTTPResultHeaders)(Buffer.from(""), { ...headers, "Content-Range": `bytes */${info.size}`, status: "416" });
+                }
+                range = { start, end: endInclusive + 1 };
+            }
+        }
+        let result = await bucket.store.get2(filePath, { range });
+        if (!result) {
+            return (0, callHTTPHandler_1.setHTTPResultHeaders)(Buffer.from(""), { status: "404" });
+        }
+        if (range) {
+            return (0, callHTTPHandler_1.setHTTPResultHeaders)(result.data, { ...headers, "Content-Range": `bytes ${range.start}-${range.end - 1}/${info.size}`, status: "206" });
+        }
+        return (0, callHTTPHandler_1.setHTTPResultHeaders)(result.data, headers);
+    }
+}
+const largeUploadInfo = new Map();
+// Access checks run as hooks on the register shape below, keyed off the call's arguments, so the
+// method bodies don't each repeat them
+const accountAccess = async (context) => {
+    await requireAccess(String(context.call.args[0]));
+};
+const uploadAccess = async (context) => {
+    let info = largeUploadInfo.get(String(context.call.args[0]));
+    // Unknown upload ids are handled by the methods themselves (throw / no-op)
+    if (!info)
+        return;
+    await requireAccess(info.account);
+};
+const adminAccess = async () => {
+    requireAdmin();
+};
+exports.RemoteStorageController = SocketFunction_1.SocketFunction.register(exports.REMOTE_STORAGE_CLASS_GUID, new RemoteStorageControllerBase(), () => ({
+    ping: {},
+    authenticate: {},
+    requestAccess: {},
+    getAccessState: {},
+    listRequestsForIP: { hooks: [accountAccess] },
+    grantAccess: {},
+    adminListRequests: { hooks: [adminAccess] },
+    adminGrantAccess: { hooks: [adminAccess] },
+    get: { hooks: [accountAccess] },
+    get2: { hooks: [accountAccess] },
+    set: { hooks: [accountAccess] },
+    del: { hooks: [accountAccess] },
+    getInfo: { hooks: [accountAccess] },
+    findInfo: { hooks: [accountAccess] },
+    getChangesAfter: { hooks: [accountAccess] },
+    getArchivesConfig: { hooks: [accountAccess] },
+    getIndexInfo: { hooks: [accountAccess] },
+    getSyncStatus: { hooks: [accountAccess] },
+    startLargeFile: { hooks: [accountAccess] },
+    uploadPart: { hooks: [uploadAccess] },
+    finishLargeFile: { hooks: [uploadAccess] },
+    cancelLargeFile: { hooks: [uploadAccess] },
+    httpEntry: {},
+}), () => ({
+    noClientHooks: true,
+    noDefaultHooks: true,
+}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storageController.js","sourceRoot":"","sources":["storageController.ts"],"names":[],"mappings":"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","sourcesContent":["module.allowclient = true;\n\nimport { SocketFunction } from \"socket-function/SocketFunction\";\nimport { SocketFunctionHook } from \"socket-function/SocketFunctionTypes\";\nimport { getNodeIdIP } from \"socket-function/src/nodeCache\";\nimport { setHTTPResultHeaders, getCurrentHTTPRequest } from \"socket-function/src/callHTTPHandler\";\nimport { performLocalCall } from \"socket-function/src/callManager\";\nimport { RequireController } from \"socket-function/require/RequireController\";\nimport { timeInMinute } from \"socket-function/src/misc\";\nimport { getCommonName, getPublicIdentifier, getOwnMachineId, verify, verifyMachineIdForPublicKey } from \"../../misc/https/certs\";\nimport { ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus, IMMUTABLE_CACHE_TIME } from \"../IArchives\";\nimport { ROUTING_FILE } from \"./remoteConfig\";\nimport {\n    getStorageServerConfig, getTrust, getRequests, getLoadedBucket, writeBucketFile,\n    deleteBucketFile, assertWritesAllowed, assertMutable, LoadedBucket,\n} from \"./storageServerState\";\n\n// The remote storage server's API. Authentication uses certs.ts machine identities: a client\n// proves it owns its machine key by signing a timestamped token (bound to this server, so tokens\n// can't be replayed elsewhere), and the server then trusts that connection as that machineId.\n// Access to an account is granted to specific machineIds, via a command line command run on the\n// storage machine (see storageServer.ts).\n//\n// There is no bucket-creation API: a bucket exists iff its routing config (ROUTING_FILE) exists,\n// and writing that file creates or reconfigures the bucket (see storageServerState.ts). Reads of\n// nonexistent buckets return undefined / empty, same as reads of nonexistent files.\n\nexport const REMOTE_STORAGE_CLASS_GUID = \"RemoteStorageController-b7e42a91\";\nexport const STORAGE_AUTH_PURPOSE = \"remoteStorage-auth-1\";\n// Error markers, so clients can identify these failures inside error messages\nexport const STORAGE_NOT_AUTHENTICATED = \"REMOTE_STORAGE_NOT_AUTHENTICATED_cf2f7b1e\";\nexport const STORAGE_ACCESS_DENIED = \"REMOTE_STORAGE_ACCESS_DENIED_9d81a4c0\";\n\nconst AUTH_TIME_WINDOW = timeInMinute * 10;\nconst MAX_SESSIONS = 100 * 1000;\nconst MAX_REQUESTS_PER_IP = 50;\n\nexport type AuthToken = {\n    certPem: string;\n    time: number;\n    signature: string;\n};\nexport type AccessRequest = {\n    requestId: string;\n    account: string;\n    machineId: string;\n    ip: string;\n    time: number;\n};\nexport type TrustRecord = {\n    account: string;\n    machineId: string;\n    ip: string;\n    time: number;\n};\nexport type AccessState = {\n    machineId: string;\n    ip: string;\n    hasAccess: boolean;\n    // A single ssh command, runnable from anywhere, that runs the grantAccess CLI on the storage\n    // machine to grant the caller's own pending request. Only set when the caller has a pending\n    // request (so an already-trusted caller has no need for it).\n    grantAccessCommand?: string;\n    // Only the machines that ALREADY have access. Pending requests are NEVER listed here — showing\n    // them would let a trusted user accidentally approve a random request. Callers see pending\n    // requests only by explicitly typing an IP into listRequestsForIP.\n    trustedMachines?: TrustRecord[];\n};\n\n// callerNodeId -> authenticated machineId. Connections are long-lived websockets, so a session\n// lasts until the connection drops (clients re-authenticate on reconnect).\nconst sessions = new Map<string, string>();\n\nconst CONTENT_TYPES: { [ext: string]: string } = {\n    html: \"text/html\", js: \"text/javascript\", css: \"text/css\", json: \"application/json\",\n    txt: \"text/plain\", png: \"image/png\", jpg: \"image/jpeg\", jpeg: \"image/jpeg\", gif: \"image/gif\",\n    svg: \"image/svg+xml\", webp: \"image/webp\", mp4: \"video/mp4\", webm: \"video/webm\",\n    mp3: \"audio/mpeg\", wav: \"audio/wav\", pdf: \"application/pdf\",\n};\n\nfunction assertValidName(value: string, kind: string) {\n    if (!/^[\\w-]{1,64}$/.test(value)) {\n        throw new Error(`Invalid ${kind} ${JSON.stringify(value)}, expected 1-64 characters of letters/numbers/underscore/dash`);\n    }\n}\nfunction assertValidPath(path: string) {\n    if (Buffer.from(path, \"utf8\").length > 1000) {\n        throw new Error(`Path too long: ${path.length} characters > 1000. Path: ${path.slice(0, 200)}`);\n    }\n    if (!path || path.startsWith(\"/\") || path.endsWith(\"/\") || path.includes(\"//\") || path.includes(\"\\\\\") || path.includes(\"\\x00\")) {\n        throw new Error(`Invalid path ${JSON.stringify(path.slice(0, 200))}, paths cannot be empty, start or end with /, or contain //, backslashes, or null characters`);\n    }\n    // Paths are one-to-one with files on disk, so . and .. segments would escape the store folder\n    if (path.split(\"/\").some(part => part === \".\" || part === \"..\")) {\n        throw new Error(`Invalid path ${JSON.stringify(path.slice(0, 200))}, paths cannot contain . or .. segments`);\n    }\n}\n\nfunction getCallerMachineId(): string {\n    let caller = SocketFunction.getCaller();\n    let machineId = sessions.get(caller.nodeId);\n    if (!machineId) {\n        throw new Error(`${STORAGE_NOT_AUTHENTICATED} Call authenticate first (connection ${caller.nodeId})`);\n    }\n    return machineId;\n}\nfunction getCallerIP(): string {\n    return getNodeIdIP(SocketFunction.getCaller().nodeId);\n}\nfunction isAdmin(machineId: string): boolean {\n    return machineId === getOwnMachineId(getStorageServerConfig().rootDomain);\n}\nfunction requireAdmin(): string {\n    let machineId = getCallerMachineId();\n    if (!isAdmin(machineId)) {\n        throw new Error(`${STORAGE_ACCESS_DENIED} Admin commands must be run from the storage machine itself (caller machine ${machineId})`);\n    }\n    return machineId;\n}\nasync function requireAccess(account: string): Promise<string> {\n    assertValidName(account, \"account\");\n    let machineId = getCallerMachineId();\n    if (isAdmin(machineId)) return machineId;\n    let trust = await getTrust();\n    let trusted = await trust.get(`${account}|${machineId}`);\n    if (!trusted) {\n        let { domain, port } = getStorageServerConfig();\n        throw new Error(`${STORAGE_ACCESS_DENIED} Machine ${machineId} has no access to account ${JSON.stringify(account)}. Visit https://${domain}:${port}/${account} for access instructions.`);\n    }\n    return machineId;\n}\n\n// A single command, runnable from anywhere, that sshes into the storage machine and runs the\n// grantAccess CLI there\nfunction getGrantAccessCommand(requestId: string): string {\n    let { sshTarget, serverCommand } = getStorageServerConfig();\n    return `ssh ${sshTarget} '${serverCommand} --requestId ${requestId}'`;\n}\n\nasync function getBucket(account: string, bucketName: string): Promise<LoadedBucket | undefined> {\n    assertValidName(account, \"account\");\n    assertValidName(bucketName, \"bucket name\");\n    return await getLoadedBucket(account, bucketName);\n}\n\nclass RemoteStorageControllerBase {\n    // Latency measurement (see SourceWrapper's pinging); no auth, it measures the transport\n    async ping(): Promise<void> { }\n\n    // Proves the caller owns the machine key for the machineId in its certificate. The signature\n    // must be fresh and bound to this server, so it cannot be replayed to (or from) other servers.\n    async authenticate(token: AuthToken): Promise<{ machineId: string; ip: string }> {\n        let { domain, port } = getStorageServerConfig();\n        let caller = SocketFunction.getCaller();\n        if (Math.abs(Date.now() - token.time) > AUTH_TIME_WINDOW) {\n            throw new Error(`Auth token time is too far from the server time (token ${token.time}, server ${Date.now()}, allowed drift ${AUTH_TIME_WINDOW}ms)`);\n        }\n        verify(token.certPem, token.signature, {\n            purpose: STORAGE_AUTH_PURPOSE,\n            time: token.time,\n            server: `${domain}:${port}`,\n        });\n        let machineId = getCommonName(token.certPem).split(\".\")[0];\n        if (!verifyMachineIdForPublicKey({ machineId, publicKey: getPublicIdentifier(token.certPem) })) {\n            throw new Error(`Certificate common name ${JSON.stringify(getCommonName(token.certPem))} does not match its public key`);\n        }\n        sessions.set(caller.nodeId, machineId);\n        while (sessions.size > MAX_SESSIONS) {\n            let oldest = sessions.keys().next().value;\n            if (oldest === undefined) break;\n            sessions.delete(oldest);\n        }\n        return { machineId, ip: getCallerIP() };\n    }\n\n    // Records that the calling machine wants access to an account. Requests are kept per requesting\n    // IP, so the storage machine's admin can list them with --listAccess <ip> and grant one.\n    async requestAccess(account: string): Promise<{ machineId: string; ip: string; requestId: string; grantAccessCommand: string }> {\n        assertValidName(account, \"account\");\n        let machineId = getCallerMachineId();\n        let ip = getCallerIP();\n        let requestsStorage = await getRequests();\n        let requests = await requestsStorage.get(ip) || [];\n        let existing = requests.find(x => x.account === account && x.machineId === machineId);\n        if (existing) {\n            existing.time = Date.now();\n        } else {\n            existing = {\n                requestId: Math.random().toString(36).slice(2, 10),\n                account,\n                machineId,\n                ip,\n                time: Date.now(),\n            };\n            requests.push(existing);\n        }\n        while (requests.length > MAX_REQUESTS_PER_IP) requests.shift();\n        await requestsStorage.set(ip, requests);\n        return { machineId, ip, requestId: existing.requestId, grantAccessCommand: getGrantAccessCommand(existing.requestId) };\n    }\n\n    async getAccessState(account: string): Promise<AccessState> {\n        assertValidName(account, \"account\");\n        let machineId = getCallerMachineId();\n        let ip = getCallerIP();\n        let trust = await getTrust();\n        let hasAccess = isAdmin(machineId) || !!await trust.get(`${account}|${machineId}`);\n        let result: AccessState = { machineId, ip, hasAccess };\n        if (!hasAccess) {\n            let requests = await getRequests();\n            let ownRequest = (await requests.get(ip) || []).find(x => x.account === account && x.machineId === machineId);\n            if (ownRequest) {\n                result.grantAccessCommand = getGrantAccessCommand(ownRequest.requestId);\n            }\n            return result;\n        }\n\n        let trustedMachines: TrustRecord[] = [];\n        for (let key of await trust.getKeys()) {\n            if (!key.startsWith(`${account}|`)) continue;\n            let record = await trust.get(key);\n            if (record) trustedMachines.push(record);\n        }\n        result.trustedMachines = trustedMachines;\n        return result;\n    }\n\n    // Callable by any machine that has access to `account`. Returns pending access requests for the\n    // account that come from EXACTLY `ip`. Callers must type in an IP explicitly — the server never\n    // volunteers a list of requesting IPs, so a trusted user can't accidentally approve a random\n    // request from a machine they didn't mean to trust.\n    async listRequestsForIP(account: string, ip: string): Promise<AccessRequest[]> {\n        let requests = await getRequests();\n        return (await requests.get(ip) || []).filter(x => x.account === account);\n    }\n\n    // Callable by any machine that has access to the request's account (or by the storage-machine\n    // admin). Grants the requested access; the caller must supply the specific requestId, which they\n    // only get by explicitly looking up requests for a specific IP.\n    async grantAccess(requestId: string): Promise<TrustRecord> {\n        // Must capture in the synchronous phase — SocketFunction.getCaller() only works before any await.\n        let callerMachineId = getCallerMachineId();\n        let trust = await getTrust();\n        let requests = await getRequests();\n        for (let ip of await requests.getKeys()) {\n            for (let request of await requests.get(ip) || []) {\n                if (request.requestId !== requestId) continue;\n                if (!isAdmin(callerMachineId) && !await trust.get(`${request.account}|${callerMachineId}`)) {\n                    throw new Error(`${STORAGE_ACCESS_DENIED} Machine ${callerMachineId} has no access to account ${JSON.stringify(request.account)}`);\n                }\n                let record: TrustRecord = {\n                    account: request.account,\n                    machineId: request.machineId,\n                    ip: request.ip,\n                    time: Date.now(),\n                };\n                await trust.set(`${request.account}|${request.machineId}`, record);\n                return record;\n            }\n        }\n        throw new Error(`No access request found with id ${JSON.stringify(requestId)}. It may have already been granted or expired.`);\n    }\n\n    // Admin (must be run from the storage machine itself, which shares the server's machineId).\n    // Only returns requests for the given IP, so you cannot accidentally grant a request from an\n    // IP you didn't explicitly type in.\n    async adminListRequests(ip: string): Promise<AccessRequest[]> {\n        let requests = await getRequests();\n        return await requests.get(ip) || [];\n    }\n    async adminGrantAccess(requestId: string): Promise<TrustRecord> {\n        let trust = await getTrust();\n        let requests = await getRequests();\n        for (let ip of await requests.getKeys()) {\n            for (let request of await requests.get(ip) || []) {\n                if (request.requestId !== requestId) continue;\n                let record: TrustRecord = {\n                    account: request.account,\n                    machineId: request.machineId,\n                    ip: request.ip,\n                    time: Date.now(),\n                };\n                await trust.set(`${request.account}|${request.machineId}`, record);\n                return record;\n            }\n        }\n        throw new Error(`No access request found with id ${JSON.stringify(requestId)}. It may have already been granted or expired.`);\n    }\n\n    async get(account: string, bucketName: string, path: string, range?: { start: number; end: number }): Promise<Buffer | undefined> {\n        let result = await this.get2(account, bucketName, path, range);\n        return result && result.data || undefined;\n    }\n    async get2(account: string, bucketName: string, path: string, range?: { start: number; end: number }): Promise<{ data: Buffer; writeTime: number; size: number } | undefined> {\n        assertValidPath(path);\n        let bucket = await getBucket(account, bucketName);\n        if (!bucket) return undefined;\n        return await bucket.store.get2(path, { range });\n    }\n    async set(account: string, bucketName: string, path: string, data: Buffer, lastModified?: number): Promise<void> {\n        assertValidName(bucketName, \"bucket name\");\n        assertValidPath(path);\n        // Handles bucket creation (writes of ROUTING_FILE), reconfiguration, fast mode, and\n        // immutability — see storageServerState.ts\n        await writeBucketFile(account, bucketName, path, Buffer.from(data), { lastModified });\n    }\n    async del(account: string, bucketName: string, path: string): Promise<void> {\n        assertValidName(bucketName, \"bucket name\");\n        assertValidPath(path);\n        await deleteBucketFile(account, bucketName, path);\n    }\n    async getInfo(account: string, bucketName: string, path: string): Promise<{ writeTime: number; size: number } | undefined> {\n        assertValidPath(path);\n        let bucket = await getBucket(account, bucketName);\n        if (!bucket) return undefined;\n        return await bucket.store.getInfo(path);\n    }\n    async findInfo(account: string, bucketName: string, prefix: string, config?: { shallow?: boolean; type?: \"files\" | \"folders\" }): Promise<ArchiveFileInfo[]> {\n        let bucket = await getBucket(account, bucketName);\n        if (!bucket) return [];\n        return await bucket.store.findInfo(prefix, config);\n    }\n    // Fast (served from the store's BulkDatabase2 index, not a scan) — see IArchives.getChangesAfter\n    async getChangesAfter(account: string, bucketName: string, time: number): Promise<ArchiveFileInfo[]> {\n        let bucket = await getBucket(account, bucketName);\n        if (!bucket) return [];\n        if (!bucket.store.getChangesAfter) {\n            throw new Error(`Bucket ${account}/${bucketName} does not support getChangesAfter (rawDisk buckets have no index)`);\n        }\n        return await bucket.store.getChangesAfter(time);\n    }\n    async getArchivesConfig(account: string, bucketName: string): Promise<ArchivesConfig> {\n        let bucket = await getBucket(account, bucketName);\n        // Missing buckets say true, matching what they become once created (the default store type)\n        let progress = bucket?.store.getSyncProgress?.();\n        return {\n            supportsChangesAfter: !bucket || !!bucket.store.getChangesAfter,\n            remoteConfig: bucket?.routing,\n            index: progress?.index,\n            indexSources: progress?.sources,\n            readerDiskLimit: progress?.readerDiskLimit,\n            syncing: progress?.syncing,\n        };\n    }\n    /** Walks the whole index for exact totals (overall and per holding source) - more expensive\n     *  than the maintained counters that getArchivesConfig returns, but immune to counter drift. */\n    async getIndexInfo(account: string, bucketName: string): Promise<{ fileCount: number; byteCount: number; sources: { debugName: string; fileCount: number; byteCount: number }[] } | undefined> {\n        let bucket = await getBucket(account, bucketName);\n        if (!bucket || !bucket.store.computeIndexTotals) return undefined;\n        return await bucket.store.computeIndexTotals();\n    }\n    async getSyncStatus(account: string, bucketName: string): Promise<ArchivesSyncStatus> {\n        let bucket = await getBucket(account, bucketName);\n        if (!bucket) return { allScansComplete: true, indexSize: 0, sources: [] };\n        if (!bucket.store.getSyncStatus) {\n            throw new Error(`Bucket ${account}/${bucketName} does not support getSyncStatus (rawDisk buckets have no synchronization)`);\n        }\n        return await bucket.store.getSyncStatus();\n    }\n\n    async startLargeFile(account: string, bucketName: string, path: string): Promise<string> {\n        assertWritesAllowed();\n        // Validates now, so the upload doesn't fail at the end\n        assertValidPath(path);\n        let bucket = await getBucket(account, bucketName);\n        if (!bucket) {\n            throw new Error(`Bucket ${account}/${bucketName} does not exist. Write its routing config to ${JSON.stringify(ROUTING_FILE)} to create it.`);\n        }\n        await assertMutable(bucket, path, Date.now());\n        let id = await bucket.store.startLargeUpload();\n        largeUploadInfo.set(id, { account, bucketName, path });\n        return id;\n    }\n    async uploadPart(uploadId: string, data: Buffer): Promise<void> {\n        assertWritesAllowed();\n        let info = largeUploadInfo.get(uploadId);\n        if (!info) throw new Error(`Unknown large upload ${uploadId}`);\n        let bucket = await getBucket(info.account, info.bucketName);\n        if (!bucket) throw new Error(`Bucket ${info.account}/${info.bucketName} no longer exists`);\n        await bucket.store.appendLargeUpload(uploadId, Buffer.from(data));\n    }\n    async finishLargeFile(uploadId: string): Promise<void> {\n        assertWritesAllowed();\n        let info = largeUploadInfo.get(uploadId);\n        if (!info) throw new Error(`Unknown large upload ${uploadId}`);\n        largeUploadInfo.delete(uploadId);\n        let bucket = await getBucket(info.account, info.bucketName);\n        if (!bucket) throw new Error(`Bucket ${info.account}/${info.bucketName} no longer exists`);\n        await bucket.store.finishLargeUpload(uploadId, info.path);\n    }\n    async cancelLargeFile(uploadId: string): Promise<void> {\n        let info = largeUploadInfo.get(uploadId);\n        if (!info) return;\n        largeUploadInfo.delete(uploadId);\n        let bucket = await getBucket(info.account, info.bucketName);\n        if (!bucket) return;\n        await bucket.store.cancelLargeUpload(uploadId);\n    }\n\n    // The server's single default HTTP route. /file/<account>/<bucketName>/<path> serves files from\n    // public buckets over plain GETs (see IArchives.getURL); every other path serves the access\n    // page (via RequireController.requireHTML — the path is the account name, see accessPage.tsx).\n    async httpEntry(config?: { requireCalls?: string[]; cacheTime?: number }): Promise<Buffer> {\n        // Both are keyed by the current call and must be captured synchronously, before any await\n        let caller = SocketFunction.getCaller();\n        let request = getCurrentHTTPRequest();\n        let pathname = new URL(request?.url || \"/\", \"https://localhost\").pathname;\n        if (!pathname.startsWith(\"/file/\")) {\n            return await performLocalCall({\n                caller,\n                call: { nodeId: caller.nodeId, classGuid: RequireController._classGuid, functionName: \"requireHTML\", args: [config] },\n            }) as Buffer;\n        }\n        let parts = pathname.split(\"/\").filter(x => x).map(decodeURIComponent);\n        let account = parts[1];\n        let bucketName = parts[2];\n        let filePath = parts.slice(3).join(\"/\");\n        if (!account || !bucketName || !filePath) {\n            return setHTTPResultHeaders(Buffer.from(\"\"), { status: \"404\" });\n        }\n        assertValidName(account, \"account\");\n        assertValidName(bucketName, \"bucket name\");\n        assertValidPath(filePath);\n        let bucket = await getLoadedBucket(account, bucketName);\n        if (!bucket) {\n            return setHTTPResultHeaders(Buffer.from(\"\"), { status: \"404\" });\n        }\n        if (!bucket.self?.public) {\n            throw new Error(`Bucket ${account}/${bucketName} is not public, so its files cannot be read over plain URLs`);\n        }\n        // The index answers existence + write time + size without touching any data, so\n        // If-Modified-Since and range validation cost nothing\n        let info = await bucket.store.getInfo(filePath);\n        if (!info || !info.size) {\n            return setHTTPResultHeaders(Buffer.from(\"\"), { status: \"404\" });\n        }\n        let ext = filePath.split(\".\").pop() || \"\";\n        let headers: { [header: string]: string } = {\n            \"Content-Type\": CONTENT_TYPES[ext.toLowerCase()] || \"application/octet-stream\",\n            \"Last-Modified\": new Date(info.writeTime).toUTCString(),\n            \"Accept-Ranges\": \"bytes\",\n        };\n        if (bucket.self?.immutable) {\n            headers[\"Cache-Control\"] = `max-age=${IMMUTABLE_CACHE_TIME / 1000}`;\n        }\n        let ifModifiedSince = request?.headers[\"if-modified-since\"];\n        if (typeof ifModifiedSince === \"string\") {\n            let since = new Date(ifModifiedSince).getTime();\n            // Last-Modified is served at 1 second resolution, so compare at that resolution\n            if (since && Math.floor(info.writeTime / 1000) * 1000 <= since) {\n                return setHTTPResultHeaders(Buffer.from(\"\"), { ...headers, status: \"304\" });\n            }\n        }\n        let range: { start: number; end: number } | undefined;\n        let rangeHeader = request?.headers[\"range\"];\n        if (typeof rangeHeader === \"string\") {\n            // Single-range form only (bytes=start-end / start- / -suffix); anything else serves the full file\n            let match = /^bytes=(\\d*)-(\\d*)$/.exec(rangeHeader.trim());\n            if (match && (match[1] || match[2])) {\n                let start: number;\n                let endInclusive = info.size - 1;\n                if (!match[1]) {\n                    start = Math.max(0, info.size - +match[2]);\n                } else {\n                    start = +match[1];\n                    if (match[2]) {\n                        endInclusive = Math.min(+match[2], info.size - 1);\n                    }\n                }\n                if (start >= info.size || start > endInclusive) {\n                    return setHTTPResultHeaders(Buffer.from(\"\"), { ...headers, \"Content-Range\": `bytes */${info.size}`, status: \"416\" });\n                }\n                range = { start, end: endInclusive + 1 };\n            }\n        }\n        let result = await bucket.store.get2(filePath, { range });\n        if (!result) {\n            return setHTTPResultHeaders(Buffer.from(\"\"), { status: \"404\" });\n        }\n        if (range) {\n            return setHTTPResultHeaders(result.data, { ...headers, \"Content-Range\": `bytes ${range.start}-${range.end - 1}/${info.size}`, status: \"206\" });\n        }\n        return setHTTPResultHeaders(result.data, headers);\n    }\n}\n\nconst largeUploadInfo = new Map<string, { account: string; bucketName: string; path: string }>();\n\n// Access checks run as hooks on the register shape below, keyed off the call's arguments, so the\n// method bodies don't each repeat them\nconst accountAccess: SocketFunctionHook = async (context) => {\n    await requireAccess(String(context.call.args[0]));\n};\nconst uploadAccess: SocketFunctionHook = async (context) => {\n    let info = largeUploadInfo.get(String(context.call.args[0]));\n    // Unknown upload ids are handled by the methods themselves (throw / no-op)\n    if (!info) return;\n    await requireAccess(info.account);\n};\nconst adminAccess: SocketFunctionHook = async () => {\n    requireAdmin();\n};\n\nexport const RemoteStorageController = SocketFunction.register(\n    REMOTE_STORAGE_CLASS_GUID,\n    new RemoteStorageControllerBase(),\n    () => ({\n        ping: {},\n        authenticate: {},\n        requestAccess: {},\n        getAccessState: {},\n        listRequestsForIP: { hooks: [accountAccess] },\n        grantAccess: {},\n        adminListRequests: { hooks: [adminAccess] },\n        adminGrantAccess: { hooks: [adminAccess] },\n        get: { hooks: [accountAccess] },\n        get2: { hooks: [accountAccess] },\n        set: { hooks: [accountAccess] },\n        del: { hooks: [accountAccess] },\n        getInfo: { hooks: [accountAccess] },\n        findInfo: { hooks: [accountAccess] },\n        getChangesAfter: { hooks: [accountAccess] },\n        getArchivesConfig: { hooks: [accountAccess] },\n        getIndexInfo: { hooks: [accountAccess] },\n        getSyncStatus: { hooks: [accountAccess] },\n        startLargeFile: { hooks: [accountAccess] },\n        uploadPart: { hooks: [uploadAccess] },\n        finishLargeFile: { hooks: [uploadAccess] },\n        cancelLargeFile: { hooks: [uploadAccess] },\n        httpEntry: {},\n    }),\n    () => ({\n        noClientHooks: true,\n        noDefaultHooks: true,\n    })\n);\n"]}
+ /* _JS_SOURCE_HASH = "1f9c71eed3bbc12aa14eb6d02745131cca48eb4ea142276c2937d85ae7bf92db"; */