0.2.7

.gitattributes

@@ -3,3 +3,5 @@
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.pdf filter=lfs diff=lfs merge=lfs -text
 *.enc filter=lfs diff=lfs merge=lfs -text
+*.svg filter=lfs diff=lfs merge=lfs -text
+*.excalidraw filter=lfs diff=lfs merge=lfs -text

.github/workflows/auto-build.yml

@@ -13,6 +13,8 @@ jobs:
   build:
     runs-on: ubuntu-latest
 
+    environment: env-for-buildci
+
     strategy:
       matrix:
         node-version: [16.x]

.gitignore

@@ -13,5 +13,8 @@ main.js
 # obsidian
 data.json
 
+# debug
+logs.txt
+
 # hidden files
 .*

README.md

@@ -1,18 +1,24 @@
 # Remotely Save
 
-This is yet another unofficial sync plugin for Obsidian.
+This is yet another unofficial sync plugin for Obsidian. If you like it or find it useful, please consider give it a [star ![GitHub Repo stars](https://img.shields.io/github/stars/fyears/remotely-save?style=social)](https://github.com/fyears/remotely-save) on Github.
+
+[![BuildCI](https://github.com/fyears/remotely-save/actions/workflows/auto-build.yml/badge.svg)](https://github.com/fyears/remotely-save/actions/workflows/auto-build.yml) [![Latest release: 0.2.6)](https://img.shields.io/github/downloads/fyears/remotely-save/0.2.6/main.js?sort=semver)](https://github.com/fyears/remotely-save/releases) [![Previous release: 0.2.5)](https://img.shields.io/github/downloads/fyears/remotely-save/0.2.5/main.js)](https://github.com/fyears/remotely-save/releases)
 
 ## Disclaimer
 
-- **This is NOT the [official sync service](https://github.com/fyears/obsidian-remotely-save.git) provided by Obsidian.**
+- **This is NOT the [official sync service](https://obsidian.md/sync) provided by Obsidian.**
 
 ## !!!Caution!!!
 
-As of November 2021, the plugin is considered in BETA stage. **DO NOT USE IT for any serious vaults.** **Backup your vault before using this plugin.** Don't be surprise to data loss!
+As of Jan 2022, the plugin is considered in BETA stage. **DO NOT USE IT for any serious vaults.** **ALWAYS, ALWAYS, backup your vault before using this plugin.**
 
 ## Features
 
-- **Amazon S3 or S3-compatible services are supported.** Webdav supports on the plan.
+- Supports:
+  - Amazon S3 or S3-compatible
+  - Dropbox
+  - OneDrive
+  - Webdav
 - **Obsidiain Mobile supported.** Vaults can be synced across mobile and desktop devices with the cloud service as the "broker".
 - **[End-to-end encryption](./docs/encryption.md) supported.** Files would be encrypted using openssl format before being sent to the cloud **if** user specify a password.
 - **[Minimal Intrusive](./docs/minimal_intrusive_design.md).**
@@ -27,18 +33,77 @@ As of November 2021, the plugin is considered in BETA stage. **DO NOT USE IT for
 - **Cloud services cost you money.** Always be aware of the costs and pricing.
 - **All files or folder starting with `.` (dot) or `_` (underscore) are treated as hidden files, and would NOT be synced.** It's useful if you have some files just staying locally. But this strategy also means that themes / other plugins / settings of this plugin would neither be synced.
 
+## Questions, Suggestions, Or Bugs
+
+You are greatly welcome to ask questions, post any suggestions, or report any bugs! The project is mainly maintained on GitHub:
+
+- Questions: [GitHub repo Discussions](https://github.com/fyears/remotely-save/discussions)
+- Suggestions: also in [GitHub repo Discussions](https://github.com/fyears/remotely-save/discussions)
+- Bugs: [GitHub repo Issues](https://github.com/fyears/remotely-save/issues) (NOT Discussion)
+
+Additionally, the plugin author may occasionally visit Obsidian official forum and official Discord server, and pay attention to this-plugin-related information there.
+
 ## Download and Install
 
-- Option #1: [![BuildCI](https://github.com/fyears/obsidian-remotely-save/actions/workflows/auto-build.yml/badge.svg)](https://github.com/fyears/obsidian-remotely-save/actions/workflows/auto-build.yml) Every artifacts are placed in the "Summary" under every successful builds.
+- Option #1: You can search, download, and install the plugin in official "community plugin list".
-- Option #2: Besides manually downloading the files, you can also use [Obsidian42 - BRAT](https://github.com/TfTHacker/obsidian42-brat) to install this plugin.
+- Option #2: You can also use [Obsidian42 - BRAT](https://github.com/TfTHacker/obsidian42-brat) to install this plugin. Input `fyears/remotely-save` in the configuration of BRAT.
-- Option #3: The pluin would be submitted to the official "community plugin list" in near future.
+- Option #3: [![GitHub release (latest by SemVer and asset including pre-releases)](https://img.shields.io/github/downloads-pre/fyears/remotely-save/latest/main.js?sort=semver)](https://github.com/fyears/remotely-save/releases) Manually download assets (`main.js`, `manifest.json`, `styles.css`) from the latest release.
+- Option #4: [![BuildCI](https://github.com/fyears/remotely-save/actions/workflows/auto-build.yml/badge.svg)](https://github.com/fyears/remotely-save/actions/workflows/auto-build.yml) Every artifacts are placed in the "Summary" under every successful builds. It's automatically generated by every commit, may break something.
 
 ## Usage
 
+### S3
+
 - Prepare your S3 (-compatible) service information: [endpoint, region](https://docs.aws.amazon.com/general/latest/gr/s3.html), [access key id, secret access key](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/getting-your-credentials.html), bucket name. The bucket should be empty and solely for syncing a vault.
-- Configure (enable) [CORS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enabling-cors-examples.html) for requests from `app://obsidian.md`. It's unfortunately required, because the plugin sends requests from a browser-like envirement.
+- Configure (enable) [CORS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enabling-cors-examples.html) for requests from `app://obsidian.md` and `capacitor://localhost` and `http://localhost`. It's unfortunately required, because the plugin sends requests from a browser-like envirement. And those addresses are tested and found on desktop and ios and android.
 - Download and enable this plugin.
-- Enter your infomation to the settings of this plugin.
+- Enter your information to the settings of this plugin.
 - If you want to enable end-to-end encryption, also set a password in settings. If you do not specify a password, the files and folders are synced in plain, original content to the cloud.
 - Click the new "switch" icon on the ribbon (the left sidebar), **every time** you want to sync your vault between local and remote. (No "auto sync" yet.)
 - **Be patient while syncing.** Especially in the first-time sync.
+
+### Dropbox
+
+- **This plugin's function for Dropbox is not as mature as functions for S3.**
+- **This plugin is NOT an official Dropbox product.** The plugin just uses Dropbox's public API.
+- After the authorization, the plugin can read your name and email (which cannot be unselected on Dropbox api), and read and write files in your Dropbox's `/Apps/remotely-save` folder.
+- If you decide to authorize this plugin to connect to Dropbox, please go to plugin's settings, and choose Dropbox then follow the instructions.
+- Password-based end-to-end encryption is also supported. But please be aware that **the vault name itself is not encrypted**.
+
+### OneDrive
+
+- **This plugin's function for OneDrive is not as mature as functions for S3.**
+- **This plugin is NOT an official Microsoft / OneDrive product.** The plugin just uses Microsoft's [OneDrive's public API](https://docs.microsoft.com/en-us/onedrive/developer/rest-api).
+- After the authorization, the plugin can read your name and email, and read and write files in your OneDrive's `/Apps/remotely-save` folder.
+- If you decide to authorize this plugin to connect to OneDrive, please go to plugin's settings, and choose OneDrive then follow the instructions.
+- Password-based end-to-end encryption is also supported. But please be aware that **the vault name itself is not encrypted**.
+
+### webdav
+
+- **webdav support is considered experimental.**
+- Currently only supports BASIC authorization method.
+- Currently webdav server has to be enabled CORS for requests from `app://obsidian.md` and `capacitor://localhost` and `http://localhost`, **AND** all webdav HTTP methods, **AND** all webdav headers. These are required, because Obsidian mobile works like a browser and mobile plugins are limited by CORS policies.
+  - Popular software NextCloud, OwnCloud, `rclone serve webdav` do **NOT** enable CORS by default. If you are using any of them, you should evaluate the risk, and find a way to enable CORS, before using this plugin.
+  - The plugin is tested successfully under python package [`wsgidav` (version 4.0)](https://github.com/mar10/wsgidav). See [this issue](https://github.com/mar10/wsgidav/issues/239) for some details.
+- Your data would be synced to a `${vaultName}` sub folder on your webdav server.
+- Password-based end-to-end encryption is also supported. But please be aware that **the vault name itself is not encrypted**.
+
+## Import And Export Not-Oauth2 Plugin Settings By QR Code
+
+It's often verbose / inconvenient to input not-oauth2 credentials on mobile. (On different desktop computers, it's trivial to copy and paste `data.json` across different devices.)
+
+So this plugin has a helper function to export those settings as a QR code, then you could use mobile device's camera to import the settings.
+
+Attention:
+
+1. Oauth2 - related information is omitted. It means that Dropbox, OneDrive login credentials are NOT included in the QR Code.
+2. Please, NEVER share the QR Code to others. It's as equivalent to the login credentials.
+
+Steps:
+
+1. Configure the plugin settings on one device, and make sure the sync functions work. (E.g, you could sync notes using S3 credentials.)
+2. Open plugin settings page. Then scroll down the page, until the section "Import and Export Settings". Click the button "Get QR Code". A new modal should show up and you should see a QR code.
+3. On a second device, make sure the vault name is the same as the first device's.
+4. On that second device, use its camera app, or any apps that support scanning QR codes, to scan the QR code from the first device. (On latest iOS, the system's built in camera app should work. On Android, at least one open source app [Binary Eye](https://github.com/markusfisch/BinaryEye) is tested to be working.)
+5. A link / url / address should be identified in the scan-QR-code app, and you could follow the instruction in the app, and then you should be redirected to open the Obsidian app.
+6. And finally, there should be a new notice in the Obsidian app saying the settings are successfully imported. Otherwise please check the error message in the notice.

assets/logo.excalidraw

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b33b2a71f2d91988416c17015b59ef205dbf6a8c704ecac1cc95ed03ccc2c8e
+size 16537

assets/logo.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:98358aa726dcb5565164ff260634f5c527223d1f2ec1d0410b400625c8dad704
+size 14082

assets/logo.svg

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:02a5057ebe38e4c3835c8354f53aca01c4c2335d8a0435e22f509b4ca4a73ca4
+size 12889

docs/encryption.md

@@ -15,15 +15,20 @@ The encryption algorithm is delibrately designed to be aligned with openssl form
    openssl enc -d -p -aes-256-cbc -pbkdf2 -iter 20000 -pass pass:somepassword -in ./sometext.txt.enc -out ./sometext.txt
    ```
 
-3. The file/directory path strings, are encrypted using openssl in binary mode and then `base32` is applied.
+3. The file/directory path strings, are encrypted using openssl in binary mode and then `base64url without padding` is applied.
    Assuming the file path is `a-folder-文件夹/a-file-文件.md`, then the following commands are equivilent:
 
    ```bash
-   # pure string encryption then base32
+   # prepare the functions
-   echo -n 'a-folder-文件夹/a-file-文件.md' | openssl enc -aes-256-cbc -pbkdf2 -iter 20000 -pass pass:mylongpassword | base32 -w 0
+   # https://unix.stackexchange.com/questions/628842
+   base64url::encode () { base64 -w0 | tr '+/' '-_' | tr -d '='; }
+   base64url::decode () { awk '{ if (length($0) % 4 == 3) print $0"="; else if (length($0) % 4 == 2) print $0"=="; else print $0; }' | tr -- '-_' '+/' | base64 -d; }
 
-   # pure string base32 then decryption
+   # pure string encryption then base32
-   echo -n 'KNQWY5DFMRPV7UHRWVYFSHE2XVVVZCFN65SR7ETEKO5L6EYGXCVEPT4A2LVTW4W2ZHXWF3K22SVA562CCZ6SALARXJY6AAXXHLK5UOA=' | base32 -d -w 00 | openssl enc -d -aes-256-cbc -pbkdf2 -iter 20000 -pass pass:mylongpassword
+   echo -n 'a-folder-文件夹/a-file-文件.md' | openssl enc -aes-256-cbc -pbkdf2 -iter 20000 -pass pass:mylongpassword | base64url::encode
+
+   # pure string base64url then decryption
+   echo -n 'U2FsdGVkX19tNkdFL5rZeHxbe7FL-Pp5mkZJkDNFJWFT6lldZlfa57j0C_cKn0I3PZ9YDvOkyoKqfF6lbn0_yg' | base64url::decode | openssl enc -d -aes-256-cbc -pbkdf2 -iter 20000 -pass pass:mylongpassword
    ```
 
 4. The directory is considered as special "0-byte" object on remote s3. So this meta infomation may be easily guessed if some third party can access the remote bucket.

esbuild.config.mjs

@@ -0,0 +1,49 @@
+import dotenv from "dotenv/config";
+import esbuild from "esbuild";
+import process from "process";
+// import builtins from 'builtin-modules'
+
+const banner = `/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+`;
+
+const prod = process.argv[2] === "production";
+
+const DEFAULT_DROPBOX_APP_KEY = process.env.DROPBOX_APP_KEY || "";
+const DEFAULT_ONEDRIVE_CLIENT_ID = process.env.ONEDRIVE_CLIENT_ID || "";
+const DEFAULT_ONEDRIVE_AUTHORITY = process.env.ONEDRIVE_AUTHORITY || "";
+
+esbuild
+  .build({
+    banner: {
+      js: banner,
+    },
+    loader: {
+      ".svg": "text",
+    },
+    entryPoints: ["./src/main.ts"],
+    bundle: true,
+    external: [
+      "obsidian",
+      "electron",
+      "fs",
+      "crypto",
+      // ...builtins
+    ],
+    format: "cjs",
+    watch: !prod,
+    target: "es2016",
+    logLevel: "info",
+    sourcemap: prod ? false : "inline",
+    treeShaking: true,
+    minify: prod,
+    outfile: "main.js",
+    define: {
+      "process.env.DEFAULT_DROPBOX_APP_KEY": `"${DEFAULT_DROPBOX_APP_KEY}"`,
+      "process.env.DEFAULT_ONEDRIVE_CLIENT_ID": `"${DEFAULT_ONEDRIVE_CLIENT_ID}"`,
+      "process.env.DEFAULT_ONEDRIVE_AUTHORITY": `"${DEFAULT_ONEDRIVE_AUTHORITY}"`,
+    },
+  })
+  .catch(() => process.exit(1));

manifest.json

@@ -1,9 +1,9 @@
 {
-  "id": "obsidian-remotely-Save",
+  "id": "remotely-save",
   "name": "Remotely Save",
-  "version": "0.0.16",
+  "version": "0.2.7",
   "minAppVersion": "0.12.15",
-  "description": "Yet another unofficial plugin allowing users to sync notes between local device and the cloud service.",
+  "description": "Yet another unofficial plugin allowing users to synchronize notes between local device and the cloud service.",
   "author": "fyears",
   "authorUrl": "https://github.com/fyears",
   "isDesktopOnly": false

package.json

@@ -1,54 +1,76 @@
 {
-  "name": "obsidian-remotely-save",
+  "name": "remotely-save",
-  "version": "0.0.16",
+  "version": "0.2.7",
   "description": "This is yet another sync plugin for Obsidian app.",
   "scripts": {
-    "dev": "webpack --mode development --watch",
+    "dev": "node esbuild.config.mjs",
+    "build2": "tsc -noEmit -skipLibCheck && node esbuild.config.mjs production",
     "build": "webpack --mode production",
     "format": "npx prettier --write .",
     "clean": "npx rimraf main.js",
     "test": "cross-env TS_NODE_COMPILER_OPTIONS={\\\"module\\\":\\\"commonjs\\\"} mocha -r ts-node/register 'tests/**/*.ts'"
   },
+  "browser": {
+    "path": "path-browserify",
+    "process": "process/browser",
+    "stream": "stream-browserify",
+    "crypto": "crypto-browserify"
+  },
   "source": "main.ts",
   "keywords": [],
   "author": "",
   "license": "Apache-2.0",
   "devDependencies": {
+    "@microsoft/microsoft-graph-types": "^2.11.0",
     "@types/chai": "^4.2.22",
     "@types/chai-as-promised": "^7.1.4",
+    "@types/jsdom": "^16.2.13",
+    "@types/lodash": "^4.14.178",
     "@types/mime-types": "^2.1.1",
     "@types/mocha": "^9.0.0",
     "@types/node": "^14.14.37",
+    "@types/qrcode": "^1.4.1",
+    "builtin-modules": "^3.2.0",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "cross-env": "^7.0.3",
+    "dotenv": "^10.0.0",
+    "esbuild": "^0.14.0",
+    "jsdom": "^19.0.0",
     "mocha": "^9.1.3",
     "prettier": "^2.4.1",
-    "terser-webpack-plugin": "^5.2.4",
     "ts-loader": "^9.2.6",
     "ts-node": "^10.4.0",
     "tslib": "^2.2.0",
     "typescript": "^4.4.4",
     "webdav-server": "^2.6.2",
-    "webpack": "^5.58.2",
+    "webpack": "^5.64.4",
     "webpack-cli": "^4.9.1"
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.37.0",
     "@aws-sdk/lib-storage": "^3.40.1",
     "@aws-sdk/signature-v4-crt": "^3.37.0",
+    "@azure/msal-node": "^1.4.0",
+    "@microsoft/microsoft-graph-client": "^3.0.1",
     "acorn": "^8.5.0",
+    "assert": "^2.0.0",
     "aws-crt": "^1.10.1",
     "buffer": "^6.0.3",
     "codemirror": "^5.63.1",
+    "crypto-browserify": "^3.12.0",
+    "dropbox": "^10.22.0",
     "localforage": "^1.10.0",
+    "lodash": "^4.17.21",
     "mime-types": "^2.1.33",
     "obsidian": "^0.12.0",
     "path-browserify": "^1.0.1",
     "process": "^0.11.10",
+    "qrcode": "^1.5.0",
     "rfc4648": "^1.5.0",
     "rimraf": "^3.0.2",
     "stream-browserify": "^3.0.0",
+    "util": "^0.12.4",
     "webdav": "^4.7.0",
     "webdav-fs": "^4.0.0",
     "xregexp": "^5.1.0"

src/baseTypes.ts

@@ -0,0 +1,78 @@
+/**
+ * Only type defs here.
+ * To avoid circular dependency.
+ */
+
+export type SUPPORTED_SERVICES_TYPE = "s3" | "webdav" | "dropbox" | "onedrive";
+
+export interface S3Config {
+  s3Endpoint: string;
+  s3Region: string;
+  s3AccessKeyID: string;
+  s3SecretAccessKey: string;
+  s3BucketName: string;
+}
+
+export interface DropboxConfig {
+  accessToken: string;
+  clientID: string;
+  refreshToken: string;
+  accessTokenExpiresInSeconds: number;
+  accessTokenExpiresAtTime: number;
+  accountID: string;
+  username: string;
+  credentialsShouldBeDeletedAtTime?: number;
+}
+
+export type WebdavAuthType = "digest" | "basic";
+
+export interface WebdavConfig {
+  address: string;
+  username: string;
+  password: string;
+  authType: WebdavAuthType;
+}
+
+export interface OnedriveConfig {
+  accessToken: string;
+  clientID: string;
+  authority: string;
+  refreshToken: string;
+  accessTokenExpiresInSeconds: number;
+  accessTokenExpiresAtTime: number;
+  deltaLink: string;
+  username: string;
+  credentialsShouldBeDeletedAtTime?: number;
+}
+
+export interface RemotelySavePluginSettings {
+  s3: S3Config;
+  webdav: WebdavConfig;
+  dropbox: DropboxConfig;
+  onedrive: OnedriveConfig;
+  password: string;
+  serviceType: SUPPORTED_SERVICES_TYPE;
+}
+
+export interface RemoteItem {
+  key: string;
+  lastModified: number;
+  size: number;
+  remoteType: SUPPORTED_SERVICES_TYPE;
+  etag?: string;
+}
+
+export const COMMAND_URI = "remotely-save";
+export const COMMAND_CALLBACK = "remotely-save-cb";
+export const COMMAND_CALLBACK_ONEDRIVE = "remotely-save-cb-onedrive";
+export const COMMAND_CALLBACK_DROPBOX = "remotely-save-cb-dropbox";
+
+export interface UriParams {
+  func?: string;
+  vault?: string;
+  ver?: string;
+  data?: string;
+}
+
+// 80 days
+export const OAUTH2_FORCE_EXPIRE_MILLISECONDS = 1000 * 60 * 60 * 24 * 80;

src/encrypt.ts

@@ -1,15 +1,12 @@
-import { base32, base64 } from "rfc4648";
+import { base32, base64url } from "rfc4648";
-import {
+import { bufferToArrayBuffer, hexStringToTypedArray } from "./misc";
-  bufferToArrayBuffer,
-  arrayBufferToBuffer,
-  hexStringToTypedArray,
-  arrayBufferToHex,
-} from "./misc";
 
 const DEFAULT_ITER = 20000;
 
 // base32.stringify(Buffer.from('Salted__'))
 export const MAGIC_ENCRYPTED_PREFIX_BASE32 = "KNQWY5DFMRPV";
+// base64.stringify(Buffer.from('Salted__'))
+export const MAGIC_ENCRYPTED_PREFIX_BASE64URL = "U2FsdGVkX";
 
 const getKeyIVFromPassword = async (
   salt: Uint8Array,
@@ -120,7 +117,7 @@ export const encryptStringToBase32 = async (
     rounds,
     saltHex
   );
-  return base32.stringify(new Uint8Array(enc));
+  return base32.stringify(new Uint8Array(enc), { pad: false });
 };
 
 export const decryptBase32ToString = async (
@@ -130,7 +127,36 @@ export const decryptBase32ToString = async (
 ) => {
   return new TextDecoder().decode(
     await decryptArrayBuffer(
-      bufferToArrayBuffer(base32.parse(text)),
+      bufferToArrayBuffer(base32.parse(text, { loose: true })),
+      password,
+      rounds
+    )
+  );
+};
+
+export const encryptStringToBase64url = async (
+  text: string,
+  password: string,
+  rounds: number = DEFAULT_ITER,
+  saltHex: string = ""
+) => {
+  const enc = await encryptArrayBuffer(
+    bufferToArrayBuffer(new TextEncoder().encode(text)),
+    password,
+    rounds,
+    saltHex
+  );
+  return base64url.stringify(new Uint8Array(enc), { pad: false });
+};
+
+export const decryptBase64urlToString = async (
+  text: string,
+  password: string,
+  rounds: number = DEFAULT_ITER
+) => {
+  return new TextDecoder().decode(
+    await decryptArrayBuffer(
+      bufferToArrayBuffer(base64url.parse(text, { loose: true })),
       password,
       rounds
     )

src/importExport.ts

@@ -0,0 +1,80 @@
+import QRCode from "qrcode";
+import cloneDeep from "lodash/cloneDeep";
+
+import {
+  COMMAND_URI,
+  UriParams,
+  RemotelySavePluginSettings,
+} from "./baseTypes";
+
+export const exportQrCodeUri = async (
+  settings: RemotelySavePluginSettings,
+  currentVaultName: string,
+  pluginVersion: string
+) => {
+  const settings2 = cloneDeep(settings);
+  delete settings2.dropbox;
+  delete settings2.onedrive;
+  const data = encodeURIComponent(JSON.stringify(settings2));
+  const vault = encodeURIComponent(currentVaultName);
+  const version = encodeURIComponent(pluginVersion);
+  const rawUri = `obsidian://${COMMAND_URI}?func=settings&version=${version}&vault=${vault}&data=${data}`;
+  // console.log(uri)
+  const imgUri = await QRCode.toDataURL(rawUri);
+  return {
+    rawUri,
+    imgUri,
+  };
+};
+
+export interface ProcessQrCodeResultType {
+  status: "error" | "ok";
+  message: string;
+  result?: RemotelySavePluginSettings;
+}
+
+export const importQrCodeUri = (
+  inputParams: any,
+  currentVaultName: string
+): ProcessQrCodeResultType => {
+  let params = inputParams as UriParams;
+  if (
+    params.func === undefined ||
+    params.func !== "settings" ||
+    params.vault === undefined ||
+    params.data === undefined
+  ) {
+    return {
+      status: "error",
+      message: `the uri is not for exporting/importing settings: ${JSON.stringify(
+        inputParams
+      )}`,
+    };
+  }
+
+  if (params.vault !== currentVaultName) {
+    return {
+      status: "error",
+      message: `the target vault is ${
+        params.vault
+      } but you are currently in ${currentVaultName}: ${JSON.stringify(
+        inputParams
+      )}`,
+    };
+  }
+
+  let settings = {} as RemotelySavePluginSettings;
+  try {
+    settings = JSON.parse(params.data);
+  } catch (e) {
+    return {
+      status: "error",
+      message: `errors while parsing settings: ${JSON.stringify(inputParams)}`,
+    };
+  }
+  return {
+    status: "ok",
+    message: "ok",
+    result: settings,
+  };
+};

src/localdb.ts

@@ -1,7 +1,7 @@
 import localforage from "localforage";
 import { TAbstractFile, TFile, TFolder } from "obsidian";
 
-import type { SUPPORTED_SERVICES_TYPE } from "./misc";
+import type { SUPPORTED_SERVICES_TYPE } from "./baseTypes";
 import type { SyncPlanType } from "./sync";
 
 export type LocalForage = typeof localforage;
@@ -197,7 +197,8 @@ export const insertRenameRecord = async (
   await db.deleteHistoryTbl.setItem(k.key, k);
 };
 
-export const upsertSyncMetaMappingDataS3 = async (
+export const upsertSyncMetaMappingData = async (
+  serviceType: SUPPORTED_SERVICES_TYPE,
   db: InternalDBs,
   localKey: string,
   localMTime: number,
@@ -215,13 +216,14 @@ export const upsertSyncMetaMappingDataS3 = async (
     remoteMtime: remoteMTime,
     remoteSize: remoteSize,
     remoteExtraKey: remoteExtraKey,
-    remoteType: "s3",
+    remoteType: serviceType,
     keyType: localKey.endsWith("/") ? "folder" : "file",
   };
   await db.syncMappingTbl.setItem(remoteKey, aggregratedInfo);
 };
 
-export const getSyncMetaMappingByRemoteKeyS3 = async (
+export const getSyncMetaMappingByRemoteKey = async (
+  serviceType: SUPPORTED_SERVICES_TYPE,
   db: InternalDBs,
   remoteKey: string,
   remoteMTime: number,
@@ -240,7 +242,7 @@ export const getSyncMetaMappingByRemoteKeyS3 = async (
     potentialItem.remoteKey === remoteKey &&
     potentialItem.remoteMtime === remoteMTime &&
     potentialItem.remoteExtraKey === remoteExtraKey &&
-    potentialItem.remoteType === "s3"
+    potentialItem.remoteType === serviceType
   ) {
     // the result was found
     return potentialItem;

src/main.ts

@@ -1,59 +1,77 @@
+import { Modal, Notice, Plugin, Setting } from "obsidian";
+import cloneDeep from "lodash/cloneDeep";
+import type { RemotelySavePluginSettings } from "./baseTypes";
 import {
-  App,
+  COMMAND_CALLBACK,
-  Modal,
+  COMMAND_CALLBACK_ONEDRIVE,
-  Notice,
+  COMMAND_CALLBACK_DROPBOX,
-  Plugin,
+  COMMAND_URI,
-  PluginSettingTab,
+} from "./baseTypes";
-  Setting,
+import { importQrCodeUri } from "./importExport";
-  request,
+import type { InternalDBs } from "./localdb";
-  Platform,
-  TFile,
-  TFolder,
-} from "obsidian";
-import * as CodeMirror from "codemirror";
 import {
-  prepareDBs,
-  destroyDBs,
-  loadDeleteRenameHistoryTable,
-  clearAllSyncPlanRecords,
-  clearAllSyncMetaMapping,
   insertDeleteRecord,
   insertRenameRecord,
   insertSyncPlanRecord,
+  loadDeleteRenameHistoryTable,
+  prepareDBs,
 } from "./localdb";
-import type { InternalDBs } from "./localdb";
+import { RemoteClient } from "./remote";
-
-import type { SyncStatusType, PasswordCheckType } from "./sync";
-import { isPasswordOk, getSyncPlan, doActualSync } from "./sync";
 import {
-  DEFAULT_S3_CONFIG,
+  DEFAULT_DROPBOX_CONFIG,
-  getS3Client,
+  getAuthUrlAndVerifier as getAuthUrlAndVerifierDropbox,
-  listFromRemote,
+  sendAuthReq as sendAuthReqDropbox,
-  S3Config,
+  setConfigBySuccessfullAuthInplace as setConfigBySuccessfullAuthInplaceDropbox,
-  checkS3Connectivity,
+} from "./remoteForDropbox";
-} from "./s3";
+import {
-import { exportSyncPlansToFiles } from "./debugMode";
+  AccessCodeResponseSuccessfulType,
-
+  DEFAULT_ONEDRIVE_CONFIG,
-interface RemotelySavePluginSettings {
+  sendAuthReq as sendAuthReqOnedrive,
-  s3?: S3Config;
+  setConfigBySuccessfullAuthInplace as setConfigBySuccessfullAuthInplaceOnedrive,
-  password?: string;
+} from "./remoteForOnedrive";
-}
+import { DEFAULT_S3_CONFIG } from "./remoteForS3";
+import { DEFAULT_WEBDAV_CONFIG } from "./remoteForWebdav";
+import { RemotelySaveSettingTab } from "./settings";
+import type { SyncStatusType } from "./sync";
+import { doActualSync, getSyncPlan, isPasswordOk } from "./sync";
 
 const DEFAULT_SETTINGS: RemotelySavePluginSettings = {
   s3: DEFAULT_S3_CONFIG,
+  webdav: DEFAULT_WEBDAV_CONFIG,
+  dropbox: DEFAULT_DROPBOX_CONFIG,
+  onedrive: DEFAULT_ONEDRIVE_CONFIG,
   password: "",
+  serviceType: "s3",
 };
 
+interface OAuth2Info {
+  verifier?: string;
+  helperModal?: Modal;
+  authDiv?: HTMLElement;
+  revokeDiv?: HTMLElement;
+  revokeAuthSetting?: Setting;
+}
+
 export default class RemotelySavePlugin extends Plugin {
   settings: RemotelySavePluginSettings;
-  cm: CodeMirror.Editor;
+  // cm: CodeMirror.Editor;
   db: InternalDBs;
   syncStatus: SyncStatusType;
+  oauth2Info: OAuth2Info;
 
   async onload() {
-    console.log("loading plugin obsidian-remotely-save");
+    console.log(`loading plugin ${this.manifest.id}`);
+
+    this.oauth2Info = {
+      verifier: "",
+      helperModal: undefined,
+      authDiv: undefined,
+      revokeDiv: undefined,
+      revokeAuthSetting: undefined,
+    }; // init
 
     await this.loadSettings();
+    await this.checkIfOauthExpires();
 
     await this.prepareDB();
 
@@ -71,6 +89,183 @@ export default class RemotelySavePlugin extends Plugin {
       })
     );
 
+    this.registerObsidianProtocolHandler(COMMAND_URI, async (inputParams) => {
+      const parsed = importQrCodeUri(inputParams, this.app.vault.getName());
+      if (parsed.status === "error") {
+        new Notice(parsed.message);
+      } else {
+        const copied = cloneDeep(parsed.result);
+        // new Notice(JSON.stringify(copied))
+        this.settings = Object.assign({}, this.settings, copied);
+        this.saveSettings();
+        new Notice(
+          `New not-oauth2 settings for ${this.manifest.name} saved. Reopen the plugin Settings to the effect.`
+        );
+      }
+    });
+
+    this.registerObsidianProtocolHandler(
+      COMMAND_CALLBACK,
+      async (inputParams) => {
+        new Notice(
+          `Your uri call a callback that's not supported yet: ${JSON.stringify(
+            inputParams
+          )}`
+        );
+      }
+    );
+
+    this.registerObsidianProtocolHandler(
+      COMMAND_CALLBACK_DROPBOX,
+      async (inputParams) => {
+        if (inputParams.code !== undefined) {
+          if (this.oauth2Info.helperModal !== undefined) {
+            this.oauth2Info.helperModal.contentEl.empty();
+            this.oauth2Info.helperModal.contentEl.createEl("p", {
+              text: "Connecting to Dropbox...",
+            });
+            this.oauth2Info.helperModal.contentEl.createEl("p", {
+              text: "Please DO NOT close this modal.",
+            });
+          }
+
+          let authRes = await sendAuthReqDropbox(
+            this.settings.dropbox.clientID,
+            this.oauth2Info.verifier,
+            inputParams.code
+          );
+
+          const self = this;
+          setConfigBySuccessfullAuthInplaceDropbox(
+            this.settings.dropbox,
+            authRes,
+            () => self.saveSettings()
+          );
+
+          const client = new RemoteClient(
+            "dropbox",
+            undefined,
+            undefined,
+            this.settings.dropbox,
+            undefined,
+            this.app.vault.getName(),
+            () => self.saveSettings()
+          );
+
+          const username = await client.getUser();
+          this.settings.dropbox.username = username;
+          await this.saveSettings();
+
+          new Notice(`Good! We've connected to Dropbox as user ${username}!`);
+
+          this.oauth2Info.verifier = ""; // reset it
+          this.oauth2Info.helperModal?.close(); // close it
+          this.oauth2Info.helperModal = undefined;
+
+          this.oauth2Info.authDiv?.toggleClass(
+            "dropbox-auth-button-hide",
+            this.settings.dropbox.username !== ""
+          );
+          this.oauth2Info.authDiv = undefined;
+
+          this.oauth2Info.revokeAuthSetting?.setDesc(
+            `You've connected as user ${this.settings.dropbox.username}. If you want to disconnect, click this button.`
+          );
+          this.oauth2Info.revokeAuthSetting = undefined;
+          this.oauth2Info.revokeDiv?.toggleClass(
+            "dropbox-revoke-auth-button-hide",
+            this.settings.dropbox.username === ""
+          );
+          this.oauth2Info.revokeDiv = undefined;
+        } else {
+          new Notice(
+            "Something went wrong from response from Dropbox. Maybe you rejected the auth?"
+          );
+          throw Error(
+            `do not know how to deal with the callback: ${JSON.stringify(
+              inputParams
+            )}`
+          );
+        }
+      }
+    );
+
+    this.registerObsidianProtocolHandler(
+      COMMAND_CALLBACK_ONEDRIVE,
+      async (inputParams) => {
+        if (inputParams.code !== undefined) {
+          if (this.oauth2Info.helperModal !== undefined) {
+            this.oauth2Info.helperModal.contentEl.empty();
+            this.oauth2Info.helperModal.contentEl.createEl("p", {
+              text: "Connecting to Onedrive...",
+            });
+            this.oauth2Info.helperModal.contentEl.createEl("p", {
+              text: "Please DO NOT close this modal.",
+            });
+          }
+
+          let rsp = await sendAuthReqOnedrive(
+            this.settings.onedrive.clientID,
+            this.settings.onedrive.authority,
+            inputParams.code,
+            this.oauth2Info.verifier
+          );
+
+          if ((rsp as any).error !== undefined) {
+            throw Error(`${JSON.stringify(rsp)}`);
+          }
+
+          const self = this;
+          setConfigBySuccessfullAuthInplaceOnedrive(
+            this.settings.onedrive,
+            rsp as AccessCodeResponseSuccessfulType,
+            () => self.saveSettings()
+          );
+
+          const client = new RemoteClient(
+            "onedrive",
+            undefined,
+            undefined,
+            undefined,
+            this.settings.onedrive,
+            this.app.vault.getName(),
+            () => self.saveSettings()
+          );
+          this.settings.onedrive.username = await client.getUser();
+          await this.saveSettings();
+
+          this.oauth2Info.verifier = ""; // reset it
+          this.oauth2Info.helperModal?.close(); // close it
+          this.oauth2Info.helperModal = undefined;
+
+          this.oauth2Info.authDiv?.toggleClass(
+            "onedrive-auth-button-hide",
+            this.settings.onedrive.username !== ""
+          );
+          this.oauth2Info.authDiv = undefined;
+
+          this.oauth2Info.revokeAuthSetting?.setDesc(
+            `You've connected as user ${this.settings.onedrive.username}. If you want to disconnect, click this button.`
+          );
+          this.oauth2Info.revokeAuthSetting = undefined;
+          this.oauth2Info.revokeDiv?.toggleClass(
+            "onedrive-revoke-auth-button-hide",
+            this.settings.onedrive.username === ""
+          );
+          this.oauth2Info.revokeDiv = undefined;
+        } else {
+          new Notice(
+            "Something went wrong from response from OneDrive. Maybe you rejected the auth?"
+          );
+          throw Error(
+            `do not know how to deal with the callback: ${JSON.stringify(
+              inputParams
+            )}`
+          );
+        }
+      }
+    );
+
     this.addRibbonIcon("switch", "Remotely Save", async () => {
       if (this.syncStatus !== "idle") {
         new Notice(
@@ -81,19 +276,30 @@ export default class RemotelySavePlugin extends Plugin {
 
       try {
         //console.log(`huh ${this.settings.password}`)
-        new Notice("1/6 Remotely Save Sync Preparing");
+        new Notice(
+          `1/7 Remotely Save Sync Preparing (${this.settings.serviceType})`
+        );
         this.syncStatus = "preparing";
 
-        new Notice("2/6 Starting to fetch remote meta data.");
+        new Notice("2/7 Starting to fetch remote meta data.");
         this.syncStatus = "getting_remote_meta";
-        const s3Client = getS3Client(this.settings.s3);
+        const self = this;
-        const remoteRsp = await listFromRemote(s3Client, this.settings.s3);
+        const client = new RemoteClient(
+          this.settings.serviceType,
+          this.settings.s3,
+          this.settings.webdav,
+          this.settings.dropbox,
+          this.settings.onedrive,
+          this.app.vault.getName(),
+          () => self.saveSettings()
+        );
+        const remoteRsp = await client.listFromRemote();
+        // console.log(remoteRsp);
 
-        new Notice("3/6 Starting to fetch local meta data.");
+        new Notice("3/7 Starting to fetch local meta data.");
         this.syncStatus = "getting_local_meta";
         const local = this.app.vault.getAllLoadedFiles();
         const localHistory = await loadDeleteRenameHistoryTable(this.db);
-        // console.log(remoteRsp);
         // console.log(local);
         // console.log(localHistory);
 
@@ -115,6 +321,7 @@ export default class RemotelySavePlugin extends Plugin {
           local,
           localHistory,
           this.db,
+          client.serviceType,
           this.settings.password
         );
         console.log(syncPlan.mixedStates); // for debugging
@@ -127,8 +334,7 @@ export default class RemotelySavePlugin extends Plugin {
 
         this.syncStatus = "syncing";
         await doActualSync(
-          s3Client,
+          client,
-          this.settings.s3,
           this.db,
           this.app.vault,
           syncPlan,
@@ -150,11 +356,6 @@ export default class RemotelySavePlugin extends Plugin {
 
     this.addSettingTab(new RemotelySaveSettingTab(this.app, this));
 
-    this.registerCodeMirror((cm: CodeMirror.Editor) => {
-      this.cm = cm;
-      console.log("codemirror registered.");
-    });
-
     // this.registerDomEvent(document, "click", (evt: MouseEvent) => {
     //   console.log("click", evt);
     // });
@@ -165,18 +366,101 @@ export default class RemotelySavePlugin extends Plugin {
   }
 
   onunload() {
-    console.log("unloading plugin obsidian-remotely-save");
+    console.log(`unloading plugin ${this.manifest.id}`);
     this.destroyDBs();
   }
 
   async loadSettings() {
-    this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());
+    this.settings = Object.assign(
+      {},
+      cloneDeep(DEFAULT_SETTINGS),
+      await this.loadData()
+    );
+    if (this.settings.dropbox.clientID === "") {
+      this.settings.dropbox.clientID = DEFAULT_SETTINGS.dropbox.clientID;
+    }
+    if (this.settings.onedrive.clientID === "") {
+      this.settings.onedrive.clientID = DEFAULT_SETTINGS.onedrive.clientID;
+    }
+    if (this.settings.onedrive.authority === "") {
+      this.settings.onedrive.authority = DEFAULT_SETTINGS.onedrive.authority;
+    }
   }
 
   async saveSettings() {
     await this.saveData(this.settings);
   }
 
+  async checkIfOauthExpires() {
+    let needSave: boolean = false;
+    const current = Date.now();
+
+    // fullfill old version settings
+    if (
+      this.settings.dropbox.refreshToken !== "" &&
+      this.settings.dropbox.credentialsShouldBeDeletedAtTime === undefined
+    ) {
+      // It has a refreshToken, but not expire time.
+      // Likely to be a setting from old version.
+      // we set it to a month.
+      this.settings.dropbox.credentialsShouldBeDeletedAtTime =
+        current + 1000 * 60 * 60 * 24 * 30;
+      needSave = true;
+    }
+    if (
+      this.settings.onedrive.refreshToken !== "" &&
+      this.settings.onedrive.credentialsShouldBeDeletedAtTime === undefined
+    ) {
+      this.settings.onedrive.credentialsShouldBeDeletedAtTime =
+        current + 1000 * 60 * 60 * 24 * 30;
+      needSave = true;
+    }
+
+    // check expired or not
+    let dropboxExpired = false;
+    if (
+      this.settings.dropbox.refreshToken !== "" &&
+      current >= this.settings.dropbox.credentialsShouldBeDeletedAtTime
+    ) {
+      dropboxExpired = true;
+      this.settings.dropbox = cloneDeep(DEFAULT_DROPBOX_CONFIG);
+      needSave = true;
+    }
+
+    let onedriveExpired = false;
+    if (
+      this.settings.onedrive.refreshToken !== "" &&
+      current >= this.settings.onedrive.credentialsShouldBeDeletedAtTime
+    ) {
+      onedriveExpired = true;
+      this.settings.onedrive = cloneDeep(DEFAULT_ONEDRIVE_CONFIG);
+      needSave = true;
+    }
+
+    // save back
+    if (needSave) {
+      await this.saveSettings();
+    }
+
+    // send notice
+    if (dropboxExpired && onedriveExpired) {
+      new Notice(
+        `${this.manifest.name}: You haven't manually auth Dropbox and OneDrive for a while, you need to re-auth them again.`,
+        6000
+      );
+    } else if (dropboxExpired) {
+      new Notice(
+        `${this.manifest.name}: You haven't manually auth Dropbox for a while, you need to re-auth it again.`,
+        6000
+      );
+    } else if (onedriveExpired) {
+      new Notice(
+        `${this.manifest.name}: You haven't manually auth OneDrive for a while, you need to re-auth it again.`,
+        6000
+      );
+    }
+  }
+
   async prepareDB() {
     this.db = await prepareDBs();
   }
@@ -185,287 +469,3 @@ export default class RemotelySavePlugin extends Plugin {
     /* destroyDBs(this.db); */
   }
 }
-
-export class PasswordModal extends Modal {
-  plugin: RemotelySavePlugin;
-  newPassword: string;
-  constructor(app: App, plugin: RemotelySavePlugin, newPassword: string) {
-    super(app);
-    this.plugin = plugin;
-    this.newPassword = newPassword;
-  }
-
-  onOpen() {
-    let { contentEl } = this;
-    // contentEl.setText("Add Or change password.");
-    contentEl.createEl("h2", { text: "Hold on and PLEASE READ ON..." });
-    contentEl.createEl("p", {
-      text: "If the field is not empty, files are enctrypted using the password locally before sent to remote.",
-    });
-    contentEl.createEl("p", {
-      text: "If the field is empty, then no password is used, and files would be sent without encryption.",
-    });
-
-    contentEl.createEl("p", {
-      text: "Attention 1/4: The password itself is stored in PLAIN TEXT LOCALLY and would not be sent to remote by this plugin.",
-    });
-    contentEl.createEl("p", {
-      text: "Attention 2/4: Non-empty file contents are encrypted using openssl format. File/directory path are also encrypted then applied base32. BUT, some metadata such as file sizes and directory structures are not encrypted or can be easily guessed, and directory path are stored as 0-byte-size object remotely.",
-    });
-    contentEl.createEl("p", {
-      text: "Attention 3/4: Before changing password, you should make sure the remote store (s3/webdav/...) IS EMPTY, or REMOTE FILES WERE ENCRYPTED BY THAT NEW PASSWORD. OTHERWISE SOMETHING BAD WOULD HAPPEN!",
-    });
-    contentEl.createEl("p", {
-      text: "Attention 4/4: The longer the password, the better.",
-    });
-
-    new Setting(contentEl)
-      .addButton((button) => {
-        button.setButtonText("The Second Confirm to change password.");
-        button.onClick(async () => {
-          this.plugin.settings.password = this.newPassword;
-          await this.plugin.saveSettings();
-          new Notice("New password saved!");
-          this.close();
-        });
-        button.setClass("password_second_confirm");
-      })
-      .addButton((button) => {
-        button.setButtonText("Go Back");
-        button.onClick(() => {
-          this.close();
-        });
-      });
-  }
-
-  onClose() {
-    let { contentEl } = this;
-    contentEl.empty();
-  }
-}
-
-class RemotelySaveSettingTab extends PluginSettingTab {
-  plugin: RemotelySavePlugin;
-
-  constructor(app: App, plugin: RemotelySavePlugin) {
-    super(app, plugin);
-    this.plugin = plugin;
-  }
-
-  display(): void {
-    let { containerEl } = this;
-
-    containerEl.empty();
-
-    containerEl.createEl("h1", { text: "Remotely Save" });
-
-    const s3Div = containerEl.createEl("div");
-    s3Div.createEl("h2", { text: "S3 (-compatible) Service" });
-
-    s3Div.createEl("p", {
-      text: "You can use Amazon S3 or another S3-compatible service to sync your vault. Enter your bucket information below.",
-    });
-
-    s3Div.createEl("p", {
-      text: "Disclaimer: The infomation is stored in PLAIN TEXT locally. Other malicious/harmful/faulty plugins may or may not be able to read the info. If you see any unintentional access to your S3 bucket, please immediately delete the access key to stop further accessment.",
-      cls: "s3-disclaimer",
-    });
-
-    s3Div.createEl("p", {
-      text: "You need to configure CORS to allow requests from origin app://obsidian.md",
-    });
-
-    s3Div.createEl("p", {
-      text: "Some Amazon S3 official docs:",
-    });
-
-    const s3LinksUl = s3Div.createEl("div").createEl("ul");
-
-    s3LinksUl.createEl("li").createEl("a", {
-      href: "https://docs.aws.amazon.com/general/latest/gr/s3.html",
-      text: "Endpoint and region info",
-    });
-
-    s3LinksUl.createEl("li").createEl("a", {
-      href: "https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/getting-your-credentials.html",
-      text: "Access key ID and Secret access key info",
-    });
-
-    s3LinksUl.createEl("li").createEl("a", {
-      href: "https://docs.aws.amazon.com/AmazonS3/latest/userguide/enabling-cors-examples.html",
-      text: "Configuring CORS",
-    });
-
-    new Setting(s3Div)
-      .setName("s3Endpoint")
-      .setDesc("s3Endpoint")
-      .addText((text) =>
-        text
-          .setPlaceholder("")
-          .setValue(this.plugin.settings.s3.s3Endpoint)
-          .onChange(async (value) => {
-            this.plugin.settings.s3.s3Endpoint = value.trim();
-            await this.plugin.saveSettings();
-          })
-      );
-
-    new Setting(s3Div)
-      .setName("s3Region")
-      .setDesc("s3Region")
-      .addText((text) =>
-        text
-          .setPlaceholder("")
-          .setValue(`${this.plugin.settings.s3.s3Region}`)
-          .onChange(async (value) => {
-            this.plugin.settings.s3.s3Region = value.trim();
-            await this.plugin.saveSettings();
-          })
-      );
-
-    new Setting(s3Div)
-      .setName("s3AccessKeyID")
-      .setDesc("s3AccessKeyID")
-      .addText((text) =>
-        text
-          .setPlaceholder("")
-          .setValue(`${this.plugin.settings.s3.s3AccessKeyID}`)
-          .onChange(async (value) => {
-            this.plugin.settings.s3.s3AccessKeyID = value.trim();
-            await this.plugin.saveSettings();
-          })
-      );
-
-    new Setting(s3Div)
-      .setName("s3SecretAccessKey")
-      .setDesc("s3SecretAccessKey")
-      .addText((text) =>
-        text
-          .setPlaceholder("")
-          .setValue(`${this.plugin.settings.s3.s3SecretAccessKey}`)
-          .onChange(async (value) => {
-            this.plugin.settings.s3.s3SecretAccessKey = value.trim();
-            await this.plugin.saveSettings();
-          })
-      );
-
-    new Setting(s3Div)
-      .setName("s3BucketName")
-      .setDesc("s3BucketName")
-      .addText((text) =>
-        text
-          .setPlaceholder("")
-          .setValue(`${this.plugin.settings.s3.s3BucketName}`)
-          .onChange(async (value) => {
-            this.plugin.settings.s3.s3BucketName = value.trim();
-            await this.plugin.saveSettings();
-          })
-      );
-
-    new Setting(s3Div)
-      .setName("check connectivity")
-      .setDesc("check connectivity")
-      .addButton(async (button) => {
-        button.setButtonText("Check");
-        button.onClick(async () => {
-          new Notice("Checking...");
-          const s3Client = getS3Client(this.plugin.settings.s3);
-          const res = await checkS3Connectivity(
-            s3Client,
-            this.plugin.settings.s3
-          );
-          if (res) {
-            new Notice("Great! The bucket can be accessed.");
-          } else {
-            new Notice("The S3 bucket cannot be reached.");
-          }
-        });
-      });
-
-    const generalDiv = containerEl.createEl("div");
-    generalDiv.createEl("h2", { text: "General" });
-
-    const passwordDiv = generalDiv.createEl("div");
-    let newPassword = `${this.plugin.settings.password}`;
-    new Setting(passwordDiv)
-      .setName("encryption password")
-      .setDesc(
-        'Password for E2E encryption. Empty for no password. You need to click "Confirm".'
-      )
-      .addText((text) =>
-        text
-          .setPlaceholder("")
-          .setValue(`${this.plugin.settings.password}`)
-          .onChange(async (value) => {
-            newPassword = value.trim();
-          })
-      )
-      .addButton(async (button) => {
-        button.setButtonText("Confirm");
-        button.onClick(async () => {
-          new PasswordModal(this.app, this.plugin, newPassword).open();
-        });
-      });
-
-    const debugDiv = containerEl.createEl("div");
-    debugDiv.createEl("h2", { text: "Debug" });
-    const syncPlanDiv = debugDiv.createEl("div");
-    syncPlanDiv.createEl("p", {
-      text: "Sync plans are created every time after you trigger sync and before the actual sync. Useful to know what would actually happen in those sync.",
-    });
-
-    new Setting(syncPlanDiv)
-      .setName("export sync plans")
-      .setDesc("export sync plans")
-      .addButton(async (button) => {
-        button.setButtonText("Export");
-        button.onClick(async () => {
-          await exportSyncPlansToFiles(this.plugin.db, this.app.vault);
-          new Notice("sync plans history exported");
-        });
-      });
-
-    new Setting(syncPlanDiv)
-      .setName("delete sync plans history in db")
-      .setDesc("delete sync plans history in db")
-      .addButton(async (button) => {
-        button.setButtonText("Delete History");
-        button.onClick(async () => {
-          await clearAllSyncPlanRecords(this.plugin.db);
-          new Notice("sync plans history (in db) deleted");
-        });
-      });
-
-    const syncMappingDiv = debugDiv.createEl("div");
-    syncMappingDiv.createEl("p", {
-      text: "Sync mappings history stores the actual LOCAL last modified time of the REMOTE objects. Clearing it may cause unnecessary data exchanges in next-time sync.",
-    });
-
-    new Setting(syncMappingDiv)
-      .setName("delete sync mappings history in db")
-      .setDesc("delete sync mappings history in db")
-      .addButton(async (button) => {
-        button.setButtonText("Delete Sync Mappings");
-        button.onClick(async () => {
-          await clearAllSyncMetaMapping(this.plugin.db);
-          new Notice("sync mappings history (in local db) deleted");
-        });
-      });
-
-    const dbsResetDiv = debugDiv.createEl("div");
-    syncMappingDiv.createEl("p", {
-      text: "Reset local internal caches/databases (for debugging purposes). You would want to reload the plugin after resetting this. This option will not empty the {s3, password...} settings.",
-    });
-    new Setting(syncMappingDiv)
-      .setName("reset local internal cache/databases")
-      .setDesc("reset local internal cache/databases")
-      .addButton(async (button) => {
-        button.setButtonText("Reset");
-        button.onClick(async () => {
-          await destroyDBs();
-          new Notice(
-            "Local internal cache/databases deleted. Please manually reload the plugin."
-          );
-        });
-      });
-  }
-}

src/misc.ts

@@ -1,11 +1,9 @@
 import { Vault } from "obsidian";
 import * as path from "path";
 
-import { base32 } from "rfc4648";
+import { base32, base64url } from "rfc4648";
 import XRegExp from "xregexp";
 
-export type SUPPORTED_SERVICES_TYPE = "s3" | "webdav" | "ftp";
-
 /**
  * If any part of the file starts with '.' or '_' then it's a hidden file.
  * @param item
@@ -47,7 +45,10 @@ export const getFolderLevels = (x: string) => {
   const y1 = x.split("/");
   let i = 0;
   for (let index = 0; index + 1 < y1.length; index++) {
-    res.push(y1.slice(0, index + 1).join("/"));
+    const k = y1.slice(0, index + 1).join("/");
+    if (k !== "" && k !== "/") {
+      res.push(k);
+    }
   }
   return res;
 };
@@ -113,6 +114,14 @@ export const base64ToBase32 = (a: string) => {
   return base32.stringify(Buffer.from(a, "base64"));
 };
 
+export const base64ToBase64url = (a: string, pad: boolean = false) => {
+  let b = a.replace(/\+/g, "-").replace(/\//g, "_");
+  if (!pad) {
+    b = b.replace(/=/g, "");
+  }
+  return b;
+};
+
 /**
  * iOS Safari could decrypt string with invalid password!
  * So we need an extra way to test the decrypted result.
@@ -130,3 +139,60 @@ export const isVaildText = (a: string) => {
     a
   );
 };
+
+/**
+ * If input is already a folder, returns it as is;
+ * And if input is a file, returns its direname.
+ * @param a
+ * @returns
+ */
+export const getPathFolder = (a: string) => {
+  if (a.endsWith("/")) {
+    return a;
+  }
+  const b = path.posix.dirname(a);
+  return b.endsWith("/") ? b : `${b}/`;
+};
+
+/**
+ * https://stackoverflow.com/questions/54511144
+ * @param a
+ * @param delimiter
+ * @returns
+ */
+export const setToString = (a: Set<string>, delimiter: string = ",") => {
+  return [...a].join(delimiter);
+};
+
+export const extractSvgSub = (x: string, subEl: string = "rect") => {
+  const parser = new window.DOMParser();
+  const dom = parser.parseFromString(x, "image/svg+xml");
+  const svg = dom.querySelector("svg");
+  svg.setAttribute("viewbox", "0 0 10 10");
+  return svg.innerHTML;
+};
+
+/**
+ * https://stackoverflow.com/questions/18230217
+ * @param min
+ * @param max
+ * @returns
+ */
+export const getRandomIntInclusive = (min: number, max: number) => {
+  const randomBuffer = new Uint32Array(1);
+  window.crypto.getRandomValues(randomBuffer);
+  let randomNumber = randomBuffer[0] / (0xffffffff + 1);
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(randomNumber * (max - min + 1)) + min;
+};
+
+/**
+ * Random buffer
+ * @param byteLength
+ * @returns
+ */
+export const getRandomArrayBuffer = (byteLength: number) => {
+  const k = window.crypto.getRandomValues(new Uint8Array(byteLength));
+  return bufferToArrayBuffer(k);
+};

src/remote.ts

@@ -0,0 +1,281 @@
+import { Vault } from "obsidian";
+import type {
+  DropboxConfig,
+  OnedriveConfig,
+  S3Config,
+  SUPPORTED_SERVICES_TYPE,
+  WebdavConfig,
+} from "./baseTypes";
+import * as dropbox from "./remoteForDropbox";
+import * as onedrive from "./remoteForOnedrive";
+import * as s3 from "./remoteForS3";
+import * as webdav from "./remoteForWebdav";
+
+export class RemoteClient {
+  readonly serviceType: SUPPORTED_SERVICES_TYPE;
+  readonly s3Client?: s3.S3Client;
+  readonly s3Config?: S3Config;
+  readonly webdavClient?: webdav.WrappedWebdavClient;
+  readonly webdavConfig?: WebdavConfig;
+  readonly dropboxClient?: dropbox.WrappedDropboxClient;
+  readonly dropboxConfig?: DropboxConfig;
+  readonly onedriveClient?: onedrive.WrappedOnedriveClient;
+  readonly onedriveConfig?: OnedriveConfig;
+
+  constructor(
+    serviceType: SUPPORTED_SERVICES_TYPE,
+    s3Config?: S3Config,
+    webdavConfig?: WebdavConfig,
+    dropboxConfig?: DropboxConfig,
+    onedriveConfig?: OnedriveConfig,
+    vaultName?: string,
+    saveUpdatedConfigFunc?: () => Promise<any>
+  ) {
+    this.serviceType = serviceType;
+    // the client may modify the config inplace,
+    // so we use a ref not copy of config here
+    if (serviceType === "s3") {
+      this.s3Config = s3Config;
+      this.s3Client = s3.getS3Client(this.s3Config);
+    } else if (serviceType === "webdav") {
+      if (vaultName === undefined) {
+        throw Error("remember to provide vault name while init webdav client");
+      }
+      this.webdavConfig = webdavConfig;
+      this.webdavClient = webdav.getWebdavClient(this.webdavConfig, vaultName);
+    } else if (serviceType === "dropbox") {
+      if (vaultName === undefined || saveUpdatedConfigFunc === undefined) {
+        throw Error(
+          "remember to provide vault name and callback while init dropbox client"
+        );
+      }
+      this.dropboxConfig = dropboxConfig;
+      this.dropboxClient = dropbox.getDropboxClient(
+        this.dropboxConfig,
+        vaultName,
+        saveUpdatedConfigFunc
+      );
+    } else if (serviceType === "onedrive") {
+      if (vaultName === undefined || saveUpdatedConfigFunc === undefined) {
+        throw Error(
+          "remember to provide vault name and callback while init onedrive client"
+        );
+      }
+      this.onedriveConfig = onedriveConfig;
+      this.onedriveClient = onedrive.getOnedriveClient(
+        this.onedriveConfig,
+        vaultName,
+        saveUpdatedConfigFunc
+      );
+    } else {
+      throw Error(`not supported service type ${this.serviceType}`);
+    }
+  }
+
+  getRemoteMeta = async (fileOrFolderPath: string) => {
+    if (this.serviceType === "s3") {
+      return await s3.getRemoteMeta(
+        this.s3Client,
+        this.s3Config,
+        fileOrFolderPath
+      );
+    } else if (this.serviceType === "webdav") {
+      return await webdav.getRemoteMeta(this.webdavClient, fileOrFolderPath);
+    } else if (this.serviceType === "dropbox") {
+      return await dropbox.getRemoteMeta(this.dropboxClient, fileOrFolderPath);
+    } else if (this.serviceType === "onedrive") {
+      return await onedrive.getRemoteMeta(
+        this.onedriveClient,
+        fileOrFolderPath
+      );
+    } else {
+      throw Error(`not supported service type ${this.serviceType}`);
+    }
+  };
+
+  uploadToRemote = async (
+    fileOrFolderPath: string,
+    vault: Vault,
+    isRecursively: boolean = false,
+    password: string = "",
+    remoteEncryptedKey: string = "",
+    foldersCreatedBefore: Set<string> | undefined = undefined
+  ) => {
+    if (this.serviceType === "s3") {
+      return await s3.uploadToRemote(
+        this.s3Client,
+        this.s3Config,
+        fileOrFolderPath,
+        vault,
+        isRecursively,
+        password,
+        remoteEncryptedKey
+      );
+    } else if (this.serviceType === "webdav") {
+      return await webdav.uploadToRemote(
+        this.webdavClient,
+        fileOrFolderPath,
+        vault,
+        isRecursively,
+        password,
+        remoteEncryptedKey
+      );
+    } else if (this.serviceType === "dropbox") {
+      return await dropbox.uploadToRemote(
+        this.dropboxClient,
+        fileOrFolderPath,
+        vault,
+        isRecursively,
+        password,
+        remoteEncryptedKey,
+        foldersCreatedBefore
+      );
+    } else if (this.serviceType === "onedrive") {
+      return await onedrive.uploadToRemote(
+        this.onedriveClient,
+        fileOrFolderPath,
+        vault,
+        isRecursively,
+        password,
+        remoteEncryptedKey,
+        foldersCreatedBefore
+      );
+    } else {
+      throw Error(`not supported service type ${this.serviceType}`);
+    }
+  };
+
+  listFromRemote = async (prefix?: string) => {
+    if (this.serviceType === "s3") {
+      return await s3.listFromRemote(this.s3Client, this.s3Config, prefix);
+    } else if (this.serviceType === "webdav") {
+      return await webdav.listFromRemote(this.webdavClient, prefix);
+    } else if (this.serviceType === "dropbox") {
+      return await dropbox.listFromRemote(this.dropboxClient, prefix);
+    } else if (this.serviceType === "onedrive") {
+      return await onedrive.listFromRemote(this.onedriveClient, prefix);
+    } else {
+      throw Error(`not supported service type ${this.serviceType}`);
+    }
+  };
+
+  downloadFromRemote = async (
+    fileOrFolderPath: string,
+    vault: Vault,
+    mtime: number,
+    password: string = "",
+    remoteEncryptedKey: string = ""
+  ) => {
+    if (this.serviceType === "s3") {
+      return await s3.downloadFromRemote(
+        this.s3Client,
+        this.s3Config,
+        fileOrFolderPath,
+        vault,
+        mtime,
+        password,
+        remoteEncryptedKey
+      );
+    } else if (this.serviceType === "webdav") {
+      return await webdav.downloadFromRemote(
+        this.webdavClient,
+        fileOrFolderPath,
+        vault,
+        mtime,
+        password,
+        remoteEncryptedKey
+      );
+    } else if (this.serviceType === "dropbox") {
+      return await dropbox.downloadFromRemote(
+        this.dropboxClient,
+        fileOrFolderPath,
+        vault,
+        mtime,
+        password,
+        remoteEncryptedKey
+      );
+    } else if (this.serviceType === "onedrive") {
+      return await onedrive.downloadFromRemote(
+        this.onedriveClient,
+        fileOrFolderPath,
+        vault,
+        mtime,
+        password,
+        remoteEncryptedKey
+      );
+    } else {
+      throw Error(`not supported service type ${this.serviceType}`);
+    }
+  };
+
+  deleteFromRemote = async (
+    fileOrFolderPath: string,
+    password: string = "",
+    remoteEncryptedKey: string = ""
+  ) => {
+    if (this.serviceType === "s3") {
+      return await s3.deleteFromRemote(
+        this.s3Client,
+        this.s3Config,
+        fileOrFolderPath,
+        password,
+        remoteEncryptedKey
+      );
+    } else if (this.serviceType === "webdav") {
+      return await webdav.deleteFromRemote(
+        this.webdavClient,
+        fileOrFolderPath,
+        password,
+        remoteEncryptedKey
+      );
+    } else if (this.serviceType === "dropbox") {
+      return await dropbox.deleteFromRemote(
+        this.dropboxClient,
+        fileOrFolderPath,
+        password,
+        remoteEncryptedKey
+      );
+    } else if (this.serviceType === "onedrive") {
+      return await onedrive.deleteFromRemote(
+        this.onedriveClient,
+        fileOrFolderPath,
+        password,
+        remoteEncryptedKey
+      );
+    } else {
+      throw Error(`not supported service type ${this.serviceType}`);
+    }
+  };
+
+  checkConnectivity = async () => {
+    if (this.serviceType === "s3") {
+      return await s3.checkConnectivity(this.s3Client, this.s3Config);
+    } else if (this.serviceType === "webdav") {
+      return await webdav.checkConnectivity(this.webdavClient);
+    } else if (this.serviceType === "dropbox") {
+      return await dropbox.checkConnectivity(this.dropboxClient);
+    } else if (this.serviceType === "onedrive") {
+      return await onedrive.checkConnectivity(this.onedriveClient);
+    } else {
+      throw Error(`not supported service type ${this.serviceType}`);
+    }
+  };
+
+  getUser = async () => {
+    if (this.serviceType === "dropbox") {
+      return await dropbox.getUserDisplayName(this.dropboxClient);
+    } else if (this.serviceType === "onedrive") {
+      return await onedrive.getUserDisplayName(this.onedriveClient);
+    } else {
+      throw Error(`not supported service type ${this.serviceType}`);
+    }
+  };
+
+  revokeAuth = async () => {
+    if (this.serviceType === "dropbox") {
+      return await dropbox.revokeAuth(this.dropboxClient);
+    } else {
+      throw Error(`not supported service type ${this.serviceType}`);
+    }
+  };
+}

src/remoteForDropbox.ts

@@ -0,0 +1,631 @@
+import { Dropbox, DropboxAuth, files } from "dropbox";
+import { Vault } from "obsidian";
+import * as path from "path";
+import {
+  DropboxConfig,
+  RemoteItem,
+  COMMAND_CALLBACK_DROPBOX,
+  OAUTH2_FORCE_EXPIRE_MILLISECONDS,
+} from "./baseTypes";
+import { decryptArrayBuffer, encryptArrayBuffer } from "./encrypt";
+import { bufferToArrayBuffer, getFolderLevels, mkdirpInVault } from "./misc";
+
+export { Dropbox } from "dropbox";
+
+export const DEFAULT_DROPBOX_CONFIG: DropboxConfig = {
+  accessToken: "",
+  clientID: process.env.DEFAULT_DROPBOX_APP_KEY,
+  refreshToken: "",
+  accessTokenExpiresInSeconds: 0,
+  accessTokenExpiresAtTime: 0,
+  accountID: "",
+  username: "",
+  credentialsShouldBeDeletedAtTime: 0,
+};
+
+export const getDropboxPath = (fileOrFolderPath: string, vaultName: string) => {
+  let key = fileOrFolderPath;
+  if (fileOrFolderPath === "/" || fileOrFolderPath === "") {
+    // special
+    key = `/${vaultName}`;
+  }
+  if (!fileOrFolderPath.startsWith("/")) {
+    // then this is original path in Obsidian
+    key = `/${vaultName}/${fileOrFolderPath}`;
+  }
+  if (key.endsWith("/")) {
+    key = key.slice(0, key.length - 1);
+  }
+  return key;
+};
+
+const getNormPath = (fileOrFolderPath: string, vaultName: string) => {
+  if (
+    !(
+      fileOrFolderPath === `/${vaultName}` ||
+      fileOrFolderPath.startsWith(`/${vaultName}/`)
+    )
+  ) {
+    throw Error(`"${fileOrFolderPath}" doesn't starts with "/${vaultName}/"`);
+  }
+  return fileOrFolderPath.slice(`/${vaultName}/`.length);
+};
+
+const fromDropboxItemToRemoteItem = (
+  x:
+    | files.FileMetadataReference
+    | files.FolderMetadataReference
+    | files.DeletedMetadataReference,
+  vaultName: string
+): RemoteItem => {
+  let key = getNormPath(x.path_display, vaultName);
+  if (x[".tag"] === "folder" && !key.endsWith("/")) {
+    key = `${key}/`;
+  }
+
+  if (x[".tag"] === "folder") {
+    return {
+      key: key,
+      lastModified: undefined,
+      size: 0,
+      remoteType: "dropbox",
+      etag: `${x.id}\t`,
+    } as RemoteItem;
+  } else if (x[".tag"] === "file") {
+    return {
+      key: key,
+      lastModified: Date.parse(x.server_modified).valueOf(),
+      size: x.size,
+      remoteType: "dropbox",
+      etag: `${x.id}\t${x.content_hash}`,
+    } as RemoteItem;
+  } else if (x[".tag"] === "deleted") {
+    throw Error("do not support deleted tag");
+  }
+};
+
+/**
+ * Dropbox api doesn't return mtime for folders.
+ * This is a try to assign mtime by using files in folder.
+ * @param allFilesFolders
+ * @returns
+ */
+const fixLastModifiedTimeInplace = (allFilesFolders: RemoteItem[]) => {
+  if (allFilesFolders.length === 0) {
+    return;
+  }
+
+  // sort by longer to shorter
+  allFilesFolders.sort((a, b) => b.key.length - a.key.length);
+
+  // a "map" from dir to mtime
+  let potentialMTime = {} as Record<string, number>;
+
+  // first sort pass, from buttom to up
+  for (const item of allFilesFolders) {
+    if (item.key.endsWith("/")) {
+      // itself is a folder, and initially doesn't have mtime
+      if (item.lastModified === undefined && item.key in potentialMTime) {
+        // previously we gathered all sub info of this folder
+        item.lastModified = potentialMTime[item.key];
+      }
+    }
+    const parent = `${path.posix.dirname(item.key)}/`;
+    if (item.lastModified !== undefined) {
+      if (parent in potentialMTime) {
+        potentialMTime[parent] = Math.max(
+          potentialMTime[parent],
+          item.lastModified
+        );
+      } else {
+        potentialMTime[parent] = item.lastModified;
+      }
+    }
+  }
+
+  // second pass, from up to buttom.
+  // fill mtime by parent folder or Date.Now() if still not available.
+  // this is only possible if no any sub-folder-files recursively.
+  // we do not sort the array again, just iterate over it by reverse
+  // using good old for loop.
+  for (let i = allFilesFolders.length - 1; i >= 0; --i) {
+    const item = allFilesFolders[i];
+    if (!item.key.endsWith("/")) {
+      continue; // skip files
+    }
+    if (item.lastModified !== undefined) {
+      continue; // don't need to deal with it
+    }
+    const parent = `${path.posix.dirname(item.key)}/`;
+    if (parent in potentialMTime) {
+      item.lastModified = potentialMTime[parent];
+    } else {
+      item.lastModified = Date.now().valueOf();
+      potentialMTime[item.key] = item.lastModified;
+    }
+  }
+
+  return allFilesFolders;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Dropbox authorization using PKCE
+// see https://dropbox.tech/developers/pkce--what-and-why-
+////////////////////////////////////////////////////////////////////////////////
+
+export const getAuthUrlAndVerifier = async (appKey: string) => {
+  const auth = new DropboxAuth({
+    clientId: appKey,
+  });
+  const authUrl = (
+    await auth.getAuthenticationUrl(
+      `obsidian://${COMMAND_CALLBACK_DROPBOX}`,
+      undefined,
+      "code",
+      "offline",
+      undefined,
+      "none",
+      true
+    )
+  ).toString();
+  const verifier = auth.getCodeVerifier();
+  return {
+    authUrl: authUrl,
+    verifier: verifier,
+  };
+};
+
+export interface DropboxSuccessAuthRes {
+  access_token: string;
+  token_type: "bearer";
+  expires_in: string;
+  refresh_token?: string;
+  scope?: string;
+  uid?: string;
+  account_id?: string;
+}
+
+export const sendAuthReq = async (
+  appKey: string,
+  verifier: string,
+  authCode: string
+) => {
+  const resp1 = await fetch("https://api.dropboxapi.com/oauth2/token", {
+    method: "POST",
+    body: new URLSearchParams({
+      code: authCode,
+      grant_type: "authorization_code",
+      code_verifier: verifier,
+      client_id: appKey,
+      redirect_uri: `obsidian://${COMMAND_CALLBACK_DROPBOX}`,
+    }),
+  });
+  const resp2 = (await resp1.json()) as DropboxSuccessAuthRes;
+  return resp2;
+};
+
+export const sendRefreshTokenReq = async (
+  appKey: string,
+  refreshToken: string
+) => {
+  console.log("start auto getting refreshed Dropbox access token.");
+  const resp1 = await fetch("https://api.dropboxapi.com/oauth2/token", {
+    method: "POST",
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+      client_id: appKey,
+    }),
+  });
+  const resp2 = (await resp1.json()) as DropboxSuccessAuthRes;
+  console.log("finish auto getting refreshed Dropbox access token.");
+  return resp2;
+};
+
+export const setConfigBySuccessfullAuthInplace = async (
+  config: DropboxConfig,
+  authRes: DropboxSuccessAuthRes,
+  saveUpdatedConfigFunc: () => Promise<any> | undefined
+) => {
+  console.log("start updating local info of Dropbox token");
+
+  config.accessToken = authRes.access_token;
+  config.accessTokenExpiresInSeconds = parseInt(authRes.expires_in);
+  config.accessTokenExpiresAtTime =
+    Date.now() + parseInt(authRes.expires_in) * 1000 - 10 * 1000;
+
+  // manually set it expired after 80 days;
+  config.credentialsShouldBeDeletedAtTime =
+    Date.now() + OAUTH2_FORCE_EXPIRE_MILLISECONDS;
+
+  if (authRes.refresh_token !== undefined) {
+    config.refreshToken = authRes.refresh_token;
+  }
+  if (authRes.refresh_token !== undefined) {
+    config.accountID = authRes.account_id;
+  }
+
+  if (saveUpdatedConfigFunc !== undefined) {
+    await saveUpdatedConfigFunc();
+  }
+
+  console.log("finish updating local info of Dropbox token");
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Other usual common methods
+////////////////////////////////////////////////////////////////////////////////
+
+export class WrappedDropboxClient {
+  dropboxConfig: DropboxConfig;
+  vaultName: string;
+  saveUpdatedConfigFunc: () => Promise<any>;
+  dropbox: Dropbox;
+  vaultFolderExists: boolean;
+  constructor(
+    dropboxConfig: DropboxConfig,
+    vaultName: string,
+    saveUpdatedConfigFunc: () => Promise<any>
+  ) {
+    this.dropboxConfig = dropboxConfig;
+    this.vaultName = vaultName;
+    this.saveUpdatedConfigFunc = saveUpdatedConfigFunc;
+    this.vaultFolderExists = false;
+  }
+
+  init = async () => {
+    // check token
+    if (
+      this.dropboxConfig.accessToken === "" ||
+      this.dropboxConfig.refreshToken === ""
+    ) {
+      throw Error("The user has not manually auth yet.");
+    }
+    const currentTs = Date.now();
+    if (this.dropboxConfig.accessTokenExpiresAtTime > currentTs) {
+      this.dropbox = new Dropbox({
+        accessToken: this.dropboxConfig.accessToken,
+      });
+    } else {
+      if (this.dropboxConfig.refreshToken === "") {
+        throw Error(
+          "We need to automatically refresh token but none is stored."
+        );
+      }
+      const resp = await sendRefreshTokenReq(
+        this.dropboxConfig.clientID,
+        this.dropboxConfig.refreshToken
+      );
+
+      setConfigBySuccessfullAuthInplace(
+        this.dropboxConfig,
+        resp,
+        this.saveUpdatedConfigFunc
+      );
+      this.dropbox = new Dropbox({
+        accessToken: this.dropboxConfig.accessToken,
+      });
+    }
+
+    // check vault folder
+    // console.log(`checking remote has folder /${this.vaultName}`);
+    if (this.vaultFolderExists) {
+      // console.log(`already checked, /${this.vaultName} exist before`)
+    } else {
+      const res = await this.dropbox.filesListFolder({
+        path: "",
+        recursive: false,
+      });
+      for (const item of res.result.entries) {
+        if (item.path_display === `/${this.vaultName}`) {
+          this.vaultFolderExists = true;
+          break;
+        }
+      }
+      if (!this.vaultFolderExists) {
+        console.log(`remote does not have folder /${this.vaultName}`);
+        await this.dropbox.filesCreateFolderV2({
+          path: `/${this.vaultName}`,
+        });
+        console.log(`remote folder /${this.vaultName} created`);
+        this.vaultFolderExists = true;
+      } else {
+        // console.log(`remote folder /${this.vaultName} exists`);
+      }
+    }
+
+    return this.dropbox;
+  };
+}
+
+/**
+ * @param dropboxConfig
+ * @returns
+ */
+export const getDropboxClient = (
+  dropboxConfig: DropboxConfig,
+  vaultName: string,
+  saveUpdatedConfigFunc: () => Promise<any>
+) => {
+  return new WrappedDropboxClient(
+    dropboxConfig,
+    vaultName,
+    saveUpdatedConfigFunc
+  );
+};
+
+export const getRemoteMeta = async (
+  client: WrappedDropboxClient,
+  fileOrFolderPath: string
+) => {
+  await client.init();
+  if (fileOrFolderPath === "" || fileOrFolderPath === "/") {
+    // filesGetMetadata doesn't support root folder
+    // we instead try to list files
+    // if no error occurs, we ensemble a fake result.
+    const rsp = await client.dropbox.filesListFolder({
+      path: `/${client.vaultName}`,
+      recursive: false, // don't need to recursive here
+    });
+    if (rsp.status !== 200) {
+      throw Error(JSON.stringify(rsp));
+    }
+    return {
+      key: fileOrFolderPath,
+      lastModified: undefined,
+      size: 0,
+      remoteType: "dropbox",
+      etag: undefined,
+    } as RemoteItem;
+  }
+
+  const key = getDropboxPath(fileOrFolderPath, client.vaultName);
+
+  const rsp = await client.dropbox.filesGetMetadata({
+    path: key,
+  });
+  if (rsp.status !== 200) {
+    throw Error(JSON.stringify(rsp));
+  }
+  return fromDropboxItemToRemoteItem(rsp.result, client.vaultName);
+};
+
+export const uploadToRemote = async (
+  client: WrappedDropboxClient,
+  fileOrFolderPath: string,
+  vault: Vault,
+  isRecursively: boolean = false,
+  password: string = "",
+  remoteEncryptedKey: string = "",
+  foldersCreatedBefore: Set<string> | undefined = undefined
+) => {
+  await client.init();
+
+  let uploadFile = fileOrFolderPath;
+  if (password !== "") {
+    uploadFile = remoteEncryptedKey;
+  }
+  uploadFile = getDropboxPath(uploadFile, client.vaultName);
+
+  const isFolder = fileOrFolderPath.endsWith("/");
+
+  if (isFolder && isRecursively) {
+    throw Error("upload function doesn't implement recursive function yet!");
+  } else if (isFolder && !isRecursively) {
+    // folder
+    if (password === "") {
+      // if not encrypted, mkdir a remote folder
+      if (foldersCreatedBefore?.has(uploadFile)) {
+        // created, pass
+      } else {
+        try {
+          await client.dropbox.filesCreateFolderV2({
+            path: uploadFile,
+          });
+          foldersCreatedBefore?.add(uploadFile);
+        } catch (err) {
+          if (err.status === 409) {
+            // pass
+            foldersCreatedBefore?.add(uploadFile);
+          } else {
+            throw err;
+          }
+        }
+      }
+      const res = await getRemoteMeta(client, uploadFile);
+      return res;
+    } else {
+      // if encrypted, upload a fake file with the encrypted file name
+      await client.dropbox.filesUpload({
+        path: uploadFile,
+        contents: "",
+      });
+      return await getRemoteMeta(client, uploadFile);
+    }
+  } else {
+    // file
+    // we ignore isRecursively parameter here
+    const localContent = await vault.adapter.readBinary(fileOrFolderPath);
+    let remoteContent = localContent;
+    if (password !== "") {
+      remoteContent = await encryptArrayBuffer(localContent, password);
+    }
+    // in dropbox, we don't need to create folders before uploading! cool!
+    // TODO: filesUploadSession for larger files (>=150 MB)
+    await client.dropbox.filesUpload({
+      path: uploadFile,
+      contents: remoteContent,
+      mode: {
+        ".tag": "overwrite",
+      },
+    });
+    // we want to mark that parent folders are created
+    if (foldersCreatedBefore !== undefined) {
+      const dirs = getFolderLevels(uploadFile).map((x) =>
+        getDropboxPath(x, client.vaultName)
+      );
+      for (const dir of dirs) {
+        foldersCreatedBefore?.add(dir);
+      }
+    }
+    return await getRemoteMeta(client, uploadFile);
+  }
+};
+
+export const listFromRemote = async (
+  client: WrappedDropboxClient,
+  prefix?: string
+) => {
+  if (prefix !== undefined) {
+    throw Error("prefix not supported (yet)");
+  }
+  await client.init();
+  let res = await client.dropbox.filesListFolder({
+    path: `/${client.vaultName}`,
+    recursive: true,
+    include_deleted: false,
+    limit: 1000,
+  });
+  if (res.status !== 200) {
+    throw Error(JSON.stringify(res));
+  }
+  // console.log(res);
+
+  const contents = res.result.entries;
+  const unifiedContents = contents
+    .filter((x) => x[".tag"] !== "deleted")
+    .filter((x) => x.path_display !== `/${client.vaultName}`)
+    .map((x) => fromDropboxItemToRemoteItem(x, client.vaultName));
+
+  while (res.result.has_more) {
+    res = await client.dropbox.filesListFolderContinue({
+      cursor: res.result.cursor,
+    });
+    if (res.status !== 200) {
+      throw Error(JSON.stringify(res));
+    }
+
+    const contents2 = res.result.entries;
+    const unifiedContents2 = contents2
+      .filter((x) => x[".tag"] !== "deleted")
+      .filter((x) => x.path_display !== `/${client.vaultName}`)
+      .map((x) => fromDropboxItemToRemoteItem(x, client.vaultName));
+    unifiedContents.push(...unifiedContents2);
+  }
+
+  fixLastModifiedTimeInplace(unifiedContents);
+
+  return {
+    Contents: unifiedContents,
+  };
+};
+
+const downloadFromRemoteRaw = async (
+  client: WrappedDropboxClient,
+  fileOrFolderPath: string
+) => {
+  await client.init();
+  const key = getDropboxPath(fileOrFolderPath, client.vaultName);
+  const rsp = await client.dropbox.filesDownload({
+    path: key,
+  });
+  if ((rsp.result as any).fileBlob !== undefined) {
+    // we get a Blob
+    const content = (rsp.result as any).fileBlob as Blob;
+    return await content.arrayBuffer();
+  } else if ((rsp.result as any).fileBinary !== undefined) {
+    // we get a Buffer
+    const content = (rsp.result as any).fileBinary as Buffer;
+    return bufferToArrayBuffer(content);
+  } else {
+    throw Error(`unknown rsp from dropbox download: ${rsp}`);
+  }
+};
+
+export const downloadFromRemote = async (
+  client: WrappedDropboxClient,
+  fileOrFolderPath: string,
+  vault: Vault,
+  mtime: number,
+  password: string = "",
+  remoteEncryptedKey: string = ""
+) => {
+  await client.init();
+
+  const isFolder = fileOrFolderPath.endsWith("/");
+
+  await mkdirpInVault(fileOrFolderPath, vault);
+
+  // the file is always local file
+  // we need to encrypt it
+
+  if (isFolder) {
+    // mkdirp locally is enough
+    // do nothing here
+  } else {
+    let downloadFile = fileOrFolderPath;
+    if (password !== "") {
+      downloadFile = remoteEncryptedKey;
+    }
+    downloadFile = getDropboxPath(downloadFile, client.vaultName);
+    const remoteContent = await downloadFromRemoteRaw(client, downloadFile);
+    let localContent = remoteContent;
+    if (password !== "") {
+      localContent = await decryptArrayBuffer(remoteContent, password);
+    }
+    await vault.adapter.writeBinary(fileOrFolderPath, localContent, {
+      mtime: mtime,
+    });
+  }
+};
+
+export const deleteFromRemote = async (
+  client: WrappedDropboxClient,
+  fileOrFolderPath: string,
+  password: string = "",
+  remoteEncryptedKey: string = ""
+) => {
+  if (fileOrFolderPath === "/") {
+    return;
+  }
+  let remoteFileName = fileOrFolderPath;
+  if (password !== "") {
+    remoteFileName = remoteEncryptedKey;
+  }
+  remoteFileName = getDropboxPath(remoteFileName, client.vaultName);
+
+  await client.init();
+  try {
+    await client.dropbox.filesDeleteV2({
+      path: remoteFileName,
+    });
+  } catch (err) {
+    console.error("some error while deleting");
+    console.error(err);
+  }
+};
+
+export const checkConnectivity = async (client: WrappedDropboxClient) => {
+  try {
+    const results = await getRemoteMeta(client, "/");
+    if (results === undefined) {
+      return false;
+    }
+    return true;
+  } catch (err) {
+    console.error("dropbox connectivity error:");
+    console.error(err);
+    return false;
+  }
+};
+
+export const getUserDisplayName = async (client: WrappedDropboxClient) => {
+  await client.init();
+  const acct = await client.dropbox.usersGetCurrentAccount();
+  return acct.result.name.display_name;
+};
+
+export const revokeAuth = async (client: WrappedDropboxClient) => {
+  await client.init();
+  await client.dropbox.authTokenRevoke();
+};

src/remoteForOnedrive.ts

@@ -0,0 +1,737 @@
+import { CryptoProvider, PublicClientApplication } from "@azure/msal-node";
+import {
+  AuthenticationProvider,
+  Client,
+  FileUpload,
+  LargeFileUploadSession,
+  LargeFileUploadTask,
+  LargeFileUploadTaskOptions,
+  Range,
+  UploadEventHandlers,
+  UploadResult,
+} from "@microsoft/microsoft-graph-client";
+import type { DriveItem, User } from "@microsoft/microsoft-graph-types";
+import cloneDeep from "lodash/cloneDeep";
+import { request, Vault } from "obsidian";
+import * as path from "path";
+import {
+  DropboxConfig,
+  OAUTH2_FORCE_EXPIRE_MILLISECONDS,
+  OnedriveConfig,
+  RemoteItem,
+} from "./baseTypes";
+import { COMMAND_CALLBACK_ONEDRIVE } from "./baseTypes";
+import { decryptArrayBuffer, encryptArrayBuffer } from "./encrypt";
+import {
+  getRandomArrayBuffer,
+  getRandomIntInclusive,
+  mkdirpInVault,
+} from "./misc";
+
+const SCOPES = ["User.Read", "Files.ReadWrite.AppFolder", "offline_access"];
+const REDIRECT_URI = `obsidian://${COMMAND_CALLBACK_ONEDRIVE}`;
+
+export const DEFAULT_ONEDRIVE_CONFIG: OnedriveConfig = {
+  accessToken: "",
+  clientID: process.env.DEFAULT_ONEDRIVE_CLIENT_ID,
+  authority: process.env.DEFAULT_ONEDRIVE_AUTHORITY,
+  refreshToken: "",
+  accessTokenExpiresInSeconds: 0,
+  accessTokenExpiresAtTime: 0,
+  deltaLink: "",
+  username: "",
+  credentialsShouldBeDeletedAtTime: 0,
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Onedrive authorization using PKCE
+////////////////////////////////////////////////////////////////////////////////
+
+export async function getAuthUrlAndVerifier(
+  clientID: string,
+  authority: string
+) {
+  const cryptoProvider = new CryptoProvider();
+  const { verifier, challenge } = await cryptoProvider.generatePkceCodes();
+
+  const pkceCodes = {
+    challengeMethod: "S256", // Use SHA256 Algorithm
+    verifier: verifier,
+    challenge: challenge,
+  };
+
+  const authCodeUrlParams = {
+    redirectUri: REDIRECT_URI,
+    scopes: SCOPES,
+    codeChallenge: pkceCodes.challenge, // PKCE Code Challenge
+    codeChallengeMethod: pkceCodes.challengeMethod, // PKCE Code Challenge Method
+  };
+
+  const pca = new PublicClientApplication({
+    auth: {
+      clientId: clientID,
+      authority: authority,
+    },
+  });
+  const authCodeUrl = await pca.getAuthCodeUrl(authCodeUrlParams);
+
+  return {
+    authUrl: authCodeUrl,
+    verifier: verifier,
+  };
+}
+
+/**
+ * Check doc from
+ * https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-auth-code-flow
+ * https://docs.microsoft.com/en-us/onedrive/developer/rest-api/getting-started/graph-oauth?view=odsp-graph-online#code-flow
+ */
+export interface AccessCodeResponseSuccessfulType {
+  token_type: "Bearer" | "bearer";
+  expires_in: number;
+  ext_expires_in?: number;
+  scope: string;
+  access_token: string;
+  refresh_token?: string;
+  id_token?: string;
+}
+export interface AccessCodeResponseFailedType {
+  error: string;
+  error_description: string;
+  error_codes: number[];
+  timestamp: string;
+  trace_id: string;
+  correlation_id: string;
+}
+
+export const sendAuthReq = async (
+  clientID: string,
+  authority: string,
+  authCode: string,
+  verifier: string
+) => {
+  // // original code snippets for references
+  // const authResponse = await pca.acquireTokenByCode({
+  //   redirectUri: REDIRECT_URI,
+  //   scopes: SCOPES,
+  //   code: authCode,
+  //   codeVerifier: verifier, // PKCE Code Verifier
+  // });
+  // console.log('authResponse')
+  // console.log(authResponse)
+  // return authResponse;
+
+  // Because of the CORS problem,
+  // we need to construct raw request using Obsidian request,
+  // instead of using msal
+  // https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-auth-code-flow
+  // https://docs.microsoft.com/en-us/onedrive/developer/rest-api/getting-started/graph-oauth?view=odsp-graph-online#code-flow
+  const rsp1 = await request({
+    url: `${authority}/oauth2/v2.0/token`,
+    method: "POST",
+    contentType: "application/x-www-form-urlencoded",
+    body: new URLSearchParams({
+      tenant: "consumers",
+      client_id: clientID,
+      scope: SCOPES.join(" "),
+      code: authCode,
+      redirect_uri: REDIRECT_URI,
+      grant_type: "authorization_code",
+      code_verifier: verifier,
+    }).toString(),
+  });
+
+  const rsp2 = JSON.parse(rsp1);
+  // console.log(rsp2);
+
+  if (rsp2.error !== undefined) {
+    return rsp2 as AccessCodeResponseFailedType;
+  } else {
+    return rsp2 as AccessCodeResponseSuccessfulType;
+  }
+};
+
+export const sendRefreshTokenReq = async (
+  clientID: string,
+  authority: string,
+  refreshToken: string
+) => {
+  // also use Obsidian request to bypass CORS issue.
+  const rsp1 = await request({
+    url: `${authority}/oauth2/v2.0/token`,
+    method: "POST",
+    contentType: "application/x-www-form-urlencoded",
+    body: new URLSearchParams({
+      tenant: "consumers",
+      client_id: clientID,
+      scope: SCOPES.join(" "),
+      refresh_token: refreshToken,
+      grant_type: "refresh_token",
+    }).toString(),
+  });
+
+  const rsp2 = JSON.parse(rsp1);
+  // console.log(rsp2);
+
+  if (rsp2.error !== undefined) {
+    return rsp2 as AccessCodeResponseFailedType;
+  } else {
+    return rsp2 as AccessCodeResponseSuccessfulType;
+  }
+};
+
+export const setConfigBySuccessfullAuthInplace = async (
+  config: OnedriveConfig,
+  authRes: AccessCodeResponseSuccessfulType,
+  saveUpdatedConfigFunc: () => Promise<any> | undefined
+) => {
+  console.log("start updating local info of OneDrive token");
+  config.accessToken = authRes.access_token;
+  config.accessTokenExpiresAtTime =
+    Date.now() + authRes.expires_in - 5 * 60 * 1000;
+  config.accessTokenExpiresInSeconds = authRes.expires_in;
+  config.refreshToken = authRes.refresh_token;
+
+  // manually set it expired after 80 days;
+  config.credentialsShouldBeDeletedAtTime =
+    Date.now() + OAUTH2_FORCE_EXPIRE_MILLISECONDS;
+
+  if (saveUpdatedConfigFunc !== undefined) {
+    await saveUpdatedConfigFunc();
+  }
+
+  console.log("finish updating local info of Onedrive token");
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Other usual common methods
+////////////////////////////////////////////////////////////////////////////////
+
+const getOnedrivePath = (fileOrFolderPath: string, vaultName: string) => {
+  // https://docs.microsoft.com/en-us/onedrive/developer/rest-api/concepts/special-folders-appfolder?view=odsp-graph-online
+  const prefix = `/drive/special/approot:/${vaultName}`;
+  if (fileOrFolderPath.startsWith(prefix)) {
+    // already transformed, return as is
+    return fileOrFolderPath;
+  }
+
+  let key = fileOrFolderPath;
+  if (fileOrFolderPath === "/" || fileOrFolderPath === "") {
+    // special
+    return prefix;
+  }
+  if (key.endsWith("/")) {
+    key = key.slice(0, key.length - 1);
+  }
+
+  key = `${prefix}/${key}`;
+  return key;
+};
+
+const getNormPath = (fileOrFolderPath: string, vaultName: string) => {
+  const prefix = `/drive/special/approot:/${vaultName}`;
+
+  if (
+    !(fileOrFolderPath === prefix || fileOrFolderPath.startsWith(`${prefix}/`))
+  ) {
+    throw Error(
+      `"${fileOrFolderPath}" doesn't starts with "${prefix}/" or equals to "${prefix}"`
+    );
+  }
+
+  if (fileOrFolderPath === prefix) {
+    return "/";
+  }
+  return fileOrFolderPath.slice(`${prefix}/`.length);
+};
+
+const constructFromDriveItemToRemoteItemError = (x: DriveItem) => {
+  return `parentPath="${x.parentReference.path}", selfName="${x.name}"`;
+};
+
+const fromDriveItemToRemoteItem = (
+  x: DriveItem,
+  vaultName: string
+): RemoteItem => {
+  let key = "";
+
+  // possible prefix:
+  // pure english: /drive/root:/Apps/remotely-save/${vaultName}
+  // or localized, e.g.: /drive/root:/应用/remotely-save/${vaultName}
+  const FIRST_COMMON_PREFIX_REGEX = /^\/drive\/root:\/[^\/]+\/remotely-save\//g;
+
+  // another possibile prefix
+  const SECOND_COMMON_PREFIX_RAW = `/drive/items/`;
+
+  const fullPathOriginal = `${x.parentReference.path}/${x.name}`;
+  const matchFirstPrefixRes = fullPathOriginal.match(FIRST_COMMON_PREFIX_REGEX);
+  if (
+    matchFirstPrefixRes !== null &&
+    fullPathOriginal.startsWith(`${matchFirstPrefixRes[0]}${vaultName}`)
+  ) {
+    const foundPrefix = `${matchFirstPrefixRes[0]}${vaultName}`;
+    key = fullPathOriginal.substring(foundPrefix.length + 1);
+  } else if (x.parentReference.path.startsWith(SECOND_COMMON_PREFIX_RAW)) {
+    // it's something like
+    // /drive/items/<some_id>!<another_id>:/${vaultName}/<subfolder>
+    // with uri encoded!
+    const parPath = decodeURIComponent(x.parentReference.path);
+    key = parPath.substring(parPath.indexOf(":") + 1);
+    if (key.startsWith(`/${vaultName}/`)) {
+      key = key.substring(`/${vaultName}/`.length);
+      key = `${key}/${x.name}`;
+    } else if (key === `/${vaultName}`) {
+      key = x.name;
+    } else {
+      throw Error(
+        `we meet file/folder and do not know how to deal with it:\n${constructFromDriveItemToRemoteItemError(
+          x
+        )}`
+      );
+    }
+  } else {
+    throw Error(
+      `we meet file/folder and do not know how to deal with it:\n${constructFromDriveItemToRemoteItemError(
+        x
+      )}`
+    );
+  }
+
+  const isFolder = "folder" in x;
+  if (isFolder) {
+    key = `${key}/`;
+  }
+  return {
+    key: key,
+    lastModified: Date.parse(x.fileSystemInfo.lastModifiedDateTime),
+    size: isFolder ? 0 : x.size,
+    remoteType: "onedrive",
+    etag: x.eTag || x.cTag || "",
+  };
+};
+
+// to adapt to the required interface
+class MyAuthProvider implements AuthenticationProvider {
+  onedriveConfig: OnedriveConfig;
+  saveUpdatedConfigFunc: () => Promise<any>;
+  constructor(
+    onedriveConfig: OnedriveConfig,
+    saveUpdatedConfigFunc: () => Promise<any>
+  ) {
+    this.onedriveConfig = onedriveConfig;
+    this.saveUpdatedConfigFunc = saveUpdatedConfigFunc;
+  }
+  getAccessToken = async () => {
+    if (
+      this.onedriveConfig.accessToken === "" ||
+      this.onedriveConfig.refreshToken === ""
+    ) {
+      throw Error("The user has not manually auth yet.");
+    }
+
+    const currentTs = Date.now();
+    if (this.onedriveConfig.accessTokenExpiresAtTime > currentTs) {
+      return this.onedriveConfig.accessToken;
+    } else {
+      // use refreshToken to refresh
+      const r = await sendRefreshTokenReq(
+        this.onedriveConfig.clientID,
+        this.onedriveConfig.authority,
+        this.onedriveConfig.refreshToken
+      );
+      if ((r as any).error !== undefined) {
+        const r2 = r as AccessCodeResponseFailedType;
+        throw Error(
+          `Error while refreshing accessToken: ${r2.error}, ${r2.error_codes}: ${r2.error_description}`
+        );
+      }
+      const r2 = r as AccessCodeResponseSuccessfulType;
+      this.onedriveConfig.accessToken = r2.access_token;
+      this.onedriveConfig.refreshToken = r2.refresh_token;
+      this.onedriveConfig.accessTokenExpiresInSeconds = r2.expires_in;
+      this.onedriveConfig.accessTokenExpiresAtTime =
+        currentTs + r2.expires_in * 1000 - 60 * 2 * 1000;
+      await this.saveUpdatedConfigFunc();
+      console.log("Onedrive accessToken updated");
+      return this.onedriveConfig.accessToken;
+    }
+  };
+}
+
+export class WrappedOnedriveClient {
+  onedriveConfig: OnedriveConfig;
+  vaultName: string;
+  client: Client;
+  vaultFolderExists: boolean;
+  saveUpdatedConfigFunc: () => Promise<any>;
+  constructor(
+    onedriveConfig: OnedriveConfig,
+    vaultName: string,
+    saveUpdatedConfigFunc: () => Promise<any>
+  ) {
+    this.onedriveConfig = onedriveConfig;
+    this.vaultName = vaultName;
+    this.vaultFolderExists = false;
+    this.saveUpdatedConfigFunc = saveUpdatedConfigFunc;
+    this.client = Client.initWithMiddleware({
+      authProvider: new MyAuthProvider(onedriveConfig, saveUpdatedConfigFunc),
+    });
+  }
+
+  init = async () => {
+    // check token
+    if (
+      this.onedriveConfig.accessToken === "" ||
+      this.onedriveConfig.refreshToken === ""
+    ) {
+      throw Error("The user has not manually auth yet.");
+    }
+
+    // check vault folder
+    // console.log(`checking remote has folder /${this.vaultName}`);
+    if (this.vaultFolderExists) {
+      // console.log(`already checked, /${this.vaultName} exist before`)
+    } else {
+      const k = await this.client.api("/drive/special/approot/children").get();
+      // console.log(k);
+      this.vaultFolderExists =
+        (k.value as DriveItem[]).filter((x) => x.name === this.vaultName)
+          .length > 0;
+      if (!this.vaultFolderExists) {
+        console.log(`remote does not have folder /${this.vaultName}`);
+        await this.client.api("/drive/special/approot/children").post({
+          name: `${this.vaultName}`,
+          folder: {},
+          "@microsoft.graph.conflictBehavior": "replace",
+        });
+        console.log(`remote folder /${this.vaultName} created`);
+        this.vaultFolderExists = true;
+      } else {
+        // console.log(`remote folder /${this.vaultName} exists`);
+      }
+    }
+  };
+}
+
+export const getOnedriveClient = (
+  onedriveConfig: OnedriveConfig,
+  vaultName: string,
+  saveUpdatedConfigFunc: () => Promise<any>
+) => {
+  return new WrappedOnedriveClient(
+    onedriveConfig,
+    vaultName,
+    saveUpdatedConfigFunc
+  );
+};
+
+/**
+ * Use delta api to list all files and folders
+ * https://docs.microsoft.com/en-us/onedrive/developer/rest-api/api/driveitem_delta?view=odsp-graph-online
+ * @param client
+ * @param prefix
+ */
+export const listFromRemote = async (
+  client: WrappedOnedriveClient,
+  prefix?: string
+) => {
+  if (prefix !== undefined) {
+    throw Error("prefix not supported (yet)");
+  }
+  await client.init();
+
+  const NEXT_LINK_KEY = "@odata.nextLink";
+  const DELTA_LINK_KEY = "@odata.deltaLink";
+  let res = await client.client
+    .api(`/drive/special/approot:/${client.vaultName}:/delta`)
+    .get();
+  let driveItems = res.value as DriveItem[];
+
+  while (NEXT_LINK_KEY in res) {
+    res = await client.client.api(res[NEXT_LINK_KEY]).get();
+    driveItems.push(...cloneDeep(res.value as DriveItem[]));
+  }
+
+  // lastly we should have delta link?
+  if (DELTA_LINK_KEY in res) {
+    client.onedriveConfig.deltaLink = res[DELTA_LINK_KEY];
+    await client.saveUpdatedConfigFunc();
+  }
+
+  driveItems = driveItems.map((x) => {
+    const y = cloneDeep(x);
+    y.parentReference.path = y.parentReference.path.replace("/Apps", "/应用");
+    return y;
+  });
+
+  // unify everything to RemoteItem
+  const unifiedContents = driveItems
+    .map((x) => fromDriveItemToRemoteItem(x, client.vaultName))
+    .filter((x) => x.key !== "/");
+  return {
+    Contents: unifiedContents,
+  };
+};
+
+export const getRemoteMeta = async (
+  client: WrappedOnedriveClient,
+  fileOrFolderPath: string
+) => {
+  await client.init();
+  const remotePath = getOnedrivePath(fileOrFolderPath, client.vaultName);
+  // console.log(`remotePath=${remotePath}`);
+  const rsp = await client.client
+    .api(remotePath)
+    .select("cTag,eTag,fileSystemInfo,folder,file,name,parentReference,size")
+    .get();
+  // console.log(rsp);
+  const driveItem = rsp as DriveItem;
+  const res = fromDriveItemToRemoteItem(driveItem, client.vaultName);
+  // console.log(res);
+  return res;
+};
+
+export const uploadToRemote = async (
+  client: WrappedOnedriveClient,
+  fileOrFolderPath: string,
+  vault: Vault,
+  isRecursively: boolean = false,
+  password: string = "",
+  remoteEncryptedKey: string = "",
+  foldersCreatedBefore: Set<string> | undefined = undefined
+) => {
+  await client.init();
+
+  let uploadFile = fileOrFolderPath;
+  if (password !== "") {
+    uploadFile = remoteEncryptedKey;
+  }
+  uploadFile = getOnedrivePath(uploadFile, client.vaultName);
+  // console.log(`uploadFile=${uploadFile}`);
+
+  const isFolder = fileOrFolderPath.endsWith("/");
+
+  if (isFolder && isRecursively) {
+    throw Error("upload function doesn't implement recursive function yet!");
+  } else if (isFolder && !isRecursively) {
+    // folder
+    if (password === "") {
+      // if not encrypted, mkdir a remote folder
+      if (foldersCreatedBefore?.has(uploadFile)) {
+        // created, pass
+      } else {
+        // https://stackoverflow.com/questions/56479865/creating-nested-folders-in-one-go-onedrive-api
+        // use PATCH to create folder recursively!!!
+        await client.client.api(uploadFile).patch({
+          folder: {},
+          "@microsoft.graph.conflictBehavior": "replace",
+        });
+      }
+      const res = await getRemoteMeta(client, uploadFile);
+      return res;
+    } else {
+      // if encrypted,
+      // upload a fake, random-size file
+      // with the encrypted file name
+      const byteLengthRandom = getRandomIntInclusive(
+        1,
+        65536 /* max allowed */
+      );
+      const arrBufRandom = await encryptArrayBuffer(
+        getRandomArrayBuffer(byteLengthRandom),
+        password
+      );
+
+      const uploadSession: LargeFileUploadSession =
+        await LargeFileUploadTask.createUploadSession(
+          client.client,
+          `https://graph.microsoft.com/v1.0/me${encodeURIComponent(
+            uploadFile
+          )}:/createUploadSession`,
+          {
+            item: {
+              "@microsoft.graph.conflictBehavior": "replace",
+            },
+          }
+        );
+      const task = new LargeFileUploadTask(
+        client.client,
+        new FileUpload(
+          arrBufRandom,
+          path.posix.basename(uploadFile),
+          arrBufRandom.byteLength
+        ),
+        uploadSession,
+        {
+          rangeSize: 1024 * 1024,
+          uploadEventHandlers: {
+            progress: (range?: Range) => {
+              // Handle progress event
+              // console.log(
+              //   `uploading ${range.minValue}-${range.maxValue} of ${fileOrFolderPath}`
+              // );
+            },
+          } as UploadEventHandlers,
+        } as LargeFileUploadTaskOptions
+      );
+      const uploadResult: UploadResult = await task.upload();
+      // console.log(uploadResult)
+      const res = await getRemoteMeta(client, uploadFile);
+      return res;
+    }
+  } else {
+    // file
+    // we ignore isRecursively parameter here
+    const localContent = await vault.adapter.readBinary(fileOrFolderPath);
+    let remoteContent = localContent;
+    if (password !== "") {
+      remoteContent = await encryptArrayBuffer(localContent, password);
+    }
+
+    // no need to create parent folders firstly, cool!
+
+    // we need to customize the special root folder,
+    // so use LargeFileUploadTask instead of OneDriveLargeFileUploadTask
+    const progress = (range?: Range) => {
+      // Handle progress event
+      // console.log(
+      //   `uploading ${range.minValue}-${range.maxValue} of ${fileOrFolderPath}`
+      // );
+    };
+    const uploadEventHandlers: UploadEventHandlers = {
+      progress: progress,
+    };
+    const options: LargeFileUploadTaskOptions = {
+      rangeSize: 1024 * 1024,
+      uploadEventHandlers: uploadEventHandlers,
+    };
+    const payload = {
+      item: {
+        "@microsoft.graph.conflictBehavior": "replace",
+      },
+    };
+    // uploadFile already starts with /drive/special/approot:/${vaultName}
+    const uploadSession: LargeFileUploadSession =
+      await LargeFileUploadTask.createUploadSession(
+        client.client,
+        `https://graph.microsoft.com/v1.0/me${encodeURIComponent(
+          uploadFile
+        )}:/createUploadSession`,
+        payload
+      );
+    const fileObject = new FileUpload(
+      remoteContent,
+      path.posix.basename(uploadFile),
+      remoteContent.byteLength
+    );
+    const task = new LargeFileUploadTask(
+      client.client,
+      fileObject,
+      uploadSession,
+      options
+    );
+    const uploadResult: UploadResult = await task.upload();
+    // console.log(uploadResult)
+    const res = await getRemoteMeta(client, uploadFile);
+    return res;
+  }
+};
+
+const downloadFromRemoteRaw = async (
+  client: WrappedOnedriveClient,
+  fileOrFolderPath: string
+): Promise<ArrayBuffer> => {
+  await client.init();
+  const key = getOnedrivePath(fileOrFolderPath, client.vaultName);
+  const rsp = await client.client
+    .api(key)
+    .select("@microsoft.graph.downloadUrl")
+    .get();
+  const downloadUrl: string = rsp["@microsoft.graph.downloadUrl"];
+  const content = await (await fetch(downloadUrl)).arrayBuffer();
+  return content;
+};
+
+export const downloadFromRemote = async (
+  client: WrappedOnedriveClient,
+  fileOrFolderPath: string,
+  vault: Vault,
+  mtime: number,
+  password: string = "",
+  remoteEncryptedKey: string = ""
+) => {
+  await client.init();
+
+  const isFolder = fileOrFolderPath.endsWith("/");
+
+  await mkdirpInVault(fileOrFolderPath, vault);
+
+  if (isFolder) {
+    // mkdirp locally is enough
+    // do nothing here
+  } else {
+    let downloadFile = fileOrFolderPath;
+    if (password !== "") {
+      downloadFile = remoteEncryptedKey;
+    }
+    downloadFile = getOnedrivePath(downloadFile, client.vaultName);
+    const remoteContent = await downloadFromRemoteRaw(client, downloadFile);
+    let localContent = remoteContent;
+    if (password !== "") {
+      localContent = await decryptArrayBuffer(remoteContent, password);
+    }
+    await vault.adapter.writeBinary(fileOrFolderPath, localContent, {
+      mtime: mtime,
+    });
+  }
+};
+
+export const deleteFromRemote = async (
+  client: WrappedOnedriveClient,
+  fileOrFolderPath: string,
+  password: string = "",
+  remoteEncryptedKey: string = ""
+) => {
+  if (fileOrFolderPath === "/") {
+    return;
+  }
+  let remoteFileName = fileOrFolderPath;
+  if (password !== "") {
+    remoteFileName = remoteEncryptedKey;
+  }
+  remoteFileName = getOnedrivePath(remoteFileName, client.vaultName);
+
+  await client.init();
+  await client.client.api(remoteFileName).delete();
+};
+
+export const checkConnectivity = async (client: WrappedOnedriveClient) => {
+  try {
+    const k = await getUserDisplayName(client);
+    return k !== "<unknown display name>";
+  } catch (err) {
+    return false;
+  }
+};
+
+export const getUserDisplayName = async (client: WrappedOnedriveClient) => {
+  await client.init();
+  const res: User = await client.client.api("/me").select("displayName").get();
+  return res.displayName || "<unknown display name>";
+};
+
+/**
+ *
+ * https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-protocols-oidc#send-a-sign-out-request
+ * https://docs.microsoft.com/en-us/graph/api/user-revokesigninsessions
+ * https://docs.microsoft.com/en-us/graph/api/user-invalidateallrefreshtokens
+ * @param client
+ */
+// export const revokeAuth = async (client: WrappedOnedriveClient) => {
+//   await client.init();
+//   await client.client.api('/me/revokeSignInSessions').post(undefined);
+// };
+
+export const getRevokeAddr = async () => {
+  return "https://account.live.com/consent/Manage";
+};

src/remoteForS3.ts

@@ -1,38 +1,29 @@
-import { Buffer } from "buffer";
-import { Readable } from "stream";
-
-import { Vault } from "obsidian";
-
-import { Upload } from "@aws-sdk/lib-storage";
-import {
-  S3Client,
-  ListObjectsV2Command,
-  PutObjectCommand,
-  GetObjectCommand,
-  DeleteObjectCommand,
-  HeadObjectCommand,
-  HeadBucketCommand,
-  ListObjectsV2CommandInput,
-  ListObjectsV2CommandOutput,
-} from "@aws-sdk/client-s3";
-
 import type { _Object } from "@aws-sdk/client-s3";
-
+import {
+  DeleteObjectCommand,
+  GetObjectCommand,
+  HeadBucketCommand,
+  HeadObjectCommand,
+  HeadObjectCommandOutput,
+  ListObjectsV2Command,
+  ListObjectsV2CommandInput,
+  PutObjectCommand,
+  S3Client,
+} from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
+import { Buffer } from "buffer";
+import * as mime from "mime-types";
+import { Vault } from "obsidian";
+import { Readable } from "stream";
+import { RemoteItem, S3Config } from "./baseTypes";
+import { decryptArrayBuffer, encryptArrayBuffer } from "./encrypt";
 import {
   arrayBufferToBuffer,
   bufferToArrayBuffer,
   mkdirpInVault,
 } from "./misc";
-import * as mime from "mime-types";
-import { decryptArrayBuffer, encryptArrayBuffer } from "./encrypt";
 
-export interface S3Config {
+export { S3Client } from "@aws-sdk/client-s3";
-  s3Endpoint: string;
-  s3Region: string;
-  s3AccessKeyID: string;
-  s3SecretAccessKey: string;
-  s3BucketName: string;
-}
 
 export const DEFAULT_S3_CONFIG = {
   s3Endpoint: "",
@@ -44,6 +35,29 @@ export const DEFAULT_S3_CONFIG = {
 
 export type S3ObjectType = _Object;
 
+const fromS3ObjectToRemoteItem = (x: S3ObjectType) => {
+  return {
+    key: x.Key,
+    lastModified: x.LastModified.valueOf(),
+    size: x.Size,
+    remoteType: "s3",
+    etag: x.ETag,
+  } as RemoteItem;
+};
+
+const fromS3HeadObjectToRemoteItem = (
+  key: string,
+  x: HeadObjectCommandOutput
+) => {
+  return {
+    key: key,
+    lastModified: x.LastModified.valueOf(),
+    size: x.ContentLength,
+    remoteType: "s3",
+    etag: x.ETag,
+  } as RemoteItem;
+};
+
 export const getS3Client = (s3Config: S3Config) => {
   let endpoint = s3Config.s3Endpoint;
   if (!(endpoint.startsWith("http://") || endpoint.startsWith("https://"))) {
@@ -65,12 +79,14 @@ export const getRemoteMeta = async (
   s3Config: S3Config,
   fileOrFolderPath: string
 ) => {
-  return await s3Client.send(
+  const res = await s3Client.send(
     new HeadObjectCommand({
       Bucket: s3Config.s3BucketName,
       Key: fileOrFolderPath,
     })
   );
+
+  return fromS3HeadObjectToRemoteItem(fileOrFolderPath, res);
 };
 
 export const uploadToRemote = async (
@@ -181,10 +197,7 @@ export const listFromRemote = async (
 
   // ensemble fake rsp
   return {
-    "$.metadata": {
+    Contents: contents.map((x) => fromS3ObjectToRemoteItem(x)),
-      httpStatusCode: 200,
-    },
-    Contents: contents,
   };
 };
 
@@ -199,12 +212,12 @@ const getObjectBodyToArrayBuffer = async (
   b: Readable | ReadableStream | Blob
 ) => {
   if (b instanceof Readable) {
-    const chunks: Uint8Array[] = [];
+    return (await new Promise((resolve, reject) => {
-    for await (let chunk of b) {
+      const chunks: Uint8Array[] = [];
-      chunks.push(chunk);
+      b.on("data", (chunk) => chunks.push(chunk));
-    }
+      b.on("error", reject);
-    const buf = Buffer.concat(chunks);
+      b.on("end", () => resolve(bufferToArrayBuffer(Buffer.concat(chunks))));
-    return bufferToArrayBuffer(buf);
+    })) as ArrayBuffer;
   } else if (b instanceof ReadableStream) {
     return await new Response(b, {}).arrayBuffer();
   } else if (b instanceof Blob) {
@@ -214,7 +227,7 @@ const getObjectBodyToArrayBuffer = async (
   }
 };
 
-export const downloadFromRemoteRaw = async (
+const downloadFromRemoteRaw = async (
   s3Client: S3Client,
   s3Config: S3Config,
   fileOrFolderPath: string
@@ -302,7 +315,7 @@ export const deleteFromRemote = async (
       await s3Client.send(
         new DeleteObjectCommand({
           Bucket: s3Config.s3BucketName,
-          Key: element.Key,
+          Key: element.key,
         })
       );
     });
@@ -320,7 +333,7 @@ export const deleteFromRemote = async (
  * @param s3Config
  * @returns
  */
-export const checkS3Connectivity = async (
+export const checkConnectivity = async (
   s3Client: S3Client,
   s3Config: S3Config
 ) => {

src/remoteForWebdav.ts

@@ -0,0 +1,303 @@
+import { Buffer } from "buffer";
+import { Vault } from "obsidian";
+import type { FileStat, WebDAVClient } from "webdav/web";
+import { AuthType, BufferLike, createClient } from "webdav/web";
+import type { RemoteItem, WebdavConfig } from "./baseTypes";
+import { decryptArrayBuffer, encryptArrayBuffer } from "./encrypt";
+import { bufferToArrayBuffer, getPathFolder, mkdirpInVault } from "./misc";
+export type { WebDAVClient } from "webdav/web";
+
+export const DEFAULT_WEBDAV_CONFIG = {
+  address: "",
+  username: "",
+  password: "",
+  authType: "basic",
+} as WebdavConfig;
+
+const getWebdavPath = (fileOrFolderPath: string, vaultName: string) => {
+  let key = fileOrFolderPath;
+  if (fileOrFolderPath === "/" || fileOrFolderPath === "") {
+    // special
+    key = `/${vaultName}/`;
+  }
+  if (!fileOrFolderPath.startsWith("/")) {
+    key = `/${vaultName}/${fileOrFolderPath}`;
+  }
+  return key;
+};
+
+const getNormPath = (fileOrFolderPath: string, vaultName: string) => {
+  if (
+    !(
+      fileOrFolderPath === `/${vaultName}` ||
+      fileOrFolderPath.startsWith(`/${vaultName}/`)
+    )
+  ) {
+    throw Error(`"${fileOrFolderPath}" doesn't starts with "/${vaultName}/"`);
+  }
+  // if (fileOrFolderPath.startsWith("/")) {
+  //   return fileOrFolderPath.slice(1);
+  // }
+  return fileOrFolderPath.slice(`/${vaultName}/`.length);
+};
+
+const fromWebdavItemToRemoteItem = (x: FileStat, vaultName: string) => {
+  let key = getNormPath(x.filename, vaultName);
+  if (x.type === "directory" && !key.endsWith("/")) {
+    key = `${key}/`;
+  }
+  return {
+    key: key,
+    lastModified: Date.parse(x.lastmod).valueOf(),
+    size: x.size,
+    remoteType: "webdav",
+    etag: x.etag || undefined,
+  } as RemoteItem;
+};
+
+export class WrappedWebdavClient {
+  webdavConfig: WebdavConfig;
+  vaultName: string;
+  client: WebDAVClient;
+  vaultFolderExists: boolean;
+  constructor(webdavConfig: WebdavConfig, vaultName: string) {
+    this.webdavConfig = webdavConfig;
+    this.vaultName = vaultName;
+    this.vaultFolderExists = false;
+  }
+
+  init = async () => {
+    // init client if not inited
+    if (this.client === undefined) {
+      if (
+        this.webdavConfig.username !== "" &&
+        this.webdavConfig.password !== ""
+      ) {
+        this.client = createClient(this.webdavConfig.address, {
+          username: this.webdavConfig.username,
+          password: this.webdavConfig.password,
+          authType:
+            this.webdavConfig.authType === "digest"
+              ? AuthType.Digest
+              : AuthType.Password,
+        });
+      } else {
+        console.log("no password");
+        this.client = createClient(this.webdavConfig.address);
+      }
+    }
+
+    // check vault folder
+    if (this.vaultFolderExists) {
+      // pass
+    } else {
+      const res = await this.client.exists(`/${this.vaultName}`);
+      if (res) {
+        // console.log("remote vault folder exits!");
+        this.vaultFolderExists = true;
+      } else {
+        console.log("remote vault folder not exists, creating");
+        await this.client.createDirectory(`/${this.vaultName}`);
+        console.log("remote vault folder created!");
+        this.vaultFolderExists = true;
+      }
+    }
+  };
+}
+
+export const getWebdavClient = (
+  webdavConfig: WebdavConfig,
+  vaultName: string
+) => {
+  return new WrappedWebdavClient(webdavConfig, vaultName);
+};
+
+export const getRemoteMeta = async (
+  client: WrappedWebdavClient,
+  fileOrFolderPath: string
+) => {
+  await client.init();
+  const remotePath = getWebdavPath(fileOrFolderPath, client.vaultName);
+  // console.log(`remotePath = ${remotePath}`);
+  const res = (await client.client.stat(remotePath, {
+    details: false,
+  })) as FileStat;
+  return fromWebdavItemToRemoteItem(res, client.vaultName);
+};
+
+export const uploadToRemote = async (
+  client: WrappedWebdavClient,
+  fileOrFolderPath: string,
+  vault: Vault,
+  isRecursively: boolean = false,
+  password: string = "",
+  remoteEncryptedKey: string = ""
+) => {
+  await client.init();
+  let uploadFile = fileOrFolderPath;
+  if (password !== "") {
+    uploadFile = remoteEncryptedKey;
+  }
+  uploadFile = getWebdavPath(uploadFile, client.vaultName);
+
+  const isFolder = fileOrFolderPath.endsWith("/");
+
+  if (isFolder && isRecursively) {
+    throw Error("upload function doesn't implement recursive function yet!");
+  } else if (isFolder && !isRecursively) {
+    // folder
+    if (password === "") {
+      // if not encrypted, mkdir a remote folder
+      await client.client.createDirectory(uploadFile, {
+        recursive: true,
+      });
+      const res = await getRemoteMeta(client, uploadFile);
+      return res;
+    } else {
+      // if encrypted, upload a fake file with the encrypted file name
+      await client.client.putFileContents(uploadFile, "", {
+        overwrite: true,
+        onUploadProgress: (progress) => {
+          // console.log(`Uploaded ${progress.loaded} bytes of ${progress.total}`);
+        },
+      });
+
+      return await getRemoteMeta(client, uploadFile);
+    }
+  } else {
+    // file
+    // we ignore isRecursively parameter here
+    const localContent = await vault.adapter.readBinary(fileOrFolderPath);
+    let remoteContent = localContent;
+    if (password !== "") {
+      remoteContent = await encryptArrayBuffer(localContent, password);
+    }
+    // we need to create folders before uploading
+    const dir = getPathFolder(uploadFile);
+    if (dir !== "/" && dir !== "") {
+      await client.client.createDirectory(dir, { recursive: true });
+    }
+    await client.client.putFileContents(uploadFile, remoteContent, {
+      overwrite: true,
+      onUploadProgress: (progress) => {
+        console.log(`Uploaded ${progress.loaded} bytes of ${progress.total}`);
+      },
+    });
+
+    return await getRemoteMeta(client, uploadFile);
+  }
+};
+
+export const listFromRemote = async (
+  client: WrappedWebdavClient,
+  prefix?: string
+) => {
+  if (prefix !== undefined) {
+    throw Error("prefix not supported");
+  }
+  await client.init();
+  const contents = (await client.client.getDirectoryContents(
+    `/${client.vaultName}`,
+    {
+      deep: true,
+      details: false /* no need for verbose details here */,
+      glob: "/**" /* avoid dot files by using glob */,
+    }
+  )) as FileStat[];
+  return {
+    Contents: contents.map((x) =>
+      fromWebdavItemToRemoteItem(x, client.vaultName)
+    ),
+  };
+};
+
+const downloadFromRemoteRaw = async (
+  client: WrappedWebdavClient,
+  fileOrFolderPath: string
+) => {
+  await client.init();
+  const buff = (await client.client.getFileContents(
+    getWebdavPath(fileOrFolderPath, client.vaultName)
+  )) as BufferLike;
+  if (buff instanceof ArrayBuffer) {
+    return buff;
+  } else if (buff instanceof Buffer) {
+    return bufferToArrayBuffer(buff);
+  }
+  throw Error(`unexpected file content result with type ${typeof buff}`);
+};
+
+export const downloadFromRemote = async (
+  client: WrappedWebdavClient,
+  fileOrFolderPath: string,
+  vault: Vault,
+  mtime: number,
+  password: string = "",
+  remoteEncryptedKey: string = ""
+) => {
+  await client.init();
+
+  const isFolder = fileOrFolderPath.endsWith("/");
+
+  await mkdirpInVault(fileOrFolderPath, vault);
+
+  // the file is always local file
+  // we need to encrypt it
+
+  if (isFolder) {
+    // mkdirp locally is enough
+    // do nothing here
+  } else {
+    let downloadFile = fileOrFolderPath;
+    if (password !== "") {
+      downloadFile = remoteEncryptedKey;
+    }
+    downloadFile = getWebdavPath(downloadFile, client.vaultName);
+    const remoteContent = await downloadFromRemoteRaw(client, downloadFile);
+    let localContent = remoteContent;
+    if (password !== "") {
+      localContent = await decryptArrayBuffer(remoteContent, password);
+    }
+    await vault.adapter.writeBinary(fileOrFolderPath, localContent, {
+      mtime: mtime,
+    });
+  }
+};
+
+export const deleteFromRemote = async (
+  client: WrappedWebdavClient,
+  fileOrFolderPath: string,
+  password: string = "",
+  remoteEncryptedKey: string = ""
+) => {
+  if (fileOrFolderPath === "/") {
+    return;
+  }
+  let remoteFileName = fileOrFolderPath;
+  if (password !== "") {
+    remoteFileName = remoteEncryptedKey;
+  }
+  remoteFileName = getWebdavPath(remoteFileName, client.vaultName);
+
+  await client.init();
+  try {
+    await client.client.deleteFile(remoteFileName);
+    // console.log(`delete ${remoteFileName} succeeded`);
+  } catch (err) {
+    console.error("some error while deleting");
+    console.log(err);
+  }
+};
+
+export const checkConnectivity = async (client: WrappedWebdavClient) => {
+  try {
+    await client.init();
+    const results = await getRemoteMeta(client, "/");
+    if (results === undefined) {
+      return false;
+    }
+    return true;
+  } catch (err) {
+    return false;
+  }
+};

src/settings.ts

@@ -0,0 +1,943 @@
+import { App, Modal, Notice, PluginSettingTab, Setting } from "obsidian";
+import type { SUPPORTED_SERVICES_TYPE, WebdavAuthType } from "./baseTypes";
+import { exportSyncPlansToFiles } from "./debugMode";
+import { exportQrCodeUri } from "./importExport";
+import {
+  clearAllSyncMetaMapping,
+  clearAllSyncPlanRecords,
+  destroyDBs,
+} from "./localdb";
+import type RemotelySavePlugin from "./main"; // unavoidable
+import { RemoteClient } from "./remote";
+import {
+  DEFAULT_DROPBOX_CONFIG,
+  getAuthUrlAndVerifier as getAuthUrlAndVerifierDropbox,
+  sendAuthReq as sendAuthReqDropbox,
+  setConfigBySuccessfullAuthInplace,
+} from "./remoteForDropbox";
+import {
+  DEFAULT_ONEDRIVE_CONFIG,
+  getAuthUrlAndVerifier as getAuthUrlAndVerifierOnedrive,
+} from "./remoteForOnedrive";
+
+class PasswordModal extends Modal {
+  plugin: RemotelySavePlugin;
+  newPassword: string;
+  constructor(app: App, plugin: RemotelySavePlugin, newPassword: string) {
+    super(app);
+    this.plugin = plugin;
+    this.newPassword = newPassword;
+  }
+
+  onOpen() {
+    let { contentEl } = this;
+    // contentEl.setText("Add Or change password.");
+    contentEl.createEl("h2", { text: "Hold on and PLEASE READ ON..." });
+    contentEl.createEl("p", {
+      text: "If the field is not empty, files would be encrypted locally before being uploaded.",
+    });
+    contentEl.createEl("p", {
+      text: "If the field is empty, then files would be uploaded without encryption.",
+    });
+
+    contentEl.createEl("p", {
+      text: "Attention 1/5: The vault name is NOT encrypted. The plugin creates a folder with the vault name on some remote services.",
+      cls: "password-disclaimer",
+    });
+    contentEl.createEl("p", {
+      text: "Attention 2/5: The password itself is stored in PLAIN TEXT LOCALLY.",
+      cls: "password-disclaimer",
+    });
+    contentEl.createEl("p", {
+      text: "Attention 3/5: Some metadata are not encrypted or can be easily guessed. (File sizes are closed to their unencrypted ones, and directory path may be stored as 0-byte-size object.)",
+      cls: "password-disclaimer",
+    });
+    contentEl.createEl("p", {
+      text: "Attention 4/5: You should make sure the remote store IS EMPTY, or REMOTE FILES WERE ENCRYPTED BY THAT NEW PASSWORD, to avoid conflictions.",
+    });
+    contentEl.createEl("p", {
+      text: "Attention 5/5: The longer the password, the better.",
+    });
+
+    new Setting(contentEl)
+      .addButton((button) => {
+        button.setButtonText("The Second Confirm to change password.");
+        button.onClick(async () => {
+          this.plugin.settings.password = this.newPassword;
+          await this.plugin.saveSettings();
+          new Notice("New password saved!");
+          this.close();
+        });
+        button.setClass("password-second-confirm");
+      })
+      .addButton((button) => {
+        button.setButtonText("Go Back");
+        button.onClick(() => {
+          this.close();
+        });
+      });
+  }
+
+  onClose() {
+    let { contentEl } = this;
+    contentEl.empty();
+  }
+}
+
+class DropboxAuthModal extends Modal {
+  readonly plugin: RemotelySavePlugin;
+  readonly authDiv: HTMLDivElement;
+  readonly revokeAuthDiv: HTMLDivElement;
+  readonly revokeAuthSetting: Setting;
+  constructor(
+    app: App,
+    plugin: RemotelySavePlugin,
+    authDiv: HTMLDivElement,
+    revokeAuthDiv: HTMLDivElement,
+    revokeAuthSetting: Setting
+  ) {
+    super(app);
+    this.plugin = plugin;
+    this.authDiv = authDiv;
+    this.revokeAuthDiv = revokeAuthDiv;
+    this.revokeAuthSetting = revokeAuthSetting;
+  }
+
+  async onOpen() {
+    let { contentEl } = this;
+
+    const { authUrl, verifier } = await getAuthUrlAndVerifierDropbox(
+      this.plugin.settings.dropbox.clientID
+    );
+    this.plugin.oauth2Info.verifier = verifier;
+
+    contentEl.createEl("p", {
+      text: "Visit the address in a browser, and follow the steps.",
+    });
+    contentEl.createEl("p", {
+      text: "Finally you should be redirected to Obsidian.",
+    });
+    contentEl.createEl("p").createEl("a", {
+      href: authUrl,
+      text: authUrl,
+    });
+  }
+
+  onClose() {
+    let { contentEl } = this;
+    contentEl.empty();
+  }
+}
+
+export class OnedriveAuthModal extends Modal {
+  readonly plugin: RemotelySavePlugin;
+  readonly authDiv: HTMLDivElement;
+  readonly revokeAuthDiv: HTMLDivElement;
+  readonly revokeAuthSetting: Setting;
+  constructor(
+    app: App,
+    plugin: RemotelySavePlugin,
+    authDiv: HTMLDivElement,
+    revokeAuthDiv: HTMLDivElement,
+    revokeAuthSetting: Setting
+  ) {
+    super(app);
+    this.plugin = plugin;
+    this.authDiv = authDiv;
+    this.revokeAuthDiv = revokeAuthDiv;
+    this.revokeAuthSetting = revokeAuthSetting;
+  }
+
+  async onOpen() {
+    let { contentEl } = this;
+
+    const { authUrl, verifier } = await getAuthUrlAndVerifierOnedrive(
+      this.plugin.settings.onedrive.clientID,
+      this.plugin.settings.onedrive.authority
+    );
+    this.plugin.oauth2Info.verifier = verifier;
+
+    contentEl.createEl("p", {
+      text: "Visit the address in a browser, and follow the steps.",
+    });
+    contentEl.createEl("p", {
+      text: "Finally you should be redirected to Obsidian.",
+    });
+    contentEl.createEl("p").createEl("a", {
+      href: authUrl,
+      text: authUrl,
+    });
+  }
+
+  onClose() {
+    let { contentEl } = this;
+    contentEl.empty();
+  }
+}
+
+export class OnedriveRevokeAuthModal extends Modal {
+  readonly plugin: RemotelySavePlugin;
+  readonly authDiv: HTMLDivElement;
+  readonly revokeAuthDiv: HTMLDivElement;
+  constructor(
+    app: App,
+    plugin: RemotelySavePlugin,
+    authDiv: HTMLDivElement,
+    revokeAuthDiv: HTMLDivElement
+  ) {
+    super(app);
+    this.plugin = plugin;
+    this.authDiv = authDiv;
+    this.revokeAuthDiv = revokeAuthDiv;
+  }
+
+  async onOpen() {
+    let { contentEl } = this;
+    contentEl.createEl("p", {
+      text: 'Step 1: Go to the following address, click the "Edit" button for the plugin, then click "Remove these permissions" button on the page.',
+    });
+    const consentUrl = "https://microsoft.com/consent";
+    contentEl.createEl("p").createEl("a", {
+      href: consentUrl,
+      text: consentUrl,
+    });
+
+    contentEl.createEl("p", {
+      text: "Step 2: Click the button below, to clean the locally-saved login credentials.",
+    });
+
+    new Setting(contentEl)
+      .setName("Clean Locally-Saved Login Credentials")
+      .setDesc("You need to click the button.")
+      .addButton(async (button) => {
+        button.setButtonText("Clean");
+        button.onClick(async () => {
+          try {
+            this.plugin.settings.onedrive = JSON.parse(
+              JSON.stringify(DEFAULT_ONEDRIVE_CONFIG)
+            );
+            await this.plugin.saveSettings();
+            this.authDiv.toggleClass(
+              "onedrive-auth-button-hide",
+              this.plugin.settings.onedrive.username !== ""
+            );
+            this.revokeAuthDiv.toggleClass(
+              "onedrive-revoke-auth-button-hide",
+              this.plugin.settings.onedrive.username === ""
+            );
+            new Notice("Cleaned!");
+            this.close();
+          } catch (err) {
+            console.error(err);
+            new Notice("Something goes wrong while revoking");
+          }
+        });
+      });
+  }
+
+  onClose() {
+    let { contentEl } = this;
+    contentEl.empty();
+  }
+}
+
+class ExportSettingsQrCodeModal extends Modal {
+  plugin: RemotelySavePlugin;
+  constructor(app: App, plugin: RemotelySavePlugin) {
+    super(app);
+    this.plugin = plugin;
+  }
+
+  async onOpen() {
+    let { contentEl } = this;
+
+    const { rawUri, imgUri } = await exportQrCodeUri(
+      this.plugin.settings,
+      this.app.vault.getName(),
+      this.plugin.manifest.version
+    );
+
+    const div1 = contentEl.createDiv();
+    div1.createEl("p", {
+      text: "This exports not-oauth2 settings. (It means that Dropbox, OneDrive info are NOT exported.)",
+    });
+    div1.createEl("p", {
+      text: "You can use another device to scan this qrcode.",
+    });
+    div1.createEl("p", {
+      text: "Or, you can click the button to copy the special url.",
+    });
+
+    const div2 = contentEl.createDiv();
+    div2.createEl(
+      "button",
+      {
+        text: "Click to copy the special URI",
+      },
+      (el) => {
+        el.onclick = async () => {
+          await navigator.clipboard.writeText(rawUri);
+          new Notice("special uri copied to clipboard!");
+        };
+      }
+    );
+
+    const div3 = contentEl.createDiv();
+    div3.createEl(
+      "img",
+      {
+        cls: "qrcode-img",
+      },
+      async (el) => {
+        el.src = imgUri;
+      }
+    );
+  }
+
+  onClose() {
+    let { contentEl } = this;
+    contentEl.empty();
+  }
+}
+
+export class RemotelySaveSettingTab extends PluginSettingTab {
+  plugin: RemotelySavePlugin;
+
+  constructor(app: App, plugin: RemotelySavePlugin) {
+    super(app, plugin);
+    this.plugin = plugin;
+  }
+
+  display(): void {
+    let { containerEl } = this;
+
+    containerEl.empty();
+
+    containerEl.createEl("h1", { text: "Remotely Save" });
+
+    //////////////////////////////////////////////////
+    // below for general
+    //////////////////////////////////////////////////
+
+    const generalDiv = containerEl.createEl("div");
+    generalDiv.createEl("h2", { text: "General" });
+
+    const passwordDiv = generalDiv.createEl("div");
+    let newPassword = `${this.plugin.settings.password}`;
+    new Setting(passwordDiv)
+      .setName("encryption password")
+      .setDesc(
+        'Password for E2E encryption. Empty for no password. You need to click "Confirm".'
+      )
+      .addText((text) =>
+        text
+          .setPlaceholder("")
+          .setValue(`${this.plugin.settings.password}`)
+          .onChange(async (value) => {
+            newPassword = value.trim();
+          })
+      )
+      .addButton(async (button) => {
+        button.setButtonText("Confirm");
+        button.onClick(async () => {
+          new PasswordModal(this.app, this.plugin, newPassword).open();
+        });
+      });
+
+    //////////////////////////////////////////////////
+    // below for general chooser (part 1/2)
+    //////////////////////////////////////////////////
+
+    // we need to create the div in advance of any other service divs
+    const serviceChooserDiv = generalDiv.createEl("div");
+
+    //////////////////////////////////////////////////
+    // below for s3
+    //////////////////////////////////////////////////
+
+    const s3Div = containerEl.createEl("div", { cls: "s3-hide" });
+    s3Div.toggleClass("s3-hide", this.plugin.settings.serviceType !== "s3");
+    s3Div.createEl("h2", { text: "Remote For S3 or compatible" });
+
+    s3Div.createEl("p", {
+      text: "Disclaimer: This plugin is NOT an official Amazon product.",
+      cls: "s3-disclaimer",
+    });
+
+    s3Div.createEl("p", {
+      text: "Disclaimer: The information is stored in PLAIN TEXT locally. Other malicious/harmful/faulty plugins could read the info. If you see any unintentional access to your bucket, please immediately delete the access key on your AWS (or other S3-service provider) settings.",
+      cls: "s3-disclaimer",
+    });
+
+    s3Div.createEl("p", {
+      text: "You need to configure CORS to allow requests from origin app://obsidian.md and capacitor://localhost and http://localhost",
+    });
+
+    s3Div.createEl("p", {
+      text: "Some Amazon S3 official docs for references:",
+    });
+
+    const s3LinksUl = s3Div.createEl("div").createEl("ul");
+
+    s3LinksUl.createEl("li").createEl("a", {
+      href: "https://docs.aws.amazon.com/general/latest/gr/s3.html",
+      text: "Endpoint and region info",
+    });
+
+    s3LinksUl.createEl("li").createEl("a", {
+      href: "https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/getting-your-credentials.html",
+      text: "Access key ID and Secret access key info",
+    });
+
+    s3LinksUl.createEl("li").createEl("a", {
+      href: "https://docs.aws.amazon.com/AmazonS3/latest/userguide/enabling-cors-examples.html",
+      text: "Configuring CORS",
+    });
+
+    new Setting(s3Div)
+      .setName("s3Endpoint")
+      .setDesc("s3Endpoint")
+      .addText((text) =>
+        text
+          .setPlaceholder("")
+          .setValue(this.plugin.settings.s3.s3Endpoint)
+          .onChange(async (value) => {
+            this.plugin.settings.s3.s3Endpoint = value.trim();
+            await this.plugin.saveSettings();
+          })
+      );
+
+    new Setting(s3Div)
+      .setName("s3Region")
+      .setDesc("s3Region")
+      .addText((text) =>
+        text
+          .setPlaceholder("")
+          .setValue(`${this.plugin.settings.s3.s3Region}`)
+          .onChange(async (value) => {
+            this.plugin.settings.s3.s3Region = value.trim();
+            await this.plugin.saveSettings();
+          })
+      );
+
+    new Setting(s3Div)
+      .setName("s3AccessKeyID")
+      .setDesc("s3AccessKeyID")
+      .addText((text) =>
+        text
+          .setPlaceholder("")
+          .setValue(`${this.plugin.settings.s3.s3AccessKeyID}`)
+          .onChange(async (value) => {
+            this.plugin.settings.s3.s3AccessKeyID = value.trim();
+            await this.plugin.saveSettings();
+          })
+      );
+
+    new Setting(s3Div)
+      .setName("s3SecretAccessKey")
+      .setDesc("s3SecretAccessKey")
+      .addText((text) =>
+        text
+          .setPlaceholder("")
+          .setValue(`${this.plugin.settings.s3.s3SecretAccessKey}`)
+          .onChange(async (value) => {
+            this.plugin.settings.s3.s3SecretAccessKey = value.trim();
+            await this.plugin.saveSettings();
+          })
+      );
+
+    new Setting(s3Div)
+      .setName("s3BucketName")
+      .setDesc("s3BucketName")
+      .addText((text) =>
+        text
+          .setPlaceholder("")
+          .setValue(`${this.plugin.settings.s3.s3BucketName}`)
+          .onChange(async (value) => {
+            this.plugin.settings.s3.s3BucketName = value.trim();
+            await this.plugin.saveSettings();
+          })
+      );
+
+    new Setting(s3Div)
+      .setName("check connectivity")
+      .setDesc("check connectivity")
+      .addButton(async (button) => {
+        button.setButtonText("Check");
+        button.onClick(async () => {
+          new Notice("Checking...");
+          const client = new RemoteClient("s3", this.plugin.settings.s3);
+          const res = await client.checkConnectivity();
+          if (res) {
+            new Notice("Great! The bucket can be accessed.");
+          } else {
+            new Notice("The S3 bucket cannot be reached.");
+          }
+        });
+      });
+
+    //////////////////////////////////////////////////
+    // below for dropbpx
+    //////////////////////////////////////////////////
+
+    const dropboxDiv = containerEl.createEl("div", { cls: "dropbox-hide" });
+    dropboxDiv.toggleClass(
+      "dropbox-hide",
+      this.plugin.settings.serviceType !== "dropbox"
+    );
+    dropboxDiv.createEl("h2", { text: "Remote For Dropbox" });
+    dropboxDiv.createEl("p", {
+      text: "Disclaimer: This app is NOT an official Dropbox product.",
+      cls: "dropbox-disclaimer",
+    });
+    dropboxDiv.createEl("p", {
+      text: "Disclaimer: The information is stored in PLAIN TEXT locally. Other malicious/harmful/faulty plugins could read the info. If you see any unintentional access to your Dropbox, please immediately disconnect this app on https://www.dropbox.com/account/connected_apps .",
+      cls: "dropbox-disclaimer",
+    });
+    dropboxDiv.createEl("p", {
+      text: `We will create and sync inside the folder /Apps/${
+        this.plugin.manifest.id
+      }/${this.app.vault.getName()} on your Dropbox.`,
+    });
+
+    const dropboxSelectAuthDiv = dropboxDiv.createDiv();
+    const dropboxAuthDiv = dropboxSelectAuthDiv.createDiv({
+      cls: "dropbox-auth-button-hide",
+    });
+    const dropboxRevokeAuthDiv = dropboxSelectAuthDiv.createDiv({
+      cls: "dropbox-revoke-auth-button-hide",
+    });
+
+    const dropboxRevokeAuthSetting = new Setting(dropboxRevokeAuthDiv)
+      .setName("Revoke Auth")
+      .setDesc(
+        `You've connected as user ${this.plugin.settings.dropbox.username}. If you want to disconnect, click this button`
+      )
+      .addButton(async (button) => {
+        button.setButtonText("Revoke Auth");
+        button.onClick(async () => {
+          try {
+            const self = this;
+            const client = new RemoteClient(
+              "dropbox",
+              undefined,
+              undefined,
+              this.plugin.settings.dropbox,
+              undefined,
+              this.app.vault.getName(),
+              () => self.plugin.saveSettings()
+            );
+            await client.revokeAuth();
+            this.plugin.settings.dropbox = JSON.parse(
+              JSON.stringify(DEFAULT_DROPBOX_CONFIG)
+            );
+            await this.plugin.saveSettings();
+            dropboxAuthDiv.toggleClass(
+              "dropbox-auth-button-hide",
+              this.plugin.settings.dropbox.username !== ""
+            );
+            dropboxRevokeAuthDiv.toggleClass(
+              "dropbox-revoke-auth-button-hide",
+              this.plugin.settings.dropbox.username === ""
+            );
+            new Notice("Revoked!");
+          } catch (err) {
+            console.error(err);
+            new Notice("Something goes wrong while revoking");
+          }
+        });
+      });
+
+    new Setting(dropboxAuthDiv)
+      .setName("Auth")
+      .setDesc("Auth")
+      .addButton(async (button) => {
+        button.setButtonText("Auth");
+        button.onClick(async () => {
+          const modal = new DropboxAuthModal(
+            this.app,
+            this.plugin,
+            dropboxAuthDiv,
+            dropboxRevokeAuthDiv,
+            dropboxRevokeAuthSetting
+          );
+          this.plugin.oauth2Info.helperModal = modal;
+          this.plugin.oauth2Info.authDiv = dropboxAuthDiv;
+          this.plugin.oauth2Info.revokeDiv = dropboxRevokeAuthDiv;
+          this.plugin.oauth2Info.revokeAuthSetting = dropboxRevokeAuthSetting;
+          modal.open();
+        });
+      });
+
+    dropboxAuthDiv.toggleClass(
+      "dropbox-auth-button-hide",
+      this.plugin.settings.dropbox.username !== ""
+    );
+    dropboxRevokeAuthDiv.toggleClass(
+      "dropbox-revoke-auth-button-hide",
+      this.plugin.settings.dropbox.username === ""
+    );
+
+    new Setting(dropboxDiv)
+      .setName("check connectivity")
+      .setDesc("check connectivity")
+      .addButton(async (button) => {
+        button.setButtonText("Check");
+        button.onClick(async () => {
+          new Notice("Checking...");
+          const self = this;
+          const client = new RemoteClient(
+            "dropbox",
+            undefined,
+            undefined,
+            this.plugin.settings.dropbox,
+            undefined,
+            this.app.vault.getName(),
+            () => self.plugin.saveSettings()
+          );
+
+          const res = await client.checkConnectivity();
+          if (res) {
+            new Notice("Great! We can connect to Dropbox!");
+          } else {
+            new Notice("We cannot connect to Dropbox.");
+          }
+        });
+      });
+
+    //////////////////////////////////////////////////
+    // below for onedrive
+    //////////////////////////////////////////////////
+
+    const onedriveDiv = containerEl.createEl("div", { cls: "onedrive-hide" });
+    onedriveDiv.toggleClass(
+      "onedrive-hide",
+      this.plugin.settings.serviceType !== "onedrive"
+    );
+    onedriveDiv.createEl("h2", { text: "Remote For Onedrive" });
+    onedriveDiv.createEl("p", {
+      text: "Disclaimer: This app is NOT an official Microsoft / Onedrive product.",
+      cls: "onedrive-disclaimer",
+    });
+    onedriveDiv.createEl("p", {
+      text: "Disclaimer: The information is stored in PLAIN TEXT locally. Other malicious/harmful/faulty plugins could read the info. If you see any unintentional access to your Onedrive, please immediately disconnect this app on https://microsoft.com/consent .",
+      cls: "onedrive-disclaimer",
+    });
+    onedriveDiv.createEl("p", {
+      text: `We will create and sync inside the folder /Apps/${
+        this.plugin.manifest.id
+      }/${this.app.vault.getName()} on your Onedrive.`,
+    });
+
+    const onedriveSelectAuthDiv = onedriveDiv.createDiv();
+    const onedriveAuthDiv = onedriveSelectAuthDiv.createDiv({
+      cls: "onedrive-auth-button-hide",
+    });
+    const onedriveRevokeAuthDiv = onedriveSelectAuthDiv.createDiv({
+      cls: "onedrive-revoke-auth-button-hide",
+    });
+
+    const onedriveRevokeAuthSetting = new Setting(onedriveRevokeAuthDiv)
+      .setName("Revoke Auth")
+      .setDesc(
+        `You've connected as user ${this.plugin.settings.onedrive.username}. If you want to disconnect, click this button`
+      )
+      .addButton(async (button) => {
+        button.setButtonText("Revoke Auth");
+        button.onClick(async () => {
+          new OnedriveRevokeAuthModal(
+            this.app,
+            this.plugin,
+            onedriveAuthDiv,
+            onedriveRevokeAuthDiv
+          ).open();
+        });
+      });
+
+    new Setting(onedriveAuthDiv)
+      .setName("Auth")
+      .setDesc("Auth")
+      .addButton(async (button) => {
+        button.setButtonText("Auth");
+        button.onClick(async () => {
+          const modal = new OnedriveAuthModal(
+            this.app,
+            this.plugin,
+            onedriveAuthDiv,
+            onedriveRevokeAuthDiv,
+            onedriveRevokeAuthSetting
+          );
+          this.plugin.oauth2Info.helperModal = modal;
+          this.plugin.oauth2Info.authDiv = onedriveAuthDiv;
+          this.plugin.oauth2Info.revokeDiv = onedriveRevokeAuthDiv;
+          this.plugin.oauth2Info.revokeAuthSetting = onedriveRevokeAuthSetting;
+          modal.open();
+        });
+      });
+
+    onedriveAuthDiv.toggleClass(
+      "onedrive-auth-button-hide",
+      this.plugin.settings.onedrive.username !== ""
+    );
+    onedriveRevokeAuthDiv.toggleClass(
+      "onedrive-revoke-auth-button-hide",
+      this.plugin.settings.onedrive.username === ""
+    );
+
+    new Setting(onedriveDiv)
+      .setName("check connectivity")
+      .setDesc("check connectivity")
+      .addButton(async (button) => {
+        button.setButtonText("Check");
+        button.onClick(async () => {
+          new Notice("Checking...");
+          const self = this;
+          const client = new RemoteClient(
+            "onedrive",
+            undefined,
+            undefined,
+            undefined,
+            this.plugin.settings.onedrive,
+            this.app.vault.getName(),
+            () => self.plugin.saveSettings()
+          );
+
+          const res = await client.checkConnectivity();
+          if (res) {
+            new Notice("Great! We can connect to Onedrive!");
+          } else {
+            new Notice("We cannot connect to Onedrive.");
+          }
+        });
+      });
+
+    //////////////////////////////////////////////////
+    // below for webdav
+    //////////////////////////////////////////////////
+
+    const webdavDiv = containerEl.createEl("div", { cls: "webdav-hide" });
+    webdavDiv.toggleClass(
+      "webdav-hide",
+      this.plugin.settings.serviceType !== "webdav"
+    );
+
+    webdavDiv.createEl("h2", { text: "Remote For Webdav" });
+
+    webdavDiv.createEl("p", {
+      text: "Disclaimer: The information is stored in PLAIN TEXT locally. Other malicious/harmful/faulty plugins may read the info. If you see any unintentional access to your webdav server, please immediately change the username and password.",
+      cls: "webdav-disclaimer",
+    });
+
+    webdavDiv.createEl("p", {
+      text: "You need to configure CORS to allow requests from origin app://obsidian.md and capacitor://localhost and http://localhost",
+    });
+
+    webdavDiv.createEl("p", {
+      text: `We will create and sync inside the folder /${this.app.vault.getName()} on your server.`,
+    });
+
+    new Setting(webdavDiv)
+      .setName("server address")
+      .setDesc("server address")
+      .addText((text) =>
+        text
+          .setPlaceholder("")
+          .setValue(this.plugin.settings.webdav.address)
+          .onChange(async (value) => {
+            this.plugin.settings.webdav.address = value.trim();
+            await this.plugin.saveSettings();
+          })
+      );
+
+    new Setting(webdavDiv)
+      .setName("server username")
+      .setDesc("server username")
+      .addText((text) =>
+        text
+          .setPlaceholder("")
+          .setValue(this.plugin.settings.webdav.username)
+          .onChange(async (value) => {
+            this.plugin.settings.webdav.username = value.trim();
+            await this.plugin.saveSettings();
+          })
+      );
+
+    new Setting(webdavDiv)
+      .setName("server password")
+      .setDesc("server password")
+      .addText((text) =>
+        text
+          .setPlaceholder("")
+          .setValue(this.plugin.settings.webdav.password)
+          .onChange(async (value) => {
+            this.plugin.settings.webdav.password = value.trim();
+            await this.plugin.saveSettings();
+          })
+      );
+
+    new Setting(webdavDiv)
+      .setName("server auth type")
+      .setDesc("If no password, this option would be ignored.")
+      .addDropdown((dropdown) => {
+        dropdown.addOption("basic", "basic");
+        // dropdown.addOption("digest", "digest");
+
+        dropdown
+          .setValue(this.plugin.settings.webdav.authType)
+          .onChange(async (val: WebdavAuthType) => {
+            this.plugin.settings.webdav.authType = val;
+            await this.plugin.saveSettings();
+          });
+      });
+
+    new Setting(webdavDiv)
+      .setName("check connectivity")
+      .setDesc("check connectivity")
+      .addButton(async (button) => {
+        button.setButtonText("Check");
+        button.onClick(async () => {
+          new Notice("Checking...");
+          const client = new RemoteClient(
+            "webdav",
+            undefined,
+            this.plugin.settings.webdav,
+            undefined,
+            undefined,
+            this.app.vault.getName()
+          );
+          const res = await client.checkConnectivity();
+          if (res) {
+            new Notice("Great! The webdav server can be accessed.");
+          } else {
+            new Notice(
+              "The webdav server cannot be reached (possible to be any of address/username/password/authtype/CORS errors)."
+            );
+          }
+        });
+      });
+
+    //////////////////////////////////////////////////
+    // below for general chooser (part 2/2)
+    //////////////////////////////////////////////////
+
+    // we need to create chooser
+    // after all service-div-s being created
+    new Setting(serviceChooserDiv)
+      .setName("Choose service")
+      .setDesc("Choose a service.")
+      .addDropdown(async (dropdown) => {
+        dropdown.addOption("s3", "S3 or compatible");
+        dropdown.addOption("dropbox", "Dropbox");
+        dropdown.addOption("webdav", "Webdav (beta)");
+        dropdown.addOption("onedrive", "OneDrive (alpha)");
+        dropdown
+          .setValue(this.plugin.settings.serviceType)
+          .onChange(async (val: SUPPORTED_SERVICES_TYPE) => {
+            this.plugin.settings.serviceType = val;
+            s3Div.toggleClass(
+              "s3-hide",
+              this.plugin.settings.serviceType !== "s3"
+            );
+            dropboxDiv.toggleClass(
+              "dropbox-hide",
+              this.plugin.settings.serviceType !== "dropbox"
+            );
+            onedriveDiv.toggleClass(
+              "onedrive-hide",
+              this.plugin.settings.serviceType !== "onedrive"
+            );
+            webdavDiv.toggleClass(
+              "webdav-hide",
+              this.plugin.settings.serviceType !== "webdav"
+            );
+            await this.plugin.saveSettings();
+          });
+      });
+
+    //////////////////////////////////////////////////
+    // below for import and export functions
+    //////////////////////////////////////////////////
+
+    // import and export
+    const importExportDiv = containerEl.createEl("div");
+    importExportDiv.createEl("h2", {
+      text: "Import and Export Partial Settings",
+    });
+
+    new Setting(importExportDiv)
+      .setName("export")
+      .setDesc("Export not-oauth2 settings by generating a qrcode.")
+      .addButton(async (button) => {
+        button.setButtonText("Get QR Code");
+        button.onClick(async () => {
+          new ExportSettingsQrCodeModal(this.app, this.plugin).open();
+        });
+      });
+
+    new Setting(importExportDiv)
+      .setName("import")
+      .setDesc(
+        "You should open a camera or scan-qrcode app, to manually scan the QR code."
+      );
+
+    //////////////////////////////////////////////////
+    // below for debug
+    //////////////////////////////////////////////////
+
+    const debugDiv = containerEl.createEl("div");
+    debugDiv.createEl("h2", { text: "Debug" });
+    const syncPlanDiv = debugDiv.createEl("div");
+    new Setting(syncPlanDiv)
+      .setName("export sync plans")
+      .setDesc(
+        "Sync plans are created every time after you trigger sync and before the actual sync. Useful to know what would actually happen in those sync. Click the button to export sync plans"
+      )
+      .addButton(async (button) => {
+        button.setButtonText("Export");
+        button.onClick(async () => {
+          await exportSyncPlansToFiles(this.plugin.db, this.app.vault);
+          new Notice("sync plans history exported");
+        });
+      });
+    new Setting(syncPlanDiv)
+      .setName("delete sync plans history in db")
+      .setDesc("delete sync plans history in db")
+      .addButton(async (button) => {
+        button.setButtonText("Delete History");
+        button.onClick(async () => {
+          await clearAllSyncPlanRecords(this.plugin.db);
+          new Notice("sync plans history (in db) deleted");
+        });
+      });
+
+    const syncMappingDiv = debugDiv.createEl("div");
+    new Setting(syncMappingDiv)
+      .setName("delete sync mappings history in db")
+      .setDesc(
+        "Sync mappings history stores the actual LOCAL last modified time of the REMOTE objects. Clearing it may cause unnecessary data exchanges in next-time sync. Click the button to delete sync mappings history in db"
+      )
+      .addButton(async (button) => {
+        button.setButtonText("Delete Sync Mappings");
+        button.onClick(async () => {
+          await clearAllSyncMetaMapping(this.plugin.db);
+          new Notice("sync mappings history (in local db) deleted");
+        });
+      });
+
+    const dbsResetDiv = debugDiv.createEl("div");
+    new Setting(dbsResetDiv)
+      .setName("reset local internal cache/databases")
+      .setDesc(
+        "Reset local internal caches/databases (for debugging purposes). You would want to reload the plugin after resetting this. This option will not empty the {s3, password...} settings."
+      )
+      .addButton(async (button) => {
+        button.setButtonText("Reset");
+        button.onClick(async () => {
+          await destroyDBs();
+          new Notice(
+            "Local internal cache/databases deleted. Please manually reload the plugin."
+          );
+        });
+      });
+  }
+}

src/sync.ts

@@ -1,32 +1,20 @@
-import { TAbstractFile, TFolder, TFile, Vault } from "obsidian";
+import { TAbstractFile, TFile, TFolder, Vault } from "obsidian";
-
+import type { RemoteItem, SUPPORTED_SERVICES_TYPE } from "./baseTypes";
-import { S3Client } from "@aws-sdk/client-s3";
-
-import {
-  clearDeleteRenameHistoryOfKey,
-  upsertSyncMetaMappingDataS3,
-  getSyncMetaMappingByRemoteKeyS3,
-} from "./localdb";
-import type { FileFolderHistoryRecord, InternalDBs } from "./localdb";
-
-import {
-  S3Config,
-  S3ObjectType,
-  uploadToRemote,
-  deleteFromRemote,
-  downloadFromRemote,
-} from "./s3";
-import {
-  mkdirpInVault,
-  SUPPORTED_SERVICES_TYPE,
-  isHiddenPath,
-  isVaildText,
-} from "./misc";
 import {
   decryptBase32ToString,
-  encryptStringToBase32,
+  decryptBase64urlToString,
+  encryptStringToBase64url,
   MAGIC_ENCRYPTED_PREFIX_BASE32,
+  MAGIC_ENCRYPTED_PREFIX_BASE64URL,
 } from "./encrypt";
+import type { FileFolderHistoryRecord, InternalDBs } from "./localdb";
+import {
+  clearDeleteRenameHistoryOfKey,
+  getSyncMetaMappingByRemoteKey,
+  upsertSyncMetaMappingData,
+} from "./localdb";
+import { isHiddenPath, isVaildText, mkdirpInVault } from "./misc";
+import { RemoteClient } from "./remote";
 
 export type SyncStatusType =
   | "idle"
@@ -85,7 +73,7 @@ export interface PasswordCheckType {
 }
 
 export const isPasswordOk = async (
-  remote: S3ObjectType[],
+  remote: RemoteItem[],
   password: string = ""
 ) => {
   if (remote === undefined || remote.length === 0) {
@@ -95,9 +83,9 @@ export const isPasswordOk = async (
       reason: "empty_remote",
     } as PasswordCheckType;
   }
-  const santyCheckKey = remote[0].Key;
+  const santyCheckKey = remote[0].key;
   if (santyCheckKey.startsWith(MAGIC_ENCRYPTED_PREFIX_BASE32)) {
-    // this is encrypted!
+    // this is encrypted using old base32!
     // try to decrypt it using the provided password.
     if (password === "") {
       return {
@@ -108,6 +96,38 @@ export const isPasswordOk = async (
     try {
       const res = await decryptBase32ToString(santyCheckKey, password);
 
+      // additional test
+      // because iOS Safari bypasses decryption with wrong password!
+      if (isVaildText(res)) {
+        return {
+          ok: true,
+          reason: "password_matched",
+        } as PasswordCheckType;
+      } else {
+        return {
+          ok: false,
+          reason: "invalid_text_after_decryption",
+        } as PasswordCheckType;
+      }
+    } catch (error) {
+      return {
+        ok: false,
+        reason: "password_not_matched",
+      } as PasswordCheckType;
+    }
+  }
+  if (santyCheckKey.startsWith(MAGIC_ENCRYPTED_PREFIX_BASE64URL)) {
+    // this is encrypted using new base64url!
+    // try to decrypt it using the provided password.
+    if (password === "") {
+      return {
+        ok: false,
+        reason: "remote_encrypted_local_no_password",
+      } as PasswordCheckType;
+    }
+    try {
+      const res = await decryptBase64urlToString(santyCheckKey, password);
+
       // additional test
       // because iOS Safari bypasses decryption with wrong password!
       if (isVaildText(res)) {
@@ -143,26 +163,36 @@ export const isPasswordOk = async (
 };
 
 const ensembleMixedStates = async (
-  remote: S3ObjectType[],
+  remote: RemoteItem[],
   local: TAbstractFile[],
   deleteHistory: FileFolderHistoryRecord[],
   db: InternalDBs,
+  remoteType: SUPPORTED_SERVICES_TYPE,
   password: string = ""
 ) => {
   const results = {} as Record<string, FileOrFolderMixedState>;
 
   if (remote !== undefined) {
     for (const entry of remote) {
-      const remoteEncryptedKey = entry.Key;
+      const remoteEncryptedKey = entry.key;
       let key = remoteEncryptedKey;
       if (password !== "") {
-        key = await decryptBase32ToString(remoteEncryptedKey, password);
+        if (remoteEncryptedKey.startsWith(MAGIC_ENCRYPTED_PREFIX_BASE32)) {
+          key = await decryptBase32ToString(remoteEncryptedKey, password);
+        } else if (
+          remoteEncryptedKey.startsWith(MAGIC_ENCRYPTED_PREFIX_BASE64URL)
+        ) {
+          key = await decryptBase64urlToString(remoteEncryptedKey, password);
+        } else {
+          throw Error(`unexpected key=${remoteEncryptedKey}`);
+        }
       }
-      const backwardMapping = await getSyncMetaMappingByRemoteKeyS3(
+      const backwardMapping = await getSyncMetaMappingByRemoteKey(
+        remoteType,
         db,
         key,
-        entry.LastModified.valueOf(),
+        entry.lastModified,
-        entry.ETag
+        entry.etag
       );
 
       let r = {} as FileOrFolderMixedState;
@@ -171,16 +201,16 @@ const ensembleMixedStates = async (
         r = {
           key: key,
           exist_remote: true,
-          mtime_remote: backwardMapping.localMtime,
+          mtime_remote: backwardMapping.localMtime || entry.lastModified,
-          size_remote: backwardMapping.localSize,
+          size_remote: backwardMapping.localSize || entry.size,
           remote_encrypted_key: remoteEncryptedKey,
         };
       } else {
         r = {
           key: key,
           exist_remote: true,
-          mtime_remote: entry.LastModified.valueOf(),
+          mtime_remote: entry.lastModified,
-          size_remote: entry.Size,
+          size_remote: entry.size,
           remote_encrypted_key: remoteEncryptedKey,
         };
       }
@@ -398,14 +428,19 @@ const getOperation = (
     r.decision_branch = 11;
   }
 
+  if (r.decision === "unknown") {
+    throw Error(`unknown decision for ${JSON.stringify(r)}`);
+  }
+
   return r;
 };
 
 export const getSyncPlan = async (
-  remote: S3ObjectType[],
+  remote: RemoteItem[],
   local: TAbstractFile[],
   deleteHistory: FileFolderHistoryRecord[],
   db: InternalDBs,
+  remoteType: SUPPORTED_SERVICES_TYPE,
   password: string = ""
 ) => {
   const mixedStates = await ensembleMixedStates(
@@ -413,6 +448,7 @@ export const getSyncPlan = async (
     local,
     deleteHistory,
     db,
+    remoteType,
     password
   );
   for (const [key, val] of Object.entries(mixedStates)) {
@@ -420,120 +456,146 @@ export const getSyncPlan = async (
   }
   const plan = {
     ts: Date.now(),
-    remoteType: "s3",
+    remoteType: remoteType,
     mixedStates: mixedStates,
   } as SyncPlanType;
   return plan;
 };
 
+const dispatchOperationToActual = async (
+  key: string,
+  state: FileOrFolderMixedState,
+  client: RemoteClient,
+  db: InternalDBs,
+  vault: Vault,
+  password: string = "",
+  foldersCreatedBefore: Set<string> | undefined = undefined
+) => {
+  let remoteEncryptedKey = key;
+  if (password !== "") {
+    remoteEncryptedKey = state.remote_encrypted_key;
+    if (remoteEncryptedKey === undefined || remoteEncryptedKey === "") {
+      // the old version uses base32
+      // remoteEncryptedKey = await encryptStringToBase32(key, password);
+      // the new version users base64url
+      remoteEncryptedKey = await encryptStringToBase64url(key, password);
+    }
+  }
+
+  if (
+    state.decision === undefined ||
+    state.decision === "unknown" ||
+    state.decision === "undecided"
+  ) {
+    throw Error(`unknown decision in ${JSON.stringify(state)}`);
+  } else if (state.decision === "skip") {
+    // do nothing
+  } else if (state.decision === "download_clearhist") {
+    await client.downloadFromRemote(
+      state.key,
+      vault,
+      state.mtime_remote,
+      password,
+      remoteEncryptedKey
+    );
+    await clearDeleteRenameHistoryOfKey(db, state.key);
+  } else if (state.decision === "upload_clearhist") {
+    const remoteObjMeta = await client.uploadToRemote(
+      state.key,
+      vault,
+      false,
+      password,
+      remoteEncryptedKey,
+      foldersCreatedBefore
+    );
+    await upsertSyncMetaMappingData(
+      client.serviceType,
+      db,
+      state.key,
+      state.mtime_local,
+      state.size_local,
+      state.key,
+      remoteObjMeta.lastModified,
+      remoteObjMeta.size,
+      remoteObjMeta.etag
+    );
+    await clearDeleteRenameHistoryOfKey(db, state.key);
+  } else if (state.decision === "download") {
+    await mkdirpInVault(state.key, vault);
+    await client.downloadFromRemote(
+      state.key,
+      vault,
+      state.mtime_remote,
+      password,
+      remoteEncryptedKey
+    );
+  } else if (state.decision === "delremote_clearhist") {
+    await client.deleteFromRemote(state.key, password, remoteEncryptedKey);
+    await clearDeleteRenameHistoryOfKey(db, state.key);
+  } else if (state.decision === "upload") {
+    const remoteObjMeta = await client.uploadToRemote(
+      state.key,
+      vault,
+      false,
+      password,
+      remoteEncryptedKey,
+      foldersCreatedBefore
+    );
+    await upsertSyncMetaMappingData(
+      client.serviceType,
+      db,
+      state.key,
+      state.mtime_local,
+      state.size_local,
+      state.key,
+      remoteObjMeta.lastModified,
+      remoteObjMeta.size,
+      remoteObjMeta.etag
+    );
+  } else if (state.decision === "clearhist") {
+    await clearDeleteRenameHistoryOfKey(db, state.key);
+  } else {
+    throw Error("this should never happen!");
+  }
+};
+
 export const doActualSync = async (
-  s3Client: S3Client,
+  client: RemoteClient,
-  s3Config: S3Config,
   db: InternalDBs,
   vault: Vault,
   syncPlan: SyncPlanType,
   password: string = ""
 ) => {
   const keyStates = syncPlan.mixedStates;
-  await Promise.all(
+  const foldersCreatedBefore = new Set<string>();
-    Object.entries(keyStates)
+  for (const [k, v] of Object.entries(keyStates).sort(
-      .sort((k, v) => -(k as string).length)
+    ([k1, v1], [k2, v2]) => k2.length - k1.length
-      .map(async ([k, v]) => {
+  )) {
-        const key = k as string;
+    const k2 = k as string;
-        const state = v as FileOrFolderMixedState;
+    const v2 = v as FileOrFolderMixedState;
-        let remoteEncryptedKey = key;
+    await dispatchOperationToActual(
-        if (password !== "") {
+      k as string,
-          remoteEncryptedKey = state.remote_encrypted_key;
+      v as FileOrFolderMixedState,
-          if (remoteEncryptedKey === undefined || remoteEncryptedKey === "") {
+      client,
-            remoteEncryptedKey = await encryptStringToBase32(key, password);
+      db,
-          }
+      vault,
-        }
+      password,
-
+      foldersCreatedBefore
-        if (
+    );
-          state.decision === undefined ||
+    // console.log(`finished ${k}, with ${setToString(foldersCreatedBefore)}`);
-          state.decision === "unknown" ||
+  }
-          state.decision === "undecided"
+  // await Promise.all(
-        ) {
+  //   Object.entries(keyStates)
-          throw Error(`unknown decision in ${JSON.stringify(state)}`);
+  //     .map(async ([k, v]) =>
-        } else if (state.decision === "skip") {
+  //       dispatchOperationToActual(
-          // do nothing
+  //         k as string,
-        } else if (state.decision === "download_clearhist") {
+  //         v as FileOrFolderMixedState,
-          await downloadFromRemote(
+  //         client,
-            s3Client,
+  //         db,
-            s3Config,
+  //         vault,
-            state.key,
+  //         password,
-            vault,
+  //         foldersCreatedBefore
-            state.mtime_remote,
+  //       )
-            password,
+  //     )
-            remoteEncryptedKey
+  // );
-          );
-          await clearDeleteRenameHistoryOfKey(db, state.key);
-        } else if (state.decision === "upload_clearhist") {
-          const remoteObjMeta = await uploadToRemote(
-            s3Client,
-            s3Config,
-            state.key,
-            vault,
-            false,
-            password,
-            remoteEncryptedKey
-          );
-          await upsertSyncMetaMappingDataS3(
-            db,
-            state.key,
-            state.mtime_local,
-            state.size_local,
-            state.key,
-            remoteObjMeta.LastModified.valueOf(),
-            remoteObjMeta.ContentLength,
-            remoteObjMeta.ETag
-          );
-          await clearDeleteRenameHistoryOfKey(db, state.key);
-        } else if (state.decision === "download") {
-          await mkdirpInVault(state.key, vault);
-          await downloadFromRemote(
-            s3Client,
-            s3Config,
-            state.key,
-            vault,
-            state.mtime_remote,
-            password,
-            remoteEncryptedKey
-          );
-        } else if (state.decision === "delremote_clearhist") {
-          await deleteFromRemote(
-            s3Client,
-            s3Config,
-            state.key,
-            password,
-            remoteEncryptedKey
-          );
-          await clearDeleteRenameHistoryOfKey(db, state.key);
-        } else if (state.decision === "upload") {
-          const remoteObjMeta = await uploadToRemote(
-            s3Client,
-            s3Config,
-            state.key,
-            vault,
-            false,
-            password,
-            remoteEncryptedKey
-          );
-          await upsertSyncMetaMappingDataS3(
-            db,
-            state.key,
-            state.mtime_local,
-            state.size_local,
-            state.key,
-            remoteObjMeta.LastModified.valueOf(),
-            remoteObjMeta.ContentLength,
-            remoteObjMeta.ETag
-          );
-        } else if (state.decision === "clearhist") {
-          await clearDeleteRenameHistoryOfKey(db, state.key);
-        } else {
-          throw Error("this should never happen!");
-        }
-      })
-  );
 };

styles.css

@@ -1,9 +1,58 @@
 /* set the styles */
 
-.password_second_confirm {
+.password-second-confirm {
+  font-weight: bold;
+}
+
+.password-disclaimer {
   font-weight: bold;
 }
 
 .s3-disclaimer {
   font-weight: bold;
 }
+.s3-hide {
+  display: none;
+}
+
+.dropbox-disclaimer {
+  font-weight: bold;
+}
+.dropbox-hide {
+  display: none;
+}
+
+.dropbox-auth-button-hide {
+  display: none;
+}
+
+.dropbox-revoke-auth-button-hide {
+  display: none;
+}
+
+.onedrive-disclaimer {
+  font-weight: bold;
+}
+.onedrive-hide {
+  display: none;
+}
+
+.onedrive-auth-button-hide {
+  display: none;
+}
+
+.onedrive-revoke-auth-button-hide {
+  display: none;
+}
+
+.webdav-disclaimer {
+  font-weight: bold;
+}
+.webdav-hide {
+  display: none;
+}
+
+.qrcode-img {
+  width: 350px;
+  height: 350px;
+}

tests/encrypt.test.ts

@@ -1,14 +1,15 @@
-import * as fs from "fs";
-import * as path from "path";
 import * as chai from "chai";
 import chaiAsPromised from "chai-as-promised";
-import { base64ToBase32, bufferToArrayBuffer } from "../src/misc";
+import * as fs from "fs";
+import * as path from "path";
 import {
   decryptArrayBuffer,
   decryptBase32ToString,
   encryptArrayBuffer,
   encryptStringToBase32,
+  encryptStringToBase64url,
 } from "../src/encrypt";
+import { base64ToBase64url, bufferToArrayBuffer } from "../src/misc";
 
 chai.use(chaiAsPromised);
 const expect = chai.expect;
@@ -52,7 +53,7 @@ describe("Encryption tests", () => {
     ).toString("utf-8");
     const password = "somepassword";
     const saltHex = "8302F586FAB491EC";
-    const enc = await encryptStringToBase32(
+    const enc = await encryptStringToBase64url(
       fileContent,
       password,
       undefined,
@@ -65,9 +66,9 @@ describe("Encryption tests", () => {
     const opensslBase64Res =
       "U2FsdGVkX1+DAvWG+rSR7BPXMnlvSSVGMdjsx7kE1CTH+28P+yAZRdDGgFWMGkMd";
     // we output base32, so we need some transformation
-    const opensslBase32Res = base64ToBase32(opensslBase64Res);
+    const opensslBase64urlRes = base64ToBase64url(opensslBase64Res);
 
-    expect(enc).equal(opensslBase32Res);
+    expect(enc).equal(opensslBase64urlRes);
   });
 
   it("should encrypt binary file and get the same result as openssl", async () => {

tests/misc.test.ts

@@ -1,7 +1,5 @@
-import * as fs from "fs";
-import * as path from "path";
 import { expect } from "chai";
-
+import { JSDOM } from "jsdom";
 import * as misc from "../src/misc";
 
 describe("Misc: hidden file", () => {
@@ -69,6 +67,28 @@ describe("Misc: get folder levels", () => {
     const res3 = ["xxx", "xxx/yyy", "xxx/yyy/zzz"];
     expect(misc.getFolderLevels(item3)).to.deep.equal(res3);
   });
+
+  it("should treat path starting with / correctly", () => {
+    const item = "/xxx/yyy/zzz.md";
+    const res = ["/xxx", "/xxx/yyy"];
+    expect(misc.getFolderLevels(item)).to.deep.equal(res);
+
+    const item2 = "/xxx/yyy/zzz";
+    const res2 = ["/xxx", "/xxx/yyy"];
+    expect(misc.getFolderLevels(item2)).to.deep.equal(res2);
+
+    const item3 = "/xxx/yyy/zzz/";
+    const res3 = ["/xxx", "/xxx/yyy", "/xxx/yyy/zzz"];
+    expect(misc.getFolderLevels(item3)).to.deep.equal(res3);
+
+    const item4 = "/xxx";
+    const res4 = [] as string[];
+    expect(misc.getFolderLevels(item4)).to.deep.equal(res4);
+
+    const item5 = "/";
+    const res5 = [] as string[];
+    expect(misc.getFolderLevels(item5)).to.deep.equal(res5);
+  });
 });
 
 describe("Misc: vaild file name tests", () => {
@@ -89,3 +109,39 @@ describe("Misc: vaild file name tests", () => {
     expect(x).to.be.true;
   });
 });
+
+describe("Misc: get dirname", () => {
+  it("should return itself for folder", async () => {
+    const x = misc.getPathFolder("ssss/");
+    // console.log(x)
+    expect(x).to.equal("ssss/");
+  });
+
+  it("should return folder for file", async () => {
+    const x = misc.getPathFolder("sss/yyy");
+    // console.log(x)
+    expect(x).to.equal("sss/");
+  });
+
+  it("should treat / specially", async () => {
+    const x = misc.getPathFolder("/");
+    expect(x).to.equal("/");
+
+    const y = misc.getPathFolder("/abc");
+    expect(y).to.equal("/");
+  });
+});
+
+describe("Misc: extract svg", () => {
+  beforeEach(function () {
+    const fakeBrowser = new JSDOM("");
+    global.window = fakeBrowser.window as any;
+  });
+
+  it("should extract rect from svg correctly", () => {
+    const x = "<svg><rect/><g/></svg>";
+    const y = misc.extractSvgSub(x);
+    // console.log(x)
+    expect(y).to.equal("<rect/><g/>");
+  });
+});

tsconfig.json

@@ -11,6 +11,7 @@
     // "allowSyntheticDefaultImports": true,
     "esModuleInterop": true,
     "importHelpers": true,
+    "isolatedModules": true,
     "lib": ["dom", "es5", "scripthost", "es2015"]
   },
   "include": ["**/*.ts"]

versions.json

@@ -1,3 +1,3 @@
 {
-  "0.0.16": "0.12.15"
+  "0.2.7": "0.12.15"
 }

webpack.config.js

@@ -1,7 +1,12 @@
+require("dotenv").config();
 const path = require("path");
 const webpack = require("webpack");
 const TerserPlugin = require("terser-webpack-plugin");
 
+const DEFAULT_DROPBOX_APP_KEY = process.env.DROPBOX_APP_KEY || "";
+const DEFAULT_ONEDRIVE_CLIENT_ID = process.env.ONEDRIVE_CLIENT_ID || "";
+const DEFAULT_ONEDRIVE_AUTHORITY = process.env.ONEDRIVE_AUTHORITY || "";
+
 module.exports = {
   entry: "./src/main.ts",
   target: "web",
@@ -11,6 +16,11 @@ module.exports = {
     libraryTarget: "commonjs",
   },
   plugins: [
+    new webpack.DefinePlugin({
+      "process.env.DEFAULT_DROPBOX_APP_KEY": `"${DEFAULT_DROPBOX_APP_KEY}"`,
+      "process.env.DEFAULT_ONEDRIVE_CLIENT_ID": `"${DEFAULT_ONEDRIVE_CLIENT_ID}"`,
+      "process.env.DEFAULT_ONEDRIVE_AUTHORITY": `"${DEFAULT_ONEDRIVE_AUTHORITY}"`,
+    }),
     // Work around for Buffer is undefined:
     // https://github.com/webpack/changelog-v5/issues/10
     new webpack.ProvidePlugin({
@@ -27,6 +37,10 @@ module.exports = {
         use: "ts-loader",
         exclude: /node_modules/,
       },
+      {
+        test: /\.svg?$/,
+        type: "asset/source",
+      },
     ],
   },
   resolve: {
@@ -37,7 +51,8 @@ module.exports = {
       // buffer: require.resolve("buffer/"),
       // console: require.resolve("console-browserify"),
       // constants: require.resolve("constants-browserify"),
-      // crypto: require.resolve("crypto-browserify"),
+      crypto: require.resolve("crypto-browserify"),
+      // crypto: false,
       // domain: require.resolve("domain-browser"),
       // events: require.resolve("events"),
       // http: require.resolve("stream-http"),