sliftutils 1.7.9 → 1.7.10

package/index.d.ts

@@ -150,10 +150,14 @@ declare module "sliftutils/misc/https/dns" {
     export declare function setRecord(type: string, key: string, value: string, proxied?: "proxied"): Promise<void>;
     /** Keeps existing records */
     export declare function addRecord(type: string, key: string, value: string, proxied?: "proxied"): Promise<void>;
-    /** Provide Cloudflare credentials directly (an API token, or a path to a file containing one), instead of relying on ./cloudflare.json */
+    /** Provide Cloudflare credentials directly instead of relying on ./cloudflare.json. Exactly one of
+     *  key (the API token itself) or path (a file to read it from) — TypeScript rejects both/neither. */
     export declare function setCloudflareCredentials(config: {
-        key?: string;
-        path?: string;
+        value: {
+            key: string;
+        } | {
+            path: string;
+        };
     }): void;
 
 }
@@ -163,9 +167,12 @@ declare module "sliftutils/misc/https/hostServer" {
         /** Full domain to host on (e.g. "testsite.example.com"). The HTTPS cert is created for this domain and *.domain, so using a subdomain never touches the root domain (beyond its _acme-challenge TXT record). */
         domain: string;
         port: number;
-        /** Cloudflare API token (or a path to a file containing one). If neither is given, ./cloudflare.json is used. */
-        cloudflareApiToken?: string;
-        cloudflareApiTokenPath?: string;
+        /** Cloudflare API token: either the token string ({ key }) or a path to a file containing it ({ path }). Required — pass { path: "./cloudflare.json" } explicitly for the on-disk file. */
+        cloudflareApiToken: {
+            key: string;
+        } | {
+            path: string;
+        };
         /** Creates an unproxied A record pointing domain at this machine (publicIp, or our detected external IP) */
         setDNSRecord?: boolean;
         publicIp?: string;
@@ -796,6 +803,75 @@ declare module "sliftutils/render-utils/observer" {
 
 }
 
+declare module "sliftutils/storage/ArchivesDisk" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import { IArchives, ArchiveFileInfo, ArchivesConfig } from "./IArchives";
+    export declare class ArchivesDisk implements IArchives {
+        private folder;
+        constructor(folder: string);
+        private filesDir;
+        private uploadsDir;
+        private handles;
+        private largeUploads;
+        private nextLargeUploadId;
+        init: {
+            (): Promise<void>;
+            reset(): void;
+            set(newValue: Promise<void>): void;
+        };
+        getDebugName(): string;
+        getConfig(): Promise<ArchivesConfig>;
+        private filePath;
+        set(key: string, data: Buffer, config?: {
+            lastModified?: number;
+        }): Promise<void>;
+        del(key: string): Promise<void>;
+        get(key: string, config?: {
+            range?: {
+                start: number;
+                end: number;
+            };
+        }): Promise<Buffer | undefined>;
+        get2(key: string, config?: {
+            range?: {
+                start: number;
+                end: number;
+            };
+        }): Promise<{
+            data: Buffer;
+            writeTime: number;
+        } | undefined>;
+        getInfo(key: string): Promise<{
+            writeTime: number;
+            size: number;
+        } | undefined>;
+        find(prefix: string, config?: {
+            shallow?: boolean;
+            type: "files" | "folders";
+        }): Promise<string[]>;
+        findInfo(prefix: string, config?: {
+            shallow?: boolean;
+            type?: "files" | "folders";
+        }): Promise<ArchiveFileInfo[]>;
+        private collectFiles;
+        setLargeFile(config: {
+            path: string;
+            getNextData(): Promise<Buffer | undefined>;
+        }): Promise<void>;
+        startLargeUpload(): Promise<string>;
+        appendLargeUpload(id: string, data: Buffer): Promise<void>;
+        finishLargeUpload(id: string, key: string): Promise<void>;
+        cancelLargeUpload(id: string): Promise<void>;
+        getURL(path: string): Promise<string>;
+    }
+    export declare function applyFindInfoShape(files: ArchiveFileInfo[], prefix: string, config?: {
+        shallow?: boolean;
+        type?: "files" | "folders";
+    }): ArchiveFileInfo[];
+
+}
+
 declare module "sliftutils/storage/BulkDatabase2/BulkDatabase2" {
     import { BulkDatabaseBase, ReactiveDeps, BulkDatabase2Config, BulkFileInfoListing, MergeAttemptResult } from "./BulkDatabaseBase";
     export { BulkDatabaseBase, noopReactiveDeps, bulkDatabase2Timing } from "./BulkDatabaseBase";
@@ -1972,11 +2048,78 @@ declare module "sliftutils/storage/FileFolderAPI" {
 declare module "sliftutils/storage/IArchives" {
     /// <reference types="node" />
     /// <reference types="node" />
+    export declare const MAX_LAST_MODIFIED_FUTURE: number;
+    export declare function assertValidLastModified(lastModified: number): void;
+    export type RemoteConfig = {
+        version?: number;
+        sources: RemoteConfigBase[];
+    };
+    /**
+        string arguments will be a url, looking like:
+            https://storage2.vidgridweb.com:4445/file/exampleaccount/examplebucket/storage/storagerouting.json
+            https://f002.backblazeb2.com/file/querysubtest-com-public-immutable/storage/storagerouting.json
+            - These map to { url }, with the type inferred from the url
+            - Hosted urls are /file/<account>/<bucketName>/..., backblaze urls are /file/<bucketName>/...
+
+        NOTE: If we do not have right access to these, then it becomes a read-only IArchives, where we solely read using the url form (which might throw due to not having access as well). UNLESS Our configuration explicitly has public: false, in which case, we don't even hit the URL and we throw on access.
+
+        NOTE: If we're in the browser, we should allow downloading the files via the URL form (if it's a public bucket), however, we won't allow writing, because their servers do not allow secure browser writes.
+    */
+    export type RemoteConfigBase = string | HostedConfig | BackblazeConfig;
+    export type CommonConfig = {
+        /** The default options for the first config in a list is DEFAULT_BASE_SYNC_OPTIONS. The rest default to DEFAULT_SYNC_OPTIONS. */
+        syncOptions?: SyncOptions;
+    };
+    export type HostedConfig = CommonConfig & {
+        type: "remote";
+        url: string;
+        accountName?: string;
+        public?: boolean;
+        fast?: boolean;
+        writeDelay?: number;
+        rawDisk?: boolean;
+        immutable?: boolean;
+    };
+    export type BackblazeConfig = CommonConfig & {
+        type: "backblaze";
+        url: string;
+        bucketName: string;
+        public?: boolean;
+        immutable?: boolean;
+    };
+    export declare const DEFAULT_BASE_SYNC_OPTIONS: SyncOptions;
+    export declare const DEFAULT_SYNC_OPTIONS: SyncOptions;
     export type ArchiveFileInfo = {
         path: string;
         createTime: number;
         size: number;
     };
+    export type ArchivesConfig = {
+        supportsChangesAfter?: boolean;
+    };
+    export type SyncOptions = {
+        copyFiles?: boolean;
+        noWriteBack?: boolean;
+        cacheReads?: boolean;
+        validWindow: [number, number];
+        required?: boolean;
+    };
+    export type ArchivesSource = {
+        source: IArchives;
+        options: SyncOptions;
+    };
+    export type ArchivesSyncSourceStatus = {
+        debugName: string;
+        options: SyncOptions;
+        supportsChangesAfter: boolean;
+        initialScanComplete: boolean;
+        scannedCount: number;
+    };
+    export type ArchivesSyncStatus = {
+        allScansComplete: boolean;
+        indexSize: number;
+        sources: ArchivesSyncSourceStatus[];
+    };
     export interface IArchives {
         getDebugName(): string;
         get(fileName: string, config?: {
@@ -1985,13 +2128,31 @@ declare module "sliftutils/storage/IArchives" {
                 end: number;
             };
         }): Promise<Buffer | undefined>;
-        set(fileName: string, data: Buffer): Promise<void>;
+        /** Like get, but also returns the last-write time of the file. get just calls get2. */
+        get2(fileName: string, config?: {
+            range?: {
+                start: number;
+                end: number;
+            };
+        }): Promise<{
+            data: Buffer;
+            writeTime: number;
+        } | undefined>;
+        /**
+         * lastModified stamps the write with that last-write time instead of now. If it is OLDER than
+         * the file's current last-write time the write no-ops (so delayed / synchronized writes can
+         * never clobber newer data). Times more than 15 minutes in the future are rejected.
+         */
+        set(fileName: string, data: Buffer, config?: {
+            lastModified?: number;
+        }): Promise<void>;
         del(fileName: string): Promise<void>;
         /** Streams a file too large to hold in memory. getNextData returns undefined when done. */
         setLargeFile(config: {
             path: string;
             getNextData(): Promise<Buffer | undefined>;
         }): Promise<void>;
+        /** writeTime is the last-write time — see ArchiveFileInfo.createTime, which is the same value. */
         getInfo(fileName: string): Promise<{
             writeTime: number;
             size: number;
@@ -2006,6 +2167,15 @@ declare module "sliftutils/storage/IArchives" {
         }): Promise<ArchiveFileInfo[]>;
         /** Only works for public buckets (private buckets are API-access only). */
         getURL(path: string): Promise<string>;
+        /** The bucket's configuration, which tells whether the optional functions are supported. */
+        getConfig(): Promise<ArchivesConfig>;
+        /**
+         * All files changed after the given time. Only exists when getConfig().supportsChangesAfter;
+         * backed by an index, so it is fast (unlike a full findInfo scan). Deletions are not reported.
+         */
+        getChangesAfter?(time: number): Promise<ArchiveFileInfo[]>;
+        /** Synchronization introspection, for backends that synchronize from sources (see BlobStore). */
+        getSyncStatus?(): Promise<ArchivesSyncStatus>;
     }
 
 }
@@ -2266,7 +2436,7 @@ declare module "sliftutils/storage/TransactionStorage" {
 declare module "sliftutils/storage/backblaze" {
     /// <reference types="node" />
     /// <reference types="node" />
-    import { IArchives } from "./IArchives";
+    import { IArchives, ArchivesConfig } from "./IArchives";
     export declare class ArchivesBackblaze implements IArchives {
         private config;
         constructor(config: {
@@ -2291,7 +2461,19 @@ declare module "sliftutils/storage/backblaze" {
             };
             retryCount?: number;
         }): Promise<Buffer | undefined>;
-        set(fileName: string, data: Buffer): Promise<void>;
+        get2(fileName: string, config?: {
+            range?: {
+                start: number;
+                end: number;
+            };
+        }): Promise<{
+            data: Buffer;
+            writeTime: number;
+        } | undefined>;
+        getConfig(): Promise<ArchivesConfig>;
+        set(fileName: string, data: Buffer, config?: {
+            lastModified?: number;
+        }): Promise<void>;
         del(fileName: string): Promise<void>;
         setLargeFile(config: {
             path: string;
@@ -2574,23 +2756,16 @@ declare module "sliftutils/storage/remoteFileStorage" {
 declare module "sliftutils/storage/remoteStorage/ArchivesRemote" {
     /// <reference types="node" />
     /// <reference types="node" />
-    import { IArchives, ArchiveFileInfo } from "../IArchives";
+    import { IArchives, ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus } from "../IArchives";
     export type ArchivesRemoteConfig = {
-        address: string;
-        port: number;
-        account: string;
-        bucketName: string;
-        public?: boolean;
-        fast?: boolean;
-        writeDelay?: number;
+        url: string;
+        accountName?: string;
+        waitForAccess?: boolean;
     };
-    export declare function buildPublicFileURL(config: {
+    export declare function parseStorageUrl(url: string): {
         address: string;
         port: number;
-        account: string;
-        bucketName: string;
-        path: string;
-    }): string;
+    };
     export declare function authenticateStorage(config: {
         address: string;
         port: number;
@@ -2602,16 +2777,21 @@ declare module "sliftutils/storage/remoteStorage/ArchivesRemote" {
     export declare class ArchivesRemote implements IArchives {
         private config;
         constructor(config: ArchivesRemoteConfig);
+        private parsed;
+        private account;
+        private bucketName;
         private nodeId;
         private controller;
-        private setupDone;
         private lastDeniedLog;
         getDebugName(): string;
         private authenticate;
         private callAuthed;
-        waitingForAccess(): Promise<string | undefined>;
+        waitingForAccess(): Promise<{
+            link: string;
+            machineId: string;
+            ip: string;
+        } | undefined>;
         private onAccessDenied;
-        private ensureSetup;
         private call;
         get(fileName: string, config?: {
             range?: {
@@ -2619,7 +2799,18 @@ declare module "sliftutils/storage/remoteStorage/ArchivesRemote" {
                 end: number;
             };
         }): Promise<Buffer | undefined>;
-        set(fileName: string, data: Buffer): Promise<void>;
+        get2(fileName: string, config?: {
+            range?: {
+                start: number;
+                end: number;
+            };
+        }): Promise<{
+            data: Buffer;
+            writeTime: number;
+        } | undefined>;
+        set(fileName: string, data: Buffer, config?: {
+            lastModified?: number;
+        }): Promise<void>;
         del(fileName: string): Promise<void>;
         getInfo(fileName: string): Promise<{
             writeTime: number;
@@ -2633,11 +2824,64 @@ declare module "sliftutils/storage/remoteStorage/ArchivesRemote" {
             shallow?: boolean;
             type: "files" | "folders";
         }): Promise<string[]>;
+        getChangesAfter(time: number): Promise<ArchiveFileInfo[]>;
+        getConfig(): Promise<ArchivesConfig>;
+        getSyncStatus(): Promise<ArchivesSyncStatus>;
+        setLargeFile(config: {
+            path: string;
+            getNextData(): Promise<Buffer | undefined>;
+        }): Promise<void>;
+        getURL(path: string): Promise<string>;
+    }
+
+}
+
+declare module "sliftutils/storage/remoteStorage/ArchivesUrl" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import { IArchives, ArchiveFileInfo, ArchivesConfig } from "../IArchives";
+    export declare class ArchivesUrl implements IArchives {
+        private base;
+        constructor(base: string);
+        getDebugName(): string;
+        private readOnlyError;
+        get(fileName: string, config?: {
+            range?: {
+                start: number;
+                end: number;
+            };
+        }): Promise<Buffer | undefined>;
+        get2(fileName: string, config?: {
+            range?: {
+                start: number;
+                end: number;
+            };
+        }): Promise<{
+            data: Buffer;
+            writeTime: number;
+        } | undefined>;
+        getInfo(fileName: string): Promise<{
+            writeTime: number;
+            size: number;
+        } | undefined>;
+        set(fileName: string, data: Buffer, config?: {
+            lastModified?: number;
+        }): Promise<void>;
+        del(fileName: string): Promise<void>;
         setLargeFile(config: {
             path: string;
             getNextData(): Promise<Buffer | undefined>;
         }): Promise<void>;
+        find(prefix: string, config?: {
+            shallow?: boolean;
+            type: "files" | "folders";
+        }): Promise<string[]>;
+        findInfo(prefix: string, config?: {
+            shallow?: boolean;
+            type: "files" | "folders";
+        }): Promise<ArchiveFileInfo[]>;
         getURL(path: string): Promise<string>;
+        getConfig(): Promise<ArchivesConfig>;
     }
 
 }
@@ -2650,45 +2894,97 @@ declare module "sliftutils/storage/remoteStorage/accessPage" {
 declare module "sliftutils/storage/remoteStorage/blobStore" {
     /// <reference types="node" />
     /// <reference types="node" />
-    import { ArchiveFileInfo } from "../IArchives";
+    import { ArchiveFileInfo, ArchivesSource, ArchivesSyncStatus } from "../IArchives";
     export declare const DEFAULT_FAST_WRITE_DELAY: number;
     export type WriteConfig = {
         fast?: boolean;
         writeDelay?: number;
+        lastModified?: number;
     };
-    export declare class BlobStore {
+    export type IBucketStore = {
+        get(fileName: string, config?: {
+            range?: {
+                start: number;
+                end: number;
+            };
+        }): Promise<Buffer | undefined>;
+        get2(fileName: string, config?: {
+            range?: {
+                start: number;
+                end: number;
+            };
+        }): Promise<{
+            data: Buffer;
+            writeTime: number;
+        } | undefined>;
+        set(fileName: string, data: Buffer, config?: WriteConfig): Promise<void>;
+        del(fileName: string, config?: WriteConfig): Promise<void>;
+        getInfo(fileName: string): Promise<{
+            writeTime: number;
+            size: number;
+        } | undefined>;
+        findInfo(prefix: string, config?: {
+            shallow?: boolean;
+            type?: "files" | "folders";
+        }): Promise<ArchiveFileInfo[]>;
+        getChangesAfter?(time: number): Promise<ArchiveFileInfo[]>;
+        getSyncStatus?(): Promise<ArchivesSyncStatus>;
+        startLargeUpload(): Promise<string>;
+        appendLargeUpload(id: string, data: Buffer): Promise<void>;
+        finishLargeUpload(id: string, key: string): Promise<void>;
+        cancelLargeUpload(id: string): Promise<void>;
+    };
+    export declare class BlobStore implements IBucketStore {
         private folder;
-        constructor(folder: string);
-        private memCache;
-        private overlay;
-        private writeQueue;
-        private openBlobs;
-        private largeUploads;
-        private nextLargeUploadId;
-        private currentBlobNumber;
-        private currentBlobOffset;
-        private currentBlobFd;
+        private sources;
+        private config?;
+        constructor(folder: string, sources: ArchivesSource[], config?: {
+            onIndexChanged?: ((key: string) => void) | undefined;
+        } | undefined);
+        private stopped;
         private index;
-        private deadBytes;
-        private blobsDir;
+        private mem;
+        private dirty;
+        private overlay;
+        private sourceStates;
         init: {
             (): Promise<void>;
             reset(): void;
             set(newValue: Promise<void>): void;
         };
-        private blobName;
-        private blobPath;
-        private getBlobHandle;
-        private closeBlobHandle;
-        private addDeadBytes;
-        private appendData;
+        dispose(): Promise<void>;
+        private loadIndex;
         private setIndexEntry;
+        private deleteIndexEntry;
+        private flushIndex;
+        private runSourceSync;
+        private scanSource;
+        private applyScanned;
+        private pollChanges;
+        private copySourceFiles;
+        private waitForRequiredScans;
+        private checkMissingKey;
+        private getIndexEntry;
+        get(key: string, config?: {
+            range?: {
+                start: number;
+                end: number;
+            };
+        }): Promise<Buffer | undefined>;
+        get2(key: string, config?: {
+            range?: {
+                start: number;
+                end: number;
+            };
+        }): Promise<{
+            data: Buffer;
+            writeTime: number;
+        } | undefined>;
+        private cacheRead;
         set(key: string, data: Buffer, config?: WriteConfig): Promise<void>;
+        private writeToSources;
         del(key: string, config?: WriteConfig): Promise<void>;
-        get(key: string, range?: {
-            start: number;
-            end: number;
-        }): Promise<Buffer | undefined>;
+        private deleteFromSources;
         getInfo(key: string): Promise<{
             writeTime: number;
             size: number;
@@ -2697,22 +2993,125 @@ declare module "sliftutils/storage/remoteStorage/blobStore" {
             shallow?: boolean;
             type?: "files" | "folders";
         }): Promise<ArchiveFileInfo[]>;
+        getChangesAfter(time: number): Promise<ArchiveFileInfo[]>;
+        getSyncStatus(): Promise<ArchivesSyncStatus>;
+        private getDiskSource;
         startLargeUpload(): Promise<string>;
         appendLargeUpload(id: string, data: Buffer): Promise<void>;
         finishLargeUpload(id: string, key: string): Promise<void>;
         cancelLargeUpload(id: string): Promise<void>;
         private flushOverlay;
-        private compact;
     }
 
 }
 
+declare module "sliftutils/storage/remoteStorage/cliArgs" {
+    export declare function getArg(name: string): string | undefined;
+
+}
+
+declare module "sliftutils/storage/remoteStorage/createArchives" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import { IArchives, RemoteConfig, RemoteConfigBase, HostedConfig, BackblazeConfig, ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus } from "../IArchives";
+    export declare function createApiArchives(source: HostedConfig | BackblazeConfig): IArchives;
+    export declare class ArchivesChain implements IArchives {
+        private normalized;
+        private adopted;
+        private sourcesPromise;
+        constructor(config: RemoteConfig | RemoteConfigBase);
+        getDebugName(): string;
+        private getSourceConfigs;
+        private getSources;
+        private init;
+        private ensureRouting;
+        private readFromSource;
+        private read;
+        private getAccessHelp;
+        private write;
+        waitingForAccess(): Promise<{
+            link: string;
+            machineId: string;
+            ip: string;
+        } | undefined>;
+        get(fileName: string, config?: {
+            range?: {
+                start: number;
+                end: number;
+            };
+        }): Promise<Buffer | undefined>;
+        get2(fileName: string, config?: {
+            range?: {
+                start: number;
+                end: number;
+            };
+        }): Promise<{
+            data: Buffer;
+            writeTime: number;
+        } | undefined>;
+        getInfo(fileName: string): Promise<{
+            writeTime: number;
+            size: number;
+        } | undefined>;
+        find(prefix: string, config?: {
+            shallow?: boolean;
+            type: "files" | "folders";
+        }): Promise<string[]>;
+        findInfo(prefix: string, config?: {
+            shallow?: boolean;
+            type: "files" | "folders";
+        }): Promise<ArchiveFileInfo[]>;
+        getChangesAfter(time: number): Promise<ArchiveFileInfo[]>;
+        getSyncStatus(): Promise<ArchivesSyncStatus>;
+        getConfig(): Promise<ArchivesConfig>;
+        set(fileName: string, data: Buffer, config?: {
+            lastModified?: number;
+        }): Promise<void>;
+        del(fileName: string): Promise<void>;
+        setLargeFile(config: {
+            path: string;
+            getNextData(): Promise<Buffer | undefined>;
+        }): Promise<void>;
+        getURL(path: string): Promise<string>;
+    }
+    export declare function createArchives(config: RemoteConfig | RemoteConfigBase): ArchivesChain;
+
+}
+
+declare module "sliftutils/storage/remoteStorage/grantAccessCli" {
+    export {};
+
+}
+
+declare module "sliftutils/storage/remoteStorage/remoteConfig" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import { RemoteConfig, RemoteConfigBase, HostedConfig, BackblazeConfig } from "../IArchives";
+    export declare const ROUTING_FILE = "storage/storagerouting.json";
+    export declare function getConfigVersion(config: RemoteConfig): number;
+    /** Strips the routing-file suffix, leaving the bucket's public base URL (file paths append to it). */
+    export declare function getBucketBaseUrl(url: string): string;
+    export declare function buildFileUrl(baseUrl: string, filePath: string): string;
+    export declare function parseHostedUrl(url: string): {
+        address: string;
+        port: number;
+        account: string;
+        bucketName: string;
+    };
+    export declare function parseBackblazeUrl(url: string): {
+        bucketName: string;
+    };
+    export declare function normalizeSource(source: RemoteConfigBase): HostedConfig | BackblazeConfig;
+    export declare function normalizeRemoteConfig(config: RemoteConfig | RemoteConfigBase): RemoteConfig;
+    export declare function parseRoutingData(data: Buffer): RemoteConfig;
+    export declare function serializeRemoteConfig(config: RemoteConfig): Buffer;
+
+}
+
 declare module "sliftutils/storage/remoteStorage/storageController" {
     /// <reference types="node" />
     /// <reference types="node" />
-    import { ArchiveFileInfo } from "../IArchives";
-    import type { BlobStore } from "./blobStore";
-    import type { IStorage } from "../IStorage";
+    import { ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus } from "../IArchives";
     export declare const REMOTE_STORAGE_CLASS_GUID = "RemoteStorageController-b7e42a91";
     export declare const STORAGE_AUTH_PURPOSE = "remoteStorage-auth-1";
     export declare const STORAGE_NOT_AUTHENTICATED = "REMOTE_STORAGE_NOT_AUTHENTICATED_cf2f7b1e";
@@ -2735,33 +3134,13 @@ declare module "sliftutils/storage/remoteStorage/storageController" {
         ip: string;
         time: number;
     };
-    export type BucketConfig = {
-        public?: boolean;
-        fast?: boolean;
-        writeDelay?: number;
-    };
     export type AccessState = {
         machineId: string;
         ip: string;
         hasAccess: boolean;
-        listAccessCommand: string;
         grantAccessCommand?: string;
-        machines?: (AccessRequest & {
-            trusted: boolean;
-        })[];
-    };
-    export type StorageServerState = {
-        domain: string;
-        port: number;
-        rootDomain: string;
-        sshTarget: string;
-        serverCommand: string;
-        blobStore: BlobStore;
-        trust: IStorage<TrustRecord>;
-        requests: IStorage<AccessRequest[]>;
-        buckets: IStorage<BucketConfig>;
+        trustedMachines?: TrustRecord[];
     };
-    export declare function setStorageServerState(state: StorageServerState): void;
     export declare const RemoteStorageController: import("socket-function/SocketFunctionTypes").SocketRegistered<{
         authenticate: (token: AuthToken) => Promise<{
             machineId: string;
@@ -2774,14 +3153,22 @@ declare module "sliftutils/storage/remoteStorage/storageController" {
             grantAccessCommand: string;
         }>;
         getAccessState: (account: string) => Promise<AccessState>;
+        listRequestsForIP: (account: string, ip: string) => Promise<AccessRequest[]>;
+        grantAccess: (requestId: string) => Promise<TrustRecord>;
         adminListRequests: (ip: string) => Promise<AccessRequest[]>;
         adminGrantAccess: (requestId: string) => Promise<TrustRecord>;
-        ensureBucket: (account: string, bucketName: string, config: BucketConfig) => Promise<void>;
         get: (account: string, bucketName: string, path: string, range?: {
             start: number;
             end: number;
         }) => Promise<Buffer | undefined>;
-        set: (account: string, bucketName: string, path: string, data: Buffer) => Promise<void>;
+        get2: (account: string, bucketName: string, path: string, range?: {
+            start: number;
+            end: number;
+        }) => Promise<{
+            data: Buffer;
+            writeTime: number;
+        } | undefined>;
+        set: (account: string, bucketName: string, path: string, data: Buffer, lastModified?: number) => Promise<void>;
         del: (account: string, bucketName: string, path: string) => Promise<void>;
         getInfo: (account: string, bucketName: string, path: string) => Promise<{
             writeTime: number;
@@ -2791,17 +3178,80 @@ declare module "sliftutils/storage/remoteStorage/storageController" {
             shallow?: boolean;
             type?: "files" | "folders";
         }) => Promise<ArchiveFileInfo[]>;
+        getChangesAfter: (account: string, bucketName: string, time: number) => Promise<ArchiveFileInfo[]>;
+        getArchivesConfig: (account: string, bucketName: string) => Promise<ArchivesConfig>;
+        getSyncStatus: (account: string, bucketName: string) => Promise<ArchivesSyncStatus>;
         startLargeFile: (account: string, bucketName: string, path: string) => Promise<string>;
         uploadPart: (uploadId: string, data: Buffer) => Promise<void>;
         finishLargeFile: (uploadId: string) => Promise<void>;
         cancelLargeFile: (uploadId: string) => Promise<void>;
-        getPublicFile: (account: string, bucketName: string, path: string) => Promise<Buffer>;
+        httpEntry: (config?: {
+            requireCalls?: string[];
+            cacheTime?: number;
+        }) => Promise<Buffer>;
     }>;
 
 }
 
 declare module "sliftutils/storage/remoteStorage/storageServer" {
     import "./accessPage";
+    export type HostStorageServerConfig = {
+        url: string;
+        folder: string;
+        cloudflareApiToken?: {
+            key: string;
+        } | {
+            path: string;
+        };
+        lowSpaceThresholdBytes?: number;
+    };
+    export declare function hostStorageServer(config: HostStorageServerConfig): Promise<void>;
+
+}
+
+declare module "sliftutils/storage/remoteStorage/storageServerCli" {
+    export {};
+
+}
+
+declare module "sliftutils/storage/remoteStorage/storageServerState" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import { IBucketStore } from "./blobStore";
+    import { RemoteConfig, HostedConfig, IArchives } from "../IArchives";
+    import type { IStorage } from "../IStorage";
+    import type { AccessRequest, TrustRecord } from "./storageController";
+    export type StorageServerConfig = {
+        domain: string;
+        port: number;
+        rootDomain: string;
+        sshTarget: string;
+        serverCommand: string;
+        folder: string;
+    };
+    export declare function setStorageServerConfig(value: StorageServerConfig): void;
+    export declare function getStorageServerConfig(): StorageServerConfig;
+    export declare function getStorageServerConfigOptional(): StorageServerConfig | undefined;
+    export declare function setWritesRejectedReason(reason: string | undefined): void;
+    export declare function getWritesRejectedReason(): string | undefined;
+    export declare function assertWritesAllowed(): void;
+    export declare function getTrust(): Promise<IStorage<TrustRecord>>;
+    export declare function getRequests(): Promise<IStorage<AccessRequest[]>>;
+    export type LoadedBucket = {
+        account: string;
+        bucketName: string;
+        routing: RemoteConfig;
+        routingJSON: string;
+        self: HostedConfig | undefined;
+        store: IBucketStore;
+    };
+    export declare function getLoadedBucket(account: string, bucketName: string): Promise<LoadedBucket | undefined>;
+    export declare function assertMutable(bucket: LoadedBucket, filePath: string): Promise<void>;
+    export declare function writeBucketFile(account: string, bucketName: string, filePath: string, data: Buffer, config?: {
+        lastModified?: number;
+    }): Promise<void>;
+    export declare function deleteBucketFile(account: string, bucketName: string, filePath: string): Promise<void>;
+    export declare function getLocalArchives(account: string, bucketName: string): IArchives;
 
 }