vault backup: 2025-04-06 08:14:19

.obsidian/community-plugins.json

@@ -4,5 +4,7 @@
   "obsidian-linter",
   "terminal",
   "table-editor-obsidian",
-  "dataview"
+  "dataview",
+  "weather-fetcher",
+  "geocoding-properties"
 ]

.obsidian/daily-notes.json

@@ -0,0 +1,4 @@
+{
+  "template": "templates/daily_template",
+  "autorun": true
+}

.obsidian/graph.json

@@ -17,6 +17,6 @@
   "repelStrength": 10,
   "linkStrength": 1,
   "linkDistance": 250,
-  "scale": 0.9832475302420375,
+  "scale": 3.0302387620056708,
   "close": true
 }

.obsidian/hotkeys.json

@@ -39,14 +39,6 @@
       "key": "-"
     }
   ],
-  "copilot:chat-toggle-window": [
-    {
-      "modifiers": [
-        "Alt"
-      ],
-      "key": "J"
-    }
-  ],
   "terminal:open-terminal.integrated.current": [
     {
       "modifiers": [
@@ -73,15 +65,6 @@
       "key": "G"
     }
   ],
-  "copilot:chat-open-window": [
-    {
-      "modifiers": [
-        "Alt",
-        "Mod"
-      ],
-      "key": "J"
-    }
-  ],
   "table-editor-obsidian:format-all-tables": [
     {
       "modifiers": [
@@ -90,5 +73,14 @@
       ],
       "key": "L"
     }
+  ],
+  "copilot:chat-toggle-window": [
+    {
+      "modifiers": [
+        "Alt",
+        "Mod"
+      ],
+      "key": "J"
+    }
   ]
 }

.obsidian/plugins/geocoding-properties/data.json

@@ -0,0 +1,32 @@
+{
+  "properties": {
+    "address": {
+      "frontmatterKey": "address",
+      "enabled": true
+    },
+    "lat": {
+      "frontmatterKey": "lat",
+      "enabled": true
+    },
+    "lng": {
+      "frontmatterKey": "lng",
+      "enabled": true
+    },
+    "location": {
+      "frontmatterKey": "location",
+      "enabled": true
+    },
+    "map_link": {
+      "frontmatterKey": "map_link",
+      "enabled": false
+    },
+    "map_view_link": {
+      "frontmatterKey": "map_view_link",
+      "enabled": false
+    }
+  },
+  "overrideExistingProperties": false,
+  "mapLinkProvider": "osm",
+  "apiProvider": "free-geocoding-api",
+  "apiKey": ""
+}

.obsidian/plugins/geocoding-properties/main.js

@@ -0,0 +1,602 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/deepmerge/dist/cjs.js
+var require_cjs = __commonJS({
+  "node_modules/deepmerge/dist/cjs.js"(exports, module2) {
+    "use strict";
+    var isMergeableObject = function isMergeableObject2(value) {
+      return isNonNullObject(value) && !isSpecial(value);
+    };
+    function isNonNullObject(value) {
+      return !!value && typeof value === "object";
+    }
+    function isSpecial(value) {
+      var stringValue = Object.prototype.toString.call(value);
+      return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
+    }
+    var canUseSymbol = typeof Symbol === "function" && Symbol.for;
+    var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for("react.element") : 60103;
+    function isReactElement(value) {
+      return value.$$typeof === REACT_ELEMENT_TYPE;
+    }
+    function emptyTarget(val) {
+      return Array.isArray(val) ? [] : {};
+    }
+    function cloneUnlessOtherwiseSpecified(value, options) {
+      return options.clone !== false && options.isMergeableObject(value) ? deepmerge(emptyTarget(value), value, options) : value;
+    }
+    function defaultArrayMerge(target, source, options) {
+      return target.concat(source).map(function(element) {
+        return cloneUnlessOtherwiseSpecified(element, options);
+      });
+    }
+    function getMergeFunction(key, options) {
+      if (!options.customMerge) {
+        return deepmerge;
+      }
+      var customMerge = options.customMerge(key);
+      return typeof customMerge === "function" ? customMerge : deepmerge;
+    }
+    function getEnumerableOwnPropertySymbols(target) {
+      return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+        return Object.propertyIsEnumerable.call(target, symbol);
+      }) : [];
+    }
+    function getKeys(target) {
+      return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
+    }
+    function propertyIsOnObject(object, property) {
+      try {
+        return property in object;
+      } catch (_) {
+        return false;
+      }
+    }
+    function propertyIsUnsafe(target, key) {
+      return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
+    }
+    function mergeObject(target, source, options) {
+      var destination = {};
+      if (options.isMergeableObject(target)) {
+        getKeys(target).forEach(function(key) {
+          destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+        });
+      }
+      getKeys(source).forEach(function(key) {
+        if (propertyIsUnsafe(target, key)) {
+          return;
+        }
+        if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
+          destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
+        } else {
+          destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+        }
+      });
+      return destination;
+    }
+    function deepmerge(target, source, options) {
+      options = options || {};
+      options.arrayMerge = options.arrayMerge || defaultArrayMerge;
+      options.isMergeableObject = options.isMergeableObject || isMergeableObject;
+      options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
+      var sourceIsArray = Array.isArray(source);
+      var targetIsArray = Array.isArray(target);
+      var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+      if (!sourceAndTargetTypesMatch) {
+        return cloneUnlessOtherwiseSpecified(source, options);
+      } else if (sourceIsArray) {
+        return options.arrayMerge(target, source, options);
+      } else {
+        return mergeObject(target, source, options);
+      }
+    }
+    deepmerge.all = function deepmergeAll(array, options) {
+      if (!Array.isArray(array)) {
+        throw new Error("first argument should be an array");
+      }
+      return array.reduce(function(prev, next) {
+        return deepmerge(prev, next, options);
+      }, {});
+    };
+    var deepmerge_1 = deepmerge;
+    module2.exports = deepmerge_1;
+  }
+});
+
+// src/main.ts
+var main_exports = {};
+__export(main_exports, {
+  default: () => GeocodingPlugin
+});
+module.exports = __toCommonJS(main_exports);
+var import_deepmerge = __toESM(require_cjs());
+var import_obsidian6 = require("obsidian");
+
+// src/search-modal.ts
+var import_obsidian2 = require("obsidian");
+
+// src/results-modal.ts
+var import_obsidian = require("obsidian");
+var GeocodingResultsModal = class extends import_obsidian.SuggestModal {
+  constructor(plugin, results) {
+    super(plugin.app);
+    this.plugin = plugin;
+    this.results = results;
+    this.setPlaceholder("Select result");
+  }
+  getSuggestions(query) {
+    return this.results.filter(
+      (result) => result.address.toLowerCase().includes(query.toLowerCase())
+    );
+  }
+  onChooseSuggestion(result) {
+    this.plugin.insertProperties(result);
+  }
+  renderSuggestion({ address, lat, lng, info }, el) {
+    el.createEl("div", {
+      text: `${address} (${lat}, ${lng})`
+    });
+    if (info) {
+      el.createEl("small", {
+        text: info
+      });
+    }
+  }
+};
+
+// src/search-modal.ts
+var GeocodingSearchModal = class extends import_obsidian2.Modal {
+  constructor(plugin, searchTerm) {
+    super(plugin.app);
+    this.plugin = plugin;
+    this.searchTerm = searchTerm;
+  }
+  async onSubmit() {
+    this.close();
+    const results = await this.plugin.getResults(this.searchTerm);
+    new GeocodingResultsModal(this.plugin, results).open();
+  }
+  onOpen() {
+    const { contentEl } = this;
+    contentEl.createEl("h1", {
+      text: "Confirm search term"
+    });
+    new import_obsidian2.Setting(contentEl).setName("Name").addText((text) => {
+      const component = text.setValue(this.searchTerm).onChange((value) => {
+        this.searchTerm = value;
+      });
+      component.inputEl.style.width = "100%";
+    });
+    new import_obsidian2.Setting(contentEl).addButton(
+      (btn) => btn.setButtonText("Submit").setCta().onClick(async () => {
+        await this.onSubmit();
+      })
+    );
+    contentEl.addEventListener("keypress", async (e) => {
+      if (e.key === "Enter") {
+        e.preventDefault();
+        await this.onSubmit();
+      }
+    });
+  }
+  onClose() {
+    const { contentEl } = this;
+    contentEl.empty();
+  }
+};
+
+// src/settings.ts
+var propertyDescriptions = {
+  address: {
+    name: "Address",
+    detail: "Format varies by provider"
+  },
+  lat: {
+    name: "Latitude"
+  },
+  lng: {
+    name: "Longitude"
+  },
+  location: {
+    name: "Location",
+    detail: "Coordinates in [lat, lng] format"
+  },
+  map_link: {
+    name: "Map link"
+  },
+  map_view_link: {
+    name: "Map view link",
+    detail: "A link in [](geo:lat,lng) format"
+  }
+};
+var defaultSettings = {
+  properties: {
+    address: {
+      frontmatterKey: "address",
+      enabled: true
+    },
+    lat: {
+      frontmatterKey: "lat",
+      enabled: false
+    },
+    lng: {
+      frontmatterKey: "lng",
+      enabled: false
+    },
+    location: {
+      frontmatterKey: "location",
+      enabled: false
+    },
+    map_link: {
+      frontmatterKey: "map_link",
+      enabled: false
+    },
+    map_view_link: {
+      frontmatterKey: "map_view_link",
+      enabled: false
+    }
+  },
+  overrideExistingProperties: false,
+  mapLinkProvider: "google",
+  apiProvider: "free-geocoding-api",
+  apiKey: ""
+};
+
+// src/settings-tab.ts
+var import_obsidian3 = require("obsidian");
+var GeocodingPluginSettingTab = class extends import_obsidian3.PluginSettingTab {
+  constructor(app, plugin) {
+    super(app, plugin);
+    this.plugin = plugin;
+  }
+  display() {
+    const { containerEl } = this;
+    containerEl.empty();
+    containerEl.createEl("h2", { text: "Properties" });
+    for (const [key, description] of Object.entries(
+      propertyDescriptions
+    )) {
+      const property = this.plugin.settings.properties[key];
+      new import_obsidian3.Setting(containerEl).setName(description.name || key).setDesc(description.detail || "").addText(
+        (text) => text.setValue(property.frontmatterKey).onChange(async (value) => {
+          if (!value) {
+            return;
+          }
+          property.frontmatterKey = value;
+          await this.plugin.saveSettings();
+        })
+      ).addToggle(
+        (toggle) => toggle.setValue(property.enabled).onChange(async (value) => {
+          property.enabled = value;
+          await this.plugin.saveSettings();
+        })
+      );
+    }
+    containerEl.createEl("h2", { text: "Behavior" });
+    new import_obsidian3.Setting(containerEl).setName("Override existing properties").setDesc(
+      "Whether to override existing properties with the same name"
+    ).addToggle(
+      (toggle) => toggle.setValue(this.plugin.settings.overrideExistingProperties).onChange(async (value) => {
+        this.plugin.settings.overrideExistingProperties = value;
+        await this.plugin.saveSettings();
+      })
+    );
+    new import_obsidian3.Setting(containerEl).setName("Map link provider").setDesc("Provider for the map_link property, if enabled").addDropdown(
+      (dropdown) => dropdown.addOptions({
+        google: "Google Maps",
+        apple: "Apple Maps",
+        osm: "OpenStreetMap"
+      }).setValue(this.plugin.settings.mapLinkProvider).onChange(async (value) => {
+        switch (value) {
+          case "google":
+          case "apple":
+          case "osm":
+            this.plugin.settings.mapLinkProvider = value;
+            break;
+        }
+        await this.plugin.saveSettings();
+      })
+    );
+    containerEl.createEl("h2", { text: "API" });
+    new import_obsidian3.Setting(containerEl).setName("API provider").addDropdown(
+      (dropdown) => dropdown.addOptions({
+        ["free-geocoding-api"]: "Free Geocoding API",
+        ["google-geocoding"]: "Google Geocoding"
+      }).setValue(this.plugin.settings.apiProvider).onChange(async (value) => {
+        switch (value) {
+          case "free-geocoding-api":
+          case "google-geocoding":
+            this.plugin.settings.apiProvider = value;
+            break;
+        }
+        await this.plugin.saveSettings();
+      })
+    );
+    new import_obsidian3.Setting(containerEl).setName("API key").setDisabled(
+      this.plugin.settings.apiProvider !== "google-geocoding"
+    ).addText(
+      (text) => text.setValue(this.plugin.settings.apiKey).onChange(async (value) => {
+        this.plugin.settings.apiKey = value;
+        await this.plugin.saveSettings();
+      })
+    );
+  }
+};
+
+// src/utils/fetch-free-geocoding-api-results.ts
+var import_obsidian4 = require("obsidian");
+var fetchFreeGeocodingAPIResults = async (searchTerm, apiKey) => {
+  const params = new URLSearchParams({
+    q: searchTerm,
+    api_key: apiKey
+  });
+  const url = `https://geocode.maps.co/search?${params.toString()}`;
+  const response = await (0, import_obsidian4.requestUrl)({
+    url,
+    throw: false
+  });
+  const retryAfter = response.headers["Retry-After"];
+  switch (response.status) {
+    case 200:
+      break;
+    case 401:
+      throw new Error("Unauthorized. Please check your API key.");
+    case 409:
+    case 503:
+      if (retryAfter) {
+        throw new Error(
+          `Too many requests. Please try again in ${retryAfter} seconds.`
+        );
+      }
+      throw new Error("Too many requests. Please try again later.");
+    default:
+      throw new Error(`Server responded with ${response.status}`);
+  }
+  const results = response.json;
+  return results.map((result) => ({
+    address: result.display_name,
+    lat: Number(result.lat),
+    lng: Number(result.lon),
+    info: `${result.class} ${result.type}`,
+    id: result.osm_id.toString(),
+    provider: "free-geocoding-api"
+  }));
+};
+
+// src/utils/fetch-google-geocoding-results.ts
+var import_obsidian5 = require("obsidian");
+var fetchGoogleGeocodingResults = async (searchTerm, apiKey) => {
+  const params = new URLSearchParams({
+    address: searchTerm,
+    key: apiKey
+  });
+  const url = `https://maps.googleapis.com/maps/api/geocode/json?${params.toString()}`;
+  const response = await (0, import_obsidian5.requestUrl)({
+    url,
+    throw: false
+  });
+  if (response.status !== 200) {
+    throw new Error(`Server responded with ${response.status}`);
+  }
+  const { status, results } = response.json;
+  switch (status) {
+    case "OK":
+      break;
+    case "ZERO_RESULTS":
+      throw new Error("No results found");
+    case "OVER_DAILY_LIMIT":
+      throw new Error("Over daily limit");
+    case "OVER_QUERY_LIMIT":
+      throw new Error("Over query limit");
+    case "REQUEST_DENIED":
+      throw new Error("Request denied (invalid API key?)");
+    default:
+      throw new Error("Unknown API response");
+  }
+  return results.map((result) => ({
+    address: result.formatted_address,
+    lat: result.geometry.location.lat,
+    lng: result.geometry.location.lng,
+    info: result.types.join(", "),
+    id: result.place_id,
+    provider: "google-geocoding"
+  }));
+};
+
+// src/utils/make-apple-maps-link.ts
+var makeAppleMapsLink = ({ address, lat, lng }) => {
+  const params = new URLSearchParams({
+    ll: `${lat},${lng}`,
+    address
+    // used only for display
+  });
+  return `https://maps.apple.com/?${params.toString()}`;
+};
+
+// src/utils/make-google-maps-link.ts
+var makeGoogleMapsLink = ({
+  id,
+  provider,
+  lat,
+  lng
+}) => {
+  if (provider === "google-geocoding") {
+    return `https://www.google.com/maps/search/?api=1&query=Google&query_place_id=${id}`;
+  }
+  const params = new URLSearchParams({
+    api: "1",
+    // we can only query by lat,lng or address, so we choose the more precise option
+    query: `${lat},${lng}`
+  });
+  return `https://www.google.com/maps/search/?${params.toString()}`;
+};
+
+// src/utils/make-osm-link.ts
+var makeOsmLink = ({ id, provider, lat, lng }) => {
+  if (provider === "free-geocoding-api") {
+  }
+  const params = new URLSearchParams({
+    mlat: lat.toString(),
+    mlon: lng.toString()
+  });
+  return `https://openstreetmap.org/?${params.toString()}`;
+};
+
+// src/main.ts
+var GeocodingPlugin = class extends import_obsidian6.Plugin {
+  async onload() {
+    await this.loadSettings();
+    this.addSettingTab(new GeocodingPluginSettingTab(this.app, this));
+    this.addCommand({
+      id: "insert-into-current-note",
+      name: "Insert properties into current note",
+      editorCallback: async (_, ctx) => {
+        const currentFile = ctx.file;
+        if (!currentFile) {
+          return;
+        }
+        const searchTerm = this.getSearchTerm(currentFile);
+        new GeocodingSearchModal(this, searchTerm).open();
+      }
+    });
+    this.addCommand({
+      id: "insert-into-current-note-no-confirmation",
+      name: "Insert properties into current note (no confirmation)",
+      editorCallback: async (_, ctx) => {
+        const currentFile = ctx.file;
+        if (!currentFile) {
+          return;
+        }
+        const searchTerm = this.getSearchTerm(currentFile);
+        const results = await this.getResults(searchTerm);
+        await this.insertProperties(results[0]);
+      }
+    });
+  }
+  getSearchTerm(file) {
+    let searchTerm = file.basename;
+    const metadataCache = this.app.metadataCache.getFileCache(file);
+    if (metadataCache == null ? void 0 : metadataCache.frontmatter) {
+      searchTerm = metadataCache.frontmatter.address || metadataCache.frontmatter.title || searchTerm;
+    }
+    return searchTerm;
+  }
+  async getResults(searchTerm) {
+    const results = [];
+    try {
+      const { apiProvider, apiKey } = this.settings;
+      switch (apiProvider) {
+        case "free-geocoding-api":
+          results.push(
+            ...await fetchFreeGeocodingAPIResults(
+              searchTerm,
+              apiKey
+            )
+          );
+          break;
+        case "google-geocoding":
+          results.push(
+            ...await fetchGoogleGeocodingResults(
+              searchTerm,
+              apiKey
+            )
+          );
+          break;
+        default:
+          throw new Error(`Invalid API provider: ${apiProvider}`);
+      }
+    } catch (error) {
+      new import_obsidian6.Notice(String(error));
+      throw error;
+    }
+    if (!(results == null ? void 0 : results.length)) {
+      new import_obsidian6.Notice(`No results found for "${searchTerm}"`);
+    }
+    return results;
+  }
+  async insertProperties(result) {
+    const currentFile = this.app.workspace.getActiveFile();
+    if (!currentFile) {
+      return;
+    }
+    const { overrideExistingProperties, mapLinkProvider, properties } = this.settings;
+    this.app.fileManager.processFrontMatter(currentFile, (frontmatter) => {
+      for (const [key, property] of Object.entries(properties)) {
+        const shouldInsert = property.enabled && (overrideExistingProperties || frontmatter[property.frontmatterKey] === void 0);
+        if (!shouldInsert) {
+          continue;
+        }
+        switch (key) {
+          case "location":
+            frontmatter[property.frontmatterKey] = [
+              result.lat.toString(),
+              result.lng.toString()
+            ];
+            break;
+          case "map_link":
+            switch (mapLinkProvider) {
+              case "google":
+                frontmatter[property.frontmatterKey] = makeGoogleMapsLink(result);
+                break;
+              case "apple":
+                frontmatter[property.frontmatterKey] = makeAppleMapsLink(result);
+                break;
+              case "osm":
+                frontmatter[property.frontmatterKey] = makeOsmLink(result);
+                break;
+            }
+            break;
+          case "map_view_link": {
+            frontmatter[property.frontmatterKey] = `[](geo:${result.lat},${result.lng})`;
+            break;
+          }
+          default:
+            frontmatter[property.frontmatterKey] = result[key];
+            break;
+        }
+      }
+    });
+  }
+  async loadSettings() {
+    this.settings = (0, import_deepmerge.default)(defaultSettings, await this.loadData() || {});
+  }
+  async saveSettings() {
+    await this.saveData(this.settings);
+  }
+};
+
+/* nosourcemap */

.obsidian/plugins/geocoding-properties/manifest.json

@@ -0,0 +1,10 @@
+{
+	"id": "geocoding-properties",
+	"name": "Geocoding Properties",
+	"version": "2.0.2",
+	"minAppVersion": "0.15.0",
+	"description": "Insert address / location data from geocoding APIs as Obsidian properties.",
+	"author": "Jose Elias Alvarez",
+	"authorUrl": "https://github.com/jose-elias-alvarez",
+	"isDesktopOnly": false
+}

.obsidian/plugins/global-proxy/main.js

@@ -0,0 +1,185 @@
+var import_obsidian = require("obsidian");
+
+const DEFAULT_SETTINGS = {
+    enableProxy: false,
+    httpProxy: "",
+	httpsProxy: "",
+	socksProxy: "",
+	bypassRules: "<local>,127.*,10.*,172.16.*,172.17.*,172.18.*,172.19.*,172.20.*,172.21.*,172.22.*,172.23.*,172.24.*,172.25.*,172.26.*,172.27.*,172.28.*,172.29.*,172.30.*,172.31.*,192.168.*",
+	pluginTokens: "persist:surfing-vault-${appId}"
+};
+
+var GlobalProxyPlugin = class extends import_obsidian.Plugin {
+  async onload() {
+    await this.loadSettings();
+    this.addSettingTab(new GlobalProxySettingTab(this.app, this));
+  }
+  
+  async onunload() {
+    this.disableProxy()
+  }
+  
+  async loadSettings() {
+    this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());
+	this.sessionMap = {}
+	this.enableProxy();
+  }
+  async saveSettings() {
+    await this.saveData(this.settings);
+  }
+  
+  async enableProxy() {
+		if (!this.settings.enableProxy) {
+			return;
+		}
+	  
+		let sessions = []
+		this.sessionMap.default = electron.remote.session.defaultSession
+		sessions.push(this.sessionMap.default)
+		  
+		if (!!this.settings.pluginTokens) {
+			let pluginTokens = this.settings.pluginTokens.split("\n");
+			for (var i = 0; i < pluginTokens.length; i++) {
+				if (!pluginTokens[i]) {
+					continue;
+				}
+				let token = pluginTokens[i].replace("${appId}", this.app.appId)
+				let session = await electron.remote.session.fromPartition(token)
+				sessions.push(session)
+				this.sessionMap[token] = session
+			}
+		}
+
+		let proxyRules = this.composeProxyRules(), 
+			proxyBypassRules = proxyRules ? this.settings.bypassRules : undefined;
+
+		for (var i = 0; i < sessions.length; i++) {
+			await sessions[i].setProxy({ proxyRules, proxyBypassRules }); 
+		}
+
+		if (proxyRules) {
+			new import_obsidian.Notice('Enable proxy!');
+		}
+	}
+	
+	
+	async disableProxy() {
+		let sessions = []
+		for (const key in this.sessionMap) {
+			sessions.push(this.sessionMap[key])
+		}
+				
+		for (var i = 0; i < sessions.length; i++) {
+			await sessions[i].setProxy({});
+			await sessions[i].closeAllConnections();
+		}
+		new import_obsidian.Notice('Disable proxy!');
+	}
+	
+	
+	composeProxyRules() {
+		if (!["socksProxy", "httpProxy", "httpsProxy"].
+			map((p) => !this.settings[p] || isValidFormat(this.settings[p])).reduce((res, check)=>{return res && check}, true)) {
+			return undefined;
+		}
+		
+		
+		const httpProxy= isValidFormat(this.settings.httpProxy) ? ";http=" + this.settings.httpProxy : "";
+		const httpsProxy= isValidFormat(this.settings.httpsProxy) ? ";https=" + this.settings.httpsProxy : "";
+		if (isValidFormat(this.settings.socksProxy)) {
+			return this.settings.socksProxy + httpProxy + httpsProxy + ",direct://"
+		} else if (!!httpProxy) {
+			return !!httpsProxy ? "http=" + this.settings.httpProxy + httpsProxy + ",direct://"
+				: this.settings.httpProxy + ",direct://"
+		} else if (!!httpsProxy) {
+			return this.settings.httpsProxy + ",direct://"
+		}
+		
+		return undefined;
+	}
+};
+
+var GlobalProxySettingTab = class extends import_obsidian.PluginSettingTab {
+  constructor(app, plugin) {
+    super(app, plugin);
+    this.plugin = plugin;
+  }
+  display() {
+    const { containerEl } = this;
+    containerEl.empty();
+	new import_obsidian.Setting(containerEl)
+	.setName("Enable proxy")
+	.setDesc("Change your proxy status")
+	.addToggle((val) => val
+	.setValue(this.plugin.settings.enableProxy)
+	.onChange(async (value) =>  {
+		this.plugin.settings.enableProxy = value;
+		await this.plugin.saveSettings();
+		value ? this.plugin.enableProxy() : this.plugin.disableProxy();
+    }));
+	new import_obsidian.Setting(containerEl)
+	.setName("Socks Proxy")
+	.setDesc("Set up your socks proxy")
+	.addText((text) => text
+	.setPlaceholder("<scheme>://<host>:<port>")
+	.setValue(this.plugin.settings.socksProxy)
+	.onChange((value) => {
+      this.refreshProxy("socksProxy", value); 
+    }));
+	new import_obsidian.Setting(containerEl)
+	.setName("Http Proxy")
+	.setDesc("Set up your http proxy")
+	.addText((text) => text
+	.setPlaceholder("<scheme>://<host>:<port>")
+	.setValue(this.plugin.settings.httpProxy)
+	.onChange((value) => {
+	  this.refreshProxy("httpProxy", value); 
+    }));
+	new import_obsidian.Setting(containerEl)
+	.setName("Https Proxy")
+	.setDesc("Set up your https proxy")
+	.addText((text) => text
+	.setPlaceholder("<scheme>://<host>:<port>")
+	.setValue(this.plugin.settings.httpsProxy)
+	.onChange((value) => {
+	  this.refreshProxy("httpsProxy", value);      
+    }));
+	new import_obsidian.Setting(containerEl)
+	.setName("Plugin Tokens")
+	.setDesc("For proxy specified plugins")
+	.addTextArea((text) => text
+	.setValue(this.plugin.settings.pluginTokens)
+	.onChange((value) => {
+	  this.refreshProxy("pluginTokens", value);  
+    }));
+	new import_obsidian.Setting(containerEl)
+	.setName("Blacklist")
+	.setDesc("Proxy blacklist")
+	.addTextArea((text) => text
+	.setPlaceholder("[URL_SCHEME://] HOSTNAME_PATTERN [:<port>]\n. HOSTNAME_SUFFIX_PATTERN [:PORT]\n[SCHEME://] IP_LITERAL [:PORT]\nIP_LITERAL / PREFIX_LENGTH_IN_BITS\n<local>")
+	.setValue(this.plugin.settings.bypassRules)
+	.onChange((value) => {
+	  this.refreshProxy("bypassRules", value);      
+    }));
+  }
+  async refreshProxy(key, value) {
+	  this.plugin.settings[key] = value;
+	  this.plugin.saveSettings();
+	  
+	  this.plugin.enableProxy(); 
+  }
+};
+
+
+function isValidFormat(proxyUrl) {
+  if (!!proxyUrl) {
+	  const regex = /^(\w+):\/\/([^:/]+):(\d+)$/;
+	  const matches = proxyUrl.match(regex);
+	  return !!matches;
+  }
+  return false;
+}
+
+module.exports = GlobalProxyPlugin;
+
+/* nosourcemap */

.obsidian/plugins/global-proxy/manifest.json

@@ -0,0 +1,11 @@
+{
+	"id": "global-proxy",
+	"name": "Global Proxy",
+	"version": "1.0.4",
+	"minAppVersion": "0.15.0",
+	"description": "Use network proxy throughout Obsidian according to the rules configured in this plugin.",
+	"author": "windingblack",
+	"fundingUrl": "https://www.buymeacoffee.com/windingblack",
+	"authorUrl": "https://github.com/windingblack",
+	"isDesktopOnly": true
+}

.obsidian/plugins/weather-fetcher/data.json

@@ -0,0 +1,5 @@
+{
+  "source": "wttr",
+  "cacheSeconds": 300,
+  "addRibbon": true
+}

.obsidian/plugins/weather-fetcher/manifest.json

@@ -0,0 +1,10 @@
+{
+  "id": "weather-fetcher",
+  "name": "Weather Fetcher",
+  "version": "0.0.3",
+  "minAppVersion": "0.12.0",
+  "description": "Fetch and insert current weather into the editor of Obsidian.",
+  "author": "fyears",
+  "authorUrl": "https://github.com/fyears/obsidian-weather",
+  "isDesktopOnly": false
+}

.obsidian/plugins/weather-fetcher/styles.css

@@ -0,0 +1,3 @@
+/* 
+body {
+} */

.obsidian/templates.json

@@ -0,0 +1,3 @@
+{
+  "folder": "templates"
+}

.obsidian/workspace.json

@@ -4,21 +4,21 @@
     "type": "split",
     "children": [
       {
-        "id": "c7e2d8a551657180",
+        "id": "5e3b239df99769bd",
         "type": "tabs",
         "children": [
           {
-            "id": "5c17d1698a118a5f",
+            "id": "4365a0c25a4f26f9",
             "type": "leaf",
             "state": {
               "type": "markdown",
               "state": {
-                "file": "new notes/快捷键设置.md",
-                "mode": "preview",
+                "file": "copilot-conversations/ubuntu lvm bindfs.md",
+                "mode": "source",
                 "source": false
               },
               "icon": "lucide-file",
-              "title": "快捷键设置"
+              "title": "ubuntu lvm bindfs"
             }
           }
         ]
@@ -88,39 +88,6 @@
         "id": "32b176fd8dff1165",
         "type": "tabs",
         "children": [
-          {
-            "id": "f2e4add240703050",
-            "type": "leaf",
-            "state": {
-              "type": "backlink",
-              "state": {
-                "file": "new notes/快捷键设置.md",
-                "collapseAll": false,
-                "extraContext": false,
-                "sortOrder": "alphabetical",
-                "showSearch": false,
-                "searchQuery": "",
-                "backlinkCollapsed": false,
-                "unlinkedCollapsed": false
-              },
-              "icon": "links-coming-in",
-              "title": "Backlinks for 快捷键设置"
-            }
-          },
-          {
-            "id": "6f91e2bf8c196925",
-            "type": "leaf",
-            "state": {
-              "type": "outgoing-link",
-              "state": {
-                "file": "new notes/快捷键设置.md",
-                "linksCollapsed": false,
-                "unlinkedCollapsed": true
-              },
-              "icon": "links-going-out",
-              "title": "Outgoing links from 快捷键设置"
-            }
-          },
           {
             "id": "ef29c0acdfab7689",
             "type": "leaf",
@@ -137,49 +104,63 @@
             }
           },
           {
-            "id": "b07f0e0bbd9a2a1d",
+            "id": "445ac2f458bd24b6",
+            "type": "leaf",
+            "state": {
+              "type": "backlink",
+              "state": {
+                "file": "copilot-conversations/ubuntu lvm bindfs.md",
+                "collapseAll": false,
+                "extraContext": false,
+                "sortOrder": "alphabetical",
+                "showSearch": false,
+                "searchQuery": "",
+                "backlinkCollapsed": false,
+                "unlinkedCollapsed": true
+              },
+              "icon": "links-coming-in",
+              "title": "Backlinks for ubuntu lvm bindfs"
+            }
+          },
+          {
+            "id": "8c579b681aaaa178",
+            "type": "leaf",
+            "state": {
+              "type": "outgoing-link",
+              "state": {
+                "file": "copilot-conversations/ubuntu lvm bindfs.md",
+                "linksCollapsed": false,
+                "unlinkedCollapsed": true
+              },
+              "icon": "links-going-out",
+              "title": "Outgoing links from ubuntu lvm bindfs"
+            }
+          },
+          {
+            "id": "cf7a4dcbb71782cb",
             "type": "leaf",
             "state": {
               "type": "outline",
               "state": {
-                "file": "new notes/快捷键设置.md",
+                "file": "copilot-conversations/ubuntu lvm bindfs.md",
                 "followCursor": false,
                 "showSearch": false,
                 "searchQuery": ""
               },
               "icon": "lucide-list",
-              "title": "Outline of 快捷键设置"
-            }
-          },
-          {
-            "id": "074859f93ca00fe5",
-            "type": "leaf",
-            "state": {
-              "type": "copilot-chat-view",
-              "state": {},
-              "icon": "message-square",
-              "title": "Copilot"
-            }
-          },
-          {
-            "id": "1f3c167b8064457c",
-            "type": "leaf",
-            "state": {
-              "type": "git-view",
-              "state": {},
-              "icon": "git-pull-request",
-              "title": "Source Control"
+              "title": "Outline of ubuntu lvm bindfs"
             }
           }
         ],
-        "currentTab": 5
+        "currentTab": 3
       }
     ],
     "direction": "horizontal",
-    "width": 390.5
+    "width": 409.5
   },
   "left-ribbon": {
     "hiddenItems": {
+      "weather-fetcher:Insert Weather": false,
       "switcher:Open quick switcher": false,
       "graph:Open graph view": false,
       "canvas:Create new canvas": false,
@@ -192,13 +173,25 @@
       "table-editor-obsidian:Advanced Tables Toolbar": false
     }
   },
-  "active": "f2e4add240703050",
+  "active": "4365a0c25a4f26f9",
   "lastOpenFiles": [
-    "new notes/chat history.md",
+    "copilot-conversations/dataview ob q&a.md",
+    "Chats/New Chat.md",
+    "copilot-conversations/ubuntu lvm bindfs.md",
     "new notes/快捷键设置.md",
+    "new notes/设置 nodeTest这个项目目录作为练手的项目.md",
+    "new notes/找到了如何入门obsidian的途径.md",
+    "new notes/chat history.md",
+    "new notes/pdf 插件的学习.md",
+    "new notes/Untitled.md",
+    "templates/base_template.md",
+    "templates/daily_template.md",
+    "Task.md",
+    "欢迎.md",
+    "Welcome.md",
     "new notes/2025-04-04.md",
-    "copilot-conversations/在ubuntu下可不可以把几个物理硬盘挂在到一个逻辑目录下@20250404_111308.md",
-    "copilot-conversations/如果我使用dataview插件查询在我的笔记目录里,是不是我需要事先有个目录里面的所有笔记都是包含特定模版的数据,这样更便于查询,或者说只有文档内包含特定属性的文档,那么查询结果中才能包含特定属性的文@20250404_232407.md",
-    "Chats/New Chat.md"
+    "new notes/2025-04-05.md",
+    "templates/daily.md",
+    "templates"
   ]
 }

copilot-conversations/dataview ob q&a.md

@@ -5,6 +5,9 @@ tags:
   - copilot-conversation
   - dataview
   - plugin
+  - qanda
+title: 如果我使用dataview插件查询在我的笔记目录里,是不是我需要事先有个目录里面的所有笔记都是包含特定模版的数据,这样更便于查询,或者说只有文档内包含特定属性的文档,那么查询结果中才能包含特定属性的文@20250404_232407
+time: 20250404_232407
 ---
 
 **user**: 如果我使用dataview插件查询在我的笔记目录里,是不是我需要事先有个目录里面的所有笔记都是包含特定模版的数据,这样更便于查询,或者说只有文档内包含特定属性的文档,那么查询结果中才能包含特定属性的文档,

copilot-conversations/ubuntu lvm bindfs.md

@@ -1,10 +1,12 @@
 ---
 epoch: 1743736388464
-modelKey: qwen-max-latest|3rd party (openai-format)
+modelKey: 
 tags:
   - copilot-conversation
   - lvm
   - ubuntu
+title: 在ubuntu下可不可以把几个物理硬盘挂在到一个逻辑目录下
+time: 20250404_111308
 ---
 
 **user**: 在ubuntu下可不可以把几个物理硬盘挂在到一个逻辑目录下

new notes/2025-04-04.md

@@ -0,0 +1,38 @@
+---
+date: 2025-04-04
+tags:
+  - journal
+  - daily
+title: 日记 - 2025-04-04
+weather: 
+mood:
+---
+
+# 2025-04-04
+
+## 今日目标
+
+- 
+
+## 完成事项
+
+- [[找到了如何入门obsidian的途径]]
+- [[设置 nodeTest这个项目目录作为练手的项目]]
+## 学到的新东西
+
+- 
+
+## 遇到的问题及解决方案
+
+- 
+
+## 明日计划
+
+-  [[pdf 插件的学习 ]]
+-  [[模版学习]] 
+
+## 其他备注
+
+- 
+
+

new notes/2025-04-05.md

@@ -0,0 +1,34 @@
+---
+date: 2025-04-05
+tags: [journal, daily]
+title: 日记 - 2025-04-05
+weather: "Beijing, China: ☀️   🌡️+13°C 🌬️↘21km/h"
+---
+
+# 2025-04-05
+
+## 今日目标
+
+- 
+
+## 完成事项
+
+- 
+
+## 学到的新东西
+
+- 
+
+## 遇到的问题及解决方案
+
+- 
+
+## 明日计划
+
+- 
+
+## 其他备注
+
+- 
+
+

new notes/快捷键设置.md

@@ -40,8 +40,8 @@ Fn = Fn
 | open a terminal | ⌥ + T  | 打开一个终端 |
 
 #### advance table
-| name            | hotkey   | comment      |
-| --------------- | -------- | ------------ |
-| open a terminal | ⌥ + ⌘ +l | 打开一个终端 |
+| name            | hotkey   | comment |     |
+| --------------- | -------- | ------- | --- |
+| open a terminal | ⌥ + ⌘ +l | 打开一个终端  |     |
 
 

new notes/找到了如何入门obsidian的途径.md

@@ -0,0 +1,13 @@
+---
+tags:
+  - test
+  - job
+links:
+  - obsidian://open?vault=notesTest&file=new%20notes%2F2025-04-04
+---
+
+- 契合自己的路线:
+	- markdown 
+	- git
+	- terminal + lazyvim + avante
+	- copilot

new notes/设置 nodeTest这个项目目录作为练手的项目.md

@@ -0,0 +1,7 @@
+---
+tags:
+  - test
+  - job
+links: obsidian://open?vault=notesTest&file=new%20notes%2F2025-04-04
+---
+并以此充实起

templates/base_template.md

@@ -0,0 +1,7 @@
+---
+date: {{date:YYYY-MM-DD}}
+tags: [journal, daily]
+title: 日记 - {{date:YYYY-MM-DD}}
+weather: 
+mood: 
+---

templates/daily_template.md

@@ -0,0 +1,35 @@
+---
+date: {{date:YYYY-MM-DD}}
+tags: [journal, daily]
+title: 日记 - {{date:YYYY-MM-DD}}
+weather: 
+mood: 
+---
+
+# {{title}}
+
+## 今日目标
+
+- 
+
+## 完成事项
+
+- 
+
+## 学到的新东西
+
+- 
+
+## 遇到的问题及解决方案
+
+- 
+
+## 明日计划
+
+- 
+
+## 其他备注
+
+- 
+
+