sliftutils 1.7.9 → 1.7.11

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

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.ArchivesRemote = exports.authenticateStorage = exports.parseStorageUrl = void 0;
+module.allowclient = true;
+const SocketFunction_1 = require("socket-function/SocketFunction");
+const misc_1 = require("socket-function/src/misc");
+const batching_1 = require("socket-function/src/batching");
+const certs_1 = require("../../misc/https/certs");
+const remoteConfig_1 = require("./remoteConfig");
+const storageController_1 = require("./storageController");
+// A bucket on our remote storage server (storageServer.ts), used like ArchivesBackblaze. Works in
+// Node.js and the browser. Authenticates with this machine's certs.ts identity; if the account
+// hasn't trusted this machine yet it requests access, and by default waits, logging instructions
+// every minute (calls block until access is granted).
+const ACCESS_RETRY_DELAY = 1000 * 30;
+const LARGE_FILE_PART_SIZE = 8 * 1024 * 1024;
+function parseStorageUrl(url) {
+    let u = new URL(url);
+    if (u.protocol !== "https:") {
+        throw new Error(`Storage URL must use https, got ${JSON.stringify(u.protocol)} in ${JSON.stringify(url)}`);
+    }
+    return { address: u.hostname, port: +u.port || 443 };
+}
+exports.parseStorageUrl = parseStorageUrl;
+// Authenticates a connection to a storage server with this machine's certs.ts identity
+async function authenticateStorage(config) {
+    // hostServer nodeIds are machine-specific, so connections by domain must target "any server
+    // at this address" (which is how browsers always connect)
+    SocketFunction_1.SocketFunction.ENABLE_CLIENT_MODE = true;
+    let rootDomain = config.address.split(".").slice(-2).join(".");
+    await (0, certs_1.loadIdentityCA)(rootDomain);
+    let ca = (0, certs_1.getIdentityCA)(rootDomain);
+    let time = Date.now();
+    let signature = (0, certs_1.sign)({ key: ca.key }, {
+        purpose: storageController_1.STORAGE_AUTH_PURPOSE,
+        time,
+        server: `${config.address}:${config.port}`,
+    });
+    return await storageController_1.RemoteStorageController.nodes[config.nodeId].authenticate({ certPem: ca.cert.toString(), time, signature });
+}
+exports.authenticateStorage = authenticateStorage;
+class ArchivesRemote {
+    constructor(config) {
+        this.config = config;
+        this.parsed = (0, remoteConfig_1.parseHostedUrl)(this.config.url);
+        this.account = this.config.accountName || this.parsed.account;
+        this.bucketName = this.parsed.bucketName;
+        this.nodeId = SocketFunction_1.SocketFunction.connect({ address: this.parsed.address, port: this.parsed.port });
+        this.controller = storageController_1.RemoteStorageController.nodes[this.nodeId];
+        this.lastDeniedLog = 0;
+        // hostServer nodeIds are machine-specific, so connections by domain must target "any
+        // server at this address" (which is how browsers always connect)
+        SocketFunction_1.SocketFunction.ENABLE_CLIENT_MODE = true;
+    }
+    getDebugName() {
+        return `remoteStorage/${this.parsed.address}:${this.parsed.port}/${this.account}/${this.bucketName}`;
+    }
+    isConnected() {
+        return SocketFunction_1.SocketFunction.isNodeConnected(this.nodeId);
+    }
+    async ping() {
+        await this.controller.ping();
+    }
+    async authenticate() {
+        await authenticateStorage({ address: this.parsed.address, port: this.parsed.port, nodeId: this.nodeId });
+    }
+    // Runs a call, authenticating (and re-authenticating after reconnects) as needed. Unlike
+    // call(), does NOT wait for account access.
+    async callAuthed(fnc) {
+        try {
+            return await fnc();
+        }
+        catch (e) {
+            if (!String(e.stack || e).includes(storageController_1.STORAGE_NOT_AUTHENTICATED))
+                throw e;
+            await this.authenticate();
+            return await fnc();
+        }
+    }
+    // Returns undefined if this machine has access to the account. Otherwise puts in an access
+    // request and returns our machineId + ip (so the caller can display them alongside the link,
+    // for the approver to match the incoming request) and the link to the grant page.
+    async waitingForAccess() {
+        let state = await this.callAuthed(() => this.controller.getAccessState(this.account));
+        if (state.hasAccess)
+            return undefined;
+        let requested = await this.callAuthed(() => this.controller.requestAccess(this.account));
+        return {
+            link: `https://${this.parsed.address}:${this.parsed.port}/${this.account}`,
+            machineId: requested.machineId,
+            ip: requested.ip,
+        };
+    }
+    async hasWriteAccess() {
+        let state = await this.callAuthed(() => this.controller.getAccessState(this.account));
+        return !!state.hasAccess;
+    }
+    // Registers our access request server-side (so an admin has a requestId to grant) and logs the
+    // grant instructions, at most once a minute
+    async registerAccessRequest() {
+        let requested = await this.callAuthed(() => this.controller.requestAccess(this.account));
+        if (Date.now() - this.lastDeniedLog > misc_1.timeInMinute) {
+            this.lastDeniedLog = Date.now();
+            console.log(`No access to storage account ${JSON.stringify(this.account)} on ${this.parsed.address}:${this.parsed.port} (our machine ${requested.machineId}, ip ${requested.ip}). See https://${this.parsed.address}:${this.parsed.port}/${this.account} - or grant it with: ${requested.grantAccessCommand}`);
+        }
+    }
+    // Runs a call, authenticating (and re-authenticating after reconnects) and waiting for account
+    // access as needed. With waitForAccess false, denied calls throw immediately instead - but the
+    // access request is still registered (in the background), so the denial is grantable.
+    async call(fnc) {
+        while (true) {
+            try {
+                return await fnc();
+            }
+            catch (e) {
+                let message = String(e.stack || e);
+                if (message.includes(storageController_1.STORAGE_NOT_AUTHENTICATED)) {
+                    await this.authenticate();
+                    continue;
+                }
+                if (message.includes(storageController_1.STORAGE_ACCESS_DENIED)) {
+                    if (this.config.waitForAccess === false) {
+                        void this.registerAccessRequest().catch(() => { });
+                        throw e;
+                    }
+                    await this.registerAccessRequest();
+                    await (0, batching_1.delay)(ACCESS_RETRY_DELAY);
+                    continue;
+                }
+                throw e;
+            }
+        }
+    }
+    async get(fileName, config) {
+        let result = await this.get2(fileName, config);
+        return result && result.data || undefined;
+    }
+    async get2(fileName, config) {
+        let result = await this.call(() => this.controller.get2(this.account, this.bucketName, fileName, config === null || config === void 0 ? void 0 : config.range));
+        return result && { data: Buffer.from(result.data), writeTime: result.writeTime, size: result.size } || undefined;
+    }
+    async set(fileName, data, config) {
+        await this.call(() => this.controller.set(this.account, this.bucketName, fileName, data, config === null || config === void 0 ? void 0 : config.lastModified));
+    }
+    async del(fileName) {
+        await this.call(() => this.controller.del(this.account, this.bucketName, fileName));
+    }
+    async getInfo(fileName) {
+        return await this.call(() => this.controller.getInfo(this.account, this.bucketName, fileName));
+    }
+    async findInfo(prefix, config) {
+        return await this.call(() => this.controller.findInfo(this.account, this.bucketName, prefix, config));
+    }
+    async find(prefix, config) {
+        return (await this.findInfo(prefix, config)).map(x => x.path);
+    }
+    async getChangesAfter(time) {
+        return await this.call(() => this.controller.getChangesAfter(this.account, this.bucketName, time));
+    }
+    async getConfig() {
+        return await this.call(() => this.controller.getArchivesConfig(this.account, this.bucketName));
+    }
+    async getSyncStatus() {
+        return await this.call(() => this.controller.getSyncStatus(this.account, this.bucketName));
+    }
+    async setLargeFile(config) {
+        // Ensure we're authenticated with access BEFORE consuming any data (the stream cannot be
+        // rewound, so we can't use the retry loop around the actual upload)
+        await this.call(() => this.controller.getInfo(this.account, this.bucketName, config.path));
+        let uploadId = await this.controller.startLargeFile(this.account, this.bucketName, config.path);
+        try {
+            while (true) {
+                let data = await config.getNextData();
+                if (!data)
+                    break;
+                for (let offset = 0; offset < data.length; offset += LARGE_FILE_PART_SIZE) {
+                    await this.controller.uploadPart(uploadId, data.subarray(offset, offset + LARGE_FILE_PART_SIZE));
+                }
+            }
+            await this.controller.finishLargeFile(uploadId);
+        }
+        catch (e) {
+            try {
+                await this.controller.cancelLargeFile(uploadId);
+            }
+            catch (_a) { }
+            throw e;
+        }
+    }
+    async getURL(path) {
+        // Only actually loads for public buckets (the server rejects plain URL reads otherwise)
+        return (0, remoteConfig_1.buildFileUrl)((0, remoteConfig_1.getBucketBaseUrl)(this.config.url), path);
+    }
+}
+exports.ArchivesRemote = ArchivesRemote;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ArchivesRemote.js","sourceRoot":"","sources":["ArchivesRemote.ts"],"names":[],"mappings":"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","sourcesContent":["module.allowclient = true;\n\nimport { SocketFunction } from \"socket-function/SocketFunction\";\nimport { timeInMinute } from \"socket-function/src/misc\";\nimport { delay } from \"socket-function/src/batching\";\nimport { getIdentityCA, loadIdentityCA, sign } from \"../../misc/https/certs\";\nimport { IArchives, ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus } from \"../IArchives\";\nimport { parseHostedUrl, getBucketBaseUrl, buildFileUrl } from \"./remoteConfig\";\nimport {\n    RemoteStorageController, STORAGE_AUTH_PURPOSE,\n    STORAGE_NOT_AUTHENTICATED, STORAGE_ACCESS_DENIED,\n} from \"./storageController\";\n\n// A bucket on our remote storage server (storageServer.ts), used like ArchivesBackblaze. Works in\n// Node.js and the browser. Authenticates with this machine's certs.ts identity; if the account\n// hasn't trusted this machine yet it requests access, and by default waits, logging instructions\n// every minute (calls block until access is granted).\n\nconst ACCESS_RETRY_DELAY = 1000 * 30;\nconst LARGE_FILE_PART_SIZE = 8 * 1024 * 1024;\n\nexport type ArchivesRemoteConfig = {\n    // The bucket's routing URL, which addresses the server, account, and bucket in one:\n    //  https://storage.example.com:4444/file/<account>/<bucketName>/storage/storagerouting.json\n    url: string;\n    // Access is checked against this account (defaults to the account in the url)\n    accountName?: string;\n    // false: access-denied calls throw immediately (the error includes the access page link)\n    // instead of requesting access and blocking until it is granted (the default).\n    waitForAccess?: boolean;\n};\n\nexport function parseStorageUrl(url: string): { address: string; port: number } {\n    let u = new URL(url);\n    if (u.protocol !== \"https:\") {\n        throw new Error(`Storage URL must use https, got ${JSON.stringify(u.protocol)} in ${JSON.stringify(url)}`);\n    }\n    return { address: u.hostname, port: +u.port || 443 };\n}\n\n// Authenticates a connection to a storage server with this machine's certs.ts identity\nexport async function authenticateStorage(config: { address: string; port: number; nodeId: string }): Promise<{ machineId: string; ip: string }> {\n    // hostServer nodeIds are machine-specific, so connections by domain must target \"any server\n    // at this address\" (which is how browsers always connect)\n    SocketFunction.ENABLE_CLIENT_MODE = true;\n    let rootDomain = config.address.split(\".\").slice(-2).join(\".\");\n    await loadIdentityCA(rootDomain);\n    let ca = getIdentityCA(rootDomain);\n    let time = Date.now();\n    let signature = sign({ key: ca.key }, {\n        purpose: STORAGE_AUTH_PURPOSE,\n        time,\n        server: `${config.address}:${config.port}`,\n    });\n    return await RemoteStorageController.nodes[config.nodeId].authenticate({ certPem: ca.cert.toString(), time, signature });\n}\n\nexport class ArchivesRemote implements IArchives {\n    constructor(private config: ArchivesRemoteConfig) {\n        // hostServer nodeIds are machine-specific, so connections by domain must target \"any\n        // server at this address\" (which is how browsers always connect)\n        SocketFunction.ENABLE_CLIENT_MODE = true;\n    }\n\n    private parsed = parseHostedUrl(this.config.url);\n    private account = this.config.accountName || this.parsed.account;\n    private bucketName = this.parsed.bucketName;\n    private nodeId = SocketFunction.connect({ address: this.parsed.address, port: this.parsed.port });\n    private controller = RemoteStorageController.nodes[this.nodeId];\n    private lastDeniedLog = 0;\n\n    public getDebugName() {\n        return `remoteStorage/${this.parsed.address}:${this.parsed.port}/${this.account}/${this.bucketName}`;\n    }\n\n    public isConnected(): boolean {\n        return SocketFunction.isNodeConnected(this.nodeId);\n    }\n\n    public async ping(): Promise<void> {\n        await this.controller.ping();\n    }\n\n    private async authenticate(): Promise<void> {\n        await authenticateStorage({ address: this.parsed.address, port: this.parsed.port, nodeId: this.nodeId });\n    }\n\n    // Runs a call, authenticating (and re-authenticating after reconnects) as needed. Unlike\n    // call(), does NOT wait for account access.\n    private async callAuthed<T>(fnc: () => Promise<T>): Promise<T> {\n        try {\n            return await fnc();\n        } catch (e: any) {\n            if (!String(e.stack || e).includes(STORAGE_NOT_AUTHENTICATED)) throw e;\n            await this.authenticate();\n            return await fnc();\n        }\n    }\n\n    // Returns undefined if this machine has access to the account. Otherwise puts in an access\n    // request and returns our machineId + ip (so the caller can display them alongside the link,\n    // for the approver to match the incoming request) and the link to the grant page.\n    public async waitingForAccess(): Promise<{ link: string; machineId: string; ip: string } | undefined> {\n        let state = await this.callAuthed(() => this.controller.getAccessState(this.account));\n        if (state.hasAccess) return undefined;\n        let requested = await this.callAuthed(() => this.controller.requestAccess(this.account));\n        return {\n            link: `https://${this.parsed.address}:${this.parsed.port}/${this.account}`,\n            machineId: requested.machineId,\n            ip: requested.ip,\n        };\n    }\n\n    public async hasWriteAccess(): Promise<boolean> {\n        let state = await this.callAuthed(() => this.controller.getAccessState(this.account));\n        return !!state.hasAccess;\n    }\n\n    // Registers our access request server-side (so an admin has a requestId to grant) and logs the\n    // grant instructions, at most once a minute\n    private async registerAccessRequest(): Promise<void> {\n        let requested = await this.callAuthed(() => this.controller.requestAccess(this.account));\n        if (Date.now() - this.lastDeniedLog > timeInMinute) {\n            this.lastDeniedLog = Date.now();\n            console.log(`No access to storage account ${JSON.stringify(this.account)} on ${this.parsed.address}:${this.parsed.port} (our machine ${requested.machineId}, ip ${requested.ip}). See https://${this.parsed.address}:${this.parsed.port}/${this.account} - or grant it with: ${requested.grantAccessCommand}`);\n        }\n    }\n\n    // Runs a call, authenticating (and re-authenticating after reconnects) and waiting for account\n    // access as needed. With waitForAccess false, denied calls throw immediately instead - but the\n    // access request is still registered (in the background), so the denial is grantable.\n    private async call<T>(fnc: () => Promise<T>): Promise<T> {\n        while (true) {\n            try {\n                return await fnc();\n            } catch (e: any) {\n                let message = String(e.stack || e);\n                if (message.includes(STORAGE_NOT_AUTHENTICATED)) {\n                    await this.authenticate();\n                    continue;\n                }\n                if (message.includes(STORAGE_ACCESS_DENIED)) {\n                    if (this.config.waitForAccess === false) {\n                        void this.registerAccessRequest().catch(() => { });\n                        throw e;\n                    }\n                    await this.registerAccessRequest();\n                    await delay(ACCESS_RETRY_DELAY);\n                    continue;\n                }\n                throw e;\n            }\n        }\n    }\n\n    public async get(fileName: string, config?: { range?: { start: number; end: number } }): Promise<Buffer | undefined> {\n        let result = await this.get2(fileName, config);\n        return result && result.data || undefined;\n    }\n    public async get2(fileName: string, config?: { range?: { start: number; end: number } }): Promise<{ data: Buffer; writeTime: number; size: number } | undefined> {\n        let result = await this.call(() => this.controller.get2(this.account, this.bucketName, fileName, config?.range));\n        return result && { data: Buffer.from(result.data), writeTime: result.writeTime, size: result.size } || undefined;\n    }\n    public async set(fileName: string, data: Buffer, config?: { lastModified?: number }): Promise<void> {\n        await this.call(() => this.controller.set(this.account, this.bucketName, fileName, data, config?.lastModified));\n    }\n    public async del(fileName: string): Promise<void> {\n        await this.call(() => this.controller.del(this.account, this.bucketName, fileName));\n    }\n    public async getInfo(fileName: string): Promise<{ writeTime: number; size: number } | undefined> {\n        return await this.call(() => this.controller.getInfo(this.account, this.bucketName, fileName));\n    }\n    public async findInfo(prefix: string, config?: { shallow?: boolean; type: \"files\" | \"folders\" }): Promise<ArchiveFileInfo[]> {\n        return await this.call(() => this.controller.findInfo(this.account, this.bucketName, prefix, config));\n    }\n    public async find(prefix: string, config?: { shallow?: boolean; type: \"files\" | \"folders\" }): Promise<string[]> {\n        return (await this.findInfo(prefix, config)).map(x => x.path);\n    }\n    public async getChangesAfter(time: number): Promise<ArchiveFileInfo[]> {\n        return await this.call(() => this.controller.getChangesAfter(this.account, this.bucketName, time));\n    }\n    public async getConfig(): Promise<ArchivesConfig> {\n        return await this.call(() => this.controller.getArchivesConfig(this.account, this.bucketName));\n    }\n    public async getSyncStatus(): Promise<ArchivesSyncStatus> {\n        return await this.call(() => this.controller.getSyncStatus(this.account, this.bucketName));\n    }\n\n    public async setLargeFile(config: { path: string; getNextData(): Promise<Buffer | undefined> }): Promise<void> {\n        // Ensure we're authenticated with access BEFORE consuming any data (the stream cannot be\n        // rewound, so we can't use the retry loop around the actual upload)\n        await this.call(() => this.controller.getInfo(this.account, this.bucketName, config.path));\n        let uploadId = await this.controller.startLargeFile(this.account, this.bucketName, config.path);\n        try {\n            while (true) {\n                let data = await config.getNextData();\n                if (!data) break;\n                for (let offset = 0; offset < data.length; offset += LARGE_FILE_PART_SIZE) {\n                    await this.controller.uploadPart(uploadId, data.subarray(offset, offset + LARGE_FILE_PART_SIZE));\n                }\n            }\n            await this.controller.finishLargeFile(uploadId);\n        } catch (e) {\n            try {\n                await this.controller.cancelLargeFile(uploadId);\n            } catch { }\n            throw e;\n        }\n    }\n\n    public async getURL(path: string): Promise<string> {\n        // Only actually loads for public buckets (the server rejects plain URL reads otherwise)\n        return buildFileUrl(getBucketBaseUrl(this.config.url), path);\n    }\n}\n"]}
+ /* _JS_SOURCE_HASH = "065b8b11387821eb401e95ea507db3d6f1dba4b1bb63cbc23ec898f5490b85ce"; */

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.ArchivesUrl = void 0;
+module.allowclient = true;
+const remoteConfig_1 = require("./remoteConfig");
+// Read-only IArchives over a public bucket's plain-URL form (our storage server's
+// /file/<account>/<bucketName>/... route, or a backblaze friendly URL). Used when we have no API
+// access to a source. Only single-file reads work: there is no listing, and writes always throw.
+class ArchivesUrl {
+    // base is the bucket's public base URL, e.g. https://host:port/file/<account>/<bucketName>
+    constructor(base) {
+        this.base = base;
+    }
+    getDebugName() {
+        return `url/${this.base}`;
+    }
+    readOnlyError(operation) {
+        return new Error(`${operation} is not supported over URL-form access (no API access to this source, only public URL reads). Source: ${this.base}`);
+    }
+    async get(fileName, config) {
+        let result = await this.get2(fileName, config);
+        return result && result.data || undefined;
+    }
+    async get2(fileName, config) {
+        let url = (0, remoteConfig_1.buildFileUrl)(this.base, fileName);
+        let headers = {};
+        let range = config === null || config === void 0 ? void 0 : config.range;
+        if (range) {
+            headers["Range"] = `bytes=${range.start}-${range.end - 1}`;
+        }
+        let response = await fetch(url, { headers });
+        if (response.status === 404)
+            return undefined;
+        if (!response.ok) {
+            throw new Error(`Read of ${url} failed: ${response.status} ${response.statusText}`);
+        }
+        let data = Buffer.from(await response.arrayBuffer());
+        // A real 206 only returns the requested slice, so the full size lives in Content-Range's total.
+        let size = data.length;
+        let contentRange = response.headers.get("content-range");
+        let total = contentRange && Number(contentRange.split("/")[1]);
+        if (total && Number.isFinite(total)) {
+            size = total;
+        }
+        // Servers that don't support ranges return the full file with a 200 (ours serves real
+        // 206s, but backblaze friendly URLs and proxies may not)
+        if (range && response.status === 200) {
+            data = data.subarray(Math.min(range.start, data.length), Math.min(range.end, data.length));
+        }
+        let lastModified = response.headers.get("last-modified");
+        let writeTime = lastModified && new Date(lastModified).getTime() || 0;
+        return { data, writeTime, size };
+    }
+    async getInfo(fileName) {
+        let result = await this.get2(fileName);
+        return result && { writeTime: result.writeTime, size: result.size } || undefined;
+    }
+    async set(fileName, data, config) {
+        throw this.readOnlyError("set");
+    }
+    async del(fileName) {
+        throw this.readOnlyError("del");
+    }
+    async setLargeFile(config) {
+        throw this.readOnlyError("setLargeFile");
+    }
+    async find(prefix, config) {
+        throw this.readOnlyError("find (listing)");
+    }
+    async findInfo(prefix, config) {
+        throw this.readOnlyError("findInfo (listing)");
+    }
+    async getURL(path) {
+        return (0, remoteConfig_1.buildFileUrl)(this.base, path);
+    }
+    async getConfig() {
+        return {};
+    }
+    async hasWriteAccess() {
+        return false;
+    }
+}
+exports.ArchivesUrl = ArchivesUrl;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ArchivesUrl.js","sourceRoot":"","sources":["ArchivesUrl.ts"],"names":[],"mappings":"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","sourcesContent":["module.allowclient = true;\n\nimport { IArchives, ArchiveFileInfo, ArchivesConfig } from \"../IArchives\";\nimport { buildFileUrl } from \"./remoteConfig\";\n\n// Read-only IArchives over a public bucket's plain-URL form (our storage server's\n// /file/<account>/<bucketName>/... route, or a backblaze friendly URL). Used when we have no API\n// access to a source. Only single-file reads work: there is no listing, and writes always throw.\n\nexport class ArchivesUrl implements IArchives {\n    // base is the bucket's public base URL, e.g. https://host:port/file/<account>/<bucketName>\n    constructor(private base: string) { }\n\n    public getDebugName() {\n        return `url/${this.base}`;\n    }\n\n    private readOnlyError(operation: string): Error {\n        return new Error(`${operation} is not supported over URL-form access (no API access to this source, only public URL reads). Source: ${this.base}`);\n    }\n\n    public async get(fileName: string, config?: { range?: { start: number; end: number } }): Promise<Buffer | undefined> {\n        let result = await this.get2(fileName, config);\n        return result && result.data || undefined;\n    }\n    public async get2(fileName: string, config?: { range?: { start: number; end: number } }): Promise<{ data: Buffer; writeTime: number; size: number } | undefined> {\n        let url = buildFileUrl(this.base, fileName);\n        let headers: Record<string, string> = {};\n        let range = config?.range;\n        if (range) {\n            headers[\"Range\"] = `bytes=${range.start}-${range.end - 1}`;\n        }\n        let response = await fetch(url, { headers });\n        if (response.status === 404) return undefined;\n        if (!response.ok) {\n            throw new Error(`Read of ${url} failed: ${response.status} ${response.statusText}`);\n        }\n        let data = Buffer.from(await response.arrayBuffer());\n        // A real 206 only returns the requested slice, so the full size lives in Content-Range's total.\n        let size = data.length;\n        let contentRange = response.headers.get(\"content-range\");\n        let total = contentRange && Number(contentRange.split(\"/\")[1]);\n        if (total && Number.isFinite(total)) {\n            size = total;\n        }\n        // Servers that don't support ranges return the full file with a 200 (ours serves real\n        // 206s, but backblaze friendly URLs and proxies may not)\n        if (range && response.status === 200) {\n            data = data.subarray(Math.min(range.start, data.length), Math.min(range.end, data.length));\n        }\n        let lastModified = response.headers.get(\"last-modified\");\n        let writeTime = lastModified && new Date(lastModified).getTime() || 0;\n        return { data, writeTime, size };\n    }\n    public async getInfo(fileName: string): Promise<{ writeTime: number; size: number } | undefined> {\n        let result = await this.get2(fileName);\n        return result && { writeTime: result.writeTime, size: result.size } || undefined;\n    }\n\n    public async set(fileName: string, data: Buffer, config?: { lastModified?: number }): Promise<void> {\n        throw this.readOnlyError(\"set\");\n    }\n    public async del(fileName: string): Promise<void> {\n        throw this.readOnlyError(\"del\");\n    }\n    public async setLargeFile(config: { path: string; getNextData(): Promise<Buffer | undefined> }): Promise<void> {\n        throw this.readOnlyError(\"setLargeFile\");\n    }\n    public async find(prefix: string, config?: { shallow?: boolean; type: \"files\" | \"folders\" }): Promise<string[]> {\n        throw this.readOnlyError(\"find (listing)\");\n    }\n    public async findInfo(prefix: string, config?: { shallow?: boolean; type: \"files\" | \"folders\" }): Promise<ArchiveFileInfo[]> {\n        throw this.readOnlyError(\"findInfo (listing)\");\n    }\n\n    public async getURL(path: string): Promise<string> {\n        return buildFileUrl(this.base, path);\n    }\n    public async getConfig(): Promise<ArchivesConfig> {\n        return {};\n    }\n\n    public async hasWriteAccess(): Promise<boolean> {\n        return false;\n    }\n}\n"]}
+ /* _JS_SOURCE_HASH = "3b08e87dc92fd46752eef014c02d0b938c7e7ae588bb1d9582446c2f1b980993"; */

package/storage/remoteStorage/dist/accessPage.tsx.cache

@@ -0,0 +1,222 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+module.allowclient = true;
+const preact_1 = __importDefault(require("preact"));
+const mobx_1 = require("mobx");
+const observer_1 = require("../../render-utils/observer");
+const misc_1 = require("socket-function/src/misc");
+const typesafecss_1 = require("typesafecss");
+const SocketFunction_1 = require("socket-function/SocketFunction");
+const storageController_1 = require("./storageController");
+const ArchivesRemote_1 = require("./ArchivesRemote");
+// The storage server's access page. Visit https://<storageDomain>:<port>/<accountName> to request
+// access to that account for this browser's machine identity. Once granted, lists the machines that
+// have access. To approve someone else's request, the user must type in the requester's IP —
+// pending requests are NEVER shown unsolicited (so a trusted user can't accidentally approve a
+// random machine's request).
+const REFRESH_INTERVAL = 1000 * 15;
+const COPIED_RESET_DELAY = 2000;
+let CopyableCommand = class CopyableCommand extends preact_1.default.Component {
+    constructor() {
+        super(...arguments);
+        this.synced = (0, mobx_1.observable)({
+            copied: false,
+        });
+    }
+    render() {
+        let command = this.props.command;
+        return preact_1.default.createElement("div", { className: typesafecss_1.css.hbox(8).alignItems("flex-start") },
+            preact_1.default.createElement("button", { onClick: async () => {
+                    await navigator.clipboard.writeText(command);
+                    this.synced.copied = true;
+                    setTimeout(() => { this.synced.copied = false; }, COPIED_RESET_DELAY);
+                } }, this.synced.copied && "Copied!" || "Copy"),
+            preact_1.default.createElement("code", { className: typesafecss_1.css.fontFamily("monospace").whiteSpace("pre-wrap")
+                    .hsl(0, 0, 92).pad2(8, 4).borderRadius(4) }, command));
+    }
+};
+CopyableCommand = __decorate([
+    observer_1.observer
+], CopyableCommand);
+let AccessPage = class AccessPage extends preact_1.default.Component {
+    constructor() {
+        super(...arguments);
+        this.synced = (0, mobx_1.observable)({
+            account: "",
+            state: undefined,
+            error: "",
+            lookupIp: "",
+            lookupResults: undefined,
+            lookupError: "",
+            looking: false,
+            granting: "",
+        });
+        this.authenticated = false;
+        this.lookupIP = async () => {
+            let ip = this.synced.lookupIp.trim();
+            if (!ip)
+                return;
+            this.synced.looking = true;
+            this.synced.lookupError = "";
+            try {
+                let controller = await this.controller();
+                let requests = await controller.listRequestsForIP(this.synced.account, ip);
+                this.synced.lookupResults = { ip, requests };
+            }
+            catch (e) {
+                this.synced.lookupError = String(e);
+            }
+            finally {
+                this.synced.looking = false;
+            }
+        };
+        this.approve = async (request) => {
+            this.synced.granting = request.requestId;
+            try {
+                let controller = await this.controller();
+                await controller.grantAccess(request.requestId);
+                if (this.synced.lookupResults) {
+                    this.synced.lookupResults.requests = this.synced.lookupResults.requests.filter(r => r.requestId !== request.requestId);
+                }
+                await this.refresh(this.synced.account);
+            }
+            catch (e) {
+                this.synced.lookupError = String(e);
+            }
+            finally {
+                this.synced.granting = "";
+            }
+        };
+    }
+    componentDidMount() {
+        let account = decodeURIComponent(location.pathname.split("/")[1] || "");
+        this.synced.account = account;
+        if (!account)
+            return;
+        void (async () => {
+            var _a;
+            while (true) {
+                try {
+                    await this.refresh(account);
+                }
+                catch (e) {
+                    this.synced.error = String(e);
+                }
+                if ((_a = this.synced.state) === null || _a === void 0 ? void 0 : _a.hasAccess)
+                    break;
+                await new Promise(resolve => setTimeout(resolve, REFRESH_INTERVAL));
+            }
+        })();
+    }
+    async controller() {
+        let address = location.hostname;
+        let port = +location.port || 443;
+        let nodeId = SocketFunction_1.SocketFunction.connect({ address, port });
+        if (!this.authenticated) {
+            await (0, ArchivesRemote_1.authenticateStorage)({ address, port, nodeId });
+            this.authenticated = true;
+        }
+        return storageController_1.RemoteStorageController.nodes[nodeId];
+    }
+    async refresh(account) {
+        let controller = await this.controller();
+        await controller.requestAccess(account);
+        this.synced.state = await controller.getAccessState(account);
+        this.synced.error = "";
+    }
+    render() {
+        let synced = this.synced;
+        let { account, state, error } = synced;
+        if (!account) {
+            return preact_1.default.createElement("div", { className: typesafecss_1.css.vbox(8).pad2(16) },
+                preact_1.default.createElement("div", null, "Remote storage server."),
+                preact_1.default.createElement("div", null, "Visit /(account name) to request access to an account for this browser."));
+        }
+        return preact_1.default.createElement("div", { className: typesafecss_1.css.vbox(12).pad2(16) },
+            preact_1.default.createElement("div", null,
+                "Storage account: ",
+                account),
+            error && preact_1.default.createElement("div", null,
+                "Error: ",
+                error),
+            !state && !error && preact_1.default.createElement("div", null, "Requesting access..."),
+            state && !state.hasAccess && preact_1.default.createElement("div", { className: typesafecss_1.css.vbox(8) },
+                preact_1.default.createElement("div", null,
+                    "This machine (",
+                    state.machineId,
+                    ", ip ",
+                    state.ip,
+                    ") does NOT have access yet."),
+                preact_1.default.createElement("div", null, "An access request has been made. To grant it, run this command:"),
+                state.grantAccessCommand && preact_1.default.createElement(CopyableCommand, { command: state.grantAccessCommand }),
+                preact_1.default.createElement("div", null,
+                    "This page rechecks every ",
+                    REFRESH_INTERVAL / 1000,
+                    " seconds.")),
+            state && state.hasAccess && preact_1.default.createElement("div", { className: typesafecss_1.css.vbox(16) },
+                preact_1.default.createElement("div", null,
+                    "This machine (",
+                    state.machineId,
+                    ", ip ",
+                    state.ip,
+                    ") has access."),
+                preact_1.default.createElement("div", { className: typesafecss_1.css.vbox(6) },
+                    preact_1.default.createElement("div", null, "Machines with access:"),
+                    preact_1.default.createElement("table", null,
+                        preact_1.default.createElement("thead", null,
+                            preact_1.default.createElement("tr", null,
+                                preact_1.default.createElement("th", { className: typesafecss_1.css.pad2(8, 2).textAlign("left") }, "Machine"),
+                                preact_1.default.createElement("th", { className: typesafecss_1.css.pad2(8, 2).textAlign("left") }, "IP"),
+                                preact_1.default.createElement("th", { className: typesafecss_1.css.pad2(8, 2).textAlign("left") }, "Granted"))),
+                        preact_1.default.createElement("tbody", null, (state.trustedMachines || []).map(m => preact_1.default.createElement("tr", { key: m.machineId },
+                            preact_1.default.createElement("td", { className: typesafecss_1.css.pad2(8, 2) }, m.machineId),
+                            preact_1.default.createElement("td", { className: typesafecss_1.css.pad2(8, 2) }, m.ip),
+                            preact_1.default.createElement("td", { className: typesafecss_1.css.pad2(8, 2) }, new Date(m.time).toLocaleString())))))),
+                preact_1.default.createElement("div", { className: typesafecss_1.css.vbox(6) },
+                    preact_1.default.createElement("div", null, "Approve request"),
+                    preact_1.default.createElement("div", { className: typesafecss_1.css.hbox(8).alignItems("center") },
+                        preact_1.default.createElement("input", { placeholder: "ip", value: synced.lookupIp, onInput: e => { synced.lookupIp = e.currentTarget.value; }, onKeyDown: e => { if (e.key === "Enter")
+                                void this.lookupIP(); } }),
+                        preact_1.default.createElement("button", { disabled: synced.looking || !synced.lookupIp.trim(), onClick: this.lookupIP }, "search")),
+                    synced.lookupError && preact_1.default.createElement("div", null,
+                        "Error: ",
+                        synced.lookupError),
+                    synced.lookupResults && synced.lookupResults.requests.length === 0 && preact_1.default.createElement("div", null,
+                        "No pending requests for ",
+                        synced.lookupResults.ip,
+                        " on this account."),
+                    synced.lookupResults && synced.lookupResults.requests.length > 0 && preact_1.default.createElement("table", null,
+                        preact_1.default.createElement("thead", null,
+                            preact_1.default.createElement("tr", null,
+                                preact_1.default.createElement("th", { className: typesafecss_1.css.pad2(8, 2).textAlign("left") }, "Machine"),
+                                preact_1.default.createElement("th", { className: typesafecss_1.css.pad2(8, 2).textAlign("left") }, "IP"),
+                                preact_1.default.createElement("th", { className: typesafecss_1.css.pad2(8, 2).textAlign("left") }, "Requested"),
+                                preact_1.default.createElement("th", { className: typesafecss_1.css.pad2(8, 2).textAlign("left") }))),
+                        preact_1.default.createElement("tbody", null, synced.lookupResults.requests.map(r => preact_1.default.createElement("tr", { key: r.requestId },
+                            preact_1.default.createElement("td", { className: typesafecss_1.css.pad2(8, 2) }, r.machineId),
+                            preact_1.default.createElement("td", { className: typesafecss_1.css.pad2(8, 2) }, r.ip),
+                            preact_1.default.createElement("td", { className: typesafecss_1.css.pad2(8, 2) }, new Date(r.time).toLocaleString()),
+                            preact_1.default.createElement("td", { className: typesafecss_1.css.pad2(8, 2) },
+                                preact_1.default.createElement("button", { disabled: !!synced.granting, onClick: async () => this.approve(r) }, synced.granting === r.requestId && "Approving..." || "Approve")))))))));
+    }
+};
+AccessPage = __decorate([
+    observer_1.observer
+], AccessPage);
+async function main() {
+    if ((0, misc_1.isNode)())
+        return;
+    preact_1.default.render(preact_1.default.createElement(AccessPage, null), document.body);
+}
+main().catch(console.error);
+//# sourceMappingURL=data:application/json;base64,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//=
+ /* _JS_SOURCE_HASH = "d43f249567654f23591587d34655a51c9c544bab51526debcd47389968cadb82"; */